@xmemo/client 0.4.154 → 0.4.156

package/src/mcp/json-clients.js

@@ -0,0 +1,354 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  AGENT_INSTANCE_ENV_VAR,
+  AGENT_ID_HEADER,
+  AGENT_INSTANCE_HEADER,
+  MCP_SERVER_NAME,
+  TOKEN_ENV_VAR
+} from '../constants.js';
+import { UsageError } from '../errors.js';
+import {
+  bestEffortChmod,
+  isPlainObject,
+  parseJsonConfig,
+  readTextIfExists
+} from '../runtime.js';
+import { envReferenceIdentity } from './identity.js';
+import { existingJsonMcpServerName } from './names.js';
+
+export const JSON_MCP_CLIENT_DEFINITIONS = Object.freeze([
+  httpClientDefinition('cursor', 'Cursor', 'defaultCursorConfigPath', { urlKey: 'url', authentication: 'env-bearer' }),
+  httpClientDefinition('gemini-cli', 'Gemini CLI', 'defaultGeminiConfigPath', { urlKey: 'httpUrl', authentication: 'oauth' }),
+  httpClientDefinition('antigravity', 'Antigravity', 'defaultAntigravityConfigPath', { urlKey: 'serverUrl', authentication: 'oauth' }),
+  httpClientDefinition('antigravity-ide', 'Antigravity IDE', 'defaultAntigravityIdeConfigPath', { urlKey: 'url', authentication: 'oauth', defaultIdentityId: 'antigravity', extra: { type: 'http' } }),
+  httpClientDefinition('antigravity2', 'Antigravity 2.0', 'defaultAntigravity2ConfigPath', { urlKey: 'url', authentication: 'oauth', defaultIdentityId: 'antigravity', extra: { type: 'http' } }),
+  httpClientDefinition('antigravity-cli', 'Antigravity CLI', 'defaultAntigravityCliConfigPath', { urlKey: 'httpUrl', authentication: 'oauth', defaultIdentityId: 'antigravity' }),
+  httpClientDefinition('windsurf', 'Windsurf', 'defaultWindsurfConfigPath', { urlKey: 'serverUrl', authentication: 'env-bearer' }),
+  httpClientDefinition('cline', 'Cline', 'defaultClineConfigPath', { urlKey: 'httpUrl', authentication: 'env-bearer' }),
+  nestedTransportClientDefinition('continue', 'Continue', 'defaultContinueConfigPath'),
+  commandClientDefinition('claude-desktop', 'Claude Desktop', 'defaultClaudeConfigPath'),
+  httpClientDefinition('openclaw', 'OpenClaw', 'defaultOpenclawConfigPath', { urlKey: 'url', authentication: 'env-bearer' }),
+  httpClientDefinition('kiro', 'Kiro', 'defaultKiroConfigPath', { urlKey: 'url', authentication: 'env-bearer' }),
+  commandClientDefinition('zed', 'Zed', 'defaultZedConfigPath', { section: 'context_servers' }),
+  nestedTransportClientDefinition('jetbrains', 'JetBrains', 'defaultJetbrainsConfigPath'),
+  remoteClientDefinition('opencode', 'OpenCode', 'defaultOpencodeConfigPath'),
+  httpClientDefinition('qwen', 'Qwen', 'defaultQwenConfigPath', { urlKey: 'httpUrl', authentication: 'oauth' }),
+  commandClientDefinition('trae', 'Trae', 'defaultTraeConfigPath'),
+  commandClientDefinition('trae-solo', 'Trae Solo', 'defaultTraeSoloConfigPath'),
+  commandClientDefinition('claude-code', 'Claude Code', 'defaultClaudecodeConfigPath')
+]);
+
+const JSON_MCP_CLIENTS_BY_ID = new Map(JSON_MCP_CLIENT_DEFINITIONS.map((definition) => [definition.id, definition]));
+
+function httpClientDefinition(id, label, defaultConfigPath, options) {
+  return {
+    id,
+    label,
+    defaultConfigPath,
+    configKind: 'json',
+    section: 'mcpServers',
+    serverKind: 'http',
+    bearerSyntax: 'env-colon',
+    ...options
+  };
+}
+
+function nestedTransportClientDefinition(id, label, defaultConfigPath) {
+  return {
+    id,
+    label,
+    defaultConfigPath,
+    configKind: 'json',
+    section: 'mcpServers',
+    serverKind: 'nested-transport',
+    authentication: 'env-bearer',
+    bearerSyntax: 'plain',
+    mergeExperimentalModelContextProtocolServers: true
+  };
+}
+
+function commandClientDefinition(id, label, defaultConfigPath, options = {}) {
+  return {
+    id,
+    label,
+    defaultConfigPath,
+    configKind: 'json',
+    section: 'mcpServers',
+    serverKind: 'mcp-remote-command',
+    authentication: 'env-bearer',
+    ...options
+  };
+}
+
+function remoteClientDefinition(id, label, defaultConfigPath) {
+  return {
+    id,
+    label,
+    defaultConfigPath,
+    configKind: 'json',
+    section: 'mcp',
+    serverKind: 'remote',
+    authentication: 'oauth'
+  };
+}
+
+export function jsonMcpClientDefinition(clientId) {
+  return JSON_MCP_CLIENTS_BY_ID.get(clientId) ?? null;
+}
+
+export function jsonMcpClientIds() {
+  return JSON_MCP_CLIENT_DEFINITIONS.map((definition) => definition.id);
+}
+
+export function jsonClientConfig(clientId, mcpUrl, identity) {
+  const definition = requireJsonMcpClientDefinition(clientId);
+  return sectionConfig(definition.section, jsonClientServerConfig(clientId, mcpUrl, identity));
+}
+
+export function jsonClientSnippet(clientId, mcpUrl, identity) {
+  return `${JSON.stringify(jsonClientConfig(clientId, mcpUrl, identity), null, 2)}\n`;
+}
+
+export function jsonClientServerConfig(clientId, mcpUrl, identity) {
+  const definition = requireJsonMcpClientDefinition(clientId);
+  const resolvedIdentity = identity ?? envReferenceIdentity(definition.defaultIdentityId ?? definition.id);
+  return serverConfigFromDefinition(definition, mcpUrl, resolvedIdentity);
+}
+
+export async function mergeJsonClientMcpConfig(clientId, configPath, mcpUrl, identity) {
+  const definition = requireJsonMcpClientDefinition(clientId);
+  const serverConfig = serverConfigFromDefinition(definition, mcpUrl, identity);
+  await mergeJsonSectionConfig(configPath, definition.section, serverConfig, definition.section, (parsed) => {
+    if (definition.mergeExperimentalModelContextProtocolServers && isPlainObject(parsed.experimental)) {
+      mergeExperimentalModelContextProtocolServers(parsed, serverConfig, mcpUrl);
+    }
+  });
+}
+
+function requireJsonMcpClientDefinition(clientId) {
+  const definition = jsonMcpClientDefinition(clientId);
+  if (!definition) {
+    throw new UsageError(`Unsupported JSON MCP client: ${clientId}`);
+  }
+  return definition;
+}
+
+function sectionConfig(sectionName, serverConfig) {
+  return {
+    [sectionName]: {
+      [MCP_SERVER_NAME]: serverConfig
+    }
+  };
+}
+
+function serverConfigFromDefinition(definition, mcpUrl, identity) {
+  if (definition.serverKind === 'mcp-remote-command') {
+    return mcpRemoteCommandJsonServerConfig(mcpUrl, identity);
+  }
+
+  if (definition.serverKind === 'nested-transport') {
+    return {
+      transport: {
+        type: 'streamable-http',
+        url: mcpUrl,
+        headers: headersForDefinition(definition, identity)
+      }
+    };
+  }
+
+  if (definition.serverKind === 'remote') {
+    return {
+      type: 'remote',
+      url: mcpUrl,
+      enabled: true,
+      headers: headersForDefinition(definition, identity)
+    };
+  }
+
+  return {
+    ...(definition.extra ?? {}),
+    [definition.urlKey]: mcpUrl,
+    headers: headersForDefinition(definition, identity)
+  };
+}
+
+function headersForDefinition(definition, identity) {
+  const headers = {
+    [AGENT_ID_HEADER]: identity.agentId,
+    [AGENT_INSTANCE_HEADER]: identity.agentInstanceId
+  };
+
+  if (definition.authentication === 'env-bearer') {
+    headers.Authorization = authorizationHeader(definition.bearerSyntax);
+  }
+
+  return orderedHeaders(headers);
+}
+
+function orderedHeaders(headers) {
+  if (!headers.Authorization) {
+    return headers;
+  }
+  return {
+    Authorization: headers.Authorization,
+    [AGENT_ID_HEADER]: headers[AGENT_ID_HEADER],
+    [AGENT_INSTANCE_HEADER]: headers[AGENT_INSTANCE_HEADER]
+  };
+}
+
+function authorizationHeader(syntax) {
+  if (syntax === 'plain') {
+    return `Bearer \${${TOKEN_ENV_VAR}}`;
+  }
+  return `Bearer \${env:${TOKEN_ENV_VAR}}`;
+}
+
+function mcpRemoteCommandJsonServerConfig(mcpUrl, identity) {
+  return {
+    command: 'npx',
+    args: [
+      '-y',
+      'mcp-remote',
+      mcpUrl,
+      '--header',
+      `Authorization:Bearer \${${TOKEN_ENV_VAR}}`,
+      '--header',
+      `${AGENT_ID_HEADER}:${identity.agentId}`,
+      '--header',
+      `${AGENT_INSTANCE_HEADER}:\${${AGENT_INSTANCE_ENV_VAR}}`
+    ],
+    env: {
+      [TOKEN_ENV_VAR]: `\${env:${TOKEN_ENV_VAR}}`,
+      [AGENT_INSTANCE_ENV_VAR]: identity.agentInstanceId
+    }
+  };
+}
+
+async function mergeJsonSectionConfig(configPath, sectionName, serverConfig, duplicatePath = sectionName, afterMerge) {
+  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[sectionName])) {
+    parsed[sectionName] = {};
+  }
+  const existingName = existingJsonMcpServerName(parsed[sectionName]);
+  if (existingName) {
+    throw new UsageError(`MCP config already contains ${duplicatePath}.${existingName}. Edit ${configPath} manually to avoid duplicate server definitions.`);
+  }
+  parsed[sectionName][MCP_SERVER_NAME] = serverConfig;
+  afterMerge?.(parsed);
+  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 mergeExperimentalModelContextProtocolServers(parsed, serverConfig, mcpUrl) {
+  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(serverConfig);
+  }
+}
+
+export const cursorJsonConfig = (mcpUrl, identity = envReferenceIdentity('cursor')) => jsonClientConfig('cursor', mcpUrl, identity);
+export const cursorJsonSnippet = (mcpUrl, identity = envReferenceIdentity('cursor')) => jsonClientSnippet('cursor', mcpUrl, identity);
+export const cursorJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('cursor')) => jsonClientServerConfig('cursor', mcpUrl, identity);
+export const mergeJsonMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('cursor', configPath, mcpUrl, identity);
+
+export const geminiJsonConfig = (mcpUrl, identity = envReferenceIdentity('gemini-cli')) => jsonClientConfig('gemini-cli', mcpUrl, identity);
+export const geminiJsonSnippet = (mcpUrl, identity = envReferenceIdentity('gemini-cli')) => jsonClientSnippet('gemini-cli', mcpUrl, identity);
+export const geminiJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('gemini-cli')) => jsonClientServerConfig('gemini-cli', mcpUrl, identity);
+export const mergeGeminiMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('gemini-cli', configPath, mcpUrl, identity);
+
+export const antigravityJsonConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientConfig('antigravity', mcpUrl, identity);
+export const antigravityJsonSnippet = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientSnippet('antigravity', mcpUrl, identity);
+export const antigravityJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientServerConfig('antigravity', mcpUrl, identity);
+export const mergeAntigravityMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('antigravity', configPath, mcpUrl, identity);
+
+export const antigravityIdeJsonConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientConfig('antigravity-ide', mcpUrl, identity);
+export const antigravityIdeJsonSnippet = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientSnippet('antigravity-ide', mcpUrl, identity);
+export const antigravityIdeJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientServerConfig('antigravity-ide', mcpUrl, identity);
+export const mergeAntigravityIdeMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('antigravity-ide', configPath, mcpUrl, identity);
+
+export const antigravity2JsonConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientConfig('antigravity2', mcpUrl, identity);
+export const antigravity2JsonSnippet = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientSnippet('antigravity2', mcpUrl, identity);
+export const antigravity2JsonServerConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientServerConfig('antigravity2', mcpUrl, identity);
+export const mergeAntigravity2McpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('antigravity2', configPath, mcpUrl, identity);
+
+export const antigravityCliJsonConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientConfig('antigravity-cli', mcpUrl, identity);
+export const antigravityCliJsonSnippet = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientSnippet('antigravity-cli', mcpUrl, identity);
+export const antigravityCliJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('antigravity')) => jsonClientServerConfig('antigravity-cli', mcpUrl, identity);
+export const mergeAntigravityCliMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('antigravity-cli', configPath, mcpUrl, identity);
+
+export const windsurfJsonConfig = (mcpUrl, identity = envReferenceIdentity('windsurf')) => jsonClientConfig('windsurf', mcpUrl, identity);
+export const windsurfJsonSnippet = (mcpUrl, identity = envReferenceIdentity('windsurf')) => jsonClientSnippet('windsurf', mcpUrl, identity);
+export const windsurfJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('windsurf')) => jsonClientServerConfig('windsurf', mcpUrl, identity);
+export const mergeWindsurfMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('windsurf', configPath, mcpUrl, identity);
+
+export const clineJsonConfig = (mcpUrl, identity = envReferenceIdentity('cline')) => jsonClientConfig('cline', mcpUrl, identity);
+export const clineJsonSnippet = (mcpUrl, identity = envReferenceIdentity('cline')) => jsonClientSnippet('cline', mcpUrl, identity);
+export const clineJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('cline')) => jsonClientServerConfig('cline', mcpUrl, identity);
+export const mergeClineMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('cline', configPath, mcpUrl, identity);
+
+export const continueJsonConfig = (mcpUrl, identity = envReferenceIdentity('continue')) => jsonClientConfig('continue', mcpUrl, identity);
+export const continueJsonSnippet = (mcpUrl, identity = envReferenceIdentity('continue')) => jsonClientSnippet('continue', mcpUrl, identity);
+export const continueJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('continue')) => jsonClientServerConfig('continue', mcpUrl, identity);
+export const mergeContinueMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('continue', configPath, mcpUrl, identity);
+
+export const claudeJsonConfig = (mcpUrl, identity = envReferenceIdentity('claude-desktop')) => jsonClientConfig('claude-desktop', mcpUrl, identity);
+export const claudeJsonSnippet = (mcpUrl, identity = envReferenceIdentity('claude-desktop')) => jsonClientSnippet('claude-desktop', mcpUrl, identity);
+export const claudeJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('claude-desktop')) => jsonClientServerConfig('claude-desktop', mcpUrl, identity);
+export const mergeClaudeMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('claude-desktop', configPath, mcpUrl, identity);
+
+export const openclawJsonConfig = (mcpUrl, identity = envReferenceIdentity('openclaw')) => jsonClientConfig('openclaw', mcpUrl, identity);
+export const openclawJsonSnippet = (mcpUrl, identity = envReferenceIdentity('openclaw')) => jsonClientSnippet('openclaw', mcpUrl, identity);
+export const openclawJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('openclaw')) => jsonClientServerConfig('openclaw', mcpUrl, identity);
+export const mergeOpenclawMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('openclaw', configPath, mcpUrl, identity);
+
+export const kiroJsonConfig = (mcpUrl, identity = envReferenceIdentity('kiro')) => jsonClientConfig('kiro', mcpUrl, identity);
+export const kiroJsonSnippet = (mcpUrl, identity = envReferenceIdentity('kiro')) => jsonClientSnippet('kiro', mcpUrl, identity);
+export const kiroJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('kiro')) => jsonClientServerConfig('kiro', mcpUrl, identity);
+export const mergeKiroMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('kiro', configPath, mcpUrl, identity);
+
+export const zedJsonConfig = (mcpUrl, identity = envReferenceIdentity('zed')) => jsonClientConfig('zed', mcpUrl, identity);
+export const zedJsonSnippet = (mcpUrl, identity = envReferenceIdentity('zed')) => jsonClientSnippet('zed', mcpUrl, identity);
+export const zedJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('zed')) => jsonClientServerConfig('zed', mcpUrl, identity);
+export const mergeZedMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('zed', configPath, mcpUrl, identity);
+
+export const jetbrainsJsonConfig = (mcpUrl, identity = envReferenceIdentity('jetbrains')) => jsonClientConfig('jetbrains', mcpUrl, identity);
+export const jetbrainsJsonSnippet = (mcpUrl, identity = envReferenceIdentity('jetbrains')) => jsonClientSnippet('jetbrains', mcpUrl, identity);
+export const jetbrainsJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('jetbrains')) => jsonClientServerConfig('jetbrains', mcpUrl, identity);
+export const mergeJetbrainsMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('jetbrains', configPath, mcpUrl, identity);
+
+export const opencodeJsonConfig = (mcpUrl, identity = envReferenceIdentity('opencode')) => jsonClientConfig('opencode', mcpUrl, identity);
+export const opencodeJsonSnippet = (mcpUrl, identity = envReferenceIdentity('opencode')) => jsonClientSnippet('opencode', mcpUrl, identity);
+export const opencodeJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('opencode')) => jsonClientServerConfig('opencode', mcpUrl, identity);
+export const mergeOpencodeMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('opencode', configPath, mcpUrl, identity);
+
+export const qwenJsonConfig = (mcpUrl, identity = envReferenceIdentity('qwen')) => jsonClientConfig('qwen', mcpUrl, identity);
+export const qwenJsonSnippet = (mcpUrl, identity = envReferenceIdentity('qwen')) => jsonClientSnippet('qwen', mcpUrl, identity);
+export const qwenJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('qwen')) => jsonClientServerConfig('qwen', mcpUrl, identity);
+export const mergeQwenMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('qwen', configPath, mcpUrl, identity);
+
+export const traeJsonConfig = (mcpUrl, identity = envReferenceIdentity('trae')) => jsonClientConfig('trae', mcpUrl, identity);
+export const traeJsonSnippet = (mcpUrl, identity = envReferenceIdentity('trae')) => jsonClientSnippet('trae', mcpUrl, identity);
+export const traeJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('trae')) => jsonClientServerConfig('trae', mcpUrl, identity);
+export const mergeTraeMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('trae', configPath, mcpUrl, identity);
+
+export const traeSoloJsonConfig = (mcpUrl, identity = envReferenceIdentity('trae-solo')) => jsonClientConfig('trae-solo', mcpUrl, identity);
+export const traeSoloJsonSnippet = (mcpUrl, identity = envReferenceIdentity('trae-solo')) => jsonClientSnippet('trae-solo', mcpUrl, identity);
+export const traeSoloJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('trae-solo')) => jsonClientServerConfig('trae-solo', mcpUrl, identity);
+export const mergeTraeSoloMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('trae-solo', configPath, mcpUrl, identity);
+
+export const claudecodeJsonConfig = (mcpUrl, identity = envReferenceIdentity('claude-code')) => jsonClientConfig('claude-code', mcpUrl, identity);
+export const claudecodeJsonSnippet = (mcpUrl, identity = envReferenceIdentity('claude-code')) => jsonClientSnippet('claude-code', mcpUrl, identity);
+export const claudecodeJsonServerConfig = (mcpUrl, identity = envReferenceIdentity('claude-code')) => jsonClientServerConfig('claude-code', mcpUrl, identity);
+export const mergeClaudecodeMcpConfig = (configPath, mcpUrl, identity) => mergeJsonClientMcpConfig('claude-code', configPath, mcpUrl, identity);

