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

package/dist/src/lib/server/browser.js

@@ -3,7 +3,7 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { BrowserFetcher } from '../BrowserFetcher.js';
+import { BrowserInstance } from '../fetchers/browser/BrowserInstance.js';
 import { log, COMPONENTS } from '../logger.js';
 import { isAccessDeniedError, isNetworkError } from '../utils/errorDetection.js';
 // 全局浏览器实例 (Global browser instance)
@@ -34,7 +34,7 @@ export async function closeBrowserInstance(debug = false) {
         if (debug) {
             log('server.closingBrowser', debug, {}, COMPONENTS.SERVER);
         }
-        await BrowserFetcher.closeBrowser(true);
+        await BrowserInstance.closeBrowser(debug);
         browserInitialized = false;
     }
 }
@@ -46,15 +46,47 @@ export async function closeBrowserInstance(debug = false) {
  */
 export function shouldSwitchToBrowser(error) {
     // 检查错误是否表明需要浏览器模式 (Check if error indicates browser mode is needed)
-    if (error && error.message) {
-        const errorMessage = error.message;
-        return isAccessDeniedError(errorMessage) ||
-            isNetworkError(errorMessage) ||
-            errorMessage.toLowerCase().includes('javascript required') ||
-            errorMessage.toLowerCase().includes('und_err_connect_timeout') ||
-            errorMessage.toLowerCase().includes('fetch failed');
+    if (!error)
+        return false;
+    // 提取错误消息，无论错误对象的形式如何
+    let errorMessage;
+    if (typeof error === 'string') {
+        errorMessage = error;
     }
-    return false;
+    else if (error instanceof Error) {
+        errorMessage = error.message;
+    }
+    else if (error && typeof error === 'object') {
+        if ('message' in error && typeof error.message === 'string') {
+            errorMessage = error.message;
+        }
+        else if ('content' in error && Array.isArray(error.content) && error.content.length > 0) {
+            // 处理 MCP 响应格式
+            const content = error.content[0];
+            errorMessage = content && typeof content === 'object' && 'text' in content ? String(content.text) : String(error);
+        }
+        else {
+            try {
+                errorMessage = JSON.stringify(error);
+            }
+            catch {
+                errorMessage = String(error);
+            }
+        }
+    }
+    else {
+        errorMessage = String(error);
+    }
+    // 检查是否包含 HTTP 403 Forbidden 错误，这是最常见的需要切换到浏览器模式的情况
+    if (errorMessage.includes('403') ||
+        errorMessage.toLowerCase().includes('forbidden')) {
+        return true;
+    }
+    return isAccessDeniedError(errorMessage) ||
+        isNetworkError(errorMessage) ||
+        errorMessage.toLowerCase().includes('javascript required') ||
+        errorMessage.toLowerCase().includes('und_err_connect_timeout') ||
+        errorMessage.toLowerCase().includes('fetch failed');
 }
 /**
  * 检查是否应该使用浏览器模式 (Check if browser mode should be used)

package/dist/src/lib/server/fetcher.js

@@ -3,8 +3,7 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { BrowserFetcher } from '../BrowserFetcher.js';
-import { NodeFetcher } from '../NodeFetcher.js';
+import { Fetcher } from '../fetch.js';
 import { log, COMPONENTS } from '../logger.js';
 import { initializeBrowser, closeBrowserInstance, shouldSwitchToBrowser } from './browser.js';
 /**
@@ -32,13 +31,15 @@ export async function fetchWithAutoDetect(params, type) {
             // 根据类型选择合适的浏览器获取方法 (Choose appropriate browser fetching method based on type)
             switch (type) {
                 case 'html':
-                    return await BrowserFetcher.html(params);
+                    return await Fetcher.html(params);
                 case 'json':
-                    return await BrowserFetcher.json(params);
+                    return await Fetcher.json(params);
                 case 'txt':
-                    return await BrowserFetcher.txt(params);
+                    return await Fetcher.txt(params);
                 case 'markdown':
-                    return await BrowserFetcher.markdown(params);
+                    return await Fetcher.markdown(params);
+                default:
+                    throw new Error(`Unsupported content type: ${type}`);
             }
         }
         else {
@@ -48,63 +49,112 @@ export async function fetchWithAutoDetect(params, type) {
             }
             try {
                 // 根据类型选择合适的标准获取方法 (Choose appropriate standard fetching method based on type)
+                let result;
                 switch (type) {
                     case 'html': {
-                        const result = await NodeFetcher.html(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: result.html }],
-                            isError: false
-                        };
+                        result = await Fetcher.html(params);
+                        break;
                     }
                     case 'json': {
-                        const result = await NodeFetcher.json(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: typeof result.json === 'string' ? result.json : JSON.stringify(result.json, null, 2) }],
-                            isError: false
-                        };
+                        result = await Fetcher.json(params);
+                        break;
                     }
                     case 'txt': {
-                        const result = await NodeFetcher.txt(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: result.text }],
-                            isError: false
-                        };
+                        result = await Fetcher.txt(params);
+                        break;
                     }
                     case 'markdown': {
-                        const result = await NodeFetcher.markdown(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: result.markdown }],
-                            isError: false
+                        result = await Fetcher.markdown(params);
+                        break;
+                    }
+                    default:
+                        throw new Error(`Unsupported content type: ${type}`);
+                }
+                // 检查结果是否为错误，并且是否包含403或forbidden关键词
+                if (result.isError && autoDetectMode) {
+                    const errorText = result.content && result.content[0] && result.content[0].text
+                        ? String(result.content[0].text)
+                        : '';
+                    const is403Error = errorText.includes('403') ||
+                        errorText.toLowerCase().includes('forbidden');
+                    if (is403Error || shouldSwitchToBrowser(errorText)) {
+                        if (debug) {
+                            log('server.switchingToBrowserMode', debug, {
+                                url: params.url,
+                                error: errorText,
+                                reason: is403Error ? '403 Forbidden' : 'Other error requiring browser'
+                            }, COMPONENTS.SERVER);
+                        }
+                        // 确保浏览器已初始化
+                        await initializeBrowser(debug);
+                        // 设置浏览器模式参数
+                        const browserParams = {
+                            ...params,
+                            useBrowser: true,
+                            debug: debug
                         };
+                        // 根据类型选择合适的浏览器获取方法
+                        let browserResult;
+                        switch (type) {
+                            case 'html':
+                                browserResult = await Fetcher.html(browserParams);
+                                break;
+                            case 'json':
+                                browserResult = await Fetcher.json(browserParams);
+                                break;
+                            case 'txt':
+                                browserResult = await Fetcher.txt(browserParams);
+                                break;
+                            case 'markdown':
+                                browserResult = await Fetcher.markdown(browserParams);
+                                break;
+                            default:
+                                throw new Error(`Unsupported content type: ${type}`);
+                        }
+                        return browserResult;
                     }
                 }
+                return result;
             }
             catch (error) {
                 // 如果标准模式失败且启用了自动检测
-                if (autoDetectMode && shouldSwitchToBrowser(error)) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // 检查是否应该切换到浏览器模式
+                // 特别处理 HTTP 403 Forbidden 错误，这是最常见的需要切换到浏览器模式的情况
+                const shouldSwitch = autoDetectMode && (shouldSwitchToBrowser(error) ||
+                    errorMessage.includes('403') ||
+                    errorMessage.toLowerCase().includes('forbidden'));
+                if (shouldSwitch) {
                     if (debug) {
                         log('server.switchingToBrowserMode', debug, { url: params.url }, COMPONENTS.SERVER);
                     }
                     // 确保浏览器已初始化
                     await initializeBrowser(debug);
                     // 设置浏览器模式参数
-                    params.useBrowser = true;
-                    params.debug = debug;
+                    const browserParams = {
+                        ...params,
+                        useBrowser: true,
+                        debug: debug
+                    };
                     // 根据类型选择合适的浏览器获取方法
+                    let browserResult;
                     switch (type) {
                         case 'html':
-                            return await BrowserFetcher.html(params);
+                            browserResult = await Fetcher.html(browserParams);
+                            break;
                         case 'json':
-                            return await BrowserFetcher.json(params);
+                            browserResult = await Fetcher.json(browserParams);
+                            break;
                         case 'txt':
-                            return await BrowserFetcher.txt(params);
+                            browserResult = await Fetcher.txt(browserParams);
+                            break;
                         case 'markdown':
-                            return await BrowserFetcher.markdown(params);
+                            browserResult = await Fetcher.markdown(browserParams);
+                            break;
+                        default:
+                            throw new Error(`Unsupported content type: ${type}`);
                     }
+                    return browserResult;
                 }
                 // 如果不需要切换到浏览器模式，则抛出原始错误
                 throw error;
@@ -127,4 +177,4 @@ export async function fetchWithAutoDetect(params, type) {
         content: [{ type: 'text', text: `Unsupported content type: ${type}` }],
         isError: true
     };
-}
+} // 修复注释

package/dist/src/lib/server/index.js

@@ -3,8 +3,8 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { log, COMPONENTS } from '../logger.js';
 import { closeBrowserInstance } from './browser.js';
 import { registerTools } from './tools.js';

package/dist/src/lib/server/prompts.js

@@ -3,7 +3,7 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { ListPromptsRequestSchema, GetPromptRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { log, COMPONENTS } from '../logger.js';
 import { t } from '../i18n/index.js';
 // 定义提示模板 (Define prompt templates)

package/dist/src/lib/server/resources.js

@@ -3,7 +3,7 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { log, getLogFilePath, clearLogFile, COMPONENTS } from '../logger.js';
 import fs from 'fs';
 import path from 'path';

package/dist/src/lib/server/tools.js

@@ -3,7 +3,7 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { log, COMPONENTS } from '../logger.js';
 import { fetchWithAutoDetect } from './fetcher.js';
 import { closeBrowserInstance } from './browser.js';
@@ -312,18 +312,20 @@ function registerToolCallHandler(server) {
             // 处理不同类型的获取请求 (Handle different types of fetch requests)
             if (name === 'fetch_html' || name === 'fetch_json' || name === 'fetch_txt' || name === 'fetch_markdown') {
                 const result = await handleFetchRequest(name, args, debug);
+                // 直接返回符合 MCP SDK 要求的格式
                 return result;
             }
             else {
                 // 未知工具 (Unknown tool)
                 log('tools.unknownTool', debug, { name }, COMPONENTS.SERVER);
                 return {
-                    isError: true,
                     content: [
                         {
+                            type: "text",
                             text: `Unknown tool: ${name}`
                         }
-                    ]
+                    ],
+                    isError: true
                 };
             }
         }
@@ -331,12 +333,13 @@ function registerToolCallHandler(server) {
             // 处理错误 (Handle error)
             log('tools.callError', debug, { name, error: error.message }, COMPONENTS.SERVER);
             return {
-                isError: true,
                 content: [
                     {
+                        type: "text",
                         text: error.message
                     }
-                ]
+                ],
+                isError: true
             };
         }
         finally {
@@ -359,12 +362,13 @@ async function handleFetchRequest(name, args, debug) {
     if (!args.url) {
         log('tools.missingUrl', debug, {}, COMPONENTS.SERVER);
         return {
-            isError: true,
             content: [
                 {
+                    type: "text",
                     text: "URL parameter is required"
                 }
-            ]
+            ],
+            isError: true
         };
     }
     // 记录请求 (Log request)
@@ -378,18 +382,50 @@ async function handleFetchRequest(name, args, debug) {
         // 根据工具名称确定内容类型 (Determine content type based on tool name)
         const type = name.replace('fetch_', '');
         const result = await fetchWithAutoDetect(params, type);
-        return result;
+        // 确保返回标准结构体 (Ensure returning standard structure)
+        if (result.isError) {
+            // 确保错误内容有正确的类型 (Ensure error content has correct type)
+            if (!result.content[0].type) {
+                result.content[0].type = "text";
+            }
+        }
+        else {
+            // 对于 JSON 类型，验证内容是否为有效的 JSON (For JSON type, validate if content is valid JSON)
+            if (type === 'json') {
+                try {
+                    // 尝试解析 JSON (Try to parse JSON)
+                    JSON.parse(result.content[0].text);
+                }
+                catch (jsonError) {
+                    // JSON 解析失败，但仍然返回原始内容 (JSON parsing failed, but still return original content)
+                    log('tools.jsonParseWarning', debug, { error: jsonError.message }, COMPONENTS.SERVER);
+                    // 不将 isError 设置为 true，保持原始结果
+                    // (Don't set isError to true, keep original result)
+                }
+            }
+            // 确保成功内容有正确的类型 (Ensure success content has correct type)
+            if (!result.content[0].type) {
+                result.content[0].type = "text";
+            }
+        }
+        // 将FetchResponse转换为符合MCP SDK要求的格式
+        return {
+            content: result.content,
+            isError: result.isError
+        };
     }
     catch (error) {
         // 处理错误 (Handle error)
         log('tools.fetchError', debug, { url: args.url, error: error.message }, COMPONENTS.SERVER);
+        // 确保返回标准结构体 (Ensure returning standard structure)
         return {
-            isError: true,
             content: [
                 {
+                    type: "text",
                     text: `Error fetching ${args.url}: ${error.message}`
                 }
-            ]
+            ],
+            isError: true
         };
     }
 }

package/dist/src/lib/utils/ErrorHandler.js

@@ -0,0 +1,125 @@
+/*
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { isAccessDeniedError, isNetworkError } from './errorDetection.js';
+import { log, COMPONENTS } from '../logger.js';
+/**
+ * 错误类型枚举
+ * (Error type enumeration)
+ */
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType["NETWORK"] = "network";
+    ErrorType["ACCESS_DENIED"] = "access_denied";
+    ErrorType["TIMEOUT"] = "timeout";
+    ErrorType["PARSE"] = "parse";
+    ErrorType["VALIDATION"] = "validation";
+    ErrorType["BROWSER"] = "browser";
+    ErrorType["UNKNOWN"] = "unknown";
+})(ErrorType || (ErrorType = {}));
+/**
+ * 错误处理器类，用于统一处理和分类错误
+ * (Error handler class for unified error handling and classification)
+ */
+export class ErrorHandler {
+    /**
+     * 处理错误并返回格式化的错误消息
+     * (Handle error and return formatted error message)
+     *
+     * @param error 捕获的错误对象 (Caught error object)
+     * @param component 组件名称，用于日志 (Component name for logging)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @param context 错误上下文信息 (Error context information)
+     * @returns 格式化的错误消息 (Formatted error message)
+     */
+    static handleError(error, component = COMPONENTS.SERVER, debug = false, context = {}) {
+        const errorType = this.classifyError(error);
+        const errorMessage = this.getErrorMessage(error);
+        // 记录错误日志
+        // (Log error)
+        log(`errors.${errorType}_error`, debug, {
+            error: errorMessage,
+            ...context
+        }, component);
+        return errorMessage;
+    }
+    /**
+     * 分类错误类型
+     * (Classify error type)
+     *
+     * @param error 捕获的错误对象 (Caught error object)
+     * @returns 错误类型 (Error type)
+     */
+    static classifyError(error) {
+        const errorMessage = this.getErrorMessage(error);
+        // 先检查超时错误 (Check timeout errors first)
+        if (errorMessage.toLowerCase().includes('timeout')) {
+            return ErrorType.TIMEOUT;
+        }
+        if (isNetworkError(errorMessage)) {
+            return ErrorType.NETWORK;
+        }
+        if (isAccessDeniedError(errorMessage)) {
+            return ErrorType.ACCESS_DENIED;
+        }
+        if (errorMessage.toLowerCase().includes('parse') ||
+            errorMessage.toLowerCase().includes('json') ||
+            errorMessage.toLowerCase().includes('syntax')) {
+            return ErrorType.PARSE;
+        }
+        if (errorMessage.toLowerCase().includes('browser') ||
+            errorMessage.toLowerCase().includes('puppeteer') ||
+            errorMessage.toLowerCase().includes('page') ||
+            errorMessage.toLowerCase().includes('chrome')) {
+            return ErrorType.BROWSER;
+        }
+        if (errorMessage.toLowerCase().includes('valid') ||
+            errorMessage.toLowerCase().includes('schema') ||
+            errorMessage.toLowerCase().includes('type')) {
+            return ErrorType.VALIDATION;
+        }
+        return ErrorType.UNKNOWN;
+    }
+    /**
+     * 获取错误消息
+     * (Get error message)
+     *
+     * @param error 捕获的错误对象 (Caught error object)
+     * @returns 错误消息字符串 (Error message string)
+     */
+    static getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        if (error && typeof error === 'object') {
+            if ('message' in error && typeof error.message === 'string') {
+                return error.message;
+            }
+            try {
+                return JSON.stringify(error);
+            }
+            catch {
+                return String(error);
+            }
+        }
+        return String(error);
+    }
+    /**
+     * 创建带有错误类型的错误对象
+     * (Create error object with error type)
+     *
+     * @param message 错误消息 (Error message)
+     * @param type 错误类型 (Error type)
+     * @returns 带有类型的错误对象 (Error object with type)
+     */
+    static createError(message, type = ErrorType.UNKNOWN) {
+        const error = new Error(message);
+        error.type = type;
+        return error;
+    }
+}

