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

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

@@ -4,6 +4,65 @@
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
 import { t } from './index.js';
+/**
+ * 日志级别枚举 (Log level enum)
+ */
+export var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["DEBUG"] = 0] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 1] = "INFO";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 3] = "ERROR";
+    LogLevel[LogLevel["NONE"] = 4] = "NONE";
+})(LogLevel || (LogLevel = {}));
+/**
+ * 获取当前日志级别 (Get current log level)
+ * @returns 日志级别 (Log level)
+ */
+function getCurrentLogLevel() {
+    const debugEnv = process.env.DEBUG;
+    if (debugEnv === 'none')
+        return LogLevel.NONE;
+    if (debugEnv === 'error')
+        return LogLevel.ERROR;
+    if (debugEnv === 'warn')
+        return LogLevel.WARN;
+    if (debugEnv === 'info')
+        return LogLevel.INFO;
+    if (debugEnv === 'debug' || debugEnv === 'true')
+        return LogLevel.DEBUG;
+    // 默认为 INFO 级别 (Default to INFO level)
+    return LogLevel.INFO;
+}
+/**
+ * 尝试翻译键名 (Try to translate a key)
+ * @param key 翻译键 (Translation key)
+ * @param params 翻译参数 (Translation parameters)
+ * @returns 翻译后的文本 (Translated text)
+ */
+function translateKey(key, params) {
+    try {
+        // 尝试翻译键名 (Try to translate the key)
+        const translated = t(key, params);
+        // 确保结果是字符串 (Ensure the result is a string)
+        let translatedStr = typeof translated === 'string' ? translated : JSON.stringify(translated);
+        // 检查翻译后的字符串是否仍然包含占位符，如果包含，手动进行插值替换
+        // (Check if the translated string still contains placeholders, if so, manually perform interpolation)
+        if (params && typeof translatedStr === 'string') {
+            for (const key in params) {
+                const placeholder = `{{${key}}}`;
+                if (translatedStr.includes(placeholder)) {
+                    translatedStr = translatedStr.replace(new RegExp(placeholder, 'g'), String(params[key]));
+                }
+            }
+        }
+        return translatedStr;
+    }
+    catch (error) {
+        // 如果翻译失败，返回原始键名 (If translation fails, return the original key)
+        return key;
+    }
+}
 /**
  * 创建一个带前缀的日志记录器 (Create a logger with prefix)
  * @param prefix 日志前缀 (Log prefix)
@@ -12,25 +71,34 @@ import { t } from './index.js';
 export function createLogger(prefix) {
     return {
         /**
-         * 输出信息日志 (Output info log)
+         * 输出调试日志 (Output debug log)
          * @param key 翻译键 (Translation key)
          * @param params 翻译参数 (Translation parameters)
-         * @param forceDebug 是否强制输出信息日志 (Whether to force output info logs)
+         * @param forceLog 是否强制输出日志 (Whether to force output logs)
          */
