pyric-tools 0.1.0-alpha.7

package/dist/bridge/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/bridge/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAUH,OAAO,EACL,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AASnD,8EAA8E;AAC9E,0EAA0E;AAC1E,wEAAwE;AACxE,6EAA6E;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/bridge/protocol.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Wire protocol shared by `pyric-tools/bridge` (Node bridge) and
+ * `pyric-tools/bridge` (in-browser sandbox connector).
+ *
+ * The bridge process speaks MCP HTTP to external agents (Claude Code,
+ * Cursor) on `/mcp` and WebSocket to the in-browser sandbox on
+ * `/sandbox`. Data-plane and sandbox-management tool calls received
+ * over MCP are forwarded to whichever browser tab is currently
+ * connected; the browser dispatches them into the local
+ * `LocalEnvironment` and returns the result.
+ *
+ * This module has NO runtime imports — only types — so it can be
+ * referenced from both the `node` and `browser` builds without
+ * pulling Node-specific or DOM-specific modules into the wrong
+ * environment.
+ */
+import type { OpMessage, SubMessage } from '../serve/worker/protocol.js';
+/** Bridge mode set at process start. */
+export type BridgeMode = 'sandbox' | 'prod';
+/** Health report returned by the bridge's `GET /health` endpoint. */
+export interface HealthReport {
+    status: 'ok';
+    mode: BridgeMode;
+    /** Project id when `mode==='prod'`; sandbox identifier otherwise. */
+    project: string;
+    /** Whether a browser tab is currently connected over `/sandbox`. */
+    sandboxConnected: boolean;
+    /** Bridge package version. */
+    version: string;
+    /** ISO timestamp the bridge started. */
+    startedAt: string;
+    /**
+     * Random identity, stable for this bridge process's lifetime. The discovery
+     * pointer (`.pyric/serve.json`) records the same value, so a proxy can confirm
+     * it reached the SAME server the pointer names — two sandboxes can collide on
+     * one port across loopback families (IPv4 `*:P` + IPv6 `[::1]:P`), and `mode`
+     * alone can't tell them apart. (Not `version` — that's hardcoded.)
+     */
+    instanceId: string;
+}
+/** Default port the standalone bridge binds to. */
+export declare const DEFAULT_BRIDGE_PORT = 5174;
+/** Default WS path the browser connects to. */
+export declare const DEFAULT_SANDBOX_PATH = "/sandbox";
+/** Default HTTP path the MCP client connects to. */
+export declare const DEFAULT_MCP_PATH = "/mcp";
+/** Default health endpoint path. */
+export declare const DEFAULT_HEALTH_PATH = "/health";
+/**
+ * WS close code the transport sends a sandbox peer when a NEWER registration
+ * displaces it (last-connection-wins). Application-defined (4000–4999 per RFC
+ * 6455 §7.4.2) so it survives every WS stack verbatim. The browser client
+ * treats this close as "the slot is legitimately held by another tab" and
+ * enters STANDBY (poll the health endpoint, reconnect only when the slot is
+ * vacant) instead of re-helloing — two open tabs used to kick each other in a
+ * perpetual last-wins fight, re-firing every relayed subscription and failing
+ * all in-flight worker ops once per cycle. Any OTHER close (server restart,
+ * network drop, tab-refresh takeover) keeps the immediate-reconnect loop.
+ */
+export declare const PEER_REPLACED_CLOSE_CODE = 4001;
+/** Human-readable reason sent with {@link PEER_REPLACED_CLOSE_CODE}. */
+export declare const PEER_REPLACED_CLOSE_REASON = "replaced by a newer sandbox peer";
+/** Browser → bridge: "I'm here and ready to receive tool calls." */
+export interface HelloFromClient {
+    type: 'hello';
+    /** Protocol version. Bump if the wire format changes incompatibly. */
+    protocol: 1;
+    /** Tool names the browser can dispatch. Bridge uses this to size MCP tool surface. */
+    tools: string[];
+    /** Stable identifier for this sandbox session (for audit log). */
+    sandboxId: string;
+    /**
+     * Optional peer capabilities (additive). The bridge only sends `worker-*`
+     * frames to a peer that declared {@link WORKER_RELAY_CAPABILITY} — an old
+     * peer that omits it simply never receives them, and worker ops against it
+     * fail fast with a clear error instead of timing out.
+     */
+    capabilities?: string[];
+}
+/** Bridge → browser: acknowledge connection. */
+export interface HelloFromBridge {
+    type: 'hello-ack';
+    protocol: 1;
+    /** Bridge version, for compatibility checks. */
+    bridgeVersion: string;
+}
+/** Bridge → browser: please dispatch this tool call into the sandbox. */
+export interface ToolCallRequest {
+    type: 'tool-call';
+    /** Correlation id — browser must echo in `ToolCallResponse`. */
+    id: string;
+    /** Tool name (e.g. `firestore_simulator_create`). */
+    name: string;
+    /** Tool arguments (JSON-serializable). */
+    args: Record<string, unknown>;
+}
+/** Browser → bridge: tool call result. */
+export interface ToolCallResponse {
+    type: 'tool-result';
+    /** Correlation id from the matching request. */
+    id: string;
+    /** When `ok===false`, `error` is populated and `result` is omitted. */
+    ok: boolean;
+    /** Tool result (matches `ToolResult` shape from `@inbrowser/agent`). */
+    result?: {
+        ok: boolean;
+        summary: string;
+        data?: unknown;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/** Peer capability flag: "I can relay worker-op / worker-sub frames". */
+export declare const WORKER_RELAY_CAPABILITY = "worker-relay";
+/** `Omit` distributed over a union (plain `Omit` collapses union members). */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/** A worker one-shot op, minus the port-level `t`/`id` the relay re-mints. */
+export type WorkerOpPayload = DistributiveOmit<OpMessage, 't' | 'id'>;
+/**
+ * A worker subscription, minus the port-level `t`/`subId`. Slice 1 relays
+ * snap-delivering subs (RTDB value, auth state, Firestore); the unified
+ * event stream (`target: 'events'`) is NOT relayable yet — it needs bounded
+ * backpressure first (slice 2).
+ */
+export type WorkerSubPayload = DistributiveOmit<SubMessage, 't' | 'subId'>;
+/** Node consumer → bridge: attach as a worker-relay consumer (NOT a peer —
+ *  a consumer never replaces the browser tab in last-connection-wins). */
+export interface AttachFromConsumer {
+    type: 'attach';
+    protocol: 1;
+}
+/** Bridge → Node consumer: attach acknowledged. */
+export interface AttachAckFromBridge {
+    type: 'attach-ack';
+    protocol: 1;
+    bridgeVersion: string;
+    /** Whether a browser tab is currently registered as the sandbox peer. */
+    peerConnected: boolean;
+    /**
+     * The `pyric-tools` package version the serve/bridge process runs
+     * (version-skew stamp). ADDITIVE + OPTIONAL: old servers omit it and
+     * the client stays silent. When present and different from the
+     * client's own version, the client warns once at attach and enriches
+     * op-timeout errors — a skewed old worker can accept a newer op frame
+     * and die mid-handling, which otherwise surfaces as a bare timeout.
+     */
+    serveVersion?: string;
+}
+/** Toward the worker: dispatch this one-shot op. (consumer→bridge and
+ *  bridge→browser use the same shape; `id` is per-leg.) */
+export interface WorkerOpFrame {
+    type: 'worker-op';
+    /** Correlation id — echoed back in the matching `worker-res`. */
+    id: string;
+    op: WorkerOpPayload;
+}
+/** Away from the worker: the relayed op result. */
+export interface WorkerResFrame {
+    type: 'worker-res';
+    id: string;
+    /** When `ok === false`, `error` is populated and `value` omitted. */
+    ok: boolean;
+    value?: unknown;
+    /** `denialContext` (additive, spike gap 6): the structured "why did this
+     *  deny" frame a `SandboxError` carries on `permission-denied` — plain
+     *  JSON, so it rides the WS legs verbatim and the Node side re-attaches it. */
+    error?: {
+        code: string;
+        message: string;
+        denialContext?: unknown;
+    };
+}
+/** Toward the worker: register a subscription. Re-issued by the bridge to a
+ *  NEW peer on reconnect/replacement (value subs re-deliver a fresh initial
+ *  snapshot, so replay is cursor-free and last-value-wins-safe). */
+export interface WorkerSubFrame {
+    type: 'worker-sub';
+    subId: string;
+    sub: WorkerSubPayload;
+}
+/** Toward the worker: tear a subscription down. */
+export interface WorkerUnsubFrame {
+    type: 'worker-unsub';
+    subId: string;
+}
+/** Away from the worker: one streamed snapshot for a subscription. A failed
+ *  ESTABLISHMENT also arrives here as `value: { __error: { code, message } }`
+ *  (the worker host's snap-error convention) — relays forward it verbatim. */
+export interface WorkerSnapFrame {
+    type: 'worker-snap';
+    subId: string;
+    value: unknown;
+}
+/** Either direction: ping for keepalive / liveness detection. */
+export interface Ping {
+    type: 'ping';
+    /** Echo back as `pong.id`. */
+    id: string;
+}
+/** Pong response to a Ping. */
+export interface Pong {
+    type: 'pong';
+    id: string;
+}
+export type BridgeMessage = HelloFromClient | HelloFromBridge | AttachFromConsumer | AttachAckFromBridge | ToolCallRequest | ToolCallResponse | WorkerOpFrame | WorkerResFrame | WorkerSubFrame | WorkerUnsubFrame | WorkerSnapFrame | Ping | Pong;
+/** Type guard for runtime parsing. */
+export declare function isBridgeMessage(value: unknown): value is BridgeMessage;
+/** Error returned by MCP when no browser tab is currently connected. */
+export declare const NO_SANDBOX_ERROR_MESSAGE = "sandbox not connected. Open your dev server in a browser and refresh the page so the bridge client can register.";
+/** Error for worker ops against a peer that predates the worker relay. */
+export declare const NO_WORKER_RELAY_ERROR_MESSAGE = "the connected browser tab does not support the worker relay \u2014 reload the tab (and update pyric if reloading does not help).";
+/** Human label for a non-JSON-safe binary value, or null when `value` (and
+ *  every nested array/plain-object member) is free of binary containers. */
+export declare function findBinaryPayload(value: unknown): string | null;
+/**
+ * Assert a worker-op result (or subscription snap value) is safe to
+ * serialize onto the JSON relay. Throws (code `invalid-argument`) naming
+ * the offending type and the base64 storage ops to use instead — so a
+ * future caller relaying `storage.getBlob` gets a clear error, not `{}`.
+ *
+ * `context` is a human label for the message: `op '<method>'` for op
+ * results, `subscription '<subId>'` for snap values.
+ */
+export declare function assertJsonSafeRelayValue(context: string, value: unknown): void;
+export {};
+//# sourceMappingURL=protocol.d.ts.map

package/dist/bridge/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/bridge/protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzE,wCAAwC;AACxC,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;AAE5C,qEAAqE;AACrE,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,IAAI,CAAC;IACb,IAAI,EAAE,UAAU,CAAC;IACjB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,gBAAgB,EAAE,OAAO,CAAC;IAC1B,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,mDAAmD;AACnD,eAAO,MAAM,mBAAmB,OAAO,CAAC;AAExC,+CAA+C;AAC/C,eAAO,MAAM,oBAAoB,aAAa,CAAC;AAE/C,oDAAoD;AACpD,eAAO,MAAM,gBAAgB,SAAS,CAAC;AAEvC,oCAAoC;AACpC,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAE7C,wEAAwE;AACxE,eAAO,MAAM,0BAA0B,qCAAqC,CAAC;AAQ7E,oEAAoE;AACpE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,sEAAsE;IACtE,QAAQ,EAAE,CAAC,CAAC;IACZ,sFAAsF;IACtF,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB;AAED,gDAAgD;AAChD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,QAAQ,EAAE,CAAC,CAAC;IACZ,gDAAgD;IAChD,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,CAAC;IAClB,gEAAgE;IAChE,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,aAAa,CAAC;IACpB,gDAAgD;IAChD,EAAE,EAAE,MAAM,CAAC;IACX,uEAAuE;IACvE,EAAE,EAAE,OAAO,CAAC;IACZ,wEAAwE;IACxE,MAAM,CAAC,EAAE;QACP,EAAE,EAAE,OAAO,CAAC;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,OAAO,CAAC;KAChB,CAAC;IACF,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAcD,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,iBAAiB,CAAC;AAEtD,8EAA8E;AAC9E,KAAK,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,IAAI,CAAC,SAAS,OAAO,GAC/D,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACV,KAAK,CAAC;AAEV,8EAA8E;AAC9E,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAC,SAAS,EAAE,GAAG,GAAG,IAAI,CAAC,CAAC;AAEtE;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC,UAAU,EAAE,GAAG,GAAG,OAAO,CAAC,CAAC;AAE3E;0EAC0E;AAC1E,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,CAAC,CAAC;CACb;AAED,mDAAmD;AACnD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,CAAC,CAAC;IACZ,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,aAAa,EAAE,OAAO,CAAC;IACvB;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;2DAC2D;AAC3D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,WAAW,CAAC;IAClB,iEAAiE;IACjE,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,eAAe,CAAC;CACrB;AAED,mDAAmD;AACnD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;mFAE+E;IAC/E,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpE;AAED;;oEAEoE;AACpE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,gBAAgB,CAAC;CACvB;AAED,mDAAmD;AACnD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;8EAE8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,aAAa,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,OAAO,CAAC;CAChB;AAED,iEAAiE;AACjE,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,+BAA+B;AAC/B,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,aAAa,GACrB,eAAe,GACf,eAAe,GACf,kBAAkB,GAClB,mBAAmB,GACnB,eAAe,GACf,gBAAgB,GAChB,aAAa,GACb,cAAc,GACd,cAAc,GACd,gBAAgB,GAChB,eAAe,GACf,IAAI,GACJ,IAAI,CAAC;AAET,sCAAsC;AACtC,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,aAAa,CAkBtE;AAED,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,qHAC+E,CAAC;AAErH,0EAA0E;AAC1E,eAAO,MAAM,6BAA6B,qIACqF,CAAC;AAYhI;4EAC4E;AAC5E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAmB/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,GACb,IAAI,CAWN"}

package/dist/bridge/protocol.js

@@ -0,0 +1,131 @@
+/**
+ * Wire protocol shared by `pyric-tools/bridge` (Node bridge) and
+ * `pyric-tools/bridge` (in-browser sandbox connector).
+ *
+ * The bridge process speaks MCP HTTP to external agents (Claude Code,
+ * Cursor) on `/mcp` and WebSocket to the in-browser sandbox on
+ * `/sandbox`. Data-plane and sandbox-management tool calls received
+ * over MCP are forwarded to whichever browser tab is currently
+ * connected; the browser dispatches them into the local
+ * `LocalEnvironment` and returns the result.
+ *
+ * This module has NO runtime imports — only types — so it can be
+ * referenced from both the `node` and `browser` builds without
+ * pulling Node-specific or DOM-specific modules into the wrong
+ * environment.
+ */
+/** Default port the standalone bridge binds to. */
+export const DEFAULT_BRIDGE_PORT = 5174;
+/** Default WS path the browser connects to. */
+export const DEFAULT_SANDBOX_PATH = '/sandbox';
+/** Default HTTP path the MCP client connects to. */
+export const DEFAULT_MCP_PATH = '/mcp';
+/** Default health endpoint path. */
+export const DEFAULT_HEALTH_PATH = '/health';
+/**
+ * WS close code the transport sends a sandbox peer when a NEWER registration
+ * displaces it (last-connection-wins). Application-defined (4000–4999 per RFC
+ * 6455 §7.4.2) so it survives every WS stack verbatim. The browser client
+ * treats this close as "the slot is legitimately held by another tab" and
+ * enters STANDBY (poll the health endpoint, reconnect only when the slot is
+ * vacant) instead of re-helloing — two open tabs used to kick each other in a
+ * perpetual last-wins fight, re-firing every relayed subscription and failing
+ * all in-flight worker ops once per cycle. Any OTHER close (server restart,
+ * network drop, tab-refresh takeover) keeps the immediate-reconnect loop.
+ */
+export const PEER_REPLACED_CLOSE_CODE = 4001;
+/** Human-readable reason sent with {@link PEER_REPLACED_CLOSE_CODE}. */
+export const PEER_REPLACED_CLOSE_REASON = 'replaced by a newer sandbox peer';
+// ── Generic worker relay (remote sandbox, slice 1) ───────────────────
+//
+// Beyond `tool-call`, the bridge can relay ANY SharedWorker-protocol op or
+// (snap-delivering) subscription between a Node consumer and the browser
+// peer. The SAME frame shapes travel both legs:
+//
+//   Node consumer ──ws──> bridge ──ws──> browser tab ──port──> worker
+//
+// Correlation ids/subIds are re-minted per hop (consumer-minted on the
+// consumer leg, bridge-minted UUIDs on the peer leg, page-local ids on the
+// worker port) so each hop's pending/registry maps stay collision-free.
+/** Peer capability flag: "I can relay worker-op / worker-sub frames". */
+export const WORKER_RELAY_CAPABILITY = 'worker-relay';
+/** Type guard for runtime parsing. */
+export function isBridgeMessage(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const t = value.type;
+    return (t === 'hello' ||
+        t === 'hello-ack' ||
+        t === 'attach' ||
+        t === 'attach-ack' ||
+        t === 'tool-call' ||
+        t === 'tool-result' ||
+        t === 'worker-op' ||
+        t === 'worker-res' ||
+        t === 'worker-sub' ||
+        t === 'worker-unsub' ||
+        t === 'worker-snap' ||
+        t === 'ping' ||
+        t === 'pong');
+}
+/** Error returned by MCP when no browser tab is currently connected. */
+export const NO_SANDBOX_ERROR_MESSAGE = 'sandbox not connected. Open your dev server in a browser and refresh the page so the bridge client can register.';
+/** Error for worker ops against a peer that predates the worker relay. */
+export const NO_WORKER_RELAY_ERROR_MESSAGE = 'the connected browser tab does not support the worker relay — reload the tab (and update pyric if reloading does not help).';
+// ─── Binary-payload guard (worker-op relay boundary) ────────────────────────
+//
+// Both WS legs of the worker relay are `JSON.stringify` — a `Blob` or
+// `ArrayBuffer` in a relayed value silently becomes `{}` and a TypedArray /
+// Buffer becomes an index-keyed object. Nothing errors; the far side just
+// receives garbage (the live failure mode: relaying `storage.getBlob` yields
+// `{}`). This guard turns that silent corruption into a loud, remediable
+// rejection at the relay boundary. It is a cheap explicit TYPE check
+// (Blob/ArrayBuffer/TypedArray/DataView), NOT a full JSON round-trip.
+/** Human label for a non-JSON-safe binary value, or null when `value` (and
+ *  every nested array/plain-object member) is free of binary containers. */
+export function findBinaryPayload(value) {
+    if (value === null || typeof value !== 'object')
+        return null;
+    if (typeof Blob !== 'undefined' && value instanceof Blob)
+        return 'Blob';
+    if (value instanceof ArrayBuffer)
+        return 'ArrayBuffer';
+    if (ArrayBuffer.isView(value)) {
+        return value.constructor?.name ?? 'TypedArray';
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const hit = findBinaryPayload(item);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
+    for (const item of Object.values(value)) {
+        const hit = findBinaryPayload(item);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/**
+ * Assert a worker-op result (or subscription snap value) is safe to
+ * serialize onto the JSON relay. Throws (code `invalid-argument`) naming
+ * the offending type and the base64 storage ops to use instead — so a
+ * future caller relaying `storage.getBlob` gets a clear error, not `{}`.
+ *
+ * `context` is a human label for the message: `op '<method>'` for op
+ * results, `subscription '<subId>'` for snap values.
+ */
+export function assertJsonSafeRelayValue(context, value) {
+    const kind = findBinaryPayload(value);
+    if (!kind)
+        return;
+    const err = new Error(`worker ${context} produced a binary payload (${kind}) that cannot cross the ` +
+        'JSON bridge relay — it would be silently corrupted by JSON.stringify. Use the ' +
+        "base64 storage ops instead ('storage.getBytes' / 'storage.putBytes'), which carry " +
+        "bytes as JSON-safe 'dataB64' strings; 'storage.getBlob' is MessagePort-only.");
+    err.code = 'invalid-argument';
+    throw err;
+}
+//# sourceMappingURL=protocol.js.map

package/dist/bridge/protocol.js.map

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

package/dist/bridge/server/audit.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Audit log writer. Every bridge tool call (sandbox or prod) appends
+ * one JSON line to the project's events.ndjson file.
+ *
+ * Audit events land at the project's conventional location:
+ *   `~/.pyric/projects/<projectId>/events.ndjson`
+ *
+ * The bridge passes its `BridgeToolEvent` here through `onToolEvent`.
+ * Writes are best-effort — failure to log must not break tool
+ * dispatch.
+ */
+import type { BridgeToolEvent } from './bridge.js';
+export interface AuditWriter {
+    write(event: BridgeToolEvent): void;
+    /** Filesystem path of the active log. */
+    readonly path: string;
+}
+export declare function createAuditWriter(project: string): AuditWriter;
+//# sourceMappingURL=audit.d.ts.map

package/dist/bridge/server/audit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.d.ts","sourceRoot":"","sources":["../../../src/bridge/server/audit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAKH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,WAAW;IAC1B,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IACpC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CAuB9D"}

package/dist/bridge/server/audit.js

@@ -0,0 +1,46 @@
+/**
+ * Audit log writer. Every bridge tool call (sandbox or prod) appends
+ * one JSON line to the project's events.ndjson file.
+ *
+ * Audit events land at the project's conventional location:
+ *   `~/.pyric/projects/<projectId>/events.ndjson`
+ *
+ * The bridge passes its `BridgeToolEvent` here through `onToolEvent`.
+ * Writes are best-effort — failure to log must not break tool
+ * dispatch.
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, appendFileSync } from 'node:fs';
+export function createAuditWriter(project) {
+    const dir = join(homedir(), '.pyric', 'projects', sanitiseProjectId(project));
+    const path = join(dir, 'events.ndjson');
+    try {
+        mkdirSync(dir, { recursive: true });
+    }
+    catch (err) {
+        // If we can't create the directory, fall back to silent no-op.
+        return {
+            write: () => { },
+            path,
+        };
+    }
+    return {
+        path,
+        write(event) {
+            try {
+                const line = JSON.stringify(event) + '\n';
+                appendFileSync(path, line, { encoding: 'utf8' });
+            }
+            catch {
+                // Drop the entry; tool dispatch continues.
+            }
+        },
+    };
+}
+function sanitiseProjectId(value) {
+    // Project ids are normally alphanumeric + dash; defend against
+    // path traversal just in case (someone passes `../etc` etc.).
+    return value.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 128) || 'unknown';
+}
+//# sourceMappingURL=audit.js.map

package/dist/bridge/server/audit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.js","sourceRoot":"","sources":["../../../src/bridge/server/audit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AASpD,MAAM,UAAU,iBAAiB,CAAC,OAAe;IAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9E,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC;IACxC,IAAI,CAAC;QACH,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACtC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,+DAA+D;QAC/D,OAAO;YACL,KAAK,EAAE,GAAG,EAAE,GAAE,CAAC;YACf,IAAI;SACL,CAAC;IACJ,CAAC;IACD,OAAO;QACL,IAAI;QACJ,KAAK,CAAC,KAAsB;YAC1B,IAAI,CAAC;gBACH,MAAM,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;gBAC1C,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;YACnD,CAAC;YAAC,MAAM,CAAC;gBACP,2CAA2C;YAC7C,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED,SAAS,iBAAiB,CAAC,KAAa;IACtC,+DAA+D;IAC/D,8DAA8D;IAC9D,OAAO,KAAK,CAAC,OAAO,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC;AAC3E,CAAC"}

package/dist/bridge/server/bridge.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Bridge core — process-local state for forwarding MCP tool calls
+ * from external clients to the (one) connected sandbox peer in the
+ * browser. Transport-agnostic: the HTTP MCP server and the WS server
+ * both plug into this through `dispatch()` / `handleSandboxMessage()`
+ * / `registerSandboxPeer()`.
+ *
+ * Multi-tab is naive: last-connection-wins. New peer replaces the
+ * old, pending calls against the old peer reject with a clear error.
+ *
+ * Mode determines architecture:
+ *  - sandbox: every tool call is forwarded over WS to the browser.
+ *    The bridge does not execute tools itself; it acts as a relay
+ *    with a tool-name allow-list pinned by the peer's `hello`.
+ *  - prod: tools execute in-process via `composeMcpRegistry` with
+ *    the supplied `scope` + `adminDeps`. No peer needed.
+ */
+import type { BridgeMessage, BridgeMode, HealthReport, WorkerOpPayload, WorkerSubPayload } from '../protocol.js';
+import type { ConfirmHandler, ConfirmDecision } from './confirm.js';
+/** Subset of `@inbrowser/agent`'s `ToolResult` shape the bridge emits. */
+export interface BridgeToolResult {
+    ok: boolean;
+    summary: string;
+    data?: unknown;
+}
+/** Function the bridge calls to send a message to the current sandbox peer. */
+export type SendToPeer = (msg: BridgeMessage) => void;
+export interface BridgeOptions {
+    /** Mode set at process start; switching requires restart. */
+    mode: BridgeMode;
+    /**
+     * Project id surfaced in /health and audit-log paths. For sandbox
+     * mode, default is `'sandbox'`. For prod mode, required (typically
+     * the Firebase project id).
+     */
+    project?: string;
+    /** Bridge version surfaced in /health + Hello messages. */
+    version: string;
+    /**
+     * Per-call request timeout in ms when forwarding to the browser.
+     * Defaults to 30s; the bridge rejects the MCP call with a clear
+     * "sandbox call timed out" error after this.
+     */
+    callTimeoutMs?: number;
+    /**
+     * Hook called whenever a tool finishes (success or failure).
+     * Use this for the audit log — write the entry to disk here.
+     * The bridge does not own audit-log persistence.
+     */
+    onToolEvent?: (event: BridgeToolEvent) => void;
+    /**
+     * Per-action confirmation handler. Required for prod-mode bridges
+     * to gate dangerous tools on real human approval (see
+     * the design rationale). The wrapper in
+     * `mcp.ts` consults this handler before invoking each in-process
+     * prod tool. Sandbox mode ignores it (forwarded tool calls are
+     * not gated; the browser sandbox is the trust boundary).
+     *
+     * If omitted in prod mode, the standalone server installs a
+     * `createDenyAllHandler()` as a fail-safe.
+     */
+    confirmHandler?: ConfirmHandler;
+}
+export interface BridgeToolEvent {
+    timestamp: string;
+    mode: BridgeMode;
+    project: string;
+    tool: string;
+    args: Record<string, unknown>;
+    result: BridgeToolResult | {
+        ok: false;
+        summary: string;
+        error?: {
+            code: string;
+            message: string;
+        };
+    };
+    durationMs: number;
+    /**
+     * Confirmation decision for prod-mode in-process tools. Omitted
+     * for sandbox-forwarded calls (no confirmation needed) and for
+     * prod calls that ran with no handler configured (a misconfig).
+     */
+    confirmation?: {
+        policy: string;
+        decision: 'approved' | 'denied';
+        reason: ConfirmDecision['reason'];
+        elapsed_ms: number;
+        prompt_shown_at?: string;
+    };
+}
+export interface Bridge {
+    readonly mode: BridgeMode;
+    readonly project: string;
+    readonly version: string;
+    readonly startedAt: string;
+    /** Stable per-process identity (see HealthReport.instanceId). */
+    readonly instanceId: string;
+    /** Confirmation handler; null in sandbox mode. */
+    readonly confirmHandler: ConfirmHandler | null;
+    /**
+     * Record a tool event in the bridge's audit pipeline. Called by
+     * the in-process tool wrapper in `mcp.ts` after a prod tool
+     * finishes (whether it ran or was denied). Sandbox-forwarded
+     * tools log via the existing onToolEvent path inside dispatch().
+     */
+    recordToolEvent(event: BridgeToolEvent): void;
+    /**
+     * Register a browser-side peer. Returns a disconnect function the
+     * caller MUST invoke when the WS closes. Last-wins: a new
+     * registration disconnects the previous peer (its pending calls
+     * fail with a clear error).
+     *
+     * `capabilities` come from the peer's `hello` — the bridge only sends
+     * `worker-*` frames to a peer that declared `'worker-relay'`.
+     *
+     * `onReplaced` fires when a NEWER registration displaces this peer. The
+     * transport MUST use it to close the old socket: the browser side's
+     * close handler tears down its relayed worker subscriptions — without
+     * this, a replaced tab's SharedWorker listeners would live until the tab
+     * closed, streaming snaps the bridge drops as stale-generation forever.
+     */
+    registerSandboxPeer(send: SendToPeer, tools: string[], sandboxId: string, capabilities?: string[], onReplaced?: () => void): () => void;
+    /** True if a sandbox peer is currently registered. */
+    isSandboxConnected(): boolean;
+    /**
+     * Generation counter of the CURRENT peer registration (0 = no peer has
+     * ever registered). The transport captures this right after registering
+     * and tags every inbound message with it, so a frame arriving on a
+     * REPLACED peer's socket (tab refresh mid-flight) can never resolve a new
+     * peer's pending call or deliver a stale subscription snapshot.
+     */
+    peerGeneration(): number;
+    /** Tool names the bridge currently exposes to MCP. */
+    toolNames(): string[];
+    /** Dispatch a tool call. Forwards to peer in sandbox mode. */
+    dispatch(name: string, args: Record<string, unknown>): Promise<BridgeToolResult>;
+    /**
+     * Relay a generic worker op to the peer's SharedWorker. Resolves with the
+     * worker's `res.value`; rejects with an Error carrying `.code` on worker
+     * failure, timeout, no peer, or a peer without the worker relay.
+     */
+    dispatchWorkerOp(op: WorkerOpPayload): Promise<unknown>;
+    /**
+     * Register a worker subscription. Ownership lives HERE: the registry
+     * survives peer churn, and every registered sub is re-issued to a new
+     * peer on registration (RTDB value / auth-state subs re-deliver a fresh
+     * initial snapshot, so replay is cursor-free). `onSnap` receives every
+     * relayed snap value verbatim — including the worker host's
+     * `{ __error: { code, message } }` establishment-failure convention.
+     * Returns the unsubscribe function.
+     */
+    subscribeWorker(sub: WorkerSubPayload, onSnap: (value: unknown) => void): () => void;
+    /**
+     * Handle a message from the sandbox peer (tool-result, pong, …).
+     * `generation` is the peer generation the transport captured at
+     * registration; when provided, `worker-res`/`worker-snap` frames from a
+     * stale generation are dropped.
+     */
+    handleSandboxMessage(msg: BridgeMessage, generation?: number): void;
+    /** /health endpoint payload. */
+    health(): HealthReport;
+}
+export declare function createBridge(opts: BridgeOptions): Bridge;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge/server/bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge.d.ts","sourceRoot":"","sources":["../../../src/bridge/server/bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,KAAK,EACV,aAAa,EACb,UAAU,EACV,YAAY,EAEZ,eAAe,EACf,gBAAgB,EAGjB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpE,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,+EAA+E;AAC/E,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,EAAE,aAAa,KAAK,IAAI,CAAC;AAEtD,MAAM,WAAW,aAAa;IAC5B,6DAA6D;IAC7D,IAAI,EAAE,UAAU,CAAC;IACjB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;IAC/C;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,gBAAgB,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IACrG,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,YAAY,CAAC,EAAE;QACb,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,UAAU,GAAG,QAAQ,CAAC;QAChC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;QAClC,UAAU,EAAE,MAAM,CAAC;QACnB,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,kDAAkD;IAClD,QAAQ,CAAC,cAAc,EAAE,cAAc,GAAG,IAAI,CAAC;IAC/C;;;;;OAKG;IACH,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IAE9C;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CACjB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,EAAE,EACf,SAAS,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,EAAE,EACvB,UAAU,CAAC,EAAE,MAAM,IAAI,GACtB,MAAM,IAAI,CAAC;IAEd,sDAAsD;IACtD,kBAAkB,IAAI,OAAO,CAAC;IAE9B;;;;;;OAMG;IACH,cAAc,IAAI,MAAM,CAAC;IAEzB,sDAAsD;IACtD,SAAS,IAAI,MAAM,EAAE,CAAC;IAEtB,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEjF;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAExD;;;;;;;;OAQG;IACH,eAAe,CAAC,GAAG,EAAE,gBAAgB,EAAE,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;IAErF;;;;;OAKG;IACH,oBAAoB,CAAC,GAAG,EAAE,aAAa,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpE,gCAAgC;IAChC,MAAM,IAAI,YAAY,CAAC;CACxB;AAgED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAoZxD"}