@becrafter/prompt-manager 0.1.2 → 0.1.9

package/packages/server/services/template.service.js

@@ -0,0 +1,333 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import YAML from 'yaml';
+import { z } from 'zod';
+import crypto from 'crypto';
+import os from 'os';
+import { logger } from '../utils/logger.js';
+import { config } from '../utils/config.js';
+import { util } from '../utils/util.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 模板数据结构验证schema
+ */
+const TemplateSchema = z.object({
+  id: z.string().optional(),
+  name: z.string().min(1, '模板名称不能为空'),
+  description: z.string().optional(),
+  content: z.union([z.string(), z.array(z.any())]).default(''),
+  type: z.enum(['optimize', 'iterate']).default('optimize'),
+  format: z.enum(['simple', 'advanced']).default('simple'),
+  isBuiltIn: z.boolean().optional().default(false),
+  filePath: z.string().optional()
+});
+
+/**
+ * 模板管理器类
+ */
+class TemplateManager {
+  constructor() {
+    this.builtInDir = path.join(util.getBuiltInConfigsDir(), 'templates/built-in');
+    this.customDir = path.join(os.homedir(), '.prompt-manager/configs/templates');
+    this.loadedTemplates = new Map();
+    this.idToPathMap = new Map();
+  }
+
+  /**
+   * 基于文件路径生成固定长度的唯一ID
+   * @param {string} relativePath - 相对于模板目录的路径
+   * @returns {string} 固定长度的唯一ID字符串（8位）
+   */
+  generateUniqueId(relativePath) {
+    const hash = crypto.createHash('sha256');
+    hash.update(relativePath);
+    const hashHex = hash.digest('hex');
+    return hashHex.substring(0, 8);
+  }
+
+  /**
+   * 注册ID到路径的映射
+   * @param {string} id - 唯一ID
+   * @param {string} relativePath - 相对路径
+   */
+  registerIdPathMapping(id, relativePath) {
+    this.idToPathMap.set(id, relativePath);
+  }
+
+  /**
+   * 确保目录存在
+   */
+  async ensureDirectories() {
+    await fs.ensureDir(this.builtInDir);
+    await fs.ensureDir(this.customDir);
+  }
+
+  /**
+   * 加载所有模板
+   */
+  async loadTemplates() {
+    try {
+      logger.info('开始加载优化模板');
+
+      // 确保目录存在
+      await this.ensureDirectories();
+
+      // 清空之前的加载结果
+      this.loadedTemplates.clear();
+      this.idToPathMap.clear();
+
+      // 加载内置模板
+      await this.loadTemplatesFromDir(this.builtInDir, true);
+
+      // 加载用户自定义模板
+      await this.loadTemplatesFromDir(this.customDir, false);
+
+      logger.info(`模板加载完成: 共 ${this.loadedTemplates.size} 个模板`);
+
+      return {
+        success: this.loadedTemplates.size,
+        templates: Array.from(this.loadedTemplates.values())
+      };
+    } catch (error) {
+      logger.error('加载模板时发生错误:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 从指定目录加载模板
+   * @param {string} dir - 目录路径
+   * @param {boolean} isBuiltIn - 是否为内置模板
+   */
+  async loadTemplatesFromDir(dir, isBuiltIn) {
+    try {
+      if (!fs.existsSync(dir)) {
+        logger.warn(`模板目录不存在: ${dir}`);
+        return;
+      }
+
+      const files = await fs.readdir(dir);
+      const templateFiles = files.filter(file => {
+        const ext = path.extname(file).toLowerCase();
+        return ['.yaml', '.yml', '.json'].includes(ext);
+      });
+
+      for (const fileName of templateFiles) {
+        const filePath = path.join(dir, fileName);
+        const relativePath = fileName;
+
+        try {
+          const content = await fs.readFile(filePath, 'utf8');
+          const ext = path.extname(fileName).toLowerCase();
+
+          let templateData;
+          if (ext === '.json') {
+            templateData = JSON.parse(content);
+          } else {
+            templateData = YAML.parse(content);
+          }
+
+          // 验证模板数据结构
+          const validatedTemplate = TemplateSchema.parse(templateData);
+
+          // 添加元数据
+          validatedTemplate.isBuiltIn = isBuiltIn;
+          validatedTemplate.filePath = filePath;
+
+          // 生成唯一ID
+          const uniqueId = this.generateUniqueId(relativePath);
+          validatedTemplate.id = uniqueId;
+
+          // 注册ID到路径的映射
+          this.registerIdPathMapping(uniqueId, relativePath);
+
+          // 存储模板
+          this.loadedTemplates.set(uniqueId, validatedTemplate);
+
+          logger.debug(`加载模板: ${validatedTemplate.name} -> ID: ${uniqueId} (${isBuiltIn ? '内置' : '自定义'})`);
+        } catch (error) {
+          logger.error(`加载模板文件 ${fileName} 失败:`, error.message);
+        }
+      }
+    } catch (error) {
+      logger.error(`扫描模板目录 ${dir} 时发生错误:`, error.message);
+    }
+  }
+
+  /**
+   * 获取所有已加载的模板
+   */
+  getTemplates() {
+    return Array.from(this.loadedTemplates.values());
+  }
+
+  /**
+   * 根据ID获取模板
+   * @param {string} id - 模板ID
+   */
+  getTemplate(id) {
+    return this.loadedTemplates.get(id) || null;
+  }
+
+  /**
+   * 创建新模板
+   * @param {Object} templateData - 模板数据
+   * @returns {Object} 创建的模板
+   */
+  async createTemplate(templateData) {
+    try {
+      // 验证模板数据
+      const validatedTemplate = TemplateSchema.parse(templateData);
+
+      // 生成文件名（使用名称的拼音或英文，这里简化为使用名称）
+      const fileName = `${validatedTemplate.name.replace(/\s+/g, '_')}.yaml`;
+      const filePath = path.join(this.customDir, fileName);
+
+      // 检查文件是否已存在
+      if (fs.existsSync(filePath)) {
+        throw new Error(`模板 ${validatedTemplate.name} 已存在`);
+      }
+
+      // 准备保存的数据
+      const dataToSave = {
+        name: validatedTemplate.name,
+        description: validatedTemplate.description || '',
+        content: validatedTemplate.content,
+        type: validatedTemplate.type,
+        format: validatedTemplate.format
+      };
+
+      // 保存为 YAML 文件
+      await fs.writeFile(filePath, YAML.stringify(dataToSave), 'utf8');
+
+      // 生成唯一ID
+      const uniqueId = this.generateUniqueId(fileName);
+
+      // 更新模板数据
+      validatedTemplate.id = uniqueId;
+      validatedTemplate.isBuiltIn = false;
+      validatedTemplate.filePath = filePath;
+
+      // 注册ID到路径的映射
+      this.registerIdPathMapping(uniqueId, fileName);
+
+      // 存储到内存
+      this.loadedTemplates.set(uniqueId, validatedTemplate);
+
+      logger.info(`创建模板: ${validatedTemplate.name} -> ID: ${uniqueId}`);
+
+      return validatedTemplate;
+    } catch (error) {
+      logger.error('创建模板失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 更新模板
+   * @param {string} id - 模板ID
+   * @param {Object} templateData - 新的模板数据
+   * @returns {Object} 更新后的模板
+   */
+  async updateTemplate(id, templateData) {
+    try {
+      const existingTemplate = this.getTemplate(id);
+
+      if (!existingTemplate) {
+        throw new Error(`模板不存在: ${id}`);
+      }
+
+      // 内置模板不能修改
+      if (existingTemplate.isBuiltIn) {
+        throw new Error('内置模板不能修改');
+      }
+
+      // 验证模板数据
+      const validatedTemplate = TemplateSchema.parse(templateData);
+
+      // 准备保存的数据
+      const dataToSave = {
+        name: validatedTemplate.name,
+        description: validatedTemplate.description || '',
+        content: validatedTemplate.content,
+        type: validatedTemplate.type,
+        format: validatedTemplate.format
+      };
+
+      // 更新文件
+      await fs.writeFile(existingTemplate.filePath, YAML.stringify(dataToSave), 'utf8');
+
+      // 更新内存中的数据
+      existingTemplate.name = validatedTemplate.name;
+      existingTemplate.description = validatedTemplate.description;
+      existingTemplate.content = validatedTemplate.content;
+      existingTemplate.type = validatedTemplate.type;
+      existingTemplate.format = validatedTemplate.format;
+
+      logger.info(`更新模板: ${existingTemplate.name} -> ID: ${id}`);
+
+      return existingTemplate;
+    } catch (error) {
+      logger.error('更新模板失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 删除模板
+   * @param {string} id - 模板ID
+   */
+  async deleteTemplate(id) {
+    try {
+      const template = this.getTemplate(id);
+
+      if (!template) {
+        throw new Error(`模板不存在: ${id}`);
+      }
+
+      // 内置模板不能删除
+      if (template.isBuiltIn) {
+        throw new Error('内置模板不能删除');
+      }
+
+      // 删除文件
+      await fs.remove(template.filePath);
+
+      // 从内存中移除
+      this.loadedTemplates.delete(id);
+      this.idToPathMap.delete(id);
+
+      logger.info(`删除模板: ${template.name} -> ID: ${id}`);
+    } catch (error) {
+      logger.error('删除模板失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 重新加载模板
+   */
+  async reloadTemplates() {
+    logger.info('重新加载模板');
+    return await this.loadTemplates();
+  }
+
+  /**
+   * 验证模板数据结构
+   * @param {Object} templateData - 要验证的模板数据
+   * @returns {Object} 验证后的模板数据
+   */
+  validateTemplateData(templateData) {
+    return TemplateSchema.parse(templateData);
+  }
+}
+
+// 创建全局TemplateManager实例
+export const templateManager = new TemplateManager();
+
+// 导出TemplateManager类供测试使用
+export { TemplateManager };

package/packages/server/toolm/tool-description-generator-optimized.service.js

@@ -240,7 +240,10 @@ export function generateToolmDescription() {
     const toolComparison = generateToolComparison(tools);
     
     // 组装完整的描述（优化结构，减少冗余）
-    const description = `ToolM 是 Prompt Manager 新一代工具系统运行时，提供统一的工具管理和执行能力。
+    const description = `🛠️ ToolM 是 Prompt Manager 新一代工具系统运行时，提供统一的工具管理和执行能力。
+
+【规范名称】promptmanager_toolm
+【调用说明】在提示词中使用 promptmanager_toolm，实际调用时自动映射到 mcp__[server]__action
 
 ## 核心特性
 
@@ -318,7 +321,7 @@ ${categorizedToolList}
  * @returns {string} 默认描述
  */
 function getDefaultDescription() {
-  return `ToolM 是 Prompt Manager 新一代工具系统运行时，提供统一的工具管理和执行能力。
+  return `🛠️ ToolM 是 Prompt Manager 新一代工具系统运行时，提供统一的工具管理和执行能力。
 
 ## 核心特性
 

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

@@ -27,8 +27,28 @@ const __dirname = path.dirname(__filename);
 export async function syncSystemTools() {
   logger.info('开始同步系统工具到沙箱环境...');
   
-  // 系统工具源目录
-  const toolsDir = path.join(__dirname, '..', '..', 'resources', 'tools');
+  // 判断运行环境类型
+  const isElectronPackaged = process.resourcesPath &&
+                            (process.resourcesPath.includes('app.asar') ||
+                             process.resourcesPath.includes('Electron.app'));
+
+  const isNpmPackage = __dirname.includes('node_modules');
+
+  let toolsDir;
+
+  if (isElectronPackaged) {
+    // Electron 打包环境：工具位于 runtime/toolbox/
+    toolsDir = path.join(process.resourcesPath, 'runtime', 'toolbox');
+    logger.debug('Electron 打包环境，使用工具目录:', { toolsDir });
+  } else if (isNpmPackage) {
+    // NPM 包环境：工具位于 packages/resources/tools/
+    toolsDir = path.join(__dirname, '..', '..', 'resources', 'tools');
+    logger.debug('NPM 包环境，使用工具目录:', { toolsDir });
+  } else {
+    // 开发环境：工具位于 packages/resources/tools/
+    toolsDir = path.join(__dirname, '..', '..', 'resources', 'tools');
+    logger.debug('开发环境，使用工具目录:', { toolsDir });
+  }
   
   // 目标沙箱目录
   const toolboxDir = path.join(os.homedir(), '.prompt-manager', 'toolbox');
@@ -39,7 +59,31 @@ export async function syncSystemTools() {
   // 检查源目录是否存在
   if (!await pathExists(toolsDir)) {
     logger.warn(`系统工具目录不存在，跳过同步: ${toolsDir}`);
-    return;
+    
+    // 在打包环境中，如果工具目录不存在，尝试从其他可能的位置查找
+    if (isPackaged) {
+      // 尝试其他可能的路径
+      const alternativePaths = [
+        path.join(process.resourcesPath, 'app.asar', 'runtime', 'toolbox'),
+        path.join(process.resourcesPath, '..', 'runtime', 'toolbox'),
+        path.join(__dirname, '..', '..', 'resources', 'tools') // 回退到开发路径
+      ];
+      
+      for (const altPath of alternativePaths) {
+        if (await pathExists(altPath)) {
+          toolsDir = altPath;
+          logger.info(`找到替代工具目录: ${toolsDir}`);
+          break;
+        }
+      }
+      
+      if (!await pathExists(toolsDir)) {
+        logger.warn('所有可能的工具目录都不存在，跳过工具同步');
+        return;
+      }
+    } else {
+      return;
+    }
   }
   
   try {

package/packages/server/utils/config.js

@@ -121,7 +121,7 @@ export class Config {
 
     // 其他配置
     this.serverName = process.env.MCP_SERVER_NAME || 'prompt-manager';
-    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.1.2';
+    this.serverVersion = process.env.MCP_SERVER_VERSION || '0.1.9';
     this.logLevel = process.env.LOG_LEVEL || 'info';
     this.maxPrompts = parseInt(process.env.MAX_PROMPTS) || 1000;
     this.recursiveScan = process.env.RECURSIVE_SCAN !== 'false'; // 默认启用递归扫描
@@ -255,6 +255,13 @@ export class Config {
     return this.port;
   }
 
+  /**
+   * 设置服务器端口（用于动态端口分配）
+   */
+  setPort(port) {
+    this.port = port;
+  }
+
   /**
    * 获取服务器名称
    */

package/packages/server/utils/port-checker.js

@@ -0,0 +1,63 @@
+import net from 'net';
+
+/**
+ * 检查指定端口是否可用
+ * @param {number} port - 要检查的端口号
+ * @returns {Promise<boolean>} - 端口是否可用
+ */
+export async function checkPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    
+    server.listen(port, () => {
+      server.once('close', () => {
+        resolve(true);
+      });
+      server.close();
+    });
+    
+    server.on('error', () => {
+      resolve(false);
+    });
+  });
+}
+
+/**
+ * 在指定范围内查找可用端口
+ * @param {number} startPort - 起始端口号
+ * @param {number} maxAttempts - 最大尝试次数
+ * @returns {Promise<number>} - 可用的端口号
+ */
+export async function findAvailablePort(startPort, maxAttempts = 10) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await checkPortAvailable(port)) {
+      return port;
+    }
+  }
+  throw new Error(`无法在 ${startPort} 到 ${startPort + maxAttempts - 1} 范围内找到可用端口`);
+}
+
+/**
+ * 检查端口是否被特定进程占用
+ * @param {number} port - 端口号
+ * @returns {Promise<Object>} - 端口占用信息
+ */
+export async function getPortInfo(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    
+    server.listen(port, () => {
+      server.close();
+      resolve({ available: true, process: null });
+    });
+    
+    server.on('error', (error) => {
+      if (error.code === 'EADDRINUSE') {
+        resolve({ available: false, error: '端口已被占用' });
+      } else {
+        resolve({ available: false, error: error.message });
+      }
+    });
+  });
+}

package/packages/server/utils/util.js

@@ -371,6 +371,33 @@ export class Util {
         // 返回默认路径
         return devWebPath;
     };
+
+    /**
+     * 获取内置配置文件目录
+     * 兼容开发环境和打包后的环境
+     * @returns {string} 配置目录路径
+     */
+    getBuiltInConfigsDir() {
+        // 检查是否在 Electron 环境中运行
+        const isElectron = typeof process !== 'undefined' && 
+                          process.versions && 
+                          process.versions.electron;
+        
+        // 检查是否是打包应用
+        // 在 macOS 打包应用中，process.resourcesPath 存在
+        if (process.resourcesPath) {
+            // 在打包应用中，内置配置位于 Resources/runtime/configs/
+            const packagedConfigPath = path.join(process.resourcesPath, 'runtime', 'configs');
+            if (this._pathExistsSync(packagedConfigPath)) {
+                return packagedConfigPath;
+            }
+        }
+        
+        // 在开发环境中，配置位于 packages/server/configs/
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        return path.resolve(__dirname, '../configs');
+    }
     
     _pathExistsSync(filePath) {
         try {