ccman 3.0.31 → 3.0.33

package/dist/index.js

@@ -9,8 +9,1935 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../core/package.json
+var package_default;
+var init_package = __esm({
+  "../core/package.json"() {
+    package_default = {
+      name: "@ccman/core",
+      version: "3.0.33",
+      type: "module",
+      description: "Core business logic for ccman",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      files: [
+        "dist",
+        "templates"
+      ],
+      scripts: {
+        build: "tsc",
+        test: "vitest run",
+        "test:watch": "vitest",
+        clean: "rm -rf dist"
+      },
+      keywords: [
+        "codex",
+        "claude",
+        "claude-code",
+        "ai",
+        "api",
+        "config",
+        "manager"
+      ],
+      author: "2ue",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/2ue/ccm.git",
+        directory: "packages/core"
+      },
+      homepage: "https://github.com/2ue/ccm#readme",
+      bugs: {
+        url: "https://github.com/2ue/ccm/issues"
+      },
+      dependencies: {
+        "@iarna/toml": "^2.2.5",
+        "proper-lockfile": "^4.1.2",
+        webdav: "^5.8.0"
+      },
+      devDependencies: {
+        vitest: "^1.0.0"
+      },
+      engines: {
+        node: ">=18.0.0"
+      }
+    };
+  }
+});
+
+// ../core/dist/paths.js
+import * as os from "os";
+import * as path from "path";
+function getCcmanDir() {
+  return ccmanDir;
+}
+function getCodexDir() {
+  return codexDir;
+}
+function getClaudeDir() {
+  return claudeDir;
+}
+function getConfigPath() {
+  return path.join(ccmanDir, "config.json");
+}
+function getCodexConfigPath() {
+  return path.join(codexDir, "config.toml");
+}
+function getCodexAuthPath() {
+  return path.join(codexDir, "auth.json");
+}
+function getClaudeConfigPath() {
+  return path.join(claudeDir, "settings.json");
+}
+function getClaudeJsonPath() {
+  return path.join(rootDir, ".claude.json");
+}
+var isDev, isTest, rootDir, ccmanDir, codexDir, claudeDir;
+var init_paths = __esm({
+  "../core/dist/paths.js"() {
+    "use strict";
+    isDev = process.env.NODE_ENV === "development";
+    isTest = process.env.NODE_ENV === "test";
+    if (isTest) {
+      rootDir = path.join(os.tmpdir(), `ccman-test-${process.pid}`);
+    } else if (isDev) {
+      rootDir = path.join(os.tmpdir(), "ccman-dev");
+    } else {
+      rootDir = os.homedir();
+    }
+    ccmanDir = path.join(rootDir, ".ccman");
+    codexDir = path.join(rootDir, ".codex");
+    claudeDir = path.join(rootDir, ".claude");
+  }
+});
+
+// ../core/dist/utils/file.js
+import * as fs from "fs";
+import * as path2 from "path";
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+function readJSON(filePath) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function writeJSON(filePath, data) {
+  const dir = path2.dirname(filePath);
+  ensureDir(dir);
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2), { mode: 384 });
+  fs.renameSync(tmpPath, filePath);
+}
+function fileExists(filePath) {
+  try {
+    fs.accessSync(filePath, fs.constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_file = __esm({
+  "../core/dist/utils/file.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/utils/template.js
+function replaceVariables(template, variables) {
+  const jsonStr = JSON.stringify(template);
+  let result = jsonStr;
+  for (const [key, value] of Object.entries(variables)) {
+    const escapedValue = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+    result = result.replace(new RegExp(`{{${key}}}`, "g"), escapedValue);
+  }
+  return JSON.parse(result);
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue);
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+var init_template = __esm({
+  "../core/dist/utils/template.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/writers/codex.js
+import * as fs2 from "fs";
+import * as path3 from "path";
+import { fileURLToPath } from "url";
+import { parse as parseToml, stringify as stringifyToml } from "@iarna/toml";
+function loadCodexTemplateConfig() {
+  try {
+    const templatePath = path3.resolve(__dirname, "../../templates/codex/config.toml");
+    if (fs2.existsSync(templatePath)) {
+      const content = fs2.readFileSync(templatePath, "utf-8");
+      return parseToml(content);
+    }
+  } catch {
+  }
+  return CODEX_DEFAULT_CONFIG;
+}
+function writeCodexConfig(provider) {
+  ensureDir(getCodexDir());
+  const configPath = getCodexConfigPath();
+  let userConfig = {};
+  if (fileExists(configPath)) {
+    const content = fs2.readFileSync(configPath, "utf-8");
+    userConfig = parseToml(content);
+  }
+  const templateConfig = loadCodexTemplateConfig();
+  const mergedConfig = deepMerge(templateConfig, userConfig);
+  mergedConfig.model_provider = provider.name;
+  mergedConfig.model = provider.model || mergedConfig.model || "gpt-5-codex";
+  mergedConfig.model_providers = mergedConfig.model_providers || {};
+  mergedConfig.model_providers[provider.name] = {
+    name: provider.name,
+    base_url: provider.baseUrl,
+    wire_api: "responses",
+    requires_openai_auth: true
+  };
+  fs2.writeFileSync(configPath, stringifyToml(mergedConfig), { mode: 384 });
+  const authPath = getCodexAuthPath();
+  let auth;
+  if (fileExists(authPath)) {
+    const content = fs2.readFileSync(authPath, "utf-8");
+    auth = JSON.parse(content);
+  } else {
+    auth = { OPENAI_API_KEY: "" };
+  }
+  auth.OPENAI_API_KEY = provider.apiKey;
+  fs2.writeFileSync(authPath, JSON.stringify(auth, null, 2), { mode: 384 });
+}
+var __filename, __dirname, CODEX_DEFAULT_CONFIG;
+var init_codex = __esm({
+  "../core/dist/writers/codex.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+    init_template();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path3.dirname(__filename);
+    CODEX_DEFAULT_CONFIG = {
+      model: "gpt-5.1",
+      model_reasoning_effort: "high",
+      disable_response_storage: true,
+      sandbox_mode: "workspace-write",
+      windows_wsl_setup_acknowledged: true,
+      approval_policy: "never",
+      profile: "auto-max",
+      file_opener: "vscode",
+      history: {
+        persistence: "save-all"
+      },
+      tui: {
+        notifications: true
+      },
+      shell_environment_policy: {
+        inherit: "all",
+        ignore_default_excludes: false
+      },
+      features: {
+        plan_tool: true,
+        apply_patch_freeform: true,
+        view_image_tool: true,
+        web_search_request: true,
+        unified_exec: false,
+        streamable_shell: false,
+        rmcp_client: true
+      },
+      sandbox_workspace_write: {
+        network_access: true
+      },
+      profiles: {
+        "auto-max": {
+          approval_policy: "never",
+          sandbox_mode: "workspace-write"
+        },
+        "review": {
+          approval_policy: "on-request",
+          sandbox_mode: "workspace-write"
+        }
+      },
+      notice: {
+        hide_gpt5_1_migration_prompt: true
+      }
+    };
+  }
+});
+
+// ../core/dist/writers/claude.js
+import * as fs3 from "fs";
+import * as path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function loadClaudeTemplateConfig() {
+  try {
+    const templatePath = path4.resolve(__dirname2, "../../templates/claude/settings.json");
+    if (fs3.existsSync(templatePath)) {
+      const content = fs3.readFileSync(templatePath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return CLAUDE_CONFIG_TEMPLATE;
+}
+function writeClaudeConfig(provider) {
+  ensureDir(getClaudeDir());
+  const configPath = getClaudeConfigPath();
+  let userConfig = {};
+  if (fileExists(configPath)) {
+    const content = fs3.readFileSync(configPath, "utf-8");
+    userConfig = JSON.parse(content);
+  }
+  const defaultTemplate = loadClaudeTemplateConfig();
+  const defaultConfig = replaceVariables(defaultTemplate, {
+    apiKey: provider.apiKey,
+    baseUrl: provider.baseUrl
+  });
+  const mergedConfig = deepMerge(defaultConfig, userConfig);
+  mergedConfig.env = mergedConfig.env || {};
+  mergedConfig.env.ANTHROPIC_AUTH_TOKEN = provider.apiKey;
+  mergedConfig.env.ANTHROPIC_BASE_URL = provider.baseUrl;
+  fs3.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), { mode: 384 });
+}
+var __filename2, __dirname2, CLAUDE_CONFIG_TEMPLATE;
+var init_claude = __esm({
+  "../core/dist/writers/claude.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+    init_template();
+    __filename2 = fileURLToPath2(import.meta.url);
+    __dirname2 = path4.dirname(__filename2);
+    CLAUDE_CONFIG_TEMPLATE = {
+      env: {
+        ANTHROPIC_AUTH_TOKEN: "{{apiKey}}",
+        ANTHROPIC_BASE_URL: "{{baseUrl}}",
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: 1,
+        CLAUDE_CODE_MAX_OUTPUT_TOKENS: 32e3
+      },
+      permissions: {
+        allow: [],
+        deny: []
+      }
+    };
+  }
+});
+
+// ../core/dist/writers/mcp.js
+import * as fs4 from "fs";
+import * as path5 from "path";
+function getMCPConfigPath() {
+  return path5.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"];
+      }
+    }
+  } else {
+    config.servers = [];
+  }
+  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 init_mcp = __esm({
+  "../core/dist/writers/mcp.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+  }
+});
+
+// ../core/dist/presets/codex.js
+var CODEX_PRESETS;
+var init_codex2 = __esm({
+  "../core/dist/presets/codex.js"() {
+    "use strict";
+    CODEX_PRESETS = [
+      {
+        name: "88Code",
+        baseUrl: "https://www.88code.org/openai/v1",
+        description: "88Code API \u670D\u52A1"
+      }
+    ];
+  }
+});
+
+// ../core/dist/presets/claude.js
+var CC_PRESETS;
+var init_claude2 = __esm({
+  "../core/dist/presets/claude.js"() {
+    "use strict";
+    CC_PRESETS = [
+      {
+        name: "Anthropic Official",
+        baseUrl: "https://api.anthropic.com",
+        description: "Anthropic \u5B98\u65B9 API"
+      },
+      {
+        name: "AnyRouter",
+        baseUrl: "https://anyrouter.top",
+        description: "AnyRouter API \u670D\u52A1"
+      },
+      {
+        name: "PackyCode",
+        baseUrl: "https://api.packycode.com",
+        description: "PackyCode API \u670D\u52A1"
+      },
+      {
+        name: "88Code",
+        baseUrl: "https://www.88code.org/api",
+        description: "88Code API \u670D\u52A1"
+      },
+      {
+        name: "KKYYXX",
+        baseUrl: "https://api.kkyyxx.xyz",
+        description: "KKYYXX API \u670D\u52A1"
+      },
+      {
+        name: "BigModel",
+        baseUrl: "https://open.bigmodel.cn/api/anthropic",
+        description: "\u667A\u8C31 BigModel API"
+      },
+      {
+        name: "ModelScope",
+        baseUrl: "https://api-inference.modelscope.cn/v1/chat/completions",
+        description: "\u963F\u91CC\u4E91 ModelScope API"
+      }
+    ];
+  }
+});
+
+// ../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
+import * as path6 from "path";
+function createToolManager(tool) {
+  const toolConfig = TOOL_CONFIGS[tool];
+  const configPath = toolConfig.configPath;
+  function generateId() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 8);
+    return `${tool}-${timestamp}-${random}`;
+  }
+  function loadConfig2() {
+    if (toolConfig.customLoader) {
+      return toolConfig.customLoader();
+    }
+    if (!fileExists(configPath)) {
+      ensureDir(getCcmanDir());
+      const initialConfig = {
+        providers: [],
+        presets: []
+      };
+      writeJSON(configPath, initialConfig);
+      return initialConfig;
+    }
+    return readJSON(configPath);
+  }
+  function saveConfig2(config) {
+    if (toolConfig.customSaver) {
+      toolConfig.customSaver(config);
+      return;
+    }
+    writeJSON(configPath, config);
+  }
+  return {
+    add(input) {
+      const config = loadConfig2();
+      const nameExists = config.providers.some((p) => p.name === input.name);
+      if (nameExists) {
+        throw new ProviderNameConflictError(input.name);
+      }
+      const timestamp = Date.now();
+      const provider = {
+        id: generateId(),
+        name: input.name,
+        desc: input.desc,
+        baseUrl: input.baseUrl,
+        apiKey: input.apiKey,
+        model: input.model,
+        createdAt: timestamp,
+        lastModified: timestamp
+      };
+      config.providers.push(provider);
+      saveConfig2(config);
+      if (toolConfig.autoSync) {
+        toolConfig.writer(provider);
+      }
+      return provider;
+    },
+    list() {
+      const config = loadConfig2();
+      return config.providers;
+    },
+    get(id) {
+      const config = loadConfig2();
+      const provider = config.providers.find((p) => p.id === id);
+      if (!provider) {
+        throw new ProviderNotFoundError(id);
+      }
+      return provider;
+    },
+    findByName(name) {
+      const config = loadConfig2();
+      const lowerName = name.toLowerCase();
+      return config.providers.find((p) => p.name.toLowerCase() === lowerName);
+    },
+    switch(id) {
+      const config = loadConfig2();
+      const provider = config.providers.find((p) => p.id === id);
+      if (!provider) {
+        throw new ProviderNotFoundError(id);
+      }
+      config.currentProviderId = id;
+      provider.lastUsedAt = Date.now();
+      saveConfig2(config);
+      toolConfig.writer(provider);
+    },
+    getCurrent() {
+      const config = loadConfig2();
+      if (!config.currentProviderId) {
+        return null;
+      }
+      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);
+      if (!provider) {
+        throw new ProviderNotFoundError(id);
+      }
+      if (updates.name !== void 0 && updates.name !== provider.name) {
+        const nameConflict = config.providers.some((p) => p.id !== id && p.name === updates.name);
+        if (nameConflict) {
+          throw new ProviderNameConflictError(updates.name);
+        }
+      }
+      if (updates.name !== void 0)
+        provider.name = updates.name;
+      if (updates.desc !== void 0)
+        provider.desc = updates.desc;
+      if (updates.baseUrl !== void 0)
+        provider.baseUrl = updates.baseUrl;
+      if (updates.apiKey !== void 0)
+        provider.apiKey = updates.apiKey;
+      if (updates.model !== void 0)
+        provider.model = updates.model;
+      provider.lastModified = Date.now();
+      saveConfig2(config);
+      if (config.currentProviderId === id) {
+        toolConfig.writer(provider);
+      }
+      if (toolConfig.autoSync) {
+        toolConfig.writer(provider);
+      }
+      return provider;
+    },
+    remove(id) {
+      const config = loadConfig2();
+      const index = config.providers.findIndex((p) => p.id === id);
+      if (index === -1) {
+        throw new ProviderNotFoundError(id);
+      }
+      if (config.currentProviderId === id) {
+        config.currentProviderId = void 0;
+      }
+      config.providers.splice(index, 1);
+      saveConfig2(config);
+      if (toolConfig.autoSync) {
+        toolConfig.writer({});
+      }
+    },
+    clone(sourceId, newName) {
+      const source = this.get(sourceId);
+      const config = loadConfig2();
+      const nameExists = config.providers.some((p) => p.name === newName);
+      if (nameExists) {
+        throw new ProviderNameConflictError(newName);
+      }
+      const timestamp = Date.now();
+      const newProvider = {
+        ...source,
+        id: generateId(),
+        name: newName,
+        desc: void 0,
+        createdAt: timestamp,
+        lastModified: timestamp,
+        lastUsedAt: void 0
+      };
+      config.providers.push(newProvider);
+      saveConfig2(config);
+      return newProvider;
+    },
+    addPreset(input) {
+      const config = loadConfig2();
+      if (!config.presets) {
+        config.presets = [];
+      }
+      const allPresets = [...toolConfig.builtinPresets, ...config.presets];
+      const nameExists = allPresets.some((p) => p.name === input.name);
+      if (nameExists) {
+        throw new PresetNameConflictError(input.name);
+      }
+      const preset = {
+        name: input.name,
+        baseUrl: input.baseUrl,
+        description: input.description
+      };
+      config.presets.push(preset);
+      saveConfig2(config);
+      return {
+        ...preset,
+        isBuiltIn: false
+      };
+    },
+    listPresets() {
+      const config = loadConfig2();
+      const userPresets = config.presets || [];
+      const builtinWithFlag = toolConfig.builtinPresets.map((p) => ({
+        ...p,
+        isBuiltIn: true
+      }));
+      const userWithFlag = userPresets.map((p) => ({
+        ...p,
+        isBuiltIn: false
+      }));
+      return [...builtinWithFlag, ...userWithFlag];
+    },
+    editPreset(name, updates) {
+      const config = loadConfig2();
+      if (!config.presets) {
+        config.presets = [];
+      }
+      const preset = config.presets.find((p) => p.name === name);
+      if (!preset) {
+        throw new Error(`\u9884\u7F6E\u4E0D\u5B58\u5728: ${name}`);
+      }
+      if (updates.name !== void 0 && updates.name !== preset.name) {
+        const allPresets = [...toolConfig.builtinPresets, ...config.presets];
+        const nameConflict = allPresets.some((p) => p.name !== name && p.name === updates.name);
+        if (nameConflict) {
+          throw new PresetNameConflictError(updates.name);
+        }
+      }
+      if (updates.name !== void 0)
+        preset.name = updates.name;
+      if (updates.baseUrl !== void 0)
+        preset.baseUrl = updates.baseUrl;
+      if (updates.description !== void 0)
+        preset.description = updates.description;
+      saveConfig2(config);
+      return {
+        ...preset,
+        isBuiltIn: false
+      };
+    },
+    removePreset(name) {
+      const config = loadConfig2();
+      if (!config.presets) {
+        return;
+      }
+      const index = config.presets.findIndex((p) => p.name === name);
+      if (index === -1) {
+        throw new Error(`Preset not found: ${name}`);
+      }
+      config.presets.splice(index, 1);
+      saveConfig2(config);
+    }
+  };
+}
+function createCodexManager() {
+  return createToolManager("codex");
+}
+function createClaudeManager() {
+  return createToolManager("claude");
+}
+function createMCPManager() {
+  return createToolManager("mcp");
+}
+var TOOL_CONFIGS;
+var init_tool_manager = __esm({
+  "../core/dist/tool-manager.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+    init_codex();
+    init_claude();
+    init_mcp();
+    init_codex2();
+    init_claude2();
+    init_mcp2();
+    init_tool_manager_types();
+    TOOL_CONFIGS = {
+      codex: {
+        configPath: path6.join(getCcmanDir(), "codex.json"),
+        builtinPresets: CODEX_PRESETS,
+        writer: writeCodexConfig
+      },
+      claude: {
+        configPath: path6.join(getCcmanDir(), "claude.json"),
+        builtinPresets: CC_PRESETS,
+        writer: writeClaudeConfig
+      },
+      mcp: {
+        configPath: path6.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((s) => s.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((s) => s.enabledApps.includes(app)).map((s) => s.name);
+          }
+          saveMCPConfig(mcpConfig);
+        }
+      }
+    };
+  }
+});
+
+// ../core/dist/migrate.js
+var init_migrate = __esm({
+  "../core/dist/migrate.js"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// ../core/dist/config.js
+import * as fs5 from "fs";
+function ensureConfigDir() {
+  const dir = getCcmanDir();
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+  }
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fs5.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = fs5.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to load config: ${error.message}`);
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const configPath = getConfigPath();
+  try {
+    const tempPath = `${configPath}.tmp`;
+    fs5.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
+      mode: 384
+    });
+    fs5.renameSync(tempPath, configPath);
+  } catch (error) {
+    throw new Error(`Failed to save config: ${error.message}`);
+  }
+}
+function getSyncConfig() {
+  const config = loadConfig();
+  return config.sync || null;
+}
+function saveSyncConfig(syncConfig) {
+  const config = loadConfig();
+  config.sync = syncConfig;
+  saveConfig(config);
+}
+function updateLastSyncTime() {
+  const config = loadConfig();
+  if (config.sync) {
+    config.sync.lastSync = Date.now();
+    saveConfig(config);
+  }
+}
+var init_config = __esm({
+  "../core/dist/config.js"() {
+    "use strict";
+    init_paths();
+  }
+});
+
+// ../core/dist/sync/webdav-client.js
+import { createClient } from "webdav";
+function normalizePath(dir) {
+  if (!dir || dir === "/") {
+    return "/";
+  }
+  const normalized = dir.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  return `/${normalized}`;
+}
+function joinPath(baseDir, filename) {
+  const normalizedBase = normalizePath(baseDir);
+  const normalizedFile = filename.replace(/^\/+/, "");
+  if (normalizedBase === "/") {
+    return `/${normalizedFile}`;
+  }
+  return `${normalizedBase}/${normalizedFile}`;
+}
+function createWebDAVClient(config) {
+  const client = createClient(config.webdavUrl, {
+    username: config.username,
+    password: config.password,
+    authType: config.authType || "password",
+    // 默认使用 Basic Auth
+    maxBodyLength: 100 * 1024 * 1024,
+    // 100MB
+    maxContentLength: 100 * 1024 * 1024
+    // 100MB
+  });
+  return client;
+}
+async function testWebDAVConnection(config) {
+  const remoteDir = normalizePath(config.remoteDir || "/");
+  try {
+    const client = createWebDAVClient(config);
+    await client.getDirectoryContents(remoteDir);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+async function ensureDirectory(config, dirPath) {
+  const client = createWebDAVClient(config);
+  const normalizedPath = normalizePath(dirPath);
+  if (normalizedPath === "/") {
+    return true;
+  }
+  try {
+    const exists = await client.exists(normalizedPath);
+    if (exists) {
+      return true;
+    }
+    const parentPath = normalizedPath.substring(0, normalizedPath.lastIndexOf("/"));
+    if (parentPath && parentPath !== "/") {
+      await ensureDirectory(config, parentPath);
+    }
+    await client.createDirectory(normalizedPath);
+    return true;
+  } catch (error) {
+    console.warn(`\u521B\u5EFA\u76EE\u5F55 ${normalizedPath} \u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u76F4\u63A5\u4E0A\u4F20\u6587\u4EF6:`, error.message);
+    return false;
+  }
+}
+function isPathNotFoundError(error) {
+  const msg = error.message.toLowerCase();
+  return msg.includes("404") || msg.includes("409") || msg.includes("not found") || msg.includes("conflict");
+}
+async function uploadToWebDAV(config, filename, data) {
+  const client = createWebDAVClient(config);
+  const remoteDir = normalizePath(config.remoteDir || "/");
+  const fullPath = joinPath(remoteDir, filename);
+  try {
+    await client.putFileContents(fullPath, data, { overwrite: true });
+  } catch (firstError) {
+    if (isPathNotFoundError(firstError)) {
+      const dirPath = fullPath.substring(0, fullPath.lastIndexOf("/"));
+      if (dirPath && dirPath !== "/") {
+        await ensureDirectory(config, dirPath);
+        await client.putFileContents(fullPath, data, { overwrite: true });
+      } else {
+        throw firstError;
+      }
+    } else {
+      throw firstError;
+    }
+  }
+  try {
+    const exists = await client.exists(fullPath);
+    if (!exists) {
+      throw new Error(`\u6587\u4EF6\u4E0A\u4F20\u540E\u672A\u5728\u670D\u52A1\u5668\u4E0A\u627E\u5230: ${fullPath}`);
+    }
+  } catch (verifyError) {
+    const errorMsg = verifyError.message;
+    if (errorMsg.includes("multistatus") || errorMsg.includes("Invalid response")) {
+      throw new Error(`WebDAV \u914D\u7F6E\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\uFF1A
+1. URL \u662F\u5426\u4E3A WebDAV \u7AEF\u70B9\uFF08\u4E0D\u662F\u7F51\u9875\u5730\u5740\uFF09
+2. \u7528\u6237\u540D\u548C\u5BC6\u7801\u662F\u5426\u6B63\u786E
+3. \u8BA4\u8BC1\u7C7B\u578B\u662F\u5426\u5339\u914D
+
+\u8BE6\u7EC6\uFF1A${errorMsg}`);
+    }
+    throw verifyError;
+  }
+}
+async function downloadFromWebDAV(config, filename) {
+  const client = createWebDAVClient(config);
+  const remoteDir = normalizePath(config.remoteDir || "/");
+  const fullPath = joinPath(remoteDir, filename);
+  try {
+    const contents = await client.getFileContents(fullPath, { format: "text" });
+    return contents;
+  } catch (error) {
+    throw new Error(`\u4E0B\u8F7D\u5931\u8D25: ${error.message}`);
+  }
+}
+async function existsOnWebDAV(config, filename) {
+  const client = createWebDAVClient(config);
+  const remoteDir = normalizePath(config.remoteDir || "/");
+  const fullPath = joinPath(remoteDir, filename);
+  try {
+    return await client.exists(fullPath);
+  } catch (error) {
+    return false;
+  }
+}
+var init_webdav_client = __esm({
+  "../core/dist/sync/webdav-client.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/sync/crypto.js
+import * as crypto from "crypto";
+function deriveKey(password, salt) {
+  return crypto.pbkdf2Sync(password, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+}
+function encryptApiKey(apiKey, password) {
+  if (typeof apiKey !== "string") {
+    throw new Error("API Key \u7F3A\u5931\u6216\u7C7B\u578B\u9519\u8BEF\uFF0C\u65E0\u6CD5\u52A0\u5BC6");
+  }
+  if (!password) {
+    throw new Error("\u540C\u6B65\u5BC6\u7801\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const salt = crypto.randomBytes(SALT_LENGTH);
+  const iv = crypto.randomBytes(IV_LENGTH);
+  const key = deriveKey(password, salt);
+  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
+  let encrypted = cipher.update(apiKey, "utf8");
+  encrypted = Buffer.concat([encrypted, cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const result = Buffer.concat([salt, iv, tag, encrypted]);
+  return result.toString("base64");
+}
+function decryptApiKey(encryptedApiKey, password) {
+  try {
+    const data = Buffer.from(encryptedApiKey, "base64");
+    const salt = data.subarray(0, SALT_LENGTH);
+    const iv = data.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+    const tag = data.subarray(SALT_LENGTH + IV_LENGTH, SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+    const encrypted = data.subarray(SALT_LENGTH + IV_LENGTH + TAG_LENGTH);
+    const key = deriveKey(password, salt);
+    const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
+    decipher.setAuthTag(tag);
+    let decrypted = decipher.update(encrypted);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return decrypted.toString("utf8");
+  } catch (error) {
+    throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
+  }
+}
+function encryptProviders(providers, password) {
+  return providers.map((provider) => {
+    if (typeof provider.apiKey !== "string" || provider.apiKey.length === 0) {
+      throw new Error(`\u670D\u52A1\u5546 "${provider.name}" \u7684 API Key \u4E3A\u7A7A\u6216\u7F3A\u5931\uFF0C\u8BF7\u5148\u5728 ccman \u4E2D\u8865\u5168\u540E\u518D\u8FDB\u884C\u540C\u6B65`);
+    }
+    return {
+      ...provider,
+      apiKey: encryptApiKey(provider.apiKey, password)
+    };
+  });
+}
+function decryptProviders(encryptedProviders, password) {
+  return encryptedProviders.map((provider) => ({
+    ...provider,
+    apiKey: decryptApiKey(provider.apiKey, password)
+  }));
+}
+var ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, TAG_LENGTH, PBKDF2_ITERATIONS;
+var init_crypto = __esm({
+  "../core/dist/sync/crypto.js"() {
+    "use strict";
+    ALGORITHM = "aes-256-gcm";
+    KEY_LENGTH = 32;
+    IV_LENGTH = 16;
+    SALT_LENGTH = 32;
+    TAG_LENGTH = 16;
+    PBKDF2_ITERATIONS = 1e5;
+  }
+});
+
+// ../core/dist/sync/merge-advanced.js
+function isSameConfig(a, b) {
+  return a.baseUrl === b.baseUrl && a.apiKey === b.apiKey;
+}
+function isProviderEqual(a, b) {
+  return a.id === b.id && a.name === b.name && a.baseUrl === b.baseUrl && a.apiKey === b.apiKey;
+}
+function resolveNameConflict(existingProviders, newProvider) {
+  const existingNames = new Set(existingProviders.map((p) => p.name));
+  if (!existingNames.has(newProvider.name)) {
+    return newProvider;
+  }
+  let suffix = 2;
+  let newName = `${newProvider.name}_${suffix}`;
+  while (existingNames.has(newName)) {
+    suffix++;
+    newName = `${newProvider.name}_${suffix}`;
+  }
+  console.log(`name \u51B2\u7A81\uFF1A\u5C06 "${newProvider.name}" \u91CD\u547D\u540D\u4E3A "${newName}"`);
+  return {
+    ...newProvider,
+    name: newName
+  };
+}
+function mergeProviders(local, remote) {
+  const mergedMap = /* @__PURE__ */ new Map();
+  let hasChanges = false;
+  for (const localProvider of local) {
+    mergedMap.set(localProvider.id, localProvider);
+  }
+  for (const remoteProvider of remote) {
+    const existingLocal = Array.from(mergedMap.values()).find((p) => isSameConfig(p, remoteProvider));
+    if (existingLocal) {
+      mergedMap.delete(existingLocal.id);
+      mergedMap.set(remoteProvider.id, remoteProvider);
+      if (!isProviderEqual(existingLocal, remoteProvider)) {
+        hasChanges = true;
+        console.log(`\u76F8\u540C\u914D\u7F6E (${remoteProvider.baseUrl})\uFF0C\u4F7F\u7528\u4E91\u7AEF\u6570\u636E`);
+      }
+    } else {
+      const existingProviders = Array.from(mergedMap.values());
+      const resolvedProvider = resolveNameConflict(existingProviders, remoteProvider);
+      mergedMap.set(resolvedProvider.id, resolvedProvider);
+      hasChanges = true;
+      console.log(`\u65B0 provider ${resolvedProvider.name}\uFF0C\u6DFB\u52A0\u5230\u5408\u5E76\u5217\u8868`);
+    }
+  }
+  const merged = Array.from(mergedMap.values());
+  return {
+    merged,
+    hasChanges
+  };
+}
+function resolvePresetNameConflict(existingPresets, newPreset) {
+  const existingNames = new Set(existingPresets.map((p) => p.name));
+  if (!existingNames.has(newPreset.name)) {
+    return newPreset;
+  }
+  let suffix = 2;
+  let newName = `${newPreset.name}_${suffix}`;
+  while (existingNames.has(newName)) {
+    suffix++;
+    newName = `${newPreset.name}_${suffix}`;
+  }
+  console.log(`preset name \u51B2\u7A81\uFF1A\u5C06 "${newPreset.name}" \u91CD\u547D\u540D\u4E3A "${newName}"`);
+  return {
+    ...newPreset,
+    name: newName
+  };
+}
+function mergePresets(local, remote) {
+  const localPresets = local || [];
+  const remotePresets = remote || [];
+  const mergedMap = /* @__PURE__ */ new Map();
+  for (const preset of localPresets) {
+    mergedMap.set(preset.baseUrl, preset);
+  }
+  for (const remotePreset of remotePresets) {
+    const existingLocal = mergedMap.get(remotePreset.baseUrl);
+    if (existingLocal) {
+      mergedMap.set(remotePreset.baseUrl, remotePreset);
+      console.log(`preset ${remotePreset.name} (${remotePreset.baseUrl})\uFF0C\u4F7F\u7528\u4E91\u7AEF\u6570\u636E`);
+    } else {
+      const existingPresets = Array.from(mergedMap.values());
+      const resolvedPreset = resolvePresetNameConflict(existingPresets, remotePreset);
+      mergedMap.set(resolvedPreset.baseUrl, resolvedPreset);
+    }
+  }
+  return Array.from(mergedMap.values());
+}
+var init_merge_advanced = __esm({
+  "../core/dist/sync/merge-advanced.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/sync/merge.js
+import fs6 from "fs";
+import path7 from "path";
+function backupConfig(configPath, keepCount = 3) {
+  if (!fs6.existsSync(configPath)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}`);
+  }
+  const timestamp = Date.now();
+  const backupPath = `${configPath}.backup.${timestamp}`;
+  fs6.copyFileSync(configPath, backupPath);
+  cleanupOldBackups(configPath, keepCount);
+  return backupPath;
+}
+function cleanupOldBackups(configPath, keepCount) {
+  const dir = path7.dirname(configPath);
+  const basename = path7.basename(configPath);
+  const backupPrefix = `${basename}.backup.`;
+  try {
+    const files = fs6.readdirSync(dir);
+    const backups = files.filter((f) => f.startsWith(backupPrefix)).map((f) => {
+      const timestampStr = f.substring(backupPrefix.length);
+      const timestamp = parseInt(timestampStr, 10);
+      if (isNaN(timestamp)) {
+        return null;
+      }
+      return {
+        name: f,
+        path: path7.join(dir, f),
+        timestamp
+      };
+    }).filter((backup) => backup !== null).sort((a, b) => b.timestamp - a.timestamp);
+    const toDelete = backups.slice(keepCount);
+    for (const backup of toDelete) {
+      try {
+        fs6.unlinkSync(backup.path);
+      } catch (error) {
+        console.warn(`\u65E0\u6CD5\u5220\u9664\u65E7\u5907\u4EFD\u6587\u4EF6 ${backup.name}: ${error.message}`);
+      }
+    }
+  } catch (error) {
+    console.warn(`\u6E05\u7406\u65E7\u5907\u4EFD\u65F6\u51FA\u9519: ${error.message}`);
+  }
+}
+var init_merge = __esm({
+  "../core/dist/sync/merge.js"() {
+    "use strict";
+  }
+});
+
+// ../core/dist/sync/sync-v2.js
+import fs7 from "fs";
+import path8 from "path";
+async function uploadToCloud(config, password) {
+  const ccmanDir2 = getCcmanDir();
+  const codexConfigPath = path8.join(ccmanDir2, "codex.json");
+  const claudeConfigPath = path8.join(ccmanDir2, "claude.json");
+  const codexConfig = readJSON(codexConfigPath);
+  const claudeConfig = readJSON(claudeConfigPath);
+  const encryptedCodexProviders = encryptProviders(codexConfig.providers, password);
+  const encryptedClaudeProviders = encryptProviders(claudeConfig.providers, password);
+  const encryptedCodexConfig = {
+    ...codexConfig,
+    // 保留所有字段
+    providers: encryptedCodexProviders
+    // 只替换 providers（加密后的）
+  };
+  const encryptedClaudeConfig = {
+    ...claudeConfig,
+    // 保留所有字段
+    providers: encryptedClaudeProviders
+    // 只替换 providers（加密后的）
+  };
+  const codexJson = JSON.stringify(encryptedCodexConfig, null, 2);
+  const claudeJson = JSON.stringify(encryptedClaudeConfig, null, 2);
+  await uploadToWebDAV(config, CODEX_REMOTE_PATH, codexJson);
+  await uploadToWebDAV(config, CLAUDE_REMOTE_PATH, claudeJson);
+  updateLastSyncTime();
+  console.log("\u2705 \u914D\u7F6E\u5DF2\u4E0A\u4F20\u5230\u4E91\u7AEF");
+}
+async function downloadFromCloud(config, password) {
+  const codexExists = await existsOnWebDAV(config, CODEX_REMOTE_PATH);
+  const claudeExists = await existsOnWebDAV(config, CLAUDE_REMOTE_PATH);
+  if (!codexExists && !claudeExists) {
+    throw new Error("\u8FDC\u7A0B\u914D\u7F6E\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u4E0A\u4F20\u914D\u7F6E");
+  }
+  const codexJson = codexExists ? await downloadFromWebDAV(config, CODEX_REMOTE_PATH) : null;
+  const claudeJson = claudeExists ? await downloadFromWebDAV(config, CLAUDE_REMOTE_PATH) : null;
+  const remoteCodexConfig = codexJson ? JSON.parse(codexJson) : null;
+  const remoteClaudeConfig = claudeJson ? JSON.parse(claudeJson) : null;
+  let decryptedCodexProviders = null;
+  let decryptedClaudeProviders = null;
+  try {
+    if (remoteCodexConfig) {
+      decryptedCodexProviders = decryptProviders(remoteCodexConfig.providers, password);
+    }
+    if (remoteClaudeConfig) {
+      decryptedClaudeProviders = decryptProviders(remoteClaudeConfig.providers, password);
+    }
+  } catch (error) {
+    throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
+  }
+  const backupPaths = [];
+  const ccmanDir2 = getCcmanDir();
+  const codexConfigPath = path8.join(ccmanDir2, "codex.json");
+  const claudeConfigPath = path8.join(ccmanDir2, "claude.json");
+  try {
+    if (fs7.existsSync(codexConfigPath)) {
+      backupPaths.push(backupConfig(codexConfigPath));
+    }
+    if (fs7.existsSync(claudeConfigPath)) {
+      backupPaths.push(backupConfig(claudeConfigPath));
+    }
+  } catch (error) {
+    throw new Error(`\u5907\u4EFD\u5931\u8D25: ${error.message}`);
+  }
+  try {
+    if (remoteCodexConfig && decryptedCodexProviders) {
+      const newCodexConfig = {
+        ...remoteCodexConfig,
+        // 使用云端配置的所有字段
+        providers: decryptedCodexProviders
+        // 只替换 providers（解密后的）
+      };
+      writeJSON(codexConfigPath, newCodexConfig);
+      applyCurrentProvider("codex", newCodexConfig);
+    }
+    if (remoteClaudeConfig && decryptedClaudeProviders) {
+      const newClaudeConfig = {
+        ...remoteClaudeConfig,
+        // 使用云端配置的所有字段
+        providers: decryptedClaudeProviders
+        // 只替换 providers（解密后的）
+      };
+      writeJSON(claudeConfigPath, newClaudeConfig);
+      applyCurrentProvider("claude", newClaudeConfig);
+    }
+    updateLastSyncTime();
+    console.log("\u2705 \u914D\u7F6E\u5DF2\u4ECE\u4E91\u7AEF\u4E0B\u8F7D\u5E76\u5E94\u7528");
+    return backupPaths;
+  } catch (error) {
+    for (const backupPath of backupPaths) {
+      const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
+      if (fs7.existsSync(backupPath)) {
+        fs7.copyFileSync(backupPath, originalPath);
+      }
+    }
+    throw new Error(`\u8986\u76D6\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
+  }
+}
+async function mergeSync(config, password) {
+  const codexExists = await existsOnWebDAV(config, CODEX_REMOTE_PATH);
+  const claudeExists = await existsOnWebDAV(config, CLAUDE_REMOTE_PATH);
+  if (!codexExists && !claudeExists) {
+    console.log("\u8FDC\u7A0B\u914D\u7F6E\u4E0D\u5B58\u5728\uFF0C\u6267\u884C\u4E0A\u4F20\u64CD\u4F5C");
+    await uploadToCloud(config, password);
+    return {
+      hasChanges: true,
+      backupPaths: []
+    };
+  }
+  const codexJson = codexExists ? await downloadFromWebDAV(config, CODEX_REMOTE_PATH) : null;
+  const claudeJson = claudeExists ? await downloadFromWebDAV(config, CLAUDE_REMOTE_PATH) : null;
+  const remoteCodexConfig = codexJson ? JSON.parse(codexJson) : null;
+  const remoteClaudeConfig = claudeJson ? JSON.parse(claudeJson) : null;
+  let remoteCodexProviders = [];
+  let remoteClaudeProviders = [];
+  try {
+    if (remoteCodexConfig) {
+      remoteCodexProviders = decryptProviders(remoteCodexConfig.providers, password);
+    }
+    if (remoteClaudeConfig) {
+      remoteClaudeProviders = decryptProviders(remoteClaudeConfig.providers, password);
+    }
+  } catch (error) {
+    throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
+  }
+  const ccmanDir2 = getCcmanDir();
+  const codexConfigPath = path8.join(ccmanDir2, "codex.json");
+  const claudeConfigPath = path8.join(ccmanDir2, "claude.json");
+  const localCodexConfig = readJSON(codexConfigPath);
+  const localClaudeConfig = readJSON(claudeConfigPath);
+  const codexMergeResult = mergeProviders(localCodexConfig.providers, remoteCodexProviders);
+  const claudeMergeResult = mergeProviders(localClaudeConfig.providers, remoteClaudeProviders);
+  const hasChanges = codexMergeResult.hasChanges || claudeMergeResult.hasChanges;
+  if (!hasChanges) {
+    console.log("\u2139\uFE0F \u914D\u7F6E\u5DF2\u540C\u6B65\uFF0C\u65E0\u9700\u64CD\u4F5C");
+    return {
+      hasChanges: false,
+      backupPaths: []
+    };
+  }
+  const backupPaths = [];
+  try {
+    if (fs7.existsSync(codexConfigPath)) {
+      backupPaths.push(backupConfig(codexConfigPath));
+    }
+    if (fs7.existsSync(claudeConfigPath)) {
+      backupPaths.push(backupConfig(claudeConfigPath));
+    }
+  } catch (error) {
+    throw new Error(`\u5907\u4EFD\u5931\u8D25: ${error.message}`);
+  }
+  const mergedCodexPresets = mergePresets(localCodexConfig.presets, remoteCodexConfig?.presets);
+  const mergedClaudePresets = mergePresets(localClaudeConfig.presets, remoteClaudeConfig?.presets);
+  try {
+    const mergedCodexConfig = {
+      ...localCodexConfig,
+      // 保留本地配置的所有字段
+      providers: codexMergeResult.merged,
+      // 替换为合并后的 providers
+      presets: mergedCodexPresets
+      // 替换为合并后的 presets
+    };
+    const mergedClaudeConfig = {
+      ...localClaudeConfig,
+      // 保留本地配置的所有字段
+      providers: claudeMergeResult.merged,
+      // 替换为合并后的 providers
+      presets: mergedClaudePresets
+      // 替换为合并后的 presets
+    };
+    writeJSON(codexConfigPath, mergedCodexConfig);
+    writeJSON(claudeConfigPath, mergedClaudeConfig);
+    applyCurrentProvider("codex", mergedCodexConfig);
+    applyCurrentProvider("claude", mergedClaudeConfig);
+    const encryptedCodexProviders = encryptProviders(codexMergeResult.merged, password);
+    const encryptedClaudeProviders = encryptProviders(claudeMergeResult.merged, password);
+    const encryptedCodexConfig = {
+      ...mergedCodexConfig,
+      // 保留合并后配置的所有字段
+      providers: encryptedCodexProviders
+      // 只替换 providers（加密后的）
+    };
+    const encryptedClaudeConfig = {
+      ...mergedClaudeConfig,
+      // 保留合并后配置的所有字段
+      providers: encryptedClaudeProviders
+      // 只替换 providers（加密后的）
+    };
+    const codexJson2 = JSON.stringify(encryptedCodexConfig, null, 2);
+    const claudeJson2 = JSON.stringify(encryptedClaudeConfig, null, 2);
+    await uploadToWebDAV(config, CODEX_REMOTE_PATH, codexJson2);
+    await uploadToWebDAV(config, CLAUDE_REMOTE_PATH, claudeJson2);
+    updateLastSyncTime();
+    console.log("\u2705 \u914D\u7F6E\u5DF2\u5408\u5E76\u5E76\u540C\u6B65\u5230\u4E91\u7AEF");
+    return {
+      hasChanges: true,
+      backupPaths
+    };
+  } catch (error) {
+    for (const backupPath of backupPaths) {
+      const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
+      if (fs7.existsSync(backupPath)) {
+        fs7.copyFileSync(backupPath, originalPath);
+      }
+    }
+    throw new Error(`\u5408\u5E76\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
+  }
+}
+function applyCurrentProvider(tool, config) {
+  if (!config.currentProviderId) {
+    return;
+  }
+  const provider = config.providers.find((p) => p.id === config.currentProviderId);
+  if (!provider) {
+    return;
+  }
+  if (tool === "codex") {
+    writeCodexConfig(provider);
+  } else {
+    writeClaudeConfig(provider);
+  }
+}
+var CODEX_REMOTE_PATH, CLAUDE_REMOTE_PATH;
+var init_sync_v2 = __esm({
+  "../core/dist/sync/sync-v2.js"() {
+    "use strict";
+    init_config();
+    init_webdav_client();
+    init_crypto();
+    init_merge_advanced();
+    init_merge();
+    init_paths();
+    init_file();
+    init_codex();
+    init_claude();
+    CODEX_REMOTE_PATH = ".ccman/codex.json";
+    CLAUDE_REMOTE_PATH = ".ccman/claude.json";
+  }
+});
+
+// ../core/dist/export.js
+import * as fs8 from "fs";
+import * as path9 from "path";
+function validateExport() {
+  const ccmanDir2 = getCcmanDir();
+  const codexPath = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const claudePath = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const missingFiles = [];
+  if (!fileExists(codexPath)) {
+    missingFiles.push(CODEX_CONFIG_FILE);
+  }
+  if (!fileExists(claudePath)) {
+    missingFiles.push(CLAUDE_CONFIG_FILE);
+  }
+  if (missingFiles.length > 0) {
+    return {
+      valid: false,
+      message: `\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${missingFiles.join(", ")}`,
+      missingFiles
+    };
+  }
+  return { valid: true };
+}
+function validateImportDir(sourceDir) {
+  if (!fileExists(sourceDir)) {
+    return {
+      valid: false,
+      message: `\u76EE\u5F55\u4E0D\u5B58\u5728: ${sourceDir}`,
+      foundFiles: []
+    };
+  }
+  const stats = fs8.statSync(sourceDir);
+  if (!stats.isDirectory()) {
+    return {
+      valid: false,
+      message: `\u4E0D\u662F\u6709\u6548\u7684\u76EE\u5F55: ${sourceDir}`,
+      foundFiles: []
+    };
+  }
+  const codexPath = path9.join(sourceDir, CODEX_CONFIG_FILE);
+  const claudePath = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
+  const foundFiles = [];
+  if (fileExists(codexPath)) {
+    foundFiles.push(CODEX_CONFIG_FILE);
+  }
+  if (fileExists(claudePath)) {
+    foundFiles.push(CLAUDE_CONFIG_FILE);
+  }
+  if (foundFiles.length === 0) {
+    return {
+      valid: false,
+      message: `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6 (${CODEX_CONFIG_FILE} \u6216 ${CLAUDE_CONFIG_FILE})`,
+      foundFiles: []
+    };
+  }
+  return {
+    valid: true,
+    foundFiles
+  };
+}
+function exportConfig(targetDir) {
+  const validation = validateExport();
+  if (!validation.valid) {
+    throw new Error(validation.message);
+  }
+  ensureDir(targetDir);
+  const ccmanDir2 = getCcmanDir();
+  const exportedFiles = [];
+  const codexSrc = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const codexDst = path9.join(targetDir, CODEX_CONFIG_FILE);
+  if (fileExists(codexSrc)) {
+    fs8.copyFileSync(codexSrc, codexDst);
+    exportedFiles.push(CODEX_CONFIG_FILE);
+  }
+  const claudeSrc = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const claudeDst = path9.join(targetDir, CLAUDE_CONFIG_FILE);
+  if (fileExists(claudeSrc)) {
+    fs8.copyFileSync(claudeSrc, claudeDst);
+    exportedFiles.push(CLAUDE_CONFIG_FILE);
+  }
+  return {
+    success: true,
+    targetDir,
+    exportedFiles
+  };
+}
+function importConfig(sourceDir) {
+  const validation = validateImportDir(sourceDir);
+  if (!validation.valid) {
+    throw new Error(validation.message);
+  }
+  const ccmanDir2 = getCcmanDir();
+  const backupPaths = [];
+  const importedFiles = [];
+  ensureDir(ccmanDir2);
+  try {
+    if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
+      const codexDst = path9.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);
+      importedFiles.push(CODEX_CONFIG_FILE);
+    }
+    if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
+      const claudeDst = path9.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);
+      importedFiles.push(CLAUDE_CONFIG_FILE);
+    }
+    return {
+      success: true,
+      backupPaths,
+      importedFiles
+    };
+  } catch (error) {
+    for (const backupPath of backupPaths) {
+      const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
+      if (fileExists(backupPath)) {
+        fs8.copyFileSync(backupPath, originalPath);
+      }
+    }
+    throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
+  }
+}
+var CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
+var init_export = __esm({
+  "../core/dist/export.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+    init_merge();
+    CODEX_CONFIG_FILE = "codex.json";
+    CLAUDE_CONFIG_FILE = "claude.json";
+  }
+});
+
+// ../core/dist/claude-clean.js
+import * as fs9 from "fs";
+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 = fs9.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}`;
+  fs9.copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+function saveJsonAtomic(filePath, data) {
+  const tempPath = `${filePath}.tmp`;
+  const content = JSON.stringify(data, null, 2);
+  fs9.writeFileSync(tempPath, content, { mode: 384 });
+  fs9.renameSync(tempPath, filePath);
+}
+function analyzeClaudeJson() {
+  const filePath = getClaudeJsonPath();
+  if (!fs9.existsSync(filePath)) {
+    return {
+      fileSize: 0,
+      fileSizeFormatted: "0 B",
+      projectCount: 0,
+      totalHistoryCount: 0,
+      projectHistory: [],
+      cacheSize: 0,
+      estimatedSavings: {
+        conservative: 0,
+        moderate: 0,
+        aggressive: 0
+      }
+    };
+  }
+  const fileSize = getFileSize(filePath);
+  const content = fs9.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 (!fs9.existsSync(filePath)) {
+    throw new Error(`${filePath} \u6587\u4EF6\u4E0D\u5B58\u5728`);
+  }
+  const backupPath = backupFile(filePath);
+  const sizeBefore = getFileSize(filePath);
+  const content = fs9.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 CleanPresets;
+var init_claude_clean = __esm({
+  "../core/dist/claude-clean.js"() {
+    "use strict";
+    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_dist = __esm({
+  "../core/dist/index.js"() {
+    "use strict";
+    init_package();
+    init_tool_manager();
+    init_codex2();
+    init_claude2();
+    init_mcp2();
+    init_mcp();
+    init_migrate();
+    init_paths();
+    init_config();
+    init_webdav_client();
+    init_sync_v2();
+    init_crypto();
+    init_merge_advanced();
+    init_export();
+    init_claude_clean();
+    VERSION = package_default.version;
+  }
+});
+
 // src/utils/sync-config.ts
-import { getSyncConfig, saveSyncConfig as coreSaveSyncConfig, getConfigPath } from "@ccman/core";
 function loadSyncConfig() {
   try {
     const config = getSyncConfig();
@@ -22,13 +1949,13 @@ function loadSyncConfig() {
     throw new Error(`\u8BFB\u53D6\u540C\u6B65\u914D\u7F6E\u5931\u8D25: ${error.message}`);
   }
 }
-function saveSyncConfig(config) {
+function saveSyncConfig2(config) {
   try {
     const configToSave = { ...config };
     if (!configToSave.rememberSyncPassword) {
       delete configToSave.syncPassword;
     }
-    coreSaveSyncConfig(configToSave);
+    saveSyncConfig(configToSave);
   } catch (error) {
     throw new Error(`\u4FDD\u5B58\u540C\u6B65\u914D\u7F6E\u5931\u8D25: ${error.message}`);
   }
@@ -39,6 +1966,7 @@ function getSyncConfigPath() {
 var init_sync_config = __esm({
   "src/utils/sync-config.ts"() {
     "use strict";
+    init_dist();
   }
 });
 
@@ -49,7 +1977,6 @@ __export(config_exports, {
 });
 import chalk3 from "chalk";
 import inquirer from "inquirer";
-import { testWebDAVConnection } from "@ccman/core";
 function configCommand(program2) {
   program2.command("config").description("\u914D\u7F6E WebDAV \u8FDE\u63A5").action(async () => {
     try {
@@ -201,7 +2128,7 @@ function configCommand(program2) {
         console.log();
         return;
       }
-      saveSyncConfig(newConfig);
+      saveSyncConfig2(newConfig);
       console.log();
       console.log(chalk3.green("\u2705 \u914D\u7F6E\u4FDD\u5B58\u6210\u529F"));
       console.log();
@@ -243,10 +2170,11 @@ function configCommand(program2) {
     }
   });
 }
-var init_config = __esm({
+var init_config2 = __esm({
   "src/commands/sync/config.ts"() {
     "use strict";
     init_sync_config();
+    init_dist();
   }
 });
 
@@ -271,7 +2199,7 @@ async function ensureConfigExists() {
   if (!shouldConfig) {
     return null;
   }
-  const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
   const cmd = new Command();
   configCommand2(cmd);
   await cmd.parseAsync(["node", "ccman", "config"]);
@@ -290,7 +2218,6 @@ __export(test_exports, {
   testCommand: () => testCommand
 });
 import chalk5 from "chalk";
-import { testWebDAVConnection as testWebDAVConnection2 } from "@ccman/core";
 function testCommand(program2) {
   program2.command("test").description("\u6D4B\u8BD5 WebDAV \u8FDE\u63A5").action(async () => {
     try {
@@ -300,7 +2227,7 @@ function testCommand(program2) {
         return;
       }
       console.log(chalk5.bold("\n\u{1F50D} \u6D4B\u8BD5 WebDAV \u8FDE\u63A5...\n"));
-      const success = await testWebDAVConnection2(config);
+      const success = await testWebDAVConnection(config);
       if (success) {
         console.log(chalk5.green("\u2705 \u8FDE\u63A5\u6210\u529F"));
         console.log();
@@ -328,6 +2255,7 @@ function testCommand(program2) {
 var init_test = __esm({
   "src/commands/sync/test.ts"() {
     "use strict";
+    init_dist();
     init_helpers();
   }
 });
@@ -339,7 +2267,6 @@ __export(upload_exports, {
 });
 import chalk6 from "chalk";
 import inquirer3 from "inquirer";
-import { uploadToCloud, createCodexManager, createClaudeManager } from "@ccman/core";
 function uploadCommand(program2) {
   program2.command("upload").description("\u4E0A\u4F20\u672C\u5730\u914D\u7F6E\u5230\u4E91\u7AEF").action(async () => {
     try {
@@ -406,6 +2333,7 @@ function uploadCommand(program2) {
 var init_upload = __esm({
   "src/commands/sync/upload.ts"() {
     "use strict";
+    init_dist();
     init_helpers();
   }
 });
@@ -417,7 +2345,6 @@ __export(download_exports, {
 });
 import chalk7 from "chalk";
 import inquirer4 from "inquirer";
-import { downloadFromCloud } from "@ccman/core";
 function downloadCommand(program2) {
   program2.command("download").description("\u4ECE\u4E91\u7AEF\u4E0B\u8F7D\u914D\u7F6E\u5230\u672C\u5730").action(async () => {
     try {
@@ -464,8 +2391,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(chalk7.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path3) => {
-          console.log(chalk7.gray(`  ${path3}`));
+        backupPaths.forEach((path12) => {
+          console.log(chalk7.gray(`  ${path12}`));
         });
         console.log();
       }
@@ -480,6 +2407,7 @@ function downloadCommand(program2) {
 var init_download = __esm({
   "src/commands/sync/download.ts"() {
     "use strict";
+    init_dist();
     init_helpers();
   }
 });
@@ -491,7 +2419,6 @@ __export(merge_exports, {
 });
 import chalk8 from "chalk";
 import inquirer5 from "inquirer";
-import { mergeSync } from "@ccman/core";
 function mergeCommand(program2) {
   program2.command("merge").description("\u667A\u80FD\u5408\u5E76\u672C\u5730\u548C\u4E91\u7AEF\u914D\u7F6E").action(async () => {
     try {
@@ -526,8 +2453,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(chalk8.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path3) => {
-          console.log(chalk8.gray(`  ${path3}`));
+        result.backupPaths.forEach((path12) => {
+          console.log(chalk8.gray(`  ${path12}`));
         });
         console.log();
       }
@@ -543,9 +2470,10 @@ function mergeCommand(program2) {
     }
   });
 }
-var init_merge = __esm({
+var init_merge2 = __esm({
   "src/commands/sync/merge.ts"() {
     "use strict";
+    init_dist();
     init_helpers();
   }
 });
@@ -556,7 +2484,6 @@ __export(status_exports, {
   statusCommand: () => statusCommand
 });
 import chalk9 from "chalk";
-import { createCodexManager as createCodexManager2, createClaudeManager as createClaudeManager2 } from "@ccman/core";
 function statusCommand(program2) {
   program2.command("status").description("\u67E5\u770B\u540C\u6B65\u72B6\u6001").action(async () => {
     try {
@@ -575,8 +2502,8 @@ function statusCommand(program2) {
       console.log(`  \u8BA4\u8BC1: ${chalk9.gray(config.authType === "password" ? "Basic Auth" : "Digest Auth")}`);
       console.log(`  \u540C\u6B65\u5BC6\u7801: ${config.syncPassword ? chalk9.green("\u2713 \u5DF2\u4FDD\u5B58") : chalk9.yellow("\u2717 \u672A\u4FDD\u5B58")}`);
       console.log();
-      const codexManager = createCodexManager2();
-      const claudeManager = createClaudeManager2();
+      const codexManager = createCodexManager();
+      const claudeManager = createClaudeManager();
       const codexProviders = codexManager.list();
       const claudeProviders = claudeManager.list();
       console.log(chalk9.bold("\u672C\u5730\u914D\u7F6E:"));
@@ -602,6 +2529,7 @@ function statusCommand(program2) {
 var init_status = __esm({
   "src/commands/sync/status.ts"() {
     "use strict";
+    init_dist();
     init_sync_config();
   }
 });
@@ -648,7 +2576,7 @@ async function startSyncMenu() {
     try {
       switch (action) {
         case "config": {
-          const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+          const { configCommand: configCommand2 } = await Promise.resolve().then(() => (init_config2(), config_exports));
           const cmd = new Command2();
           configCommand2(cmd);
           await cmd.parseAsync(["node", "ccman", "config"]);
@@ -676,7 +2604,7 @@ async function startSyncMenu() {
           break;
         }
         case "merge": {
-          const { mergeCommand: mergeCommand2 } = await Promise.resolve().then(() => (init_merge(), merge_exports));
+          const { mergeCommand: mergeCommand2 } = await Promise.resolve().then(() => (init_merge2(), merge_exports));
           const cmd = new Command2();
           mergeCommand2(cmd);
           await cmd.parseAsync(["node", "ccman", "merge"]);
@@ -707,11 +2635,11 @@ async function startSyncMenu() {
 var init_sync = __esm({
   "src/commands/sync/index.ts"() {
     "use strict";
-    init_config();
+    init_config2();
     init_test();
     init_upload();
     init_download();
-    init_merge();
+    init_merge2();
     init_status();
   }
 });
@@ -721,8 +2649,8 @@ import { Command as Command3 } from "commander";
 import chalk33 from "chalk";
 
 // src/utils/logo.ts
+init_dist();
 import chalk from "chalk";
-import { VERSION } from "@ccman/core";
 function printLogo() {
   console.log(
     chalk.bold(
@@ -742,19 +2670,14 @@ function printLogo() {
 }
 
 // src/commands/codex/add.ts
+init_dist();
 import chalk12 from "chalk";
 import inquirer8 from "inquirer";
-import {
-  createCodexManager as createCodexManager4,
-  CODEX_PRESETS,
-  getCodexConfigPath,
-  getCodexAuthPath
-} from "@ccman/core";
 
 // src/interactive.ts
+init_dist();
 import inquirer7 from "inquirer";
 import chalk11 from "chalk";
-import { createCodexManager as createCodexManager3, createClaudeManager as createClaudeManager3 } from "@ccman/core";
 
 // src/utils/format.ts
 import chalk2 from "chalk";
@@ -938,7 +2861,7 @@ async function showPresetsMenu() {
   console.log(chalk11.yellow("\n\u26A0\uFE0F  \u9884\u7F6E\u670D\u52A1\u5546\u7BA1\u7406\u529F\u80FD\u5373\u5C06\u63A8\u51FA\n"));
 }
 async function handleAdd(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const toolName = tool === "claude" ? "Claude" : "Codex";
   const presets = manager.listPresets();
   console.log(chalk11.bold(`
