@adversity/coding-tool-x 3.1.0 → 3.1.2

package/src/server/api/config.js

@@ -2,6 +2,13 @@ const express = require('express');
 const router = express.Router();
 const { loadConfig, saveConfig } = require('../../config/loader');
 const DEFAULT_CONFIG = require('../../config/default');
+const { getAllChannels } = require('../services/channels');
+const { getChannels: getCodexChannels } = require('../services/codex-channels');
+const { getChannels: getGeminiChannels } = require('../services/gemini-channels');
+const {
+  probeModelAvailability,
+  fetchModelsFromProvider
+} = require('../services/model-detector');
 
 function clampNumber(value, fallback) {
   const num = typeof value === 'number' ? value : parseFloat(value);
@@ -36,6 +43,354 @@ function sanitizePricing(inputPricing, currentPricing) {
   return sanitized;
 }
 
+function normalizeModelDiscovery(modelDiscovery, currentValue = DEFAULT_CONFIG.modelDiscovery) {
+  const current = currentValue && typeof currentValue === 'object'
+    ? currentValue
+    : DEFAULT_CONFIG.modelDiscovery;
+  const input = modelDiscovery && typeof modelDiscovery === 'object'
+    ? modelDiscovery
+    : {};
+
+  return {
+    useV1ModelsEndpoint: input.useV1ModelsEndpoint !== undefined
+      ? input.useV1ModelsEndpoint === true
+      : current.useV1ModelsEndpoint === true
+  };
+}
+
+function uniqueModels(models = []) {
+  const seen = new Set();
+  const result = [];
+
+  models.forEach((model) => {
+    if (typeof model !== 'string') return;
+    const trimmed = model.trim();
+    if (!trimmed) return;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    result.push(trimmed);
+  });
+
+  return result;
+}
+
+function collectChannelPreferredModels(channel) {
+  const candidates = [];
+  if (!channel || typeof channel !== 'object') return candidates;
+
+  candidates.push(channel.model);
+  candidates.push(channel.speedTestModel);
+
+  const modelConfig = channel.modelConfig;
+  if (modelConfig && typeof modelConfig === 'object') {
+    candidates.push(modelConfig.model);
+    candidates.push(modelConfig.opusModel);
+    candidates.push(modelConfig.sonnetModel);
+    candidates.push(modelConfig.haikuModel);
+  }
+
+  if (Array.isArray(channel.modelRedirects)) {
+    channel.modelRedirects.forEach((rule) => {
+      candidates.push(rule?.from);
+      candidates.push(rule?.to);
+    });
+  }
+
+  return uniqueModels(candidates);
+}
+
+function parseBooleanQuery(value, defaultValue = false) {
+  if (value === undefined || value === null || value === '') return defaultValue;
+  const normalized = String(value).trim().toLowerCase();
+  return ['1', 'true', 'yes', 'on'].includes(normalized);
+}
+
+async function probeModelsForSingleChannel(channel, channelType, options = {}) {
+  const builtInPreferred = Array.isArray(DEFAULT_CONFIG.defaultModels?.[channelType])
+    ? DEFAULT_CONFIG.defaultModels[channelType]
+    : [];
+  const preferredModels = uniqueModels([
+    ...collectChannelPreferredModels(channel),
+    ...builtInPreferred
+  ]);
+
+  try {
+    if (channelType === 'codex') {
+      const listResult = await fetchModelsFromProvider(channel, 'openai_compatible');
+      const listedModels = Array.isArray(listResult?.models) ? listResult.models : [];
+      if (listedModels.length > 0) {
+        return uniqueModels(listedModels);
+      }
+    }
+
+    const probe = await probeModelAvailability(channel, channelType, {
+      forceRefresh: !!options.forceRefresh,
+      stopOnFirstAvailable: false,
+      preferredModels
+    });
+    const probedModels = Array.isArray(probe?.availableModels) ? probe.availableModels : [];
+    if (probedModels.length > 0) {
+      return uniqueModels(probedModels);
+    }
+  } catch (error) {
+    console.warn(`[Config API] Probe failed for channel ${channel?.name || channel?.id || 'unknown'}: ${error.message}`);
+  }
+
+  return preferredModels;
+}
+
+async function probeModelsForChannels(channels = [], channelType, options = {}) {
+  const enabledChannels = (channels || []).filter(ch => ch && ch.enabled !== false);
+  if (enabledChannels.length === 0) return [];
+
+  const resultSets = [];
+  // 模型探测改为串行，避免并发触发上游会话窗口限流
+  for (const channel of enabledChannels) {
+    // eslint-disable-next-line no-await-in-loop
+    const models = await probeModelsForSingleChannel(channel, channelType, options);
+    resultSets.push(models);
+  }
+  return uniqueModels(resultSets.flat());
+}
+
+function mergeProbedAndConfiguredModels(probedModels, configuredModels, toolType) {
+  const safeConfigured = Array.isArray(configuredModels) ? configuredModels : [];
+  const safeProbed = Array.isArray(probedModels) ? probedModels : [];
+  const builtInDefaults = Array.isArray(DEFAULT_CONFIG.defaultModels?.[toolType])
+    ? DEFAULT_CONFIG.defaultModels[toolType]
+    : [];
+  if (safeProbed.length > 0) {
+    return uniqueModels([...safeProbed, ...safeConfigured, ...builtInDefaults]);
+  }
+  return uniqueModels([...safeConfigured, ...builtInDefaults]);
+}
+
+/**
+ * Validate model list
+ * @param {Array} models - Array of model names
+ * @param {string} toolType - Tool type (claude, codex, gemini)
+ * @returns {Object} { valid: boolean, cleaned: array, error?: string }
+ */
+function validateModelList(models, toolType) {
+  if (!Array.isArray(models)) {
+    return { valid: false, error: `${toolType}: models must be an array` };
+  }
+
+  if (models.length === 0) {
+    return { valid: false, error: `${toolType}: model list cannot be empty` };
+  }
+
+  if (models.length > 50) {
+    return { valid: false, error: `${toolType}: maximum 50 models allowed, got ${models.length}` };
+  }
+
+  const modelNamePattern = /^[a-zA-Z0-9._\-/:]+$/;
+  const cleaned = [];
+  const seen = new Set();
+
+  for (let i = 0; i < models.length; i++) {
+    const model = models[i];
+
+    if (typeof model !== 'string') {
+      return { valid: false, error: `${toolType}: model at index ${i} must be a string, got ${typeof model}` };
+    }
+
+    const trimmed = model.trim();
+
+    if (trimmed.length === 0) {
+      return { valid: false, error: `${toolType}: model at index ${i} is empty or whitespace` };
+    }
+
+    if (!modelNamePattern.test(trimmed)) {
+      return { valid: false, error: `${toolType}: model "${trimmed}" contains invalid characters (allowed: a-z A-Z 0-9 . _ - / :)` };
+    }
+
+    if (!seen.has(trimmed)) {
+      seen.add(trimmed);
+      cleaned.push(trimmed);
+    }
+  }
+
+  return { valid: true, cleaned };
+}
+
+/**
+ * GET /api/config/default-models
+ * 获取默认模型列表
+ */
+router.get('/default-models', async (req, res) => {
+  try {
+    const config = loadConfig();
+    const configuredDefaultModels = config.defaultModels || DEFAULT_CONFIG.defaultModels;
+    const probe = parseBooleanQuery(req.query.probe, false);
+
+    if (!probe) {
+      return res.json({
+        defaultModels: configuredDefaultModels,
+        probed: false
+      });
+    }
+
+    const forceRefresh = parseBooleanQuery(req.query.forceRefresh, true);
+    const claudeChannels = getAllChannels();
+    const codexData = getCodexChannels();
+    const geminiData = getGeminiChannels();
+
+    // 各工具类型也按串行探测，进一步降低并发压力
+    const claudeProbed = await probeModelsForChannels(claudeChannels || [], 'claude', { forceRefresh });
+    const codexProbed = await probeModelsForChannels(codexData?.channels || [], 'codex', { forceRefresh });
+    const geminiProbed = await probeModelsForChannels(geminiData?.channels || [], 'gemini', { forceRefresh });
+
+    const defaultModels = {
+      claude: mergeProbedAndConfiguredModels(
+        claudeProbed,
+        configuredDefaultModels.claude,
+        'claude'
+      ),
+      codex: mergeProbedAndConfiguredModels(
+        codexProbed,
+        configuredDefaultModels.codex,
+        'codex'
+      ),
+      gemini: mergeProbedAndConfiguredModels(
+        geminiProbed,
+        configuredDefaultModels.gemini,
+        'gemini'
+      )
+    };
+
+    res.json({
+      defaultModels,
+      probed: true,
+      forceRefresh
+    });
+  } catch (error) {
+    console.error('[Config API] Failed to get default models:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/config/default-models
+ * 更新默认模型列表
+ */
+router.post('/default-models', (req, res) => {
+  try {
+    const { defaultModels } = req.body;
+
+    if (!defaultModels || typeof defaultModels !== 'object') {
+      return res.status(400).json({
+        error: 'defaultModels must be an object'
+      });
+    }
+
+    const validToolTypes = ['claude', 'codex', 'gemini'];
+    const providedTypes = Object.keys(defaultModels);
+
+    // Validate that only valid tool types are provided
+    for (const toolType of providedTypes) {
+      if (!validToolTypes.includes(toolType)) {
+        return res.status(400).json({
+          error: `Invalid tool type: ${toolType}. Valid types: ${validToolTypes.join(', ')}`
+        });
+      }
+    }
+
+    // Validate each model list
+    const validated = {};
+    const errors = {};
+
+    for (const toolType of providedTypes) {
+      const result = validateModelList(defaultModels[toolType], toolType);
+      if (!result.valid) {
+        errors[toolType] = result.error;
+      } else {
+        validated[toolType] = result.cleaned;
+      }
+    }
+
+    if (Object.keys(errors).length > 0) {
+      return res.status(400).json({
+        error: 'Validation failed',
+        details: errors
+      });
+    }
+
+    // Load current config and merge
+    const config = loadConfig();
+    const newDefaultModels = {
+      ...(config.defaultModels || DEFAULT_CONFIG.defaultModels),
+      ...validated
+    };
+
+    // Save config
+    const newConfig = {
+      ...config,
+      projectsDir: config.projectsDir.replace(require('os').homedir(), '~'),
+      defaultModels: newDefaultModels
+    };
+
+    saveConfig(newConfig);
+
+    res.json({
+      success: true,
+      defaultModels: newDefaultModels
+    });
+  } catch (error) {
+    console.error('[Config API] Failed to save default models:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/config/default-models/reset
+ * 重置默认模型列表
+ */
+router.post('/default-models/reset', (req, res) => {
+  try {
+    const { toolType } = req.body;
+
+    const config = loadConfig();
+    let newDefaultModels;
+
+    if (toolType) {
+      // Reset specific tool type
+      const validToolTypes = ['claude', 'codex', 'gemini'];
+      if (!validToolTypes.includes(toolType)) {
+        return res.status(400).json({
+          error: `Invalid tool type: ${toolType}. Valid types: ${validToolTypes.join(', ')}`
+        });
+      }
+
+      newDefaultModels = {
+        ...(config.defaultModels || DEFAULT_CONFIG.defaultModels),
+        [toolType]: DEFAULT_CONFIG.defaultModels[toolType]
+      };
+    } else {
+      // Reset all tool types
+      newDefaultModels = { ...DEFAULT_CONFIG.defaultModels };
+    }
+
+    // Save config
+    const newConfig = {
+      ...config,
+      projectsDir: config.projectsDir.replace(require('os').homedir(), '~'),
+      defaultModels: newDefaultModels
+    };
+
+    saveConfig(newConfig);
+
+    res.json({
+      success: true,
+      defaultModels: newDefaultModels
+    });
+  } catch (error) {
+    console.error('[Config API] Failed to reset default models:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 /**
  * GET /api/config/advanced
  * 获取高级配置（端口、日志、性能等）
@@ -43,16 +398,19 @@ function sanitizePricing(inputPricing, currentPricing) {
 router.get('/advanced', (req, res) => {
   try {
     const config = loadConfig();
+    const modelDiscovery = normalizeModelDiscovery(config.modelDiscovery);
     res.json({
       ports: {
-        webUI: config.ports?.webUI || 10099,
-        proxy: config.ports?.proxy || 10088,
-        codexProxy: config.ports?.codexProxy || 10089,
-        geminiProxy: config.ports?.geminiProxy || 10090
+        webUI: config.ports?.webUI || 19999,
+        proxy: config.ports?.proxy || 20088,
+        codexProxy: config.ports?.codexProxy || 20089,
+        geminiProxy: config.ports?.geminiProxy || 20090,
+        opencodeProxy: config.ports?.opencodeProxy || 20091
       },
       maxLogs: config.maxLogs || 100,
       statsInterval: config.statsInterval || 30,
       enableSessionBinding: config.enableSessionBinding !== false, // 默认开启
+      modelDiscovery,
       pricing: config.pricing || DEFAULT_CONFIG.pricing
     });
   } catch (error) {
@@ -67,7 +425,14 @@ router.get('/advanced', (req, res) => {
  */
 router.post('/advanced', (req, res) => {
   try {
-    const { ports, maxLogs, statsInterval, pricing, enableSessionBinding } = req.body;
+    const {
+      ports,
+      maxLogs,
+      statsInterval,
+      pricing,
+      enableSessionBinding,
+      modelDiscovery
+    } = req.body;
 
     // 验证端口
     if (ports) {
@@ -104,6 +469,10 @@ router.post('/advanced', (req, res) => {
     // 加载当前配置
     const config = loadConfig();
     const sanitizedPricing = sanitizePricing(pricing, config.pricing);
+    const normalizedModelDiscovery = normalizeModelDiscovery(
+      modelDiscovery,
+      config.modelDiscovery || DEFAULT_CONFIG.modelDiscovery
+    );
 
     let normalizedPorts = config.ports;
     if (ports) {
@@ -122,6 +491,7 @@ router.post('/advanced', (req, res) => {
       maxLogs: maxLogs !== undefined ? parseInt(maxLogs) : config.maxLogs,
       statsInterval: statsInterval !== undefined ? parseInt(statsInterval) : config.statsInterval,
       enableSessionBinding: enableSessionBinding !== undefined ? enableSessionBinding : (config.enableSessionBinding !== false),
+      modelDiscovery: normalizedModelDiscovery,
       pricing: sanitizedPricing
     };
 
@@ -135,6 +505,7 @@ router.post('/advanced', (req, res) => {
         maxLogs: newConfig.maxLogs,
         statsInterval: newConfig.statsInterval,
         enableSessionBinding: newConfig.enableSessionBinding,
+        modelDiscovery: newConfig.modelDiscovery,
         pricing: newConfig.pricing
       }
     });

package/src/server/api/convert.js

@@ -1,6 +1,15 @@
 const express = require('express');
 const router = express.Router();
 const { convertSession, previewConversion } = require('../services/session-converter');
+const {
+  SUPPORTED_SOURCE_TYPES,
+  SUPPORTED_TARGET_APIS,
+  convertToOpenCodePayload,
+  convertClaudeToOpenCodePayload,
+  convertCodexToOpenCodePayload,
+  convertGeminiToOpenCodePayload,
+  normalizeSourceType
+} = require('../services/opencode-gateway-converter');
 
 /**
  * 获取支持的格式列表
@@ -42,6 +51,130 @@ router.get('/formats', (req, res) => {
   });
 });
 
+/**
+ * 获取 OpenCode 网关支持格式
+ * GET /api/convert/opencode/formats
+ */
+router.get('/opencode/formats', (req, res) => {
+  res.json({
+    sourceTypes: SUPPORTED_SOURCE_TYPES.map(type => ({
+      id: type,
+      name: type === 'claude'
+        ? 'Claude Code'
+        : type === 'codex'
+          ? 'Codex'
+          : 'Gemini'
+    })),
+    target: 'opencode',
+    targetApis: SUPPORTED_TARGET_APIS,
+    defaultTargetApi: 'responses',
+    endpoints: {
+      responses: '/v1/responses',
+      'chat.completions': '/v1/chat/completions'
+    },
+    sourceEndpoints: {
+      claude: '/api/convert/opencode/claude',
+      codex: '/api/convert/opencode/codex',
+      gemini: '/api/convert/opencode/gemini'
+    }
+  });
+});
+
+function handleOpenCodeConvert(req, res, sourceType, converter) {
+  try {
+    const { payload, options = {} } = req.body || {};
+
+    if (!payload) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameters: payload'
+      });
+    }
+
+    const result = converter({ payload, options });
+    return res.json({
+      success: true,
+      ...result
+    });
+  } catch (error) {
+    console.error(`[Convert API] OpenCode ${sourceType} convert error:`, error);
+    return res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+}
+
+/**
+ * Claude Code -> OpenCode
+ * POST /api/convert/opencode/claude
+ * Body: { payload, options? }
+ */
+router.post('/opencode/claude', (req, res) => {
+  return handleOpenCodeConvert(req, res, 'claude', convertClaudeToOpenCodePayload);
+});
+
+/**
+ * Codex -> OpenCode
+ * POST /api/convert/opencode/codex
+ * Body: { payload, options? }
+ */
+router.post('/opencode/codex', (req, res) => {
+  return handleOpenCodeConvert(req, res, 'codex', convertCodexToOpenCodePayload);
+});
+
+/**
+ * Gemini -> OpenCode
+ * POST /api/convert/opencode/gemini
+ * Body: { payload, options? }
+ */
+router.post('/opencode/gemini', (req, res) => {
+  return handleOpenCodeConvert(req, res, 'gemini', convertGeminiToOpenCodePayload);
+});
+
+/**
+ * 在线转换为 OpenCode 可处理格式
+ * POST /api/convert/opencode
+ * Body: { sourceType, payload, options? }
+ */
+router.post('/opencode', (req, res) => {
+  try {
+    const { sourceType, payload, options = {} } = req.body || {};
+
+    if (!sourceType || !payload) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameters: sourceType, payload'
+      });
+    }
+
+    const normalized = normalizeSourceType(sourceType);
+    if (!SUPPORTED_SOURCE_TYPES.includes(normalized)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid sourceType: ${sourceType}. Must be one of: ${SUPPORTED_SOURCE_TYPES.join(', ')}`
+      });
+    }
+
+    const result = convertToOpenCodePayload({
+      sourceType: normalized,
+      payload,
+      options
+    });
+
+    return res.json({
+      success: true,
+      ...result
+    });
+  } catch (error) {
+    console.error('[Convert API] OpenCode gateway convert error:', error);
+    return res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
 /**
  * 预览转换结果
  * POST /api/convert/preview

package/src/server/api/dashboard.js

@@ -9,18 +9,22 @@ const { getAllChannels } = require('../services/channels');
 const { getProxyStatus } = require('../proxy-server');
 const { getCodexProxyStatus } = require('../codex-proxy-server');
 const { getGeminiProxyStatus } = require('../gemini-proxy-server');
+const { getOpenCodeProxyStatus } = require('../opencode-proxy-server');
 const { getProjectAndSessionCounts: getClaudeCounts } = require('../services/sessions');
 const { getProjectAndSessionCounts: getCodexCounts } = require('../services/codex-sessions');
 const { getProjectAndSessionCounts: getGeminiCounts } = require('../services/gemini-sessions');
+const { getProjectAndSessionCounts: getOpenCodeCounts } = require('../services/opencode-sessions');
 
 // Channel-specific services
 const { getChannels: getCodexChannels } = require('../services/codex-channels');
 const { getChannels: getGeminiChannels } = require('../services/gemini-channels');
+const { getChannels: getOpenCodeChannels } = require('../services/opencode-channels');
 
 // Statistics
 const { getTodayStatistics } = require('../services/statistics-service');
 const { getTodayStatistics: getCodexTodayStatistics } = require('../services/codex-statistics-service');
 const { getTodayStatistics: getGeminiTodayStatistics } = require('../services/gemini-statistics-service');
+const { getTodayStatistics: getOpenCodeTodayStatistics } = require('../services/opencode-statistics-service');
 
 /**
  * GET /api/dashboard/init
@@ -37,15 +41,19 @@ router.get('/init', async (req, res) => {
       claudeChannels,
       codexChannels,
       geminiChannels,
+      opencodeChannels,
       claudeProxyStatus,
       codexProxyStatus,
       geminiProxyStatus,
+      opencodeProxyStatus,
       claudeTodayStats,
       codexTodayStats,
       geminiTodayStats,
+      opencodeTodayStats,
       claudeCounts,
       codexCounts,
-      geminiCounts
+      geminiCounts,
+      opencodeCounts
     ] = await Promise.all([
       // UI Config
       Promise.resolve(loadUIConfig()),
@@ -57,21 +65,25 @@ router.get('/init', async (req, res) => {
       Promise.resolve(getAllChannels()),
       Promise.resolve(getCodexChannels()),
       Promise.resolve(getGeminiChannels()),
+      Promise.resolve(getOpenCodeChannels()),
 
       // Proxy Status
       Promise.resolve(getProxyStatus()),
       Promise.resolve(getCodexProxyStatus()),
       Promise.resolve(getGeminiProxyStatus()),
+      Promise.resolve(getOpenCodeProxyStatus()),
 
       // Today Stats (所有平台)
       Promise.resolve(getTodayStatistics()),
       Promise.resolve(getCodexTodayStatistics()),
       Promise.resolve(getGeminiTodayStatistics()),
+      Promise.resolve(getOpenCodeTodayStatistics()),
 
       // 轻量级统计
       Promise.resolve(getClaudeCounts(config)),
       Promise.resolve(getCodexCounts()),
-      Promise.resolve(getGeminiCounts())
+      Promise.resolve(getGeminiCounts()),
+      Promise.resolve(getOpenCodeCounts())
     ]);
 
     // 格式化统计数据：取 summary 和 byModel 中的数据
@@ -95,22 +107,26 @@ router.get('/init', async (req, res) => {
         channels: {
           claude: claudeChannels,
           codex: codexChannels,
-          gemini: geminiChannels
+          gemini: geminiChannels,
+          opencode: opencodeChannels.channels || []
         },
         proxyStatus: {
           claude: claudeProxyStatus,
           codex: codexProxyStatus,
-          gemini: geminiProxyStatus
+          gemini: geminiProxyStatus,
+          opencode: opencodeProxyStatus
         },
         counts: {
           claude: claudeCounts || { projectCount: 0, sessionCount: 0 },
           codex: codexCounts || { projectCount: 0, sessionCount: 0 },
-          gemini: geminiCounts || { projectCount: 0, sessionCount: 0 }
+          gemini: geminiCounts || { projectCount: 0, sessionCount: 0 },
+          opencode: opencodeCounts || { projectCount: 0, sessionCount: 0 }
         },
         todayStats: {
           claude: formatStats(claudeTodayStats),
           codex: formatStats(codexTodayStats),
-          gemini: formatStats(geminiTodayStats)
+          gemini: formatStats(geminiTodayStats),
+          opencode: formatStats(opencodeTodayStats)
         }
       }
     });