@basein/runner 0.1.0

package/dist/upstream/http-client.d.ts

@@ -0,0 +1,78 @@
+/**
+ * http-client — a remote upstream over streamable HTTP or legacy SSE (Phase 2.2).
+ *
+ * Ported in shape from RRepeat's `mcp-http-client.ts`, but message-level rather
+ * than call-level: this transport must carry *any* frame in either direction,
+ * responses included (see the deviation note in `upstream/client.ts`).
+ *
+ * TWO TRANSPORTS, because both are in the wild:
+ *
+ *   - **streamable HTTP** (`--transport http`, current): every client→server
+ *     message is a POST to one endpoint. The reply comes back as a JSON body or
+ *     as an SSE stream carrying it. A session id handed out in the
+ *     `Mcp-Session-Id` response header must be echoed on every later request.
+ *     Server-initiated messages arrive on a standing GET stream, opened lazily
+ *     after `initialize` and skipped when the server answers 405.
+ *   - **legacy SSE** (`--transport sse`): a long-lived GET carries every reply
+ *     and announces the POST endpoint with an `endpoint` event, so the handshake
+ *     is inverted — you must be listening before you can send.
+ *
+ * AUTH (§9). The host's own OAuth authenticates the server it is *configured*
+ * with, which is now the proxy — so a remote upstream's credentials have to
+ * reach us some other way. They come from `--header` / the environment at spawn
+ * time and are held in memory only; nothing is written to disk here.
+ */
+import type { JsonRpcMessage } from "../jsonrpc/types.js";
+import { BaseUpstreamClient } from "./client.js";
+import { Readable } from "node:stream";
+export interface HttpUpstreamOptions {
+    url: string;
+    /** `"http"` = streamable HTTP (default); `"sse"` = the legacy two-endpoint flow. */
+    transport?: "http" | "sse";
+    /** Extra headers (auth, tenancy) sent on every request. */
+    headers?: Record<string, string>;
+    label?: string;
+    /** How long to wait for the SSE `endpoint` announcement. Default 15s. */
+    connectTimeoutMs?: number;
+}
+export declare class HttpUpstreamClient extends BaseUpstreamClient {
+    readonly ready: Promise<void>;
+    private readonly url;
+    private readonly transport;
+    private readonly headers;
+    private readonly label;
+    private readonly connectTimeoutMs;
+    private sessionId?;
+    /** Legacy SSE only: where to POST, announced by the stream's `endpoint` event. */
+    private postUrl?;
+    private readonly abort;
+    /** Serialises POSTs so messages leave in the order the host sent them. */
+    private chain;
+    private standingStreamOpened;
+    constructor(opts: HttpUpstreamOptions);
+    private connect;
+    private openSseEndpointStream;
+    /**
+     * Streamable HTTP: open the standing GET stream that carries server-initiated
+     * requests (`sampling/createMessage`, `elicitation/create`, list-changed
+     * notifications). A 405 means this server does not offer one — normal, and not
+     * an error: everything it sends will ride the POST responses instead.
+     */
+    private openStandingStream;
+    /** Read an SSE body, calling `onEvent(eventName, data)` per complete event. */
+    private pumpSse;
+    /** Hand one inbound JSON-RPC payload to the relay (or to a `bir:` waiter). */
+    private dispatch;
+    private target;
+    private sessionHeaders;
+    send(msg: JsonRpcMessage): void;
+    private post;
+    close(): void;
+}
+/**
+ * Adapt a Node stream of newline-delimited JSON into the message callback shape,
+ * used by the tests' in-process fakes. Exported here rather than in a test file
+ * so the production framing is what the fakes exercise.
+ */
+export declare function readFramesFrom(stream: Readable, onMessage: (msg: JsonRpcMessage) => void): () => void;
+//# sourceMappingURL=http-client.d.ts.map

package/dist/upstream/http-client.js

