npm - @lmcc-dev/mult-fetch-mcp-server - Versions diffs - 1.0.3 → 1.1.0 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (113) hide show

package/README.md +3 -1
package/README.zh.md +3 -2
package/dist/src/client.d.ts +6 -0
package/dist/src/client.js +26 -28
package/dist/src/client.js.map +1 -0
package/dist/src/index.d.ts +15 -0
package/dist/src/index.js.map +1 -0
package/dist/src/lib/BrowserFetcher.d.ts +175 -0
package/dist/src/lib/BrowserFetcher.js.map +1 -0
package/dist/src/lib/NodeFetcher.d.ts +92 -0
package/dist/src/lib/NodeFetcher.js +143 -84
package/dist/src/lib/NodeFetcher.js.map +1 -0
package/dist/src/lib/i18n/index.js.map +1 -0
package/dist/src/lib/i18n/keys.js +135 -0
package/dist/src/lib/i18n/locales/en/browser.d.ts +61 -0
package/dist/src/lib/i18n/locales/en/browser.js +68 -54
package/dist/src/lib/i18n/locales/en/browser.js.map +1 -0
package/dist/src/lib/i18n/locales/en/client.d.ts +39 -0
package/dist/src/lib/i18n/locales/en/client.js.map +1 -0
package/dist/src/lib/i18n/locales/en/errors.d.ts +17 -0
package/dist/src/lib/i18n/locales/en/errors.js.map +1 -0
package/dist/src/lib/i18n/locales/en/fetcher.d.ts +66 -0
package/dist/src/lib/i18n/locales/en/fetcher.js +60 -59
package/dist/src/lib/i18n/locales/en/fetcher.js.map +1 -0
package/dist/src/lib/i18n/locales/en/index.d.ts +344 -0
package/dist/src/lib/i18n/locales/en/index.js +1 -1
package/dist/src/lib/i18n/locales/en/index.js.map +1 -0
package/dist/src/lib/i18n/locales/en/node.d.ts +41 -0
package/dist/src/lib/i18n/locales/en/node.js.map +1 -0
package/dist/src/lib/i18n/locales/en/prompts.d.ts +65 -0
package/dist/src/lib/i18n/locales/en/prompts.js.map +1 -0
package/dist/src/lib/i18n/locales/en/resources.d.ts +41 -0
package/dist/src/lib/i18n/locales/en/resources.js +30 -15
package/dist/src/lib/i18n/locales/en/resources.js.map +1 -0
package/dist/src/lib/i18n/locales/en/server.d.ts +30 -0
package/dist/src/lib/i18n/locales/en/server.js.map +1 -0
package/dist/src/lib/i18n/locales/en/tools.d.ts +24 -0
package/dist/src/lib/i18n/locales/en/tools.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/browser.d.ts +61 -0
package/dist/src/lib/i18n/locales/zh/browser.js +68 -54
package/dist/src/lib/i18n/locales/zh/browser.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/client.d.ts +38 -0
package/dist/src/lib/i18n/locales/zh/client.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/errors.d.ts +17 -0
package/dist/src/lib/i18n/locales/zh/errors.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/fetcher.d.ts +66 -0
package/dist/src/lib/i18n/locales/zh/fetcher.js +60 -59
package/dist/src/lib/i18n/locales/zh/fetcher.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/index.d.ts +343 -0
package/dist/src/lib/i18n/locales/zh/index.js +1 -1
package/dist/src/lib/i18n/locales/zh/index.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/node.d.ts +41 -0
package/dist/src/lib/i18n/locales/zh/node.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/prompts.d.ts +65 -0
package/dist/src/lib/i18n/locales/zh/prompts.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/resources.d.ts +41 -0
package/dist/src/lib/i18n/locales/zh/resources.js +28 -13
package/dist/src/lib/i18n/locales/zh/resources.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/server.d.ts +30 -0
package/dist/src/lib/i18n/locales/zh/server.js.map +1 -0
package/dist/src/lib/i18n/locales/zh/tools.d.ts +24 -0
package/dist/src/lib/i18n/locales/zh/tools.js.map +1 -0
package/dist/src/lib/i18n/logger.d.ts +38 -0
package/dist/src/lib/i18n/logger.js.map +1 -0
package/dist/src/lib/logger.d.ts +32 -0
package/dist/src/lib/logger.js.map +1 -0
package/dist/src/lib/server/browser.d.ts +34 -0
package/dist/src/lib/server/browser.js +10 -16
package/dist/src/lib/server/browser.js.map +1 -0
package/dist/src/lib/server/fetcher.d.ts +20 -0
package/dist/src/lib/server/fetcher.js.map +1 -0
package/dist/src/lib/server/index.d.ts +10 -0
package/dist/src/lib/server/index.js.map +1 -0
package/dist/src/lib/server/prompts.d.ts +11 -0
package/dist/src/lib/server/prompts.js.map +1 -0
package/dist/src/lib/server/resources.d.ts +11 -0
package/dist/src/lib/server/resources.js.map +1 -0
package/dist/src/lib/server/tools.d.ts +12 -0
package/dist/src/lib/server/tools.js +369 -309
package/dist/src/lib/server/tools.js.map +1 -0
package/dist/src/lib/server/types.d.ts +71 -0
package/dist/src/lib/server/types.js.map +1 -0
package/dist/src/lib/types.d.ts +119 -0
package/dist/src/lib/types.js.map +1 -0
package/dist/src/lib/utils/errorDetection.js +41 -0
package/dist/src/lib/utils/errors.js +279 -0
package/dist/src/mcp-server.d.ts +6 -0
package/dist/src/mcp-server.js.map +1 -0
package/dist/tests/BrowserFetcher.test.js +951 -0
package/dist/tests/NodeFetcher.test.js +263 -0
package/dist/tests/client.test.js +250 -0
package/dist/tests/i18n.test.js +179 -0
package/dist/tests/jest.setup.d.ts +6 -0
package/dist/tests/jest.setup.js +30 -0
package/dist/tests/jest.setup.js.map +1 -0
package/dist/tests/logger.test.js +99 -0
package/dist/tests/mcp-server.test.js +113 -0
package/dist/tests/server/browser.test.js +197 -0
package/dist/tests/server/fetcher.test.js +216 -0
package/dist/tests/server/index.test.js +122 -0
package/dist/tests/server/prompts.test.js +243 -0
package/dist/tests/server/resources.test.js +359 -0
package/dist/tests/server/tools.test.js +222 -0
package/dist/tests/test-direct-client.d.ts +6 -0
package/dist/tests/test-direct-client.js.map +1 -0
package/dist/tests/test-mcp-methods.d.ts +6 -0
package/dist/tests/test-mcp-methods.js.map +1 -0
package/dist/tests/test-mcp.d.ts +6 -0
package/dist/tests/test-mcp.js.map +1 -0
package/dist/tests/test-mini4k.d.ts +6 -0
package/dist/tests/test-mini4k.js.map +1 -0
package/dist/tests/types.test.js +57 -0
package/package.json +11 -2

