ccman 3.0.33 → 3.1.1

package/dist/index.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.0.33",
+      version: "3.1.1",
       type: "module",
       description: "Core business logic for ccman",
       main: "./dist/index.js",
@@ -43,12 +43,12 @@ var init_package = __esm({
       license: "MIT",
       repository: {
         type: "git",
-        url: "https://github.com/2ue/ccm.git",
+        url: "https://github.com/2ue/ccman.git",
         directory: "packages/core"
       },
-      homepage: "https://github.com/2ue/ccm#readme",
+      homepage: "https://github.com/2ue/ccman#readme",
       bugs: {
-        url: "https://github.com/2ue/ccm/issues"
+        url: "https://github.com/2ue/ccman/issues"
       },
       dependencies: {
         "@iarna/toml": "^2.2.5",
@@ -65,6 +65,59 @@ var init_package = __esm({
   }
 });
 
+// ../core/dist/constants.js
+var TOOL_TYPES, MAIN_TOOL_TYPES, TOOL_CONFIG;
+var init_constants = __esm({
+  "../core/dist/constants.js"() {
+    "use strict";
+    TOOL_TYPES = {
+      CODEX: "codex",
+      CLAUDE: "claude",
+      MCP: "mcp",
+      GEMINI: "gemini"
+    };
+    MAIN_TOOL_TYPES = {
+      CODEX: TOOL_TYPES.CODEX,
+      CLAUDE: TOOL_TYPES.CLAUDE,
+      GEMINI: TOOL_TYPES.GEMINI
+    };
+    TOOL_CONFIG = {
+      [TOOL_TYPES.CODEX]: {
+        displayName: "Codex",
+        color: "blue",
+        textColorClass: "text-blue-600",
+        bgColorClass: "bg-blue-50",
+        hoverBgColorClass: "hover:bg-blue-100",
+        description: "Codex AI \u52A9\u624B"
+      },
+      [TOOL_TYPES.CLAUDE]: {
+        displayName: "Claude Code",
+        color: "purple",
+        textColorClass: "text-purple-600",
+        bgColorClass: "bg-purple-50",
+        hoverBgColorClass: "hover:bg-purple-100",
+        description: "Claude Code AI \u52A9\u624B"
+      },
+      [TOOL_TYPES.MCP]: {
+        displayName: "MCP",
+        color: "gray",
+        textColorClass: "text-gray-600",
+        bgColorClass: "bg-gray-50",
+        hoverBgColorClass: "hover:bg-gray-100",
+        description: "MCP \u670D\u52A1"
+      },
+      [TOOL_TYPES.GEMINI]: {
+        displayName: "Gemini CLI",
+        color: "green",
+        textColorClass: "text-green-600",
+        bgColorClass: "bg-green-50",
+        hoverBgColorClass: "hover:bg-green-100",
+        description: "Gemini CLI AI \u52A9\u624B"
+      }
+    };
+  }
+});
+
 // ../core/dist/paths.js
 import * as os from "os";
 import * as path from "path";
@@ -77,6 +130,9 @@ function getCodexDir() {
 function getClaudeDir() {
   return claudeDir;
 }
+function getGeminiDir() {
+  return geminiDir;
+}
 function getConfigPath() {
   return path.join(ccmanDir, "config.json");
 }
@@ -92,7 +148,13 @@ function getClaudeConfigPath() {
 function getClaudeJsonPath() {
   return path.join(rootDir, ".claude.json");
 }
-var isDev, isTest, rootDir, ccmanDir, codexDir, claudeDir;
+function getGeminiSettingsPath() {
+  return path.join(geminiDir, "settings.json");
+}
+function getGeminiEnvPath() {
+  return path.join(geminiDir, ".env");
+}
+var isDev, isTest, rootDir, ccmanDir, codexDir, claudeDir, geminiDir;
 var init_paths = __esm({
   "../core/dist/paths.js"() {
     "use strict";
@@ -108,6 +170,7 @@ var init_paths = __esm({
     ccmanDir = path.join(rootDir, ".ccman");
     codexDir = path.join(rootDir, ".codex");
     claudeDir = path.join(rootDir, ".claude");
+    geminiDir = path.join(rootDir, ".gemini");
   }
 });
 
@@ -344,15 +407,13 @@ function migrateMCPConfig(config) {
     config.managedServerNames = {
       claude: config.managedServerNames,
       codex: [],
-      cursor: [],
-      windsurf: []
+      gemini: []
     };
   } else if (!config.managedServerNames) {
     config.managedServerNames = {
       claude: [],
       codex: [],
-      cursor: [],
-      windsurf: []
+      gemini: []
     };
   }
   if (config.servers) {
@@ -374,8 +435,7 @@ function loadMCPConfig() {
       managedServerNames: {
         claude: [],
         codex: [],
-        cursor: [],
-        windsurf: []
+        gemini: []
       }
     };
   }
@@ -441,10 +501,10 @@ function writeMCPConfigForApp(app, _provider) {
       break;
     case "codex":
       return;
-    case "cursor":
-      return;
-    case "windsurf":
-      return;
+    case "gemini":
+      configPath = getGeminiSettingsPath();
+      configDir = getGeminiDir();
+      break;
   }
   ensureDir(configDir);
   let appConfig = {};
@@ -625,6 +685,127 @@ var init_mcp2 = __esm({
   }
 });
 
+// ../core/dist/presets/gemini.js
+var GEMINI_PRESETS;
+var init_gemini = __esm({
+  "../core/dist/presets/gemini.js"() {
+    "use strict";
+    GEMINI_PRESETS = [
+      {
+        name: "Google Gemini (API Key)",
+        baseUrl: "",
+        description: "\u4F7F\u7528\u5B98\u65B9 Gemini API\uFF08\u901A\u8FC7 GEMINI_API_KEY \u6216 GOOGLE_API_KEY \u8BA4\u8BC1\uFF09"
+      },
+      {
+        name: "PackyAPI",
+        baseUrl: "https://www.packyapi.com",
+        description: "PackyAPI Gemini \u517C\u5BB9\u670D\u52A1"
+      },
+      {
+        name: "LiteLLM Proxy",
+        baseUrl: "http://localhost:4000",
+        description: "\u4F7F\u7528\u672C\u5730 LiteLLM Proxy \u4F5C\u4E3A Gemini \u517C\u5BB9\u4EE3\u7406"
+      }
+    ];
+  }
+});
+
+// ../core/dist/writers/gemini.js
+import * as fs5 from "fs";
+function loadEnvFile(envPath) {
+  if (!fileExists(envPath))
+    return {};
+  const content = fs5.readFileSync(envPath, "utf-8");
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1)
+      continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    const value = trimmed.slice(eqIndex + 1).trim();
+    if (!key)
+      continue;
+    result[key] = value;
+  }
+  return result;
+}
+function saveEnvFile(envPath, env) {
+  const lines = [];
+  const keys = Object.keys(env).sort();
+  for (const key of keys) {
+    lines.push(`${key}=${String(env[key])}`);
+  }
+  const content = lines.join("\n") + (lines.length ? "\n" : "");
+  fs5.writeFileSync(envPath, content, { mode: 384 });
+}
+function writeGeminiConfig(provider) {
+  const settingsPath = getGeminiSettingsPath();
+  const envPath = getGeminiEnvPath();
+  const dir = getGeminiDir();
+  ensureDir(dir);
+  let settings = {};
+  if (fileExists(settingsPath)) {
+    try {
+      const content = fs5.readFileSync(settingsPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === "object") {
+        settings = parsed;
+      }
+    } catch (error) {
+      throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 Gemini settings.json: ${error.message}`);
+    }
+  }
+  if (!settings.ide || typeof settings.ide !== "object") {
+    settings.ide = {};
+  }
+  if (settings.ide.enabled === void 0) {
+    settings.ide.enabled = true;
+  }
+  if (!settings.security || typeof settings.security !== "object") {
+    settings.security = {};
+  }
+  if (!settings.security.auth || typeof settings.security.auth !== "object") {
+    settings.security.auth = {};
+  }
+  if (settings.security.auth.selectedType === void 0) {
+    settings.security.auth.selectedType = "gemini-api-key";
+  }
+  try {
+    const tempPath = `${settingsPath}.tmp`;
+    fs5.writeFileSync(tempPath, JSON.stringify(settings, null, 2), {
+      mode: 384
+    });
+    fs5.renameSync(tempPath, settingsPath);
+  } catch (error) {
+    throw new Error(`\u5199\u5165 Gemini settings.json \u5931\u8D25: ${error.message}`);
+  }
+  const env = loadEnvFile(envPath);
+  if (provider.baseUrl && provider.baseUrl.trim().length > 0) {
+    env.GOOGLE_GEMINI_BASE_URL = provider.baseUrl;
+  } else {
+    delete env.GOOGLE_GEMINI_BASE_URL;
+  }
+  if (provider.apiKey && provider.apiKey.trim().length > 0) {
+    env.GEMINI_API_KEY = provider.apiKey;
+  } else {
+    delete env.GEMINI_API_KEY;
+  }
+  if (provider.model && provider.model.trim().length > 0) {
+    env.GEMINI_MODEL = provider.model;
+  }
+  saveEnvFile(envPath, env);
+}
+var init_gemini2 = __esm({
+  "../core/dist/writers/gemini.js"() {
+    "use strict";
+    init_paths();
+    init_file();
+  }
+});
+
 // ../core/dist/tool-manager.types.js
 var ProviderNotFoundError, ProviderNameConflictError, PresetNameConflictError;
 var init_tool_manager_types = __esm({
@@ -901,6 +1082,9 @@ function createClaudeManager() {
 function createMCPManager() {
   return createToolManager("mcp");
 }
+function createGeminiManager() {
+  return createToolManager("gemini");
+}
 var TOOL_CONFIGS;
 var init_tool_manager = __esm({
   "../core/dist/tool-manager.js"() {
@@ -913,6 +1097,8 @@ var init_tool_manager = __esm({
     init_codex2();
     init_claude2();
     init_mcp2();
+    init_gemini();
+    init_gemini2();
     init_tool_manager_types();
     TOOL_CONFIGS = {
       codex: {
@@ -949,11 +1135,16 @@ var init_tool_manager = __esm({
             }
             return mcpServer;
           });
-          for (const app of ["claude", "codex", "cursor", "windsurf"]) {
+          for (const app of ["claude", "codex", "gemini"]) {
             mcpConfig.managedServerNames[app] = mcpConfig.servers.filter((s) => s.enabledApps.includes(app)).map((s) => s.name);
           }
           saveMCPConfig(mcpConfig);
         }
+      },
+      gemini: {
+        configPath: path6.join(getCcmanDir(), "gemini.json"),
+        builtinPresets: GEMINI_PRESETS,
+        writer: writeGeminiConfig
       }
     };
   }
@@ -968,20 +1159,20 @@ var init_migrate = __esm({
 });
 
 // ../core/dist/config.js
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 function ensureConfigDir() {
   const dir = getCcmanDir();
-  if (!fs5.existsSync(dir)) {
-    fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs6.existsSync(dir)) {
+    fs6.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!fs5.existsSync(configPath)) {
+  if (!fs6.existsSync(configPath)) {
     return {};
   }
   try {
-    const content = fs5.readFileSync(configPath, "utf-8");
+    const content = fs6.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to load config: ${error.message}`);
@@ -992,10 +1183,10 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   try {
     const tempPath = `${configPath}.tmp`;
-    fs5.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
+    fs6.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
       mode: 384
     });
-    fs5.renameSync(tempPath, configPath);
+    fs6.renameSync(tempPath, configPath);
   } catch (error) {
     throw new Error(`Failed to save config: ${error.message}`);
   }
@@ -1319,15 +1510,15 @@ var init_merge_advanced = __esm({
 });
 
 // ../core/dist/sync/merge.js
-import fs6 from "fs";
+import fs7 from "fs";
 import path7 from "path";
 function backupConfig(configPath, keepCount = 3) {
-  if (!fs6.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}`);
   }
   const timestamp = Date.now();
   const backupPath = `${configPath}.backup.${timestamp}`;
-  fs6.copyFileSync(configPath, backupPath);
+  fs7.copyFileSync(configPath, backupPath);
   cleanupOldBackups(configPath, keepCount);
   return backupPath;
 }
@@ -1336,7 +1527,7 @@ function cleanupOldBackups(configPath, keepCount) {
   const basename = path7.basename(configPath);
   const backupPrefix = `${basename}.backup.`;
   try {
-    const files = fs6.readdirSync(dir);
+    const files = fs7.readdirSync(dir);
     const backups = files.filter((f) => f.startsWith(backupPrefix)).map((f) => {
       const timestampStr = f.substring(backupPrefix.length);
       const timestamp = parseInt(timestampStr, 10);
@@ -1352,7 +1543,7 @@ function cleanupOldBackups(configPath, keepCount) {
     const toDelete = backups.slice(keepCount);
     for (const backup of toDelete) {
       try {
-        fs6.unlinkSync(backup.path);
+        fs7.unlinkSync(backup.path);
       } catch (error) {
         console.warn(`\u65E0\u6CD5\u5220\u9664\u65E7\u5907\u4EFD\u6587\u4EF6 ${backup.name}: ${error.message}`);
       }
@@ -1368,91 +1559,81 @@ var init_merge = __esm({
 });
 
 // ../core/dist/sync/sync-v2.js
-import fs7 from "fs";
+import fs8 from "fs";
 import path8 from "path";
 async function uploadToCloud(config, password) {
   const ccmanDir2 = getCcmanDir();
-  const codexConfigPath = path8.join(ccmanDir2, "codex.json");
-  const claudeConfigPath = path8.join(ccmanDir2, "claude.json");
-  const codexConfig = readJSON(codexConfigPath);
-  const claudeConfig = readJSON(claudeConfigPath);
-  const encryptedCodexProviders = encryptProviders(codexConfig.providers, password);
-  const encryptedClaudeProviders = encryptProviders(claudeConfig.providers, password);
-  const encryptedCodexConfig = {
-    ...codexConfig,
-    // 保留所有字段
-    providers: encryptedCodexProviders
-    // 只替换 providers（加密后的）
-  };
-  const encryptedClaudeConfig = {
-    ...claudeConfig,
-    // 保留所有字段
-    providers: encryptedClaudeProviders
-    // 只替换 providers（加密后的）
-  };
-  const codexJson = JSON.stringify(encryptedCodexConfig, null, 2);
-  const claudeJson = JSON.stringify(encryptedClaudeConfig, null, 2);
-  await uploadToWebDAV(config, CODEX_REMOTE_PATH, codexJson);
-  await uploadToWebDAV(config, CLAUDE_REMOTE_PATH, claudeJson);
+  const toolKeys = Object.keys(TOOL_SYNC_CONFIG);
+  for (const tool of toolKeys) {
+    const { remotePath, configFilename } = TOOL_SYNC_CONFIG[tool];
+    const configPath = path8.join(ccmanDir2, configFilename);
+    const localConfig = readJSON(configPath);
+    const encryptedProviders = encryptProviders(localConfig.providers, password);
+    const encryptedConfig = {
+      ...localConfig,
+      // 保留所有字段
+      providers: encryptedProviders
+      // 只替换 providers（加密后的）
+    };
+    const jsonContent = JSON.stringify(encryptedConfig, null, 2);
+    await uploadToWebDAV(config, remotePath, jsonContent);
+  }
   updateLastSyncTime();
   console.log("\u2705 \u914D\u7F6E\u5DF2\u4E0A\u4F20\u5230\u4E91\u7AEF");
 }
 async function downloadFromCloud(config, password) {
-  const codexExists = await existsOnWebDAV(config, CODEX_REMOTE_PATH);
-  const claudeExists = await existsOnWebDAV(config, CLAUDE_REMOTE_PATH);
-  if (!codexExists && !claudeExists) {
+  const ccmanDir2 = getCcmanDir();
+  const toolKeys = Object.keys(TOOL_SYNC_CONFIG);
+  const existsChecks = await Promise.all(toolKeys.map(async (tool) => {
+    const { remotePath } = TOOL_SYNC_CONFIG[tool];
+    return existsOnWebDAV(config, remotePath);
+  }));
+  if (!existsChecks.some((exists) => exists)) {
     throw new Error("\u8FDC\u7A0B\u914D\u7F6E\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5148\u4E0A\u4F20\u914D\u7F6E");
   }
-  const codexJson = codexExists ? await downloadFromWebDAV(config, CODEX_REMOTE_PATH) : null;
-  const claudeJson = claudeExists ? await downloadFromWebDAV(config, CLAUDE_REMOTE_PATH) : null;
-  const remoteCodexConfig = codexJson ? JSON.parse(codexJson) : null;
-  const remoteClaudeConfig = claudeJson ? JSON.parse(claudeJson) : null;
-  let decryptedCodexProviders = null;
-  let decryptedClaudeProviders = null;
-  try {
-    if (remoteCodexConfig) {
-      decryptedCodexProviders = decryptProviders(remoteCodexConfig.providers, password);
-    }
-    if (remoteClaudeConfig) {
-      decryptedClaudeProviders = decryptProviders(remoteClaudeConfig.providers, password);
+  const remoteConfigs = [];
+  for (let i = 0; i < toolKeys.length; i++) {
+    const tool = toolKeys[i];
+    const { remotePath } = TOOL_SYNC_CONFIG[tool];
+    if (existsChecks[i]) {
+      const jsonContent = await downloadFromWebDAV(config, remotePath);
+      const remoteConfig = JSON.parse(jsonContent);
+      try {
+        const decryptedProviders = decryptProviders(remoteConfig.providers, password);
+        remoteConfigs.push({ tool, config: remoteConfig, decryptedProviders });
+      } catch (error) {
+        throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
+      }
+    } else {
+      remoteConfigs.push({ tool, config: null, decryptedProviders: null });
     }
-  } catch (error) {
-    throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
   }
   const backupPaths = [];
-  const ccmanDir2 = getCcmanDir();
-  const codexConfigPath = path8.join(ccmanDir2, "codex.json");
-  const claudeConfigPath = path8.join(ccmanDir2, "claude.json");
   try {
-    if (fs7.existsSync(codexConfigPath)) {
-      backupPaths.push(backupConfig(codexConfigPath));
-    }
-    if (fs7.existsSync(claudeConfigPath)) {
-      backupPaths.push(backupConfig(claudeConfigPath));
+    for (const tool of toolKeys) {
+      const { configFilename } = TOOL_SYNC_CONFIG[tool];
+      const configPath = path8.join(ccmanDir2, configFilename);
+      if (fs8.existsSync(configPath)) {
+        backupPaths.push(backupConfig(configPath));
+      }
     }
   } catch (error) {
     throw new Error(`\u5907\u4EFD\u5931\u8D25: ${error.message}`);
   }
   try {
-    if (remoteCodexConfig && decryptedCodexProviders) {
-      const newCodexConfig = {
-        ...remoteCodexConfig,
-        // 使用云端配置的所有字段
-        providers: decryptedCodexProviders
-        // 只替换 providers（解密后的）
-      };
-      writeJSON(codexConfigPath, newCodexConfig);
-      applyCurrentProvider("codex", newCodexConfig);
-    }
-    if (remoteClaudeConfig && decryptedClaudeProviders) {
-      const newClaudeConfig = {
-        ...remoteClaudeConfig,
+    for (const { tool, config: remoteConfig, decryptedProviders } of remoteConfigs) {
+      if (!remoteConfig || !decryptedProviders)
+        continue;
+      const { configFilename } = TOOL_SYNC_CONFIG[tool];
+      const configPath = path8.join(ccmanDir2, configFilename);
+      const newConfig = {
+        ...remoteConfig,
         // 使用云端配置的所有字段
-        providers: decryptedClaudeProviders
+        providers: decryptedProviders
         // 只替换 providers（解密后的）
       };
-      writeJSON(claudeConfigPath, newClaudeConfig);
-      applyCurrentProvider("claude", newClaudeConfig);
+      writeJSON(configPath, newConfig);
+      applyCurrentProvider(tool, newConfig);
     }
     updateLastSyncTime();
     console.log("\u2705 \u914D\u7F6E\u5DF2\u4ECE\u4E91\u7AEF\u4E0B\u8F7D\u5E76\u5E94\u7528");
@@ -1460,17 +1641,21 @@ async function downloadFromCloud(config, password) {
   } catch (error) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
-      if (fs7.existsSync(backupPath)) {
-        fs7.copyFileSync(backupPath, originalPath);
+      if (fs8.existsSync(backupPath)) {
+        fs8.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u8986\u76D6\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
   }
 }
 async function mergeSync(config, password) {
-  const codexExists = await existsOnWebDAV(config, CODEX_REMOTE_PATH);
-  const claudeExists = await existsOnWebDAV(config, CLAUDE_REMOTE_PATH);
-  if (!codexExists && !claudeExists) {
+  const ccmanDir2 = getCcmanDir();
+  const toolKeys = Object.keys(TOOL_SYNC_CONFIG);
+  const existsChecks = await Promise.all(toolKeys.map(async (tool) => {
+    const { remotePath } = TOOL_SYNC_CONFIG[tool];
+    return existsOnWebDAV(config, remotePath);
+  }));
+  if (!existsChecks.some((exists) => exists)) {
     console.log("\u8FDC\u7A0B\u914D\u7F6E\u4E0D\u5B58\u5728\uFF0C\u6267\u884C\u4E0A\u4F20\u64CD\u4F5C");
     await uploadToCloud(config, password);
     return {
@@ -1478,30 +1663,31 @@ async function mergeSync(config, password) {
       backupPaths: []
     };
   }
-  const codexJson = codexExists ? await downloadFromWebDAV(config, CODEX_REMOTE_PATH) : null;
-  const claudeJson = claudeExists ? await downloadFromWebDAV(config, CLAUDE_REMOTE_PATH) : null;
-  const remoteCodexConfig = codexJson ? JSON.parse(codexJson) : null;
-  const remoteClaudeConfig = claudeJson ? JSON.parse(claudeJson) : null;
-  let remoteCodexProviders = [];
-  let remoteClaudeProviders = [];
-  try {
-    if (remoteCodexConfig) {
-      remoteCodexProviders = decryptProviders(remoteCodexConfig.providers, password);
-    }
-    if (remoteClaudeConfig) {
-      remoteClaudeProviders = decryptProviders(remoteClaudeConfig.providers, password);
+  const mergeDataList = [];
+  for (let i = 0; i < toolKeys.length; i++) {
+    const tool = toolKeys[i];
+    const { remotePath, configFilename } = TOOL_SYNC_CONFIG[tool];
+    const configPath = path8.join(ccmanDir2, configFilename);
+    const localConfig = readJSON(configPath);
+    let remoteProviders = [];
+    if (existsChecks[i]) {
+      try {
+        const jsonContent = await downloadFromWebDAV(config, remotePath);
+        const remoteConfig = JSON.parse(jsonContent);
+        remoteProviders = decryptProviders(remoteConfig.providers, password);
+      } catch (error) {
+        throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
+      }
     }
-  } catch (error) {
-    throw new Error("\u89E3\u5BC6\u5931\u8D25\uFF1A\u5BC6\u7801\u9519\u8BEF\u6216\u6570\u636E\u635F\u574F");
+    const mergeResult = mergeProviders(localConfig.providers, remoteProviders);
+    mergeDataList.push({
+      tool,
+      localConfig,
+      remoteProviders,
+      mergeResult
+    });
   }
-  const ccmanDir2 = getCcmanDir();
-  const codexConfigPath = path8.join(ccmanDir2, "codex.json");
-  const claudeConfigPath = path8.join(ccmanDir2, "claude.json");
-  const localCodexConfig = readJSON(codexConfigPath);
-  const localClaudeConfig = readJSON(claudeConfigPath);
-  const codexMergeResult = mergeProviders(localCodexConfig.providers, remoteCodexProviders);
-  const claudeMergeResult = mergeProviders(localClaudeConfig.providers, remoteClaudeProviders);
-  const hasChanges = codexMergeResult.hasChanges || claudeMergeResult.hasChanges;
+  const hasChanges = mergeDataList.some((data) => data.mergeResult.hasChanges);
   if (!hasChanges) {
     console.log("\u2139\uFE0F \u914D\u7F6E\u5DF2\u540C\u6B65\uFF0C\u65E0\u9700\u64CD\u4F5C");
     return {
@@ -1511,56 +1697,47 @@ async function mergeSync(config, password) {
   }
   const backupPaths = [];
   try {
-    if (fs7.existsSync(codexConfigPath)) {
-      backupPaths.push(backupConfig(codexConfigPath));
-    }
-    if (fs7.existsSync(claudeConfigPath)) {
-      backupPaths.push(backupConfig(claudeConfigPath));
+    for (const tool of toolKeys) {
+      const { configFilename } = TOOL_SYNC_CONFIG[tool];
+      const configPath = path8.join(ccmanDir2, configFilename);
+      if (fs8.existsSync(configPath)) {
+        backupPaths.push(backupConfig(configPath));
+      }
     }
   } catch (error) {
     throw new Error(`\u5907\u4EFD\u5931\u8D25: ${error.message}`);
   }
-  const mergedCodexPresets = mergePresets(localCodexConfig.presets, remoteCodexConfig?.presets);
-  const mergedClaudePresets = mergePresets(localClaudeConfig.presets, remoteClaudeConfig?.presets);
   try {
-    const mergedCodexConfig = {
-      ...localCodexConfig,
-      // 保留本地配置的所有字段
-      providers: codexMergeResult.merged,
-      // 替换为合并后的 providers
-      presets: mergedCodexPresets
-      // 替换为合并后的 presets
-    };
-    const mergedClaudeConfig = {
-      ...localClaudeConfig,
-      // 保留本地配置的所有字段
-      providers: claudeMergeResult.merged,
-      // 替换为合并后的 providers
-      presets: mergedClaudePresets
-      // 替换为合并后的 presets
-    };
-    writeJSON(codexConfigPath, mergedCodexConfig);
-    writeJSON(claudeConfigPath, mergedClaudeConfig);
-    applyCurrentProvider("codex", mergedCodexConfig);
-    applyCurrentProvider("claude", mergedClaudeConfig);
-    const encryptedCodexProviders = encryptProviders(codexMergeResult.merged, password);
-    const encryptedClaudeProviders = encryptProviders(claudeMergeResult.merged, password);
-    const encryptedCodexConfig = {
-      ...mergedCodexConfig,
-      // 保留合并后配置的所有字段
-      providers: encryptedCodexProviders
-      // 只替换 providers（加密后的）
-    };
-    const encryptedClaudeConfig = {
-      ...mergedClaudeConfig,
-      // 保留合并后配置的所有字段
-      providers: encryptedClaudeProviders
-      // 只替换 providers（加密后的）
-    };
-    const codexJson2 = JSON.stringify(encryptedCodexConfig, null, 2);
-    const claudeJson2 = JSON.stringify(encryptedClaudeConfig, null, 2);
-    await uploadToWebDAV(config, CODEX_REMOTE_PATH, codexJson2);
-    await uploadToWebDAV(config, CLAUDE_REMOTE_PATH, claudeJson2);
+    for (let i = 0; i < mergeDataList.length; i++) {
+      const { tool, localConfig, mergeResult } = mergeDataList[i];
+      const { remotePath, configFilename } = TOOL_SYNC_CONFIG[tool];
+      const configPath = path8.join(ccmanDir2, configFilename);
+      let remoteConfig = null;
+      if (existsChecks[i]) {
+        const jsonContent2 = await downloadFromWebDAV(config, remotePath);
+        remoteConfig = JSON.parse(jsonContent2);
+      }
+      const mergedPresets = mergePresets(localConfig.presets, remoteConfig?.presets);
+      const mergedConfig = {
+        ...localConfig,
+        // 保留本地配置的所有字段
+        providers: mergeResult.merged,
+        // 替换为合并后的 providers
+        presets: mergedPresets
+        // 替换为合并后的 presets
+      };
+      writeJSON(configPath, mergedConfig);
+      applyCurrentProvider(tool, mergedConfig);
+      const encryptedProviders = encryptProviders(mergeResult.merged, password);
+      const encryptedConfig = {
+        ...mergedConfig,
+        // 保留合并后配置的所有字段
+        providers: encryptedProviders
+        // 只替换 providers（加密后的）
+      };
+      const jsonContent = JSON.stringify(encryptedConfig, null, 2);
+      await uploadToWebDAV(config, remotePath, jsonContent);
+    }
     updateLastSyncTime();
     console.log("\u2705 \u914D\u7F6E\u5DF2\u5408\u5E76\u5E76\u540C\u6B65\u5230\u4E91\u7AEF");
     return {
@@ -1570,8 +1747,8 @@ async function mergeSync(config, password) {
   } catch (error) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
-      if (fs7.existsSync(backupPath)) {
-        fs7.copyFileSync(backupPath, originalPath);
+      if (fs8.existsSync(backupPath)) {
+        fs8.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5408\u5E76\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -1585,13 +1762,10 @@ function applyCurrentProvider(tool, config) {
   if (!provider) {
     return;
   }
-  if (tool === "codex") {
-    writeCodexConfig(provider);
-  } else {
-    writeClaudeConfig(provider);
-  }
+  const { writerFunc } = TOOL_SYNC_CONFIG[tool];
+  writerFunc(provider);
 }
-var CODEX_REMOTE_PATH, CLAUDE_REMOTE_PATH;
+var TOOL_SYNC_CONFIG;
 var init_sync_v2 = __esm({
   "../core/dist/sync/sync-v2.js"() {
     "use strict";
@@ -1604,13 +1778,30 @@ var init_sync_v2 = __esm({
     init_file();
     init_codex();
     init_claude();
-    CODEX_REMOTE_PATH = ".ccman/codex.json";
-    CLAUDE_REMOTE_PATH = ".ccman/claude.json";
+    init_gemini2();
+    init_constants();
+    TOOL_SYNC_CONFIG = {
+      [MAIN_TOOL_TYPES.CODEX]: {
+        remotePath: ".ccman/codex.json",
+        configFilename: "codex.json",
+        writerFunc: writeCodexConfig
+      },
+      [MAIN_TOOL_TYPES.CLAUDE]: {
+        remotePath: ".ccman/claude.json",
+        configFilename: "claude.json",
+        writerFunc: writeClaudeConfig
+      },
+      [MAIN_TOOL_TYPES.GEMINI]: {
+        remotePath: ".ccman/gemini.json",
+        configFilename: "gemini.json",
+        writerFunc: writeGeminiConfig
+      }
+    };
   }
 });
 
 // ../core/dist/export.js
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path9 from "path";
 function validateExport() {
   const ccmanDir2 = getCcmanDir();
@@ -1640,7 +1831,7 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const stats = fs8.statSync(sourceDir);
+  const stats = fs9.statSync(sourceDir);
   if (!stats.isDirectory()) {
     return {
       valid: false,
@@ -1680,13 +1871,13 @@ function exportConfig(targetDir) {
   const codexSrc = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
   const codexDst = path9.join(targetDir, CODEX_CONFIG_FILE);
   if (fileExists(codexSrc)) {
-    fs8.copyFileSync(codexSrc, codexDst);
+    fs9.copyFileSync(codexSrc, codexDst);
     exportedFiles.push(CODEX_CONFIG_FILE);
   }
   const claudeSrc = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
   const claudeDst = path9.join(targetDir, CLAUDE_CONFIG_FILE);
   if (fileExists(claudeSrc)) {
-    fs8.copyFileSync(claudeSrc, claudeDst);
+    fs9.copyFileSync(claudeSrc, claudeDst);
     exportedFiles.push(CLAUDE_CONFIG_FILE);
   }
   return {
@@ -1712,7 +1903,7 @@ function importConfig(sourceDir) {
         backupPaths.push(backupPath);
       }
       const codexSrc = path9.join(sourceDir, CODEX_CONFIG_FILE);
-      fs8.copyFileSync(codexSrc, codexDst);
+      fs9.copyFileSync(codexSrc, codexDst);
       importedFiles.push(CODEX_CONFIG_FILE);
     }
     if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
@@ -1722,7 +1913,7 @@ function importConfig(sourceDir) {
         backupPaths.push(backupPath);
       }
       const claudeSrc = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
-      fs8.copyFileSync(claudeSrc, claudeDst);
+      fs9.copyFileSync(claudeSrc, claudeDst);
       importedFiles.push(CLAUDE_CONFIG_FILE);
     }
     return {
@@ -1734,7 +1925,7 @@ function importConfig(sourceDir) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
       if (fileExists(backupPath)) {
-        fs8.copyFileSync(backupPath, originalPath);
+        fs9.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -1753,7 +1944,7 @@ var init_export = __esm({
 });
 
 // ../core/dist/claude-clean.js
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 function formatBytes(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
@@ -1763,7 +1954,7 @@ function formatBytes(bytes) {
 }
 function getFileSize(filePath) {
   try {
-    const stats = fs9.statSync(filePath);
+    const stats = fs10.statSync(filePath);
     return stats.size;
   } catch {
     return 0;
@@ -1772,18 +1963,18 @@ function getFileSize(filePath) {
 function backupFile(filePath) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").split(".")[0];
   const backupPath = `${filePath}.backup-${timestamp}`;
-  fs9.copyFileSync(filePath, backupPath);
+  fs10.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 function saveJsonAtomic(filePath, data) {
   const tempPath = `${filePath}.tmp`;
   const content = JSON.stringify(data, null, 2);
-  fs9.writeFileSync(tempPath, content, { mode: 384 });
-  fs9.renameSync(tempPath, filePath);
+  fs10.writeFileSync(tempPath, content, { mode: 384 });
+  fs10.renameSync(tempPath, filePath);
 }
 function analyzeClaudeJson() {
   const filePath = getClaudeJsonPath();
-  if (!fs9.existsSync(filePath)) {
+  if (!fs10.existsSync(filePath)) {
     return {
       fileSize: 0,
       fileSizeFormatted: "0 B",
@@ -1799,7 +1990,7 @@ function analyzeClaudeJson() {
     };
   }
   const fileSize = getFileSize(filePath);
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const content = fs10.readFileSync(filePath, "utf-8");
   const config = JSON.parse(content);
   const projects = config.projects || {};
   const projectHistory = [];
@@ -1833,12 +2024,12 @@ function analyzeClaudeJson() {
 }
 function cleanClaudeJson(options = {}) {
   const filePath = getClaudeJsonPath();
-  if (!fs9.existsSync(filePath)) {
+  if (!fs10.existsSync(filePath)) {
     throw new Error(`${filePath} \u6587\u4EF6\u4E0D\u5B58\u5728`);
   }
   const backupPath = backupFile(filePath);
   const sizeBefore = getFileSize(filePath);
-  const content = fs9.readFileSync(filePath, "utf-8");
+  const content = fs10.readFileSync(filePath, "utf-8");
   const config = JSON.parse(content);
   const cleanedItems = applyCleanOptions(config, options);
   saveJsonAtomic(filePath, config);
@@ -1919,10 +2110,12 @@ var init_dist = __esm({
   "../core/dist/index.js"() {
     "use strict";
     init_package();
+    init_constants();
     init_tool_manager();
     init_codex2();
     init_claude2();
     init_mcp2();
+    init_gemini();
     init_mcp();
     init_migrate();
     init_paths();
@@ -2646,7 +2839,7 @@ var init_sync = __esm({
 
 // src/index.ts
 import { Command as Command3 } from "commander";
-import chalk33 from "chalk";
+import chalk40 from "chalk";
 
 // src/utils/logo.ts
 init_dist();
@@ -2705,6 +2898,21 @@ function formatProviderTable(providers, currentId) {
 }
 
 // src/interactive.ts
+var CLI_TOOL_CONFIG = {
+  [TOOL_TYPES.CODEX]: { name: "Codex", emoji: "\u{1F536}", cmd: "cx" },
+  [TOOL_TYPES.CLAUDE]: { name: "Claude", emoji: "\u{1F537}", cmd: "cc" },
+  [TOOL_TYPES.GEMINI]: { name: "Gemini", emoji: "\u{1F48E}", cmd: "gm" }
+};
+function getManager(tool) {
+  switch (tool) {
+    case TOOL_TYPES.CODEX:
+      return createCodexManager();
+    case TOOL_TYPES.CLAUDE:
+      return createClaudeManager();
+    case TOOL_TYPES.GEMINI:
+      return createGeminiManager();
+  }
+}
 async function promptProviderForm(defaults) {
   const answers = await inquirer7.prompt([
     {
@@ -2766,6 +2974,7 @@ async function startMainMenu() {
         choices: [
           { name: "\u{1F537} Claude \u7BA1\u7406", value: "claude" },
           { name: "\u{1F536} Codex \u7BA1\u7406", value: "codex" },
+          { name: "\u{1F48E} Gemini \u7BA1\u7406", value: "gemini" },
           { name: "\u{1F504} WebDAV \u540C\u6B65", value: "sync" },
           { name: "\u{1F4E6} \u9884\u7F6E\u670D\u52A1\u5546\u7BA1\u7406", value: "presets" },
           { name: "\u274C \u9000\u51FA", value: "exit" }
@@ -2780,6 +2989,8 @@ async function startMainMenu() {
       await startClaudeMenu();
     } else if (choice === "codex") {
       await startCodexMenu();
+    } else if (choice === "gemini") {
+      await startGeminiMenu();
     } else if (choice === "sync") {
       const { startSyncMenu: startSyncMenu2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
       await startSyncMenu2();
@@ -2789,14 +3000,16 @@ async function startMainMenu() {
   }
 }
 async function startClaudeMenu() {
-  await showToolMenu("claude");
+  await showToolMenu(TOOL_TYPES.CLAUDE);
 }
 async function startCodexMenu() {
-  await showToolMenu("codex");
+  await showToolMenu(TOOL_TYPES.CODEX);
+}
+async function startGeminiMenu() {
+  await showToolMenu(TOOL_TYPES.GEMINI);
 }
 async function showToolMenu(tool) {
-  const toolName = tool === "claude" ? "Claude" : "Codex";
-  const toolEmoji = tool === "claude" ? "\u{1F537}" : "\u{1F536}";
+  const { name: toolName, emoji: toolEmoji } = CLI_TOOL_CONFIG[tool];
   while (true) {
     console.log();
     const { action } = await inquirer7.prompt([
@@ -2810,7 +3023,7 @@ async function showToolMenu(tool) {
           { name: "\u{1F4CB} \u5217\u51FA\u6240\u6709\u670D\u52A1\u5546", value: "list" },
           { name: "\u{1F441}\uFE0F  \u67E5\u770B\u5F53\u524D\u670D\u52A1\u5546", value: "current" },
           { name: "\u270F\uFE0F  \u7F16\u8F91\u670D\u52A1\u5546", value: "edit" },
-          { name: "\u{1F4CB} \u514B\u9686\u670D\u52A1\u5546", value: "clone" },
+          { name: "\u{1F501} \u514B\u9686\u670D\u52A1\u5546", value: "clone" },
           { name: "\u{1F5D1}\uFE0F  \u5220\u9664\u670D\u52A1\u5546", value: "remove" },
           { name: "\u2B05\uFE0F  \u8FD4\u56DE\u4E0A\u7EA7", value: "back" }
         ]
@@ -2861,8 +3074,8 @@ async function showPresetsMenu() {
   console.log(chalk11.yellow("\n\u26A0\uFE0F  \u9884\u7F6E\u670D\u52A1\u5546\u7BA1\u7406\u529F\u80FD\u5373\u5C06\u63A8\u51FA\n"));
 }
 async function handleAdd(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
-  const toolName = tool === "claude" ? "Claude" : "Codex";
+  const manager = getManager(tool);
+  const { name: toolName, cmd } = CLI_TOOL_CONFIG[tool];
   const presets = manager.listPresets();
   console.log(chalk11.bold(`
 \u{1F4DD} \u6DFB\u52A0 ${toolName} \u670D\u52A1\u5546
@@ -2960,14 +3173,12 @@ async function handleAdd(tool) {
     manager.switch(provider.id);
     console.log(chalk11.green("\u2705 \u5DF2\u5207\u6362\u5230\u65B0\u670D\u52A1\u5546\n"));
   } else {
-    console.log(
-      chalk11.blue("\u{1F4A1} \u7A0D\u540E\u5207\u6362:") + chalk11.white(` ccman ${tool === "codex" ? "cx" : "cc"} use "${provider.name}"
-`)
-    );
+    console.log(chalk11.blue("\u{1F4A1} \u7A0D\u540E\u5207\u6362:") + chalk11.white(` ccman ${cmd} use "${provider.name}"
+`));
   }
 }
 async function handleSwitch(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
+  const manager = getManager(tool);
   const providers = manager.list();
   const current = manager.getCurrent();
   if (providers.length === 0) {
@@ -2992,10 +3203,10 @@ async function handleSwitch(tool) {
 `));
 }
 async function handleList(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
+  const manager = getManager(tool);
   const providers = manager.list();
   const current = manager.getCurrent();
-  const toolName = tool === "claude" ? "Claude" : "Codex";
+  const { name: toolName } = CLI_TOOL_CONFIG[tool];
   if (providers.length === 0) {
     console.log(chalk11.yellow(`
 \u26A0\uFE0F  \u6682\u65E0 ${toolName} \u670D\u52A1\u5546
@@ -3007,9 +3218,9 @@ async function handleList(tool) {
   console.log(formatProviderTable(providers, current?.id));
 }
 async function handleCurrent(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
+  const manager = getManager(tool);
   const current = manager.getCurrent();
-  const toolName = tool === "claude" ? "Claude" : "Codex";
+  const { name: toolName } = CLI_TOOL_CONFIG[tool];
   if (!current) {
     console.log(chalk11.yellow(`
 \u26A0\uFE0F  \u672A\u9009\u62E9\u4EFB\u4F55 ${toolName} \u670D\u52A1\u5546
@@ -3028,7 +3239,7 @@ async function handleCurrent(tool) {
   console.log();
 }
 async function handleEdit(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
+  const manager = getManager(tool);
   const providers = manager.list();
   if (providers.length === 0) {
     console.log(chalk11.yellow("\n\u26A0\uFE0F  \u6682\u65E0\u670D\u52A1\u5546\n"));
@@ -3089,7 +3300,7 @@ async function handleEdit(tool) {
   console.log(chalk11.green("\n\u2705 \u7F16\u8F91\u6210\u529F\n"));
 }
 async function handleClone(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
+  const manager = getManager(tool);
   const providers = manager.list();
   if (providers.length === 0) {
     console.log(chalk11.yellow("\n\u26A0\uFE0F  \u6682\u65E0\u670D\u52A1\u5546\n"));
@@ -3136,7 +3347,7 @@ async function handleClone(tool) {
   console.log();
 }
 async function handleRemove(tool) {
-  const manager = tool === "codex" ? createCodexManager() : createClaudeManager();
+  const manager = getManager(tool);
   const providers = manager.list();
   if (providers.length === 0) {
     console.log(chalk11.yellow("\n\u26A0\uFE0F  \u6682\u65E0\u670D\u52A1\u5546\n"));
@@ -4648,7 +4859,7 @@ function editCommand3(program2) {
         targetId = selectedId;
       }
       const provider = manager.get(targetId);
-      const currentCommand3 = provider.baseUrl;
+      const currentCommand4 = provider.baseUrl;
       const currentArgs = provider.apiKey;
       const currentEnv = provider.model;
       console.log(chalk30.bold("\n\u270F\uFE0F  \u7F16\u8F91 MCP \u670D\u52A1\u5668\n"));
@@ -4664,7 +4875,7 @@ function editCommand3(program2) {
           type: "input",
           name: "command",
           message: "\u542F\u52A8\u547D\u4EE4:",
-          default: currentCommand3
+          default: currentCommand4
         },
         {
           type: "input",
@@ -4683,7 +4894,7 @@ function editCommand3(program2) {
       if (answers.name && answers.name !== provider.name) {
         updates.name = answers.name;
       }
-      if (answers.command && answers.command !== currentCommand3) {
+      if (answers.command && answers.command !== currentCommand4) {
         updates.baseUrl = answers.command;
       }
       if (answers.args && answers.args !== currentArgs) {
@@ -4732,44 +4943,480 @@ function createMCPCommands(program2) {
   editCommand3(program2);
 }
 
+// src/commands/gemini/add.ts
+init_dist();
+import chalk31 from "chalk";
+import inquirer22 from "inquirer";
+function addCommand4(program2) {
+  program2.command("add").description("\u6DFB\u52A0\u65B0\u7684 Gemini CLI \u670D\u52A1\u5546(\u4EA4\u4E92\u5F0F)").action(async () => {
+    try {
+      const manager = createGeminiManager();
+      console.log(chalk31.bold("\n\u{1F4DD} \u6DFB\u52A0 Gemini CLI \u670D\u52A1\u5546\n"));
+      const { usePreset } = await inquirer22.prompt([
+        {
+          type: "list",
+          name: "usePreset",
+          message: "\u9009\u62E9\u914D\u7F6E\u6765\u6E90:",
+          choices: [
+            { name: "\u{1F4E6} \u4F7F\u7528\u9884\u7F6E\u670D\u52A1\u5546", value: true },
+            { name: "\u270F\uFE0F  \u81EA\u5B9A\u4E49\u914D\u7F6E", value: false }
+          ]
+        }
+      ]);
+      let name;
+      let desc;
+      let baseUrl;
+      let apiKey;
+      if (usePreset) {
+        const { presetName } = await inquirer22.prompt([
+          {
+            type: "list",
+            name: "presetName",
+            message: "\u9009\u62E9\u9884\u7F6E\u670D\u52A1\u5546:",
+            choices: GEMINI_PRESETS.map((p) => ({
+              name: `${p.name} - ${p.description}`,
+              value: p.name
+            }))
+          }
+        ]);
+        const preset = GEMINI_PRESETS.find((p) => p.name === presetName);
+        console.log(chalk31.blue(`
+\u4F7F\u7528\u9884\u8BBE: ${preset.name} - ${preset.description}
+`));
+        const input = await promptProviderForm({
+          name: preset.name,
+          desc: "",
+          baseUrl: preset.baseUrl,
+          apiKey: ""
+        });
+        name = input.name;
+        desc = input.desc;
+        baseUrl = input.baseUrl;
+        apiKey = input.apiKey;
+      } else {
+        const answers = await inquirer22.prompt([
+          {
+            type: "input",
+            name: "name",
+            message: "\u670D\u52A1\u5546\u540D\u79F0:",
+            validate: (value) => {
+              if (!value) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+              return true;
+            }
+          },
+          {
+            type: "input",
+            name: "baseUrl",
+            message: "API \u5730\u5740 (\u53EF\u4E3A\u7A7A\uFF0C\u4F7F\u7528\u5B98\u65B9\u9ED8\u8BA4):",
+            validate: (value) => {
+              if (!value) return true;
+              if (!value.startsWith("http://") && !value.startsWith("https://")) {
+                return "API \u5730\u5740\u5FC5\u987B\u4EE5 http:// \u6216 https:// \u5F00\u5934";
+              }
+              return true;
+            }
+          },
+          {
+            type: "password",
+            name: "apiKey",
+            message: "API \u5BC6\u94A5 (\u53EF\u4E3A\u7A7A\uFF0C\u4F7F\u7528\u73AF\u5883\u5DF2\u914D\u7F6E\u7684 Key):",
+            mask: "*"
+          }
+        ]);
+        name = answers.name;
+        desc = void 0;
+        baseUrl = answers.baseUrl || "";
+        apiKey = answers.apiKey || "";
+      }
+      const provider = manager.add({ name, desc, baseUrl, apiKey });
+      console.log();
+      console.log(chalk31.green("\u2705 \u6DFB\u52A0\u6210\u529F"));
+      console.log();
+      console.log(`  ${chalk31.bold(provider.name)} ${chalk31.blue("[Gemini CLI]")}`);
+      console.log(`  ${chalk31.gray(provider.baseUrl || "(\u4F7F\u7528\u9ED8\u8BA4\u7AEF\u70B9)")}`);
+      console.log();
+      const { switchNow } = await inquirer22.prompt([
+        {
+          type: "confirm",
+          name: "switchNow",
+          message: "\u662F\u5426\u7ACB\u5373\u5207\u6362\u5230\u6B64\u670D\u52A1\u5546?",
+          default: true
+        }
+      ]);
+      if (switchNow) {
+        manager.switch(provider.id);
+        console.log(chalk31.green("\u2705 \u5DF2\u5207\u6362\u5230\u65B0\u670D\u52A1\u5546"));
+        console.log();
+        console.log(chalk31.gray("\u914D\u7F6E\u5DF2\u66F4\u65B0:"));
+        console.log(chalk31.gray(`  - ${getGeminiSettingsPath()}`));
+        console.log(chalk31.gray(`  - ${getGeminiEnvPath()}`));
+      } else {
+        console.log(chalk31.blue("\u{1F4A1} \u7A0D\u540E\u5207\u6362:") + chalk31.white(` ccman gm use "${provider.name}"`));
+      }
+    } catch (error) {
+      console.error(chalk31.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/list.ts
+init_dist();
+import chalk32 from "chalk";
+function listCommand4(program2) {
+  program2.command("list").alias("ls").description("\u5217\u51FA\u6240\u6709 Gemini CLI \u670D\u52A1\u5546").action(async () => {
+    try {
+      const manager = createGeminiManager();
+      const providers = manager.list();
+      const current = manager.getCurrent();
+      if (providers.length === 0) {
+        console.log(chalk32.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Gemini CLI \u670D\u52A1\u5546\n"));
+        console.log(chalk32.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk32.white(" ccman gm add\n"));
+        return;
+      }
+      console.log(chalk32.bold(`
+\u{1F4CB} Gemini CLI \u670D\u52A1\u5546 (${providers.length} \u4E2A)`));
+      console.log(formatProviderTable(providers, current?.id));
+    } catch (error) {
+      console.error(chalk32.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/use.ts
+init_dist();
+import chalk33 from "chalk";
+import inquirer23 from "inquirer";
+function useCommand3(program2) {
+  program2.command("use [name]").description("\u5207\u6362 Gemini CLI \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createGeminiManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk33.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Gemini CLI \u670D\u52A1\u5546\n"));
+        console.log(chalk33.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk33.white(" ccman gm add\n"));
+        return;
+      }
+      let targetId;
+      if (name) {
+        const provider2 = manager.findByName(name);
+        if (!provider2) {
+          throw new ProviderNotFoundError(name);
+        }
+        targetId = provider2.id;
+      } else {
+        const { selectedId } = await inquirer23.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u5207\u6362\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)"}`,
+              value: p.id
+            }))
+          }
+        ]);
+        targetId = selectedId;
+      }
+      manager.switch(targetId);
+      const provider = manager.get(targetId);
+      console.log();
+      console.log(chalk33.green("\u2705 \u5207\u6362\u6210\u529F"));
+      console.log();
+      console.log(`  ${chalk33.bold(provider.name)} ${chalk33.blue("[Gemini CLI]")}`);
+      console.log(`  ${chalk33.gray(`URL: ${provider.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)"}`)}`);
+      console.log();
+      console.log(chalk33.gray("\u914D\u7F6E\u5DF2\u66F4\u65B0:"));
+      console.log(chalk33.gray(`  - ${getGeminiSettingsPath()}`));
+      console.log(chalk33.gray(`  - ${getGeminiEnvPath()}`));
+      console.log();
+    } catch (error) {
+      if (error instanceof ProviderNotFoundError) {
+        console.error(chalk33.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${error.message}
+`));
+        console.log(chalk33.blue("\u{1F4A1} \u67E5\u770B\u6240\u6709\u670D\u52A1\u5546:") + chalk33.white(" ccman gm list\n"));
+      } else {
+        console.error(chalk33.red(`
+\u274C ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/current.ts
+init_dist();
+import chalk34 from "chalk";
+function currentCommand3(program2) {
+  program2.command("current").description("\u663E\u793A\u5F53\u524D Gemini CLI \u670D\u52A1\u5546").action(async () => {
+    try {
+      const manager = createGeminiManager();
+      const current = manager.getCurrent();
+      if (!current) {
+        console.log(chalk34.yellow("\n\u26A0\uFE0F  \u5F53\u524D\u6CA1\u6709\u6FC0\u6D3B\u7684 Gemini CLI \u670D\u52A1\u5546\n"));
+        console.log(chalk34.blue("\u{1F4A1} \u5217\u51FA\u670D\u52A1\u5546:") + chalk34.white(" ccman gm list\n"));
+        return;
+      }
+      console.log(chalk34.bold("\n\u{1F3AF} \u5F53\u524D Gemini CLI \u670D\u52A1\u5546\n"));
+      console.log(`  \u540D\u79F0: ${chalk34.bold(current.name)}`);
+      console.log(`  \u5730\u5740: ${chalk34.gray(current.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)")}`);
+      console.log();
+    } catch (error) {
+      console.error(chalk34.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/remove.ts
+init_dist();
+import chalk35 from "chalk";
+import inquirer24 from "inquirer";
+function removeCommand4(program2) {
+  program2.command("remove [name]").alias("rm").description("\u5220\u9664 Gemini CLI \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createGeminiManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk35.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Gemini CLI \u670D\u52A1\u5546\n"));
+        console.log(chalk35.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk35.white(" ccman gm add\n"));
+        return;
+      }
+      let targetId;
+      let targetName;
+      if (name) {
+        const provider = manager.findByName(name);
+        if (!provider) {
+          console.log(chalk35.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${name}
+`));
+          process.exit(1);
+        }
+        targetId = provider.id;
+        targetName = provider.name;
+      } else {
+        const { selectedId } = await inquirer24.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u5220\u9664\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)"}`,
+              value: p.id
+            }))
+          }
+        ]);
+        const provider = manager.get(selectedId);
+        targetId = provider.id;
+        targetName = provider.name;
+      }
+      const { confirm } = await inquirer24.prompt([
+        {
+          type: "confirm",
+          name: "confirm",
+          message: `\u786E\u5B9A\u8981\u5220\u9664\u670D\u52A1\u5546 "${targetName}" \u5417\uFF1F`,
+          default: false
+        }
+      ]);
+      if (!confirm) {
+        console.log(chalk35.gray("\n\u5DF2\u53D6\u6D88\u5220\u9664\n"));
+        return;
+      }
+      manager.remove(targetId);
+      console.log(chalk35.green("\n\u2705 \u5DF2\u5220\u9664\u670D\u52A1\u5546\n"));
+    } catch (error) {
+      console.error(chalk35.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/edit.ts
+init_dist();
+import chalk36 from "chalk";
+import inquirer25 from "inquirer";
+function editCommand4(program2) {
+  program2.command("edit [name]").description("\u7F16\u8F91 Gemini CLI \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createGeminiManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk36.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Gemini CLI \u670D\u52A1\u5546\n"));
+        console.log(chalk36.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk36.white(" ccman gm add\n"));
+        return;
+      }
+      let targetId;
+      if (name) {
+        const provider2 = manager.findByName(name);
+        if (!provider2) {
+          console.log(chalk36.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${name}
+`));
+          process.exit(1);
+        }
+        targetId = provider2.id;
+      } else {
+        const { selectedId } = await inquirer25.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u7F16\u8F91\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)"}`,
+              value: p.id
+            }))
+          }
+        ]);
+        targetId = selectedId;
+      }
+      const provider = manager.get(targetId);
+      const input = await promptProviderForm({
+        name: provider.name,
+        desc: provider.desc ?? "",
+        baseUrl: provider.baseUrl,
+        apiKey: provider.apiKey
+      });
+      manager.edit(targetId, {
+        name: input.name,
+        desc: input.desc,
+        baseUrl: input.baseUrl,
+        apiKey: input.apiKey
+      });
+      console.log(chalk36.green("\n\u2705 \u7F16\u8F91\u6210\u529F\n"));
+    } catch (error) {
+      console.error(chalk36.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/clone.ts
+init_dist();
+import chalk37 from "chalk";
+import inquirer26 from "inquirer";
+function cloneCommand3(program2) {
+  program2.command("clone [name]").description("\u514B\u9686 Gemini CLI \u670D\u52A1\u5546").action(async (name) => {
+    try {
+      const manager = createGeminiManager();
+      const providers = manager.list();
+      if (providers.length === 0) {
+        console.log(chalk37.yellow("\n\u26A0\uFE0F  \u6682\u65E0 Gemini CLI \u670D\u52A1\u5546\n"));
+        console.log(chalk37.blue("\u{1F4A1} \u6DFB\u52A0\u670D\u52A1\u5546:") + chalk37.white(" ccman gm add\n"));
+        return;
+      }
+      let sourceId;
+      if (name) {
+        const provider = manager.findByName(name);
+        if (!provider) {
+          console.log(chalk37.red(`
+\u274C \u670D\u52A1\u5546\u4E0D\u5B58\u5728: ${name}
+`));
+          process.exit(1);
+        }
+        sourceId = provider.id;
+      } else {
+        const { selectedId } = await inquirer26.prompt([
+          {
+            type: "list",
+            name: "selectedId",
+            message: "\u9009\u62E9\u8981\u514B\u9686\u7684\u670D\u52A1\u5546:",
+            choices: providers.map((p) => ({
+              name: `${p.name} - ${p.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)"}`,
+              value: p.id
+            }))
+          }
+        ]);
+        sourceId = selectedId;
+      }
+      const { newName } = await inquirer26.prompt([
+        {
+          type: "input",
+          name: "newName",
+          message: "\u8F93\u5165\u65B0\u670D\u52A1\u5546\u540D\u79F0:",
+          validate: (value) => {
+            if (!value) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+            return true;
+          }
+        }
+      ]);
+      const newProvider = manager.clone(sourceId, newName);
+      console.log();
+      console.log(chalk37.green("\u2705 \u514B\u9686\u6210\u529F"));
+      console.log();
+      console.log(`  ${chalk37.bold(newProvider.name)} ${chalk37.blue("[Gemini CLI]")}`);
+      console.log(`  ${chalk37.gray(newProvider.baseUrl || "(\u9ED8\u8BA4\u7AEF\u70B9)")}`);
+      console.log();
+    } catch (error) {
+      console.error(chalk37.red(`
+\u274C ${error.message}
+`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/gemini/index.ts
+function createGeminiCommands(program2) {
+  addCommand4(program2);
+  listCommand4(program2);
+  useCommand3(program2);
+  currentCommand3(program2);
+  removeCommand4(program2);
+  editCommand4(program2);
+  cloneCommand3(program2);
+}
+
 // src/index.ts
 init_sync();
 
 // src/commands/export.ts
 init_dist();
-import chalk31 from "chalk";
+import chalk38 from "chalk";
 import path10 from "path";
 function exportCommand(program2) {
   program2.command("export <\u76EE\u6807\u76EE\u5F55>").description("\u5BFC\u51FA\u914D\u7F6E\u5230\u672C\u5730\u76EE\u5F55\uFF08\u5305\u542B API Key\uFF09").action(async (targetDir) => {
     try {
-      console.log(chalk31.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
+      console.log(chalk38.bold("\n\u{1F4E6} \u5BFC\u51FA\u914D\u7F6E\n"));
       const validation = validateExport();
       if (!validation.valid) {
-        console.log(chalk31.red(`\u274C ${validation.message}
+        console.log(chalk38.red(`\u274C ${validation.message}
 `));
         process.exit(1);
       }
       const resolvedPath = targetDir.startsWith("~") ? path10.join(process.env.HOME || "", targetDir.slice(1)) : path10.resolve(targetDir);
       console.log("\u5BFC\u51FA\u6587\u4EF6:");
-      console.log(`  ${chalk31.cyan("codex.json")}  - Codex \u914D\u7F6E`);
-      console.log(`  ${chalk31.cyan("claude.json")} - Claude \u914D\u7F6E`);
+      console.log(`  ${chalk38.cyan("codex.json")}  - Codex \u914D\u7F6E`);
+      console.log(`  ${chalk38.cyan("claude.json")} - Claude \u914D\u7F6E`);
       console.log();
-      console.log(`\u76EE\u6807\u76EE\u5F55: ${chalk31.cyan(resolvedPath)}`);
+      console.log(`\u76EE\u6807\u76EE\u5F55: ${chalk38.cyan(resolvedPath)}`);
       console.log();
-      console.log(chalk31.yellow("\u26A0\uFE0F  \u5BFC\u51FA\u6587\u4EF6\u5305\u542B API Key\uFF0C\u8BF7\u59A5\u5584\u4FDD\u7BA1"));
+      console.log(chalk38.yellow("\u26A0\uFE0F  \u5BFC\u51FA\u6587\u4EF6\u5305\u542B API Key\uFF0C\u8BF7\u59A5\u5584\u4FDD\u7BA1"));
       console.log();
       const result = exportConfig(resolvedPath);
-      console.log(chalk31.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
+      console.log(chalk38.green("\u2705 \u5BFC\u51FA\u6210\u529F"));
       console.log();
       console.log("\u5DF2\u5BFC\u51FA\u6587\u4EF6:");
       for (const file of result.exportedFiles) {
-        console.log(`  ${chalk31.cyan("\u2713")} ${file}`);
+        console.log(`  ${chalk38.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(chalk31.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
+      console.log(chalk38.blue(`\u{1F4A1} \u5BFC\u5165\u547D\u4EE4: ccman import ${resolvedPath}
 `));
     } catch (error) {
-      console.error(chalk31.red(`
+      console.error(chalk38.red(`
 \u274C ${error.message}
 `));
       process.exit(1);
@@ -4779,31 +5426,31 @@ function exportCommand(program2) {
 
 // src/commands/import.ts
 init_dist();
-import chalk32 from "chalk";
-import inquirer22 from "inquirer";
+import chalk39 from "chalk";
+import inquirer27 from "inquirer";
 import path11 from "path";
 function importCommand(program2) {
   program2.command("import <\u6E90\u76EE\u5F55>").description("\u4ECE\u672C\u5730\u76EE\u5F55\u5BFC\u5165\u914D\u7F6E\uFF08\u4F1A\u8986\u76D6\u5F53\u524D\u914D\u7F6E\uFF09").action(async (sourceDir) => {
     try {
       const resolvedPath = sourceDir.startsWith("~") ? path11.join(process.env.HOME || "", sourceDir.slice(1)) : path11.resolve(sourceDir);
-      console.log(chalk32.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
+      console.log(chalk39.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {
-        console.log(chalk32.red(`\u274C ${validation.message}
+        console.log(chalk39.red(`\u274C ${validation.message}
 `));
         process.exit(1);
       }
-      console.log(chalk32.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
-      console.log(`\u6E90\u76EE\u5F55: ${chalk32.cyan(resolvedPath)}`);
+      console.log(chalk39.yellow("\u26A0\uFE0F  \u8B66\u544A\uFF1A\u5BFC\u5165\u5C06\u8986\u76D6\u5F53\u524D\u914D\u7F6E\n"));
+      console.log(`\u6E90\u76EE\u5F55: ${chalk39.cyan(resolvedPath)}`);
       console.log();
       console.log("\u627E\u5230\u914D\u7F6E\u6587\u4EF6:");
       for (const file of validation.foundFiles) {
-        console.log(`  ${chalk32.cyan("\u2713")} ${file}`);
+        console.log(`  ${chalk39.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(chalk32.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
+      console.log(chalk39.gray("\u5F53\u524D\u914D\u7F6E\u5C06\u88AB\u8986\u76D6\uFF08\u81EA\u52A8\u5907\u4EFD\uFF09"));
       console.log();
-      const { confirmFirst } = await inquirer22.prompt([
+      const { confirmFirst } = await inquirer27.prompt([
         {
           type: "confirm",
           name: "confirmFirst",
@@ -4812,13 +5459,13 @@ function importCommand(program2) {
         }
       ]);
       if (!confirmFirst) {
-        console.log(chalk32.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        console.log(chalk39.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
         return;
       }
       console.log();
-      console.log(chalk32.red.bold("\u26A0\uFE0F  \u6700\u540E\u786E\u8BA4\uFF1A\u6B64\u64CD\u4F5C\u5C06\u8986\u76D6\u6240\u6709\u5F53\u524D\u914D\u7F6E\uFF01"));
+      console.log(chalk39.red.bold("\u26A0\uFE0F  \u6700\u540E\u786E\u8BA4\uFF1A\u6B64\u64CD\u4F5C\u5C06\u8986\u76D6\u6240\u6709\u5F53\u524D\u914D\u7F6E\uFF01"));
       console.log();
-      const { confirmSecond } = await inquirer22.prompt([
+      const { confirmSecond } = await inquirer27.prompt([
         {
           type: "confirm",
           name: "confirmSecond",
@@ -4827,31 +5474,31 @@ function importCommand(program2) {
         }
       ]);
       if (!confirmSecond) {
-        console.log(chalk32.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
+        console.log(chalk39.gray("\n\u274C \u5DF2\u53D6\u6D88\n"));
         return;
       }
       console.log();
-      console.log(chalk32.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
-      console.log(chalk32.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
+      console.log(chalk39.gray("\u{1F4BE} \u5907\u4EFD\u5F53\u524D\u914D\u7F6E..."));
+      console.log(chalk39.gray("\u{1F4E5} \u5BFC\u5165\u65B0\u914D\u7F6E..."));
       const result = importConfig(resolvedPath);
       console.log();
-      console.log(chalk32.green("\u2705 \u5BFC\u5165\u6210\u529F"));
+      console.log(chalk39.green("\u2705 \u5BFC\u5165\u6210\u529F"));
       console.log();
       if (result.backupPaths.length > 0) {
         console.log("\u5907\u4EFD\u6587\u4EF6:");
         for (const backupPath of result.backupPaths) {
-          console.log(`  ${chalk32.gray(backupPath)}`);
+          console.log(`  ${chalk39.gray(backupPath)}`);
         }
         console.log();
       }
       console.log("\u5DF2\u5BFC\u5165\u6587\u4EF6:");
       for (const file of result.importedFiles) {
-        console.log(`  ${chalk32.cyan("\u2713")} ${file}`);
+        console.log(`  ${chalk39.cyan("\u2713")} ${file}`);
       }
       console.log();
-      console.log(chalk32.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
+      console.log(chalk39.blue("\u{1F4A1} \u8BF7\u4F7F\u7528 'ccman cx use' \u6216 'ccman cc use' \u5207\u6362\u670D\u52A1\u5546\n"));
     } catch (error) {
-      console.error(chalk32.red(`
+      console.error(chalk39.red(`
 \u274C ${error.message}
 `));
       process.exit(1);
@@ -4862,10 +5509,10 @@ function importCommand(program2) {
 // src/index.ts
 init_dist();
 if (process.env.NODE_ENV === "development") {
-  console.log(chalk33.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
-  console.log(chalk33.gray(`  ccman: ${getCcmanDir()}`));
-  console.log(chalk33.gray(`  codex:  ${getCodexDir()}`));
-  console.log(chalk33.gray(`  claude: ${getClaudeDir()}`));
+  console.log(chalk40.gray("\n[\u5F00\u53D1\u6A21\u5F0F] \u914D\u7F6E\u76EE\u5F55:"));
+  console.log(chalk40.gray(`  ccman: ${getCcmanDir()}`));
+  console.log(chalk40.gray(`  codex:  ${getCodexDir()}`));
+  console.log(chalk40.gray(`  claude: ${getClaudeDir()}`));
   console.log();
 }
 var program = new Command3();
@@ -4877,21 +5524,21 @@ program.name("ccman").description("Codex/Claude Code API \u670D\u52A1\u5546\u914
 });
 program.on("command:*", (operands) => {
   const unknownCommand = operands[0];
-  console.error(chalk33.red(`
+  console.error(chalk40.red(`
 \u274C \u672A\u77E5\u547D\u4EE4: ${unknownCommand}
 `));
-  const availableCommands = ["cx", "cc", "mcp", "sync", "export", "import"];
+  const availableCommands = ["cx", "cc", "gm", "mcp", "sync", "export", "import"];
   const suggestions = availableCommands.filter(
     (cmd) => cmd.includes(unknownCommand) || unknownCommand.includes(cmd)
   );
   if (suggestions.length > 0) {
-    console.log(chalk33.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
+    console.log(chalk40.yellow("\u{1F4A1} \u4F60\u662F\u4E0D\u662F\u60F3\u8F93\u5165:"));
     suggestions.forEach((cmd) => {
-      console.log(chalk33.cyan(`   ccman ${cmd}`));
+      console.log(chalk40.cyan(`   ccman ${cmd}`));
     });
     console.log();
   }
-  console.log(chalk33.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + chalk33.cyan("ccman --help"));
+  console.log(chalk40.gray("\u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4: ") + chalk40.cyan("ccman --help"));
   console.log();
   process.exit(1);
 });
@@ -4907,6 +5554,12 @@ cc.action(async () => {
   printLogo();
   await startClaudeMenu();
 });
+var gm = program.command("gm").description("\u7BA1\u7406 Gemini CLI \u670D\u52A1\u5546");
+createGeminiCommands(gm);
+gm.action(async () => {
+  printLogo();
+  await startGeminiMenu();
+});
 var mcp = program.command("mcp").description("\u7BA1\u7406 MCP \u670D\u52A1\u5668");
 createMCPCommands(mcp);
 mcp.action(() => {