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

package/dist/session-launch-operations.js

@@ -0,0 +1,124 @@
+import { newSessionId } from "@rynx-ai/core";
+import { db } from "./db.js";
+import { createSessionMeta } from "./session-meta-store.js";
+const MAX_ID_LENGTH = 512;
+const SHA256_PATTERN = /^[a-fA-F0-9]{64}$/;
+export class SessionLaunchOperationConflictError extends Error {
+    pluginId;
+    scopeId;
+    operationId;
+    code = "SESSION_LAUNCH_OPERATION_CONFLICT";
+    constructor(pluginId, scopeId, operationId) {
+        super(`session launch operation was reused with a different request: ${pluginId}/${scopeId}/${operationId}`);
+        this.pluginId = pluginId;
+        this.scopeId = scopeId;
+        this.operationId = operationId;
+        this.name = "SessionLaunchOperationConflictError";
+    }
+}
+export class SessionLaunchOperationTargetDeletedError extends Error {
+    pluginId;
+    scopeId;
+    operationId;
+    sessionId;
+    code = "SESSION_LAUNCH_OPERATION_TARGET_DELETED";
+    constructor(pluginId, scopeId, operationId, sessionId) {
+        super(`session launch operation target was deleted: ${pluginId}/${scopeId}/${operationId}`);
+        this.pluginId = pluginId;
+        this.scopeId = scopeId;
+        this.operationId = operationId;
+        this.sessionId = sessionId;
+        this.name = "SessionLaunchOperationTargetDeletedError";
+    }
+}
+/**
+ * Atomically allocate a persisted machine session for one plugin operation.
+ *
+ * The durable operation row is the idempotency boundary across runner crashes,
+ * daemon restarts, and remote lease re-delivery. It deliberately excludes any
+ * Workspace concept: `scopeId` and `operationId` are opaque to the daemon.
+ */
+export function ensurePluginSessionLaunch(input) {
+    const pluginId = requiredId(input.pluginId, "pluginId");
+    const scopeId = requiredId(input.scopeId, "scopeId");
+    const operationId = requiredId(input.operationId, "operationId");
+    const requestHash = requiredRequestHash(input.requestHash);
+    const ensure = db().transaction(() => {
+        const existing = readOperation(pluginId, scopeId, operationId);
+        if (existing) {
+            if (existing.request_hash !== requestHash) {
+                throw new SessionLaunchOperationConflictError(pluginId, scopeId, operationId);
+            }
+            if (existing.state === "deleted") {
+                return { disposition: "deleted", sessionId: existing.session_id };
+            }
+            if (!sessionExists(existing.session_id)) {
+                // Preserve the operation key even when an older deletion path removed
+                // the session without first marking its launch operation. Throwing from
+                // inside this transaction would roll the repair back, so return a
+                // sentinel and raise the typed error after the commit.
+                tombstoneOperations(existing.session_id, new Date().toISOString());
+                return { disposition: "deleted", sessionId: existing.session_id };
+            }
+            return { disposition: "replayed", sessionId: existing.session_id };
+        }
+        const now = new Date().toISOString();
+        let sessionId = newSessionId();
+        while (sessionExists(sessionId))
+            sessionId = newSessionId();
+        createSessionMeta({
+            ...input.session,
+            id: sessionId,
+            source: `plugin:${pluginId}`,
+            createdAt: now,
+            updatedAt: now,
+        });
+        if (!sessionExists(sessionId)) {
+            throw new Error(`plugin session launch failed to persist session metadata: ${sessionId}`);
+        }
+        db()
+            .prepare(`INSERT INTO plugin_session_launch_operations
+           (plugin_id, scope_id, operation_id, request_hash, session_id, state,
+            created_at, updated_at, deleted_at)
+         VALUES (?, ?, ?, ?, ?, 'active', ?, ?, NULL)`)
+            .run(pluginId, scopeId, operationId, requestHash, sessionId, now, now);
+        return { disposition: "created", sessionId };
+    });
+    const result = ensure.immediate();
+    if (result.disposition === "deleted") {
+        throw new SessionLaunchOperationTargetDeletedError(pluginId, scopeId, operationId, result.sessionId);
+    }
+    return result;
+}
+function readOperation(pluginId, scopeId, operationId) {
+    return db()
+        .prepare(`SELECT request_hash, session_id, state
+       FROM plugin_session_launch_operations
+       WHERE plugin_id = ? AND scope_id = ? AND operation_id = ?`)
+        .get(pluginId, scopeId, operationId);
+}
+function sessionExists(sessionId) {
+    return Boolean(db().prepare("SELECT 1 FROM sessions WHERE id = ?").pluck().get(sessionId));
+}
+function tombstoneOperations(sessionId, now) {
+    return db()
+        .prepare(`UPDATE plugin_session_launch_operations
+       SET state = 'deleted', updated_at = ?, deleted_at = ?
+       WHERE session_id = ? AND state = 'active'`)
+        .run(now, now, sessionId).changes;
+}
+function requiredId(value, label) {
+    const normalized = value?.trim();
+    if (!normalized)
+        throw new Error(`${label} is required`);
+    if (normalized.length > MAX_ID_LENGTH)
+        throw new Error(`${label} is too long`);
+    return normalized;
+}
+function requiredRequestHash(value) {
+    const normalized = value?.trim();
+    if (!SHA256_PATTERN.test(normalized)) {
+        throw new Error("requestHash must be a SHA-256 hex digest");
+    }
+    return normalized.toLowerCase();
+}

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.d.ts

