@chances-ai/wire 24.0.0

package/dist/serve/replay-hub.d.ts

@@ -0,0 +1,102 @@
+/**
+ * (v19 M2 / docs/6.2 §3.2; v20 M3) `ReplayHub` — the seq-stamping, fan-out
+ * `ByteSink` with a bounded replay ring. The engine driver (M3: `AcpEngineDriver`)
+ * writes its outbound frames through a `BoundedNdjsonWriter` whose sink is this
+ * hub. The hub:
+ *
+ *   1. stamps a relay-authoritative monotonic `rseq` on every frame (the
+ *      reconnect cursor — `stampSeq`, a payload-agnostic byte splice);
+ *   2. keeps the last N stamped frames in a fixed-capacity ring so a
+ *      reconnecting client can replay the gap (`replaySince`); a cursor below
+ *      the ring floor gets a typed `reset` (cold reload — never a silent gap);
+ *   3. fans the stamped frame out to EVERY attached socket (no exclusive
+ *      controller — the goose/OpenHands model), guarding each send so a
+ *      closed/wedged socket is isolated and never blocks the others or the
+ *      engine.
+ *
+ * Session state (`busy` + open `request_permission` ids) is read straight off
+ * the `AcpEngineDriver` (authoritative) by `AcpSessionHost`, NOT snooped from the
+ * fan-out bytes — so the hub stays a pure payload-agnostic seq/replay/fan-out
+ * layer. (A byte-snoop lived here in the chances-rpc era; it was removed with the
+ * M3 hard cutover, since ACP frames' first key is `rseq`/`jsonrpc`, never `type`.)
+ *
+ * **The engine never blocks on a slow remote.** `write()` ALWAYS returns `true`:
+ * the ring is the durable buffer, so there is no reason to park the writer (and
+ * parking on the slowest of many fan-out sockets would let one stalled tab
+ * throttle everyone — the exact failure goose avoids by never blocking the
+ * producer and dropping a lagging subscriber instead). A socket that stops
+ * draining is dropped past a hard byte cap; it reconnects and replays from the
+ * ring. JS's single thread makes seq-assign + ring-push naturally atomic — no
+ * lock (unlike goose's Rust `Mutex`).
+ *
+ * Socket-free by construction (fake {@link ServerSocket}s in tests).
+ */
+import { type ByteSink } from "../rpc/index.js";
+import type { ServerSocket } from "./ws-transport.js";
+/** Default ring depth (frames). Generous vs goose's 512 / claude-code's 5000;
+ *  a normal turn is well under this, so a transient drop replays in full. */
+export declare const DEFAULT_RING_CAPACITY = 4096;
+export interface ReplayHubOptions {
+    /** Ring depth in frames. Default {@link DEFAULT_RING_CAPACITY}. */
+    capacity?: number;
+}
+export interface ReplaySlice {
+    /** True ⇒ the client's cursor predates the ring floor; it must discard its
+     *  transcript and take `frames` (the whole live ring) as a cold reload. */
+    reset: boolean;
+    /** The stamped frame lines to replay, in ascending `rseq` order. */
+    frames: string[];
+}
+export declare class ReplayHub implements ByteSink {
+    private readonly capacity;
+    /** Fixed-size circular buffer of stamped frames (O(1) push + evict-oldest, no
+     *  per-frame `Array.shift`). `start` is the oldest slot; `count` ≤ capacity. */
+    private readonly buf;
+    private start;
+    private count;
+    private counter;
+    private readonly sockets;
+    private drainWaiters;
+    constructor(opts?: ReplayHubOptions);
+    /**
+     * Stamp + ring + fan-out. ALWAYS returns `true` — the engine/writer
+     * never parks on a slow remote (the ring is the durable buffer). Receives the
+     * writer's `JSON.stringify(frame) + "\n"`; `stampSeq` splices `rseq` after the
+     * leading `{`, leaving the trailing newline untouched.
+     */
+    write(chunk: string): boolean;
+    /** Dormant in M2: `write` never returns `false`, so the writer never awaits a
+     *  drain. Kept faithful to the `ByteSink` contract (and woken by
+     *  {@link signalDrain}) in case a future path parks. */
+    once(_event: "drain", listener: () => void): void;
+    /** Release any (dormant) parked writer — e.g. a socket became writable. */
+    signalDrain(): void;
+    private ringPush;
+    /** The highest `rseq` assigned (0 ⇒ nothing written yet). */
+    get headSeq(): number;
+    /** The oldest `rseq` still replayable (0 ⇒ ring empty). */
+    get floorSeq(): number;
+    /**
+     * Frames a client at `lastSeq` has missed. `reset` ⇒ its cursor is below the
+     * ring floor (unrecoverable) — the caller cold-reloads it with the whole ring.
+     * Mirrors goose `subscribe`: `last_id > 0 && floor > 0 && last_id < floor`
+     * ⇒ too far behind.
+     */
+    replaySince(lastSeq: number): ReplaySlice;
+    /** Add a socket to the live fan-out set. Caller (SessionHost) has already sent
+     *  the welcome + replay synchronously, so the first live frame this socket
+     *  sees is strictly newer than everything replayed (disjoint, in order). */
+    addSocket(socket: ServerSocket): void;
+    removeSocket(socket: ServerSocket): void;
+    get socketCount(): number;
+    /**
+     * Send one stamped frame to a single socket, guarded: a dead socket
+     * (`send===0`) or a wedged one (buffer past the hard cap) is dropped + closed,
+     * never throwing, never blocking the others. Returns whether the socket stays
+     * attached. Reused by {@link SessionHost} for the synchronous replay path so
+     * replay + live share one robust send.
+     */
+    sendTo(socket: ServerSocket, line: string): boolean;
+    private fanout;
+}
+//# sourceMappingURL=replay-hub.d.ts.map

