@becrafter/prompt-manager 0.0.19 → 0.1.1

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

@@ -0,0 +1,334 @@
+/**
+ * 工具执行上下文服务
+ * 
+ * 职责：
+ * 1. 创建工具执行上下文（包含 API、路径解析、模块导入等）
+ * 2. 提供统一的工具执行环境
+ */
+
+import path from 'path';
+import os from 'os';
+import { createRequire } from 'module';
+import { logger } from '../utils/logger.js';
+import { getLogger } from './tool-logger.service.js';
+import { getStorage } from './tool-storage.service.js';
+import { loadToolEnvironment, saveToolEnvironment } from './tool-environment.service.js';
+
+/**
+ * 创建工具执行上下文
+ * @param {string} toolName - 工具名称
+ * @param {object} toolModule - 工具模块
+ * @returns {object} 工具执行上下文
+ */
+export async function createToolContext(toolName, toolModule) {
+  const toolDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
+  
+  // 1. 加载工具环境变量
+  const toolEnvVars = await loadToolEnvironment(toolName);
+  
+  // 2. 创建工具日志记录器
+  const toolLogger = getLogger(toolName);
+  
+  // 3. 创建工具存储服务
+  const toolStorage = getStorage(toolName);
+  
+  // 4. 创建 API 上下文
+  const apiContext = {
+    logger: toolLogger,
+    storage: toolStorage,
+    environment: {
+      get: (key) => {
+        // 优先从工具环境变量获取
+        if (toolEnvVars[key] !== undefined) {
+          return toolEnvVars[key];
+        }
+        // 然后从系统环境变量获取
+        return process.env[key];
+      },
+      set: async (key, value) => {
+        // 更新工具环境变量
+        toolEnvVars[key] = value;
+        await saveToolEnvironment(toolName, { [key]: value });
+      }
+    }
+  };
+
+  // 5. 创建工具专用的 require 函数
+  const packageJsonPath = path.resolve(path.join(toolDir, 'package.json'));
+  const toolRequire = createRequire(packageJsonPath);
+  
+  // 6. 创建工具执行上下文
+  const toolContext = {
+    api: apiContext,
+    __toolDir: toolDir,
+    __toolName: toolName,
+    // 文件系统初始化状态（框架管理）
+    _filesystemInitialized: false,
+    _allowedDirectories: null,
+    
+    // 框架提供的文件系统基础能力
+    getAllowedDirectories() {
+      const { api } = this;
+      
+      // 默认值
+      let allowedDirs = ['~/.prompt-manager'];
+      
+      if (api && api.environment) {
+        try {
+          let configStr = api.environment.get('ALLOWED_DIRECTORIES');
+          
+          // 如果直接获取失败，尝试使用工具特定的环境变量名
+          if (!configStr) {
+            const toolSpecificKey = `${toolName.toUpperCase().replace(/-/g, '_')}_ALLOWED_DIRECTORIES`;
+            configStr = process.env[toolSpecificKey];
+          }
+          
+          if (configStr) {
+            // 处理转义字符（从 .env 文件解析时可能需要）
+            configStr = configStr.replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+            
+            // 首先尝试作为 JSON 字符串解析
+            try {
+              const parsed = JSON.parse(configStr);
+              if (Array.isArray(parsed) && parsed.length > 0) {
+                allowedDirs = parsed;
+              }
+            } catch (parseError) {
+              // 如果不是 JSON，尝试作为逗号分隔的字符串
+              if (typeof configStr === 'string' && configStr.includes(',')) {
+                allowedDirs = configStr.split(',').map(s => s.trim()).filter(s => s);
+              } else if (configStr) {
+                allowedDirs = [configStr];
+              }
+            }
+          }
+        } catch (error) {
+          // 回退到默认值
+          api?.logger?.warn('Failed to parse ALLOWED_DIRECTORIES', { error: error.message });
+        }
+      }
+      
+      // 展开 ~ 到主目录并规范化路径
+      return allowedDirs.map(dir => {
+        const expanded = dir.replace(/^~/, os.homedir());
+        return path.resolve(expanded);
+      });
+    },
+    
+    async initializeFilesystem() {
+      if (!this._filesystemInitialized) {
+        // 获取允许的目录列表
+        const allowedDirectories = this.getAllowedDirectories();
+        this._allowedDirectories = allowedDirectories;
+        this._filesystemInitialized = true;
+        
+        // 记录日志
+        const { api } = this;
+        api?.logger?.info('Filesystem initialized', { 
+          allowedDirectories: this._allowedDirectories 
+        });
+      }
+    },
+    
+    resolvePromptManagerPath(inputPath) {
+      const { api } = this;
+      
+      // 获取允许的目录列表
+      const allowedDirs = this._allowedDirectories || this.getAllowedDirectories();
+      
+      if (!inputPath) {
+        // 没有路径时返回第一个允许的目录
+        return allowedDirs[0];
+      }
+      
+      // 处理 ~ 开头的路径
+      const expandedPath = inputPath.replace(/^~/, os.homedir());
+      
+      // 如果是绝对路径
+      if (path.isAbsolute(expandedPath)) {
+        const resolved = path.resolve(expandedPath);
+        const normalizedResolved = path.normalize(resolved);
+        
+        // 检查路径是否在允许的目录范围内
+        const isAllowed = allowedDirs.some(dir => {
+          const normalizedDir = path.normalize(dir);
+          
+          // 完全匹配允许的目录
+          if (normalizedResolved === normalizedDir) {
+            return true;
+          }
+          
+          // 检查是否是允许目录的子路径
+          const relativePath = path.relative(normalizedDir, normalizedResolved);
+          
+          // 如果 relativePath 以 .. 开头，说明路径不在允许目录内
+          if (relativePath.startsWith('..')) {
+            return false;
+          }
+          
+          // 如果 relativePath 为空，说明是完全匹配（已在上面检查）
+          if (relativePath === '') {
+            return false;
+          }
+          
+          // 相对路径存在且不以 .. 开头，说明是允许目录的子路径
+          return true;
+        });
+        
+        if (!isAllowed) {
+          const dirsStr = allowedDirs.join(', ');
+          api?.logger?.warn('Path access denied', { path: resolved, allowedDirs });
+          throw new Error(`路径越权: ${inputPath} 不在允许的目录范围内 [${dirsStr}]`);
+        }
+        
+        return resolved;
+      }
+      
+      // 相对路径，尝试在每个允许的目录中解析
+      const baseDir = allowedDirs[0];
+      const fullPath = path.join(baseDir, expandedPath);
+      const resolved = path.resolve(fullPath);
+      const normalizedResolved = path.normalize(resolved);
+      
+      // 安全检查：确保解析后的路径在允许的目录内或其子目录中
+      const isAllowed = allowedDirs.some(dir => {
+        const normalizedDir = path.normalize(dir);
+        
+        // 完全匹配允许的目录
+        if (normalizedResolved === normalizedDir) {
+          return true;
+        }
+        
+        // 检查是否是允许目录的子路径
+        const relativePath = path.relative(normalizedDir, normalizedResolved);
+        
+        // 如果 relativePath 以 .. 开头，说明路径不在允许目录内
+        if (relativePath.startsWith('..')) {
+          return false;
+        }
+        
+        // 如果 relativePath 为空，说明是完全匹配（已在上面检查）
+        if (relativePath === '') {
+          return false;
+        }
+        
+        // 相对路径存在且不以 .. 开头，说明是允许目录的子路径
+        return true;
+      });
+      
+      if (!isAllowed) {
+        const dirsStr = allowedDirs.join(', ');
+        api?.logger?.warn('Path resolution failed', { path: inputPath, resolved, allowedDirs });
+        throw new Error(`路径越权: ${inputPath} 解析后超出允许的目录范围 [${dirsStr}]`);
+      }
+      
+      return resolved;
+    },
+    
+    // 提供工具专用的模块导入函数
+    requireToolModule: (moduleName) => {
+      try {
+        // 首先尝试从工具的 node_modules 导入
+        return toolRequire(moduleName);
+      } catch (error) {
+        // 如果失败，尝试从系统 node_modules 导入
+        try {
+          return require(moduleName);
+        } catch (e) {
+          throw new Error(`无法导入模块 ${moduleName}: ${error.message}`);
+        }
+      }
+    },
+    
+    // 提供工具专用的动态导入函数（支持 ES 模块和 CommonJS）
+    importToolModule: async (moduleName) => {
+      try {
+        // 首先尝试使用 require 导入（适用于 CommonJS 模块，如 pdf-parse）
+        const module = toolRequire(moduleName);
+        
+        logger.debug(`模块 ${moduleName} require 成功`, {
+          type: typeof module,
+          isFunction: typeof module === 'function',
+          isObject: typeof module === 'object',
+          keys: typeof module === 'object' ? Object.keys(module).slice(0, 10) : []
+        });
+        
+        // pdf-parse 是 CommonJS 模块，直接导出函数
+        // 如果 module 是函数，直接返回
+        if (typeof module === 'function') {
+          return { default: module };
+        }
+        
+        // 如果是对象，检查是否有 default
+        if (module && typeof module === 'object') {
+          // 如果已经有 default，直接返回
+          if (module.default) {
+            return module;
+          }
+          
+          // 检查是否有常见的导出名称（如 PDFParse）
+          if (module.PDFParse && typeof module.PDFParse === 'function') {
+            return { default: module.PDFParse };
+          }
+          
+          // 否则包装为 { default: module }
+          return { default: module, ...module };
+        }
+        
+        return module;
+      } catch (requireError) {
+        logger.debug(`require 失败，尝试 import: ${moduleName}`, { error: requireError.message });
+        // 如果 require 失败，尝试使用 import（适用于 ES 模块）
+        try {
+          const modulePath = toolRequire.resolve(moduleName);
+          logger.debug(`使用 import 导入模块: ${moduleName}`, { path: modulePath });
+          return await import(modulePath);
+        } catch (resolveError) {
+          logger.debug(`resolve 失败，尝试特殊路径: ${moduleName}`, { error: resolveError.message });
+          
+          // 特殊处理：某些包的 main 字段指向错误的路径，需要尝试备用路径
+          const fallbackPaths = {
+            'chrome-devtools-mcp': 'chrome-devtools-mcp/build/src/index.js'
+          };
+          
+          if (fallbackPaths[moduleName]) {
+            try {
+              const fallbackPath = toolRequire.resolve(fallbackPaths[moduleName]);
+              logger.debug(`使用备用路径导入 ${moduleName}`, { path: fallbackPath });
+              return await import(fallbackPath);
+            } catch (fallbackError) {
+              logger.debug(`备用路径也失败: ${moduleName}`, { error: fallbackError.message });
+            }
+          }
+          
+          // 如果 resolve 失败，尝试直接导入（可能从系统 node_modules）
+          try {
+            logger.debug(`尝试直接导入模块: ${moduleName}`);
+            return await import(moduleName);
+          } catch (importError) {
+            logger.error(`导入模块失败: ${moduleName}`, {
+              requireError: requireError.message,
+              resolveError: resolveError.message,
+              importError: importError.message,
+              toolDir
+            });
+            throw new Error(`无法导入模块 ${moduleName}。请确保依赖已安装。错误: ${requireError.message}`);
+          }
+        }
+      }
+    }
+  };
+  
+  // 7. 将工具模块的所有方法复制到上下文中，并绑定this
+  // 这样工具方法之间可以相互调用（如 execute 调用 this.initializeFilesystem）
+  for (const [key, value] of Object.entries(toolModule)) {
+    if (typeof value === 'function') {
+      toolContext[key] = value.bind(toolContext);
+    } else {
+      toolContext[key] = value;
+    }
+  }
+  
+  return toolContext;
+}
+

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