-        info: (key, params, forceDebug) => {
-            // 只有在环境变量DEBUG为true或forceDebug为true时才输出信息日志
-            if (process.env.DEBUG === 'true' || forceDebug === true) {
-                console.error(`[${prefix}] ${t(key, params)}`);
+        debug: (key, params, forceLog) => {
+            // 只有在明确设置 forceLog 为 true 时才输出日志 (Only output logs when forceLog is explicitly set to true)
+            if (forceLog) {
+                const translatedMessage = translateKey(key, params);
+                // 在 MCP 环境中，所有日志都应该使用 error 级别输出
+                // (In MCP environment, all logs should be output at error level)
+                console.error(`[${prefix}] ${translatedMessage}`);
             }
         },
         /**
-         * 输出错误日志 (Output error log)
+         * 输出信息日志 (Output info log)
          * @param key 翻译键 (Translation key)
          * @param params 翻译参数 (Translation parameters)
+         * @param forceLog 是否强制输出日志 (Whether to force output logs)
          */
-        error: (key, params) => {
-            // 错误日志总是输出，不受debug控制
-            console.error(`[${prefix}] ${t(key, params)}`);
+        info: (key, params, forceLog) => {
+            // 只有在明确设置 forceLog 为 true 时才输出日志 (Only output logs when forceLog is explicitly set to true)
+            if (forceLog) {
+                const translatedMessage = translateKey(key, params);
+                // 在 MCP 环境中，所有日志都应该使用 error 级别输出
+                // (In MCP environment, all logs should be output at error level)
+                console.error(`[${prefix}] ${translatedMessage}`);
+            }
         },
         /**
          * 输出警告日志 (Output warning log)
@@ -38,20 +106,23 @@ export function createLogger(prefix) {
          * @param params 翻译参数 (Translation parameters)
          */
         warn: (key, params) => {
-            // 警告日志总是输出，不受debug控制
-            console.error(`[${prefix}] ${t(key, params)}`);
+            // 警告日志总是输出 (Warning logs are always output)
+            const translatedMessage = translateKey(key, params);
+            // 在 MCP 环境中，所有日志都应该使用 error 级别输出
+            // (In MCP environment, all logs should be output at error level)
+            console.error(`[${prefix}] ${translatedMessage}`);
         },
         /**
-         * 输出调试日志 (Output debug log)
+         * 输出错误日志 (Output error log)
          * @param key 翻译键 (Translation key)
          * @param params 翻译参数 (Translation parameters)
-         * @param forceDebug 是否强制输出调试日志 (Whether to force output debug logs)
          */
-        debug: (key, params, forceDebug) => {
-            // 只有在forceDebug=true时才输出调试日志
-            if (forceDebug === true) {
-                console.error(`[${prefix}] ${t(key, params)}`);
-            }
+        error: (key, params) => {
+            // 错误日志总是输出 (Error logs are always output)
+            const translatedMessage = translateKey(key, params);
+            // 在 MCP 环境中，所有日志都应该使用 error 级别输出
+            // (In MCP environment, all logs should be output at error level)
+            console.error(`[${prefix}] ${translatedMessage}`);
         }
     };
 }

package/dist/src/lib/logger.js

@@ -8,6 +8,30 @@ import { t } from './i18n/index.js';
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+// 导入所有翻译文件 (Import all translation files)
+import serverZh from './i18n/locales/zh/server.js';
+import clientZh from './i18n/locales/zh/client.js';
+import toolsZh from './i18n/locales/zh/tools.js';
+import browserZh from './i18n/locales/zh/browser.js';
+import nodeZh from './i18n/locales/zh/node.js';
+import fetcherZh from './i18n/locales/zh/fetcher.js';
+import factoryZh from './i18n/locales/zh/factory.js';
+import errorsZh from './i18n/locales/zh/errors.js';
+import resourcesZh from './i18n/locales/zh/resources.js';
+import promptsZh from './i18n/locales/zh/prompts.js';
+// 创建翻译映射 (Create translation mapping)
+const translationMap = {
+    server: serverZh,
+    client: clientZh,
+    tools: toolsZh,
+    browser: browserZh,
+    node: nodeZh,
+    fetcher: fetcherZh,
+    factory: factoryZh,
+    errors: errorsZh,
+    resources: resourcesZh,
+    prompts: promptsZh
+};
 // 组件名称常量 (Component name constants)
 export const COMPONENTS = {
     SERVER: 'MCP-SERVER',
@@ -16,7 +40,8 @@ export const COMPONENTS = {
     CLIENT: 'CLIENT',
     RESOURCES: 'MCP-RESOURCES',
     PROMPTS: 'MCP-PROMPTS',
-    TOOLS: 'MCP-TOOLS'
+    TOOLS: 'MCP-TOOLS',
+    FETCHER_FACTORY: 'FETCHER-FACTORY'
 };
 // 日志文件路径 (Log file path)
 const LOG_DIR = path.join(os.homedir(), '.mult-fetch-mcp-server');
@@ -32,6 +57,8 @@ catch (error) {
 }
 // 组件日志记录器缓存 (Component logger cache)
 const loggerCache = {};
+// 翻译缓存，避免重复翻译相同的键名 (Translation cache to avoid repeated translation of the same key)
+const translationCache = {};
 /**
  * 获取指定组件的日志记录器 (Get logger for specified component)
  * @param component 组件名称 (Component name)
@@ -93,6 +120,101 @@ export function clearLogFile() {
 export function getLogFilePath() {
     return LOG_FILE;
 }
+/**
+ * 尝试翻译键名 (Try to translate a key)
+ * @param key 翻译键 (Translation key)
+ * @param options 翻译选项 (Translation options)
+ * @param component 组件名称 (Component name)
+ * @returns 翻译后的文本 (Translated text)
+ */
+function translateKey(key, options, component = COMPONENTS.SERVER) {
+    // 如果没有选项，尝试使用缓存 (If no options, try to use cache)
+    if (!options || Object.keys(options).length === 0) {
+        // 生成缓存键 (Generate cache key)
+        const cacheKey = `${key}`;
+        // 如果缓存中存在该键，直接返回缓存的翻译 (If the key exists in cache, return the cached translation)
+        if (translationCache[cacheKey]) {
+            return translationCache[cacheKey];
+        }
+        try {
+            // 尝试翻译键名 (Try to translate the key)
+            const translated = t(key, options);
+            // 确保结果是字符串 (Ensure the result is a string)
+            const translatedStr = typeof translated === 'string' ? translated : JSON.stringify(translated);
+            // 如果翻译结果与键名相同，可能是嵌套键未被正确处理 (If translation result is the same as key, nested key may not be handled correctly)
+            if (translatedStr === key) {
+                // 尝试手动处理嵌套键 (Try to manually handle nested keys)
+                const parts = key.split('.');
+                if (parts.length > 1) {
+                    const namespace = parts[0];
+                    const subKey = parts.slice(1).join('.');
+                    // 根据命名空间获取对应的翻译对象 (Get translation object based on namespace)
+                    const translation = translationMap[namespace];
+                    // 如果找到了翻译对象，尝试获取子键的翻译 (If translation object is found, try to get translation of subkey)
+                    if (translation && translation[subKey]) {
+                        // 将翻译结果存入缓存 (Store the translation result in cache)
+                        translationCache[cacheKey] = translation[subKey];
+                        return translation[subKey];
+                    }
+                }
+            }
+            // 将翻译结果存入缓存 (Store the translation result in cache)
+            translationCache[cacheKey] = translatedStr;
+            return translatedStr;
+        }
+        catch (error) {
+            // 如果翻译失败，返回原始键名 (If translation fails, return the original key)
+            return key;
+        }
+    }
+    else {
+        // 如果有选项，不使用缓存 (If there are options, don't use cache)
+        try {
+            // 尝试翻译键名 (Try to translate the key)
+            const translated = t(key, options);
+            // 确保结果是字符串 (Ensure the result is a string)
+            let translatedStr = typeof translated === 'string' ? translated : JSON.stringify(translated);
+            // 检查翻译后的字符串是否仍然包含占位符，如果包含，手动进行插值替换
+            // (Check if the translated string still contains placeholders, if so, manually perform interpolation)
+            if (options && typeof translatedStr === 'string') {
+                for (const key in options) {
+                    const placeholder = `{{${key}}}`;
+                    if (translatedStr.includes(placeholder)) {
+                        translatedStr = translatedStr.replace(new RegExp(placeholder, 'g'), String(options[key]));
+                    }
+                }
+            }
+            // 如果翻译结果与键名相同，可能是嵌套键未被正确处理 (If translation result is the same as key, nested key may not be handled correctly)
+            if (translatedStr === key) {
+                // 尝试手动处理嵌套键 (Try to manually handle nested keys)
+                const parts = key.split('.');
+                if (parts.length > 1) {
+                    const namespace = parts[0];
+                    const subKey = parts.slice(1).join('.');
+                    // 根据命名空间获取对应的翻译对象 (Get translation object based on namespace)
+                    const translation = translationMap[namespace];
+                    // 如果找到了翻译对象，尝试获取子键的翻译 (If translation object is found, try to get translation of subkey)
+                    if (translation && translation[subKey]) {
+                        // 如果有选项，进行插值 (If there are options, do interpolation)
+                        let result = translation[subKey];
+                        for (const key in options) {
+                            const placeholder = `{{${key}}}`;
+                            if (result.includes(placeholder)) {
+                                result = result.replace(new RegExp(placeholder, 'g'), String(options[key]));
+                            }
+                        }
+                        return result;
+                    }
+                }
+            }
+            return translatedStr;
+        }
+        catch (error) {
+            // 如果翻译失败，返回原始键名 (If translation fails, return the original key)
+            return key;
+        }
+    }
+}
 /**
  * 统一日志函数 (Unified log function)
  * 输出调试信息到标准错误流和日志文件 (Output debug information to standard error stream and log file)
@@ -108,19 +230,18 @@ export function log(key, debug = false, options, component = COMPONENTS.SERVER)
     }
     // 获取组件的日志记录器 (Get logger for component)
     const logger = getLogger(component);
-    // 输出到控制台 (Output to console)
-    logger.debug(key, options, debug);
-    // 翻译消息 (Translate message)
-    let translatedMessage;
-    try {
-        const translated = t(key, options);
-        // 确保 translatedMessage 是字符串 (Ensure translatedMessage is a string)
-        translatedMessage = typeof translated === 'string' ? translated : JSON.stringify(translated);
-    }
-    catch (error) {
-        // 如果翻译失败，使用原始消息 (If translation fails, use original message)
-        translatedMessage = typeof key === 'string' ? key : JSON.stringify(key);
-    }
+    // 翻译键名 (Translate the key)
+    const translatedMessage = translateKey(key, options, component);
+    // 在 MCP 环境中，所有日志都应该使用 error 级别输出 (In MCP environment, all logs should be output at error level)
+    console.error(`[${component}] ${translatedMessage}`);
     // 写入日志文件 (Write to log file)
     writeToLogFile(component, translatedMessage);
 }
+/**
+ * 清除翻译缓存 (Clear translation cache)
+ */
+export function clearTranslationCache() {
+    Object.keys(translationCache).forEach(key => {
+        delete translationCache[key];
+    });
+}

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

@@ -3,8 +3,9 @@
  * 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)
 let browserInitialized = false;
 /**
@@ -33,32 +34,25 @@ export async function closeBrowserInstance(debug = false) {
         if (debug) {
             log('server.closingBrowser', debug, {}, COMPONENTS.SERVER);
         }
-        await BrowserFetcher.closeBrowser(true);
+        await BrowserInstance.closeBrowser(debug);
         browserInitialized = false;
     }
 }
 /**
- * 检查是否应该切换到浏览器模式 (Check if should switch to browser mode)
- * 根据错误信息判断是否需要浏览器模式 (Determine if browser mode is needed based on error message)
+ * 判断是否应该切换到浏览器模式 (Determine if should switch to browser mode)
+ * 根据错误信息判断是否需要浏览器模式 (Based on error message to determine if browser mode is needed)
  * @param error 错误对象 (Error object)
- * @returns 是否应该切换到浏览器模式 (Whether to switch to browser mode)
+ * @returns 是否应该切换到浏览器模式 (Whether should switch to browser mode)
  */
 export function shouldSwitchToBrowser(error) {
     // 检查错误是否表明需要浏览器模式 (Check if error indicates browser mode is needed)
     if (error && error.message) {
-        const errorMessage = error.message.toLowerCase();
-        return errorMessage.includes('403') ||
-            errorMessage.includes('forbidden') ||
-            errorMessage.includes('access denied') ||
-            errorMessage.includes('cloudflare') ||
-            errorMessage.includes('captcha') ||
-            errorMessage.includes('javascript required') ||
-            errorMessage.includes('timeout') ||
-            errorMessage.includes('connect timeout') ||
-            errorMessage.includes('socket') ||
-            errorMessage.includes('econnrefused') ||
-            errorMessage.includes('und_err_connect_timeout') ||
-            errorMessage.includes('fetch failed');
+        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');
     }
     return false;
 }

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,13 @@ 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);
             }
         }
         else {
@@ -50,36 +49,16 @@ export async function fetchWithAutoDetect(params, type) {
                 // 根据类型选择合适的标准获取方法 (Choose appropriate standard fetching method based on type)
                 switch (type) {
                     case 'html': {
-                        const result = await NodeFetcher.html(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: result.html }],
-                            isError: false
-                        };
+                        return await Fetcher.html(params);
                     }
                     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
-                        };
+                        return await Fetcher.json(params);
                     }
                     case 'txt': {
-                        const result = await NodeFetcher.txt(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: result.text }],
-                            isError: false
-                        };
+                        return await Fetcher.txt(params);
                     }
                     case 'markdown': {
-                        const result = await NodeFetcher.markdown(params);
-                        // 转换为统一格式 (Convert to unified format)
-                        return {
-                            content: [{ type: 'text', text: result.markdown }],
-                            isError: false
-                        };
+                        return await Fetcher.markdown(params);
                     }
                 }
             }
@@ -97,13 +76,13 @@ export async function fetchWithAutoDetect(params, 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);
                     }
                 }
                 // 如果不需要切换到浏览器模式，则抛出原始错误

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';