ccman 3.3.3 → 3.3.5

package/dist/index.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.3.3",
+      version: "3.3.5",
       type: "module",
       description: "Core business logic for ccman - Manage Codex, Claude Code, Gemini CLI, and MCP configurations",
       main: "./dist/index.js",
@@ -269,10 +269,25 @@ import * as fs2 from "fs";
 import * as path3 from "path";
 import { fileURLToPath } from "url";
 import { parse as parseToml, stringify as stringifyToml } from "@iarna/toml";
+function resolveTemplatePath(relativePath) {
+  const candidates = [
+    // @ccman/core runtime (dist/writers -> templates)
+    path3.resolve(__dirname, "../../templates", relativePath),
+    // Bundled CLI runtime (dist -> dist/templates)
+    path3.resolve(__dirname, "templates", relativePath),
+    // Fallback (some bundlers/layouts)
+    path3.resolve(__dirname, "../templates", relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
 function loadCodexTemplateConfig() {
   try {
-    const templatePath = path3.resolve(__dirname, "../../templates/codex/config.toml");
-    if (fs2.existsSync(templatePath)) {
+    const templatePath = resolveTemplatePath("codex/config.toml");
+    if (templatePath) {
       const content = fs2.readFileSync(templatePath, "utf-8");
       return parseToml(content);
     }
@@ -321,10 +336,10 @@ var init_codex = __esm({
     __filename = fileURLToPath(import.meta.url);
     __dirname = path3.dirname(__filename);
     CODEX_DEFAULT_CONFIG = {
-      model: "gpt-5.1",
+      model: "gpt-5.1-code-max",
       model_reasoning_effort: "high",
       disable_response_storage: true,
-      sandbox_mode: "workspace-write",
+      sandbox_mode: "danger-full-access",
       windows_wsl_setup_acknowledged: true,
       approval_policy: "never",
       profile: "auto-max",
@@ -356,7 +371,7 @@ var init_codex = __esm({
           approval_policy: "never",
           sandbox_mode: "workspace-write"
         },
-        "review": {
+        review: {
           approval_policy: "on-request",
           sandbox_mode: "workspace-write"
         }
@@ -372,10 +387,25 @@ var init_codex = __esm({
 import * as fs3 from "fs";
 import * as path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
+function resolveTemplatePath2(relativePath) {
+  const candidates = [
+    // @ccman/core runtime (dist/writers -> templates)
+    path4.resolve(__dirname2, "../../templates", relativePath),
+    // Bundled CLI runtime (dist -> dist/templates)
+    path4.resolve(__dirname2, "templates", relativePath),
+    // Fallback (some bundlers/layouts)
+    path4.resolve(__dirname2, "../templates", relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (fs3.existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
 function loadClaudeTemplateConfig() {
   try {
-    const templatePath = path4.resolve(__dirname2, "../../templates/claude/settings.json");
-    if (fs3.existsSync(templatePath)) {
+    const templatePath = resolveTemplatePath2("claude/settings.json");
+    if (templatePath) {
       const content = fs3.readFileSync(templatePath, "utf-8");
       return JSON.parse(content);
     }
@@ -421,7 +451,8 @@ var init_claude = __esm({
       permissions: {
         allow: [],
         deny: []
-      }
+      },
+      alwaysThinkingEnabled: true
     };
   }
 });
@@ -733,7 +764,7 @@ var init_opencode = __esm({
       },
       {
         name: "GMN (COM)",
-        baseUrl: "https://gmn.chuangzuoli.com",
+        baseUrl: "https://gmn.chuangzuoli.com/v1",
         description: "GMN \u670D\u52A1 (OpenCode \u517C\u5BB9)"
       }
     ];
@@ -857,6 +888,38 @@ var init_gemini2 = __esm({
 });
 
 // ../core/dist/writers/opencode.js
+import * as fs6 from "fs";
+import * as path6 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function resolveTemplatePath3(relativePath) {
+  const candidates = [
+    // @ccman/core runtime (dist/writers -> templates)
+    path6.resolve(__dirname3, "../../templates", relativePath),
+    // Bundled CLI runtime (dist -> dist/templates)
+    path6.resolve(__dirname3, "templates", relativePath),
+    // Fallback (some bundlers/layouts)
+    path6.resolve(__dirname3, "../templates", relativePath)
+  ];
+  for (const candidate of candidates) {
+    if (fs6.existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function loadOpenCodeTemplateConfig() {
+  try {
+    const templatePath = resolveTemplatePath3("opencode/opencode.json");
+    if (templatePath) {
+      const content = fs6.readFileSync(templatePath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    }
+  } catch {
+  }
+  return OPENCODE_CONFIG_TEMPLATE;
+}
 function parseProviderMeta(raw) {
   if (!raw || !raw.trim())
     return null;
@@ -870,76 +933,124 @@ function parseProviderMeta(raw) {
   }
   return null;
 }
-function toProviderKey(name) {
-  const normalized = name.trim().toLowerCase();
-  const collapsed = normalized.replace(/\s+/g, "-");
-  const cleaned = collapsed.replace(/[^a-z0-9-_]/g, "");
-  return cleaned || "provider";
+function enforceAgentStoreFalse(agent) {
+  const base = agent && typeof agent === "object" && !Array.isArray(agent) ? agent : {};
+  return deepMerge(base, {
+    build: {
+      options: {
+        store: false
+      }
+    },
+    plan: {
+      options: {
+        store: false
+      }
+    }
+  });
+}
+function enforceModelStoreFalse(models) {
+  const base = models && typeof models === "object" && !Array.isArray(models) ? models : {};
+  return deepMerge(base, {
+    [OPENCODE_MODEL_KEY]: {
+      options: {
+        store: false
+      },
+      variants: {
+        low: {},
+        medium: {},
+        high: {},
+        xhigh: {}
+      }
+    }
+  });
 }
 function writeOpenCodeConfig(provider) {
   ensureDir(getOpenCodeDir());
   const configPath = getOpenCodeConfigPath();
   const existingConfig = fileExists(configPath) ? readJSON(configPath) : {};
   const meta = parseProviderMeta(provider.model);
-  const npmPackage = meta?.npm || DEFAULT_NPM_PACKAGE;
-  const providerKey = toProviderKey(provider.name);
-  const existingProvider = existingConfig.provider?.[providerKey];
-  const models = meta?.models || existingProvider?.models || DEFAULT_MODELS;
-  const providerConfig = {
-    ...existingProvider,
-    npm: npmPackage,
-    name: provider.name,
+  const template = loadOpenCodeTemplateConfig();
+  const defaultConfig = replaceVariables(template, {
+    baseUrl: provider.baseUrl,
+    apiKey: provider.apiKey
+  });
+  const mergedConfig = deepMerge(defaultConfig, existingConfig);
+  const templateProvider = defaultConfig.provider?.[OPENCODE_PROVIDER_KEY];
+  const existingProvider = mergedConfig.provider?.[OPENCODE_PROVIDER_KEY];
+  const models = enforceModelStoreFalse(meta?.models || existingProvider?.models || templateProvider?.models || DEFAULT_MODELS);
+  const providerConfig = deepMerge(templateProvider || {}, {
+    ...existingProvider || {},
     options: {
       ...existingProvider?.options || {},
       baseURL: provider.baseUrl,
       apiKey: provider.apiKey
     },
     models
-  };
-  const existingProviders = existingConfig.provider && typeof existingConfig.provider === "object" ? { ...existingConfig.provider } : {};
+  });
+  const existingProviders = mergedConfig.provider && typeof mergedConfig.provider === "object" && !Array.isArray(mergedConfig.provider) ? { ...mergedConfig.provider } : {};
   const nextConfig = {
-    ...existingConfig,
+    ...mergedConfig,
     $schema: OPENCODE_SCHEMA,
+    model: OPENCODE_MODEL,
+    agent: enforceAgentStoreFalse(mergedConfig.agent),
     provider: {
       ...existingProviders,
-      [providerKey]: providerConfig
+      [OPENCODE_PROVIDER_KEY]: providerConfig
     }
   };
   writeJSON(configPath, nextConfig);
 }
-var OPENCODE_SCHEMA, DEFAULT_NPM_PACKAGE, DEFAULT_MODELS;
+var OPENCODE_SCHEMA, OPENCODE_PROVIDER_KEY, OPENCODE_MODEL, OPENCODE_MODEL_KEY, __filename3, __dirname3, DEFAULT_MODELS, OPENCODE_CONFIG_TEMPLATE;
 var init_opencode2 = __esm({
   "../core/dist/writers/opencode.js"() {
     "use strict";
     init_paths();
     init_file();
+    init_template();
     OPENCODE_SCHEMA = "https://opencode.ai/config.json";
-    DEFAULT_NPM_PACKAGE = "@ai-sdk/openai";
+    OPENCODE_PROVIDER_KEY = "openai";
+    OPENCODE_MODEL = "openai/gpt-5.2-codex";
+    OPENCODE_MODEL_KEY = "gpt-5.2-codex";
+    __filename3 = fileURLToPath3(import.meta.url);
+    __dirname3 = path6.dirname(__filename3);
     DEFAULT_MODELS = {
-      "gpt-5.2-codex": {
+      [OPENCODE_MODEL_KEY]: {
+        name: "GPT-5.2 Codex",
+        options: {
+          store: false
+        },
         variants: {
-          xhigh: {
-            reasoningEffort: "xhigh",
-            textVerbosity: "low",
-            reasoningSummary: "auto"
-          },
-          high: {
-            reasoningEffort: "high",
-            textVerbosity: "low",
-            reasoningSummary: "auto"
-          },
-          medium: {
-            reasoningEffort: "medium",
-            textVerbosity: "low",
-            reasoningSummary: "auto"
+          low: {},
+          medium: {},
+          high: {},
+          xhigh: {}
+        }
+      }
+    };
+    OPENCODE_CONFIG_TEMPLATE = {
+      provider: {
+        [OPENCODE_PROVIDER_KEY]: {
+          options: {
+            baseURL: "{{baseUrl}}",
+            apiKey: "{{apiKey}}"
           },
-          low: {
-            reasoningEffort: "low",
-            textVerbosity: "low",
-            reasoningSummary: "auto"
+          models: DEFAULT_MODELS
+        }
+      },
+      agent: {
+        build: {
+          options: {
+            store: false
+          }
+        },
+        plan: {
+          options: {
+            store: false
           }
         }
-      }
+      },
+      $schema: OPENCODE_SCHEMA,
+      model: OPENCODE_MODEL
     };
   }
 });
@@ -971,7 +1082,7 @@ var init_tool_manager_types = __esm({
 });
 
 // ../core/dist/tool-manager.js
-import * as path6 from "path";
+import * as path7 from "path";
 function createToolManager(tool) {
   const toolConfig = TOOL_CONFIGS[tool];
   const configPath = toolConfig.configPath;
@@ -1245,17 +1356,17 @@ var init_tool_manager = __esm({
     init_tool_manager_types();
     TOOL_CONFIGS = {
       codex: {
-        configPath: path6.join(getCcmanDir(), "codex.json"),
+        configPath: path7.join(getCcmanDir(), "codex.json"),
         builtinPresets: CODEX_PRESETS,
         writer: writeCodexConfig
       },
       claude: {
-        configPath: path6.join(getCcmanDir(), "claude.json"),
+        configPath: path7.join(getCcmanDir(), "claude.json"),
         builtinPresets: CC_PRESETS,
         writer: writeClaudeConfig
       },
       mcp: {
-        configPath: path6.join(getCcmanDir(), "mcp.json"),
+        configPath: path7.join(getCcmanDir(), "mcp.json"),
         builtinPresets: MCP_PRESETS,
         writer: writeMCPConfig,
         autoSync: true,
@@ -1285,12 +1396,12 @@ var init_tool_manager = __esm({
         }
       },
       gemini: {
-        configPath: path6.join(getCcmanDir(), "gemini.json"),
+        configPath: path7.join(getCcmanDir(), "gemini.json"),
         builtinPresets: GEMINI_PRESETS,
         writer: writeGeminiConfig
       },
       opencode: {
-        configPath: path6.join(getCcmanDir(), "opencode.json"),
+        configPath: path7.join(getCcmanDir(), "opencode.json"),
         builtinPresets: OPENCODE_PRESETS,
         writer: writeOpenCodeConfig
       }
@@ -1307,20 +1418,20 @@ var init_migrate = __esm({
 });
 
 // ../core/dist/config.js
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 function ensureConfigDir() {
   const dir = getCcmanDir();
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
   }
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!fs6.existsSync(configPath)) {
+  if (!fs7.existsSync(configPath)) {
     return {};
   }
   try {
-    const content = fs6.readFileSync(configPath, "utf-8");
+    const content = fs7.readFileSync(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to load config: ${error.message}`);
@@ -1331,10 +1442,10 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   try {
     const tempPath = `${configPath}.tmp`;
-    fs6.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
+    fs7.writeFileSync(tempPath, JSON.stringify(config, null, 2), {
       mode: 384
     });
-    fs6.renameSync(tempPath, configPath);
+    fs7.renameSync(tempPath, configPath);
   } catch (error) {
     throw new Error(`Failed to save config: ${error.message}`);
   }
@@ -1658,24 +1769,24 @@ var init_merge_advanced = __esm({
 });
 
 // ../core/dist/sync/merge.js
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 function backupConfig(configPath, keepCount = 3) {
-  if (!fs7.existsSync(configPath)) {
+  if (!fs8.existsSync(configPath)) {
     throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}`);
   }
   const timestamp = Date.now();
   const backupPath = `${configPath}.backup.${timestamp}`;
-  fs7.copyFileSync(configPath, backupPath);
+  fs8.copyFileSync(configPath, backupPath);
   cleanupOldBackups(configPath, keepCount);
   return backupPath;
 }
 function cleanupOldBackups(configPath, keepCount) {
-  const dir = path7.dirname(configPath);
-  const basename = path7.basename(configPath);
+  const dir = path8.dirname(configPath);
+  const basename = path8.basename(configPath);
   const backupPrefix = `${basename}.backup.`;
   try {
-    const files = fs7.readdirSync(dir);
+    const files = fs8.readdirSync(dir);
     const backups = files.filter((f) => f.startsWith(backupPrefix)).map((f) => {
       const timestampStr = f.substring(backupPrefix.length);
       const timestamp = parseInt(timestampStr, 10);
@@ -1684,14 +1795,14 @@ function cleanupOldBackups(configPath, keepCount) {
       }
       return {
         name: f,
-        path: path7.join(dir, f),
+        path: path8.join(dir, f),
         timestamp
       };
     }).filter((backup) => backup !== null).sort((a, b) => b.timestamp - a.timestamp);
     const toDelete = backups.slice(keepCount);
     for (const backup of toDelete) {
       try {
-        fs7.unlinkSync(backup.path);
+        fs8.unlinkSync(backup.path);
       } catch (error) {
         console.warn(`\u65E0\u6CD5\u5220\u9664\u65E7\u5907\u4EFD\u6587\u4EF6 ${backup.name}: ${error.message}`);
       }
@@ -1707,14 +1818,14 @@ var init_merge = __esm({
 });
 
 // ../core/dist/sync/sync-v2.js
-import fs8 from "fs";
-import path8 from "path";
+import fs9 from "fs";
+import path9 from "path";
 async function uploadToCloud(config, password) {
   const ccmanDir2 = getCcmanDir();
   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 configPath = path9.join(ccmanDir2, configFilename);
     const localConfig = readJSON(configPath);
     const encryptedProviders = encryptProviders(localConfig.providers, password);
     const encryptedConfig = {
@@ -1760,8 +1871,8 @@ async function downloadFromCloud(config, password) {
   try {
     for (const tool of toolKeys) {
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path8.join(ccmanDir2, configFilename);
-      if (fs8.existsSync(configPath)) {
+      const configPath = path9.join(ccmanDir2, configFilename);
+      if (fs9.existsSync(configPath)) {
         backupPaths.push(backupConfig(configPath));
       }
     }
@@ -1773,7 +1884,7 @@ async function downloadFromCloud(config, password) {
       if (!remoteConfig || !decryptedProviders)
         continue;
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path8.join(ccmanDir2, configFilename);
+      const configPath = path9.join(ccmanDir2, configFilename);
       const newConfig = {
         ...remoteConfig,
         // 使用云端配置的所有字段
@@ -1789,8 +1900,8 @@ async function downloadFromCloud(config, password) {
   } catch (error) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
-      if (fs8.existsSync(backupPath)) {
-        fs8.copyFileSync(backupPath, originalPath);
+      if (fs9.existsSync(backupPath)) {
+        fs9.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u8986\u76D6\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -1815,7 +1926,7 @@ async function mergeSync(config, password) {
   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 configPath = path9.join(ccmanDir2, configFilename);
     const localConfig = readJSON(configPath);
     let remoteProviders = [];
     if (existsChecks[i]) {
@@ -1847,8 +1958,8 @@ async function mergeSync(config, password) {
   try {
     for (const tool of toolKeys) {
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path8.join(ccmanDir2, configFilename);
-      if (fs8.existsSync(configPath)) {
+      const configPath = path9.join(ccmanDir2, configFilename);
+      if (fs9.existsSync(configPath)) {
         backupPaths.push(backupConfig(configPath));
       }
     }
@@ -1859,7 +1970,7 @@ async function mergeSync(config, password) {
     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);
+      const configPath = path9.join(ccmanDir2, configFilename);
       let remoteConfig = null;
       if (existsChecks[i]) {
         const jsonContent2 = await downloadFromWebDAV(config, remotePath);
@@ -1895,8 +2006,8 @@ async function mergeSync(config, password) {
   } catch (error) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
-      if (fs8.existsSync(backupPath)) {
-        fs8.copyFileSync(backupPath, originalPath);
+      if (fs9.existsSync(backupPath)) {
+        fs9.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5408\u5E76\u914D\u7F6E\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -1949,12 +2060,12 @@ var init_sync_v2 = __esm({
 });
 
 // ../core/dist/export.js
-import * as fs9 from "fs";
-import * as path9 from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 function validateExport() {
   const ccmanDir2 = getCcmanDir();
-  const codexPath = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const claudePath = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const codexPath = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const claudePath = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
   const missingFiles = [];
   if (!fileExists(codexPath)) {
     missingFiles.push(CODEX_CONFIG_FILE);
@@ -1979,7 +2090,7 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const stats = fs9.statSync(sourceDir);
+  const stats = fs10.statSync(sourceDir);
   if (!stats.isDirectory()) {
     return {
       valid: false,
@@ -1987,8 +2098,8 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const codexPath = path9.join(sourceDir, CODEX_CONFIG_FILE);
-  const claudePath = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
+  const codexPath = path10.join(sourceDir, CODEX_CONFIG_FILE);
+  const claudePath = path10.join(sourceDir, CLAUDE_CONFIG_FILE);
   const foundFiles = [];
   if (fileExists(codexPath)) {
     foundFiles.push(CODEX_CONFIG_FILE);
@@ -2016,16 +2127,16 @@ function exportConfig(targetDir) {
   ensureDir(targetDir);
   const ccmanDir2 = getCcmanDir();
   const exportedFiles = [];
-  const codexSrc = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const codexDst = path9.join(targetDir, CODEX_CONFIG_FILE);
+  const codexSrc = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const codexDst = path10.join(targetDir, CODEX_CONFIG_FILE);
   if (fileExists(codexSrc)) {
-    fs9.copyFileSync(codexSrc, codexDst);
+    fs10.copyFileSync(codexSrc, codexDst);
     exportedFiles.push(CODEX_CONFIG_FILE);
   }
-  const claudeSrc = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
-  const claudeDst = path9.join(targetDir, CLAUDE_CONFIG_FILE);
+  const claudeSrc = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const claudeDst = path10.join(targetDir, CLAUDE_CONFIG_FILE);
   if (fileExists(claudeSrc)) {
-    fs9.copyFileSync(claudeSrc, claudeDst);
+    fs10.copyFileSync(claudeSrc, claudeDst);
     exportedFiles.push(CLAUDE_CONFIG_FILE);
   }
   return {
@@ -2045,23 +2156,23 @@ function importConfig(sourceDir) {
   ensureDir(ccmanDir2);
   try {
     if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
-      const codexDst = path9.join(ccmanDir2, CODEX_CONFIG_FILE);
+      const codexDst = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
       if (fileExists(codexDst)) {
         const backupPath = backupConfig(codexDst);
         backupPaths.push(backupPath);
       }
-      const codexSrc = path9.join(sourceDir, CODEX_CONFIG_FILE);
-      fs9.copyFileSync(codexSrc, codexDst);
+      const codexSrc = path10.join(sourceDir, CODEX_CONFIG_FILE);
+      fs10.copyFileSync(codexSrc, codexDst);
       importedFiles.push(CODEX_CONFIG_FILE);
     }
     if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
-      const claudeDst = path9.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+      const claudeDst = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
       if (fileExists(claudeDst)) {
         const backupPath = backupConfig(claudeDst);
         backupPaths.push(backupPath);
       }
-      const claudeSrc = path9.join(sourceDir, CLAUDE_CONFIG_FILE);
-      fs9.copyFileSync(claudeSrc, claudeDst);
+      const claudeSrc = path10.join(sourceDir, CLAUDE_CONFIG_FILE);
+      fs10.copyFileSync(claudeSrc, claudeDst);
       importedFiles.push(CLAUDE_CONFIG_FILE);
     }
     return {
@@ -2073,7 +2184,7 @@ function importConfig(sourceDir) {
     for (const backupPath of backupPaths) {
       const originalPath = backupPath.replace(/\.backup\.\d+$/, "");
       if (fileExists(backupPath)) {
-        fs9.copyFileSync(backupPath, originalPath);
+        fs10.copyFileSync(backupPath, originalPath);
       }
     }
     throw new Error(`\u5BFC\u5165\u5931\u8D25\uFF0C\u5DF2\u6062\u590D\u5907\u4EFD: ${error.message}`);
@@ -2092,7 +2203,7 @@ var init_export = __esm({
 });
 
 // ../core/dist/claude-clean.js
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 function formatBytes(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
@@ -2102,7 +2213,7 @@ function formatBytes(bytes) {
 }
 function getFileSize(filePath) {
   try {
-    const stats = fs10.statSync(filePath);
+    const stats = fs11.statSync(filePath);
     return stats.size;
   } catch {
     return 0;
@@ -2111,18 +2222,18 @@ function getFileSize(filePath) {
 function backupFile(filePath) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").split(".")[0];
   const backupPath = `${filePath}.backup-${timestamp}`;
-  fs10.copyFileSync(filePath, backupPath);
+  fs11.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 function saveJsonAtomic(filePath, data) {
   const tempPath = `${filePath}.tmp`;
   const content = JSON.stringify(data, null, 2);
-  fs10.writeFileSync(tempPath, content, { mode: 384 });
-  fs10.renameSync(tempPath, filePath);
+  fs11.writeFileSync(tempPath, content, { mode: 384 });
+  fs11.renameSync(tempPath, filePath);
 }
 function analyzeClaudeJson() {
   const filePath = getClaudeJsonPath();
-  if (!fs10.existsSync(filePath)) {
+  if (!fs11.existsSync(filePath)) {
     return {
       fileSize: 0,
       fileSizeFormatted: "0 B",
@@ -2138,7 +2249,7 @@ function analyzeClaudeJson() {
     };
   }
   const fileSize = getFileSize(filePath);
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const config = JSON.parse(content);
   const projects = config.projects || {};
   const projectHistory = [];
@@ -2172,12 +2283,12 @@ function analyzeClaudeJson() {
 }
 function cleanClaudeJson(options = {}) {
   const filePath = getClaudeJsonPath();
-  if (!fs10.existsSync(filePath)) {
+  if (!fs11.existsSync(filePath)) {
     throw new Error(`${filePath} \u6587\u4EF6\u4E0D\u5B58\u5728`);
   }
   const backupPath = backupFile(filePath);
   const sizeBefore = getFileSize(filePath);
-  const content = fs10.readFileSync(filePath, "utf-8");
+  const content = fs11.readFileSync(filePath, "utf-8");
   const config = JSON.parse(content);
   const cleanedItems = applyCleanOptions(config, options);
   saveJsonAtomic(filePath, config);
@@ -2733,8 +2844,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(chalk7.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path12) => {
-          console.log(chalk7.gray(`  ${path12}`));
+        backupPaths.forEach((path13) => {
+          console.log(chalk7.gray(`  ${path13}`));
         });
         console.log();
       }
@@ -2795,8 +2906,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(chalk8.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path12) => {
-          console.log(chalk8.gray(`  ${path12}`));
+        result.backupPaths.forEach((path13) => {
+          console.log(chalk8.gray(`  ${path13}`));
         });
         console.log();
       }
@@ -3006,7 +3117,7 @@ function printLogo() {
 `
     )
   );
-  console.log(chalk.gray("  Codex/Claude Code API \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177"));
+  console.log(chalk.gray("  \u591A\u5DE5\u5177 AI \u670D\u52A1\u5546\u914D\u7F6E\u7BA1\u7406\u5DE5\u5177"));
   console.log(chalk.gray(`  \u7248\u672C ${VERSION}
 `));
 }
@@ -3046,27 +3157,6 @@ function formatProviderTable(providers, currentId) {
   return lines.join("\n");
 }
 
-// src/utils/opencode.ts
-var DEFAULT_OPENCODE_NPM = "@ai-sdk/openai";
-function parseOpenCodeMeta(raw) {
-  if (!raw || !raw.trim()) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object") {
-      return parsed;
-    }
-  } catch {
-    return { npm: raw };
-  }
-  return null;
-}
-function buildOpenCodeModel(meta) {
-  const payload = {};
-  if (meta.npm) payload.npm = meta.npm;
-  if (meta.models) payload.models = meta.models;
-  return JSON.stringify(payload);
-}
-
 // src/interactive.ts
 var CLI_TOOL_CONFIG = {
   [TOOL_TYPES.CODEX]: { name: "Codex", emoji: "\u{1F536}", cmd: "cx" },
@@ -3333,20 +3423,7 @@ async function handleAdd(tool) {
     baseUrl = answers.baseUrl;
     apiKey = answers.apiKey;
   }
-  let model;
-  if (tool === TOOL_TYPES.OPENCODE) {
-    const { npmPackage } = await inquirer7.prompt([
-      {
-        type: "input",
-        name: "npmPackage",
-        message: "\u517C\u5BB9\u5305 (npm):",
-        default: DEFAULT_OPENCODE_NPM,
-        validate: (value) => value ? true : "npm \u5305\u4E0D\u80FD\u4E3A\u7A7A"
-      }
-    ]);
-    model = buildOpenCodeModel({ npm: npmPackage });
-  }
-  const provider = manager.add({ name, desc, baseUrl, apiKey, model });
+  const provider = manager.add({ name, desc, baseUrl, apiKey });
   console.log();
   console.log(chalk11.green("\u2705 \u6DFB\u52A0\u6210\u529F"));
   console.log();
@@ -3449,8 +3526,6 @@ async function handleEdit(tool) {
     }
   ]);
   const provider = providers.find((p) => p.id === providerId);
-  const meta = tool === TOOL_TYPES.OPENCODE ? parseOpenCodeMeta(provider.model) : null;
-  const currentNpm = meta?.npm || DEFAULT_OPENCODE_NPM;
   const answers = await inquirer7.prompt([
     {
       type: "input",
@@ -3485,25 +3560,11 @@ async function handleEdit(tool) {
       mask: "*"
     }
   ]);
-  let model;
-  if (tool === TOOL_TYPES.OPENCODE) {
-    const { npmPackage } = await inquirer7.prompt([
-      {
-        type: "input",
-        name: "npmPackage",
-        message: "\u517C\u5BB9\u5305 (npm):",
-        default: currentNpm,
-        validate: (value) => value ? true : "npm \u5305\u4E0D\u80FD\u4E3A\u7A7A"
-      }
-    ]);
-    model = buildOpenCodeModel({ npm: npmPackage, models: meta?.models });
-  }
   manager.edit(providerId, {
     name: answers.name,
     desc: answers.desc || void 0,
     baseUrl: answers.baseUrl,
-    apiKey: answers.apiKey || void 0,
-    model
+    apiKey: answers.apiKey || void 0
   });
   console.log(chalk11.green("\n\u2705 \u7F16\u8F91\u6210\u529F\n"));
 }
@@ -3526,8 +3587,6 @@ async function handleClone(tool) {
     }
   ]);
   const provider = providers.find((p) => p.id === providerId);
-  const meta = tool === TOOL_TYPES.OPENCODE ? parseOpenCodeMeta(provider.model) : null;
-  const currentNpm = meta?.npm || DEFAULT_OPENCODE_NPM;
   const answers = await inquirer7.prompt([
     {
       type: "input",
@@ -3544,26 +3603,12 @@ async function handleClone(tool) {
       validate: (value) => value ? true : "API \u5BC6\u94A5\u4E0D\u80FD\u4E3A\u7A7A"
     }
   ]);
-  let model;
-  if (tool === TOOL_TYPES.OPENCODE) {
-    const { npmPackage } = await inquirer7.prompt([
-      {
-        type: "input",
-        name: "npmPackage",
-        message: "\u517C\u5BB9\u5305 (npm):",
-        default: currentNpm,
-        validate: (value) => value ? true : "npm \u5305\u4E0D\u80FD\u4E3A\u7A7A"
-      }
-    ]);
-    model = buildOpenCodeModel({ npm: npmPackage, models: meta?.models });
-  }
   const newProvider = manager.add({
     name: answers.name,
     // 克隆时不继承描述,留空让用户后续编辑
     desc: void 0,
     baseUrl: provider.baseUrl,
-    apiKey: answers.apiKey,
-    model
+    apiKey: answers.apiKey
   });
   console.log(chalk11.green("\n\u2705 \u514B\u9686\u6210\u529F\n"));
   console.log(`  ${chalk11.bold(newProvider.name)}`);
@@ -5686,21 +5731,11 @@ function addCommand5(program2) {
         baseUrl = answers.baseUrl;
         apiKey = answers.apiKey;
       }
-      const { npmPackage } = await inquirer27.prompt([
-        {
-          type: "input",
-          name: "npmPackage",
-          message: "\u517C\u5BB9\u5305 (npm):",
-          default: DEFAULT_OPENCODE_NPM,
-          validate: (value) => value ? true : "npm \u5305\u4E0D\u80FD\u4E3A\u7A7A"
-        }
-      ]);
       const provider = manager.add({
         name,
         desc,
         baseUrl,
-        apiKey,
-        model: buildOpenCodeModel({ npm: npmPackage })
+        apiKey
       });
       console.log();
       console.log(chalk38.green("\u2705 \u6DFB\u52A0\u6210\u529F"));
@@ -5880,32 +5915,17 @@ function editCommand5(program2) {
         targetId = selectedId;
       }
       const provider = manager.get(targetId);
-      const meta = parseOpenCodeMeta(provider.model);
-      const currentNpm = meta?.npm || DEFAULT_OPENCODE_NPM;
       const input = await promptProviderForm({
         name: provider.name,
         desc: provider.desc ?? "",
         baseUrl: provider.baseUrl,
         apiKey: provider.apiKey
       });
-      const { npmPackage } = await inquirer29.prompt([
-        {
-          type: "input",
-          name: "npmPackage",
-          message: "\u517C\u5BB9\u5305 (npm):",
-          default: currentNpm,
-          validate: (value) => value ? true : "npm \u5305\u4E0D\u80FD\u4E3A\u7A7A"
-        }
-      ]);
       manager.edit(targetId, {
         name: input.name,
         desc: input.desc,
         baseUrl: input.baseUrl,
-        apiKey: input.apiKey,
-        model: buildOpenCodeModel({
-          npm: npmPackage,
-          models: meta?.models
-        })
+        apiKey: input.apiKey
       });
       console.log(chalk42.green("\n\u2705 \u7F16\u8F91\u6210\u529F\n"));
     } catch (error) {
@@ -6027,8 +6047,6 @@ function cloneCommand4(program2) {
         sourceId = selectedId;
       }
       const source = manager.get(sourceId);
-      const meta = parseOpenCodeMeta(source.model);
-      const currentNpm = meta?.npm || DEFAULT_OPENCODE_NPM;
       let cloned;
       if (newName) {
         cloned = manager.clone(sourceId, newName);
@@ -6042,24 +6060,11 @@ function cloneCommand4(program2) {
           baseUrl: source.baseUrl,
           apiKey: source.apiKey
         });
-        const { npmPackage } = await inquirer31.prompt([
-          {
-            type: "input",
-            name: "npmPackage",
-            message: "\u517C\u5BB9\u5305 (npm):",
-            default: currentNpm,
-            validate: (value) => value ? true : "npm \u5305\u4E0D\u80FD\u4E3A\u7A7A"
-          }
-        ]);
         cloned = manager.add({
           name: input.name,
           desc: input.desc,
           baseUrl: input.baseUrl,
-          apiKey: input.apiKey,
-          model: buildOpenCodeModel({
-            npm: npmPackage,
-            models: meta?.models
-          })
+          apiKey: input.apiKey
         });
       }
       console.log();
@@ -6095,7 +6100,7 @@ init_sync();
 // src/commands/export.ts
 init_dist2();
 import chalk45 from "chalk";
-import path10 from "path";
+import path11 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 {
@@ -6106,7 +6111,7 @@ function exportCommand(program2) {
 `));
         process.exit(1);
       }
-      const resolvedPath = targetDir.startsWith("~") ? path10.join(process.env.HOME || "", targetDir.slice(1)) : path10.resolve(targetDir);
+      const resolvedPath = targetDir.startsWith("~") ? path11.join(process.env.HOME || "", targetDir.slice(1)) : path11.resolve(targetDir);
       console.log("\u5BFC\u51FA\u6587\u4EF6:");
       console.log(`  ${chalk45.cyan("codex.json")}  - Codex \u914D\u7F6E`);
       console.log(`  ${chalk45.cyan("claude.json")} - Claude \u914D\u7F6E`);
@@ -6138,11 +6143,11 @@ function exportCommand(program2) {
 init_dist2();
 import chalk46 from "chalk";
 import inquirer32 from "inquirer";
-import path11 from "path";
+import path12 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);
+      const resolvedPath = sourceDir.startsWith("~") ? path12.join(process.env.HOME || "", sourceDir.slice(1)) : path12.resolve(sourceDir);
       console.log(chalk46.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {
@@ -6231,6 +6236,66 @@ var GMN_OPENAI_BASE_URLS = {
   cn: "https://gmn.chuangzuoli.cn/openai",
   com: "https://gmn.chuangzuoli.com"
 };
+var TOTAL_STEPS = 4;
+function renderStep(current, total, title) {
+  const barLength = total;
+  const filledLength = Math.min(current, total);
+  const bar = `${"\u25A0".repeat(filledLength)}${"\u25A1".repeat(barLength - filledLength)}`;
+  return `\u6B65\u9AA4 ${current}/${total} [${bar}] ${title}`;
+}
+function printBanner() {
+  printLogo();
+  console.log(
+    chalk47.cyanBright(
+      [
+        "  \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557",
+        " \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D  \u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551",
+        " \u2588\u2588\u2551  \u2588\u2588\u2588\u2557 \u2588\u2588\u2554\u2588\u2588\u2588\u2588\u2554\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551",
+        " \u2588\u2588\u2551   \u2588\u2588\u2551 \u2588\u2588\u2551\u255A\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551",
+        " \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2551 \u255A\u2550\u255D \u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551",
+        "  \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u255D     \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D",
+        "  CCMAN  GMN \u4E00\u952E\u914D\u7F6E\u5411\u5BFC"
+      ].join("\n")
+    )
+  );
+  console.log(chalk47.gray("\u81EA\u52A8\u5199\u5165\u9009\u4E2D\u5DE5\u5177\u914D\u7F6E\uFF0C\u652F\u6301\u591A\u9009\u4E0E\u7AEF\u70B9\u9009\u62E9\u3002\n"));
+}
+function printKeyNotice() {
+  console.log(
+    chalk47.yellow(
+      [
+        "\u63D0\u793A\uFF1ACodex \u4E0E OpenCode \u5171\u4EAB OpenAI \u5957\u9910/\u7AEF\u70B9\uFF1BGemini \u4E0E Claude \u9700\u5355\u72EC\u8BA2\u9605\u3002",
+        "\u4F8B\u5982\uFF1AGemini \u5957\u9910\u4E0D\u80FD\u7528\u4E8E Codex/OpenCode\uFF0CClaude \u5957\u9910\u4E5F\u4E0D\u80FD\u901A\u7528\u3002",
+        "VS Code \u7684 Codex \u63D2\u4EF6\u82E5\u4F7F\u7528\u672C\u673A\u9ED8\u8BA4\u914D\u7F6E\uFF0C\u4E5F\u4F1A\u8DDF\u968F\u672C\u6B21\u5199\u5165\u751F\u6548\u3002"
+      ].join("\n")
+    )
+  );
+}
+function printWriteTargets(platforms) {
+  console.log(chalk47.gray(`\u5199\u5165\u76EE\u5F55: ${getCcmanDir()}`));
+  if (platforms.includes("codex")) {
+    console.log(chalk47.gray(`  - Codex: ${getCodexConfigPath()}`));
+    console.log(chalk47.gray(`  - Codex: ${getCodexAuthPath()}`));
+  }
+  if (platforms.includes("claude")) {
+    console.log(chalk47.gray(`  - Claude Code: ${getClaudeConfigPath()}`));
+  }
+  if (platforms.includes("gemini")) {
+    console.log(chalk47.gray(`  - Gemini CLI: ${getGeminiSettingsPath()}`));
+    console.log(chalk47.gray(`  - Gemini CLI: ${getGeminiEnvPath()}`));
+  }
+  if (platforms.includes("opencode")) {
+    console.log(chalk47.gray(`  - OpenCode: ${getOpenCodeConfigPath()}`));
+  }
+  const env = process.env.NODE_ENV;
+  if (env === "development" || env === "test") {
+    console.log(
+      chalk47.yellow(
+        `\u26A0\uFE0F \u5F53\u524D NODE_ENV=${env}\uFF0C\u5C06\u5199\u5165\u5F00\u53D1/\u6D4B\u8BD5\u76EE\u5F55\uFF1B\u5982\u9700\u5199\u5165\u771F\u5B9E HOME\uFF0C\u8BF7\u5728\u751F\u4EA7\u73AF\u5883\u8FD0\u884C\uFF08unset NODE_ENV\uFF09\u3002`
+      )
+    );
+  }
+}
 function parsePlatforms(platformArg) {
   if (platformArg === "all") {
     return [...VALID_PLATFORMS];
@@ -6263,13 +6328,14 @@ async function promptPlatforms() {
     {
       type: "checkbox",
       name: "platforms",
-      message: "\u9009\u62E9\u5E73\u53F0:",
+      message: "\u9009\u62E9\u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u53EF\u591A\u9009\uFF0C\u7A7A\u683C\u9009\u62E9 / a\u5168\u9009 / i\u53CD\u9009 / \u56DE\u8F66\u786E\u8BA4\uFF09:",
+      dontShowHints: true,
       choices: [
-        { name: "Claude Code", value: "claude" },
-        { name: "Codex", value: "codex" },
-        { name: "Gemini CLI", value: "gemini" },
-        { name: "OpenCode", value: "opencode" },
-        { name: "\u5168\u90E8 (all)", value: "all" }
+        { name: "Claude Code\uFF08\u9700\u5355\u72EC\u8BA2\u9605 Claude \u5957\u9910\uFF09", value: "claude" },
+        { name: "Codex\uFF08\u9700\u5355\u72EC\u8BA2\u9605 OpenAI \u5957\u9910\uFF09", value: "codex" },
+        { name: "Gemini CLI\uFF08\u9700\u5355\u72EC\u8BA2\u9605 Gemini \u5957\u9910\uFF09", value: "gemini" },
+        { name: "OpenCode\uFF08\u4E0E Codex \u5171\u4EAB OpenAI \u5957\u9910\uFF09", value: "opencode" },
+        { name: "\u5168\u90E8\uFF08\u5C06\u4F9D\u6B21\u914D\u7F6E\u6240\u6709\u5DE5\u5177\uFF09", value: "all" }
       ],
       default: DEFAULT_PLATFORMS,
       validate: (value) => {
@@ -6306,10 +6372,10 @@ async function resolveOpenAIDomain(domainArg, platforms) {
     {
       type: "list",
       name: "domain",
-      message: "\u9009\u62E9 Codex/OpenCode \u7684 OpenAI Base URL:",
+      message: "\u9009\u62E9 Codex/OpenCode \u7684 OpenAI Base URL\uFF08\u53EA\u5F71\u54CD\u8FD9\u4E24\u4E2A\u5DE5\u5177\uFF09:",
       choices: [
-        { name: `CN  ${GMN_OPENAI_BASE_URLS.cn}`, value: "cn" },
-        { name: `COM ${GMN_OPENAI_BASE_URLS.com}`, value: "com" }
+        { name: `CN\uFF08\u56FD\u5185\uFF09  ${GMN_OPENAI_BASE_URLS.cn}`, value: "cn" },
+        { name: `COM\uFF08\u56FD\u9645\uFF09 ${GMN_OPENAI_BASE_URLS.com}`, value: "com" }
       ],
       default: "cn"
     }
@@ -6317,23 +6383,42 @@ async function resolveOpenAIDomain(domainArg, platforms) {
   return answers.domain;
 }
 async function gmnCommand(apiKey, platformArg, domainArg) {
+  printBanner();
   let platforms;
   try {
+    console.log(chalk47.cyan(`
+${renderStep(1, TOTAL_STEPS, "\u9009\u62E9\u8981\u914D\u7F6E\u7684\u5DE5\u5177")}`));
     platforms = await resolvePlatforms(platformArg);
   } catch (error) {
     console.error(chalk47.red(`\u274C ${error.message}`));
     process.exit(1);
   }
+  console.log(chalk47.gray(`\u5DF2\u9009\u62E9: ${platforms.join(", ")}`));
+  printKeyNotice();
   let openaiDomain;
   try {
+    if (platforms.includes("codex") || platforms.includes("opencode")) {
+      console.log(
+        chalk47.cyan(`
+${renderStep(2, TOTAL_STEPS, "\u9009\u62E9 OpenAI \u7AEF\u70B9 (\u4EC5 Codex/OpenCode)")}`)
+      );
+    } else {
+      console.log(chalk47.cyan(`
+${renderStep(2, TOTAL_STEPS, "\u9009\u62E9 OpenAI \u7AEF\u70B9 (\u5DF2\u8DF3\u8FC7)")}`));
+      console.log(chalk47.gray("\u672A\u9009\u62E9 Codex/OpenCode\uFF0C\u5C06\u8DF3\u8FC7\u6B64\u6B65\u9AA4\u3002"));
+    }
     openaiDomain = await resolveOpenAIDomain(domainArg, platforms);
   } catch (error) {
     console.error(chalk47.red(`\u274C ${error.message}`));
     process.exit(1);
   }
   let resolvedApiKey = apiKey?.trim();
+  console.log(chalk47.cyan(`
+${renderStep(3, TOTAL_STEPS, "\u8F93\u5165 API Key")}`));
   if (!resolvedApiKey) {
     resolvedApiKey = await promptApiKey();
+  } else {
+    console.log(chalk47.gray("\u5DF2\u901A\u8FC7\u53C2\u6570\u63D0\u4F9B API Key\uFF08\u5DF2\u9690\u85CF\uFF09"));
   }
   if (!resolvedApiKey?.trim()) {
     console.error(chalk47.red("\u274C \u9519\u8BEF: API Key \u4E0D\u80FD\u4E3A\u7A7A"));
@@ -6346,9 +6431,14 @@ async function gmnCommand(apiKey, platformArg, domainArg) {
     gemini: GMN_BASE_URLS.gemini,
     opencode: openaiBaseUrl
   };
-  console.log(chalk47.cyan("\u{1F680} \u5F00\u59CB\u914D\u7F6E GMN..."));
-  console.log(chalk47.gray(`\u5E73\u53F0: ${platforms.join(", ")}
-`));
+  console.log(chalk47.cyan(`
+${renderStep(4, TOTAL_STEPS, "\u5F00\u59CB\u5199\u5165\u914D\u7F6E")}`));
+  console.log(chalk47.gray(`\u5DF2\u9009\u62E9\u5E73\u53F0: ${platforms.join(", ")}`));
+  if (platforms.includes("codex") || platforms.includes("opencode")) {
+    console.log(chalk47.gray(`OpenAI \u7AEF\u70B9: ${openaiBaseUrl}`));
+  }
+  printWriteTargets(platforms);
+  console.log();
   const ALL_TOOLS = {
     claude: { name: "Claude Code", manager: createClaudeManager() },
     codex: { name: "Codex", manager: createCodexManager() },
@@ -6359,19 +6449,23 @@ async function gmnCommand(apiKey, platformArg, domainArg) {
     platform,
     ...ALL_TOOLS[platform]
   }));
+  let completed = 0;
   for (const { platform, name, manager } of tools) {
     try {
+      console.log(chalk47.gray(`\u2192 \u914D\u7F6E ${name}...`));
       const baseUrl = platformBaseUrls[platform];
       const existing = manager.findByName(PROVIDER_NAME);
       const provider = existing ? manager.edit(existing.id, { baseUrl, apiKey: resolvedApiKey }) : manager.add({ name: PROVIDER_NAME, baseUrl, apiKey: resolvedApiKey });
       manager.switch(provider.id);
+      completed += 1;
       console.log(chalk47.green(`\u2705 ${name}`));
     } catch (error) {
       console.error(chalk47.red(`\u274C ${name}: ${error.message}`));
     }
   }
-  console.log(chalk47.green("\n\u{1F389} GMN \u914D\u7F6E\u5B8C\u6210\uFF01"));
-  console.log(chalk47.gray("\u63D0\u793A\uFF1A\u8BF7\u91CD\u542F\u5BF9\u5E94\u7684\u5DE5\u5177\u4EE5\u4F7F\u914D\u7F6E\u751F\u6548\u3002"));
+  console.log(chalk47.green(`
+\u{1F389} GMN \u914D\u7F6E\u5B8C\u6210\uFF01(${completed}/${tools.length})`));
+  console.log(chalk47.gray("\u63D0\u793A\uFF1A\u8BF7\u91CD\u542F\u5BF9\u5E94\u5DE5\u5177/\u63D2\u4EF6\u4EE5\u4F7F\u914D\u7F6E\u751F\u6548\u3002"));
 }
 
 // src/index.ts

package/dist/templates/opencode/opencode.json

@@ -0,0 +1,38 @@
+{
+  "provider": {
+    "openai": {
+      "options": {
+        "baseURL": "{{baseUrl}}",
+        "apiKey": "{{apiKey}}"
+      },
+      "models": {
+        "gpt-5.2-codex": {
+          "name": "GPT-5.2 Codex",
+          "options": {
+            "store": false
+          },
+          "variants": {
+            "low": {},
+            "medium": {},
+            "high": {},
+            "xhigh": {}
+          }
+        }
+      }
+    }
+  },
+  "agent": {
+    "build": {
+      "options": {
+        "store": false
+      }
+    },
+    "plan": {
+      "options": {
+        "store": false
+      }
+    }
+  },
+  "$schema": "https://opencode.ai/config.json",
+  "model": "openai/gpt-5.2-codex"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccman",
-  "version": "3.3.3",
+  "version": "3.3.5",
   "type": "module",
   "description": "Manage Codex, Claude Code, Gemini CLI, OpenCode, and MCP API service provider configurations",
   "main": "./dist/index.js",