@rynx-ai/daemon 0.1.0 → 0.1.10-beta.2

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,
@@ -81,8 +91,59 @@ function migrate(conn) {
       UNIQUE(session_id, position)
     );
     CREATE INDEX IF NOT EXISTS idx_session_items_session ON session_items(session_id, position);
+    CREATE TABLE IF NOT EXISTS session_resources (
+      id               TEXT PRIMARY KEY,
+      session_id       TEXT NOT NULL,
+      client_upload_id TEXT NOT NULL,
+      upload_id        TEXT NOT NULL UNIQUE,
+      filename         TEXT NOT NULL,
+      media_type       TEXT NOT NULL CHECK(media_type IN ('image/png', 'image/jpeg', 'image/webp')),
+      byte_length      INTEGER NOT NULL,
+      uploaded_bytes   INTEGER NOT NULL DEFAULT 0,
+      sha256           TEXT,
+      width            INTEGER,
+      height           INTEGER,
+      state            TEXT NOT NULL DEFAULT 'uploading'
+        CHECK(state IN ('uploading', 'staged', 'committed')),
+      message_item_id  TEXT,
+      created_at       INTEGER NOT NULL,
+      committed_at     INTEGER,
+      UNIQUE(session_id, client_upload_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_resources_session
+      ON session_resources(session_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_session_resources_message
+      ON session_resources(message_item_id);
+    CREATE TABLE IF NOT EXISTS session_message_operations (
+      session_id       TEXT NOT NULL,
+      client_message_id TEXT NOT NULL,
+      request_hash     TEXT NOT NULL,
+      state            TEXT NOT NULL DEFAULT 'prepared'
+        CHECK(state IN (
+          'prepared',
+          'injecting',
+          'injected',
+          'mirrored',
+          'outcome_unknown',
+          'failed_not_started'
+        )),
+      error            TEXT,
+      created_at       INTEGER NOT NULL,
+      updated_at       INTEGER NOT NULL,
+      PRIMARY KEY(session_id, client_message_id)
+    );
+    CREATE TABLE IF NOT EXISTS session_message_operation_resources (
+      session_id        TEXT NOT NULL,
+      client_message_id TEXT NOT NULL,
+      resource_id       TEXT NOT NULL UNIQUE REFERENCES session_resources(id) ON DELETE CASCADE,
+      PRIMARY KEY(session_id, client_message_id, resource_id),
+      FOREIGN KEY(session_id, client_message_id)
+        REFERENCES session_message_operations(session_id, client_message_id)
+        ON DELETE CASCADE
+    );
     CREATE TABLE IF NOT EXISTS sessions (
       id               TEXT PRIMARY KEY,
+      provider         TEXT,
       agent            TEXT,
       config           TEXT,
       model            TEXT,
@@ -92,6 +153,117 @@ function migrate(conn) {
       created_at       TEXT NOT NULL,
       updated_at       TEXT
     );
+    CREATE TABLE IF NOT EXISTS session_pending_messages (
+      session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
+      message    TEXT NOT NULL,
+      state      TEXT NOT NULL DEFAULT 'queued' CHECK(state IN ('queued', 'outcome_unknown')),
+      created_at TEXT NOT NULL
+    );
+    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 +271,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 +304,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 +351,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,35 @@
+import { type DesktopBrowserHostCommandFrame, type DesktopBrowserHostErrorCode, type DesktopBrowserHostEvent, type DesktopBrowserHostLeaseFrame, type DesktopBrowserHostPresentation, 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;
+        presentation: DesktopBrowserHostPresentation;
+        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>;