package/dist/tests/NodeFetcher.test.js ADDED Viewed

@@ -0,0 +1,263 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { NodeFetcher } from '../src/lib/NodeFetcher.js';
+// 模拟node-fetch
+jest.mock('node-fetch', () => {
+    const mockFetch = jest.fn();
+    // 创建模拟Response
+    const createMockResponse = (url) => {
+        // 根据URL返回不同的内容
+        let textContent = '<html><body><h1>测试页面</h1></body></html>';
+        let jsonContent = { test: 'data' };
+        let contentType = 'text/html; charset=utf-8';
+        if (url.includes('/api')) {
+            textContent = JSON.stringify(jsonContent);
+            contentType = 'application/json; charset=utf-8';
+        }
+        else if (url.includes('/text')) {
+            textContent = '这是纯文本内容';
+            contentType = 'text/plain; charset=utf-8';
+        }
+        else if (url.includes('/md')) {
+            textContent = '# 标题\n\n这是Markdown内容';
+            contentType = 'text/markdown; charset=utf-8';
+        }
+        return {
+            ok: true,
+            status: 200,
+            statusText: 'OK',
+            url: url,
+            headers: {
+                get: jest.fn((name) => {
+                    if (name.toLowerCase() === 'content-type') {
+                        return contentType;
+                    }
+                    return null;
+                }),
+                raw: () => ({}),
+                entries: () => [['content-type', contentType]]
+            },
+            text: jest.fn().mockResolvedValue(textContent),
+            json: jest.fn().mockResolvedValue(jsonContent),
+            buffer: jest.fn().mockResolvedValue(Buffer.from(textContent)),
+            clone: jest.fn(function () { return this; })
+        };
+    };
+    // 设置默认返回值
+    mockFetch.mockImplementation((url) => {
+        return Promise.resolve(createMockResponse(url));
+    });
+    return mockFetch;
+});
+// 模拟http-proxy-agent和https-proxy-agent
+jest.mock('http-proxy-agent', () => ({
+    HttpProxyAgent: jest.fn().mockImplementation(() => ({}))
+}));
+jest.mock('https-proxy-agent', () => ({
+    HttpsProxyAgent: jest.fn().mockImplementation(() => ({}))
+}));
+// 模拟child_process
+jest.mock('child_process', () => ({
+    execSync: jest.fn().mockReturnValue(Buffer.from(''))
+}));
+// 模拟i18n
+jest.mock('../src/lib/i18n/index.js', () => ({
+    t: (key, options) => {
+        return options ? `${key} ${JSON.stringify(options)}` : key;
+    }
+}));
+// 模拟logger
+jest.mock('../src/lib/logger.js', () => ({
+    log: jest.fn(),
+    COMPONENTS: {
+        NODE_FETCH: 'NODE-FETCH'
+    }
+}));
+describe('NodeFetcher类测试 (NodeFetcher Class Tests)', () => {
+    let fetch;
+    beforeEach(() => {
+        // 重置所有模拟
+        jest.clearAllMocks();
+        // 获取模拟的fetch函数
+        fetch = require('node-fetch');
+    });
+    describe('基本功能测试 (Basic Functionality Tests)', () => {
+        test('应该有html方法 (Should have html method)', () => {
+            expect(typeof NodeFetcher.html).toBe('function');
+        });
+        test('应该有json方法 (Should have json method)', () => {
+            expect(typeof NodeFetcher.json).toBe('function');
+        });
+        test('应该有txt方法 (Should have txt method)', () => {
+            expect(typeof NodeFetcher.txt).toBe('function');
+        });
+        test('应该有markdown方法 (Should have markdown method)', () => {
+            expect(typeof NodeFetcher.markdown).toBe('function');
+        });
+    });
+    describe('html方法测试 (html Method Tests)', () => {
+        test('应该能够获取HTML内容 (Should fetch HTML content)', async () => {
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com',
+                debug: true
+            };
+            // 调用方法
+            const result = await NodeFetcher.html(payload);
+            // 验证结果
+            expect(result).toBeDefined();
+            expect(result.html).toBeDefined();
+            expect(result.url).toBe('https://example.com');
+            expect(result.status).toBe(200);
+            expect(result.headers).toBeDefined();
+            expect(result.html).toContain('<html>');
+            // 验证fetch被调用
+            expect(fetch).toHaveBeenCalledWith(payload.url, expect.objectContaining({
+                headers: expect.any(Object),
+                timeout: expect.any(Number)
+            }));
+        });
+        test('应该处理获取HTML时的错误 (Should handle errors when fetching HTML)', async () => {
+            // 模拟fetch失败
+            fetch.mockRejectedValueOnce(new Error('Network error'));
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com',
+                debug: true
+            };
+            // 调用方法并验证它抛出错误
+            await expect(NodeFetcher.html(payload)).rejects.toThrow('Network error');
+        });
+    });
+    describe('json方法测试 (json Method Tests)', () => {
+        test('应该能够获取JSON内容 (Should fetch JSON content)', async () => {
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com/api',
+                debug: true
+            };
+            // 调用方法
+            const result = await NodeFetcher.json(payload);
+            // 验证结果
+            expect(result).toBeDefined();
+            expect(result.json).toBeDefined();
+            expect(result.json).toEqual({ test: 'data' });
+            expect(result.url).toBe('https://example.com/api');
+            expect(result.status).toBe(200);
+            expect(result.headers).toBeDefined();
+            // 验证fetch被调用
+            expect(fetch).toHaveBeenCalledWith(payload.url, expect.objectContaining({
+                headers: expect.any(Object),
+                timeout: expect.any(Number)
+            }));
+        });
+        test('应该处理获取JSON时的错误 (Should handle errors when fetching JSON)', async () => {
+            // 模拟fetch失败
+            fetch.mockRejectedValueOnce(new Error('Network error'));
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com/api',
+                debug: true
+            };
+            // 调用方法并验证它抛出错误
+            await expect(NodeFetcher.json(payload)).rejects.toThrow('Network error');
+        });
+    });
+    describe('txt方法测试 (txt Method Tests)', () => {
+        test('应该能够获取文本内容 (Should fetch text content)', async () => {
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com/text',
+                debug: true
+            };
+            // 调用方法
+            const result = await NodeFetcher.txt(payload);
+            // 验证结果
+            expect(result).toBeDefined();
+            expect(result.text).toBeDefined();
+            expect(result.url).toBe('https://example.com/text');
+            expect(result.status).toBe(200);
+            expect(result.headers).toBeDefined();
+            // 验证fetch被调用
+            expect(fetch).toHaveBeenCalledWith(payload.url, expect.objectContaining({
+                headers: expect.any(Object),
+                timeout: expect.any(Number)
+            }));
+        });
+        test('应该处理获取文本时的错误 (Should handle errors when fetching text)', async () => {
+            // 模拟fetch失败
+            fetch.mockRejectedValueOnce(new Error('Network error'));
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com/text',
+                debug: true
+            };
+            // 调用方法并验证它抛出错误
+            await expect(NodeFetcher.txt(payload)).rejects.toThrow('Network error');
+        });
+    });
+    describe('markdown方法测试 (markdown Method Tests)', () => {
+        test('应该能够获取Markdown内容 (Should fetch Markdown content)', async () => {
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com/md',
+                debug: true
+            };
+            // 调用方法
+            const result = await NodeFetcher.markdown(payload);
+            // 验证结果
+            expect(result).toBeDefined();
+            expect(result.markdown).toBeDefined();
+            expect(result.url).toBe('https://example.com/md');
+            expect(result.status).toBe(200);
+            expect(result.headers).toBeDefined();
+            // 验证fetch被调用
+            expect(fetch).toHaveBeenCalledWith(payload.url, expect.objectContaining({
+                headers: expect.any(Object),
+                timeout: expect.any(Number)
+            }));
+        });
+        test('应该处理获取Markdown时的错误 (Should handle errors when fetching Markdown)', async () => {
+            // 模拟fetch失败
+            fetch.mockRejectedValueOnce(new Error('Network error'));
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com/md',
+                debug: true
+            };
+            // 调用方法并验证它抛出错误
+            await expect(NodeFetcher.markdown(payload)).rejects.toThrow('Network error');
+        });
+    });
+    describe('代理功能测试 (Proxy Functionality Tests)', () => {
+        test('应该正确处理HTTP代理 (Should handle HTTP proxy correctly)', async () => {
+            // 准备测试数据
+            const payload = {
+                url: 'http://example.com',
+                proxy: 'http://proxy.example.com:8080',
+                debug: true
+            };
+            // 调用方法
+            await NodeFetcher.html(payload);
+            // 验证HttpProxyAgent被调用
+            const { HttpProxyAgent } = require('http-proxy-agent');
+            expect(HttpProxyAgent).toHaveBeenCalledWith(payload.proxy);
+        });
+        test('应该正确处理HTTPS代理 (Should handle HTTPS proxy correctly)', async () => {
+            // 准备测试数据
+            const payload = {
+                url: 'https://example.com',
+                proxy: 'http://proxy.example.com:8080',
+                debug: true
+            };
+            // 调用方法
+            await NodeFetcher.html(payload);
+            // 验证HttpsProxyAgent被调用
+            const { HttpsProxyAgent } = require('https-proxy-agent');
+            expect(HttpsProxyAgent).toHaveBeenCalledWith(payload.proxy);
+        });
+    });
+});

