ccman 3.0.21 → 3.0.22

package/dist/index.js

@@ -39,7 +39,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.0.21",
+      version: "3.0.22",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -2357,20 +2357,20 @@ var init_claude2 = __esm({
 });
 
 // ../core/dist/tool-manager.js
-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 generateId(tool) {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${tool}-${timestamp}-${random}`;
+}
+function createCodexManager() {
+  const configPath = path3.join(getCcmanDir(), "codex.json");
   function loadConfig2() {
     if (!fileExists(configPath)) {
       ensureDir(getCcmanDir());
       const initialConfig = {
         providers: [],
         presets: []
+        // 只存储用户自定义预置
       };
       writeJSON(configPath, initialConfig);
       return initialConfig;
@@ -2389,11 +2389,12 @@ function createToolManager(tool) {
       }
       const timestamp = Date.now();
       const provider = {
-        id: generateId(),
+        id: generateId("codex"),
         name: input.name,
         baseUrl: input.baseUrl,
         apiKey: input.apiKey,
         model: input.model,
+        // 保存 model 字段
         createdAt: timestamp,
         lastModified: timestamp
       };
@@ -2427,7 +2428,7 @@ function createToolManager(tool) {
       config.currentProviderId = id;
       provider.lastUsedAt = Date.now();
       saveConfig2(config);
-      toolConfig.writer(provider);
+      writeCodexConfig(provider);
     },
     getCurrent() {
       const config = loadConfig2();
@@ -2460,7 +2461,7 @@ function createToolManager(tool) {
       provider.lastModified = Date.now();
       saveConfig2(config);
       if (config.currentProviderId === id) {
-        toolConfig.writer(provider);
+        writeCodexConfig(provider);
       }
       return provider;
     },
@@ -2486,7 +2487,7 @@ function createToolManager(tool) {
       const timestamp = Date.now();
       const newProvider = {
         ...source,
-        id: generateId(),
+        id: generateId("codex"),
         name: newName,
         createdAt: timestamp,
         lastModified: timestamp,
@@ -2501,7 +2502,7 @@ function createToolManager(tool) {
       if (!config.presets) {
         config.presets = [];
       }
-      const allPresets = [...toolConfig.builtinPresets, ...config.presets];
+      const allPresets = [...CODEX_PRESETS, ...config.presets];
       const nameExists = allPresets.some((p) => p.name === input.name);
       if (nameExists) {
         throw new PresetNameConflictError(input.name);
@@ -2513,23 +2514,12 @@ function createToolManager(tool) {
       };
       config.presets.push(preset);
       saveConfig2(config);
-      return {
-        ...preset,
-        isBuiltIn: false
-      };
+      return preset;
     },
     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];
+      return [...CODEX_PRESETS, ...userPresets];
     },
     editPreset(name, updates) {
       const config = loadConfig2();
@@ -2541,7 +2531,7 @@ function createToolManager(tool) {
         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 allPresets = [...CODEX_PRESETS, ...config.presets];
         const nameConflict = allPresets.some((p) => p.name !== name && p.name === updates.name);
         if (nameConflict) {
           throw new PresetNameConflictError(updates.name);
@@ -2554,10 +2544,7 @@ function createToolManager(tool) {
       if (updates.description !== void 0)
         preset.description = updates.description;
       saveConfig2(config);
-      return {
-        ...preset,
-        isBuiltIn: false
-      };
+      return preset;
     },
     removePreset(name) {
       const config = loadConfig2();
@@ -2573,13 +2560,201 @@ function createToolManager(tool) {
     }
   };
 }
-function createCodexManager() {
-  return createToolManager("codex");
-}
 function createClaudeManager() {
-  return createToolManager("claude");
+  const configPath = path3.join(getCcmanDir(), "claude.json");
+  function loadConfig2() {
+    if (!fileExists(configPath)) {
+      ensureDir(getCcmanDir());
+      const initialConfig = {
+        providers: [],
+        presets: []
+        // 只存储用户自定义预置
+      };
+      writeJSON(configPath, initialConfig);
+      return initialConfig;
+    }
+    return readJSON(configPath);
+  }
+  function saveConfig2(config) {
+    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("claude"),
+        name: input.name,
+        baseUrl: input.baseUrl,
+        apiKey: input.apiKey,
+        createdAt: timestamp,
+        lastModified: timestamp
+      };
+      config.providers.push(provider);
+      saveConfig2(config);
+      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);
+      writeClaudeConfig(provider);
+    },
+    getCurrent() {
+      const config = loadConfig2();
+      if (!config.currentProviderId) {
+        return null;
+      }
+      const provider = config.providers.find((p) => p.id === config.currentProviderId);
+      return provider || null;
+    },
+    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.baseUrl !== void 0)
+        provider.baseUrl = updates.baseUrl;
+      if (updates.apiKey !== void 0)
+        provider.apiKey = updates.apiKey;
+      provider.lastModified = Date.now();
+      saveConfig2(config);
+      if (config.currentProviderId === id) {
+        writeClaudeConfig(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);
+    },
+    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("claude"),
+        name: newName,
+        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 = [...CC_PRESETS, ...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;
+    },
+    listPresets() {
+      const config = loadConfig2();
+      const userPresets = config.presets || [];
+      return [...CC_PRESETS, ...userPresets];
+    },
+    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 = [...CC_PRESETS, ...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;
+    },
+    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);
+    }
+  };
 }
-var path3, ProviderNotFoundError, ProviderNameConflictError, PresetNameConflictError, TOOL_CONFIGS;
+var path3, ProviderNotFoundError, ProviderNameConflictError, PresetNameConflictError;
 var init_tool_manager = __esm({
   "../core/dist/tool-manager.js"() {
     "use strict";
@@ -2608,18 +2783,6 @@ var init_tool_manager = __esm({
         this.name = "PresetNameConflictError";
       }
     };
-    TOOL_CONFIGS = {
-      codex: {
-        configPath: path3.join(getCcmanDir(), "codex.json"),
-        builtinPresets: CODEX_PRESETS,
-        writer: writeCodexConfig
-      },
-      claude: {
-        configPath: path3.join(getCcmanDir(), "claude.json"),
-        builtinPresets: CC_PRESETS,
-        writer: writeClaudeConfig
-      }
-    };
   }
 });
 
@@ -16146,24 +16309,14 @@ function decryptApiKey(encryptedApiKey, password) {
 }
 function encryptProviders(providers, password) {
   return providers.map((provider) => ({
-    id: provider.id,
-    name: provider.name,
-    baseUrl: provider.baseUrl,
-    encryptedApiKey: encryptApiKey(provider.apiKey, password),
-    createdAt: provider.createdAt,
-    lastModified: provider.lastModified,
-    lastUsedAt: provider.lastUsedAt
+    ...provider,
+    apiKey: encryptApiKey(provider.apiKey, password)
   }));
 }
 function decryptProviders(encryptedProviders, password) {
   return encryptedProviders.map((provider) => ({
-    id: provider.id,
-    name: provider.name,
-    baseUrl: provider.baseUrl,
-    apiKey: decryptApiKey(provider.encryptedApiKey, password),
-    createdAt: provider.createdAt,
-    lastModified: provider.lastModified,
-    lastUsedAt: provider.lastUsedAt
+    ...provider,
+    apiKey: decryptApiKey(provider.apiKey, password)
   }));
 }
 var crypto, ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, TAG_LENGTH, PBKDF2_ITERATIONS;
@@ -16181,15 +16334,6 @@ var init_crypto2 = __esm({
 });
 
 // ../core/dist/sync/merge-advanced.js
-function ensureLastModified(provider) {
-  if (provider.lastModified === void 0) {
-    return {
-      ...provider,
-      lastModified: provider.createdAt
-    };
-  }
-  return provider;
-}
 function isSameConfig(a, b) {
   return a.baseUrl === b.baseUrl && a.apiKey === b.apiKey;
 }
@@ -16214,49 +16358,26 @@ function resolveNameConflict(existingProviders, newProvider) {
   };
 }
 function mergeProviders(local, remote) {
-  const localProviders = local.map(ensureLastModified);
-  const remoteProviders = remote.map(ensureLastModified);
   const mergedMap = /* @__PURE__ */ new Map();
   let hasChanges = false;
-  for (const localProvider of localProviders) {
+  for (const localProvider of local) {
     mergedMap.set(localProvider.id, localProvider);
   }
-  for (const remoteProvider of remoteProviders) {
-    if (mergedMap.has(remoteProvider.id)) {
-      const localProvider = mergedMap.get(remoteProvider.id);
-      if (remoteProvider.lastModified > localProvider.lastModified) {
-        console.log(`provider ${remoteProvider.id} \u8FDC\u7A0B\u66F4\u65B0\uFF0C\u4F7F\u7528\u8FDC\u7A0B\u7248\u672C`);
-        mergedMap.set(remoteProvider.id, remoteProvider);
+  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;
-      } else if (remoteProvider.lastModified < localProvider.lastModified) {
-        console.log(`provider ${remoteProvider.id} \u672C\u5730\u66F4\u65B0\uFF0C\u4F7F\u7528\u672C\u5730\u7248\u672C`);
-        hasChanges = true;
-      } else {
-        if (!isProviderEqual(localProvider, remoteProvider)) {
-          console.log(`provider ${remoteProvider.id} \u65F6\u95F4\u6233\u76F8\u540C\u4F46\u5185\u5BB9\u4E0D\u540C\uFF0C\u4F7F\u7528\u8FDC\u7A0B\u7248\u672C`);
-          mergedMap.set(remoteProvider.id, remoteProvider);
-          hasChanges = true;
-        }
+        console.log(`\u76F8\u540C\u914D\u7F6E (${remoteProvider.baseUrl})\uFF0C\u4F7F\u7528\u4E91\u7AEF\u6570\u636E`);
       }
     } else {
-      const existingWithSameConfig = Array.from(mergedMap.values()).find((p) => isSameConfig(p, remoteProvider));
-      if (existingWithSameConfig) {
-        if (remoteProvider.lastModified > existingWithSameConfig.lastModified) {
-          console.log(`\u76F8\u540C\u914D\u7F6E (${remoteProvider.baseUrl})\uFF0C\u8FDC\u7A0B\u66F4\u65B0\uFF0C\u66FF\u6362 ${existingWithSameConfig.id} \u4E3A ${remoteProvider.id}`);
-          mergedMap.delete(existingWithSameConfig.id);
-          mergedMap.set(remoteProvider.id, remoteProvider);
-          hasChanges = true;
-        } else {
-          console.log(`\u76F8\u540C\u914D\u7F6E (${remoteProvider.baseUrl})\uFF0C\u672C\u5730\u66F4\u65B0\uFF0C\u4FDD\u7559 ${existingWithSameConfig.id}`);
-          hasChanges = true;
-        }
-      } else {
-        console.log(`\u65B0 provider ${remoteProvider.id}\uFF0C\u6DFB\u52A0\u5230\u5408\u5E76\u5217\u8868`);
-        const existingProviders = Array.from(mergedMap.values());
-        const resolvedProvider = resolveNameConflict(existingProviders, remoteProvider);
-        mergedMap.set(resolvedProvider.id, resolvedProvider);
-        hasChanges = true;
-      }
+      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());
@@ -16265,6 +16386,43 @@ function mergeProviders(local, remote) {
     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";
@@ -16281,12 +16439,16 @@ async function uploadToCloud(config, password) {
   const encryptedCodexProviders = encryptProviders(codexConfig.providers, password);
   const encryptedClaudeProviders = encryptProviders(claudeConfig.providers, password);
   const encryptedCodexConfig = {
-    currentProviderId: codexConfig.currentProviderId,
+    ...codexConfig,
+    // 保留所有字段
     providers: encryptedCodexProviders
+    // 只替换 providers（加密后的）
   };
   const encryptedClaudeConfig = {
-    currentProviderId: claudeConfig.currentProviderId,
+    ...claudeConfig,
+    // 保留所有字段
     providers: encryptedClaudeProviders
+    // 只替换 providers（加密后的）
   };
   const codexJson = JSON.stringify(encryptedCodexConfig, null, 2);
   const claudeJson = JSON.stringify(encryptedClaudeConfig, null, 2);
@@ -16331,24 +16493,22 @@ async function downloadFromCloud(config, password) {
     throw new Error(`\u5907\u4EFD\u5931\u8D25: ${error.message}`);
   }
   try {
-    const currentCodexConfig = readJSON(codexConfigPath);
-    const currentClaudeConfig = readJSON(claudeConfigPath);
     if (remoteCodexConfig && decryptedCodexProviders) {
       const newCodexConfig = {
-        currentProviderId: remoteCodexConfig.currentProviderId,
-        providers: decryptedCodexProviders,
-        presets: currentCodexConfig.presets
-        // 保留本地 presets
+        ...remoteCodexConfig,
+        // 使用云端配置的所有字段
+        providers: decryptedCodexProviders
+        // 只替换 providers（解密后的）
       };
       writeJSON(codexConfigPath, newCodexConfig);
       applyCurrentProvider("codex", newCodexConfig);
     }
     if (remoteClaudeConfig && decryptedClaudeProviders) {
       const newClaudeConfig = {
-        currentProviderId: remoteClaudeConfig.currentProviderId,
-        providers: decryptedClaudeProviders,
-        presets: currentClaudeConfig.presets
-        // 保留本地 presets
+        ...remoteClaudeConfig,
+        // 使用云端配置的所有字段
+        providers: decryptedClaudeProviders
+        // 只替换 providers（解密后的）
       };
       writeJSON(claudeConfigPath, newClaudeConfig);
       applyCurrentProvider("claude", newClaudeConfig);
@@ -16418,16 +16578,24 @@ async function mergeSync(config, password) {
   } 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 = {
-      currentProviderId: localCodexConfig.currentProviderId,
+      ...localCodexConfig,
+      // 保留本地配置的所有字段
       providers: codexMergeResult.merged,
-      presets: localCodexConfig.presets
+      // 替换为合并后的 providers
+      presets: mergedCodexPresets
+      // 替换为合并后的 presets
     };
     const mergedClaudeConfig = {
-      currentProviderId: localClaudeConfig.currentProviderId,
+      ...localClaudeConfig,
+      // 保留本地配置的所有字段
       providers: claudeMergeResult.merged,
-      presets: localClaudeConfig.presets
+      // 替换为合并后的 providers
+      presets: mergedClaudePresets
+      // 替换为合并后的 presets
     };
     writeJSON(codexConfigPath, mergedCodexConfig);
     writeJSON(claudeConfigPath, mergedClaudeConfig);
@@ -16436,12 +16604,16 @@ async function mergeSync(config, password) {
     const encryptedCodexProviders = encryptProviders(codexMergeResult.merged, password);
     const encryptedClaudeProviders = encryptProviders(claudeMergeResult.merged, password);
     const encryptedCodexConfig = {
-      currentProviderId: mergedCodexConfig.currentProviderId,
+      ...mergedCodexConfig,
+      // 保留合并后配置的所有字段
       providers: encryptedCodexProviders
+      // 只替换 providers（加密后的）
     };
     const encryptedClaudeConfig = {
-      currentProviderId: mergedClaudeConfig.currentProviderId,
+      ...mergedClaudeConfig,
+      // 保留合并后配置的所有字段
       providers: encryptedClaudeProviders
+      // 只替换 providers（加密后的）
     };
     const codexJson2 = JSON.stringify(encryptedCodexConfig, null, 2);
     const claudeJson2 = JSON.stringify(encryptedClaudeConfig, null, 2);
@@ -16661,45 +16833,12 @@ var init_dist4 = __esm({
 });
 
 // src/utils/sync-config.ts
-function getMachineId() {
-  return import_crypto4.default.createHash("sha256").update(import_os.default.hostname() + import_os.default.userInfo().username).digest();
-}
-function encrypt(text) {
-  const key = getMachineId();
-  const iv = import_crypto4.default.randomBytes(16);
-  const cipher = import_crypto4.default.createCipheriv("aes-256-cbc", key, iv);
-  let encrypted = cipher.update(text, "utf8", "hex");
-  encrypted += cipher.final("hex");
-  return iv.toString("hex") + ":" + encrypted;
-}
-function decrypt(encrypted) {
-  const parts = encrypted.split(":");
-  const iv = Buffer.from(parts[0], "hex");
-  const encryptedText = parts[1];
-  const key = getMachineId();
-  const decipher = import_crypto4.default.createDecipheriv("aes-256-cbc", key, iv);
-  let decrypted = decipher.update(encryptedText, "hex", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
-}
 function loadSyncConfig() {
   try {
     const config = getSyncConfig();
     if (!config) {
       return null;
     }
-    if (config.password && config.password.includes(":")) {
-      try {
-        config.password = decrypt(config.password);
-      } catch {
-      }
-    }
-    if (config.syncPassword && config.syncPassword.includes(":")) {
-      try {
-        config.syncPassword = decrypt(config.syncPassword);
-      } catch {
-      }
-    }
     return config;
   } catch (error) {
     throw new Error(`\u8BFB\u53D6\u540C\u6B65\u914D\u7F6E\u5931\u8D25: ${error.message}`);
@@ -16708,12 +16847,7 @@ function loadSyncConfig() {
 function saveSyncConfig2(config) {
   try {
     const configToSave = { ...config };
-    if (configToSave.password) {
-      configToSave.password = encrypt(configToSave.password);
-    }
-    if (configToSave.syncPassword && configToSave.rememberSyncPassword) {
-      configToSave.syncPassword = encrypt(configToSave.syncPassword);
-    } else {
+    if (!configToSave.rememberSyncPassword) {
       delete configToSave.syncPassword;
     }
     configToSave.lastSync = Date.now();
@@ -16725,12 +16859,9 @@ function saveSyncConfig2(config) {
 function getSyncConfigPath() {
   return getConfigPath();
 }
-var import_crypto4, import_os;
 var init_sync_config = __esm({
   "src/utils/sync-config.ts"() {
     "use strict";
-    import_crypto4 = __toESM(require("crypto"));
-    import_os = __toESM(require("os"));
     init_dist4();
   }
 });
@@ -18956,6 +19087,26 @@ program.name("ccman").description("Codex/Claude Code API \u670D\u52A1\u5546\u914
   }
   throw err;
 });
+program.on("command:*", (operands) => {
+  const unknownCommand = operands[0];
+  console.error(import_chalk27.default.red(`
+\u274C \u672A\u77E5\u547D\u4EE4: ${unknownCommand}
+`));
+  const availableCommands = ["cx", "cc", "sync", "export", "import"];
+  const suggestions = availableCommands.filter(
+    (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
+  );
+  if (suggestions.length > 0) {
+    console.log(import_chalk27.default.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
+    suggestions.forEach((cmd) => {
+      console.log(import_chalk27.default.cyan(`   ccman ${cmd}`));
+    });
+    console.log();
+  }
+  console.log(import_chalk27.default.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + import_chalk27.default.cyan("ccman --help"));
+  console.log();
+  process.exit(1);
+});
 var cx = program.command("cx").description("\u7BA1\u7406 Codex \u670D\u52A1\u5546");
 createCodexCommands(cx);
 cx.action(async () => {

package/package.json

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