chore: Refactors configure to leverage @gleanwork/mcp-config-schema (#265)

Author: steve-calvert-glean

packages/configure-mcp-server/package.json

@@ -47,15 +47,13 @@
   },
   "dependencies": {
     "@gleanwork/local-mcp-server": "workspace:*",
+    "@gleanwork/mcp-config-schema": "^0.7.0",
     "@gleanwork/mcp-server-utils": "workspace:*",
     "dotenv": "^17.2.1",
     "mcp-remote": "^0.1.18",
     "meow": "^13.2.0",
-    "open": "^10.2.0",
     "tldts": "^7.0.10",
-    "yaml": "^2.8.0",
-    "zod": "^3.25.65",
-    "zod-to-json-schema": "^3.24.6"
+    "yaml": "^2.8.0"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
@@ -73,6 +71,7 @@
     "globals": "^16.3.0",
     "msw": "^2.10.2",
     "npm-run-all": "^4.1.5",
+    "open": "^10.2.0",
     "rimraf": "^6.0.1",
     "sort-package-json": "^3.4.0",
     "tsx": "^4.20.3",

packages/configure-mcp-server/src/configure/client/claude-code.ts

@@ -4,104 +4,12 @@
  * Similar to Claude Desktop but uses a different config path
  */
 
-import path from 'path';
-import {
-  MCPConfigPath,
-  createBaseClient,
-  MCPServersConfig,
-  StandardMCPConfig,
-  buildMcpServerName,
-} from './index.js';
-import type { ConfigureOptions } from '../index.js';
+import { createBaseClient } from './index.js';
+import { CLIENT } from '@gleanwork/mcp-config-schema';
 
-export const claudeCodeConfigPath: MCPConfigPath = {
-  configDir: '',
-  configFileName: '.claude.json',
-};
-
-function claudeCodePathResolver(homedir: string) {
-  const baseDir = process.env.GLEAN_MCP_CONFIG_DIR || homedir;
-  return path.join(baseDir, claudeCodeConfigPath.configFileName);
-}
-
-function mcpServersHook(servers: MCPServersConfig): StandardMCPConfig {
-  return {
-    mcpServers: servers,
-  };
-}
-
-const claudeCodeClient = createBaseClient(
-  'Claude Code',
-  claudeCodeConfigPath,
-  ['Run `claude mcp list` and verify the server is listed'],
-  claudeCodePathResolver,
-  mcpServersHook,
-);
-
-function createClaudeCodeMcpServersConfig(
-  instanceOrUrl: string,
-  apiToken?: string,
-  options?: ConfigureOptions,
-): MCPServersConfig {
-  const env = {};
-
-  // local set up
-  if (!options?.remote) {
-    const args = ['serve'];
-    if (options?.agents) {
-      args.push('--agents');
-    }
-    if (instanceOrUrl) {
-      args.push('--instance', instanceOrUrl);
-    }
-    if (apiToken) {
-      args.push('--token', apiToken);
-    }
-
-    const mcpServerName = buildMcpServerName(options || {});
-    return {
-      [mcpServerName]: {
-        command: 'npx',
-        args: ['-y', '@gleanwork/local-mcp-server', ...args],
-        type: 'stdio',
-        env,
-      },
-    };
-  }
-
-  // Remote configuration requires a full URL
-  if (
-    !instanceOrUrl.startsWith('http://') &&
-    !instanceOrUrl.startsWith('https://')
-  ) {
-    throw new Error(
-      'Remote configuration requires a full URL (starting with http:// or https://)',
-    );
-  }
-
-  const serverUrl = instanceOrUrl;
-  const mcpServerName = buildMcpServerName(options || {}, serverUrl);
-
-  return {
-    [mcpServerName]: {
-      type: 'http',
-      url: serverUrl,
-    },
-  };
-}
-
-claudeCodeClient.configTemplate = (
-  subdomainOrUrl?: string,
-  apiToken?: string,
-  options?: ConfigureOptions,
-): StandardMCPConfig => {
-  const servers = createClaudeCodeMcpServersConfig(
-    subdomainOrUrl || '<glean instance name or URL>',
-    apiToken,
-    options,
-  );
-  return { mcpServers: servers };
-};
+const claudeCodeClient = createBaseClient(CLIENT.CLAUDE_CODE, [
+  'Run `claude mcp list` and verify the server is listed',
+]);
 
 claudeCodeClient.successMessage = (
   configPath: string,

packages/configure-mcp-server/src/configure/client/claude.ts

@@ -4,46 +4,13 @@
  * https://modelcontextprotocol.io/quickstart/user
  */
 
-import path from 'path';
-import { MCPConfigPath, createBaseClient } from './index.js';
+import { createBaseClient } from './index.js';
+import { CLIENT } from '@gleanwork/mcp-config-schema';
 
-export const claudeConfigPath: MCPConfigPath = {
-  configDir: 'Claude',
-  configFileName: 'claude_desktop_config.json',
-};
-
-function claudePathResolver(homedir: string) {
-  let baseDir: string;
-
-  if (process.env.GLEAN_MCP_CONFIG_DIR) {
-    baseDir = process.env.GLEAN_MCP_CONFIG_DIR;
-  } else if (process.platform === 'darwin') {
-    baseDir = path.join(homedir, 'Library', 'Application Support');
-  } else if (process.platform === 'win32') {
-    baseDir = process.env.APPDATA || '';
-  } else {
-    throw new Error('Unsupported platform for Claude Desktop');
-  }
-
-  return path.join(
-    baseDir,
-    claudeConfigPath.configDir,
-    claudeConfigPath.configFileName,
-  );
-}
-
-/**
- * Claude Desktop client configuration
- */
-const claudeClient = createBaseClient(
-  'Claude Desktop',
-  claudeConfigPath,
-  [
-    'Restart Claude Desktop',
-    'You should see a hammer icon in the input box, indicating MCP tools are available',
-    'Click the hammer to see available tools',
-  ],
-  claudePathResolver,
-);
+const claudeClient = createBaseClient(CLIENT.CLAUDE_DESKTOP, [
+  'Restart Claude Desktop',
+  'MCP tools will be available in your conversations',
+  'The model will have access to Glean search and other configured tools',
+]);
 
 export default claudeClient;

packages/configure-mcp-server/src/configure/client/cursor.ts

@@ -4,17 +4,10 @@
  * https://docs.cursor.com/context/model-context-protocol
  */
 
-import { MCPConfigPath, createBaseClient } from './index.js';
+import { createBaseClient } from './index.js';
+import { CLIENT } from '@gleanwork/mcp-config-schema';
 
-export const cursorConfigPath: MCPConfigPath = {
-  configDir: '.cursor',
-  configFileName: 'mcp.json',
-};
-
-/**
- * Cursor client configuration
- */
-const cursorClient = createBaseClient('Cursor', cursorConfigPath, [
+const cursorClient = createBaseClient(CLIENT.CURSOR, [
   'Restart Cursor',
   'Agent will now have access to Glean tools',
   "You'll be asked for approval when Agent uses these tools",

packages/configure-mcp-server/src/configure/client/goose.ts

@@ -1,84 +1,83 @@
-import path from 'path';
+import { createBaseClient } from './index.js';
+import type { ConfigureOptions } from '../index.js';
 import {
-  MCPConfigPath,
-  MCPClientConfig,
-  GooseConfig,
-  GooseExtensionConfig,
-  createBaseClient,
+  CLIENT,
+  MCPConfigRegistry,
   buildMcpServerName,
-  MCPServersConfig,
-} from './index.js';
-import type { ConfigureOptions } from '../index.js';
+} from '@gleanwork/mcp-config-schema';
+import yaml from 'yaml';
+import mcpRemotePackageJson from 'mcp-remote/package.json' with { type: 'json' };
 
-export const gooseConfigPath: MCPConfigPath = {
-  configDir: path.join('.config', 'goose'),
-  configFileName: 'config.yaml',
-};
+const mcpRemoteVersion = mcpRemotePackageJson.version;
 
-function goosePathResolver(homedir: string) {
-  if (process.platform === 'win32') {
-    return path.join(process.env.APPDATA || homedir, 'goose', 'config.yaml');
-  }
+const gooseClient = createBaseClient(CLIENT.GOOSE, ['Restart Goose']);
 
-  const baseDir = process.env.GLEAN_MCP_CONFIG_DIR || homedir;
-  return path.join(
-    baseDir,
-    gooseConfigPath.configDir,
-    gooseConfigPath.configFileName,
-  );
-}
+// Override configTemplate to use the package's YAML output directly
+gooseClient.configTemplate = (
+  instanceOrUrl?: string,
+  apiToken?: string,
+  options?: ConfigureOptions,
+) => {
+  const registry = new MCPConfigRegistry();
+  const builder = registry.createBuilder(CLIENT.GOOSE);
+  const isRemote = options?.remote === true;
 
-function toGooseConfig(servers: MCPServersConfig): GooseConfig {
-  const extensions: Record<string, GooseExtensionConfig> = {};
-  for (const [name, server] of Object.entries(servers)) {
-    if (!server) continue;
+  const configOutput = builder.buildConfiguration({
+    mode: isRemote ? 'remote' : 'local',
+    serverUrl: isRemote ? instanceOrUrl : undefined,
+    instance: !isRemote ? instanceOrUrl : undefined,
+    apiToken: apiToken,
+    serverName: isRemote
+      ? buildMcpServerName({
+          mode: 'remote',
+          serverUrl: instanceOrUrl,
+          agents: options?.agents,
+        })
+      : undefined,
+    includeWrapper: false,
+  });
 
-    // Goose only supports stdio configs (with command and args)
-    // This shouldn't happen in practice since Goose uses createMcpServersConfig
-    // which always generates stdio configs, but check defensively
-    if (!server.command || !server.args) {
-      console.warn(
-        `Skipping server ${name}: Goose requires stdio configuration`,
-      );
-      continue;
-    }
+  // Parse the YAML to pin mcp-remote version if needed
+  const parsed = yaml.parse(configOutput);
 
-    extensions[name] = {
-      args: server.args,
-      bundled: null,
-      cmd: server.command,
-      description: '',
-      enabled: true,
-      env_keys: [],
-      envs: server.env || {},
-      name: 'glean',
-      timeout: 300,
-      type: server.type ?? 'stdio',
-    };
+  if (isRemote) {
+    for (const [, serverConfig] of Object.entries(parsed)) {
+      if (
+        serverConfig &&
+        typeof serverConfig === 'object' &&
+        'cmd' in serverConfig
+      ) {
+        const config = serverConfig as any;
+        if (config.cmd === 'npx' && config.args) {
+          config.args = config.args.map((arg: string) => {
+            if (arg === 'mcp-remote' || arg.startsWith('mcp-remote@')) {
+              return `mcp-remote@${mcpRemoteVersion}`;
+            }
+            return arg;
+          });
+        }
+      }
+    }
   }
-  return { extensions };
-}
 
-function updateConfig(
+  return parsed;
+};
+
+// Custom updateConfig for Goose's flat structure
+gooseClient.updateConfig = (
   existingConfig: Record<string, any>,
   newConfig: Record<string, any>,
-  options: ConfigureOptions,
-): Record<string, any> {
+): Record<string, any> => {
   const result = { ...existingConfig };
-  result.extensions = result.extensions || {};
-  const mcpServerName = buildMcpServerName(options);
-  result.extensions[mcpServerName] = newConfig.extensions[mcpServerName];
-  return result;
-}
 
-const gooseClient: MCPClientConfig = createBaseClient(
-  'Goose',
-  gooseConfigPath,
-  ['Restart Goose'],
-  goosePathResolver,
-  toGooseConfig,
-);
+  // For Goose, servers are at the top level
+  for (const serverName in newConfig) {
+    if (serverName === 'glean' || serverName.startsWith('glean_')) {
+      result[serverName] = newConfig[serverName];
+    }
+  }
 
-gooseClient.updateConfig = updateConfig;
+  return result;
+};
 
 export default gooseClient;