file-system-with-oss-mcp 1.2.5 → 1.2.7

package/dist/index.js

@@ -91,9 +91,11 @@ var ConfigManager = class _ConfigManager {
   static onestepClients = { "saber": "saber_secret", "onestep_user": "ewkej3243242" };
   oAuthConfig;
   newApiUser;
+  apiConfig;
   constructor() {
     this.oAuthConfig = {};
     this.newApiUser = {};
+    this.apiConfig = {};
   }
   static async getInstance() {
     if (!_ConfigManager.instance) {
@@ -101,11 +103,12 @@ var ConfigManager = class _ConfigManager {
     }
     return _ConfigManager.instance;
   }
-  static async init(newApiUser, userSetting) {
+  static async init(newApiUser, userSetting, apiConfig) {
     if (!_ConfigManager.instance) {
       _ConfigManager.instance = new _ConfigManager();
       await _ConfigManager.instance.loadConfig(userSetting);
       _ConfigManager.instance.newApiUser = newApiUser;
+      _ConfigManager.instance.apiConfig = apiConfig;
     }
     return _ConfigManager.instance;
   }
@@ -143,6 +146,12 @@ var ConfigManager = class _ConfigManager {
   getOAuthConfig() {
     return this.oAuthConfig;
   }
+  getNewApiUser() {
+    return this.newApiUser;
+  }
+  getApiConfig() {
+    return this.apiConfig;
+  }
 };
 
 // src/config/config.ts
@@ -179,6 +188,11 @@ async function getServerConfig(isStdioMode = false) {
     logger.error("allowedDirectories argv variable is not set");
     throw new Error("allowedDirectories environment variable is not set");
   }
+  const apiServer = process.argv.find((arg) => arg.startsWith("--apiServer="));
+  if (!apiServer) {
+    logger.error("apiServer argv variable is not set");
+    throw new Error("apiServer environment variable is not set");
+  }
   const config3 = {
     port: 3e3,
     ossConfig: {},
@@ -192,7 +206,6 @@ async function getServerConfig(isStdioMode = false) {
   const directoriesInparam = allowedDirectories.split("=")[1];
   let tempdirs = directoriesInparam.replaceAll("\\", "\\").split(",") ?? [];
   const normalizeDirs = tempdirs.map((dir) => normalizePath(expandHome(dir)));
-  logger.info("Allowed directories:", allowedDirectories);
   await Promise.all(normalizeDirs.map(async (dir) => {
     try {
       const stats = await stat(expandHome(dir));
@@ -206,6 +219,7 @@ async function getServerConfig(isStdioMode = false) {
     }
   }));
   config3.allowedDirectories = normalizeDirs;
+  console.log("Allowed directories:", normalizeDirs);
   config3.configSources.port = "cli";
   const newApiAuthDataString = Buffer.from(newApiAuthData.split("=")[1], "base64").toString("utf8");
   const newApiAuthDataArry = newApiAuthDataString.split("\u8B8A");
@@ -219,7 +233,9 @@ async function getServerConfig(isStdioMode = false) {
   const allOssConfigs = { "default": { region: "cn-hongkong", accessKeyId: userSetting.accessKeyId, accessKeySecret: userSetting.accessKeySecret, bucket: userSetting.bucketName, endpoint: userSetting.endpoint, cdnHost: userSetting.cdnHost } };
   config3.ossConfig = allOssConfigs;
   config3.configSources.ossConfig = "cli";
-  ConfigManager.init(newApiUser, userSetting);
+  const apiServerDataString = Buffer.from(apiServer.split("=")[1], "base64").toString("utf8");
+  const apiServerConfig = JSON.parse(apiServerDataString);
+  await ConfigManager.init(newApiUser, userSetting, apiServerConfig);
   if (Object.keys(config3.ossConfig).length === 0) {
     logger.warn("\u672A\u627E\u5230\u6709\u6548\u7684OSS\u914D\u7F6E\u3002\u670D\u52A1\u5668\u5C06\u542F\u52A8\uFF0C\u4F46\u4E0A\u4F20\u529F\u80FD\u5C06\u4E0D\u53EF\u7528\u3002");
   }
@@ -360,8 +376,8 @@ var ossService = new OssService();
 // src/server.ts
 import express from "express";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import fs3 from "fs";
-import { stat as stat2, realpath, readdir, readFile, writeFile, mkdir, rename } from "fs/promises";
+import fs3, { mkdirSync } from "fs";
+import { stat as stat2, realpath, readdir, readFile, writeFile, mkdir, rename, copyFile } from "fs/promises";
 import { createTwoFilesPatch } from "diff";
 import os2 from "os";
 import * as fpath2 from "path";
@@ -461,49 +477,6 @@ var thirdparyLogin = async (grantType) => {
     req.end();
   });
 };
-var classifyFiles = async (fileUrl) => {
-  const response = await thirdparyLogin("client_credentials");
-  const accessToken = response.data.accessToken;
-  const postData = JSON.stringify({
-    fileUrl,
-    splitPdf: 0,
-    trimPage: 0,
-    provider: "dify"
-  });
-  const config3 = (await ConfigManager.getInstance()).getOAuthConfig();
-  const options = {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Content-Length": Buffer.byteLength(postData),
-      "cloudx-auth": `Bearer ${accessToken}`,
-      "Authorization": `Basic ${config3.basicAuth}`,
-      "Lan": "en",
-      "Locale": "hk"
-    }
-  };
-  return new Promise((resolve3, reject) => {
-    console.log("classifyFiles request:", JSON.stringify(options));
-    const req = request(config3.host + "/api/onestep-jod/docs2png/classifyFile", options, (res) => {
-      let responseBody = "";
-      res.on("data", (chunk) => {
-        responseBody += chunk.toString();
-      });
-      res.on("end", () => {
-        resolve3(JSON.parse(responseBody));
-      });
-    });
-    req.on("error", (error) => {
-      reject(new Error(`Request failed: ${error.message}`));
-    });
-    req.on("timeout", () => {
-      req.destroy(new Error("Request timed out"));
-    });
-    req.setTimeout(1e3 * 120);
-    req.write(postData);
-    req.end();
-  });
-};
 var recFilesWithPull = async (fileUrls) => {
   const response = await recFiles(fileUrls);
   if (response.code === 200 && response.status == 0) {
@@ -710,6 +683,54 @@ var convertPdfToDocx = async (pdfUrl) => {
     req.end();
   });
 };
+var convertMarkdownToDoc = async (markdown, resultType) => {
+  const response = await thirdparyLogin("client_credentials");
+  const accessToken = response.data.accessToken;
+  const postData = JSON.stringify({
+    markdown,
+    resultType
+  });
+  const config3 = (await ConfigManager.getInstance()).getOAuthConfig();
+  const options = {
+    method: "POST",
+    // rejectUnauthorized: false,
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(postData),
+      "cloudx-auth": `Bearer ${accessToken}`,
+      "Authorization": `Basic ${config3.basicAuth}`,
+      "Lan": "en",
+      "Locale": "hk"
+    }
+  };
+  return new Promise((resolve3, reject) => {
+    logger.info("convertMarkdownToDoc request:", JSON.stringify(options));
+    const req = request(config3.host + "/api/onestep-jod/jodApi/generateDoc/markdown2Doc", options, (res) => {
+      let responseBody = "";
+      res.on("data", (chunk) => {
+        responseBody += chunk.toString();
+      });
+      res.on("end", () => {
+        logger.info("convertMarkdownToDoc response:", responseBody);
+        const jsonObject = JSON.parse(responseBody);
+        if (jsonObject.code == 200) {
+          resolve3(jsonObject.data);
+        } else {
+          reject(new Error(`Request failed: ${jsonObject.msg}`));
+        }
+      });
+    });
+    req.on("error", (error) => {
+      reject(new Error(`Request failed: ${error.message}`));
+    });
+    req.on("timeout", () => {
+      req.destroy(new Error("Request timed out"));
+    });
+    req.setTimeout(1e3 * 600);
+    req.write(postData);
+    req.end();
+  });
+};
 var convertPdfToMarkdownWithPull = async (pdfUrl) => {
   const transactionId = await convertPdfToMarkdown(pdfUrl);
   const pullResult = async function(transactionId2) {
@@ -876,6 +897,134 @@ var DocType = /* @__PURE__ */ ((DocType2) => {
   DocType2.nameContains = nameContains;
 })(DocType || (DocType = {}));
 
+// src/api/cherry/client.ts
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+var McpClient = class {
+  client;
+  logger;
+  constructor(client, logger2) {
+    this.client = client;
+    this.logger = logger2;
+  }
+  async CallTool(request2) {
+    const req = {
+      method: "tools/call",
+      params: {
+        name: request2.method,
+        arguments: request2.data
+      }
+    };
+    const response = {
+      isError: false,
+      content: []
+    };
+    let contents = [];
+    try {
+      const result = await this.client.callTool(req.params, CallToolResultSchema, { timeout: 60 * 1e3 });
+      response.isError = result.isError;
+      if (result.content && Array.isArray(result.content)) {
+        for (const content of result.content) {
+          switch (content.type) {
+            case "text":
+              contents.push({
+                type: content.type,
+                text: content.text || ""
+              });
+              break;
+            case "image":
+              contents.push({
+                type: content.type,
+                text: content.data || content.url || ""
+              });
+              break;
+            case "audio":
+              contents.push({
+                type: content.type,
+                text: content.data || content.url || ""
+              });
+              break;
+            default:
+              this.logger.error("not supported content: %j", content);
+              break;
+          }
+        }
+      }
+      response.content = contents;
+      return response;
+    } catch (err) {
+      this.logger.error("CallTool failed: %s", err instanceof Error ? err.message : String(err));
+      response.isError = true;
+      contents.push({
+        type: "text",
+        text: err instanceof Error ? err.message : String(err)
+      });
+      response.content = contents;
+      return response;
+    }
+  }
+};
+
+// src/api/cherry/api.ts
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { uuidv7 } from "zod/v4";
+var CherryClient = class {
+  config;
+  logger;
+  mcpServers;
+  mcpClients;
+  constructor(config3, logger2) {
+    this.config = config3;
+    this.logger = logger2;
+    this.mcpServers = {};
+    this.mcpClients = {};
+  }
+  async listMcpServer() {
+    this.logger.info(`Fetching list of MCP servers(http://${this.config.host}:${this.config.port}/v1/mcps)`);
+    const res = await fetch(`http://${this.config.host}:${this.config.port}/v1/mcps`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`
+      }
+    });
+    const data = await res.json();
+    return data;
+  }
+  async getMcpServerInfo(request2) {
+    const res = await fetch(`http://${this.config.host}:${this.config.port}/v1/mcps/${request2.serverId}`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.config.apiKey}`
+      }
+    });
+    const data = await res.json();
+    return data;
+  }
+  async callTool(request2) {
+    let mcpClient = this.mcpClients[request2.serverId];
+    if (mcpClient == null) {
+      const transport = new StreamableHTTPClientTransport(
+        new URL(`http://${this.config.host}:${this.config.port}/v1/mcps/${request2.serverId}/mcp`),
+        { requestInit: { headers: { Authorization: `Bearer ${this.config.apiKey}` } }, sessionId: uuidv7().toString() }
+      );
+      const client = new Client({
+        name: "oss-mcp-client",
+        version: "1.0.0"
+      }, {});
+      this.logger.info("Connecting to MCP server...");
+      await transport.start();
+      await client.connect(transport);
+      mcpClient = new McpClient(client, this.logger);
+    }
+    try {
+      return await mcpClient.CallTool(request2);
+    } catch (err) {
+      this.logger.error("CallTool failed: %s", err instanceof Error ? err.message : String(err));
+      throw err;
+    }
+  }
+};
+
 // src/server.ts
 var Logger = {
   log: (...args) => {
@@ -1049,11 +1198,14 @@ ${diff}${"`".repeat(numBackticks)}
 var OssMcpServer = class _OssMcpServer {
   server;
   sseTransport = null;
+  cherryClient = null;
+  static DEFAULT_CATEGORIES = ["\u53D1\u7968", "\u94F6\u884C\u6D41\u6C34", "\u9280\u884C\u8A62\u8B49\u51FD", "\u5408\u540C", "\u516C\u53F8\u57FA\u672C\u8CC7\u6599", "\u4E2A\u4EBA\u4FE1\u606F", "\u5176\u4ED6"];
+  static CLASSIFY_SERVER_ID;
   constructor() {
     this.server = new McpServer(
       {
         name: "onestep/filesystem-oss-mcp",
-        version: "1.2.5"
+        version: "1.2.7"
       },
       // 使用正确格式的capabilities配置
       {
@@ -1115,8 +1267,72 @@ var OssMcpServer = class _OssMcpServer {
   static async create() {
     const instance = new _OssMcpServer();
     await instance.registerTools();
+    setTimeout(async () => {
+      const config3 = (await ConfigManager.getInstance()).getApiConfig();
+      instance.cherryClient = new CherryClient(config3, logger);
+      instance.cherryClient.listMcpServer();
+    }, 5e3);
     return instance;
   }
+  async read_any_file(path3) {
+    if (!path3) {
+      throw new Error(`Invalid arguments for read_file: ${path3}`);
+    }
+    let temPcontent = "";
+    if (path3.startsWith("http")) {
+      const recResult = await recFilesWithPull([path3]);
+      if (recResult.code === 200) {
+        temPcontent = recResult.data;
+        return {
+          content: [{ type: "text", text: temPcontent }]
+        };
+      } else {
+        logger.error(`read  file ${path3} Error:`, recResult.msg);
+        throw new Error(`Server returned an error `);
+      }
+    }
+    const validPath = await validatePath(path3);
+    const fileExtension = fpath2.extname(validPath).toUpperCase();
+    if (TextDocType.isTextDocType(fileExtension)) {
+      temPcontent = await readFile(validPath, "utf-8");
+    } else {
+      const result = await this.aliOssUpload(validPath);
+      if (result.isError) {
+        console.error(`[aliOssUpload] Server returned an error`);
+        if (result.content && result.content.length > 0) {
+          result.content.forEach((contentItem) => {
+            if (contentItem.type === "text") {
+              console.error(`[aliOssUpload] Error detail: ${contentItem.text}`);
+            } else {
+              console.error(`[aliOssUpload] Error detail item:`, contentItem);
+            }
+          });
+        } else {
+          console.error(`[aliOssUpload] Server returned an unspecified error.`);
+        }
+        throw new Error(`Server returned an error `);
+      } else if (result.content && result.content.length > 0) {
+        console.log(`[aliOssUpload] Upload successful. Server response:${result.content[0].text}`);
+        const ossFile = JSON.parse(result.content[0].text);
+        if (ossFile.code === 0) {
+          const recResult = await recFilesWithPull([ossFile.url]);
+          if (recResult.code === 200) {
+            temPcontent = recResult.data;
+          } else {
+            console.error(`read  file ${validPath} Error:`, recResult.msg);
+          }
+        } else {
+          console.error(`upload file ${validPath} Error:`, ossFile.msg);
+        }
+      } else {
+        console.log(`[aliOssUpload] Tool call  completed, but server returned no specific content. Full result:`, result.result);
+        throw new Error(`Server returned an error `);
+      }
+    }
+    return {
+      content: [{ type: "text", text: temPcontent }]
+    };
+  }
   async registerTools() {
     logger.info("\u83B7\u53D6\u6240\u6709OSS\u914D\u7F6E...");
     const configs = await ossService.getConfigs();
@@ -1180,63 +1396,7 @@ ${configNames2.map((name) => `- ${name}`).join("\n")}`
       "\u8BFB\u53D6\u4EFB\u4F55\u6587\u4EF6\u5185\u5BB9",
       { path: z3.string().describe("\u6587\u4EF6\u8DEF\u5F84(\u53EF\u4EE5\u662F\u8FDC\u7A0Burl)") },
       async ({ path: path3 }) => {
-        if (!path3) {
-          throw new Error(`Invalid arguments for read_file: ${path3}`);
-        }
-        let temPcontent = "";
-        if (path3.startsWith("http")) {
-          const recResult = await recFilesWithPull([path3]);
-          if (recResult.code === 200) {
-            temPcontent = recResult.data;
-            return {
-              content: [{ type: "text", text: temPcontent }]
-            };
-          } else {
-            logger.error(`read  file ${path3} Error:`, recResult.msg);
-            throw new Error(`Server returned an error `);
-          }
-        }
-        const validPath = await validatePath(path3);
-        const fileExtension = fpath2.extname(validPath).toUpperCase();
-        if (TextDocType.isTextDocType(fileExtension)) {
-          temPcontent = await readFile(validPath, "utf-8");
-        } else {
-          const result = await this.aliOssUpload(validPath);
-          if (result.isError) {
-            console.error(`[aliOssUpload] Server returned an error`);
-            if (result.content && result.content.length > 0) {
-              result.content.forEach((contentItem) => {
-                if (contentItem.type === "text") {
-                  console.error(`[aliOssUpload] Error detail: ${contentItem.text}`);
-                } else {
-                  console.error(`[aliOssUpload] Error detail item:`, contentItem);
-                }
-              });
-            } else {
-              console.error(`[aliOssUpload] Server returned an unspecified error.`);
-            }
-            throw new Error(`Server returned an error `);
-          } else if (result.content && result.content.length > 0) {
-            console.log(`[aliOssUpload] Upload successful. Server response:${result.content[0].text}`);
-            const ossFile = JSON.parse(result.content[0].text);
-            if (ossFile.code === 0) {
-              const recResult = await recFilesWithPull([ossFile.url]);
-              if (recResult.code === 200) {
-                temPcontent = recResult.data;
-              } else {
-                console.error(`read  file ${validPath} Error:`, recResult.msg);
-              }
-            } else {
-              console.error(`upload file ${validPath} Error:`, ossFile.msg);
-            }
-          } else {
-            console.log(`[aliOssUpload] Tool call  completed, but server returned no specific content. Full result:`, result.result);
-            throw new Error(`Server returned an error `);
-          }
-        }
-        return {
-          content: [{ type: "text", text: temPcontent }]
-        };
+        return await this.read_any_file(path3);
       }
     );
     this.server.tool(
@@ -1251,9 +1411,9 @@ ${configNames2.map((name) => `- ${name}`).join("\n")}`
           paths.map(async (filePath) => {
             try {
               const validPath = await validatePath(filePath);
-              const content = await readFile(validPath, "utf-8");
+              const response = await this.read_any_file(validPath);
               return `${filePath}:
-${content}
+${response.content[0].text}
 `;
             } catch (error) {
               const errorMessage = error instanceof Error ? error.message : String(error);
@@ -1422,72 +1582,66 @@ ${ossService.getAllowedDirectories()?.join("\n")}`
       }
     );
     this.server.tool(
-      "classify_files_in_directory_by_file_content",
-      "\u6839\u636E\u6587\u4EF6\u5177\u4F53\u5185\u5BB9\u5BF9\u76EE\u5F55\u4E2D\u7684\u6587\u4EF6\u8FDB\u884C\u5206\u7C7B",
+      "classify_files_in_directory",
+      "\u5BF9\u76EE\u5F55\u4E2D\u7684\u6587\u4EF6\u8FDB\u884C\u5206\u7C7B",
       {
         originDirectory: z3.string().describe("Path to the directory to classify"),
-        newDirectory: z3.string().optional().describe("Path to the new directory after classification")
+        categories: z3.array(z3.string()).optional().describe("categories for classification")
       },
-      async ({ originDirectory, newDirectory }) => {
+      async ({ originDirectory, categories }) => {
         if (!originDirectory) {
           throw new Error(`Invalid arguments for classify_files_in_directory`);
         }
+        if (!categories) {
+          categories = _OssMcpServer.DEFAULT_CATEGORIES;
+        }
+        const newDirectory = await validatePath(originDirectory.split("/").slice(0, -1).join("_classified"));
         const files = await readdir(originDirectory, { withFileTypes: true, recursive: true });
         const resultMap = /* @__PURE__ */ new Map();
+        const fileNamePathMap = /* @__PURE__ */ new Map();
         for (const file of files) {
           const filePath = fpath2.join(file.parentPath, file.name);
           if (file.isFile()) {
-            const result = await this.aliOssUpload(filePath);
-            if (result.isError) {
-              console.error(`[aliOssUpload] Server returned an error`);
-              if (result.content && result.content.length > 0) {
-                result.content.forEach((contentItem) => {
-                  if (contentItem.type === "text") {
-                    console.error(`[aliOssUpload] Error detail: ${contentItem.text}`);
-                  } else {
-                    console.error(`[aliOssUpload] Error detail item:`, contentItem);
-                  }
-                });
-              } else {
-                console.error(`[aliOssUpload] Server returned an unspecified error.`);
-              }
-              throw new Error(`Server returned an error `);
-            } else if (result.content && result.content.length > 0) {
-              console.log(`[aliOssUpload] Upload successful. Server response:${result.content[0].text}`);
-              const ossFile = JSON.parse(result.content[0].text);
-              if (ossFile.code === 0) {
-                const classifyResult = await classifyFiles(ossFile.url);
-                if (classifyResult.code === 200) {
-                  console.log(`classify file ${filePath} Success:`, classifyResult.data);
-                  const docType = DocType.nameContains(classifyResult.data);
-                  if (resultMap.get(docType) != null) {
-                    resultMap.get(docType)?.push(filePath);
-                  } else {
-                    resultMap.set(docType, [filePath]);
-                  }
+            fileNamePathMap.set(file.name, filePath);
+          }
+        }
+        if (this.cherryClient?.config.enabled) {
+          if (Object.keys(this.cherryClient.mcpServers).length == 0) {
+            await this.cherryClient?.listMcpServer();
+          }
+          if (!_OssMcpServer.CLASSIFY_SERVER_ID) {
+            _OssMcpServer.CLASSIFY_SERVER_ID = Object.values(this.cherryClient.mcpServers).find((server) => server.name.indexOf("onestep\u516C\u53F8\u8BA2\u5355") > -1)?.id || "";
+            console.log(`[classify_files_in_directory] CLASSIFY_SERVER_ID: ${_OssMcpServer.CLASSIFY_SERVER_ID}`);
+          }
+        }
+        const response = await this.cherryClient?.callTool({
+          serverId: _OssMcpServer.CLASSIFY_SERVER_ID,
+          method: "batchClassifyFileNames",
+          data: { "fileNames": Array.from(fileNamePathMap.keys()), "categories": categories }
+        });
+        if (response?.isError) {
+          throw new Error(`can't classify files`);
+        } else {
+          const classifiedJson = response?.content[0].text;
+          const classifiedData = JSON.parse(classifiedJson);
+          categories.forEach((category) => {
+            mkdirSync(fpath2.join(newDirectory, category), { recursive: true });
+          });
+          classifiedData.classifiedByFileNames.forEach(async (item) => {
+            Object.keys(item).forEach(async (key) => {
+              const fileNames = item[key];
+              fileNames.forEach(async (fileName) => {
+                const newFilePath = fpath2.join(newDirectory, key, fileName);
+                const fileArray = resultMap.get(key);
+                if (fileArray) {
+                  fileArray.push(newFilePath);
                 } else {
-                  console.error(`classify file ${filePath} Error:`, classifyResult.msg);
-                  return {
-                    content: [{
-                      type: "text",
-                      text: `cannot classify file ${filePath} Error: ${classifyResult.msg}`
-                    }]
-                  };
+                  resultMap.set(key, [newFilePath]);
                 }
-              } else {
-                console.error(`upload file ${filePath} Error:`, ossFile.msg);
-                return {
-                  content: [{
-                    type: "text",
-                    text: `cannot classify file ${filePath} Error: ${ossFile.msg}`
-                  }]
-                };
-              }
-            } else {
-              console.log(`[aliOssUpload] Tool call  completed, but server returned no specific content. Full result:`, result.result);
-              throw new Error(`Server returned an error `);
-            }
-          }
+                await copyFile(fileNamePathMap.get(fileName), newFilePath);
+              });
+            });
+          });
         }
         return {
           content: [{
@@ -1693,6 +1847,60 @@ ${JSON.stringify(convertResult)}`
         };
       }
     );
+    this.server.tool(
+      "convert_markdown_to_pdf",
+      "markdown\u8F6C\u6362\u6210pdf\u6587\u4EF6",
+      { path: z3.string().describe("\u6587\u4EF6\u8DEF\u5F84(\u53EF\u4EE5\u662F\u8FDC\u7A0Burl)") },
+      async ({ path: path3 }) => {
+        if (!path3) {
+          throw new Error(`Invalid arguments for convert_markdown_to_pdf tool`);
+        }
+        let content = "";
+        if (path3.startsWith("http")) {
+          const resp = await this.read_any_file(path3);
+          content = resp.content[0].text ?? "";
+        } else {
+          const validPath = await validatePath(path3);
+          content = await readFile(validPath, "utf-8");
+        }
+        const buffer = Buffer.from(content, "utf-8");
+        const base64String = buffer.toString("base64");
+        const convertResult = await convertMarkdownToDoc(base64String, 1);
+        return {
+          content: [{
+            type: "text",
+            text: `${convertResult}`
+          }]
+        };
+      }
+    );
+    this.server.tool(
+      "convert_markdown_to_docx",
+      "markdown\u8F6C\u6362\u6210docx\u6587\u4EF6",
+      { path: z3.string().describe("\u6587\u4EF6\u8DEF\u5F84(\u53EF\u4EE5\u662F\u8FDC\u7A0Burl)") },
+      async ({ path: path3 }) => {
+        if (!path3) {
+          throw new Error(`Invalid arguments for convert_markdown_to_docx tool`);
+        }
+        let content = "";
+        if (path3.startsWith("http")) {
+          const resp = await this.read_any_file(path3);
+          content = resp.content[0].text ?? "";
+        } else {
+          const validPath = await validatePath(path3);
+          content = await readFile(validPath, "utf-8");
+        }
+        const buffer = Buffer.from(content, "utf-8");
+        const base64String = buffer.toString("base64");
+        const convertResult = await convertMarkdownToDoc(base64String, 0);
+        return {
+          content: [{
+            type: "text",
+            text: `${convertResult}`
+          }]
+        };
+      }
+    );
   }
   async connect(transport) {
     try {