@@ -0,0 +1,261 @@
+/**
+ * http-client — a remote upstream over streamable HTTP or legacy SSE (Phase 2.2).
+ *
+ * Ported in shape from RRepeat's `mcp-http-client.ts`, but message-level rather
+ * than call-level: this transport must carry *any* frame in either direction,
+ * responses included (see the deviation note in `upstream/client.ts`).
+ *
+ * TWO TRANSPORTS, because both are in the wild:
+ *
+ *   - **streamable HTTP** (`--transport http`, current): every client→server
+ *     message is a POST to one endpoint. The reply comes back as a JSON body or
+ *     as an SSE stream carrying it. A session id handed out in the
+ *     `Mcp-Session-Id` response header must be echoed on every later request.
+ *     Server-initiated messages arrive on a standing GET stream, opened lazily
+ *     after `initialize` and skipped when the server answers 405.
+ *   - **legacy SSE** (`--transport sse`): a long-lived GET carries every reply
+ *     and announces the POST endpoint with an `endpoint` event, so the handshake
+ *     is inverted — you must be listening before you can send.
+ *
+ * AUTH (§9). The host's own OAuth authenticates the server it is *configured*
+ * with, which is now the proxy — so a remote upstream's credentials have to
+ * reach us some other way. They come from `--header` / the environment at spawn
+ * time and are held in memory only; nothing is written to disk here.
+ */
+import { readFrames } from "../jsonrpc/framing.js";
+import { logDetail, logLine, errText } from "../util/log.js";
+import { BaseUpstreamClient } from "./client.js";
+import { Readable } from "node:stream";
+export class HttpUpstreamClient extends BaseUpstreamClient {
+    ready;
+    url;
+    transport;
+    headers;
+    label;
+    connectTimeoutMs;
+    sessionId;
+    /** Legacy SSE only: where to POST, announced by the stream's `endpoint` event. */
+    postUrl;
+    abort = new AbortController();
+    /** Serialises POSTs so messages leave in the order the host sent them. */
+    chain = Promise.resolve();
+    standingStreamOpened = false;
+    constructor(opts) {
+        super();
+        this.url = opts.url;
+        this.transport = opts.transport ?? "http";
+        this.headers = opts.headers ?? {};
+        this.label = opts.label ?? new URL(opts.url).host;
+        this.connectTimeoutMs = opts.connectTimeoutMs ?? 15_000;
+        this.ready = this.connect();
+    }
+    async connect() {
+        if (this.transport === "sse")
+            await this.openSseEndpointStream();
+        // Streamable HTTP needs no connect step: the first POST is the handshake,
+        // and that POST is the host's own `initialize` relayed verbatim.
+    }
+    // ── legacy SSE: listen first, then learn where to POST ────────────────────
+    async openSseEndpointStream() {
+        const res = await fetch(this.url, {
+            method: "GET",
+            headers: { accept: "text/event-stream", ...this.headers },
+            signal: this.abort.signal,
+        });
+        if (!res.ok || !res.body) {
+            throw new Error(`SSE connect failed: ${res.status} ${res.statusText}`);
+        }
+        let announce;
+        const announced = new Promise((resolve) => {
+            announce = resolve;
+        });
+        void this.pumpSse(res.body, (event, data) => {
+            if (event === "endpoint") {
+                this.postUrl = new URL(data, this.url).toString();
+                announce?.();
+                return;
+            }
+            this.dispatch(data);
+        }).catch((err) => {
+            if (!this.dead) {
+                logLine("upstream.stream_ended", { server: this.label, error: errText(err) });
+                this.closed({ error: err instanceof Error ? err : new Error(String(err)) });
+            }
+        });
+        const timer = setTimeout(() => announce?.(), this.connectTimeoutMs);
+        await announced;
+        clearTimeout(timer);
+        if (!this.postUrl)
+            throw new Error("SSE server never announced its endpoint");
+    }
+    /**
+     * Streamable HTTP: open the standing GET stream that carries server-initiated
+     * requests (`sampling/createMessage`, `elicitation/create`, list-changed
+     * notifications). A 405 means this server does not offer one — normal, and not
+     * an error: everything it sends will ride the POST responses instead.
+     */
+    async openStandingStream() {
+        if (this.standingStreamOpened || this.transport !== "http")
+            return;
+        this.standingStreamOpened = true;
+        try {
+            const res = await fetch(this.url, {
+                method: "GET",
+                headers: { accept: "text/event-stream", ...this.sessionHeaders(), ...this.headers },
+                signal: this.abort.signal,
+            });
+            if (!res.ok || !res.body) {
+                logDetail("upstream.no_standing_stream", { server: this.label, status: res.status });
+                return;
+            }
+            void this.pumpSse(res.body, (_event, data) => this.dispatch(data)).catch(() => {
+                logDetail("upstream.standing_stream_ended", { server: this.label });
+            });
+        }
+        catch {
+            // No standing stream. Not fatal — see the doc comment above.
+        }
+    }
+    /** Read an SSE body, calling `onEvent(eventName, data)` per complete event. */
+    async pumpSse(body, onEvent) {
+        const reader = body.getReader();
+        const decoder = new TextDecoder();
+        let buf = "";
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return;
+            buf += decoder.decode(value, { stream: true });
+            let sep;
+            // Events are separated by a blank line; \r\n is legal too.
+            while ((sep = buf.search(/\r?\n\r?\n/)) !== -1) {
+                const raw = buf.slice(0, sep);
+                buf = buf.slice(sep + (buf[sep] === "\r" ? 4 : 2));
+                let event = "message";
+                const data = [];
+                for (const line of raw.split(/\r?\n/)) {
+                    if (line.startsWith("event:"))
+                        event = line.slice(6).trim();
+                    else if (line.startsWith("data:"))
+                        data.push(line.slice(5).replace(/^ /, ""));
+                }
+                if (data.length)
+                    onEvent(event, data.join("\n"));
+            }
+        }
+    }
+    /** Hand one inbound JSON-RPC payload to the relay (or to a `bir:` waiter). */
+    dispatch(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            logDetail("upstream.unparseable", { server: this.label, sample: raw.slice(0, 120) });
+            return;
+        }
+        if (!msg || typeof msg !== "object" || Array.isArray(msg))
+            return;
+        this.accept(msg);
+    }
+    target() {
+        return this.transport === "sse" ? (this.postUrl ?? this.url) : this.url;
+    }
+    sessionHeaders() {
+        return this.sessionId ? { "mcp-session-id": this.sessionId } : {};
+    }
+    send(msg) {
+        if (this.dead)
+            return;
+        logDetail("upstream.send", {
+            server: this.label,
+            method: msg.method,
+        });
+        // Serialised: MCP is order-sensitive (`initialize` before anything else, and
+        // `notifications/initialized` before the first call), and parallel fetches
+        // would let a later POST overtake an earlier one.
+        this.chain = this.chain.then(() => this.post(msg)).catch(() => undefined);
+    }
+    async post(msg) {
+        const isInitialize = msg.method === "initialize";
+        try {
+            const res = await fetch(this.target(), {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    accept: "application/json, text/event-stream",
+                    ...this.sessionHeaders(),
+                    ...this.headers,
+                },
+                body: JSON.stringify(msg),
+                signal: this.abort.signal,
+            });
+            const sid = res.headers.get("mcp-session-id");
+            if (sid)
+                this.sessionId = sid;
+            if (!res.ok) {
+                // A transport-level failure toward a request needs an answer, or the
+                // host waits forever. The relay owns that decision, so surface it as a
+                // JSON-RPC error response on the inbound path.
+                const id = msg.id;
+                const text = await res.text().catch(() => "");
+                logLine("upstream.http_error", {
+                    server: this.label,
+                    status: res.status,
+                    method: msg.method,
+                });
+                if (id !== undefined && id !== null) {
+                    this.accept({
+                        jsonrpc: "2.0",
+                        id: id,
+                        error: {
+                            code: -32000,
+                            message: `upstream HTTP ${res.status} ${res.statusText}${text ? ` — ${text.slice(0, 500)}` : ""}`,
+                        },
+                    });
+                }
+                return;
+            }
+            const contentType = res.headers.get("content-type") ?? "";
+            if (contentType.includes("text/event-stream") && res.body) {
+                void this.pumpSse(res.body, (_event, data) => this.dispatch(data)).catch(() => undefined);
+            }
+            else if (this.transport !== "sse") {
+                const text = await res.text();
+                if (text.trim())
+                    this.dispatch(text);
+                // An empty body is a 202-style acknowledgement — normal for notifications.
+            }
+            if (isInitialize)
+                void this.openStandingStream();
+        }
+        catch (err) {
+            if (this.abort.signal.aborted)
+                return;
+            const id = msg.id;
+            logLine("upstream.send_failed", { server: this.label, error: errText(err) });
+            if (id !== undefined && id !== null) {
+                this.accept({
+                    jsonrpc: "2.0",
+                    id: id,
+                    error: { code: -32000, message: `upstream unreachable: ${errText(err)}` },
+                });
+            }
+        }
+    }
+    close() {
+        if (this.dead)
+            return;
+        this.closed({});
+        this.abort.abort();
+    }
+}
+/**
+ * Adapt a Node stream of newline-delimited JSON into the message callback shape,
+ * used by the tests' in-process fakes. Exported here rather than in a test file
+ * so the production framing is what the fakes exercise.
+ */
+export function readFramesFrom(stream, onMessage) {
+    return readFrames(stream, { onMessage });
+}
+//# sourceMappingURL=http-client.js.map

