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

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

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

package/dist/src/lib/utils/errorDetection.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.
+ */
+/**
+ * 检查错误文本是否表示访问被拒绝或需要人机验证
+ * (Check if error text indicates access denied or requires human verification)
+ *
+ * @param errorText 错误文本 (Error text to check)
+ * @returns 是否为访问被拒绝错误 (Whether it's an access denied error)
+ */
+export function isAccessDeniedError(errorText) {
+    if (!errorText)
+        return false;
+    const lowerCaseError = errorText.toLowerCase();
+    return lowerCaseError.includes('403') ||
+        lowerCaseError.includes('forbidden') ||
+        lowerCaseError.includes('access denied') ||
+        lowerCaseError.includes('cloudflare') ||
+        lowerCaseError.includes('captcha') ||
+        lowerCaseError.includes('blocked') ||
+        lowerCaseError.includes('security check');
+}
+/**
+ * 检查错误文本是否表示网络错误
+ * (Check if error text indicates a network error)
+ *
+ * @param errorText 错误文本 (Error text to check)
+ * @returns 是否为网络错误 (Whether it's a network error)
+ */
+export function isNetworkError(errorText) {
+    if (!errorText)
+        return false;
+    const lowerCaseError = errorText.toLowerCase();
+    return lowerCaseError.includes('network') ||
+        lowerCaseError.includes('connection') ||
+        lowerCaseError.includes('timeout') ||
+        lowerCaseError.includes('unreachable') ||
+        lowerCaseError.includes('econnrefused');
+}

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

