ccman 3.0.17 → 3.0.19

package/dist/index.js

@@ -39,7 +39,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.0.17",
+      version: "3.0.19",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -2163,37 +2163,55 @@ var require_toml = __commonJS({
   }
 });
 
+// ../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
 function writeCodexConfig(provider) {
   ensureDir(getCodexDir());
   const configPath = getCodexConfigPath();
-  let config;
+  let userConfig = {};
   if (fileExists(configPath)) {
     const content = fs2.readFileSync(configPath, "utf-8");
-    config = (0, import_toml.parse)(content);
-  } else {
-    config = {};
+    userConfig = (0, import_toml.parse)(content);
   }
-  config.model_provider = provider.name;
-  config.model_providers = config.model_providers || {};
-  config.model_providers[provider.name] = {
+  const mergedConfig = deepMerge(CODEX_DEFAULT_CONFIG, 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
-    // 固定值
   };
-  if (!config.model) {
-    config.model = "gpt-5";
-  }
-  if (!config.model_reasoning_effort) {
-    config.model_reasoning_effort = "high";
-  }
-  if (!("disable_response_storage" in config)) {
-    config.disable_response_storage = true;
-  }
-  fs2.writeFileSync(configPath, (0, import_toml.stringify)(config), { mode: 384 });
+  fs2.writeFileSync(configPath, (0, import_toml.stringify)(mergedConfig), { mode: 384 });
   const authPath = getCodexAuthPath();
   let auth;
   if (fileExists(authPath)) {
@@ -2205,7 +2223,7 @@ function writeCodexConfig(provider) {
   auth.OPENAI_API_KEY = provider.apiKey;
   fs2.writeFileSync(authPath, JSON.stringify(auth, null, 2), { mode: 384 });
 }
-var fs2, import_toml;
+var fs2, import_toml, CODEX_DEFAULT_CONFIG;
 var init_codex = __esm({
   "../core/dist/writers/codex.js"() {
     "use strict";
@@ -2213,6 +2231,29 @@ var init_codex = __esm({
     import_toml = __toESM(require_toml(), 1);
     init_paths();
     init_file();
+    init_template();
+    CODEX_DEFAULT_CONFIG = {
+      model_reasoning_effort: "high",
+      disable_response_storage: true,
+      sandbox_mode: "workspace-write",
+      windows_wsl_setup_acknowledged: true,
+      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
+      },
+      tools: {
+        web_search: true,
+        view_image: true
+      },
+      sandbox_workspace_write: {
+        network_access: true
+      }
+    };
   }
 });
 
@@ -2220,42 +2261,38 @@ var init_codex = __esm({
 function writeClaudeConfig(provider) {
   ensureDir(getClaudeDir());
   const configPath = getClaudeConfigPath();
-  let settings;
+  let userConfig = {};
   if (fileExists(configPath)) {
     const content = fs3.readFileSync(configPath, "utf-8");
-    settings = JSON.parse(content);
-  } else {
-    settings = {};
-  }
-  if (!settings.env) {
-    settings.env = {};
-  }
-  settings.env.ANTHROPIC_AUTH_TOKEN = provider.apiKey;
-  settings.env.ANTHROPIC_BASE_URL = provider.baseUrl;
-  if (!("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC" in settings.env)) {
-    settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = 1;
-  }
-  if (!("CLAUDE_CODE_MAX_OUTPUT_TOKENS" in settings.env)) {
-    settings.env.CLAUDE_CODE_MAX_OUTPUT_TOKENS = 32e3;
+    userConfig = JSON.parse(content);
   }
-  if (!settings.permissions) {
-    settings.permissions = { allow: [], deny: [] };
-  }
-  if (!settings.permissions.allow) {
-    settings.permissions.allow = [];
-  }
-  if (!settings.permissions.deny) {
-    settings.permissions.deny = [];
-  }
-  fs3.writeFileSync(configPath, JSON.stringify(settings, null, 2), { mode: 384 });
+  const defaultConfig = replaceVariables(CLAUDE_CONFIG_TEMPLATE, {
+    apiKey: provider.apiKey,
+    baseUrl: provider.baseUrl
+  });
+  const mergedConfig = deepMerge(defaultConfig, userConfig);
+  fs3.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), { mode: 384 });
 }
-var fs3;
+var fs3, CLAUDE_CONFIG_TEMPLATE;
 var init_claude = __esm({
   "../core/dist/writers/claude.js"() {
     "use strict";
     fs3 = __toESM(require("fs"), 1);
     init_paths();
     init_file();
+    init_template();
+    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: []
+      }
+    };
   }
 });
 
@@ -2342,8 +2379,8 @@ function createCodexManager() {
       ensureDir(getCcmanDir());
       const initialConfig = {
         providers: [],
-        presets: [...CODEX_PRESETS]
-        // 初始化内置预置到配置文件
+        presets: []
+        // 只存储用户自定义预置
       };
       writeJSON(configPath, initialConfig);
       return initialConfig;
@@ -2366,6 +2403,8 @@ function createCodexManager() {
         name: input.name,
         baseUrl: input.baseUrl,
         apiKey: input.apiKey,
+        model: input.model,
+        // 保存 model 字段
         createdAt: timestamp,
         lastModified: timestamp
       };
@@ -2387,7 +2426,8 @@ function createCodexManager() {
     },
     findByName(name) {
       const config = loadConfig2();
-      return config.providers.find((p) => p.name === name);
+      const lowerName = name.toLowerCase();
+      return config.providers.find((p) => p.name.toLowerCase() === lowerName);
     },
     switch(id) {
       const config = loadConfig2();
@@ -2426,6 +2466,8 @@ function createCodexManager() {
         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) {
@@ -2535,8 +2577,8 @@ function createClaudeManager() {
       ensureDir(getCcmanDir());
       const initialConfig = {
         providers: [],
-        presets: [...CC_PRESETS]
-        // 初始化内置预置到配置文件
+        presets: []
+        // 只存储用户自定义预置
       };
       writeJSON(configPath, initialConfig);
       return initialConfig;
@@ -2580,7 +2622,8 @@ function createClaudeManager() {
     },
     findByName(name) {
       const config = loadConfig2();
-      return config.providers.find((p) => p.name === name);
+      const lowerName = name.toLowerCase();
+      return config.providers.find((p) => p.name.toLowerCase() === lowerName);
     },
     switch(id) {
       const config = loadConfig2();
@@ -3001,22 +3044,22 @@ var require_url_parse = __commonJS({
     }
     function resolve(relative, base) {
       if (relative === "") return base;
-      var path11 = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i2 = path11.length, last = path11[i2 - 1], unshift = false, up = 0;
+      var path12 = (base || "/").split("/").slice(0, -1).concat(relative.split("/")), i2 = path12.length, last = path12[i2 - 1], unshift = false, up = 0;
       while (i2--) {
-        if (path11[i2] === ".") {
-          path11.splice(i2, 1);
-        } else if (path11[i2] === "..") {
-          path11.splice(i2, 1);
+        if (path12[i2] === ".") {
+          path12.splice(i2, 1);
+        } else if (path12[i2] === "..") {
+          path12.splice(i2, 1);
           up++;
         } else if (up) {
           if (i2 === 0) unshift = true;
-          path11.splice(i2, 1);
+          path12.splice(i2, 1);
           up--;
         }
       }
-      if (unshift) path11.unshift("");
-      if (last === "." || last === "..") path11.push("");
-      return path11.join("/");
+      if (unshift) path12.unshift("");
+      if (last === "." || last === "..") path12.push("");
+      return path12.join("/");
     }
     function Url(address, location, parser) {
       address = trimLeft(address);
@@ -3442,14 +3485,14 @@ var require_path_posix = __commonJS({
     posix.resolve = function() {
       var resolvedPath = "", resolvedAbsolute = false;
       for (var i2 = arguments.length - 1; i2 >= -1 && !resolvedAbsolute; i2--) {
-        var path11 = i2 >= 0 ? arguments[i2] : process.cwd();
-        if (!isString(path11)) {
+        var path12 = i2 >= 0 ? arguments[i2] : process.cwd();
+        if (!isString(path12)) {
           throw new TypeError("Arguments to path.resolve must be strings");
-        } else if (!path11) {
+        } else if (!path12) {
           continue;
         }
-        resolvedPath = path11 + "/" + resolvedPath;
-        resolvedAbsolute = path11.charAt(0) === "/";
+        resolvedPath = path12 + "/" + resolvedPath;
+        resolvedAbsolute = path12.charAt(0) === "/";
       }
       resolvedPath = normalizeArray(
         resolvedPath.split("/"),
@@ -3457,36 +3500,36 @@ var require_path_posix = __commonJS({
       ).join("/");
       return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
     };
-    posix.normalize = function(path11) {
-      var isAbsolute = posix.isAbsolute(path11), trailingSlash = path11.substr(-1) === "/";
-      path11 = normalizeArray(path11.split("/"), !isAbsolute).join("/");
-      if (!path11 && !isAbsolute) {
-        path11 = ".";
+    posix.normalize = function(path12) {
+      var isAbsolute = posix.isAbsolute(path12), trailingSlash = path12.substr(-1) === "/";
+      path12 = normalizeArray(path12.split("/"), !isAbsolute).join("/");
+      if (!path12 && !isAbsolute) {
+        path12 = ".";
       }
-      if (path11 && trailingSlash) {
-        path11 += "/";
+      if (path12 && trailingSlash) {
+        path12 += "/";
       }
-      return (isAbsolute ? "/" : "") + path11;
+      return (isAbsolute ? "/" : "") + path12;
     };
-    posix.isAbsolute = function(path11) {
-      return path11.charAt(0) === "/";
+    posix.isAbsolute = function(path12) {
+      return path12.charAt(0) === "/";
     };
     posix.join = function() {
-      var path11 = "";
+      var path12 = "";
       for (var i2 = 0; i2 < arguments.length; i2++) {
         var segment = arguments[i2];
         if (!isString(segment)) {
           throw new TypeError("Arguments to path.join must be strings");
         }
         if (segment) {
-          if (!path11) {
-            path11 += segment;
+          if (!path12) {
+            path12 += segment;
           } else {
-            path11 += "/" + segment;
+            path12 += "/" + segment;
           }
         }
       }
-      return posix.normalize(path11);
+      return posix.normalize(path12);
     };
     posix.relative = function(from, to) {
       from = posix.resolve(from).substr(1);
@@ -3520,11 +3563,11 @@ var require_path_posix = __commonJS({
       outputParts = outputParts.concat(toParts.slice(samePartsLength));
       return outputParts.join("/");
     };
-    posix._makeLong = function(path11) {
-      return path11;
+    posix._makeLong = function(path12) {
+      return path12;
     };
-    posix.dirname = function(path11) {
-      var result = posixSplitPath(path11), root = result[0], dir = result[1];
+    posix.dirname = function(path12) {
+      var result = posixSplitPath(path12), root = result[0], dir = result[1];
       if (!root && !dir) {
         return ".";
       }
@@ -3533,15 +3576,15 @@ var require_path_posix = __commonJS({
       }
       return root + dir;
     };
-    posix.basename = function(path11, ext2) {
-      var f3 = posixSplitPath(path11)[2];
+    posix.basename = function(path12, ext2) {
+      var f3 = posixSplitPath(path12)[2];
       if (ext2 && f3.substr(-1 * ext2.length) === ext2) {
         f3 = f3.substr(0, f3.length - ext2.length);
       }
       return f3;
     };
-    posix.extname = function(path11) {
-      return posixSplitPath(path11)[3];
+    posix.extname = function(path12) {
+      return posixSplitPath(path12)[3];
     };
     posix.format = function(pathObject) {
       if (!util.isObject(pathObject)) {
@@ -14939,10 +14982,10 @@ var require_nested_property = __commonJS({
         return false;
       }
     }
-    function traverse(object, path11) {
+    function traverse(object, path12) {
       var callback = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : function() {
       };
-      var segments = path11.split(PATH_DELIMITER);
+      var segments = path12.split(PATH_DELIMITER);
       var length = segments.length;
       var _loop = function _loop2(idx2) {
         var currentSegment = segments[idx2];
@@ -15184,11 +15227,11 @@ async function createDirectory(context, dirPath, options = {}) {
   const response = await request(requestOptions, context);
   handleResponseCode(context, response);
 }
-function ensureCollectionPath(path11) {
-  if (!path11.endsWith("/")) {
-    return path11 + "/";
+function ensureCollectionPath(path12) {
+  if (!path12.endsWith("/")) {
+    return path12 + "/";
   }
-  return path11;
+  return path12;
 }
 async function createDirectoryRecursively(context, dirPath, options = {}) {
   const paths = getAllDirectories(normalisePath(dirPath));
@@ -15563,7 +15606,7 @@ var init_xml = __esm({
 });
 
 // ../../node_modules/.pnpm/webdav@5.8.0/node_modules/webdav/dist/node/operations/lock.js
-async function lock(context, path11, options = {}) {
+async function lock(context, path12, options = {}) {
   const { refreshToken, timeout = DEFAULT_TIMEOUT } = options;
   const headers = {
     Accept: "text/plain,application/xml",
@@ -15573,7 +15616,7 @@ async function lock(context, path11, options = {}) {
     headers.If = refreshToken;
   }
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, encodePath(path11)),
+    url: joinURL(context.remoteURL, encodePath(path12)),
     method: "LOCK",
     headers,
     data: generateLockXML(context.contactHref)
@@ -15593,9 +15636,9 @@ async function lock(context, path11, options = {}) {
     serverTimeout
   };
 }
-async function unlock(context, path11, token, options = {}) {
+async function unlock(context, path12, token, options = {}) {
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, encodePath(path11)),
+    url: joinURL(context.remoteURL, encodePath(path12)),
     method: "UNLOCK",
     headers: {
       "Lock-Token": token
@@ -15645,9 +15688,9 @@ var init_quota = __esm({
 
 // ../../node_modules/.pnpm/webdav@5.8.0/node_modules/webdav/dist/node/operations/getQuota.js
 async function getQuota(context, options = {}) {
-  const path11 = options.path || "/";
+  const path12 = options.path || "/";
   const requestOptions = prepareRequestOptions({
-    url: joinURL(context.remoteURL, path11),
+    url: joinURL(context.remoteURL, path12),
     method: "PROPFIND",
     headers: {
       Accept: "text/plain,application/xml",
@@ -15987,29 +16030,29 @@ function createClient(remoteURL, options = {}) {
   setupAuth(context, username, password, token, ha1);
   return {
     copyFile: (filename, destination, options2) => copyFile(context, filename, destination, options2),
-    createDirectory: (path11, options2) => createDirectory(context, path11, options2),
+    createDirectory: (path12, options2) => createDirectory(context, path12, options2),
     createReadStream: (filename, options2) => createReadStream2(context, filename, options2),
     createWriteStream: (filename, options2, callback) => createWriteStream(context, filename, options2, callback),
-    customRequest: (path11, requestOptions) => customRequest(context, path11, requestOptions),
+    customRequest: (path12, requestOptions) => customRequest(context, path12, requestOptions),
     deleteFile: (filename, options2) => deleteFile(context, filename, options2),
-    exists: (path11, options2) => exists(context, path11, options2),
-    getDirectoryContents: (path11, options2) => getDirectoryContents(context, path11, options2),
+    exists: (path12, options2) => exists(context, path12, options2),
+    getDirectoryContents: (path12, options2) => getDirectoryContents(context, path12, options2),
     getFileContents: (filename, options2) => getFileContents(context, filename, options2),
     getFileDownloadLink: (filename) => getFileDownloadLink(context, filename),
     getFileUploadLink: (filename) => getFileUploadLink(context, filename),
     getHeaders: () => Object.assign({}, context.headers),
     getQuota: (options2) => getQuota(context, options2),
-    lock: (path11, options2) => lock(context, path11, options2),
+    lock: (path12, options2) => lock(context, path12, options2),
     moveFile: (filename, destinationFilename, options2) => moveFile(context, filename, destinationFilename, options2),
     putFileContents: (filename, data, options2) => putFileContents(context, filename, data, options2),
     partialUpdateFileContents: (filePath, start, end, data, options2) => partialUpdateFileContents(context, filePath, start, end, data, options2),
-    getDAVCompliance: (path11) => getDAVCompliance(context, path11),
-    search: (path11, options2) => getSearch2(context, path11, options2),
+    getDAVCompliance: (path12) => getDAVCompliance(context, path12),
+    search: (path12, options2) => getSearch2(context, path12, options2),
     setHeaders: (headers2) => {
       context.headers = Object.assign({}, headers2);
     },
-    stat: (path11, options2) => getStat(context, path11, options2),
-    unlock: (path11, token2, options2) => unlock(context, path11, token2, options2)
+    stat: (path12, options2) => getStat(context, path12, options2),
+    unlock: (path12, token2, options2) => unlock(context, path12, token2, options2)
   };
 }
 var DEFAULT_CONTACT_HREF;
@@ -16182,20 +16225,52 @@ var init_webdav_client = __esm({
 });
 
 // ../core/dist/sync/merge.js
-function backupConfig(configPath) {
+function backupConfig(configPath, keepCount = 3) {
   if (!import_fs.default.existsSync(configPath)) {
     throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}`);
   }
   const timestamp = Date.now();
   const backupPath = `${configPath}.backup.${timestamp}`;
   import_fs.default.copyFileSync(configPath, backupPath);
+  cleanupOldBackups(configPath, keepCount);
   return backupPath;
 }
-var import_fs;
+function cleanupOldBackups(configPath, keepCount) {
+  const dir = import_path17.default.dirname(configPath);
+  const basename2 = import_path17.default.basename(configPath);
+  const backupPrefix = `${basename2}.backup.`;
+  try {
+    const files = import_fs.default.readdirSync(dir);
+    const backups = files.filter((f3) => f3.startsWith(backupPrefix)).map((f3) => {
+      const timestampStr = f3.substring(backupPrefix.length);
+      const timestamp = parseInt(timestampStr, 10);
+      if (isNaN(timestamp)) {
+        return null;
+      }
+      return {
+        name: f3,
+        path: import_path17.default.join(dir, f3),
+        timestamp
+      };
+    }).filter((backup) => backup !== null).sort((a, b) => b.timestamp - a.timestamp);
+    const toDelete = backups.slice(keepCount);
+    for (const backup of toDelete) {
+      try {
+        import_fs.default.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 import_fs, import_path17;
 var init_merge2 = __esm({
   "../core/dist/sync/merge.js"() {
     "use strict";
     import_fs = __toESM(require("fs"), 1);
+    import_path17 = __toESM(require("path"), 1);
   }
 });
 
@@ -16372,8 +16447,8 @@ var init_merge_advanced = __esm({
 // ../core/dist/sync/sync-v2.js
 async function uploadToCloud(config, password) {
   const ccmanDir2 = getCcmanDir();
-  const codexConfigPath = import_path17.default.join(ccmanDir2, "codex.json");
-  const claudeConfigPath = import_path17.default.join(ccmanDir2, "claude.json");
+  const codexConfigPath = import_path18.default.join(ccmanDir2, "codex.json");
+  const claudeConfigPath = import_path18.default.join(ccmanDir2, "claude.json");
   const codexConfig = readJSON(codexConfigPath);
   const claudeConfig = readJSON(claudeConfigPath);
   const encryptedCodexProviders = encryptProviders(codexConfig.providers, password);
@@ -16416,8 +16491,8 @@ async function downloadFromCloud(config, password) {
   }
   const backupPaths = [];
   const ccmanDir2 = getCcmanDir();
-  const codexConfigPath = import_path17.default.join(ccmanDir2, "codex.json");
-  const claudeConfigPath = import_path17.default.join(ccmanDir2, "claude.json");
+  const codexConfigPath = import_path18.default.join(ccmanDir2, "codex.json");
+  const claudeConfigPath = import_path18.default.join(ccmanDir2, "claude.json");
   try {
     if (import_fs2.default.existsSync(codexConfigPath)) {
       backupPaths.push(backupConfig(codexConfigPath));
@@ -16439,6 +16514,7 @@ async function downloadFromCloud(config, password) {
         // 保留本地 presets
       };
       writeJSON(codexConfigPath, newCodexConfig);
+      applyCurrentProvider("codex", newCodexConfig);
     }
     if (remoteClaudeConfig && decryptedClaudeProviders) {
       const newClaudeConfig = {
@@ -16448,8 +16524,9 @@ async function downloadFromCloud(config, password) {
         // 保留本地 presets
       };
       writeJSON(claudeConfigPath, newClaudeConfig);
+      applyCurrentProvider("claude", newClaudeConfig);
     }
-    console.log("\u2705 \u914D\u7F6E\u5DF2\u4ECE\u4E91\u7AEF\u4E0B\u8F7D\u5E76\u8986\u76D6\u672C\u5730");
+    console.log("\u2705 \u914D\u7F6E\u5DF2\u4ECE\u4E91\u7AEF\u4E0B\u8F7D\u5E76\u5E94\u7528");
     return backupPaths;
   } catch (error) {
     for (const backupPath of backupPaths) {
@@ -16489,8 +16566,8 @@ async function mergeSync(config, password) {
     throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
   }
   const ccmanDir2 = getCcmanDir();
-  const codexConfigPath = import_path17.default.join(ccmanDir2, "codex.json");
-  const claudeConfigPath = import_path17.default.join(ccmanDir2, "claude.json");
+  const codexConfigPath = import_path18.default.join(ccmanDir2, "codex.json");
+  const claudeConfigPath = import_path18.default.join(ccmanDir2, "claude.json");
   const localCodexConfig = readJSON(codexConfigPath);
   const localClaudeConfig = readJSON(claudeConfigPath);
   const codexMergeResult = mergeProviders(localCodexConfig.providers, remoteCodexProviders);
@@ -16527,6 +16604,8 @@ async function mergeSync(config, password) {
     };
     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 = {
@@ -16556,18 +16635,34 @@ async function mergeSync(config, password) {
     throw new Error(`\u5408\u5E76\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
   }
 }
-var import_fs2, import_path17, CODEX_REMOTE_PATH, CLAUDE_REMOTE_PATH;
+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 import_fs2, import_path18, CODEX_REMOTE_PATH, CLAUDE_REMOTE_PATH;
 var init_sync_v2 = __esm({
   "../core/dist/sync/sync-v2.js"() {
     "use strict";
     import_fs2 = __toESM(require("fs"), 1);
-    import_path17 = __toESM(require("path"), 1);
+    import_path18 = __toESM(require("path"), 1);
     init_webdav_client();
     init_crypto2();
     init_merge_advanced();
     init_merge2();
     init_paths();
     init_file();
+    init_codex();
+    init_claude();
     CODEX_REMOTE_PATH = ".ccman/codex.json";
     CLAUDE_REMOTE_PATH = ".ccman/claude.json";
   }
@@ -16576,8 +16671,8 @@ var init_sync_v2 = __esm({
 // ../core/dist/export.js
 function validateExport() {
   const ccmanDir2 = getCcmanDir();
-  const codexPath = path8.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const claudePath = path8.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  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);
@@ -16610,8 +16705,8 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const codexPath = path8.join(sourceDir, CODEX_CONFIG_FILE);
-  const claudePath = path8.join(sourceDir, CLAUDE_CONFIG_FILE);
+  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);
@@ -16639,14 +16734,14 @@ function exportConfig(targetDir) {
   ensureDir(targetDir);
   const ccmanDir2 = getCcmanDir();
   const exportedFiles = [];
-  const codexSrc = path8.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const codexDst = path8.join(targetDir, CODEX_CONFIG_FILE);
+  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 = path8.join(ccmanDir2, CLAUDE_CONFIG_FILE);
-  const claudeDst = path8.join(targetDir, CLAUDE_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);
@@ -16668,22 +16763,22 @@ function importConfig(sourceDir) {
   ensureDir(ccmanDir2);
   try {
     if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
-      const codexDst = path8.join(ccmanDir2, CODEX_CONFIG_FILE);
+      const codexDst = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
       if (fileExists(codexDst)) {
         const backupPath = backupConfig(codexDst);
         backupPaths.push(backupPath);
       }
-      const codexSrc = path8.join(sourceDir, CODEX_CONFIG_FILE);
+      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 = path8.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+      const claudeDst = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
       if (fileExists(claudeDst)) {
         const backupPath = backupConfig(claudeDst);
         backupPaths.push(backupPath);
       }
-      const claudeSrc = path8.join(sourceDir, CLAUDE_CONFIG_FILE);
+      const claudeSrc = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
       fs8.copyFileSync(claudeSrc, claudeDst);
       importedFiles.push(CLAUDE_CONFIG_FILE);
     }
@@ -16702,12 +16797,12 @@ function importConfig(sourceDir) {
     throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
   }
 }
-var fs8, path8, CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
+var fs8, path9, CODEX_CONFIG_FILE, CLAUDE_CONFIG_FILE;
 var init_export = __esm({
   "../core/dist/export.js"() {
     "use strict";
     fs8 = __toESM(require("fs"), 1);
-    path8 = __toESM(require("path"), 1);
+    path9 = __toESM(require("path"), 1);
     init_paths();
     init_file();
     init_merge2();
@@ -17185,8 +17280,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(import_chalk6.default.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path11) => {
-          console.log(import_chalk6.default.gray(`  ${path11}`));
+        backupPaths.forEach((path12) => {
+          console.log(import_chalk6.default.gray(`  ${path12}`));
         });
         console.log();
       }
@@ -17250,8 +17345,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(import_chalk7.default.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path11) => {
-          console.log(import_chalk7.default.gray(`  ${path11}`));
+        result.backupPaths.forEach((path12) => {
+          console.log(import_chalk7.default.gray(`  ${path12}`));
         });
         console.log();
       }
@@ -17454,6 +17549,7 @@ var import_chalk27 = __toESM(require("chalk"));
 
 // src/utils/logo.ts
 var import_chalk = __toESM(require("chalk"));
+init_dist4();
 function printLogo() {
   console.log(
     import_chalk.default.bold(
@@ -17467,7 +17563,9 @@ function printLogo() {
 `
     )
   );
-  console.log(import_chalk.default.gray("  Codex/Claude Code API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177\n"));
+  console.log(import_chalk.default.gray("  Codex/Claude Code API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177"));
+  console.log(import_chalk.default.gray(`  \u7248\u672C ${VERSION}
+`));
 }
 
 // src/commands/codex/add.ts
@@ -18893,7 +18991,7 @@ init_sync2();
 
 // src/commands/export.ts
 var import_chalk25 = __toESM(require("chalk"));
-var import_path18 = __toESM(require("path"));
+var import_path19 = __toESM(require("path"));
 init_dist4();
 function exportCommand(program2) {
   program2.command("export <\u76EE\u6807\u76EE\u5F55>").description("\u5BFC\u51FA\u914D\u7F6E\u5230\u672C\u5730\u76EE\u5F55\uFF08\u5305\u542B API Key\uFF09").action(async (targetDir) => {
@@ -18905,7 +19003,7 @@ function exportCommand(program2) {
 `));
         process.exit(1);
       }
-      const resolvedPath = targetDir.startsWith("~") ? import_path18.default.join(process.env.HOME || "", targetDir.slice(1)) : import_path18.default.resolve(targetDir);
+      const resolvedPath = targetDir.startsWith("~") ? import_path19.default.join(process.env.HOME || "", targetDir.slice(1)) : import_path19.default.resolve(targetDir);
       console.log("\u5BFC\u51FA\u6587\u4EF6:");
       console.log(`  ${import_chalk25.default.cyan("codex.json")}  - Codex \u914D\u7F6E`);
       console.log(`  ${import_chalk25.default.cyan("claude.json")} - Claude \u914D\u7F6E`);
@@ -18936,12 +19034,12 @@ function exportCommand(program2) {
 // src/commands/import.ts
 var import_chalk26 = __toESM(require("chalk"));
 var import_inquirer17 = __toESM(require("inquirer"));
-var import_path19 = __toESM(require("path"));
+var import_path20 = __toESM(require("path"));
 init_dist4();
 function importCommand(program2) {
   program2.command("import <\u6E90\u76EE\u5F55>").description("\u4ECE\u672C\u5730\u76EE\u5F55\u5BFC\u5165\u914D\u7F6E\uFF08\u4F1A\u8986\u76D6\u5F53\u524D\u914D\u7F6E\uFF09").action(async (sourceDir) => {
     try {
-      const resolvedPath = sourceDir.startsWith("~") ? import_path19.default.join(process.env.HOME || "", sourceDir.slice(1)) : import_path19.default.resolve(sourceDir);
+      const resolvedPath = sourceDir.startsWith("~") ? import_path20.default.join(process.env.HOME || "", sourceDir.slice(1)) : import_path20.default.resolve(sourceDir);
       console.log(import_chalk26.default.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccman",
-  "version": "3.0.17",
+  "version": "3.0.19",
   "description": "Manage Codex and Claude Code API service provider configurations",
   "main": "./dist/index.js",
   "bin": {