package/dist/upstream/lazy-client.d.ts

@@ -0,0 +1,31 @@
+/**
+ * lazy-client — defer creating the real upstream until the host first speaks.
+ *
+ * WHAT `--lazy` CAN AND CANNOT BUY (docs §13, open question 3). Phase 8 suggests
+ * deferring the upstream spawn "until the first `tools/list`". That is not
+ * reachable without breaking Phase 3: answering `initialize` before the upstream
+ * exists means *fabricating* capabilities and `serverInfo`, which is precisely
+ * the mistake that makes a proxy silently swallow prompts and resources.
+ *
+ * So the honest deferral is one message earlier: the upstream is created on the
+ * **first host message**, whatever it is. For a client that connects its MCP
+ * servers at session start (Claude Code does) that saves nothing, because
+ * `initialize` arrives immediately. For a client that spawns servers eagerly but
+ * connects them on demand, it saves the whole upstream process until it is used.
+ * The flag is opt-in for exactly that reason, and this comment is the measurement
+ * the open question asks for: the saving is a property of the host, not of us.
+ */
+import type { JsonRpcMessage } from "../jsonrpc/types.js";
+import { BaseUpstreamClient, type UpstreamClient } from "./client.js";
+export declare class LazyUpstreamClient extends BaseUpstreamClient {
+    readonly ready: Promise<void>;
+    private inner?;
+    private readonly create;
+    private resolveReady;
+    private rejectReady;
+    constructor(create: () => UpstreamClient);
+    private ensure;
+    send(msg: JsonRpcMessage): void;
+    close(): void;
+}
+//# sourceMappingURL=lazy-client.d.ts.map