@@ -1,7 +1,7 @@
 /**
  * The unified machine-session record (SQLite) — one row per session regardless
  * of origin (the web console AND every channel). Holds identity/meta (source /
- * agent / inline config / model / title / …) so the **session list survives a
+ * provider / agent / inline config / model / title / …) so the **session list survives a
  * daemon restart**; the transcript lives in `session_items` (see
  * {@link import("./session-log-store.js")}). Runtime `status` is intentionally
  * not stored — it is reconstructed as `idle` after a restart.
@@ -11,12 +11,13 @@
  * via the `ChannelContext`, so a channel registers its sessions the same way the
  * console does.
  */
-import type { MachineSessionRecord, SessionRegistry } from "@rynx-ai/core";
+import { type MachineSessionRecord, type SessionRegistry } from "@rynx-ai/core";
 /** Back-compat alias for the unified record. */
 export type StoredSessionMeta = MachineSessionRecord;
 export declare function listSessionMetas(): StoredSessionMeta[];
 export declare function getSessionMeta(id: string): StoredSessionMeta | undefined;
 export declare function createSessionMeta(meta: StoredSessionMeta): void;
+export declare function updateSessionMeta(meta: StoredSessionMeta): void;
 export declare function setSessionTitle(id: string, title: string): void;
 export declare function removeSessionMeta(id: string): void;
 /** {@link SessionRegistry} over the same `sessions` table — the form channels

package/dist/session-meta-store.js

@@ -1,5 +1,19 @@
+/**
+ * The unified machine-session record (SQLite) — one row per session regardless
+ * of origin (the web console AND every channel). Holds identity/meta (source /
+ * provider / agent / inline config / model / title / …) so the **session list survives a
+ * daemon restart**; the transcript lives in `session_items` (see
+ * {@link import("./session-log-store.js")}). Runtime `status` is intentionally
+ * not stored — it is reconstructed as `idle` after a restart.
+ *
+ * Exposes both the standalone functions the control-plane deps wire in and a
+ * {@link SessionRegistry} adapter ({@link sessionRegistry}) injected into channels
+ * via the `ChannelContext`, so a channel registers its sessions the same way the
+ * console does.
+ */
+import { normalizeSessionTitle, } from "@rynx-ai/core";
 import { db } from "./db.js";
