@adversity/coding-tool-x 2.2.0

package/src/server/api/dashboard.js

@@ -0,0 +1,125 @@
+const express = require('express');
+const router = express.Router();
+const { loadConfig } = require('../../config/loader');
+
+// Services
+const { loadUIConfig } = require('../services/ui-config');
+const { loadFavorites } = require('../services/favorites');
+const { getAllChannels } = require('../services/channels');
+const { getProxyStatus } = require('../proxy-server');
+const { getCodexProxyStatus } = require('../codex-proxy-server');
+const { getGeminiProxyStatus } = require('../gemini-proxy-server');
+const { getProjectAndSessionCounts: getClaudeCounts } = require('../services/sessions');
+const { getProjectAndSessionCounts: getCodexCounts } = require('../services/codex-sessions');
+const { getProjectAndSessionCounts: getGeminiCounts } = require('../services/gemini-sessions');
+
+// Channel-specific services
+const { getChannels: getCodexChannels } = require('../services/codex-channels');
+const { getChannels: getGeminiChannels } = require('../services/gemini-channels');
+
+// Statistics
+const { getTodayStatistics } = require('../services/statistics-service');
+const { getTodayStatistics: getCodexTodayStatistics } = require('../services/codex-statistics-service');
+const { getTodayStatistics: getGeminiTodayStatistics } = require('../services/gemini-statistics-service');
+
+/**
+ * GET /api/dashboard/init
+ * 聚合首页所需的所有数据，一次请求返回
+ */
+router.get('/init', async (req, res) => {
+  try {
+    const config = loadConfig();
+
+    // 并行获取所有数据
+    const [
+      uiConfig,
+      favorites,
+      claudeChannels,
+      codexChannels,
+      geminiChannels,
+      claudeProxyStatus,
+      codexProxyStatus,
+      geminiProxyStatus,
+      claudeTodayStats,
+      codexTodayStats,
+      geminiTodayStats,
+      claudeCounts,
+      codexCounts,
+      geminiCounts
+    ] = await Promise.all([
+      // UI Config
+      Promise.resolve(loadUIConfig()),
+
+      // Favorites
+      Promise.resolve(loadFavorites()),
+
+      // Channels
+      Promise.resolve(getAllChannels()),
+      Promise.resolve(getCodexChannels()),
+      Promise.resolve(getGeminiChannels()),
+
+      // Proxy Status
+      Promise.resolve(getProxyStatus()),
+      Promise.resolve(getCodexProxyStatus()),
+      Promise.resolve(getGeminiProxyStatus()),
+
+      // Today Stats (所有平台)
+      Promise.resolve(getTodayStatistics()),
+      Promise.resolve(getCodexTodayStatistics()),
+      Promise.resolve(getGeminiTodayStatistics()),
+
+      // 轻量级统计
+      Promise.resolve(getClaudeCounts(config)),
+      Promise.resolve(getCodexCounts()),
+      Promise.resolve(getGeminiCounts())
+    ]);
+
+    // 格式化统计数据：取 summary 中的数据
+    const formatStats = (stats) => {
+      if (stats && stats.summary) {
+        return {
+          requests: stats.summary.requests || 0,
+          tokens: stats.summary.tokens || 0,
+          cost: stats.summary.cost || 0
+        };
+      }
+      return { requests: 0, tokens: 0, cost: 0 };
+    };
+
+    res.json({
+      success: true,
+      data: {
+        uiConfig,
+        favorites,
+        channels: {
+          claude: claudeChannels,
+          codex: codexChannels,
+          gemini: geminiChannels
+        },
+        proxyStatus: {
+          claude: claudeProxyStatus,
+          codex: codexProxyStatus,
+          gemini: geminiProxyStatus
+        },
+        counts: {
+          claude: claudeCounts || { projectCount: 0, sessionCount: 0 },
+          codex: codexCounts || { projectCount: 0, sessionCount: 0 },
+          gemini: geminiCounts || { projectCount: 0, sessionCount: 0 }
+        },
+        todayStats: {
+          claude: formatStats(claudeTodayStats),
+          codex: formatStats(codexTodayStats),
+          gemini: formatStats(geminiTodayStats)
+        }
+      }
+    });
+  } catch (error) {
+    console.error('Dashboard init error:', error);
+    res.status(500).json({
+      success: false,
+      message: error.message
+    });
+  }
+});
+
+module.exports = router;

