@becrafter/prompt-manager 0.0.19 → 0.1.1

package/packages/server/toolm/validate-system.js

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+/**
+ * 工具系统全面验证脚本
+ * 
+ * 验证内容：
+ * 1. 目录结构是否完整
+ * 2. 文件是否存在且可读
+ * 3. 模块导入是否正常
+ * 4. 工具接口是否符合规范
+ * 5. MCP服务器集成是否正确
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { pathExists } from './tool-utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m'
+};
+
+function log(msg, color = 'reset') {
+  console.log(`${colors[color]}${msg}${colors.reset}`);
+}
+
+function success(msg) {
+  log(`✓ ${msg}`, 'green');
+}
+
+function error(msg) {
+  log(`✗ ${msg}`, 'red');
+}
+
+function warning(msg) {
+  log(`⚠ ${msg}`, 'yellow');
+}
+
+function info(msg) {
+  log(`ℹ ${msg}`, 'cyan');
+}
+
+function section(title) {
+  log(`\n${'='.repeat(60)}`, 'blue');
+  log(` ${title}`, 'bright');
+  log('='.repeat(60), 'blue');
+  console.log();
+}
+
+// 验证结果收集
+const results = {
+  total: 0,
+  passed: 0,
+  failed: 0,
+  warnings: 0,
+  errors: []
+};
+
+function check(description, test) {
+  results.total++;
+  try {
+    const result = test();
+    if (result === true || result === undefined) {
+      success(description);
+      results.passed++;
+      return true;
+    } else if (result === 'warning') {
+      warning(description);
+      results.warnings++;
+      return 'warning';
+    } else {
+      error(description);
+      results.failed++;
+      results.errors.push(description);
+      return false;
+    }
+  } catch (err) {
+    error(`${description}: ${err.message}`);
+    results.failed++;
+    results.errors.push(`${description}: ${err.message}`);
+    return false;
+  }
+}
+
+async function asyncCheck(description, test) {
+  results.total++;
+  try {
+    const result = await test();
+    if (result === true || result === undefined) {
+      success(description);
+      results.passed++;
+      return true;
+    } else if (result === 'warning') {
+      warning(description);
+      results.warnings++;
+      return 'warning';
+    } else {
+      error(description);
+      results.failed++;
+      results.errors.push(description);
+      return false;
+    }
+  } catch (err) {
+    error(`${description}: ${err.message}`);
+    results.failed++;
+    results.errors.push(`${description}: ${err.message}`);
+    return false;
+  }
+}
+
+// 1. 验证目录结构
+async function validateDirectoryStructure() {
+  section('1. 验证目录结构');
+  
+  const rootDir = path.join(__dirname, '..', '..', '..', '..');
+  const paths = {
+    'tools目录': path.join(__dirname),
+    '系统工具目录': path.join(rootDir, 'packages', 'resources', 'tools'),
+    '用户工具目录': path.join(os.homedir(), '.prompt-manager', 'tools'),
+  };
+  
+  for (const [name, dirPath] of Object.entries(paths)) {
+    await asyncCheck(`${name} 存在: ${dirPath}`, async () => {
+      const exists = await pathExists(dirPath);
+      if (!exists && name === '用户工具目录') {
+        // 用户工具目录不存在时创建
+        await fs.ensureDir(dirPath);
+        info(`  已创建目录: ${dirPath}`);
+        return 'warning';
+      }
+      return exists;
+    });
+  }
+}
+
+// 2. 验证核心文件
+async function validateCoreFiles() {
+  section('2. 验证核心文件');
+  
+  const coreFiles = [
+    { name: '工具加载服务', path: path.join(__dirname, 'tool-loader.service.js') },
+    { name: '工具管理处理器', path: path.join(__dirname, 'tool-manager.handler.js') },
+    { name: '工具系统入口', path: path.join(__dirname, 'index.js') },
+    { name: 'MCP服务器', path: path.join(__dirname, '..', 'mcp.server.js') },
+  ];
+  
+  for (const file of coreFiles) {
+    await asyncCheck(`${file.name} 文件存在`, async () => {
+      return await pathExists(file.path);
+    });
+    
+    await asyncCheck(`${file.name} 可读`, async () => {
+      try {
+        await fs.access(file.path, fs.constants.R_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+}
+
+// 3. 验证工具文件
+async function validateToolFiles() {
+  section('3. 验证工具文件');
+  
+  const rootDir = path.join(__dirname, '..', '..', '..', '..');
+  const toolsDir = path.join(rootDir, 'packages', 'resources', 'tools');
+  
+  if (!await pathExists(toolsDir)) {
+    error(`工具目录不存在: ${toolsDir}`);
+    return;
+  }
+  
+  const toolDirs = await fs.readdir(toolsDir);
+  info(`找到 ${toolDirs.length} 个工具目录`);
+  
+  for (const toolDir of toolDirs) {
+    const toolPath = path.join(toolsDir, toolDir);
+    const stat = await fs.stat(toolPath);
+    
+    if (!stat.isDirectory()) continue;
+    
+    const toolFile = path.join(toolPath, `${toolDir}.tool.js`);
+    await asyncCheck(`工具 '${toolDir}' 文件存在`, async () => {
+      return await pathExists(toolFile);
+    });
+  }
+}
+
+// 4. 验证模块导入
+async function validateModuleImports() {
+  section('4. 验证模块导入');
+  
+  // 验证工具加载服务
+  await asyncCheck('导入工具加载服务', async () => {
+    const module = await import('./tool-loader.service.js');
+    return module.toolLoaderService !== undefined;
+  });
+  
+  // 验证工具管理处理器
+  await asyncCheck('导入工具管理处理器', async () => {
+    const module = await import('./tool-manager.handler.js');
+    return typeof module.handleToolM === 'function';
+  });
+  
+  // 验证工具系统入口
+  await asyncCheck('导入工具系统入口', async () => {
+    const module = await import('./index.js');
+    return module.toolLoaderService !== undefined && module.handleToolM !== undefined;
+  });
+}
+
+// 5. 验证工具接口规范
+async function validateToolInterfaces() {
+  section('5. 验证工具接口规范');
+  
+  const rootDir = path.join(__dirname, '..', '..', '..', '..');
+  const toolsDir = path.join(rootDir, 'packages', 'resources', 'tools');
+  
+  if (!await pathExists(toolsDir)) {
+    warning('工具目录不存在，跳过接口验证');
+    return;
+  }
+  
+  const toolDirs = await fs.readdir(toolsDir);
+  
+  for (const toolDir of toolDirs) {
+    const toolPath = path.join(toolsDir, toolDir);
+    const stat = await fs.stat(toolPath);
+    
+    if (!stat.isDirectory()) continue;
+    
+    const toolFile = path.join(toolPath, `${toolDir}.tool.js`);
+    
+    if (!await pathExists(toolFile)) continue;
+    
+    await asyncCheck(`工具 '${toolDir}' 符合接口规范`, async () => {
+      const toolModule = await import(toolFile);
+      const tool = toolModule.default || toolModule;
+      
+      // 必需方法
+      if (typeof tool.execute !== 'function') {
+        throw new Error('缺少 execute 方法');
+      }
+      
+      // 推荐方法
+      const recommendedMethods = ['getMetadata', 'getSchema', 'getDependencies', 'getBusinessErrors'];
+      const missing = recommendedMethods.filter(method => typeof tool[method] !== 'function');
+      
+      if (missing.length > 0) {
+        info(`  缺少推荐方法: ${missing.join(', ')}`);
+      }
+      
+      return true;
+    });
+  }
+}
+
+// 6. 验证工具加载器功能
+async function validateToolLoaderFunctionality() {
+  section('6. 验证工具加载器功能');
+  
+  const { toolLoaderService } = await import('./tool-loader.service.js');
+  
+  await asyncCheck('初始化工具加载器', async () => {
+    await toolLoaderService.initialize();
+    return toolLoaderService.initialized === true;
+  });
+  
+  await asyncCheck('获取工具列表', async () => {
+    const tools = toolLoaderService.getAllTools();
+    info(`  加载了 ${tools.length} 个工具`);
+    return Array.isArray(tools);
+  });
+  
+  // 检查 filesystem 工具
+  await asyncCheck('filesystem 工具已加载', async () => {
+    return toolLoaderService.hasTool('filesystem');
+  });
+  
+  if (toolLoaderService.hasTool('filesystem')) {
+    await asyncCheck('获取 filesystem 工具详情', async () => {
+      const tool = toolLoaderService.getTool('filesystem');
+      info(`  工具名称: ${tool.metadata.name}`);
+      info(`  工具描述: ${tool.metadata.description}`);
+      return tool !== undefined;
+    });
+    
+    await asyncCheck('生成 filesystem 工具手册', async () => {
+      const manual = toolLoaderService.generateManual('filesystem');
+      return typeof manual === 'string' && manual.length > 0;
+    });
+  }
+}
+
+// 7. 验证工具管理处理器功能
+async function validateToolManagerFunctionality() {
+  section('7. 验证工具管理处理器功能');
+  
+  const { handleToolM } = await import('./tool-manager.handler.js');
+  
+  // 测试 manual 模式
+  await asyncCheck('手册模式正常工作', async () => {
+    const yamlInput = `tool: tool://filesystem
+mode: manual`;
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    return result.content && result.content[0].type === 'text';
+  });
+  
+  // 测试 execute 模式
+  await asyncCheck('执行模式正常工作', async () => {
+    const yamlInput = `tool: tool://filesystem
+mode: execute
+parameters:
+  method: list_allowed_directories`;
+    
+    const result = await handleToolM({ yaml: yamlInput });
+    return result.content && result.content[0].type === 'text';
+  });
+  
+  // 测试错误处理
+  await asyncCheck('错误处理正常工作', async () => {
+    try {
+      const yamlInput = `tool: tool://nonexistent
+mode: execute`;
+      await handleToolM({ yaml: yamlInput });
+      return false; // 应该抛出错误
+    } catch (error) {
+      return error.message.includes('不存在');
+    }
+  });
+}
+
+// 8. 验证 MCP 服务器集成
+async function validateMCPServerIntegration() {
+  section('8. 验证 MCP 服务器集成');
+  
+  await asyncCheck('MCP 服务器模块可导入', async () => {
+    const module = await import('../mcp.server.js');
+    return typeof module.getMcpServer === 'function';
+  });
+  
+  await asyncCheck('MCP 服务器包含 toolm 工具', async () => {
+    // 这需要实际启动服务器才能验证，这里只检查导入
+    info('  需要启动服务器才能完全验证，当前仅检查模块导入');
+    return 'warning';
+  });
+}
+
+// 9. 生成报告
+function generateReport() {
+  section('验证结果汇总');
+  
+  console.log(`总计测试: ${results.total}`);
+  log(`通过: ${results.passed}`, 'green');
+  if (results.warnings > 0) {
+    log(`警告: ${results.warnings}`, 'yellow');
+  }
+  if (results.failed > 0) {
+    log(`失败: ${results.failed}`, 'red');
+  }
+  
+  const percentage = (results.passed / results.total * 100).toFixed(1);
+  console.log(`\n通过率: ${percentage}%`);
+  
+  if (results.errors.length > 0) {
+    section('失败的测试');
+    results.errors.forEach((err, index) => {
+      error(`${index + 1}. ${err}`);
+    });
+  }
+  
+  console.log();
+  if (results.failed === 0) {
+    log('🎉 所有验证通过！工具系统已准备就绪。', 'green');
+    return true;
+  } else {
+    log('⚠️  部分验证失败，请检查并修复错误。', 'yellow');
+    return false;
+  }
+}
+
+// 主函数
+async function main() {
+  log('\n╔════════════════════════════════════════════════════════╗', 'cyan');
+  log('║     Prompt Manager 工具系统全面验证                    ║', 'cyan');
+  log('╚════════════════════════════════════════════════════════╝', 'cyan');
+  
+  try {
+    await validateDirectoryStructure();
+    await validateCoreFiles();
+    await validateToolFiles();
+    await validateModuleImports();
+    await validateToolInterfaces();
+    await validateToolLoaderFunctionality();
+    await validateToolManagerFunctionality();
+    await validateMCPServerIntegration();
+    
+    const success = generateReport();
+    process.exit(success ? 0 : 1);
+  } catch (error) {
+    console.error('\n验证过程中发生致命错误:');
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// 运行验证
+main();
+

package/packages/server/utils/config.js

@@ -3,6 +3,27 @@ import path from 'path';
 import os from 'os';
 import { fileURLToPath } from 'url';
 import crypto from 'crypto';
+import dotenv from 'dotenv';
+
+// 解析路径中的环境变量和 ~
+function expandPath(inputPath) {
+  if (!inputPath) return inputPath;
+
+  // 展开 ~ 为用户主目录
+  if (inputPath.startsWith('~/')) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+
+  // 展开环境变量（支持 ${VAR} 和 $VAR 格式）
+  return inputPath.replace(/\$(\w+)|\$\{(\w+)\}/g, (match, varName1, varName2) => {
+    const varName = varName1 || varName2;
+    return process.env[varName] || match; // 如果环境变量不存在，保留原值
+  });
+}
+
+// 加载 .env 文件
+const configHome = path.join(os.homedir(), '.prompt-manager');
+dotenv.config({ path: path.join(configHome, '.env') });
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -63,11 +84,16 @@ MCP Prompt Server - 智能 Prompt 管理服务器
   LOG_LEVEL                  日志级别 (默认: info)
   MAX_PROMPTS                最大prompt数量限制 (默认: 1000)
   RECURSIVE_SCAN             是否启用递归扫描子目录 (默认: true)
+  ADMIN_ENABLE               是否启用管理员功能 (默认: true)
+  ADMIN_REQUIRE_AUTH         是否需要登录认证 (默认: true)
+  ADMIN_USERNAME             管理员用户名 (默认: admin)
+  ADMIN_PASSWORD             管理员密码 (默认: admin)
 
 示例:
   node packages/server/server.js --prompts-dir /path/to/prompts
   node packages/server/server.js -p ./examples/prompts -P 8080
   LOG_LEVEL=debug node packages/server/server.js -p /custom/prompts
+  ADMIN_REQUIRE_AUTH=false node packages/server/server.js  # 禁用登录认证
 `);
 }
 
@@ -85,8 +111,8 @@ export class Config {
     }
 
     // 确定prompts目录
-    this.promptsDir = cliArgs.promptsDir ||
-      process.env.PROMPTS_DIR ||
+    this.promptsDir = expandPath(cliArgs.promptsDir) ||
+      expandPath(process.env.PROMPTS_DIR) ||
       DEFAULT_PROMPTS_DIR;
     this.configHome = path.dirname(this.promptsDir);
 
@@ -95,15 +121,20 @@ export class Config {
 
     // 其他配置
     this.serverName = process.env.MCP_SERVER_NAME || 'prompt-manager';
-    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.0.19';
+    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.1.1';
     this.logLevel = process.env.LOG_LEVEL || 'info';
     this.maxPrompts = parseInt(process.env.MAX_PROMPTS) || 1000;
     this.recursiveScan = process.env.RECURSIVE_SCAN !== 'false'; // 默认启用递归扫描
 
+    // Surge 静态资源代理配置
+    this.surgeTarget = process.env.SURGE_TARGET || 'https://becrafter.surge.sh';
+
     // 管理员配置
     this.adminEnable = process.env.ADMIN_ENABLE !== 'false'; // 默认启用管理员功能
     this.adminPath = process.env.ADMIN_PATH || '/admin';
     this.exportToken = process.env.EXPORT_TOKEN || crypto.randomBytes(32).toString('hex');
+    // 是否需要认证（默认需要）
+    this.adminRequireAuth = process.env.ADMIN_REQUIRE_AUTH !== 'false';
 
     // 管理员账户（从环境变量或默认值）
     const adminUsername = process.env.ADMIN_USERNAME || 'admin';
@@ -144,12 +175,14 @@ export class Config {
       recursiveScan,
       adminEnable,
       adminPath,
+      adminRequireAuth,
       admins,
-      exportToken
+      exportToken,
+      surgeTarget
     } = overrides;
 
     if (promptsDir) {
-      this.promptsDir = promptsDir;
+      this.promptsDir = expandPath(promptsDir);
       this.configHome = path.dirname(this.promptsDir);
     }
     if (port) {
@@ -176,12 +209,18 @@ export class Config {
     if (adminPath) {
       this.adminPath = adminPath;
     }
+    if (typeof adminRequireAuth === 'boolean') {
+      this.adminRequireAuth = adminRequireAuth;
+    }
     if (Array.isArray(admins) && admins.length) {
       this.admins = admins;
     }
     if (exportToken) {
       this.exportToken = exportToken;
     }
+    if (surgeTarget) {
+      this.surgeTarget = surgeTarget;
+    }
   }
 
 
@@ -276,6 +315,11 @@ export class Config {
     process.stderr.write(`   递归扫描: ${this.recursiveScan ? '启用' : '禁用'}\n`);
     process.stderr.write(`   Prompts目录: ${this.promptsDir}\n`);
     process.stderr.write(`   最大Prompt数量: ${this.maxPrompts}\n`);
+    process.stderr.write(`   管理员功能: ${this.adminEnable ? '启用' : '禁用'}\n`);
+    if (this.adminEnable) {
+      process.stderr.write(`   登录认证: ${this.adminRequireAuth ? '需要' : '不需要'}\n`);
+    }
+    process.stderr.write(`   Surge代理目标: ${this.surgeTarget}\n`);
     process.stderr.write('======================================================================================\n\n');
   }
 }

package/packages/server/utils/util.js

@@ -8,7 +8,8 @@ import { fileURLToPath } from 'url';
 import { logger } from './logger.js';
 
 export const GROUP_META_FILENAME = '.groupmeta.json';
-export const GROUP_NAME_REGEX = /^[a-zA-Z0-9-_\u4e00-\u9fa5]{1,64}$/;
+// 允许中文、空格、emoji 等字符，禁止路径分隔符及常见非法文件名字符
+export const GROUP_NAME_REGEX = /^(?![.]{1,2}$)[^\\/:*?"<>|\r\n]{1,64}$/;
 
 // 获取当前文件的目录路径
 const __filename = fileURLToPath(import.meta.url);
@@ -206,6 +207,7 @@ export class Util {
      * @returns 
      */
     isValidGroupName(name) {
+        if (typeof name !== 'string') return false;
         return GROUP_NAME_REGEX.test(name);
     }
 
