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

package/dist/remote-runtime-connection-manager.js

@@ -1,9 +1,10 @@
 import { randomUUID } from "node:crypto";
+import { RUNTIME_BROWSER_INSPECT_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-browser-inspect";
 import { RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-browser-surface";
 import { RUNTIME_EMULATOR_SURFACE_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-emulator-surface";
 import { assertRemoteRuntimeRpcMethodSupported, assertRemoteRuntimeSessionEventsSupported, assertRemoteRuntimeSessionTerminalSupported, parseRemoteRuntimeRpcRequest, REMOTE_RUNTIME_RPC_METHOD_METADATA, } from "@rynx-ai/protocol/remote-runtime-rpc";
 import { REMOTE_RUNTIME_CORE_PROTOCOL, } from "@rynx-ai/protocol/remote-runtime";
-import { connectDirectRuntime, openDirectRuntimeBrowserSurface, DirectRuntimeCallTransportError, DirectRuntimeClientCapacityError, DirectRuntimeClientError, DirectRuntimeRpcError, DirectRuntimeSessionEventsError, DirectRuntimeSessionTerminalError, } from "@rynx-ai/remote-runtime-client";
+import { connectDirectRuntime, openDirectRuntimeBrowserInspect, openDirectRuntimeBrowserSurface, DirectRuntimeCallTransportError, DirectRuntimeClientCapacityError, DirectRuntimeClientError, DirectRuntimeRpcError, DirectRuntimeSessionEventsError, DirectRuntimeSessionTerminalError, } from "@rynx-ai/remote-runtime-client";
 import { SessionTerminalOpenError } from "@rynx-ai/server";
 const LOCAL_SELECTOR = "local";
 const TARGET_SELECTOR_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._~-]{0,255}$/;
@@ -41,6 +42,8 @@ export class DaemonRuntimeConnectionManager {
     maxIdleConnections;
     slots = new Map();
     generations = new Map();
+    /** Independent inspect sockets must outlive shared control-channel eviction. */
+    browserInspectClosers = new Map();
     localStatusSnapshot;
     closed = false;
     managerClosePromise;
@@ -48,6 +51,7 @@ export class DaemonRuntimeConnectionManager {
         this.options = options;
         this.client = options.client ?? {
             connect: (credential) => connectDirectRuntime(credential),
+            openBrowserInspect: (credential, target, inspectOptions) => openDirectRuntimeBrowserInspect(credential, target, inspectOptions),
             openBrowserSurface: (credential, frame, surfaceOptions) => openDirectRuntimeBrowserSurface(credential, frame, surfaceOptions),
         };
         this.idleTtlMs = nonNegativeInteger(options.idleTtlMs, DEFAULT_IDLE_TTL_MS, "idleTtlMs");
@@ -89,11 +93,12 @@ export class DaemonRuntimeConnectionManager {
         }
         this.bumpGeneration(daemonId);
         const slot = this.slots.get(daemonId);
+        const closingInspects = this.closeBrowserInspects(daemonId);
         if (!slot)
-            return Promise.resolve();
+            return closingInspects;
         this.slots.delete(daemonId);
         this.cancelIdleTimer(slot);
-        return this.closeSlot(slot);
+        return closeAll([this.closeSlot(slot), closingInspects]);
     }
     close() {
         if (this.managerClosePromise)
@@ -105,7 +110,12 @@ export class DaemonRuntimeConnectionManager {
             this.bumpGeneration(slot.daemonId);
             this.cancelIdleTimer(slot);
         }
-        this.managerClosePromise = closeAll(slots.map((slot) => this.closeSlot(slot)));
+        const inspectClosures = [...this.browserInspectClosers.keys()]
+            .map((daemonId) => this.closeBrowserInspects(daemonId));
+        this.managerClosePromise = closeAll([
+            ...slots.map((slot) => this.closeSlot(slot)),
+            ...inspectClosures,
+        ]);
         return this.managerClosePromise;
     }
     localLease() {
@@ -226,6 +236,9 @@ export class DaemonRuntimeConnectionManager {
                     throw error;
                 }
             },
+            openBrowserInspect: async () => {
+                throw managerError("incompatible", "Local Runtime Browser Inspect is not available through the Runtime connection lease", undefined, "not_started");
+            },
             openEmulatorSurface: async (sessionId, bindingId, surfaceOptions = {}) => {
                 if (released)
                     throw managerError("closed", "Runtime connection lease was released");
@@ -487,6 +500,20 @@ export class DaemonRuntimeConnectionManager {
                 }
                 return await this.openDedicatedDirectBrowserSurface(slot, frame, surfaceOptions);
             },
+            openBrowserInspect: async (target, inspectOptions = {}) => {
+                if (released)
+                    throw managerError("closed", "Runtime connection lease was released");
+                this.assertOpen();
+                this.assertSlotCurrent(slot);
+                throwIfAborted(inspectOptions.signal);
+                const status = slot.status;
+                if (!status)
+                    throw managerError("closed", "Runtime status is not available");
+                if (!status.semanticCapabilities.includes(RUNTIME_BROWSER_INSPECT_SEMANTIC_CAPABILITY)) {
+                    throw managerError("incompatible", "Remote Runtime Browser Inspect is unavailable", undefined, "not_started");
+                }
+                return await this.openDedicatedDirectBrowserInspect(slot, target, inspectOptions);
+            },
             openEmulatorSurface: async (sessionId, bindingId, surfaceOptions = {}) => {
                 if (released)
                     throw managerError("closed", "Runtime connection lease was released");
@@ -701,6 +728,71 @@ export class DaemonRuntimeConnectionManager {
             resolveOpeningOperation();
         }
     }
+    async openDedicatedDirectBrowserInspect(slot, target, options) {
+        const timeoutMs = parseCallTimeout(options.timeoutMs);
+        let persisted;
+        try {
+            persisted = await this.options.credentials.load(slot.target.credentialRef);
+        }
+        catch (error) {
+            throw managerError("authentication_failed", "Runtime target credential is unavailable", error);
+        }
+        if (persisted.daemonId !== slot.target.daemonId ||
+            persisted.identityPublicKey !== slot.target.identityPublicKey) {
+            throw managerError("identity_mismatch", "Runtime target metadata does not match its protected credential");
+        }
+        this.assertSlotCurrent(slot);
+        throwIfAborted(options.signal);
+        const credential = {
+            ...persisted,
+            directEndpoint: slot.target.directRoute.endpoint,
+        };
+        const openBrowserInspect = this.client.openBrowserInspect
+            ?? ((inspectCredential, inspectTarget, inspectOptions) => openDirectRuntimeBrowserInspect(inspectCredential, inspectTarget, inspectOptions));
+        const signal = combinedSignal(options.signal, slot.dedicatedAbortController.signal);
+        let resolveOpeningOperation;
+        const openingOperation = new Promise((resolve) => {
+            resolveOpeningOperation = resolve;
+        });
+        slot.pendingDedicatedOpenings.add(openingOperation);
+        let resolvedConnection;
+        let opening;
+        try {
+            throwIfAborted(signal);
+            opening = openBrowserInspect(credential, target, {
+                ...(timeoutMs === undefined ? {} : { timeoutMs }),
+                ...(signal ? { signal } : {}),
+            }).then((opened) => {
+                resolvedConnection = opened;
+                return opened;
+            });
+            const connection = await waitFor(opening, signal);
+            this.assertSlotCurrent(slot);
+            throwIfAborted(signal);
+            slot.lastUsedAt = Date.now();
+            return this.trackDedicatedBrowserInspect(slot, connection, options.signal);
+        }
+        catch (error) {
+            if (resolvedConnection) {
+                await resolvedConnection.close().catch(() => undefined);
+            }
+            else if (opening) {
+                const closeLate = opening.then((opened) => opened.close()).catch(() => undefined);
+                if (slot.dedicatedAbortController.signal.aborted)
+                    await closeLate;
+                else
+                    void closeLate;
+            }
+            if (slot.dedicatedAbortController.signal.aborted && isAbort(error)) {
+                throw managerError("closed", "Runtime connection was invalidated while opening Browser Inspect");
+            }
+            throw error;
+        }
+        finally {
+            slot.pendingDedicatedOpenings.delete(openingOperation);
+            resolveOpeningOperation();
+        }
+    }
     async openDedicatedDirectEmulatorSurface(slot, sessionId, bindingId, options) {
         const timeoutMs = parseCallTimeout(options.timeoutMs);
         let persisted;
@@ -934,6 +1026,80 @@ export class DaemonRuntimeConnectionManager {
             },
         };
     }
+    trackDedicatedBrowserInspect(slot, connection, signal) {
+        let close;
+        let finished = false;
+        const onAbort = () => {
+            void close().catch(() => undefined);
+        };
+        close = this.registerBrowserInspectCloser(slot.daemonId, () => {
+            finished = true;
+            signal?.removeEventListener("abort", onAbort);
+            return connection.close();
+        }, connection.closed.then(() => {
+            finished = true;
+            signal?.removeEventListener("abort", onAbort);
+        }));
+        if (signal?.aborted)
+            onAbort();
+        else
+            signal?.addEventListener("abort", onAbort, { once: true });
+        return {
+            daemonInstanceId: connection.daemonInstanceId,
+            send: async (message) => {
+                if (finished) {
+                    throw managerError("closed", "Remote Browser Inspect connection is closed");
+                }
+                throwIfAborted(signal);
+                await connection.send(message);
+            },
+            close,
+            [Symbol.asyncIterator]: () => {
+                const iterator = connection[Symbol.asyncIterator]();
+                return {
+                    next: async () => {
+                        if (finished)
+                            return { done: true, value: undefined };
+                        throwIfAborted(signal);
+                        return await iterator.next();
+                    },
+                    return: async () => {
+                        await close();
+                        return { done: true, value: undefined };
+                    },
+                };
+            },
+        };
+    }
+    registerBrowserInspectCloser(daemonId, closeResource, naturallyClosed) {
+        let closers = this.browserInspectClosers.get(daemonId);
+        if (!closers) {
+            closers = new Set();
+            this.browserInspectClosers.set(daemonId, closers);
+        }
+        let closePromise;
+        const forget = () => {
+            closers.delete(close);
+            if (closers.size === 0)
+                this.browserInspectClosers.delete(daemonId);
+        };
+        const close = () => {
+            closePromise ??= Promise.resolve()
+                .then(closeResource)
+                .finally(forget);
+            return closePromise;
+        };
+        closers.add(close);
+        void naturallyClosed.then(forget, forget);
+        return close;
+    }
+    closeBrowserInspects(daemonId) {
+        const closers = this.browserInspectClosers.get(daemonId);
+        if (!closers)
+            return Promise.resolve();
+        this.browserInspectClosers.delete(daemonId);
+        return closeAll([...closers].map((close) => close()));
+    }
     trackDedicatedEmulatorSurface(slot, connection, surface) {
         const close = this.registerDedicatedCloser(slot, async () => {
             try {

package/dist/remote-runtime-target-control.d.ts

@@ -5,7 +5,7 @@ import { type DaemonRuntimeHost, type RuntimeTargetControlHost, type RuntimeTarg
 import { DaemonRuntimeConnectionManager } from "./remote-runtime-connection-manager.js";
 import { FileRemoteRuntimeCredentialStore } from "./remote-runtime-credential-store.js";
 import { RemoteRuntimeTargetStore } from "./remote-runtime-target-store.js";
-export type RuntimeTargetControlErrorCode = "invalid_offer" | "invalid_target" | "not_found" | "conflict" | "tls_error" | "identity_mismatch" | "incompatible" | "authentication_failed" | "protocol_error" | "deadline_exceeded" | "outcome_unknown" | "unreachable";
+export type RuntimeTargetControlErrorCode = "invalid_offer" | "offer_expired" | "offer_rejected" | "invalid_target" | "not_found" | "conflict" | "tls_error" | "identity_mismatch" | "incompatible" | "authentication_failed" | "protocol_error" | "deadline_exceeded" | "outcome_unknown" | "unreachable";
 export declare class RuntimeTargetControlError extends Error {
     readonly code: RuntimeTargetControlErrorCode;
     constructor(code: RuntimeTargetControlErrorCode, message: string, options?: ErrorOptions);
@@ -13,6 +13,8 @@ export declare class RuntimeTargetControlError extends Error {
 interface PairInput {
     offer: unknown;
     displayName?: string;
+    replaceExisting?: boolean;
+    expectedDaemonId?: string;
 }
 interface RuntimeTargetClientAdapter {
     pair(offer: PairingOffer, options: PairDirectRuntimeOptions): ReturnType<typeof pairDirectRuntime>;
@@ -33,7 +35,9 @@ export declare class DaemonRuntimeTargetControl implements RuntimeTargetControlH
         status: DaemonStatus;
     }>;
     private discardExpiredPending;
+    private removePendingEnrollment;
     private resumePendingEnrollment;
+    private cleanupReplacedTarget;
     private probe;
     test(selector: string): Promise<{
         target: RuntimeTargetView;

package/dist/remote-runtime-target-control.js

@@ -51,15 +51,25 @@ export class DaemonRuntimeTargetControl {
             if (offer.daemonId === this.localRuntime.status().daemonId) {
                 throw controlError("conflict", "cannot pair the local daemon as a remote target");
             }
+            if (input.replaceExisting
+                ? input.expectedDaemonId !== offer.daemonId
+                : input.expectedDaemonId !== undefined) {
+                throw controlError("invalid_target", "the fresh pairing link does not match the Runtime selected for reauthorization");
+            }
             // Validate all client-local metadata before any network enrollment.
-            const targetName = displayName(input.displayName, offer.daemonId);
             const existing = this.targets.get(offer.daemonId);
             if (existing) {
                 if (existing.identityPublicKey !== offer.identityPublicKey) {
                     throw controlError("identity_mismatch", "a target with this daemonId has a different pinned identity key");
                 }
-                throw controlError("conflict", "this Runtime target is already paired");
+                if (!input.replaceExisting) {
+                    throw controlError("conflict", "this Runtime target is already paired");
+                }
+            }
+            else if (input.replaceExisting) {
+                throw controlError("not_found", "the Runtime target to reauthorize was not found");
             }
+            const targetName = displayName(input.displayName ?? (input.replaceExisting ? existing?.displayName : undefined), offer.daemonId);
             const fingerprint = pairingOfferFingerprint(offer);
             let pending = this.targets.getPendingEnrollment(offer.claimId);
             const otherPending = this.targets.getPendingEnrollmentForDaemon(offer.daemonId);
@@ -70,7 +80,7 @@ export class DaemonRuntimeTargetControl {
             if (pending)
                 assertPendingOffer(pending, offer, fingerprint);
             if (!pending && parsed.expired) {
-                throw controlError("invalid_offer", "pairing offer has expired");
+                throw controlError("offer_expired", "pairing offer has expired");
             }
             if (!pending) {
                 const identity = generateDirectRuntimeClientIdentity();
@@ -93,7 +103,7 @@ export class DaemonRuntimeTargetControl {
                     throw persistenceError("failed to prepare the Runtime enrollment", error);
                 }
             }
-            return await this.resumePendingEnrollment(pending, offer, targetName, parsed.expired);
+            return await this.resumePendingEnrollment(pending, offer, targetName, parsed.expired, input.replaceExisting ? existing : undefined);
         }
         finally {
             this.pairing = false;
@@ -103,15 +113,18 @@ export class DaemonRuntimeTargetControl {
         if (Date.parse(pending.expiresAt) > Date.now()) {
             throw controlError("conflict", "a different unexpired enrollment is already pending for this Runtime");
         }
+        await this.removePendingEnrollment(pending, "failed to discard an expired Runtime enrollment");
+    }
+    async removePendingEnrollment(pending, failureMessage) {
         try {
             await this.credentials.remove(pending.credentialRef);
             this.targets.removePendingEnrollment(pending.claimId);
         }
         catch (error) {
-            throw persistenceError("failed to discard an expired Runtime enrollment", error);
+            throw persistenceError(failureMessage, error);
         }
     }
-    async resumePendingEnrollment(pending, offer, targetName, offerExpired) {
+    async resumePendingEnrollment(pending, offer, targetName, offerExpired, replacedTarget) {
         let enrollment;
         try {
             enrollment = await this.credentials.loadEnrollment(pending.credentialRef);
@@ -131,7 +144,11 @@ export class DaemonRuntimeTargetControl {
                 });
             }
             catch (error) {
-                throw normalizeClientError(error);
+                const normalized = normalizePairingClientError(error);
+                if (normalized.code === "offer_rejected") {
+                    await this.removePendingEnrollment(pending, "failed to discard the rejected Runtime enrollment");
+                }
+                throw normalized;
             }
             assertPairResult(paired, offer, enrollment.credential);
             accepted = secretCredentialFrom(paired.credential);
@@ -148,6 +165,9 @@ export class DaemonRuntimeTargetControl {
             assertCredentialTarget(accepted, pending.daemonId, pending.identityPublicKey);
             status = await this.probe(directCredentialForOffer(accepted, offer));
         }
+        const invalidation = replacedTarget
+            ? this.connections.invalidate(replacedTarget.daemonId)
+            : undefined;
         let target;
         try {
             target = this.targets.commitPendingEnrollment(pending.claimId, {
@@ -156,13 +176,42 @@ export class DaemonRuntimeTargetControl {
                 identityPublicKey: offer.identityPublicKey,
                 credentialRef: pending.credentialRef,
                 directEndpoint: offer.directEndpoint,
+            }, {
+                replaceExisting: replacedTarget !== undefined,
             });
         }
         catch (error) {
+            await invalidation?.catch(() => undefined);
             throw persistenceError("failed to persist the paired Runtime target", error);
         }
+        if (replacedTarget) {
+            await this.cleanupReplacedTarget(replacedTarget, invalidation);
+        }
         return { target: targetView(target), status };
     }
+    async cleanupReplacedTarget(replacedTarget, invalidation) {
+        const failures = [];
+        try {
+            await invalidation;
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        try {
+            await this.credentials.remove(replacedTarget.credentialRef);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+        if (failures.length > 0) {
+            console.warn(JSON.stringify({
+                level: "warn",
+                type: "remote-runtime-reauthorization-cleanup",
+                daemonId: replacedTarget.daemonId,
+                errors: failures.map((error) => error instanceof Error ? error.message : String(error)),
+            }));
+        }
+    }
     async probe(credential) {
         let connection;
         try {
@@ -408,6 +457,12 @@ function normalizeClientError(error) {
     }
     return controlError("unreachable", "remote Runtime connection failed", error);
 }
+function normalizePairingClientError(error) {
+    if (error instanceof DirectRuntimeClientError && error.code === "authentication_failed") {
+        return controlError("offer_rejected", "the remote Host rejected this pairing offer; it may already have been used, expired, or revoked", error);
+    }
+    return normalizeClientError(error);
+}
 function normalizeConnectionManagerError(error) {
     const code = error.code === "closed" || error.code === "cancelled" ? "unreachable" : error.code;
     return controlError(code, error.message, error);

package/dist/remote-runtime-target-store.d.ts

@@ -34,6 +34,9 @@ export interface AddRemoteRuntimePendingEnrollmentInput {
     offerFingerprint: string;
     expiresAt: string;
 }
+export interface CommitRemoteRuntimePendingEnrollmentOptions {
+    replaceExisting?: boolean;
+}
 export declare class RemoteRuntimeTargetStore {
     private readonly connection;
     private readonly clock;
@@ -43,7 +46,7 @@ export declare class RemoteRuntimeTargetStore {
     getPendingEnrollment(claimIdInput: string): RemoteRuntimePendingEnrollment | undefined;
     getPendingEnrollmentForDaemon(daemonIdInput: string): RemoteRuntimePendingEnrollment | undefined;
     removePendingEnrollment(claimIdInput: string): RemoteRuntimePendingEnrollment | undefined;
-    commitPendingEnrollment(claimIdInput: string, input: AddRemoteRuntimeTargetInput): RemoteRuntimeTarget;
+    commitPendingEnrollment(claimIdInput: string, input: AddRemoteRuntimeTargetInput, options?: CommitRemoteRuntimePendingEnrollmentOptions): RemoteRuntimeTarget;
     get(daemonIdInput: string): RemoteRuntimeTarget | undefined;
     list(): RemoteRuntimeTarget[];
     remove(daemonIdInput: string): RemoteRuntimeTarget | undefined;

package/dist/remote-runtime-target-store.js

@@ -78,7 +78,7 @@ export class RemoteRuntimeTargetStore {
         });
         return remove.immediate();
     }
-    commitPendingEnrollment(claimIdInput, input) {
+    commitPendingEnrollment(claimIdInput, input, options = {}) {
         const claimId = validId(claimIdInput, "claimId");
         const normalized = normalizeTargetInput(input);
         const now = validNow(this.clock()).toISOString();
@@ -91,7 +91,12 @@ export class RemoteRuntimeTargetStore {
                 pending.credentialRef !== normalized.credentialRef) {
                 throw new Error("pending Runtime enrollment does not match the accepted credential");
             }
-            insertTarget(this.connection, normalized, now);
+            if (options.replaceExisting) {
+                replaceTarget(this.connection, normalized, now);
+            }
+            else {
+                insertTarget(this.connection, normalized, now);
+            }
             const deleted = this.connection.prepare("DELETE FROM runtime_pending_enrollments WHERE claim_id = ?").run(claimId);
             if (deleted.changes !== 1) {
                 throw new Error("pending Runtime enrollment changed concurrently");
@@ -193,6 +198,20 @@ function insertTarget(connection, input, now) {
        (daemon_id, endpoint, updated_at)
      VALUES (?, ?, ?)`).run(input.daemonId, input.directEndpoint, now);
 }
+function replaceTarget(connection, input, now) {
+    const updatedTarget = connection.prepare(`UPDATE runtime_targets
+     SET display_name = ?, credential_ref = ?, updated_at = ?
+     WHERE daemon_id = ? AND identity_public_key = ?`).run(input.displayName, input.credentialRef, now, input.daemonId, input.identityPublicKey);
+    if (updatedTarget.changes !== 1) {
+        throw new RemoteRuntimeTargetConflictError("the Runtime target to reauthorize is missing or has a different pinned identity");
+    }
+    const updatedRoute = connection.prepare(`UPDATE runtime_direct_routes
+     SET endpoint = ?, updated_at = ?
+     WHERE daemon_id = ?`).run(input.directEndpoint, now, input.daemonId);
+    if (updatedRoute.changes !== 1) {
+        throw new Error("the Runtime target route to reauthorize is missing");
+    }
+}
 function targetFromRow(row) {
     const input = normalizeTargetInput({
         daemonId: row.daemon_id,

package/dist/session-log-store.js

@@ -37,6 +37,35 @@ export class SqliteSessionLogStore {
                     created_by: stored.createdBy ?? null,
                     created_at: stored.createdAt,
                 });
+                if (stored.type === "message" && stored.data.role === "user") {
+                    const resourceIds = stored.data.content.flatMap((part) => part.type === "input_image" ? [part.resourceId] : []);
+                    const operationIds = new Set();
+                    for (const resourceId of resourceIds) {
+                        const resource = conn.prepare(`SELECT state, message_item_id
+                 FROM session_resources
+                WHERE id = ? AND session_id = ?`).get(resourceId, sessionId);
+                        if (!resource ||
+                            resource.state === "uploading" ||
+                            (resource.message_item_id && resource.message_item_id !== stored.id)) {
+                            throw new Error(`Session image resource ${resourceId} is not committable`);
+                        }
+                        conn.prepare(`UPDATE session_resources
+                  SET state = 'committed', message_item_id = ?,
+                      committed_at = COALESCE(committed_at, ?)
+                WHERE id = ? AND session_id = ?`).run(stored.id, stored.createdAt, resourceId, sessionId);
+                        const operation = conn.prepare(`SELECT client_message_id
+                 FROM session_message_operation_resources
+                WHERE session_id = ? AND resource_id = ?`).get(sessionId, resourceId);
+                        if (operation)
+                            operationIds.add(operation.client_message_id);
+                    }
+                    for (const clientMessageId of operationIds) {
+                        conn.prepare(`UPDATE session_message_operations
+                  SET state = 'mirrored', error = NULL, updated_at = ?
+                WHERE session_id = ? AND client_message_id = ?
+                  AND state IN ('injecting', 'injected', 'outcome_unknown')`).run(stored.createdAt, sessionId, clientMessageId);
+                    }
+                }
                 return stored;
             });
         });

package/dist/session-meta-store.js

@@ -94,7 +94,9 @@ export const sessionRegistry = {
 function rowToMeta(row) {
     return {
         id: row.id,
-        provider: row.provider === "codex" || row.provider === "claude" ? row.provider : undefined,
+        provider: row.provider === "codex" || row.provider === "traex" || row.provider === "claude"
+            ? row.provider
+            : undefined,
         agent: row.agent ?? undefined,
         config: row.config ? JSON.parse(row.config) : undefined,
         model: row.model ?? undefined,

package/dist/session-pending-message-store.d.ts

@@ -0,0 +1,2 @@
+import type { MachineSessionPendingMessagePort } from "@rynx-ai/server";
+export declare const sessionPendingMessageStore: MachineSessionPendingMessagePort;

package/dist/session-pending-message-store.js

@@ -0,0 +1,41 @@
+import { db } from "./db.js";
+export const sessionPendingMessageStore = {
+    put(message) {
+        const result = db()
+            .prepare(`INSERT OR IGNORE INTO session_pending_messages
+           (session_id, message, state, created_at)
+         VALUES (?, ?, 'queued', ?)`)
+            .run(message.sessionId, message.message, message.createdAt);
+        return result.changes === 1;
+    },
+    get(sessionId) {
+        const row = db()
+            .prepare(`SELECT session_id, message, state, created_at
+         FROM session_pending_messages WHERE session_id = ?`)
+            .get(sessionId);
+        return row ? fromRow(row) : undefined;
+    },
+    list() {
+        return db()
+            .prepare(`SELECT session_id, message, state, created_at
+         FROM session_pending_messages ORDER BY created_at`)
+            .all().map(fromRow);
+    },
+    markOutcomeUnknown(sessionId) {
+        db()
+            .prepare(`UPDATE session_pending_messages SET state = 'outcome_unknown'
+         WHERE session_id = ? AND state = 'queued'`)
+            .run(sessionId);
+    },
+    delete(sessionId) {
+        db().prepare("DELETE FROM session_pending_messages WHERE session_id = ?").run(sessionId);
+    },
+};
+function fromRow(row) {
+    return {
+        sessionId: row.session_id,
+        message: row.message,
+        state: row.state,
+        createdAt: row.created_at,
+    };
+}

package/dist/session-resource-store.d.ts

@@ -0,0 +1,32 @@
+import { type UserContentPart } from "@rynx-ai/core";
+import { type RemoteRuntimeSessionResourceDeleteParams, type RemoteRuntimeSessionResourceDeleteResult, type RemoteRuntimeSessionResourceGetParams, type RemoteRuntimeSessionResourceGetResult, type RemoteRuntimeSessionResourcePolicyResult, type RemoteRuntimeSessionResourceReadParams, type RemoteRuntimeSessionResourceReadResult, type RemoteRuntimeSessionResourceUploadBeginParams, type RemoteRuntimeSessionResourceUploadBeginResult, type RemoteRuntimeSessionResourceUploadChunkParams, type RemoteRuntimeSessionResourceUploadChunkResult, type RemoteRuntimeSessionResourceUploadCommitParams, type RemoteRuntimeSessionResourceUploadCommitResult } from "@rynx-ai/protocol/remote-runtime-rpc";
+import { type MachineSessionPreparedInput, type MachineSessionResourcePort } from "@rynx-ai/server";
+export declare class SqliteSessionResourceStore implements MachineSessionResourcePort {
+    private readonly root;
+    constructor(root?: string);
+    policy(_sessionId: string): RemoteRuntimeSessionResourcePolicyResult;
+    beginUpload(input: RemoteRuntimeSessionResourceUploadBeginParams): Promise<RemoteRuntimeSessionResourceUploadBeginResult>;
+    writeUploadChunk(input: RemoteRuntimeSessionResourceUploadChunkParams): Promise<RemoteRuntimeSessionResourceUploadChunkResult>;
+    commitUpload(input: RemoteRuntimeSessionResourceUploadCommitParams): Promise<RemoteRuntimeSessionResourceUploadCommitResult>;
+    getResource(input: RemoteRuntimeSessionResourceGetParams): Promise<RemoteRuntimeSessionResourceGetResult>;
+    readResource(input: RemoteRuntimeSessionResourceReadParams): Promise<RemoteRuntimeSessionResourceReadResult>;
+    deleteResource(input: RemoteRuntimeSessionResourceDeleteParams): Promise<RemoteRuntimeSessionResourceDeleteResult>;
+    prepareInput(sessionId: string, content: UserContentPart[], clientMessageId?: string): Promise<MachineSessionPreparedInput>;
+    markMessageInjecting(sessionId: string, clientMessageId: string): void;
+    markMessageInjected(sessionId: string, clientMessageId: string): void;
+    markMessageOutcomeUnknown(sessionId: string, clientMessageId: string, reason: string): void;
+    markMessageFailedNotStarted(sessionId: string, clientMessageId: string, reason: string): void;
+    deleteSession(sessionId: string): void;
+    private prepareMessageOperation;
+    private bindOperationResources;
+    private transitionOperation;
+    private finalizeUpload;
+    private reconcileUploadOffset;
+    private rowByUpload;
+    private requireUpload;
+    private requireResource;
+    private sessionDirectory;
+    private partialPath;
+    private finalPath;
+    private sweepExpiredStagedResources;
+}