@@ -1044,7 +2967,7 @@ async function handleAdd(tool) {
   }
 }
 async function handleSwitch(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const providers = manager.list();
   const current = manager.getCurrent();
   if (providers.length === 0) {
@@ -1069,7 +2992,7 @@ async function handleSwitch(tool) {
 `));
 }
 async function handleList(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const providers = manager.list();
   const current = manager.getCurrent();
   const toolName = tool === "claude" ? "Claude" : "Codex";
@@ -1084,7 +3007,7 @@ async function handleList(tool) {
   console.log(formatProviderTable(providers, current?.id));
 }
 async function handleCurrent(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const current = manager.getCurrent();
   const toolName = tool === "claude" ? "Claude" : "Codex";
   if (!current) {
@@ -1105,7 +3028,7 @@ async function handleCurrent(tool) {
   console.log();
 }
 async function handleEdit(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const providers = manager.list();
   if (providers.length === 0) {
     console.log(chalk11.yellow("\n\u26A0\uFE0F  \u6682\u65E0\u670D\u52A1\u5546\n"));
@@ -1166,7 +3089,7 @@ async function handleEdit(tool) {
   console.log(chalk11.green("\n\u2705 \u7F16\u8F91\u6210\u529F\n"));
 }
 async function handleClone(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const providers = manager.list();
   if (providers.length === 0) {
     console.log(chalk11.yellow("\n\u26A0\uFE0F  \u6682\u65E0\u670D\u52A1\u5546\n"));
@@ -1213,7 +3136,7 @@ async function handleClone(tool) {
   console.log();
 }
 async function handleRemove(tool) {
-  const manager = tool === "codex" ? createCodexManager3() : createClaudeManager3();
+  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
   const providers = manager.list();
   if (providers.length === 0) {
     console.log(chalk11.yellow("\n\u26A0\uFE0F  \u6682\u65E0\u670D\u52A1\u5546\n"));
@@ -1253,7 +3176,7 @@ async function handleRemove(tool) {
 function addCommand(program2) {
   program2.command("add").description("\u6DFB\u52A0\u65B0\u7684 Codex \u670D\u52A1\u5546(\u4EA4\u4E92\u5F0F)").action(async () => {
     try {
-      const manager = createCodexManager4();
+      const manager = createCodexManager();
       console.log(chalk12.bold("\n\u{1F4DD} \u6DFB\u52A0 Codex \u670D\u52A1\u5546\n"));
       const { usePreset } = await inquirer8.prompt([
         {
@@ -1370,12 +3293,12 @@ function addCommand(program2) {
 }
 
 // src/commands/codex/list.ts
+init_dist();
 import chalk13 from "chalk";
-import { createCodexManager as createCodexManager5 } from "@ccman/core";
 function listCommand(program2) {
   program2.command("list").alias("ls").description("\u5217\u51FA\u6240\u6709 Codex \u670D\u52A1\u5546").action(async () => {
     try {
-      const manager = createCodexManager5();
+      const manager = createCodexManager();
       const providers = manager.list();
       const current = manager.getCurrent();
       if (providers.length === 0) {
@@ -1396,18 +3319,13 @@ function listCommand(program2) {
 }
 
 // src/commands/codex/use.ts
+init_dist();
 import chalk14 from "chalk";
 import inquirer9 from "inquirer";
-import {
-  createCodexManager as createCodexManager6,
-  ProviderNotFoundError,
-  getCodexConfigPath as getCodexConfigPath2,
-  getCodexAuthPath as getCodexAuthPath2
-} from "@ccman/core";
 function useCommand(program2) {
   program2.command("use [name]").description("\u5207\u6362 Codex \u670D\u52A1\u5546").action(async (name) => {
     try {
-      const manager = createCodexManager6();
+      const manager = createCodexManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk14.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Codex \u670D\u52A1\u5546\n"));
@@ -1444,8 +3362,8 @@ function useCommand(program2) {
       console.log(`  ${chalk14.gray(`URL: ${provider.baseUrl}`)}`);
       console.log();
       console.log(chalk14.gray("\u914D\u7F6E\u5DF2\u66F4\u65B0:"));
-      console.log(chalk14.gray(`  - ${getCodexConfigPath2()}`));
-      console.log(chalk14.gray(`  - ${getCodexAuthPath2()}`));
+      console.log(chalk14.gray(`  - ${getCodexConfigPath()}`));
+      console.log(chalk14.gray(`  - ${getCodexAuthPath()}`));
       console.log();
     } catch (error) {
       if (error instanceof ProviderNotFoundError) {
@@ -1464,12 +3382,12 @@ function useCommand(program2) {
 }
 
 // src/commands/codex/current.ts
+init_dist();
 import chalk15 from "chalk";
-import { createCodexManager as createCodexManager7 } from "@ccman/core";
 function currentCommand(program2) {
   program2.command("current").description("\u663E\u793A\u5F53\u524D\u4F7F\u7528\u7684 Codex \u670D\u52A1\u5546").action(async () => {
     try {
-      const manager = createCodexManager7();
+      const manager = createCodexManager();
       const current = manager.getCurrent();
       if (!current) {
         console.log(chalk15.yellow("\n\u26A0\uFE0F  \u672A\u9009\u62E9\u4EFB\u4F55 Codex \u670D\u52A1\u5546\n"));
@@ -1495,13 +3413,13 @@ function currentCommand(program2) {
 }
 
 // src/commands/codex/remove.ts
+init_dist();
 import chalk16 from "chalk";
 import inquirer10 from "inquirer";
-import { createCodexManager as createCodexManager8, ProviderNotFoundError as ProviderNotFoundError2 } from "@ccman/core";
 function removeCommand(program2) {
   program2.command("remove [name]").alias("rm").description("\u5220\u9664 Codex \u670D\u52A1\u5546").action(async (name) => {
     try {
-      const manager = createCodexManager8();
+      const manager = createCodexManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk16.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Codex \u670D\u52A1\u5546\n"));
@@ -1512,7 +3430,7 @@ function removeCommand(program2) {
       if (name) {
         const provider = manager.findByName(name);
         if (!provider) {
-          throw new ProviderNotFoundError2(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider.id;
         targetName = provider.name;
@@ -1549,7 +3467,7 @@ function removeCommand(program2) {
       console.log(chalk16.green(`\u2705 \u5DF2\u5220\u9664: ${targetName}`));
       console.log();
     } catch (error) {
-      if (error instanceof ProviderNotFoundError2) {
+      if (error instanceof ProviderNotFoundError) {
         console.error(chalk16.red(`
 \u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728
 `));
@@ -1565,13 +3483,13 @@ function removeCommand(program2) {
 }
 
 // src/commands/codex/edit.ts
+init_dist();
 import chalk17 from "chalk";
 import inquirer11 from "inquirer";
-import { createCodexManager as createCodexManager9, ProviderNotFoundError as ProviderNotFoundError3 } from "@ccman/core";
 function editCommand(program2) {
   program2.command("edit [name]").description("\u7F16\u8F91 Codex \u670D\u52A1\u5546").action(async (name) => {
     try {
-      const manager = createCodexManager9();
+      const manager = createCodexManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk17.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Codex \u670D\u52A1\u5546\n"));
@@ -1581,7 +3499,7 @@ function editCommand(program2) {
       if (name) {
         const provider2 = manager.findByName(name);
         if (!provider2) {
-          throw new ProviderNotFoundError3(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider2.id;
       } else {
@@ -1653,13 +3571,13 @@ function editCommand(program2) {
 }
 
 // src/commands/codex/clone.ts
+init_dist();
 import chalk18 from "chalk";
 import inquirer12 from "inquirer";
-import { createCodexManager as createCodexManager10, ProviderNotFoundError as ProviderNotFoundError4 } from "@ccman/core";
 function cloneCommand(program2) {
   program2.command("clone [source-name] [new-name]").description("\u514B\u9686 Codex \u670D\u52A1\u5546").action(async (sourceName, newName) => {
     try {
-      const manager = createCodexManager10();
+      const manager = createCodexManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk18.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Codex \u670D\u52A1\u5546\n"));
@@ -1669,7 +3587,7 @@ function cloneCommand(program2) {
       if (sourceName) {
         const provider = manager.findByName(sourceName);
         if (!provider) {
-          throw new ProviderNotFoundError4(sourceName);
+          throw new ProviderNotFoundError(sourceName);
         }
         sourceId = provider.id;
       } else {
@@ -1731,17 +3649,13 @@ function createCodexCommands(program2) {
 }
 
 // src/commands/claude/add.ts
+init_dist();
 import chalk19 from "chalk";
 import inquirer13 from "inquirer";
-import {
-  createClaudeManager as createClaudeManager4,
-  CC_PRESETS,
-  getClaudeConfigPath
-} from "@ccman/core";
 function addCommand2(program2) {
   program2.command("add").description("\u6DFB\u52A0\u65B0\u7684 Claude Code \u670D\u52A1\u5546(\u4EA4\u4E92\u5F0F)").action(async () => {
     try {
-      const manager = createClaudeManager4();
+      const manager = createClaudeManager();
       console.log(chalk19.bold("\n\u{1F4DD} \u6DFB\u52A0 Claude Code \u670D\u52A1\u5546\n"));
       const { usePreset } = await inquirer13.prompt([
         {
@@ -1857,12 +3771,12 @@ function addCommand2(program2) {
 }
 
 // src/commands/claude/list.ts
+init_dist();
 import chalk20 from "chalk";
-import { createClaudeManager as createClaudeManager5 } from "@ccman/core";
 function listCommand2(program2) {
   program2.command("list").alias("ls").description("\u5217\u51FA\u6240\u6709 Claude Code \u670D\u52A1\u5546").action(async () => {
     try {
-      const manager = createClaudeManager5();
+      const manager = createClaudeManager();
       const providers = manager.list();
       const current = manager.getCurrent();
       if (providers.length === 0) {
@@ -1883,17 +3797,13 @@ function listCommand2(program2) {
 }
 
 // src/commands/claude/use.ts
+init_dist();
 import chalk21 from "chalk";
 import inquirer14 from "inquirer";
-import {
-  createClaudeManager as createClaudeManager6,
-  ProviderNotFoundError as ProviderNotFoundError5,
-  getClaudeConfigPath as getClaudeConfigPath2
-} from "@ccman/core";
 function useCommand2(program2) {
   program2.command("use [name]").description("\u5207\u6362 Claude Code \u670D\u52A1\u5546").action(async (name) => {
     try {
-      const manager = createClaudeManager6();
+      const manager = createClaudeManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk21.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Claude Code \u670D\u52A1\u5546\n"));
@@ -1904,7 +3814,7 @@ function useCommand2(program2) {
       if (name) {
         const provider2 = manager.findByName(name);
         if (!provider2) {
-          throw new ProviderNotFoundError5(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider2.id;
       } else {
@@ -1930,10 +3840,10 @@ function useCommand2(program2) {
       console.log(`  ${chalk21.gray(`URL: ${provider.baseUrl}`)}`);
       console.log();
       console.log(chalk21.gray("\u914D\u7F6E\u5DF2\u66F4\u65B0:"));
-      console.log(chalk21.gray(`  - ${getClaudeConfigPath2()}`));
+      console.log(chalk21.gray(`  - ${getClaudeConfigPath()}`));
       console.log();
     } catch (error) {
-      if (error instanceof ProviderNotFoundError5) {
+      if (error instanceof ProviderNotFoundError) {
         console.error(chalk21.red(`
 \u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${error.message}
 `));
@@ -1949,12 +3859,12 @@ function useCommand2(program2) {
 }
 
 // src/commands/claude/current.ts
+init_dist();
 import chalk22 from "chalk";
-import { createClaudeManager as createClaudeManager7 } from "@ccman/core";
 function currentCommand2(program2) {
   program2.command("current").description("\u663E\u793A\u5F53\u524D\u4F7F\u7528\u7684 Claude Code \u670D\u52A1\u5546").action(async () => {
     try {
-      const manager = createClaudeManager7();
+      const manager = createClaudeManager();
       const current = manager.getCurrent();
       if (!current) {
         console.log(chalk22.yellow("\n\u26A0\uFE0F  \u672A\u9009\u62E9\u4EFB\u4F55 Claude Code \u670D\u52A1\u5546\n"));
@@ -1980,13 +3890,13 @@ function currentCommand2(program2) {
 }
 
 // src/commands/claude/remove.ts
+init_dist();
 import chalk23 from "chalk";
 import inquirer15 from "inquirer";
-import { createClaudeManager as createClaudeManager8, ProviderNotFoundError as ProviderNotFoundError6 } from "@ccman/core";
 function removeCommand2(program2) {
   program2.command("remove [name]").alias("rm").description("\u5220\u9664 Claude Code \u670D\u52A1\u5546").action(async (name) => {
     try {
-      const manager = createClaudeManager8();
+      const manager = createClaudeManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk23.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Claude Code \u670D\u52A1\u5546\n"));
@@ -1997,7 +3907,7 @@ function removeCommand2(program2) {
       if (name) {
         const provider = manager.findByName(name);
         if (!provider) {
-          throw new ProviderNotFoundError6(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider.id;
         targetName = provider.name;
@@ -2034,7 +3944,7 @@ function removeCommand2(program2) {
       console.log(chalk23.green(`\u2705 \u5DF2\u5220\u9664: ${targetName}`));
       console.log();
     } catch (error) {
-      if (error instanceof ProviderNotFoundError6) {
+      if (error instanceof ProviderNotFoundError) {
         console.error(chalk23.red(`
 \u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728
 `));
@@ -2050,13 +3960,13 @@ function removeCommand2(program2) {
 }
 
 // src/commands/claude/edit.ts
+init_dist();
 import chalk24 from "chalk";
 import inquirer16 from "inquirer";
-import { createClaudeManager as createClaudeManager9, ProviderNotFoundError as ProviderNotFoundError7 } from "@ccman/core";
 function editCommand2(program2) {
   program2.command("edit [name]").description("\u7F16\u8F91 Claude Code \u670D\u52A1\u5546").action(async (name) => {
     try {
-      const manager = createClaudeManager9();
+      const manager = createClaudeManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk24.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Claude Code \u670D\u52A1\u5546\n"));
@@ -2066,7 +3976,7 @@ function editCommand2(program2) {
       if (name) {
         const provider2 = manager.findByName(name);
         if (!provider2) {
-          throw new ProviderNotFoundError7(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider2.id;
       } else {
@@ -2138,13 +4048,13 @@ function editCommand2(program2) {
 }
 
 // src/commands/claude/clone.ts
+init_dist();
 import chalk25 from "chalk";
 import inquirer17 from "inquirer";
-import { createClaudeManager as createClaudeManager10, ProviderNotFoundError as ProviderNotFoundError8 } from "@ccman/core";
 function cloneCommand2(program2) {
   program2.command("clone [source-name] [new-name]").description("\u514B\u9686 Claude Code \u670D\u52A1\u5546").action(async (sourceName, newName) => {
     try {
-      const manager = createClaudeManager10();
+      const manager = createClaudeManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk25.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Claude Code \u670D\u52A1\u5546\n"));
@@ -2154,7 +4064,7 @@ function cloneCommand2(program2) {
       if (sourceName) {
         const provider = manager.findByName(sourceName);
         if (!provider) {
-          throw new ProviderNotFoundError8(sourceName);
+          throw new ProviderNotFoundError(sourceName);
         }
         sourceId = provider.id;
       } else {
@@ -2205,10 +4115,10 @@ function cloneCommand2(program2) {
 }
 
 // src/commands/clean.ts
+init_dist();
 import chalk26 from "chalk";
 import inquirer18 from "inquirer";
-import { analyzeClaudeJson, cleanClaudeJson, CleanPresets } from "@ccman/core";
-function formatBytes(bytes) {
+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`;
@@ -2231,9 +4141,9 @@ function displayAnalysis() {
     }
     console.log();
     console.log(chalk26.cyan("\u9884\u8BA1\u53EF\u8282\u7701\u7A7A\u95F4:"));
-    console.log(`  ${chalk26.green("\u4FDD\u5B88\u6E05\u7406")} (\u4FDD\u755910\u6761): ${chalk26.bold(formatBytes(analysis.estimatedSavings.conservative))}`);
-    console.log(`  ${chalk26.yellow("\u4E2D\u7B49\u6E05\u7406")} (\u4FDD\u75595\u6761):  ${chalk26.bold(formatBytes(analysis.estimatedSavings.moderate))}`);
-    console.log(`  ${chalk26.red("\u6FC0\u8FDB\u6E05\u7406")} (\u6E05\u7A7A\u5386\u53F2):  ${chalk26.bold(formatBytes(analysis.estimatedSavings.aggressive))}`);
+    console.log(`  ${chalk26.green("\u4FDD\u5B88\u6E05\u7406")} (\u4FDD\u755910\u6761): ${chalk26.bold(formatBytes2(analysis.estimatedSavings.conservative))}`);
+    console.log(`  ${chalk26.yellow("\u4E2D\u7B49\u6E05\u7406")} (\u4FDD\u75595\u6761):  ${chalk26.bold(formatBytes2(analysis.estimatedSavings.moderate))}`);
+    console.log(`  ${chalk26.red("\u6FC0\u8FDB\u6E05\u7406")} (\u6E05\u7A7A\u5386\u53F2):  ${chalk26.bold(formatBytes2(analysis.estimatedSavings.aggressive))}`);
     console.log();
     console.log(chalk26.blue(`\u{1F4A1} \u6267\u884C\u6E05\u7406: ccman cc clean
 `));
@@ -2278,9 +4188,9 @@ function cleanCommand(program2) {
       console.log(chalk26.cyan("\n\u6B63\u5728\u6E05\u7406...\n"));
       const result = cleanClaudeJson(cleanOptions);
       console.log(chalk26.green("\u2705 \u6E05\u7406\u5B8C\u6210\n"));
-      console.log(`\u6E05\u7406\u524D: ${chalk26.bold(formatBytes(result.sizeBefore))}`);
-      console.log(`\u6E05\u7406\u540E: ${chalk26.bold(formatBytes(result.sizeAfter))}`);
-      console.log(`\u8282\u7701\u7A7A\u95F4: ${chalk26.green.bold(formatBytes(result.saved))} (${(result.saved / result.sizeBefore * 100).toFixed(1)}%)`);
+      console.log(`\u6E05\u7406\u524D: ${chalk26.bold(formatBytes2(result.sizeBefore))}`);
+      console.log(`\u6E05\u7406\u540E: ${chalk26.bold(formatBytes2(result.sizeAfter))}`);
+      console.log(`\u8282\u7701\u7A7A\u95F4: ${chalk26.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: ${chalk26.bold(result.cleanedItems.projectHistory)} \u6761`);
@@ -2346,15 +4256,15 @@ async function promptForOptions(analysis) {
       message: "\u9009\u62E9\u6E05\u7406\u65B9\u6848:",
       choices: [
         {
-          name: `${chalk26.green("\u4FDD\u5B88\u6E05\u7406")} - \u4FDD\u7559\u6700\u8FD110\u6761\u8BB0\u5F55\uFF0C\u6E05\u7406\u7F13\u5B58 (\u8282\u7701\u7EA6 ${formatBytes(analysis.estimatedSavings.conservative)})`,
+          name: `${chalk26.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: `${chalk26.yellow("\u4E2D\u7B49\u6E05\u7406")} - \u4FDD\u7559\u6700\u8FD15\u6761\u8BB0\u5F55\uFF0C\u6E05\u7406\u7F13\u5B58\u548C\u7EDF\u8BA1 (\u8282\u7701\u7EA6 ${formatBytes(analysis.estimatedSavings.moderate)})`,
+          name: `${chalk26.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: `${chalk26.red("\u6FC0\u8FDB\u6E05\u7406")} - \u6E05\u7A7A\u5386\u53F2\u8BB0\u5F55\uFF0C\u6E05\u7406\u7F13\u5B58\u548C\u7EDF\u8BA1 (\u8282\u7701\u7EA6 ${formatBytes(analysis.estimatedSavings.aggressive)})`,
+          name: `${chalk26.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"
         },
         {
@@ -2422,9 +4332,9 @@ function createClaudeCommands(program2) {
 }
 
 // src/commands/mcp/add.ts
+init_dist();
 import chalk27 from "chalk";
 import inquirer19 from "inquirer";
-import { createMCPManager, MCP_PRESETS_DETAIL, getClaudeConfigPath as getClaudeConfigPath3 } from "@ccman/core";
 function addCommand3(program2) {
   program2.command("add").description("\u6DFB\u52A0\u65B0\u7684 MCP \u670D\u52A1\u5668(\u4EA4\u4E92\u5F0F)").action(async () => {
     try {
@@ -2571,7 +4481,7 @@ function addCommand3(program2) {
       console.log(chalk27.green("\u2705 \u914D\u7F6E\u5DF2\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
       console.log();
       console.log(chalk27.gray("\u914D\u7F6E\u6587\u4EF6:"));
-      console.log(chalk27.gray(`  - ${getClaudeConfigPath3()}`));
+      console.log(chalk27.gray(`  - ${getClaudeConfigPath()}`));
       console.log();
     } catch (error) {
       console.error(chalk27.red(`
@@ -2583,12 +4493,12 @@ function addCommand3(program2) {
 }
 
 // src/commands/mcp/list.ts
+init_dist();
 import chalk28 from "chalk";
-import { createMCPManager as createMCPManager2 } from "@ccman/core";
 function listCommand3(program2) {
   program2.command("list").alias("ls").description("\u5217\u51FA\u6240\u6709 MCP \u670D\u52A1\u5668").action(async () => {
     try {
-      const manager = createMCPManager2();
+      const manager = createMCPManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk28.yellow("\n\u26A0\uFE0F  \u6682\u65E0 MCP \u670D\u52A1\u5668\n"));
@@ -2629,13 +4539,13 @@ function listCommand3(program2) {
 }
 
 // src/commands/mcp/remove.ts
+init_dist();
 import chalk29 from "chalk";
 import inquirer20 from "inquirer";
-import { createMCPManager as createMCPManager3, ProviderNotFoundError as ProviderNotFoundError9, getClaudeConfigPath as getClaudeConfigPath4 } from "@ccman/core";
 function removeCommand3(program2) {
   program2.command("remove [name]").alias("rm").description("\u5220\u9664 MCP \u670D\u52A1\u5668").action(async (name) => {
     try {
-      const manager = createMCPManager3();
+      const manager = createMCPManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk29.yellow("\n\u26A0\uFE0F  \u6682\u65E0 MCP \u670D\u52A1\u5668\n"));
@@ -2646,7 +4556,7 @@ function removeCommand3(program2) {
       if (name) {
         const provider = manager.findByName(name);
         if (!provider) {
-          throw new ProviderNotFoundError9(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider.id;
         targetName = provider.name;
@@ -2685,10 +4595,10 @@ function removeCommand3(program2) {
       console.log(chalk29.green("\u2705 \u914D\u7F6E\u5DF2\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
       console.log();
       console.log(chalk29.gray("\u914D\u7F6E\u6587\u4EF6:"));
-      console.log(chalk29.gray(`  - ${getClaudeConfigPath4()}`));
+      console.log(chalk29.gray(`  - ${getClaudeConfigPath()}`));
       console.log();
     } catch (error) {
-      if (error instanceof ProviderNotFoundError9) {
+      if (error instanceof ProviderNotFoundError) {
         console.error(chalk29.red(`
 \u274C MCP \u670D\u52A1\u5668\u4E0D\u5B58\u5728
 `));
@@ -2704,13 +4614,13 @@ function removeCommand3(program2) {
 }
 
 // src/commands/mcp/edit.ts
+init_dist();
 import chalk30 from "chalk";
 import inquirer21 from "inquirer";
-import { createMCPManager as createMCPManager4, ProviderNotFoundError as ProviderNotFoundError10, getClaudeConfigPath as getClaudeConfigPath5 } from "@ccman/core";
 function editCommand3(program2) {
   program2.command("edit [name]").description("\u7F16\u8F91 MCP \u670D\u52A1\u5668").action(async (name) => {
     try {
-      const manager = createMCPManager4();
+      const manager = createMCPManager();
       const providers = manager.list();
       if (providers.length === 0) {
         console.log(chalk30.yellow("\n\u26A0\uFE0F  \u6682\u65E0 MCP \u670D\u52A1\u5668\n"));
@@ -2720,7 +4630,7 @@ function editCommand3(program2) {
       if (name) {
         const provider2 = manager.findByName(name);
         if (!provider2) {
-          throw new ProviderNotFoundError10(name);
+          throw new ProviderNotFoundError(name);
         }
         targetId = provider2.id;
       } else {
@@ -2803,7 +4713,7 @@ function editCommand3(program2) {
       console.log(chalk30.green("\u2705 \u914D\u7F6E\u5DF2\u81EA\u52A8\u540C\u6B65\u5230 ~/.claude.json"));
       console.log();
       console.log(chalk30.gray("\u914D\u7F6E\u6587\u4EF6:"));
-      console.log(chalk30.gray(`  - ${getClaudeConfigPath5()}`));
+      console.log(chalk30.gray(`  - ${getClaudeConfigPath()}`));
       console.log();
     } catch (error) {
       console.error(chalk30.red(`
@@ -2826,9 +4736,9 @@ function createMCPCommands(program2) {
 init_sync();
 
 // src/commands/export.ts
+init_dist();
 import chalk31 from "chalk";
-import path from "path";
-import { exportConfig, validateExport } from "@ccman/core";
+import path10 from "path";
 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 {
@@ -2839,7 +4749,7 @@ function exportCommand(program2) {
 `));
         process.exit(1);
       }
-      const resolvedPath = targetDir.startsWith("~") ? path.join(process.env.HOME || "", targetDir.slice(1)) : path.resolve(targetDir);
+      const resolvedPath = targetDir.startsWith("~") ? path10.join(process.env.HOME || "", targetDir.slice(1)) : path10.resolve(targetDir);
       console.log("\u5BFC\u51FA\u6587\u4EF6:");
       console.log(`  ${chalk31.cyan("codex.json")}  - Codex \u914D\u7F6E`);
       console.log(`  ${chalk31.cyan("claude.json")} - Claude \u914D\u7F6E`);
@@ -2868,14 +4778,14 @@ function exportCommand(program2) {
 }
 
 // src/commands/import.ts
+init_dist();
 import chalk32 from "chalk";
 import inquirer22 from "inquirer";
-import path2 from "path";
-import { importConfig, validateImportDir } from "@ccman/core";
+import path11 from "path";
 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("~") ? path2.join(process.env.HOME || "", sourceDir.slice(1)) : path2.resolve(sourceDir);
+      const resolvedPath = sourceDir.startsWith("~") ? path11.join(process.env.HOME || "", sourceDir.slice(1)) : path11.resolve(sourceDir);
       console.log(chalk32.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {
@@ -2950,7 +4860,7 @@ function importCommand(program2) {
 }
 
 // src/index.ts
-import { getCcmanDir, getCodexDir, getClaudeDir, VERSION as VERSION2 } from "@ccman/core";
+init_dist();
 if (process.env.NODE_ENV === "development") {
   console.log(chalk33.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
   console.log(chalk33.gray(`  ccman: ${getCcmanDir()}`));
@@ -2959,7 +4869,7 @@ if (process.env.NODE_ENV === "development") {
   console.log();
 }
 var program = new Command3();
-program.name("ccman").description("Codex/Claude Code API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177").version(VERSION2).showHelpAfterError(false).exitOverride((err) => {
+program.name("ccman").description("Codex/Claude Code API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177").version(VERSION).showHelpAfterError(false).exitOverride((err) => {
   if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
     process.exit(0);
   }