s-app-scoder-agent 0.6.0 → 0.7.0

package/dist/mcp.js

@@ -1,12 +1,15 @@
 /**
- * Minimal MCP (Model Context Protocol) client for stdio servers.
+ * Minimal MCP (Model Context Protocol) client.
  *
- * Implements JSON-RPC 2.0 over stdin/stdout with line-delimited messages.
- * Connects to configured stdio servers, exposes their tools as
- * `mcp__<server>__<tool>` prefixed names in the agent's tool registry.
+ * M3: pluggable transport — `StdioTransport` (JSON-RPC 2.0 over stdin/stdout,
+ * line-delimited) và `HttpTransport` (Streamable HTTP: POST JSON-RPC, nhận
+ * JSON hoặc SSE stream, echo `Mcp-Session-Id`). Config `url` → http, ngược
+ * lại → stdio. Exposes discovered tools as `mcp__<server>__<tool>` prefixed
+ * names in the agent's tool registry.
  */
 import { spawn } from "node:child_process";
 import { CLIENT_NAME, getVersion } from "./version.js";
+import { redactSecrets } from "./llm.js";
 export const MCP_TOOL_PREFIX = "mcp__";
 export function mcpToolKey(serverName, toolName) {
     return `${MCP_TOOL_PREFIX}${serverName}__${toolName}`;
@@ -19,38 +22,309 @@ function expandEnv(env) {
     }
     return out;
 }
