@becrafter/prompt-manager 0.0.16 → 0.0.19

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

@@ -0,0 +1,89 @@
+/**
+ * 开放数据接口
+ */
+import express from 'express';
+import { logger } from '../utils/logger.js';
+import { util } from '../utils/util.js';
+
+const router = express.Router();
+
+router.get('/prompts', (req, res) => {
+    try {
+        const prompts = util.getPromptsFromFiles();
+
+        // 过滤出启用的提示词
+        const filtered = prompts.filter(prompt => {
+            const groupActive = prompt.groupEnabled !== false;
+            const promptActive = prompt.enabled === true;
+            return groupActive && promptActive;
+        });
+        logger.debug(`filtered prompts: ${JSON.stringify(filtered)}`);
+
+        // 判断是否有搜索参数，且搜索参数名为search
+        if (req.query.search) {
+            const search = req.query.search;
+
+            // 实现相似度匹配算法
+            const searchResults = filtered.map(prompt => {
+                const score = util.calculateSimilarityScore(search, prompt);
+                return {
+                    prompt: {
+                        id: prompt.uniqueId,
+                        name: prompt.name,
+                        description: prompt.description || `Prompt: ${prompt.name}`,
+                        metadata: {
+                            // fileName: prompt.fileName,
+                            fullPath: prompt.relativePath
+                        }
+                    },
+                    score: score
+                };
+            })
+                .filter(result => result.score > 0) // 只返回有匹配的结果
+                .sort((a, b) => b.score - a.score); // 按相似度得分降序排列
+
+            // 只返回prompt字段
+            res.json(searchResults.map(result => result.prompt));
+        } else {
+            // 无搜索参数时，返回精简信息
+            const simplifiedPrompts = filtered.map(prompt => ({
+                id: prompt.uniqueId,
+                name: prompt.name,
+                description: prompt.description || `Prompt: ${prompt.name}`,
+                metadata: {
+                    // fileName: prompt.fileName,
+                    fullPath: prompt.relativePath
+                }
+            }));
+
+            res.json(simplifiedPrompts);
+        }
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// 查看提示词内容
+router.post('/process', async (req, res) => {
+    try {
+        const { promptName, arguments: args } = req.body;
+
+        if (!promptName) {
+            return res.status(400).json({ error: 'Missing promptName' });
+        }
+
+        const prompts = util.getPromptsFromFiles();
+        const prompt = prompts.find(p => p.name === promptName);
+
+        if (!prompt) {
+            return res.status(404).json({ error: `Prompt "${promptName}" not found` });
+        }
+
+        const processedPrompt = await util.processPromptContent(prompt, args);
+        res.json({ processedText: processedPrompt });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+export const openRouter = router;

package/packages/server/app.js

@@ -0,0 +1,163 @@
+import express from 'express';
+import cors from 'cors';
+import path from 'path';
+import { randomUUID } from 'node:crypto';
+import { util } from './utils/util.js';
+import { config } from './utils/config.js';
+import { logger } from './utils/logger.js';
+import { adminRouter } from './api/admin.routes.js';
+import { openRouter } from './api/open.routes.js';
+import { getMcpServer } from './mcp/mcp.server.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { InMemoryEventStore } from '@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js';
+
+
+const app = express();
+const adminUiRoot = util.getAdminUiRoot();
+
+// 全局中间件
+app.use(cors());
+app.use(express.json({ limit: '8mb' }));
+app.use(express.urlencoded({ extended: true }));
+
+
+// 为管理员界面提供静态文件服务 - 根路径
+app.use(config.adminPath, express.static(adminUiRoot));
+
+// 为管理员界面提供根路径访问（当用户访问 /admin 时显示 admin.html）
+app.get(config.adminPath, (req, res) => {
+  res.sendFile(path.join(adminUiRoot, 'admin.html'));
+});
+
+// 为管理员界面提供根路径访问（当用户访问 /admin/ 时显示 admin.html）
+app.get(config.adminPath + '/', (req, res) => {
+  res.sendFile(path.join(adminUiRoot, 'admin.html'));
+});
+
+
+// 注册后台API
+app.use('/adminapi', adminRouter);
+
+// 注册开放API
+app.use('/openapi', openRouter);
+
+
+const transports = {};
+const mcpServers = {}; // 存储每个会话的MCP服务器实例
+
+// 挂载MCP流式服务（独立路径前缀，避免冲突）
+app.all('/mcp', (req, res) => {
+  try {
+    let transport;
+    const sessionId = req.headers['mcp-session-id'] || '';
+    
+    if (sessionId && transports[sessionId]) {
+      const existingTransport = transports[sessionId];
+      // Check if the transport is of the correct type
+      if (existingTransport instanceof StreamableHTTPServerTransport) {
+        // Reuse existing transport
+        transport = existingTransport;
+      } else {
+        // Transport exists but is not a StreamableHTTPServerTransport (could be SSEServerTransport)
+        res.status(400).json({
+            jsonrpc: '2.0',
+            error: {
+                code: -32000,
+                message: 'Bad Request: Session exists but uses a different transport protocol'
+            },
+            id: null
+        });
+        return;
+      }
+    } else if (!sessionId && req.method === 'POST' && isInitializeRequest(req.body)) {
+      const eventStore = new InMemoryEventStore();
+      transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID(),
+          eventStore, // Enable resumability
+          onsessioninitialized: sessionId => {
+              // Store the transport by session ID when session is initialized
+              console.log(`StreamableHTTP session initialized with ID: ${sessionId}`);
+              transports[sessionId] = transport;
+              
+              // 为新会话创建MCP服务器实例
+              mcpServers[sessionId] = getMcpServer();
+              mcpServers[sessionId].connect(transport);
+          }
+      });
+
+      // Set up onclose handler to clean up transport when closed
+      transport.onclose = () => {
+          const sid = transport.sessionId;
+          if (sid && transports[sid]) {
+              console.log(`Transport closed for session ${sid}, removing from transports map`);
+              delete transports[sid];
+              // 清理MCP服务器实例
+              if (mcpServers[sid]) {
+                  delete mcpServers[sid];
+              }
+          }
+      };
+
+      // 添加错误处理
+      transport.onerror = (error) => {
+          console.error('MCP Transport error:', error);
+      };
+    } else {
+      // Invalid request - no session ID or not initialization request
+      res.status(400).json({
+          jsonrpc: '2.0',
+          error: {
+              code: -32000,
+              message: 'Bad Request: No valid session ID provided'
+          },
+          id: null
+      });
+      return;
+    }
+    
+    // Handle the request with the transport
+    transport.handleRequest(req, res, req.body);
+  } catch (error) {
+    logger.error('Error handling MCP request: ' + error.message);
+    return res.status(500).json({
+        jsonrpc: '2.0',
+        error: {
+            code: -32603,
+            message: 'Internal server error'
+        },
+        id: null
+    });
+  }
+});
+
+// 错误处理中间件
+app.use((err, req, res, next) => {
+  console.error(`[服务器错误]: ${err.message}`);
+  res.status(500).send('Internal Server Error')
+});
+
+// 404处理
+app.use((req, res) => {
+  res.status(404).send('Not Found')
+});
+
+// 导出清理函数
+export function cleanupMcpSessions() {
+  console.log('Cleaning up MCP sessions');
+  // 清理所有活动的传输和服务器实例
+  for (const sessionId in transports) {
+    try {
+      if (transports[sessionId] && typeof transports[sessionId].close === 'function') {
+        transports[sessionId].close();
+      }
+    } catch (error) {
+      console.error(`Error closing transport for session ${sessionId}:`, error);
+    }
+    delete transports[sessionId];
+  }
+  
+  // 注意：mcpServers 对象在 app.js 中不可访问，需要在 server.js 中处理
+}
+
+export default app;

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

@@ -0,0 +1,265 @@
+// 导入自定义模块
+import { config } from '../utils/config.js';
+import { logger } from '../utils/logger.js';
+import { util } from '../utils/util.js';
+
+// 处理 get_prompt 工具调用
+export async function handleGetPrompt(args) {
+  // 注意：这里为了兼容性，我们同时支持prompt_id和name参数
+  const promptId = args.prompt_id || args.name;
+  
+  if (!promptId) {
+    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
+    name: prompt.name,
+    description: prompt.description || `Prompt: ${prompt.name}`,
+    messages: prompt.messages || [],
+    arguments: prompt.arguments || [],
+    filePath: prompt.relativePath,  // 添加文件路径信息
+  };
+
+  if (config.getLogLevel() === 'debug') {
+    promptInfo.metadata = {
+      uniqueId: prompt.uniqueId,
+      fileName: prompt.fileName,
+      fullPath: prompt.filePath,
+    };
+  }
+
+  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 || [];
+
+  // 如果搜索词为空，则返回所有提示词
+  if (!searchTerm) {
+    let simplifiedPrompts = formatResults(allPrompts);
+
+    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); // 按相似度得分降序排列
+  
+
+  let result = {
+    success: true,
+    query: searchTerm || '',
+    count: searchResults.length,
+    results: formatResults(searchResults),
+  }
+
+  if (logLevel === 'debug') {
+    result.debug = {
+      scores: searchResults.map(result => ({
+        id: result.prompt.id,
+        name: result.prompt.name,
+        score: result.score,
+        fullPath: result.prompt.filePath,
+      }))
+    }
+  }
+
+  return convertToText(result, 'list');
+}
+
+/**
+ * 处理 reload_prompts 工具调用
+ */
+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)
+      }
+    ]
+  };
+}
+
+/**
+ * 格式化搜索结果
+ * @param {*} results 
+ * @returns 
+ */
+function formatResults(results = []) {
+  if (!Array.isArray(results)) return [];
+
+  return results.map(result => {
+    const prompt = result.prompt ? result.prompt : result;
+    const baseItem = {
+      id: prompt.id || prompt.uniqueId || '',
+      name: prompt.name || 'Unnamed Prompt',
+      description: prompt.description || `Prompt: ${prompt.name || 'Unnamed'}`
+    };
+
+    if (config.getLogLevel() === 'debug') {
+      return {
+        ...baseItem,
+        metadata: {
+          fullPath: prompt.filePath || ''
+        }
+      };
+    }
+    return baseItem;
+  });
+}
+
+/**
+ * 处理列表格式输出
+ * @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";
+  output += `📅 ${formattedDate}\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 => {
+      output += `- [${prompt.id}] ${prompt.name}\n`;
+      output += `  - ${prompt.description}\n`;
+    });
+  } else {
+    output += "(无提示词)\n";
+  }
+  
+  output += "\n--------------------------------------------------\n";
+  output += "[STATE_AREA]\n";
+  output += "📍 **当前状态**：prompts_completed\n";
+  
+  // 返回格式化文本
+  return output;
+}
+
+/**
+ * 处理详情格式输出
+ * @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";
+  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";
+  
+  // 添加参数信息
+  if (prompt.arguments && Array.isArray(prompt.arguments) && prompt.arguments.length > 0) {
+    prompt.arguments.forEach(param => {
+      const requiredText = param.required ? "必填" : "非必填";
+      output += `- ${param.name}: ${param.type}; ${requiredText}; ${param.description}\n`;
+    });
+  } else {
+    output += "(无参数)\n";
+  }
+  
+  output += "\n--------------------------------------------------\n";
+  output += "[PROMPT_CONTENT_AREA]\n";
+  
+  // 添加消息内容
+  if (prompt.messages && Array.isArray(prompt.messages)) {
+    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 += "\n[STATE_AREA]\n";
+  output += "📍 **当前状态**：prompt_loaded\n";
+  
+  return output;
+}
+
+/**
+ * 将对象转换为格式化的text类型输出
+ * @param {*} result 
+ * @param {string} format - 输出格式类型: 'list' 或 'detail'
+ * @returns 
+ */
+function convertToText(result, format) {
+  let ret = ""
+  switch (format) {
+    case 'list':
+      ret = formatListOutput(result);
+      break;
+    case 'detail':
+      ret = formatDetailOutput(result);
+      break;
+    default:
+      ret =JSON.stringify(result, null, 2);
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: ret
+      }
+    ]
+  };
+}

