coding-tool-x 3.2.0

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

@@ -0,0 +1,417 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getChannels,
+  createChannel,
+  updateChannel,
+  deleteChannel,
+  getEnabledChannels,
+  saveChannelOrder,
+  applyChannelToSettings
+} = require('../services/codex-channels');
+const { getSchedulerState } = require('../services/channel-scheduler');
+const { getChannelHealthStatus, resetChannelHealth } = require('../services/channel-health');
+const { broadcastSchedulerState, broadcastLog } = require('../websocket-server');
+const { isCodexInstalled } = require('../services/codex-config');
+const {
+  testChannelSpeed,
+  getLatencyLevel,
+  sanitizeBatchConcurrency,
+  runWithConcurrencyLimit
+} = require('../services/speed-test');
+const { clearCodexRedirectCache } = require('../codex-proxy-server');
+const { getDefaultSpeedTestModelByToolType } = require('../../config/model-metadata');
+const CODEX_GATEWAY_SOURCE_TYPE = 'codex';
+
+function getDefaultCodexModel() {
+  return getDefaultSpeedTestModelByToolType('codex');
+}
+
+module.exports = (config) => {
+  /**
+   * GET /api/codex/channels
+   * 获取所有 Codex 渠道（包含健康状态）
+   */
+  router.get('/', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.json({
+          channels: [],
+          error: 'Codex CLI not installed'
+        });
+      }
+
+      const data = getChannels();
+      // 为每个渠道添加健康状态
+      const channelsWithHealth = (data.channels || []).map(ch => ({
+        ...ch,
+        health: getChannelHealthStatus(ch.id, 'codex')
+      }));
+      res.json({ channels: channelsWithHealth });
+    } catch (err) {
+      console.error('[Codex Channels API] Failed to get channels:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/codex/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: '渠道不存在' });
+      }
+
+      const gatewaySourceType = CODEX_GATEWAY_SOURCE_TYPE;
+      const models = [getDefaultCodexModel()];
+      const result = {
+        models,
+        supported: models.length > 0,
+        cached: false,
+        fallbackUsed: false,
+        lastChecked: new Date().toISOString(),
+        error: models.length > 0 ? null : '未配置默认模型列表',
+        errorHint: models.length > 0 ? null : '请在设置中配置 Codex 默认模型'
+      };
+
+      res.json({
+        channelId: id,
+        gatewaySourceType,
+        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('[Codex Channels API] Error fetching models:', error);
+      res.status(500).json({
+        error: '获取模型列表失败',
+        channelId: req.params.id
+      });
+    }
+  });
+
+  /**
+   * POST /api/codex/channels
+   * 创建新渠道
+   * Body: { name, providerKey, baseUrl, apiKey, websiteUrl }
+   */
+  router.post('/', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const {
+        name,
+        providerKey,
+        baseUrl,
+        apiKey,
+        websiteUrl,
+        enabled,
+        weight,
+        maxConcurrency,
+        modelRedirects,
+        speedTestModel,
+        presetId,
+        gatewaySourceType
+      } = req.body;
+
+      if (!name || !providerKey || !baseUrl) {
+        return res.status(400).json({ error: 'Missing required fields: name, providerKey, baseUrl' });
+      }
+
+      if (!apiKey) {
+        return res.status(400).json({ error: 'Missing required fields: apiKey' });
+      }
+
+      // wireApi 固定为 'responses' (OpenAI Responses API 格式)
+      const channel = createChannel(name, providerKey, baseUrl, apiKey, 'responses', {
+        websiteUrl,
+        enabled,
+        weight,
+        maxConcurrency,
+        modelRedirects: modelRedirects || [],
+        speedTestModel: speedTestModel || null,
+        presetId: presetId || null,
+        gatewaySourceType
+      });
+      res.json(channel);
+      broadcastSchedulerState('codex', getSchedulerState('codex'));
+    } catch (err) {
+      console.error('[Codex Channels API] Failed to create channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * PUT /api/codex/channels/:channelId
+   * 更新渠道
+   */
+  router.put('/:channelId', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      const updates = req.body;
+
+      const channel = updateChannel(channelId, updates);
+      // 清除该渠道的模型重定向日志缓存，使下次请求时重新打印
+      clearCodexRedirectCache(channelId);
+      res.json(channel);
+      broadcastSchedulerState('codex', getSchedulerState('codex'));
+    } catch (err) {
+      console.error('[Codex Channels API] Failed to update channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * DELETE /api/codex/channels/:channelId
+   * 删除渠道
+   */
+  router.delete('/:channelId', async (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      const result = await deleteChannel(channelId);
+      res.json(result);
+      broadcastSchedulerState('codex', getSchedulerState('codex'));
+    } catch (err) {
+      console.error('[Codex Channels API] Failed to delete channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/codex/channels/order
+   * 保存渠道顺序
+   */
+  router.post('/order', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { order } = req.body;
+
+      if (!Array.isArray(order)) {
+        return res.status(400).json({ error: 'order must be an array' });
+      }
+
+      saveChannelOrder(order);
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[Codex Channels API] Failed to save channel order:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/codex/channels/enabled
+   * 获取所有启用的渠道（供调度器使用）
+   */
+  router.get('/enabled', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.json({ channels: [] });
+      }
+
+      const channels = getEnabledChannels();
+      res.json({ channels });
+    } catch (err) {
+      console.error('[Codex Channels API] Failed to get enabled channels:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/codex/channels/:channelId/speed-test
+   * 测试单个渠道速度
+   */
+  router.post('/:channelId/speed-test', async (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      const { timeout = 10000 } = req.body;
+      const data = getChannels();
+      const channel = data.channels.find(ch => ch.id === channelId);
+
+      if (!channel) {
+        return res.status(404).json({ error: '渠道不存在' });
+      }
+
+      const speedTestType = CODEX_GATEWAY_SOURCE_TYPE;
+      const result = await testChannelSpeed(channel, timeout, speedTestType);
+      result.level = getLatencyLevel(result.latency);
+      result.gatewaySourceType = speedTestType;
+
+      res.json(result);
+    } catch (error) {
+      console.error('[Codex Channels API] Error testing channel speed:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /api/codex/channels/speed-test-all
+   * 测试所有渠道速度
+   */
+  router.post('/speed-test-all', async (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.json({ results: [], message: 'Codex CLI not installed' });
+      }
+
+      const { timeout = 10000, concurrency } = req.body || {};
+      const data = getChannels();
+      const channels = data.channels || [];
+      const safeConcurrency = sanitizeBatchConcurrency(concurrency);
+
+      if (channels.length === 0) {
+        return res.json({ results: [], message: '没有可测试的渠道' });
+      }
+
+      const results = await runWithConcurrencyLimit(
+        channels,
+        safeConcurrency,
+        async channel => {
+          const speedTestType = CODEX_GATEWAY_SOURCE_TYPE;
+          const result = await testChannelSpeed(channel, timeout, speedTestType);
+          result.level = getLatencyLevel(result.latency);
+          result.gatewaySourceType = speedTestType;
+          return result;
+        }
+      );
+
+      // 成功在前，成功结果按延迟升序
+      results.sort((a, b) => {
+        if (a.success && !b.success) return -1;
+        if (!a.success && b.success) return 1;
+        if (a.success && b.success) {
+          const aLatency = (a.latency === null || a.latency === undefined) ? Infinity : a.latency;
+          const bLatency = (b.latency === null || b.latency === undefined) ? Infinity : b.latency;
+          return aLatency - bLatency;
+        }
+        return 0;
+      });
+
+      res.json({
+        results,
+        summary: {
+          total: results.length,
+          success: results.filter(r => r.success).length,
+          failed: results.filter(r => !r.success).length,
+          avgLatency: calculateAvgLatency(results),
+          concurrency: safeConcurrency
+        }
+      });
+    } catch (error) {
+      console.error('[Codex Channels API] Error testing all channels speed:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /api/codex/channels/:channelId/apply-to-settings
+   * 将渠道应用到 Codex 配置文件
+   */
+  router.post('/:channelId/apply-to-settings', async (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      const channel = applyChannelToSettings(channelId);
+
+      // 如果代理正在运行，停止它
+      const { getCodexProxyStatus, stopCodexProxyServer } = require('../codex-proxy-server');
+      const proxyStatus = getCodexProxyStatus();
+
+      if (proxyStatus && proxyStatus.running) {
+        console.log(`Codex proxy is running, stopping to apply channel settings: ${channel.name}`);
+        await stopCodexProxyServer({ clearStartTime: false });
+
+        broadcastLog({
+          type: 'action',
+          action: 'stop_proxy',
+          message: `已停止动态切换，默认使用当前渠道`,
+          timestamp: Date.now(),
+          source: 'codex'
+        });
+      }
+
+      broadcastLog({
+        type: 'action',
+        action: 'apply_settings',
+        message: `已将 (${channel.name}) 渠道写入配置文件中`,
+        channelName: channel.name,
+        timestamp: Date.now(),
+        source: 'codex'
+      });
+
+      res.json({
+        message: `已将 (${channel.name}) 渠道写入配置文件中`,
+        channel
+      });
+    } catch (error) {
+      console.error('[Codex Channels API] Error applying channel to settings:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /api/codex/channels/:channelId/reset-health
+   * 重置渠道健康状态
+   */
+  router.post('/:channelId/reset-health', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      resetChannelHealth(channelId, 'codex');
+      broadcastSchedulerState('codex', getSchedulerState('codex'));
+
+      res.json({
+        success: true,
+        message: '渠道健康状态已重置',
+        health: getChannelHealthStatus(channelId, 'codex')
+      });
+    } catch (error) {
+      console.error('[Codex Channels API] Error resetting channel health:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  return router;
+};
+
+// 计算平均延迟
+function calculateAvgLatency(results) {
+  const successResults = results.filter(
+    r => r.success && r.latency !== null && r.latency !== undefined
+  );
+  if (successResults.length === 0) return null;
+  const sum = successResults.reduce((acc, r) => acc + r.latency, 0);
+  return Math.round(sum / successResults.length);
+}

package/src/server/api/codex-projects.js

@@ -0,0 +1,104 @@
+const express = require('express');
+const router = express.Router();
+const { getProjects, saveProjectOrder, deleteProject } = require('../services/codex-sessions');
+const { isCodexInstalled } = require('../services/codex-config');
+
+const DEBUG_CODEX_PERF = process.env.DEBUG_CODEX_PERF === '1';
+
+function logPerf(route, startMs, detail = '') {
+  if (!DEBUG_CODEX_PERF) return;
+  const duration = Date.now() - startMs;
+  const suffix = detail ? ` | ${detail}` : '';
+  console.log(`[Codex Perf] ${route}: ${duration}ms${suffix}`);
+}
+
+module.exports = (config) => {
+  /**
+   * GET /api/codex/projects
+   * 获取所有 Codex 项目列表
+   */
+  router.get('/', (req, res) => {
+    const startMs = Date.now();
+    try {
+      // 检查 Codex 是否安装
+      if (!isCodexInstalled()) {
+        logPerf('GET /api/codex/projects', startMs, 'codex not installed');
+        return res.json({
+          projects: [],
+          currentProject: null,
+          error: 'Codex CLI not installed or not found'
+        });
+      }
+
+      const projects = getProjects();
+      logPerf('GET /api/codex/projects', startMs, `projects=${projects.length}`);
+
+      res.json({
+        projects,
+        currentProject: projects[0] ? projects[0].name : null
+      });
+    } catch (err) {
+      console.error('[Codex API] Failed to get projects:', err);
+      logPerf('GET /api/codex/projects', startMs, `error=${err.message}`);
+
+      if (err.code === 'ENOENT') {
+        return res.status(404).json({
+          error: 'Codex sessions directory not found',
+          projects: []
+        });
+      }
+
+      res.status(500).json({
+        error: err.message,
+        projects: []
+      });
+    }
+  });
+
+  /**
+   * POST /api/codex/projects/order
+   * 保存项目排序
+   */
+  router.post('/order', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { order } = req.body;
+
+      if (!Array.isArray(order)) {
+        return res.status(400).json({ error: 'order must be an array' });
+      }
+
+      saveProjectOrder(order);
+
+      res.json({ success: true });
+    } catch (err) {
+      console.error('[Codex API] Failed to save project order:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * DELETE /api/codex/projects/:projectName
+   * 删除项目（删除项目下所有会话）
+   */
+  router.delete('/:projectName', (req, res) => {
+    try {
+      if (!isCodexInstalled()) {
+        return res.status(404).json({ error: 'Codex CLI not installed' });
+      }
+
+      const { projectName } = req.params;
+      const result = deleteProject(projectName);
+
+      res.json(result);
+    } catch (err) {
+      console.error('[Codex API] Failed to delete project:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+};

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

@@ -0,0 +1,195 @@
+const express = require('express');
+const router = express.Router();
+const {
+  startCodexProxyServer,
+  stopCodexProxyServer,
+  getCodexProxyStatus
+} = require('../codex-proxy-server');
+const {
+  setProxyConfig,
+  restoreSettings,
+  isProxyConfig,
+  getCurrentProxyPort,
+  configExists,
+  hasBackup
+} = require('../services/codex-settings-manager');
+const { getChannels, getEnabledChannels } = require('../services/codex-channels');
+const { clearAllLogs } = require('../websocket-server');
+const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
+const fs = require('fs');
+const path = require('path');
+
+function sanitizeChannel(channel) {
+  if (!channel) return null;
+  return {
+    id: channel.id,
+    name: channel.name,
+    baseUrl: channel.baseUrl,
+    websiteUrl: channel.websiteUrl,
+    providerKey: channel.providerKey
+  };
+}
+
+// 保存激活渠道ID
+function saveActiveChannelId(channelId) {
+  ensureStorageDirMigrated();
+  const filePath = PATHS.activeChannel.codex;
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify({ activeChannelId: channelId }, null, 2), 'utf8');
+}
+
+function removeActiveChannelFile() {
+  ensureStorageDirMigrated();
+  const filePath = PATHS.activeChannel.codex;
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+    console.log('[Codex Proxy] Removed codex-active-channel.json');
+  }
+}
+
+// 获取代理状态
+router.get('/status', (req, res) => {
+  try {
+    const proxyStatus = getCodexProxyStatus();
+    const { channels } = getChannels();
+    const enabledChannels = channels.filter(ch => ch.enabled !== false);
+    const activeChannel = enabledChannels[0]; // 多渠道模式：第一个启用的渠道
+    const configStatus = {
+      isProxyConfig: isProxyConfig(),
+      configExists: configExists(),
+      hasBackup: hasBackup(),
+      currentProxyPort: getCurrentProxyPort()
+    };
+
+    res.json({
+      proxy: proxyStatus,
+      config: configStatus,
+      activeChannel: sanitizeChannel(activeChannel)
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 启动代理
+router.post('/start', async (req, res) => {
+  try {
+    // 1. 检查 Codex 配置文件是否存在
+    if (!configExists()) {
+      return res.status(400).json({
+        error: 'Codex config.toml not found. Please run Codex CLI at least once.'
+      });
+    }
+
+    // 2. 获取当前启用的渠道（多渠道模式）
+    const enabledChannels = getEnabledChannels();
+    const currentChannel = enabledChannels[0];
+    if (!currentChannel) {
+      return res.status(400).json({
+        error: 'No enabled Codex channel found. Please create and enable a channel first.'
+      });
+    }
+
+    // 3. 保存当前激活渠道ID（用于代理模式）
+    saveActiveChannelId(currentChannel.id);
+    console.log(`[Codex Proxy] Saved active channel: ${currentChannel.name} (${currentChannel.id})`);
+
+    // 4. 启动代理服务器
+    const proxyResult = await startCodexProxyServer();
+
+    if (!proxyResult.success) {
+      return res.status(500).json({ error: 'Failed to start Codex proxy server' });
+    }
+
+    // 5. 设置代理配置（备份并修改 config.toml 和 auth.json）
+    const configResult = setProxyConfig(proxyResult.port);
+
+    const updatedStatus = getCodexProxyStatus();
+    const { channels: allChannels } = getChannels();
+    const activeChannel = allChannels.filter(ch => ch.enabled !== false)[0];
+    const { broadcastProxyState } = require('../websocket-server');
+    broadcastProxyState('codex', updatedStatus, activeChannel, allChannels);
+
+    // 构建响应消息，包含环境变量提示（仅首次）
+    let message = `Codex proxy started on port ${proxyResult.port}, active channel: ${currentChannel.name}`;
+    let envHint = null;
+
+    // 只有首次注入环境变量时才提示用户执行 source 命令
+    if (configResult.envInjected && configResult.isFirstTime) {
+      envHint = {
+        command: configResult.sourceCommand,
+        message: `首次启用需在 Codex 终端执行: ${configResult.sourceCommand}`
+      };
+    }
+
+    res.json({
+      success: true,
+      port: proxyResult.port,
+      activeChannel: sanitizeChannel(currentChannel),
+      message,
+      envHint
+    });
+  } catch (error) {
+    console.error('[Codex Proxy] Error starting proxy:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 停止代理
+router.post('/stop', async (req, res) => {
+  try {
+    // 1. 获取当前启用的渠道（多渠道模式）
+    const { channels } = getChannels();
+    const enabledChannels = channels.filter(ch => ch.enabled !== false);
+    const activeChannel = enabledChannels[0];
+
+    // 2. 停止代理服务器
+    const proxyResult = await stopCodexProxyServer();
+
+    // 3. 恢复原始配置
+    const { broadcastProxyState } = require('../websocket-server');
+
+    if (hasBackup()) {
+      restoreSettings();
+      console.log('[Codex Proxy] Restored settings from backup');
+
+      // Enforce single-channel mode: apply the active channel and disable all others
+      if (activeChannel) {
+        const { applyChannelToSettings } = require('../services/codex-channels');
+        applyChannelToSettings(activeChannel.id);
+        console.log(`[Codex Proxy] Single-channel mode enforced: ${activeChannel.name}`);
+      }
+
+      // 删除 active-channel.json
+      removeActiveChannelFile();
+
+      const response = {
+        success: true,
+        message: `Codex proxy stopped, settings restored${activeChannel ? ' (channel: ' + activeChannel.name + ')' : ''}`,
+        port: proxyResult.port,
+        restoredChannel: activeChannel?.name
+      };
+      res.json(response);
+
+      const updatedStatus = getCodexProxyStatus();
+      broadcastProxyState('codex', updatedStatus, activeChannel, channels);
+    } else {
+      res.json({
+        success: true,
+        message: 'Codex proxy stopped (no backup to restore)',
+        port: proxyResult.port
+      });
+
+      const updatedStatus = getCodexProxyStatus();
+      broadcastProxyState('codex', updatedStatus, activeChannel, channels);
+    }
+  } catch (error) {
+    console.error('[Codex Proxy] Error stopping proxy:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;