package/dist/serve/replay-hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-hub.d.ts","sourceRoot":"","sources":["../../src/serve/replay-hub.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;6EAC6E;AAC7E,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAY1C,MAAM,WAAW,gBAAgB;IAC/B,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B;+EAC2E;IAC3E,KAAK,EAAE,OAAO,CAAC;IACf,oEAAoE;IACpE,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,qBAAa,SAAU,YAAW,QAAQ;IACxC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC;oFACgF;IAChF,OAAO,CAAC,QAAQ,CAAC,GAAG,CAA2B;IAC/C,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,KAAK,CAAK;IAElB,OAAO,CAAC,OAAO,CAAK;IAEpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,YAAY,CAAyB;gBAEjC,IAAI,GAAE,gBAAqB;IAOvC;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAQ7B;;4DAEwD;IACxD,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAIjD,2EAA2E;IAC3E,WAAW,IAAI,IAAI;IAQnB,OAAO,CAAC,QAAQ;IAWhB,6DAA6D;IAC7D,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,2DAA2D;IAC3D,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW;IAezC;;gFAE4E;IAC5E,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAIrC,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAIxC,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO;IAyBnD,OAAO,CAAC,MAAM;CAKf"}

package/dist/serve/replay-hub.js

@@ -0,0 +1,176 @@
+/**
+ * (v19 M2 / docs/6.2 §3.2; v20 M3) `ReplayHub` — the seq-stamping, fan-out
+ * `ByteSink` with a bounded replay ring. The engine driver (M3: `AcpEngineDriver`)
+ * writes its outbound frames through a `BoundedNdjsonWriter` whose sink is this
+ * hub. The hub:
+ *
+ *   1. stamps a relay-authoritative monotonic `rseq` on every frame (the
+ *      reconnect cursor — `stampSeq`, a payload-agnostic byte splice);
+ *   2. keeps the last N stamped frames in a fixed-capacity ring so a
+ *      reconnecting client can replay the gap (`replaySince`); a cursor below
+ *      the ring floor gets a typed `reset` (cold reload — never a silent gap);
+ *   3. fans the stamped frame out to EVERY attached socket (no exclusive
+ *      controller — the goose/OpenHands model), guarding each send so a
+ *      closed/wedged socket is isolated and never blocks the others or the
+ *      engine.
+ *
+ * Session state (`busy` + open `request_permission` ids) is read straight off
+ * the `AcpEngineDriver` (authoritative) by `AcpSessionHost`, NOT snooped from the
+ * fan-out bytes — so the hub stays a pure payload-agnostic seq/replay/fan-out
+ * layer. (A byte-snoop lived here in the chances-rpc era; it was removed with the
+ * M3 hard cutover, since ACP frames' first key is `rseq`/`jsonrpc`, never `type`.)
+ *
+ * **The engine never blocks on a slow remote.** `write()` ALWAYS returns `true`:
+ * the ring is the durable buffer, so there is no reason to park the writer (and
+ * parking on the slowest of many fan-out sockets would let one stalled tab
+ * throttle everyone — the exact failure goose avoids by never blocking the
+ * producer and dropping a lagging subscriber instead). A socket that stops
+ * draining is dropped past a hard byte cap; it reconnects and replays from the
+ * ring. JS's single thread makes seq-assign + ring-push naturally atomic — no
+ * lock (unlike goose's Rust `Mutex`).
+ *
+ * Socket-free by construction (fake {@link ServerSocket}s in tests).
+ */
+import { stampSeq } from "../rpc/index.js";
+/** Default ring depth (frames). Generous vs goose's 512 / claude-code's 5000;
+ *  a normal turn is well under this, so a transient drop replays in full. */
+export const DEFAULT_RING_CAPACITY = 4096;
+/** Drop a socket whose own send buffer grows past this (a wedged reader). 16 MiB
+ *  is far above any loopback steady state — it only catches a truly stuck client
+ *  so relay memory stays bounded. The dropped client reconnects + replays. */
+const WEDGED_SOCKET_BYTES = 16 * 1024 * 1024;
+export class ReplayHub {
+    capacity;
+    /** Fixed-size circular buffer of stamped frames (O(1) push + evict-oldest, no
+     *  per-frame `Array.shift`). `start` is the oldest slot; `count` ≤ capacity. */
+    buf;
+    start = 0;
+    count = 0;
+    counter = 0; // last assigned rseq (monotonic, from 1)
+    sockets = new Set();
+    drainWaiters = [];
+    constructor(opts = {}) {
+        this.capacity = Math.max(1, opts.capacity ?? DEFAULT_RING_CAPACITY);
+        this.buf = new Array(this.capacity);
+    }
+    // -- ByteSink (the BoundedNdjsonWriter writes through this) -----------------
+    /**
+     * Stamp + ring + fan-out. ALWAYS returns `true` — the engine/writer
+     * never parks on a slow remote (the ring is the durable buffer). Receives the
+     * writer's `JSON.stringify(frame) + "\n"`; `stampSeq` splices `rseq` after the
+     * leading `{`, leaving the trailing newline untouched.
+     */
+    write(chunk) {
+        const seq = ++this.counter;
+        const stamped = stampSeq(chunk, seq);
+        this.ringPush(seq, stamped);
+        this.fanout(stamped);
+        return true;
+    }
+    /** Dormant in M2: `write` never returns `false`, so the writer never awaits a
+     *  drain. Kept faithful to the `ByteSink` contract (and woken by
+     *  {@link signalDrain}) in case a future path parks. */
+    once(_event, listener) {
+        this.drainWaiters.push(listener);
+    }
+    /** Release any (dormant) parked writer — e.g. a socket became writable. */
+    signalDrain() {
+        const waiters = this.drainWaiters;
+        this.drainWaiters = [];
+        for (const fn of waiters)
+            fn();
+    }
+    // -- ring -------------------------------------------------------------------
+    ringPush(seq, line) {
+        if (this.count < this.capacity) {
+            this.buf[(this.start + this.count) % this.capacity] = { seq, line };
+            this.count++;
+        }
+        else {
+            // Full: overwrite the oldest slot and advance the floor. O(1).
+            this.buf[this.start] = { seq, line };
+            this.start = (this.start + 1) % this.capacity;
+        }
+    }
+    /** The highest `rseq` assigned (0 ⇒ nothing written yet). */
+    get headSeq() {
+        return this.counter;
+    }
+    /** The oldest `rseq` still replayable (0 ⇒ ring empty). */
+    get floorSeq() {
+        return this.count === 0 ? 0 : this.buf[this.start].seq;
+    }
+    /**
+     * Frames a client at `lastSeq` has missed. `reset` ⇒ its cursor is below the
+     * ring floor (unrecoverable) — the caller cold-reloads it with the whole ring.
+     * Mirrors goose `subscribe`: `last_id > 0 && floor > 0 && last_id < floor`
+     * ⇒ too far behind.
+     */
+    replaySince(lastSeq) {
+        const floor = this.floorSeq;
+        const reset = lastSeq > 0 && floor > 0 && lastSeq < floor;
+        const since = reset ? 0 : lastSeq;
+        const frames = [];
+        // Ring order is strictly ascending in `seq`; collect the suffix `seq > since`.
+        for (let i = 0; i < this.count; i++) {
+            const slot = this.buf[(this.start + i) % this.capacity];
+            if (slot.seq > since)
+                frames.push(slot.line);
+        }
+        return { reset, frames };
+    }
+    // -- fan-out ----------------------------------------------------------------
+    /** Add a socket to the live fan-out set. Caller (SessionHost) has already sent
+     *  the welcome + replay synchronously, so the first live frame this socket
+     *  sees is strictly newer than everything replayed (disjoint, in order). */
+    addSocket(socket) {
+        this.sockets.add(socket);
+    }
+    removeSocket(socket) {
+        this.sockets.delete(socket);
+    }
+    get socketCount() {
+        return this.sockets.size;
+    }
+    /**
+     * Send one stamped frame to a single socket, guarded: a dead socket
+     * (`send===0`) or a wedged one (buffer past the hard cap) is dropped + closed,
+     * never throwing, never blocking the others. Returns whether the socket stays
+     * attached. Reused by {@link SessionHost} for the synchronous replay path so
+     * replay + live share one robust send.
+     */
+    sendTo(socket, line) {
+        let sent;
+        try {
+            sent = socket.send(line);
+        }
+        catch {
+            this.sockets.delete(socket);
+            return false; // socket threw mid-send (closing) — isolate it
+        }
+        if (sent === 0) {
+            this.sockets.delete(socket);
+            return false; // dropped/dead
+        }
+        const buffered = socket.bufferedAmount;
+        if (buffered !== undefined && buffered > WEDGED_SOCKET_BYTES) {
+            this.sockets.delete(socket);
+            try {
+                socket.close(1013, "relay: client too slow");
+            }
+            catch {
+                /* already gone */
+            }
+            return false;
+        }
+        return true; // sent or backpressured-but-enqueued (-1) — stays attached
+    }
+    fanout(stamped) {
+        if (this.sockets.size === 0)
+            return;
+        // Snapshot so a removal during iteration (a guard-drop) is safe.
+        for (const socket of [...this.sockets])
+            this.sendTo(socket, stamped);
+    }
+}
+//# sourceMappingURL=replay-hub.js.map