package/packages/server/mcp/mcp.server.js

@@ -0,0 +1,181 @@
+import { config } from '../utils/config.js';
+import { z } from 'zod';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import {
+    handleGetPrompt,
+    handleSearchPrompts,
+    handleReloadPrompts
+} from './mcp.handler.js';
+import { handleToolX } from './toolx.handler.js';
+
+class Server {
+    constructor() {
+        this.server = new McpServer(
+            {
+                name: 'Prompt Management Server',
+                version: config.getServerVersion()
+            },
+            { capabilities: { logging: {} } }
+        );
+    }
+
+    registerTools(tools) {
+        for (const tool of tools) {
+            this.server.registerTool(tool.name,
+                {
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                },
+                tool.handler
+            );
+        }
+    }
+
+    getServer() {
+        return this.server;
+    }
+}
+
+export const getMcpServer = () => {
+    const mcpServer = new Server();
+    mcpServer.registerTools([
+        {
+            name: 'search_prompts',
+            description: `功能：智能检索提示词库，匹配用户需求\n描述：根据用户输入内容（可为空）搜索匹配的提示词，返回候选提示词的 ID、名称、简短描述。若输入为空则返回全部提示词列表。帮助用户快速定位适合的提示词，无需记忆具体名称。\n\n示例：\n- 用户："我想写一首诗" → 工具返回：[ID:001, 名称:诗歌创作, 描述:生成古典/现代风格诗歌]\n- 用户："（无输入）" → 工具返回：完整提示词库概览`,
+            inputSchema: {
+                name: z.string().optional().describe('提示词名称或关键词，用于搜索匹配提示词'),
+            },
+            handler: async (args) => {
+                return handleSearchPrompts(args);
+            }
+        },
+        {
+            name: 'get_prompt',
+            description: `功能：精准获取并应用提示词详情\n描述：根据提示词 ID 或名称 调用具体内容，自动将其嵌入当前对话上下文，无需用户手动复制。支持通过 search_prompts 返回的 ID/名称直接获取。\n\n示例：\n- 用户："使用 ID 001" → 工具自动加载诗歌创作提示词并生成内容\n- 用户："调用'营销文案生成'" → 工具匹配名称后应用对应提示词`,
+            inputSchema: {
+                prompt_id: z.string().describe('提示词的唯一标识 ID/名称'),
+            },
+            handler: async (args) => {
+                return handleGetPrompt(args);
+            }
+        },
+        {
+            name: 'toolx',
+            description: `ToolX is the Prompt Manager tool runtime for loading and executing various tools.
+
+## Why ToolX Exists
+
+ToolX is your gateway to the Prompt Manager tool ecosystem. Think of it as:
+- A **universal remote control** for all Prompt Manager tools
+- Your **interface** to specialized capabilities (file operations, etc.)
+- The **bridge** between you (AI agent) and powerful system tools
+
+Without ToolX, you cannot access any Prompt Manager ecosystem tools.
+
+## When to Use ToolX
+
+### Common Scenarios (IF-THEN rules):
+- IF user needs file operations → USE tool://filesystem via toolx
+- IF you see tool:// in any context → USE toolx to call it
+
+### First Time Using Any Tool
+⚠️ **MUST run mode: manual first** to read the tool's documentation
+⚠️ Example: toolx with mode: manual for tool://filesystem
+
+## How to Use ToolX (Copy These Patterns)
+
+### Pattern 1: Read Tool Manual (First Time)
+
+**Exact code to use:**
+\`\`\`javascript
+// Call the toolx function with this exact structure:
+toolx({
+  yaml: \`tool: tool://filesystem\nmode: manual\`
+})
+\`\`\`
+
+**What this does:** Shows you how to use the filesystem tool
+
+### Pattern 2: Execute Tool with Parameters
+
+**Exact code to use:**
+\`\`\`javascript
+toolx({
+  yaml: \`tool: tool://filesystem\nmode: execute\nparameters:\n  path: /path/to/file.txt\n  action: read\`
+})
+\`\`\`
+
+**What this does:** Reads a file at the specified path
+
+### Pattern 3: Configure Tool Environment
+
+**Exact code to use:**
+\`\`\`javascript
+toolx({
+  yaml: \`tool: tool://my-tool\nmode: configure\nparameters:\n  API_KEY: sk-xxx123\n  TIMEOUT: 30000\`
+})
+\`\`\`
+
+**What this does:** Sets environment variables for the tool
+
+## Critical Rules (Must Follow)
+
+### ✅ Correct Format
+The yaml parameter MUST be a complete YAML document:
+- Start with \`tool: tool://tool-name\`
+- Add \`mode: execute\` (or manual/configure)
+- If needed, add \`parameters:\` section with proper indentation
+
+### ❌ Common Mistakes to Avoid
+- DON'T pass just "tool://filesystem" (missing YAML structure)
+- DON'T add @ prefix like "@tool://filesystem" (system handles it)
+- DON'T forget "tool://" prefix (not "tool: filesystem")
+- DON'T forget to read manual first for new tools
+
+## Available System Tools
+
+Quick reference of built-in tools:
+- **tool://filesystem** - File operations (read/write/list/delete)
+
+To see all available tools: check the tools directory
+
+## Step-by-Step Workflow
+
+### Step 1: Discover Available Tools
+Check the tools directory to see what tools exist
+
+### Step 2: Read Tool Manual
+\`\`\`javascript
+toolx({
+  yaml: \`tool: tool://TOOLNAME\nmode: manual\`
+})
+\`\`\`
+
+### Step 3: Execute Tool
+Copy the example from manual, modify parameters for your needs
+
+### Step 4: Handle Errors
+If execution fails, check:
+- Is the tool name correct?
+- Are parameters properly indented?
+- Did you read the manual first?
+
+`,
+            inputSchema: {
+                yaml: z.string().describe('YAML 格式的工具调用配置')
+            },
+            handler: async (args) => {
+                return handleToolX(args);
+            }
+        }
+        // {
+        //     name: 'reload_prompts',
+        //     description: 'Force a reload of all preset prompts to overwrite the cache.',
+        //     inputSchema: {},
+        //     handler: async (args) => {
+        //         return handleReloadPrompts(args);
+        //     }
+        // }
+    ]);
+    return mcpServer.getServer();
+};