@becrafter/prompt-manager 0.0.18 → 0.1.1

package/packages/server/toolm/tool-mode-handlers.service.js

@@ -0,0 +1,224 @@
+/**
+ * 工具模式处理器服务
+ * 
+ * 职责：
+ * 1. 处理 manual 模式 - 显示工具手册
+ * 2. 处理 configure 模式 - 配置工具环境变量
+ * 3. 处理 log 模式 - 查看工具日志
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { logger } from '../utils/logger.js';
+import { toolLoaderService } from './tool-loader.service.js';
+import { saveToolEnvironment, getToolEnvironmentInfo } from './tool-environment.service.js';
+import { flushAllLogQueues } from './tool-logger.service.js';
+import { pathExists } from './tool-utils.js';
+import { executeTool } from './tool-execution.service.js';
+
+/**
+ * 处理 manual 模式 - 显示工具手册
+ * @param {string} toolName - 工具名称
+ * @returns {object} MCP 格式的返回结果
+ */
+export function handleManualMode(toolName) {
+  logger.info(`显示工具手册: ${toolName}`);
+  
+  try {
+    const manual = toolLoaderService.generateManual(toolName);
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: manual
+        }
+      ]
+    };
+  } catch (error) {
+    logger.error(`生成工具手册失败: ${toolName}`, { error: error.message });
+    throw error;
+  }
+}
+
+/**
+ * 处理 execute 模式 - 执行工具
+ * @param {string} toolName - 工具名称
+ * @param {object} parameters - 工具参数
+ * @returns {object} MCP 格式的返回结果
+ */
+export async function handleExecuteMode(toolName, parameters) {
+  return await executeTool(toolName, parameters);
+}
+
+/**
+ * 处理 configure 模式 - 配置工具环境变量
+ * @param {string} toolName - 工具名称
+ * @param {object} parameters - 配置参数
+ * @returns {object} MCP 格式的返回结果
+ */
+export async function handleConfigureMode(toolName, parameters) {
+  logger.info(`配置工具: ${toolName}`, { parameters });
+  
+  try {
+    const tool = toolLoaderService.getTool(toolName);
+    
+    // 获取工具的环境变量定义
+    const schema = tool.schema || {};
+    const envProps = schema.environment?.properties || {};
+    
+    // 如果有配置参数，保存配置
+    if (parameters && Object.keys(parameters).length > 0) {
+      // 验证配置参数
+      const configuredVars = {};
+      for (const [key, value] of Object.entries(parameters)) {
+        if (!envProps[key]) {
+          logger.warn(`未知的环境变量: ${key}`, { tool: toolName });
+        }
+        configuredVars[key] = value;
+      }
+      
+      // 保存到 .env 文件
+      await saveToolEnvironment(toolName, configuredVars);
+      
+      logger.info(`工具配置成功: ${toolName}`, { configured: Object.keys(configuredVars) });
+    }
+    
+    // 获取当前配置信息
+    const envInfo = await getToolEnvironmentInfo(toolName, schema);
+    const metadata = tool.metadata || {};
+    
+    // 生成格式化的配置信息
+    let configText = `# 工具配置信息\n\n`;
+    configText += `## 工具信息\n\n`;
+    configText += `**工具名称**: ${toolName}\n`;
+    configText += `**工具版本**: ${metadata.version || '1.0.0'}\n`;
+    configText += `**配置状态**: ${envInfo.configured.length > 0 ? '✅ 已配置' : '⚠️ 未配置'}\n\n`;
+    
+    configText += `## 环境配置路径\n\n`;
+    configText += `**配置文件路径**: \`${envInfo.envFilePath}\`\n\n`;
+    
+    if (envInfo.configured.length > 0) {
+      configText += `## 当前配置\n\n`;
+      configText += `### 已配置项\n\n`;
+      configText += `| 配置项 | 当前值 | 说明 | 状态 |\n`;
+      configText += `|--------|--------|------|------|\n`;
+      for (const item of envInfo.configured) {
+        const value = String(item.value).length > 50 
+          ? String(item.value).substring(0, 50) + '...'
+          : String(item.value);
+        configText += `| ${item.key} | ${value} | ${item.description} | ${item.status} |\n`;
+      }
+      configText += `\n`;
+    }
+    
+    if (envInfo.unconfigured.length > 0) {
+      configText += `### 未配置项（使用默认值）\n\n`;
+      configText += `| 配置项 | 默认值 | 说明 | 状态 |\n`;
+      configText += `|--------|--------|------|------|\n`;
+      for (const item of envInfo.unconfigured) {
+        const defaultValue = item.defaultValue !== undefined 
+          ? String(item.defaultValue)
+          : '(无)';
+        configText += `| ${item.key} | ${defaultValue} | ${item.description} | ${item.status} |\n`;
+      }
+      configText += `\n`;
+    }
+    
+    configText += `## 配置操作\n\n`;
+    configText += `### 如何更新配置\n\n`;
+    configText += `使用以下命令更新配置：\n\n`;
+    configText += `\`\`\`yaml\n`;
+    configText += `tool: tool://${toolName}\n`;
+    configText += `mode: configure\n`;
+    configText += `parameters:\n`;
+    if (envProps && Object.keys(envProps).length > 0) {
+      const firstKey = Object.keys(envProps)[0];
+      const firstDef = envProps[firstKey];
+      configText += `  ${firstKey}: ${firstDef.default || 'value'}\n`;
+    }
+    configText += `\`\`\`\n\n`;
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: configText
+        }
+      ]
+    };
+    
+  } catch (error) {
+    logger.error(`工具配置失败: ${toolName}`, { error: error.message });
+    throw error;
+  }
+}
+
+/**
+ * 处理 log 模式 - 查看工具日志
+ * @param {string} toolName - 工具名称
+ * @param {object} parameters - 日志参数
+ * @returns {object} MCP 格式的返回结果
+ */
+export async function handleLogMode(toolName, parameters) {
+  logger.info(`查看工具日志: ${toolName}`, { parameters });
+  
+  try {
+    // 先刷新日志队列，确保最新日志已写入
+    await flushAllLogQueues();
+    
+    const toolDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
+    const logFilePath = path.join(toolDir, 'run.log');
+    
+    // 检查日志文件是否存在
+    if (!await pathExists(logFilePath)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `工具 ${toolName} 暂无日志文件\n\n日志文件路径: \`${logFilePath}\``
+          }
+        ]
+      };
+    }
+    
+    // 读取日志文件
+    const logContent = await fs.readFile(logFilePath, 'utf-8');
+    const logLines = logContent.split('\n').filter(line => line.trim());
+    
+    const action = parameters.action || 'tail';
+    const lines = parameters.lines || 50;
+    
+    let selectedLines = [];
+    
+    if (action === 'tail') {
+      // 取最后N行
+      selectedLines = logLines.slice(-lines);
+    } else if (action === 'head') {
+      // 取前N行
+      selectedLines = logLines.slice(0, lines);
+    } else if (action === 'all') {
+      // 取所有行
+      selectedLines = logLines;
+    } else {
+      throw new Error(`不支持的操作: ${action}，支持的操作: tail, head, all`);
+    }
+    
+    const logText = selectedLines.join('\n');
+    
+    return {
+      content: [
+        {
+          type: "text",
+          text: `# 工具日志\n\n**工具**: ${toolName}\n**日志文件**: \`${logFilePath}\`\n**操作**: ${action}\n**行数**: ${selectedLines.length}\n\n\`\`\`\n${logText}\n\`\`\``
+        }
+      ]
+    };
+    
+  } catch (error) {
+    logger.error(`查看工具日志失败: ${toolName}`, { error: error.message });
+    throw error;
+  }
+}
+