package/dist/upstream/lazy-client.js

@@ -0,0 +1,53 @@
+/**
+ * lazy-client — defer creating the real upstream until the host first speaks.
+ *
+ * WHAT `--lazy` CAN AND CANNOT BUY (docs §13, open question 3). Phase 8 suggests
+ * deferring the upstream spawn "until the first `tools/list`". That is not
+ * reachable without breaking Phase 3: answering `initialize` before the upstream
+ * exists means *fabricating* capabilities and `serverInfo`, which is precisely
+ * the mistake that makes a proxy silently swallow prompts and resources.
+ *
+ * So the honest deferral is one message earlier: the upstream is created on the
+ * **first host message**, whatever it is. For a client that connects its MCP
+ * servers at session start (Claude Code does) that saves nothing, because
+ * `initialize` arrives immediately. For a client that spawns servers eagerly but
+ * connects them on demand, it saves the whole upstream process until it is used.
+ * The flag is opt-in for exactly that reason, and this comment is the measurement
+ * the open question asks for: the saving is a property of the host, not of us.
+ */
+import { BaseUpstreamClient } from "./client.js";
+export class LazyUpstreamClient extends BaseUpstreamClient {
+    ready;
+    inner;
+    create;
+    resolveReady;
+    rejectReady;
+    constructor(create) {
+        super();
+        this.create = create;
+        this.ready = new Promise((resolve, reject) => {
+            this.resolveReady = resolve;
+            this.rejectReady = reject;
+        });
+    }
+    ensure() {
+        if (this.inner)
+            return this.inner;
+        const inner = this.create();
+        this.inner = inner;
+        inner.onMessage((msg) => this.accept(msg));
+        inner.onClose((info) => this.closed(info));
+        inner.ready.then(() => this.resolveReady(), (err) => this.rejectReady(err instanceof Error ? err : new Error(String(err))));
+        return inner;
+    }
+    send(msg) {
+        if (this.dead)
+            return;
+        this.ensure().send(msg);
+    }
+    close() {
+        this.inner?.close();
+        this.closed({});
+    }
+}
+//# sourceMappingURL=lazy-client.js.map

