@becrafter/prompt-manager 0.1.22 → 0.2.2

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

@@ -7,82 +7,88 @@ import { util } from '../utils/util.js';
 export async function handleGetPrompt(args) {
   // 注意：这里为了兼容性，我们同时支持prompt_id和name参数
   const promptId = args.prompt_id || args.name;
-  
+
   if (!promptId) {
-    throw new Error("缺少必需参数: prompt_id");
+    throw new Error('缺少必需参数: prompt_id');
   }
-  
+
   const promptManager = await util.getPromptManager();
   const prompt = promptManager.getPrompt(promptId);
   if (!prompt) {
     throw new Error(`未找到ID为 "${promptId}" 的prompt`);
   }
-  
+
   // 返回完整的prompt信息
   const promptInfo = {
-    id: prompt.uniqueId,        // 使用基于文件路径的唯一ID
+    id: prompt.uniqueId, // 使用基于文件路径的唯一ID
     name: prompt.name,
     description: prompt.description || `Prompt: ${prompt.name}`,
     messages: prompt.messages || [],
     arguments: prompt.arguments || [],
-    filePath: prompt.relativePath,  // 添加文件路径信息
+    filePath: prompt.relativePath // 添加文件路径信息
   };
 
   if (config.getLogLevel() === 'debug') {
     promptInfo.metadata = {
       uniqueId: prompt.uniqueId,
       fileName: prompt.fileName,
-      fullPath: prompt.filePath,
+      fullPath: prompt.filePath
     };
   }
 
-  return convertToText({
-    success: true,
-    prompt: promptInfo
-  }, 'detail');
+  return convertToText(
+    {
+      success: true,
+      prompt: promptInfo
+    },
+    'detail'
+  );
 }
 
 // 处理 search_prompts 工具调用
 export async function handleSearchPrompts(args) {
   // 注意：这里为了兼容性，我们同时支持title和name参数
   const searchTerm = args.title || args.name;
-  
+
   const logLevel = config.getLogLevel();
   const promptManager = await util.getPromptManager();
-  let allPrompts = (await promptManager.loadPrompts()).prompts || [];
+  const allPrompts = (await promptManager.loadPrompts()).prompts || [];
 
   // 如果搜索词为空，则返回所有提示词
   if (!searchTerm) {
-    let simplifiedPrompts = formatResults(allPrompts);
+    const simplifiedPrompts = formatResults(allPrompts);
 
-    return convertToText({
-      success: true,
-      query: searchTerm || '',
-      count: simplifiedPrompts.length,
-      results: simplifiedPrompts
-    }, 'list');
+    return convertToText(
+      {
+        success: true,
+        query: searchTerm || '',
+        count: simplifiedPrompts.length,
+        results: simplifiedPrompts
+      },
+      'list'
+    );
   }
-  
+
   // 实现相似度匹配算法
-  const searchResults = allPrompts.map(prompt => {
-    prompt.description = prompt.description || `Prompt: ${prompt.name}`;
-    prompt.arguments = prompt.arguments || [];
-    prompt.hasArguments = prompt.arguments && prompt.arguments.length > 0;
-    return {
-      prompt: prompt,
-      score: util.calculateSimilarityScore(searchTerm, prompt),
-    };
-  })
-  .filter(result => result.score > 0) // 只返回有匹配的结果
-  .sort((a, b) => b.score - a.score); // 按相似度得分降序排列
-  
+  const searchResults = allPrompts
+    .map(prompt => {
+      prompt.description = prompt.description || `Prompt: ${prompt.name}`;
+      prompt.arguments = prompt.arguments || [];
+      prompt.hasArguments = prompt.arguments && prompt.arguments.length > 0;
+      return {
+        prompt,
+        score: util.calculateSimilarityScore(searchTerm, prompt)
+      };
+    })
+    .filter(result => result.score > 0) // 只返回有匹配的结果
+    .sort((a, b) => b.score - a.score); // 按相似度得分降序排列
 
-  let result = {
+  const result = {
     success: true,
     query: searchTerm || '',
     count: searchResults.length,
-    results: formatResults(searchResults),
-  }
+    results: formatResults(searchResults)
+  };
 
   if (logLevel === 'debug') {
     result.debug = {
@@ -90,9 +96,9 @@ export async function handleSearchPrompts(args) {
         id: result.prompt.id,
         name: result.prompt.name,
         score: result.score,
-        fullPath: result.prompt.filePath,
+        fullPath: result.prompt.filePath
       }))
-    }
+    };
   }
 
   return convertToText(result, 'list');