package/src/mcp/names.js

@@ -0,0 +1,12 @@
+import {
+  LEGACY_MCP_SERVER_NAMES,
+  MCP_SERVER_NAME
+} from '../constants.js';
+
+export function knownMcpServerNames() {
+  return [MCP_SERVER_NAME, ...LEGACY_MCP_SERVER_NAMES];
+}
+
+export function existingJsonMcpServerName(mcpServers) {
+  return knownMcpServerNames().find((name) => mcpServers[name]);
+}

package/src/mcp/paths.js

@@ -0,0 +1,154 @@
+import os from 'node:os';
+import path from 'node:path';
+
+export function configRoot(env) {
+  if (env.XMEMO_CONFIG_HOME) {
+    return env.XMEMO_CONFIG_HOME;
+  }
+
+  if (env.MEMORY_OS_CONFIG_HOME) {
+    return env.MEMORY_OS_CONFIG_HOME;
+  }
+
+  if (process.platform === 'win32' && env.LOCALAPPDATA) {
+    return path.join(env.LOCALAPPDATA, 'XMemo', 'CLI');
+  }
+
+  if (env.XDG_CONFIG_HOME) {
+    return path.join(env.XDG_CONFIG_HOME, 'xmemo');
+  }
+
+  const home = env.HOME || os.homedir();
+  return path.join(home, '.config', 'xmemo');
+}
+
+export function defaultCodexConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.codex', 'config.toml');
+}
+
+export function defaultCursorConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.cursor', 'mcp.json');
+}
+
+export function defaultGeminiConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.gemini', 'settings.json');
+}
+
+export function defaultAntigravityConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.gemini', 'config', 'mcp_config.json');
+}
+
+export function defaultAntigravityIdeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.gemini', 'config', 'mcp_config.json');
+}
+
+export function defaultAntigravity2ConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.gemini', 'config', 'mcp_config.json');
+}
+
+export function defaultAntigravityCliConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.gemini', 'config', 'mcp_config.json');
+}
+
+export function defaultCopilotConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(env.COPILOT_HOME ?? path.join(home, '.copilot'), 'mcp-config.json');
+}
+
+export function defaultWindsurfConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.codeium', 'windsurf', 'mcp_config.json');
+}
+
+export function defaultClineConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, 'Documents', 'Cline', 'MCP', 'cline_mcp_settings.json');
+}
+
+export function defaultContinueConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.continue', 'config.json');
+}
+
+export 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');
+}
+
+export function defaultOpenclawConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.openclaw', 'openclaw.json');
+}
+
+export function defaultKiroConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.kiro', 'settings', 'mcp.json');
+}
+
+export 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');
+}
+
+export function defaultJetbrainsConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.continue', 'config.json');
+}
+
+export function defaultOpencodeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.config', 'opencode', 'opencode.json');
+}
+
+export function defaultHermesConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.hermes', 'config.yaml');
+}
+
+export function defaultQwenConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.qwen', 'settings.json');
+}
+
+export function defaultTraeConfigPath(env) {
+  if (process.platform === 'win32' && env.APPDATA) {
+    return path.join(env.APPDATA, 'Trae', 'User', 'mcp.json');
+  }
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'Trae', 'User', 'mcp.json');
+  }
+  return path.join(home, '.config', 'Trae', 'User', 'mcp.json');
+}
+
+export function defaultTraeSoloConfigPath(env) {
+  if (process.platform === 'win32' && env.APPDATA) {
+    return path.join(env.APPDATA, 'TRAE SOLO', 'User', 'mcp.json');
+  }
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  if (process.platform === 'darwin') {
+    return path.join(home, 'Library', 'Application Support', 'TRAE SOLO', 'User', 'mcp.json');
+  }
+  return path.join(home, '.config', 'TRAE SOLO', 'User', 'mcp.json');
+}
+
+export function defaultClaudecodeConfigPath(env) {
+  const home = env.USERPROFILE || env.HOME || os.homedir();
+  return path.join(home, '.claude.json');
+}

