@adversity/coding-tool-x 2.3.0 → 2.4.1

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

@@ -4,6 +4,7 @@ const path = require('path');
 const { execSync } = require('child_process');
 const { PATHS } = require('../../config/paths');
 const configTemplatesService = require('./config-templates-service');
+const permissionTemplatesService = require('./permission-templates-service');
 
 // 工作区配置文件路径
 const WORKSPACES_CONFIG = path.join(PATHS.base, 'workspaces.json');
@@ -299,73 +300,14 @@ function createWorkspace(options) {
       }
     }
 
-    // 应用权限模板（如果指定且不是 'none'）
+    // 应用权限模板（如果指定）
     let permissionInfo = null;
-    if (permissionTemplate && permissionTemplate !== 'none') {
+    if (permissionTemplate) {
       try {
-        const permissionTemplates = {
-          safe: {
-            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(*)'
-            ]
-          },
-          balanced: {
-            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:*)'
-            ]
-          },
-          permissive: {
-            allow: [
-              'Bash(*)',
-              'Read(*)',
-              'Edit(*)'
-            ],
-            deny: [
-              'Bash(rm -rf /*)',
-              'Bash(sudo rm -rf:*)'
-            ]
-          }
-        };
+        // 从权限模板服务获取模板
+        const template = permissionTemplatesService.getTemplateById(permissionTemplate);
 
-        const permSettings = permissionTemplates[permissionTemplate];
-        if (permSettings) {
+        if (template && template.permissions) {
           // 为工作区中的每个项目应用权限设置
           for (const proj of workspaceProjects) {
             const projSettingsDir = path.join(proj.targetPath, '.claude');
@@ -388,8 +330,8 @@ function createWorkspace(options) {
 
             // 更新权限设置
             settings.permissions = {
-              allow: permSettings.allow,
-              deny: permSettings.deny
+              allow: template.permissions.allow || [],
+              deny: template.permissions.deny || []
             };
 
             // 保存设置
@@ -454,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) {
@@ -678,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);
 
       // 标记客户端存活