ccman 3.0.16 → 3.0.18

package/dist/index.js

@@ -39,7 +39,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.0.16",
+      version: "3.0.18",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -3001,22 +3001,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 +3442,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 +3457,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 +3520,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 +3533,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 +14939,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 +15184,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 +15563,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 +15573,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 +15593,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 +15645,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 +15987,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;
@@ -16083,32 +16083,10 @@ function createWebDAVClient(config) {
 async function testWebDAVConnection(config) {
   try {
     const client = createWebDAVClient(config);
-    try {
-      await client.exists("/");
-      return true;
-    } catch (error1) {
-      console.log("\u65B9\u6CD51\u5931\u8D25\uFF0C\u5C1D\u8BD5\u65B9\u6CD52:", error1);
-      try {
-        await client.getDirectoryContents("/");
-        return true;
-      } catch (error2) {
-        console.log("\u65B9\u6CD52\u5931\u8D25\uFF0C\u5C1D\u8BD5\u65B9\u6CD53:", error2);
-        try {
-          const testDir = "/.ccman-test";
-          await client.createDirectory(testDir);
-          try {
-            await client.deleteFile(testDir);
-          } catch (e2) {
-          }
-          return true;
-        } catch (error3) {
-          console.error("\u6240\u6709\u6D4B\u8BD5\u65B9\u6CD5\u90FD\u5931\u8D25");
-          throw error3;
-        }
-      }
-    }
+    await client.exists("/");
+    return true;
   } catch (error) {
-    console.error("WebDAV \u8FDE\u63A5\u5931\u8D25:", error);
+    console.error("WebDAV \u8FDE\u63A5\u5931\u8D25:", error.message);
     return false;
   }
 }
@@ -16134,20 +16112,45 @@ async function ensureDirectory(config, dirPath) {
     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 {
-    const dirPath = fullPath.substring(0, fullPath.lastIndexOf("/"));
-    if (dirPath && dirPath !== "/") {
-      await ensureDirectory(config, dirPath);
+    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;
     }
-    await client.putFileContents(fullPath, data, {
-      overwrite: true
-    });
-  } catch (error) {
-    throw new Error(`\u4E0A\u4F20\u5931\u8D25: ${error.message}`);
+  }
+  try {
+    const exists2 = await client.exists(fullPath);
+    if (!exists2) {
+      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) {
@@ -16179,20 +16182,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);
   }
 });
 
@@ -16369,8 +16404,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);
@@ -16413,8 +16448,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));
@@ -16486,8 +16521,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);
@@ -16553,12 +16588,12 @@ 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;
+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();
@@ -16573,8 +16608,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);
@@ -16607,8 +16642,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);
@@ -16636,14 +16671,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);
@@ -16665,22 +16700,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);
     }
@@ -16699,12 +16734,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();
@@ -17182,8 +17217,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();
       }
@@ -17247,8 +17282,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();
       }
@@ -18890,7 +18925,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) => {
@@ -18902,7 +18937,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`);
@@ -18933,12 +18968,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.16",
+  "version": "3.0.18",
   "description": "Manage Codex and Claude Code API service provider configurations",
   "main": "./dist/index.js",
   "bin": {