package/dist/upstream/stdio-client.d.ts

@@ -0,0 +1,57 @@
+/**
+ * stdio-client — an upstream MCP server spawned as a child process (Phase 2.1).
+ *
+ * TWO THINGS THAT BREAK STDIO PROXIES, both handled here:
+ *
+ *  1. **The upstream's stderr must never reach our stdout.** Our stdout *is* the
+ *     host's JSON-RPC stream; one stray byte desynchronises it and the failure
+ *     surfaces as an unrelated MCP error. Upstream stderr is forwarded to *our*
+ *     stderr, line-prefixed with the server name so a multi-proxy session stays
+ *     readable.
+ *  2. **Windows `.cmd` resolution.** `npx` on Windows is `npx.cmd`, and since
+ *     Node 20.12 a `.cmd`/`.bat` cannot be spawned without a shell. Rather than
+ *     hand the whole command line to `shell: true` (which re-parses arguments and
+ *     mangles JSON), {@link resolveCommand} resolves the real file on PATH and,
+ *     for a batch file, invokes `cmd.exe /d /s /c` with `windowsVerbatimArguments`
+ *     and its own quoting.
+ */
+import type { JsonRpcMessage } from "../jsonrpc/types.js";
+import { BaseUpstreamClient } from "./client.js";
+export interface StdioUpstreamOptions {
+    command: string;
+    args?: string[];
+    env?: Record<string, string | undefined>;
+    cwd?: string;
+    /** Prefix for forwarded stderr lines. Defaults to the command itself. */
+    label?: string;
+    /** Restart once with this backoff if the upstream dies unexpectedly. 0 disables. */
+    restartDelayMs?: number;
+}
+/** What `spawn` should actually be given for `command` on this platform. */
+export interface ResolvedCommand {
+    command: string;
+    args: string[];
+    windowsVerbatimArguments?: boolean;
+}
+/** Find `command` on PATH, trying PATHEXT extensions. Returns undefined if absent. */
+export declare function whichSync(command: string, env?: NodeJS.ProcessEnv): string | undefined;
+/**
+ * Turn `(command, args)` into something `spawn` can run with `shell: false`.
+ * On POSIX this is the identity. On Windows a batch file is wrapped in `cmd.exe`.
+ */
+export declare function resolveCommand(command: string, args: string[], env?: NodeJS.ProcessEnv): ResolvedCommand;
+export declare class StdioUpstreamClient extends BaseUpstreamClient {
+    readonly ready: Promise<void>;
+    private child?;
+    private detach?;
+    private readonly label;
+    private readonly opts;
+    private restartsLeft;
+    private closing;
+    constructor(opts: StdioUpstreamOptions);
+    private start;
+    private onChildGone;
+    send(msg: JsonRpcMessage): void;
+    close(): void;
+}
+//# sourceMappingURL=stdio-client.d.ts.map

