@adversity/coding-tool-x 2.4.0 → 2.4.1

package/src/server/services/pty-manager.js

@@ -5,6 +5,7 @@
 
 const os = require('os');
 const path = require('path');
+const fs = require('fs');
 
 // 尝试加载 node-pty，如果失败则提示
 let pty = null;
@@ -40,7 +41,22 @@ class PtyManager {
     if (process.platform === 'win32') {
       return process.env.COMSPEC || 'cmd.exe';
     }
-    return process.env.SHELL || '/bin/zsh';
+
+    // 优先使用环境变量指定的 shell
+    if (process.env.SHELL && fs.existsSync(process.env.SHELL)) {
+      return process.env.SHELL;
+    }
+
+    // 回退到常见的 shell,按优先级检查
+    const commonShells = ['/bin/bash', '/bin/sh', '/usr/bin/bash', '/usr/bin/sh'];
+    for (const shell of commonShells) {
+      if (fs.existsSync(shell)) {
+        return shell;
+      }
+    }
+
+    // 最后回退
+    return '/bin/sh';
   }
 
   /**
@@ -78,6 +94,9 @@ class PtyManager {
     // 检查 PTY 是否可用
     if (!pty) {
       const errMsg = this.getPtyError() || 'node-pty is not available';
+      console.error('[PTY] Cannot create terminal:', errMsg);
+      console.error('[PTY] Node version:', process.version);
+      console.error('[PTY] Platform:', process.platform);
       throw new Error(`Cannot create terminal: ${errMsg}`);
     }
 
@@ -94,6 +113,21 @@ class PtyManager {
       startCommand = null
     } = options;
 
+    // 验证 shell 和 cwd 存在
+    if (!fs.existsSync(shell)) {
+      const error = `Shell not found: ${shell}`;
+      console.error('[PTY]', error);
+      throw new Error(error);
+    }
+    if (!fs.existsSync(cwd)) {
+      const error = `Working directory not found: ${cwd}`;
+      console.error('[PTY]', error);
+      throw new Error(error);
+    }
+
+    console.log(`[PTY] Creating terminal: shell=${shell}, cwd=${cwd}`);
+
+
     const terminalId = `term_${this.nextId++}_${Date.now()}`;
 
     // 合并环境变量

package/src/server/services/sessions.js

@@ -11,6 +11,7 @@ const {
   checkHasMessagesCache,
   rememberHasMessages
 } = require('./session-cache');
+const { globalCache, CacheKeys } = require('./enhanced-cache');
 const { PATHS } = require('../../config/paths');
 
 // Base directory for cc-tool data
@@ -82,15 +83,15 @@ function saveForkRelations(relations) {
   fs.writeFileSync(relationsFile, JSON.stringify(relations, null, 2), 'utf8');
 }
 
-// Get all projects with stats
-function getProjects(config) {
+// Get all projects with stats (async version)
+async function getProjects(config) {
   const projectsDir = config.projectsDir;
 
   if (!fs.existsSync(projectsDir)) {
     return [];
   }
 
-  const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+  const entries = await fs.promises.readdir(projectsDir, { withFileTypes: true });
   return entries
     .filter(entry => entry.isDirectory())
     .map(entry => entry.name);
@@ -283,32 +284,43 @@ function extractCwdFromSessionHeader(sessionFile) {
   return null;
 }
 
-// Get projects with detailed stats (with caching)
-function getProjectsWithStats(config, options = {}) {
+// Get projects with detailed stats (with caching) - async version
+async function getProjectsWithStats(config, options = {}) {
   if (!options.force) {
+    // Check enhanced cache first
+    const cacheKey = `${CacheKeys.PROJECTS}${config.projectsDir}`;
+    const enhancedCached = globalCache.get(cacheKey);
+    if (enhancedCached) {
+      return enhancedCached;
+    }
+
+    // Check old cache
     const cached = getCachedProjects(config);
     if (cached) {
+      globalCache.set(cacheKey, cached, 300000); // 5分钟
       return cached;
     }
   }
 
-  const data = buildProjectsWithStats(config);
+  const data = await buildProjectsWithStats(config);
   setCachedProjects(config, data);
+  globalCache.set(`${CacheKeys.PROJECTS}${config.projectsDir}`, data, 300000);
   return data;
 }
 
-function buildProjectsWithStats(config) {
+async function buildProjectsWithStats(config) {
   const projectsDir = config.projectsDir;
 
   if (!fs.existsSync(projectsDir)) {
     return [];
   }
 
-  const entries = fs.readdirSync(projectsDir, { withFileTypes: true });
+  const entries = await fs.promises.readdir(projectsDir, { withFileTypes: true });
 
-  return entries
+  // Process all projects concurrently
+  const projectPromises = entries
     .filter(entry => entry.isDirectory())
-    .map(entry => {
+    .map(async (entry) => {
       const projectName = entry.name;
       const projectPath = path.join(projectsDir, projectName);
 
@@ -320,24 +332,29 @@ function buildProjectsWithStats(config) {
       let lastUsed = null;
 
       try {
-        const files = fs.readdirSync(projectPath);
+        const files = await fs.promises.readdir(projectPath);
         const jsonlFiles = files.filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
 
-        // Filter: only count sessions that have actual messages (not just file-history-snapshots)
-        const sessionFilesWithMessages = jsonlFiles.filter(f => {
-          const filePath = path.join(projectPath, f);
-          return hasActualMessages(filePath);
-        });
+        // Filter: only count sessions that have actual messages (in parallel)
+        const sessionChecks = await Promise.all(
+          jsonlFiles.map(async (f) => {
+            const filePath = path.join(projectPath, f);
+            const hasMessages = await hasActualMessages(filePath);
+            return hasMessages ? f : null;
+          })
+        );
 
+        const sessionFilesWithMessages = sessionChecks.filter(f => f !== null);
         sessionCount = sessionFilesWithMessages.length;
 
         // Find most recent session (only from sessions with messages)
         if (sessionFilesWithMessages.length > 0) {
-          const stats = sessionFilesWithMessages.map(f => {
+          const statPromises = sessionFilesWithMessages.map(async (f) => {
             const filePath = path.join(projectPath, f);
-            const stat = fs.statSync(filePath);
+            const stat = await fs.promises.stat(filePath);
             return stat.mtime.getTime();
           });
+          const stats = await Promise.all(statPromises);
           lastUsed = Math.max(...stats);
         }
       } catch (err) {
@@ -351,8 +368,10 @@ function buildProjectsWithStats(config) {
         sessionCount,
         lastUsed
       };
-    })
-    .sort((a, b) => (b.lastUsed || 0) - (a.lastUsed || 0)); // Sort by last used
+    });
+
+  const projects = await Promise.all(projectPromises);
+  return projects.sort((a, b) => (b.lastUsed || 0) - (a.lastUsed || 0)); // Sort by last used
 }
 
 // 获取 Claude 项目/会话数量（轻量统计）
@@ -383,16 +402,27 @@ function getProjectAndSessionCounts(config) {
   return { projectCount, sessionCount };
 }
 
-// Check if a session file has actual messages (not just file-history-snapshots)
-function hasActualMessages(filePath) {
+// Check if a session file has actual messages (async with enhanced caching)
+async function hasActualMessages(filePath) {
   try {
-    const stats = fs.statSync(filePath);
-    const cached = checkHasMessagesCache(filePath, stats);
+    const stats = await fs.promises.stat(filePath);
+
+    // Check enhanced cache first
+    const cacheKey = `${CacheKeys.HAS_MESSAGES}${filePath}:${stats.mtime.getTime()}`;
+    const cached = globalCache.get(cacheKey);
     if (typeof cached === 'boolean') {
       return cached;
     }
 
-    const result = scanSessionFileForMessages(filePath);
+    // Check old cache mechanism
+    const oldCached = checkHasMessagesCache(filePath, stats);
+    if (typeof oldCached === 'boolean') {
+      globalCache.set(cacheKey, oldCached, 600000); // 10分钟
+      return oldCached;
+    }
+
+    const result = await scanSessionFileForMessagesAsync(filePath);
+    globalCache.set(cacheKey, result, 600000);
     rememberHasMessages(filePath, stats, result);
     return result;
   } catch (err) {
@@ -434,30 +464,74 @@ function scanSessionFileForMessages(filePath) {
   }
 }
 
-// Get sessions for a project
-function getSessionsForProject(config, projectName) {
+// Async version using streams for better performance
+function scanSessionFileForMessagesAsync(filePath) {
+  return new Promise((resolve) => {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf8', highWaterMark: 64 * 1024 });
+    const pattern = /"type"\s*:\s*"(user|assistant|summary)"/;
+    let found = false;
+    let leftover = '';
+
+    stream.on('data', (chunk) => {
+      if (found) return;
+      const combined = leftover + chunk;
+      if (pattern.test(combined)) {
+        found = true;
+        stream.destroy();
+        resolve(true);
+      }
+      leftover = combined.slice(-64);
+    });
+
+    stream.on('end', () => {
+      if (!found) resolve(false);
+    });
+
+    stream.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+// Get sessions for a project - async version
+async function getSessionsForProject(config, projectName) {
+  // Check cache first
+  const cacheKey = `${CacheKeys.SESSIONS}${projectName}`;
+  const cached = globalCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+
   const projectConfig = { ...config, currentProject: projectName };
   const sessions = getAllSessions(projectConfig);
   const forkRelations = getForkRelations();
   const savedOrder = getSessionOrder(projectName);
 
-  // Parse session info and calculate total size, filter out sessions with no messages
+  // Parse session info and calculate total size, filter out sessions with no messages (in parallel)
   let totalSize = 0;
-  const sessionsWithInfo = sessions
-    .filter(session => hasActualMessages(session.filePath))
-    .map(session => {
-      const info = parseSessionInfoFast(session.filePath);
-      totalSize += session.size || 0;
-      return {
-        sessionId: session.sessionId,
-        mtime: session.mtime,
-        size: session.size,
-        filePath: session.filePath,
-        gitBranch: info.gitBranch || null,
-        firstMessage: info.firstMessage || null,
-        forkedFrom: forkRelations[session.sessionId] || null
-      };
-    });
+
+  const sessionChecks = await Promise.all(
+    sessions.map(async (session) => {
+      const hasMessages = await hasActualMessages(session.filePath);
+      return hasMessages ? session : null;
+    })
+  );
+
+  const validSessions = sessionChecks.filter(s => s !== null);
+
+  const sessionsWithInfo = validSessions.map(session => {
+    const info = parseSessionInfoFast(session.filePath);
+    totalSize += session.size || 0;
+    return {
+      sessionId: session.sessionId,
+      mtime: session.mtime,
+      size: session.size,
+      filePath: session.filePath,
+      gitBranch: info.gitBranch || null,
+      firstMessage: info.firstMessage || null,
+      forkedFrom: forkRelations[session.sessionId] || null
+    };
+  });
 
   // Apply saved order if exists
   let orderedSessions = sessionsWithInfo;
@@ -478,10 +552,14 @@ function getSessionsForProject(config, projectName) {
     orderedSessions = ordered;
   }
 
-  return {
+  const result = {
     sessions: orderedSessions,
     totalSize
   };
+
+  // Cache for 2 minutes
+  globalCache.set(cacheKey, result, 120000);
+  return result;
 }
 
 // Delete a session

package/src/server/services/skill-service.js

@@ -847,14 +847,14 @@ class SkillService {
 
       request.on('error', (err) => {
         file.close();
-        fs.unlink(dest, () => {});
+        fs.unlink(dest, () => { });
         reject(err);
       });
 
       request.on('timeout', () => {
         request.destroy();
         file.close();
-        fs.unlink(dest, () => {});
+        fs.unlink(dest, () => { });
         reject(new Error('Download timeout'));
       });
     });
@@ -912,6 +912,256 @@ ${content}
     return { success: true, message: '技能创建成功', directory };
   }
 
+  /**
+   * 创建带多文件的技能
+   * @param {string} directory - 技能目录名
+   * @param {Array<{path: string, content: string}>} files - 文件数组
+   * @returns {Object} 创建结果
+   */
+  createSkillWithFiles({ directory, files }) {
+    const dest = path.join(this.installDir, directory);
+
+    // 检查是否已存在
+    if (fs.existsSync(dest)) {
+      throw new Error(`技能目录 "${directory}" 已存在`);
+    }
+
+    // 验证必须包含 SKILL.md
+    const hasSkillMd = files.some(f =>
+      f.path === 'SKILL.md' || f.path.endsWith('/SKILL.md')
+    );
+    if (!hasSkillMd) {
+      throw new Error('技能必须包含 SKILL.md 文件');
+    }
+
+    // 创建目录
+    fs.mkdirSync(dest, { recursive: true });
+
+    // 写入所有文件
+    for (const file of files) {
+      const filePath = path.join(dest, file.path);
+      const fileDir = path.dirname(filePath);
+
+      // 确保父目录存在
+      if (!fs.existsSync(fileDir)) {
+        fs.mkdirSync(fileDir, { recursive: true });
+      }
+
+      // 写入文件内容
+      if (file.isBase64) {
+        // 二进制文件使用 base64 编码
+        fs.writeFileSync(filePath, Buffer.from(file.content, 'base64'));
+      } else {
+        fs.writeFileSync(filePath, file.content, 'utf-8');
+      }
+    }
+
+    // 清除缓存
+    this.skillsCache = null;
+    this.cacheTime = 0;
+
+    return {
+      success: true,
+      message: '技能创建成功',
+      directory,
+      fileCount: files.length
+    };
+  }
+
+  /**
+   * 获取技能目录下所有文件列表
+   * @param {string} directory - 技能目录名
+   * @returns {Array<{path: string, size: number, isDirectory: boolean}>}
+   */
+  getSkillFiles(directory) {
+    const skillPath = path.join(this.installDir, directory);
+
+    if (!fs.existsSync(skillPath)) {
+      throw new Error(`技能 "${directory}" 不存在`);
+    }
+
+    const files = [];
+    this._scanFilesRecursive(skillPath, skillPath, files);
+    return files;
+  }
+
+  /**
+   * 递归扫描目录获取文件列表
+   */
+  _scanFilesRecursive(currentDir, baseDir, files) {
+    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      const relativePath = path.relative(baseDir, fullPath);
+
+      if (entry.isDirectory()) {
+        files.push({
+          path: relativePath,
+          size: 0,
+          isDirectory: true
+        });
+        this._scanFilesRecursive(fullPath, baseDir, files);
+      } else {
+        const stats = fs.statSync(fullPath);
+        files.push({
+          path: relativePath,
+          size: stats.size,
+          isDirectory: false
+        });
+      }
+    }
+  }
+
+  /**
+   * 获取技能文件内容
+   * @param {string} directory - 技能目录名
+   * @param {string} filePath - 文件相对路径
+   * @returns {Object} 文件内容
+   */
+  getSkillFileContent(directory, filePath) {
+    const fullPath = path.join(this.installDir, directory, filePath);
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`文件 "${filePath}" 不存在`);
+    }
+
+    const stats = fs.statSync(fullPath);
+    if (stats.isDirectory()) {
+      throw new Error(`"${filePath}" 是目录，不是文件`);
+    }
+
+    // 判断是否是文本文件
+    const textExtensions = ['.md', '.txt', '.json', '.js', '.ts', '.py', '.sh', '.yaml', '.yml', '.toml', '.xml', '.html', '.css'];
+    const ext = path.extname(filePath).toLowerCase();
+    const isText = textExtensions.includes(ext);
+
+    if (isText) {
+      return {
+        path: filePath,
+        content: fs.readFileSync(fullPath, 'utf-8'),
+        isBase64: false,
+        size: stats.size
+      };
+    } else {
+      return {
+        path: filePath,
+        content: fs.readFileSync(fullPath).toString('base64'),
+        isBase64: true,
+        size: stats.size
+      };
+    }
+  }
+
+  /**
+   * 添加文件到现有技能
+   * @param {string} directory - 技能目录名
+   * @param {Array<{path: string, content: string, isBase64?: boolean}>} files - 文件数组
+   */
+  addSkillFiles(directory, files) {
+    const skillPath = path.join(this.installDir, directory);
+
+    if (!fs.existsSync(skillPath)) {
+      throw new Error(`技能 "${directory}" 不存在`);
+    }
+
+    const added = [];
+    for (const file of files) {
+      const filePath = path.join(skillPath, file.path);
+      const fileDir = path.dirname(filePath);
+
+      // 确保父目录存在
+      if (!fs.existsSync(fileDir)) {
+        fs.mkdirSync(fileDir, { recursive: true });
+      }
+
+      // 写入文件
+      if (file.isBase64) {
+        fs.writeFileSync(filePath, Buffer.from(file.content, 'base64'));
+      } else {
+        fs.writeFileSync(filePath, file.content, 'utf-8');
+      }
+      added.push(file.path);
+    }
+
+    // 清除缓存
+    this.skillsCache = null;
+    this.cacheTime = 0;
+
+    return { success: true, added };
+  }
+
+  /**
+   * 删除技能中的文件
+   * @param {string} directory - 技能目录名
+   * @param {string} filePath - 文件相对路径
+   */
+  deleteSkillFile(directory, filePath) {
+    const skillPath = path.join(this.installDir, directory);
+
+    if (!fs.existsSync(skillPath)) {
+      throw new Error(`技能 "${directory}" 不存在`);
+    }
+
+    // 不允许删除 SKILL.md
+    if (filePath === 'SKILL.md') {
+      throw new Error('不能删除 SKILL.md 文件');
+    }
+
+    const fullPath = path.join(skillPath, filePath);
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`文件 "${filePath}" 不存在`);
+    }
+
+    const stats = fs.statSync(fullPath);
+    if (stats.isDirectory()) {
+      fs.rmSync(fullPath, { recursive: true, force: true });
+    } else {
+      fs.unlinkSync(fullPath);
+    }
+
+    // 清除缓存
+    this.skillsCache = null;
+    this.cacheTime = 0;
+
+    return { success: true, deleted: filePath };
+  }
+
+  /**
+   * 更新技能文件内容
+   * @param {string} directory - 技能目录名
+   * @param {string} filePath - 文件相对路径
+   * @param {string} content - 新内容
+   * @param {boolean} isBase64 - 是否为 base64 编码
+   */
+  updateSkillFile(directory, filePath, content, isBase64 = false) {
+    const skillPath = path.join(this.installDir, directory);
+
+    if (!fs.existsSync(skillPath)) {
+      throw new Error(`技能 "${directory}" 不存在`);
+    }
+
+    const fullPath = path.join(skillPath, filePath);
+
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`文件 "${filePath}" 不存在`);
+    }
+
+    if (isBase64) {
+      fs.writeFileSync(fullPath, Buffer.from(content, 'base64'));
+    } else {
+      fs.writeFileSync(fullPath, content, 'utf-8');
+    }
+
+    // 清除缓存
+    this.skillsCache = null;
+    this.cacheTime = 0;
+
+    return { success: true, updated: filePath };
+  }
+
+
   /**
    * 卸载技能
    */

