@becrafter/prompt-manager 0.1.22 → 0.2.2

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

@@ -1,18 +1,18 @@
 /**
  * 工具执行上下文服务
- * 
+ *
  * 职责：
  * 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';
+import { config } from '../utils/config.js';
 
 /**
  * 创建工具执行上下文
@@ -21,23 +21,23 @@ import { loadToolEnvironment, saveToolEnvironment } from './tool-environment.ser
  * @returns {object} 工具执行上下文
  */
 export async function createToolContext(toolName, toolModule) {
-  const toolDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
-  
+  const toolDir = config.getToolDir(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) => {
+      get: key => {
         // 优先从工具环境变量获取
         if (toolEnvVars[key] !== undefined) {
           return toolEnvVars[key];
@@ -56,7 +56,7 @@ export async function createToolContext(toolName, toolModule) {
   // 5. 创建工具专用的 require 函数
   const packageJsonPath = path.resolve(path.join(toolDir, 'package.json'));
   const toolRequire = createRequire(packageJsonPath);
-  
+
   // 6. 创建工具执行上下文
   const toolContext = {
     api: apiContext,
@@ -65,28 +65,28 @@ export async function createToolContext(toolName, toolModule) {
     // 文件系统初始化状态（框架管理）
     _filesystemInitialized: false,
     _allowedDirectories: null,
-    
+
     // 框架提供的文件系统基础能力
     getAllowedDirectories() {
       const { api } = this;
-      
+
       // 默认值
-      let allowedDirs = ['~/.prompt-manager'];
-      
+      let allowedDirs = [config.getConfigHome()];
+
       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);
@@ -96,7 +96,10 @@ export async function createToolContext(toolName, toolModule) {
             } catch (parseError) {
               // 如果不是 JSON，尝试作为逗号分隔的字符串
               if (typeof configStr === 'string' && configStr.includes(',')) {
-                allowedDirs = configStr.split(',').map(s => s.trim()).filter(s => s);
+                allowedDirs = configStr
+                  .split(',')
+                  .map(s => s.trim())
+                  .filter(s => s);
               } else if (configStr) {
                 allowedDirs = [configStr];
               }
@@ -107,126 +110,126 @@ export async function createToolContext(toolName, toolModule) {
           api?.logger?.warn('Failed to parse ALLOWED_DIRECTORIES', { error: error.message });
         }
       }
-      
+
       // 展开 ~ 到主目录并规范化路径
       return allowedDirs.map(dir => {
-        const expanded = dir.replace(/^~/, os.homedir());
+        const expanded = dir.replace(/^~/, config.getConfigHome());
         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 
+        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());
-      
+      const expandedPath = inputPath.replace(/^~/, config.getConfigHome());
+
       // 如果是绝对路径
       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) => {
+    requireToolModule: moduleName => {
       try {
         // 首先尝试从工具的 node_modules 导入
         return toolRequire(moduleName);
@@ -239,42 +242,42 @@ export async function createToolContext(toolName, toolModule) {
         }
       }
     },
-    
+
     // 提供工具专用的动态导入函数（支持 ES 模块和 CommonJS）
-    importToolModule: async (moduleName) => {
+    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 });
@@ -285,12 +288,12 @@ export async function createToolContext(toolName, toolModule) {
           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]);
@@ -300,7 +303,7 @@ export async function createToolContext(toolName, toolModule) {
               logger.debug(`备用路径也失败: ${moduleName}`, { error: fallbackError.message });
             }
           }
-          
+
           // 如果 resolve 失败，尝试直接导入（可能从系统 node_modules）
           try {
             logger.debug(`尝试直接导入模块: ${moduleName}`);
@@ -318,7 +321,7 @@ export async function createToolContext(toolName, toolModule) {
       }
     }
   };
-  
+
   // 7. 将工具模块的所有方法复制到上下文中，并绑定this
   // 这样工具方法之间可以相互调用（如 execute 调用 this.initializeFilesystem）
   for (const [key, value] of Object.entries(toolModule)) {
@@ -328,7 +331,6 @@ export async function createToolContext(toolName, toolModule) {
       toolContext[key] = value;
     }
   }
-  
+
   return toolContext;
 }
-

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

@@ -1,20 +1,20 @@
 /**
  * 工具依赖管理服务
- * 
+ *
  * 职责：
  * 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';
+import { config } from '../utils/config.js';
 
 /**
  * 确保工具依赖已安装
@@ -22,34 +22,34 @@ import PackageInstaller from './package-installer.service.js';
  * @param {object} toolModule - 工具模块（可选，用于自动创建 package.json）
  */
 export async function ensureToolDependencies(toolName, toolModule = null) {
-  const toolDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
+  const toolDir = config.getToolDir(toolName);
   const packageJsonPath = path.join(toolDir, 'package.json');
   const nodeModulesPath = path.join(toolDir, 'node_modules');
-  
+
   // 检查 package.json 是否存在，如果不存在则自动创建
-  if (!await pathExists(packageJsonPath)) {
+  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);
-  
+  const needsInstall = !(await pathExists(nodeModulesPath)) || (await needsDependencyUpdate(toolDir, dependencies));
+
   if (needsInstall) {
     logger.info(`工具 ${toolName} 依赖需要安装或更新，开始安装...`);
     await installDependencies(toolDir, dependencies);
     return;
   }
-  
+
   logger.debug(`工具 ${toolName} 依赖已存在且为最新`);
 }
 
@@ -62,7 +62,7 @@ export async function ensureToolDependencies(toolName, toolModule = null) {
 async function createPackageJson(toolName, toolDir, toolModule) {
   // 确保工具目录存在
   await fs.ensureDir(toolDir);
-  
+
   // 获取工具依赖（如果工具模块提供了 getDependencies 方法）
   let dependencies = {};
   if (toolModule && typeof toolModule.getDependencies === 'function') {
@@ -72,7 +72,7 @@ async function createPackageJson(toolName, toolDir, toolModule) {
       logger.warn(`获取工具 ${toolName} 依赖失败:`, error.message);
     }
   }
-  
+
   // 获取工具元数据（用于 package.json 的基本信息）
   let metadata = { name: toolName, version: '1.0.0' };
   if (toolModule && typeof toolModule.getMetadata === 'function') {
@@ -82,7 +82,7 @@ async function createPackageJson(toolName, toolDir, toolModule) {
       logger.warn(`获取工具 ${toolName} 元数据失败:`, error.message);
     }
   }
-  
+
   // 创建 package.json
   const packageJson = {
     name: `@prompt-manager/tool-${toolName}`,
@@ -90,15 +90,15 @@ async function createPackageJson(toolName, toolDir, toolModule) {
     description: metadata.description || `Prompt Manager tool: ${toolName}`,
     main: `${toolName}.tool.js`,
     type: 'module',
-    dependencies: 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 
+
+  logger.info(`已为工具 ${toolName} 创建 package.json`, {
+    dependencies: Object.keys(dependencies).length
   });
 }
 
@@ -111,17 +111,17 @@ async function createPackageJson(toolName, toolDir, toolModule) {
 async function needsDependencyUpdate(toolDir, expectedDependencies) {
   try {
     // 检查每个依赖是否已安装且版本匹配
-    for (const [packageName, expectedVersion] of Object.entries(expectedDependencies)) {
+    for (const [packageName] 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 });
@@ -136,27 +136,26 @@ async function needsDependencyUpdate(toolDir, expectedDependencies) {
  */
 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,
+      dependencies,
       timeout: 300000 // 5分钟超时
     });
-    
+
     logger.info('依赖安装成功', {
       elapsed: result.elapsed,
       installedCount: result.installedPackages.length,
       packages: result.installedPackages
     });
-    
+
     return result;
-    
   } catch (error) {
-    logger.error('依赖安装失败', { 
+    logger.error('依赖安装失败', {
       error: error.message,
       toolDir,
       dependencies,
@@ -165,4 +164,3 @@ async function installDependencies(toolDir, dependencies) {
     throw new Error(`依赖安装失败: ${error.message}`);
   }
 }
-