@lessie/mcp-server 0.0.6 → 0.1.0

package/dist/index.js

@@ -1,115 +1,77 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { readFileSync } from "node:fs";
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-const pkg = require("../package.json");
-function loadInstructions() {
-    try {
-        const raw = readFileSync(new URL("../SKILL.md", import.meta.url), "utf-8");
-        return raw.replace(/^---[\s\S]*?---\n*/, "").trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-// ── 环境变量 ──────────────────────────────────────────────────────────────────
-const BASE_URL = process.env.LESSIE_BASE_URL || 'https://www.lessie.ai/prod-api';
-const API_KEY = process.env.LESSIE_API_KEY;
-if (!BASE_URL) {
-    console.error("Error: LESSIE_BASE_URL is not set");
-    process.exit(1);
-}
-if (!API_KEY) {
-    console.error("Error: LESSIE_API_KEY is not set");
-    process.exit(1);
-}
-let jwtCache = null;
 /**
- * 获取有效的 JWT token。
- * 若缓存不存在或距过期不足 60 秒，则重新向 /auth/token 换取。
+ * 入口：创建 MCP Server，注册工具，启动 stdio 传输。
+ *
+ * 工具路由策略：
+ *   authorize   → 发起 OAuth 授权流程
+ *   use_lessie  → 代理调用远程 MCP Server 上的工具
  */
-async function getJwt() {
-    const now = Date.now();
-    const REFRESH_BEFORE_MS = 60 * 1000;
-    if (jwtCache && jwtCache.expiry - now > REFRESH_BEFORE_MS) {
-        return jwtCache.token;
-    }
-    const res = await fetch(`${BASE_URL}/auth/token`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ apiKey: API_KEY }),
-    });
-    if (!res.ok) {
-        throw new Error(`Failed to exchange API key for JWT: ${res.status} ${res.statusText} ${BASE_URL}/auth/token`);
-    }
-    const body = (await res.json());
-    if (!body.data?.token) {
-        throw new Error(`/auth/token response missing data.token. Got: ${JSON.stringify(body)}`);
-    }
-    jwtCache = {
-        token: body.data.token,
-        expiry: now + body.data.expiresIn * 1000,
-    };
-    return jwtCache.token;
-}
-async function api(method, path, body) {
-    const token = await getJwt();
-    const res = await fetch(`${BASE_URL}${path}`, {
-        method,
-        headers: {
-            "Authorization": token,
-            "Content-Type": "application/json",
-        },
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-    });
-    if (!res.ok) {
-        const text = await res.text().catch(() => "");
-        throw new Error(`API error ${res.status} ${res.statusText}${text ? `: ${text}` : ""}`);
-    }
-    if (res.status === 204)
-        return undefined;
-    const wrapper = (await res.json());
-    return wrapper.data;
-}
-// ── 工具结果辅助函数 ───────────────────────────────────────────────────────────
-function textResult(data) {
-    return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-    };
-}
-// ── MCP Server ────────────────────────────────────────────────────────────────
-const server = new McpServer({
-    name: "lessie-mcp",
-    version: pkg.version,
-}, {
+import "./process-handlers.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { REMOTE_MCP_URL, pkg, loadInstructions } from "./config.js";
+import { connectToRemote, listRemoteTools, isRemoteConnected, setOnAuthComplete, setOnAuthError } from "./remote.js";
+import { registerTools } from "./tools.js";
+console.error("[lessie] Modules loaded");
+const server = new McpServer({ name: "lessie-mcp", version: pkg.version }, {
+    capabilities: { tools: { listChanged: true } },
     instructions: loadInstructions(),
 });
-// ── 工具定义 ──────────────────────────────────────────────────────────────────
-// 命名规范：下划线分隔，动词开头（如 list_xxx、get_xxx、create_xxx）。
-// 写入类工具在 description 中注明"执行前请向用户确认"。
-server.tool("get_jwt", "获取当前有效的 JWT token，可用于直接调用 Lessie API。返回 token 字符串和剩余有效时间。", {}, async () => {
-    const token = await getJwt();
-    const remainingMs = jwtCache ? jwtCache.expiry - Date.now() : 0;
-    return textResult({
-        token,
-        remainingSeconds: Math.max(0, Math.floor(remainingMs / 1000)),
-    });
-});
-server.tool("get_account_info", "查看当前 Lessie 账号的详细信息，包括用户名、邮箱、账号状态、角色、邀请码等。", {}, async () => {
-    const data = await api("GET", "/agent/account/info");
-    return textResult(data);
-});
+registerTools(server);
 // ── 启动 ──────────────────────────────────────────────────────────────────────
+console.error("[lessie] Creating transport...");
 const transport = new StdioServerTransport();
+console.error("[lessie] Connecting server...");
 await server.connect(transport);
-await getJwt();
-server.sendLoggingMessage({
-    level: "info",
-    logger: "lessie",
-    data: "Token acquired successfully",
+console.error("[lessie] Server connected, setting up auth callback...");
+setOnAuthComplete((toolCount) => {
+    server.sendLoggingMessage({
+        level: "info",
+        logger: "lessie",
+        data: `Authorization successful. Connected to remote MCP server. Discovered ${toolCount} tools.`,
+    });
+    server.sendToolListChanged();
+});
+setOnAuthError(({ code, message }) => {
+    const hint = code === "timeout"
+        ? "Please call the 'authorize' tool again to generate a new authorization link."
+        : code === "port_in_use"
+            ? `Port conflict detected. Check for processes using the callback port, then call 'authorize' to retry.`
+            : "Please call the 'authorize' tool to retry.";
+    server.sendLoggingMessage({
+        level: "error",
+        logger: "lessie",
+        data: `Authorization failed: ${message}. ${hint}`,
+    });
 });
+console.error("[lessie] Connecting to remote...");
+try {
+    await connectToRemote();
+    console.error("[lessie] connectToRemote() completed, connected:", isRemoteConnected());
+    if (isRemoteConnected()) {
+        const remoteTools = await listRemoteTools();
+        server.sendLoggingMessage({
+            level: "info",
+            logger: "lessie",
+            data: `Connected to remote MCP server (${REMOTE_MCP_URL}). Discovered ${remoteTools.length} tools.`,
+        });
+    }
+    else if (REMOTE_MCP_URL) {
+        server.sendLoggingMessage({
+            level: "warning",
+            logger: "lessie",
+            data: "Remote MCP server requires authorization. Use the 'authorize' tool to connect.",
+        });
+    }
+}
+catch (err) {
+    console.error("[lessie] connectToRemote() threw:", err);
+    server.sendLoggingMessage({
+        level: "error",
+        logger: "lessie",
+        data: `Failed to connect to remote MCP server: ${err}`,
+    });
+}
+console.error("[lessie] Startup complete");
 server.sendLoggingMessage({
     level: "info",
     logger: "lessie",

package/dist/process-handlers.js

@@ -0,0 +1,10 @@
+process.on("uncaughtException", (err) => {
+    console.error("[lessie] Uncaught exception:", err);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error("[lessie] Unhandled rejection:", reason);
+});
+process.on("exit", (code) => {
+    console.error(`[lessie] Process exiting with code ${code}`);
+});
+export {};

package/dist/remote.js

@@ -0,0 +1,267 @@
+/**
+ * 远程 MCP 代理客户端。
+ *
+ * 以 MCP Client 身份连接远程 MCP Server，发现其工具并代理调用。
+ * 传输层使用 Streamable HTTP。
+ *
+ * 鉴权策略：
+ *   1. 启动时检查本地缓存令牌，有才尝试连接，无则跳过
+ *   2. 用户通过 authorize 工具触发 OAuth 流程（直接调用 SDK auth()）
+ *   3. 用户在浏览器完成登录后，后台自动交换令牌并连接
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
+import { REMOTE_MCP_URL, pkg } from "./config.js";
+import { authProvider } from "./auth.js";
+const DEBUG = !!process.env.DEBUG_OAUTH;
+const debugFetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = init?.method ?? "GET";
+    console.error(`[OAuth] --> ${method} ${url}`);
+    if (init?.headers)
+        console.error(`[OAuth]     headers:`, JSON.stringify(init.headers));
+    if (init?.body)
+        console.error(`[OAuth]     body:`, String(init.body));
+    const res = await fetch(input, init);
+    const cloned = res.clone();
+    const text = await cloned.text().catch(() => "");
+    console.error(`[OAuth] <-- ${res.status} ${res.statusText}`);
+    if (text)
+        console.error(`[OAuth]     response:`, text.slice(0, 2000));
+    return res;
+};
+const fetchFn = DEBUG ? debugFetch : undefined;
+let client = null;
+let cachedTools = [];
+let reconnecting = null;
+let authCompletion = null;
+let onAuthComplete = null;
+let onAuthError = null;
+let lastAuthError = null;
+/** 注册授权完成回调（用于发送 logging 通知） */
+export function setOnAuthComplete(cb) {
+    onAuthComplete = cb;
+}
+/** 注册授权失败回调（用于主动通知 Agent） */
+export function setOnAuthError(cb) {
+    onAuthError = cb;
+}
+export function isRemoteConnected() {
+    return client !== null;
+}
+/** 若授权流程正在进行中，等待其完成（成功或失败） */
+export async function waitForAuthCompletion() {
+    if (authCompletion)
+        await authCompletion;
+}
+/** 启动时静默连接：有缓存令牌才尝试，无令牌或连接失败则跳过 */
+export async function connectToRemote() {
+    if (!REMOTE_MCP_URL)
+        return;
+    if (!(await authProvider.tokens()))
+        return;
+    const url = new URL(REMOTE_MCP_URL);
+    try {
+        client = await tryConnect(url);
+        const { tools } = await client.listTools();
+        cachedTools = tools;
+    }
+    catch {
+        client = null;
+    }
+}
+/**
+ * 发起 OAuth 授权流程，返回结构化结果。
+ *
+ * 状态说明：
+ *   connected  — 已连接远程服务器
+ *   auth_url   — 生成了授权链接，等待用户浏览器完成登录
+ *   waiting    — 授权流程进行中，正在等待浏览器回调
+ *   error      — 授权流程出错（附带错误码和引导信息）
+ */
+export async function initiateAuth() {
+    if (client) {
+        const tools = await listRemoteTools();
+        return { status: "connected", toolCount: tools.length };
+    }
+    if (!REMOTE_MCP_URL) {
+        return { status: "error", errorCode: "not_configured", message: "LESSIE_REMOTE_MCP_URL is not configured" };
+    }
+    // 授权流程进行中：告诉 Agent 当前等待状态
+    if (authProvider.pendingAuthUrl && authCompletion) {
+        const elapsed = authProvider.waitingSince
+            ? Date.now() - authProvider.waitingSince
+            : 0;
+        return {
+            status: "waiting",
+            authUrl: authProvider.pendingAuthUrl,
+            elapsedMs: elapsed,
+        };
+    }
+    // 上次异步错误（超时、授权拒绝等），记录后清除
+    const prevError = lastAuthError;
+    lastAuthError = null;
+    const serverUrl = REMOTE_MCP_URL;
+    try {
+        await authProvider.prepareCallbackServer();
+        const result = await auth(authProvider, { serverUrl, fetchFn });
+        if (result === "AUTHORIZED") {
+            const url = new URL(serverUrl);
+            client = await tryConnect(url);
+            const { tools } = await client.listTools();
+            cachedTools = tools;
+            return { status: "connected", toolCount: tools.length };
+        }
+        const authUrl = authProvider.pendingAuthUrl;
+        if (!authUrl) {
+            return { status: "error", errorCode: "no_auth_url", message: "OAuth flow initiated but no authorization URL was generated" };
+        }
+        ensureAuthCompletion();
+        return {
+            status: "auth_url",
+            authUrl,
+            ...(prevError ? { previousError: prevError.message } : {}),
+        };
+    }
+    catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        return { status: "error", errorCode: categorizeAuthError(error), message: error.message };
+    }
+}
+/** 启动后台任务：等待用户浏览器回调 → 交换令牌 → 连接远程服务器 */
+function ensureAuthCompletion() {
+    if (authCompletion)
+        return;
+    const serverUrl = REMOTE_MCP_URL;
+    const url = new URL(serverUrl);
+    authCompletion = (async () => {
+        try {
+            const code = await authProvider.waitForCallback();
+            await auth(authProvider, { serverUrl, authorizationCode: code, fetchFn });
+            client = await tryConnect(url);
+            const { tools } = await client.listTools();
+            cachedTools = tools;
+            authProvider.pendingAuthUrl = null;
+            onAuthComplete?.(cachedTools.length);
+        }
+        catch (e) {
+            authProvider.pendingAuthUrl = null;
+            const error = e instanceof Error ? e : new Error(String(e));
+            const code = categorizeAuthError(error);
+            lastAuthError = { code, message: error.message };
+            onAuthError?.({ code, message: error.message });
+            console.error("[lessie] Authorization completion failed:", e);
+        }
+        finally {
+            authCompletion = null;
+        }
+    })();
+}
+function categorizeAuthError(err) {
+    const msg = err.message.toLowerCase();
+    const code = err.code;
+    if (code === "EADDRINUSE" || msg.includes("already in use") || msg.includes("no available port"))
+        return "port_in_use";
+    if (msg.includes("timed out") || msg.includes("timeout"))
+        return "timeout";
+    if (msg.includes("authorization denied") || msg.includes("access_denied"))
+        return "auth_denied";
+    if (msg.includes("callback server"))
+        return "server_error";
+    return "unknown";
+}
+async function tryConnect(url) {
+    const c = new Client({ name: "lessie-mcp-proxy", version: pkg.version });
+    await c.connect(new StreamableHTTPClientTransport(url, { authProvider, fetch: fetchFn }));
+    return c;
+}
+/** 获取远程工具列表；连接可用时实时刷新，否则返回缓存 */
+export async function listRemoteTools() {
+    if (!client)
+        return cachedTools;
+    try {
+        const { tools } = await client.listTools();
+        cachedTools = tools;
+    }
+    catch (err) {
+        console.warn("[lessie] Failed to refresh remote tools, using cache:", String(err));
+    }
+    return cachedTools;
+}
+/** 转发工具调用到远程 MCP Server；失败时引导用户重新授权 */
+export async function callRemoteTool(name, args) {
+    if (authCompletion)
+        await authCompletion;
+    if (!client) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `无法调用工具 ${name}：远程 MCP 服务器未连接。请先使用 authorize 工具完成登录授权。`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    try {
+        return (await client.callTool({ name, arguments: args }));
+    }
+    catch (err) {
+        if (!isAuthError(err)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `工具 ${name} 调用失败: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        await reconnect();
+        if (!client) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `工具 ${name} 调用失败（认证过期），请使用 authorize 工具重新登录。`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        return (await client.callTool({ name, arguments: args }));
+    }
+}
+function isAuthError(err) {
+    const obj = err;
+    const status = obj?.status ?? obj?.statusCode;
+    if (status === 401 || status === 403)
+        return true;
+    if (err instanceof Error) {
+        const msg = err.message.toLowerCase();
+        return msg.includes("unauthorized") || msg.includes("forbidden");
+    }
+    return false;
+}
+/**
+ * 重连，关闭旧连接；并发调用共享同一个 Promise 避免竞争。
+ * 静默尝试连接，若令牌已失效则 client 保持 null。
+ */
+async function reconnect() {
+    if (reconnecting)
+        return reconnecting;
+    reconnecting = (async () => {
+        try {
+            const old = client;
+            client = null;
+            await old?.close().catch(() => { });
+            await connectToRemote();
+        }
+        finally {
+            reconnecting = null;
+        }
+    })();
+    return reconnecting;
+}

package/dist/schema.js

@@ -0,0 +1,71 @@
+/**
+ * JSON Schema (MCP Tool inputSchema) → Zod shape 转换。
+ *
+ * MCP 工具的 inputSchema 是 JSON Schema 的受限子集（type: "object"），
+ * 这里只处理 properties 中可能出现的常见类型。
+ * 不支持的类型回退为 z.unknown()。
+ */
+import { z } from "zod";
+function convertProperty(prop) {
+    const types = Array.isArray(prop.type) ? prop.type : prop.type ? [prop.type] : [];
+    const hasNull = types.includes("null");
+    const nonNullTypes = types.filter((t) => t !== "null");
+    const primaryType = nonNullTypes[0];
+    let schema;
+    if (prop.enum && Array.isArray(prop.enum)) {
+        const values = prop.enum.filter((v) => v !== null);
+        schema = values.length > 0 ? z.enum(values) : z.unknown();
+    }
+    else {
+        switch (primaryType) {
+            case "string":
+                schema = z.string();
+                break;
+            case "number":
+            case "integer":
+                schema = z.number();
+                break;
+            case "boolean":
+                schema = z.boolean();
+                break;
+            case "array":
+                schema = prop.items ? z.array(convertProperty(prop.items)) : z.array(z.unknown());
+                break;
+            case "object":
+                if (prop.properties) {
+                    schema = z.object(convertShape(prop.properties, prop.required));
+                }
+                else {
+                    schema = z.record(z.unknown());
+                }
+                break;
+            default:
+                schema = z.unknown();
+        }
+    }
+    if (hasNull)
+        schema = schema.nullable();
+    if (prop.description)
+        schema = schema.describe(prop.description);
+    return schema;
+}
+function convertShape(properties, required) {
+    const requiredSet = new Set(required ?? []);
+    const shape = {};
+    for (const [key, prop] of Object.entries(properties)) {
+        let field = convertProperty(prop);
+        if (!requiredSet.has(key))
+            field = field.optional();
+        shape[key] = field;
+    }
+    return shape;
+}
+/**
+ * 将 MCP Tool 的 inputSchema（JSON Schema object）转换为 Zod raw shape。
+ * 返回的 shape 可以直接传给 McpServer.registerTool() 的 inputSchema 参数。
+ */
+export function jsonSchemaToZodShape(inputSchema) {
+    if (!inputSchema.properties || Object.keys(inputSchema.properties).length === 0)
+        return undefined;
+    return convertShape(inputSchema.properties, inputSchema.required);
+}

package/dist/tools.js

@@ -0,0 +1,145 @@
+/**
+ * 本地工具注册。
+ *
+ * 定义不依赖远程 MCP Server 的工具（如鉴权辅助工具）。
+ * 新增工具时在 registerTools() 中通过 server.registerTool() 注册。
+ */
+import { z } from "zod";
+import { initiateAuth, listRemoteTools, callRemoteTool, isRemoteConnected, waitForAuthCompletion } from "./remote.js";
+import { DEFAULT_CALLBACK_PORT, PORT_SCAN_RANGE } from "./auth.js";
+function portInUseGuidance() {
+    const endPort = DEFAULT_CALLBACK_PORT + PORT_SCAN_RANGE - 1;
+    return [
+        `授权回调服务器启动失败：端口 ${DEFAULT_CALLBACK_PORT}–${endPort} 均被占用。`,
+        "",
+        "可能原因：上次授权流程未正常关闭，或其他程序占用了这些端口。",
+        `请执行 \`lsof -i :${DEFAULT_CALLBACK_PORT}-${endPort}\` 查看占用进程并终止，然后重新调用此工具重试。`,
+    ].join("\n");
+}
+const ERROR_GUIDANCE = {
+    port_in_use: portInUseGuidance,
+    timeout: [
+        "授权超时：2 分钟内未收到浏览器回调。",
+        "",
+        "可能原因：",
+        "  - 用户未在浏览器中完成授权流程",
+        "  - 浏览器页面已关闭或未正确加载",
+        "  - 网络连接问题导致回调未到达",
+        "",
+        "请重新调用此工具生成新的授权链接，并提醒用户在浏览器中完成授权。",
+    ].join("\n"),
+    auth_denied: [
+        "用户拒绝了授权请求。",
+        "",
+        "如果用户需要使用远程功能，请重新调用此工具生成新的授权链接，",
+        "并请用户在浏览器中点击「允许」完成授权。",
+    ].join("\n"),
+    server_error: [
+        "授权回调服务器运行异常。",
+        "",
+        "请重新调用此工具重试。如果问题持续出现，可能需要检查系统网络配置或防火墙设置。",
+    ].join("\n"),
+    not_configured: [
+        "远程 MCP 服务器地址未配置。",
+        "",
+        "请检查环境变量 LESSIE_REMOTE_MCP_URL 是否正确设置。",
+    ].join("\n"),
+};
+function formatAuthResult(result) {
+    switch (result.status) {
+        case "connected":
+            return {
+                content: [{
+                        type: "text",
+                        text: `已连接到远程 MCP 服务器，共发现 ${result.toolCount} 个远程工具，无需重新授权。\n\n可通过 use_lessie 工具调用远程功能：不传 tool 参数可列出所有工具，传入 tool 和 arguments 可调用指定工具。`,
+                    }],
+            };
+        case "auth_url": {
+            const lines = [];
+            if (result.previousError) {
+                lines.push(`⚠ 上次授权尝试失败：${result.previousError}`);
+                lines.push("已自动发起新的授权流程。");
+                lines.push("");
+            }
+            lines.push("需要授权登录。请在浏览器中打开以下链接完成授权：", "", result.authUrl, "", "授权完成后，使用 use_lessie 工具调用远程功能（不传 tool 参数可查看所有可用工具）。", `如果 2 分钟内未完成授权，流程将超时，届时请重新调用此工具重试。`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "waiting": {
+            const elapsedSec = Math.floor(result.elapsedMs / 1000);
+            const remainingSec = Math.max(0, 120 - elapsedSec);
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `授权流程进行中，正在等待用户在浏览器中完成登录。`,
+                            `已等待 ${elapsedSec} 秒，剩余超时时间约 ${remainingSec} 秒。`,
+                            "",
+                            "请提醒用户在浏览器中完成授权。如果用户已关闭页面，可以重新访问以下链接：",
+                            "",
+                            result.authUrl,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        case "error": {
+            const entry = ERROR_GUIDANCE[result.errorCode];
+            const guidance = typeof entry === "function" ? entry()
+                : entry ?? `授权失败：${result.message}\n\n请重新调用此工具重试。`;
+            return {
+                content: [{ type: "text", text: guidance }],
+                isError: true,
+            };
+        }
+    }
+}
+export function registerTools(server) {
+    server.registerTool("authorize", {
+        description: "连接到远程 Lessie 服务。首次使用或授权过期时返回授权链接，用户需在浏览器中打开完成登录。已连接时返回当前状态。授权异常时返回诊断信息和修复建议。",
+    }, async () => {
+        const result = await initiateAuth();
+        return formatAuthResult(result);
+    });
+    server.registerTool("use_lessie", {
+        description: "调用远程 Lessie 工具的统一入口。不传 tool 参数时列出所有可用的远程工具及其参数说明；传入 tool 和 arguments 时调用指定的远程工具。需先通过 authorize 完成授权。",
+        inputSchema: {
+            tool: z.string().optional().describe("要调用的远程工具名称，留空则列出所有可用工具"),
+            arguments: z.record(z.unknown()).optional().describe("传递给远程工具的参数"),
+        },
+    }, async (args) => {
+        const toolName = args.tool;
+        await waitForAuthCompletion();
+        if (!isRemoteConnected()) {
+            return {
+                content: [{
+                        type: "text",
+                        text: "远程 MCP 服务器未连接。请先调用 authorize 工具完成授权。",
+                    }],
+                isError: true,
+            };
+        }
+        if (!toolName) {
+            const tools = await listRemoteTools();
+            if (tools.length === 0) {
+                return {
+                    content: [{ type: "text", text: "当前没有可用的远程工具。" }],
+                };
+            }
+            const listing = tools.map((t) => {
+                const params = t.inputSchema?.properties
+                    ? Object.entries(t.inputSchema.properties)
+                        .map(([k, v]) => `    - ${k} (${v.type ?? "any"}): ${v.description ?? ""}`)
+                        .join("\n")
+                    : "    （无参数）";
+                const required = t.inputSchema?.required?.join(", ") ?? "";
+                return `## ${t.name}\n${t.description ?? ""}\n  参数:\n${params}${required ? `\n  必填: ${required}` : ""}`;
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `共 ${tools.length} 个远程工具可用：\n\n${listing.join("\n\n")}`,
+                    }],
+            };
+        }
+        return callRemoteTool(toolName, args.arguments ?? {});
+    });
+}

package/mcpb/.mcpbignore

@@ -0,0 +1,4 @@
+pack.sh
+*.mcpb
+node_modules
+README.md