package/src/server/services/workspace-service.js

@@ -396,27 +396,44 @@ function deleteWorkspace(id, removeFiles = false) {
 
   const workspace = data.workspaces[index];
 
-  // 如果需要删除物理文件
-  if (removeFiles && fs.existsSync(workspace.path)) {
-    try {
-      // 清理 worktrees
-      for (const proj of workspace.projects) {
-        if (proj.worktrees && proj.worktrees.length > 0) {
-          for (const wt of proj.worktrees) {
-            if (fs.existsSync(wt.path)) {
-              try {
-                execSync(`git worktree remove "${wt.path}" --force`, {
-                  cwd: proj.sourcePath,
-                  stdio: 'pipe'
-                });
-              } catch (error) {
-                console.error(`删除 worktree 失败: ${wt.path}`, error.message);
+  // 清理 worktrees (无论是否删除工作区目录,都应该清理 worktree)
+  for (const proj of workspace.projects) {
+    if (proj.isGitRepo && proj.sourcePath && fs.existsSync(proj.sourcePath)) {
+      try {
+        // 重新扫描实际的 worktrees,确保获取最新状态
+        const actualWorktrees = getGitWorktrees(proj.sourcePath);
+        for (const wt of actualWorktrees) {
+          // 只删除属于这个工作区的 worktree (通过 -ws- 标识符识别)
+          if (wt.path && wt.path.includes('-ws-')) {
+            try {
+              console.log(`清理 worktree: ${wt.path}`);
+              execSync(`git worktree remove "${wt.path}" --force`, {
+                cwd: proj.sourcePath,
+                stdio: 'pipe'
+              });
+            } catch (error) {
+              console.error(`删除 worktree 失败: ${wt.path}`, error.message);
+              // 如果 git worktree remove 失败,尝试手动删除目录
+              if (fs.existsSync(wt.path)) {
+                try {
+                  fs.rmSync(wt.path, { recursive: true, force: true });
+                  console.log(`手动删除 worktree 目录: ${wt.path}`);
+                } catch (rmError) {
+                  console.error(`手动删除 worktree 目录失败: ${wt.path}`, rmError.message);
+                }
               }
             }
           }
         }
+      } catch (error) {
+        console.error(`扫描 worktree 失败: ${proj.sourcePath}`, error.message);
       }
+    }
+  }
 
+  // 如果需要删除物理文件
+  if (removeFiles && fs.existsSync(workspace.path)) {
+    try {
       // 删除工作区目录
       fs.rmSync(workspace.path, { recursive: true, force: true });
     } catch (error) {
@@ -620,10 +637,11 @@ function getAllAvailableProjects() {
       const projects = sessionsService.getProjectsWithStats(config, { force: true });
 
       for (const proj of projects) {
-        // 使用 fullPath 去重
+        // 使用 fullPath + channel 组合去重,允许同一项目在不同渠道显示
         const projectPath = proj.fullPath;
-        if (projectPath && !seenPaths.has(projectPath)) {
-          seenPaths.add(projectPath);
+        const projectKey = `${projectPath}:${channel.name}`;
+        if (projectPath && !seenPaths.has(projectKey)) {
+          seenPaths.add(projectKey);
           allProjects.push({
             name: proj.name,
             displayName: proj.displayName,

package/src/server/websocket-server.js

@@ -175,7 +175,10 @@ function startWebSocketServer(httpServer) {
       console.log(`✅ WebSocket server started on ws://127.0.0.1:${port}/ws`);
     }
 
-    wss.on('connection', (ws) => {
+    wss.on('connection', (ws, req) => {
+      const clientIp = req.socket.remoteAddress;
+      console.log(`[WebSocket] New connection from ${clientIp}`);
+
       wsClients.add(ws);
 
       // 标记客户端存活