@rynx-ai/daemon 0.1.0 → 0.1.9

package/dist/db.js

@@ -1,25 +1,30 @@
 /**
  * `~/.rynx/rynx.db` — the daemon's SQLite store. Concerns kept apart:
- *  - `channels`  — a channel = a plugin type + its config/credentials (`options`).
- *    The transport/connection, configured & authorized on its own.
- *  - `instances` — a runnable binding: a channel + an agent (1:1 with a channel,
+ *  - `channels`  — a chat type + its plugin-owned config/credentials.
+ *  - `instances` — a runnable binding: a chat channel + an agent (1:1 with a channel,
  *    enforced by a UNIQUE channel_id). This is what the daemon mounts.
- *  - `plugins`   — installed plugins (CLI-managed) the loader imports.
- *  - `session_items` — the canonical, append-only conversation log (one row per
- *    {@link import("@rynx-ai/core").SessionItem}); see {@link import("./session-log-store.js")}.
+ *  - `plugins`   — static manifests, grants and immutable install locations.
+ *  - `plugin_session_launch_operations` — durable idempotency/tombstones.
+ *  - `control_links` — generic, one-use links to the local session console.
+ *  - `runtime_pairing_claims` / `runtime_client_grants` — one-use enrollment
+ *    claims and the durable client identities they issue for direct runtimes.
+ *  - `runtime_targets` / `runtime_direct_routes` / `runtime_pending_enrollments`
+ *    — client-local daemon trust, replaceable location, and crash recovery.
+ *  - `session_items` — the canonical, append-only conversation log; see
+ *    {@link import("./session-log-store.js")}.
  *
  * Connections are cached per resolved path so tests can point `RYNX_DB` /
  * `RYNX_HOME` at a temp dir. Override with `RYNX_DB` (full path) or `RYNX_HOME`.
  */
 import { randomUUID } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import Database from "better-sqlite3";