@@ -101,21 +107,25 @@ export async function handleSearchPrompts(args) {
 /**
  * 处理 reload_prompts 工具调用
  */
-export async function handleReloadPrompts(args) {
+export async function handleReloadPrompts(_args) {
   logger.info('重新加载prompts...');
-  
+
   const promptManager = await util.getPromptManager();
   const result = await promptManager.reloadPrompts();
-  
+
   return {
     content: [
       {
-        type: "text",
-        text: JSON.stringify({
-          success: true,
-          message: `重新加载完成: 成功 ${result.success} 个, 失败 ${result.errorCount} 个`,
-          result: formatResults(result.prompts)
-        }, null, 2)
+        type: 'text',
+        text: JSON.stringify(
+          {
+            success: true,
+            message: `重新加载完成: 成功 ${result.success} 个, 失败 ${result.errorCount} 个`,
+            result: formatResults(result.prompts)
+          },
+          null,
+          2
+        )
       }
     ]
   };
@@ -123,8 +133,8 @@ export async function handleReloadPrompts(args) {
 
 /**
  * 格式化搜索结果
- * @param {*} results 
- * @returns 
+ * @param {*} results
+ * @returns
  */
 function formatResults(results = []) {
   if (!Array.isArray(results)) return [];
@@ -151,23 +161,23 @@ function formatResults(results = []) {
 
 /**
  * 处理列表格式输出
- * @param {*} result 
- * @returns 
+ * @param {*} result
+ * @returns
  */
 function formatListOutput(result) {
   // 生成当前时间戳
   const now = new Date();
   const formattedDate = `${now.getFullYear()}/${(now.getMonth() + 1).toString().padStart(2, '0')}/${now.getDate().toString().padStart(2, '0')} ${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
-  
+
   // 构建新的输出格式
-  let output = "";
-  output += "[PROMPT_HEADER_AREA]\n";
-  output += "🎭 **PromptManager 提示词清单**\n";
+  let output = '';
+  output += '[PROMPT_HEADER_AREA]\n';
+  output += '🎭 **PromptManager 提示词清单**\n';
   output += `📅 ${formattedDate}\n\n`;
-  output += "--------------------------------------------------\n";
-  output += "[PROMPT_LIST_AREA]\n\n";
+  output += '--------------------------------------------------\n';
+  output += '[PROMPT_LIST_AREA]\n\n';
   output += `📦 **提示词列表** (${result.count}个)\n`;
-  
+
   // 添加提示词列表
   if (result.results && Array.isArray(result.results) && result.results.length > 0) {
     result.results.forEach(prompt => {
@@ -175,75 +185,71 @@ function formatListOutput(result) {
       output += `  - ${prompt.description}\n`;
     });
   } else {
-    output += "(无提示词)\n";
+    output += '(无提示词)\n';
   }
-  
-  output += "\n--------------------------------------------------\n";
-  output += "[STATE_AREA]\n";
-  output += "📍 **当前状态**：prompts_completed\n";
-  
+
+  output += '\n--------------------------------------------------\n';
+  output += '[STATE_AREA]\n';
+  output += '📍 **当前状态**：prompts_completed\n';
+
   // 返回格式化文本
   return output;
 }
 
 /**
  * 处理详情格式输出
- * @param {*} result 
+ * @param {*} result
  * @returns string
  */
 function formatDetailOutput(result) {
   const prompt = result.prompt;
-  
-  // 生成当前时间戳
-  const now = new Date();
-  const formattedDate = `${now.getFullYear()}/${(now.getMonth() + 1).toString().padStart(2, '0')}/${now.getDate().toString().padStart(2, '0')} ${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
-  
+
   // 构建新的输出格式
-  let output = "";
-  output += "--------------------------------------------------\n";
-  output += "[PROMPT_HEADER_AREA]\n";
+  let output = '';
+  output += '--------------------------------------------------\n';
+  output += '[PROMPT_HEADER_AREA]\n';
   output += `- id: ${prompt.id}\n`;
   output += `- name: ${prompt.name}\n`;
   output += `- description: ${prompt.description}\n`;
   output += `- filepath: ${prompt.filePath}\n\n`;
-  output += "--------------------------------------------------\n";
-  output += "[PROMPT_PARAMS_AREA]\n";
-  
+  output += '--------------------------------------------------\n';
+  output += '[PROMPT_PARAMS_AREA]\n';
+
   // 添加参数信息
   if (prompt.arguments && Array.isArray(prompt.arguments) && prompt.arguments.length > 0) {
     prompt.arguments.forEach(param => {
-      const requiredText = param.required ? "必填" : "非必填";
+      const requiredText = param.required ? '必填' : '非必填';
       output += `- ${param.name}: ${param.type}; ${requiredText}; ${param.description}\n`;
     });
   } else {
-    output += "(无参数)\n";
+    output += '(无参数)\n';
   }
-  
-  output += "\n--------------------------------------------------\n";
-  output += "[PROMPT_CONTENT_AREA]\n";
-  
+
+  output += '\n--------------------------------------------------\n';
+  output += '[PROMPT_CONTENT_AREA]\n';
+
   // 添加消息内容
   if (prompt.messages && Array.isArray(prompt.messages)) {
-    const userMessages = prompt.messages.filter(msg => msg.role !== "");
+    const userMessages = prompt.messages.filter(msg => msg.role !== '');
     if (userMessages.length > 0 && userMessages[0].content && userMessages[0].content.text) {
-      output += userMessages[0].content.text + "\n";
+      output += `${userMessages[0].content.text}\n`;
     }
   }
-  
-  output += "\n[STATE_AREA]\n";
-  output += "📍 **当前状态**：prompt_loaded\n";
-  
+
+  output += '\n[STATE_AREA]\n';
+  output += '📍 **当前状态**：prompt_loaded\n';
+
   return output;
 }
 
 /**
  * 将对象转换为格式化的text类型输出
- * @param {*} result 
+ * @param {*} result
  * @param {string} format - 输出格式类型: 'list' 或 'detail'
- * @returns 
+ * @returns
  */
 function convertToText(result, format) {
-  let ret = ""
+  let ret = '';
   switch (format) {
     case 'list':
       ret = formatListOutput(result);
@@ -252,12 +258,12 @@ function convertToText(result, format) {
       ret = formatDetailOutput(result);
       break;
     default:
-      ret =JSON.stringify(result, null, 2);
+      ret = JSON.stringify(result, null, 2);
   }
   return {
     content: [
       {
-        type: "text",
+        type: 'text',
         text: ret
       }
     ]
@@ -272,7 +278,7 @@ export async function handlePrompts(args) {
   const { action, query } = args;
 
   if (!action) {
-    throw new Error("缺少必需参数: action (search 或 get)");
+    throw new Error('缺少必需参数: action (search 或 get)');
   }
 
   switch (action) {
@@ -281,7 +287,7 @@ export async function handlePrompts(args) {
 
     case 'get':
       if (!query) {
-        throw new Error("get操作需要提供query参数指定提示词ID或名称");
+        throw new Error('get操作需要提供query参数指定提示词ID或名称');
       }
       return handleGetPrompt({ prompt_id: query });
 

package/packages/server/middlewares/auth.middleware.js

@@ -1,40 +1,40 @@
 import { config } from '../utils/config.js';
 
 /**
-     * 管理员API中间件
-     * @param {*} req 
-     * @param {*} res 
-     * @param {*} next 
-     * @returns 
-     */
+ * 管理员API中间件
+ * @param {*} req
+ * @param {*} res
+ * @param {*} next
+ * @returns
+ */
 export function adminAuthMiddleware(req, res, next) {
-    // 检查是否启用了管理员功能
-    if (!config.adminEnable) {
-        return res.status(404).json({ error: 'Admin功能未启用' });
-    }
+  // 检查是否启用了管理员功能
+  if (!config.adminEnable) {
+    return res.status(404).json({ error: 'Admin功能未启用' });
+  }
 
-    // 如果不需要认证，直接通过
-    if (!config.adminRequireAuth) {
-        next();
-        return;
-    }
+  // 如果不需要认证，直接通过
+  if (!config.adminRequireAuth) {
+    next();
+    return;
+  }
 
-    // 检查Authorization请求头是否存在且格式正确
-    const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
-        return res.status(401).json({ error: '未提供认证令牌' });
-    }
+  // 检查Authorization请求头是否存在且格式正确
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return res.status(401).json({ error: '未提供认证令牌' });
+  }
 
-    // 提取Bearer token
-    const token = authHeader.substring(7);
+  // 提取Bearer token
+  const token = authHeader.substring(7);
 
-    // 验证令牌是否在配置的管理员列表中
-    const admin = config.admins.find(a => a.token === token);
-    if (!admin) {
-        return res.status(401).json({ error: '无效的认证令牌' });
-    }
+  // 验证令牌是否在配置的管理员列表中
+  const admin = config.admins.find(a => a.token === token);
+  if (!admin) {
+    return res.status(401).json({ error: '无效的认证令牌' });
+  }
 
-    // 将管理员信息附加到请求对象，供后续中间件使用
-    req.admin = admin;
-    next();
-}
+  // 将管理员信息附加到请求对象，供后续中间件使用
+  req.admin = admin;
+  next();
+}

package/packages/server/server.js

@@ -4,9 +4,10 @@ import { config } from './utils/config.js';
 import { logger } from './utils/logger.js';
 import { util } from './utils/util.js';
 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 { checkPortAvailable, findAvailablePort } from './utils/port-checker.js';
+import { checkPortAvailable } from './utils/port-checker.js';
 
 // 动态导入 promptManager，以处理 Electron 打包后的路径问题
 let promptManager;
@@ -33,34 +34,39 @@ export async function isServerRunning() {
   if (!serverInstance) {
     return false;
   }
-  
+
   // 实际验证服务器是否在监听
-  return new Promise((resolve) => {
-    import('http').then(http => {
-      // 设置超时以避免长时间等待
-      const req = http.request({
-        hostname: 'localhost',
-        port: config.getPort(),
-        path: '/health',
-        method: 'GET',
-        timeout: 2000
-      }, (res) => {
-        resolve(true);
-      });
-      
-      req.on('error', () => {
-        resolve(false);
-      });
-      
-      req.on('timeout', () => {
-        req.destroy();
+  return new Promise(resolve => {
+    import('http')
+      .then(http => {
+        // 设置超时以避免长时间等待
+        const req = http.request(
+          {
+            hostname: 'localhost',
+            port: config.getPort(),
+            path: '/health',
+            method: 'GET',
+            timeout: 2000
+          },
+          _res => {
+            resolve(true);
+          }
+        );
+
+        req.on('error', () => {
+          resolve(false);
+        });
+
+        req.on('timeout', () => {
+          req.destroy();
+          resolve(false);
+        });
+
+        req.end();
+      })
+      .catch(() => {
         resolve(false);
       });
-      
-      req.end();
-    }).catch(() => {
-      resolve(false);
-    });
   });
 }
 
@@ -86,19 +92,19 @@ export async function startServer(options = {}) {
   serverStartingPromise = (async () => {
     try {
       await _handleConfig(options);
-      
+
       // 检查端口可用性
       const port = config.getPort();
       const isPortAvailable = await checkPortAvailable(port);
-      
+
       if (!isPortAvailable) {
         const errorMsg = `端口 ${port} 已被占用，请检查是否有其他服务在使用该端口，或手动指定其他端口`;
         logger.error(errorMsg);
         throw new Error(errorMsg);
       }
-      
+
       await promptManager.loadPrompts();
-      
+
       // 加载优化模板和模型
       try {
         const { templateManager } = await import('./services/template.service.js');
@@ -115,17 +121,24 @@ export async function startServer(options = {}) {
       } catch (error) {
         logger.warn('加载优化模型失败，继续启动服务', { error: error.message });
       }
-      
+
       // 同步系统工具到沙箱环境
       try {
         await syncSystemTools();
       } catch (error) {
         logger.error('同步系统工具失败，继续启动服务', { error: error.message });
       }
-      
-    // MCP 长连接可能长时间空闲（IDE 侧保持会话），若沿用 Node 默认超时（requestTimeout 5 分钟、keepAliveTimeout 5 秒、headersTimeout 60 秒）
-    // 会导致连接被动关闭。这里将相关超时调高/关闭以避免 IDE 定期断开。
-    const MCP_LONG_TIMEOUT = 24 * 60 * 60 * 1000; // 24h
+
+      // 同步作者配置到沙箱环境
+      try {
+        await syncAuthorConfig();
+      } catch (error) {
+        logger.error('同步作者配置失败，继续启动服务', { error: error.message });
+      }
+
+      // MCP 长连接可能长时间空闲（IDE 侧保持会话），若沿用 Node 默认超时（requestTimeout 5 分钟、keepAliveTimeout 5 秒、headersTimeout 60 秒）
+      // 会导致连接被动关闭。这里将相关超时调高/关闭以避免 IDE 定期断开。
+      const MCP_LONG_TIMEOUT = 24 * 60 * 60 * 1000; // 24h
 
       // 启动日志清理任务
       startLogCleanupTask();
@@ -137,7 +150,9 @@ export async function startServer(options = {}) {
             logger.info(`MCP服务启动成功  http://localhost:${port}/mcp`);
             if (config.adminEnable) {
               logger.info(`管理员界面可通过 http://localhost:${port}${config.adminPath} 访问`);
-              process.stderr.write('\n======================================================================================\n');
+              process.stderr.write(
+                '\n======================================================================================\n'
+              );
             }
 
             // 放宽 HTTP 服务器超时，防止 MCP 流式会话被意外回收
@@ -149,17 +164,17 @@ export async function startServer(options = {}) {
 
             // 设置服务器实例
             serverInstance = server;
-            
-            // 启动WebSocket服务，传入 HTTP 服务器端口
+
             try {
-                await webSocketService.start({ port: config.getPort() });
-                const wsPort = webSocketService.getPort();
-                logger.info(`WebSocket服务启动成功，端口: ${wsPort}`);
+              // WebSocket服务使用动态端口（端口0，由系统自动分配）
+              await webSocketService.start();
+              const wsPort = webSocketService.getPort();
+              logger.info(`WebSocket服务启动成功，端口: ${wsPort}`);
             } catch (wsError) {
               logger.error('WebSocket服务启动失败:', wsError.message);
               // WebSocket服务失败不影响主服务器运行
             }
-            
+
             resolve(server);
           } catch (error) {
             logger.error('服务器启动后处理失败:', error.message);
@@ -168,7 +183,7 @@ export async function startServer(options = {}) {
           }
         });
 
-        server.on('error', (err) => {
+        server.on('error', err => {
           logger.error('服务器启动失败:', err.message);
           if (err.code === 'EADDRINUSE') {
             logger.error(`端口 ${port} 已被占用，请检查是否有其他服务在使用该端口`);
@@ -220,7 +235,7 @@ export async function stopServer() {
   }
 
   await new Promise((resolve, reject) => {
-    serverInstance.close((err) => {
+    serverInstance.close(err => {
       if (err) {
         logger.error('停止服务器失败:', err.message);
         reject(err);
@@ -255,7 +270,7 @@ const isDirectRun = (() => {
 })();
 
 if (isDirectRun) {
-  startServer().catch((error) => {
+  startServer().catch(error => {
     logger.error('服务器启动失败:', error.message);
     process.exit(1);
   });