package/packages/server/toolm/tool-storage.service.js

@@ -0,0 +1,111 @@
+/**
+ * 工具存储服务
+ * 
+ * 职责：
+ * 1. 为每个工具提供独立的存储空间
+ * 2. 数据持久化到工具目录的 data 目录
+ * 3. 提供简单的 key-value 存储接口
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { logger } from '../utils/logger.js';
+import { pathExists } from './tool-utils.js';
+
+// 存储缓存：toolName -> storage data
+const storageCache = new Map();
+
+/**
+ * 获取工具存储服务
+ * @param {string} toolName - 工具名称
+ * @returns {object} 存储服务对象
+ */
+export function getStorage(toolName) {
+  if (!storageCache.has(toolName)) {
+    storageCache.set(toolName, {});
+  }
+  
+  const storage = storageCache.get(toolName);
+  const storageFile = getStorageFilePath(toolName);
+  
+  // 加载存储数据（如果存在）
+  loadStorageData(toolName, storageFile, storage);
+  
+  return {
+    getItem: (key) => {
+      return storage[key];
+    },
+    
+    setItem: (key, value) => {
+      storage[key] = value;
+      // 异步保存
+      saveStorageData(toolName, storageFile, storage).catch(error => {
+        logger.error(`保存工具存储失败: ${toolName}`, { error: error.message });
+      });
+    },
+    
+    removeItem: (key) => {
+      delete storage[key];
+      // 异步保存
+      saveStorageData(toolName, storageFile, storage).catch(error => {
+        logger.error(`保存工具存储失败: ${toolName}`, { error: error.message });
+      });
+    },
+    
+    clear: () => {
+      storageCache.set(toolName, {});
+      // 删除存储文件
+      fs.remove(storageFile).catch(error => {
+        logger.error(`删除工具存储文件失败: ${toolName}`, { error: error.message });
+      });
+    }
+  };
+}
+
+/**
+ * 获取存储文件路径
+ * @param {string} toolName - 工具名称
+ * @returns {string} 存储文件路径
+ */
+function getStorageFilePath(toolName) {
+  const toolDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
+  return path.join(toolDir, 'data', 'storage.json');
+}
+
+/**
+ * 加载存储数据
+ * @param {string} toolName - 工具名称
+ * @param {string} storageFile - 存储文件路径
+ * @param {object} storage - 存储对象
+ */
+async function loadStorageData(toolName, storageFile, storage) {
+  try {
+    if (await pathExists(storageFile)) {
+      const data = await fs.readJson(storageFile);
+      Object.assign(storage, data);
+      logger.debug(`工具 ${toolName} 存储数据已加载`);
+    }
+  } catch (error) {
+    logger.warn(`加载工具存储数据失败: ${toolName}`, { error: error.message });
+  }
+}
+
+/**
+ * 保存存储数据
+ * @param {string} toolName - 工具名称
+ * @param {string} storageFile - 存储文件路径
+ * @param {object} storage - 存储对象
+ */
+async function saveStorageData(toolName, storageFile, storage) {
+  try {
+    const toolDir = path.dirname(storageFile);
+    await fs.ensureDir(toolDir);
+    await fs.writeJson(storageFile, storage, { spaces: 2 });
+    logger.debug(`工具 ${toolName} 存储数据已保存`);
+  } catch (error) {
+    logger.error(`保存工具存储数据失败: ${toolName}`, { error: error.message });
+    throw error;
+  }
+}
+