package/dist/serve/replay-hub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay-hub.js","sourceRoot":"","sources":["../../src/serve/replay-hub.ts"],"names":[],"mappings":"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"}

package/dist/serve/tls.d.ts

@@ -0,0 +1,20 @@
+export interface SelfSignedCert {
+    /** PEM certificate. */
+    cert: string;
+    /** PEM private key. */
+    key: string;
+    /** SHA-256 fingerprint of the DER cert: uppercase colon-separated hex (goose's
+     *  format — exactly what a client pins). */
+    fingerprint: string;
+}
+/**
+ * Generate a self-signed EC (P-256, ECDSA-SHA256) cert valid for `hosts` (always
+ * plus `localhost` + `127.0.0.1`). `now` is injected so the validity window is
+ * deterministic in tests. Async — WebCrypto under the hood (proven to survive
+ * `bun --compile` in the Stage 0 spike).
+ */
+export declare function generateSelfSignedCert(hosts: string[], now?: number, validityDays?: number): Promise<SelfSignedCert>;
+/** SHA-256 fingerprint of a PEM cert (over its DER bytes), uppercase colon hex —
+ *  the value printed to stderr + embedded in the QR + pinned by clients. */
+export declare function fingerprintOf(certPem: string): string;
+//# sourceMappingURL=tls.d.ts.map

