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

package/dist/src/lib/fetchers/node/NodeFetcher.js

@@ -0,0 +1,180 @@
+/**
+ * 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 { log, COMPONENTS } from '../../logger.js';
+import { HttpClient } from './HttpClient.js';
+import { ErrorHandler } from '../../utils/ErrorHandler.js';
+/**
+ * Node模式获取器类 (Node mode fetcher class)
+ * 使用node-fetch实现标准模式的网页获取 (Implements webpage fetching in standard mode using node-fetch)
+ */
+export class NodeFetcher {
+    /**
+     * 获取HTML内容 (Get HTML content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns HTML内容 (HTML content)
+     */
+    async html(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('node.startingHtmlFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await HttpClient.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 {
+                content: [{ type: 'text', text: html }],
+                isError: false
+            };
+        }
+        catch (error) {
+            // 使用ErrorHandler处理错误 (Use ErrorHandler to handle error)
+            const errorMessage = ErrorHandler.handleError(error, COMPONENTS.NODE_FETCH, debug, { url: requestPayload.url, method: 'html' });
+            // 返回错误信息 (Return error message)
+            return {
+                content: [{ type: 'text', text: `Error fetching HTML: ${errorMessage}` }],
+                isError: true
+            };
+        }
+    }
+    /**
+     * 获取JSON内容 (Get JSON content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns JSON内容 (JSON content)
+     */
+    async json(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('node.startingJsonFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await HttpClient.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);
+                // 返回JSON内容 (Return JSON content)
+                return {
+                    content: [{ type: 'text', text }],
+                    isError: false
+                };
+            }
+            catch (parseError) {
+                // 处理JSON解析错误 (Handle JSON parse error)
+                const textPreview = text.length > 100 ? `${text.substring(0, 100)}...` : text;
+                const error = new Error(`Invalid JSON: ${parseError instanceof Error ? parseError.message : String(parseError)}. Text preview: "${textPreview}", length: ${text.length}`);
+                error.text = text;
+                error.originalError = parseError;
+                log('fetcher.jsonParseError', debug, {
+                    error: String(parseError),
+                    textPreview,
+                    textLength: text.length
+                }, COMPONENTS.NODE_FETCH);
+                // 返回错误信息 (Return error message)
+                return {
+                    content: [{ type: 'text', text: `Error parsing JSON: ${error}` }],
+                    isError: true
+                };
+            }
+        }
+        catch (error) {
+            // 使用ErrorHandler处理错误 (Use ErrorHandler to handle error)
+            const errorMessage = ErrorHandler.handleError(error, COMPONENTS.NODE_FETCH, debug, { url: requestPayload.url, method: 'json' });
+            // 返回错误信息 (Return error message)
+            return {
+                content: [{ type: 'text', text: `Error fetching JSON: ${errorMessage}` }],
+                isError: true
+            };
+        }
+    }
+    /**
+     * 获取纯文本内容 (Get plain text content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns 纯文本内容 (Plain text content)
+     */
+    async txt(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('node.startingTxtFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await HttpClient.fetchWithRedirects(requestPayload);
+            // 读取响应文本 (Read response text)
+            log('node.readingText', debug, {}, COMPONENTS.NODE_FETCH);
+            const text = await response.text();
+            log('node.textContentLength', debug, { length: text.length }, COMPONENTS.NODE_FETCH);
+            // 返回纯文本内容 (Return plain text content)
+            return {
+                content: [{ type: 'text', text }],
+                isError: false
+            };
+        }
+        catch (error) {
+            // 使用ErrorHandler处理错误 (Use ErrorHandler to handle error)
+            const errorMessage = ErrorHandler.handleError(error, COMPONENTS.NODE_FETCH, debug, { url: requestPayload.url, method: 'txt' });
+            // 返回错误信息 (Return error message)
+            return {
+                content: [{ type: 'text', text: `Error fetching text: ${errorMessage}` }],
+                isError: true
+            };
+        }
+    }
+    /**
+     * 获取Markdown内容 (Get Markdown content)
+     * @param requestPayload 请求参数 (Request parameters)
+     * @returns Markdown内容 (Markdown content)
+     */
+    async markdown(requestPayload) {
+        const { debug = false } = requestPayload;
+        log('node.startingMarkdownFetch', debug, {}, COMPONENTS.NODE_FETCH);
+        try {
+            // 执行请求 (Execute request)
+            const response = await HttpClient.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);
+            // 创建Turndown服务 (Create Turndown service)
+            log('node.creatingTurndown', debug, {}, COMPONENTS.NODE_FETCH);
+            const turndownService = new TurndownService({
+                headingStyle: 'atx',
+                codeBlockStyle: 'fenced',
+                bulletListMarker: '-'
+            });
+            // 添加表格支持
+            turndownService.addRule('tables', {
+                filter: ['table'],
+                replacement: function (content, node) {
+                    const tableContent = content.trim();
+                    return '\n\n' + tableContent + '\n\n';
+                }
+            });
+            // 将HTML转换为Markdown (Convert HTML to Markdown)
+            log('node.convertingToMarkdown', debug, {}, COMPONENTS.NODE_FETCH);
+            const markdown = turndownService.turndown(html);
+            log('node.markdownContentLength', debug, { length: markdown.length }, COMPONENTS.NODE_FETCH);
+            // 返回Markdown内容 (Return Markdown content)
+            return {
+                content: [{ type: 'text', text: markdown }],
+                isError: false
+            };
+        }
+        catch (error) {
+            // 使用ErrorHandler处理错误 (Use ErrorHandler to handle error)
+            const errorMessage = ErrorHandler.handleError(error, COMPONENTS.NODE_FETCH, debug, { url: requestPayload.url, method: 'markdown' });
+            // 返回错误信息 (Return error message)
+            return {
+                content: [{ type: 'text', text: `Error fetching Markdown: ${errorMessage}` }],
+                isError: true
+            };
+        }
+    }
+}

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

