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

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

@@ -3,74 +3,84 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { BROWSER_KEYS } from '../../keys.js';
+import { BROWSER_KEYS } from '../../keys/browser.js';
 // 浏览器相关消息 (Browser related messages)
-export const browser = {
+export default {
+    // 浏览器生命周期 (Browser lifecycle)
     [BROWSER_KEYS.closing]: "Closing browser...",
     [BROWSER_KEYS.closed]: "Browser closed",
     [BROWSER_KEYS.starting]: "Starting new browser instance",
     [BROWSER_KEYS.startingFailed]: "Browser startup failed: {{error}}",
     [BROWSER_KEYS.alreadyRunning]: "Browser is starting, waiting...",
-    [BROWSER_KEYS.creatingPage]: "Browser started successfully",
-    [BROWSER_KEYS.navigatingTo]: "Navigating to URL...",
+    // 页面操作 (Page operations)
+    [BROWSER_KEYS.creatingPage]: "Creating new page",
+    [BROWSER_KEYS.navigatingTo]: "Navigating to URL: {{url}}",
     [BROWSER_KEYS.waitingForSelector]: "Waiting for selector: {{selector}}",
-    [BROWSER_KEYS.waitingForTimeout]: "Waiting for timeout: {{timeout}}",
+    [BROWSER_KEYS.waitingForTimeout]: "Waiting for timeout: {{timeout}}ms",
     [BROWSER_KEYS.scrollingToBottom]: "Auto-scrolling page...",
+    [BROWSER_KEYS.scrollError]: "Error while scrolling: {{error}}",
     [BROWSER_KEYS.gettingContent]: "Getting page content...",
-    [BROWSER_KEYS.savingCookies]: "Saving cookies...",
-    [BROWSER_KEYS.contentLength]: "Content length: {{length}}",
-    [BROWSER_KEYS.cookiesSaved]: "Cookies saved",
-    [BROWSER_KEYS.cookiesLoaded]: "Cookies loaded",
-    [BROWSER_KEYS.noCookiesFound]: "No cookies found",
+    [BROWSER_KEYS.contentLength]: "Content length: {{length}} bytes",
+    // Cookie 相关 (Cookie related)
+    [BROWSER_KEYS.savingCookies]: "Saving cookies for domain: {{domain}}",
+    [BROWSER_KEYS.cookiesSaved]: "Cookies saved successfully",
+    [BROWSER_KEYS.loadingCookies]: "Loading cookies for domain: {{domain}}",
+    [BROWSER_KEYS.cookiesLoaded]: "Cookies loaded successfully",
+    [BROWSER_KEYS.noCookiesFound]: "No cookies found for domain: {{domain}}",
+    // 错误相关 (Error related)
     [BROWSER_KEYS.errorLoadingCookies]: "Error loading cookies: {{error}}",
     [BROWSER_KEYS.errorSavingCookies]: "Error saving cookies: {{error}}",
-    [BROWSER_KEYS.errorNavigating]: "Error navigating: {{error}}",
-    [BROWSER_KEYS.errorGettingContent]: "Error in browser fetch: {{error}}",
+    [BROWSER_KEYS.errorNavigating]: "Error navigating to URL: {{error}}",
+    [BROWSER_KEYS.errorGettingContent]: "Error getting content: {{error}}",
     [BROWSER_KEYS.errorClosingBrowser]: "Error closing browser: {{error}}",
     [BROWSER_KEYS.errorCreatingPage]: "Error creating page: {{error}}",
-    // 额外的键（不在 BROWSER_KEYS 中定义的）
-    "waiting": "Browser is starting, waiting...",
-    "startupSuccess": "Browser started successfully",
-    "navigating": "Navigating to URL...",
-    "scrolling": "Auto-scrolling page...",
-    "scrollCompleted": "Auto-scroll completed",
-    "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...",
-    "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...",
-    "browserStartupSuccess": "Browser started successfully",
-    "browserStartupFailed": "Browser startup failed: {{error}}",
-    "usingCustomChromePath": "Using custom Chrome path: {{path}}",
-    "browserDisconnected": "Browser disconnected",
-    "waitingForBrowserStart": "Waiting for browser to start",
-    "reusingExistingBrowser": "Reusing existing browser instance",
-    "startingBrowser": "Starting browser",
-    "browserStarted": "Browser started successfully",
-    "browserStartError": "Browser startup error: {{error}}"
+    [BROWSER_KEYS.closingError]: "Error during browser closing: {{error}}",
+    // 额外的浏览器相关键 (Additional browser related keys)
+    [BROWSER_KEYS.waiting]: "Browser is starting, waiting...",
+    [BROWSER_KEYS.startupSuccess]: "Browser started successfully",
+    [BROWSER_KEYS.navigating]: "Navigating to URL: {{url}}",
+    [BROWSER_KEYS.scrolling]: "Auto-scrolling page...",
+    [BROWSER_KEYS.scrollCompleted]: "Auto-scroll completed",
+    [BROWSER_KEYS.contentTruncated]: "Content too large, truncating...",
+    [BROWSER_KEYS.pageClosed]: "Page closed",
+    [BROWSER_KEYS.fetchError]: "Error in browser fetch: {{error}}",
+    [BROWSER_KEYS.highMemory]: "High memory usage detected: {{usage}}MB",
+    [BROWSER_KEYS.closingDueToMemory]: "Closing browser due to high memory usage",
+    [BROWSER_KEYS.forcingGC]: "Forcing garbage collection",
+    [BROWSER_KEYS.memoryCheckError]: "Error checking memory usage: {{error}}",
+    [BROWSER_KEYS.usingCookies]: "Using cookies for domain: {{domain}}",
+    [BROWSER_KEYS.usingProxy]: "Using proxy: {{proxy}}",
+    // Cloudflare 相关 (Cloudflare related)
+    [BROWSER_KEYS.checkingCloudflare]: "Checking for Cloudflare protection",
+    [BROWSER_KEYS.cloudflareDetected]: "Cloudflare protection detected",
+    [BROWSER_KEYS.simulatingHuman]: "Simulating human interaction to bypass Cloudflare",
+    [BROWSER_KEYS.simulatingHumanError]: "Error simulating human interaction: {{error}}",
+    [BROWSER_KEYS.stillOnCloudflare]: "Still on Cloudflare page after bypass attempt",
+    [BROWSER_KEYS.bypassFailed]: "Cloudflare bypass failed",
+    [BROWSER_KEYS.cloudflareError]: "Cloudflare error: {{error}}",
+    [BROWSER_KEYS.continuingWithoutBypass]: "Continuing without Cloudflare bypass",
+    [BROWSER_KEYS.unableToBypassCloudflare]: "Unable to bypass Cloudflare protection",
+    // 获取和重试相关 (Fetch and retry related)
+    [BROWSER_KEYS.fetchingWithRetry]: "Fetching with retry: attempt {{attempt}} of {{maxAttempts}}",
+    [BROWSER_KEYS.memoryUsage]: "Current memory usage: {{usage}}MB",
+    [BROWSER_KEYS.memoryTooHigh]: "Memory usage too high: {{usage}}MB",
+    [BROWSER_KEYS.contentTooLarge]: "Content too large: {{size}} bytes",
+    [BROWSER_KEYS.failedToParseJSON]: "Failed to parse JSON: {{error}}",
+    [BROWSER_KEYS.startingBrowserFetchForMarkdown]: "Starting browser fetch for Markdown",
+    [BROWSER_KEYS.errorInBrowserFetchForMarkdown]: "Error in browser fetch for Markdown: {{error}}",
+    [BROWSER_KEYS.fetchRequest]: "Fetch request: {{url}}",
+    [BROWSER_KEYS.usingStoredCookies]: "Using stored cookies for domain: {{domain}}",
+    [BROWSER_KEYS.closingInstance]: "Closing browser instance",
+    [BROWSER_KEYS.fetchErrorWithAttempt]: "Fetch error (attempt {{attempt}}): {{error}}",
+    [BROWSER_KEYS.retryingAfterDelay]: "Retrying after {{delay}}ms delay",
+    // 浏览器启动相关 (Browser startup related)
+    [BROWSER_KEYS.browserStartupSuccess]: "Browser startup successful",
+    [BROWSER_KEYS.browserStartupFailed]: "Browser startup failed: {{error}}",
+    [BROWSER_KEYS.usingCustomChromePath]: "Using custom Chrome path: {{path}}",
+    [BROWSER_KEYS.browserDisconnected]: "Browser disconnected",
+    [BROWSER_KEYS.waitingForBrowserStart]: "Waiting for browser to start...",
+    [BROWSER_KEYS.reusingExistingBrowser]: "Reusing existing browser instance",
+    [BROWSER_KEYS.startingBrowser]: "Starting browser...",
+    [BROWSER_KEYS.browserStarted]: "Browser started",
+    [BROWSER_KEYS.browserStartError]: "Browser start error: {{error}}"
 };

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

@@ -3,38 +3,62 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
+import { CLIENT_KEYS } from '../../keys/client.js';
 // 客户端相关消息 (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"
+export default {
+    // 连接相关 (Connection related)
+    [CLIENT_KEYS.connecting]: 'Connecting to MCP server...',
+    [CLIENT_KEYS.connected]: 'Connected to MCP server',
+    [CLIENT_KEYS.connectionFailed]: 'Failed to connect to MCP server: {{error}}',
+    [CLIENT_KEYS.disconnected]: 'Disconnected from MCP server',
+    [CLIENT_KEYS.reconnecting]: 'Reconnecting to MCP server...',
+    // 错误相关 (Error related)
+    [CLIENT_KEYS.clientError]: 'Client error: {{error}}',
+    [CLIENT_KEYS.transportError]: 'Transport error: {{error}}',
+    [CLIENT_KEYS.requestError]: 'Request error: {{error}}',
+    [CLIENT_KEYS.fetchError]: 'Fetch error: {{error}}',
+    // 请求相关 (Request related)
+    [CLIENT_KEYS.requestStarted]: 'Request started: {{id}}',
+    [CLIENT_KEYS.requestCompleted]: 'Request completed: {{id}}',
+    [CLIENT_KEYS.requestCancelled]: 'Request cancelled: {{id}}',
+    // 内容相关 (Content related)
+    [CLIENT_KEYS.fetchingHtml]: 'Fetching HTML from {{url}}',
+    [CLIENT_KEYS.fetchingJson]: 'Fetching JSON from {{url}}',
+    [CLIENT_KEYS.fetchingText]: 'Fetching text from {{url}}',
+    [CLIENT_KEYS.fetchingMarkdown]: 'Fetching Markdown from {{url}}',
+    [CLIENT_KEYS.fetchSuccessful]: 'Fetch successful',
+    [CLIENT_KEYS.contentLength]: 'Content length: {{length}} bytes',
+    // 调试相关 (Debug related)
+    [CLIENT_KEYS.debugMode]: 'Debug mode: {{enabled}}',
+    [CLIENT_KEYS.debugInfo]: 'Debug info: {{info}}',
+    // 原有键 (Original keys)
+    [CLIENT_KEYS.error]: 'Error: {{error}}',
+    [CLIENT_KEYS.callTool]: 'Calling tool: {{name}}',
+    [CLIENT_KEYS.callToolSuccess]: 'Tool call successful: {{name}}',
+    [CLIENT_KEYS.callToolError]: 'Tool call error: {{name}} - {{error}}',
+    [CLIENT_KEYS.statusCodeDetected]: 'Status code detected: {{code}}',
+    [CLIENT_KEYS.usageInfo]: 'Usage info: {{info}}',
+    [CLIENT_KEYS.exampleUsage]: 'Example usage: {{example}}',
+    [CLIENT_KEYS.invalidJson]: 'Invalid JSON: {{error}}',
+    [CLIENT_KEYS.usingCommandLineProxy]: 'Using command line proxy: {{proxy}}',
+    [CLIENT_KEYS.invalidProxyFormat]: 'Invalid proxy format: {{proxy}}',
+    [CLIENT_KEYS.usingEnvProxy]: 'Using environment proxy: {{proxy}}',
+    [CLIENT_KEYS.usingShellProxy]: 'Using shell proxy: {{proxy}}',
+    [CLIENT_KEYS.noShellProxy]: 'No shell proxy found',
+    [CLIENT_KEYS.systemProxyDisabled]: 'System proxy disabled',
+    [CLIENT_KEYS.usingSystemProxy]: 'Using system proxy: {{proxy}}',
+    [CLIENT_KEYS.noSystemProxy]: 'No system proxy found',
+    [CLIENT_KEYS.requestFailed]: 'Request failed: {{error}}',
+    [CLIENT_KEYS.fatalError]: 'Fatal error: {{error}}',
+    [CLIENT_KEYS.startingServer]: 'Starting server...',
+    [CLIENT_KEYS.fetchingUrl]: 'Fetching URL: {{url}}',
+    [CLIENT_KEYS.usingMode]: 'Using {{mode}} mode',
+    [CLIENT_KEYS.fetchFailed]: 'Fetch failed: {{error}}',
+    [CLIENT_KEYS.fetchSuccess]: 'Fetch successful',
+    [CLIENT_KEYS.browserModeNeeded]: 'Browser mode needed for: {{url}}',
+    [CLIENT_KEYS.retryingWithBrowser]: 'Retrying with browser mode',
+    [CLIENT_KEYS.browserModeFetchFailed]: 'Browser mode fetch failed: {{error}}',
+    [CLIENT_KEYS.browserModeFetchSuccess]: 'Browser mode fetch successful',
+    [CLIENT_KEYS.serverClosed]: 'Server closed',
+    [CLIENT_KEYS.proxySet]: 'Proxy set: {{proxy}}'
 };

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

@@ -3,16 +3,40 @@
  * 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"
+import { ERROR_KEYS } from '../../keys/errors.js';
+export default {
+    // 通用错误日志 (Generic error logging)
+    [ERROR_KEYS.occurred]: 'Error occurred: type={{type}}, message={{message}}',
+    // 参数错误 (Parameter errors)
+    [ERROR_KEYS.missingRequiredParam]: 'Missing required parameter: {{param}}',
+    [ERROR_KEYS.invalidUrl]: 'Invalid URL: {{url}}',
+    // 请求错误 (Request errors)
+    [ERROR_KEYS.requestTimeout]: 'Request timed out after {{timeout}}ms',
+    [ERROR_KEYS.maxRedirectsExceeded]: 'Maximum redirects exceeded ({{max}})',
+    [ERROR_KEYS.requestFailed]: 'Request failed with status {{status}}: {{message}}',
+    [ERROR_KEYS.networkError]: 'Network error: {{message}}',
+    // 响应错误 (Response errors)
+    [ERROR_KEYS.invalidResponse]: 'Invalid response: {{message}}',
+    [ERROR_KEYS.invalidContentType]: 'Invalid content type: {{contentType}}',
+    [ERROR_KEYS.invalidJson]: 'Invalid JSON response',
+    // 浏览器错误 (Browser errors)
+    [ERROR_KEYS.browserInitFailed]: 'Browser initialization failed: {{message}}',
+    [ERROR_KEYS.pageLoadFailed]: 'Page load failed: {{message}}',
+    // 访问限制错误 (Access restriction errors)
+    [ERROR_KEYS.forbidden]: 'Access forbidden (403)',
+    [ERROR_KEYS.cloudflareProtection]: 'Cloudflare protection detected',
+    [ERROR_KEYS.captchaRequired]: 'CAPTCHA verification required',
+    // 连接错误 (Connection errors)
+    [ERROR_KEYS.timeout]: 'Connection timed out after {{timeout}}',
+    [ERROR_KEYS.connectionProblem]: 'Connection problem detected',
+    // 通用错误 (Generic errors)
+    [ERROR_KEYS.unknownError]: 'Unknown error: {{message}}',
+    // 错误类型键 (Error type keys)
+    [ERROR_KEYS.network_error]: 'Network error: {{error}}',
+    [ERROR_KEYS.access_denied_error]: 'Access denied: {{error}}',
+    [ERROR_KEYS.timeout_error]: 'Timeout error: {{error}}',
+    [ERROR_KEYS.parse_error]: 'Parse error: {{error}}',
+    [ERROR_KEYS.validation_error]: 'Validation error: {{error}}',
+    [ERROR_KEYS.browser_error]: 'Browser error: {{error}}',
+    [ERROR_KEYS.unknown_error]: 'Unknown error: {{error}}'
 };

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

@@ -0,0 +1,38 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { FACTORY_KEYS } from '../../keys/factory.js';
+export default {
+    // 日志消息 (Log messages)
+    [FACTORY_KEYS.creating_fetcher]: 'Creating fetcher of type {{type}}',
+    [FACTORY_KEYS.fetcher_created]: '{{type}} fetcher created successfully',
+    [FACTORY_KEYS.fetcher_creation_failed]: 'Failed to create {{type}} fetcher: {{error}}',
+    [FACTORY_KEYS.invalid_fetcher_type]: 'Invalid fetcher type: {{type}}',
+    [FACTORY_KEYS.browser_mode_enabled]: 'Browser mode enabled',
+    [FACTORY_KEYS.browser_mode_disabled]: 'Browser mode disabled',
+    [FACTORY_KEYS.using_default_mode]: 'Using default mode: {{mode}}',
+    [FACTORY_KEYS.initializing]: 'Initializing fetcher factory',
+    [FACTORY_KEYS.initialization_complete]: 'Fetcher factory initialization complete',
+    [FACTORY_KEYS.initialization_failed]: 'Fetcher factory initialization failed: {{error}}',
+    [FACTORY_KEYS.auto_detecting_mode]: 'Auto detecting mode',
+    [FACTORY_KEYS.using_browser_mode]: 'Using browser mode',
+    [FACTORY_KEYS.using_node_mode]: 'Using Node mode',
+    [FACTORY_KEYS.defaultingToNodeMode]: 'Defaulting to Node mode',
+    // 为了向后兼容，保留旧的键 (For backward compatibility, keep the old keys)
+    creating_fetcher: 'Creating fetcher of type {{type}}',
+    fetcher_created: '{{type}} fetcher created successfully',
+    fetcher_creation_failed: 'Failed to create {{type}} fetcher: {{error}}',
+    invalid_fetcher_type: 'Invalid fetcher type: {{type}}',
+    browser_mode_enabled: 'Browser mode enabled',
+    browser_mode_disabled: 'Browser mode disabled',
+    using_default_mode: 'Using default mode: {{mode}}',
+    initializing: 'Initializing fetcher factory',
+    initialization_complete: 'Fetcher factory initialization complete',
+    initialization_failed: 'Fetcher factory initialization failed: {{error}}',
+    auto_detecting_mode: 'Auto detecting mode',
+    using_browser_mode: 'Using browser mode',
+    using_node_mode: 'Using Node mode',
+    defaulting_to_node_mode: 'Defaulting to Node mode'
+};

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

@@ -3,9 +3,9 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { FETCHER_KEYS } from '../../keys.js';
+import { FETCHER_KEYS } from '../../keys/fetcher.js';
 // 获取器相关消息 (Fetcher related messages)
-export const fetcher = {
+export default {
     [FETCHER_KEYS.addingDelay]: "Adding random delay",
     [FETCHER_KEYS.delayCompleted]: "Delay completed after {{delay}}ms",
     [FETCHER_KEYS.usingProxy]: "Using proxy: {{proxy}}",
@@ -14,6 +14,8 @@ export const fetcher = {
     [FETCHER_KEYS.notUsingProxy]: "Not using any proxy",
     [FETCHER_KEYS.finalProxyUsed]: "Final proxy used: {{proxy}}",
     [FETCHER_KEYS.noProxy]: "No proxy will be used",
+    [FETCHER_KEYS.foundNoProxy]: "Found no proxy: {{noProxy}}",
+    [FETCHER_KEYS.systemProxyDisabled]: "System proxy disabled",
     [FETCHER_KEYS.fetchingUrl]: "Fetching URL: {{url}} (Redirect: {{redirect}})",
     [FETCHER_KEYS.usingUserAgent]: "Using User-Agent: {{userAgent}}",
     [FETCHER_KEYS.usingHttpsProxy]: "Using HTTPS proxy",
@@ -35,6 +37,10 @@ export const fetcher = {
     [FETCHER_KEYS.fetchFailed]: "Failed to fetch: {{error}}",
     [FETCHER_KEYS.tooManyRedirects]: "Too many redirects ({{redirects}})",
     [FETCHER_KEYS.startingHtmlFetch]: "Starting HTML fetch",
+    [FETCHER_KEYS.fetchingHtml]: "Fetching HTML",
+    [FETCHER_KEYS.fetchingJson]: "Fetching JSON",
+    [FETCHER_KEYS.fetchingTxt]: "Fetching text",
+    [FETCHER_KEYS.fetchingMarkdown]: "Fetching Markdown",
     [FETCHER_KEYS.readingText]: "Reading text content",
     [FETCHER_KEYS.htmlContentLength]: "HTML content length: {{length}} bytes",
     [FETCHER_KEYS.startingJsonFetch]: "Starting JSON fetch",

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

@@ -3,20 +3,22 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { server } from './server.js';
-import { client } from './client.js';
-import { fetcher } from './fetcher.js';
-import { browser } from './browser.js';
-import { node } from './node.js';
-import { tools } from './tools.js';
-import { errors } from './errors.js';
-import { resources } from './resources.js';
+import server from './server.js';
+import client from './client.js';
+import fetcher from './fetcher.js';
+import factory from './factory.js';
+import browser from './browser.js';
+import node from './node.js';
+import tools from './tools.js';
+import errors from './errors.js';
+import resources from './resources.js';
 import prompts from './prompts.js';
 // 英文翻译资源 (English translation resources)
 export const enTranslation = {
     server,
     client,
     fetcher,
+    factory,
     browser,
     node,
     tools,

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

@@ -3,40 +3,62 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
+import { NODE_KEYS } from '../../keys/node.js';
 // Node获取器相关消息 (Node fetcher related messages)
-export const node = {
-    addingDelay: "Adding random delay...",
-    noProxy: "No proxy will be used",
-    usingProxy: "Using proxy: {{proxy}}",
-    usingHttpsProxy: "Using HTTPS proxy agent",
-    usingHttpProxy: "Using HTTP proxy agent",
-    usingUserAgent: "Using User-Agent: {{userAgent}}",
-    requestDetails: "Request details: URL={{url}}, Method={{method}}, Proxy={{proxy}}",
-    requestOptions: "Request options: {{options}}",
-    startingFetch: "Starting fetch request...",
-    fetchingUrl: "Fetching URL: {{url}}",
-    responseStatus: "Response status: {{status}} {{statusText}}",
-    redirectingTo: "Redirecting to: {{location}}",
-    constructedFullRedirectUrl: "Constructed full redirect URL: {{redirectUrl}}",
-    requestSuccess: "Request successful",
-    errorResponse: "Error response: {{status}} {{statusText}}",
-    errorResponseBody: "Error response body (first 200 chars): {{body}}",
-    errorReadingBody: "Failed to read error response body: {{error}}",
-    fetchError: "Fetch error: {{error}}",
-    requestAborted: "Request aborted after {{duration}}ms",
-    networkError: "Network error ({{code}}), might retry with browser mode",
-    tooManyRedirects: "Too many redirects ({{redirects}})",
-    startingHtmlFetch: "Starting HTML fetch",
-    readingText: "Got response, reading text",
-    htmlContentLength: "HTML content length: {{length}} bytes",
-    htmlFetchError: "HTML fetch error: {{error}}",
-    startingJsonFetch: "Starting JSON fetch",
-    parsingJson: "Got response, parsing JSON",
-    jsonParsed: "JSON parsed successfully",
-    jsonParseError: "JSON parse error: {{error}}",
-    jsonFetchError: "JSON fetch error: {{error}}",
-    startingTxtFetch: "Starting TXT fetch",
-    startingMarkdownFetch: "Starting Markdown fetch",
-    creatingTurndown: "Creating TurndownService instance",
-    convertingToMarkdown: "Converting HTML to Markdown"
+export default {
+    // 延迟和代理相关 (Delay and proxy related)
+    [NODE_KEYS.addingDelay]: 'Adding delay: {{delay}}ms',
+    [NODE_KEYS.noProxy]: 'No proxy',
+    [NODE_KEYS.usingProxy]: 'Using proxy: {{proxy}}',
+    [NODE_KEYS.usingHttpsProxy]: 'Using HTTPS proxy',
+    [NODE_KEYS.usingHttpProxy]: 'Using HTTP proxy',
+    // 系统代理相关 (System proxy related)
+    [NODE_KEYS.checkingProxyEnv]: 'Checking proxy environment variables',
+    [NODE_KEYS.envVarValue]: 'Environment variable {{envVar}} = {{value}}',
+    [NODE_KEYS.foundSystemProxy]: 'Found system proxy: {{proxy}}',
+    [NODE_KEYS.checkingSystemEnvVars]: 'Checking system environment variables, platform: {{platform}}',
+    [NODE_KEYS.windowsEnvVars]: 'Windows environment variables: {{output}}',
+    [NODE_KEYS.foundWindowsEnvProxy]: 'Found Windows environment proxy: {{proxy}}',
+    [NODE_KEYS.errorGettingWindowsEnvVars]: 'Error getting Windows environment variables: {{error}}',
+    [NODE_KEYS.unixEnvVars]: 'Unix environment variables: {{output}}',
+    [NODE_KEYS.foundUnixEnvProxy]: 'Found Unix environment proxy: {{proxy}}',
+    [NODE_KEYS.errorGettingUnixEnvVars]: 'Error getting Unix environment variables: {{error}}',
+    [NODE_KEYS.noSystemProxyFound]: 'No system proxy found',
+    [NODE_KEYS.errorGettingSystemEnvVars]: 'Error getting system environment variables: {{error}}',
+    [NODE_KEYS.foundNoProxy]: 'Found NO_PROXY setting: {{noProxy}}',
+    // 请求相关 (Request related)
+    [NODE_KEYS.usingUserAgent]: "Using User-Agent: {{userAgent}}",
+    [NODE_KEYS.requestDetails]: "Request details: method={{method}}, URL={{url}}",
+    [NODE_KEYS.requestOptions]: "Request options: {{options}}",
+    [NODE_KEYS.startingFetch]: "Starting fetch: {{url}}",
+    [NODE_KEYS.fetchingUrl]: "Fetching URL: {{url}}",
+    // 响应相关 (Response related)
+    [NODE_KEYS.responseStatus]: "Response status: {{status}}",
+    [NODE_KEYS.redirectingTo]: "Redirecting to: {{url}}",
+    [NODE_KEYS.constructedFullRedirectUrl]: "Constructed full redirect URL: {{url}}",
+    [NODE_KEYS.requestSuccess]: "Request successful",
+    // 错误相关 (Error related)
+    [NODE_KEYS.errorResponse]: "Error response: {{status}}",
+    [NODE_KEYS.errorResponseBody]: "Error response body: {{body}}",
+    [NODE_KEYS.errorReadingBody]: "Error reading response body: {{error}}",
+    [NODE_KEYS.fetchError]: "Fetch error: {{error}}",
+    [NODE_KEYS.requestAborted]: "Request aborted",
+    [NODE_KEYS.networkError]: "Network error: {{code}}",
+    [NODE_KEYS.tooManyRedirects]: "Too many redirects",
+    // 内容类型相关 (Content type related)
+    [NODE_KEYS.startingHtmlFetch]: 'Starting HTML fetch',
+    [NODE_KEYS.readingText]: 'Reading text content',
+    [NODE_KEYS.htmlContentLength]: 'HTML content length: {{length}} bytes',
+    [NODE_KEYS.htmlFetchError]: 'Error fetching HTML: {{error}}',
+    [NODE_KEYS.startingJsonFetch]: 'Starting JSON fetch',
+    [NODE_KEYS.parsingJson]: 'Parsing JSON',
+    [NODE_KEYS.jsonParsed]: 'JSON parsed successfully',
+    [NODE_KEYS.jsonParseError]: 'JSON parse error: {{error}}',
+    [NODE_KEYS.jsonFetchError]: 'Error fetching JSON: {{error}}',
+    [NODE_KEYS.startingTxtFetch]: 'Starting plain text fetch',
+    [NODE_KEYS.textContentLength]: 'Text content length: {{length}} bytes',
+    [NODE_KEYS.startingMarkdownFetch]: 'Starting Markdown fetch',
+    [NODE_KEYS.creatingTurndown]: 'Creating Turndown service',
+    [NODE_KEYS.convertingToMarkdown]: 'Converting HTML to Markdown',
+    [NODE_KEYS.markdownContentLength]: 'Markdown content length: {{length}} bytes'
 };