package/packages/server/toolm/tool-sync.service.js

@@ -0,0 +1,138 @@
+/**
+ * 工具同步服务
+ * 
+ * 职责：
+ * 1. 将系统内置工具从 packages/resources/tools/ 同步到 ~/.prompt-manager/toolbox/
+ * 2. 为每个工具创建独立的沙箱目录结构
+ * 3. 生成 package.json 文件（如果不存在）
+ * 
+ * 执行时机：
+ * - HTTP 服务启动时（server.js 的 startServer() 函数中）
+ * - 在 MCP 服务器初始化之前执行
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { logger } from '../utils/logger.js';
+import { pathExists } from './tool-utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 同步系统工具到沙箱环境
+ */
+export async function syncSystemTools() {
+  logger.info('开始同步系统工具到沙箱环境...');
+  
+  // 系统工具源目录
+  const toolsDir = path.join(__dirname, '..', '..', 'resources', 'tools');
+  
+  // 目标沙箱目录
+  const toolboxDir = path.join(os.homedir(), '.prompt-manager', 'toolbox');
+  
+  // 确保工具箱目录存在
+  await fs.ensureDir(toolboxDir);
+  
+  // 检查源目录是否存在
+  if (!await pathExists(toolsDir)) {
+    logger.warn(`系统工具目录不存在，跳过同步: ${toolsDir}`);
+    return;
+  }
+  
+  try {
+    // 读取系统工具目录
+    const entries = await fs.readdir(toolsDir, { withFileTypes: true });
+    
+    let syncedCount = 0;
+    
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      
+      const toolName = entry.name;
+      const toolDir = path.join(toolsDir, toolName);
+      const toolFile = path.join(toolDir, `${toolName}.tool.js`);
+      
+      // 检查工具文件是否存在
+      if (!await pathExists(toolFile)) {
+        logger.debug(`工具文件不存在，跳过: ${toolFile}`);
+        continue;
+      }
+      
+      try {
+        // 创建目标沙箱目录
+        const sandboxDir = path.join(toolboxDir, toolName);
+        await fs.ensureDir(sandboxDir);
+        
+        // 复制工具文件
+        const sandboxToolFile = path.join(sandboxDir, `${toolName}.tool.js`);
+        await fs.copyFile(toolFile, sandboxToolFile);
+        
+        // 创建或更新 package.json
+        const packageJsonPath = path.join(sandboxDir, 'package.json');
+        let packageJson = {};
+        
+        if (await pathExists(packageJsonPath)) {
+          // 读取现有的 package.json
+          try {
+            packageJson = await fs.readJson(packageJsonPath);
+          } catch (error) {
+            logger.warn(`读取 package.json 失败，将重新创建: ${packageJsonPath}`, { error: error.message });
+          }
+        }
+        
+        // 读取工具模块获取依赖信息
+        let dependencies = {};
+        try {
+          const toolModule = await import(toolFile);
+          if (toolModule.default && typeof toolModule.default.getDependencies === 'function') {
+            dependencies = toolModule.default.getDependencies() || {};
+          }
+        } catch (error) {
+          logger.warn(`读取工具依赖失败: ${toolName}`, { error: error.message });
+        }
+        
+        // 更新 package.json
+        packageJson = {
+          name: `@prompt-manager/${toolName}`,
+          version: packageJson.version || '1.0.0',
+          description: packageJson.description || `Prompt Manager System Tool: ${toolName}`,
+          main: `${toolName}.tool.js`,
+          type: 'module',
+          dependencies: {
+            ...(packageJson.dependencies || {}),
+            ...dependencies
+          },
+          private: true
+        };
+        
+        // 写入 package.json
+        await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+        
+        // 创建必要的子目录
+        await fs.ensureDir(path.join(sandboxDir, 'data'));
+        await fs.ensureDir(path.join(sandboxDir, 'logs'));
+        
+        syncedCount++;
+        logger.info(`系统工具 ${toolName} 已同步到沙箱环境`, { 
+          source: toolFile,
+          target: sandboxDir 
+        });
+        
+      } catch (error) {
+        logger.error(`同步工具失败: ${toolName}`, { error: error.message });
+      }
+    }
+    
+    logger.info(`系统工具同步完成，共同步 ${syncedCount} 个工具`);
+    
+  } catch (error) {
+    logger.error('同步系统工具失败', { error: error.message });
+    throw error;
+  }
+}
+