@@ -15,22 +15,110 @@ const resources = {
         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)
+/**
+ * 将嵌套的翻译资源扁平化 (Flatten nested translation resources)
+ * @param resources 嵌套的翻译资源 (Nested translation resources)
+ * @returns 扁平化的翻译资源 (Flattened translation resources)
+ */
+function flattenResources(resources) {
+    const flattened = {};
+    // 遍历所有语言 (Iterate through all languages)
+    for (const lang in resources) {
+        flattened[lang] = { translation: {} };
+        const translation = resources[lang].translation;
+        // 遍历所有命名空间 (Iterate through all namespaces)
+        for (const namespace in translation) {
+            const nsTranslation = translation[namespace];
+            // 遍历命名空间中的所有键 (Iterate through all keys in the namespace)
+            for (const key in nsTranslation) {
+                // 直接使用原始键名，不添加命名空间前缀 (Use the original key directly, without adding namespace prefix)
+                flattened[lang].translation[key] = nsTranslation[key];
+            }
+        }
     }
-});
+    return flattened;
+}
+// 扁平化翻译资源 (Flatten translation resources)
+const flattenedResources = flattenResources(resources);
+/**
+ * 初始化 i18next 配置 (Initialize i18next configuration)
+ */
+const initializeI18n = () => {
+    // 获取当前语言环境 (Get current language environment)
+    const currentLanguage = process.env.MCP_LANG || 'en';
+    // 初始化 i18next (Initialize i18next)
+    i18next.init({
+        resources: flattenedResources,
+        // 优先使用专门的环境变量，其次默认使用英语
+        // (Priority: dedicated environment variable, then default to English)
+        lng: currentLanguage,
+        fallbackLng: 'en',
+        interpolation: {
+            escapeValue: false // 不转义插值 (Don't escape interpolation)
+        },
+        debug: false, // 禁用 i18n 调试 (Disable i18n debug)
+        returnEmptyString: false, // 不返回空字符串 (Don't return empty string)
+        returnNull: false, // 不返回 null (Don't return null)
+        returnObjects: true, // 返回对象 (Return objects)
+        saveMissing: false, // 不保存缺失的翻译键 (Don't save missing translation keys)
+        keySeparator: false, // 禁用键分隔符，使用完整的键路径 (Disable key separator, use full key path)
+        nsSeparator: false, // 禁用命名空间分隔符 (Disable namespace separator)
+        missingKeyHandler: (lng, ns, key, fallbackValue) => {
+            // 不输出任何日志，由上层调用决定是否输出 (Don't output any logs, let the upper-level call decide whether to output)
+        }
+    });
+    return i18next;
+};
+// 初始化 i18next 实例 (Initialize i18next instance)
+const i18n = initializeI18n();
 // 导出 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;
