s-app-scoder-agent 0.9.3 → 0.9.6

package/dist/io/console-reporter.js

@@ -0,0 +1,24 @@
+import * as ui from "./terminal.js";
+/** Default reporter preserving the existing classic terminal behavior. */
+export const consoleReporter = {
+    info: ui.info,
+    step: ui.step,
+    success: ui.success,
+    warn: ui.warn,
+    error: ui.error,
+    llm: ui.llm,
+    toolCall: ui.toolCall,
+    toolResult: ui.toolResult,
+    buildStatus: ui.buildStatus,
+    header: ui.header,
+    banner: ui.banner,
+    llmStreamStart: ui.llmStreamStart,
+    llmStreamChunk: ui.llmStreamChunk,
+    llmStreamEnd: ui.llmStreamEnd,
+    toolStreamStart: ui.toolStreamStart,
+    toolStreamChunk: ui.toolStreamChunk,
+    toolStreamEnd: ui.toolStreamEnd,
+    isToolStreamOpen: ui.isToolStreamOpen,
+    printDiff: ui.printDiff,
+    diffSummary: ui.diffSummary,
+};

package/dist/io/reporter.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/connection.js

@@ -0,0 +1,227 @@
+import { CLIENT_NAME, getVersion } from "../shared/version.js";
+import { redactSecrets } from "../llm/llm.js";
+import { HttpTransport } from "./transport-http.js";
+import { StdioTransport } from "./transport-stdio.js";
+// ── JSON-RPC connection ──────────────────────────────────────────────────────
+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;
+    /** MCP A: inbound server notifications (tools/list_changed, progress…). */
+    onNotification = null;
+    /** Server-reported metadata from `initialize` (surfaced on /mcp). */
+    serverInfo = {};
+    capabilities = {};
+    instructions = null;
+    /** Protocol version negotiated with the server. */
+    protocolVersion = "2024-11-05";
+    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. Negotiate the
+        // highest protocol version we support that the server accepts.
+        const initRes = await this.rpc("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: CLIENT_NAME, version: getVersion() },
+        }, timeoutMs);
+        this.protocolVersion = initRes.protocolVersion ?? "2024-11-05";
+        this.capabilities = initRes.capabilities ?? {};
+        this.serverInfo = initRes.serverInfo ?? {};
+        this.instructions = initRes.instructions ?? null;
+        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) {
+                // Server notifications (tools/list_changed, progress, message) —
+                // route them to the manager so it can react (re-register tools etc.).
+                this.onNotification?.(msg);
+                return;
+            }
+            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();
+        }
+    }
+    /** MCP A: liveness probe — prefer ping (official MCP spec), fallback tools/list. */
+    async healthy(timeoutMs = 5_000) {
+        if (!this.alive)
+            return false;
+        try {
+            // ping was added in MCP 2025-03; fall back to tools/list for older servers.
+            if (this.capabilities.ping === true) {
+                await this.rpc("ping", {}, timeoutMs);
+            }
+            else {
+                await this.rpc("tools/list", {}, timeoutMs);
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** MCP A: explicit ping. */
+    async ping(timeoutMs = 5_000) {
+        await this.rpc("ping", {}, timeoutMs);
+    }
+    async listTools(timeoutMs = 120_000) {
+        const res = await this.rpc("tools/list", {}, timeoutMs);
+        return (res.tools ?? []).filter((t) => typeof t.name === "string");
+    }
+    // ── Phase 4: resources ────────────────────────────────────────────────────
+    async listResources(timeoutMs = 30_000) {
+        const res = await this.rpc("resources/list", {}, timeoutMs);
+        return (res.resources ?? []).filter((r) => typeof r.uri === "string");
+    }
+    async listResourceTemplates(timeoutMs = 30_000) {
+        const res = await this.rpc("resources/templates/list", {}, timeoutMs);
+        return (res.resourceTemplates ?? []).filter((r) => typeof r.uriTemplate === "string");
+    }
+    async readResource(uri, timeoutMs = 30_000) {
+        const res = await this.rpc("resources/read", { uri }, timeoutMs);
+        return { contents: res.contents ?? [] };
+    }
+    async subscribeResource(uri, timeoutMs = 30_000) {
+        await this.rpc("resources/subscribe", { uri }, timeoutMs);
+    }
+    async unsubscribeResource(uri, timeoutMs = 30_000) {
+        await this.rpc("resources/unsubscribe", { uri }, timeoutMs);
+    }
+    // ── Phase 4: prompts ──────────────────────────────────────────────────────
+    async listPrompts(timeoutMs = 30_000) {
+        const res = await this.rpc("prompts/list", {}, timeoutMs);
+        return (res.prompts ?? []).filter((p) => typeof p.name === "string");
+    }
+    async getPrompt(name, args, timeoutMs = 30_000) {
+        const res = await this.rpc("prompts/get", { name, arguments: args ?? {} }, timeoutMs);
+        return { description: res.description, messages: res.messages ?? [] };
+    }
+    async callTool(name, args, timeoutMs = 120_000) {
+        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);
+        // H-13: MCP servers are third-party — redact secret shapes from output
+        // before it enters the conversation or logs.
+        const structured = res.structuredContent
+            ? JSON.parse(redactSecrets(JSON.stringify(res.structuredContent)))
+            : undefined;
+        return { ok: !isErr, output: redactSecrets(parts.join("\n")) || "(empty result)", structured };
+    }
+    kill() {
+        this.manuallyClosed = true;
+        this.setState("dead", "closed by client");
+        this.drain(new Error("disconnected"));
+        this.transport.close();
+    }
+    // ── internals ─────────────────────────────────────────────────────────────
+    async rpc(method, params, timeoutMs) {
+        if (!this.alive)
+            throw new Error(`MCP server "${this.name}" not connected`);
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP "${method}" timed out after ${(timeoutMs / 1000).toFixed(0)}s`));
+            }, timeoutMs);
+            this.pending.set(id, {
+                resolve: (v) => { clearTimeout(timer); resolve(v); },
+                reject: (e) => { clearTimeout(timer); reject(e); },
+            });
+            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);
+                }
+            });
+        });
+    }
+    drain(err) {
+        for (const [, p] of this.pending)
+            p.reject(err);
+        this.pending.clear();
+    }
+}

package/dist/mcp/env.js

@@ -0,0 +1,8 @@
+/** Expand {env:VAR} references in config env values. */
+export function expandEnv(env) {
+    const out = {};
+    for (const [k, v] of Object.entries(env ?? {})) {
+        out[k] = v.replace(/\{env:([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, n) => process.env[n] ?? "");
+    }
+    return out;
+}