-// ── JSON-RPC stdio connection ─────────────────────────────────────────────────
-export class McpConnection {
-    name;
+/** stdio transport — spawn process, line-delimited JSON-RPC trên stdin/stdout. */
+export class StdioTransport {
     cfg;
+    kind = "stdio";
     proc = null;
-    nextId = 1;
-    pending = new Map();
+    /** Tail of the server's stderr (last 4KB) — surfaced on connect failures. */
+    stderrTail = "";
     buf = "";
-    constructor(name, cfg) {
-        this.name = name;
+    msgCb = null;
+    downCb = null;
+    constructor(cfg) {
         this.cfg = cfg;
     }
     get alive() {
         return this.proc !== null && this.proc.exitCode === null;
     }
-    async connect(timeoutMs = 15_000) {
-        const p = spawn(this.cfg.command, this.cfg.args ?? [], {
+    onMessage(cb) {
+        this.msgCb = cb;
+    }
+    onDown(cb) {
+        this.downCb = cb;
+    }
+    async start() {
+        const command = this.cfg.command;
+        if (!command)
+            throw new Error("MCP stdio transport requires \"command\" in the server config");
+        const p = spawn(command, this.cfg.args ?? [], {
             stdio: ["pipe", "pipe", "pipe"],
             env: { ...process.env, ...expandEnv(this.cfg.env) },
+            // Windows: npx/foo.cmd chỉ spawn được qua shell (libuv không tự tìm .cmd).
+            shell: process.platform === "win32",
         });
         this.proc = p;
-        p.stderr?.on("data", () => { });
-        p.on("error", (e) => this.drain(new Error(`spawn: ${e.message}`)));
-        p.on("exit", () => this.drain(new Error("process exited")));
+        p.stderr?.on("data", (c) => {
+            // Keep the tail for diagnostics (server logs/help output on crash);
+            // otherwise stderr is intentionally ignored.
+            this.stderrTail = (this.stderrTail + c.toString("utf8")).slice(-4096);
+        });
+        p.on("error", (e) => this.downCb?.(new Error(`spawn: ${e.message}`)));
+        p.on("exit", (code) => this.downCb?.(new Error(`process exited (code ${code ?? "?"})`)));
         p.stdout?.on("data", (c) => this.onChunk(c));
+    }
+    send(msg) {
+        if (!this.proc?.stdin?.writable)
+            return Promise.resolve();
+        try {
+            this.proc.stdin.write(JSON.stringify(msg) + "\n");
+        }
+        catch { /* ignore */ }
+        return Promise.resolve();
+    }
+    close() {
+        if (this.proc) {
+            try {
+                this.proc.kill();
+            }
+            catch { /* already dead */ }
+            this.proc = null;
+        }
+    }
+    onChunk(chunk) {
+        this.buf += chunk.toString("utf8");
+        let i;
+        while ((i = this.buf.indexOf("\n")) !== -1) {
+            const line = this.buf.slice(0, i).trim();
+            this.buf = this.buf.slice(i + 1);
+            if (!line)
+                continue;
+            try {
+                this.msgCb?.(JSON.parse(line));
+            }
+            catch { /* skip malformed */ }
+        }
+    }
+}
+/**
+ * M3: Streamable HTTP transport — POST một JSON-RPC message, server trả về
+ * `application/json` (single response) hoặc `text/event-stream` (SSE; parse
+ * các `data:` events). Echo `Mcp-Session-Id` từ initialize trên các request
+ * sau. Stateless: lỗi request → reject call hiện tại; call sau tự retry
+ * (không cần background reconnect như stdio).
+ */
+export class HttpTransport {
+    cfg;
+    kind = "http";
+    sessionId = null;
+    msgCb = null;
+    closed = false;
+    constructor(cfg) {
+        this.cfg = cfg;
+    }
+    get alive() {
+        return !this.closed;
+    }
+    onMessage(cb) {
+        this.msgCb = cb;
+    }
+    onDown(_cb) {
+        // HTTP là stateless — không có channel chết để báo.
+    }
+    async start() {
+        this.closed = false;
+    }
+    async send(msg) {
+        if (this.closed)
+            throw new Error(`MCP HTTP transport "${this.cfg.url}" closed`);
+        const res = await this.post(msg, this.sessionId);
+        // Session expired (server restart) → thử lại một lần không session.
+        if ((res.status === 404 || res.status === 400) && this.sessionId) {
+            this.sessionId = null;
+            const retry = await this.post(msg, null);
+            return this.consume(retry);
+        }
+        return this.consume(res);
+    }
+    close() {
+        this.closed = true;
+        this.sessionId = null;
+    }
+    async post(msg, sessionId) {
+        const url = this.cfg.url;
+        if (!url)
+            throw new Error("MCP HTTP transport requires \"url\" in the server config");
+        // M3: headers hỗ trợ {env:VAR} substitution như env — không hardcode secrets.
+        const headers = {
+            "content-type": "application/json",
+            accept: "application/json, text/event-stream",
+            ...expandEnv(this.cfg.headers),
+        };
+        if (sessionId)
+            headers["mcp-session-id"] = sessionId;
+        try {
+            return await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(msg),
+                signal: AbortSignal.timeout(120_000),
+            });
+        }
+        catch (e) {
+            throw new Error(`MCP HTTP "${url}": ${e.message}`, { cause: e });
+        }
+    }
+    async consume(res) {
+        const sid = res.headers.get("mcp-session-id");
+        if (sid)
+            this.sessionId = sid;
+        if (!res.ok) {
+            res.body?.cancel().catch(() => { });
+            throw new Error(`MCP HTTP ${res.status} ${res.statusText}`);
+        }
+        const ct = res.headers.get("content-type") ?? "";
+        if (ct.includes("text/event-stream")) {
+            const text = await res.text();
+            for (const m of parseSseMessages(text))
+                this.msgCb?.(m);
+        }
+        else if (ct.includes("application/json")) {
+            const body = (await res.text()).trim();
+            if (body) {
+                try {
+                    this.msgCb?.(JSON.parse(body));
+                }
+                catch { /* skip malformed */ }
+            }
+        } // 202/no-content (notifications) — nothing to parse
+    }
+}
+/** Parse SSE text thành JSON-RPC messages (concat các dòng `data:` liên tiếp). */
+export function parseSseMessages(text) {
+    const out = [];
+    for (const block of text.split(/\r?\n\r?\n/)) {
+        const data = block
+            .split(/\r?\n/)
+            .filter((l) => l.startsWith("data:"))
+            .map((l) => l.slice(5).trim())
+            .join("\n");
+        if (!data)
+            continue;
+        try {
+            out.push(JSON.parse(data));
+        }
+        catch { /* skip malformed */ }
+    }
+    return out;
+}
+const RECONNECT_MAX = 5;
+const RECONNECT_BASE_MS = 500; // backoff: 0.5s, 1s, 2s, 4s, 8s
+export class McpConnection {
+    name;
+    cfg;
+    transport;
+    nextId = 1;
+    pending = new Map();
+    /** M1: current state machine position. */
+    state = "connecting";
+    /** M1: status/state sink (AgentEvent mcp_status). */
+    onState = null;
+    manuallyClosed = false;
+    reconnectAttempt = 0;
+    constructor(name, cfg) {
+        this.name = name;
+        this.cfg = cfg;
+        // M3: url → HTTP transport; ngược lại stdio (default).
+        const kind = cfg.type ?? (cfg.url ? "http" : "stdio");
+        if (kind === "http" && !cfg.url)
+            throw new Error(`MCP server "${name}": type "http" nhưng thiếu url`);
+        if (kind === "stdio" && !cfg.command)
+            throw new Error(`MCP server "${name}": thiếu command`);
+        this.transport = kind === "http" ? new HttpTransport(cfg) : new StdioTransport(cfg);
+    }
+    /** stdio process (null với HTTP) — dùng trong tests. */
+    get proc() {
+        return this.transport.kind === "stdio" ? this.transport.proc : null;
+    }
+    get stderrTail() {
+        return this.transport.kind === "stdio" ? this.transport.stderrTail : "";
+    }
+    get alive() {
+        return this.transport.alive;
+    }
+    setState(s, detail) {
+        this.state = s;
+        this.onState?.(s, detail);
+    }
+    async connect(timeoutMs = 15_000) {
+        this.manuallyClosed = false;
+        await this.startAndHandshake(timeoutMs);
+    }
+    async startAndHandshake(timeoutMs) {
+        await this.transport.start();
+        this.wireTransport();
         // MCP handshake: initialize + notifications/initialized
         await this.rpc("initialize", {
             protocolVersion: "2024-11-05",
             capabilities: {},
             clientInfo: { name: CLIENT_NAME, version: getVersion() },
         }, timeoutMs);
-        this.send({ jsonrpc: "2.0", method: "notifications/initialized" });
+        void this.transport.send({ jsonrpc: "2.0", method: "notifications/initialized" }).catch(() => {
+            // notification — không có pending để reject; lỗi sẽ lộ ở call sau.
+        });
+        this.setState("ready", "connected");
+    }
+    /** Wire inbound messages + channel-death → reconnect (stdio only). */
+    wireTransport() {
+        this.transport.onMessage((msg) => {
+            if (msg.id === undefined)
+                return; // notification — nothing pending
+            const pending = this.pending.get(msg.id);
+            if (!pending)
+                return;
+            this.pending.delete(msg.id);
+            const err = msg.error;
+            if (err)
+                pending.reject(new Error(`${err.code}: ${err.message}`));
+            else
+                pending.resolve((msg.result ?? {}));
+        });
+        if (this.transport.kind === "stdio") {
+            this.transport.onDown((err) => {
+                // M1: exit → drain pending (reject rõ ràng) → reconnect, trừ khi
+                // kill() chủ đích.
+                this.drain(new Error(`MCP server "${this.name}" ${err.message}`));
+                if (this.manuallyClosed)
+                    return;
+                void this.scheduleReconnect();
+            });
+        }
+    }
+    /** M1: exponential backoff reconnect — tools/list refresh do Manager lo. */
+    async scheduleReconnect() {
+        if (this.reconnectAttempt >= RECONNECT_MAX) {
+            this.setState("dead", `reconnect failed after ${RECONNECT_MAX} attempts`);
+            return;
+        }
+        this.reconnectAttempt++;
+        const delay = RECONNECT_BASE_MS * 2 ** (this.reconnectAttempt - 1);
+        this.setState("reconnecting", `attempt ${this.reconnectAttempt}/${RECONNECT_MAX} in ${delay}ms`);
+        await new Promise((r) => setTimeout(r, delay));
+        if (this.manuallyClosed)
+            return;
+        try {
+            await this.startAndHandshake(15_000);
+            this.reconnectAttempt = 0;
+            this.setState("ready", "reconnected");
+        }
+        catch (e) {
+            this.drain(e);
+            await this.scheduleReconnect();
+        }
+    }
+    /** M1: health check — ping không có response trong MCP spec stdio → dùng
+     *  tools/list với timeout ngắn làm liveness probe. */
+    async healthy(timeoutMs = 5_000) {
+        if (!this.alive)
+            return false;
+        try {
+            await this.rpc("tools/list", {}, timeoutMs);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
     async listTools(timeoutMs = 120_000) {
         const res = await this.rpc("tools/list", {}, timeoutMs);
@@ -60,27 +334,17 @@ export class McpConnection {
         const res = await this.rpc("tools/call", { name, arguments: args }, timeoutMs);
         const isErr = res.isError === true;
         const parts = (res.content ?? []).map((c) => c.text ?? "").filter(Boolean);
-        return { ok: !isErr, output: parts.join("\n") || "(empty result)" };
+        // H-13: MCP servers are third-party — redact secret shapes from output
+        // before it enters the conversation or logs.
+        return { ok: !isErr, output: redactSecrets(parts.join("\n")) || "(empty result)", structured: res.structuredContent };
     }
     kill() {
+        this.manuallyClosed = true;
+        this.setState("dead", "closed by client");
         this.drain(new Error("disconnected"));
-        if (this.proc) {
-            try {
-                this.proc.kill();
-            }
-            catch { /* already dead */ }
-            this.proc = null;
-        }
+        this.transport.close();
     }
     // ── internals ─────────────────────────────────────────────────────────────
-    send(msg) {
-        if (!this.proc?.stdin?.writable)
-            return;
-        try {
-            this.proc.stdin.write(JSON.stringify(msg) + "\n");
-        }
-        catch { /* ignore */ }
-    }
     async rpc(method, params, timeoutMs) {
         if (!this.alive)
             throw new Error(`MCP server "${this.name}" not connected`);
@@ -94,36 +358,15 @@ export class McpConnection {
                 resolve: (v) => { clearTimeout(timer); resolve(v); },
                 reject: (e) => { clearTimeout(timer); reject(e); },
             });
-            this.send({ jsonrpc: "2.0", id, method, params });
+            void Promise.resolve(this.transport.send({ jsonrpc: "2.0", id, method, params })).catch((e) => {
+                const p = this.pending.get(id);
+                if (p) {
+                    this.pending.delete(id);
+                    p.reject(e);
+                }
+            });
         });
     }
-    onChunk(chunk) {
-        this.buf += chunk.toString("utf8");
-        let i;
-        while ((i = this.buf.indexOf("\n")) !== -1) {
-            const line = this.buf.slice(0, i).trim();
-            this.buf = this.buf.slice(i + 1);
-            if (!line)
-                continue;
-            let msg;
-            try {
-                msg = JSON.parse(line);
-            }
-            catch {
-                continue;
-            }
-            if (msg.id === undefined)
-                continue;
-            const pending = this.pending.get(msg.id);
-            if (!pending)
-                continue;
-            this.pending.delete(msg.id);
-            if (msg.error)
-                pending.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
-            else
-                pending.resolve(msg.result ?? {});
-        }
-    }
     drain(err) {
         for (const [, p] of this.pending)
             p.reject(err);
@@ -134,6 +377,10 @@ export class McpManager {
     configs;
     conns = new Map();
     tools = new Map();
+    /** Status sink (default console.error; the TUI routes it to a notice). */
+    onStatus = null;
+    /** Sidebar TUI: máy trạng thái per-server (connecting/ready/reconnecting/dead). */
+    onServerState = null;
     constructor(configs) {
         this.configs = configs;
     }
@@ -141,32 +388,75 @@ export class McpManager {
     async connectAll() {
         await Promise.allSettled(Object.entries(this.configs).map(async ([name, cfg]) => {
             const conn = new McpConnection(name, cfg);
+            this.wireReconnect(name, conn);
             await conn.connect();
-            const defs = await conn.listTools();
-            for (const def of defs) {
-                const key = mcpToolKey(name, def.name);
-                if (this.tools.has(key))
-                    throw new Error(`Duplicate MCP tool: ${key}`);
-                this.tools.set(key, { conn, serverName: name, toolName: def.name, def });
-            }
+            await this.registerTools(name, conn);
             this.conns.set(name, conn);
         })).then((results) => {
+            const report = this.onStatus ?? ((line) => console.error(line));
             results.forEach((r, i) => {
                 const name = Object.keys(this.configs)[i];
                 if (r.status === "rejected") {
-                    console.error(`⚠  MCP server "${name}" unavailable: ${String(r.reason?.message).slice(0, 160)}`);
+                    this.onServerState?.(name, "dead", "connect failed");
+                    report(`⚠  MCP server "${name}" unavailable: ${String(r.reason?.message).slice(0, 160)}`);
                 }
                 else {
                     const n = [...this.tools.values()].filter((t) => t.serverName === name).length;
-                    console.error(`✓ MCP "${name}" connected — ${n} tool${n === 1 ? "" : "s"}`);
+                    report(`✓ MCP "${name}" connected — ${n} tool${n === 1 ? "" : "s"}`);
                 }
             });
         });
         return this.tools.size;
     }
+    /** M1: surface connection state machine + refresh tools sau reconnect. */
+    wireReconnect(name, conn) {
+        conn.onState = (state, detail) => {
+            // Sidebar TUI: structured state trước — mọi transition đều thú vị với
+            // map mcpServers, còn chat notice chỉ với reconnect/dead/ready (dưới).
+            this.onServerState?.(name, state, detail);
+            const report = this.onStatus ?? ((line) => console.error(line));
+            if (state === "reconnecting")
+                report(`⚠  MCP "${name}" ${detail}`);
+            if (state === "dead")
+                report(`✘ MCP "${name}" dead: ${detail}`);
+            if (state === "ready" && detail === "reconnected") {
+                report(`✓ MCP "${name}" reconnected`);
+                // Refresh tool list — server có thể đăng ký bộ tool mới.
+                conn
+                    .listTools()
+                    .then((defs) => this.reregisterTools(name, conn, defs))
+                    .catch(() => { });
+            }
+        };
+    }
+    async registerTools(name, conn) {
+        const defs = await conn.listTools();
+        this.reregisterTools(name, conn, defs);
+    }
+    /** Replace một server's tool registrations (reconnect refresh). */
+    reregisterTools(name, conn, defs) {
+        for (const [key, t] of [...this.tools]) {
+            if (t.serverName === name)
+                this.tools.delete(key);
+        }
+        for (const def of defs) {
+            const key = mcpToolKey(name, def.name);
+            this.tools.set(key, { conn, serverName: name, toolName: def.name, def });
+        }
+    }
     hasTool(name) {
         return this.tools.has(name);
     }
+    /** Per-server tool listing (for /mcp status display). */
+    listToolsByServer() {
+        const map = new Map();
+        for (const t of this.tools.values()) {
+            const arr = map.get(t.serverName) ?? [];
+            arr.push({ name: t.toolName, description: t.def.description, inputSchema: t.def.inputSchema });
+            map.set(t.serverName, arr);
+        }
+        return [...map.entries()].map(([server, tools]) => ({ server, tools }));
+    }
     getTool(name) {
         return this.tools.get(name);
     }
@@ -185,5 +475,42 @@ export class McpManager {
         for (const c of this.conns.values())
             c.kill();
         this.conns.clear();
+        this.tools.clear();
+    }
+    /** M4: config hot-reload — connect server mới, kill server đã bị xóa khỏi config. */
+    async applyConfig(configs) {
+        this.configs = configs;
+        // Server bị xóa → kill + unregister.
+        for (const [name, conn] of [...this.conns]) {
+            if (!configs[name]) {
+                conn.kill();
+                this.conns.delete(name);
+                for (const [key, t] of [...this.tools]) {
+                    if (t.serverName === name)
+                        this.tools.delete(key);
+                }
+                const report = this.onStatus ?? ((line) => console.error(line));
+                report(`✘ MCP "${name}" removed (config changed)`);
+            }
+        }
+        // Server mới → connect.
+        for (const [name, cfg] of Object.entries(configs)) {
+            if (this.conns.has(name))
+                continue;
+            const conn = new McpConnection(name, cfg);
+            this.wireReconnect(name, conn);
+            try {
+                await conn.connect();
+                await this.registerTools(name, conn);
+                this.conns.set(name, conn);
+                const report = this.onStatus ?? ((line) => console.error(line));
+                const n = [...this.tools.values()].filter((t) => t.serverName === name).length;
+                report(`✓ MCP "${name}" connected — ${n} tool${n === 1 ? "" : "s"} (hot-reload)`);
+            }
+            catch (e) {
+                const report = this.onStatus ?? ((line) => console.error(line));
+                report(`⚠  MCP server "${name}" unavailable: ${String(e.message).slice(0, 160)}`);
+            }
+        }
     }
 }