+export default i18n;
+/**
+ * 翻译函数 - 提供类型安全和错误处理 (Translation function - provides type safety and error handling)
+ * @param key 翻译键 (Translation key)
+ * @param options 翻译选项 (Translation options)
+ * @returns 翻译结果 (Translation result)
+ */
+export const t = (key, options) => {
+    try {
+        // 检查键是否存在 (Check if the key exists)
+        const exists = i18n.exists(key);
+        if (!exists) {
+            return key;
+        }
+        const result = i18n.t(key, options);
+        return result;
+    }
+    catch (error) {
+        return key; // 出错时返回原始键 (Return the original key when an error occurs)
+    }
+};
+/**
+ * 切换语言函数 (Language switching function)
+ * @param lng 目标语言 (Target language)
+ * @returns Promise，解析为切换后的语言 (Promise that resolves to the switched language)
+ */
+export const changeLanguage = (lng) => {
+    // 不输出任何日志，由上层调用决定是否输出 (Don't output any logs, let the upper-level call decide whether to output)
+    return i18n.changeLanguage(lng).then(() => lng);
+};
+/**
+ * 获取当前语言函数 (Get current language function)
+ * @returns 当前语言 (Current language)
+ */
+export const getCurrentLanguage = () => (i18n.language || 'en');
+/**
+ * 检查键是否存在 (Check if a key exists)
+ * @param key 要检查的键 (Key to check)
+ * @returns 键是否存在 (Whether the key exists)
+ */
+export const hasTranslation = (key) => {
+    return i18n.exists(key);
+};
+/**
+ * 获取所有支持的语言 (Get all supported languages)
+ * @returns 支持的语言数组 (Array of supported languages)
+ */
+export const getSupportedLanguages = () => {
+    return Object.keys(resources);
+};

package/dist/src/lib/i18n/keys/base.js

@@ -0,0 +1,41 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+/**
+ * 创建键名生成器 - 用于生成特定模块的键名 (Create key name generator - for generating key names for specific modules)
+ * @param module 模块名称 (Module name)
+ * @returns 键名生成函数 (Key name generator function)
+ */
+export const createKeyGenerator = (module) => (key) => `${module}.${key}`;
+/**
+ * 创建资源操作键 - 用于生成资源操作相关的键 (Create resource operation keys - for generating resource operation related keys)
+ * @param module 模块名称 (Module name)
+ * @param operation 操作名称 (Operation name)
+ * @returns 资源操作键对象 (Resource operation keys object)
+ */
+export const createResourceOperationKeys = (module, operation) => {
+    const keyGen = createKeyGenerator(`${module}.${operation}`);
+    return {
+        request: keyGen('request'),
+        success: keyGen('success'),
+        error: keyGen('error'),
+        notFound: keyGen('notFound'),
+        duplicate: keyGen('duplicate')
+    };
+};
+/**
+ * 创建资源键 - 用于生成资源相关的键 (Create resource keys - for generating resource related keys)
+ * @param module 模块名称 (Module name)
+ * @returns 资源键对象 (Resource keys object)
+ */
+export const createResourceKeys = (module) => {
+    return {
+        list: createResourceOperationKeys(module, 'list'),
+        get: createResourceOperationKeys(module, 'get'),
+        create: createResourceOperationKeys(module, 'create'),
+        update: createResourceOperationKeys(module, 'update'),
+        delete: createResourceOperationKeys(module, 'delete')
+    };
+};

package/dist/src/lib/i18n/keys/browser.js