package/dist/tests/client.test.js ADDED Viewed

@@ -0,0 +1,250 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+// 保存原始值以便在测试后恢复
+const originalArgv = process.argv;
+const originalExit = process.exit;
+const originalStdoutWrite = process.stdout.write;
+// 模拟 logger 模块
+const mockLog = jest.fn();
+jest.mock('../src/lib/logger.js', () => ({
+    log: mockLog,
+    COMPONENTS: {
+        CLIENT: 'CLIENT',
+        SERVER: 'SERVER',
+        NODE_FETCH: 'NODE-FETCH',
+        BROWSER_FETCH: 'BROWSER-FETCH'
+    }
+}));
+// 模拟依赖模块
+jest.mock('@modelcontextprotocol/sdk/client/index.js', () => ({
+    Client: jest.fn().mockImplementation(() => ({
+        connect: jest.fn().mockResolvedValue(undefined),
+        callTool: jest.fn(),
+        close: jest.fn().mockResolvedValue(undefined)
+    }))
+}));
+jest.mock('@modelcontextprotocol/sdk/client/stdio.js', () => ({
+    StdioClientTransport: jest.fn().mockImplementation(() => ({}))
+}));
+jest.mock('child_process', () => ({
+    execSync: jest.fn()
+}));
+// 模拟 process.exit
+jest.spyOn(process, 'exit').mockImplementation((code) => {
+    console.log(`[模拟] process.exit(${code})`);
+    return undefined;
+});
+// 创建模拟的客户端模块
+const mockClientModule = {
+    responseRequiresBrowser: jest.fn((response, debug = false) => {
+        if (response.isError) {
+            const errorText = response.content[0].text.toLowerCase();
+            if (debug) {
+                mockLog('fetcher.fetchError', debug, { error: response.content[0].text }, 'CLIENT');
+                if (errorText.includes('403') || errorText.includes('forbidden')) {
+                    mockLog('errors.forbidden', debug, {}, 'CLIENT');
+                }
+            }
+            return errorText.includes('403') ||
+                errorText.includes('forbidden') ||
+                errorText.includes('cloudflare') ||
+                errorText.includes('timeout') ||
+                errorText.includes('econnrefused');
+        }
+        return false;
+    }),
+    smartFetch: jest.fn(async (params) => {
+        const mockClient = new Client({
+            name: "fetch-mcp-client",
+            version: "1.0.0"
+        });
+        await mockClient.connect(new StdioClientTransport({
+            command: 'node',
+            args: ['index.js'],
+            stderr: 'inherit'
+        }));
+        try {
+            // 使用 any 类型来避免类型错误
+            const result = await mockClient.callTool({
+                name: params.method || 'fetch_html',
+                arguments: params
+            });
+            // 确保返回值符合 ResponseType 接口
+            return {
+                isError: typeof result.isError === 'boolean' ? result.isError : false,
+                content: Array.isArray(result.content) ? result.content : [{ text: '' }]
+            };
+        }
+        finally {
+            await mockClient.close();
+        }
+    }),
+    main: jest.fn(() => {
+        // 检查命令行参数
+        if (process.argv.length < 4) {
+            mockLog('client.usageInfo', true, {}, 'CLIENT');
+            mockLog('client.exampleUsage', true, {}, 'CLIENT');
+            process.exit(1);
+            return;
+        }
+        const method = process.argv[2];
+        let paramsJson = process.argv[3];
+        try {
+            JSON.parse(paramsJson);
+        }
+        catch (error) {
+            mockLog('client.invalidJson', true, {}, 'CLIENT');
+            process.exit(1);
+            return;
+        }
+        // 模拟成功执行
+        return;
+    })
+};
+// 模拟 client.ts 模块
+jest.mock('../src/client.js', () => mockClientModule, { virtual: true });
+describe('client.ts 测试', () => {
+    // 在每个测试前重置模拟
+    beforeEach(() => {
+        jest.resetModules();
+        jest.clearAllMocks();
+    });
+    // 在所有测试后恢复原始值
+    afterAll(() => {
+        process.exit = originalExit;
+        process.argv = originalArgv;
+    });
+    describe('responseRequiresBrowser 函数测试', () => {
+        test('应该在响应包含 403 错误时返回 true', () => {
+            // 模拟依赖
+            jest.doMock('../src/lib/logger.js', () => ({
+                log: jest.fn(),
+                COMPONENTS: {
+                    CLIENT: 'CLIENT'
+                }
+            }));
+            // 导入被测试的模块
+            const { responseRequiresBrowser } = require('../src/client.js');
+            const response = {
+                isError: true,
+                content: [{ text: '403 Forbidden' }]
+            };
+            const result = responseRequiresBrowser(response, true);
+            expect(result).toBe(true);
+        });
+        test('应该在响应不是错误时返回 false', () => {
+            // 模拟依赖
+            jest.doMock('../src/lib/logger.js', () => ({
+                log: jest.fn(),
+                COMPONENTS: {
+                    CLIENT: 'CLIENT'
+                }
+            }));
+            // 导入被测试的模块
+            const { responseRequiresBrowser } = require('../src/client.js');
+            const response = {
+                isError: false,
+                content: [{ text: 'Success' }]
+            };
+            const result = responseRequiresBrowser(response);
+            expect(result).toBe(false);
+        });
+    });
+    describe('smartFetch 函数测试', () => {
+        test('应该使用标准模式发送请求并返回结果', async () => {
+            // 模拟成功响应
+            const mockResult = {
+                isError: false,
+                content: [{ text: '<html><body>Success</body></html>' }]
+            };
+            // 设置 callTool 的返回值
+            const mockCallTool = jest.fn().mockResolvedValue(mockResult);
+            Client.mockImplementation(() => ({
+                connect: jest.fn().mockResolvedValue(undefined),
+                callTool: mockCallTool,
+                close: jest.fn().mockResolvedValue(undefined)
+            }));
+            // 调用函数
+            const result = await mockClientModule.smartFetch({
+                url: 'https://example.com',
+                debug: true
+            });
+            // 验证结果
+            expect(result).toEqual(mockResult);
+            // 验证调用
+            expect(Client).toHaveBeenCalled();
+            expect(StdioClientTransport).toHaveBeenCalled();
+            expect(mockCallTool).toHaveBeenCalledWith({
+                name: 'fetch_html',
+                arguments: expect.objectContaining({
+                    url: 'https://example.com',
+                    debug: true
+                })
+            });
+        });
+        test('应该在任何情况下都关闭客户端连接', async () => {
+            // 模拟 callTool 抛出错误
+            const mockClose = jest.fn().mockResolvedValue(undefined);
+            Client.mockImplementation(() => ({
+                connect: jest.fn().mockResolvedValue(undefined),
+                callTool: jest.fn().mockRejectedValue(new Error('Test error')),
+                close: mockClose
+            }));
+            // 调用函数并捕获错误
+            await expect(mockClientModule.smartFetch({
+                url: 'https://example.com',
+                debug: true
+            })).rejects.toThrow('Test error');
+            // 验证 close 被调用
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+    describe('main 函数测试', () => {
+        test('应该在参数不足时显示使用信息并退出', () => {
+            // 保存原始的 process.argv
+            const testArgv = process.argv;
+            try {
+                // 设置参数不足
+                process.argv = ['node', 'client.js'];
+                // 重置 mockLog 函数
+                mockLog.mockClear();
+                // 调用 main 函数
+                mockClientModule.main();
+                // 验证 log 函数被调用
+                expect(mockLog).toHaveBeenCalledWith('client.usageInfo', true, {}, 'CLIENT');
+                expect(mockLog).toHaveBeenCalledWith('client.exampleUsage', true, {}, 'CLIENT');
+                // 验证 process.exit 被调用
+                expect(process.exit).toHaveBeenCalledWith(1);
+            }
+            finally {
+                // 恢复原始的 process.argv
+                process.argv = testArgv;
+            }
+        });
+        test('应该在 JSON 解析失败时显示错误并退出', () => {
+            // 保存原始的 process.argv
+            const testArgv = process.argv;
+            try {
+                // 设置无效的 JSON
+                process.argv = ['node', 'client.js', 'fetch_html', 'invalid-json'];
+                // 重置 mockLog 函数
+                mockLog.mockClear();
+                // 调用 main 函数
+                mockClientModule.main();
+                // 验证 log 函数被调用
+                expect(mockLog).toHaveBeenCalledWith('client.invalidJson', true, {}, 'CLIENT');
+                // 验证 process.exit 被调用
+                expect(process.exit).toHaveBeenCalledWith(1);
+            }
+            finally {
+                // 恢复原始的 process.argv
+                process.argv = testArgv;
+            }
+        });
+    });
+});

package/dist/tests/i18n.test.js ADDED Viewed

@@ -0,0 +1,179 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import i18next, { t, changeLanguage, getCurrentLanguage } from '../src/lib/i18n/index.js';
+import { createLogger } from '../src/lib/i18n/logger.js';
+describe('i18n模块测试 (i18n Module Tests)', () => {
+    // 保存原始环境变量
+    const originalEnv = process.env.MCP_LANG;
+    // 在每个测试后恢复环境变量
+    afterEach(() => {
+        process.env.MCP_LANG = originalEnv;
+    });
+    test('默认语言为英语 (Default language is English)', () => {
+        // 确保没有设置MCP_LANG环境变量
+        delete process.env.MCP_LANG;
+        // 重新初始化i18next
+        i18next.init({
+            resources: i18next.options.resources,
+            lng: process.env.MCP_LANG || 'en',
+            fallbackLng: 'en',
+            interpolation: {
+                escapeValue: false
+            }
+        });
+        // 验证当前语言为英语
+        expect(getCurrentLanguage()).toBe('en');
+    });
+    test('可以切换语言 (Can switch language)', () => {
+        // 切换到中文
+        changeLanguage('zh');
+        // 验证当前语言为中文
+        expect(getCurrentLanguage()).toBe('zh');
+        // 切换回英语
+        changeLanguage('en');
+        // 验证当前语言为英语
+        expect(getCurrentLanguage()).toBe('en');
+    });
+    test('翻译函数能正确工作 (Translation function works correctly)', () => {
+        // 切换到英语
+        changeLanguage('en');
+        // 测试一个存在的翻译键
+        const serverStartingKey = 'server.starting';
+        const serverStartingTranslation = t(serverStartingKey);
+        // 验证翻译结果不为空且不等于键名
+        expect(serverStartingTranslation).not.toBe('');
+        expect(serverStartingTranslation).not.toBe(serverStartingKey);
+        // 切换到中文
+        changeLanguage('zh');
+        // 测试同一个翻译键
+        const zhTranslation = t(serverStartingKey);
+        // 验证中文翻译结果不为空且不等于键名
+        expect(zhTranslation).not.toBe('');
+        expect(zhTranslation).not.toBe(serverStartingKey);
+        // 验证中文翻译与英文翻译不同
+        expect(zhTranslation).not.toBe(serverStartingTranslation);
+    });
+    test('带参数的翻译 (Translation with parameters)', () => {
+        // 切换到英语
+        changeLanguage('en');
+        // 使用一个简单的翻译键进行测试
+        const testKey = 'server.starting';
+        const params = { name: 'Test Server' };
+        const translationWithParams = t(testKey, params);
+        // 验证翻译结果不为空且不等于键名
+        expect(translationWithParams).not.toBe('');
+        expect(translationWithParams).not.toBe(testKey);
+    });
+    test('不存在的翻译键返回键名 (Non-existent translation key returns key name)', () => {
+        // 测试不存在的翻译键
+        const nonExistentKey = 'non.existent.key';
+        const translation = t(nonExistentKey);
+        // 验证翻译结果等于键名
+        expect(translation).toBe(nonExistentKey);
+    });
+});
+describe('i18n Logger模块测试 (i18n Logger Module Tests)', () => {
+    // 保存原始的console方法
+    const originalConsoleLog = console.log;
+    const originalConsoleError = console.error;
+    // 在每个测试前设置mock
+    beforeEach(() => {
+        console.log = jest.fn();
+        console.error = jest.fn();
+        process.env.DEBUG = 'false';
+    });
+    // 在每个测试后恢复原始方法
+    afterEach(() => {
+        console.log = originalConsoleLog;
+        console.error = originalConsoleError;
+        delete process.env.DEBUG;
+    });
+    test('创建日志记录器 (Create logger)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 验证logger对象包含预期的方法
+        expect(logger).toHaveProperty('info');
+        expect(logger).toHaveProperty('error');
+        expect(logger).toHaveProperty('warn');
+        expect(logger).toHaveProperty('debug');
+    });
+    test('info方法在DEBUG=true时输出日志 (info method outputs logs when DEBUG=true)', () => {
+        // 设置DEBUG环境变量为true
+        process.env.DEBUG = 'true';
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用info方法
+        logger.info('test.info');
+        // 验证console.error被调用（i18n logger使用console.error输出所有日志）
+        expect(console.error).toHaveBeenCalled();
+        // 验证调用参数包含前缀和消息
+        const callArg = console.error.mock.calls[0][0];
+        expect(callArg).toContain('[TEST]');
+    });
+    test('info方法在DEBUG=false且forceDebug=false时不输出日志 (info method does not output logs when DEBUG=false and forceDebug=false)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用info方法，不强制输出
+        logger.info('test.info');
+        // 验证console.error没有被调用
+        expect(console.error).not.toHaveBeenCalled();
+    });
+    test('info方法在forceDebug=true时输出日志 (info method outputs logs when forceDebug=true)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用info方法，强制输出
+        logger.info('test.info', {}, true);
+        // 验证console.error被调用
+        expect(console.error).toHaveBeenCalled();
+        // 验证调用参数包含前缀和消息
+        const callArg = console.error.mock.calls[0][0];
+        expect(callArg).toContain('[TEST]');
+    });
+    test('error方法总是输出日志 (error method always outputs logs)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用error方法
+        logger.error('test.error');
+        // 验证console.error被调用
+        expect(console.error).toHaveBeenCalled();
+        // 验证调用参数包含前缀和消息
+        const callArg = console.error.mock.calls[0][0];
+        expect(callArg).toContain('[TEST]');
+        expect(callArg).toContain('test.error');
+    });
+    test('warn方法总是输出日志 (warn method always outputs logs)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用warn方法
+        logger.warn('test.warn');
+        // 验证console.error被调用
+        expect(console.error).toHaveBeenCalled();
+        // 验证调用参数包含前缀和消息
+        const callArg = console.error.mock.calls[0][0];
+        expect(callArg).toContain('[TEST]');
+        expect(callArg).toContain('test.warn');
+    });
+    test('debug方法在forceDebug=true时输出日志 (debug method outputs logs when forceDebug=true)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用debug方法，强制输出
+        logger.debug('test.debug', {}, true);
+        // 验证console.error被调用
+        expect(console.error).toHaveBeenCalled();
+        // 验证调用参数包含前缀和消息
+        const callArg = console.error.mock.calls[0][0];
+        expect(callArg).toContain('[TEST]');
+        expect(callArg).toContain('test.debug');
+    });
+    test('debug方法在forceDebug=false时不输出日志 (debug method does not output logs when forceDebug=false)', () => {
+        // 创建日志记录器
+        const logger = createLogger('TEST');
+        // 调用debug方法，不强制输出
+        logger.debug('test.debug');
+        // 验证console.error没有被调用
+        expect(console.error).not.toHaveBeenCalled();
+    });
+});