package/src/mcp/proxy.js

@@ -0,0 +1,111 @@
+import http from 'node:http';
+
+import { optionValue, parsePositiveInteger } from '../args.js';
+import {
+  AGENT_ID_HEADER,
+  AGENT_INSTANCE_HEADER,
+  CLI_VERSION,
+  COMMAND_NAME,
+  DEFAULT_SERVICE_URL,
+  DEFAULT_PROXY_HOST,
+  DEFAULT_PROXY_PORT,
+  PRODUCT_NAME,
+  TOKEN_ENV_VAR
+} from '../constants.js';
+import { credentialsPath, resolveCredentialToken, validateToken } from '../auth.js';
+import { endpointUrl, normalizeBaseUrl } from '../http.js';
+import { UsageError } from '../errors.js';
+import { writeLine } from '../io.js';
+import { closeServer, readAll, waitForShutdown } from '../runtime.js';
+
+export async function mcpProxyCommand(args, io, { agentIdentity }) {
+  const baseUrl = normalizeBaseUrl(baseUrlOption(args, io.env));
+  const mcpUrl = endpointUrl(baseUrl, '/mcp');
+  const host = optionValue(args, '--host') ?? DEFAULT_PROXY_HOST;
+  const port = parsePositiveInteger(optionValue(args, '--port') ?? String(DEFAULT_PROXY_PORT), '--port');
+  const token = await resolveCredentialToken(io.env);
+  if (!token) {
+    throw new UsageError(`No token found. Run \`${COMMAND_NAME} login\` or \`${COMMAND_NAME} token add --from-stdin\` first.`);
+  }
+  validateToken(token);
+  const identity = await agentIdentity('copilot-cli', io.env);
+
+  const server = http.createServer(async (request, response) => {
+    try {
+      await handleMcpProxyRequest({ request, response, mcpUrl, token, identity, io });
+    } catch (error) {
+      response.statusCode = 502;
+      response.setHeader('content-type', 'application/json');
+      response.end(JSON.stringify({ error: 'mcp_proxy_error', message: error.message }));
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, host, () => {
+      server.off('error', reject);
+      resolve();
+    });
+  });
+
+  writeLine(io.stdout, `${PRODUCT_NAME} MCP proxy listening on http://${host}:${port}/mcp`);
+  writeLine(io.stdout, `Forwarding to ${mcpUrl}`);
+  writeLine(io.stdout, `Credential source: ${TOKEN_ENV_VAR} or ${credentialsPath(io.env)}`);
+  if (io.keepAlive === false) {
+    await closeServer(server);
+    return 0;
+  }
+
+  await waitForShutdown(server, io);
+  return 0;
+}
+
+async function handleMcpProxyRequest({ request, response, mcpUrl, token, identity, io }) {
+  const requestUrl = new URL(request.url ?? '/', `http://${request.headers.host ?? `${DEFAULT_PROXY_HOST}:${DEFAULT_PROXY_PORT}`}`);
+  if (request.method !== 'POST' || requestUrl.pathname !== '/mcp') {
+    response.statusCode = 404;
+    response.setHeader('content-type', 'application/json');
+    response.end(JSON.stringify({ error: 'not_found' }));
+    return;
+  }
+
+  const body = await readAll(request);
+  const upstreamHeaders = {
+    accept: String(request.headers.accept || 'application/json, text/event-stream'),
+    'content-type': String(request.headers['content-type'] || 'application/json'),
+    authorization: `Bearer ${token}`,
+    [AGENT_ID_HEADER]: identity.agentId,
+    [AGENT_INSTANCE_HEADER]: identity.agentInstanceId,
+    'user-agent': `XMemo-CLI-Proxy/${CLI_VERSION} (+https://github.com/yonro/memory-os-cli)`
+  };
+  const sessionId = request.headers['mcp-session-id'];
+  if (sessionId) {
+    upstreamHeaders['mcp-session-id'] = Array.isArray(sessionId) ? sessionId[0] : sessionId;
+  }
+
+  const upstream = await io.fetch(mcpUrl, {
+    method: 'POST',
+    headers: upstreamHeaders,
+    body
+  });
+
+  response.statusCode = upstream.status;
+  for (const header of ['content-type', 'mcp-session-id']) {
+    const value = upstream.headers.get(header);
+    if (value) {
+      response.setHeader(header, value);
+    }
+  }
+  const buffer = Buffer.from(await upstream.arrayBuffer());
+  response.end(buffer);
+}
+
+function baseUrlOption(args, env) {
+  return optionValue(args, '--url')
+    ?? optionValue(args, '--base-url')
+    ?? env.XMEMO_URL
+    ?? env.XMEMO_BASE_URL
+    ?? env.MEMORY_OS_URL
+    ?? env.MEMORY_OS_BASE_URL
+    ?? DEFAULT_SERVICE_URL;
+}