@@ -0,0 +1,91 @@
+/**
+* Author: Martin <lmccc.dev@gmail.com>
+* Co-Author: AI Assistant (Claude)
+* Description: This code was collaboratively developed by Martin and AI Assistant.
+*/
+import { createKeyGenerator } from './base.js';
+/**
+ * 浏览器相关键 (Browser related keys)
+ */
+export const BROWSER_KEYS = (() => {
+    const keyGen = createKeyGenerator('browser');
+    return {
+        // 浏览器生命周期 (Browser lifecycle)
+        closing: keyGen('closing'),
+        closed: keyGen('closed'),
+        starting: keyGen('starting'),
+        startingFailed: keyGen('startingFailed'),
+        alreadyRunning: keyGen('alreadyRunning'),
+        // 页面操作 (Page operations)
+        creatingPage: keyGen('creatingPage'),
+        navigatingTo: keyGen('navigatingTo'),
+        waitingForSelector: keyGen('waitingForSelector'),
+        waitingForTimeout: keyGen('waitingForTimeout'),
+        scrollingToBottom: keyGen('scrollingToBottom'),
+        scrollError: keyGen('scrollError'),
+        gettingContent: keyGen('gettingContent'),
+        contentLength: keyGen('contentLength'),
+        // Cookie 相关 (Cookie related)
+        savingCookies: keyGen('savingCookies'),
+        cookiesSaved: keyGen('cookiesSaved'),
+        loadingCookies: keyGen('loadingCookies'),
+        cookiesLoaded: keyGen('cookiesLoaded'),
+        noCookiesFound: keyGen('noCookiesFound'),
+        // 错误相关 (Error related)
+        errorLoadingCookies: keyGen('errorLoadingCookies'),
+        errorSavingCookies: keyGen('errorSavingCookies'),
+        errorNavigating: keyGen('errorNavigating'),
+        errorGettingContent: keyGen('errorGettingContent'),
+        errorClosingBrowser: keyGen('errorClosingBrowser'),
+        errorCreatingPage: keyGen('errorCreatingPage'),
+        closingError: keyGen('closingError'),
+        // 额外的浏览器相关键 (Additional browser related keys)
+        waiting: keyGen('waiting'),
+        startupSuccess: keyGen('startupSuccess'),
+        navigating: keyGen('navigating'),
+        scrolling: keyGen('scrolling'),
+        scrollCompleted: keyGen('scrollCompleted'),
+        contentTruncated: keyGen('contentTruncated'),
+        pageClosed: keyGen('pageClosed'),
+        fetchError: keyGen('fetchError'),
+        highMemory: keyGen('highMemory'),
+        closingDueToMemory: keyGen('closingDueToMemory'),
+        forcingGC: keyGen('forcingGC'),
+        memoryCheckError: keyGen('memoryCheckError'),
+        usingCookies: keyGen('usingCookies'),
+        usingProxy: keyGen('usingProxy'),
+        // Cloudflare 相关 (Cloudflare related)
+        checkingCloudflare: keyGen('checkingCloudflare'),
+        cloudflareDetected: keyGen('cloudflareDetected'),
+        simulatingHuman: keyGen('simulatingHuman'),
+        simulatingHumanError: keyGen('simulatingHumanError'),
+        stillOnCloudflare: keyGen('stillOnCloudflare'),
+        bypassFailed: keyGen('bypassFailed'),
+        cloudflareError: keyGen('cloudflareError'),
+        continuingWithoutBypass: keyGen('continuingWithoutBypass'),
+        unableToBypassCloudflare: keyGen('unableToBypassCloudflare'),
+        // 获取和重试相关 (Fetch and retry related)
+        fetchingWithRetry: keyGen('fetchingWithRetry'),
+        memoryUsage: keyGen('memoryUsage'),
+        memoryTooHigh: keyGen('memoryTooHigh'),
+        contentTooLarge: keyGen('contentTooLarge'),
+        failedToParseJSON: keyGen('failedToParseJSON'),
+        startingBrowserFetchForMarkdown: keyGen('startingBrowserFetchForMarkdown'),
+        errorInBrowserFetchForMarkdown: keyGen('errorInBrowserFetchForMarkdown'),
+        fetchRequest: keyGen('fetchRequest'),
+        usingStoredCookies: keyGen('usingStoredCookies'),
+        closingInstance: keyGen('closingInstance'),
+        fetchErrorWithAttempt: keyGen('fetchErrorWithAttempt'),
+        retryingAfterDelay: keyGen('retryingAfterDelay'),
+        // 浏览器启动相关 (Browser startup related)
+        browserStartupSuccess: keyGen('browserStartupSuccess'),
+        browserStartupFailed: keyGen('browserStartupFailed'),
+        usingCustomChromePath: keyGen('usingCustomChromePath'),
+        browserDisconnected: keyGen('browserDisconnected'),
+        waitingForBrowserStart: keyGen('waitingForBrowserStart'),
+        reusingExistingBrowser: keyGen('reusingExistingBrowser'),
+        startingBrowser: keyGen('startingBrowser'),
+        browserStarted: keyGen('browserStarted'),
+        browserStartError: keyGen('browserStartError')
+    };
+})();

