coding-tool-x 3.6.7 → 3.6.9

package/src/server/services/config-artifact-paths.js

@@ -0,0 +1,116 @@
+const path = require('path');
+
+function isWindowsAbsolutePath(input = '') {
+  return path.win32.isAbsolute(String(input || '')) || /^[a-zA-Z]:[\\/]/.test(String(input || ''));
+}
+
+function normalizeSafeRelativePath(input, label = 'path', options = {}) {
+  const {
+    allowEmpty = false,
+    allowHiddenSegments = false,
+    allowBackslash = true
+  } = options;
+
+  const rawInput = String(input ?? '').trim();
+  if (!rawInput) {
+    if (allowEmpty) return '';
+    throw new Error(`Invalid ${label}`);
+  }
+  if (rawInput.includes('\0')) {
+    throw new Error(`Invalid ${label}`);
+  }
+  if (path.isAbsolute(rawInput) || isWindowsAbsolutePath(rawInput) || rawInput.startsWith('//') || rawInput.startsWith('\\\\')) {
+    throw new Error(`Invalid ${label}`);
+  }
+  if (!allowBackslash && rawInput.includes('\\')) {
+    throw new Error(`Invalid ${label}`);
+  }
+
+  const normalizedInput = rawInput.replace(/\\/g, '/');
+  const normalized = path.posix.normalize(normalizedInput).replace(/^(\.\/)+/, '');
+  if (!normalized || normalized === '.') {
+    if (allowEmpty) return '';
+    throw new Error(`Invalid ${label}`);
+  }
+  if (
+    normalized === '..' ||
+    normalized.startsWith('../') ||
+    normalized.includes('/../') ||
+    path.posix.isAbsolute(normalized)
+  ) {
+    throw new Error(`Invalid ${label}`);
+  }
+
+  const segments = normalized.split('/').filter(Boolean);
+  if (!allowHiddenSegments && segments.some(segment => segment.startsWith('.'))) {
+    throw new Error(`Invalid ${label}`);
+  }
+
+  return normalized;
+}
+
+function normalizeSafeFileStem(input, label = 'name', options = {}) {
+  const {
+    allowDots = true,
+    allowHidden = false,
+    pattern = allowDots
+      ? /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/
+      : /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/
+  } = options;
+  const rawInput = String(input ?? '').trim();
+  if (!rawInput || rawInput.includes('\0')) {
+    throw new Error(`Invalid ${label}`);
+  }
+  if (rawInput.includes('/') || rawInput.includes('\\') || rawInput.includes('..')) {
+    throw new Error(`Invalid ${label}`);
+  }
+  if (!allowHidden && rawInput.startsWith('.')) {
+    throw new Error(`Invalid ${label}`);
+  }
+  if (pattern && !pattern.test(rawInput)) {
+    throw new Error(`Invalid ${label}`);
+  }
+  return rawInput;
+}
+
+function resolveInsideRoot(rootDir, relativePath, label = 'path', options = {}) {
+  const { allowRoot = false } = options;
+  const resolvedRoot = path.resolve(rootDir);
+  const safeRelativePath = normalizeSafeRelativePath(relativePath, label, options);
+  const resolvedPath = path.resolve(resolvedRoot, safeRelativePath);
+  const isInside = resolvedPath === resolvedRoot || resolvedPath.startsWith(`${resolvedRoot}${path.sep}`);
+  if (!isInside || (!allowRoot && resolvedPath === resolvedRoot)) {
+    throw new Error(`${label} escapes target directory`);
+  }
+  return resolvedPath;
+}
+
+function assertInsideAllowedRoots(targetPath, roots = [], label = 'path', options = {}) {
+  const { allowRoot = false } = options;
+  const resolvedTarget = path.resolve(String(targetPath || ''));
+  const allowed = roots.some(root => {
+    if (!root) return false;
+    const resolvedRoot = path.resolve(root);
+    if (!allowRoot && resolvedTarget === resolvedRoot) return false;
+    return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(`${resolvedRoot}${path.sep}`);
+  });
+  if (!allowed) {
+    throw new Error(`${label} escapes allowed directories`);
+  }
+  return resolvedTarget;
+}
+
+function pathHasProtectedSegment(relativePath, protectedSegments = []) {
+  const normalized = normalizeSafeRelativePath(relativePath, 'path', { allowHiddenSegments: true });
+  const segments = normalized.split('/').filter(Boolean);
+  return protectedSegments.some(segment => segments.includes(segment));
+}
+
+module.exports = {
+  assertInsideAllowedRoots,
+  isWindowsAbsolutePath,
+  normalizeSafeFileStem,
+  normalizeSafeRelativePath,
+  pathHasProtectedSegment,
+  resolveInsideRoot
+};