package/dist/src/test-i18n.js

@@ -0,0 +1,139 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 测试国际化功能 (Test internationalization functionality)
+import { log, COMPONENTS, clearTranslationCache } from './lib/logger.js';
+import { t, changeLanguage, getCurrentLanguage } from './lib/i18n/index.js';
+/**
+ * 测试翻译键 (Test translation keys)
+ * @param keys 要测试的键数组 (Array of keys to test)
+ * @param language 语言 (Language)
+ */
+function testKeys(keys, language) {
+    console.log(`\n=== 测试 ${language} 翻译 (Testing ${language} translation) ===`);
+    for (const key of keys) {
+        try {
+            const translated = t(key);
+            console.log(`Key: ${key}`);
+            console.log(`Translation: ${translated}`);
+            console.log('---');
+        }
+        catch (error) {
+            console.error(`Error translating key: ${key}`);
+            console.error(error);
+            console.log('---');
+        }
+    }
+}
+/**
+ * 测试日志函数 (Test log function)
+ * @param keys 要测试的键数组 (Array of keys to test)
+ * @param component 组件名称 (Component name)
+ */
+function testLogFunction(keys, component) {
+    console.log(`\n=== 测试日志函数 (Testing log function) ===`);
+    for (const key of keys) {
+        log(key, true, {}, component);
+    }
+}
+/**
+ * 测试带参数的翻译 (Test translation with parameters)
+ * @param keys 要测试的键数组 (Array of keys to test)
+ * @param params 参数对象 (Parameters object)
+ */
+function testWithParams(keys, params) {
+    console.log(`\n=== 测试带参数的翻译 (Testing translation with parameters) ===`);
+    for (const key of keys) {
+        try {
+            const translated = t(key, params);
+            console.log(`Key: ${key}`);
+            console.log(`Params: ${JSON.stringify(params)}`);
+            console.log(`Translation: ${translated}`);
+            console.log('---');
+        }
+        catch (error) {
+            console.error(`Error translating key with params: ${key}`);
+            console.error(error);
+            console.log('---');
+        }
+    }
+}
+/**
+ * 测试翻译缓存 (Test translation cache)
+ * @param key 要测试的键 (Key to test)
+ * @param iterations 迭代次数 (Number of iterations)
+ */
+function testTranslationCache(key, iterations) {
+    console.log(`\n=== 测试翻译缓存 (Testing translation cache) ===`);
+    console.log(`Key: ${key}`);
+    console.log(`Iterations: ${iterations}`);
+    // 清除翻译缓存 (Clear translation cache)
+    clearTranslationCache();
+    // 测试不使用缓存的性能 (Test performance without cache)
+    console.log('Without cache:');
+    const startWithoutCache = Date.now();
+    for (let i = 0; i < iterations; i++) {
+        t(key);
+    }
+    const endWithoutCache = Date.now();
+    console.log(`Time: ${endWithoutCache - startWithoutCache}ms`);
+    // 测试使用缓存的性能 (Test performance with cache)
+    console.log('With cache:');
+    const startWithCache = Date.now();
+    for (let i = 0; i < iterations; i++) {
+        log(key, true, {}, COMPONENTS.SERVER);
+    }
+    const endWithCache = Date.now();
+    console.log(`Time: ${endWithCache - startWithCache}ms`);
+    console.log('---');
+}
+/**
+ * 设置环境变量 (Set environment variable)
+ * @param name 环境变量名称 (Environment variable name)
+ * @param value 环境变量值 (Environment variable value)
+ */
+function setEnv(name, value) {
+    process.env[name] = value;
+    console.log(`Set environment variable ${name}=${value}`);
+}
+/**
+ * 主测试函数 (Main test function)
+ */
+async function testI18n() {
+    console.log('=== 测试国际化功能 (Testing internationalization functionality) ===');
+    // 测试简单的键 (Test simple keys)
+    const simpleKeys = [
+        'server.starting',
+        'server.started',
+        'server.stopping',
+        'server.stopped'
+    ];
+    // 确保 MCP_LANG 环境变量设置为英文 (Ensure MCP_LANG environment variable is set to English)
+    setEnv('MCP_LANG', 'en');
+    // 测试英文翻译 (Test English translation)
+    changeLanguage('en');
+    console.log(`Current language: ${getCurrentLanguage()}`);
+    testKeys(simpleKeys, 'English');
+    // 测试日志函数 (Test log function)
+    testLogFunction(simpleKeys, COMPONENTS.SERVER);
+    // 测试带参数的翻译 (Test translation with parameters)
+    testWithParams(['server.listeningOn'], { port: 8080 });
+    // 测试翻译缓存 (Test translation cache)
+    testTranslationCache('server.starting', 10);
+    // 确保 MCP_LANG 环境变量设置为中文 (Ensure MCP_LANG environment variable is set to Chinese)
+    setEnv('MCP_LANG', 'zh');
+    // 测试中文翻译 (Test Chinese translation)
+    changeLanguage('zh');
+    console.log(`Current language: ${getCurrentLanguage()}`);
+    testKeys(simpleKeys, 'Chinese');
+    // 测试日志函数 (Test log function)
+    testLogFunction(simpleKeys, COMPONENTS.SERVER);
+    // 测试带参数的翻译 (Test translation with parameters)
+    testWithParams(['server.listeningOn'], { port: 8080 });
+    // 测试翻译缓存 (Test translation cache)
+    testTranslationCache('server.starting', 10);
+}
+// 运行测试 (Run test)
+testI18n().catch(console.error);