coding-tool-x 3.2.0

package/src/ui/menu.js

@@ -0,0 +1,139 @@
+// 菜单显示
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const packageInfo = require('../../package.json');
+
+function normalizeCliType(type) {
+  if (type === 'claude' || type === 'codex' || type === 'gemini' || type === 'opencode') {
+    return type;
+  }
+  return 'claude';
+}
+
+function pickActiveChannel(channels) {
+  if (!Array.isArray(channels) || channels.length === 0) {
+    return null;
+  }
+  return channels.find(channel => channel.enabled !== false) || channels[0];
+}
+
+function getChannelAndProxyStatus(cliType) {
+  const currentType = normalizeCliType(cliType);
+
+  if (currentType === 'claude') {
+    const { getCurrentChannel } = require('../server/services/channels');
+    const { getProxyStatus } = require('../server/proxy-server');
+    return { channel: getCurrentChannel(), proxyStatus: getProxyStatus() };
+  }
+
+  if (currentType === 'codex') {
+    const { getChannels } = require('../server/services/codex-channels');
+    const { getCodexProxyStatus } = require('../server/codex-proxy-server');
+    const data = getChannels();
+    return { channel: pickActiveChannel(data?.channels), proxyStatus: getCodexProxyStatus() };
+  }
+
+  if (currentType === 'gemini') {
+    const { getChannels } = require('../server/services/gemini-channels');
+    const { getGeminiProxyStatus } = require('../server/gemini-proxy-server');
+    const data = getChannels();
+    return { channel: pickActiveChannel(data?.channels), proxyStatus: getGeminiProxyStatus() };
+  }
+
+  const { getChannels } = require('../server/services/opencode-channels');
+  const { getOpenCodeProxyStatus } = require('../server/opencode-proxy-server');
+  const data = getChannels();
+  return { channel: pickActiveChannel(data?.channels), proxyStatus: getOpenCodeProxyStatus() };
+}
+
+/**
+ * 显示主菜单
+ */
+async function showMainMenu(config) {
+  console.log(chalk.bold.cyan('\n╔═══════════════════════════════════════════════╗'));
+  console.log(chalk.bold.cyan(`║    Claude Code 会话管理工具 v${packageInfo.version}          ║`));
+  console.log(chalk.bold.cyan('╚═══════════════════════════════════════════════╝\n'));
+
+  // 显示当前CLI类型
+  const cliTypes = {
+    claude: { name: 'Claude Code', color: 'cyan' },
+    codex: { name: 'Codex', color: 'green' },
+    gemini: { name: 'Gemini', color: 'magenta' },
+    opencode: { name: 'OpenCode', color: 'yellow' }
+  };
+  const currentType = normalizeCliType(config.currentCliType || 'claude');
+  const typeInfo = cliTypes[currentType] || cliTypes.claude;
+  console.log(chalk[typeInfo.color](`当前类型: ${typeInfo.name}`));
+
+  const projectName = config.currentProject
+    ? config.currentProject.replace(/-/g, '/').substring(1)
+    : '未设置';
+  console.log(chalk.gray(`当前项目: ${projectName}`));
+
+  // 显示当前渠道和代理状态（根据类型显示对应的渠道和代理）
+  try {
+    const { channel: currentChannel, proxyStatus } = getChannelAndProxyStatus(currentType);
+
+    if (currentChannel) {
+      console.log(chalk.gray(`当前渠道: ${currentChannel.name}`));
+    }
+
+    if (proxyStatus.running) {
+      console.log(chalk.green(`动态切换: 已开启 (端口 ${proxyStatus.port})`));
+    } else {
+      console.log(chalk.gray('动态切换: 未开启'));
+    }
+  } catch (err) {
+    // 忽略错误
+  }
+
+  console.log(chalk.gray('─'.repeat(50)));
+
+  // 获取代理状态，用于显示动态切换的状态（根据当前类型）
+  let proxyStatusText = '未开启';
+  try {
+    const { proxyStatus } = getChannelAndProxyStatus(currentType);
+
+    if (proxyStatus && proxyStatus.running) {
+      proxyStatusText = '已开启';
+    }
+  } catch (err) {
+    // 忽略错误
+    console.error('获取代理状态失败:', err.message);
+  }
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: '请选择操作:',
+      pageSize: 16,
+      choices: [
+        { name: chalk.bold.yellow('切换 CLI 类型'), value: 'switch-cli-type' },
+        new inquirer.Separator(chalk.gray('─'.repeat(14))),
+        { name: chalk.bold.hex('#00D9FF')('启动 Web UI'), value: 'ui' },
+        new inquirer.Separator(chalk.gray('─'.repeat(14))),
+        { name: chalk.cyan('列出最新对话'), value: 'list' },
+        { name: chalk.green('搜索会话'), value: 'search' },
+        { name: chalk.magenta('切换项目'), value: 'switch' },
+        { name: chalk.hex('#FF6B35')('工作区管理'), value: 'workspace' },
+        new inquirer.Separator(chalk.gray('─'.repeat(14))),
+        { name: chalk.cyan('渠道管理'), value: 'switch-channel' },
+        { name: chalk.cyan('查看调度状态'), value: 'channel-status' },
+        { name: chalk.cyan(`是否开启动态切换 (${proxyStatusText})`), value: 'toggle-proxy' },
+        { name: chalk.cyan('添加渠道'), value: 'add-channel' },
+        { name: chalk.blue('插件管理'), value: 'plugin-menu' },
+        new inquirer.Separator(chalk.gray('─'.repeat(14))),
+        { name: chalk.magenta('配置端口'), value: 'port-config' },
+        { name: chalk.yellow('恢复默认配置'), value: 'reset' },
+        { name: chalk.gray('退出程序'), value: 'exit' },
+      ],
+    },
+  ]);
+
+  return action;
+}
+
+module.exports = {
+  showMainMenu,
+};