package/dist/serve/tls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tls.d.ts","sourceRoot":"","sources":["../../src/serve/tls.ts"],"names":[],"mappings":"AAgBA,MAAM,WAAW,cAAc;IAC7B,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,uBAAuB;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ;gDAC4C;IAC5C,WAAW,EAAE,MAAM,CAAC;CACrB;AAMD;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,GAAE,MAAmB,EAAE,YAAY,GAAE,MAA8B,GAAG,OAAO,CAAC,cAAc,CAAC,CAa7J;AAED;4EAC4E;AAC5E,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/serve/tls.js

@@ -0,0 +1,64 @@
+/**
+ * (v21 M4 / docs/6.5 §3) Self-signed TLS for a non-loopback `chances serve`,
+ * mirroring goose's model (`crates/goose-server/src/tls.rs`). On a LAN bind we
+ * generate a self-signed cert (SAN = the bound host + `localhost` + `127.0.0.1`),
+ * print its SHA-256 fingerprint, and clients PIN it (TOFU — defeats LAN MITM even
+ * with a self-signed cert). The CLI CACHES the cert (in the vault) so the
+ * fingerprint is stable across restarts — a client pairs once.
+ *
+ * This module is PURE cert generation + fingerprinting; caching/storage is the
+ * CLI's job (the relay stays storage-free). The fingerprint is SHA-256 of the DER
+ * cert, derived here via node:crypto's `X509Certificate.fingerprint256` — NOT
+ * selfsigned's own `.fingerprint`, which is SHA-1 (the Stage 0 spike caught this).
+ */
+import { X509Certificate } from "node:crypto";
+import { generate } from "selfsigned";
+/** Default cert validity. 825 days = the CA/Browser-forum max for leaf certs;
+ *  ample for a long-lived local pairing, re-mintable any time. */
+const DEFAULT_VALIDITY_DAYS = 825;
+/**
+ * Generate a self-signed EC (P-256, ECDSA-SHA256) cert valid for `hosts` (always
+ * plus `localhost` + `127.0.0.1`). `now` is injected so the validity window is
+ * deterministic in tests. Async — WebCrypto under the hood (proven to survive
+ * `bun --compile` in the Stage 0 spike).
+ */
+export async function generateSelfSignedCert(hosts, now = Date.now(), validityDays = DEFAULT_VALIDITY_DAYS) {
+    const pems = await generate([{ name: "commonName", value: "chances serve" }], {
+        keyType: "ec",
+        curve: "P-256",
+        algorithm: "sha256",
+        notBeforeDate: new Date(now),
+        notAfterDate: new Date(now + validityDays * 24 * 3600 * 1000),
+        extensions: [
+            { name: "basicConstraints", cA: false, critical: true },
+            { name: "subjectAltName", altNames: buildAltNames(hosts) },
+        ],
+    });
+    return { cert: pems.cert, key: pems.private, fingerprint: fingerprintOf(pems.cert) };
+}
+/** SHA-256 fingerprint of a PEM cert (over its DER bytes), uppercase colon hex —
+ *  the value printed to stderr + embedded in the QR + pinned by clients. */
+export function fingerprintOf(certPem) {
+    return new X509Certificate(certPem).fingerprint256;
+}
+/** SAN list: `localhost` + `127.0.0.1` are always present (the loopback aliases),
+ *  plus each requested host classified as DNS (type 2) or IP (type 7). Deduped. */
+function buildAltNames(hosts) {
+    const dns = new Set(["localhost"]);
+    const ips = new Set(["127.0.0.1"]);
+    for (const h of hosts) {
+        if (h === "0.0.0.0" || h === "::")
+            continue; // wildcard binds are not a SAN
+        if (isIpLiteral(h))
+            ips.add(h);
+        else
+            dns.add(h);
+    }
+    return [...[...dns].map((value) => ({ type: 2, value })), ...[...ips].map((ip) => ({ type: 7, ip }))];
+}
+/** Crude IPv4/IPv6 literal check (enough to route a host into the right SAN
+ *  slot; a hostname with letters is DNS, a dotted-quad or colon form is an IP). */
+function isIpLiteral(h) {
+    return /^\d{1,3}(\.\d{1,3}){3}$/.test(h) || h.includes(":");
+}
+//# sourceMappingURL=tls.js.map

