@becrafter/prompt-manager 0.1.31 → 0.2.3-alpha.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@becrafter/prompt-manager",
-  "version": "0.1.31",
+  "version": "0.2.3-alpha.7",
   "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": "npm run build --prefix packages/server",
-    "build:admin-ui": "npm run build --prefix packages/admin-ui",
+    "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",
@@ -47,12 +47,19 @@
     "format:check": "cd packages/server && npm run format:check",
     "verify": "npm run verify:publish",
     "verify:publish": "node scripts/verify-publish.js",
+    "verify:build": "node scripts/verify-build.js",
     "release:pre-check": "node scripts/pre-release-check.js",
     "release:update-version": "node scripts/update-version.js",
     "release:rollback": "node scripts/rollback-release.js rollback",
     "check:deps": "bash scripts/check-dependencies.sh",
     "check:env": "bash scripts/check-env.sh",
     "setup:env": "node scripts/preinstall-check.js",
+    "clean": "bash scripts/clean-environment.sh",
+    "clean:cache": "bash scripts/clean-environment.sh cache-only",
+    "clean:deps": "bash scripts/clean-environment.sh deps-only",
+    "clean:build": "bash scripts/clean-environment.sh build-only",
+    "clean:reinstall": "npm run clean && npm install",
+    "test:build": "bash scripts/build.sh test-build",
     "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": [
@@ -81,7 +88,7 @@
     "node-fetch": "^3.3.2",
     "node-pty": "^1.0.0",
     "sharp": "^0.34.4",
-    "tar": "^7.5.1",
+    "tar": "^7.5.4",
     "to-ico": "^1.0.1",
     "ws": "^8.18.0",
     "yaml": "^2.4.1",
@@ -114,5 +121,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/resources/tools/agent-browser/agent-browser.tool.js

@@ -795,7 +795,7 @@ export default {
         return { dragged: { from: params.source, to: params.target } };
 
       case 'screenshot':
-        const page = browser.getPage();
+        const screenshotPage = browser.getPage();
         const screenshotOptions = {};
         if (params.fullPage) screenshotOptions.fullPage = true;
         if (params.screenshotFormat) screenshotOptions.type = params.screenshotFormat;
@@ -806,7 +806,7 @@ export default {
           const buffer = await locator.screenshot(screenshotOptions);
           return { buffer: buffer.toString('base64'), selector: params.selector };
         } else {
-          const buffer = await page.screenshot(screenshotOptions);
+          const buffer = await screenshotPage.screenshot(screenshotOptions);
           if (params.screenshotPath) {
             const fs = await import('fs');
             fs.writeFileSync(params.screenshotPath, buffer);
@@ -908,60 +908,60 @@ export default {
 
       case 'getbyrole':
         if (params.role && params.subaction) {
-          const page = browser.getPage();
-          const locator = page.getByRole(params.role, { name: params.name });
+          const rolePage = browser.getPage();
+          const locator = rolePage.getByRole(params.role, { name: params.name });
           await this.executeSubaction(locator, params.subaction, params.value);
         }
         return { role: params.role, name: params.name };
 
       case 'getbytext':
         if (params.text && params.subaction) {
-          const page = browser.getPage();
+          const textPage = browser.getPage();
           const options = {};
           if (params.exact !== undefined) options.exact = params.exact;
-          const locator = page.getByText(params.text, options);
+          const locator = textPage.getByText(params.text, options);
           await this.executeSubaction(locator, params.subaction);
         }
         return { text: params.text };
 
       case 'getbylabel':
         if (params.label && params.subaction) {
-          const page = browser.getPage();
-          const locator = page.getByLabel(params.label);
+          const labelPage = browser.getPage();
+          const locator = labelPage.getByLabel(params.label);
           await this.executeSubaction(locator, params.subaction, params.value);
         }
         return { label: params.label };
 
       case 'getbyplaceholder':
         if (params.placeholder && params.subaction) {
-          const page = browser.getPage();
-          const locator = page.getByPlaceholder(params.placeholder);
+          const placeholderPage = browser.getPage();
+          const locator = placeholderPage.getByPlaceholder(params.placeholder);
           await this.executeSubaction(locator, params.subaction, params.value);
         }
         return { placeholder: params.placeholder };
 
       case 'getbyalttext':
         if (params.altText && params.subaction) {
-          const page = browser.getPage();
-          const locator = page.getByAltText(params.altText);
+          const altTextPage = browser.getPage();
+          const locator = altTextPage.getByAltText(params.altText);
           await this.executeSubaction(locator, params.subaction);
         }
         return { altText: params.altText };
 
       case 'getbytitle':
         if (params.name && params.subaction) {
-          const page = browser.getPage();
+          const titlePage = browser.getPage();
           const options = {};
           if (params.exact !== undefined) options.exact = params.exact;
-          const locator = page.getByTitle(params.name, options);
+          const locator = titlePage.getByTitle(params.name, options);
           await this.executeSubaction(locator, params.subaction);
         }
         return { title: params.name };
 
       case 'getbytestid':
         if (params.testId && params.subaction) {
-          const page = browser.getPage();
-          const locator = page.getByTestId(params.testId);
+          const testIdPage = browser.getPage();
+          const locator = testIdPage.getByTestId(params.testId);
           await this.executeSubaction(locator, params.subaction, params.value);
         }
         return { testId: params.testId };
@@ -1199,7 +1199,8 @@ export default {
       case 'download':
         if (params.selector && params.downloadPath) {
           const locator = browser.getLocator(params.selector);
-          const downloadPromise = page.waitForEvent('download');
+          const downloadPage = browser.getPage();
+          const downloadPromise = downloadPage.waitForEvent('download');
           await locator.click();
           const download = await downloadPromise;
           await download.saveAs(params.downloadPath);

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();