@@ -0,0 +1,168 @@
+/**
+ * 工具依赖管理服务
+ * 
+ * 职责：
+ * 1. 检查工具依赖是否已安装
+ * 2. 自动安装工具依赖（使用 @npmcli/arborist，不依赖系统 npm）
+ * 3. 验证依赖版本匹配
+ * 
+ * 使用 PackageInstaller 基于 @npmcli/arborist 实现，可在 Electron 环境中直接使用
+ */
+
+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';
+import PackageInstaller from './package-installer.service.js';
+
+/**
+ * 确保工具依赖已安装
+ * @param {string} toolName - 工具名称
+ * @param {object} toolModule - 工具模块（可选，用于自动创建 package.json）
+ */
+export async function ensureToolDependencies(toolName, toolModule = null) {
+  const toolDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
+  const packageJsonPath = path.join(toolDir, 'package.json');
+  const nodeModulesPath = path.join(toolDir, 'node_modules');
+  
+  // 检查 package.json 是否存在，如果不存在则自动创建
+  if (!await pathExists(packageJsonPath)) {
+    logger.info(`工具 ${toolName} 缺少 package.json，正在自动创建...`);
+    await createPackageJson(toolName, toolDir, toolModule);
+  }
+  
+  const packageJson = await fs.readJson(packageJsonPath);
+  const dependencies = packageJson.dependencies || {};
+  
+  // 如果没有依赖，直接返回
+  if (Object.keys(dependencies).length === 0) {
+    logger.debug(`工具 ${toolName} 无需依赖`);
+    return;
+  }
+  
+  // 检查 node_modules 是否存在，或者检查依赖是否需要更新
+  const needsInstall = !await pathExists(nodeModulesPath) || await needsDependencyUpdate(toolDir, dependencies);
+  
+  if (needsInstall) {
+    logger.info(`工具 ${toolName} 依赖需要安装或更新，开始安装...`);
+    await installDependencies(toolDir, dependencies);
+    return;
+  }
+  
+  logger.debug(`工具 ${toolName} 依赖已存在且为最新`);
+}
+
+/**
+ * 自动创建 package.json 文件
+ * @param {string} toolName - 工具名称
+ * @param {string} toolDir - 工具目录
+ * @param {object} toolModule - 工具模块（可选）
+ */
+async function createPackageJson(toolName, toolDir, toolModule) {
+  // 确保工具目录存在
+  await fs.ensureDir(toolDir);
+  
+  // 获取工具依赖（如果工具模块提供了 getDependencies 方法）
+  let dependencies = {};
+  if (toolModule && typeof toolModule.getDependencies === 'function') {
+    try {
+      dependencies = toolModule.getDependencies() || {};
+    } catch (error) {
+      logger.warn(`获取工具 ${toolName} 依赖失败:`, error.message);
+    }
+  }
+  
+  // 获取工具元数据（用于 package.json 的基本信息）
+  let metadata = { name: toolName, version: '1.0.0' };
+  if (toolModule && typeof toolModule.getMetadata === 'function') {
+    try {
+      metadata = toolModule.getMetadata() || metadata;
+    } catch (error) {
+      logger.warn(`获取工具 ${toolName} 元数据失败:`, error.message);
+    }
+  }
+  
+  // 创建 package.json
+  const packageJson = {
+    name: `@prompt-manager/tool-${toolName}`,
+    version: metadata.version || '1.0.0',
+    description: metadata.description || `Prompt Manager tool: ${toolName}`,
+    main: `${toolName}.tool.js`,
+    type: 'module',
+    dependencies: dependencies
+  };
+  
+  // 写入 package.json
+  const packageJsonPath = path.join(toolDir, 'package.json');
+  await fs.writeJson(packageJsonPath, packageJson, { spaces: 2 });
+  
+  logger.info(`已为工具 ${toolName} 创建 package.json`, { 
+    dependencies: Object.keys(dependencies).length 
+  });
+}
+
+/**
+ * 检查依赖是否需要更新
+ * @param {string} toolDir - 工具目录
+ * @param {Object} expectedDependencies - 期望的依赖列表
+ * @returns {Promise<boolean>} 是否需要更新
+ */
+async function needsDependencyUpdate(toolDir, expectedDependencies) {
+  try {
+    // 检查每个依赖是否已安装且版本匹配
+    for (const [packageName, expectedVersion] of Object.entries(expectedDependencies)) {
+      const isInstalled = await PackageInstaller.isPackageInstalled(toolDir, packageName);
+      if (!isInstalled) {
+        logger.debug(`依赖 ${packageName} 未安装，需要更新`);
+        return true;
+      }
+      
+      // 可以进一步检查版本是否匹配（简化版本，暂时只检查是否存在）
+      // 如果需要精确版本匹配，可以读取 package.json 并比较版本
+    }
+    
+    return false;
+  } catch (error) {
+    logger.warn('检查依赖更新状态失败，将重新安装', { error: error.message });
+    return true; // 出错时重新安装
+  }
+}
+
+/**
+ * 安装工具依赖（使用 PackageInstaller 基于 @npmcli/arborist）
+ * @param {string} toolDir - 工具目录
+ * @param {Object} dependencies - 依赖列表
+ */
+async function installDependencies(toolDir, dependencies) {
+  logger.info(`在目录 ${toolDir} 中安装依赖...`, { dependencies });
+  
+  try {
+    // 使用 PackageInstaller 安装依赖
+    // PackageInstaller 使用 @npmcli/arborist，不依赖系统 npm
+    // 可在 Electron 环境中直接使用
+    const result = await PackageInstaller.install({
+      workingDir: toolDir,
+      dependencies: dependencies,
+      timeout: 300000 // 5分钟超时
+    });
+    
+    logger.info('依赖安装成功', {
+      elapsed: result.elapsed,
+      installedCount: result.installedPackages.length,
+      packages: result.installedPackages
+    });
+    
+    return result;
+    
+  } catch (error) {
+    logger.error('依赖安装失败', { 
+      error: error.message,
+      toolDir,
+      dependencies,
+      stack: error.stack
+    });
+    throw new Error(`依赖安装失败: ${error.message}`);
+  }
+}
+