package/dist/serve/tls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tls.js","sourceRoot":"","sources":["../../src/serve/tls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAYtC;kEACkE;AAClE,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAElC;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,KAAe,EAAE,MAAc,IAAI,CAAC,GAAG,EAAE,EAAE,eAAuB,qBAAqB;IAClI,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,eAAe,EAAE,CAAC,EAAE;QAC5E,OAAO,EAAE,IAAI;QACb,KAAK,EAAE,OAAO;QACd,SAAS,EAAE,QAAQ;QACnB,aAAa,EAAE,IAAI,IAAI,CAAC,GAAG,CAAC;QAC5B,YAAY,EAAE,IAAI,IAAI,CAAC,GAAG,GAAG,YAAY,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;QAC7D,UAAU,EAAE;YACV,EAAE,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE;YACvD,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,aAAa,CAAC,KAAK,CAAC,EAAE;SAC3D;KACF,CAAC,CAAC;IACH,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;AACvF,CAAC;AAED;4EAC4E;AAC5E,MAAM,UAAU,aAAa,CAAC,OAAe;IAC3C,OAAO,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC,cAAc,CAAC;AACrD,CAAC;AAED;mFACmF;AACnF,SAAS,aAAa,CAAC,KAAe;IACpC,MAAM,GAAG,GAAG,IAAI,GAAG,CAAS,CAAC,WAAW,CAAC,CAAC,CAAC;IAC3C,MAAM,GAAG,GAAG,IAAI,GAAG,CAAS,CAAC,WAAW,CAAC,CAAC,CAAC;IAC3C,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,IAAI;YAAE,SAAS,CAAC,+BAA+B;QAC5E,IAAI,WAAW,CAAC,CAAC,CAAC;YAAE,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;YAC1B,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IACD,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAU,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAU,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;AAC1H,CAAC;AAED;mFACmF;AACnF,SAAS,WAAW,CAAC,CAAS;IAC5B,OAAO,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;AAC9D,CAAC"}