-const COLS = "id, agent, config, model, reasoning_effort, title, source, created_at, updated_at";
+const COLS = "id, provider, agent, config, model, reasoning_effort, title, source, created_at, updated_at";
 export function listSessionMetas() {
     return db()
         .prepare(`SELECT ${COLS} FROM sessions ORDER BY created_at`)
@@ -13,27 +27,60 @@ export function getSessionMeta(id) {
 export function createSessionMeta(meta) {
     db()
         .prepare(`INSERT OR IGNORE INTO sessions
-         (id, agent, config, model, reasoning_effort, title, source, created_at, updated_at)
-       VALUES (@id, @agent, @config, @model, @reasoning_effort, @title, @source, @created_at, @updated_at)`)
+         (id, provider, agent, config, model, reasoning_effort, title, source, created_at, updated_at)
+       VALUES (@id, @provider, @agent, @config, @model, @reasoning_effort, @title, @source, @created_at, @updated_at)`)
         .run({
         id: meta.id,
+        provider: meta.provider ?? null,
         agent: meta.agent ?? null,
         config: meta.config ? JSON.stringify(meta.config) : null,
         model: meta.model ?? null,
         reasoning_effort: meta.reasoningEffort ?? null,
-        title: meta.title ?? null,
+        title: normalizeSessionTitle(meta.title) ?? null,
         source: meta.source,
         created_at: meta.createdAt,
         updated_at: meta.updatedAt ?? meta.createdAt,
     });
 }
+export function updateSessionMeta(meta) {
+    db()
+        .prepare(`UPDATE sessions
+       SET provider = @provider,
+           agent = @agent,
+           config = @config,
+           model = @model,
+           reasoning_effort = @reasoning_effort,
+           title = @title,
+           source = @source,
+           updated_at = @updated_at
+       WHERE id = @id`)
+        .run({
+        id: meta.id,
+        provider: meta.provider ?? null,
+        agent: meta.agent ?? null,
+        config: meta.config ? JSON.stringify(meta.config) : null,
+        model: meta.model ?? null,
+        reasoning_effort: meta.reasoningEffort ?? null,
+        title: normalizeSessionTitle(meta.title) ?? null,
+        source: meta.source,
+        updated_at: meta.updatedAt ?? new Date().toISOString(),
+    });
+}
 export function setSessionTitle(id, title) {
     db()
         .prepare("UPDATE sessions SET title = ?, updated_at = ? WHERE id = ?")
-        .run(title, new Date().toISOString(), id);
+        .run(normalizeSessionTitle(title), new Date().toISOString(), id);
 }
 export function removeSessionMeta(id) {
-    db().prepare("DELETE FROM sessions WHERE id = ?").run(id);
+    db().transaction(() => {
+        const now = new Date().toISOString();
+        db()
+            .prepare(`UPDATE plugin_session_launch_operations
+         SET state = 'deleted', updated_at = ?, deleted_at = ?
+         WHERE session_id = ? AND state = 'active'`)
+            .run(now, now, id);
+        db().prepare("DELETE FROM sessions WHERE id = ?").run(id);
+    }).immediate();
 }
 /** {@link SessionRegistry} over the same `sessions` table — the form channels
  *  receive through their `ChannelContext`. */
@@ -47,11 +94,16 @@ export const sessionRegistry = {
 function rowToMeta(row) {
     return {
         id: row.id,
+        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,
         reasoningEffort: (row.reasoning_effort ?? undefined),
-        title: row.title ?? undefined,
+        // Normalize on read as well so pre-boundary database rows cannot poison an
+        // entire Remote Session list page after upgrading the daemon.
+        title: normalizeSessionTitle(row.title ?? undefined),
         source: row.source ?? "console",
         createdAt: row.created_at,
         updatedAt: row.updated_at ?? row.created_at,

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;
+}