package/src/ui/prompts.js

@@ -0,0 +1,100 @@
+// 交互提示
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+/**
+ * 选择会话提示
+ */
+async function promptSelectSession(choices) {
+  const { sessionId } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'sessionId',
+      message: '选择会话或操作:',
+      pageSize: 15,
+      choices: choices,
+    },
+  ]);
+
+  return sessionId;
+}
+
+/**
+ * Fork 确认提示
+ */
+async function promptForkConfirm() {
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: chalk.bold('选择恢复方式:'),
+      default: 'continue',
+      choices: [
+        {
+          name: chalk.green('📝 继续原会话 (推荐) - 在原会话上继续对话，所有内容会追加到原文件'),
+          value: 'continue',
+        },
+        {
+          name: chalk.yellow('🌿 创建新分支 (Fork) - 基于原会话创建新会话，保留原会话不变'),
+          value: 'fork',
+        },
+        new inquirer.Separator(chalk.gray('─'.repeat(14))),
+        { name: chalk.blue('↩️  返回重新选择'), value: 'back' },
+      ],
+    },
+  ]);
+
+  return action;
+}
+
+/**
+ * 搜索关键词提示
+ */
+async function promptSearchKeyword() {
+  const { keyword } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'keyword',
+      message: chalk.cyan('🔎 输入搜索关键词:'),
+      validate: (input) => {
+        if (!input.trim()) {
+          return '请输入搜索关键词';
+        }
+        return true;
+      },
+    },
+  ]);
+
+  return keyword.trim();
+}
+
+/**
+ * 选择项目提示
+ */
+async function promptSelectProject(projects) {
+  // 添加取消选项
+  const choices = [
+    ...projects,
+    new inquirer.Separator(chalk.gray('─'.repeat(14))),
+    { name: chalk.gray('↩️  取消切换'), value: null }
+  ];
+
+  const { project } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'project',
+      message: chalk.cyan('选择项目:'),
+      pageSize: 15,
+      choices: choices,
+    },
+  ]);
+
+  return project;
+}
+
+module.exports = {
+  promptSelectSession,
+  promptForkConfirm,
+  promptSearchKeyword,
+  promptSelectProject,
+};

package/src/utils/format.js

@@ -0,0 +1,43 @@
+// 格式化工具函数
+
+/**
+ * 格式化时间
+ */
+function formatTime(date) {
+  const now = new Date();
+  const diff = now - new Date(date);
+  const minutes = Math.floor(diff / 60000);
+  const hours = Math.floor(diff / 3600000);
+  const days = Math.floor(diff / 86400000);
+
+  if (minutes < 1) return '刚刚';
+  if (minutes < 60) return `${minutes}分钟前`;
+  if (hours < 24) return `${hours}小时前`;
+  if (days < 30) return `${days}天前`;
+  return new Date(date).toLocaleDateString('zh-CN');
+}
+
+/**
+ * 格式化文件大小
+ */
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+/**
+ * 截断文本
+ */
+function truncate(text, maxLength) {
+  if (!text) return '';
+  text = text.replace(/\s+/g, ' ').trim();
+  if (text.length <= maxLength) return text;
+  return text.substring(0, maxLength) + '...';
+}
+
+module.exports = {
+  formatTime,
+  formatSize,
+  truncate,
+};

package/src/utils/port-helper.js

