ccman 3.0.24 → 3.0.27

package/dist/index.js

@@ -39,7 +39,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.0.24",
+      version: "3.0.27",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -110,7 +110,10 @@ function getCodexAuthPath() {
 function getClaudeConfigPath() {
   return path.join(claudeDir, "settings.json");
 }
-var os, path, isDev, isTest, ccmanDir, codexDir, claudeDir;
+function getClaudeJsonPath() {
+  return path.join(rootDir, ".claude.json");
+}
+var os, path, isDev, isTest, rootDir, ccmanDir, codexDir, claudeDir;
 var init_paths = __esm({
   "../core/dist/paths.js"() {
     "use strict";
@@ -119,20 +122,15 @@ var init_paths = __esm({
     isDev = process.env.NODE_ENV === "development";
     isTest = process.env.NODE_ENV === "test";
     if (isTest) {
-      const testRoot = path.join(os.tmpdir(), `ccman-test-${process.pid}`);
-      ccmanDir = path.join(testRoot, ".ccman");
-      codexDir = path.join(testRoot, ".codex");
-      claudeDir = path.join(testRoot, ".claude");
+      rootDir = path.join(os.tmpdir(), `ccman-test-${process.pid}`);
     } else if (isDev) {
-      const devRoot = path.join(os.tmpdir(), "ccman-dev");
-      ccmanDir = path.join(devRoot, ".ccman");
-      codexDir = path.join(devRoot, ".codex");
-      claudeDir = path.join(devRoot, ".claude");
+      rootDir = path.join(os.tmpdir(), "ccman-dev");
     } else {
-      ccmanDir = path.join(os.homedir(), ".ccman");
-      codexDir = path.join(os.homedir(), ".codex");
-      claudeDir = path.join(os.homedir(), ".claude");
+      rootDir = os.homedir();
     }
+    ccmanDir = path.join(rootDir, ".ccman");
+    codexDir = path.join(rootDir, ".codex");
+    claudeDir = path.join(rootDir, ".claude");
   }
 });
 
@@ -2299,6 +2297,167 @@ var init_claude = __esm({
   }
 });
 
+// ../core/dist/writers/mcp.js
+function getMCPConfigPath() {
+  return path3.join(getCcmanDir(), "mcp.json");
+}
+function migrateMCPConfig(config) {
+  if (Array.isArray(config.managedServerNames)) {
+    config.managedServerNames = {
+      claude: config.managedServerNames,
+      codex: [],
+      cursor: [],
+      windsurf: []
+    };
+  } else if (!config.managedServerNames) {
+    config.managedServerNames = {
+      claude: [],
+      codex: [],
+      cursor: [],
+      windsurf: []
+    };
+  }
+  if (config.servers) {
+    for (const server of config.servers) {
+      if (!server.enabledApps) {
+        server.enabledApps = ["claude"];
+      }
+    }
+  }
+  return config;
+}
+function loadMCPConfig() {
+  const configPath = getMCPConfigPath();
+  if (!fileExists(configPath)) {
+    return {
+      servers: [],
+      managedServerNames: {
+        claude: [],
+        codex: [],
+        cursor: [],
+        windsurf: []
+      }
+    };
+  }
+  const config = readJSON(configPath);
+  return migrateMCPConfig(config);
+}
+function saveMCPConfig(config) {
+  const configPath = getMCPConfigPath();
+  writeJSON(configPath, config);
+}
+function providerToMCPServer(provider) {
+  let env;
+  let description;
+  if (provider.model) {
+    try {
+      const modelData = JSON.parse(provider.model);
+      env = modelData.env;
+      description = modelData.description;
+    } catch (error) {
+      env = JSON.parse(provider.model);
+    }
+  }
+  return {
+    id: provider.id,
+    name: provider.name,
+    command: provider.baseUrl,
+    args: provider.apiKey.split(" ").filter((arg) => arg.length > 0),
+    env,
+    description,
+    createdAt: provider.createdAt,
+    lastModified: provider.lastModified,
+    enabledApps: ["claude"]
+    // 新创建的 MCP 默认启用 Claude
+  };
+}
+function mcpServerToProvider(server) {
+  let model;
+  if (server.env || server.description) {
+    model = JSON.stringify({
+      env: server.env,
+      description: server.description
+    });
+  }
+  return {
+    id: server.id,
+    name: server.name,
+    baseUrl: server.command,
+    apiKey: server.args.join(" "),
+    model,
+    createdAt: server.createdAt,
+    lastModified: server.lastModified
+  };
+}
+function writeMCPConfigForApp(app, _provider) {
+  const mcpConfig = loadMCPConfig();
+  const enabledServers = mcpConfig.servers.filter((server) => server.enabledApps.includes(app));
+  let configPath;
+  let configDir;
+  switch (app) {
+    case "claude":
+      configPath = getClaudeConfigPath();
+      configDir = getClaudeDir();
+      break;
+    case "codex":
+      return;
+    case "cursor":
+      return;
+    case "windsurf":
+      return;
+  }
+  ensureDir(configDir);
+  let appConfig = {};
+  if (fileExists(configPath)) {
+    try {
+      const content = fs4.readFileSync(configPath, "utf-8");
+      appConfig = JSON.parse(content);
+    } catch (error) {
+      throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 ${app} \u914D\u7F6E\u6587\u4EF6: ${error.message}`);
+    }
+  }
+  const existingMCPs = appConfig.mcpServers || {};
+  const userMCPs = {};
+  const managedNames = mcpConfig.managedServerNames[app] || [];
+  for (const [name, config] of Object.entries(existingMCPs)) {
+    if (!managedNames.includes(name)) {
+      userMCPs[name] = config;
+    }
+  }
+  const ccmanMCPs = {};
+  for (const server of enabledServers) {
+    ccmanMCPs[server.name] = {
+      command: server.command,
+      args: server.args,
+      env: server.env
+    };
+  }
+  appConfig.mcpServers = {
+    ...ccmanMCPs,
+    // ccman 管理的
+    ...userMCPs
+    // 用户手动配置的（优先级更高）
+  };
+  const tempPath = `${configPath}.tmp`;
+  fs4.writeFileSync(tempPath, JSON.stringify(appConfig, null, 2), {
+    mode: 384
+  });
+  fs4.renameSync(tempPath, configPath);
+}
+function writeMCPConfig(_provider) {
+  writeMCPConfigForApp("claude", _provider);
+}
+var fs4, path3;
+var init_mcp = __esm({
+  "../core/dist/writers/mcp.js"() {
+    "use strict";
+    fs4 = __toESM(require("fs"), 1);
+    path3 = __toESM(require("path"), 1);
+    init_paths();
+    init_file();
+  }
+});
+
 // ../core/dist/presets/codex.js
 var CODEX_PRESETS;
 var init_codex2 = __esm({
@@ -2359,6 +2518,102 @@ var init_claude2 = __esm({
   }
 });
 
+// ../core/dist/presets/mcp.js
+var MCP_PRESETS_DETAIL, MCP_PRESETS;
+var init_mcp2 = __esm({
+  "../core/dist/presets/mcp.js"() {
+    "use strict";
+    MCP_PRESETS_DETAIL = [
+      {
+        name: "filesystem",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"],
+        description: "\u6587\u4EF6\u7CFB\u7EDF\u8BBF\u95EE",
+        argsPlaceholder: "\u9700\u8981\u4FEE\u6539\u7B2C3\u4E2A\u53C2\u6570\u4E3A\u5141\u8BB8\u8BBF\u95EE\u7684\u76EE\u5F55\u8DEF\u5F84"
+      },
+      {
+        name: "github",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-github"],
+        description: "GitHub \u96C6\u6210",
+        envRequired: ["GITHUB_PERSONAL_ACCESS_TOKEN"]
+      },
+      {
+        name: "postgres",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"],
+        description: "PostgreSQL \u6570\u636E\u5E93",
+        argsPlaceholder: "\u9700\u8981\u4FEE\u6539\u7B2C3\u4E2A\u53C2\u6570\u4E3A\u6570\u636E\u5E93\u8FDE\u63A5\u5B57\u7B26\u4E32"
+      },
+      {
+        name: "brave-search",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-brave-search"],
+        description: "Brave \u641C\u7D22",
+        envRequired: ["BRAVE_API_KEY"]
+      },
+      {
+        name: "google-maps",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-google-maps"],
+        description: "Google Maps",
+        envRequired: ["GOOGLE_MAPS_API_KEY"]
+      },
+      {
+        name: "puppeteer",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-puppeteer"],
+        description: "\u6D4F\u89C8\u5668\u81EA\u52A8\u5316"
+      },
+      {
+        name: "sqlite",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-sqlite", "/path/to/database.db"],
+        description: "SQLite \u6570\u636E\u5E93",
+        argsPlaceholder: "\u9700\u8981\u4FEE\u6539\u7B2C3\u4E2A\u53C2\u6570\u4E3A\u6570\u636E\u5E93\u6587\u4EF6\u8DEF\u5F84"
+      },
+      {
+        name: "sequential-thinking",
+        command: "npx",
+        args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+        description: "\u5E8F\u5217\u601D\u8003\u589E\u5F3A"
+      }
+    ];
+    MCP_PRESETS = MCP_PRESETS_DETAIL.map((preset) => ({
+      name: preset.name,
+      baseUrl: preset.command,
+      // 字段映射：command → baseUrl
+      description: preset.description
+    }));
+  }
+});
+
+// ../core/dist/tool-manager.types.js
+var ProviderNotFoundError, ProviderNameConflictError, PresetNameConflictError;
+var init_tool_manager_types = __esm({
+  "../core/dist/tool-manager.types.js"() {
+    "use strict";
+    ProviderNotFoundError = class extends Error {
+      constructor(id) {
+        super(`\u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${id}`);
+        this.name = "ProviderNotFoundError";
+      }
+    };
+    ProviderNameConflictError = class extends Error {
+      constructor(name) {
+        super(`\u670D\u52A1\u5546\u540D\u79F0\u5DF2\u5B58\u5728: ${name}`);
+        this.name = "ProviderNameConflictError";
+      }
+    };
+    PresetNameConflictError = class extends Error {
+      constructor(name) {
+        super(`\u9884\u7F6E\u540D\u79F0\u5DF2\u5B58\u5728: ${name}`);
+        this.name = "PresetNameConflictError";
+      }
+    };
+  }
+});
+
 // ../core/dist/tool-manager.js
 function createToolManager(tool) {
   const toolConfig = TOOL_CONFIGS[tool];
@@ -2369,6 +2624,9 @@ function createToolManager(tool) {
     return `${tool}-${timestamp}-${random}`;
   }
   function loadConfig2() {
+    if (toolConfig.customLoader) {
+      return toolConfig.customLoader();
+    }
     if (!fileExists(configPath)) {
       ensureDir(getCcmanDir());
       const initialConfig = {
@@ -2381,6 +2639,10 @@ function createToolManager(tool) {
     return readJSON(configPath);
   }
   function saveConfig2(config) {
+    if (toolConfig.customSaver) {
+      toolConfig.customSaver(config);
+      return;
+    }
     writeJSON(configPath, config);
   }
   return {
@@ -2402,6 +2664,9 @@ function createToolManager(tool) {
       };
       config.providers.push(provider);
       saveConfig2(config);
+      if (toolConfig.autoSync) {
+        toolConfig.writer(provider);
+      }
       return provider;
     },
     list() {
@@ -2440,6 +2705,9 @@ function createToolManager(tool) {
       const provider = config.providers.find((p) => p.id === config.currentProviderId);
       return provider || null;
     },
+    // 注：edit 方法的"复杂度"来自必要的业务逻辑（检查存在性、名称冲突、更新 4 个可选字段、同步配置）
+    // 每个 if 都不可避免，没有特殊情况或嵌套逻辑，因此禁用 complexity 检查
+    // eslint-disable-next-line complexity
     edit(id, updates) {
       const config = loadConfig2();
       const provider = config.providers.find((p) => p.id === id);
@@ -2465,6 +2733,9 @@ function createToolManager(tool) {
       if (config.currentProviderId === id) {
         toolConfig.writer(provider);
       }
+      if (toolConfig.autoSync) {
+        toolConfig.writer(provider);
+      }
       return provider;
     },
     remove(id) {
@@ -2478,6 +2749,9 @@ function createToolManager(tool) {
       }
       config.providers.splice(index, 1);
       saveConfig2(config);
+      if (toolConfig.autoSync) {
+        toolConfig.writer({});
+      }
     },
     clone(sourceId, newName) {
       const source = this.get(sourceId);
@@ -2582,45 +2856,63 @@ function createCodexManager() {
 function createClaudeManager() {
   return createToolManager("claude");
 }
-var path3, ProviderNotFoundError, ProviderNameConflictError, PresetNameConflictError, TOOL_CONFIGS;
+function createMCPManager() {
+  return createToolManager("mcp");
+}
+var path4, TOOL_CONFIGS;
 var init_tool_manager = __esm({
   "../core/dist/tool-manager.js"() {
     "use strict";
-    path3 = __toESM(require("path"), 1);
+    path4 = __toESM(require("path"), 1);
     init_paths();
     init_file();
     init_codex();
     init_claude();
+    init_mcp();
     init_codex2();
     init_claude2();
-    ProviderNotFoundError = class extends Error {
-      constructor(id) {
-        super(`\u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${id}`);
-        this.name = "ProviderNotFoundError";
-      }
-    };
-    ProviderNameConflictError = class extends Error {
-      constructor(name) {
-        super(`\u670D\u52A1\u5546\u540D\u79F0\u5DF2\u5B58\u5728: ${name}`);
-        this.name = "ProviderNameConflictError";
-      }
-    };
-    PresetNameConflictError = class extends Error {
-      constructor(name) {
-        super(`\u9884\u7F6E\u540D\u79F0\u5DF2\u5B58\u5728: ${name}`);
-        this.name = "PresetNameConflictError";
-      }
-    };
+    init_mcp2();
+    init_tool_manager_types();
     TOOL_CONFIGS = {
       codex: {
-        configPath: path3.join(getCcmanDir(), "codex.json"),
+        configPath: path4.join(getCcmanDir(), "codex.json"),
         builtinPresets: CODEX_PRESETS,
         writer: writeCodexConfig
       },
       claude: {
-        configPath: path3.join(getCcmanDir(), "claude.json"),
+        configPath: path4.join(getCcmanDir(), "claude.json"),
         builtinPresets: CC_PRESETS,
         writer: writeClaudeConfig
+      },
+      mcp: {
+        configPath: path4.join(getCcmanDir(), "mcp.json"),
+        builtinPresets: MCP_PRESETS,
+        writer: writeMCPConfig,
+        autoSync: true,
+        // MCP 需要在每个操作后自动同步到 ~/.claude.json
+        // MCP 使用特殊的配置格式（MCPConfig），需要自定义 loader/saver
+        customLoader: () => {
+          const mcpConfig = loadMCPConfig();
+          return {
+            providers: mcpConfig.servers.map(mcpServerToProvider),
+            presets: []
+          };
+        },
+        customSaver: (config) => {
+          const mcpConfig = loadMCPConfig();
+          mcpConfig.servers = config.providers.map((provider) => {
+            const existingServer = mcpConfig.servers.find((s2) => s2.id === provider.id);
+            const mcpServer = providerToMCPServer(provider);
+            if (existingServer) {
+              mcpServer.enabledApps = existingServer.enabledApps;
+            }
+            return mcpServer;
+          });
+          for (const app of ["claude", "codex", "cursor", "windsurf"]) {
+            mcpConfig.managedServerNames[app] = mcpConfig.servers.filter((s2) => s2.enabledApps.includes(app)).map((s2) => s2.name);
+          }
+          saveMCPConfig(mcpConfig);
+        }
       }
     };
   }
@@ -2637,17 +2929,17 @@ var init_migrate = __esm({
 // ../core/dist/config.js
 function ensureConfigDir() {
   const dir = getCcmanDir();
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!fs4.existsSync(configPath)) {
+  if (!fs5.existsSync(configPath)) {
     return {};
   }
   try {
-    const content = fs4.readFileSync(configPath, "utf-8");
+    const content = fs5.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to load config: ${error.message}`);
@@ -2658,10 +2950,10 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   try {
     const tempPath = `${configPath}.tmp`;
-    fs4.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
+    fs5.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
       mode: 384
     });
-    fs4.renameSync(tempPath, configPath);
+    fs5.renameSync(tempPath, configPath);
   } catch (error) {
     throw new Error(`Failed to save config: ${error.message}`);
   }
@@ -2682,11 +2974,11 @@ function updateLastSyncTime() {
     saveConfig(config);
   }
 }
-var fs4;
+var fs5;
 var init_config = __esm({
   "../core/dist/config.js"() {
     "use strict";
-    fs4 = __toESM(require("fs"), 1);
+    fs5 = __toESM(require("fs"), 1);
     init_paths();
   }
 });
@@ -2881,22 +3173,22 @@ var require_url_parse = __commonJS({
     }
     function resolve(relative, base) {
       if (relative === "") return base;
-      var path12 = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i2 = path12.length, last = path12[i2 - 1], unshift = false, up = 0;
+      var path13 = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i2 = path13.length, last = path13[i2 - 1], unshift = false, up = 0;
       while (i2--) {
-        if (path12[i2] === ".") {
-          path12.splice(i2, 1);
-        } else if (path12[i2] === "..") {
-          path12.splice(i2, 1);
+        if (path13[i2] === ".") {
+          path13.splice(i2, 1);
+        } else if (path13[i2] === "..") {
+          path13.splice(i2, 1);
           up++;
         } else if (up) {
           if (i2 === 0) unshift = true;
-          path12.splice(i2, 1);
+          path13.splice(i2, 1);
           up--;
         }
       }
-      if (unshift) path12.unshift("");
-      if (last === "." || last === "..") path12.push("");
-      return path12.join("/");
+      if (unshift) path13.unshift("");
+      if (last === "." || last === "..") path13.push("");
+      return path13.join("/");
     }
     function Url(address, location, parser) {
       address = trimLeft(address);
@@ -3322,14 +3614,14 @@ var require_path_posix = __commonJS({
     posix.resolve = function() {
       var resolvedPath = "", resolvedAbsolute = false;
       for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
-        var path12 = i2 >= 0 ? arguments[i2] : process.cwd();
-        if (!isString(path12)) {
+        var path13 = i2 >= 0 ? arguments[i2] : process.cwd();
+        if (!isString(path13)) {
           throw new TypeError("Arguments to path.resolve must be strings");
-        } else if (!path12) {
+        } else if (!path13) {
           continue;
         }
-        resolvedPath = path12 + "/" + resolvedPath;
-        resolvedAbsolute = path12.charAt(0) === "/";
+        resolvedPath = path13 + "/" + resolvedPath;
+        resolvedAbsolute = path13.charAt(0) === "/";
       }
       resolvedPath = normalizeArray(
         resolvedPath.split("/"),
@@ -3337,36 +3629,36 @@ var require_path_posix = __commonJS({
       ).join("/");
       return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
     };
-    posix.normalize = function(path12) {
-      var isAbsolute = posix.isAbsolute(path12), trailingSlash = path12.substr(-1) === "/";
-      path12 = normalizeArray(path12.split("/"), !isAbsolute).join("/");
-      if (!path12 && !isAbsolute) {
-        path12 = ".";
+    posix.normalize = function(path13) {
+      var isAbsolute = posix.isAbsolute(path13), trailingSlash = path13.substr(-1) === "/";
+      path13 = normalizeArray(path13.split("/"), !isAbsolute).join("/");
+      if (!path13 && !isAbsolute) {
+        path13 = ".";
       }
-      if (path12 && trailingSlash) {
-        path12 += "/";
+      if (path13 && trailingSlash) {
+        path13 += "/";
       }
-      return (isAbsolute ? "/" : "") + path12;
+      return (isAbsolute ? "/" : "") + path13;
     };
-    posix.isAbsolute = function(path12) {
-      return path12.charAt(0) === "/";
+    posix.isAbsolute = function(path13) {
+      return path13.charAt(0) === "/";
     };
     posix.join = function() {
-      var path12 = "";
+      var path13 = "";
       for (var i2 = 0; i2 < arguments.length; i2++) {
         var segment = arguments[i2];
         if (!isString(segment)) {
           throw new TypeError("Arguments to path.join must be strings");
         }
         if (segment) {
-          if (!path12) {
-            path12 += segment;
+          if (!path13) {
+            path13 += segment;
           } else {
-            path12 += "/" + segment;
+            path13 += "/" + segment;
           }
         }
       }
-      return posix.normalize(path12);
+      return posix.normalize(path13);
     };
     posix.relative = function(from, to) {
       from = posix.resolve(from).substr(1);
@@ -3400,11 +3692,11 @@ var require_path_posix = __commonJS({
       outputParts = outputParts.concat(toParts.slice(samePartsLength));
       return outputParts.join("/");
     };
-    posix._makeLong = function(path12) {
-      return path12;
+    posix._makeLong = function(path13) {
+      return path13;
     };
-    posix.dirname = function(path12) {
-      var result = posixSplitPath(path12), root = result[0], dir = result[1];
+    posix.dirname = function(path13) {
+      var result = posixSplitPath(path13), root = result[0], dir = result[1];
       if (!root && !dir) {
         return ".";
       }
@@ -3413,15 +3705,15 @@ var require_path_posix = __commonJS({
       }
       return root + dir;
     };
-    posix.basename = function(path12, ext2) {
-      var f3 = posixSplitPath(path12)[2];
+    posix.basename = function(path13, ext2) {
+      var f3 = posixSplitPath(path13)[2];
       if (ext2 && f3.substr(-1 * ext2.length) === ext2) {
         f3 = f3.substr(0, f3.length - ext2.length);
       }
       return f3;
     };
-    posix.extname = function(path12) {
-      return posixSplitPath(path12)[3];
+    posix.extname = function(path13) {
+      return posixSplitPath(path13)[3];
     };
     posix.format = function(pathObject) {
       if (!util.isObject(pathObject)) {
@@ -12083,7 +12375,7 @@ var init_escape2 = __esm({
 });
 
 // ../../node_modules/.pnpm/minimatch@9.0.5/node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path5, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
+var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path6, sep, GLOBSTAR, qmark2, star2, twoStarDot, twoStarNoDot, filter, ext, defaults, braceExpand, makeRe, match, globMagic, regExpEscape2, Minimatch;
 var init_esm2 = __esm({
   "../../node_modules/.pnpm/minimatch@9.0.5/node_modules/minimatch/dist/esm/index.js"() {
     "use strict";
@@ -12153,11 +12445,11 @@ var init_esm2 = __esm({
       return (f3) => f3.length === len && f3 !== "." && f3 !== "..";
     };
     defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    path5 = {
+    path6 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    sep = defaultPlatform === "win32" ? path5.win32.sep : path5.posix.sep;
+    sep = defaultPlatform === "win32" ? path6.win32.sep : path6.posix.sep;
     minimatch.sep = sep;
     GLOBSTAR = Symbol("globstar **");
     minimatch.GLOBSTAR = GLOBSTAR;
@@ -14819,10 +15111,10 @@ var require_nested_property = __commonJS({
         return false;
       }
     }
-    function traverse(object, path12) {
+    function traverse(object, path13) {
       var callback = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : function() {
       };
-      var segments = path12.split(PATH_DELIMITER);
+      var segments = path13.split(PATH_DELIMITER);
       var length = segments.length;
       var _loop = function _loop2(idx2) {
         var currentSegment = segments[idx2];
@@ -15064,11 +15356,11 @@ async function createDirectory(context, dirPath, options = {}) {
   const response = await request(requestOptions, context);
   handleResponseCode(context, response);
 }
-function ensureCollectionPath(path12) {
-  if (!path12.endsWith("/")) {
-    return path12 + "/";
+function ensureCollectionPath(path13) {
+  if (!path13.endsWith("/")) {
+    return path13 + "/";
   }
-  return path12;
+  return path13;
 }
 async function createDirectoryRecursively(context, dirPath, options = {}) {
   const paths = getAllDirectories(normalisePath(dirPath));
@@ -15443,7 +15735,7 @@ var init_xml = __esm({
 });
 
 // ../../node_modules/.pnpm/webdav@5.8.0/node_modules/webdav/dist/node/operations/lock.js
-async function lock(context, path12, options = {}) {
+async function lock(context, path13, options = {}) {
   const { refreshToken, timeout = DEFAULT_TIMEOUT } = options;
   const headers = {
     Accept: "text/plain,application/xml",
@@ -15453,7 +15745,7 @@ async function lock(context, path12, options = {}) {
     headers.If = refreshToken;
   }
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, encodePath(path12)),
+    url: joinURL(context.remoteURL, encodePath(path13)),
     method: "LOCK",
     headers,
     data: generateLockXML(context.contactHref)
@@ -15473,9 +15765,9 @@ async function lock(context, path12, options = {}) {
     serverTimeout
   };
 }
-async function unlock(context, path12, token, options = {}) {
+async function unlock(context, path13, token, options = {}) {
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, encodePath(path12)),
+    url: joinURL(context.remoteURL, encodePath(path13)),
     method: "UNLOCK",
     headers: {
       "Lock-Token": token
@@ -15525,9 +15817,9 @@ var init_quota = __esm({
 
 // ../../node_modules/.pnpm/webdav@5.8.0/node_modules/webdav/dist/node/operations/getQuota.js
 async function getQuota(context, options = {}) {
-  const path12 = options.path || "/";
+  const path13 = options.path || "/";
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, path12),
+    url: joinURL(context.remoteURL, path13),
     method: "PROPFIND",
     headers: {
       Accept: "text/plain,application/xml",
@@ -15867,29 +16159,29 @@ function createClient(remoteURL, options = {}) {
   setupAuth(context, username, password, token, ha1);
   return {
     copyFile: (filename, destination, options2) => copyFile(context, filename, destination, options2),
-    createDirectory: (path12, options2) => createDirectory(context, path12, options2),
+    createDirectory: (path13, options2) => createDirectory(context, path13, options2),
     createReadStream: (filename, options2) => createReadStream2(context, filename, options2),
     createWriteStream: (filename, options2, callback) => createWriteStream(context, filename, options2, callback),
-    customRequest: (path12, requestOptions) => customRequest(context, path12, requestOptions),
+    customRequest: (path13, requestOptions) => customRequest(context, path13, requestOptions),
     deleteFile: (filename, options2) => deleteFile(context, filename, options2),
-    exists: (path12, options2) => exists(context, path12, options2),
-    getDirectoryContents: (path12, options2) => getDirectoryContents(context, path12, options2),
+    exists: (path13, options2) => exists(context, path13, options2),
+    getDirectoryContents: (path13, options2) => getDirectoryContents(context, path13, options2),
     getFileContents: (filename, options2) => getFileContents(context, filename, options2),
     getFileDownloadLink: (filename) => getFileDownloadLink(context, filename),
     getFileUploadLink: (filename) => getFileUploadLink(context, filename),
     getHeaders: () => Object.assign({}, context.headers),
     getQuota: (options2) => getQuota(context, options2),
-    lock: (path12, options2) => lock(context, path12, options2),
+    lock: (path13, options2) => lock(context, path13, options2),
     moveFile: (filename, destinationFilename, options2) => moveFile(context, filename, destinationFilename, options2),
     putFileContents: (filename, data, options2) => putFileContents(context, filename, data, options2),
     partialUpdateFileContents: (filePath, start, end, data, options2) => partialUpdateFileContents(context, filePath, start, end, data, options2),
-    getDAVCompliance: (path12) => getDAVCompliance(context, path12),
-    search: (path12, options2) => getSearch2(context, path12, options2),
+    getDAVCompliance: (path13) => getDAVCompliance(context, path13),
+    search: (path13, options2) => getSearch2(context, path13, options2),
     setHeaders: (headers2) => {
       context.headers = Object.assign({}, headers2);
     },
-    stat: (path12, options2) => getStat(context, path12, options2),
-    unlock: (path12, token2, options2) => unlock(context, path12, token2, options2)
+    stat: (path13, options2) => getStat(context, path13, options2),
+    unlock: (path13, token2, options2) => unlock(context, path13, token2, options2)
   };
 }
 var DEFAULT_CONTACT_HREF;
@@ -16510,8 +16802,8 @@ var init_sync_v2 = __esm({
 // ../core/dist/export.js
 function validateExport() {
   const ccmanDir2 = getCcmanDir();
-  const codexPath = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const claudePath = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const codexPath = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const claudePath = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
   const missingFiles = [];
   if (!fileExists(codexPath)) {
     missingFiles.push(CODEX_CONFIG_FILE);
@@ -16536,7 +16828,7 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const stats = fs8.statSync(sourceDir);
+  const stats = fs9.statSync(sourceDir);
   if (!stats.isDirectory()) {
     return {
       valid: false,
@@ -16544,8 +16836,8 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const codexPath = path9.join(sourceDir, CODEX_CONFIG_FILE);
-  const claudePath = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
+  const codexPath = path10.join(sourceDir, CODEX_CONFIG_FILE);
+  const claudePath = path10.join(sourceDir, CLAUDE_CONFIG_FILE);
   const foundFiles = [];
   if (fileExists(codexPath)) {
     foundFiles.push(CODEX_CONFIG_FILE);
@@ -16573,16 +16865,16 @@ function exportConfig(targetDir) {
   ensureDir(targetDir);
   const ccmanDir2 = getCcmanDir();
   const exportedFiles = [];
-  const codexSrc = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const codexDst = path9.join(targetDir, CODEX_CONFIG_FILE);
+  const codexSrc = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const codexDst = path10.join(targetDir, CODEX_CONFIG_FILE);
   if (fileExists(codexSrc)) {
-    fs8.copyFileSync(codexSrc, codexDst);
+    fs9.copyFileSync(codexSrc, codexDst);
     exportedFiles.push(CODEX_CONFIG_FILE);
   }
-  const claudeSrc = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
-  const claudeDst = path9.join(targetDir, CLAUDE_CONFIG_FILE);
+  const claudeSrc = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const claudeDst = path10.join(targetDir, CLAUDE_CONFIG_FILE);
   if (fileExists(claudeSrc)) {
-    fs8.copyFileSync(claudeSrc, claudeDst);
+    fs9.copyFileSync(claudeSrc, claudeDst);
     exportedFiles.push(CLAUDE_CONFIG_FILE);
   }
   return {
@@ -16602,23 +16894,23 @@ function importConfig(sourceDir) {
   ensureDir(ccmanDir2);
   try {
     if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
-      const codexDst = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
+      const codexDst = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
       if (fileExists(codexDst)) {
         const backupPath = backupConfig(codexDst);
         backupPaths.push(backupPath);
       }
-      const codexSrc = path9.join(sourceDir, CODEX_CONFIG_FILE);
-      fs8.copyFileSync(codexSrc, codexDst);
+      const codexSrc = path10.join(sourceDir, CODEX_CONFIG_FILE);
+      fs9.copyFileSync(codexSrc, codexDst);
       importedFiles.push(CODEX_CONFIG_FILE);
     }
     if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
-      const claudeDst = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+      const claudeDst = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
       if (fileExists(claudeDst)) {
         const backupPath = backupConfig(claudeDst);
         backupPaths.push(backupPath);
       }
-      const claudeSrc = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
-      fs8.copyFileSync(claudeSrc, claudeDst);
+      const claudeSrc = path10.join(sourceDir, CLAUDE_CONFIG_FILE);
+      fs9.copyFileSync(claudeSrc, claudeDst);
       importedFiles.push(CLAUDE_CONFIG_FILE);
     }
     return {
@@ -16630,18 +16922,18 @@ function importConfig(sourceDir) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
       if (fileExists(backupPath)) {
-        fs8.copyFileSync(backupPath, originalPath);
+        fs9.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
   }
 }
-var fs8, path9, CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
+var fs9, path10, CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
 var init_export = __esm({
   "../core/dist/export.js"() {
     "use strict";
-    fs8 = __toESM(require("fs"), 1);
-    path9 = __toESM(require("path"), 1);
+    fs9 = __toESM(require("fs"), 1);
+    path10 = __toESM(require("path"), 1);
     init_paths();
     init_file();
     init_merge2();
@@ -16650,6 +16942,155 @@ var init_export = __esm({
   }
 });
 
+// ../core/dist/claude-clean.js
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1024 * 1024)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function getFileSize(filePath) {
+  try {
+    const stats = fs10.statSync(filePath);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+function backupFile(filePath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").split(".")[0];
+  const backupPath = `${filePath}.backup-${timestamp}`;
+  fs10.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function saveJsonAtomic(filePath, data) {
+  const tempPath = `${filePath}.tmp`;
+  const content = JSON.stringify(data, null, 2);
+  fs10.writeFileSync(tempPath, content, { mode: 384 });
+  fs10.renameSync(tempPath, filePath);
+}
+function analyzeClaudeJson() {
+  const filePath = getClaudeJsonPath();
+  if (!fs10.existsSync(filePath)) {
+    throw new Error("~/.claude.json \u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+  const fileSize = getFileSize(filePath);
+  const content = fs10.readFileSync(filePath, "utf-8");
+  const config = JSON.parse(content);
+  const projects = config.projects || {};
+  const projectHistory = [];
+  let totalHistoryCount = 0;
+  for (const [projectPath, projectData] of Object.entries(projects)) {
+    const historyCount = projectData.history?.length || 0;
+    totalHistoryCount += historyCount;
+    projectHistory.push({
+      path: projectPath,
+      count: historyCount
+    });
+  }
+  projectHistory.sort((a, b) => b.count - a.count);
+  const cacheSize = config.cachedChangelog?.length || 0;
+  const historySize = fileSize - cacheSize - 2e4;
+  const avgHistorySize = totalHistoryCount > 0 ? historySize / totalHistoryCount : 0;
+  const estimatedSavings = {
+    conservative: Math.floor(avgHistorySize * Math.max(0, totalHistoryCount - projectHistory.length * 10)) + cacheSize,
+    moderate: Math.floor(avgHistorySize * Math.max(0, totalHistoryCount - projectHistory.length * 5)) + cacheSize,
+    aggressive: Math.floor(historySize) + cacheSize
+  };
+  return {
+    fileSize,
+    fileSizeFormatted: formatBytes(fileSize),
+    projectCount: projectHistory.length,
+    totalHistoryCount,
+    projectHistory,
+    cacheSize,
+    estimatedSavings
+  };
+}
+function cleanClaudeJson(options = {}) {
+  const filePath = getClaudeJsonPath();
+  if (!fs10.existsSync(filePath)) {
+    throw new Error("~/.claude.json \u6587\u4EF6\u4E0D\u5B58\u5728");
+  }
+  const backupPath = backupFile(filePath);
+  const sizeBefore = getFileSize(filePath);
+  const content = fs10.readFileSync(filePath, "utf-8");
+  const config = JSON.parse(content);
+  const cleanedItems = applyCleanOptions(config, options);
+  saveJsonAtomic(filePath, config);
+  const sizeAfter = getFileSize(filePath);
+  return {
+    sizeBefore,
+    sizeAfter,
+    saved: sizeBefore - sizeAfter,
+    cleanedItems,
+    backupPath
+  };
+}
+function applyCleanOptions(config, options) {
+  let projectHistoryCount = 0;
+  if (options.cleanProjectHistory && config.projects) {
+    const keepCount = options.keepRecentCount ?? 10;
+    const targetProjects = options.projectPaths || [];
+    for (const [projectPath, projectData] of Object.entries(config.projects)) {
+      if (targetProjects.length > 0 && !targetProjects.includes(projectPath)) {
+        continue;
+      }
+      if (projectData.history && Array.isArray(projectData.history)) {
+        const originalCount = projectData.history.length;
+        projectData.history = projectData.history.slice(-keepCount);
+        projectHistoryCount += originalCount - projectData.history.length;
+      }
+    }
+  }
+  if (options.cleanCache) {
+    delete config.cachedChangelog;
+    config.changelogLastFetched = 0;
+  }
+  if (options.cleanStats) {
+    config.numStartups = 0;
+    config.promptQueueUseCount = 0;
+    config.tipsHistory = {};
+  }
+  return {
+    projectHistory: projectHistoryCount,
+    cache: options.cleanCache || false,
+    stats: options.cleanStats || false
+  };
+}
+var fs10, CleanPresets;
+var init_claude_clean = __esm({
+  "../core/dist/claude-clean.js"() {
+    "use strict";
+    fs10 = __toESM(require("fs"), 1);
+    init_paths();
+    CleanPresets = {
+      /** 保守清理：保留最近10条记录，清理缓存 */
+      conservative: () => ({
+        cleanProjectHistory: true,
+        keepRecentCount: 10,
+        cleanCache: true,
+        cleanStats: false
+      }),
+      /** 中等清理：保留最近5条记录，清理缓存和统计 */
+      moderate: () => ({
+        cleanProjectHistory: true,
+        keepRecentCount: 5,
+        cleanCache: true,
+        cleanStats: true
+      }),
+      /** 激进清理：清空历史记录，清理缓存和统计 */
+      aggressive: () => ({
+        cleanProjectHistory: true,
+        keepRecentCount: 0,
+        cleanCache: true,
+        cleanStats: true
+      })
+    };
+  }
+});
+
 // ../core/dist/index.js
 var VERSION;
 var init_dist4 = __esm({
@@ -16659,6 +17100,8 @@ var init_dist4 = __esm({
     init_tool_manager();
     init_codex2();
     init_claude2();
+    init_mcp2();
+    init_mcp();
     init_migrate();
     init_paths();
     init_config();
@@ -16667,6 +17110,7 @@ var init_dist4 = __esm({
     init_crypto2();
     init_merge_advanced();
     init_export();
+    init_claude_clean();
     VERSION = package_default.version;
   }
 });
@@ -17119,8 +17563,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(import_chalk7.default.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path12) => {
-          console.log(import_chalk7.default.gray(`  ${path12}`));
+        backupPaths.forEach((path13) => {
+          console.log(import_chalk7.default.gray(`  ${path13}`));
         });
         console.log();
       }
@@ -17182,8 +17626,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(import_chalk8.default.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path12) => {
-          console.log(import_chalk8.default.gray(`  ${path12}`));
+        result.backupPaths.forEach((path13) => {
+          console.log(import_chalk8.default.gray(`  ${path13}`));
         });
         console.log();
       }
@@ -17380,7 +17824,7 @@ var init_sync = __esm({
 
 // src/index.ts
 var import_commander3 = require("commander");
-var import_chalk28 = __toESM(require("chalk"));
+var import_chalk33 = __toESM(require("chalk"));
 
 // src/utils/logo.ts
 var import_chalk = __toESM(require("chalk"));
@@ -18810,6 +19254,210 @@ function cloneCommand2(program2) {
   });
 }
 
+// src/commands/clean.ts
+var import_chalk26 = __toESM(require("chalk"));
+var import_inquirer18 = __toESM(require("inquirer"));
+init_dist4();
+function formatBytes2(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function displayAnalysis() {
+  try {
+    console.log(import_chalk26.default.bold("\n\u{1F4CA} \u5206\u6790 ~/.claude.json\n"));
+    const analysis = analyzeClaudeJson();
+    console.log(import_chalk26.default.cyan("\u6587\u4EF6\u5927\u5C0F:"), import_chalk26.default.bold(analysis.fileSizeFormatted));
+    console.log();
+    console.log(import_chalk26.default.cyan("\u9879\u76EE\u7EDF\u8BA1:"));
+    console.log(`  \u9879\u76EE\u603B\u6570: ${import_chalk26.default.bold(analysis.projectCount)}`);
+    console.log(`  \u5386\u53F2\u8BB0\u5F55\u603B\u6570: ${import_chalk26.default.bold(analysis.totalHistoryCount)} \u6761`);
+    console.log();
+    console.log(import_chalk26.default.cyan("\u5386\u53F2\u8BB0\u5F55\u6700\u591A\u7684\u9879\u76EE:"));
+    const top5 = analysis.projectHistory.slice(0, 5);
+    for (const project of top5) {
+      const displayPath = project.path.length > 50 ? "..." + project.path.slice(-47) : project.path;
+      console.log(`  ${import_chalk26.default.bold(project.count.toString().padStart(3))} \u6761  ${displayPath}`);
+    }
+    console.log();
+    console.log(import_chalk26.default.cyan("\u9884\u8BA1\u53EF\u8282\u7701\u7A7A\u95F4:"));
+    console.log(`  ${import_chalk26.default.green("\u4FDD\u5B88\u6E05\u7406")} (\u4FDD\u755910\u6761): ${import_chalk26.default.bold(formatBytes2(analysis.estimatedSavings.conservative))}`);
+    console.log(`  ${import_chalk26.default.yellow("\u4E2D\u7B49\u6E05\u7406")} (\u4FDD\u75595\u6761):  ${import_chalk26.default.bold(formatBytes2(analysis.estimatedSavings.moderate))}`);
+    console.log(`  ${import_chalk26.default.red("\u6FC0\u8FDB\u6E05\u7406")} (\u6E05\u7A7A\u5386\u53F2):  ${import_chalk26.default.bold(formatBytes2(analysis.estimatedSavings.aggressive))}`);
+    console.log();
+    console.log(import_chalk26.default.blue(`\u{1F4A1} \u6267\u884C\u6E05\u7406: ccman cc clean
+`));
+  } catch (error) {
+    console.error(import_chalk26.default.red(`
+\u274C ${error.message}
+`));
+    process.exit(1);
+  }
+}
+function cleanAnalyzeCommand(program2) {
+  program2.command("clean:analyze").description("\u5206\u6790 ~/.claude.json \u6587\u4EF6\u5927\u5C0F\u548C\u5360\u7528").action(() => {
+    displayAnalysis();
+  });
+}
+function cleanCommand(program2) {
+  program2.command("clean").description("\u6E05\u7406 ~/.claude.json \u6587\u4EF6\uFF08\u5386\u53F2\u8BB0\u5F55\u3001\u7F13\u5B58\u7B49\uFF09").option("--preset <type>", "\u4F7F\u7528\u9884\u8BBE\u65B9\u6848 (conservative|moderate|aggressive)").option("--keep <count>", "\u4FDD\u7559\u6700\u8FD1N\u6761\u5386\u53F2\u8BB0\u5F55").option("--cache", "\u6E05\u7406\u7F13\u5B58\u6570\u636E").option("--stats", "\u91CD\u7F6E\u4F7F\u7528\u7EDF\u8BA1").option("--projects <paths>", "\u53EA\u6E05\u7406\u6307\u5B9A\u9879\u76EE\uFF08\u9017\u53F7\u5206\u9694\uFF09").action(async (options) => {
+    try {
+      console.log(import_chalk26.default.bold("\n\u{1F9F9} \u6E05\u7406 ~/.claude.json\n"));
+      const analysis = analyzeClaudeJson();
+      console.log(`\u5F53\u524D\u6587\u4EF6\u5927\u5C0F: ${import_chalk26.default.bold(analysis.fileSizeFormatted)}`);
+      console.log(`\u9879\u76EE\u6570: ${analysis.projectCount}, \u5386\u53F2\u8BB0\u5F55: ${analysis.totalHistoryCount} \u6761`);
+      console.log();
+      let cleanOptions;
+      if (options.preset || options.keep || options.cache || options.stats || options.projects) {
+        cleanOptions = buildOptionsFromArgs(options);
+      } else {
+        cleanOptions = await promptForOptions(analysis);
+      }
+      const { confirmed } = await import_inquirer18.default.prompt([
+        {
+          type: "confirm",
+          name: "confirmed",
+          message: "\u786E\u8BA4\u6267\u884C\u6E05\u7406\uFF1F\uFF08\u4F1A\u81EA\u52A8\u5907\u4EFD\u539F\u6587\u4EF6\uFF09",
+          default: true
+        }
+      ]);
+      if (!confirmed) {
+        console.log(import_chalk26.default.yellow("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        return;
+      }
+      console.log(import_chalk26.default.cyan("\n\u6B63\u5728\u6E05\u7406...\n"));
+      const result = cleanClaudeJson(cleanOptions);
+      console.log(import_chalk26.default.green("\u2705 \u6E05\u7406\u5B8C\u6210\n"));
+      console.log(`\u6E05\u7406\u524D: ${import_chalk26.default.bold(formatBytes2(result.sizeBefore))}`);
+      console.log(`\u6E05\u7406\u540E: ${import_chalk26.default.bold(formatBytes2(result.sizeAfter))}`);
+      console.log(`\u8282\u7701\u7A7A\u95F4: ${import_chalk26.default.green.bold(formatBytes2(result.saved))} (${(result.saved / result.sizeBefore * 100).toFixed(1)}%)`);
+      console.log();
+      if (result.cleanedItems.projectHistory > 0) {
+        console.log(`\u6E05\u7406\u5386\u53F2\u8BB0\u5F55: ${import_chalk26.default.bold(result.cleanedItems.projectHistory)} \u6761`);
+      }
+      if (result.cleanedItems.cache) {
+        console.log(`\u6E05\u7406\u7F13\u5B58: ${import_chalk26.default.green("\u2713")}`);
+      }
+      if (result.cleanedItems.stats) {
+        console.log(`\u91CD\u7F6E\u7EDF\u8BA1: ${import_chalk26.default.green("\u2713")}`);
+      }
+      console.log();
+      console.log(`\u5907\u4EFD\u6587\u4EF6: ${import_chalk26.default.cyan(result.backupPath)}`);
+      console.log();
+    } catch (error) {
+      console.error(import_chalk26.default.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+function buildOptionsFromArgs(args) {
+  if (args.preset) {
+    const preset = args.preset.toLowerCase();
+    if (preset === "conservative") {
+      return CleanPresets.conservative();
+    } else if (preset === "moderate") {
+      return CleanPresets.moderate();
+    } else if (preset === "aggressive") {
+      return CleanPresets.aggressive();
+    } else {
+      throw new Error(`\u672A\u77E5\u7684\u9884\u8BBE\u65B9\u6848: ${preset}\u3002\u53EF\u7528: conservative, moderate, aggressive`);
+    }
+  }
+  const options = {};
+  if (args.keep !== void 0) {
+    options.cleanProjectHistory = true;
+    options.keepRecentCount = parseInt(args.keep, 10);
+    if (isNaN(options.keepRecentCount)) {
+      throw new Error("--keep \u53C2\u6570\u5FC5\u987B\u662F\u6570\u5B57");
+    }
+  }
+  if (args.cache) {
+    options.cleanCache = true;
+  }
+  if (args.stats) {
+    options.cleanStats = true;
+  }
+  if (args.projects) {
+    options.projectPaths = args.projects.split(",").map((p) => p.trim());
+  }
+  if (!options.cleanProjectHistory && !options.cleanCache && !options.cleanStats) {
+    console.log(import_chalk26.default.yellow("\u672A\u6307\u5B9A\u6E05\u7406\u9009\u9879\uFF0C\u4F7F\u7528\u4FDD\u5B88\u9884\u8BBE\n"));
+    return CleanPresets.conservative();
+  }
+  return options;
+}
+async function promptForOptions(analysis) {
+  const answers = await import_inquirer18.default.prompt([
+    {
+      type: "list",
+      name: "preset",
+      message: "\u9009\u62E9\u6E05\u7406\u65B9\u6848:",
+      choices: [
+        {
+          name: `${import_chalk26.default.green("\u4FDD\u5B88\u6E05\u7406")} - \u4FDD\u7559\u6700\u8FD110\u6761\u8BB0\u5F55\uFF0C\u6E05\u7406\u7F13\u5B58 (\u8282\u7701\u7EA6 ${formatBytes2(analysis.estimatedSavings.conservative)})`,
+          value: "conservative"
+        },
+        {
+          name: `${import_chalk26.default.yellow("\u4E2D\u7B49\u6E05\u7406")} - \u4FDD\u7559\u6700\u8FD15\u6761\u8BB0\u5F55\uFF0C\u6E05\u7406\u7F13\u5B58\u548C\u7EDF\u8BA1 (\u8282\u7701\u7EA6 ${formatBytes2(analysis.estimatedSavings.moderate)})`,
+          value: "moderate"
+        },
+        {
+          name: `${import_chalk26.default.red("\u6FC0\u8FDB\u6E05\u7406")} - \u6E05\u7A7A\u5386\u53F2\u8BB0\u5F55\uFF0C\u6E05\u7406\u7F13\u5B58\u548C\u7EDF\u8BA1 (\u8282\u7701\u7EA6 ${formatBytes2(analysis.estimatedSavings.aggressive)})`,
+          value: "aggressive"
+        },
+        {
+          name: `${import_chalk26.default.cyan("\u81EA\u5B9A\u4E49")} - \u81EA\u5B9A\u4E49\u6E05\u7406\u9009\u9879`,
+          value: "custom"
+        }
+      ]
+    }
+  ]);
+  if (answers.preset !== "custom") {
+    if (answers.preset === "conservative") {
+      return CleanPresets.conservative();
+    } else if (answers.preset === "moderate") {
+      return CleanPresets.moderate();
+    } else {
+      return CleanPresets.aggressive();
+    }
+  }
+  const customAnswers = await import_inquirer18.default.prompt([
+    {
+      type: "confirm",
+      name: "cleanHistory",
+      message: "\u6E05\u7406\u9879\u76EE\u5386\u53F2\u8BB0\u5F55\uFF1F",
+      default: true
+    },
+    {
+      type: "number",
+      name: "keepCount",
+      message: "\u6BCF\u4E2A\u9879\u76EE\u4FDD\u7559\u6700\u8FD1\u591A\u5C11\u6761\u8BB0\u5F55\uFF1F",
+      default: 10,
+      when: (answers2) => answers2.cleanHistory
+    },
+    {
+      type: "confirm",
+      name: "cleanCache",
+      message: "\u6E05\u7406\u7F13\u5B58\u6570\u636E\uFF1F",
+      default: true
+    },
+    {
+      type: "confirm",
+      name: "cleanStats",
+      message: "\u91CD\u7F6E\u4F7F\u7528\u7EDF\u8BA1\uFF1F",
+      default: false
+    }
+  ]);
+  return {
+    cleanProjectHistory: customAnswers.cleanHistory,
+    keepRecentCount: customAnswers.keepCount || 0,
+    cleanCache: customAnswers.cleanCache,
+    cleanStats: customAnswers.cleanStats
+  };
+}
+
 // src/commands/claude/index.ts
 function createClaudeCommands(program2) {
   addCommand2(program2);
@@ -18819,46 +19467,449 @@ function createClaudeCommands(program2) {
   removeCommand2(program2);
   editCommand2(program2);
   cloneCommand2(program2);
+  cleanAnalyzeCommand(program2);
+  cleanCommand(program2);
+}
+
+// src/commands/mcp/add.ts
+var import_chalk27 = __toESM(require("chalk"));
+var import_inquirer19 = __toESM(require("inquirer"));
+init_dist4();
+function addCommand3(program2) {
+  program2.command("add").description("\u6DFB\u52A0\u65B0\u7684 MCP \u670D\u52A1\u5668(\u4EA4\u4E92\u5F0F)").action(async () => {
+    try {
+      const manager = createMCPManager();
+      console.log(import_chalk27.default.bold("\n\u{1F4DD} \u6DFB\u52A0 MCP \u670D\u52A1\u5668\n"));
+      const { usePreset } = await import_inquirer19.default.prompt([
+        {
+          type: "list",
+          name: "usePreset",
+          message: "\u9009\u62E9\u914D\u7F6E\u6765\u6E90:",
+          choices: [
+            { name: "\u{1F4E6} \u4F7F\u7528\u9884\u7F6E MCP \u670D\u52A1\u5668", value: true },
+            { name: "\u270F\uFE0F  \u81EA\u5B9A\u4E49\u914D\u7F6E", value: false }
+          ]
+        }
+      ]);
+      let name;
+      let command;
+      let args;
+      let env;
+      if (usePreset) {
+        const { presetName } = await import_inquirer19.default.prompt([
+          {
+            type: "list",
+            name: "presetName",
+            message: "\u9009\u62E9\u9884\u7F6E MCP \u670D\u52A1\u5668:",
+            choices: MCP_PRESETS_DETAIL.map((p) => ({
+              name: `${p.name} - ${p.description}`,
+              value: p.name
+            }))
+          }
+        ]);
+        const preset = MCP_PRESETS_DETAIL.find((p) => p.name === presetName);
+        console.log(import_chalk27.default.blue(`
+\u4F7F\u7528\u9884\u8BBE: ${preset.name} - ${preset.description}
+`));
+        if (preset.argsPlaceholder) {
+          console.log(import_chalk27.default.yellow(`\u26A0\uFE0F  ${preset.argsPlaceholder}
+`));
+        }
+        if (preset.envRequired && preset.envRequired.length > 0) {
+          console.log(import_chalk27.default.yellow(`\u26A0\uFE0F  \u9700\u8981\u914D\u7F6E\u73AF\u5883\u53D8\u91CF: ${preset.envRequired.join(", ")}
+`));
+        }
+        const input = await import_inquirer19.default.prompt([
+          {
+            type: "input",
+            name: "name",
+            message: "MCP \u670D\u52A1\u5668\u540D\u79F0:",
+            default: preset.name,
+            validate: (value) => {
+              if (!value) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "command",
+            message: "\u542F\u52A8\u547D\u4EE4:",
+            default: preset.command,
+            validate: (value) => {
+              if (!value) return "\u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "args",
+            message: "\u547D\u4EE4\u53C2\u6570 (\u7A7A\u683C\u5206\u9694):",
+            default: preset.args.join(" "),
+            validate: (value) => {
+              if (!value) return "\u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "env",
+            message: '\u73AF\u5883\u53D8\u91CF (JSON \u683C\u5F0F, \u5982 {"API_KEY": "xxx"}, \u53EF\u7559\u7A7A):',
+            default: ""
+          }
+        ]);
+        name = input.name;
+        command = input.command;
+        args = input.args.split(" ").filter((arg) => arg.length > 0);
+        env = input.env ? JSON.parse(input.env) : void 0;
+      } else {
+        const answers = await import_inquirer19.default.prompt([
+          {
+            type: "input",
+            name: "name",
+            message: "MCP \u670D\u52A1\u5668\u540D\u79F0:",
+            validate: (value) => {
+              if (!value) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "command",
+            message: "\u542F\u52A8\u547D\u4EE4 (\u5982 npx, node, python):",
+            default: "npx",
+            validate: (value) => {
+              if (!value) return "\u547D\u4EE4\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "args",
+            message: "\u547D\u4EE4\u53C2\u6570 (\u7A7A\u683C\u5206\u9694):",
+            validate: (value) => {
+              if (!value) return "\u53C2\u6570\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "env",
+            message: '\u73AF\u5883\u53D8\u91CF (JSON \u683C\u5F0F, \u5982 {"API_KEY": "xxx"}, \u53EF\u7559\u7A7A):',
+            default: ""
+          }
+        ]);
+        name = answers.name;
+        command = answers.command;
+        args = answers.args.split(" ").filter((arg) => arg.length > 0);
+        env = answers.env ? JSON.parse(answers.env) : void 0;
+      }
+      const provider = manager.add({
+        name,
+        baseUrl: command,
+        apiKey: args.join(" "),
+        model: env ? JSON.stringify(env) : void 0
+      });
+      console.log();
+      console.log(import_chalk27.default.green("\u2705 MCP \u670D\u52A1\u5668\u6DFB\u52A0\u6210\u529F"));
+      console.log();
+      console.log(`  ${import_chalk27.default.bold(provider.name)} ${import_chalk27.default.blue("[MCP]")}`);
+      console.log(`  ${import_chalk27.default.gray(`${command} ${args.join(" ")}`)}`);
+      if (env) {
+        console.log(import_chalk27.default.gray(`  \u73AF\u5883\u53D8\u91CF: ${Object.keys(env).join(", ")}`));
+      }
+      console.log();
+      console.log(import_chalk27.default.green("\u2705 \u914D\u7F6E\u5DF2\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
+      console.log();
+      console.log(import_chalk27.default.gray("\u914D\u7F6E\u6587\u4EF6:"));
+      console.log(import_chalk27.default.gray(`  - ${getClaudeConfigPath()}`));
+      console.log();
+    } catch (error) {
+      console.error(import_chalk27.default.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/mcp/list.ts
+var import_chalk28 = __toESM(require("chalk"));
+init_dist4();
+function listCommand3(program2) {
+  program2.command("list").alias("ls").description("\u5217\u51FA\u6240\u6709 MCP \u670D\u52A1\u5668").action(async () => {
+    try {
+      const manager = createMCPManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(import_chalk28.default.yellow("\n\u26A0\uFE0F  \u6682\u65E0 MCP \u670D\u52A1\u5668\n"));
+        console.log(import_chalk28.default.blue("\u{1F4A1} \u6DFB\u52A0 MCP \u670D\u52A1\u5668:") + import_chalk28.default.white(" ccman mcp add\n"));
+        return;
+      }
+      console.log(import_chalk28.default.bold(`
+\u{1F4CB} MCP \u670D\u52A1\u5668 (${providers.length} \u4E2A)
+`));
+      providers.forEach((provider) => {
+        const isActive = false;
+        const indicator = isActive ? import_chalk28.default.green("\u25CF") : import_chalk28.default.gray("\u25CB");
+        const nameDisplay = import_chalk28.default.bold(provider.name);
+        const commandDisplay = import_chalk28.default.gray(`${provider.baseUrl} ${provider.apiKey}`);
+        console.log(`  ${indicator} ${nameDisplay}`);
+        console.log(`    ${commandDisplay}`);
+        if (provider.model) {
+          try {
+            const env = JSON.parse(provider.model);
+            const envKeys = Object.keys(env);
+            if (envKeys.length > 0) {
+              console.log(import_chalk28.default.gray(`    \u73AF\u5883\u53D8\u91CF: ${envKeys.join(", ")}`));
+            }
+          } catch {
+          }
+        }
+        console.log();
+      });
+      console.log(import_chalk28.default.gray("\u63D0\u793A: \u6240\u6709\u914D\u7F6E\u7684 MCP \u670D\u52A1\u5668\u4F1A\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
+      console.log();
+    } catch (error) {
+      console.error(import_chalk28.default.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/mcp/remove.ts
+var import_chalk29 = __toESM(require("chalk"));
+var import_inquirer20 = __toESM(require("inquirer"));
+init_dist4();
+function removeCommand3(program2) {
+  program2.command("remove [name]").alias("rm").description("\u5220\u9664 MCP \u670D\u52A1\u5668").action(async (name) => {
+    try {
+      const manager = createMCPManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(import_chalk29.default.yellow("\n\u26A0\uFE0F  \u6682\u65E0 MCP \u670D\u52A1\u5668\n"));
+        return;
+      }
+      let targetId;
+      let targetName;
+      if (name) {
+        const provider = manager.findByName(name);
+        if (!provider) {
+          throw new ProviderNotFoundError(name);
+        }
+        targetId = provider.id;
+        targetName = provider.name;
+      } else {
+        const { selectedId } = await import_inquirer20.default.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u5220\u9664\u7684 MCP \u670D\u52A1\u5668:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl} ${p.apiKey}`,
+              value: p.id
+            }))
+          }
+        ]);
+        const provider = manager.get(selectedId);
+        targetId = selectedId;
+        targetName = provider.name;
+      }
+      const { confirmed } = await import_inquirer20.default.prompt([
+        {
+          type: "confirm",
+          name: "confirmed",
+          message: `\u786E\u5B9A\u5220\u9664 "${targetName}"?`,
+          default: false
+        }
+      ]);
+      if (!confirmed) {
+        console.log(import_chalk29.default.gray("\n\u5DF2\u53D6\u6D88\n"));
+        return;
+      }
+      manager.remove(targetId);
+      console.log();
+      console.log(import_chalk29.default.green(`\u2705 \u5DF2\u5220\u9664: ${targetName}`));
+      console.log();
+      console.log(import_chalk29.default.green("\u2705 \u914D\u7F6E\u5DF2\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
+      console.log();
+      console.log(import_chalk29.default.gray("\u914D\u7F6E\u6587\u4EF6:"));
+      console.log(import_chalk29.default.gray(`  - ${getClaudeConfigPath()}`));
+      console.log();
+    } catch (error) {
+      if (error instanceof ProviderNotFoundError) {
+        console.error(import_chalk29.default.red(`
+\u274C MCP \u670D\u52A1\u5668\u4E0D\u5B58\u5728
+`));
+        console.log(import_chalk29.default.blue("\u{1F4A1} \u67E5\u770B\u6240\u6709 MCP \u670D\u52A1\u5668:") + import_chalk29.default.white(" ccman mcp list\n"));
+      } else {
+        console.error(import_chalk29.default.red(`
+\u274C ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/mcp/edit.ts
+var import_chalk30 = __toESM(require("chalk"));
+var import_inquirer21 = __toESM(require("inquirer"));
+init_dist4();
+function editCommand3(program2) {
+  program2.command("edit [name]").description("\u7F16\u8F91 MCP \u670D\u52A1\u5668").action(async (name) => {
+    try {
+      const manager = createMCPManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(import_chalk30.default.yellow("\n\u26A0\uFE0F  \u6682\u65E0 MCP \u670D\u52A1\u5668\n"));
+        return;
+      }
+      let targetId;
+      if (name) {
+        const provider2 = manager.findByName(name);
+        if (!provider2) {
+          throw new ProviderNotFoundError(name);
+        }
+        targetId = provider2.id;
+      } else {
+        const { selectedId } = await import_inquirer21.default.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u7F16\u8F91\u7684 MCP \u670D\u52A1\u5668:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl} ${p.apiKey}`,
+              value: p.id
+            }))
+          }
+        ]);
+        targetId = selectedId;
+      }
+      const provider = manager.get(targetId);
+      const currentCommand3 = provider.baseUrl;
+      const currentArgs = provider.apiKey;
+      const currentEnv = provider.model;
+      console.log(import_chalk30.default.bold("\n\u270F\uFE0F  \u7F16\u8F91 MCP \u670D\u52A1\u5668\n"));
+      console.log(import_chalk30.default.gray("\u63D0\u793A: \u7559\u7A7A\u5219\u4FDD\u6301\u539F\u503C\n"));
+      const answers = await import_inquirer21.default.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "MCP \u670D\u52A1\u5668\u540D\u79F0:",
+          default: provider.name
+        },
+        {
+          type: "input",
+          name: "command",
+          message: "\u542F\u52A8\u547D\u4EE4:",
+          default: currentCommand3
+        },
+        {
+          type: "input",
+          name: "args",
+          message: "\u547D\u4EE4\u53C2\u6570 (\u7A7A\u683C\u5206\u9694, \u7559\u7A7A\u4FDD\u6301\u4E0D\u53D8):",
+          default: currentArgs
+        },
+        {
+          type: "input",
+          name: "env",
+          message: "\u73AF\u5883\u53D8\u91CF (JSON \u683C\u5F0F, \u7559\u7A7A\u4FDD\u6301\u4E0D\u53D8):",
+          default: currentEnv || ""
+        }
+      ]);
+      const updates = {};
+      if (answers.name && answers.name !== provider.name) {
+        updates.name = answers.name;
+      }
+      if (answers.command && answers.command !== currentCommand3) {
+        updates.baseUrl = answers.command;
+      }
+      if (answers.args && answers.args !== currentArgs) {
+        updates.apiKey = answers.args;
+      }
+      if (answers.env !== currentEnv) {
+        updates.model = answers.env || void 0;
+      }
+      if (Object.keys(updates).length === 0) {
+        console.log(import_chalk30.default.gray("\n\u672A\u505A\u4EFB\u4F55\u4FEE\u6539\n"));
+        return;
+      }
+      const updated = manager.edit(targetId, updates);
+      console.log();
+      console.log(import_chalk30.default.green("\u2705 \u7F16\u8F91\u6210\u529F"));
+      console.log();
+      console.log(`  ${import_chalk30.default.bold(updated.name)} ${import_chalk30.default.blue("[MCP]")}`);
+      console.log(`  ${import_chalk30.default.gray(`\u547D\u4EE4: ${updated.baseUrl} ${updated.apiKey}`)}`);
+      if (updated.model) {
+        try {
+          const env = JSON.parse(updated.model);
+          console.log(import_chalk30.default.gray(`  \u73AF\u5883\u53D8\u91CF: ${Object.keys(env).join(", ")}`));
+        } catch {
+        }
+      }
+      console.log();
+      console.log(import_chalk30.default.green("\u2705 \u914D\u7F6E\u5DF2\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
+      console.log();
+      console.log(import_chalk30.default.gray("\u914D\u7F6E\u6587\u4EF6:"));
+      console.log(import_chalk30.default.gray(`  - ${getClaudeConfigPath()}`));
+      console.log();
+    } catch (error) {
+      console.error(import_chalk30.default.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/mcp/index.ts
+function createMCPCommands(program2) {
+  addCommand3(program2);
+  listCommand3(program2);
+  removeCommand3(program2);
+  editCommand3(program2);
 }
 
 // src/index.ts
 init_sync();
 
 // src/commands/export.ts
-var import_chalk26 = __toESM(require("chalk"));
+var import_chalk31 = __toESM(require("chalk"));
 var import_path19 = __toESM(require("path"));
 init_dist4();
 function exportCommand(program2) {
   program2.command("export <\u76EE\u6807\u76EE\u5F55>").description("\u5BFC\u51FA\u914D\u7F6E\u5230\u672C\u5730\u76EE\u5F55\uFF08\u5305\u542B API Key\uFF09").action(async (targetDir) => {
     try {
-      console.log(import_chalk26.default.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
+      console.log(import_chalk31.default.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
       const validation = validateExport();
       if (!validation.valid) {
-        console.log(import_chalk26.default.red(`\u274C ${validation.message}
+        console.log(import_chalk31.default.red(`\u274C ${validation.message}
 `));
         process.exit(1);
       }
       const resolvedPath = targetDir.startsWith("~") ? import_path19.default.join(process.env.HOME || "", targetDir.slice(1)) : import_path19.default.resolve(targetDir);
       console.log("\u5BFC\u51FA\u6587\u4EF6:");
-      console.log(`  ${import_chalk26.default.cyan("codex.json")}  - Codex \u914D\u7F6E`);
-      console.log(`  ${import_chalk26.default.cyan("claude.json")} - Claude \u914D\u7F6E`);
+      console.log(`  ${import_chalk31.default.cyan("codex.json")}  - Codex \u914D\u7F6E`);
+      console.log(`  ${import_chalk31.default.cyan("claude.json")} - Claude \u914D\u7F6E`);
       console.log();
-      console.log(`\u76EE\u6807\u76EE\u5F55: ${import_chalk26.default.cyan(resolvedPath)}`);
+      console.log(`\u76EE\u6807\u76EE\u5F55: ${import_chalk31.default.cyan(resolvedPath)}`);
       console.log();
-      console.log(import_chalk26.default.yellow("\u26A0\uFE0F  \u5BFC\u51FA\u6587\u4EF6\u5305\u542B API Key\uFF0C\u8BF7\u59A5\u5584\u4FDD\u7BA1"));
+      console.log(import_chalk31.default.yellow("\u26A0\uFE0F  \u5BFC\u51FA\u6587\u4EF6\u5305\u542B API Key\uFF0C\u8BF7\u59A5\u5584\u4FDD\u7BA1"));
       console.log();
       const result = exportConfig(resolvedPath);
-      console.log(import_chalk26.default.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
+      console.log(import_chalk31.default.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
       console.log();
       console.log("\u5DF2\u5BFC\u51FA\u6587\u4EF6:");
       for (const file of result.exportedFiles) {
-        console.log(`  ${import_chalk26.default.cyan("\u2713")} ${file}`);
+        console.log(`  ${import_chalk31.default.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(import_chalk26.default.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
+      console.log(import_chalk31.default.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
 `));
     } catch (error) {
-      console.error(import_chalk26.default.red(`
+      console.error(import_chalk31.default.red(`
 \u274C ${error.message}
 `));
       process.exit(1);
@@ -18867,32 +19918,32 @@ function exportCommand(program2) {
 }
 
 // src/commands/import.ts
-var import_chalk27 = __toESM(require("chalk"));
-var import_inquirer18 = __toESM(require("inquirer"));
+var import_chalk32 = __toESM(require("chalk"));
+var import_inquirer22 = __toESM(require("inquirer"));
 var import_path20 = __toESM(require("path"));
 init_dist4();
 function importCommand(program2) {
   program2.command("import <\u6E90\u76EE\u5F55>").description("\u4ECE\u672C\u5730\u76EE\u5F55\u5BFC\u5165\u914D\u7F6E\uFF08\u4F1A\u8986\u76D6\u5F53\u524D\u914D\u7F6E\uFF09").action(async (sourceDir) => {
     try {
       const resolvedPath = sourceDir.startsWith("~") ? import_path20.default.join(process.env.HOME || "", sourceDir.slice(1)) : import_path20.default.resolve(sourceDir);
-      console.log(import_chalk27.default.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
+      console.log(import_chalk32.default.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {
-        console.log(import_chalk27.default.red(`\u274C ${validation.message}
+        console.log(import_chalk32.default.red(`\u274C ${validation.message}
 `));
         process.exit(1);
       }
-      console.log(import_chalk27.default.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
-      console.log(`\u6E90\u76EE\u5F55: ${import_chalk27.default.cyan(resolvedPath)}`);
+      console.log(import_chalk32.default.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
+      console.log(`\u6E90\u76EE\u5F55: ${import_chalk32.default.cyan(resolvedPath)}`);
       console.log();
       console.log("\u627E\u5230\u914D\u7F6E\u6587\u4EF6:");
       for (const file of validation.foundFiles) {
-        console.log(`  ${import_chalk27.default.cyan("\u2713")} ${file}`);
+        console.log(`  ${import_chalk32.default.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(import_chalk27.default.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
+      console.log(import_chalk32.default.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
       console.log();
-      const { confirmFirst } = await import_inquirer18.default.prompt([
+      const { confirmFirst } = await import_inquirer22.default.prompt([
         {
           type: "confirm",
           name: "confirmFirst",
@@ -18901,13 +19952,13 @@ function importCommand(program2) {
         }
       ]);
       if (!confirmFirst) {
-        console.log(import_chalk27.default.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        console.log(import_chalk32.default.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
         return;
       }
       console.log();
-      console.log(import_chalk27.default.red.bold("\u26A0\uFE0F  \u6700\u540E\u786E\u8BA4\uFF1A\u6B64\u64CD\u4F5C\u5C06\u8986\u76D6\u6240\u6709\u5F53\u524D\u914D\u7F6E\uFF01"));
+      console.log(import_chalk32.default.red.bold("\u26A0\uFE0F  \u6700\u540E\u786E\u8BA4\uFF1A\u6B64\u64CD\u4F5C\u5C06\u8986\u76D6\u6240\u6709\u5F53\u524D\u914D\u7F6E\uFF01"));
       console.log();
-      const { confirmSecond } = await import_inquirer18.default.prompt([
+      const { confirmSecond } = await import_inquirer22.default.prompt([
         {
           type: "confirm",
           name: "confirmSecond",
@@ -18916,31 +19967,31 @@ function importCommand(program2) {
         }
       ]);
       if (!confirmSecond) {
-        console.log(import_chalk27.default.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        console.log(import_chalk32.default.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
         return;
       }
       console.log();
-      console.log(import_chalk27.default.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
-      console.log(import_chalk27.default.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
+      console.log(import_chalk32.default.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
+      console.log(import_chalk32.default.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
       const result = importConfig(resolvedPath);
       console.log();
-      console.log(import_chalk27.default.green("\u2705 \u5BFC\u5165\u6210\u529F"));
+      console.log(import_chalk32.default.green("\u2705 \u5BFC\u5165\u6210\u529F"));
       console.log();
       if (result.backupPaths.length > 0) {
         console.log("\u5907\u4EFD\u6587\u4EF6:");
         for (const backupPath of result.backupPaths) {
-          console.log(`  ${import_chalk27.default.gray(backupPath)}`);
+          console.log(`  ${import_chalk32.default.gray(backupPath)}`);
         }
         console.log();
       }
       console.log("\u5DF2\u5BFC\u5165\u6587\u4EF6:");
       for (const file of result.importedFiles) {
-        console.log(`  ${import_chalk27.default.cyan("\u2713")} ${file}`);
+        console.log(`  ${import_chalk32.default.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(import_chalk27.default.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
+      console.log(import_chalk32.default.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
     } catch (error) {
-      console.error(import_chalk27.default.red(`
+      console.error(import_chalk32.default.red(`
 \u274C ${error.message}
 `));
       process.exit(1);
@@ -18951,10 +20002,10 @@ function importCommand(program2) {
 // src/index.ts
 init_dist4();
 if (process.env.NODE_ENV === "development") {
-  console.log(import_chalk28.default.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
-  console.log(import_chalk28.default.gray(`  ccman: ${getCcmanDir()}`));
-  console.log(import_chalk28.default.gray(`  codex:  ${getCodexDir()}`));
-  console.log(import_chalk28.default.gray(`  claude: ${getClaudeDir()}`));
+  console.log(import_chalk33.default.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
+  console.log(import_chalk33.default.gray(`  ccman: ${getCcmanDir()}`));
+  console.log(import_chalk33.default.gray(`  codex:  ${getCodexDir()}`));
+  console.log(import_chalk33.default.gray(`  claude: ${getClaudeDir()}`));
   console.log();
 }
 var program = new import_commander3.Command();
@@ -18966,21 +20017,21 @@ program.name("ccman").description("Codex/Claude Code API \u670D\u52A1\u5546\u914
 });
 program.on("command:*", (operands) => {
   const unknownCommand = operands[0];
-  console.error(import_chalk28.default.red(`
+  console.error(import_chalk33.default.red(`
 \u274C \u672A\u77E5\u547D\u4EE4: ${unknownCommand}
 `));
-  const availableCommands = ["cx", "cc", "sync", "export", "import"];
+  const availableCommands = ["cx", "cc", "mcp", "sync", "export", "import"];
   const suggestions = availableCommands.filter(
     (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
   );
   if (suggestions.length > 0) {
-    console.log(import_chalk28.default.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
+    console.log(import_chalk33.default.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
     suggestions.forEach((cmd) => {
-      console.log(import_chalk28.default.cyan(`   ccman ${cmd}`));
+      console.log(import_chalk33.default.cyan(`   ccman ${cmd}`));
     });
     console.log();
   }
-  console.log(import_chalk28.default.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + import_chalk28.default.cyan("ccman --help"));
+  console.log(import_chalk33.default.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + import_chalk33.default.cyan("ccman --help"));
   console.log();
   process.exit(1);
 });
@@ -18996,6 +20047,11 @@ cc.action(async () => {
   printLogo();
   await startClaudeMenu();
 });
+var mcp = program.command("mcp").description("\u7BA1\u7406 MCP \u670D\u52A1\u5668");
+createMCPCommands(mcp);
+mcp.action(() => {
+  mcp.help();
+});
 var sync = program.command("sync").description("WebDAV \u540C\u6B65\u914D\u7F6E");
 createSyncCommands(sync);
 sync.action(async () => {