ccman 3.0.20 → 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.20",
+      version: "3.0.22",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -16309,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;
@@ -16344,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;
 }
@@ -16377,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);
-        hasChanges = true;
-      } else if (remoteProvider.lastModified < localProvider.lastModified) {
-        console.log(`provider ${remoteProvider.id} \u672C\u5730\u66F4\u65B0\uFF0C\u4F7F\u7528\u672C\u5730\u7248\u672C`);
+  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 (!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());
@@ -16428,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";
@@ -16444,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);
@@ -16494,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);
@@ -16581,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);
@@ -16599,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);
@@ -16824,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}`);
@@ -16871,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();
@@ -16888,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();
   }
 });
@@ -19119,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.20",
+  "version": "3.0.22",
   "description": "Manage Codex and Claude Code API service provider configurations",
   "main": "./dist/index.js",
   "bin": {