ccman 3.3.10 → 3.3.12

package/dist/index.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "../core/package.json"() {
     package_default = {
       name: "@ccman/core",
-      version: "3.3.10",
+      version: "3.3.12",
       type: "module",
       description: "Core business logic for ccman - Manage Codex, Claude Code, Gemini CLI, and MCP configurations",
       main: "./dist/index.js",
@@ -300,7 +300,7 @@ function writeCodexConfig(provider) {
   }
   const providerKey = resolveCodexProviderKey(provider);
   nextConfig.model_provider = providerKey;
-  nextConfig.model = provider.model || nextConfig.model || "gpt-5.2-codex";
+  nextConfig.model = provider.model || nextConfig.model || "gpt-5.3-codex";
   nextConfig.model_providers = {
     [providerKey]: {
       name: providerKey,
@@ -329,12 +329,51 @@ var init_codex = __esm({
     __filename = fileURLToPath(import.meta.url);
     __dirname = path3.dirname(__filename);
     CODEX_DEFAULT_CONFIG = {
-      model: "gpt-5.2-codex",
-      model_reasoning_effort: "high",
-      model_verbosity: "high",
-      network_access: "enabled",
+      model: "gpt-5.3-codex",
+      model_reasoning_effort: "xhigh",
       disable_response_storage: true,
-      windows_wsl_setup_acknowledged: true
+      sandbox_mode: "danger-full-access",
+      windows_wsl_setup_acknowledged: true,
+      approval_policy: "never",
+      profile: "auto-max",
+      file_opener: "vscode",
+      web_search: "cached",
+      suppress_unstable_features_warning: true,
+      history: {
+        persistence: "save-all"
+      },
+      tui: {
+        notifications: true
+      },
+      shell_environment_policy: {
+        inherit: "all",
+        ignore_default_excludes: false
+      },
+      sandbox_workspace_write: {
+        network_access: true
+      },
+      features: {
+        plan_tool: true,
+        apply_patch_freeform: true,
+        view_image_tool: true,
+        unified_exec: false,
+        streamable_shell: false,
+        rmcp_client: true,
+        elevated_windows_sandbox: true
+      },
+      profiles: {
+        "auto-max": {
+          approval_policy: "never",
+          sandbox_mode: "workspace-write"
+        },
+        review: {
+          approval_policy: "on-request",
+          sandbox_mode: "workspace-write"
+        }
+      },
+      notice: {
+        hide_gpt5_1_migration_prompt: true
+      }
     };
   }
 });
@@ -748,10 +787,47 @@ var init_opencode = __esm({
 
 // ../core/dist/writers/gemini.js
 import * as fs5 from "fs";
-function loadEnvFile(envPath) {
-  if (!fileExists(envPath))
-    return {};
-  const content = fs5.readFileSync(envPath, "utf-8");
+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 (fs5.existsSync(candidate))
+      return candidate;
+  }
+  return null;
+}
+function loadGeminiSettingsTemplate() {
+  try {
+    const templatePath = resolveTemplatePath3("gemini/settings.json");
+    if (templatePath) {
+      const content = fs5.readFileSync(templatePath, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return GEMINI_SETTINGS_TEMPLATE;
+}
+function loadGeminiEnvTemplate(provider) {
+  let templateContent = GEMINI_ENV_TEMPLATE;
+  try {
+    const templatePath = resolveTemplatePath3("gemini/.env");
+    if (templatePath) {
+      templateContent = fs5.readFileSync(templatePath, "utf-8");
+    }
+  } catch {
+  }
+  const content = templateContent.replaceAll("{{baseUrl}}", provider.baseUrl || "").replaceAll("{{apiKey}}", provider.apiKey || "");
+  return parseEnvContent(content);
+}
+function parseEnvContent(content) {
   const result = {};
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -768,6 +844,12 @@ function loadEnvFile(envPath) {
   }
   return result;
 }
+function loadEnvFile(envPath) {
+  if (!fileExists(envPath))
+    return {};
+  const content = fs5.readFileSync(envPath, "utf-8");
+  return parseEnvContent(content);
+}
 function saveEnvFile(envPath, env) {
   const lines = [];
   const keys = Object.keys(env).sort();
@@ -782,18 +864,20 @@ function writeGeminiConfig(provider) {
   const envPath = getGeminiEnvPath();
   const dir = getGeminiDir();
   ensureDir(dir);
-  let settings = {};
+  let userSettings = {};
   if (fileExists(settingsPath)) {
     try {
       const content = fs5.readFileSync(settingsPath, "utf-8");
       const parsed = JSON.parse(content);
       if (parsed && typeof parsed === "object") {
-        settings = parsed;
+        userSettings = parsed;
       }
     } catch (error) {
       throw new Error(`\u65E0\u6CD5\u8BFB\u53D6 Gemini settings.json: ${error.message}`);
     }
   }
+  const settingsTemplate = loadGeminiSettingsTemplate();
+  const settings = deepMerge(settingsTemplate, userSettings);
   if (!settings.ide || typeof settings.ide !== "object") {
     settings.ide = {};
   }
@@ -818,15 +902,16 @@ function writeGeminiConfig(provider) {
   } 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 {
+  const existingEnv = loadEnvFile(envPath);
+  const templateEnv = loadGeminiEnvTemplate(provider);
+  const env = {
+    ...existingEnv,
+    ...templateEnv
+  };
+  if (!templateEnv.GOOGLE_GEMINI_BASE_URL) {
     delete env.GOOGLE_GEMINI_BASE_URL;
   }
-  if (provider.apiKey && provider.apiKey.trim().length > 0) {
-    env.GEMINI_API_KEY = provider.apiKey;
-  } else {
+  if (!templateEnv.GEMINI_API_KEY) {
     delete env.GEMINI_API_KEY;
   }
   let modelMeta = null;
@@ -854,26 +939,45 @@ function writeGeminiConfig(provider) {
   }
   saveEnvFile(envPath, env);
 }
+var __filename3, __dirname3, GEMINI_SETTINGS_TEMPLATE, GEMINI_ENV_TEMPLATE;
 var init_gemini2 = __esm({
   "../core/dist/writers/gemini.js"() {
     "use strict";
     init_paths();
     init_file();
+    init_template();
+    __filename3 = fileURLToPath3(import.meta.url);
+    __dirname3 = path6.dirname(__filename3);
+    GEMINI_SETTINGS_TEMPLATE = {
+      ide: {
+        enabled: true
+      },
+      security: {
+        auth: {
+          selectedType: "gemini-api-key"
+        }
+      }
+    };
+    GEMINI_ENV_TEMPLATE = [
+      "# Managed by ccman",
+      "GOOGLE_GEMINI_BASE_URL={{baseUrl}}",
+      "GEMINI_API_KEY={{apiKey}}"
+    ].join("\n");
   }
 });
 
 // ../core/dist/writers/opencode.js
 import * as fs6 from "fs";
-import * as path6 from "path";
-import { fileURLToPath as fileURLToPath3 } from "url";
-function resolveTemplatePath3(relativePath) {
+import * as path7 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+function resolveTemplatePath4(relativePath) {
   const candidates = [
     // @ccman/core runtime (dist/writers -> templates)
-    path6.resolve(__dirname3, "../../templates", relativePath),
+    path7.resolve(__dirname4, "../../templates", relativePath),
     // Bundled CLI runtime (dist -> dist/templates)
-    path6.resolve(__dirname3, "templates", relativePath),
+    path7.resolve(__dirname4, "templates", relativePath),
     // Fallback (some bundlers/layouts)
-    path6.resolve(__dirname3, "../templates", relativePath)
+    path7.resolve(__dirname4, "../templates", relativePath)
   ];
   for (const candidate of candidates) {
     if (fs6.existsSync(candidate))
@@ -883,7 +987,7 @@ function resolveTemplatePath3(relativePath) {
 }
 function loadOpenCodeTemplateConfig() {
   try {
-    const templatePath = resolveTemplatePath3("opencode/opencode.json");
+    const templatePath = resolveTemplatePath4("opencode/opencode.json");
     if (templatePath) {
       const content = fs6.readFileSync(templatePath, "utf-8");
       const parsed = JSON.parse(content);
@@ -975,7 +1079,7 @@ function writeOpenCodeConfig(provider) {
   };
   writeJSON(configPath, nextConfig);
 }
-var OPENCODE_SCHEMA, OPENCODE_PROVIDER_KEY, OPENCODE_MODEL, OPENCODE_MODEL_KEY, __filename3, __dirname3, DEFAULT_MODELS, OPENCODE_CONFIG_TEMPLATE;
+var OPENCODE_SCHEMA, OPENCODE_PROVIDER_KEY, OPENCODE_MODEL, OPENCODE_MODEL_KEY, __filename4, __dirname4, DEFAULT_MODELS, OPENCODE_CONFIG_TEMPLATE;
 var init_opencode2 = __esm({
   "../core/dist/writers/opencode.js"() {
     "use strict";
@@ -986,8 +1090,8 @@ var init_opencode2 = __esm({
     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);
+    __filename4 = fileURLToPath4(import.meta.url);
+    __dirname4 = path7.dirname(__filename4);
     DEFAULT_MODELS = {
       [OPENCODE_MODEL_KEY]: {
         name: "GPT-5.2 Codex",
@@ -1057,7 +1161,7 @@ var init_tool_manager_types = __esm({
 });
 
 // ../core/dist/tool-manager.js
-import * as path7 from "path";
+import * as path8 from "path";
 function createToolManager(tool) {
   const toolConfig = TOOL_CONFIGS[tool];
   const configPath = toolConfig.configPath;
@@ -1088,21 +1192,50 @@ function createToolManager(tool) {
     }
     writeJSON(configPath, config);
   }
+  function trimInput(value) {
+    if (value === void 0)
+      return void 0;
+    return value.trim();
+  }
+  function trimProvider(input) {
+    return {
+      ...input,
+      name: input.name.trim(),
+      desc: trimInput(input.desc),
+      baseUrl: input.baseUrl.trim(),
+      apiKey: input.apiKey.trim(),
+      model: trimInput(input.model)
+    };
+  }
+  function trimProviderUpdates(updates) {
+    return {
+      ...updates,
+      name: trimInput(updates.name),
+      desc: trimInput(updates.desc),
+      baseUrl: trimInput(updates.baseUrl),
+      apiKey: trimInput(updates.apiKey),
+      model: trimInput(updates.model)
+    };
+  }
   return {
     add(input) {
       const config = loadConfig2();
-      const nameExists = config.providers.some((p) => p.name === input.name);
+      const normalizedInput = trimProvider(input);
+      if (!normalizedInput.name) {
+        throw new Error("\u670D\u52A1\u5546\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      const nameExists = config.providers.some((p) => p.name.trim() === normalizedInput.name);
       if (nameExists) {
-        throw new ProviderNameConflictError(input.name);
+        throw new ProviderNameConflictError(normalizedInput.name);
       }
       const timestamp = Date.now();
       const provider = {
         id: generateId(),
-        name: input.name,
-        desc: input.desc,
-        baseUrl: input.baseUrl,
-        apiKey: input.apiKey,
-        model: input.model,
+        name: normalizedInput.name,
+        desc: normalizedInput.desc,
+        baseUrl: normalizedInput.baseUrl,
+        apiKey: normalizedInput.apiKey,
+        model: normalizedInput.model,
         createdAt: timestamp,
         lastModified: timestamp
       };
@@ -1127,8 +1260,10 @@ function createToolManager(tool) {
     },
     findByName(name) {
       const config = loadConfig2();
-      const lowerName = name.toLowerCase();
-      return config.providers.find((p) => p.name.toLowerCase() === lowerName);
+      const lowerName = name.trim().toLowerCase();
+      if (!lowerName)
+        return void 0;
+      return config.providers.find((p) => p.name.trim().toLowerCase() === lowerName);
     },
     switch(id) {
       const config = loadConfig2();
@@ -1155,25 +1290,29 @@ function createToolManager(tool) {
     edit(id, updates) {
       const config = loadConfig2();
       const provider = config.providers.find((p) => p.id === id);
+      const normalizedUpdates = trimProviderUpdates(updates);
       if (!provider) {
         throw new ProviderNotFoundError(id);
       }
-      if (updates.name !== void 0 && updates.name !== provider.name) {
-        const nameConflict = config.providers.some((p) => p.id !== id && p.name === updates.name);
+      if (normalizedUpdates.name !== void 0 && !normalizedUpdates.name) {
+        throw new Error("\u670D\u52A1\u5546\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      if (normalizedUpdates.name !== void 0 && normalizedUpdates.name !== provider.name.trim()) {
+        const nameConflict = config.providers.some((p) => p.id !== id && p.name.trim() === normalizedUpdates.name);
         if (nameConflict) {
-          throw new ProviderNameConflictError(updates.name);
+          throw new ProviderNameConflictError(normalizedUpdates.name);
         }
       }
-      if (updates.name !== void 0)
-        provider.name = updates.name;
-      if (updates.desc !== void 0)
-        provider.desc = updates.desc;
-      if (updates.baseUrl !== void 0)
-        provider.baseUrl = updates.baseUrl;
-      if (updates.apiKey !== void 0)
-        provider.apiKey = updates.apiKey;
-      if (updates.model !== void 0)
-        provider.model = updates.model;
+      if (normalizedUpdates.name !== void 0)
+        provider.name = normalizedUpdates.name;
+      if (normalizedUpdates.desc !== void 0)
+        provider.desc = normalizedUpdates.desc;
+      if (normalizedUpdates.baseUrl !== void 0)
+        provider.baseUrl = normalizedUpdates.baseUrl;
+      if (normalizedUpdates.apiKey !== void 0)
+        provider.apiKey = normalizedUpdates.apiKey;
+      if (normalizedUpdates.model !== void 0)
+        provider.model = normalizedUpdates.model;
       provider.lastModified = Date.now();
       saveConfig2(config);
       if (config.currentProviderId === id) {
@@ -1202,15 +1341,19 @@ function createToolManager(tool) {
     clone(sourceId, newName) {
       const source = this.get(sourceId);
       const config = loadConfig2();
-      const nameExists = config.providers.some((p) => p.name === newName);
+      const normalizedName = newName.trim();
+      if (!normalizedName) {
+        throw new Error("\u670D\u52A1\u5546\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      const nameExists = config.providers.some((p) => p.name.trim() === normalizedName);
       if (nameExists) {
-        throw new ProviderNameConflictError(newName);
+        throw new ProviderNameConflictError(normalizedName);
       }
       const timestamp = Date.now();
       const newProvider = {
         ...source,
         id: generateId(),
-        name: newName,
+        name: normalizedName,
         desc: void 0,
         createdAt: timestamp,
         lastModified: timestamp,
@@ -1222,18 +1365,27 @@ function createToolManager(tool) {
     },
     addPreset(input) {
       const config = loadConfig2();
+      const normalizedInput = {
+        ...input,
+        name: input.name.trim(),
+        baseUrl: input.baseUrl.trim(),
+        description: input.description.trim()
+      };
+      if (!normalizedInput.name) {
+        throw new Error("\u9884\u7F6E\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+      }
       if (!config.presets) {
         config.presets = [];
       }
       const allPresets = [...toolConfig.builtinPresets, ...config.presets];
-      const nameExists = allPresets.some((p) => p.name === input.name);
+      const nameExists = allPresets.some((p) => p.name.trim() === normalizedInput.name);
       if (nameExists) {
-        throw new PresetNameConflictError(input.name);
+        throw new PresetNameConflictError(normalizedInput.name);
       }
       const preset = {
-        name: input.name,
-        baseUrl: input.baseUrl,
-        description: input.description
+        name: normalizedInput.name,
+        baseUrl: normalizedInput.baseUrl,
+        description: normalizedInput.description
       };
       config.presets.push(preset);
       saveConfig2(config);
@@ -1257,26 +1409,36 @@ function createToolManager(tool) {
     },
     editPreset(name, updates) {
       const config = loadConfig2();
+      const normalizedName = name.trim();
+      const normalizedUpdates = {
+        ...updates,
+        name: trimInput(updates.name),
+        baseUrl: trimInput(updates.baseUrl),
+        description: trimInput(updates.description)
+      };
       if (!config.presets) {
         config.presets = [];
       }
-      const preset = config.presets.find((p) => p.name === name);
+      const preset = config.presets.find((p) => p.name.trim() === normalizedName);
       if (!preset) {
-        throw new Error(`\u9884\u7F6E\u4E0D\u5B58\u5728: ${name}`);
+        throw new Error(`\u9884\u7F6E\u4E0D\u5B58\u5728: ${normalizedName}`);
       }
-      if (updates.name !== void 0 && updates.name !== preset.name) {
+      if (normalizedUpdates.name !== void 0 && !normalizedUpdates.name) {
+        throw new Error("\u9884\u7F6E\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A");
+      }
+      if (normalizedUpdates.name !== void 0 && normalizedUpdates.name !== preset.name.trim()) {
         const allPresets = [...toolConfig.builtinPresets, ...config.presets];
-        const nameConflict = allPresets.some((p) => p.name !== name && p.name === updates.name);
+        const nameConflict = allPresets.some((p) => p.name.trim() !== normalizedName && p.name.trim() === normalizedUpdates.name);
         if (nameConflict) {
-          throw new PresetNameConflictError(updates.name);
+          throw new PresetNameConflictError(normalizedUpdates.name);
         }
       }
-      if (updates.name !== void 0)
-        preset.name = updates.name;
-      if (updates.baseUrl !== void 0)
-        preset.baseUrl = updates.baseUrl;
-      if (updates.description !== void 0)
-        preset.description = updates.description;
+      if (normalizedUpdates.name !== void 0)
+        preset.name = normalizedUpdates.name;
+      if (normalizedUpdates.baseUrl !== void 0)
+        preset.baseUrl = normalizedUpdates.baseUrl;
+      if (normalizedUpdates.description !== void 0)
+        preset.description = normalizedUpdates.description;
       saveConfig2(config);
       return {
         ...preset,
@@ -1285,12 +1447,13 @@ function createToolManager(tool) {
     },
     removePreset(name) {
       const config = loadConfig2();
+      const normalizedName = name.trim();
       if (!config.presets) {
         return;
       }
-      const index = config.presets.findIndex((p) => p.name === name);
+      const index = config.presets.findIndex((p) => p.name.trim() === normalizedName);
       if (index === -1) {
-        throw new Error(`Preset not found: ${name}`);
+        throw new Error(`Preset not found: ${normalizedName}`);
       }
       config.presets.splice(index, 1);
       saveConfig2(config);
@@ -1331,17 +1494,17 @@ var init_tool_manager = __esm({
     init_tool_manager_types();
     TOOL_CONFIGS = {
       codex: {
-        configPath: path7.join(getCcmanDir(), "codex.json"),
+        configPath: path8.join(getCcmanDir(), "codex.json"),
         builtinPresets: CODEX_PRESETS,
         writer: writeCodexConfig
       },
       claude: {
-        configPath: path7.join(getCcmanDir(), "claude.json"),
+        configPath: path8.join(getCcmanDir(), "claude.json"),
         builtinPresets: CC_PRESETS,
         writer: writeClaudeConfig
       },
       mcp: {
-        configPath: path7.join(getCcmanDir(), "mcp.json"),
+        configPath: path8.join(getCcmanDir(), "mcp.json"),
         builtinPresets: MCP_PRESETS,
         writer: writeMCPConfig,
         autoSync: true,
@@ -1371,12 +1534,12 @@ var init_tool_manager = __esm({
         }
       },
       gemini: {
-        configPath: path7.join(getCcmanDir(), "gemini.json"),
+        configPath: path8.join(getCcmanDir(), "gemini.json"),
         builtinPresets: GEMINI_PRESETS,
         writer: writeGeminiConfig
       },
       opencode: {
-        configPath: path7.join(getCcmanDir(), "opencode.json"),
+        configPath: path8.join(getCcmanDir(), "opencode.json"),
         builtinPresets: OPENCODE_PRESETS,
         writer: writeOpenCodeConfig
       }
@@ -1430,8 +1593,16 @@ function getSyncConfig() {
   return config.sync || null;
 }
 function saveSyncConfig(syncConfig) {
+  const normalizedSyncConfig = {
+    ...syncConfig,
+    webdavUrl: syncConfig.webdavUrl.trim(),
+    username: syncConfig.username.trim(),
+    password: syncConfig.password.trim(),
+    remoteDir: syncConfig.remoteDir?.trim(),
+    syncPassword: syncConfig.syncPassword?.trim()
+  };
   const config = loadConfig();
-  config.sync = syncConfig;
+  config.sync = normalizedSyncConfig;
   saveConfig(config);
 }
 function updateLastSyncTime() {
@@ -1466,9 +1637,9 @@ function joinPath(baseDir, filename) {
   return `${normalizedBase}/${normalizedFile}`;
 }
 function createWebDAVClient(config) {
-  const client = createClient(config.webdavUrl, {
-    username: config.username,
-    password: config.password,
+  const client = createClient(config.webdavUrl.trim(), {
+    username: config.username.trim(),
+    password: config.password.trim(),
     authType: config.authType || "password",
     // 默认使用 Basic Auth
     maxBodyLength: 100 * 1024 * 1024,
@@ -1745,7 +1916,7 @@ var init_merge_advanced = __esm({
 
 // ../core/dist/sync/merge.js
 import fs8 from "fs";
-import path8 from "path";
+import path9 from "path";
 function backupConfig(configPath, keepCount = 3) {
   if (!fs8.existsSync(configPath)) {
     throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${configPath}`);
@@ -1757,8 +1928,8 @@ function backupConfig(configPath, keepCount = 3) {
   return backupPath;
 }
 function cleanupOldBackups(configPath, keepCount) {
-  const dir = path8.dirname(configPath);
-  const basename = path8.basename(configPath);
+  const dir = path9.dirname(configPath);
+  const basename = path9.basename(configPath);
   const backupPrefix = `${basename}.backup.`;
   try {
     const files = fs8.readdirSync(dir);
@@ -1770,7 +1941,7 @@ function cleanupOldBackups(configPath, keepCount) {
       }
       return {
         name: f,
-        path: path8.join(dir, f),
+        path: path9.join(dir, f),
         timestamp
       };
     }).filter((backup) => backup !== null).sort((a, b) => b.timestamp - a.timestamp);
@@ -1794,13 +1965,13 @@ var init_merge = __esm({
 
 // ../core/dist/sync/sync-v2.js
 import fs9 from "fs";
-import path9 from "path";
+import path10 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 = path9.join(ccmanDir2, configFilename);
+    const configPath = path10.join(ccmanDir2, configFilename);
     const localConfig = readJSON(configPath);
     const encryptedProviders = encryptProviders(localConfig.providers, password);
     const encryptedConfig = {
@@ -1846,7 +2017,7 @@ async function downloadFromCloud(config, password) {
   try {
     for (const tool of toolKeys) {
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path9.join(ccmanDir2, configFilename);
+      const configPath = path10.join(ccmanDir2, configFilename);
       if (fs9.existsSync(configPath)) {
         backupPaths.push(backupConfig(configPath));
       }
@@ -1859,7 +2030,7 @@ async function downloadFromCloud(config, password) {
       if (!remoteConfig || !decryptedProviders)
         continue;
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path9.join(ccmanDir2, configFilename);
+      const configPath = path10.join(ccmanDir2, configFilename);
       const newConfig = {
         ...remoteConfig,
         // 使用云端配置的所有字段
@@ -1901,7 +2072,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 = path9.join(ccmanDir2, configFilename);
+    const configPath = path10.join(ccmanDir2, configFilename);
     const localConfig = readJSON(configPath);
     let remoteProviders = [];
     if (existsChecks[i]) {
@@ -1933,7 +2104,7 @@ async function mergeSync(config, password) {
   try {
     for (const tool of toolKeys) {
       const { configFilename } = TOOL_SYNC_CONFIG[tool];
-      const configPath = path9.join(ccmanDir2, configFilename);
+      const configPath = path10.join(ccmanDir2, configFilename);
       if (fs9.existsSync(configPath)) {
         backupPaths.push(backupConfig(configPath));
       }
@@ -1945,7 +2116,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 = path9.join(ccmanDir2, configFilename);
+      const configPath = path10.join(ccmanDir2, configFilename);
       let remoteConfig = null;
       if (existsChecks[i]) {
         const jsonContent2 = await downloadFromWebDAV(config, remotePath);
@@ -2036,11 +2207,11 @@ var init_sync_v2 = __esm({
 
 // ../core/dist/export.js
 import * as fs10 from "fs";
-import * as path10 from "path";
+import * as path11 from "path";
 function validateExport() {
   const ccmanDir2 = getCcmanDir();
-  const codexPath = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const claudePath = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const codexPath = path11.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const claudePath = path11.join(ccmanDir2, CLAUDE_CONFIG_FILE);
   const missingFiles = [];
   if (!fileExists(codexPath)) {
     missingFiles.push(CODEX_CONFIG_FILE);
@@ -2073,8 +2244,8 @@ function validateImportDir(sourceDir) {
       foundFiles: []
     };
   }
-  const codexPath = path10.join(sourceDir, CODEX_CONFIG_FILE);
-  const claudePath = path10.join(sourceDir, CLAUDE_CONFIG_FILE);
+  const codexPath = path11.join(sourceDir, CODEX_CONFIG_FILE);
+  const claudePath = path11.join(sourceDir, CLAUDE_CONFIG_FILE);
   const foundFiles = [];
   if (fileExists(codexPath)) {
     foundFiles.push(CODEX_CONFIG_FILE);
@@ -2102,14 +2273,14 @@ function exportConfig(targetDir) {
   ensureDir(targetDir);
   const ccmanDir2 = getCcmanDir();
   const exportedFiles = [];
-  const codexSrc = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
-  const codexDst = path10.join(targetDir, CODEX_CONFIG_FILE);
+  const codexSrc = path11.join(ccmanDir2, CODEX_CONFIG_FILE);
+  const codexDst = path11.join(targetDir, CODEX_CONFIG_FILE);
   if (fileExists(codexSrc)) {
     fs10.copyFileSync(codexSrc, codexDst);
     exportedFiles.push(CODEX_CONFIG_FILE);
   }
-  const claudeSrc = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
-  const claudeDst = path10.join(targetDir, CLAUDE_CONFIG_FILE);
+  const claudeSrc = path11.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+  const claudeDst = path11.join(targetDir, CLAUDE_CONFIG_FILE);
   if (fileExists(claudeSrc)) {
     fs10.copyFileSync(claudeSrc, claudeDst);
     exportedFiles.push(CLAUDE_CONFIG_FILE);
@@ -2131,22 +2302,22 @@ function importConfig(sourceDir) {
   ensureDir(ccmanDir2);
   try {
     if (validation.foundFiles.includes(CODEX_CONFIG_FILE)) {
-      const codexDst = path10.join(ccmanDir2, CODEX_CONFIG_FILE);
+      const codexDst = path11.join(ccmanDir2, CODEX_CONFIG_FILE);
       if (fileExists(codexDst)) {
         const backupPath = backupConfig(codexDst);
         backupPaths.push(backupPath);
       }
-      const codexSrc = path10.join(sourceDir, CODEX_CONFIG_FILE);
+      const codexSrc = path11.join(sourceDir, CODEX_CONFIG_FILE);
       fs10.copyFileSync(codexSrc, codexDst);
       importedFiles.push(CODEX_CONFIG_FILE);
     }
     if (validation.foundFiles.includes(CLAUDE_CONFIG_FILE)) {
-      const claudeDst = path10.join(ccmanDir2, CLAUDE_CONFIG_FILE);
+      const claudeDst = path11.join(ccmanDir2, CLAUDE_CONFIG_FILE);
       if (fileExists(claudeDst)) {
         const backupPath = backupConfig(claudeDst);
         backupPaths.push(backupPath);
       }
-      const claudeSrc = path10.join(sourceDir, CLAUDE_CONFIG_FILE);
+      const claudeSrc = path11.join(sourceDir, CLAUDE_CONFIG_FILE);
       fs10.copyFileSync(claudeSrc, claudeDst);
       importedFiles.push(CLAUDE_CONFIG_FILE);
     }
@@ -2819,8 +2990,8 @@ function downloadCommand(program2) {
       console.log();
       if (backupPaths.length > 0) {
         console.log(chalk7.gray("\u672C\u5730\u5907\u4EFD:"));
-        backupPaths.forEach((path13) => {
-          console.log(chalk7.gray(`  ${path13}`));
+        backupPaths.forEach((path14) => {
+          console.log(chalk7.gray(`  ${path14}`));
         });
         console.log();
       }
@@ -2881,8 +3052,8 @@ function mergeCommand(program2) {
       console.log();
       if (result.backupPaths.length > 0) {
         console.log(chalk8.gray("\u5907\u4EFD:"));
-        result.backupPaths.forEach((path13) => {
-          console.log(chalk8.gray(`  ${path13}`));
+        result.backupPaths.forEach((path14) => {
+          console.log(chalk8.gray(`  ${path14}`));
         });
         console.log();
       }
@@ -3159,7 +3330,7 @@ async function promptProviderForm(defaults) {
       message: "\u670D\u52A1\u5546\u540D\u79F0:",
       default: defaults?.name || void 0,
       validate: (value) => {
-        if (!value) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+        if (!value?.trim()) return "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
         return true;
       }
     },
@@ -3175,8 +3346,9 @@ async function promptProviderForm(defaults) {
       message: "API \u5730\u5740:",
       default: defaults?.baseUrl || void 0,
       validate: (value) => {
-        if (!value) return "API \u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A";
-        if (!value.startsWith("http://") && !value.startsWith("https://")) {
+        const trimmed = value?.trim();
+        if (!trimmed) return "API \u5730\u5740\u4E0D\u80FD\u4E3A\u7A7A";
+        if (!trimmed.startsWith("http://") && !trimmed.startsWith("https://")) {
           return "API \u5730\u5740\u5FC5\u987B\u4EE5 http:// \u6216 https:// \u5F00\u5934";
         }
         return true;
@@ -3189,16 +3361,16 @@ async function promptProviderForm(defaults) {
       default: defaults?.apiKey || void 0,
       mask: "*",
       validate: (value) => {
-        if (!value) return "API \u5BC6\u94A5\u4E0D\u80FD\u4E3A\u7A7A";
+        if (!value?.trim()) return "API \u5BC6\u94A5\u4E0D\u80FD\u4E3A\u7A7A";
         return true;
       }
     }
   ]);
   return {
-    name: answers.name,
-    desc: answers.desc || void 0,
-    baseUrl: answers.baseUrl,
-    apiKey: answers.apiKey
+    name: answers.name.trim(),
+    desc: answers.desc?.trim() || void 0,
+    baseUrl: answers.baseUrl.trim(),
+    apiKey: answers.apiKey.trim()
   };
 }
 async function startMainMenu() {
@@ -6075,7 +6247,7 @@ init_sync();
 // src/commands/export.ts
 init_dist2();
 import chalk45 from "chalk";
-import path11 from "path";
+import path12 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 {
@@ -6086,7 +6258,7 @@ function exportCommand(program2) {
 `));
         process.exit(1);
       }
-      const resolvedPath = targetDir.startsWith("~") ? path11.join(process.env.HOME || "", targetDir.slice(1)) : path11.resolve(targetDir);
+      const resolvedPath = targetDir.startsWith("~") ? path12.join(process.env.HOME || "", targetDir.slice(1)) : path12.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`);
@@ -6118,11 +6290,11 @@ function exportCommand(program2) {
 init_dist2();
 import chalk46 from "chalk";
 import inquirer32 from "inquirer";
-import path12 from "path";
+import path13 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("~") ? path12.join(process.env.HOME || "", sourceDir.slice(1)) : path12.resolve(sourceDir);
+      const resolvedPath = sourceDir.startsWith("~") ? path13.join(process.env.HOME || "", sourceDir.slice(1)) : path13.resolve(sourceDir);
       console.log(chalk46.bold("\n\u{1F4E5} \u5BFC\u5165\u914D\u7F6E\n"));
       const validation = validateImportDir(resolvedPath);
       if (!validation.valid) {
@@ -6288,12 +6460,12 @@ async function promptApiKey() {
       message: "\u8BF7\u8F93\u5165 GMN API Key:",
       mask: "*",
       validate: (value) => {
-        if (!value) return "API Key \u4E0D\u80FD\u4E3A\u7A7A";
+        if (!value?.trim()) return "API Key \u4E0D\u80FD\u4E3A\u7A7A";
         return true;
       }
     }
   ]);
-  return answers.apiKey;
+  return answers.apiKey.trim();
 }
 async function promptPlatforms() {
   const answers = await inquirer33.prompt([

package/dist/templates/codex/config.toml

@@ -1,13 +1,50 @@
-model_provider = "gmn"
 model = "gpt-5.3-codex"
 model_reasoning_effort = "xhigh"
-network_access = "enabled"
 disable_response_storage = true
+sandbox_mode = "danger-full-access"
 windows_wsl_setup_acknowledged = true
-model_verbosity = "high"
+approval_policy = "never"
+profile = "auto-max"
+file_opener = "vscode"
+model_provider = "gmn"
+web_search = "cached"
+suppress_unstable_features_warning = true
+
+[history]
+persistence = "save-all"
+
+[tui]
+notifications = true
+
+[shell_environment_policy]
+inherit = "all"
+ignore_default_excludes = false
+
+[sandbox_workspace_write]
+network_access = true
+
+[features]
+plan_tool = true
+apply_patch_freeform = true
+view_image_tool = true
+unified_exec = false
+streamable_shell = false
+rmcp_client = true
+elevated_windows_sandbox = true
+
+[profiles.auto-max]
+approval_policy = "never"
+sandbox_mode = "workspace-write"
+
+[profiles.review]
+approval_policy = "on-request"
+sandbox_mode = "workspace-write"
+
+[notice]
+hide_gpt5_1_migration_prompt = true
 
 [model_providers.gmn]
 name = "gmn"
 base_url = "https://gmn.chuangzuoli.com"
 wire_api = "responses"
-requires_openai_auth = true
+requires_openai_auth = true

package/dist/templates/gemini/settings.json

@@ -0,0 +1,10 @@
+{
+  "ide": {
+    "enabled": true
+  },
+  "security": {
+    "auth": {
+      "selectedType": "gemini-api-key"
+    }
+  }
+}

package/package.json

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