package/dist/upstream/stdio-client.js

@@ -0,0 +1,203 @@
+/**
+ * stdio-client — an upstream MCP server spawned as a child process (Phase 2.1).
+ *
+ * TWO THINGS THAT BREAK STDIO PROXIES, both handled here:
+ *
+ *  1. **The upstream's stderr must never reach our stdout.** Our stdout *is* the
+ *     host's JSON-RPC stream; one stray byte desynchronises it and the failure
+ *     surfaces as an unrelated MCP error. Upstream stderr is forwarded to *our*
+ *     stderr, line-prefixed with the server name so a multi-proxy session stays
+ *     readable.
+ *  2. **Windows `.cmd` resolution.** `npx` on Windows is `npx.cmd`, and since
+ *     Node 20.12 a `.cmd`/`.bat` cannot be spawned without a shell. Rather than
+ *     hand the whole command line to `shell: true` (which re-parses arguments and
+ *     mangles JSON), {@link resolveCommand} resolves the real file on PATH and,
+ *     for a batch file, invokes `cmd.exe /d /s /c` with `windowsVerbatimArguments`
+ *     and its own quoting.
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { readFrames, writeFrame } from "../jsonrpc/framing.js";
+import { logDetail, logLine, errText } from "../util/log.js";
+import { BaseUpstreamClient } from "./client.js";
+const BATCH_EXT = /\.(cmd|bat)$/i;
+/** Quote one argument for `cmd.exe /c`, which re-parses what it is handed. */
+function quoteForCmd(arg) {
+    return '"' + arg.replace(/"/g, '""') + '"';
+}
+/** Find `command` on PATH, trying PATHEXT extensions. Returns undefined if absent. */
+export function whichSync(command, env = process.env) {
+    if (isAbsolute(command) || command.includes("/") || command.includes("\\")) {
+        return existsSync(command) ? command : undefined;
+    }
+    const exts = process.platform === "win32"
+        ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean)
+        : [""];
+    const dirs = (env.PATH ?? "").split(delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        for (const ext of exts) {
+            const candidate = join(dir, command + ext);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return undefined;
+}
+/**
+ * Turn `(command, args)` into something `spawn` can run with `shell: false`.
+ * On POSIX this is the identity. On Windows a batch file is wrapped in `cmd.exe`.
+ */
+export function resolveCommand(command, args, env = process.env) {
+    if (process.platform !== "win32")
+        return { command, args };
+    const resolved = whichSync(command, env) ?? command;
+    if (!BATCH_EXT.test(resolved))
+        return { command: resolved, args };
+    const comspec = env.ComSpec ?? env.COMSPEC ?? "cmd.exe";
+    const line = [resolved, ...args].map(quoteForCmd).join(" ");
+    return {
+        command: comspec,
+        // `/d` skips AutoRun, `/s` makes cmd strip exactly the outer pair of quotes
+        // around the whole command, which is what lets our own quoting survive.
+        args: ["/d", "/s", "/c", '"' + line + '"'],
+        windowsVerbatimArguments: true,
+    };
+}
+export class StdioUpstreamClient extends BaseUpstreamClient {
+    ready;
+    child;
+    detach;
+    label;
+    opts;
+    restartsLeft;
+    closing = false;
+    constructor(opts) {
+        super();
+        this.opts = opts;
+        this.label = opts.label ?? opts.command;
+        this.restartsLeft = opts.restartDelayMs && opts.restartDelayMs > 0 ? 1 : 0;
+        this.ready = this.start();
+    }
+    start() {
+        const { command, args = [], env, cwd } = this.opts;
+        const spawnEnv = { ...process.env, ...env };
+        const resolved = resolveCommand(command, args, spawnEnv);
+        return new Promise((resolve, reject) => {
+            let child;
+            try {
+                child = spawn(resolved.command, resolved.args, {
+                    cwd,
+                    env: spawnEnv,
+                    stdio: ["pipe", "pipe", "pipe"],
+                    shell: false,
+                    windowsHide: true,
+                    windowsVerbatimArguments: resolved.windowsVerbatimArguments,
+                });
+            }
+            catch (err) {
+                reject(err instanceof Error ? err : new Error(String(err)));
+                return;
+            }
+            this.child = child;
+            child.once("spawn", () => {
+                logLine("upstream.spawned", {
+                    server: this.label,
+                    pid: child.pid,
+                    command: resolved.command,
+                });
+                resolve();
+            });
+            child.once("error", (err) => {
+                // A spawn failure (ENOENT) and a mid-life error arrive the same way.
+                reject(err);
+                this.onChildGone({ error: err });
+            });
+            child.once("exit", (code, signal) => this.onChildGone({ code, signal }));
+            this.detach = readFrames(child.stdout, {
+                onMessage: (msg) => this.accept(msg),
+                onParseError: (d) => logLine("upstream.unparseable", {
+                    server: this.label,
+                    reason: d.reason,
+                    bytes: d.bytes,
+                }),
+            });
+            // Upstream stderr → our stderr, never our stdout. Line-prefixed.
+            let errBuf = "";
+            child.stderr.setEncoding("utf8");
+            child.stderr.on("data", (chunk) => {
+                errBuf += chunk;
+                let nl;
+                while ((nl = errBuf.indexOf("\n")) !== -1) {
+                    const line = errBuf.slice(0, nl).replace(/\r$/, "");
+                    errBuf = errBuf.slice(nl + 1);
+                    if (line)
+                        process.stderr.write("[" + this.label + "] " + line + "\n");
+                }
+            });
+        });
+    }
+    onChildGone(info) {
+        this.detach?.();
+        this.detach = undefined;
+        if (this.closing) {
+            this.closed(info);
+            return;
+        }
+        logLine("upstream.exited", {
+            server: this.label,
+            code: info.code,
+            signal: info.signal,
+            error: info.error ? errText(info.error) : undefined,
+        });
+        if (this.restartsLeft > 0) {
+            this.restartsLeft -= 1;
+            const delay = this.opts.restartDelayMs ?? 500;
+            logLine("upstream.restarting", { server: this.label, delayMs: delay });
+            const timer = setTimeout(() => {
+                this.start().catch((err) => {
+                    logLine("upstream.restart_failed", { server: this.label, error: errText(err) });
+                    this.closed({ error: err instanceof Error ? err : new Error(String(err)) });
+                });
+            }, delay);
+            timer.unref?.();
+            return;
+        }
+        // Dead for good. The relay answers in-flight requests and stays up: the host
+        // sees one broken server, not a broken session (§10).
+        this.closed(info);
+    }
+    send(msg) {
+        const child = this.child;
+        if (!child || this.dead || child.stdin.destroyed)
+            return;
+        logDetail("upstream.send", {
+            server: this.label,
+            method: msg.method,
+        });
+        writeFrame(child.stdin, msg, (err) => logLine("upstream.write_failed", { server: this.label, error: errText(err) }));
+    }
+    close() {
+        this.closing = true;
+        this.detach?.();
+        const child = this.child;
+        if (!child) {
+            this.closed({});
+            return;
+        }
+        try {
+            child.stdin.end();
+        }
+        catch {
+            /* already gone */
+        }
+        try {
+            child.kill();
+        }
+        catch {
+            /* already gone */
+        }
+        this.closed({});
+    }
+}
+//# sourceMappingURL=stdio-client.js.map