-import { rynxHome } from "@rynx-ai/core";
 const connections = new Map();
 /** Absolute path to the SQLite file (override via `RYNX_DB`, else `~/.rynx/rynx.db`). */
 export function dbPath() {
-    return process.env.RYNX_DB?.trim() || join(rynxHome(), "rynx.db");
+    return process.env.RYNX_DB?.trim() || join(daemonHome(), "rynx.db");
 }
 /** Open (or reuse) the database at the current path, migrating + importing on first open. */
 export function db() {
@@ -50,7 +55,12 @@ function migrate(conn) {
       source       TEXT NOT NULL,
       version      TEXT,
       enabled      INTEGER NOT NULL DEFAULT 1,
-      installed_at TEXT NOT NULL
+      installed_at TEXT NOT NULL,
+      updated_at   TEXT,
+      install_path TEXT,
+      manifest     TEXT,
+      integrity    TEXT,
+      grants       TEXT
     );
     CREATE TABLE IF NOT EXISTS channels (
       id         TEXT PRIMARY KEY,
@@ -83,6 +93,7 @@ function migrate(conn) {
     CREATE INDEX IF NOT EXISTS idx_session_items_session ON session_items(session_id, position);
     CREATE TABLE IF NOT EXISTS sessions (
       id               TEXT PRIMARY KEY,
+      provider         TEXT,
       agent            TEXT,
       config           TEXT,
       model            TEXT,
@@ -92,6 +103,111 @@ function migrate(conn) {
       created_at       TEXT NOT NULL,
       updated_at       TEXT
     );
+    CREATE TABLE IF NOT EXISTS session_emulator_bindings (
+      session_id  TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
+      binding_id  TEXT NOT NULL UNIQUE,
+      backend     TEXT NOT NULL CHECK(backend IN ('ios', 'android')),
+      device_id   TEXT NOT NULL,
+      device_name TEXT,
+      attached_at TEXT NOT NULL,
+      UNIQUE(backend, device_id)
+    );
+    CREATE TABLE IF NOT EXISTS plugin_session_launch_operations (
+      plugin_id      TEXT NOT NULL,
+      scope_id       TEXT NOT NULL,
+      operation_id   TEXT NOT NULL,
+      request_hash   TEXT NOT NULL,
+      session_id     TEXT NOT NULL,
+      state          TEXT NOT NULL DEFAULT 'active' CHECK(state IN ('active', 'deleted')),
+      created_at     TEXT NOT NULL,
+      updated_at     TEXT NOT NULL,
+      deleted_at     TEXT,
+      PRIMARY KEY(plugin_id, scope_id, operation_id),
+      CHECK(
+        (state = 'active' AND deleted_at IS NULL)
+        OR
+        (state = 'deleted' AND deleted_at IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_plugin_session_launch_operations_session
+      ON plugin_session_launch_operations(session_id);
+    CREATE TABLE IF NOT EXISTS control_links (
+      token      TEXT PRIMARY KEY,
+      plugin_id  TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      expires_at TEXT NOT NULL,
+      used_at    TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_control_links_expires
+      ON control_links(expires_at);
+    CREATE TABLE IF NOT EXISTS runtime_pairing_claims (
+      claim_id                   TEXT PRIMARY KEY,
+      secret_hash                TEXT NOT NULL,
+      authorities                TEXT NOT NULL,
+      client_label               TEXT,
+      created_at                 TEXT NOT NULL,
+      expires_at                 TEXT NOT NULL,
+      consumed_at                TEXT,
+      consumed_client_id         TEXT,
+      consumed_client_public_key TEXT,
+      consumed_grant_id          TEXT,
+      CHECK (
+        (consumed_at IS NULL
+          AND consumed_client_id IS NULL
+          AND consumed_client_public_key IS NULL
+          AND consumed_grant_id IS NULL)
+        OR
+        (consumed_at IS NOT NULL
+          AND consumed_client_id IS NOT NULL
+          AND consumed_client_public_key IS NOT NULL
+          AND consumed_grant_id IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_runtime_pairing_claims_expires
+      ON runtime_pairing_claims(expires_at);
+    CREATE TABLE IF NOT EXISTS runtime_client_grants (
+      grant_id          TEXT PRIMARY KEY,
+      client_id         TEXT NOT NULL,
+      client_public_key TEXT NOT NULL UNIQUE,
+      client_label      TEXT,
+      authorities       TEXT NOT NULL,
+      created_at        TEXT NOT NULL,
+      revoked_at        TEXT,
+      last_used_at      TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_runtime_client_grants_client
+      ON runtime_client_grants(client_id);
+    CREATE TABLE IF NOT EXISTS runtime_targets (
+      daemon_id           TEXT PRIMARY KEY,
+      display_name        TEXT NOT NULL,
+      identity_public_key TEXT NOT NULL,
+      credential_ref      TEXT NOT NULL UNIQUE,
+      created_at          TEXT NOT NULL,
+      updated_at          TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS runtime_direct_routes (
+      daemon_id              TEXT PRIMARY KEY REFERENCES runtime_targets(daemon_id) ON DELETE CASCADE,
+      endpoint               TEXT NOT NULL,
+      tls_ca_certificate_pem TEXT,
+      updated_at             TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS runtime_pending_enrollments (
+      claim_id            TEXT PRIMARY KEY,
+      daemon_id           TEXT NOT NULL UNIQUE,
+      identity_public_key TEXT NOT NULL,
+      credential_ref      TEXT NOT NULL UNIQUE,
+      offer_fingerprint   TEXT NOT NULL,
+      expires_at          TEXT NOT NULL,
+      created_at          TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_runtime_pending_enrollments_expires
+      ON runtime_pending_enrollments(expires_at);
+  `);
+    // Breaking plugin-runtime cutover: remove obsolete core-owned state.
+    conn.exec(`
+    DROP TABLE IF EXISTS control_sessions;
+    DROP TABLE IF EXISTS plugin_daemon_worker_settings;
   `);
     // `sessions` is the unified machine-session record (console + every channel).
     // Add the identity columns to a pre-existing table (SQLite has no
@@ -99,7 +215,18 @@ function migrate(conn) {
     // this change — they were all console sessions.
     addColumnIfMissing(conn, "sessions", "source", "TEXT");
     addColumnIfMissing(conn, "sessions", "updated_at", "TEXT");
+    addColumnIfMissing(conn, "sessions", "provider", "TEXT");
+    const sessionColumns = conn.prepare("PRAGMA table_info(sessions)").all();
+    if (sessionColumns.some((column) => column.name === "executor")) {
+        conn.exec("UPDATE sessions SET provider = executor WHERE provider IS NULL AND executor IS NOT NULL");
+    }
+    addColumnIfMissing(conn, "plugins", "updated_at", "TEXT");
+    addColumnIfMissing(conn, "plugins", "install_path", "TEXT");
+    addColumnIfMissing(conn, "plugins", "manifest", "TEXT");
+    addColumnIfMissing(conn, "plugins", "integrity", "TEXT");
+    addColumnIfMissing(conn, "plugins", "grants", "TEXT");
     conn.exec("UPDATE sessions SET source = 'console' WHERE source IS NULL");
+    conn.exec("UPDATE plugins SET updated_at = installed_at WHERE updated_at IS NULL");
     importLegacyConfig(conn);
 }
 /** Idempotently add a column to an existing table (no-op if already present). */
@@ -121,7 +248,7 @@ function importLegacyConfig(conn) {
     const { n } = conn.prepare("SELECT COUNT(*) AS n FROM channels").get();
     if (n > 0)
         return;
-    const legacy = process.env.RYNX_CONFIG?.trim() || join(rynxHome(), "config.json");
+    const legacy = process.env.RYNX_CONFIG?.trim() || join(daemonHome(), "config.json");
     if (!existsSync(legacy))
         return;
     let channels;
@@ -168,3 +295,6 @@ function importLegacyConfig(conn) {
         /* leave the source in place if it can't be renamed */
     }
 }
+function daemonHome() {
+    return process.env.RYNX_HOME?.trim() || join(homedir(), ".rynx");
+}

package/dist/desktop-browser-host-client.d.ts

@@ -0,0 +1,34 @@
+import { type DesktopBrowserHostCommandFrame, type DesktopBrowserHostErrorCode, type DesktopBrowserHostEvent, type DesktopBrowserHostLeaseFrame, type DesktopBrowserHostSurfaceCapability, type DesktopBrowserHostSurfaceFrame } from "@rynx-ai/protocol/desktop-browser-host";
+export interface ResidentDesktopBrowserHostConnectOptions {
+    hostInstanceId: string;
+    /** Advertise only handlers that are installed in this main-process Host. */
+    capabilities: {
+        semanticPageBinding: boolean;
+        surface: DesktopBrowserHostSurfaceCapability;
+    };
+    signal?: AbortSignal;
+}
+export interface ResidentDesktopBrowserHostFailure {
+    code: DesktopBrowserHostErrorCode;
+    message: string;
+}
+/**
+ * Process-private lease used by Electron main. The management credential is
+ * resolved and consumed in this package and never returned to the app renderer.
+ */
+export interface ResidentDesktopBrowserHostCommandRequest {
+    readonly frame: DesktopBrowserHostCommandFrame;
+    /** Aborts at the daemon-supplied absolute deadline or on lease loss. */
+    readonly signal: AbortSignal;
+    reply(result: unknown): Promise<void>;
+    reject(failure: ResidentDesktopBrowserHostFailure): Promise<void>;
+}
+export interface ResidentDesktopBrowserHostConnection extends AsyncIterable<ResidentDesktopBrowserHostCommandRequest> {
+    readonly lease: DesktopBrowserHostLeaseFrame;
+    readonly closed: Promise<void>;
+    emit(event: DesktopBrowserHostEvent): Promise<void>;
+    emitSurfaceFrame(frame: Omit<DesktopBrowserHostSurfaceFrame, "leaseId">): Promise<void>;
+    close(): Promise<void>;
+}
+/** Open the sole resident daemon's authenticated loopback Desktop Host lease. */
+export declare function connectResidentDesktopBrowserHost(options: ResidentDesktopBrowserHostConnectOptions): Promise<ResidentDesktopBrowserHostConnection>;

package/dist/desktop-browser-host-client.js

@@ -0,0 +1,413 @@
+import { DESKTOP_BROWSER_HOST_MAX_BINARY_FRAME_BYTES, DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES, DESKTOP_BROWSER_HOST_MAX_PENDING_COMMANDS, DESKTOP_BROWSER_HOST_PATH, DESKTOP_BROWSER_HOST_PROTOCOL_VERSION, encodeDesktopBrowserHostSurfaceFrame, parseDesktopBrowserHostClientFrame, parseDesktopBrowserHostServerFrame, } from "@rynx-ai/protocol/desktop-browser-host";
+import { WebSocket } from "ws";
+import { ensureDaemonControlEndpoint } from "./control-endpoint.js";
+const CONNECT_TIMEOUT_MS = 5_000;
+const MAX_BUFFERED_BYTES = DESKTOP_BROWSER_HOST_MAX_BINARY_FRAME_BYTES + DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES;
+/** Open the sole resident daemon's authenticated loopback Desktop Host lease. */
+export async function connectResidentDesktopBrowserHost(options) {
+    options.signal?.throwIfAborted();
+    const hello = parseDesktopBrowserHostClientFrame({
+        type: "desktop.browser.host.hello",
+        protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+        hostInstanceId: options.hostInstanceId,
+        capabilities: {
+            semanticPageBinding: options.capabilities.semanticPageBinding,
+            surface: options.capabilities.surface,
+        },
+    });
+    if (hello.type !== "desktop.browser.host.hello") {
+        throw new Error("Desktop Browser Host hello parser returned the wrong frame");
+    }
+    const endpoint = await ensureDaemonControlEndpoint({ signal: options.signal });
+    assertLoopbackOrigin(endpoint.origin);
+    const url = new URL(DESKTOP_BROWSER_HOST_PATH, `${endpoint.origin}/`);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const socket = new WebSocket(url, {
+        headers: { "x-rynx-management-token": endpoint.managementToken },
+        handshakeTimeout: CONNECT_TIMEOUT_MS,
+        maxPayload: DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES,
+        perMessageDeflate: false,
+    });
+    const queue = new BoundedCommandQueue(DESKTOP_BROWSER_HOST_MAX_PENDING_COMMANDS);
+    let lease;
+    let leaseResolve;
+    let leaseReject;
+    const leaseReady = new Promise((resolve, reject) => {
+        leaseResolve = resolve;
+        leaseReject = reject;
+    });
+    let closedResolve;
+    const closed = new Promise((resolve) => {
+        closedResolve = resolve;
+    });
+    let terminalError;
+    let eventSequence = 0;
+    let closing = false;
+    let writerTail = Promise.resolve();
+    const activeRequests = new Map();
+    const abortActiveRequests = (error) => {
+        for (const request of activeRequests.values()) {
+            if (request.timer)
+                clearTimeout(request.timer);
+            request.settled = true;
+            request.controller.abort(error);
+        }
+        activeRequests.clear();
+    };
+    const fail = (error) => {
+        terminalError ??= error;
+        if (!lease)
+            leaseReject(error);
+        queue.close(error);
+        abortActiveRequests(error);
+    };
+    const failConnection = (error, code, reason) => {
+        fail(error);
+        if (socket.readyState < WebSocket.CLOSING)
+            socket.close(code, reason);
+    };
+    const enqueueWrite = (operation) => {
+        const current = writerTail.then(async () => {
+            if (terminalError)
+                throw terminalError;
+            await operation();
+        });
+        writerTail = current.catch(() => undefined);
+        return current.catch((error) => {
+            const failure = asError(error, "Desktop Browser Host output failed");
+            failConnection(failure, 1011, "host output failed");
+            throw failure;
+        });
+    };
+    const onAbort = () => {
+        const error = abortError(options.signal?.reason);
+        failConnection(error, 1000, "aborted");
+    };
+    options.signal?.addEventListener("abort", onAbort, { once: true });
+    socket.on("open", () => {
+        void enqueueWrite(() => sendJson(socket, hello));
+    });
+    socket.on("message", (raw, isBinary) => {
+        if (isBinary) {
+            failConnection(new Error("Desktop Browser Host daemon sent an unexpected binary frame"), 1003, "binary frame unsupported");
+            return;
+        }
+        let frame;
+        try {
+            const bytes = rawDataBytes(raw);
+            if (bytes.byteLength === 0 || bytes.byteLength > DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES) {
+                throw new Error("Desktop Browser Host daemon frame exceeded its bound");
+            }
+            frame = parseDesktopBrowserHostServerFrame(JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes)));
+        }
+        catch (error) {
+            failConnection(asError(error, "Desktop Browser Host daemon frame was invalid"), 1007, "invalid daemon frame");
+            return;
+        }
+        if (!lease) {
+            if (frame.type !== "desktop.browser.host.lease") {
+                failConnection(new Error("Desktop Browser Host daemon did not begin with a lease"), 1002, "lease required");
+                return;
+            }
+            if (frame.capabilities.semanticPageBinding &&
+                !options.capabilities.semanticPageBinding) {
+                failConnection(new Error("Desktop Browser Host daemon enabled an unadvertised Page binding capability"), 1002, "invalid lease capabilities");
+                return;
+            }
+            if (frame.capabilities.surface === "binary-v1" &&
+                options.capabilities.surface !== "binary-v1") {
+                failConnection(new Error("Desktop Browser Host daemon enabled an unadvertised Surface capability"), 1002, "invalid lease capabilities");
+                return;
+            }
+            lease = frame;
+            leaseResolve(frame);
+            return;
+        }
+        if (frame.type !== "desktop.browser.host.command" || frame.leaseId !== lease.leaseId) {
+            failConnection(new Error("Desktop Browser Host daemon sent a frame outside the active lease"), 1002, "lease mismatch");
+            return;
+        }
+        if (!queue.push(frame)) {
+            failConnection(new Error("Desktop Browser Host command capacity exceeded"), 1013, "command capacity exceeded");
+        }
+    });
+    socket.on("error", (error) => {
+        failConnection(new Error("Desktop Browser Host connection failed", { cause: error }), 1011, "connection failed");
+    });
+    socket.once("close", (code, reason) => {
+        options.signal?.removeEventListener("abort", onAbort);
+        if (!terminalError && !closing) {
+            terminalError = new Error(`Desktop Browser Host lease closed (${code})${reason.length > 0 ? `: ${reason.toString("utf8")}` : ""}`);
+        }
+        if (!lease && terminalError)
+            leaseReject(terminalError);
+        queue.close(terminalError);
+        abortActiveRequests(terminalError ?? new Error("Desktop Browser Host lease closed"));
+        closedResolve();
+    });
+    try {
+        lease = await abortableTimeout(leaseReady, CONNECT_TIMEOUT_MS, options.signal);
+    }
+    catch (error) {
+        if (socket.readyState < WebSocket.CLOSING)
+            socket.close(1000, "lease failed");
+        throw error;
+    }
+    const activeLease = lease;
+    const settle = async (command, value) => {
+        const request = activeRequests.get(command.commandId);
+        if (!request || request.settled) {
+            throw new Error("Desktop Browser Host command is already settled or stale");
+        }
+        if (command.leaseId !== activeLease.leaseId ||
+            request.controller.signal.aborted ||
+            Date.now() >= command.deadlineUnixMilliseconds) {
+            expireRequest(command, request);
+            throw new Error("Desktop Browser Host command deadline expired before settlement");
+        }
+        request.settled = true;
+        if (request.timer)
+            clearTimeout(request.timer);
+        activeRequests.delete(command.commandId);
+        await enqueueWrite(async () => {
+            const frame = parseDesktopBrowserHostClientFrame(value);
+            if (frame.type !== "desktop.browser.host.reply") {
+                throw new Error("Desktop Browser Host reply parser returned the wrong frame");
+            }
+            await sendJson(socket, frame);
+        });
+    };
+    const expireRequest = (command, request) => {
+        if (request.settled)
+            return;
+        request.settled = true;
+        if (request.timer)
+            clearTimeout(request.timer);
+        activeRequests.delete(command.commandId);
+        const error = new Error(`Desktop Browser Host ${command.command.method} deadline expired`);
+        request.controller.abort(error);
+        if (isMutatingCommand(command)) {
+            failConnection(error, 1000, "command deadline expired");
+        }
+    };
+    const requestIterator = queue[Symbol.asyncIterator]();
+    const claimedIterator = {
+        next: async () => {
+            const next = await requestIterator.next();
+            if (next.done)
+                return { done: true, value: undefined };
+            const command = next.value;
+            if (activeRequests.has(command.commandId)) {
+                const error = new Error("Desktop Browser Host daemon repeated a commandId");
+                failConnection(error, 1002, "duplicate command");
+                throw error;
+            }
+            const controller = new AbortController();
+            const remaining = command.deadlineUnixMilliseconds - Date.now();
+            const request = {
+                controller,
+                settled: false,
+            };
+            request.timer = setTimeout(() => expireRequest(command, request), Math.max(1, remaining));
+            request.timer.unref?.();
+            activeRequests.set(command.commandId, request);
+            if (remaining <= 0) {
+                expireRequest(command, request);
+                throw new Error("Desktop Browser Host received an expired command");
+            }
+            return {
+                done: false,
+                value: {
+                    frame: command,
+                    signal: controller.signal,
+                    reply: (result) => settle(command, {
+                        type: "desktop.browser.host.reply",
+                        protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+                        leaseId: activeLease.leaseId,
+                        commandId: command.commandId,
+                        ok: true,
+                        result,
+                    }),
+                    reject: (failure) => settle(command, {
+                        type: "desktop.browser.host.reply",
+                        protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+                        leaseId: activeLease.leaseId,
+                        commandId: command.commandId,
+                        ok: false,
+                        error: failure,
+                    }),
+                },
+            };
+        },
+    };
+    return {
+        lease: activeLease,
+        closed,
+        [Symbol.asyncIterator]: () => claimedIterator,
+        emit: (event) => enqueueWrite(async () => {
+            const nextSequence = eventSequence + 1;
+            const frame = parseDesktopBrowserHostClientFrame({
+                type: "desktop.browser.host.event",
+                protocolVersion: DESKTOP_BROWSER_HOST_PROTOCOL_VERSION,
+                leaseId: activeLease.leaseId,
+                eventSequence: nextSequence,
+                event,
+            });
+            if (frame.type !== "desktop.browser.host.event") {
+                throw new Error("Desktop Browser Host event parser returned the wrong frame");
+            }
+            await sendJson(socket, frame);
+            eventSequence = nextSequence;
+        }),
+        emitSurfaceFrame: (frame) => enqueueWrite(async () => {
+            if (activeLease.capabilities.surface !== "binary-v1") {
+                throw new Error("Desktop Browser Host Surface was not negotiated");
+            }
+            const encoded = encodeDesktopBrowserHostSurfaceFrame({
+                ...frame,
+                leaseId: activeLease.leaseId,
+            });
+            await sendBinary(socket, encoded);
+        }),
+        close: async () => {
+            if (closing)
+                return closed;
+            closing = true;
+            queue.close();
+            abortActiveRequests(new Error("Desktop Browser Host stopped"));
+            if (socket.readyState < WebSocket.CLOSING)
+                socket.close(1000, "host stopped");
+            if (socket.readyState === WebSocket.CLOSED)
+                closedResolve();
+            await closed;
+        },
+    };
+}
+async function sendBinary(socket, bytes) {
+    if (socket.readyState !== WebSocket.OPEN)
+        throw new Error("Desktop Browser Host lease is closed");
+    if (bytes.byteLength === 0 || bytes.byteLength > DESKTOP_BROWSER_HOST_MAX_BINARY_FRAME_BYTES) {
+        throw new Error("Desktop Browser Host binary frame exceeded its bound");
+    }
+    if (socket.bufferedAmount + bytes.byteLength > MAX_BUFFERED_BYTES) {
+        throw new Error("Desktop Browser Host output buffer exceeded its bound");
+    }
+    await new Promise((resolve, reject) => {
+        socket.send(bytes, { binary: true, compress: false }, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+async function sendJson(socket, value) {
+    if (socket.readyState !== WebSocket.OPEN)
+        throw new Error("Desktop Browser Host lease is closed");
+    const bytes = Buffer.from(JSON.stringify(value), "utf8");
+    if (bytes.byteLength === 0 || bytes.byteLength > DESKTOP_BROWSER_HOST_MAX_CONTROL_FRAME_BYTES) {
+        throw new Error("Desktop Browser Host client frame exceeded its bound");
+    }
+    if (socket.bufferedAmount + bytes.byteLength > MAX_BUFFERED_BYTES) {
+        throw new Error("Desktop Browser Host output buffer exceeded its bound");
+    }
+    await new Promise((resolve, reject) => {
+        socket.send(bytes, { binary: false, compress: false }, (error) => {
+            if (error)
+                reject(error);
+            else
+                resolve();
+        });
+    });
+}
+class BoundedCommandQueue {
+    capacity;
+    values = [];
+    waiters = [];
+    ended = false;
+    error;
+    constructor(capacity) {
+        this.capacity = capacity;
+    }
+    push(value) {
+        if (this.ended)
+            return false;
+        const waiter = this.waiters.shift();
+        if (waiter) {
+            waiter.resolve({ done: false, value });
+            return true;
+        }
+        if (this.values.length >= this.capacity)
+            return false;
+        this.values.push(value);
+        return true;
+    }
+    close(error) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.error = error;
+        // Commands are capabilities of this exact socket lease. Never drain a
+        // buffered command after abort/disconnect, even if it was parsed earlier.
+        this.values.length = 0;
+        for (const waiter of this.waiters.splice(0)) {
+            if (error)
+                waiter.reject(error);
+            else
+                waiter.resolve({ done: true, value: undefined });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                const value = this.values.shift();
+                if (value)
+                    return Promise.resolve({ done: false, value });
+                if (this.ended) {
+                    return this.error
+                        ? Promise.reject(this.error)
+                        : Promise.resolve({ done: true, value: undefined });
+                }
+                return new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+            },
+        };
+    }
+}
+function rawDataBytes(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (Array.isArray(data))
+        return Buffer.concat(data);
+    throw new Error("Desktop Browser Host received an unsupported WebSocket payload");
+}
+function isMutatingCommand(command) {
+    return command.command.method !== "browser.snapshot" &&
+        command.command.method !== "browser.cdp-endpoint";
+}
+async function abortableTimeout(promise, timeoutMs, signal) {
+    signal?.throwIfAborted();
+    const timeout = AbortSignal.timeout(timeoutMs);
+    const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+    return await new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError(combined.reason));
+        combined.addEventListener("abort", onAbort, { once: true });
+        promise.then(resolve, reject).finally(() => combined.removeEventListener("abort", onAbort));
+    });
+}
+function abortError(reason) {
+    if (reason instanceof Error)
+        return reason;
+    return new Error("Desktop Browser Host connection was aborted", { cause: reason });
+}
+function asError(error, message) {
+    return error instanceof Error ? error : new Error(message, { cause: error });
+}
+function assertLoopbackOrigin(origin) {
+    const url = new URL(origin);
+    const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    if (host !== "localhost" && host !== "127.0.0.1" && host !== "::1") {
+        throw new Error("resident daemon Desktop Browser Host endpoint is not loopback");
+    }
+}

package/dist/direct-runtime-authenticator.d.ts

@@ -0,0 +1,13 @@
+import { type DirectRuntimeServerHello } from "@rynx-ai/protocol/direct-runtime";
+import type { DaemonRuntimeHost, DirectRuntimeAuthenticationResult, DirectRuntimeAuthenticator } from "@rynx-ai/server";
+import type { DaemonInstallationIdentity } from "./installation-id.js";
+import { RemoteRuntimeAccessStore } from "./remote-runtime-access-store.js";
+/** Daemon-side proof verification shared by Direct control and Browser Surface bindings. */
+export declare class DaemonDirectRuntimeAuthenticator implements DirectRuntimeAuthenticator {
+    private readonly identity;
+    private readonly runtime;
+    private readonly access;
+    constructor(identity: DaemonInstallationIdentity, runtime: DaemonRuntimeHost, access: RemoteRuntimeAccessStore);
+    createServerHello({ channelBinding, role, signal, }: Parameters<DirectRuntimeAuthenticator["createServerHello"]>[0]): DirectRuntimeServerHello;
+    authenticate({ channelBinding, role, serverHello, clientAuthenticate, signal, }: Parameters<DirectRuntimeAuthenticator["authenticate"]>[0]): DirectRuntimeAuthenticationResult;
+}