@becrafter/prompt-manager 0.2.2 → 0.2.4-dev.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@becrafter/prompt-manager",
-  "version": "0.2.2",
+  "version": "0.2.4-dev.5",
   "description": "Remote MCP Server for managing prompts",
   "publishConfig": {
     "access": "public"
@@ -26,8 +26,8 @@
     "fix:pty": "npm rebuild node-pty",
     "help": "cd packages/server && node server.js --help",
     "build": "npm run build:admin-ui && npm run build:core",
-    "build:core": "cd packages/server && npx esbuild ./index.js --bundle --outdir=dist --format=esm --platform=node --target=node18",
-    "build:admin-ui": "cd packages/admin-ui && npx webpack --mode production",
+    "build:core": "cd packages/server && npm run build",
+    "build:admin-ui": "cd packages/admin-ui && npm run build",
     "build:desktop": "bash scripts/build.sh",
     "build:desktop:all": "bash scripts/build.sh build:all",
     "build:icons": "node ./scripts/build-icons.js",
@@ -60,6 +60,7 @@
     "clean:build": "bash scripts/clean-environment.sh build-only",
     "clean:reinstall": "npm run clean && npm install",
     "test:build": "bash scripts/build.sh test-build",
+    "test:npm-package": "node scripts/test-npm-package.js",
     "postinstall": "npm rebuild node-pty && chmod +x node_modules/node-pty/prebuilds/*/pty.node node_modules/node-pty/prebuilds/*/spawn-helper 2>/dev/null || true"
   },
   "keywords": [
@@ -88,7 +89,8 @@
     "node-fetch": "^3.3.2",
     "node-pty": "^1.0.0",
     "sharp": "^0.34.4",
-    "tar": "^7.5.1",
+    "sync-hub": "^0.0.3",
+    "tar": "^7.5.4",
     "to-ico": "^1.0.1",
     "ws": "^8.18.0",
     "yaml": "^2.4.1",
@@ -121,5 +123,14 @@
   },
   "devDependencies": {
     "@electron/rebuild": "^4.0.2"
+  },
+  "overrides": {
+    "form-data": "^4.0.1",
+    "lodash": "^4.17.21",
+    "minimist": "^1.2.8",
+    "qs": "^6.14.1",
+    "tough-cookie": "^4.1.4",
+    "jpeg-js": "^0.4.4",
+    "url-regex": "^5.0.0"
   }
 }

package/packages/server/api/admin.routes.js

@@ -4,9 +4,12 @@
 
 import express from 'express';
 import path from 'path';
+import os from 'os';
 import fs from 'fs';
 import fse from 'fs-extra';
 import yaml from 'js-yaml';
+import multer from 'multer';
+import AdmZip from 'adm-zip';
 import { spawn } from 'child_process';
 import { logger } from '../utils/logger.js';
 import { util, GROUP_META_FILENAME } from '../utils/util.js';
@@ -14,14 +17,99 @@ import { config } from '../utils/config.js';
 import { adminAuthMiddleware } from '../middlewares/auth.middleware.js';
 import { templateManager } from '../services/template.service.js';
 import { modelManager } from '../services/model.service.js';
+import { skillsManager } from '../services/skills.service.js';
 import { optimizationService } from '../services/optimization.service.js';
 import { webSocketService } from '../services/WebSocketService.js';
