@lwmxiaobei/xbcode 1.0.0

package/dist/input-submit.js

@@ -0,0 +1,41 @@
+/**
+ * 从一次输入事件中提取“应当立即提交”的文本。
+ * 正常终端会把 Enter 解析成 `key.return`，但有些环境会把整行内容连同换行一起塞进 `input`。
+ * 这里统一把两种情况折叠成同一种提交值，避免 `/exit` 之类的命令只进入输入框而不执行。
+ *
+ * 注意：多行粘贴会把“文本 + 换行 + 后续文本”一并塞进 input。
+ * 这种情况下绝不能当作 Enter 提交，否则会出现“第一行被自动发送、剩余还在输入框”的 bug。
+ * 判定方法：只有当换行符之后再无任何非换行字符时，才视作 Enter 兜底。
+ */
+export function getSubmittedValueFromInput(currentValue, input, keyReturn) {
+    if (keyReturn) {
+        return currentValue;
+    }
+    const firstLineBreak = input.search(/[\r\n]/);
+    if (firstLineBreak === -1) {
+        return null;
+    }
+    const tail = input.slice(firstLineBreak).replace(/[\r\n]/g, "");
+    if (tail.length > 0) {
+        return null;
+    }
+    return currentValue + input.slice(0, firstLineBreak);
+}
+/**
+ * 某些终端下，普通字符会正常进入输入框，但 Enter 不一定稳定触发 TextInput 的 onSubmit。
+ * 这里提供一个非常小的去重器，允许我们在父级 useInput 中补一层 Enter 处理，
+ * 同时避免一次按键触发两次提交。
+ */
+export function createSubmitDeduper(windowMs = 80) {
+    let lastValue = "";
+    let lastAt = 0;
+    return {
+        shouldSubmit(value) {
+            const now = Date.now();
+            const isDuplicate = value === lastValue && now - lastAt <= windowMs;
+            lastValue = value;
+            lastAt = now;
+            return !isDuplicate;
+        },
+    };
+}

package/dist/mcp/client.js