package/src/server/api/env.js

@@ -0,0 +1,144 @@
+/**
+ * 环境变量检测 API 路由
+ */
+
+const express = require('express');
+const router = express.Router();
+const envChecker = require('../services/env-checker');
+const envManager = require('../services/env-manager');
+
+/**
+ * GET /api/env/check
+ * 检测环境变量冲突
+ * Query: platform (可选) - claude/codex/gemini
+ */
+router.get('/check', (req, res) => {
+  try {
+    const { platform } = req.query;
+    const conflicts = envChecker.checkEnvConflicts(platform || null);
+    const stats = envChecker.getConflictStats(conflicts);
+
+    res.json({
+      success: true,
+      conflicts,
+      stats
+    });
+  } catch (error) {
+    console.error('[Env API] Check failed:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/env/delete
+ * 删除选中的环境变量（带自动备份）
+ * Body: { conflicts: Array }
+ */
+router.post('/delete', (req, res) => {
+  try {
+    const { conflicts } = req.body;
+
+    if (!conflicts || !Array.isArray(conflicts) || conflicts.length === 0) {
+      return res.status(400).json({
+        success: false,
+        error: '请选择要删除的环境变量'
+      });
+    }
+
+    const result = envManager.deleteEnvVars(conflicts);
+
+    res.json({
+      success: true,
+      ...result,
+      message: `已删除 ${result.results.filter(r => r.success).length} 个环境变量，备份已保存`
+    });
+  } catch (error) {
+    console.error('[Env API] Delete failed:', error);
+    res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * GET /api/env/backups
+ * 获取备份列表
+ */
+router.get('/backups', (req, res) => {
+  try {
+    const backups = envManager.getBackupList();
+
+    res.json({
+      success: true,
+      backups
+    });
+  } catch (error) {
+    console.error('[Env API] Get backups failed:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * POST /api/env/restore
+ * 从备份恢复
+ * Body: { backupPath: string }
+ */
+router.post('/restore', (req, res) => {
+  try {
+    const { backupPath } = req.body;
+
+    if (!backupPath) {
+      return res.status(400).json({
+        success: false,
+        error: '请指定备份文件路径'
+      });
+    }
+
+    const result = envManager.restoreFromBackup(backupPath);
+
+    res.json({
+      success: true,
+      ...result,
+      message: '环境变量已恢复'
+    });
+  } catch (error) {
+    console.error('[Env API] Restore failed:', error);
+    res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * DELETE /api/env/backups/:fileName
+ * 删除备份文件
+ */
+router.delete('/backups/:fileName', (req, res) => {
+  try {
+    const { fileName } = req.params;
+    const backupPath = `${envManager.BACKUP_DIR}/${fileName}`;
+
+    envManager.deleteBackup(backupPath);
+
+    res.json({
+      success: true,
+      message: '备份已删除'
+    });
+  } catch (error) {
+    console.error('[Env API] Delete backup failed:', error);
+    res.status(400).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+module.exports = router;

package/src/server/api/favorites.js

@@ -0,0 +1,77 @@
+const express = require('express');
+const router = express.Router();
+const {
+  addFavorite,
+  removeFavorite,
+  isFavorite,
+  getFavorites,
+  getAllFavorites
+} = require('../services/favorites');
+
+// Get all favorites
+router.get('/', (req, res) => {
+  try {
+    const favorites = getAllFavorites();
+    res.json({ success: true, favorites });
+  } catch (error) {
+    console.error('Error getting favorites:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Get favorites for a specific channel
+router.get('/:channel', (req, res) => {
+  try {
+    const { channel } = req.params;
+    const favorites = getFavorites(channel);
+    res.json({ success: true, favorites });
+  } catch (error) {
+    console.error('Error getting channel favorites:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Add a favorite
+router.post('/', (req, res) => {
+  try {
+    const { channel, sessionData } = req.body;
+
+    if (!channel || !sessionData) {
+      return res.status(400).json({ error: 'Missing required fields' });
+    }
+
+    const result = addFavorite(channel, sessionData);
+    res.json(result);
+  } catch (error) {
+    console.error('Error adding favorite:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Remove a favorite
+router.delete('/:channel/:projectName/:sessionId', (req, res) => {
+  try {
+    const { channel, projectName, sessionId } = req.params;
+
+    const result = removeFavorite(channel, decodeURIComponent(projectName), sessionId);
+    res.json(result);
+  } catch (error) {
+    console.error('Error removing favorite:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Check if favorited
+router.get('/check/:channel/:projectName/:sessionId', (req, res) => {
+  try {
+    const { channel, projectName, sessionId } = req.params;
+
+    const favorited = isFavorite(channel, decodeURIComponent(projectName), sessionId);
+    res.json({ success: true, isFavorite: favorited });
+  } catch (error) {
+    console.error('Error checking favorite:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;

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

@@ -0,0 +1,261 @@
+const express = require('express');
+const router = express.Router();
+const {
+  getChannels,
+  createChannel,
+  updateChannel,
+  deleteChannel,
+  getEnabledChannels,
+  saveChannelOrder
+} = require('../services/gemini-channels');
+const { getSchedulerState } = require('../services/channel-scheduler');
+const { getChannelHealthStatus, resetChannelHealth } = require('../services/channel-health');
+const { broadcastSchedulerState } = require('../websocket-server');
+const { isGeminiInstalled } = require('../services/gemini-config');
+const { testChannelSpeed, testMultipleChannels, getLatencyLevel } = require('../services/speed-test');
+
+module.exports = (config) => {
+  /**
+   * GET /api/gemini/channels
+   * 获取所有 Gemini 渠道（包含健康状态）
+   */
+  router.get('/', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.json({
+          channels: [],
+          error: 'Gemini CLI not installed'
+        });
+      }
+
+      const data = getChannels();
+      // 为每个渠道添加健康状态
+      const channelsWithHealth = (data.channels || []).map(ch => ({
+        ...ch,
+        health: getChannelHealthStatus(ch.id, 'gemini')
+      }));
+      res.json({ channels: channelsWithHealth });
+    } catch (err) {
+      console.error('[Gemini Channels API] Failed to get channels:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/gemini/channels
+   * 创建新渠道
+   * Body: { name, baseUrl, apiKey, model, websiteUrl }
+   */
+  router.post('/', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini CLI not installed' });
+      }
+
+      const { name, baseUrl, apiKey, model, websiteUrl, enabled, weight, maxConcurrency } = req.body;
+
+      if (!name || !baseUrl || !apiKey) {
+        return res.status(400).json({ error: 'Missing required fields: name, baseUrl, apiKey' });
+      }
+
+      const channel = createChannel(name, baseUrl, apiKey, model || 'gemini-2.5-pro', {
+        websiteUrl,
+        enabled,
+        weight,
+        maxConcurrency
+      });
+      res.json(channel);
+      broadcastSchedulerState('gemini', getSchedulerState('gemini'));
+    } catch (err) {
+      console.error('[Gemini Channels API] Failed to create channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * PUT /api/gemini/channels/:channelId
+   * 更新渠道
+   */
+  router.put('/:channelId', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      const updates = req.body;
+
+      const channel = updateChannel(channelId, updates);
+      res.json(channel);
+      broadcastSchedulerState('gemini', getSchedulerState('gemini'));
+    } catch (err) {
+      console.error('[Gemini Channels API] Failed to update channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * DELETE /api/gemini/channels/:channelId
+   * 删除渠道
+   */
+  router.delete('/:channelId', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      const result = deleteChannel(channelId);
+      res.json(result);
+      broadcastSchedulerState('gemini', getSchedulerState('gemini'));
+    } catch (err) {
+      console.error('[Gemini Channels API] Failed to delete channel:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/gemini/channels/order
+   * 保存渠道顺序
+   */
+  router.post('/order', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini 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('[Gemini Channels API] Failed to save channel order:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /api/gemini/channels/enabled
+   * 获取所有启用的渠道（供调度器使用）
+   */
+  router.get('/enabled', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.json({ channels: [] });
+      }
+
+      const channels = getEnabledChannels();
+      res.json({ channels });
+    } catch (err) {
+      console.error('[Gemini Channels API] Failed to get enabled channels:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * POST /api/gemini/channels/:channelId/speed-test
+   * 测试单个渠道速度
+   */
+  router.post('/:channelId/speed-test', async (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini 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 result = await testChannelSpeed(channel, timeout, 'gemini');
+      result.level = getLatencyLevel(result.latency);
+
+      res.json(result);
+    } catch (error) {
+      console.error('[Gemini Channels API] Error testing channel speed:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /api/gemini/channels/speed-test-all
+   * 测试所有渠道速度
+   */
+  router.post('/speed-test-all', async (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.json({ results: [], message: 'Gemini CLI not installed' });
+      }
+
+      const { timeout = 10000 } = req.body;
+      const data = getChannels();
+      const channels = data.channels || [];
+
+      if (channels.length === 0) {
+        return res.json({ results: [], message: '没有可测试的渠道' });
+      }
+
+      // Gemini 渠道使用 'gemini' 类型
+      const results = await testMultipleChannels(channels, timeout, 'gemini');
+      results.forEach(r => {
+        r.level = getLatencyLevel(r.latency);
+      });
+
+      res.json({
+        results,
+        summary: {
+          total: results.length,
+          success: results.filter(r => r.success).length,
+          failed: results.filter(r => !r.success).length,
+          avgLatency: calculateAvgLatency(results)
+        }
+      });
+    } catch (error) {
+      console.error('[Gemini Channels API] Error testing all channels speed:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  /**
+   * POST /api/gemini/channels/:channelId/reset-health
+   * 重置渠道健康状态
+   */
+  router.post('/:channelId/reset-health', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini CLI not installed' });
+      }
+
+      const { channelId } = req.params;
+      resetChannelHealth(channelId, 'gemini');
+      broadcastSchedulerState('gemini', getSchedulerState('gemini'));
+
+      res.json({
+        success: true,
+        message: '渠道健康状态已重置',
+        health: getChannelHealthStatus(channelId, 'gemini')
+      });
+    } catch (error) {
+      console.error('[Gemini 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);
+  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/gemini-projects.js

@@ -0,0 +1,91 @@
+const express = require('express');
+const router = express.Router();
+const { getProjects, saveProjectOrder, deleteProject } = require('../services/gemini-sessions');
+const { isGeminiInstalled } = require('../services/gemini-config');
+
+module.exports = (config) => {
+  /**
+   * GET /api/gemini/projects
+   * 获取所有 Gemini 项目列表
+   */
+  router.get('/', (req, res) => {
+    try {
+      // 检查 Gemini 是否安装
+      if (!isGeminiInstalled()) {
+        return res.json({
+          projects: [],
+          currentProject: null,
+          error: 'Gemini CLI not installed or not found'
+        });
+      }
+
+      const projects = getProjects();
+
+      res.json({
+        projects,
+        currentProject: projects[0] ? projects[0].name : null
+      });
+    } catch (err) {
+      console.error('[Gemini API] Failed to get projects:', err);
+
+      if (err.code === 'ENOENT') {
+        return res.status(404).json({
+          error: 'Gemini tmp directory not found',
+          projects: []
+        });
+      }
+
+      res.status(500).json({
+        error: err.message,
+        projects: []
+      });
+    }
+  });
+
+  /**
+   * POST /api/gemini/projects/order
+   * 保存项目排序
+   */
+  router.post('/order', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini 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('[Gemini API] Failed to save project order:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * DELETE /api/gemini/projects/:projectHash
+   * 删除项目（删除项目下所有会话）
+   */
+  router.delete('/:projectHash', (req, res) => {
+    try {
+      if (!isGeminiInstalled()) {
+        return res.status(404).json({ error: 'Gemini CLI not installed' });
+      }
+
+      const { projectHash } = req.params;
+      const result = deleteProject(projectHash);
+
+      res.json(result);
+    } catch (err) {
+      console.error('[Gemini API] Failed to delete project:', err);
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+};