package/dist/serve/ws-transport.d.ts

@@ -0,0 +1,64 @@
+/**
+ * (v17 M1 / v20 M3) Relay transport primitives shared by the ACP control
+ * channel. M1's `RpcServer`-per-socket binding (`RpcSocketSession` + `WsByteSink`)
+ * was retired in the M3 hard cutover: the relay now runs ONE persistent
+ * `AcpSessionHost` whose `AcpEngineDriver` writes through the `ReplayHub`, so the
+ * only pieces left here are the transport-shape primitives the relay +
+ * `AcpSessionHost` reuse:
+ *   - {@link ServerSocket}: the minimal server-socket surface the fan-out sends through.
+ *   - {@link MessageQueue}: a push-driven `AsyncIterable<string>` feeding the driver's input.
+ *   - {@link perConnectionHost}: makes per-connection shutdown a no-op so the
+ *     shared runtime outlives individual sockets.
+ *
+ * Socket-free by construction (tests inject a recording fake `ServerSocket`).
+ */
+import type { EngineHost } from "../rpc/index.js";
+/**
+ * The minimal server-socket surface the {@link ReplayHub} fan-out sends through.
+ * A `ws` WebSocket (adapted by the relay's `nodeServerSocket`) satisfies it; tests
+ * inject a recording fake. `send` returns a tri-state: `>0` bytes written, `-1`
+ * enqueued under backpressure, `0` dropped (connection gone).
+ */
+export interface ServerSocket {
+    send(data: string): number;
+    close(code?: number, reason?: string): void;
+    /** Bytes queued in the socket's own send buffer, if the transport exposes it
+     *  (`ws.bufferedAmount`). The {@link ReplayHub} fan-out reads it to drop a
+     *  WEDGED socket past a hard cap so a single dead remote can't grow relay
+     *  memory unbounded — the dropped client reconnects + replays from the ring.
+     *  Absent on test fakes (the cap is then simply never tripped). */
+    readonly bufferedAmount?: number;
+}
+/**
+ * A push-driven `AsyncIterable<string>` feeding `AcpEngineDriver.run`. WebSocket
+ * preserves message boundaries, so each inbound message is one (or a few
+ * LF-batched) ACP JSON-RPC line(s); {@link AcpSessionHost.onMessage} splits and
+ * {@link push}es each. Single-consumer (the driver iterates once); items pushed
+ * before the consumer awaits are buffered in order.
+ */
+export declare class MessageQueue implements AsyncIterable<string> {
+    private readonly buffer;
+    private waiting;
+    private ended;
+    push(line: string): void;
+    /** No more input (process shutdown) — drains the buffer, then ends the iterator. */
+    end(): void;
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+}
+/**
+ * Wrap an `EngineHost` so per-connection / per-session shutdown does NOT tear
+ * down the shared runtime. The CLI's `makeEngineHost(ctx).dispose()` runs the
+ * whole-process `disposeRuntime(ctx)` — correct for `chances rpc` (one stdio
+ * client = process lifetime) but wrong for a relay that holds a PERSISTENT
+ * session outliving individual sockets. The real teardown happens once when
+ * `chances serve` exits (`main()`'s `finally`, idempotent). `build`/`listModels`
+ * delegate unchanged; only `dispose` becomes a no-op.
+ *
+ * (v23 M5) The optional read-only workspace queries are FORWARDED when present —
+ * the relay reads them off its host to advertise `workspaceQueries` and answer
+ * `list_files`/`read_file`/`git_*`. Dropping them here (as the original wrapper
+ * did) silently disabled the 3-pane IDE over the relay even though the CLI host
+ * supported it; the desktop's real-socket test catches that regression.
+ */
+export declare function perConnectionHost(host: EngineHost): EngineHost;
+//# sourceMappingURL=ws-transport.d.ts.map