package/dist/src/lib/i18n/keys/client.js

@@ -0,0 +1,68 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { createKeyGenerator } from './base.js';
+/**
+ * 客户端相关键 (Client related keys)
+ */
+export const CLIENT_KEYS = (() => {
+    const keyGen = createKeyGenerator('client');
+    return {
+        // 连接相关 (Connection related)
+        connecting: keyGen('connecting'),
+        connected: keyGen('connected'),
+        connectionFailed: keyGen('connectionFailed'),
+        disconnected: keyGen('disconnected'),
+        reconnecting: keyGen('reconnecting'),
+        // 错误相关 (Error related)
+        clientError: keyGen('clientError'),
+        transportError: keyGen('transportError'),
+        requestError: keyGen('requestError'),
+        fetchError: keyGen('fetchError'),
+        // 请求相关 (Request related)
+        requestStarted: keyGen('requestStarted'),
+        requestCompleted: keyGen('requestCompleted'),
+        requestCancelled: keyGen('requestCancelled'),
+        // 内容相关 (Content related)
+        fetchingHtml: keyGen('fetchingHtml'),
+        fetchingJson: keyGen('fetchingJson'),
+        fetchingText: keyGen('fetchingText'),
+        fetchingMarkdown: keyGen('fetchingMarkdown'),
+        fetchSuccessful: keyGen('fetchSuccessful'),
+        contentLength: keyGen('contentLength'),
+        // 调试相关 (Debug related)
+        debugMode: keyGen('debugMode'),
+        debugInfo: keyGen('debugInfo'),
+        error: keyGen('error'),
+        callTool: keyGen('callTool'),
+        callToolSuccess: keyGen('callToolSuccess'),
+        callToolError: keyGen('callToolError'),
+        statusCodeDetected: keyGen('statusCodeDetected'),
+        usageInfo: keyGen('usageInfo'),
+        exampleUsage: keyGen('exampleUsage'),
+        invalidJson: keyGen('invalidJson'),
+        usingCommandLineProxy: keyGen('usingCommandLineProxy'),
+        invalidProxyFormat: keyGen('invalidProxyFormat'),
+        usingEnvProxy: keyGen('usingEnvProxy'),
+        usingShellProxy: keyGen('usingShellProxy'),
+        noShellProxy: keyGen('noShellProxy'),
+        systemProxyDisabled: keyGen('systemProxyDisabled'),
+        usingSystemProxy: keyGen('usingSystemProxy'),
+        noSystemProxy: keyGen('noSystemProxy'),
+        requestFailed: keyGen('requestFailed'),
+        fatalError: keyGen('fatalError'),
+        startingServer: keyGen('startingServer'),
+        fetchingUrl: keyGen('fetchingUrl'),
+        usingMode: keyGen('usingMode'),
+        fetchFailed: keyGen('fetchFailed'),
+        fetchSuccess: keyGen('fetchSuccess'),
+        browserModeNeeded: keyGen('browserModeNeeded'),
+        retryingWithBrowser: keyGen('retryingWithBrowser'),
+        browserModeFetchFailed: keyGen('browserModeFetchFailed'),
+        browserModeFetchSuccess: keyGen('browserModeFetchSuccess'),
+        serverClosed: keyGen('serverClosed'),
+        proxySet: keyGen('proxySet')
+    };
+})();

package/dist/src/lib/i18n/keys/errors.js

