@xmemo/client 0.4.138 → 0.4.141

package/README.md

@@ -310,6 +310,11 @@ absence of embedded token values.
 
 ### Cursor
 
+Cursor marketplace plugin assets live in `.cursor-plugin/marketplace.json` and
+`plugins/xmemo/`. The marketplace plugin is OAuth-first and its `mcp.json` stores
+only `https://xmemo.dev/mcp`; it must not contain `Authorization`, `Bearer`, or
+`XMEMO_KEY`.
+
 Recommended Cursor setup:
 
 ```bash
@@ -331,6 +336,8 @@ Cursor configs include
 non-secret and stored under the user's XMemo CLI config directory. By default,
 the setup prompt also installs a Cursor behavior profile at
 `~/.cursor/memory-profile.md`; answer `n` or pass `--no-profile` to skip it.
+Use this direct-key setup only for local/manual installs where Cursor OAuth is
+unavailable; public plugin submission should use the OAuth-first plugin config.
 
 ### Gemini CLI
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmemo/client",
-  "version": "0.4.138",
+  "version": "0.4.141",
   "description": "Privacy-first CLI and MCP setup helper for XMemo.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -10,7 +10,7 @@ const PACKAGE_NAME = '@xmemo/client';
 const FALLBACK_PACKAGE_NAME = '@yonro/xmemo-client';
 const COMMAND_NAME = 'xmemo';
 const LEGACY_COMMAND_NAME = 'memory-os';
-const CLI_VERSION = '0.4.138';
+const CLI_VERSION = '0.4.141';
 const DEFAULT_SERVICE_URL = 'https://xmemo.dev';
 const TOKEN_ENV_VAR = 'XMEMO_KEY';
 const LEGACY_TOKEN_ENV_VAR = 'MEMORY_OS_MCP_TOKEN';
@@ -64,6 +64,118 @@ const MCP_CLIENTS = new Map([
     buildSnippet: antigravityJsonSnippet,
     writeConfig: mergeAntigravityMcpConfig,
     configKind: 'json'
+  }],
+  ['antigravity-ide', {
+    label: 'Antigravity IDE',
+    defaultConfigPath: defaultAntigravityIdeConfigPath,
+    buildSnippet: antigravityIdeJsonSnippet,
+    writeConfig: mergeAntigravityIdeMcpConfig,
+    configKind: 'json'
+  }],
+  ['antigravity2', {
+    label: 'Antigravity 2.0',
+    defaultConfigPath: defaultAntigravity2ConfigPath,
+    buildSnippet: antigravity2JsonSnippet,
+    writeConfig: mergeAntigravity2McpConfig,
+    configKind: 'json'
+  }],
+  ['antigravity-cli', {
+    label: 'Antigravity CLI',
+    defaultConfigPath: defaultAntigravityCliConfigPath,
+    buildSnippet: antigravityCliJsonSnippet,
+    writeConfig: mergeAntigravityCliMcpConfig,
+    configKind: 'json'
+  }],
+  ['windsurf', {
+    label: 'Windsurf',
+    defaultConfigPath: defaultWindsurfConfigPath,
+    buildSnippet: windsurfJsonSnippet,
+    writeConfig: mergeWindsurfMcpConfig,
+    configKind: 'json'
+  }],
+  ['cline', {
+    label: 'Cline',
+    defaultConfigPath: defaultClineConfigPath,
+    buildSnippet: clineJsonSnippet,
+    writeConfig: mergeClineMcpConfig,
+    configKind: 'json'
+  }],
+  ['continue', {
+    label: 'Continue',
+    defaultConfigPath: defaultContinueConfigPath,
+    buildSnippet: continueJsonSnippet,
+    writeConfig: mergeContinueMcpConfig,
+    configKind: 'json'
+  }],
+  ['claude-desktop', {
+    label: 'Claude Desktop',
+    defaultConfigPath: defaultClaudeConfigPath,
+    buildSnippet: claudeJsonSnippet,
+    writeConfig: mergeClaudeMcpConfig,
+    configKind: 'json'
+  }],
+  ['openclaw', {
+    label: 'OpenClaw',
+    defaultConfigPath: defaultOpenclawConfigPath,
+    buildSnippet: openclawJsonSnippet,
+    writeConfig: mergeOpenclawMcpConfig,
+    configKind: 'json'
+  }],
+  ['kiro', {
+    label: 'Kiro',
+    defaultConfigPath: defaultKiroConfigPath,
+    buildSnippet: kiroJsonSnippet,
+    writeConfig: mergeKiroMcpConfig,
+    configKind: 'json'
+  }],
+  ['zed', {
+    label: 'Zed',
+    defaultConfigPath: defaultZedConfigPath,
+    buildSnippet: zedJsonSnippet,
+    writeConfig: mergeZedMcpConfig,
+    configKind: 'json'
+  }],
+  ['jetbrains', {
+    label: 'JetBrains',
+    defaultConfigPath: defaultJetbrainsConfigPath,
+    buildSnippet: jetbrainsJsonSnippet,
+    writeConfig: mergeJetbrainsMcpConfig,
+    configKind: 'json'
+  }],
+  ['opencode', {
+    label: 'OpenCode',
+    defaultConfigPath: defaultOpencodeConfigPath,
+    buildSnippet: opencodeJsonSnippet,
+    writeConfig: mergeOpencodeMcpConfig,
+    configKind: 'json'
+  }],
+  ['hermes', {
+    label: 'Hermes',
+    defaultConfigPath: defaultHermesConfigPath,
+    buildSnippet: hermesYamlSnippet,
+    writeConfig: mergeHermesMcpConfig,
+    configKind: 'yaml'
+  }],
+  ['qwen', {
+    label: 'Qwen',
+    defaultConfigPath: defaultQwenConfigPath,
+    buildSnippet: qwenJsonSnippet,
+    writeConfig: mergeQwenMcpConfig,
+    configKind: 'json'
+  }],
+  ['trae', {
+    label: 'Trae',
+    defaultConfigPath: defaultTraeConfigPath,
+    buildSnippet: traeJsonSnippet,
+    writeConfig: mergeTraeMcpConfig,
+    configKind: 'json'
+  }],
+  ['claude-code', {
+    label: 'Claude Code',
+    defaultConfigPath: defaultClaudecodeConfigPath,
+    buildSnippet: claudecodeJsonSnippet,
+    writeConfig: mergeClaudecodeMcpConfig,
+    configKind: 'json'
   }]
 ]);
 
@@ -74,7 +186,29 @@ const SETUP_CLIENT_ALIASES = new Map([
   ['copilot-cli', 'copilot-cli'],
   ['gemini', 'gemini-cli'],
   ['gemini-cli', 'gemini-cli'],
-  ['antigravity', 'antigravity']
+  ['antigravity', 'antigravity'],
+  ['antigravity-ide', 'antigravity-ide'],
+  ['antigravity2', 'antigravity2'],
+  ['antigravity-cli', 'antigravity-cli'],
+  ['windsurf', 'windsurf'],
+  ['cline', 'cline'],
+  ['continue', 'continue'],
+  ['claude', 'claude-desktop'],
+  ['claude-desktop', 'claude-desktop'],
+  ['openclaw', 'openclaw'],
+  ['kiro', 'kiro'],
+  ['zed', 'zed'],
+  ['jetbrains', 'jetbrains'],
+  ['opencode', 'opencode'],
+  ['hermes', 'hermes'],
+  ['qwen', 'qwen'],
+  ['qwencli', 'qwen'],
+  ['qwen-cli', 'qwen'],
+  ['trae', 'trae'],
+  ['claude-code', 'claude-code'],
+  ['claudecode', 'claude-code'],
+  ['claude-cli', 'claude-code'],
+  ['claudecode-cli', 'claude-code']
 ]);
 
 class UsageError extends Error {
@@ -393,13 +527,27 @@ async function setupCommand(args, io) {
   const baseUrl = normalizeBaseUrl(baseUrlOption(optionArgs, io.env));
   const outputJson = hasFlag(optionArgs, '--json');
   const shortClientSetup = Boolean(positionalClientId);
-  const clientId = normalizeSetupClientId(positionalClientId ?? optionValue(optionArgs, '--client'));
+  const setupAll = hasFlag(optionArgs, '--all');
+  
+  let clientId = null;
+  try {
+    clientId = normalizeSetupClientId(positionalClientId ?? optionValue(optionArgs, '--client'));
+  } catch (error) {
+    if (!setupAll) {
+      throw error;
+    }
+  }
+
+  if (setupAll && clientId) {
+    throw new UsageError('Cannot specify both --all and a specific client.');
+  }
+
   const dryRun = hasFlag(optionArgs, '--dry-run') || hasFlag(optionArgs, '--preview');
-  const writeConfig = !dryRun && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes') || shortClientSetup);
+  const writeConfig = !dryRun && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes') || shortClientSetup || (setupAll && (hasFlag(optionArgs, '--write') || hasFlag(optionArgs, '--yes'))));
   const timeoutMs = parsePositiveInteger(optionValue(optionArgs, '--timeout-ms') ?? '5000', '--timeout-ms');
 
-  if (writeConfig && !clientId) {
-    throw new UsageError(`Setup --write requires --client <${supportedSetupClientIds().join('|')}> so the CLI never writes broad config implicitly.`);
+  if (writeConfig && !clientId && !setupAll) {
+    throw new UsageError(`Setup --write requires --client <${supportedSetupClientIds().join('|')}> or --all so the CLI never writes broad config implicitly.`);
   }
 
   const discoveryUrl = endpointUrl(baseUrl, '/.well-known/memory-os.json');
@@ -412,7 +560,46 @@ async function setupCommand(args, io) {
   const status = await fetchJson(statusUrl, timeoutMs, io);
   const setupPlan = buildSetupPlan({ baseUrl, discoveryUrl, statusUrl, discovery, status });
 
-  if (clientId) {
+  if (setupAll) {
+    setupPlan.detectedClients = [];
+    const scanIds = ['codex', 'cursor', 'copilot-cli', 'gemini-cli', 'antigravity', 'antigravity-ide', 'antigravity2', 'antigravity-cli', 'windsurf', 'cline', 'continue', 'claude-desktop'];
+    for (const scanId of scanIds) {
+      const detection = await detectClient(scanId, io.env);
+      if (detection.detected) {
+        let clientPlan;
+        if (scanId === 'copilot-cli') {
+          const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
+          clientPlan = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
+          clientPlan.configPath = detection.path;
+          if (writeConfig) {
+            await mergeCopilotMcpConfig(clientPlan.configPath, clientPlan.proxyUrl);
+            clientPlan.written = true;
+          }
+        } else {
+          const client = MCP_CLIENTS.get(scanId);
+          const identity = writeConfig ? await agentIdentity(scanId, io.env) : envReferenceIdentity(scanId);
+          clientPlan = clientSetupPlan(scanId, client, setupPlan.mcpUrl, io.env, identity);
+          clientPlan.configPath = detection.path;
+          if (writeConfig) {
+            await client.writeConfig(clientPlan.configPath, setupPlan.mcpUrl, identity);
+            clientPlan.written = true;
+            if (profileClientConfig(scanId)) {
+              const installProfile = hasFlag(optionArgs, '--yes') || hasFlag(optionArgs, '--profile');
+              if (installProfile) {
+                const profileTarget = defaultProfileTarget(scanId, io.env);
+                const profileResult = await profileInstallResult(scanId, profileTarget, { write: true });
+                clientPlan.behaviorProfile = profileResult;
+                if (scanId === 'codex') {
+                  clientPlan.codexProfile = profileResult;
+                }
+              }
+            }
+          }
+        }
+        setupPlan.detectedClients.push(clientPlan);
+      }
+    }
+  } else if (clientId) {
     if (clientId === 'copilot-cli') {
       const proxyPort = parsePositiveInteger(optionValue(optionArgs, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
       setupPlan.selectedClient = copilotSetupPlan(setupPlan.mcpUrl, proxyPort, io.env);
@@ -1418,6 +1605,34 @@ function mcpConfigTemplate(clientId, mcpUrl) {
     return oauthJsonMcpTemplate(clientId, mcpUrl, antigravityJsonConfig(mcpUrl));
   }
 
+  if (clientId === 'antigravity-ide') {
+    return oauthJsonMcpTemplate(clientId, mcpUrl, antigravityIdeJsonConfig(mcpUrl));
+  }
+
+  if (clientId === 'antigravity2') {
+    return oauthJsonMcpTemplate(clientId, mcpUrl, antigravity2JsonConfig(mcpUrl));
+  }
+
+  if (clientId === 'antigravity-cli') {
+    return oauthJsonMcpTemplate(clientId, mcpUrl, antigravityCliJsonConfig(mcpUrl));
+  }
+
+  if (clientId === 'windsurf') {
+    return bearerJsonMcpTemplate(clientId, mcpUrl, windsurfJsonConfig(mcpUrl));
+  }
+
+  if (clientId === 'cline') {
+    return bearerJsonMcpTemplate(clientId, mcpUrl, clineJsonConfig(mcpUrl));
+  }
+
+  if (clientId === 'continue') {
+    return bearerJsonMcpTemplate(clientId, mcpUrl, continueJsonConfig(mcpUrl));
+  }
+
+  if (clientId === 'claude-desktop') {
+    return bearerJsonMcpTemplate(clientId, mcpUrl, claudeJsonConfig(mcpUrl));
+  }
+
   return {
     client: clientId,
     serverName: MCP_SERVER_NAME,
@@ -1606,6 +1821,30 @@ function writeSetupSummary(plan, io) {
     writeLine(io.stdout, `Admin-only actions: ${plan.boundaries.adminRequired.join(', ')}`);
   }
 
+  if (plan.detectedClients) {
+    writeLine(io.stdout, '');
+    if (plan.detectedClients.length === 0) {
+      writeLine(io.stdout, 'No local IDE or CLI client configurations were detected.');
+      writeLine(io.stdout, `Run \`${COMMAND_NAME} setup <client>\` to configure a client manually.`);
+    } else {
+      writeLine(io.stdout, `Auto-detected ${plan.detectedClients.length} client(s):`);
+      for (const client of plan.detectedClients) {
+        writeLine(io.stdout, `  [${client.written ? '✔' : ' '}] ${client.label}`);
+        writeLine(io.stdout, `      Config: ${client.configPath}`);
+        writeLine(io.stdout, `      Agent ID: ${client.agentId}`);
+      }
+      if (plan.detectedClients.some(c => c.written)) {
+        writeLine(io.stdout, '');
+        writeLine(io.stdout, 'Successfully applied XMemo MCP configuration to all detected clients!');
+        writeLine(io.stdout, 'Restart your IDEs or reload their MCP configurations to apply the changes.');
+      } else {
+        writeLine(io.stdout, '');
+        writeLine(io.stdout, `Run \`${COMMAND_NAME} setup --all --write\` to write configurations for all detected clients.`);
+      }
+    }
+    return;
+  }
+
   if (plan.selectedClient) {
     writeLine(io.stdout, '');
     writeLine(io.stdout, `Selected client: ${plan.selectedClient.label}`);
@@ -2329,6 +2568,135 @@ async function mergeAntigravityMcpConfig(configPath, mcpUrl, identity) {
   await bestEffortChmod(configPath, 0o600);
 }
 
+function antigravityIdeJsonServerConfig(mcpUrl) {
+  return {
+    type: 'http',
+    url: mcpUrl
+  };
+}
+
+function antigravityIdeJsonConfig(mcpUrl) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: antigravityIdeJsonServerConfig(mcpUrl)
+    }
+  };
+}
+
+function antigravityIdeJsonSnippet(mcpUrl, identity = envReferenceIdentity('antigravity-ide')) {
+  return `${JSON.stringify(antigravityIdeJsonConfig(mcpUrl), null, 2)}\n`;
+}
+
+async function mergeAntigravityIdeMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+
+  parsed.mcpServers[MCP_SERVER_NAME] = antigravityIdeJsonServerConfig(mcpUrl);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function antigravity2JsonServerConfig(mcpUrl) {
+  return {
+    type: 'http',
+    url: mcpUrl
+  };
+}
+
+function antigravity2JsonConfig(mcpUrl) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: antigravity2JsonServerConfig(mcpUrl)
+    }
+  };
+}
+
+function antigravity2JsonSnippet(mcpUrl, identity = envReferenceIdentity('antigravity2')) {
+  return `${JSON.stringify(antigravity2JsonConfig(mcpUrl), null, 2)}\n`;
+}
+
+async function mergeAntigravity2McpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+
+  parsed.mcpServers[MCP_SERVER_NAME] = antigravity2JsonServerConfig(mcpUrl);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function antigravityCliJsonServerConfig(mcpUrl, identity = envReferenceIdentity('antigravity-cli')) {
+  return {
+    httpUrl: mcpUrl,
+    headers: {
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
+}
+
+function antigravityCliJsonConfig(mcpUrl, identity = envReferenceIdentity('antigravity-cli')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: antigravityCliJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function antigravityCliJsonSnippet(mcpUrl, identity = envReferenceIdentity('antigravity-cli')) {
+  return `${JSON.stringify(antigravityCliJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeAntigravityCliMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+
+  parsed.mcpServers[MCP_SERVER_NAME] = antigravityCliJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
 
 async function mergeGeminiMcpConfig(configPath, mcpUrl, identity) {
   const existing = await readTextIfExists(configPath);
@@ -2485,11 +2853,11 @@ function supportedMcpClientIds() {
 }
 
 function supportedSetupClientIds() {
-  return ['codex', 'cursor', 'copilot', 'gemini', 'antigravity'];
+  return ['codex', 'cursor', 'copilot', 'gemini', 'antigravity', 'antigravity-ide', 'antigravity2', 'antigravity-cli', 'windsurf', 'cline', 'continue', 'claude'];
 }
 
 function usesClientOAuth(clientId) {
-  return clientId === 'gemini-cli' || clientId === 'antigravity';
+  return clientId === 'gemini-cli' || clientId === 'antigravity' || clientId === 'antigravity-ide' || clientId === 'antigravity2' || clientId === 'antigravity-cli';
 }
 
 function credentialsPath(env) {
@@ -2537,6 +2905,21 @@ function defaultAntigravityConfigPath(env) {
   return path.join(home, '.gemini', 'antigravity', 'mcp_config.json');
 }
 
+function defaultAntigravityIdeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.gemini', 'config', 'mcp_config.json');
+}
+
+function defaultAntigravity2ConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.antigravity2', 'mcp.json');
+}
+
+function defaultAntigravityCliConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.antigravity', 'settings.json');
+}
+
 function defaultCopilotConfigPath(env) {
   const home = env.USERPROFILE || env.HOME || os.homedir();
   return path.join(env.COPILOT_HOME ?? path.join(home, '.copilot'), 'mcp-config.json');
@@ -2666,6 +3049,51 @@ async function sleep(ms) {
 }
 
 
+async function detectClient(clientId, env) {
+  let filePaths = [];
+  if (clientId === 'copilot-cli' || clientId === 'copilot') {
+    if (process.platform === 'win32' && env.APPDATA) {
+      filePaths.push(path.join(env.APPDATA, 'Code', 'User', 'mcp.json'));
+    } else {
+      const home = env.HOME || os.homedir();
+      if (process.platform === 'darwin') {
+        filePaths.push(path.join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json'));
+      }
+      filePaths.push(path.join(home, '.config', 'Code', 'User', 'mcp.json'));
+    }
+    filePaths.push(defaultCopilotConfigPath(env));
+  } else {
+    const client = MCP_CLIENTS.get(clientId);
+    if (client) {
+      filePaths.push(client.defaultConfigPath(env));
+    }
+  }
+
+  if (clientId === 'cline') {
+    if (process.platform === 'win32' && env.APPDATA) {
+      filePaths.push(path.join(env.APPDATA, 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'));
+    } else {
+      const home = env.HOME || os.homedir();
+      if (process.platform === 'darwin') {
+        filePaths.push(path.join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'));
+      }
+      filePaths.push(path.join(home, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'));
+    }
+  }
+
+  for (const filePath of filePaths) {
+    if (await fileExists(filePath)) {
+      return { detected: true, path: filePath };
+    }
+    const parentDir = path.dirname(filePath);
+    if (await fileExists(parentDir)) {
+      return { detected: true, path: filePath };
+    }
+  }
+
+  return { detected: false };
+}
+
 function npmExecutable() {
   return os.platform() === 'win32' ? 'npm.cmd' : 'npm';
 }
@@ -2753,6 +3181,641 @@ function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
-function writeLine(stream, line) {
-  stream.write(`${line}\n`);
+function defaultWindsurfConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.codeium', 'windsurf', 'mcp_config.json');
+}
+
+function defaultClineConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, 'Documents', 'Cline', 'MCP', 'cline_mcp_settings.json');
+}
+
+function defaultContinueConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.continue', 'config.json');
+}
+
+function defaultClaudeConfigPath(env) {
+  if (process.platform === 'win32' && env.APPDATA) {
+    return path.join(env.APPDATA, 'Claude', 'claude_desktop_config.json');
+  }
+  const home = env.HOME || os.homedir();
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+  return path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+}
+
+function windsurfJsonServerConfig(mcpUrl, identity = envReferenceIdentity('windsurf')) {
+  return {
+    serverUrl: mcpUrl,
+    headers: {
+      Authorization: `Bearer \${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
 }
+
+function windsurfJsonConfig(mcpUrl, identity = envReferenceIdentity('windsurf')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: windsurfJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function windsurfJsonSnippet(mcpUrl, identity = envReferenceIdentity('windsurf')) {
+  return `${JSON.stringify(windsurfJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeWindsurfMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = windsurfJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function clineJsonServerConfig(mcpUrl, identity = envReferenceIdentity('cline')) {
+  return {
+    httpUrl: mcpUrl,
+    headers: {
+      Authorization: `Bearer \${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
+}
+
+function clineJsonConfig(mcpUrl, identity = envReferenceIdentity('cline')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: clineJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function clineJsonSnippet(mcpUrl, identity = envReferenceIdentity('cline')) {
+  return `${JSON.stringify(clineJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeClineMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = clineJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function continueJsonServerConfig(mcpUrl, identity = envReferenceIdentity('continue')) {
+  return {
+    transport: {
+      type: 'streamable-http',
+      url: mcpUrl,
+      headers: {
+        Authorization: `Bearer \${${TOKEN_ENV_VAR}}`,
+        [AGENT_ID_HEADER]: identity.agentId,
+        [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+      }
+    }
+  };
+}
+
+function continueJsonConfig(mcpUrl, identity = envReferenceIdentity('continue')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: continueJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function continueJsonSnippet(mcpUrl, identity = envReferenceIdentity('continue')) {
+  return `${JSON.stringify(continueJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeContinueMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = continueJsonServerConfig(mcpUrl, identity);
+  
+  if (isPlainObject(parsed.experimental)) {
+    if (!Array.isArray(parsed.experimental.modelContextProtocolServers)) {
+      parsed.experimental.modelContextProtocolServers = [];
+    }
+    const hasXMemo = parsed.experimental.modelContextProtocolServers.some(
+      (srv) => srv.transport && srv.transport.url === mcpUrl
+    );
+    if (!hasXMemo) {
+      parsed.experimental.modelContextProtocolServers.push(continueJsonServerConfig(mcpUrl, identity));
+    }
+  }
+
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function claudeJsonServerConfig(mcpUrl, identity = envReferenceIdentity('claude-desktop')) {
+  return {
+    command: 'npx',
+    args: [
+      '-y',
+      'mcp-remote',
+      mcpUrl
+    ],
+    env: {
+      [TOKEN_ENV_VAR]: `\${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_INSTANCE_ENV_VAR]: identity.agentInstanceId
+    }
+  };
+}
+
+function claudeJsonConfig(mcpUrl, identity = envReferenceIdentity('claude-desktop')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: claudeJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function claudeJsonSnippet(mcpUrl, identity = envReferenceIdentity('claude-desktop')) {
+  return `${JSON.stringify(claudeJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeClaudeMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = claudeJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultOpenclawConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.openclaw', 'openclaw.json');
+}
+
+function openclawJsonServerConfig(mcpUrl, identity = envReferenceIdentity('openclaw')) {
+  return {
+    url: mcpUrl,
+    headers: {
+      Authorization: `Bearer \${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
+}
+
+function openclawJsonConfig(mcpUrl, identity = envReferenceIdentity('openclaw')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: openclawJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function openclawJsonSnippet(mcpUrl, identity = envReferenceIdentity('openclaw')) {
+  return `${JSON.stringify(openclawJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeOpenclawMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = openclawJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultKiroConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.kiro', 'settings', 'mcp.json');
+}
+
+function kiroJsonServerConfig(mcpUrl, identity = envReferenceIdentity('kiro')) {
+  return {
+    url: mcpUrl,
+    headers: {
+      Authorization: `Bearer \${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
+}
+
+function kiroJsonConfig(mcpUrl, identity = envReferenceIdentity('kiro')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: kiroJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function kiroJsonSnippet(mcpUrl, identity = envReferenceIdentity('kiro')) {
+  return `${JSON.stringify(kiroJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeKiroMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = kiroJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultZedConfigPath(env) {
+  if (process.platform === 'win32' && env.APPDATA) {
+    return path.join(env.APPDATA, 'Zed', 'settings.json');
+  }
+  const home = env.HOME || env.USERPROFILE || os.homedir();
+  return path.join(home, '.config', 'zed', 'settings.json');
+}
+
+function zedJsonServerConfig(mcpUrl, identity = envReferenceIdentity('zed')) {
+  return {
+    command: 'npx',
+    args: [
+      '-y',
+      'mcp-remote',
+      mcpUrl
+    ],
+    env: {
+      [TOKEN_ENV_VAR]: `\${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_INSTANCE_ENV_VAR]: identity.agentInstanceId
+    }
+  };
+}
+
+function zedJsonConfig(mcpUrl, identity = envReferenceIdentity('zed')) {
+  return {
+    context_servers: {
+      [MCP_SERVER_NAME]: zedJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function zedJsonSnippet(mcpUrl, identity = envReferenceIdentity('zed')) {
+  return `${JSON.stringify(zedJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeZedMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.context_servers)) {
+    parsed.context_servers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.context_servers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains context_servers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.context_servers[MCP_SERVER_NAME] = zedJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultJetbrainsConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.continue', 'config.json');
+}
+
+function jetbrainsJsonServerConfig(mcpUrl, identity = envReferenceIdentity('jetbrains')) {
+  return continueJsonServerConfig(mcpUrl, identity);
+}
+
+function jetbrainsJsonConfig(mcpUrl, identity = envReferenceIdentity('jetbrains')) {
+  return continueJsonConfig(mcpUrl, identity);
+}
+
+function jetbrainsJsonSnippet(mcpUrl, identity = envReferenceIdentity('jetbrains')) {
+  return continueJsonSnippet(mcpUrl, identity);
+}
+
+async function mergeJetbrainsMcpConfig(configPath, mcpUrl, identity) {
+  await mergeContinueMcpConfig(configPath, mcpUrl, identity);
+}
+
+function defaultOpencodeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.config', 'opencode', 'opencode.json');
+}
+
+function opencodeJsonServerConfig(mcpUrl, identity = envReferenceIdentity('opencode')) {
+  return {
+    type: 'local',
+    command: [
+      'npx',
+      '-y',
+      'mcp-remote',
+      mcpUrl
+    ],
+    environment: {
+      [TOKEN_ENV_VAR]: `\${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_INSTANCE_ENV_VAR]: identity.agentInstanceId
+    }
+  };
+}
+
+function opencodeJsonConfig(mcpUrl, identity = envReferenceIdentity('opencode')) {
+  return {
+    mcp: {
+      [MCP_SERVER_NAME]: opencodeJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function opencodeJsonSnippet(mcpUrl, identity = envReferenceIdentity('opencode')) {
+  return `${JSON.stringify(opencodeJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeOpencodeMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcp)) {
+    parsed.mcp = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcp);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcp.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcp[MCP_SERVER_NAME] = opencodeJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultHermesConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.hermes', 'config.yaml');
+}
+
+function hermesYamlSnippet(mcpUrl, identity = envReferenceIdentity('hermes')) {
+  return `mcp_servers:
+  ${MCP_SERVER_NAME}:
+    command: npx
+    args:
+      - -y
+      - mcp-remote
+      - ${mcpUrl}
+    env:
+      ${TOKEN_ENV_VAR}: "\${env:${TOKEN_ENV_VAR}}"
+      ${AGENT_INSTANCE_ENV_VAR}: "${identity.agentInstanceId}"
+`;
+}
+
+async function mergeHermesMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  
+  if (existing.includes(`${MCP_SERVER_NAME}:`) || existing.includes('memory_os:') || existing.includes('memory-os:')) {
+    throw new UsageError(`MCP config already contains ${MCP_SERVER_NAME} in mcp_servers. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  
+  if (existing.trim().length === 0) {
+    await fs.writeFile(configPath, hermesYamlSnippet(mcpUrl, identity), { mode: 0o600 });
+  } else if (existing.includes('mcp_servers:')) {
+    const replacement = `mcp_servers:
+  ${MCP_SERVER_NAME}:
+    command: npx
+    args:
+      - -y
+      - mcp-remote
+      - ${mcpUrl}
+    env:
+      ${TOKEN_ENV_VAR}: "\${env:${TOKEN_ENV_VAR}}"
+      ${AGENT_INSTANCE_ENV_VAR}: "${identity.agentInstanceId}"`;
+    const updated = existing.replace('mcp_servers:', replacement);
+    await fs.writeFile(configPath, updated, { mode: 0o600 });
+  } else {
+    const prefix = existing.endsWith('\n') ? '' : '\n';
+    await fs.appendFile(configPath, `${prefix}${hermesYamlSnippet(mcpUrl, identity)}`, { mode: 0o600 });
+  }
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultQwenConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.qwen', 'settings.json');
+}
+
+function qwenJsonServerConfig(mcpUrl, identity = envReferenceIdentity('qwen')) {
+  return {
+    url: mcpUrl,
+    headers: {
+      Authorization: `Bearer \${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
+}
+
+// Reuse the trae config layout which uses mcpServers
+function qwenJsonConfig(mcpUrl, identity = envReferenceIdentity('qwen')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: qwenJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function qwenJsonSnippet(mcpUrl, identity = envReferenceIdentity('qwen')) {
+  return `${JSON.stringify(qwenJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeQwenMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = qwenJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultTraeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.trae', 'mcp.json');
+}
+
+function traeJsonServerConfig(mcpUrl, identity = envReferenceIdentity('trae')) {
+  return {
+    url: mcpUrl,
+    headers: {
+      Authorization: `Bearer \${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_ID_HEADER]: identity.agentId,
+      [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+    }
+  };
+}
+
+function traeJsonConfig(mcpUrl, identity = envReferenceIdentity('trae')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: traeJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+// Return Trae MCP config snippet
+function traeJsonSnippet(mcpUrl, identity = envReferenceIdentity('trae')) {
+  return `${JSON.stringify(traeJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeTraeMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = traeJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function defaultClaudecodeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.claude.json');
+}
+
+function claudecodeJsonServerConfig(mcpUrl, identity = envReferenceIdentity('claude-code')) {
+  return {
+    command: 'npx',
+    args: [
+      '-y',
+      'mcp-remote',
+      mcpUrl
+    ],
+    env: {
+      [TOKEN_ENV_VAR]: `\${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_INSTANCE_ENV_VAR]: identity.agentInstanceId
+    }
+  };
+}
+
+function claudecodeJsonConfig(mcpUrl, identity = envReferenceIdentity('claude-code')) {
+  return {
+    mcpServers: {
+      [MCP_SERVER_NAME]: claudecodeJsonServerConfig(mcpUrl, identity)
+    }
+  };
+}
+
+function claudecodeJsonSnippet(mcpUrl, identity = envReferenceIdentity('claude-code')) {
+  return `${JSON.stringify(claudecodeJsonConfig(mcpUrl, identity), null, 2)}\n`;
+}
+
+async function mergeClaudecodeMcpConfig(configPath, mcpUrl, identity) {
+  const existing = await readTextIfExists(configPath);
+  const parsed = existing.trim().length === 0 ? {} : parseJsonConfig(existing, configPath);
+  if (!isPlainObject(parsed)) {
+    throw new UsageError(`MCP JSON config must be an object: ${configPath}`);
+  }
+  if (!isPlainObject(parsed.mcpServers)) {
+    parsed.mcpServers = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed.mcpServers);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains mcpServers.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed.mcpServers[MCP_SERVER_NAME] = claudecodeJsonServerConfig(mcpUrl, identity);
+  await fs.mkdir(path.dirname(configPath), { recursive: true, mode: 0o700 });
+  await fs.writeFile(configPath, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+  await bestEffortChmod(configPath, 0o600);
+}
+
+function writeLine(stream, line) {
+  stream.write(`${line}\n`);
+}
+
+
+