@lmcc-dev/mult-fetch-mcp-server 1.0.1

package/dist/src/lib/NodeFetcher.js

@@ -0,0 +1,428 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import TurndownService from "turndown";
+import fetch from "node-fetch";
+import { HttpProxyAgent } from "http-proxy-agent";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { execSync } from 'child_process';
+import { log, COMPONENTS } from './logger.js';
+export class NodeFetcher {
+    /**
+     * 常用浏览器的User-Agent列表 (List of common browser User-Agents)
+     * 用于模拟不同浏览器的请求 (Used to simulate requests from different browsers)
+     */
+    static userAgents = [
+        // Chrome
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+        // Firefox
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0',
+        // Safari
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
+        // Edge
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59'
+    ];
+    /**
+     * 获取随机User-Agent (Get random User-Agent)
+     * @returns 随机的User-Agent字符串 (Random User-Agent string)
+     */
+    static getRandomUserAgent() {
+        const index = Math.floor(Math.random() * this.userAgents.length);
+        return this.userAgents[index];
+    }
+    /**
+     * 随机延迟函数 (Random delay function)
+     * 模拟人类行为，避免被检测为机器人 (Simulate human behavior, avoid being detected as a bot)
+     * @param minMs 最小延迟毫秒数 (Minimum delay in milliseconds)
+     * @param maxMs 最大延迟毫秒数 (Maximum delay in milliseconds)
+     * @returns Promise对象 (Promise object)
+     */
+    static async randomDelay(minMs = 500, maxMs = 3000) {
+        const delay = Math.floor(Math.random() * (maxMs - minMs + 1)) + minMs;
+        return new Promise(resolve => setTimeout(resolve, delay));
+    }
+    /**
+     * 获取系统代理设置 (Get system proxy settings)
+     * @param useSystemProxy 是否使用系统代理 (Whether to use system proxy)
+     * @returns 代理URL或undefined (Proxy URL or undefined)
+     */
+    static getSystemProxy(useSystemProxy = true) {
+        if (!useSystemProxy) {
+            return undefined;
+        }
+        // 检查环境变量 (Check environment variables)
+        log('fetcher.checkingProxyEnv', true, {}, COMPONENTS.NODE_FETCH);
+        const envVars = ['https_proxy', 'HTTPS_PROXY', 'http_proxy', 'HTTP_PROXY'];
+        for (const envVar of envVars) {
+            log('fetcher.envVarValue', true, {
+                envVar,
+                value: process.env[envVar]
+            }, COMPONENTS.NODE_FETCH);
+            if (process.env[envVar]) {
+                const proxyUrl = process.env[envVar];
+                log('fetcher.foundSystemProxy', true, { proxy: proxyUrl }, COMPONENTS.NODE_FETCH);
+                return proxyUrl;
+            }
+        }
+        // 尝试使用系统命令获取环境变量 (Try to get environment variables using system commands)
+        try {
+            const platform = process.platform;
+            let proxyUrl;
+            log('fetcher.checkingSystemEnvVars', true, { platform }, COMPONENTS.NODE_FETCH);
+            if (platform === 'win32') {
+                // Windows系统 - 使用set命令 (Windows - use set command)
+                try {
+                    // 使用set命令获取代理环境变量 (Use set command to get proxy environment variables)
+                    const setOutput = execSync('set http_proxy & set https_proxy & set HTTP_PROXY & set HTTPS_PROXY').toString();
+                    log('fetcher.windowsEnvVars', true, { output: setOutput.trim() }, COMPONENTS.NODE_FETCH);
+                    // 解析输出找到代理设置 (Parse output to find proxy settings)
+                    const proxyMatch = setOutput.match(/(?:http_proxy|https_proxy|HTTP_PROXY|HTTPS_PROXY)=(https?:\/\/[^=\r\n]+)/i);
+                    if (proxyMatch && proxyMatch[1]) {
+                        proxyUrl = proxyMatch[1].trim();
+                        log('fetcher.foundWindowsEnvProxy', true, { proxy: proxyUrl }, COMPONENTS.NODE_FETCH);
+                    }
+                }
+                catch (winError) {
+                    log('fetcher.errorGettingWindowsEnvVars', true, { error: String(winError) }, COMPONENTS.NODE_FETCH);
+                }
+            }
+            else {
+                // Unix系统 (macOS/Linux) - 使用export或env命令 (Unix systems - use export or env command)
+                try {
+                    // 使用env命令获取所有环境变量 (Use env command to get all environment variables)
+                    const envOutput = execSync('env').toString();
+                    log('fetcher.unixEnvVars', true, { output: envOutput.length > 200 ? envOutput.substring(0, 200) + '...' : envOutput }, COMPONENTS.NODE_FETCH);
+                    // 解析输出找到代理设置 (Parse output to find proxy settings)
+                    const proxyMatch = envOutput.match(/(?:http_proxy|https_proxy|HTTP_PROXY|HTTPS_PROXY)=(https?:\/\/[^=\n]+)/i);
+                    if (proxyMatch && proxyMatch[1]) {
+                        proxyUrl = proxyMatch[1].trim();
+                        log('fetcher.foundUnixEnvProxy', true, { proxy: proxyUrl }, COMPONENTS.NODE_FETCH);
+                    }
+                }
+                catch (unixError) {
+                    log('fetcher.errorGettingUnixEnvVars', true, { error: String(unixError) }, COMPONENTS.NODE_FETCH);
+                }
+            }
+            if (proxyUrl) {
+                return proxyUrl;
+            }
+            // 如果没有找到代理，记录日志 (If no proxy is found, log a message)
+            log('fetcher.noSystemProxyFound', true, {}, COMPONENTS.NODE_FETCH);
+        }
+        catch (error) {
+            log('fetcher.errorGettingSystemEnvVars', true, { error: String(error) }, COMPONENTS.NODE_FETCH);
+        }
+        // 检查NO_PROXY环境变量 (Check NO_PROXY environment variable)
+        const noProxy = process.env.NO_PROXY || process.env.no_proxy;
+        if (noProxy) {
+            log('fetcher.foundNoProxy', true, { noProxy }, COMPONENTS.NODE_FETCH);
+        }
+        return undefined;
+    }
+    /**
+     * 执行带重定向处理的HTTP请求 (Perform HTTP request with redirect handling)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns 响应数据 (Response data)
+     */
+    static async _fetchWithRedirects({ url, headers = {}, proxy, noDelay, timeout = 30000, // 默认30秒超时
+    maxRedirects = 10, // 最大重定向次数
+    useSystemProxy = true, // 是否使用系统代理
+    debug = false, // 是否启用调试模式
+     }) {
+        log('node.fetchingUrl', debug, { url }, COMPONENTS.NODE_FETCH);
+        // 处理代理设置 (Handle proxy settings)
+        const systemProxy = this.getSystemProxy(useSystemProxy);
+        const finalProxy = proxy || systemProxy;
+        if (finalProxy) {
+            log('node.usingProxy', debug, { proxy: finalProxy }, COMPONENTS.NODE_FETCH);
+        }
+        // 初始化重定向计数器 (Initialize redirect counter)
+        let redirectCount = 0;
+        let currentUrl = url;
+        // 记录请求开始时间 (Record request start time)
+        const fetchStart = Date.now();
+        // 创建AbortController用于超时控制 (Create AbortController for timeout control)
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            // 处理重定向循环 (Handle redirect loop)
+            while (redirectCount < maxRedirects) {
+                log('node.fetchingUrl', debug, { url: currentUrl, redirect: redirectCount }, COMPONENTS.NODE_FETCH);
+                // 如果启用了随机延迟且不是第一个请求，则添加延迟 (Add delay if random delay is enabled and not the first request)
+                if (!noDelay && redirectCount > 0) {
+                    await this.randomDelay();
+                }
+                // 准备请求头 (Prepare request headers)
+                const requestHeaders = {
+                    ...headers
+                };
+                // 添加随机User-Agent (Add random User-Agent)
+                if (!requestHeaders['User-Agent']) {
+                    const userAgent = this.getRandomUserAgent();
+                    requestHeaders['User-Agent'] = userAgent;
+                    log('node.usingUserAgent', debug, { userAgent }, COMPONENTS.NODE_FETCH);
+                }
+                // 准备请求选项 (Prepare request options)
+                const fetchOptions = {
+                    method: 'GET',
+                    headers: requestHeaders,
+                    timeout,
+                    signal: controller.signal,
+                };
+                // 设置代理 (Set proxy)
+                let agent = undefined;
+                if (finalProxy) {
+                    if (currentUrl.startsWith('https://')) {
+                        agent = new HttpsProxyAgent(finalProxy);
+                        log('node.usingHttpsProxy', debug, {}, COMPONENTS.NODE_FETCH);
+                    }
+                    else {
+                        agent = new HttpProxyAgent(finalProxy);
+                        log('node.usingHttpProxy', debug, {}, COMPONENTS.NODE_FETCH);
+                    }
+                    fetchOptions.agent = agent;
+                }
+                // 记录请求详情 (Log request details)
+                log('node.requestDetails', debug, {
+                    url: currentUrl,
+                    method: fetchOptions.method || 'GET',
+                    headers: requestHeaders,
+                    proxy: finalProxy,
+                    timeout,
+                }, COMPONENTS.NODE_FETCH);
+                // 执行请求 (Execute request)
+                const response = await fetch(currentUrl, fetchOptions);
+                // 记录响应状态 (Log response status)
+                log('node.responseStatus', debug, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: Object.fromEntries(response.headers.entries()),
+                }, COMPONENTS.NODE_FETCH);
+                // 处理重定向 (Handle redirects)
+                if (response.status >= 300 && response.status < 400 && response.headers.has('location')) {
+                    redirectCount++;
+                    // 获取重定向URL (Get redirect URL)
+                    const location = response.headers.get('location');
+                    log('node.redirectingTo', debug, { location }, COMPONENTS.NODE_FETCH);
+                    // 构建完整的重定向URL (Build complete redirect URL)
+                    let redirectUrl = location;
+                    if (location.startsWith('/')) {
+                        const urlObj = new URL(currentUrl);
+                        redirectUrl = `${urlObj.protocol}//${urlObj.host}${location}`;
+                    }
+                    else if (!location.startsWith('http')) {
+                        redirectUrl = new URL(location, currentUrl).toString();
+                    }
+                    log('node.constructedFullRedirectUrl', debug, { redirectUrl }, COMPONENTS.NODE_FETCH);
+                    // 更新当前URL为重定向URL (Update current URL to redirect URL)
+                    currentUrl = redirectUrl;
+                    continue;
+                }
+                // 如果响应成功，返回响应 (If response is successful, return response)
+                if (response.ok) {
+                    log('node.requestSuccess', debug, {}, COMPONENTS.NODE_FETCH);
+                    return response;
+                }
+                else {
+                    // 处理错误响应 (Handle error response)
+                    log('node.errorResponse', debug, { status: response.status, statusText: response.statusText }, COMPONENTS.NODE_FETCH);
+                    // 尝试读取错误响应体 (Try to read error response body)
+                    let errorText = '';
+                    try {
+                        errorText = await response.text();
+                        log('node.errorResponseBody', debug, { body: errorText.substring(0, 200) + (errorText.length > 200 ? '...' : '') }, COMPONENTS.NODE_FETCH);
+                    }
+                    catch (textError) {
+                        log('node.errorReadingBody', debug, { error: String(textError) }, COMPONENTS.NODE_FETCH);
+                    }
+                    // 创建错误对象 (Create error object)
+                    const error = new Error(`HTTP Error ${response.status}: ${response.statusText}`);
+                    error.status = response.status;
+                    error.statusText = response.statusText;
+                    error.body = errorText;
+                    throw error;
+                }
+            }
+            // 如果达到最大重定向次数，抛出错误 (If maximum redirects reached, throw error)
+            throw new Error(`Too many redirects (${maxRedirects})`);
+        }
+        catch (error) {
+            // 清除超时定时器 (Clear timeout timer)
+            clearTimeout(timeoutId);
+            // 记录错误 (Log error)
+            log('node.fetchError', debug, { error: String(error) }, COMPONENTS.NODE_FETCH);
+            // 处理超时错误 (Handle timeout error)
+            if (error.name === 'AbortError') {
+                log('node.requestAborted', debug, { duration: Date.now() - fetchStart }, COMPONENTS.NODE_FETCH);
+                const timeoutError = new Error(`Request timeout after ${timeout}ms`);
+                timeoutError.code = 'ETIMEDOUT';
+                timeoutError.timeout = timeout;
+                throw timeoutError;
+            }
+            // 处理网络错误 (Handle network error)
+            if (error.code) {
+                log('node.networkError', debug, { code: error.code || error.name }, COMPONENTS.NODE_FETCH);
+                const networkError = new Error(`Network error: ${error.code || error.message}`);
+                networkError.code = error.code;
+                networkError.originalError = error;
+                throw networkError;
+            }
+            // 处理重定向错误 (Handle redirect error)
+            if (redirectCount >= maxRedirects) {
+                log('node.tooManyRedirects', debug, { redirects: maxRedirects }, COMPONENTS.NODE_FETCH);
+                const redirectError = new Error(`Too many redirects (${maxRedirects})`);
+                redirectError.code = 'EMAXREDIRECTS';
+                redirectError.redirects = redirectCount;
+                throw redirectError;
+            }
+            // 重新抛出其他错误 (Rethrow other errors)
+            throw error;
+        }
+        finally {
+            // 清除超时定时器 (Clear timeout timer)
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * 获取HTML内容 (Get HTML content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns HTML内容 (HTML content)
+     */
+    static async html(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('node.startingHtmlFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await this._fetchWithRedirects(requestPayload);
+            // 读取响应文本 (Read response text)
+            log('node.readingText', debug, {}, COMPONENTS.NODE_FETCH);
+            const html = await response.text();
+            log('node.htmlContentLength', debug, { length: html.length }, COMPONENTS.NODE_FETCH);
+            // 返回HTML内容 (Return HTML content)
+            return {
+                html,
+                url: response.url,
+                status: response.status,
+                headers: Object.fromEntries(response.headers.entries()),
+            };
+        }
+        catch (error) {
+            // 处理错误 (Handle error)
+            log('node.htmlFetchError', debug, { error: error instanceof Error ? error.message : String(error) }, COMPONENTS.NODE_FETCH);
+            // 重新抛出错误 (Rethrow error)
+            throw error;
+        }
+    }
+    /**
+     * 获取JSON内容 (Get JSON content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns JSON内容 (JSON content)
+     */
+    static async json(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('node.startingJsonFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await this._fetchWithRedirects(requestPayload);
+            // 读取响应文本 (Read response text)
+            const text = await response.text();
+            // 解析JSON (Parse JSON)
+            log('node.parsingJson', debug, {}, COMPONENTS.NODE_FETCH);
+            let json;
+            try {
+                json = JSON.parse(text);
+                log('node.jsonParsed', debug, {}, COMPONENTS.NODE_FETCH);
+            }
+            catch (parseError) {
+                // 处理JSON解析错误 (Handle JSON parse error)
+                const error = new Error(`Invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+                error.text = text;
+                error.originalError = parseError;
+                log('node.jsonParseError', debug, { error: String(parseError) }, COMPONENTS.NODE_FETCH);
+                throw error;
+            }
+            // 返回JSON内容 (Return JSON content)
+            return {
+                json,
+                text,
+                url: response.url,
+                status: response.status,
+                headers: Object.fromEntries(response.headers.entries()),
+            };
+        }
+        catch (error) {
+            // 处理错误 (Handle error)
+            log('node.jsonFetchError', debug, { error: error instanceof Error ? error.message : String(error) }, COMPONENTS.NODE_FETCH);
+            // 重新抛出错误 (Rethrow error)
+            throw error;
+        }
+    }
+    /**
+     * 获取纯文本内容 (Get plain text content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns 纯文本内容 (Plain text content)
+     */
+    static async txt(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('fetcher.startingTxtFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await this._fetchWithRedirects(requestPayload);
+            // 读取响应文本 (Read response text)
+            log('fetcher.readingText', debug, {}, COMPONENTS.NODE_FETCH);
+            const text = await response.text();
+            log('fetcher.textContentLength', debug, { length: text.length }, COMPONENTS.NODE_FETCH);
+            // 返回纯文本内容 (Return plain text content)
+            return {
+                text,
+                url: response.url,
+                status: response.status,
+                headers: Object.fromEntries(response.headers.entries()),
+            };
+        }
+        catch (error) {
+            // 重新抛出错误 (Rethrow error)
+            throw error;
+        }
+    }
+    /**
+     * 获取Markdown内容 (Get Markdown content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns Markdown内容 (Markdown content)
+     */
+    static async markdown(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('fetcher.startingMarkdownFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await this._fetchWithRedirects(requestPayload);
+            // 读取响应文本 (Read response text)
+            log('fetcher.readingText', debug, {}, COMPONENTS.NODE_FETCH);
+            const html = await response.text();
+            log('fetcher.htmlContentLength', debug, { length: html.length }, COMPONENTS.NODE_FETCH);
+            // 创建Turndown服务 (Create Turndown service)
+            log('fetcher.creatingTurndown', debug, {}, COMPONENTS.NODE_FETCH);
+            const turndownService = new TurndownService();
+            // 将HTML转换为Markdown (Convert HTML to Markdown)
+            log('fetcher.convertingToMarkdown', debug, {}, COMPONENTS.NODE_FETCH);
+            const markdown = turndownService.turndown(html);
+            log('fetcher.markdownContentLength', debug, { length: markdown.length }, COMPONENTS.NODE_FETCH);
+            // 返回Markdown内容 (Return Markdown content)
+            return {
+                markdown,
+                html,
+                url: response.url,
+                status: response.status,
+                headers: Object.fromEntries(response.headers.entries()),
+            };
+        }
+        catch (error) {
+            // 重新抛出错误 (Rethrow error)
+            throw error;
+        }
+    }
+}

package/dist/src/lib/example.js

@@ -0,0 +1,93 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+/**
+ * 示例工具类，展示双语注释风格 (Example utility class, demonstrating bilingual comment style)
+ * 包含各种实用函数和示例 (Contains various utility functions and examples)
+ */
+export class ExampleUtils {
+    /**
+     * 缓存存储 (Cache storage)
+     * 用于存储临时数据 (Used to store temporary data)
+     */
+    static cache = new Map();
+    /**
+     * 获取用户信息 (Get user information)
+     * @param userId 用户唯一标识 (Unique identifier of the user)
+     * @param includeDetails 是否包含详细信息 (Whether to include detailed information)
+     * @returns 用户详细信息 (Detailed user information)
+     */
+    static async getUserInfo(userId, includeDetails = false) {
+        // 检查缓存中是否存在用户信息 (Check if user information exists in cache)
+        const cacheKey = `user_${userId}_${includeDetails ? 'detailed' : 'basic'}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        // 从数据库中查询用户 (Fetch user from the database)
+        const user = await this.fetchUserFromDB(userId);
+        // 如果需要详细信息，则获取额外数据 (If detailed information is needed, get additional data)
+        if (includeDetails && user) {
+            // 获取用户的额外信息 (Get additional information of the user)
+            user.details = await this.fetchUserDetails(userId);
+        }
+        // 将结果存入缓存 (Store the result in cache)
+        this.cache.set(cacheKey, user);
+        return user;
+    }
+    /**
+     * 从数据库获取用户基本信息 (Fetch basic user information from database)
+     * @param userId 用户ID (User ID)
+     * @returns 用户基本信息 (Basic user information)
+     */
+    static async fetchUserFromDB(userId) {
+        try {
+            // 这里是模拟的数据库查询 (This is a simulated database query)
+            console.log(`从数据库获取用户 ${userId} 的信息 (Fetching information of user ${userId} from database)`);
+            // 模拟网络延迟 (Simulate network delay)
+            await new Promise(resolve => setTimeout(resolve, 100));
+            // 返回模拟数据 (Return simulated data)
+            return {
+                id: userId,
+                name: `User ${userId}`,
+                email: `user${userId}@example.com`,
+                createdAt: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            // 记录错误并返回null (Log error and return null)
+            console.error(`获取用户信息失败: ${error.message} (Failed to get user information: ${error.message})`);
+            return null;
+        }
+    }
+    /**
+     * 获取用户详细信息 (Get detailed user information)
+     * @param userId 用户ID (User ID)
+     * @returns 用户详细信息 (Detailed user information)
+     */
+    static async fetchUserDetails(userId) {
+        // 模拟获取用户详细信息 (Simulate getting detailed user information)
+        console.log(`获取用户 ${userId} 的详细信息 (Getting detailed information of user ${userId})`);
+        // 模拟网络延迟 (Simulate network delay)
+        await new Promise(resolve => setTimeout(resolve, 150));
+        // 返回模拟的详细信息 (Return simulated detailed information)
+        return {
+            address: '123 Example St, City, Country',
+            phone: '+1234567890',
+            preferences: {
+                theme: 'dark',
+                notifications: true
+            }
+        };
+    }
+    /**
+     * 清除缓存 (Clear cache)
+     * 删除所有缓存的数据 (Delete all cached data)
+     */
+    static clearCache() {
+        // 清空缓存映射 (Empty the cache map)
+        this.cache.clear();
+        console.log('缓存已清空 (Cache has been cleared)');
+    }
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import i18next from 'i18next';
+import { enTranslation } from './locales/en/index.js';
+import { zhTranslation } from './locales/zh/index.js';
+// 定义语言资源 (Define language resources)
+const resources = {
+    en: {
+        translation: enTranslation
+    },
+    zh: {
+        translation: zhTranslation
+    }
+};
+// 初始化 i18next (Initialize i18next)
+i18next.init({
+    resources,
+    // 优先使用专门的环境变量，其次默认使用英语
+    // (Priority: dedicated environment variable, then default to English)
+    lng: process.env.MCP_LANG || 'en',
+    fallbackLng: 'en',
+    interpolation: {
+        escapeValue: false // 不转义插值 (Don't escape interpolation)
+    }
+});
+// 导出 i18next 实例 (Export i18next instance)
+export default i18next;
+// 导出一个简便的翻译函数 (Export a convenient translation function)
+export const t = (key, options) => i18next.t(key, options);
+// 导出语言切换函数 (Export language switching function)
+export const changeLanguage = (lng) => i18next.changeLanguage(lng);
+// 导出获取当前语言函数 (Export get current language function)
+export const getCurrentLanguage = () => i18next.language;

package/dist/src/lib/i18n/locales/en/browser.js

@@ -0,0 +1,53 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 浏览器相关消息 (Browser related messages)
+export const browser = {
+    closing: "Closing browser...",
+    closed: "Browser closed",
+    starting: "Starting new browser instance",
+    startingFailed: "Browser startup failed: {{error}}",
+    waiting: "Browser is starting, waiting...",
+    startupSuccess: "Browser started successfully",
+    navigating: "Navigating to URL...",
+    waitingForSelector: "Waiting for selector: {{selector}}",
+    waitingForTimeout: "Waiting for timeout: {{timeout}}",
+    scrolling: "Auto-scrolling page...",
+    scrollCompleted: "Auto-scroll completed",
+    gettingContent: "Getting page content...",
+    savingCookies: "Saving cookies...",
+    contentLength: "Content length: {{length}}",
+    contentTruncated: "Content too large, truncating...",
+    pageClosed: "Page closed",
+    fetchError: "Error in browser fetch: {{error}}",
+    highMemory: "High memory usage detected, attempting to free resources...",
+    closingDueToMemory: "Closing browser due to high memory usage...",
+    closingError: "Error closing browser: {{error}}",
+    forcingGC: "Forcing garbage collection...",
+    memoryCheckError: "Error checking memory usage: {{error}}",
+    usingCookies: "Using stored cookies for domain: {{domain}}",
+    usingProxy: "Using proxy: {{proxy}}",
+    checkingCloudflare: "Checking for Cloudflare protection...",
+    cloudflareDetected: "Cloudflare protection detected, attempting to bypass...",
+    simulatingHuman: "Simulating human behavior...",
+    simulatingHumanError: "Error simulating human behavior: {{error}}",
+    stillOnCloudflare: "Still on Cloudflare protection page, trying to refresh...",
+    bypassFailed: "Failed to bypass Cloudflare protection",
+    cloudflareError: "Error handling Cloudflare protection: {{error}}",
+    continuingWithoutBypass: "Unable to bypass Cloudflare protection, continuing to try to get content...",
+    fetchingWithRetry: "Fetching HTML with browser (attempt {{attempt}}/{{maxAttempts}}): {{url}}",
+    memoryUsage: "Memory usage - Heap: {{heapUsed}}MB/{{heapTotal}}MB, RSS: {{rss}}MB",
+    memoryTooHigh: "Memory usage too high - Heap: {{heapUsed}}MB/{{heapTotal}}MB, RSS: {{rss}}MB",
+    unableToBypassCloudflare: "Unable to bypass Cloudflare protection, continuing to try to get content...",
+    contentTooLarge: "Content too large, truncating...",
+    failedToParseJSON: "Failed to parse JSON: {{error}}",
+    startingBrowserFetchForMarkdown: "Starting browser fetch for Markdown: {{url}}",
+    errorInBrowserFetchForMarkdown: "Error in browser fetch for Markdown: {{error}}",
+    fetchRequest: "Browser fetch request: {{url}}",
+    usingStoredCookies: "Using stored cookies for domain: {{domain}}",
+    closingInstance: "Closing browser instance",
+    fetchErrorWithAttempt: "Error in browser fetch (attempt {{attempt}}/{{maxAttempts}}): {{error}}",
+    retryingAfterDelay: "Retrying after {{delayMs}}ms delay..."
+};

package/dist/src/lib/i18n/locales/en/client.js

@@ -0,0 +1,40 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 客户端相关消息 (Client related messages)
+export const client = {
+    connecting: "Connecting to MCP server...",
+    connected: "Connected to MCP server",
+    disconnecting: "Disconnecting from MCP server...",
+    disconnected: "Disconnected from MCP server",
+    error: "Client error: {{error}}",
+    callTool: "Calling tool: {{tool}}",
+    callToolSuccess: "Tool call successful: {{tool}}",
+    callToolError: "Tool call failed: {{tool}}, error: {{error}}",
+    statusCodeDetected: "HTTP status code detected: {{code}}",
+    usageInfo: "Usage: node client.js <method> <params_json> [proxy]",
+    exampleUsage: "Example: node client.js fetch_html '{\"url\":\"https://example.com\",\"debug\":true}'",
+    invalidJson: "Invalid JSON parameters",
+    usingCommandLineProxy: "Using command line proxy: {{proxy}}",
+    invalidProxyFormat: "Invalid proxy format: {{proxy}}",
+    usingEnvProxy: "Using environment variable proxy: {{proxy}}",
+    usingShellProxy: "Using shell proxy: {{proxy}}",
+    noShellProxy: "No shell proxy found",
+    systemProxyDisabled: "System proxy detection disabled",
+    usingSystemProxy: "Using system proxy: {{proxy}}",
+    noSystemProxy: "No system proxy found",
+    requestFailed: "Request failed: {{error}}",
+    fatalError: "Fatal error: {{error}}",
+    startingServer: "Starting server at path: {{path}}",
+    fetchingUrl: "Fetching URL: {{url}}",
+    usingMode: "Using {{mode}} mode for URL: {{url}}",
+    fetchFailed: "Fetch failed: {{error}}",
+    fetchSuccess: "Fetch successful, content length: {{length}} bytes",
+    browserModeNeeded: "Browser mode needed for URL: {{url}}",
+    retryingWithBrowser: "Retrying with browser mode for URL: {{url}}",
+    browserModeFetchFailed: "Browser mode fetch failed: {{error}}",
+    browserModeFetchSuccess: "Browser mode fetch successful, content length: {{length}} bytes",
+    serverClosed: "Server closed"
+};

package/dist/src/lib/i18n/locales/en/errors.js

@@ -0,0 +1,18 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 通用错误消息 (Common error messages)
+export const errors = {
+    missingUrl: "Missing required parameter: url",
+    invalidUrl: "Invalid URL: {{url}}",
+    timeout: "Request timed out after {{timeout}}ms",
+    networkError: "Network error: {{error}}",
+    browserError: "Browser error: {{error}}",
+    unexpectedError: "Unexpected error: {{error}}",
+    forbidden: "Reason: Access forbidden (403 Forbidden)",
+    cloudflareProtection: "Reason: Cloudflare protection",
+    captchaRequired: "Reason: CAPTCHA required",
+    connectionProblem: "Reason: Connection problem"
+};