@becrafter/prompt-manager 0.0.18 → 0.1.1

package/packages/server/toolm/index.js

@@ -0,0 +1,9 @@
+/**
+ * 工具系统入口
+ * 
+ * 提供工具系统的统一入口，导出所有工具系统组件
+ */
+
+export { toolLoaderService } from './tool-loader.service.js';
+export { handleToolM } from './tool-manager.handler.js';
+

package/packages/server/toolm/package-installer.service.js

@@ -0,0 +1,267 @@
+/**
+ * PackageInstaller - 基于 Arborist 的完整依赖管理器
+ * 
+ * 使用 npm 官方的 @npmcli/arborist，提供与 npm install 完全一致的行为
+ * 自动处理所有传递依赖、版本冲突、循环依赖等复杂场景
+ * 不依赖系统 npm，可在 Electron 环境中直接使用
+ */
+
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+import { logger } from '../utils/logger.js';
+
+class PackageInstaller {
+  /**
+   * 获取最优的npm registry
+   * 自动检测用户地区，选择最快的镜像源
+   */
+  static async getOptimalRegistry() {
+    try {
+      // 1. 检查环境变量中的用户配置
+      const userRegistry = process.env.NPM_REGISTRY || process.env.npm_config_registry;
+      if (userRegistry) {
+        logger.info(`[PackageInstaller] Using user configured registry: ${userRegistry}`);
+        return userRegistry;
+      }
+
+      // 2. 检测是否在中国地区（基于时区）
+      const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+      const isChina = timezone?.includes('Shanghai') || 
+                     timezone?.includes('Hong_Kong') ||
+                     timezone?.includes('Beijing') ||
+                     timezone?.includes('Chongqing');
+      
+      if (isChina) {
+        // 中国地区使用淘宝镜像
+        const chinaRegistry = 'https://registry.npmmirror.com';
+        logger.info(`[PackageInstaller] Detected China timezone (${timezone}), using mirror: ${chinaRegistry}`);
+        return chinaRegistry;
+      }
+
+      // 3. 默认使用官方源
+      const defaultRegistry = 'https://registry.npmjs.org/';
+      logger.debug(`[PackageInstaller] Using default registry: ${defaultRegistry}`);
+      return defaultRegistry;
+      
+    } catch (error) {
+      logger.warn(`[PackageInstaller] Failed to detect optimal registry: ${error.message}`);
+      return 'https://registry.npmjs.org/';
+    }
+  }
+
+  /**
+   * 统一的包安装入口 - 使用 Arborist 替代 npm install
+   * @param {Object} options - 安装选项
+   * @param {string} options.workingDir - 工作目录
+   * @param {Object|Array} options.dependencies - 依赖列表
+   * @param {number} options.timeout - 超时时间（毫秒）
+   * @returns {Promise<Object>} 安装结果
+   */
+  static async install({ workingDir, dependencies, timeout = 300000 }) {
+    const startTime = Date.now();
+    
+    // 构建依赖列表字符串用于日志
+    const depsList = this.buildDependenciesList(dependencies);
+    
+    logger.info(`[PackageInstaller] Starting installation via Arborist: [${depsList}]`);
+    logger.debug(`[PackageInstaller] Working directory: ${workingDir}`);
+    
+    try {
+      // 确保工作目录存在
+      await fs.ensureDir(workingDir);
+      
+      // 读取或创建package.json
+      const packageJsonPath = path.join(workingDir, 'package.json');
+      let manifest;
+      
+      try {
+        const content = await fs.readFile(packageJsonPath, 'utf8');
+        manifest = JSON.parse(content);
+        logger.debug(`[PackageInstaller] Found existing package.json`);
+      } catch (error) {
+        // package.json不存在，创建默认的
+        manifest = {
+          name: `toolbox-${path.basename(workingDir)}`,
+          version: '1.0.0',
+          description: `Tool dependencies for ${path.basename(workingDir)}`,
+          private: true,
+          dependencies: {}
+        };
+        logger.debug(`[PackageInstaller] Creating new package.json`);
+      }
+      
+      // 规范化依赖格式
+      const normalizedDeps = this.normalizeDependencies(dependencies);
+      
+      // 更新 manifest 的 dependencies
+      manifest.dependencies = { ...manifest.dependencies, ...normalizedDeps };
+      await fs.writeFile(packageJsonPath, JSON.stringify(manifest, null, 2));
+      
+      logger.debug(`[PackageInstaller] Installing ${Object.keys(normalizedDeps).length} dependencies using Arborist`);
+      
+      // 使用 Arborist 安装所有依赖（包括传递依赖）
+      // @npmcli/arborist 是 CommonJS 模块，使用 createRequire 导入
+      const { createRequire } = await import('module');
+      const require = createRequire(import.meta.url);
+      const { Arborist } = require('@npmcli/arborist');
+      
+      // 获取最优的registry
+      const registry = await this.getOptimalRegistry();
+      
+      const arb = new Arborist({
+        path: workingDir,
+        registry: registry,
+        cache: path.join(os.homedir(), '.npm', '_cacache'),
+        save: false,  // 不需要再次更新 package.json
+        omit: [],     // 安装所有依赖
+        force: false,
+        fund: false,
+        audit: false,
+        legacyPeerDeps: true  // 兼容旧包
+      });
+      
+      // 执行安装 - Arborist 会自动处理所有传递依赖
+      await arb.reify({
+        add: Object.entries(normalizedDeps).map(([name, version]) => `${name}@${version}`)
+      });
+      
+      // 加载实际安装的包信息
+      const tree = await arb.loadActual();
+      const installedPackages = [];
+      const installResults = {};
+      
+      // 收集安装的包信息
+      for (const [name, node] of tree.children) {
+        if (node && node.package) {
+          installedPackages.push(name);
+          installResults[name] = {
+            name: node.package.name,
+            version: node.package.version,
+            path: node.path
+          };
+          logger.debug(`[PackageInstaller] ✓ ${name}@${node.package.version} installed`);
+        }
+      }
+      
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      logger.info(`[PackageInstaller] Installation completed successfully in ${elapsed}s`);
+      logger.info(`[PackageInstaller] Installed ${installedPackages.length} packages with all transitive dependencies`);
+      
+      return {
+        success: true,
+        elapsed: elapsed,
+        manifest: manifest,
+        environment: 'arborist',
+        installedPackages: installedPackages,
+        results: installResults
+      };
+      
+    } catch (error) {
+      const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+      logger.error(`[PackageInstaller] Installation failed after ${elapsed}s: ${error.message}`);
+      
+      throw new Error(`Arborist installation failed: ${error.message}`);
+    }
+  }
+  
+  /**
+   * 构建依赖列表字符串用于日志
+   * @param {Object|Array} dependencies - 依赖
+   * @returns {string} 格式化的依赖列表
+   */
+  static buildDependenciesList(dependencies) {
+    if (!dependencies) return '';
+    
+    if (typeof dependencies === 'object' && !Array.isArray(dependencies)) {
+      // 对象格式：{"package": "version"}
+      return Object.keys(dependencies)
+        .map(name => `${name}@${dependencies[name]}`)
+        .join(', ');
+    } else if (Array.isArray(dependencies)) {
+      // 数组格式：["package@version"]
+      return dependencies.join(', ');
+    }
+    
+    return String(dependencies);
+  }
+  
+  /**
+   * 规范化依赖格式为对象
+   * @param {Object|Array} dependencies - 原始依赖
+   * @returns {Object} 规范化的依赖对象
+   */
+  static normalizeDependencies(dependencies) {
+    if (!dependencies) return {};
+    
+    if (typeof dependencies === 'object' && !Array.isArray(dependencies)) {
+      // 已经是对象格式
+      return dependencies;
+    }
+    
+    if (Array.isArray(dependencies)) {
+      // 数组格式转对象
+      const normalized = {};
+      for (const dep of dependencies) {
+        if (dep.includes('@')) {
+          const lastAtIndex = dep.lastIndexOf('@');
+          if (lastAtIndex > 0) {
+            const name = dep.substring(0, lastAtIndex);
+            const version = dep.substring(lastAtIndex + 1);
+            normalized[name] = version;
+          } else {
+            normalized[dep] = 'latest';
+          }
+        } else {
+          normalized[dep] = 'latest';
+        }
+      }
+      return normalized;
+    }
+    
+    return {};
+  }
+  
+  /**
+   * 检查包是否已安装
+   * @param {string} workingDir - 工作目录
+   * @param {string} packageName - 包名
+   * @returns {Promise<boolean>} 是否已安装
+   */
+  static async isPackageInstalled(workingDir, packageName) {
+    try {
+      const packagePath = packageName.startsWith('@') 
+        ? path.join(workingDir, 'node_modules', ...packageName.split('/'))
+        : path.join(workingDir, 'node_modules', packageName);
+        
+      const packageJsonPath = path.join(packagePath, 'package.json');
+      await fs.access(packageJsonPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  
+  /**
+   * 获取已安装包的信息
+   * @param {string} workingDir - 工作目录
+   * @param {string} packageName - 包名
+   * @returns {Promise<Object|null>} 包信息
+   */
+  static async getPackageInfo(workingDir, packageName) {
+    try {
+      const packagePath = packageName.startsWith('@')
+        ? path.join(workingDir, 'node_modules', ...packageName.split('/'))
+        : path.join(workingDir, 'node_modules', packageName);
+        
+      const packageJsonPath = path.join(packagePath, 'package.json');
+      const content = await fs.readFile(packageJsonPath, 'utf8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+}
+
+export default PackageInstaller;
+

package/packages/server/toolm/test-tools.js

@@ -0,0 +1,264 @@
+/**
+ * 工具系统测试文件
+ * 
+ * 用于验证工具加载、工具管理等功能是否正常工作
+ */
+
+import { toolLoaderService } from './tool-loader.service.js';
+import { handleToolM } from './tool-manager.handler.js';
+import { logger } from '../utils/logger.js';
+
+// 测试工具加载服务
+async function testToolLoader() {
+  console.log('\n========== 测试工具加载服务 ==========\n');
+  
+  try {
+    // 初始化工具加载器
+    console.log('1. 初始化工具加载器...');
+    await toolLoaderService.initialize();
+    console.log('✓ 工具加载器初始化成功');
+    
+    // 获取所有工具列表
+    console.log('\n2. 获取所有工具列表...');
+    const tools = toolLoaderService.getAllTools();
+    console.log(`✓ 共加载 ${tools.length} 个工具:`);
+    tools.forEach(tool => {
+      console.log(`  - ${tool.name}: ${tool.metadata.description || '无描述'}`);
+    });
+    
+    // 检查 filesystem 工具是否存在
+    console.log('\n3. 检查 filesystem 工具是否存在...');
+    const hasFilesystem = toolLoaderService.hasTool('filesystem');
+    if (hasFilesystem) {
+      console.log('✓ filesystem 工具已加载');
+      
+      // 获取 filesystem 工具详情
+      const filesystemTool = toolLoaderService.getTool('filesystem');
+      console.log(`  - 元数据:`, filesystemTool.metadata);
+    } else {
+      console.log('✗ filesystem 工具未找到');
+    }
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试手册模式
+async function testManualMode() {
+  console.log('\n========== 测试手册模式 (manual) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: manual`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 手册模式执行成功');
+    console.log('返回结果类型:', result.content[0].type);
+    console.log('手册内容长度:', result.content[0].text.length, '字符');
+    console.log('\n手册内容预览（前 500 字符）:');
+    console.log(result.content[0].text.substring(0, 500));
+    console.log('...\n');
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试执行模式
+async function testExecuteMode() {
+  console.log('\n========== 测试执行模式 (execute) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: execute
+parameters:
+  method: list_allowed_directories`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 执行模式测试成功');
+    console.log('返回结果:');
+    console.log(result.content[0].text);
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试配置模式
+async function testConfigureMode() {
+  console.log('\n========== 测试配置模式 (configure) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: configure
+parameters:
+  ALLOWED_DIRECTORIES: '["~/.prompt-manager", "/tmp"]'`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 配置模式测试成功');
+    console.log('返回结果:');
+    console.log(result.content[0].text);
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试日志模式
+async function testLogMode() {
+  console.log('\n========== 测试日志模式 (log) ==========\n');
+  
+  try {
+    const yamlInput = `tool: tool://filesystem
+mode: log
+parameters:
+  action: tail
+  lines: 50`;
+    
+    console.log('YAML 输入:');
+    console.log(yamlInput);
+    console.log('\n执行 handleToolM...');
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    
+    console.log('\n✓ 日志模式测试成功');
+    console.log('返回结果:');
+    console.log(result.content[0].text);
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 测试错误处理
+async function testErrorHandling() {
+  console.log('\n========== 测试错误处理 ==========\n');
+  
+  try {
+    console.log('1. 测试不存在的工具...');
+    try {
+      const yamlInput = `tool: tool://nonexistent
+mode: execute`;
+      await handleToolM({ yaml: yamlInput });
+      console.log('✗ 应该抛出错误但没有');
+      return false;
+    } catch (error) {
+      console.log('✓ 正确抛出错误:', error.message.split('\n')[0]);
+    }
+    
+    console.log('\n2. 测试缺少必需参数...');
+    try {
+      await handleToolM({});
+      console.log('✗ 应该抛出错误但没有');
+      return false;
+    } catch (error) {
+      console.log('✓ 正确抛出错误:', error.message);
+    }
+    
+    console.log('\n3. 测试无效的工具格式...');
+    try {
+      const yamlInput = `tool: filesystem
+mode: execute`;
+      await handleToolM({ yaml: yamlInput });
+      console.log('✗ 应该抛出错误但没有');
+      return false;
+    } catch (error) {
+      console.log('✓ 正确抛出错误:', error.message.split('\n')[0]);
+    }
+    
+    return true;
+  } catch (error) {
+    console.error('✗ 测试失败:', error.message);
+    console.error(error.stack);
+    return false;
+  }
+}
+
+// 主测试函数
+async function runAllTests() {
+  console.log('\n');
+  console.log('╔════════════════════════════════════════════════╗');
+  console.log('║     Prompt Manager 工具系统测试套件           ║');
+  console.log('╚════════════════════════════════════════════════╝');
+  
+  const results = [];
+  
+  // 运行所有测试
+  results.push({ name: '工具加载服务', passed: await testToolLoader() });
+  results.push({ name: '手册模式', passed: await testManualMode() });
+  results.push({ name: '执行模式', passed: await testExecuteMode() });
+  results.push({ name: '配置模式', passed: await testConfigureMode() });
+  results.push({ name: '日志模式', passed: await testLogMode() });
+  results.push({ name: '错误处理', passed: await testErrorHandling() });
+  
+  // 输出测试总结
+  console.log('\n');
+  console.log('╔════════════════════════════════════════════════╗');
+  console.log('║              测试结果总结                      ║');
+  console.log('╚════════════════════════════════════════════════╝');
+  console.log('\n');
+  
+  const passed = results.filter(r => r.passed).length;
+  const failed = results.filter(r => !r.passed).length;
+  
+  results.forEach(result => {
+    const status = result.passed ? '✓ PASS' : '✗ FAIL';
+    console.log(`${status} - ${result.name}`);
+  });
+  
+  console.log('\n');
+  console.log(`总计: ${results.length} 个测试`);
+  console.log(`通过: ${passed} 个`);
+  console.log(`失败: ${failed} 个`);
+  console.log('\n');
+  
+  if (failed === 0) {
+    console.log('🎉 所有测试通过！工具系统运行正常。');
+  } else {
+    console.log('⚠️  部分测试失败，请检查错误信息。');
+  }
+  
+  return failed === 0;
+}
+
+// 运行测试
+runAllTests()
+  .then(success => {
+    process.exit(success ? 0 : 1);
+  })
+  .catch(error => {
+    console.error('测试运行失败:', error);
+    process.exit(1);
+  });
+