package/dist/serve/ws-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-transport.d.ts","sourceRoot":"","sources":["../../src/serve/ws-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C;;;;uEAImE;IACnE,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC;AAED;;;;;;GAMG;AACH,qBAAa,YAAa,YAAW,aAAa,CAAC,MAAM,CAAC;IACxD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,OAAO,CAAsD;IACrE,OAAO,CAAC,KAAK,CAAS;IAEtB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAWxB,oFAAoF;IACpF,GAAG,IAAI,IAAI;IAUJ,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,MAAM,CAAC;CAcvD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAU9D"}

package/dist/serve/ws-transport.js

@@ -0,0 +1,92 @@
+/**
+ * (v17 M1 / v20 M3) Relay transport primitives shared by the ACP control
+ * channel. M1's `RpcServer`-per-socket binding (`RpcSocketSession` + `WsByteSink`)
+ * was retired in the M3 hard cutover: the relay now runs ONE persistent
+ * `AcpSessionHost` whose `AcpEngineDriver` writes through the `ReplayHub`, so the
+ * only pieces left here are the transport-shape primitives the relay +
+ * `AcpSessionHost` reuse:
+ *   - {@link ServerSocket}: the minimal server-socket surface the fan-out sends through.
+ *   - {@link MessageQueue}: a push-driven `AsyncIterable<string>` feeding the driver's input.
+ *   - {@link perConnectionHost}: makes per-connection shutdown a no-op so the
+ *     shared runtime outlives individual sockets.
+ *
+ * Socket-free by construction (tests inject a recording fake `ServerSocket`).
+ */
+/**
+ * A push-driven `AsyncIterable<string>` feeding `AcpEngineDriver.run`. WebSocket
+ * preserves message boundaries, so each inbound message is one (or a few
+ * LF-batched) ACP JSON-RPC line(s); {@link AcpSessionHost.onMessage} splits and
+ * {@link push}es each. Single-consumer (the driver iterates once); items pushed
+ * before the consumer awaits are buffered in order.
+ */
+export class MessageQueue {
+    buffer = [];
+    waiting = null;
+    ended = false;
+    push(line) {
+        if (this.ended)
+            return;
+        if (this.waiting) {
+            const resolve = this.waiting;
+            this.waiting = null;
+            resolve({ value: line, done: false });
+        }
+        else {
+            this.buffer.push(line);
+        }
+    }
+    /** No more input (process shutdown) — drains the buffer, then ends the iterator. */
+    end() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        if (this.waiting) {
+            const resolve = this.waiting;
+            this.waiting = null;
+            resolve({ value: undefined, done: true });
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.buffer.length > 0) {
+                yield this.buffer.shift();
+                continue;
+            }
+            if (this.ended)
+                return;
+            const next = await new Promise((resolve) => {
+                this.waiting = resolve;
+            });
+            if (next.done)
+                return;
+            yield next.value;
+        }
+    }
+}
+/**
+ * Wrap an `EngineHost` so per-connection / per-session shutdown does NOT tear
+ * down the shared runtime. The CLI's `makeEngineHost(ctx).dispose()` runs the
+ * whole-process `disposeRuntime(ctx)` — correct for `chances rpc` (one stdio
+ * client = process lifetime) but wrong for a relay that holds a PERSISTENT
+ * session outliving individual sockets. The real teardown happens once when
+ * `chances serve` exits (`main()`'s `finally`, idempotent). `build`/`listModels`
+ * delegate unchanged; only `dispose` becomes a no-op.
+ *
+ * (v23 M5) The optional read-only workspace queries are FORWARDED when present —
+ * the relay reads them off its host to advertise `workspaceQueries` and answer
+ * `list_files`/`read_file`/`git_*`. Dropping them here (as the original wrapper
+ * did) silently disabled the 3-pane IDE over the relay even though the CLI host
+ * supported it; the desktop's real-socket test catches that regression.
+ */
+export function perConnectionHost(host) {
+    return {
+        build: (resolver) => host.build(resolver),
+        listModels: () => host.listModels(),
+        dispose: async () => { },
+        ...(host.queryListFiles ? { queryListFiles: host.queryListFiles.bind(host) } : {}),
+        ...(host.queryReadFile ? { queryReadFile: host.queryReadFile.bind(host) } : {}),
+        ...(host.queryGitStatus ? { queryGitStatus: host.queryGitStatus.bind(host) } : {}),
+        ...(host.queryGitDiff ? { queryGitDiff: host.queryGitDiff.bind(host) } : {}),
+    };
+}
+//# sourceMappingURL=ws-transport.js.map

