coding-tool-x 3.2.0

package/src/server/api/convert.js

@@ -0,0 +1,260 @@
+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');
+
+/**
+ * 获取支持的格式列表
+ * GET /api/convert/formats
+ */
+router.get('/formats', (req, res) => {
+  res.json({
+    formats: [
+      {
+        id: 'claude',
+        name: 'Claude Code',
+        description: 'Anthropic Claude Code CLI session format',
+        extension: '.jsonl',
+        icon: 'claude'
+      },
+      {
+        id: 'codex',
+        name: 'OpenAI Codex',
+        description: 'OpenAI Codex CLI session format',
+        extension: '.jsonl',
+        icon: 'codex'
+      },
+      {
+        id: 'gemini',
+        name: 'Google Gemini',
+        description: 'Google Gemini CLI session format',
+        extension: '.json',
+        icon: 'gemini'
+      }
+    ],
+    conversions: [
+      { from: 'claude', to: 'codex' },
+      { from: 'claude', to: 'gemini' },
+      { from: 'codex', to: 'claude' },
+      { from: 'codex', to: 'gemini' },
+      { from: 'gemini', to: 'claude' },
+      { from: 'gemini', to: 'codex' }
+    ]
+  });
+});
+
+/**
+ * 获取 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
+ * Body: { sourceType, sessionId }
+ */
+router.post('/preview', async (req, res) => {
+  try {
+    const { sourceType, sessionId } = req.body;
+
+    if (!sourceType || !sessionId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameters: sourceType, sessionId'
+      });
+    }
+
+    const preview = await previewConversion(sourceType, sessionId);
+
+    res.json({
+      success: true,
+      preview
+    });
+  } catch (error) {
+    console.error('[Convert API] Preview error:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+/**
+ * 执行会话转换
+ * POST /api/convert
+ * Body: { sourceType, targetType, sessionId, options }
+ */
+router.post('/', async (req, res) => {
+  try {
+    const { sourceType, targetType, sessionId, options = {} } = req.body;
+
+    // 验证必需参数
+    if (!sourceType || !targetType || !sessionId) {
+      return res.status(400).json({
+        success: false,
+        error: 'Missing required parameters: sourceType, targetType, sessionId'
+      });
+    }
+
+    // 验证格式
+    const validTypes = ['claude', 'codex', 'gemini'];
+    if (!validTypes.includes(sourceType)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid sourceType: ${sourceType}. Must be one of: ${validTypes.join(', ')}`
+      });
+    }
+    if (!validTypes.includes(targetType)) {
+      return res.status(400).json({
+        success: false,
+        error: `Invalid targetType: ${targetType}. Must be one of: ${validTypes.join(', ')}`
+      });
+    }
+    if (sourceType === targetType) {
+      return res.status(400).json({
+        success: false,
+        error: 'Source and target types must be different'
+      });
+    }
+
+    // 执行转换
+    const result = await convertSession(sourceType, targetType, sessionId, options);
+
+    res.json(result);
+  } catch (error) {
+    console.error('[Convert API] Conversion error:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+module.exports = router;

package/src/server/api/dashboard.js

@@ -0,0 +1,142 @@
+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 { 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
+ * 聚合首页所需的所有数据，一次请求返回
+ */
+router.get('/init', async (req, res) => {
+  try {
+    const config = loadConfig();
+
+    // 并行获取所有数据
+    const [
+      uiConfig,
+      favorites,
+      claudeChannels,
+      codexChannels,
+      geminiChannels,
+      opencodeChannels,
+      claudeProxyStatus,
+      codexProxyStatus,
+      geminiProxyStatus,
+      opencodeProxyStatus,
+      claudeTodayStats,
+      codexTodayStats,
+      geminiTodayStats,
+      opencodeTodayStats,
+      claudeCounts,
+      codexCounts,
+      geminiCounts,
+      opencodeCounts
+    ] = await Promise.all([
+      // UI Config
+      Promise.resolve(loadUIConfig()),
+
+      // Favorites
+      Promise.resolve(loadFavorites()),
+
+      // Channels
+      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(getOpenCodeCounts())
+    ]);
+
+    // 格式化统计数据：取 summary 和 byModel 中的数据
+    const formatStats = (stats) => {
+      if (stats && stats.summary) {
+        return {
+          requests: stats.summary.requests || 0,
+          tokens: stats.summary.tokens || 0,
+          cost: stats.summary.cost || 0,
+          byModel: stats.byModel || {}
+        };
+      }
+      return { requests: 0, tokens: 0, cost: 0, byModel: {} };
+    };
+
+    res.json({
+      success: true,
+      data: {
+        uiConfig,
+        favorites,
+        channels: {
+          claude: claudeChannels,
+          codex: codexChannels,
+          gemini: geminiChannels,
+          opencode: opencodeChannels.channels || []
+        },
+        proxyStatus: {
+          claude: claudeProxyStatus,
+          codex: codexProxyStatus,
+          gemini: geminiProxyStatus,
+          opencode: opencodeProxyStatus
+        },
+        counts: {
+          claude: claudeCounts || { projectCount: 0, sessionCount: 0 },
+          codex: codexCounts || { 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),
+          opencode: formatStats(opencodeTodayStats)
+        }
+      }
+    });
+  } 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;