coding-tool-x 3.2.0

package/src/server/api/sessions.js

@@ -0,0 +1,514 @@
+const express = require('express');
+const router = express.Router();
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const readline = require('readline');
+const { getSessionsForProject, deleteSession, forkSession, saveSessionOrder, parseRealProjectPath, searchSessions, getRecentSessions, searchSessionsAcrossProjects, hasActualMessages } = require('../services/sessions');
+const { loadAliases } = require('../services/alias');
+const { broadcastLog } = require('../websocket-server');
+
+module.exports = (config) => {
+  // GET /api/sessions/search/global - Search sessions across all projects
+  router.get('/search/global', async (req, res) => {
+    try {
+      const { keyword, context } = req.query;
+
+      if (!keyword) {
+        return res.status(400).json({ error: 'Keyword is required' });
+      }
+
+      const contextLength = context ? parseInt(context) : 35;
+      const results = await searchSessionsAcrossProjects(config, keyword, contextLength);
+
+      res.json({
+        keyword,
+        totalMatches: results.reduce((sum, r) => sum + r.matchCount, 0),
+        sessions: results
+      });
+    } catch (error) {
+      console.error('Error searching sessions globally:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // GET /api/sessions/recent - Get recent sessions across all projects
+  router.get('/recent/list', async (req, res) => {
+    try {
+      const limit = parseInt(req.query.limit) || 5;
+      const sessions = await getRecentSessions(config, limit);
+      res.json({ sessions });
+    } catch (error) {
+      console.error('Error fetching recent sessions:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // GET /api/sessions/:projectName - Get sessions for a project
+  router.get('/:projectName', async (req, res) => {
+    try {
+      const { projectName } = req.params;
+      const result = await getSessionsForProject(config, projectName);
+      const aliases = loadAliases();
+
+      // Parse project path info
+      const { fullPath, projectName: displayName } = parseRealProjectPath(projectName);
+
+      res.json({
+        sessions: result.sessions,
+        totalSize: result.totalSize,
+        aliases,
+        projectInfo: {
+          name: projectName,
+          displayName,
+          fullPath
+        }
+      });
+    } catch (error) {
+      console.error('Error fetching sessions:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // DELETE /api/sessions/:projectName/:sessionId - Delete a session
+  router.delete('/:projectName/:sessionId', (req, res) => {
+    try {
+      const { projectName, sessionId } = req.params;
+      const result = deleteSession(config, projectName, sessionId);
+      res.json(result);
+    } catch (error) {
+      console.error('Error deleting session:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // POST /api/sessions/:projectName/:sessionId/fork - Fork a session
+  router.post('/:projectName/:sessionId/fork', (req, res) => {
+    try {
+      const { projectName, sessionId } = req.params;
+      const result = forkSession(config, projectName, sessionId);
+      res.json(result);
+    } catch (error) {
+      console.error('Error forking session:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // POST /api/sessions/:projectName/create - Create a new session
+  router.post('/:projectName/create', (req, res) => {
+    try {
+      const { projectName } = req.params;
+      const { toolType = 'claude' } = req.body; // 'claude', 'codex', 或 'gemini'
+      const crypto = require('crypto');
+
+      // 解析项目路径
+      const { fullPath } = parseRealProjectPath(projectName);
+
+      // 生成新的 session ID
+      const newSessionId = crypto.randomUUID();
+
+      // 根据工具类型决定会话文件路径
+      let sessionDir, sessionFile;
+
+      if (toolType === 'claude') {
+        // Claude Code: 直接创建在项目的 .claude/sessions/ 目录（与 Claude Code 默认行为一致）
+        sessionDir = path.join(fullPath, '.claude', 'sessions');
+        sessionFile = path.join(sessionDir, `${newSessionId}.jsonl`);
+      } else if (toolType === 'codex') {
+        // Codex: ~/.codex/sessions/YYYY/MM/DD/{sessionId}.jsonl
+        const now = new Date();
+        const year = now.getFullYear();
+        const month = String(now.getMonth() + 1).padStart(2, '0');
+        const day = String(now.getDate()).padStart(2, '0');
+        sessionDir = path.join(os.homedir(), '.codex', 'sessions', String(year), month, day);
+        sessionFile = path.join(sessionDir, `${newSessionId}.jsonl`);
+      } else if (toolType === 'gemini') {
+        // Gemini: ~/.gemini/tmp/{hash}/chats/{sessionId}.json
+        const pathHash = crypto.createHash('sha256').update(fullPath).digest('hex');
+        sessionDir = path.join(os.homedir(), '.gemini', 'tmp', pathHash, 'chats');
+        sessionFile = path.join(sessionDir, `${newSessionId}.json`);
+      } else {
+        return res.status(400).json({ error: 'Invalid toolType. Must be claude, codex, or gemini' });
+      }
+
+      // 确保目录存在
+      if (!fs.existsSync(sessionDir)) {
+        fs.mkdirSync(sessionDir, { recursive: true });
+      }
+
+      // 创建初始化会话文件
+      const timestamp = new Date().toISOString();
+      let initialContent;
+
+      if (toolType === 'gemini') {
+        // Gemini 使用 JSON 格式
+        initialContent = JSON.stringify({
+          id: newSessionId,
+          projectPath: fullPath,
+          createdAt: timestamp,
+          messages: []
+        }, null, 2);
+      } else {
+        // Claude 和 Codex 使用 JSONL 格式
+        const metadata = {
+          type: 'metadata',
+          cwd: fullPath,
+          gitBranch: null,
+          timestamp: timestamp
+        };
+        initialContent = JSON.stringify(metadata) + '\n';
+      }
+
+      fs.writeFileSync(sessionFile, initialContent, 'utf8');
+
+      // 广播日志
+      broadcastLog({
+        type: 'action',
+        action: 'create_session',
+        message: `创建新会话: ${newSessionId.substring(0, 8)} (${toolType})`,
+        sessionId: newSessionId,
+        tool: toolType,
+        timestamp: Date.now()
+      });
+
+      res.json({
+        success: true,
+        sessionId: newSessionId,
+        sessionFile,
+        toolType,
+        projectName
+      });
+    } catch (error) {
+      console.error('Error creating session:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // POST /api/sessions/:projectName/order - Save session order
+  router.post('/:projectName/order', (req, res) => {
+    try {
+      const { projectName } = req.params;
+      const { order } = req.body;
+      if (!Array.isArray(order)) {
+        return res.status(400).json({ error: 'order must be an array' });
+      }
+      saveSessionOrder(projectName, order);
+      res.json({ success: true });
+    } catch (error) {
+      console.error('Error saving session order:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // GET /api/sessions/:projectName/search - Search sessions content
+  router.get('/:projectName/search', (req, res) => {
+    try {
+      const { projectName } = req.params;
+      const { keyword, context } = req.query;
+
+      if (!keyword) {
+        return res.status(400).json({ error: 'Keyword is required' });
+      }
+
+      const contextLength = context ? parseInt(context) : 15;
+      const results = searchSessions(config, projectName, keyword, contextLength);
+
+      res.json({
+        keyword,
+        totalMatches: results.reduce((sum, r) => sum + r.matchCount, 0),
+        sessions: results
+      });
+    } catch (error) {
+      console.error('Error searching sessions:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // GET /api/sessions/:projectName/:sessionId/messages - Get session messages with pagination
+  router.get('/:projectName/:sessionId/messages', async (req, res) => {
+    try {
+      const { projectName, sessionId } = req.params;
+      const { page = 1, limit = 20, order = 'desc' } = req.query;
+
+      console.log(`[Messages API] Request for ${projectName}/${sessionId}, page=${page}, limit=${limit}`);
+
+      const pageNum = parseInt(page);
+      const limitNum = parseInt(limit);
+
+      // Parse real project path
+      const { fullPath } = parseRealProjectPath(projectName);
+      console.log(`[Messages API] Parsed project path: ${fullPath}`);
+
+      // Try to find session file
+      let sessionFile = null;
+      const possiblePaths = [
+        path.join(fullPath, '.claude', 'sessions', sessionId + '.jsonl'),
+        path.join(os.homedir(), '.claude', 'projects', projectName, sessionId + '.jsonl')
+      ];
+
+      console.log(`[Messages API] Trying paths:`, possiblePaths);
+
+      for (const testPath of possiblePaths) {
+        if (fs.existsSync(testPath)) {
+          sessionFile = testPath;
+          console.log(`[Messages API] Found session file: ${sessionFile}`);
+          break;
+        }
+      }
+
+      if (!sessionFile) {
+        console.error(`[Messages API] Session file not found for: ${sessionId}`);
+        return res.status(404).json({
+          error: `Session file not found: ${sessionId}`,
+          triedPaths: possiblePaths
+        });
+      }
+
+      // Check if session has actual messages (not just file-history-snapshots)
+      if (!hasActualMessages(sessionFile)) {
+        console.warn(`[Messages API] Session ${sessionId} has no actual messages (only file-history-snapshots)`);
+        return res.status(404).json({
+          error: `Session has no conversation messages: ${sessionId}`,
+          reason: 'This session contains only file history snapshots, not actual conversation data'
+        });
+      }
+
+      // Read and parse session file
+      const allMessages = [];
+      const metadata = {};
+
+      const stream = fs.createReadStream(sessionFile, { encoding: 'utf8' });
+      const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+      try {
+        for await (const line of rl) {
+          if (!line.trim()) continue;
+          try {
+            const json = JSON.parse(line);
+
+            if (json.type === 'summary' && json.summary) {
+              metadata.summary = json.summary;
+            }
+            if (json.gitBranch) {
+              metadata.gitBranch = json.gitBranch;
+            }
+            if (json.cwd) {
+              metadata.cwd = json.cwd;
+            }
+
+            if (json.type === 'user' || json.type === 'assistant') {
+              const message = {
+                type: json.type,
+                content: null,
+                timestamp: json.timestamp || null,
+                model: json.model || null
+              };
+
+              if (json.type === 'user') {
+                if (typeof json.message?.content === 'string') {
+                  message.content = json.message.content;
+                } else if (Array.isArray(json.message?.content)) {
+                  const parts = [];
+                  for (const item of json.message.content) {
+                    if (item.type === 'text' && item.text) {
+                      parts.push(item.text);
+                    } else if (item.type === 'tool_result') {
+                      const resultContent = typeof item.content === 'string'
+                        ? item.content
+                        : JSON.stringify(item.content, null, 2);
+                      parts.push(`**[工具结果]**\n\`\`\`\n${resultContent}\n\`\`\``);
+                    } else if (item.type === 'image') {
+                      parts.push('[图片]');
+                    }
+                  }
+                  message.content = parts.join('\n\n') || '[工具交互]';
+                }
+              } else if (json.type === 'assistant') {
+                if (Array.isArray(json.message?.content)) {
+                  const parts = [];
+                  for (const item of json.message.content) {
+                    if (item.type === 'text' && item.text) {
+                      parts.push(item.text);
+                    } else if (item.type === 'tool_use') {
+                      const inputStr = JSON.stringify(item.input, null, 2);
+                      parts.push(`**[调用工具: ${item.name}]**\n\`\`\`json\n${inputStr}\n\`\`\``);
+                    } else if (item.type === 'thinking' && item.thinking) {
+                      parts.push(`**[思考]**\n${item.thinking}`);
+                    }
+                  }
+                  message.content = parts.join('\n\n') || '[处理中...]';
+                } else if (typeof json.message?.content === 'string') {
+                  message.content = json.message.content;
+                }
+              }
+
+              if (message.content && message.content !== 'Warmup') {
+                allMessages.push(message);
+              }
+            }
+          } catch (err) {
+            // Skip invalid lines
+          }
+        }
+      } finally {
+        rl.close();
+        stream.destroy();
+      }
+
+      // Sort messages (desc = newest first)
+      if (order === 'desc') {
+        allMessages.reverse();
+      }
+
+      console.log(`[Messages API] Parsed ${allMessages.length} total messages`);
+
+      // Pagination
+      const total = allMessages.length;
+      const startIndex = (pageNum - 1) * limitNum;
+      const endIndex = startIndex + limitNum;
+      const messages = allMessages.slice(startIndex, endIndex);
+      const hasMore = endIndex < total;
+
+      console.log(`[Messages API] Returning ${messages.length} messages (page ${pageNum}, total ${total})`);
+
+      res.json({
+        messages,
+        metadata,
+        pagination: {
+          page: pageNum,
+          limit: limitNum,
+          total,
+          hasMore
+        }
+      });
+    } catch (error) {
+      console.error('Error fetching session messages:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // POST /api/sessions/:projectName/:sessionId/launch - Return session launch command for copy
+  router.post('/:projectName/:sessionId/launch', async (req, res) => {
+    try {
+      const { projectName, sessionId } = req.params;
+      const path = require('path');
+      const fs = require('fs');
+      const os = require('os');
+
+      // Parse real project path (important for cross-project sessions)
+      const { fullPath } = parseRealProjectPath(projectName);
+
+      const projectSessionsDir = path.join(fullPath, '.claude', 'sessions');
+      const projectSessionFile = path.join(projectSessionsDir, sessionId + '.jsonl');
+
+      // Try to find session file in multiple possible locations
+      let sessionFile = null;
+      const possiblePaths = [
+        projectSessionFile,
+        // Location 2: User's .claude/projects directory (ClaudeCode default)
+        path.join(os.homedir(), '.claude', 'projects', projectName, sessionId + '.jsonl')
+      ];
+
+      for (const testPath of possiblePaths) {
+        if (fs.existsSync(testPath)) {
+          sessionFile = testPath;
+          break;
+        }
+      }
+
+      // 如果会话只存在于全局目录，则复制到项目的 .claude/sessions 目录，避免 claude -r 找不到文件
+      if (sessionFile && sessionFile !== projectSessionFile) {
+        try {
+          if (!fs.existsSync(projectSessionsDir)) {
+            fs.mkdirSync(projectSessionsDir, { recursive: true });
+          }
+          fs.copyFileSync(sessionFile, projectSessionFile);
+          sessionFile = projectSessionFile;
+        } catch (copyError) {
+          console.warn('Failed to sync session file to project directory:', copyError.message);
+        }
+      }
+
+      if (!sessionFile) {
+        console.error(`Session file not found in any location for session: ${sessionId}`);
+        console.error('Tried paths:', possiblePaths);
+        return res.status(404).json({
+          error: `No conversation found with session ID: ${sessionId}`,
+          details: `Tried locations: ${possiblePaths.join(', ')}`
+        });
+      }
+
+      // Extract working directory from session file
+      let cwd = fullPath; // Default to project directory
+      try {
+        const content = fs.readFileSync(sessionFile, 'utf8');
+        const firstLine = content.split('\n')[0];
+        if (firstLine) {
+          const json = JSON.parse(firstLine);
+          if (json.cwd) {
+            cwd = json.cwd;
+          }
+        }
+      } catch (e) {
+        console.warn('Unable to extract cwd from session, using project path:', e.message);
+      }
+
+      // 确保会话文件在 cwd 的 .claude/sessions/ 目录下
+      // 这样 claude -r 才能找到文件
+      const cwdSessionsDir = path.join(cwd, '.claude', 'sessions');
+      const cwdSessionFile = path.join(cwdSessionsDir, sessionId + '.jsonl');
+
+      // 如果会话文件不在 cwd 的 sessions 目录，复制过去
+      if (sessionFile !== cwdSessionFile && !fs.existsSync(cwdSessionFile)) {
+        try {
+          if (!fs.existsSync(cwdSessionsDir)) {
+            fs.mkdirSync(cwdSessionsDir, { recursive: true });
+          }
+          fs.copyFileSync(sessionFile, cwdSessionFile);
+          console.log(`[Launch] Copied session to cwd: ${cwdSessionFile}`);
+        } catch (copyError) {
+          console.warn('[Launch] Failed to copy session file to cwd:', copyError.message);
+          // 如果复制失败，尝试更新 cwd 为项目目录
+          if (fs.existsSync(projectSessionsDir)) {
+            cwd = fullPath;
+            console.log(`[Launch] Fallback to project directory: ${cwd}`);
+          }
+        }
+      }
+
+      // Get alias
+      const aliases = loadAliases();
+      const alias = aliases[sessionId];
+
+      // 广播行为日志
+      broadcastLog({
+        type: 'action',
+        action: 'launch_session',
+        message: `复制会话启动命令 ${alias || sessionId.substring(0, 8)} (claude)`,
+        sessionId,
+        alias: alias || null,
+        tool: 'claude',
+        timestamp: Date.now()
+      });
+
+      const command = `claude -r ${sessionId}`;
+      const quotedCwd = `"${String(cwd).replace(/"/g, '\\"')}"`;
+      const copyCommand = `cd ${quotedCwd} && ${command}`;
+
+      res.json({
+        success: true,
+        cwd,
+        sessionFile,
+        sessionId,
+        tool: 'claude',
+        command,
+        copyCommand
+      });
+    } catch (error) {
+      console.error('Error preparing launch command:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  return router;
+};

package/src/server/api/settings.js

@@ -0,0 +1,142 @@
+const express = require('express');
+const router = express.Router();
+const {
+  MODEL_METADATA,
+  METADATA_LAST_UPDATED,
+  getDefaultSpeedTestModels,
+  saveDefaultSpeedTestModels
+} = require('../../config/model-metadata');
+const { loadConfig, saveConfig } = require('../../config/loader');
+
+function handleGetModelSettings(req, res) {
+  try {
+    const config = loadConfig();
+    const overrides = config.modelMetadataOverrides || {};
+    const defaultSpeedTestModels = getDefaultSpeedTestModels();
+
+    // Build merged table: built-in + user overrides
+    const merged = {};
+    for (const [id, meta] of Object.entries(MODEL_METADATA)) {
+      merged[id] = overrides[id]
+        ? {
+          limit: { ...meta.limit, ...(overrides[id].limit || {}) },
+          pricing: { ...meta.pricing, ...(overrides[id].pricing || {}) }
+        }
+        : meta;
+    }
+
+    // Also include any user-added custom models from overrides
+    for (const [id, meta] of Object.entries(overrides)) {
+      if (!merged[id]) {
+        merged[id] = meta;
+      }
+    }
+
+    res.json({
+      models: merged,
+      overrides,
+      builtinModelIds: Object.keys(MODEL_METADATA),
+      lastUpdated: METADATA_LAST_UPDATED,
+      defaultSpeedTestModels
+    });
+  } catch (error) {
+    console.error('Error getting model metadata:', error);
+    res.status(500).json({ error: error.message });
+  }
+}
+
+// GET /api/settings/model-settings - 获取模型设置（元数据 + 默认测速模型）
+router.get('/model-settings', handleGetModelSettings);
+// backward compatibility
+router.get('/model-metadata', handleGetModelSettings);
+
+function handleSaveModelSettings(req, res) {
+  try {
+    const { overrides, defaultSpeedTestModels } = req.body || {};
+    if (overrides !== undefined && (typeof overrides !== 'object' || overrides === null || Array.isArray(overrides))) {
+      return res.status(400).json({ error: 'overrides must be an object' });
+    }
+
+    // Validate each override entry
+    if (overrides && typeof overrides === 'object') {
+      for (const [modelId, meta] of Object.entries(overrides)) {
+        if (typeof modelId !== 'string' || !modelId.trim()) {
+          return res.status(400).json({ error: `Invalid model ID: "${modelId}"` });
+        }
+        if (meta.limit !== undefined) {
+          if (typeof meta.limit !== 'object') {
+            return res.status(400).json({ error: `${modelId}: limit must be an object` });
+          }
+          if (meta.limit.context !== undefined && (typeof meta.limit.context !== 'number' || meta.limit.context <= 0)) {
+            return res.status(400).json({ error: `${modelId}: limit.context must be a positive number` });
+          }
+          if (meta.limit.output !== undefined && (typeof meta.limit.output !== 'number' || meta.limit.output <= 0)) {
+            return res.status(400).json({ error: `${modelId}: limit.output must be a positive number` });
+          }
+        }
+        if (meta.pricing !== undefined) {
+          if (typeof meta.pricing !== 'object') {
+            return res.status(400).json({ error: `${modelId}: pricing must be an object` });
+          }
+          for (const field of ['input', 'output']) {
+            if (meta.pricing[field] !== undefined && (typeof meta.pricing[field] !== 'number' || meta.pricing[field] < 0)) {
+              return res.status(400).json({ error: `${modelId}: pricing.${field} must be a non-negative number` });
+            }
+          }
+        }
+      }
+    }
+
+    const config = loadConfig();
+    const newConfig = {
+      ...config,
+      projectsDir: config.projectsDir.replace(require('os').homedir(), '~'),
+      modelMetadataOverrides: overrides && typeof overrides === 'object'
+        ? overrides
+        : (config.modelMetadataOverrides || {})
+    };
+    saveConfig(newConfig);
+    const persistedDefaultSpeedTestModels = saveDefaultSpeedTestModels(defaultSpeedTestModels);
+
+    res.json({
+      success: true,
+      overrides: newConfig.modelMetadataOverrides,
+      defaultSpeedTestModels: persistedDefaultSpeedTestModels
+    });
+  } catch (error) {
+    console.error('Error saving model metadata:', error);
+    res.status(500).json({ error: error.message });
+  }
+}
+
+// POST /api/settings/model-settings - 保存模型设置
+router.post('/model-settings', handleSaveModelSettings);
+// backward compatibility
+router.post('/model-metadata', handleSaveModelSettings);
+
+// DELETE /api/settings/model-metadata/:modelId - 删除单个模型覆盖项（恢复内置默认值）
+function handleDeleteModelOverride(req, res) {
+  try {
+    const modelId = decodeURIComponent(req.params.modelId);
+    const config = loadConfig();
+    const overrides = { ...(config.modelMetadataOverrides || {}) };
+    delete overrides[modelId];
+
+    const newConfig = {
+      ...config,
+      projectsDir: config.projectsDir.replace(require('os').homedir(), '~'),
+      modelMetadataOverrides: overrides
+    };
+    saveConfig(newConfig);
+
+    res.json({ success: true, modelId });
+  } catch (error) {
+    console.error('Error deleting model metadata override:', error);
+    res.status(500).json({ error: error.message });
+  }
+}
+
+router.delete('/model-settings/:modelId', handleDeleteModelOverride);
+router.delete('/model-metadata/:modelId', handleDeleteModelOverride);
+
+module.exports = router;