gokuai-user-mcp 1.0.2

package/dist/index.js

@@ -0,0 +1,840 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/library.ts
+import { z } from "zod";
+
+// src/client.ts
+var GokuaiClient = class {
+  token;
+  authType;
+  apiHost;
+  constructor(apiHost2, authType2, token2) {
+    this.token = token2;
+    this.authType = authType2;
+    this.apiHost = apiHost2;
+  }
+  get authHeaders() {
+    return {
+      "Authorization": `Bearer ${this.token}`,
+      "X-Auth-Type": this.authType
+    };
+  }
+  buildUrl(path, params) {
+    const url = new URL(path, this.apiHost);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const response = await fetch(url, {
+      headers: this.authHeaders
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+    return response.json();
+  }
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value !== void 0 && value !== null) {
+        params.set(key, String(value));
+      }
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...this.authHeaders
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`HTTP ${response.status}: ${text}`);
+    }
+    return response.json();
+  }
+  async getLibraries() {
+    const resp = await this.get("/m-api/1/account/mount");
+    return resp.list || [];
+  }
+  async listFiles(mountId, fullpath, start, size) {
+    return this.get("/m-api/1/file/ls", {
+      mount_id: mountId,
+      fullpath: fullpath || "",
+      start,
+      size
+    });
+  }
+  async getFileInfo(mountId, opts) {
+    return this.get("/m-api/2/file/info", {
+      mount_id: mountId,
+      fullpath: opts.fullpath,
+      hash: opts.hash
+    });
+  }
+  async searchFiles(keyword, mountId, opts) {
+    const params = {
+      keyword,
+      mount_id: mountId,
+      start: opts?.start,
+      size: opts?.size
+    };
+    if (opts?.scope && opts.scope.length > 0) {
+      params.scope = opts.scope.join("|");
+    }
+    return this.get("/m-api/2/file/search", params);
+  }
+  async getDownloadUrl(mountId, opts) {
+    return this.get("/m-api/2/file/open", {
+      mount_id: mountId,
+      fullpath: opts.fullpath,
+      hash: opts.hash
+    });
+  }
+  async getPreviewUrl(mountId, opts, watermark) {
+    return this.get("/m-api/2/file/preview_url", {
+      mount_id: mountId,
+      fullpath: opts.fullpath,
+      hash: opts.hash,
+      watermark
+    });
+  }
+  async getFolderAttribute(mountId, opts) {
+    return this.get("/m-api/2/file/attribute", {
+      mount_id: mountId,
+      fullpath: opts.fullpath,
+      hash: opts.hash
+    });
+  }
+  async createLibrary(name, entId, capacity, storagePoint) {
+    return this.post("/m-api/1/library/create", {
+      name,
+      ent_id: entId,
+      capacity,
+      storage_point: storagePoint
+    });
+  }
+  async createFolder(mountId, fullpath, overwrite) {
+    return this.post("/m-api/2/file/create_folder", {
+      mount_id: mountId,
+      fullpath,
+      overwrite
+    });
+  }
+  async copyFile(mountId, fullpath, targetFullpath, opts) {
+    return this.post("/m-api/1/file/copy", {
+      mount_id: mountId,
+      fullpath,
+      target_fullpath: targetFullpath,
+      target_mount_id: opts?.target_mount_id
+    });
+  }
+  async moveFile(mountId, fullpath, targetFullpath) {
+    return this.post("/m-api/1/file/move", {
+      mount_id: mountId,
+      fullpath,
+      target_fullpath: targetFullpath
+    });
+  }
+  async renameFile(mountId, fullpath, newname) {
+    return this.post("/m-api/1/file/rename", {
+      mount_id: mountId,
+      fullpath,
+      newname
+    });
+  }
+  async deleteFile(mountId, fullpath) {
+    return this.post("/m-api/1/file/del", {
+      mount_id: mountId,
+      fullpath
+    });
+  }
+  async listFavorites(favId, start, size) {
+    return this.get("/m-api/1/favorites/get_files", {
+      fav_id: favId,
+      start,
+      size
+    });
+  }
+  async addFavorite(mountId, fullpath, favId) {
+    return this.post("/m-api/1/favorites/add_file", {
+      mount_id: mountId,
+      fullpath,
+      fav_id: favId
+    });
+  }
+  async removeFavorite(mountId, fullpath, favId) {
+    return this.post("/m-api/1/favorites/del_file", {
+      mount_id: mountId,
+      fullpath,
+      fav_id: favId
+    });
+  }
+};
+
+// src/tools/library.ts
+function registerLibraryTools(server2, apiHost2, authType2, token2) {
+  const client = new GokuaiClient(apiHost2, authType2, token2);
+  server2.tool(
+    "list_libraries",
+    "List all cloud libraries (\u4E91\u5E93) accessible to the current user. Returns library name, mount_id, storage usage, and member count.",
+    {},
+    async () => {
+      try {
+        const libraries = await client.getLibraries();
+        if (!libraries || libraries.length === 0) {
+          return {
+            content: [{ type: "text", text: "No libraries found." }]
+          };
+        }
+        const formatted = libraries.map((lib) => {
+          const usedGB = (lib.size_org_use / (1024 * 1024 * 1024)).toFixed(2);
+          const totalGB = (lib.size_org_total / (1024 * 1024 * 1024)).toFixed(2);
+          return [
+            `\u{1F4C1} ${lib.org_name}`,
+            `   Ent ID: ${lib.ent_id}`,
+            `   Org ID: ${lib.org_id}`,
+            `   Mount ID: ${lib.mount_id}`,
+            `   Type: ${lib.org_type}`,
+            `   Members: ${lib.member_count}`,
+            `   Owner Member ID: ${lib.owner_member_id}`,
+            `   Logo: ${lib.org_logo_url || "-"}`,
+            `   Storage: ${usedGB} GB / ${totalGB} GB`,
+            `   Storage Point: ${lib.storage_point || "-"}`,
+            `   External Access: ${lib.storage_ethernet}`
+          ].join("\n");
+        });
+        return {
+          content: [{ type: "text", text: formatted.join("\n\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "create_library",
+    "Create a new cloud library (\u4E91\u5E93). User must have permission to create libraries. Returns org_id, mount_id, and storage_point.",
+    {
+      name: z.string().describe("Library name"),
+      ent_id: z.number().describe("Enterprise ID (\u4F01\u4E1AID)"),
+      capacity: z.number().optional().describe("Storage capacity limit in bytes, -1 for unlimited"),
+      storage_point: z.string().optional().describe("Storage point, defaults to system default if not specified")
+    },
+    async ({ name, ent_id, capacity, storage_point }) => {
+      try {
+        const result = await client.createLibrary(name, ent_id, capacity, storage_point);
+        const info = [
+          `\u2705 Library created successfully: ${name}`,
+          `   Org ID: ${result.org_id}`,
+          `   Mount ID: ${result.mount_id}`,
+          `   Storage Point: ${result.storage_point || "-"}`
+        ];
+        return {
+          content: [{ type: "text", text: info.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/files.ts
+import { z as z2 } from "zod";
+
+// ../shared/dist/utils.js
+function formatFileSize(bytes) {
+  if (bytes === 0)
+    return "0 B";
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(2)} ${units[i]}`;
+}
+
+// src/tools/files.ts
+function registerFileTools(server2, apiHost2, authType2, token2) {
+  const client = new GokuaiClient(apiHost2, authType2, token2);
+  server2.tool(
+    "list_files",
+    "List files and folders in a specified path within a cloud library. Returns file names, sizes, types, and modification info.",
+    {
+      mount_id: z2.number().describe("The mount ID of the library"),
+      path: z2.string().optional().describe('The folder path to list, defaults to root ("")'),
+      start: z2.number().optional().describe("Pagination start index"),
+      size: z2.number().optional().describe("Number of items to return, defaults to 100")
+    },
+    async ({ mount_id, path, start, size }) => {
+      try {
+        const result = await client.listFiles(mount_id, path || "", start, size || 100);
+        if (!result.list || result.list.length === 0) {
+          return {
+            content: [{ type: "text", text: `No files found. Total count: ${result.count}` }]
+          };
+        }
+        const header = `Total: ${result.count} items
+${"\u2500".repeat(50)}`;
+        const formatted = result.list.map((file) => {
+          const isDir = file.dir === 1;
+          const icon = isDir ? "\u{1F4C1}" : "\u{1F4C4}";
+          const sizeStr = isDir ? "-" : formatFileSize(file.filesize);
+          const created = new Date(file.create_dateline * 1e3).toLocaleString("zh-CN");
+          const modified = new Date(file.last_dateline * 1e3).toLocaleString("zh-CN");
+          return [
+            `${icon} ${file.filename}`,
+            `   Hash: ${file.hash}`,
+            `   Mount ID: ${file.mount_id}`,
+            `   Type: ${isDir ? "Folder" : "File"}`,
+            `   Path: ${file.fullpath}`,
+            `   File Hash: ${file.filehash || "-"}`,
+            `   Size: ${sizeStr}`,
+            `   Created: ${created} by ${file.create_member_name} (ID: ${file.create_member_id})`,
+            `   Modified: ${modified} by ${file.last_member_name} (ID: ${file.last_member_id})`,
+            `   Thumbnail: ${file.thumbnail || "-"}`,
+            `   Lock: ${file.lock ? "Yes" : "No"}`
+          ].join("\n");
+        });
+        return {
+          content: [{ type: "text", text: `${header}
+${formatted.join("\n")}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get_file_info",
+    "Get detailed information about a specific file or folder. Provide either fullpath or hash to identify the file.",
+    {
+      mount_id: z2.number().describe("The mount ID of the library"),
+      fullpath: z2.string().optional().describe("Full path of the file"),
+      hash: z2.string().optional().describe("Hash of the file")
+    },
+    async ({ mount_id, fullpath, hash }) => {
+      try {
+        if (!fullpath && !hash) {
+          return {
+            content: [{ type: "text", text: "Error: Either fullpath or hash must be provided" }],
+            isError: true
+          };
+        }
+        const result = await client.getFileInfo(mount_id, { fullpath, hash });
+        const isDir = result.dir === 1;
+        const info = [
+          `Name: ${result.filename}`,
+          `Path: ${result.fullpath}`,
+          `Hash: ${result.hash}`,
+          `Mount ID: ${result.mount_id}`,
+          `Type: ${isDir ? "Folder" : "File"}`,
+          `Size: ${isDir ? "-" : formatFileSize(result.filesize)}`,
+          `File Hash: ${result.filehash || "-"}`,
+          `Created: ${new Date(result.create_dateline * 1e3).toLocaleString("zh-CN")} by ${result.create_member_name} (ID: ${result.create_member_id})`,
+          `Modified: ${new Date(result.last_dateline * 1e3).toLocaleString("zh-CN")} by ${result.last_member_name} (ID: ${result.last_member_id})`,
+          `Lock: ${result.lock ? "Yes" : "No"}`
+        ];
+        if (result.preview) {
+          info.push(`Preview: ${result.preview}`);
+        }
+        if (result.thumbnail) {
+          info.push(`Thumbnail: ${result.thumbnail}`);
+        }
+        return {
+          content: [{ type: "text", text: info.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "search_files",
+    "Search for files by keyword across a library or globally. Use mount_id=0 for global search.",
+    {
+      keyword: z2.string().describe("Search keyword"),
+      mount_id: z2.number().describe("The mount ID of the library, use 0 for global search"),
+      scope: z2.array(z2.string()).optional().describe("Search scope paths, separated by |"),
+      start: z2.number().optional().describe("Pagination start index"),
+      size: z2.number().optional().describe("Number of results to return")
+    },
+    async ({ keyword, mount_id, scope, start, size }) => {
+      try {
+        const result = await client.searchFiles(keyword, mount_id, { scope, start, size });
+        if (!result.list || result.list.length === 0) {
+          return {
+            content: [{ type: "text", text: `No files found matching "${keyword}". Total: ${result.count}` }]
+          };
+        }
+        const header = `Search results for "${keyword}" - Total: ${result.count}
+${"\u2500".repeat(50)}`;
+        const formatted = result.list.map((file) => {
+          const isDir = file.dir === 1;
+          const icon = isDir ? "\u{1F4C1}" : "\u{1F4C4}";
+          const sizeStr = isDir ? "-" : formatFileSize(file.filesize);
+          const created = new Date(file.create_dateline * 1e3).toLocaleString("zh-CN");
+          const modified = new Date(file.last_dateline * 1e3).toLocaleString("zh-CN");
+          return [
+            `${icon} ${file.filename}`,
+            `   Hash: ${file.hash}`,
+            `   Mount ID: ${file.mount_id}`,
+            `   Type: ${isDir ? "Folder" : "File"}`,
+            `   Path: ${file.fullpath}`,
+            `   File Hash: ${file.filehash || "-"}`,
+            `   Size: ${sizeStr}`,
+            `   Created: ${created} by ${file.create_member_name} (ID: ${file.create_member_id})`,
+            `   Modified: ${modified} by ${file.last_member_name} (ID: ${file.last_member_id})`,
+            `   Thumbnail: ${file.thumbnail || "-"}`,
+            `   Lock: ${file.lock ? "Yes" : "No"}`
+          ].join("\n");
+        });
+        return {
+          content: [{ type: "text", text: `${header}
+${formatted.join("\n")}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get_folder_count",
+    "Get the number of files and sub-folders inside a folder. The count includes all descendants recursively. Provide either fullpath or hash.",
+    {
+      mount_id: z2.number().describe("The mount ID of the library"),
+      fullpath: z2.string().optional().describe("Full path of the folder"),
+      hash: z2.string().optional().describe("Hash of the folder")
+    },
+    async ({ mount_id, fullpath, hash }) => {
+      try {
+        if (!fullpath && !hash) {
+          return {
+            content: [{ type: "text", text: "Error: Either fullpath or hash must be provided" }],
+            isError: true
+          };
+        }
+        const result = await client.getFolderAttribute(mount_id, { fullpath, hash });
+        const info = [
+          `\u{1F4CA} Folder Statistics:`,
+          `   Files: ${result.file_count}`,
+          `   Sub-folders: ${result.folder_count}`,
+          `   Total: ${result.file_count + result.folder_count}`
+        ];
+        return {
+          content: [{ type: "text", text: info.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/download.ts
+import { z as z3 } from "zod";
+function registerDownloadTools(server2, apiHost2, authType2, token2) {
+  const client = new GokuaiClient(apiHost2, authType2, token2);
+  server2.tool(
+    "get_download_url",
+    "Get a temporary download URL for a file (valid for 10 minutes). Provide either fullpath or hash.",
+    {
+      mount_id: z3.number().describe("The mount ID of the library"),
+      fullpath: z3.string().optional().describe("Full path of the file"),
+      hash: z3.string().optional().describe("Hash of the file")
+    },
+    async ({ mount_id, fullpath, hash }) => {
+      try {
+        if (!fullpath && !hash) {
+          return {
+            content: [{ type: "text", text: "Error: Either fullpath or hash must be provided" }],
+            isError: true
+          };
+        }
+        const result = await client.getDownloadUrl(mount_id, { fullpath, hash });
+        const info = [
+          `Download URLs (valid for 10 minutes):`,
+          ...result.uris.map((uri, i) => `  ${i + 1}. ${uri}`),
+          ``,
+          `File Hash: ${result.filehash}`,
+          `File Size: ${formatFileSize(result.filesize)}`
+        ];
+        return {
+          content: [{ type: "text", text: info.join("\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "read_file_content",
+    "Read the text content of a file from the cloud library. Downloads and returns file content as text. Best for text files (code, documents, configs). Provide either fullpath or hash.",
+    {
+      mount_id: z3.number().describe("The mount ID of the library"),
+      fullpath: z3.string().optional().describe("Full path of the file"),
+      hash: z3.string().optional().describe("Hash of the file"),
+      max_size: z3.number().optional().describe("Maximum bytes to read, defaults to 100000")
+    },
+    async ({ mount_id, fullpath, hash, max_size }) => {
+      try {
+        if (!fullpath && !hash) {
+          return {
+            content: [{ type: "text", text: "Error: Either fullpath or hash must be provided" }],
+            isError: true
+          };
+        }
+        const maxBytes = max_size || 1e5;
+        const downloadInfo = await client.getDownloadUrl(mount_id, { fullpath, hash });
+        if (!downloadInfo.uris || downloadInfo.uris.length === 0) {
+          return {
+            content: [{ type: "text", text: "Error: No download URL available for this file" }],
+            isError: true
+          };
+        }
+        if (downloadInfo.filesize > maxBytes * 10) {
+          return {
+            content: [{
+              type: "text",
+              text: `Warning: File is very large (${formatFileSize(downloadInfo.filesize)}). Consider using get_download_url instead to download it manually.`
+            }]
+          };
+        }
+        const response = await fetch(downloadInfo.uris[0]);
+        if (!response.ok) {
+          throw new Error(`Failed to download file: HTTP ${response.status}`);
+        }
+        const buffer = await response.arrayBuffer();
+        const bytes = new Uint8Array(buffer);
+        let content;
+        let truncated = false;
+        if (bytes.length > maxBytes) {
+          content = new TextDecoder("utf-8", { fatal: false }).decode(bytes.slice(0, maxBytes));
+          truncated = true;
+        } else {
+          content = new TextDecoder("utf-8", { fatal: false }).decode(bytes);
+        }
+        let result = content;
+        if (truncated) {
+          result += `
+
+--- Content truncated at ${formatFileSize(maxBytes)} (total file size: ${formatFileSize(downloadInfo.filesize)}) ---`;
+        }
+        return {
+          content: [{ type: "text", text: result }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "get_preview_url",
+    "Get a preview URL for a file (for documents, images, etc.). Provide either fullpath or hash.",
+    {
+      mount_id: z3.number().describe("The mount ID of the library"),
+      fullpath: z3.string().optional().describe("Full path of the file"),
+      hash: z3.string().optional().describe("Hash of the file"),
+      watermark: z3.string().optional().describe("Watermark text to add to the preview")
+    },
+    async ({ mount_id, fullpath, hash, watermark }) => {
+      try {
+        if (!fullpath && !hash) {
+          return {
+            content: [{ type: "text", text: "Error: Either fullpath or hash must be provided" }],
+            isError: true
+          };
+        }
+        const result = await client.getPreviewUrl(mount_id, { fullpath, hash }, watermark);
+        return {
+          content: [{ type: "text", text: `Preview URL: ${result.url}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/manage.ts
+import { z as z4 } from "zod";
+function registerManageTools(server2, apiHost2, authType2, token2) {
+  const client = new GokuaiClient(apiHost2, authType2, token2);
+  server2.tool(
+    "create_folder",
+    "Create a new folder in the cloud library at the specified path.",
+    {
+      mount_id: z4.number().describe("The mount ID of the library"),
+      fullpath: z4.string().describe("Full path of the folder to create, e.g. '/folder/subfolder'")
+    },
+    async ({ mount_id, fullpath }) => {
+      try {
+        const result = await client.createFolder(mount_id, fullpath);
+        return {
+          content: [{ type: "text", text: `Folder created successfully: ${fullpath}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "copy_file",
+    "Copy file(s) to a target path. Use '|' to separate multiple source paths for batch copy.",
+    {
+      mount_id: z4.number().describe("The mount ID of the source library"),
+      fullpath: z4.string().describe("Full path of the source file(s), use '|' to separate multiple paths"),
+      target_mount_id: z4.number().optional().describe("The mount ID of the target library (if different from source)"),
+      target_fullpath: z4.string().describe("Full path of the target location")
+    },
+    async ({ mount_id, fullpath, target_mount_id, target_fullpath }) => {
+      try {
+        const opts = target_mount_id ? { target_mount_id } : void 0;
+        const result = await client.copyFile(mount_id, fullpath, target_fullpath, opts);
+        return {
+          content: [{ type: "text", text: `File copied successfully.
+From: ${fullpath}
+To: ${target_fullpath}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "move_file",
+    "Move file(s) to a target path. Use '|' to separate multiple source paths for batch move.",
+    {
+      mount_id: z4.number().describe("The mount ID of the library"),
+      fullpath: z4.string().describe("Full path of the source file(s), use '|' to separate multiple paths"),
+      target_fullpath: z4.string().describe("Full path of the target location")
+    },
+    async ({ mount_id, fullpath, target_fullpath }) => {
+      try {
+        const result = await client.moveFile(mount_id, fullpath, target_fullpath);
+        return {
+          content: [{ type: "text", text: `File moved successfully.
+From: ${fullpath}
+To: ${target_fullpath}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "rename_file",
+    "Rename a file or folder in the cloud library.",
+    {
+      mount_id: z4.number().describe("The mount ID of the library"),
+      fullpath: z4.string().describe("Full path of the file to rename"),
+      newname: z4.string().describe("New name for the file")
+    },
+    async ({ mount_id, fullpath, newname }) => {
+      try {
+        const result = await client.renameFile(mount_id, fullpath, newname);
+        return {
+          content: [{ type: "text", text: `File renamed successfully.
+Path: ${fullpath}
+New name: ${newname}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "delete_file",
+    "Delete a file or folder from the cloud library. This action cannot be undone.",
+    {
+      mount_id: z4.number().describe("The mount ID of the library"),
+      fullpath: z4.string().describe("Full path of the file or folder to delete")
+    },
+    async ({ mount_id, fullpath }) => {
+      try {
+        const result = await client.deleteFile(mount_id, fullpath);
+        return {
+          content: [{ type: "text", text: `File deleted successfully: ${fullpath}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/favorites.ts
+import { z as z5 } from "zod";
+function registerFavoritesTools(server2, apiHost2, authType2, token2) {
+  const client = new GokuaiClient(apiHost2, authType2, token2);
+  server2.tool(
+    "list_favorites",
+    "List files in the user's favorites collection.",
+    {
+      start: z5.number().optional().describe("Pagination start index"),
+      size: z5.number().optional().describe("Number of items to return")
+    },
+    async ({ start, size }) => {
+      try {
+        const result = await client.listFavorites(void 0, start, size);
+        if (!result.list || result.list.length === 0) {
+          return {
+            content: [{ type: "text", text: "No favorites found." }]
+          };
+        }
+        const header = `Favorites - Total: ${result.count}
+${"\u2500".repeat(50)}`;
+        const formatted = result.list.map((file) => {
+          const isDir = file.dir === 1;
+          const icon = isDir ? "\u{1F4C1}" : "\u{1F4C4}";
+          const sizeStr = isDir ? "-" : formatFileSize(file.filesize);
+          const created = new Date(file.create_dateline * 1e3).toLocaleString("zh-CN");
+          const modified = new Date(file.last_dateline * 1e3).toLocaleString("zh-CN");
+          return [
+            `${icon} ${file.filename}`,
+            `   Hash: ${file.hash}`,
+            `   Mount ID: ${file.mount_id}`,
+            `   Type: ${isDir ? "Folder" : "File"}`,
+            `   Path: ${file.fullpath}`,
+            `   File Hash: ${file.filehash || "-"}`,
+            `   Size: ${sizeStr}`,
+            `   Created: ${created} by ${file.create_member_name} (ID: ${file.create_member_id})`,
+            `   Modified: ${modified} by ${file.last_member_name} (ID: ${file.last_member_id})`
+          ].join("\n");
+        });
+        return {
+          content: [{ type: "text", text: `${header}
+${formatted.join("\n")}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "add_favorite",
+    "Add a file or folder to the user's favorites.",
+    {
+      mount_id: z5.number().describe("The mount ID of the library"),
+      fullpath: z5.string().describe("Full path of the file to add to favorites")
+    },
+    async ({ mount_id, fullpath }) => {
+      try {
+        const result = await client.addFavorite(mount_id, fullpath);
+        return {
+          content: [{ type: "text", text: `Added to favorites: ${fullpath}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.tool(
+    "remove_favorite",
+    "Remove a file or folder from the user's favorites.",
+    {
+      mount_id: z5.number().describe("The mount ID of the library"),
+      fullpath: z5.string().describe("Full path of the file to remove from favorites")
+    },
+    async ({ mount_id, fullpath }) => {
+      try {
+        const result = await client.removeFavorite(mount_id, fullpath);
+        return {
+          content: [{ type: "text", text: `Removed from favorites: ${fullpath}
+${JSON.stringify(result, null, 2)}` }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/index.ts
+var token = process.env.GOKUAI_TOKEN;
+if (!token) {
+  console.error("Error: GOKUAI_TOKEN environment variable is required");
+  process.exit(1);
+}
+var authType = process.env.GOKUAI_AUTH_TYPE || "mcp";
+var apiHost = process.env.GOKUAI_API_HOST || "https://yk3.gokuai.com";
+var server = new McpServer({
+  name: "gokuai-user-mcp",
+  version: "1.0.0"
+});
+registerLibraryTools(server, apiHost, authType, token);
+registerFileTools(server, apiHost, authType, token);
+registerDownloadTools(server, apiHost, authType, token);
+registerManageTools(server, apiHost, authType, token);
+registerFavoritesTools(server, apiHost, authType, token);
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "gokuai-user-mcp",
+  "version": "1.0.2",
+  "description": "MCP Server for Gokuai Cloud Storage (User API)",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "gokuai-user-mcp": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "start": "node dist/index.js",
+    "inspector": "npx @modelcontextprotocol/inspector node dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "gokuai",
+    "cloud-storage",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@gokuai/shared": "*",
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  }
+}