@adversity/coding-tool-x 3.0.4 → 3.0.6

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

@@ -13,6 +13,8 @@ const { getChannelHealthStatus, resetChannelHealth } = require('../services/chan
 const { broadcastSchedulerState } = require('../websocket-server');
 const { isGeminiInstalled } = require('../services/gemini-config');
 const { testChannelSpeed, testMultipleChannels, getLatencyLevel } = require('../services/speed-test');
+const { clearGeminiRedirectCache } = require('../gemini-proxy-server');
+const { fetchModelsFromProvider } = require('../services/model-detector');
 
 module.exports = (config) => {
   /**
@@ -41,6 +43,42 @@ module.exports = (config) => {
     }
   });
 
+  /**
+   * GET /api/gemini/channels/:id/models
+   * 获取渠道可用模型列表
+   */
+  router.get('/:id/models', async (req, res) => {
+    try {
+      const { id } = req.params;
+      const channels = getChannels().channels || [];
+      const channel = channels.find(ch => ch.id === id);
+
+      if (!channel) {
+        return res.status(404).json({ error: '渠道不存在' });
+      }
+
+      // Gemini 渠道尝试作为 OpenAI 兼容获取，失败则回退
+      const result = await fetchModelsFromProvider(channel, 'openai_compatible');
+
+      res.json({
+        channelId: id,
+        models: result.models,
+        supported: result.supported,
+        cached: result.cached,
+        fallbackUsed: result.fallbackUsed,
+        fetchedAt: result.lastChecked || new Date().toISOString(),
+        error: result.error,
+        errorHint: result.errorHint
+      });
+    } catch (error) {
+      console.error('[Gemini Channels API] Error fetching models:', error);
+      res.status(500).json({
+        error: '获取模型列表失败',
+        channelId: req.params.id
+      });
+    }
+  });
+
   /**
    * POST /api/gemini/channels
    * 创建新渠道
@@ -86,6 +124,8 @@ module.exports = (config) => {
       const updates = req.body;
 
       const channel = updateChannel(channelId, updates);
+      // 清除该渠道的模型重定向日志缓存，使下次请求时重新打印
+      clearGeminiRedirectCache(channelId);
       res.json(channel);
       broadcastSchedulerState('gemini', getSchedulerState('gemini'));
     } catch (err) {

package/src/server/api/permissions.js

@@ -30,16 +30,16 @@ const permissionTemplatesService = require('../services/permission-templates-ser
 const router = express.Router();
 
 // Claude Code 设置文件路径
-function getClaudeSettingsPath(projectPath, isLocal = false) {
+function getClaudeSettingsPath(projectPath) {
   if (projectPath) {
-    return path.join(projectPath, '.claude', isLocal ? 'settings.local.json' : 'settings.json');
+    return path.join(projectPath, '.claude', 'settings.json');
   }
   return path.join(os.homedir(), '.claude', 'settings.json');
 }
 
 // 读取 Claude Code settings.json
-function readClaudeSettings(projectPath, isLocal = false) {
-  const settingsPath = getClaudeSettingsPath(projectPath, isLocal);
+function readClaudeSettings(projectPath) {
+  const settingsPath = getClaudeSettingsPath(projectPath);
   try {
     if (fs.existsSync(settingsPath)) {
       const content = fs.readFileSync(settingsPath, 'utf-8');
@@ -52,15 +52,29 @@ function readClaudeSettings(projectPath, isLocal = false) {
 }
 
 // 保存 Claude Code settings.json
-function saveClaudeSettings(projectPath, settings, isLocal = false) {
-  const settingsPath = getClaudeSettingsPath(projectPath, isLocal);
+function saveClaudeSettings(projectPath, settings) {
+  const settingsPath = getClaudeSettingsPath(projectPath);
   const settingsDir = path.dirname(settingsPath);
 
-  if (!fs.existsSync(settingsDir)) {
-    fs.mkdirSync(settingsDir, { recursive: true });
-  }
+  try {
+    // 确保目录存在
+    if (!fs.existsSync(settingsDir)) {
+      fs.mkdirSync(settingsDir, { recursive: true });
+    }
 
-  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+    // 写入文件
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf-8');
+
+    // 验证文件已创建
+    if (!fs.existsSync(settingsPath)) {
+      throw new Error('文件写入后验证失败，文件未被创建');
+    }
+
+    return { success: true, path: settingsPath };
+  } catch (err) {
+    console.error('[Permissions API] Error saving Claude settings:', err);
+    throw new Error(`保存配置文件失败: ${err.message}`);
+  }
 }
 
 // 全局 all-allow 状态（内存中）
@@ -117,11 +131,11 @@ router.get('/', (req, res) => {
 /**
  * 保存项目的命令执行权限设置
  * POST /api/permissions
- * Body: { projectPath, settings: { allow, deny }, isLocal }
+ * Body: { projectPath, settings: { allow, deny } }
  */
 router.post('/', (req, res) => {
   try {
-    const { projectPath, settings: newPermissions, isLocal = false } = req.body;
+    const { projectPath, settings: newPermissions } = req.body;
 
     if (!projectPath) {
       return res.status(400).json({
@@ -138,7 +152,7 @@ router.post('/', (req, res) => {
     }
 
     // 读取现有设置
-    const settings = readClaudeSettings(projectPath, isLocal);
+    const settings = readClaudeSettings(projectPath);
 
     // 更新权限设置（使用 Claude Code 的标准格式）
     settings.permissions = {
@@ -147,12 +161,13 @@ router.post('/', (req, res) => {
     };
 
     // 保存设置
-    saveClaudeSettings(projectPath, settings, isLocal);
+    const saveResult = saveClaudeSettings(projectPath, settings);
 
     res.json({
       success: true,
       message: '权限设置已保存',
-      savedTo: isLocal ? '.claude/settings.local.json' : '.claude/settings.json'
+      savedTo: '.claude/settings.json',
+      fullPath: saveResult.path
     });
   } catch (err) {
     console.error('[Permissions API] Save permissions error:', err);

package/src/server/codex-proxy-server.js

@@ -20,6 +20,10 @@ let currentPort = null;
 // 用于存储每个请求的元数据
 const requestMetadata = new Map();
 
+// 用于缓存已打印过的模型重定向规则，避免重复打印
+// 格式: { channelId: { "originalModel": "redirectedModel", ... } }
+const printedRedirectCache = new Map();
+
 // OpenAI 模型定价（每百万 tokens 的价格，单位：美元）
 // Claude 模型使用 config/model-pricing.js 中的集中定价
 const PRICING = {
@@ -40,6 +44,64 @@ const PRICING = {
 const CODEX_BASE_PRICING = DEFAULT_CONFIG.pricing.codex;
 const ONE_MILLION = 1000000;
 
+/**
+ * 检测模型层级
+ * @param {string} modelName - 模型名称
+ * @returns {string|null} 模型层级 (opus/sonnet/haiku) 或 null
+ */
+function detectModelTier(modelName) {
+  if (!modelName) return null;
+  const lower = modelName.toLowerCase();
+  if (lower.includes('opus')) return 'opus';
+  if (lower.includes('sonnet')) return 'sonnet';
+  if (lower.includes('haiku')) return 'haiku';
+  return null;
+}
+
+/**
+ * 应用模型重定向
+ * @param {string} originalModel - 原始模型名称
+ * @param {object} channel - 渠道对象，包含 modelConfig 和 modelRedirects
+ * @returns {string} 重定向后的模型名称
+ */
+function redirectModel(originalModel, channel) {
+  if (!originalModel) return originalModel;
+
+  // 优先使用新的 modelRedirects 数组格式
+  const modelRedirects = channel?.modelRedirects;
+  if (Array.isArray(modelRedirects) && modelRedirects.length > 0) {
+    for (const rule of modelRedirects) {
+      if (rule.from && rule.to && rule.from === originalModel) {
+        return rule.to;
+      }
+    }
+  }
+
+  // 向后兼容：使用旧的 modelConfig 格式
+  const modelConfig = channel?.modelConfig;
+  if (!modelConfig) return originalModel;
+
+  const tier = detectModelTier(originalModel);
+
+  // 优先级：层级特定配置 > 通用模型覆盖
+  if (tier === 'opus' && modelConfig.opusModel) {
+    return modelConfig.opusModel;
+  }
+  if (tier === 'sonnet' && modelConfig.sonnetModel) {
+    return modelConfig.sonnetModel;
+  }
+  if (tier === 'haiku' && modelConfig.haikuModel) {
+    return modelConfig.haikuModel;
+  }
+
+  // 回退到通用模型覆盖
+  if (modelConfig.model) {
+    return modelConfig.model;
+  }
+
+  return originalModel;
+}
+
 /**
  * 解析 Codex 代理目标 URL
  *
@@ -144,6 +206,18 @@ function calculateCost(model, tokens) {
   );
 }
 
+const jsonBodyParser = express.json({
+  limit: '100mb',
+  verify: (req, res, buf) => {
+    req.rawBody = Buffer.from(buf);
+  }
+});
+
+function shouldParseJson(req) {
+  const contentType = req.headers['content-type'] || '';
+  return req.method === 'POST' && contentType.includes('application/json');
+}
+
 // 启动 Codex 代理服务器
 async function startCodexProxyServer(options = {}) {
   // options.preserveStartTime - 是否保留现有的启动时间（用于切换渠道时）
@@ -160,6 +234,14 @@ async function startCodexProxyServer(options = {}) {
     currentPort = port;
 
     proxyApp = express();
+
+    proxyApp.use((req, res, next) => {
+      if (shouldParseJson(req)) {
+        return jsonBodyParser(req, res, next);
+      }
+      return next();
+    });
+
     const proxy = httpProxy.createProxyServer({});
 
     proxy.on('proxyReq', (proxyReq, req) => {
@@ -180,6 +262,15 @@ async function startCodexProxyServer(options = {}) {
       if (!proxyReq.getHeader('content-type')) {
         proxyReq.setHeader('content-type', 'application/json');
       }
+
+      if (shouldParseJson(req) && (req.rawBody || req.body)) {
+        const bodyBuffer = req.rawBody
+          ? Buffer.isBuffer(req.rawBody) ? req.rawBody : Buffer.from(req.rawBody)
+          : Buffer.from(JSON.stringify(req.body));
+        proxyReq.setHeader('Content-Length', bodyBuffer.length);
+        proxyReq.write(bodyBuffer);
+        proxyReq.end();
+      }
     });
 
     proxyApp.use(async (req, res) => {
@@ -187,6 +278,26 @@ async function startCodexProxyServer(options = {}) {
         const channel = await allocateChannel({ source: 'codex', enableSessionBinding: false });
         req.selectedChannel = channel;
 
+        // 应用模型重定向（当 proxy 开启时）
+        if (req.body && req.body.model) {
+          const originalModel = req.body.model;
+          const redirectedModel = redirectModel(originalModel, channel);
+
+          if (redirectedModel !== originalModel) {
+            req.body.model = redirectedModel;
+            // 更新 rawBody 以匹配修改后的 body
+            req.rawBody = Buffer.from(JSON.stringify(req.body));
+
+            // 只在重定向规则变化时打印日志（避免每次请求都打印）
+            const cachedRedirects = printedRedirectCache.get(channel.id) || {};
+            if (cachedRedirects[originalModel] !== redirectedModel) {
+              cachedRedirects[originalModel] = redirectedModel;
+              printedRedirectCache.set(channel.id, cachedRedirects);
+              console.log(`[Codex Model Redirect] ${originalModel} → ${redirectedModel} (channel: ${channel.name})`);
+            }
+          }
+        }
+
         const release = (() => {
           let released = false;
           return () => {
@@ -548,8 +659,22 @@ function getCodexProxyStatus() {
   };
 }
 
+/**
+ * 清除指定渠道的模型重定向日志缓存
+ * 用于在渠道配置更新后触发重新打印日志
+ * @param {string} channelId - 渠道 ID
+ */
+function clearCodexRedirectCache(channelId) {
+  if (channelId) {
+    printedRedirectCache.delete(channelId);
+  } else {
+    printedRedirectCache.clear();
+  }
+}
+
 module.exports = {
   startCodexProxyServer,
   stopCodexProxyServer,
-  getCodexProxyStatus
+  getCodexProxyStatus,
+  clearCodexRedirectCache
 };

package/src/server/gemini-proxy-server.js

@@ -18,6 +18,10 @@ let currentPort = null;
 // 用于存储每个请求的元数据
 const requestMetadata = new Map();
 
+// 用于缓存已打印过的模型重定向规则，避免重复打印
+// 格式: { channelId: { "originalModel": "redirectedModel", ... } }
+const printedGeminiRedirectCache = new Map();
+
 // Gemini 模型定价（每百万 tokens 的价格，单位：美元）
 const PRICING = {
   'gemini-2.5-pro': { input: 1.25, output: 5 },
@@ -47,6 +51,27 @@ function resolveGeminiTarget(baseUrl = '', requestPath = '') {
   return target;
 }
 
+/**
+ * 应用模型重定向（精确匹配）
+ * @param {string} originalModel - 原始模型名称
+ * @param {object} channel - 渠道对象，包含 modelRedirects 数组
+ * @returns {string} 重定向后的模型名称
+ */
+function redirectModel(originalModel, channel) {
+  if (!originalModel) return originalModel;
+
+  const modelRedirects = channel?.modelRedirects;
+  if (Array.isArray(modelRedirects) && modelRedirects.length > 0) {
+    for (const rule of modelRedirects) {
+      if (rule.from && rule.to && rule.from === originalModel) {
+        return rule.to;
+      }
+    }
+  }
+
+  return originalModel;
+}
+
 /**
  * 计算请求成本
  */
@@ -153,6 +178,27 @@ async function startGeminiProxyServer(options = {}) {
 
         broadcastSchedulerState('gemini', getSchedulerState('gemini'));
 
+        // 从 URL 中提取模型名称并应用重定向
+        // URL 格式: /models/gemini-2.5-pro:generateContent 或 /v1/models/gemini-2.5-pro:generateContent
+        const urlMatch = req.url.match(/\/models\/([\w.-]+)(:[^?]*)?/);
+        if (urlMatch) {
+          const originalModel = urlMatch[1];
+          const redirectedModel = redirectModel(originalModel, channel);
+
+          if (redirectedModel !== originalModel) {
+            // 替换 URL 中的模型名称
+            req.url = req.url.replace(`/models/${originalModel}`, `/models/${redirectedModel}`);
+
+            // 只在重定向规则变化时打印日志（避免每次请求都打印）
+            const cachedRedirects = printedGeminiRedirectCache.get(channel.id) || {};
+            if (cachedRedirects[originalModel] !== redirectedModel) {
+              cachedRedirects[originalModel] = redirectedModel;
+              printedGeminiRedirectCache.set(channel.id, cachedRedirects);
+              console.log(`[Gemini Model Redirect] ${originalModel} → ${redirectedModel} (channel: ${channel.name})`);
+            }
+          }
+        }
+
         const target = resolveGeminiTarget(channel.baseUrl, req.url);
 
         proxy.web(req, res, {
@@ -511,8 +557,22 @@ function getGeminiProxyStatus() {
   };
 }
 
+/**
+ * 清除指定渠道的模型重定向日志缓存
+ * 用于在渠道配置更新后触发重新打印日志
+ * @param {string} channelId - 渠道 ID
+ */
+function clearGeminiRedirectCache(channelId) {
+  if (channelId) {
+    printedGeminiRedirectCache.delete(channelId);
+  } else {
+    printedGeminiRedirectCache.clear();
+  }
+}
+
 module.exports = {
   startGeminiProxyServer,
   stopGeminiProxyServer,
-  getGeminiProxyStatus
+  getGeminiProxyStatus,
+  clearGeminiRedirectCache
 };

package/src/server/index.js

@@ -154,6 +154,9 @@ async function startServer(port) {
   // 配置同步 API
   app.use('/api/config-sync', require('./api/config-sync'));
 
+  // 配置注册表 API (集中管理 skills/commands/agents/rules 的启用/禁用)
+  app.use('/api/config-registry', require('./api/config-registry'));
+
   // 健康检查 API
   app.use('/api/health-check', require('./api/health-check')(config));
 

package/src/server/proxy-server.js

@@ -21,9 +21,71 @@ let currentPort = null;
 // 用于存储每个请求的元数据（用于 WebSocket 日志）
 const requestMetadata = new Map();
 
+// 用于缓存已打印过的模型重定向规则，避免重复打印
+// 格式: { channelId: { "originalModel": "redirectedModel", ... } }
+const printedRedirectCache = new Map();
+
 const CLAUDE_BASE_PRICING = DEFAULT_CONFIG.pricing.claude;
 const ONE_MILLION = 1000000;
 
+/**
+ * 检测模型层级
+ * @param {string} modelName - 模型名称
+ * @returns {string|null} 模型层级 (opus/sonnet/haiku) 或 null
+ */
+function detectModelTier(modelName) {
+  if (!modelName) return null;
+  const lower = modelName.toLowerCase();
+  if (lower.includes('opus')) return 'opus';
+  if (lower.includes('sonnet')) return 'sonnet';
+  if (lower.includes('haiku')) return 'haiku';
+  return null;
+}
+
+/**
+ * 应用模型重定向
+ * @param {string} originalModel - 原始模型名称
+ * @param {object} channel - 渠道对象，包含 modelConfig 和 modelRedirects
+ * @returns {string} 重定向后的模型名称
+ */
+function redirectModel(originalModel, channel) {
+  if (!originalModel) return originalModel;
+
+  // 优先使用新的 modelRedirects 数组格式
+  const modelRedirects = channel?.modelRedirects;
+  if (Array.isArray(modelRedirects) && modelRedirects.length > 0) {
+    for (const rule of modelRedirects) {
+      if (rule.from && rule.to && rule.from === originalModel) {
+        return rule.to;
+      }
+    }
+  }
+
+  // 向后兼容：使用旧的 modelConfig 格式
+  const modelConfig = channel?.modelConfig;
+  if (!modelConfig) return originalModel;
+
+  const tier = detectModelTier(originalModel);
+
+  // 优先级：层级特定配置 > 通用模型覆盖
+  if (tier === 'opus' && modelConfig.opusModel) {
+    return modelConfig.opusModel;
+  }
+  if (tier === 'sonnet' && modelConfig.sonnetModel) {
+    return modelConfig.sonnetModel;
+  }
+  if (tier === 'haiku' && modelConfig.haikuModel) {
+    return modelConfig.haikuModel;
+  }
+
+  // 回退到通用模型覆盖
+  if (modelConfig.model) {
+    return modelConfig.model;
+  }
+
+  return originalModel;
+}
+
 /**
  * 计算请求成本
  * @param {string} model - 模型名称
@@ -157,6 +219,27 @@ async function startProxyServer(options = {}) {
 
         req.selectedChannel = channel;
         req.sessionId = sessionId || null;
+
+        // 应用模型重定向（当 proxy 开启时）
+        if (req.body && req.body.model) {
+          const originalModel = req.body.model;
+          const redirectedModel = redirectModel(originalModel, channel);
+
+          if (redirectedModel !== originalModel) {
+            req.body.model = redirectedModel;
+            // 更新 rawBody 以匹配修改后的 body
+            req.rawBody = Buffer.from(JSON.stringify(req.body));
+
+            // 只在重定向规则变化时打印日志（避免每次请求都打印）
+            const cachedRedirects = printedRedirectCache.get(channel.id) || {};
+            if (cachedRedirects[originalModel] !== redirectedModel) {
+              cachedRedirects[originalModel] = redirectedModel;
+              printedRedirectCache.set(channel.id, cachedRedirects);
+              console.log(`[Model Redirect] ${originalModel} → ${redirectedModel} (channel: ${channel.name})`);
+            }
+          }
+        }
+
         let released = false;
 
         const release = () => {
@@ -454,8 +537,22 @@ function getProxyStatus() {
   };
 }
 
+/**
+ * 清除指定渠道的模型重定向日志缓存
+ * 用于在渠道配置更新后触发重新打印日志
+ * @param {string} channelId - 渠道 ID
+ */
+function clearRedirectCache(channelId) {
+  if (channelId) {
+    printedRedirectCache.delete(channelId);
+  } else {
+    printedRedirectCache.clear();
+  }
+}
+
 module.exports = {
   startProxyServer,
   stopProxyServer,
-  getProxyStatus
+  getProxyStatus,
+  clearRedirectCache
 };

package/src/server/services/channel-scheduler.js

@@ -74,7 +74,9 @@ function refreshChannels(source = 'claude') {
       baseUrl: ch.baseUrl,
       apiKey: ch.apiKey,
       weight: Math.max(1, Number(ch.weight) || 1),
-      maxConcurrency: ch.maxConcurrency ?? null
+      maxConcurrency: ch.maxConcurrency ?? null,
+      modelConfig: ch.modelConfig || null,
+      modelRedirects: ch.modelRedirects || []
     }));
 
   state.channels.forEach(ch => {

package/src/server/services/channels.js

@@ -187,6 +187,7 @@ function createChannel(name, baseUrl, apiKey, websiteUrl, extraConfig = {}) {
     maxConcurrency: extraConfig.maxConcurrency,
     presetId: extraConfig.presetId || 'official',
     modelConfig: extraConfig.modelConfig || null,
+    modelRedirects: extraConfig.modelRedirects || [],
     proxyUrl: extraConfig.proxyUrl || '',
     speedTestModel: extraConfig.speedTestModel || null
   });
@@ -215,8 +216,10 @@ function updateChannel(id, updates) {
     enabled: merged.enabled,
     presetId: merged.presetId,
     modelConfig: merged.modelConfig,
+    modelRedirects: merged.modelRedirects || [],
     proxyUrl: merged.proxyUrl,
-    speedTestModel: merged.speedTestModel
+    speedTestModel: merged.speedTestModel,
+    updatedAt: Date.now()
   });
 
   // Get proxy status

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

@@ -47,7 +47,9 @@ function loadChannels() {
         ...ch,
         enabled: ch.enabled !== false, // 默认启用
         weight: ch.weight || 1,
-        maxConcurrency: ch.maxConcurrency || null
+        maxConcurrency: ch.maxConcurrency || null,
+        modelRedirects: ch.modelRedirects || [],
+        speedTestModel: ch.speedTestModel || null
       }));
     }
     return data;
@@ -175,6 +177,8 @@ function createChannel(name, providerKey, baseUrl, apiKey, wireApi = 'responses'
     enabled: extraConfig.enabled !== false, // 默认启用
     weight: extraConfig.weight || 1,
     maxConcurrency: extraConfig.maxConcurrency || null,
+    modelRedirects: extraConfig.modelRedirects || [],
+    speedTestModel: extraConfig.speedTestModel || null,
     createdAt: Date.now(),
     updatedAt: Date.now()
   };
@@ -217,11 +221,13 @@ function updateChannel(channelId, updates) {
     }
   }
 
+  const merged = { ...oldChannel, ...updates };
   const newChannel = {
-    ...oldChannel,
-    ...updates,
+    ...merged,
     id: channelId, // 保持 ID 不变
     createdAt: oldChannel.createdAt, // 保持创建时间
+    modelRedirects: merged.modelRedirects || [],
+    speedTestModel: merged.speedTestModel !== undefined ? merged.speedTestModel : (oldChannel.speedTestModel || null),
     updatedAt: Date.now()
   };