+import { skillSyncService } from '../services/skill-sync.service.js';
 
 const router = express.Router();
 
 // 获取prompts目录路径（在启动时可能被覆盖）
 const promptsDir = config.getPromptsDir();
 const PROMPT_NAME_REGEX = /^(?![.]{1,2}$)[^\\/:*?"<>|\r\n]{1,64}$/;
+const SKILL_NAME_REGEX = /^(?![.]{1,2}$)[^\\/:*?"<>|\r\n]{1,64}$/;
+const SKILL_MAX_FILE_SIZE = 10 * 1024 * 1024;
+const SKILL_MAX_FILES_COUNT = 50;
+const SKILL_MAX_TOTAL_SIZE = 100 * 1024 * 1024;
+
+const skillsUpload = multer({
+  storage: multer.diskStorage({
+    destination: (req, file, cb) => {
+      cb(null, os.tmpdir());
+    },
+    filename: (req, file, cb) => {
+      const timestamp = Date.now();
+      const safeName = file.originalname.replace(/[\\/:*?"<>|\s]+/g, '-');
+      cb(null, `skill-upload-${timestamp}-${safeName}`);
+    }
+  }),
+  limits: { fileSize: SKILL_MAX_FILE_SIZE },
+  fileFilter: (req, file, cb) => {
+    if (path.extname(file.originalname).toLowerCase() !== '.zip') {
+      return cb(new Error('仅支持上传 .zip 格式的技能包'));
+    }
+    cb(null, true);
+  }
+});
+
+function parseSkillFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    throw new Error('SKILL.md 必须包含 YAML 前置部分（以 --- 包裹）');
+  }
+  const frontmatterYaml = frontmatterMatch[1];
+  let frontmatter;
+  try {
+    frontmatter = yaml.load(frontmatterYaml);
+  } catch (error) {
+    throw new Error(`YAML 前置解析失败: ${error.message}`);
+  }
+  return frontmatter;
+}
+
+function shouldIgnoreUploadEntry(entryPath) {
+  const baseName = path.basename(entryPath);
+  if (baseName === '__MACOSX' || baseName === '.DS_Store') {
+    return true;
+  }
+  return entryPath.includes(`${path.sep}__MACOSX${path.sep}`);
+}
+
+async function collectSkillFiles(rootDir) {
+  const files = [];
+  let totalSize = 0;
+
+  const walk = async currentDir => {
+    const entries = await fse.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (shouldIgnoreUploadEntry(fullPath)) continue;
+
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+
+      const stats = await fse.stat(fullPath);
+      if (stats.size > SKILL_MAX_FILE_SIZE) {
+        throw new Error(`文件 "${entry.name}" 大小超过限制 (最大 10MB)`);
+      }
+
+      totalSize += stats.size;
+      if (totalSize > SKILL_MAX_TOTAL_SIZE) {
+        throw new Error('技能总大小超过限制 (最大 100MB)');
+      }
+
+      files.push(fullPath);
+      if (files.length > SKILL_MAX_FILES_COUNT) {
+        throw new Error(`文件数量超过限制 (最多 ${SKILL_MAX_FILES_COUNT} 个)`);
+      }
+    }
+  };
+
+  await walk(rootDir);
+  return files;
+}
 
 // 获取服务器配置端点
 router.get('/config', (req, res) => {
@@ -909,4 +997,301 @@ router.put('/optimization/config', adminAuthMiddleware, (req, res) => {
   }
 });
 
+// ==================== 技能管理路由 ====================
+
+// 获取所有技能
+router.get('/skills', adminAuthMiddleware, (req, res) => {
+  try {
+    const { search, type } = req.query;
+    let skills = skillsManager.getSkillsSummary();
+
+    // 应用搜索过滤
+    if (search) {
+      const searchLower = search.toLowerCase();
+      skills = skills.filter(
+        skill => skill.name.toLowerCase().includes(searchLower) || skill.description.toLowerCase().includes(searchLower)
+      );
+    }
+
+    // 应用类型过滤
+    if (type) {
+      skills = skills.filter(skill => skill.type === type);
+    }
+
+    // 按名称排序
+    skills.sort((a, b) => a.name.localeCompare(b.name, 'zh-CN'));
+
+    res.json(skills);
+  } catch (error) {
+    logger.error('获取技能列表失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 重新加载技能
+router.post('/skills/reload', adminAuthMiddleware, async (req, res) => {
+  try {
+    const result = await skillsManager.reloadSkills();
+    res.json({ message: '技能加载成功', ...result });
+  } catch (error) {
+    logger.error('重新加载技能失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 上传技能包
+router.post('/skills/upload', adminAuthMiddleware, skillsUpload.single('file'), async (req, res) => {
+  const cleanupPaths = [];
+  try {
+    if (!req.file) {
+      return res.status(400).json({ error: '未接收到上传文件' });
+    }
+
+    // 创建解压目录
+    const extractDir = await fse.mkdtemp(path.join(os.tmpdir(), 'skill-upload-'));
+    cleanupPaths.push(extractDir);
+    cleanupPaths.push(req.file.path);
+
+    // 解压 ZIP
+    const zip = new AdmZip(req.file.path);
+    zip.extractAllTo(extractDir, true);
+
+    // 检测根目录结构
+    const entries = await fse.readdir(extractDir, { withFileTypes: true });
+    const validEntries = entries.filter(entry => !shouldIgnoreUploadEntry(entry.name));
+
+    let skillRootDir = extractDir;
+    let skillName = null;
+    let frontmatter = null;
+
+    if (validEntries.length === 1 && validEntries[0].isDirectory()) {
+      // 格式2：包含根目录
+      skillRootDir = path.join(extractDir, validEntries[0].name);
+      skillName = validEntries[0].name;
+    }
+
+    const skillMdPath = path.join(skillRootDir, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath)) {
+      return res.status(400).json({ error: '技能包缺少 SKILL.md 文件' });
+    }
+
+    const skillMdContent = await fse.readFile(skillMdPath, 'utf8');
+    frontmatter = parseSkillFrontmatter(skillMdContent);
+    skillsManager.validateSkillFrontmatter(frontmatter);
+
+    if (!skillName) {
+      // 格式1：从 SKILL.md 提取名称
+      skillName = frontmatter?.name;
+    }
+
+    if (!skillName) {
+      return res.status(400).json({ error: '无法解析技能名称' });
+    }
+
+    if (!SKILL_NAME_REGEX.test(skillName)) {
+      return res.status(400).json({ error: '技能名称格式无效' });
+    }
+
+    // 校验文件数量和大小
+    await collectSkillFiles(skillRootDir);
+
+    const targetDir = path.join(config.getSkillsDir(), skillName);
+    const overwrite = req.body?.overwrite === 'true';
+
+    if (fs.existsSync(targetDir)) {
+      if (!overwrite) {
+        return res.status(409).json({
+          error: '技能已存在',
+          canOverwrite: true,
+          skillName
+        });
+      }
+      await fse.remove(targetDir);
+    }
+
+    await fse.copy(skillRootDir, targetDir, {
+      filter: src => !shouldIgnoreUploadEntry(src)
+    });
+
+    await skillsManager.reloadSkills();
+
+    res.json({
+      success: true,
+      skillName
+    });
+  } catch (error) {
+    logger.error('上传技能包失败:', error);
+    res.status(400).json({ error: error.message || '上传失败' });
+  } finally {
+    await Promise.all(
+      cleanupPaths.map(async filePath => {
+        try {
+          await fse.remove(filePath);
+        } catch (cleanupError) {
+          logger.warn('清理临时文件失败:', cleanupError.message);
+        }
+      })
+    );
+  }
+});
+
+// 获取单个技能
+router.get('/skills/:id', adminAuthMiddleware, (req, res) => {
+  try {
+    const skill = skillsManager.getSkill(req.params.id);
+
+    if (!skill) {
+      return res.status(404).json({ error: `技能 "${req.params.id}" 未找到` });
+    }
+
+    // 读取原始文件内容
+    const rawContent = fs.readFileSync(skill.filePath, 'utf8');
+
+    res.json({
+      ...skill,
+      rawContent
+    });
+  } catch (error) {
+    logger.error('获取技能失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 创建技能
+router.post('/skills', adminAuthMiddleware, async (req, res) => {
+  try {
+    const { name, frontmatter, markdown, files } = req.body;
+
+    if (!name || !frontmatter) {
+      return res.status(400).json({ error: '名称和前置元数据是必需的' });
+    }
+
+    const skill = await skillsManager.createSkill({ name, frontmatter, markdown, files });
+    res.json(skill);
+  } catch (error) {
+    logger.error('创建技能失败:', error);
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 更新技能
+router.put('/skills/:id', adminAuthMiddleware, async (req, res) => {
+  try {
+    const { frontmatter, markdown, files } = req.body;
+    const skill = await skillsManager.updateSkill(req.params.id, { frontmatter, markdown, files });
+    res.json(skill);
+  } catch (error) {
+    if (error.message.includes('不存在') || error.message.includes('不能修改')) {
+      return res.status(404).json({ error: error.message });
+    }
+    logger.error('更新技能失败:', error);
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 删除技能
+router.delete('/skills/:id', adminAuthMiddleware, async (req, res) => {
+  try {
+    await skillsManager.deleteSkill(req.params.id);
+    res.json({ message: '技能删除成功' });
+  } catch (error) {
+    if (error.message.includes('不存在')) {
+      return res.status(404).json({ error: error.message });
+    }
+    logger.error('删除技能失败:', error);
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 复制技能
+router.post('/skills/:id/duplicate', adminAuthMiddleware, async (req, res) => {
+  try {
+    const { newName } = req.body;
+    if (!newName) {
+      return res.status(400).json({ error: '新名称是必需的' });
+    }
+    const skill = await skillsManager.duplicateSkill(req.params.id, newName);
+    res.json(skill);
+  } catch (error) {
+    if (error.message.includes('不存在')) {
+      return res.status(404).json({ error: error.message });
+    }
+    logger.error('复制技能失败:', error);
+    res.status(400).json({ error: error.message });
+  }
+});
+
+// 验证技能格式
+router.post('/skills/validate', adminAuthMiddleware, (req, res) => {
+  try {
+    const { content } = req.body;
+
+    if (!content) {
+      return res.status(400).json({ error: '技能内容是必需的' });
+    }
+
+    const skill = skillsManager.parseSkillContent(content);
+    res.json({ valid: true, skill });
+  } catch (error) {
+    res.status(400).json({
+      valid: false,
+      error: error.message,
+      suggestion: '确保 SKILL.md 包含正确的 YAML 前置部分（以 --- 包裹）和 Markdown 内容'
+    });
+  }
+});
+
+// 导出技能
+router.get('/skills/:id/export', adminAuthMiddleware, async (req, res) => {
+  try {
+    const { buffer, fileName } = await skillsManager.exportSkill(req.params.id);
+
+    res.setHeader('Content-Type', 'application/zip');
+    res.setHeader('Content-Disposition', `attachment; filename="${encodeURIComponent(fileName)}"`);
+    res.send(buffer);
+  } catch (error) {
+    if (error.message.includes('不存在')) {
+      return res.status(404).json({ error: error.message });
+    }
+    logger.error('导出技能失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// ==================== 技能同步路由 ====================
+
+// 获取同步配置
+router.get('/skill-sync/config', adminAuthMiddleware, (req, res) => {
+  try {
+    const config = skillSyncService.getConfig();
+    res.json(config);
+  } catch (error) {
+    logger.error('获取技能同步配置失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 更新同步配置
+router.post('/skill-sync/config', adminAuthMiddleware, async (req, res) => {
+  try {
+    const newConfig = req.body;
+    await skillSyncService.updateConfig(newConfig);
+    res.json({ message: '同步配置已更新', config: skillSyncService.getConfig() });
+  } catch (error) {
+    logger.error('更新技能同步配置失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// 手动执行同步
+router.post('/skill-sync/run', adminAuthMiddleware, async (req, res) => {
+  try {
+    const results = await skillSyncService.runSync();
+    res.json({ message: '同步已执行', results });
+  } catch (error) {
+    logger.error('手动执行技能同步失败:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 export const adminRouter = router;

package/packages/server/mcp/prompt.handler.js

@@ -133,8 +133,8 @@ export async function handleReloadPrompts(_args) {
 
 /**
  * 格式化搜索结果
- * @param {*} results
- * @returns
+ * @param {Array} results
+ * @returns {Array}
  */
 function formatResults(results = []) {
   if (!Array.isArray(results)) return [];
@@ -161,8 +161,8 @@ function formatResults(results = []) {
 
 /**
  * 处理列表格式输出
- * @param {*} result
- * @returns
+ * @param {Object} result
+ * @returns {string}
  */
 function formatListOutput(result) {
   // 生成当前时间戳
@@ -244,9 +244,9 @@ function formatDetailOutput(result) {
 
 /**
  * 将对象转换为格式化的text类型输出
- * @param {*} result
+ * @param {Object} result
  * @param {string} format - 输出格式类型: 'list' 或 'detail'
- * @returns
+ * @returns {Object}
  */
 function convertToText(result, format) {
   let ret = '';

package/packages/server/server.js

@@ -7,6 +7,7 @@ import { syncSystemTools } from './toolm/tool-sync.service.js';
 import { syncAuthorConfig } from './toolm/author-sync.service.js';
 import { startLogCleanupTask } from './toolm/tool-logger.service.js';
 import { webSocketService } from './services/WebSocketService.js';
+import { skillSyncService } from './services/skill-sync.service.js';
 import { checkPortAvailable } from './utils/port-checker.js';
 
 // 动态导入 promptManager，以处理 Electron 打包后的路径问题
@@ -122,6 +123,18 @@ export async function startServer(options = {}) {
         logger.warn('加载优化模型失败，继续启动服务', { error: error.message });
       }
 
+      // 加载技能
+      try {
+        const { skillsManager } = await import('./services/skills.service.js');
+        await skillsManager.loadSkills();
+        logger.info('技能加载完成');
+
+        // 初始化技能同步服务
+        await skillSyncService.init();
+      } catch (error) {
+        logger.warn('加载技能或初始化同步服务失败，继续启动服务', { error: error.message });
+      }
+
       // 同步系统工具到沙箱环境
       try {
         await syncSystemTools();

package/packages/server/services/TerminalService.js

@@ -8,8 +8,10 @@
 import { spawn } from 'child_process';
 import { randomUUID } from 'crypto';
 import { logger } from '../utils/logger.js';
+import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { fileURLToPath } from 'url';
 
 // 延迟加载 node-pty，避免编译错误
 let pty = null;
@@ -244,22 +246,19 @@ export class TerminalService {
    */
   async fixNodePtyPermissions() {
     try {
-      const { execSync } = await import('child_process');
       const platform = process.platform;
 
       // 只在 Unix-like 系统上修复权限（macOS, Linux）
       if (platform !== 'win32') {
         logger.info('🔧 检查并修复 node-pty 二进制文件权限...');
 
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+
         // 尝试多个可能的 node-pty 路径
         const possiblePaths = [
           // 路径1: 在包的 node_modules 中（开发环境）
-          path.join(
-            path.dirname(path.dirname(new URL(import.meta.url).pathname)),
-            'node_modules',
-            'node-pty',
-            'prebuilds'
-          ),
+          path.join(path.dirname(__dirname), 'node_modules', 'node-pty', 'prebuilds'),
           // 路径2: 在根 node_modules 中（npm 安装环境）
           path.join(process.cwd(), 'node_modules', 'node-pty', 'prebuilds'),
           // 路径3: 相对于当前工作目录
@@ -274,8 +273,16 @@ export class TerminalService {
           )
         ];
 
+        // 路径4: Electron 打包环境（app.asar.unpacked / resources）
+        if (process.resourcesPath) {
+          possiblePaths.push(
+            path.join(process.resourcesPath, 'app.asar.unpacked', 'node_modules', 'node-pty', 'prebuilds'),
+            path.join(process.resourcesPath, 'app.asar.unpacked', 'app', 'node_modules', 'node-pty', 'prebuilds'),
+            path.join(process.resourcesPath, 'node_modules', 'node-pty', 'prebuilds')
+          );
+        }
+
         let ptyPath = null;
-        const fs = await import('fs');
 
         for (const possiblePath of possiblePaths) {
           if (fs.existsSync(possiblePath)) {
@@ -286,14 +293,27 @@ export class TerminalService {
 
         if (ptyPath) {
           try {
-            // 添加执行权限 - 使用 find 命令来处理所有平台
-            execSync(
-              `find ${ptyPath} -type f -name "*.node" -o -name "spawn-helper" | xargs chmod +x 2>/dev/null || true`,
-              {
-                stdio: 'pipe',
-                timeout: 5000
+            // 递归修复 .node 与 spawn-helper 权限，避免空格路径问题
+            const fixPermissionsRecursive = async targetPath => {
+              const entries = await fs.promises.readdir(targetPath, { withFileTypes: true });
+              for (const entry of entries) {
+                const entryPath = path.join(targetPath, entry.name);
+                if (entry.isDirectory()) {
+                  await fixPermissionsRecursive(entryPath);
+                  continue;
+                }
+
+                if (entry.isFile() && (entry.name.endsWith('.node') || entry.name === 'spawn-helper')) {
+                  try {
+                    await fs.promises.chmod(entryPath, 0o755);
+                  } catch (error) {
+                    logger.debug(`node-pty 权限修复失败: ${entryPath} - ${error.message}`);
+                  }
+                }
               }
-            );
+            };
+
+            await fixPermissionsRecursive(ptyPath);
             logger.info('✅ node-pty 权限修复完成');
           } catch (error) {
             // 静默失败，不影响服务启动
@@ -674,8 +694,8 @@ export class TerminalService {
 
     for (const session of this.sessions.values()) {
       if (!session.isActive || now - session.lastActivity > timeoutMs) {
-        logger.info(`Cleaning up inactive session: ${session.sessionId}`);
-        this.removeSession(session.sessionId);
+        logger.info(`Cleaning up inactive session: ${session.id}`);
+        this.removeSession(session.id);
       }
     }
   }