@@ -334,20 +336,73 @@ export class Util {
       return content.trim();
     }
 
-    /**
-     * 获取admin-ui目录的绝对路径
-     * @returns {string} admin-ui目录的绝对路径
-     */
-    getAdminUiRoot() {
+    getWebUiRoot() {
+        // 检查是否在 Electron 环境中运行
+        const isElectron = typeof process !== 'undefined' && 
+                          process.versions && 
+                          process.versions.electron;
+        
+        // 检查是否是打包应用
+        if (isElectron && process.resourcesPath) {
+            // 检查是否在打包模式（在我们的应用目录下有 app.asar）
+            const ourAppAsar = path.join(process.resourcesPath, 'app.asar');
+            if (fs.existsSync(ourAppAsar)) {
+                // 在打包的 Electron 应用中，web UI 位于 app.asar 内
+                return path.join(process.resourcesPath, 'app.asar', 'web');
+            }
+        }
+        
+        // 在开发环境中，web UI 位于项目目录中的 packages/web
         const __filename = fileURLToPath(import.meta.url);
-        const __dirname = path.dirname(path.dirname(__filename));
-        return path.join(__dirname, '..', 'admin-ui');
+        const __dirname = path.dirname(__filename);
+        const devWebPath = path.join(__dirname, '..', 'web');
+        
+        if (this._pathExistsSync(devWebPath)) {
+            return devWebPath;
+        }
+        
+        // 如果上面的路径不存在，尝试从项目根目录查找
+        const projectRoot = path.resolve(__dirname, '../../..');
+        const altWebPath = path.join(projectRoot, 'packages', 'web');
+        if (this._pathExistsSync(altWebPath)) {
+            return altWebPath;
+        }
+        
+        // 返回默认路径
+        return devWebPath;
+    };
+    
+    _pathExistsSync(filePath) {
+        try {
+            fs.accessSync(filePath, fs.constants.F_OK);
+            return true;
+        } catch (error) {
+            return false;
+        }
     };
 
     async getPromptManager() {
     if (!_promptManager) {
-        const serviceModule = await import('../services/manager.js');
-        _promptManager = serviceModule.promptManager;
+        try {
+            // 首先尝试相对路径导入
+            const serviceModule = await import('../services/manager.js');
+            _promptManager = serviceModule.promptManager;
+        } catch (error) {
+            // 如果相对路径导入失败，尝试使用绝对路径
+            try {
+                const path = await import('path');
+                const { fileURLToPath } = await import('url');
+                const __filename = fileURLToPath(import.meta.url);
+                const __dirname = path.dirname(__filename);
+                const managerPath = path.join(__dirname, '..', 'services', 'manager.js');
+                const serviceModule = await import(managerPath);
+                _promptManager = serviceModule.promptManager;
+            } catch (absolutePathError) {
+                // 如果绝对路径也失败，记录错误并重新抛出
+                console.error('Failed to import promptManager with both relative and absolute paths:', absolutePathError);
+                throw absolutePathError;
+            }
+        }
     }
     return _promptManager;
     }