@@ -0,0 +1,108 @@
+const { execSync } = require('child_process');
+const net = require('net');
+
+/**
+ * 检查端口是否被占用
+ */
+function isPortInUse(port, host = '127.0.0.1') {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    let resolved = false;
+
+    const finish = (value) => {
+      if (!resolved) {
+        resolved = true;
+        resolve(value);
+      }
+    };
+
+    server.once('error', (err) => {
+      if (err.code === 'EADDRINUSE') {
+        finish(true);
+      } else {
+        finish(false);
+      }
+    });
+
+    server.once('listening', () => {
+      // 等待 close 完成后再返回，避免紧接着重新监听同端口时触发竞态
+      server.close((err) => {
+        if (err) {
+          finish(true);
+          return;
+        }
+        finish(false);
+      });
+    });
+
+    server.listen(port, host);
+  });
+}
+
+/**
+ * 查找占用端口的进程PID
+ */
+function findProcessByPort(port) {
+  try {
+    // macOS/Linux 使用 lsof
+    const result = execSync(`lsof -ti :${port}`, { encoding: 'utf-8' }).trim();
+    return result.split('\n').filter(pid => pid);
+  } catch (err) {
+    // 如果 lsof 失败，尝试使用其他命令
+    try {
+      // 适用于某些 Linux 系统
+      const result = execSync(`fuser ${port}/tcp 2>/dev/null`, { encoding: 'utf-8' }).trim();
+      return result.split(/\s+/).filter(pid => pid);
+    } catch (e) {
+      return [];
+    }
+  }
+}
+
+/**
+ * 杀掉占用端口的进程
+ */
+function killProcessByPort(port) {
+  try {
+    const pids = findProcessByPort(port);
+    if (pids.length === 0) {
+      return false;
+    }
+
+    pids.forEach(pid => {
+      try {
+        execSync(`kill -9 ${pid}`, { stdio: 'ignore' });
+      } catch (err) {
+        // 忽略单个进程杀掉失败的错误
+      }
+    });
+
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * 等待端口释放
+ */
+async function waitForPortRelease(port, timeout = 3000, host = '127.0.0.1') {
+  const startTime = Date.now();
+
+  while (Date.now() - startTime < timeout) {
+    const inUse = await isPortInUse(port, host);
+    if (!inUse) {
+      return true;
+    }
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+
+  return false;
+}
+
+module.exports = {
+  isPortInUse,
+  findProcessByPort,
+  killProcessByPort,
+  waitForPortRelease
+};

package/src/utils/session.js

@@ -0,0 +1,240 @@
+// 会话相关工具函数
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * 获取会话目录
+ */
+function getSessionsDir(config) {
+  return path.join(config.projectsDir, config.currentProject);
+}
+
+/**
+ * 获取所有会话文件
+ */
+function getAllSessions(config) {
+  const sessionsDir = getSessionsDir(config);
+  if (!fs.existsSync(sessionsDir)) {
+    console.log(chalk.red(`会话目录不存在: ${sessionsDir}`));
+    return [];
+  }
+
+  const files = fs.readdirSync(sessionsDir)
+    .filter(file => file.endsWith('.jsonl') && !file.startsWith('agent-'))
+    .map(file => {
+      const filePath = path.join(sessionsDir, file);
+      const stats = fs.statSync(filePath);
+      return {
+        sessionId: file.replace('.jsonl', ''),
+        filePath,
+        size: stats.size,
+        mtime: stats.mtime,
+      };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+
+  return files;
+}
+
+/**
+ * 快速解析会话信息（读取开头和结尾）
+ */
+function parseSessionInfoFast(filePath) {
+  try {
+    const fileSize = fs.statSync(filePath).size;
+
+    // 如果文件太大（>10MB），只读取开头和结尾
+    if (fileSize > 10 * 1024 * 1024) {
+      const fd = fs.openSync(filePath, 'r');
+
+      // 读取开头 32KB（扩大范围以找到第一条消息）
+      const headBuffer = Buffer.alloc(32 * 1024);
+      const headBytesRead = fs.readSync(fd, headBuffer, 0, 32 * 1024, 0);
+
+      // 读取结尾 8KB
+      const tailBuffer = Buffer.alloc(8192);
+      const tailOffset = Math.max(0, fileSize - 8192);
+      fs.readSync(fd, tailBuffer, 0, 8192, tailOffset);
+
+      fs.closeSync(fd);
+
+      const headContent = headBuffer.slice(0, headBytesRead).toString('utf8');
+      const tailContent = tailBuffer.toString('utf8');
+
+      const headLines = headContent.split('\n');
+      const tailLines = tailContent.split('\n').slice(-20);
+
+      return parseLinesWithTail(headLines, tailLines);
+    }
+
+    // 小文件直接读取
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    return parseLinesWithTail(lines, lines.slice(-20));
+  } catch (error) {
+    return { summary: '', gitBranch: '', firstMessage: '', lastMessage: '', messageCount: 0 };
+  }
+}
+
+/**
+ * 解析行数据（包含开头和结尾）
+ */
+function parseLinesWithTail(headLines, tailLines) {
+  let summary = '';
+  let gitBranch = '';
+  let firstMessage = '';
+  let lastMessage = '';
+  let lastUserMessage = '';
+
+  // 解析开头（查找第一条有效消息，跳过 file-history-snapshot）
+  for (const line of headLines) {
+    if (!line.trim()) continue;
+
+    try {
+      const json = JSON.parse(line);
+
+      if (json.type === 'summary' && json.summary) {
+        summary = json.summary;
+      }
+
+      if (json.gitBranch && !gitBranch) {
+        gitBranch = json.gitBranch;
+      }
+
+      // 优先找用户消息作为首条消息
+      if (json.type === 'user' && json.message && json.message.content !== 'Warmup' && !firstMessage) {
+        firstMessage = typeof json.message.content === 'string'
+          ? json.message.content
+          : JSON.stringify(json.message.content);
+      }
+    } catch (e) {
+      // 忽略解析错误
+    }
+  }
+
+  // 如果开头找不到用户消息，尝试从尾部向前找
+  if (!firstMessage) {
+    for (let i = 0; i < tailLines.length; i++) {
+      const line = tailLines[i];
+      if (!line.trim()) continue;
+
+      try {
+        const json = JSON.parse(line);
+        if (json.type === 'user' && json.message && json.message.content !== 'Warmup') {
+          firstMessage = typeof json.message.content === 'string'
+            ? json.message.content
+            : JSON.stringify(json.message.content);
+          break;
+        }
+      } catch (e) {
+        // 忽略
+      }
+    }
+  }
+
+  // 解析结尾 - 获取最后的对话
+  const validTailLines = [];
+  for (const line of tailLines) {
+    if (!line.trim()) continue;
+    try {
+      const json = JSON.parse(line);
+      if (json.type === 'user' || json.type === 'assistant') {
+        validTailLines.push(json);
+      }
+    } catch (e) {
+      // 忽略
+    }
+  }
+
+  // 从后往前找最后一条有效消息
+  for (let i = validTailLines.length - 1; i >= 0; i--) {
+    const json = validTailLines[i];
+
+    if (!lastMessage && json.type === 'assistant' && json.message && json.message.content) {
+      const content = json.message.content;
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === 'text' && item.text) {
+            lastMessage = item.text;
+            break;
+          }
+        }
+      } else if (typeof content === 'string') {
+        lastMessage = content;
+      }
+    }
+
+    if (!lastUserMessage && json.type === 'user' && json.message && json.message.content) {
+      const content = json.message.content;
+      if (typeof content === 'string' && content !== 'Warmup') {
+        lastUserMessage = content;
+      }
+    }
+
+    if (lastMessage && lastUserMessage) break;
+  }
+
+  // 如果仍然找不到首条消息，使用 summary 或 gitBranch 作为备选
+  if (!firstMessage && summary) {
+    firstMessage = `[摘要] ${summary}`;
+  } else if (!firstMessage && gitBranch) {
+    firstMessage = `[分支] ${gitBranch}`;
+  }
+
+  return {
+    summary,
+    gitBranch,
+    firstMessage,
+    lastMessage: lastMessage || lastUserMessage, // 优先显示助手回复，否则显示用户消息
+    messageCount: 0
+  };
+}
+
+/**
+ * 获取所有可用的项目
+ */
+async function getAvailableProjects(config) {
+  const projectsDir = config.projectsDir;
+  if (!fs.existsSync(projectsDir)) {
+    console.log(chalk.red(`项目目录不存在: ${projectsDir}`));
+    return [];
+  }
+
+  // 获取项目列表和统计信息（包含解析后的名称）
+  const { getProjectsWithStats, getProjectOrder } = require('../server/services/sessions');
+  const projects = await getProjectsWithStats(config);
+  const savedOrder = getProjectOrder(config);
+  const projectList = Array.isArray(projects) ? projects : [];
+
+  // 按保存的顺序排列
+  let orderedProjects = [];
+  if (savedOrder.length > 0) {
+    const projectMap = new Map(projectList.map(p => [p.name, p]));
+    for (const name of savedOrder) {
+      if (projectMap.has(name)) {
+        orderedProjects.push(projectMap.get(name));
+        projectMap.delete(name);
+      }
+    }
+    // 添加不在排序中的新项目
+    orderedProjects.push(...projectMap.values());
+  } else {
+    orderedProjects = projectList;
+  }
+
+  // 转换为选项格式
+  return orderedProjects.map(project => ({
+    name: `${project.displayName} (${project.sessionCount} 会话)`,
+    value: project.name,
+  }));
+}
+
+module.exports = {
+  getSessionsDir,
+  getAllSessions,
+  parseSessionInfoFast,
+  parseLinesWithTail,
+  getAvailableProjects,
+};