@adversity/coding-tool-x 2.3.0 → 2.4.1

package/src/server/services/permission-templates-service.js

@@ -0,0 +1,339 @@
+/**
+ * Permission Templates Service
+ *
+ * 管理权限配置模版的 CRUD 操作
+ * 支持内置模版和自定义模版
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { PATHS } = require('../../config/paths');
+
+// 权限模版存储文件
+const TEMPLATES_FILE = path.join(PATHS.config, 'permission-templates.json');
+
+// 内置权限模版
+const BUILTIN_TEMPLATES = [
+  {
+    id: 'safe',
+    name: '安全模式',
+    description: '仅允许只读命令，危险操作需要确认',
+    permissions: {
+      allow: [
+        'Bash(cat:*)',
+        'Bash(ls:*)',
+        'Bash(pwd)',
+        'Bash(echo:*)',
+        'Bash(head:*)',
+        'Bash(tail:*)',
+        'Bash(grep:*)',
+        'Read(*)'
+      ],
+      deny: [
+        'Bash(rm:*)',
+        'Bash(sudo:*)',
+        'Bash(git push:*)',
+        'Bash(git reset --hard:*)',
+        'Bash(chmod:*)',
+        'Bash(chown:*)',
+        'Edit(*)'
+      ]
+    },
+    isBuiltin: true
+  },
+  {
+    id: 'balanced',
+    name: '平衡模式',
+    description: '允许常用开发命令，危险操作需要确认',
+    permissions: {
+      allow: [
+        'Bash(cat:*)',
+        'Bash(ls:*)',
+        'Bash(pwd)',
+        'Bash(echo:*)',
+        'Bash(head:*)',
+        'Bash(tail:*)',
+        'Bash(grep:*)',
+        'Bash(find:*)',
+        'Bash(git status)',
+        'Bash(git diff:*)',
+        'Bash(git log:*)',
+        'Bash(npm run:*)',
+        'Bash(pnpm:*)',
+        'Bash(yarn:*)',
+        'Read(*)',
+        'Edit(*)'
+      ],
+      deny: [
+        'Bash(rm -rf:*)',
+        'Bash(sudo:*)',
+        'Bash(git push --force:*)',
+        'Bash(git reset --hard:*)'
+      ]
+    },
+    isBuiltin: true
+  },
+  {
+    id: 'permissive',
+    name: '宽松模式',
+    description: '允许大多数命令，仅阻止极度危险的操作',
+    permissions: {
+      allow: [
+        'Bash(*)',
+        'Read(*)',
+        'Edit(*)'
+      ],
+      deny: [
+        'Bash(rm -rf /*)',
+        'Bash(sudo rm -rf:*)'
+      ]
+    },
+    isBuiltin: true
+  },
+  {
+    id: 'mcp-full',
+    name: 'MCP 全功能',
+    description: '允许所有 MCP 工具和常用命令，适合使用 MCP 服务器的项目',
+    permissions: {
+      allow: [
+        'Read(*)',
+        'Edit(*)',
+        'Bash(cat:*)',
+        'Bash(ls:*)',
+        'Bash(find:*)',
+        'Bash(grep:*)',
+        'Bash(tree:*)',
+        'Bash(git:*)',
+        'Bash(npm:*)',
+        'Bash(pnpm:*)',
+        'Bash(yarn:*)',
+        'WebSearch',
+        'mcp__Serena__*',
+        'mcp__fetch__fetch',
+        'mcp__memory__*',
+        'mcp__github__*',
+        'mcp__context7__*'
+      ],
+      deny: [
+        'Bash(rm -rf:*)',
+        'Bash(sudo:*)'
+      ]
+    },
+    isBuiltin: true
+  }
+];
+
+/**
+ * 确保配置目录存在
+ */
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+/**
+ * 加载所有模版（内置 + 自定义）
+ */
+/**
+ * 加载所有模版（内置 + 自定义）
+ * 内置模版可被用户覆盖修改
+ */
+/**
+ * 加载所有模版（内置 + 自定义）
+ * 内置模版可被用户覆盖修改或隐藏
+ */
+function loadTemplates() {
+  try {
+    if (fs.existsSync(TEMPLATES_FILE)) {
+      const content = fs.readFileSync(TEMPLATES_FILE, 'utf8');
+      const data = JSON.parse(content);
+      
+      // 分离自定义模版和隐藏标记
+      const customTemplates = (data.custom || []).filter(t => !t._hidden);
+      const hiddenIds = (data.custom || []).filter(t => t._hidden).map(t => t.id);
+      
+      const customIds = customTemplates.map(t => t.id);
+      
+      // 过滤掉已被自定义覆盖或隐藏的内置模版
+      const effectiveBuiltin = BUILTIN_TEMPLATES.filter(t => 
+        !customIds.includes(t.id) && !hiddenIds.includes(t.id)
+      );
+      
+      return {
+        builtin: effectiveBuiltin,
+        custom: customTemplates,
+        all: [...customTemplates, ...effectiveBuiltin] // 自定义优先
+      };
+    }
+  } catch (error) {
+    console.error('[PermissionTemplates] 加载模版失败:', error.message);
+  }
+
+  return {
+    builtin: BUILTIN_TEMPLATES,
+    custom: [],
+    all: BUILTIN_TEMPLATES
+  };
+}
+
+/**
+ * 保存自定义模版
+ */
+function saveCustomTemplates(customTemplates) {
+  ensureDir(PATHS.config);
+  fs.writeFileSync(TEMPLATES_FILE, JSON.stringify({ custom: customTemplates }, null, 2), 'utf8');
+}
+
+/**
+ * 获取所有模版
+ */
+/**
+ * 获取所有模版（合并后的最终列表）
+ */
+function getAllTemplates() {
+  const { all } = loadTemplates();
+  return all;
+}
+
+/**
+ * 根据 ID 获取模版
+ */
+function getTemplateById(id) {
+  const templates = getAllTemplates();
+  return templates.find(t => t.id === id) || null;
+}
+
+/**
+ * 创建自定义模版
+ */
+function createTemplate(template) {
+  const { custom } = loadTemplates();
+
+  // 验证必填字段
+  if (!template.name || !template.name.trim()) {
+    throw new Error('模版名称不能为空');
+  }
+
+  // 生成唯一 ID
+  const id = `custom-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+  const newTemplate = {
+    id,
+    name: template.name.trim(),
+    description: template.description || '',
+    permissions: {
+      allow: template.permissions?.allow || [],
+      deny: template.permissions?.deny || []
+    },
+    isBuiltin: false,
+    createdAt: new Date().toISOString()
+  };
+
+  custom.push(newTemplate);
+  saveCustomTemplates(custom);
+
+  return newTemplate;
+}
+
+/**
+ * 更新自定义模版
+ */
+/**
+ * 更新权限模版（包括内置模版）
+ * 编辑内置模版时，会在自定义列表中创建覆盖版本
+ */
+function updateTemplate(id, updates) {
+  const { custom, all } = loadTemplates();
+  
+  // 查找模版（先查自定义，再查所有）
+  const existingTemplate = all.find(t => t.id === id);
+  if (!existingTemplate) {
+    throw new Error('模版不存在');
+  }
+
+  // 验证名称
+  if (updates.name !== undefined && !updates.name.trim()) {
+    throw new Error('模版名称不能为空');
+  }
+
+  const updated = {
+    ...existingTemplate,
+    name: updates.name?.trim() ?? existingTemplate.name,
+    description: updates.description ?? existingTemplate.description,
+    permissions: updates.permissions ?? existingTemplate.permissions,
+    isBuiltin: false, // 编辑后标记为自定义（覆盖内置）
+    updatedAt: new Date().toISOString()
+  };
+
+  // 如果是编辑内置模版，则添加到自定义列表中（覆盖）
+  const customIndex = custom.findIndex(t => t.id === id);
+  if (customIndex !== -1) {
+    custom[customIndex] = updated;
+  } else {
+    custom.push(updated);
+  }
+  
+  saveCustomTemplates(custom);
+  return updated;
+}
+
+/**
+ * 删除自定义模版
+ */
+/**
+ * 删除权限模版（包括内置模版）
+ * 删除内置模版时，会在自定义列表中添加隐藏标记
+ */
+/**
+ * 删除权限模版（包括内置模版）
+ * 删除内置模版时，会在自定义列表中添加隐藏标记
+ */
+function deleteTemplate(id) {
+  try {
+    if (!fs.existsSync(TEMPLATES_FILE)) {
+      ensureDir(PATHS.config);
+      fs.writeFileSync(TEMPLATES_FILE, JSON.stringify({ custom: [] }, null, 2), 'utf8');
+    }
+    
+    const content = fs.readFileSync(TEMPLATES_FILE, 'utf8');
+    const data = JSON.parse(content);
+    const customList = data.custom || [];
+    
+    // 检查是否为内置模版
+    const isBuiltin = BUILTIN_TEMPLATES.some(t => t.id === id);
+    
+    if (isBuiltin) {
+      // 内置模版：添加隐藏标记
+      const hideMarker = {
+        id,
+        _hidden: true,
+        deletedAt: new Date().toISOString()
+      };
+      customList.push(hideMarker);
+      fs.writeFileSync(TEMPLATES_FILE, JSON.stringify({ custom: customList }, null, 2), 'utf8');
+    } else {
+      // 自定义模版：直接删除
+      const index = customList.findIndex(t => t.id === id && !t._hidden);
+      if (index === -1) {
+        throw new Error('模版不存在');
+      }
+      customList.splice(index, 1);
+      fs.writeFileSync(TEMPLATES_FILE, JSON.stringify({ custom: customList }, null, 2), 'utf8');
+    }
+
+    return true;
+  } catch (error) {
+    if (error.message === '模版不存在') throw error;
+    throw new Error('删除模版失败: ' + error.message);
+  }
+}
+
+module.exports = {
+  getAllTemplates,
+  getTemplateById,
+  createTemplate,
+  updateTemplate,
+  deleteTemplate,
+  BUILTIN_TEMPLATES
+};

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