@becrafter/prompt-manager 0.1.22 → 0.2.2

package/packages/server/api/open.routes.js

@@ -8,87 +8,88 @@ import { util } from '../utils/util.js';
 const router = express.Router();
 
 router.get('/prompts', (req, res) => {
-    try {
-        const prompts = util.getPromptsFromFiles();
+  try {
+    const prompts = util.getPromptsFromFiles();
 
-        // 过滤出启用的提示词
-        const filtered = prompts.filter(prompt => {
-            // 检查提示词本身是否启用
-            const promptActive = prompt.enabled === true;
-            if (!promptActive) return false;
-            
-            // 检查目录状态 - util.getPromptsFromFiles() 已经正确处理了继承的启用状态
-            // groupEnabled 已经考虑了父目录的禁用状态
-            const groupActive = prompt.groupEnabled !== false;
-            return groupActive;
-        });
-        logger.debug(`filtered prompts: ${JSON.stringify(filtered)}`);
+    // 过滤出启用的提示词
+    const filtered = prompts.filter(prompt => {
+      // 检查提示词本身是否启用
+      const promptActive = prompt.enabled === true;
+      if (!promptActive) return false;
 
-        // 判断是否有搜索参数，且搜索参数名为search
-        if (req.query.search) {
-            const search = req.query.search;
+      // 检查目录状态 - util.getPromptsFromFiles() 已经正确处理了继承的启用状态
+      // groupEnabled 已经考虑了父目录的禁用状态
+      const groupActive = prompt.groupEnabled !== false;
+      return groupActive;
+    });
+    logger.debug(`filtered prompts: ${JSON.stringify(filtered)}`);
 
-            // 实现相似度匹配算法
-            const searchResults = filtered.map(prompt => {
-                const score = util.calculateSimilarityScore(search, prompt);
-                return {
-                    prompt: {
-                        id: prompt.uniqueId,
-                        name: prompt.name,
-                        description: prompt.description || `Prompt: ${prompt.name}`,
-                        metadata: {
-                            // fileName: prompt.fileName,
-                            fullPath: prompt.relativePath
-                        }
-                    },
-                    score: score
-                };
-            })
-                .filter(result => result.score > 0) // 只返回有匹配的结果
-                .sort((a, b) => b.score - a.score); // 按相似度得分降序排列
+    // 判断是否有搜索参数，且搜索参数名为search
+    if (req.query.search) {
+      const search = req.query.search;
 
-            // 只返回prompt字段
-            res.json(searchResults.map(result => result.prompt));
-        } else {
-            // 无搜索参数时，返回精简信息
-            const simplifiedPrompts = filtered.map(prompt => ({
-                id: prompt.uniqueId,
-                name: prompt.name,
-                description: prompt.description || `Prompt: ${prompt.name}`,
-                metadata: {
-                    // fileName: prompt.fileName,
-                    fullPath: prompt.relativePath
-                }
-            }));
+      // 实现相似度匹配算法
+      const searchResults = filtered
+        .map(prompt => {
+          const score = util.calculateSimilarityScore(search, prompt);
+          return {
+            prompt: {
+              id: prompt.uniqueId,
+              name: prompt.name,
+              description: prompt.description || `Prompt: ${prompt.name}`,
+              metadata: {
+                // fileName: prompt.fileName,
+                fullPath: prompt.relativePath
+              }
+            },
+            score
+          };
+        })
+        .filter(result => result.score > 0) // 只返回有匹配的结果
+        .sort((a, b) => b.score - a.score); // 按相似度得分降序排列
 
-            res.json(simplifiedPrompts);
+      // 只返回prompt字段
+      res.json(searchResults.map(result => result.prompt));
+    } else {
+      // 无搜索参数时，返回精简信息
+      const simplifiedPrompts = filtered.map(prompt => ({
+        id: prompt.uniqueId,
+        name: prompt.name,
+        description: prompt.description || `Prompt: ${prompt.name}`,
+        metadata: {
+          // fileName: prompt.fileName,
+          fullPath: prompt.relativePath
         }
-    } catch (error) {
-        res.status(500).json({ error: error.message });
+      }));
+
+      res.json(simplifiedPrompts);
     }
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
 });
 
 // 查看提示词内容
 router.post('/process', async (req, res) => {
-    try {
-        const { promptName, arguments: args } = req.body;
-
-        if (!promptName) {
-            return res.status(400).json({ error: 'Missing promptName' });
-        }
+  try {
+    const { promptName, arguments: args } = req.body;
 
-        const prompts = util.getPromptsFromFiles();
-        const prompt = prompts.find(p => p.name === promptName);
+    if (!promptName) {
+      return res.status(400).json({ error: 'Missing promptName' });
+    }
 
-        if (!prompt) {
-            return res.status(404).json({ error: `Prompt "${promptName}" not found` });
-        }
+    const prompts = util.getPromptsFromFiles();
+    const prompt = prompts.find(p => p.name === promptName);
 
-        const processedPrompt = await util.processPromptContent(prompt, args);
-        res.json({ processedText: processedPrompt });
-    } catch (error) {
-        res.status(500).json({ error: error.message });
+    if (!prompt) {
+      return res.status(404).json({ error: `Prompt "${promptName}" not found` });
     }
+
+    const processedPrompt = await util.processPromptContent(prompt, args);
+    res.json({ processedText: processedPrompt });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
 });
 
-export const openRouter = router;
+export const openRouter = router;

package/packages/server/api/surge.routes.js

@@ -19,18 +19,17 @@ const surgeProxy = createProxyMiddleware({
   // 当路由已经去除了 /surge 前缀后，路径变为 /test_prompts.json
   // 我们需要将其重写为 /assets/test_prompts.json
   pathRewrite: {
-    '^/': '/assets/',  // 将 / 开头的路径重写为 /assets/ 开头
+    '^/': '/assets/' // 将 / 开头的路径重写为 /assets/ 开头
   },
   // 设置代理请求头
-  onProxyReq: (proxyReq, req, res) => {
+  onProxyReq: (_proxyReq, _req, _res) => {
     // 可以在这里添加自定义逻辑，如设置请求头等
-    console.log(`代理请求: ${req.method} ${req.url} -> ${surgeTarget}${req.url.replace(/^\/(.*)/, '/assets/$1')}`);
   },
-  onProxyRes: (proxyRes, req, res) => {
+  onProxyRes: (proxyRes, _req, _res) => {
     // 可以在这里添加自定义逻辑，如修改响应头等
     proxyRes.headers['surge-proxy'] = 'enabled';
   },
-  onError: (err, req, res) => {
+  onError: (err, _req, res) => {
     console.error('Surge 代理错误:', err);
     res.status(500).send('代理错误');
   }
@@ -40,4 +39,4 @@ const surgeProxy = createProxyMiddleware({
 // 由于在 app.js 中已经使用了 /surge 路径前缀，这里直接处理所有请求
 router.use(surgeProxy);
 
-export const surgeRouter = router;
+export const surgeRouter = router;

package/packages/server/api/tool.routes.js

@@ -11,19 +11,20 @@ import fse from 'fs-extra';
 import { logger } from '../utils/logger.js';
 import { toolLoaderService } from '../toolm/tool-loader.service.js';
 import { pathExists } from '../toolm/tool-utils.js';
-import os from 'os';
+import { config } from '../utils/config.js';
+import { authorConfigService } from '../services/author-config.service.js';
 
 // 配置 multer 用于处理文件上传
 const upload = multer({
   storage: multer.diskStorage({
     destination: (req, file, cb) => {
-      const uploadDir = path.join(os.homedir(), '.prompt-manager', 'temp');
+      const uploadDir = config.getTempDir();
       fs.ensureDirSync(uploadDir);
       cb(null, uploadDir);
     },
     filename: (req, file, cb) => {
       // 生成唯一文件名，避免并发上传冲突
-      const uniqueName = `${Date.now()}-${Math.round(Math.random() * 1E9)}-${file.originalname}`;
+      const uniqueName = `${Date.now()}-${Math.round(Math.random() * 1e9)}-${file.originalname}`;
       cb(null, uniqueName);
     }
   }),
@@ -53,14 +54,7 @@ router.get('/list', async (req, res) => {
       await toolLoaderService.initialize();
     }
 
-    const {
-      search,
-      category,
-      tags,
-      author,
-      page = 1,
-      limit = 20
-    } = req.query;
+    const { search, category, tags, author, page = 1, limit = 20 } = req.query;
 
     // 获取所有工具
     let tools = toolLoaderService.getAllTools();
@@ -76,9 +70,7 @@ router.get('/list', async (req, res) => {
     }
 
     if (category) {
-      tools = tools.filter(tool => 
-        tool.metadata.category === category
-      );
+      tools = tools.filter(tool => tool.metadata.category === category);
     }
 
     if (tags) {
@@ -91,9 +83,7 @@ router.get('/list', async (req, res) => {
 
     if (author) {
       const authorLower = author.toLowerCase();
-      tools = tools.filter(tool => 
-        tool.metadata.author?.toLowerCase() === authorLower
-      );
+      tools = tools.filter(tool => tool.metadata.author?.toLowerCase() === authorLower);
     }
 
     // 排序
@@ -105,21 +95,37 @@ router.get('/list', async (req, res) => {
     const endIndex = startIndex + limit;
     const paginatedTools = tools.slice(startIndex, endIndex);
 
-    // 格式化返回数据
-    const formattedTools = paginatedTools.map(tool => {
-      const metadata = tool.metadata || {};
-      return {
-        id: metadata.id || tool.name,
-        name: metadata.name || tool.name,
-        description: metadata.description || '',
-        version: metadata.version || '1.0.0',
-        category: metadata.category || 'other',
-        author: metadata.author || 'Prompt Manager',
-        tags: metadata.tags || [],
-        scenarios: metadata.scenarios || [],
-        limitations: metadata.limitations || []
-      };
-    });
+    const formattedTools = await Promise.all(
+      paginatedTools.map(async tool => {
+        const metadata = tool.metadata || {};
+        const authorName = metadata.author || 'BeCrafter';
+
+        const authorInfo = await authorConfigService.resolveAuthor(authorName);
+
+        return {
+          id: metadata.id || tool.name,
+          name: metadata.name || tool.name,
+          description: metadata.description || '',
+          version: metadata.version || '1.0.0',
+          category: metadata.category || 'other',
+          author: authorInfo.name,
+          author_info: {
+            id: authorInfo.id,
+            name: authorInfo.name,
+            github: authorInfo.github,
+            homepage: authorInfo.homepage,
+            bio: authorInfo.bio,
+            featured: authorInfo.featured,
+            sort_order: authorInfo.sort_order,
+            aliases: authorInfo.aliases,
+            avatar_url: authorInfo.avatar_url
+          },
+          tags: metadata.tags || [],
+          scenarios: metadata.scenarios || [],
+          limitations: metadata.limitations || []
+        };
+      })
+    );
 
     const response = {
       success: true,
@@ -130,7 +136,6 @@ router.get('/list', async (req, res) => {
     };
 
     res.json(response);
-
   } catch (error) {
     logger.error('获取工具列表失败:', error);
     res.status(500).json({
@@ -151,7 +156,7 @@ router.get('/detail/:toolName', async (req, res) => {
     }
 
     const { toolName } = req.params;
-    
+
     // 检查工具是否存在
     if (!toolLoaderService.hasTool(toolName)) {
       return res.status(404).json({
@@ -182,7 +187,6 @@ router.get('/detail/:toolName', async (req, res) => {
       success: true,
       tool: toolDetail
     });
-
   } catch (error) {
     logger.error('获取工具详情失败:', error);
     res.status(500).json({
@@ -203,7 +207,7 @@ router.get('/readme/:toolName', async (req, res) => {
     }
 
     const { toolName } = req.params;
-    
+
     // 检查工具是否存在
     if (!toolLoaderService.hasTool(toolName)) {
       return res.status(404).json({
@@ -212,13 +216,11 @@ router.get('/readme/:toolName', async (req, res) => {
       });
     }
 
-    const tool = toolLoaderService.getTool(toolName);
-    
     // 查找 README.md 文件
-    const toolboxDir = path.join(os.homedir(), '.prompt-manager', 'toolbox', toolName);
+    const toolboxDir = config.getToolDir(toolName);
     const readmePath = path.join(toolboxDir, 'README.md');
-    
-    if (!await pathExists(readmePath)) {
+
+    if (!(await pathExists(readmePath))) {
       return res.status(404).json({
         success: false,
         error: `工具 '${toolName}' 的 README.md 文件不存在`
@@ -227,13 +229,12 @@ router.get('/readme/:toolName', async (req, res) => {
 
     const fs = await import('fs');
     const readmeContent = await fs.promises.readFile(readmePath, 'utf-8');
-    
+
     res.json({
       success: true,
       toolName,
       content: readmeContent
     });
-
   } catch (error) {
     logger.error('读取工具 README 失败:', error);
     res.status(500).json({
@@ -245,7 +246,7 @@ router.get('/readme/:toolName', async (req, res) => {
 
 /**
  * 上传工具包
- * 
+ *
  * 上传内容必须是 .zip 文件
  * 上传后需要做工具名的重复性检查，重复的不允许会给出提示，让用户自己判断是否需要覆盖
  * 解压缩 .zip 文件，然后检查里面是否存在规范约定的两个文件，至少存在这两个
@@ -275,9 +276,9 @@ router.post('/upload', upload.single('file'), async (req, res) => {
     }
 
     // 创建临时解压目录
-    const tempDir = path.join(os.homedir(), '.prompt-manager', 'temp');
+    const tempDir = config.getTempDir();
     fs.ensureDirSync(tempDir);
-    extractedDir = path.join(tempDir, `extracted_${Date.now()}_${Math.round(Math.random() * 1E9)}`);
+    extractedDir = path.join(tempDir, `extracted_${Date.now()}_${Math.round(Math.random() * 1e9)}`);
     fs.ensureDirSync(extractedDir);
 
     // 解压ZIP文件
@@ -286,10 +287,10 @@ router.post('/upload', upload.single('file'), async (req, res) => {
 
     // 检查解压后的目录结构
     const files = fs.readdirSync(extractedDir);
-    
+
     // 查找工具文件（以 .tool.js 结尾的文件）
-    const toolFiles = files.filter(file => 
-      file.endsWith('.tool.js') && fs.statSync(path.join(extractedDir, file)).isFile()
+    const toolFiles = files.filter(
+      file => file.endsWith('.tool.js') && fs.statSync(path.join(extractedDir, file)).isFile()
     );
 
     if (toolFiles.length === 0) {
@@ -304,8 +305,8 @@ router.post('/upload', upload.single('file'), async (req, res) => {
     const toolName = toolFileName.replace('.tool.js', '');
 
     // 检查是否存在 README.md
-    const hasReadme = files.some(file => 
-      file.toLowerCase() === 'readme.md' && fs.statSync(path.join(extractedDir, file)).isFile()
+    const hasReadme = files.some(
+      file => file.toLowerCase() === 'readme.md' && fs.statSync(path.join(extractedDir, file)).isFile()
     );
 
     if (!hasReadme) {
@@ -316,7 +317,7 @@ router.post('/upload', upload.single('file'), async (req, res) => {
     }
 
     // 检查工具是否已存在
-    const toolboxDir = path.join(os.homedir(), '.prompt-manager', 'toolbox');
+    const toolboxDir = config.getToolboxDir();
     const targetToolDir = path.join(toolboxDir, toolName);
     const toolExists = await pathExists(targetToolDir);
 
@@ -325,7 +326,7 @@ router.post('/upload', upload.single('file'), async (req, res) => {
       return res.status(409).json({
         success: false,
         error: `工具 "${toolName}" 已存在`,
-        toolName: toolName,
+        toolName,
         canOverwrite: true
       });
     }
@@ -341,7 +342,7 @@ router.post('/upload', upload.single('file'), async (req, res) => {
 
     // 检查工具文件是否可导入（语法验证）
     const toolFilePath = path.join(targetToolDir, toolFileName);
-    if (!await pathExists(toolFilePath)) {
+    if (!(await pathExists(toolFilePath))) {
       return res.status(500).json({
         success: false,
         error: `工具文件 ${toolFileName} 不存在`
@@ -353,19 +354,19 @@ router.post('/upload', upload.single('file'), async (req, res) => {
     try {
       const toolModule = await import(`file://${toolFilePath}`);
       tool = toolModule.default || toolModule;
-      
+
       // 验证工具接口是否符合规范
       if (typeof tool.execute !== 'function') {
         return res.status(400).json({
           success: false,
-          error: `工具文件缺少必需的 execute 方法`
+          error: '工具文件缺少必需的 execute 方法'
         });
       }
-      
+
       // 运行测试验证工具是否能正常工作
       const { createToolContext } = await import('../toolm/tool-context.service.js');
-      const toolContext = await createToolContext(toolName, tool);
-      
+      await createToolContext(toolName, tool);
+
       // 执行一个简单的测试，检查工具是否能被正确初始化
       if (typeof tool.getMetadata === 'function') {
         try {
@@ -377,13 +378,12 @@ router.post('/upload', upload.single('file'), async (req, res) => {
           logger.warn(`工具 ${toolName} 的 getMetadata 方法调用失败:`, metaError.message);
         }
       }
-      
+
       // 简单测试 execute 方法是否存在
       if (tool.execute && typeof tool.execute === 'function') {
         // 为了安全起见，不实际执行工具，只验证其签名
         logger.info(`工具 ${toolName} 的 execute 方法存在，签名验证通过`);
       }
-      
     } catch (importError) {
       // 清理失败的工具目录
       await fse.remove(targetToolDir);
@@ -423,7 +423,7 @@ router.post('/upload', upload.single('file'), async (req, res) => {
         // 重新加载工具
         await toolLoaderService.reload();
       }
-      
+
       // 验证工具是否可以被加载
       if (toolLoaderService.hasTool(toolName)) {
         logger.info(`工具 ${toolName} 验证通过并已加载`);
@@ -435,22 +435,21 @@ router.post('/upload', upload.single('file'), async (req, res) => {
     res.json({
       success: true,
       message: `工具 ${toolName} 上传成功`,
-      toolName: toolName,
+      toolName,
       overwritten: toolExists && req.body.overwrite === 'true'
     });
-
   } catch (error) {
     logger.error('工具上传失败:', error);
-    
+
     // 清理临时文件
     try {
-      if (extractedDir && await pathExists(extractedDir)) {
+      if (extractedDir && (await pathExists(extractedDir))) {
         await fse.remove(extractedDir);
       }
     } catch (cleanupError) {
       logger.error('清理临时文件失败:', cleanupError);
     }
-    
+
     res.status(500).json({
       success: false,
       error: error.message
@@ -458,16 +457,16 @@ router.post('/upload', upload.single('file'), async (req, res) => {
   } finally {
     // 确保临时上传的ZIP文件被清理
     try {
-      if (tempZipPath && await pathExists(tempZipPath)) {
+      if (tempZipPath && (await pathExists(tempZipPath))) {
         await fse.remove(tempZipPath);
       }
     } catch (cleanupError) {
       logger.error('清理上传文件失败:', cleanupError);
     }
-    
+
     // 确保临时解压目录被清理
     try {
-      if (extractedDir && await pathExists(extractedDir)) {
+      if (extractedDir && (await pathExists(extractedDir))) {
         await fse.remove(extractedDir);
       }
     } catch (cleanupError) {
@@ -476,4 +475,4 @@ router.post('/upload', upload.single('file'), async (req, res) => {
   }
 });
 
-export { router as toolRouter };
+export { router as toolRouter };