@@ -0,0 +1,279 @@
+/*
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+import { log, COMPONENTS } from '../logger.js';
+import { isAccessDeniedError, isNetworkError } from './errorDetection.js';
+// 扩展组件常量 (Extend component constants)
+const EXTENDED_COMPONENTS = {
+    ...COMPONENTS,
+    UNKNOWN: 'UNKNOWN',
+    BROWSER: 'BROWSER'
+};
+/**
+ * 错误类型枚举 (Error type enumeration)
+ */
+export var ErrorType;
+(function (ErrorType) {
+    // 网络错误 (Network errors)
+    ErrorType["NETWORK"] = "NETWORK";
+    ErrorType["TIMEOUT"] = "TIMEOUT";
+    ErrorType["CONNECTION_REFUSED"] = "CONNECTION_REFUSED";
+    // HTTP 错误 (HTTP errors)
+    ErrorType["HTTP_CLIENT_ERROR"] = "HTTP_CLIENT_ERROR";
+    ErrorType["HTTP_SERVER_ERROR"] = "HTTP_SERVER_ERROR";
+    // 访问控制错误 (Access control errors)
+    ErrorType["ACCESS_DENIED"] = "ACCESS_DENIED";
+    ErrorType["CLOUDFLARE_PROTECTION"] = "CLOUDFLARE_PROTECTION";
+    ErrorType["CAPTCHA_REQUIRED"] = "CAPTCHA_REQUIRED";
+    // 解析错误 (Parsing errors)
+    ErrorType["JSON_PARSE_ERROR"] = "JSON_PARSE_ERROR";
+    ErrorType["HTML_PARSE_ERROR"] = "HTML_PARSE_ERROR";
+    // 浏览器错误 (Browser errors)
+    ErrorType["BROWSER_LAUNCH_ERROR"] = "BROWSER_LAUNCH_ERROR";
+    ErrorType["BROWSER_NAVIGATION_ERROR"] = "BROWSER_NAVIGATION_ERROR";
+    ErrorType["BROWSER_CONTENT_ERROR"] = "BROWSER_CONTENT_ERROR";
+    // 资源错误 (Resource errors)
+    ErrorType["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+    ErrorType["RESOURCE_ACCESS_ERROR"] = "RESOURCE_ACCESS_ERROR";
+    // 工具错误 (Tool errors)
+    ErrorType["TOOL_NOT_FOUND"] = "TOOL_NOT_FOUND";
+    ErrorType["TOOL_EXECUTION_ERROR"] = "TOOL_EXECUTION_ERROR";
+    // 参数错误 (Parameter errors)
+    ErrorType["INVALID_PARAMETER"] = "INVALID_PARAMETER";
+    ErrorType["MISSING_PARAMETER"] = "MISSING_PARAMETER";
+    // 其他错误 (Other errors)
+    ErrorType["UNKNOWN"] = "UNKNOWN";
+})(ErrorType || (ErrorType = {}));
+/**
+ * 基础错误类 (Base error class)
+ */
+export class FetchError extends Error {
+    type;
+    statusCode;
+    originalError;
+    details;
+    component;
+    /**
+     * 构造函数 (Constructor)
+     * @param message 错误消息 (Error message)
+     * @param type 错误类型 (Error type)
+     * @param component 组件名称 (Component name)
+     * @param details 错误详情 (Error details)
+     */
+    constructor(message, type = ErrorType.UNKNOWN, component = EXTENDED_COMPONENTS.UNKNOWN, details) {
+        super(message);
+        this.name = 'FetchError';
+        this.type = type;
+        this.component = component;
+        this.details = details;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, FetchError.prototype);
+    }
+    /**
+     * 记录错误日志 (Log error)
+     * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+     * @param forceLog 是否强制记录日志 (Whether to force logging)
+     */
+    log(debug = false, forceLog = false) {
+        const logDetails = {
+            type: this.type,
+            message: this.message,
+            ...(this.statusCode ? { statusCode: this.statusCode } : {}),
+            ...(this.details || {})
+        };
+        log('error.occurred', debug || forceLog, logDetails, this.component);
+    }
+    /**
+     * 转换为标准响应格式 (Convert to standard response format)
+     * @returns 标准响应对象 (Standard response object)
+     */
+    toResponse() {
+        return {
+            isError: true,
+            content: [
+                {
+                    text: this.message
+                }
+            ]
+        };
+    }
+}
+/**
+ * 网络错误类 (Network error class)
+ */
+export class NetworkError extends FetchError {
+    constructor(message, component = EXTENDED_COMPONENTS.UNKNOWN, details, originalError) {
+        super(message, ErrorType.NETWORK, component, details);
+        this.name = 'NetworkError';
+        this.originalError = originalError;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, NetworkError.prototype);
+    }
+}
+/**
+ * 超时错误类 (Timeout error class)
+ */
+export class TimeoutError extends NetworkError {
+    constructor(message, component = EXTENDED_COMPONENTS.UNKNOWN, details, originalError) {
+        super(message, component, details, originalError);
+        this.name = 'TimeoutError';
+        this.type = ErrorType.TIMEOUT;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, TimeoutError.prototype);
+    }
+}
+/**
+ * HTTP 错误类 (HTTP error class)
+ */
+export class HttpError extends FetchError {
+    constructor(message, statusCode, component = EXTENDED_COMPONENTS.UNKNOWN, details, originalError) {
+        const type = statusCode >= 400 && statusCode < 500
+            ? ErrorType.HTTP_CLIENT_ERROR
+            : ErrorType.HTTP_SERVER_ERROR;
+        super(message, type, component, details);
+        this.name = 'HttpError';
+        this.statusCode = statusCode;
+        this.originalError = originalError;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, HttpError.prototype);
+    }
+}
+/**
+ * 访问被拒绝错误类 (Access denied error class)
+ */
+export class AccessDeniedError extends HttpError {
+    constructor(message, statusCode = 403, component = EXTENDED_COMPONENTS.UNKNOWN, details, originalError) {
+        super(message, statusCode, component, details, originalError);
+        this.name = 'AccessDeniedError';
+        this.type = ErrorType.ACCESS_DENIED;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, AccessDeniedError.prototype);
+    }
+}
+/**
+ * 解析错误类 (Parse error class)
+ */
+export class ParseError extends FetchError {
+    constructor(message, type = ErrorType.JSON_PARSE_ERROR, component = EXTENDED_COMPONENTS.UNKNOWN, details, originalError) {
+        super(message, type, component, details);
+        this.name = 'ParseError';
+        this.originalError = originalError;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, ParseError.prototype);
+    }
+}
+/**
+ * 浏览器错误类 (Browser error class)
+ */
+export class BrowserError extends FetchError {
+    constructor(message, type = ErrorType.BROWSER_LAUNCH_ERROR, component = EXTENDED_COMPONENTS.BROWSER, details, originalError) {
+        super(message, type, component, details);
+        this.name = 'BrowserError';
+        this.originalError = originalError;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, BrowserError.prototype);
+    }
+}
+/**
+ * 工具错误类 (Tool error class)
+ */
+export class ToolError extends FetchError {
+    constructor(message, type = ErrorType.TOOL_EXECUTION_ERROR, component = COMPONENTS.TOOLS, details, originalError) {
+        super(message, type, component, details);
+        this.name = 'ToolError';
+        this.originalError = originalError;
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, ToolError.prototype);
+    }
+}
+/**
+ * 参数错误类 (Parameter error class)
+ */
+export class ParameterError extends FetchError {
+    constructor(message, type = ErrorType.INVALID_PARAMETER, component = EXTENDED_COMPONENTS.UNKNOWN, details) {
+        super(message, type, component, details);
+        this.name = 'ParameterError';
+        // 确保 instanceof 正常工作 (Ensure instanceof works correctly)
+        Object.setPrototypeOf(this, ParameterError.prototype);
+    }
+}
+/**
+ * 创建错误对象 (Create error object)
+ * @param error 原始错误 (Original error)
+ * @param component 组件名称 (Component name)
+ * @param details 错误详情 (Error details)
+ * @returns 标准化的错误对象 (Standardized error object)
+ */
+export function createError(error, component = EXTENDED_COMPONENTS.UNKNOWN, details) {
+    // 如果已经是 FetchError 类型，直接返回
+    if (error instanceof FetchError) {
+        return error;
+    }
+    // 获取错误消息
+    const errorMessage = error instanceof Error
+        ? error.message
+        : typeof error === 'string'
+            ? error
+            : 'Unknown error';
+    // 检查错误类型并创建相应的错误对象
+    const errorText = errorMessage.toLowerCase();
+    // 检查是否为访问被拒绝错误
+    if (isAccessDeniedError(errorText)) {
+        return new AccessDeniedError(errorMessage, 403, component, details, error);
+    }
+    // 检查是否为网络错误
+    if (isNetworkError(errorText)) {
+        // 检查是否为超时错误
+        if (errorText.includes('timeout')) {
+            return new TimeoutError(errorMessage, component, details, error);
+        }
+        return new NetworkError(errorMessage, component, details, error);
+    }
+    // 检查是否为 HTTP 错误
+    const statusCodeMatch = errorText.match(/(\d{3})/);
+    if (statusCodeMatch) {
+        const statusCode = parseInt(statusCodeMatch[1], 10);
+        if (statusCode >= 400 && statusCode < 600) {
+            return new HttpError(errorMessage, statusCode, component, details, error);
+        }
+    }
+    // 检查是否为解析错误
+    if (errorText.includes('json') && (errorText.includes('parse') || errorText.includes('invalid'))) {
+        return new ParseError(errorMessage, ErrorType.JSON_PARSE_ERROR, component, details, error);
+    }
+    if (errorText.includes('html') && (errorText.includes('parse') || errorText.includes('invalid'))) {
+        return new ParseError(errorMessage, ErrorType.HTML_PARSE_ERROR, component, details, error);
+    }
+    // 检查是否为浏览器错误
+    if (errorText.includes('browser') || errorText.includes('puppeteer') || errorText.includes('chrome')) {
+        if (errorText.includes('launch') || errorText.includes('start')) {
+            return new BrowserError(errorMessage, ErrorType.BROWSER_LAUNCH_ERROR, component, details, error);
+        }
+        if (errorText.includes('navigate') || errorText.includes('goto')) {
+            return new BrowserError(errorMessage, ErrorType.BROWSER_NAVIGATION_ERROR, component, details, error);
+        }
+        return new BrowserError(errorMessage, ErrorType.BROWSER_CONTENT_ERROR, component, details, error);
+    }
+    // 默认返回通用错误
+    return new FetchError(errorMessage, ErrorType.UNKNOWN, component, details);
+}
+/**
+ * 处理错误 (Handle error)
+ * @param error 原始错误 (Original error)
+ * @param component 组件名称 (Component name)
+ * @param debug 是否启用调试模式 (Whether debug mode is enabled)
+ * @param details 错误详情 (Error details)
+ * @returns 标准化的错误响应 (Standardized error response)
+ */
+export function handleError(error, component = EXTENDED_COMPONENTS.UNKNOWN, debug = false, details) {
+    // 创建标准化的错误对象
+    const standardError = createError(error, component, details);
+    // 记录错误日志
+    standardError.log(debug, true);
+    // 返回标准化的错误响应
+    return standardError.toResponse();
+}
+// 导出错误检测函数
+export { isAccessDeniedError, isNetworkError };

package/dist/src/test-i18n.js

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