package/packages/server/toolm/tool-utils.js

@@ -0,0 +1,20 @@
+/**
+ * 工具模块共享工具函数
+ */
+
+import { access } from 'fs/promises';
+
+/**
+ * 检查路径是否存在（替代 fs.pathExists，因为 fs-extra v11 中已移除）
+ * @param {string} filePath - 文件或目录路径
+ * @returns {Promise<boolean>}
+ */
+export async function pathExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+

package/packages/server/toolm/tool-yaml-parser.service.js

@@ -0,0 +1,81 @@
+/**
+ * 工具 YAML 解析服务
+ * 
+ * 职责：
+ * 1. 解析和规范化 YAML 配置
+ * 2. 自动修正常见的 AI 错误
+ * 3. 验证必需字段
+ */
+
+import YAML from 'yaml';
+import { logger } from '../utils/logger.js';
+
+/**
+ * 解析和规范化 YAML 配置
+ * @param {string} yamlInput - 原始 YAML 输入
+ * @returns {object} 解析后的配置对象 { toolName, mode, parameters }
+ */
+export function parseToolYaml(yamlInput) {
+  if (!yamlInput) {
+    throw new Error("缺少必需参数: yaml");
+  }
+  
+  try {
+    // Auto-correct common AI mistakes
+    let yamlContent = yamlInput.trim();
+
+    // Case 1: Just a plain URL string like "tool://filesystem" or "@tool://filesystem"
+    if (yamlContent.match(/^@?tool:\/\/[\w-]+$/)) {
+      const toolName = yamlContent.replace(/^@?tool:\/\//, '');
+      yamlContent = `tool: tool://${toolName}\nmode: execute`;
+    }
+
+    // Case 2: Handle escaped backslashes and quotes: tool: \"@tool://xxx\"
+    yamlContent = yamlContent.replace(/\\\\/g, '\\').replace(/\\"/g, '"');
+
+    // Case 3: Remove @ prefix from tool URLs: @tool://xxx -> tool://xxx
+    yamlContent = yamlContent.replace(/@tool:\/\//g, 'tool://');
+
+    // Case 4: Remove quotes around tool URLs: tool: "tool://xxx" -> tool: tool://xxx
+    yamlContent = yamlContent.replace(/(tool|toolUrl|url):\s*"(tool:\/\/[^\"]+)"/g, '$1: $2');
+
+    // YAML → JSON conversion
+    const configObj = YAML.parse(yamlContent);
+
+    // Normalize field names
+    const toolIdentifier = configObj.tool || configObj.toolUrl || configObj.url;
+    const operationMode = configObj.mode || configObj.operation || 'execute';
+    const parameters = configObj.parameters || {};
+
+    // Validate required fields
+    if (!toolIdentifier) {
+      throw new Error('Missing required field: tool\nExample: tool: tool://filesystem\nAliases supported: tool / toolUrl / url');
+    }
+
+    // Validate URL format
+    if (!toolIdentifier.startsWith('tool://')) {
+      throw new Error(`Invalid tool format: ${toolIdentifier}\nMust start with tool://`);
+    }
+
+    // Get tool name
+    const toolName = toolIdentifier.replace('tool://', '');
+    
+    return {
+      toolName,
+      mode: operationMode,
+      parameters
+    };
+
+  } catch (error) {
+    // YAML parsing errors
+    if (error.name === 'YAMLException') {
+      if (error.message.includes('bad indentation') || error.message.includes('mapping entry')) {
+        throw new Error(`YAML format error: ${error.message}\n\nMultiline content requires | symbol, example:\ncontent: |\n  First line\n  Second line\n\nNote: Newline after |, indent content with 2 spaces`);
+      }
+      throw new Error(`YAML format error: ${error.message}\nCheck indentation (use spaces) and syntax`);
+    }
+
+    throw error;
+  }
+}
+