package/src/server/services/config-export-service.js

@@ -45,8 +45,8 @@ const CC_SECURITY_PATH = PATHS.security;
 const LEGACY_UI_CONFIG_PATH = PATHS.uiConfig;
 const LEGACY_NOTIFY_HOOK_PATH = PATHS.notifyHook;
 const GEMINI_SETTINGS_PATH = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
-const AGENT_PLATFORMS = ['claude', 'codex', 'opencode'];
-const COMMAND_PLATFORMS = ['claude', 'opencode'];
+const AGENT_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
+const COMMAND_PLATFORMS = ['claude', 'gemini', 'opencode'];
 const SKILL_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
 
 function getOpenCodeConfigPaths() {
@@ -386,14 +386,15 @@ function resolveAgentRelativePath(agent, platform) {
   return platform === 'codex' ? `${baseName}.toml` : `${baseName}.md`;
 }
 
-function resolveCommandRelativePath(command) {
+function resolveCommandRelativePath(command, platform = 'claude') {
   if (typeof command?.path === 'string' && command.path.trim()) {
     return command.path.trim();
   }
+  const extension = platform === 'gemini' ? '.toml' : '.md';
   if (command?.namespace) {
-    return path.join(command.namespace, `${command.name}.md`);
+    return path.join(command.namespace, `${command.name}${extension}`);
   }
-  return command?.name ? `${command.name}.md` : null;
+  return command?.name ? `${command.name}${extension}` : null;
 }
 
 function pickPrimaryChannel(channels = []) {
@@ -1399,7 +1400,7 @@ async function importConfigs(importData, options = {}) {
           const baseDir = commandsService.userCommandsDir;
 
           for (const command of platformCommands) {
-            const relativePath = resolveCommandRelativePath(command);
+            const relativePath = resolveCommandRelativePath(command, platform);
             const content = command.fullContent || command.content || buildCommandContent(command);
 
             const status = relativePath ? writeTextFile(baseDir, relativePath, content, overwrite) : 'failed';

package/src/server/services/config-registry-service.js

@@ -31,8 +31,8 @@ const SUPPORTED_PLATFORMS = ['claude', 'codex', 'gemini', 'opencode'];
 
 const PLATFORM_SUPPORT = {
   skills: { claude: true, codex: true, gemini: true, opencode: true },
-  commands: { claude: true, codex: true, gemini: false, opencode: true },
-  agents: { claude: true, codex: true, gemini: false, opencode: true },
+  commands: { claude: true, codex: true, gemini: true, opencode: true },
+  agents: { claude: true, codex: true, gemini: true, opencode: true },
   plugins: { claude: true, codex: false, gemini: false, opencode: true }
 };
 

package/src/server/services/config-sync-manager.js

@@ -4,7 +4,7 @@
  * Manages file synchronization between cc-tool central storage and CLI directories:
  * - Claude Code: ~/.claude/{skills,commands,agents,plugins}/
  * - Codex CLI: ~/.codex/skills/, ~/.codex/prompts/
- * - Gemini CLI: ~/.gemini/skills/
+ * - Gemini CLI: ~/.gemini/{skills,commands,agents}/
  * - OpenCode CLI: ~/.config/opencode/{skills,commands,agents,plugins}/
  *
  * Config types:
@@ -19,7 +19,7 @@ const path = require('path');
 const os = require('os');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { convertSkillToCodex, convertCommandToCodex } = require('./format-converter');
+const { convertSkillToCodex, convertCommandToCodex, convertCommandToGemini } = require('./format-converter');
 const { PATHS, NATIVE_PATHS, HOME_DIR, ensureStorageDirMigrated } = require('../../config/paths');
 
 // Paths
@@ -53,7 +53,9 @@ const CONFIG_TYPES = {
     codexTarget: 'prompts',
     codexSupported: true,
     convertForCodex: true,
-    geminiSupported: false,
+    geminiTarget: 'commands',
+    geminiExtension: '.toml',
+    geminiSupported: true,
     opencodeTarget: 'commands',
     opencodeLegacyTarget: 'command',
     opencodeSupported: true
@@ -63,7 +65,8 @@ const CONFIG_TYPES = {
     extension: '.md',
     claudeTarget: 'agents',
     codexSupported: true,
-    geminiSupported: false,
+    geminiTarget: 'agents',
+    geminiSupported: true,
     opencodeTarget: 'agents',
     opencodeLegacyTarget: 'agent',
     opencodeSupported: true
@@ -384,7 +387,7 @@ class ConfigSyncManager {
 
   /**
    * Sync a config item to Gemini CLI
-   * Currently only skills are supported
+   * Supports skills, commands, and agents.
    * @param {string} type - Config type
    * @param {string} name - Item name
    * @returns {Object} Result with success status
@@ -411,10 +414,21 @@ class ConfigSyncManager {
     }
 
     try {
-      const targetPath = path.join(this.geminiDir, config.geminiTarget, safeName);
+      const targetPath = this._getGeminiTargetPath(config, safeName);
       this._ensureDir(path.dirname(targetPath));
-      this._copyDirRecursive(sourcePath, targetPath);
-      console.log(`[ConfigSyncManager] Synced ${type}/${name} to Gemini (directory)`);
+      if (config.isDirectory) {
+        this._copyDirRecursive(sourcePath, targetPath);
+        console.log(`[ConfigSyncManager] Synced ${type}/${name} to Gemini (directory)`);
+      } else if (type === 'commands') {
+        const content = fs.readFileSync(sourcePath, 'utf-8');
+        const result = convertCommandToGemini(content);
+        fs.writeFileSync(targetPath, result.content, 'utf-8');
+        console.log(`[ConfigSyncManager] Synced ${type}/${name} to Gemini (command TOML)`);
+        return { success: true, target: targetPath, warnings: result.warnings || [] };
+      } else {
+        this._copyFile(sourcePath, targetPath);
+        console.log(`[ConfigSyncManager] Synced ${type}/${name} to Gemini (file)`);
+      }
       return { success: true, target: targetPath };
     } catch (err) {
       console.error(`[ConfigSyncManager] Sync to Gemini failed:`, err.message);
@@ -443,15 +457,21 @@ class ConfigSyncManager {
       return { success: true, skipped: true, reason: 'Not supported by Gemini' };
     }
 
-    const targetPath = path.join(this.geminiDir, config.geminiTarget, safeName);
+    const targetPath = this._getGeminiTargetPath(config, safeName);
     if (!fs.existsSync(targetPath)) {
       console.log(`[ConfigSyncManager] Target not found (already removed): ${targetPath}`);
       return { success: true, message: 'Already removed' };
     }
 
     try {
-      this._removeRecursive(targetPath);
-      console.log(`[ConfigSyncManager] Removed ${type}/${name} from Gemini (directory)`);
+      if (config.isDirectory) {
+        this._removeRecursive(targetPath);
+        console.log(`[ConfigSyncManager] Removed ${type}/${name} from Gemini (directory)`);
+      } else {
+        fs.unlinkSync(targetPath);
+        console.log(`[ConfigSyncManager] Removed ${type}/${name} from Gemini (file)`);
+        this._cleanupEmptyParents(path.dirname(targetPath), path.join(this.geminiDir, config.geminiTarget));
+      }
       return { success: true };
     } catch (err) {
       console.error(`[ConfigSyncManager] Remove from Gemini failed:`, err.message);
@@ -616,6 +636,9 @@ class ConfigSyncManager {
           const result = this.syncToGemini(type, name);
           if (result.success && !result.skipped) {
             results.synced.push({ type, name, platform: 'gemini' });
+            if (result.warnings && result.warnings.length > 0) {
+              results.warnings.push({ type, name, platform: 'gemini', warnings: result.warnings });
+            }
           } else if (!result.success) {
             results.errors.push({ type, name, platform: 'gemini', error: result.error });
           }
@@ -762,6 +785,17 @@ class ConfigSyncManager {
     return modernDir;
   }
 
+  _getGeminiTargetPath(config, safeName) {
+    const targetName = config.geminiExtension
+      ? safeName.replace(new RegExp(`${this._escapeRegExp(path.extname(safeName))}$`, 'i'), config.geminiExtension)
+      : safeName;
+    return path.join(this.geminiDir, config.geminiTarget, targetName);
+  }
+
+  _escapeRegExp(value) {
+    return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
   /**
    * Recursively remove a file or directory
    */

package/src/server/services/config-templates-service.js

@@ -12,7 +12,7 @@ const { AgentsService } = require('./agents-service');
 const { CommandsService } = require('./commands-service');
 const { SkillService } = require('./skill-service');
 const { PluginsService } = require('./plugins-service');
-const { convertCommandToCodex } = require('./format-converter');
+const { convertCommandToCodex, convertCommandToGemini } = require('./format-converter');
 const mcpService = require('./mcp-service');
 const promptsService = require('./prompts-service');
 const pluginsService = new PluginsService();
@@ -499,6 +499,10 @@ function generateCommandContent(command) {
   return lines.join('\n') + '\n\n' + (command.body || '');
 }
 
+function buildTemplateCommandFileName(commandName, format) {
+  return `${commandName}.${format === 'gemini' ? 'toml' : 'md'}`;
+}
+
 /**
  * 转换为 OpenCode MCP 结构（local/remote）
  */
@@ -588,6 +592,9 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
     if (aiConfigTypes.includes('opencode')) {
       agentTargets.push({ baseDir: path.join(targetDir, '.opencode', 'agents'), prefix: '.opencode/agents' });
     }
+    if (aiConfigTypes.includes('gemini')) {
+      agentTargets.push({ baseDir: path.join(targetDir, '.gemini', 'agents'), prefix: '.gemini/agents' });
+    }
 
     for (const target of agentTargets) {
       ensureDir(target.baseDir);
@@ -606,9 +613,6 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
       if (aiConfigTypes.includes('codex')) {
         pushSkipped(results.skipped, 'agent', fileName, 'Codex agents 仅支持用户级配置，项目目录应用时已跳过');
       }
-      if (aiConfigTypes.includes('gemini')) {
-        pushSkipped(results.skipped, 'agent', fileName, 'Gemini 不支持 agents，已跳过');
-      }
       if (written) {
         results.agents.applied++;
       }
@@ -626,6 +630,9 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
     if (aiConfigTypes.includes('opencode')) {
       commandTargets.push({ baseDir: path.join(targetDir, '.opencode', 'commands'), prefix: '.opencode/commands', format: 'claude' });
     }
+    if (aiConfigTypes.includes('gemini')) {
+      commandTargets.push({ baseDir: path.join(targetDir, '.gemini', 'commands'), prefix: '.gemini/commands', format: 'gemini' });
+    }
 
     for (const target of commandTargets) {
       ensureDir(target.baseDir);
@@ -638,23 +645,21 @@ function applyTemplateToProject(targetDir, templateId, options = {}) {
         let content = generateCommandContent(command);
         if (target.format === 'codex') {
           content = convertCommandToCodex(content).content;
+        } else if (target.format === 'gemini') {
+          content = convertCommandToGemini(content).content;
         }
         const targetCmdDir = command.namespace
           ? path.join(target.baseDir, command.namespace)
           : target.baseDir;
         ensureDir(targetCmdDir);
-        const filePath = path.join(targetCmdDir, `${commandName}.md`);
+        const filePath = path.join(targetCmdDir, buildTemplateCommandFileName(commandName, target.format));
         fs.writeFileSync(filePath, content, 'utf-8');
         const relativePath = command.namespace
-          ? `${target.prefix}/${command.namespace}/${commandName}.md`
-          : `${target.prefix}/${commandName}.md`;
+          ? `${target.prefix}/${command.namespace}/${buildTemplateCommandFileName(commandName, target.format)}`
+          : `${target.prefix}/${buildTemplateCommandFileName(commandName, target.format)}`;
         results.commands.files.push(relativePath);
         written = true;
       }
-
-      if (aiConfigTypes.includes('gemini')) {
-        pushSkipped(results.skipped, 'command', commandName, 'Gemini 不支持 commands，已跳过');
-      }
       if (written) {
         results.commands.applied++;
       }
@@ -795,6 +800,7 @@ function previewTemplateApplication(targetDir, templateId, options = {}) {
     const agentPrefixes = [];
     if (aiConfigTypes.includes('claude')) agentPrefixes.push('.claude/agents');
     if (aiConfigTypes.includes('opencode')) agentPrefixes.push('.opencode/agents');
+    if (aiConfigTypes.includes('gemini')) agentPrefixes.push('.gemini/agents');
 
     for (const agent of template.agents) {
       const fileName = resolveItemName(agent.fileName, agent.name, 'agent').toLowerCase().replace(/\s+/g, '-');
@@ -812,9 +818,6 @@ function previewTemplateApplication(targetDir, templateId, options = {}) {
       if (aiConfigTypes.includes('codex')) {
         pushSkipped(preview.skipped, 'agent', fileName, 'Codex agents 仅支持用户级配置，项目目录预览时已跳过');
       }
-      if (aiConfigTypes.includes('gemini')) {
-        pushSkipped(preview.skipped, 'agent', fileName, 'Gemini 不支持 agents，已跳过');
-      }
       if (applicable) {
         preview.summary.agents++;
       }
@@ -826,14 +829,16 @@ function previewTemplateApplication(targetDir, templateId, options = {}) {
     if (aiConfigTypes.includes('claude')) commandPrefixes.push('.claude/commands');
     if (aiConfigTypes.includes('codex')) commandPrefixes.push('.codex/prompts');
     if (aiConfigTypes.includes('opencode')) commandPrefixes.push('.opencode/commands');
+    if (aiConfigTypes.includes('gemini')) commandPrefixes.push('.gemini/commands');
 
     for (const command of template.commands) {
       const commandName = resolveItemName(command.name, null, 'command');
       let applicable = false;
       for (const prefix of commandPrefixes) {
+        const extension = prefix === '.gemini/commands' ? 'toml' : 'md';
         const relativePath = command.namespace
-          ? `${prefix}/${command.namespace}/${commandName}.md`
-          : `${prefix}/${commandName}.md`;
+          ? `${prefix}/${command.namespace}/${commandName}.${extension}`
+          : `${prefix}/${commandName}.${extension}`;
         const fullPath = path.join(targetDir, relativePath);
         if (fs.existsSync(fullPath)) {
           preview.willOverwrite.push(relativePath);
@@ -842,9 +847,6 @@ function previewTemplateApplication(targetDir, templateId, options = {}) {
         }
         applicable = true;
       }
-      if (aiConfigTypes.includes('gemini')) {
-        pushSkipped(preview.skipped, 'command', commandName, 'Gemini 不支持 commands，已跳过');
-      }
       if (applicable) {
         preview.summary.commands++;
       }

package/src/server/services/format-converter.js

@@ -1,11 +1,13 @@
 /**
  * 格式转换服务
  *
- * 支持 Claude Code ↔ Codex CLI 格式互转
+ * 支持 Claude Code ↔ Codex CLI/Gemini CLI 格式互转
  * - Skills: SKILL.md 格式转换
  * - Commands/Prompts: 命令/提示格式转换
  */
 
+const tomlStringify = require('@iarna/toml').stringify;
+
 // Codex CLI 限制
 const CODEX_LIMITS = {
   skillName: 100,
@@ -268,8 +270,9 @@ function escapeYamlString(str) {
  * 检测 Skill 格式
  * @returns {'claude' | 'codex' | 'unknown'}
  */
-function detectSkillFormat(content) {
+function detectSkillFormat(content, options = {}) {
   const { frontmatter } = parseFrontmatter(content);
+  const platform = options.platform || '';
 
   // Codex 特征: 有 metadata 对象
   if (frontmatter.metadata && typeof frontmatter.metadata === 'object') {
@@ -281,6 +284,11 @@ function detectSkillFormat(content) {
     return 'claude';
   }
 
+  // 在 Codex 平台上下文中，metadata 是可选的；name + description 已足够作为 Codex skill。
+  if (platform === 'codex' && frontmatter.name && frontmatter.description) {
+    return 'codex';
+  }
+
   // 两者都有 name 和 description，无法区分时默认 claude
   if (frontmatter.name && frontmatter.description) {
     return 'claude';
@@ -434,6 +442,35 @@ function convertCommandToCodex(claudeContent, options = {}) {
   };
 }
 
+/**
+ * 转换 Command: Claude Code → Gemini CLI (Custom Command TOML)
+ */
+function convertCommandToGemini(claudeContent, options = {}) {
+  const { frontmatter, body } = parseFrontmatter(claudeContent);
+  const warnings = [];
+
+  const commandConfig = {
+    prompt: body || ''
+  };
+
+  if (frontmatter.description) {
+    commandConfig.description = frontmatter.description;
+  }
+
+  const unsupportedFields = ['allowed-tools', 'model', 'context', 'agent', 'hooks'];
+  for (const field of unsupportedFields) {
+    if (frontmatter[field]) {
+      warnings.push(`${field} 字段在 Gemini commands 中不支持，已忽略`);
+    }
+  }
+
+  return {
+    content: tomlStringify(commandConfig),
+    warnings,
+    format: 'gemini'
+  };
+}
+
 /**
  * 转换 Command: Codex CLI (Custom Prompt) → Claude Code
  */
@@ -528,9 +565,9 @@ function convertCommandsBatch(commands, targetFormat) {
 /**
  * 解析 Skill 内容（支持双格式）
  */
-function parseSkillContent(content) {
+function parseSkillContent(content, options = {}) {
   const { frontmatter, body } = parseFrontmatter(content);
-  const format = detectSkillFormat(content);
+  const format = detectSkillFormat(content, options);
 
   const result = {
     name: frontmatter.name || '',
@@ -606,6 +643,7 @@ module.exports = {
 
   // Commands 转换
   convertCommandToCodex,
+  convertCommandToGemini,
   convertCommandToClaude,
   convertCommandsBatch,
 

package/src/server/services/gemini-channels.js

@@ -6,6 +6,21 @@ const { resolveChannelWebsiteUrl } = require('../../config/channel-preset-websit
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { normalizeGatewaySourceType } = require('./base/proxy-utils');
 
+const GEMINI_API_FORMATS = new Set(['gemini_api', 'vertex_ai_v1']);
+
+function clearChannelBalanceCache(channel) {
+  try {
+    require('./channel-balance').clearChannelBalanceCache('gemini', channel);
+  } catch (_) {
+    // Balance cache invalidation is best-effort and should not block channel updates.
+  }
+}
+
+function normalizeGeminiApiFormat(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  return GEMINI_API_FORMATS.has(normalized) ? normalized : 'gemini_api';
+}
+
 /**
  * Gemini 渠道管理服务（多渠道架构）
  *
@@ -118,6 +133,7 @@ function loadChannels() {
           balanceUserId: ch.balanceUserId || null,
           modelRedirects: ch.modelRedirects || [],
           speedTestModel: ch.speedTestModel || null,
+          apiFormat: normalizeGeminiApiFormat(ch.apiFormat),
           gatewaySourceType: normalizeGatewaySourceType(ch.gatewaySourceType, 'gemini')
         };
         normalized.websiteUrl = resolveChannelWebsiteUrl('gemini', normalized);
@@ -169,6 +185,7 @@ function initializeFromEnv() {
         maxConcurrency: null,
         balanceToken: '',
         balanceUserId: null,
+        apiFormat: 'gemini_api',
         gatewaySourceType: 'gemini',
         createdAt: Date.now(),
         updatedAt: Date.now()
@@ -230,6 +247,7 @@ function createChannel(name, baseUrl, apiKey, model = 'gemini-2.5-pro', extraCon
     balanceUserId: extraConfig.balanceUserId || null,
     modelRedirects: extraConfig.modelRedirects || [],
     speedTestModel: extraConfig.speedTestModel || null,
+    apiFormat: normalizeGeminiApiFormat(extraConfig.apiFormat),
     gatewaySourceType: normalizeGatewaySourceType(extraConfig.gatewaySourceType, 'gemini'),
     createdAt: Date.now(),
     updatedAt: Date.now()
@@ -275,6 +293,7 @@ function updateChannel(channelId, updates) {
     createdAt: oldChannel.createdAt, // 保持创建时间
     modelRedirects: updates.modelRedirects !== undefined ? updates.modelRedirects : (oldChannel.modelRedirects || []),
     speedTestModel: updates.speedTestModel !== undefined ? updates.speedTestModel : (oldChannel.speedTestModel || null),
+    apiFormat: updates.apiFormat !== undefined ? normalizeGeminiApiFormat(updates.apiFormat) : normalizeGeminiApiFormat(oldChannel.apiFormat),
     balanceToken: updates.balanceToken !== undefined ? updates.balanceToken : (oldChannel.balanceToken || ''),
     balanceUserId: updates.balanceUserId !== undefined ? updates.balanceUserId : (oldChannel.balanceUserId || null),
     gatewaySourceType: normalizeGatewaySourceType(merged.gatewaySourceType, 'gemini'),
@@ -300,6 +319,9 @@ function updateChannel(channelId, updates) {
   }
 
   saveChannels(data);
+  if (oldChannel.enabled === false && nextChannel.enabled !== false) {
+    clearChannelBalanceCache(nextChannel);
+  }
 
   // Only sync .env when proxy is OFF.
   // In dynamic switching mode, defer local config writes until proxy stop.
@@ -329,6 +351,7 @@ function applyChannelToSettings(channelId, channels = null) {
     throw new Error('Channel not found');
   }
 
+  const wasEnabled = channel.enabled !== false;
   // In single-channel mode, only this channel should be enabled
   data.channels.forEach(ch => {
     ch.enabled = ch.id === channelId;
@@ -337,6 +360,9 @@ function applyChannelToSettings(channelId, channels = null) {
   if (!channels) {
     saveChannels(data);
   }
+  if (!wasEnabled) {
+    clearChannelBalanceCache(channel);
+  }
 
   clearNativeOAuth('gemini');
 
@@ -502,5 +528,8 @@ module.exports = {
   isProxyConfig,
   getGeminiDir,
   applyChannelToSettings,
-  disableAllChannels
+  disableAllChannels,
+  _test: {
+    normalizeGeminiApiFormat
+  }
 };