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

package/dist/src/lib/i18n/locales/zh/resources.js

@@ -3,60 +3,57 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { RESOURCES_KEYS } from '../../keys.js';
-// 资源相关消息 (Resources related messages)
-export const resources = {
-    // 资源列表相关 (Resource list related)
-    [RESOURCES_KEYS.list.request]: "收到资源列表请求: {params}",
-    [RESOURCES_KEYS.list.success]: "资源列表获取成功",
-    [RESOURCES_KEYS.list.error]: "获取资源列表时出错: {error}",
-    // 资源获取相关 (Resource get related)
-    [RESOURCES_KEYS.get.request]: "收到资源读取请求: {uri}",
-    [RESOURCES_KEYS.get.success]: "资源获取成功: {uri}",
-    [RESOURCES_KEYS.get.error]: "读取资源时出错: {uri}, {error}",
-    [RESOURCES_KEYS.get.notFound]: "未找到资源: {uri}",
-    // 资源创建相关 (Resource create related)
-    [RESOURCES_KEYS.create.request]: "收到资源创建请求: {uri}",
-    [RESOURCES_KEYS.create.success]: "资源创建成功: {uri}",
-    [RESOURCES_KEYS.create.error]: "创建资源时出错: {uri}, {error}",
-    [RESOURCES_KEYS.create.duplicate]: "资源已存在: {uri}",
-    // 资源更新相关 (Resource update related)
-    [RESOURCES_KEYS.update.request]: "收到资源更新请求: {uri}",
-    [RESOURCES_KEYS.update.success]: "资源更新成功: {uri}",
-    [RESOURCES_KEYS.update.error]: "更新资源时出错: {uri}, {error}",
-    [RESOURCES_KEYS.update.notFound]: "未找到要更新的资源: {uri}",
-    // 资源删除相关 (Resource delete related)
-    [RESOURCES_KEYS.delete.request]: "收到资源删除请求: {uri}",
-    [RESOURCES_KEYS.delete.success]: "资源删除成功: {uri}",
-    [RESOURCES_KEYS.delete.error]: "删除资源时出错: {uri}, {error}",
-    [RESOURCES_KEYS.delete.notFound]: "未找到要删除的资源: {uri}",
-    // 额外的键（不在 RESOURCES_KEYS 中定义的）
-    fileReadError: "读取文件时出错: {filePath}, {error}",
-    invalidUri: "无效的资源URI",
-    notFound: "资源未找到",
+import { RESOURCES_KEYS } from '../../keys/resources.js';
+// 资源相关消息 (Resource related messages)
+export default {
+    // 列表操作 (List operations)
+    [RESOURCES_KEYS.list.request]: "收到资源列表请求",
+    [RESOURCES_KEYS.list.success]: "成功获取资源列表",
+    [RESOURCES_KEYS.list.error]: "获取资源列表出错：{{error}}",
+    [RESOURCES_KEYS.list.notFound]: "未找到任何资源",
+    [RESOURCES_KEYS.list.duplicate]: "列表中发现重复资源",
+    // 获取操作 (Get operations)
+    [RESOURCES_KEYS.get.request]: "收到获取资源请求",
+    [RESOURCES_KEYS.get.success]: "成功获取资源",
+    [RESOURCES_KEYS.get.error]: "获取资源出错：{{error}}",
+    [RESOURCES_KEYS.get.notFound]: "未找到请求的资源",
+    [RESOURCES_KEYS.get.duplicate]: "发现重复资源",
+    // 读取操作 (Read operations)
+    [RESOURCES_KEYS.read.request]: "收到读取资源请求",
+    [RESOURCES_KEYS.read.success]: "成功读取资源",
+    [RESOURCES_KEYS.read.error]: "读取资源出错：{{error}}",
+    [RESOURCES_KEYS.read.notFound]: "未找到要读取的资源",
+    [RESOURCES_KEYS.readError]: "读取资源出错：{{error}}",
+    // 创建操作 (Create operations)
+    [RESOURCES_KEYS.create.request]: "收到创建资源请求",
+    [RESOURCES_KEYS.create.success]: "成功创建资源",
+    [RESOURCES_KEYS.create.error]: "创建资源出错：{{error}}",
+    [RESOURCES_KEYS.create.notFound]: "未找到父资源",
+    [RESOURCES_KEYS.create.duplicate]: "资源已存在",
+    // 更新操作 (Update operations)
+    [RESOURCES_KEYS.update.request]: "收到更新资源请求",
+    [RESOURCES_KEYS.update.success]: "成功更新资源",
+    [RESOURCES_KEYS.update.error]: "更新资源出错：{{error}}",
+    [RESOURCES_KEYS.update.notFound]: "未找到要更新的资源",
+    [RESOURCES_KEYS.update.duplicate]: "更新会导致资源重复",
+    // 删除操作 (Delete operations)
+    [RESOURCES_KEYS.delete.request]: "收到删除资源请求",
+    [RESOURCES_KEYS.delete.success]: "成功删除资源",
+    [RESOURCES_KEYS.delete.error]: "删除资源出错：{{error}}",
+    [RESOURCES_KEYS.delete.notFound]: "未找到要删除的资源",
+    [RESOURCES_KEYS.delete.duplicate]: "多个资源匹配删除条件",
+    // 其他资源相关消息 (Other resource related messages)
+    [RESOURCES_KEYS.fileReadError]: "读取文件出错：{{error}}",
+    [RESOURCES_KEYS.invalidUri]: "无效的 URI：{{uri}}",
+    [RESOURCES_KEYS.notFound]: "未找到资源：{{path}}",
     // 资源描述 (Resource descriptions)
-    readme: {
-        description: "项目自述文件，包含项目概述、安装和使用说明"
-    },
-    package: {
-        description: "项目包配置文件，包含依赖和脚本定义"
-    },
-    index: {
-        description: "项目入口文件，包含服务器启动逻辑"
-    },
-    client: {
-        description: "MCP客户端实现，用于与服务器通信"
-    },
-    // 资源模板描述 (Resource template descriptions)
-    sourceFile: {
-        name: "源代码文件",
-        description: "访问项目源代码文件"
-    },
-    docFile: {
-        name: "文档文件",
-        description: "访问项目文档文件"
-    },
-    filename: {
-        description: "文件名，包括扩展名"
-    }
+    [RESOURCES_KEYS.readme.description]: "项目 README 文件",
+    [RESOURCES_KEYS.package.description]: "包配置文件",
+    [RESOURCES_KEYS.index.description]: "主入口文件",
+    [RESOURCES_KEYS.client.description]: "客户端实现文件",
+    [RESOURCES_KEYS.sourceFile.name]: "源代码文件",
+    [RESOURCES_KEYS.sourceFile.description]: "项目源代码文件",
+    [RESOURCES_KEYS.docFile.name]: "文档文件",
+    [RESOURCES_KEYS.docFile.description]: "项目文档文件",
+    [RESOURCES_KEYS.filename.description]: "文件名"
 };

package/dist/src/lib/i18n/locales/zh/server.js

@@ -3,30 +3,56 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
+import { SERVER_KEYS } from '../../keys/server.js';
 // 服务器相关消息 (Server related messages)
-export const server = {
-    starting: "MCP 服务器启动中...",
-    connecting: "正在连接到 MCP 传输: {{transport}}",
-    started: "MCP 服务器已启动",
-    stopping: "MCP 服务器停止中...",
-    stopped: "MCP 服务器已停止",
-    error: "MCP 服务器错误: {{error}}",
-    receivedRequest: "收到工具请求: {{tool}}",
-    processingRequest: "正在处理工具请求: {{tool}}",
-    requestCompleted: "工具请求完成: {{tool}}",
-    requestFailed: "工具请求失败: {{tool}}, 错误: {{error}}",
-    receivedInterruptSignal: "收到中断信号，正在关闭服务器...",
-    receivedTerminateSignal: "收到终止信号，正在关闭服务器...",
-    uncaughtException: "未捕获的异常: {{error}}",
-    debug: "{{message}}",
-    // 新增的翻译键 (New translation keys)
-    initializingBrowser: "初始化浏览器实例...",
-    closingBrowser: "关闭浏览器实例...",
-    receivedToolRequest: "收到{{name}}请求: {{url}}",
-    processingToolRequestError: "处理{{name}}请求时出错: {{error}}",
-    usingBrowserMode: "使用浏览器模式获取 {{type}}: {{url}}",
-    usingAutoDetectMode: "使用自动检测模式获取 {{type}}: {{url}}",
-    switchingToBrowserMode: "标准模式失败，切换到浏览器模式: {{url}}",
-    fetchError: "获取 {{type}} 时出错: {{error}}",
-    connectionError: "连接到传输时出错: {{error}}"
+export default {
+    // 服务器状态相关 (Server status related)
+    [SERVER_KEYS.starting]: "MCP 服务器启动中...",
+    [SERVER_KEYS.started]: "MCP 服务器已启动",
+    [SERVER_KEYS.stopping]: "MCP 服务器停止中...",
+    [SERVER_KEYS.stopped]: "MCP 服务器已停止",
+    [SERVER_KEYS.error]: "MCP 服务器错误: {{error}}",
+    [SERVER_KEYS.startupError]: "MCP 服务器启动错误: {{error}}",
+    // 连接相关 (Connection related)
+    [SERVER_KEYS.connecting]: "正在连接到 MCP 传输: {{transport}}",
+    [SERVER_KEYS.connected]: "已连接到 MCP 传输",
+    [SERVER_KEYS.connectionFailed]: "连接到 MCP 传输失败: {{error}}",
+    [SERVER_KEYS.disconnected]: "已断开与 MCP 传输的连接: {{transport}}",
+    [SERVER_KEYS.connectionError]: "连接到 MCP 传输时出错: {{error}}",
+    // 错误相关 (Error related)
+    [SERVER_KEYS.serverError]: "MCP 服务器错误: {{error}}",
+    [SERVER_KEYS.transportError]: "MCP 传输错误: {{error}}",
+    // 请求处理相关 (Request handling related)
+    [SERVER_KEYS.receivedRequest]: "收到请求: {{id}}",
+    [SERVER_KEYS.processingRequest]: "处理请求: {{id}}",
+    [SERVER_KEYS.requestCompleted]: "请求完成: {{id}}",
+    [SERVER_KEYS.requestError]: "处理{{name}}请求时出错: {{error}}",
+    [SERVER_KEYS.requestReceived]: "收到请求: {{id}}",
+    [SERVER_KEYS.requestProcessed]: "处理了 {{method}} 请求: {{path}} ({{time}}ms)",
+    [SERVER_KEYS.requestFailed]: "工具请求失败: {{tool}}, 错误: {{error}}",
+    // 浏览器相关 (Browser related)
+    [SERVER_KEYS.initializingBrowser]: "初始化浏览器实例...",
+    [SERVER_KEYS.browserInitialized]: "浏览器实例已初始化",
+    [SERVER_KEYS.browserInitFailed]: "浏览器初始化失败: {{error}}",
+    [SERVER_KEYS.closingBrowser]: "关闭浏览器实例...",
+    [SERVER_KEYS.browserClosed]: "浏览器实例已关闭",
+    // 工具相关 (Tool related)
+    [SERVER_KEYS.tool.requestReceived]: "收到 {{name}} 工具请求",
+    [SERVER_KEYS.tool.requestProcessed]: "处理了 {{name}} 工具请求 ({{time}}ms)",
+    [SERVER_KEYS.tool.requestError]: "处理 {{name}} 请求时出错: {{error}}",
+    // 入口相关 (Entry related)
+    [SERVER_KEYS.entry.loaded]: "MCP 服务器入口点已加载",
+    // 系统相关 (System related)
+    [SERVER_KEYS.receivedInterruptSignal]: "收到中断信号，正在关闭服务器...",
+    [SERVER_KEYS.receivedTerminateSignal]: "收到终止信号，正在关闭服务器...",
+    [SERVER_KEYS.uncaughtException]: "未捕获的异常: {{error}}",
+    [SERVER_KEYS.debug]: "{{message}}",
+    [SERVER_KEYS.listeningOn]: "服务器监听端口 {{port}}",
+    // 其他键 (Other keys)
+    [SERVER_KEYS.receivedToolRequest]: "收到工具请求: {{name}}",
+    [SERVER_KEYS.processingToolRequestError]: "处理工具请求时出错: {{name}}, {{error}}",
+    [SERVER_KEYS.usingBrowserMode]: "对 {{url}} 使用浏览器模式",
+    [SERVER_KEYS.usingAutoDetectMode]: "对 {{url}} 使用自动检测模式",
+    [SERVER_KEYS.switchingToBrowserMode]: "标准模式失败，切换到浏览器模式: {{url}}",
+    [SERVER_KEYS.fetchError]: "获取 {{type}} 时出错: {{error}}"
 };

package/dist/src/lib/i18n/locales/zh/tools.js

@@ -3,23 +3,31 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-// 工具相关消息 (Tool related messages)
-export const tools = {
-    fetchHtml: {
-        description: "获取网站并以 HTML 格式返回内容",
-        error: "获取 HTML 失败: {{error}}"
-    },
-    fetchJson: {
-        description: "从 URL 获取 JSON 文件",
-        error: "获取 JSON 失败: {{error}}",
-        invalidJson: "URL 返回的 JSON 无效: {{url}}"
-    },
-    fetchTxt: {
-        description: "获取网站，以纯文本格式返回内容（无 HTML）",
-        error: "获取文本失败: {{error}}"
-    },
-    fetchMarkdown: {
-        description: "获取网站并以 Markdown 格式返回内容",
-        error: "获取 Markdown 失败: {{error}}"
-    }
+import { TOOLS_KEYS } from '../../keys/tools.js';
+export default {
+    // 工具描述 (Tool descriptions)
+    [TOOLS_KEYS.fetchHtmlDescription]: '获取网站并以HTML格式返回内容',
+    [TOOLS_KEYS.fetchJsonDescription]: '从URL获取JSON文件',
+    [TOOLS_KEYS.fetchTxtDescription]: '获取网站，以纯文本形式返回内容（无HTML）',
+    [TOOLS_KEYS.fetchMarkdownDescription]: '获取网站并以Markdown格式返回内容',
+    // 参数描述 (Parameter descriptions)
+    [TOOLS_KEYS.urlDescription]: '要获取的网站URL',
+    // 错误消息 (Error messages)
+    [TOOLS_KEYS.fetchHtmlError]: '获取HTML失败: {{error}}',
+    [TOOLS_KEYS.fetchJsonError]: '获取JSON失败: {{error}}',
+    [TOOLS_KEYS.fetchTxtError]: '获取文本失败: {{error}}',
+    [TOOLS_KEYS.fetchMarkdownError]: '获取Markdown失败: {{error}}',
+    [TOOLS_KEYS.jsonParseWarning]: '警告: JSON解析错误: {{error}}',
+    // 成功消息 (Success messages)
+    [TOOLS_KEYS.fetchHtmlSuccess]: '成功从 {{url}} 获取HTML',
+    [TOOLS_KEYS.fetchJsonSuccess]: '成功从 {{url}} 获取JSON',
+    [TOOLS_KEYS.fetchTxtSuccess]: '成功从 {{url}} 获取文本',
+    [TOOLS_KEYS.fetchMarkdownSuccess]: '成功从 {{url}} 获取Markdown',
+    // 工具调用相关 (Tool call related)
+    [TOOLS_KEYS.callReceived]: '收到工具调用: {{name}}，参数: {{args}}',
+    [TOOLS_KEYS.unknownTool]: '未知工具: {{name}}',
+    [TOOLS_KEYS.callError]: '调用工具 {{name}} 时出错: {{error}}',
+    [TOOLS_KEYS.missingUrl]: '缺少URL参数',
+    [TOOLS_KEYS.fetchRequest]: '正在从URL获取{{type}}: {{url}}',
+    [TOOLS_KEYS.fetchError]: '从URL {{url}} 获取内容时出错: {{error}}'
 };

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];
+    });
+}