@@ -0,0 +1,49 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { createKeyGenerator } from './base.js';
+/**
+ * 错误相关键 (Error related keys)
+ */
+export const ERROR_KEYS = (() => {
+    const keyGen = createKeyGenerator('errors');
+    const errorKeyGen = createKeyGenerator('error'); // 为 error 前缀创建键生成器
+    return {
+        // 通用错误日志 (Generic error logging)
+        occurred: errorKeyGen('occurred'), // 添加 error.occurred 键
+        // 参数错误 (Parameter errors)
+        missingRequiredParam: keyGen('missingRequiredParam'),
+        invalidUrl: keyGen('invalidUrl'),
+        // 请求错误 (Request errors)
+        requestTimeout: keyGen('requestTimeout'),
+        maxRedirectsExceeded: keyGen('maxRedirectsExceeded'),
+        requestFailed: keyGen('requestFailed'),
+        networkError: keyGen('networkError'),
+        // 响应错误 (Response errors)
+        invalidResponse: keyGen('invalidResponse'),
+        invalidContentType: keyGen('invalidContentType'),
+        invalidJson: keyGen('invalidJson'),
+        // 浏览器错误 (Browser errors)
+        browserInitFailed: keyGen('browserInitFailed'),
+        pageLoadFailed: keyGen('pageLoadFailed'),
+        // 访问限制错误 (Access restriction errors)
+        forbidden: keyGen('forbidden'),
+        cloudflareProtection: keyGen('cloudflareProtection'),
+        captchaRequired: keyGen('captchaRequired'),
+        // 连接错误 (Connection errors)
+        timeout: keyGen('timeout'),
+        connectionProblem: keyGen('connectionProblem'),
+        // 通用错误 (Generic errors)
+        unknownError: keyGen('unknownError'),
+        // 错误类型键 (Error type keys)
+        network_error: keyGen('network_error'),
+        access_denied_error: keyGen('access_denied_error'),
+        timeout_error: keyGen('timeout_error'),
+        parse_error: keyGen('parse_error'),
+        validation_error: keyGen('validation_error'),
+        browser_error: keyGen('browser_error'),
+        unknown_error: keyGen('unknown_error')
+    };
+})();

package/dist/src/lib/i18n/keys/factory.js

@@ -0,0 +1,46 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { createKeyGenerator } from './base.js';
+/**
+ * 工厂相关键 (Factory related keys)
+ */
+export const FACTORY_KEYS = (() => {
+    const keyGen = createKeyGenerator('factory');
+    return {
+        // 日志消息 (Log messages)
+        creating_fetcher: keyGen('creating_fetcher'),
+        fetcher_created: keyGen('fetcher_created'),
+        fetcher_creation_failed: keyGen('fetcher_creation_failed'),
+        invalid_fetcher_type: keyGen('invalid_fetcher_type'),
+        browser_mode_enabled: keyGen('browser_mode_enabled'),
+        browser_mode_disabled: keyGen('browser_mode_disabled'),
+        using_default_mode: keyGen('using_default_mode'),
+        initializing: keyGen('initializing'),
+        initialization_complete: keyGen('initialization_complete'),
+        initialization_failed: keyGen('initialization_failed'),
+        auto_detecting_mode: keyGen('auto_detecting_mode'),
+        using_browser_mode: keyGen('using_browser_mode'),
+        using_node_mode: keyGen('using_node_mode'),
+        defaultingToNodeMode: keyGen('defaultingToNodeMode')
+    };
+})();
+// 为了向后兼容，保留旧的 FACTORY 对象 (For backward compatibility, keep the old FACTORY object)
+export const FACTORY = {
+    CREATING_FETCHER: 'factory.creating_fetcher',
+    FETCHER_CREATED: 'factory.fetcher_created',
+    FETCHER_CREATION_FAILED: 'factory.fetcher_creation_failed',
+    INVALID_FETCHER_TYPE: 'factory.invalid_fetcher_type',
+    BROWSER_MODE_ENABLED: 'factory.browser_mode_enabled',
+    BROWSER_MODE_DISABLED: 'factory.browser_mode_disabled',
+    USING_DEFAULT_MODE: 'factory.using_default_mode',
+    INITIALIZING: 'factory.initializing',
+    INITIALIZATION_COMPLETE: 'factory.initialization_complete',
+    INITIALIZATION_FAILED: 'factory.initialization_failed',
+    AUTO_DETECTING_MODE: 'factory.auto_detecting_mode',
+    USING_BROWSER_MODE: 'factory.using_browser_mode',
+    USING_NODE_MODE: 'factory.using_node_mode',
+    DEFAULTING_TO_NODE_MODE: 'factory.defaultingToNodeMode'
+};