package/dist/serve/ws-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ws-transport.js","sourceRoot":"","sources":["../../src/serve/ws-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAqBH;;;;;;GAMG;AACH,MAAM,OAAO,YAAY;IACN,MAAM,GAAa,EAAE,CAAC;IAC/B,OAAO,GAAiD,IAAI,CAAC;IAC7D,KAAK,GAAG,KAAK,CAAC;IAEtB,IAAI,CAAC,IAAY;QACf,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO;QACvB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;YAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,OAAO,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IAED,oFAAoF;IACpF,GAAG;QACD,IAAI,IAAI,CAAC,KAAK;YAAE,OAAO;QACvB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;YAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;YACpB,OAAO,CAAC,EAAE,KAAK,EAAE,SAAkB,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QACrD,CAAC;IACH,CAAC;IAED,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC;QAC3B,OAAO,IAAI,EAAE,CAAC;YACZ,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBAC3B,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAG,CAAC;gBAC3B,SAAS;YACX,CAAC;YACD,IAAI,IAAI,CAAC,KAAK;gBAAE,OAAO;YACvB,MAAM,IAAI,GAAG,MAAM,IAAI,OAAO,CAAyB,CAAC,OAAO,EAAE,EAAE;gBACjE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACzB,CAAC,CAAC,CAAC;YACH,IAAI,IAAI,CAAC,IAAI;gBAAE,OAAO;YACtB,MAAM,IAAI,CAAC,KAAK,CAAC;QACnB,CAAC;IACH,CAAC;CACF;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAgB;IAChD,OAAO;QACL,KAAK,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC;QACzC,UAAU,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,EAAE;QACnC,OAAO,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;QACvB,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClF,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC/E,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,cAAc,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAClF,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC7E,CAAC;AACJ,CAAC"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@chances-ai/wire",
+  "version": "24.0.0",
+  "type": "module",
+  "exports": {
+    "./rpc": {
+      "types": "./dist/rpc/index.d.ts",
+      "import": "./dist/rpc/index.js"
+    },
+    "./serve": {
+      "types": "./dist/serve/index.d.ts",
+      "import": "./dist/serve/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@chances-ai/engine": "24.0.0",
+    "@chances-ai/runtime": "24.0.0",
+    "@chances-ai/ui-core": "24.0.0",
+    "selfsigned": "^5.5.0",
+    "ws": "^8.18.0",
+    "zod": "^3.23.8"
+  },
+  "peerDependencies": {
+    "@agentclientprotocol/sdk": "^0.22.0"
+  },
+  "peerDependenciesMeta": {
+    "@agentclientprotocol/sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@agentclientprotocol/sdk": "^0.22.0"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "check": "tsc -b",
+    "test": "bun test --timeout 30000"
+  }
+}