@lmcc-dev/mult-fetch-mcp-server 1.1.0 → 1.2.1

package/dist/tests/server/browser.test.js

@@ -3,24 +3,27 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { BrowserFetcher } from '../../src/lib/BrowserFetcher.js';
+import { BrowserInstance } from '../../src/lib/fetchers/browser/BrowserInstance.js';
+import { vi, describe, test, expect, beforeEach } from 'vitest';
+import * as logger from '../../src/lib/logger.js';
+import * as browserModule from '../../src/lib/server/browser.js';
 // 模拟依赖
-jest.mock('../../src/lib/BrowserFetcher.js');
-jest.mock('../../src/lib/logger.js', () => {
+vi.mock('../../src/lib/fetchers/browser/BrowserInstance.js');
+vi.mock('../../src/lib/logger.js', () => {
     return {
-        log: jest.fn(),
+        log: vi.fn(),
         COMPONENTS: {
             SERVER: 'server'
         }
     };
 });
 // 获取模拟的 log 函数和 COMPONENTS
-const { log, COMPONENTS } = require('../../src/lib/logger.js');
+const { log, COMPONENTS } = logger;
 // 模拟 browser.js 模块
 let browserInitialized = false;
-jest.mock('../../src/lib/server/browser.js', () => {
+vi.mock('../../src/lib/server/browser.js', () => {
     return {
-        initializeBrowser: jest.fn(async (debug = false) => {
+        initializeBrowser: vi.fn(async (debug = false) => {
             if (!browserInitialized) {
                 if (debug) {
                     log('server.initializingBrowser', debug, {}, COMPONENTS.SERVER);
@@ -28,16 +31,16 @@ jest.mock('../../src/lib/server/browser.js', () => {
                 browserInitialized = true;
             }
         }),
-        closeBrowserInstance: jest.fn(async (debug = false) => {
+        closeBrowserInstance: vi.fn(async (debug = false) => {
             if (browserInitialized) {
                 if (debug) {
                     log('server.closingBrowser', debug, {}, COMPONENTS.SERVER);
                 }
-                await BrowserFetcher.closeBrowser(true);
+                await BrowserInstance.closeBrowser(debug);
                 browserInitialized = false;
             }
         }),
-        shouldSwitchToBrowser: jest.fn((error) => {
+        shouldSwitchToBrowser: vi.fn((error) => {
             if (error && error.message) {
                 const errorMessage = error.message.toLowerCase();
                 return errorMessage.includes('403') ||
@@ -48,26 +51,27 @@ jest.mock('../../src/lib/server/browser.js', () => {
             }
             return false;
         }),
-        shouldUseBrowser: jest.fn((response, url) => {
+        shouldUseBrowser: vi.fn((response, url) => {
             if (response.isError) {
                 const errorText = response.content[0].text.toLowerCase();
                 return errorText.includes('403') ||
                     errorText.includes('forbidden') ||
                     errorText.includes('cloudflare') ||
-                    errorText.includes('javascript required');
+                    errorText.includes('timeout') ||
+                    errorText.includes('econnrefused');
             }
             return false;
         })
     };
 });
-// 导入被测试的函数
-const { initializeBrowser, closeBrowserInstance, shouldSwitchToBrowser, shouldUseBrowser } = require('../../src/lib/server/browser.js');
+// 从模块中获取函数
+const { initializeBrowser, closeBrowserInstance, shouldSwitchToBrowser, shouldUseBrowser } = browserModule;
 describe('浏览器管理函数测试 (Browser Management Functions Tests)', () => {
     beforeEach(() => {
         // 重置所有模拟
-        jest.clearAllMocks();
+        vi.clearAllMocks();
         // 设置默认返回值
-        BrowserFetcher.closeBrowser.mockResolvedValue(undefined);
+        BrowserInstance.closeBrowser.mockResolvedValue(undefined);
         // 重置 browserInitialized 变量
         browserInitialized = false;
     });
@@ -87,7 +91,7 @@ describe('浏览器管理函数测试 (Browser Management Functions Tests)', ()
         test('应该只初始化一次浏览器 (Should initialize browser only once)', async () => {
             // 调用被测试的函数两次
             await initializeBrowser(true);
-            jest.clearAllMocks(); // 清除第一次调用的记录
+            vi.clearAllMocks(); // 清除第一次调用的记录
             await initializeBrowser(true);
             // 验证第二次调用时 log 函数没有被调用
             expect(log).not.toHaveBeenCalled();
@@ -99,8 +103,8 @@ describe('浏览器管理函数测试 (Browser Management Functions Tests)', ()
             await initializeBrowser();
             // 调用被测试的函数
             await closeBrowserInstance();
-            // 验证 BrowserFetcher.closeBrowser 被调用
-            expect(BrowserFetcher.closeBrowser).toHaveBeenCalledWith(true);
+            // 验证 BrowserInstance.closeBrowser 被调用
+            expect(BrowserInstance.closeBrowser).toHaveBeenCalled();
         });
         test('应该在调试模式下记录日志 (Should log in debug mode)', async () => {
             // 首先初始化浏览器
@@ -115,8 +119,8 @@ describe('浏览器管理函数测试 (Browser Management Functions Tests)', ()
             browserInitialized = false;
             // 调用被测试的函数
             await closeBrowserInstance();
-            // 验证 BrowserFetcher.closeBrowser 没有被调用
-            expect(BrowserFetcher.closeBrowser).not.toHaveBeenCalled();
+            // 验证 BrowserInstance.closeBrowser 没有被调用
+            expect(BrowserInstance.closeBrowser).not.toHaveBeenCalled();
         });
     });
     describe('shouldSwitchToBrowser 函数测试 (shouldSwitchToBrowser Function Tests)', () => {

package/dist/tests/server/fetcher.test.js

@@ -4,15 +4,14 @@
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
 import { fetchWithAutoDetect } from '../../src/lib/server/fetcher.js';
-import { BrowserFetcher } from '../../src/lib/BrowserFetcher.js';
-import { NodeFetcher } from '../../src/lib/NodeFetcher.js';
+import { Fetcher } from '../../src/lib/fetch.js';
 import { initializeBrowser, closeBrowserInstance, shouldSwitchToBrowser } from '../../src/lib/server/browser.js';
+import { vi, describe, test, expect, beforeEach } from 'vitest';
 // 模拟依赖
-jest.mock('../../src/lib/BrowserFetcher.js');
-jest.mock('../../src/lib/NodeFetcher.js');
-jest.mock('../../src/lib/server/browser.js');
-jest.mock('../../src/lib/logger.js', () => ({
-    log: jest.fn(),
+vi.mock('../../src/lib/fetch.js');
+vi.mock('../../src/lib/server/browser.js');
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
     COMPONENTS: {
         SERVER: 'server'
     }
@@ -20,153 +19,135 @@ jest.mock('../../src/lib/logger.js', () => ({
 describe('fetchWithAutoDetect 函数测试 (fetchWithAutoDetect Function Tests)', () => {
     beforeEach(() => {
         // 重置所有模拟
-        jest.clearAllMocks();
+        vi.clearAllMocks();
         // 设置默认返回值
-        NodeFetcher.html.mockResolvedValue({ html: '<html>Test</html>' });
-        NodeFetcher.json.mockResolvedValue({ json: { test: 'data' } });
-        NodeFetcher.txt.mockResolvedValue({ text: 'Test text' });
-        NodeFetcher.markdown.mockResolvedValue({ markdown: '# Test' });
-        BrowserFetcher.html.mockResolvedValue({
-            content: [{ type: 'text', text: '<html>Browser Test</html>' }],
+        Fetcher.html.mockResolvedValue({
+            content: [{ type: 'text', text: '<html>Test</html>' }],
             isError: false
         });
-        BrowserFetcher.json.mockResolvedValue({
-            content: [{ type: 'text', text: '{"test":"browser data"}' }],
+        Fetcher.json.mockResolvedValue({
+            content: [{ type: 'text', text: '{"test":"data"}' }],
             isError: false
         });
-        BrowserFetcher.txt.mockResolvedValue({
-            content: [{ type: 'text', text: 'Browser test text' }],
+        Fetcher.txt.mockResolvedValue({
+            content: [{ type: 'text', text: 'Test text' }],
             isError: false
         });
-        BrowserFetcher.markdown.mockResolvedValue({
-            content: [{ type: 'text', text: '# Browser Test' }],
+        Fetcher.markdown.mockResolvedValue({
+            content: [{ type: 'text', text: '# Test' }],
             isError: false
         });
         initializeBrowser.mockResolvedValue(undefined);
         closeBrowserInstance.mockResolvedValue(undefined);
         shouldSwitchToBrowser.mockReturnValue(false);
     });
-    test('应该使用 NodeFetcher 获取 HTML (Should use NodeFetcher to fetch HTML)', async () => {
+    test('应该使用 Fetcher 获取 HTML (Should use Fetcher to fetch HTML)', async () => {
         const params = { url: 'https://example.com' };
         const result = await fetchWithAutoDetect(params, 'html');
-        expect(NodeFetcher.html).toHaveBeenCalledWith(params);
-        expect(BrowserFetcher.html).not.toHaveBeenCalled();
+        expect(Fetcher.html).toHaveBeenCalledWith(params);
         expect(result).toEqual({
             content: [{ type: 'text', text: '<html>Test</html>' }],
             isError: false
         });
     });
-    test('应该使用 NodeFetcher 获取 JSON (Should use NodeFetcher to fetch JSON)', async () => {
+    test('应该使用 Fetcher 获取 JSON (Should use Fetcher to fetch JSON)', async () => {
         const params = { url: 'https://example.com/data.json' };
         const result = await fetchWithAutoDetect(params, 'json');
-        expect(NodeFetcher.json).toHaveBeenCalledWith(params);
-        expect(BrowserFetcher.json).not.toHaveBeenCalled();
+        expect(Fetcher.json).toHaveBeenCalledWith(params);
         expect(result).toEqual({
-            content: [{ type: 'text', text: JSON.stringify({ test: 'data' }, null, 2) }],
+            content: [{ type: 'text', text: '{"test":"data"}' }],
             isError: false
         });
     });
-    test('应该使用 NodeFetcher 获取文本 (Should use NodeFetcher to fetch text)', async () => {
+    test('应该使用 Fetcher 获取文本 (Should use Fetcher to fetch text)', async () => {
         const params = { url: 'https://example.com/text.txt' };
         const result = await fetchWithAutoDetect(params, 'txt');
-        expect(NodeFetcher.txt).toHaveBeenCalledWith(params);
-        expect(BrowserFetcher.txt).not.toHaveBeenCalled();
+        expect(Fetcher.txt).toHaveBeenCalledWith(params);
         expect(result).toEqual({
             content: [{ type: 'text', text: 'Test text' }],
             isError: false
         });
     });
-    test('应该使用 NodeFetcher 获取 Markdown (Should use NodeFetcher to fetch Markdown)', async () => {
+    test('应该使用 Fetcher 获取 Markdown (Should use Fetcher to fetch Markdown)', async () => {
         const params = { url: 'https://example.com/readme.md' };
         const result = await fetchWithAutoDetect(params, 'markdown');
-        expect(NodeFetcher.markdown).toHaveBeenCalledWith(params);
-        expect(BrowserFetcher.markdown).not.toHaveBeenCalled();
+        expect(Fetcher.markdown).toHaveBeenCalledWith(params);
         expect(result).toEqual({
             content: [{ type: 'text', text: '# Test' }],
             isError: false
         });
     });
-    test('应该使用 BrowserFetcher 获取 HTML (Should use BrowserFetcher to fetch HTML)', async () => {
+    test('应该在浏览器模式下使用 Fetcher 获取 HTML (Should use Fetcher to fetch HTML in browser mode)', async () => {
         const params = { url: 'https://example.com', useBrowser: true };
+        // 设置浏览器模式下的返回值
+        Fetcher.html.mockResolvedValue({
+            content: [{ type: 'text', text: '<html>Browser Test</html>' }],
+            isError: false
+        });
         const result = await fetchWithAutoDetect(params, 'html');
         expect(initializeBrowser).toHaveBeenCalled();
-        expect(NodeFetcher.html).not.toHaveBeenCalled();
-        expect(BrowserFetcher.html).toHaveBeenCalledWith({ ...params, debug: false });
+        expect(Fetcher.html).toHaveBeenCalledWith({ ...params, debug: false });
         expect(result).toEqual({
             content: [{ type: 'text', text: '<html>Browser Test</html>' }],
             isError: false
         });
     });
-    test('应该使用 BrowserFetcher 获取 JSON (Should use BrowserFetcher to fetch JSON)', async () => {
+    test('应该在浏览器模式下使用 Fetcher 获取 JSON (Should use Fetcher to fetch JSON in browser mode)', async () => {
         const params = { url: 'https://example.com/data.json', useBrowser: true };
-        const result = await fetchWithAutoDetect(params, 'json');
-        expect(initializeBrowser).toHaveBeenCalled();
-        expect(NodeFetcher.json).not.toHaveBeenCalled();
-        expect(BrowserFetcher.json).toHaveBeenCalledWith({ ...params, debug: false });
-        expect(result).toEqual({
+        // 设置浏览器模式下的返回值
+        Fetcher.json.mockResolvedValue({
             content: [{ type: 'text', text: '{"test":"browser data"}' }],
             isError: false
         });
-    });
-    test('应该使用 BrowserFetcher 获取文本 (Should use BrowserFetcher to fetch text)', async () => {
-        const params = { url: 'https://example.com/text.txt', useBrowser: true };
-        const result = await fetchWithAutoDetect(params, 'txt');
+        const result = await fetchWithAutoDetect(params, 'json');
         expect(initializeBrowser).toHaveBeenCalled();
-        expect(NodeFetcher.txt).not.toHaveBeenCalled();
-        expect(BrowserFetcher.txt).toHaveBeenCalledWith({ ...params, debug: false });
+        expect(Fetcher.json).toHaveBeenCalledWith({ ...params, debug: false });
         expect(result).toEqual({
-            content: [{ type: 'text', text: 'Browser test text' }],
+            content: [{ type: 'text', text: '{"test":"browser data"}' }],
             isError: false
         });
     });
-    test('应该使用 BrowserFetcher 获取 Markdown (Should use BrowserFetcher to fetch Markdown)', async () => {
-        const params = { url: 'https://example.com/readme.md', useBrowser: true };
-        const result = await fetchWithAutoDetect(params, 'markdown');
-        expect(initializeBrowser).toHaveBeenCalled();
-        expect(NodeFetcher.markdown).not.toHaveBeenCalled();
-        expect(BrowserFetcher.markdown).toHaveBeenCalledWith({ ...params, debug: false });
-        expect(result).toEqual({
-            content: [{ type: 'text', text: '# Browser Test' }],
+    test('应该在 Fetcher 失败时自动切换到浏览器模式 (Should automatically switch to browser mode when Fetcher fails)', async () => {
+        const params = { url: 'https://example.com' };
+        // 设置 Fetcher 第一次调用抛出错误，第二次调用成功
+        Fetcher.html
+            .mockRejectedValueOnce(new Error('Fetch failed'))
+            .mockResolvedValueOnce({
+            content: [{ type: 'text', text: '<html>Browser Test</html>' }],
             isError: false
         });
-    });
-    test('应该在 NodeFetcher 失败时自动切换到 BrowserFetcher (Should automatically switch to BrowserFetcher when NodeFetcher fails)', async () => {
-        const params = { url: 'https://example.com' };
-        // 设置 NodeFetcher 抛出错误
-        NodeFetcher.html.mockRejectedValue(new Error('Fetch failed'));
         // 设置 shouldSwitchToBrowser 返回 true
         shouldSwitchToBrowser.mockReturnValue(true);
         const result = await fetchWithAutoDetect(params, 'html');
-        expect(NodeFetcher.html).toHaveBeenCalledWith(params);
+        expect(Fetcher.html).toHaveBeenCalledTimes(2);
+        expect(Fetcher.html).toHaveBeenNthCalledWith(1, params);
+        expect(Fetcher.html).toHaveBeenNthCalledWith(2, { ...params, useBrowser: true, debug: false });
         expect(shouldSwitchToBrowser).toHaveBeenCalled();
         expect(initializeBrowser).toHaveBeenCalled();
-        expect(BrowserFetcher.html).toHaveBeenCalledWith({ ...params, useBrowser: true, debug: false });
         expect(result).toEqual({
             content: [{ type: 'text', text: '<html>Browser Test</html>' }],
             isError: false
         });
     });
-    test('应该在 NodeFetcher 失败且不需要切换时抛出原始错误 (Should throw original error when NodeFetcher fails and no switch is needed)', async () => {
+    test('应该在 Fetcher 失败且不需要切换时抛出原始错误 (Should throw original error when Fetcher fails and no switch is needed)', async () => {
         const params = { url: 'https://example.com' };
-        // 设置 NodeFetcher 抛出错误
+        // 设置 Fetcher 抛出错误
         const originalError = new Error('Fetch failed');
-        NodeFetcher.html.mockRejectedValue(originalError);
+        Fetcher.html.mockRejectedValue(originalError);
         // 设置 shouldSwitchToBrowser 返回 false
         shouldSwitchToBrowser.mockReturnValue(false);
         await expect(fetchWithAutoDetect(params, 'html')).rejects.toThrow(originalError);
-        expect(NodeFetcher.html).toHaveBeenCalledWith(params);
+        expect(Fetcher.html).toHaveBeenCalledWith(params);
         expect(shouldSwitchToBrowser).toHaveBeenCalled();
-        expect(BrowserFetcher.html).not.toHaveBeenCalled();
     });
     test('应该在 autoDetectMode 为 false 时不自动切换 (Should not automatically switch when autoDetectMode is false)', async () => {
         const params = { url: 'https://example.com', autoDetectMode: false };
-        // 设置 NodeFetcher 抛出错误
+        // 设置 Fetcher 抛出错误
         const originalError = new Error('Fetch failed');
-        NodeFetcher.html.mockRejectedValue(originalError);
+        Fetcher.html.mockRejectedValue(originalError);
         await expect(fetchWithAutoDetect(params, 'html')).rejects.toThrow(originalError);
-        expect(NodeFetcher.html).toHaveBeenCalledWith(params);
+        expect(Fetcher.html).toHaveBeenCalledWith(params);
         expect(shouldSwitchToBrowser).not.toHaveBeenCalled();
-        expect(BrowserFetcher.html).not.toHaveBeenCalled();
     });
     test('应该在 closeBrowser 为 true 时关闭浏览器 (Should close browser when closeBrowser is true)', async () => {
         const params = { url: 'https://example.com', useBrowser: true, closeBrowser: true };
@@ -176,41 +157,17 @@ describe('fetchWithAutoDetect 函数测试 (fetchWithAutoDetect Function Tests)'
         // 手动调用 closeBrowserInstance 函数，模拟外部调用
         await closeBrowserInstance(false);
         expect(initializeBrowser).toHaveBeenCalled();
-        expect(BrowserFetcher.html).toHaveBeenCalled();
+        expect(Fetcher.html).toHaveBeenCalled();
         expect(closeBrowserInstance).toHaveBeenCalled();
     });
     test('应该在出错且 closeBrowser 为 true 时关闭浏览器 (Should close browser when error occurs and closeBrowser is true)', async () => {
         const params = { url: 'https://example.com', useBrowser: true, closeBrowser: true };
-        // 设置 BrowserFetcher 抛出错误
+        // 设置 Fetcher 抛出错误
         const originalError = new Error('Browser fetch failed');
-        BrowserFetcher.html.mockRejectedValue(originalError);
+        Fetcher.html.mockRejectedValue(originalError);
         await expect(fetchWithAutoDetect(params, 'html')).rejects.toThrow(originalError);
         expect(initializeBrowser).toHaveBeenCalled();
-        expect(BrowserFetcher.html).toHaveBeenCalled();
+        expect(Fetcher.html).toHaveBeenCalled();
         expect(closeBrowserInstance).toHaveBeenCalled();
     });
-    test('应该处理 JSON 对象和字符串 (Should handle JSON objects and strings)', async () => {
-        // 测试 JSON 对象
-        NodeFetcher.json.mockResolvedValue({ json: { test: 'data' } });
-        let result = await fetchWithAutoDetect({ url: 'https://example.com/data.json' }, 'json');
-        expect(result).toEqual({
-            content: [{ type: 'text', text: JSON.stringify({ test: 'data' }, null, 2) }],
-            isError: false
-        });
-        // 测试 JSON 字符串
-        NodeFetcher.json.mockResolvedValue({ json: '{"test":"string data"}' });
-        result = await fetchWithAutoDetect({ url: 'https://example.com/data.json' }, 'json');
-        expect(result).toEqual({
-            content: [{ type: 'text', text: '{"test":"string data"}' }],
-            isError: false
-        });
-    });
-    test('应该返回不支持的内容类型错误 (Should return unsupported content type error)', async () => {
-        // @ts-ignore - 故意传入不支持的类型
-        const result = await fetchWithAutoDetect({ url: 'https://example.com' }, 'unsupported');
-        expect(result).toEqual({
-            content: [{ type: 'text', text: 'Unsupported content type: unsupported' }],
-            isError: true
-        });
-    });
 });

package/dist/tests/server/index.test.js

@@ -3,32 +3,33 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
+import { vi, describe, test, expect, beforeEach, afterEach } from 'vitest';
 // 模拟依赖
-jest.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
-    Server: jest.fn().mockImplementation(() => ({
-        connect: jest.fn().mockResolvedValue(undefined),
-        registerTool: jest.fn(),
-        registerResource: jest.fn(),
-        registerPrompt: jest.fn()
+vi.mock('@modelcontextprotocol/sdk/server/index.js', () => ({
+    Server: vi.fn().mockImplementation(() => ({
+        connect: vi.fn().mockResolvedValue(undefined),
+        registerTool: vi.fn(),
+        registerResource: vi.fn(),
+        registerPrompt: vi.fn()
     }))
 }));
-jest.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
-    StdioServerTransport: jest.fn().mockImplementation(() => ({}))
+vi.mock('@modelcontextprotocol/sdk/server/stdio.js', () => ({
+    StdioServerTransport: vi.fn().mockImplementation(() => ({}))
 }));
-jest.mock('../../src/lib/server/tools.js', () => ({
-    registerTools: jest.fn()
+vi.mock('../../src/lib/server/tools.js', () => ({
+    registerTools: vi.fn()
 }));
-jest.mock('../../src/lib/server/resources.js', () => ({
-    registerResources: jest.fn()
+vi.mock('../../src/lib/server/resources.js', () => ({
+    registerResources: vi.fn()
 }));
-jest.mock('../../src/lib/server/prompts.js', () => ({
-    registerPrompts: jest.fn()
+vi.mock('../../src/lib/server/prompts.js', () => ({
+    registerPrompts: vi.fn()
 }));
-jest.mock('../../src/lib/server/browser.js', () => ({
-    closeBrowserInstance: jest.fn().mockResolvedValue(undefined)
+vi.mock('../../src/lib/server/browser.js', () => ({
+    closeBrowserInstance: vi.fn().mockResolvedValue(undefined)
 }));
-jest.mock('../../src/lib/logger.js', () => ({
-    log: jest.fn(),
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
     COMPONENTS: {
         SERVER: 'SERVER'
     }
@@ -42,15 +43,15 @@ describe('MCP服务器信号处理测试 (MCP Server Signal Handling Tests)', ()
     const originalProcessOn = process.on;
     const originalProcessExit = process.exit;
     // 存储信号处理函数
-    let exitHandler;
-    let sigintHandler;
-    let sigtermHandler;
-    let uncaughtExceptionHandler;
-    beforeEach(() => {
+    let exitHandler = null;
+    let sigintHandler = null;
+    let sigtermHandler = null;
+    let uncaughtExceptionHandler = null;
+    beforeEach(async () => {
         // 重置所有模拟
-        jest.clearAllMocks();
+        vi.clearAllMocks();
         // 模拟process.on
-        process.on = jest.fn().mockImplementation((event, handler) => {
+        process.on = vi.fn().mockImplementation((event, handler) => {
             // 存储处理函数以便测试
             if (event === 'exit') {
                 exitHandler = handler;
@@ -67,12 +68,11 @@ describe('MCP服务器信号处理测试 (MCP Server Signal Handling Tests)', ()
             return process;
         });
         // 模拟process.exit
-        process.exit = jest.fn();
+        process.exit = vi.fn();
         // 导入startServer函数
-        // 注意：我们需要在每个测试中重新导入，以确保process.on的模拟生效
-        jest.isolateModules(() => {
-            require('../../src/lib/server/index.js').startServer();
-        });
+        // 使用动态导入而不是isolateModules
+        const serverModule = await import('../../src/lib/server/index.js');
+        serverModule.startServer();
     });
     afterEach(() => {
         // 恢复原始的process.on和process.exit

package/dist/tests/server/prompts.test.js

@@ -4,9 +4,11 @@
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
 import { registerPrompts } from "../../src/lib/server/prompts.js";
-import { ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import * as logger from '../../src/lib/logger.js';
 // 模拟i18n模块
-jest.mock('../../src/lib/i18n/index.js', () => ({
+vi.mock('../../src/lib/i18n/index.js', () => ({
     t: (key) => {
         const translations = {
             'prompts.fetchWebsite.description': '获取网站内容',
@@ -44,56 +46,57 @@ jest.mock('../../src/lib/i18n/index.js', () => ({
     }
 }));
 // 模拟logger模块
-jest.mock('../../src/lib/logger.js', () => ({
-    log: jest.fn(),
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
     COMPONENTS: {
         PROMPTS: 'prompts'
     }
 }));
-describe('prompts模块测试', () => {
-    let server;
+describe('提示模块测试 (Prompts Module Tests)', () => {
+    let mockServer;
+    let mockSetRequestHandler;
     let listPromptsHandler;
     let getPromptHandler;
     beforeEach(() => {
-        // 创建模拟Server实例
-        server = {
-            setRequestHandler: jest.fn((schema, handler) => {
-                if (schema === ListPromptsRequestSchema) {
-                    listPromptsHandler = handler;
-                }
-                else if (schema === GetPromptRequestSchema) {
-                    getPromptHandler = handler;
-                }
-            })
+        // 重置所有模拟
+        vi.clearAllMocks();
+        // 创建模拟的 Server 实例
+        mockSetRequestHandler = vi.fn((schema, handler) => {
+            if (schema === ListPromptsRequestSchema) {
+                listPromptsHandler = handler;
+            }
+            else if (schema === GetPromptRequestSchema) {
+                getPromptHandler = handler;
+            }
+        });
+        mockServer = {
+            setRequestHandler: mockSetRequestHandler
         };
         // 注册提示处理程序
-        registerPrompts(server);
+        registerPrompts(mockServer);
     });
     describe('registerPrompts', () => {
         it('应该注册ListPromptsRequestSchema和GetPromptRequestSchema处理程序', () => {
-            expect(server.setRequestHandler).toHaveBeenCalledTimes(2);
-            expect(server.setRequestHandler).toHaveBeenCalledWith(ListPromptsRequestSchema, expect.any(Function));
-            expect(server.setRequestHandler).toHaveBeenCalledWith(GetPromptRequestSchema, expect.any(Function));
+            expect(mockServer.setRequestHandler).toHaveBeenCalledTimes(2);
+            expect(mockServer.setRequestHandler).toHaveBeenCalledWith(ListPromptsRequestSchema, expect.any(Function));
+            expect(mockServer.setRequestHandler).toHaveBeenCalledWith(GetPromptRequestSchema, expect.any(Function));
         });
     });
     describe('ListPromptsRequestSchema处理程序', () => {
         it('应该返回所有可用的提示', async () => {
-            const request = { params: {} };
-            const response = await listPromptsHandler(request);
-            expect(response).toHaveProperty('prompts');
-            expect(Array.isArray(response.prompts)).toBe(true);
-            expect(response.prompts.length).toBe(3);
-            // 验证返回的提示
-            const promptNames = response.prompts.map((p) => p.name);
-            expect(promptNames).toContain('mult-fetch-mcp:prompt:fetch-website');
-            expect(promptNames).toContain('mult-fetch-mcp:prompt:extract-content');
-            expect(promptNames).toContain('mult-fetch-mcp:prompt:debug-fetch');
+            const result = await listPromptsHandler({});
+            expect(result).toHaveProperty('prompts');
+            expect(Array.isArray(result.prompts)).toBe(true);
+            expect(result.prompts.length).toBeGreaterThan(0);
+            // 验证提示格式
+            const prompt = result.prompts[0];
+            expect(prompt).toHaveProperty('name');
+            expect(prompt).toHaveProperty('description');
         });
         it('应该处理debug参数', async () => {
-            const request = { params: { debug: true } };
-            await listPromptsHandler(request);
+            const result = await listPromptsHandler({ params: { debug: true } });
             // 验证日志调用
-            expect(require('../../src/lib/logger.js').log).toHaveBeenCalledWith('prompts.list.request', true, { params: { debug: true } }, 'prompts');
+            expect(logger.log).toHaveBeenCalledWith('prompts.list.request', true, expect.any(Object), 'prompts');
         });
     });
     describe('GetPromptRequestSchema处理程序', () => {