@@ -0,0 +1,466 @@
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport, StreamableHTTPError } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { McpRuntimeError } from "./types.js";
+import { isPlainRecord } from "../utils.js";
+// 裸命令名（非路径）在 spawn 时可能因 PATH 继承问题找不到，先用 which 解析成绝对路径。
+function resolveCommand(command) {
+    if (command.includes(path.sep))
+        return command;
+    try {
+        return execFileSync("which", [command], { encoding: "utf8" }).trim();
+    }
+    catch {
+        return command;
+    }
+}
+const CLIENT_INFO = {
+    name: "claude-code-mini",
+    version: "1.0.0",
+};
+const DEFAULT_TIMEOUT_MS = 30_000;
+const STDERR_BUFFER_LIMIT = 4_000;
+// 新建连接时默认先从空缓存开始，后续成功连接后再填充真实能力列表。
+function emptyCache() {
+    return {
+        tools: [],
+        resources: [],
+        prompts: [],
+    };
+}
+// 把配置转成适合展示的连接位置字符串，便于 /mcp 报告诊断。
+function formatLocation(config) {
+    if (config.transport === "stdio") {
+        const command = config.command?.trim() ?? "";
+        const args = (config.args ?? []).join(" ").trim();
+        return `${command} ${args}`.trim() || "(stdio)";
+    }
+    return config.url?.trim() || "(streamable-http)";
+}
+// 根据配置构造统一的运行时状态快照，避免不同重置路径产生不一致状态。
+function createState(config, status) {
+    return {
+        name: config.name,
+        enabled: config.enabled,
+        transport: config.transport,
+        status: status ?? (config.enabled ? "disconnected" : "disabled"),
+        timeoutMs: config.timeoutMs,
+        location: formatLocation(config),
+        cache: emptyCache(),
+    };
+}
+// 对外暴露状态时做一层深拷贝，避免调用方意外修改内部缓存数组。
+function cloneState(state) {
+    return {
+        ...state,
+        cache: {
+            ...state.cache,
+            tools: [...state.cache.tools],
+            resources: [...state.cache.resources],
+            prompts: [...state.cache.prompts],
+        },
+    };
+}
+// 只截取字符串尾部，用于保存 stderr 等“越新越有诊断价值”的文本。
+function trimTail(text, maxLength = STDERR_BUFFER_LIMIT) {
+    if (text.length <= maxLength) {
+        return text;
+    }
+    return text.slice(text.length - maxLength);
+}
+// 把 unknown 错误尽量稳定地转成可读文本，避免出现大量 [object Object]。
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (typeof error === "object" && error !== null) {
+        try {
+            return JSON.stringify(error);
+        }
+        catch {
+            return Object.prototype.toString.call(error);
+        }
+    }
+    if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+        return `${error}`;
+    }
+    if (typeof error === "symbol") {
+        return error.toString();
+    }
+    return "Unknown error";
+}
+// SDK 会用统一的 McpError + ErrorCode 表示超时和连接关闭，这里单独做类型守卫。
+function isTimeoutError(error) {
+    return error instanceof McpError && error.code === ErrorCode.RequestTimeout;
+}
+// 连接关闭属于需要“丢弃当前 client 并触发后续重连”的特殊错误。
+function isConnectionClosedError(error) {
+    return error instanceof McpError && error.code === ErrorCode.ConnectionClosed;
+}
+// 安全关闭客户端时顺手清掉事件回调，避免 close 过程再次污染状态。
+async function safeClose(client) {
+    if (!client) {
+        return;
+    }
+    try {
+        client.onclose = undefined;
+        client.onerror = undefined;
+        await client.close();
+    }
+    catch {
+        // 忽略清理阶段的异常，避免关闭流程反向影响主逻辑。
+    }
+}
+// McpClientConnection 负责“一个服务”的连接、缓存和调用。
+export class McpClientConnection {
+    config;
+    client;
+    state;
+    constructor(config) {
+        this.config = config;
+        this.state = createState(config);
+    }
+    // 配置变化时复用已有连接对象，只更新那些和配置直接相关的状态字段。
+    updateConfig(config) {
+        const previous = this.state;
+        this.config = config;
+        this.state = {
+            ...previous,
+            enabled: config.enabled,
+            transport: config.transport,
+            timeoutMs: config.timeoutMs,
+            location: formatLocation(config),
+            status: config.enabled ? previous.status : "disabled",
+            ...(config.enabled ? {} : { error: undefined }),
+        };
+    }
+    getState() {
+        return cloneState(this.state);
+    }
+    // 延迟初始化，避免为未使用的服务提前建立连接。
+    async initialize() {
+        if (!this.config.enabled) {
+            return this.applyDisabled();
+        }
+        if (!this.client) {
+            await this.connectAndLoad();
+        }
+        return this.getState();
+    }
+    // refresh 不复用旧连接，直接走完整重连和缓存重载流程。
+    async refresh() {
+        if (!this.config.enabled) {
+            return this.applyDisabled();
+        }
+        await this.connectAndLoad();
+        return this.getState();
+    }
+    // close 只负责关闭当前连接，不主动改写其他运行时字段。
+    async close() {
+        const client = this.client;
+        this.client = undefined;
+        await safeClose(client);
+    }
+    // 禁用服务时保留最近一次发现的缓存，同时释放现有连接。
+    async applyDisabled() {
+        await this.close();
+        this.state = {
+            ...createState(this.config, "disabled"),
+            cache: this.state.cache,
+        };
+        return this.getState();
+    }
+    // 以下三个公共调用入口都先确保“已连接 + 有对应 capability”，再发起真实请求。
+    async callTool(name, args) {
+        const client = await this.ensureUsableClient();
+        this.requireCapability("tools", `tool "${name}"`);
+        try {
+            return await client.callTool({ name, arguments: args }, undefined, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+        }
+        catch (error) {
+            throw await this.handleOperationFailure(error);
+        }
+    }
+    async readResource(uri) {
+        const client = await this.ensureUsableClient();
+        this.requireCapability("resources", `resource "${uri}"`);
+        try {
+            return await client.readResource({ uri }, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+        }
+        catch (error) {
+            throw await this.handleOperationFailure(error);
+        }
+    }
+    async getPrompt(name, args) {
+        const client = await this.ensureUsableClient();
+        this.requireCapability("prompts", `prompt "${name}"`);
+        try {
+            return await client.getPrompt({ name, arguments: args }, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+        }
+        catch (error) {
+            throw await this.handleOperationFailure(error);
+        }
+    }
+    // 懒建立连接，并在失败后提供稳定的业务错误而不是裸 SDK 错误。
+    async ensureUsableClient() {
+        if (!this.config.enabled) {
+            throw new McpRuntimeError("server_not_connected", `MCP server "${this.config.name}" is disabled.`);
+        }
+        if (!this.client) {
+            await this.connectAndLoad();
+        }
+        if (!this.client) {
+            throw new McpRuntimeError("server_not_connected", `MCP server "${this.config.name}" is not connected.`);
+        }
+        return this.client;
+    }
+    // 即使服务已连接，也未必支持 tool/resource/prompt 三种能力，必须先校验。
+    requireCapability(capability, target) {
+        const capabilities = this.state.capabilities;
+        if (!capabilities?.[capability]) {
+            throw new McpRuntimeError("capability_unsupported", `MCP server "${this.config.name}" does not support ${target}.`);
+        }
+    }
+    // 每次从头重连，避免配置变更或旧传输层状态泄漏到新会话中。
+    async connectAndLoad() {
+        const previousCache = this.state.cache;
+        await this.close();
+        this.state = {
+            ...this.state,
+            ...createState(this.config, "connecting"),
+            cache: previousCache,
+            capabilities: undefined,
+            serverVersion: undefined,
+            instructions: undefined,
+            error: undefined,
+            lastStderr: undefined,
+        };
+        // strict capability 模式可以让客户端在能力声明不匹配时尽早失败。
+        const client = new Client(CLIENT_INFO, {
+            capabilities: {},
+            enforceStrictCapabilities: true,
+        });
+        // 服务端主动断开时，同步更新本地连接状态。
+        client.onclose = () => {
+            this.client = undefined;
+            if (this.config.enabled) {
+                this.state = {
+                    ...this.state,
+                    status: "disconnected",
+                    error: this.state.error ?? "Connection closed.",
+                };
+            }
+        };
+        // 立即暴露传输层错误，同时尽量保留最后一次已知状态用于诊断。
+        client.onerror = (error) => {
+            this.state = {
+                ...this.state,
+                status: this.client ? "degraded" : "disconnected",
+                error: getErrorMessage(error),
+            };
+        };
+        try {
+            // 先建立底层 transport，再把能力、版本和缓存一起写回状态。
+            const transport = this.createTransport();
+            await client.connect(transport, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+            this.client = client;
+            this.state = {
+                ...this.state,
+                status: "connected",
+                capabilities: client.getServerCapabilities(),
+                serverVersion: client.getServerVersion(),
+                instructions: client.getInstructions(),
+                lastConnectedAt: Date.now(),
+                error: undefined,
+            };
+            await this.reloadCache();
+        }
+        catch (error) {
+            await safeClose(client);
+            this.client = undefined;
+            this.state = {
+                ...this.state,
+                status: "degraded",
+                error: getErrorMessage(error),
+            };
+        }
+    }
+    // 根据 transport 类型创建具体连接对象。
+    // stdio 会额外监听 stderr；HTTP 透传 headers 给远端服务。
+    createTransport() {
+        if (this.config.transport === "stdio") {
+            const cwd = this.config.cwd?.trim();
+            if (cwd) {
+                if (!fs.existsSync(cwd)) {
+                    throw new Error(`MCP server "${this.config.name}" cwd does not exist: ${cwd}`);
+                }
+                if (!fs.statSync(cwd).isDirectory()) {
+                    throw new Error(`MCP server "${this.config.name}" cwd is not a directory: ${cwd}`);
+                }
+            }
+            const transport = new StdioClientTransport({
+                command: resolveCommand(this.config.command ?? ""),
+                args: this.config.args ?? [],
+                env: Object.fromEntries(Object.entries({ ...process.env, ...(this.config.env ?? {}) }).filter(([, v]) => v !== undefined)),
+                cwd,
+                stderr: "pipe",
+            });
+            const stderr = transport.stderr;
+            if (stderr) {
+                // 只保留 stderr 尾部内容，避免诊断信息无限增长占用内存。
+                stderr.on("data", (chunk) => {
+                    const next = `${this.state.lastStderr ?? ""}${String(chunk)}`;
+                    this.state = {
+                        ...this.state,
+                        lastStderr: trimTail(next),
+                    };
+                });
+            }
+            return transport;
+        }
+        return new StreamableHTTPClientTransport(new URL(this.config.url ?? ""), {
+            requestInit: {
+                headers: this.config.headers,
+            },
+        });
+    }
+    // 重建缓存时并不要求所有能力都成功，只要能拿到一部分就先保留下来。
+    async reloadCache() {
+        if (!this.client) {
+            return;
+        }
+        const nextCache = {
+            tools: [],
+            resources: [],
+            prompts: [],
+            refreshedAt: Date.now(),
+        };
+        const errors = [];
+        // 各类 capability 独立刷新，局部失败时仍尽量保留可用元数据。
+        if (this.state.capabilities?.tools) {
+            try {
+                nextCache.tools = await this.listTools();
+            }
+            catch (error) {
+                errors.push(`tools/list failed: ${getErrorMessage(error)}`);
+            }
+        }
+        if (this.state.capabilities?.resources) {
+            try {
+                nextCache.resources = await this.listResources();
+            }
+            catch (error) {
+                errors.push(`resources/list failed: ${getErrorMessage(error)}`);
+            }
+        }
+        if (this.state.capabilities?.prompts) {
+            try {
+                nextCache.prompts = await this.listPrompts();
+            }
+            catch (error) {
+                errors.push(`prompts/list failed: ${getErrorMessage(error)}`);
+            }
+        }
+        this.state = {
+            ...this.state,
+            cache: nextCache,
+            lastRefreshAt: nextCache.refreshedAt,
+            status: errors.length > 0 ? "degraded" : "connected",
+            error: errors.length > 0 ? errors.join("\n") : undefined,
+        };
+    }
+    // 下面三个 list* 方法负责把 SDK 返回值裁剪成更稳定、更适合缓存的结构。
+    async listTools() {
+        if (!this.client) {
+            return [];
+        }
+        const tools = [];
+        let cursor;
+        // 按 MCP 分页协议持续拉取，直到收集完整工具列表。
+        do {
+            const page = await this.client.listTools(cursor ? { cursor } : undefined, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+            tools.push(...page.tools.map((tool) => ({
+                name: tool.name,
+                description: tool.description,
+                inputSchema: isPlainRecord(tool.inputSchema) ? tool.inputSchema : undefined,
+                outputSchema: isPlainRecord(tool.outputSchema) ? tool.outputSchema : undefined,
+            })));
+            cursor = page.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    async listResources() {
+        if (!this.client) {
+            return [];
+        }
+        const resources = [];
+        let cursor;
+        // resource 列表同样可能分页，不能假设一次就能拿全。
+        do {
+            const page = await this.client.listResources(cursor ? { cursor } : undefined, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+            resources.push(...page.resources.map((resource) => ({
+                uri: resource.uri,
+                name: resource.name,
+                description: resource.description,
+                mimeType: resource.mimeType,
+            })));
+            cursor = page.nextCursor;
+        } while (cursor);
+        return resources;
+    }
+    async listPrompts() {
+        if (!this.client) {
+            return [];
+        }
+        const prompts = [];
+        let cursor;
+        // prompt 定义里只保留名称、描述和参数信息，足够给模型选择与调用。
+        do {
+            const page = await this.client.listPrompts(cursor ? { cursor } : undefined, { timeout: this.config.timeoutMs || DEFAULT_TIMEOUT_MS });
+            prompts.push(...page.prompts.map((prompt) => ({
+                name: prompt.name,
+                description: prompt.description,
+                arguments: prompt.arguments?.map((arg) => ({
+                    name: arg.name,
+                    description: arg.description,
+                    required: arg.required,
+                })),
+            })));
+            cursor = page.nextCursor;
+        } while (cursor);
+        return prompts;
+    }
+    // 把底层异常归一成运行时错误，并顺便修正当前连接状态。
+    async handleOperationFailure(error) {
+        const message = getErrorMessage(error);
+        // 连接被硬断开后主动丢弃 client，让下一次请求走干净的重连流程。
+        if (isConnectionClosedError(error)) {
+            const snapshot = this.state;
+            await this.close();
+            this.state = {
+                ...snapshot,
+                status: "disconnected",
+                error: message,
+            };
+            return new McpRuntimeError("transport_error", `MCP server "${this.config.name}" disconnected: ${message}`, { cause: error });
+        }
+        const code = isTimeoutError(error) ? "request_timeout" : "transport_error";
+        // HTTP 传输层错误带状态码，补进消息里能更快区分网络故障与服务端响应异常。
+        const normalizedMessage = error instanceof StreamableHTTPError
+            ? `HTTP ${error.code ?? "unknown"}: ${message}`
+            : message;
+        this.state = {
+            ...this.state,
+            status: "degraded",
+            error: normalizedMessage,
+        };
+        return new McpRuntimeError(code, `MCP request failed for server "${this.config.name}": ${normalizedMessage}`, { cause: error });
+    }
+}