@cydm/happy-elves 0.1.0-beta.39 → 0.1.0-beta.40

package/apps/daemon/dist/runtime/external-provider.js

@@ -176,7 +176,13 @@ export function createExternalAgentRuntimeProvider(options) {
         }));
     }
     function clientForAgent(agent) {
-        return clientsByAgent.get(agent);
+        const client = clientsByAgent.get(agent);
+        if (!client)
+            return undefined;
+        if (client.isAvailable() && client.listAgents().some((profile) => profile.id === agent))
+            return client;
+        clientsByAgent.delete(agent);
+        return undefined;
     }
     function clientForHandle(handle) {
         return handle.externalProviderId ? clients.find((client) => client.id === handle.externalProviderId) : undefined;
@@ -248,7 +254,7 @@ export function createExternalAgentRuntimeProvider(options) {
                     id: "fallback",
                     load: (cursor, pageLimit) => filterHistoricalSessionPage(fallbackHistoricalSessionPage({ ...input, cursor, limit: pageLimit }), input.cwdMode),
                 },
-                ...clients.map((client) => ({
+                ...clients.filter((client) => client.isAvailable()).map((client) => ({
                     id: `external:${client.id}`,
                     load: (cursor, pageLimit) => filterHistoricalSessionPage(client.request("listHistoricalSessions", { ...input, cursor, limit: pageLimit }).catch(emptyPageUnlessCursorStale), input.cwdMode),
                 })),
@@ -470,6 +476,9 @@ class ExternalProviderClient {
     listAgents() {
         return this.agents;
     }
+    isAvailable() {
+        return this.ready && !!this.child && !this.child.killed && !this.exited;
+    }
     diagnostics() {
         const processAvailable = !!this.child && !this.child.killed && !this.exited;
         return {
@@ -648,6 +657,7 @@ class ExternalProviderClient {
         this.ready = false;
         this.exited = true;
         this.lastError = error.message;
+        this.agents = [];
         for (const [id, pending] of this.pending) {
             clearTimeout(pending.timer);
             pending.reject(error);

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.39",
+  "version": "0.1.0-beta.40",
   "private": true,
   "type": "module"
 }

package/apps/relay/dist/db.js

@@ -116,6 +116,26 @@ export function initDb(db) {
       FOREIGN KEY (machine_id) REFERENCES machines(id) ON DELETE CASCADE
     );
 
+    CREATE TABLE IF NOT EXISTS pending_session_head_advances (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      account_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      machine_id TEXT NOT NULL,
+      message_id TEXT,
+      current_head TEXT NOT NULL,
+      last_turn_id TEXT NOT NULL,
+      basis_turn_id TEXT NOT NULL,
+      basis_event_message_id TEXT NOT NULL,
+      basis_turn_seq INTEGER NOT NULL,
+      basis_occurred_at INTEGER,
+      encrypted_metadata TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (account_id) REFERENCES accounts(id) ON DELETE CASCADE,
+      FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE,
+      FOREIGN KEY (machine_id) REFERENCES machines(id) ON DELETE CASCADE
+    );
+
     CREATE TABLE IF NOT EXISTS command_results (
       account_id TEXT NOT NULL,
       request_id TEXT NOT NULL,
@@ -131,6 +151,8 @@ export function initDb(db) {
     CREATE INDEX IF NOT EXISTS idx_events_session ON session_events(session_id, id);
     CREATE INDEX IF NOT EXISTS idx_turn_aliases_runtime
       ON session_turn_aliases(account_id, session_id, runtime_turn_id);
+    CREATE INDEX IF NOT EXISTS idx_pending_head_session
+      ON pending_session_head_advances(account_id, session_id, machine_id);
     CREATE INDEX IF NOT EXISTS idx_command_results_created ON command_results(created_at);
     CREATE INDEX IF NOT EXISTS idx_controller_invites_account ON controller_invites(account_id, created_at DESC);
   `);
@@ -157,6 +179,9 @@ export function initDb(db) {
     CREATE UNIQUE INDEX IF NOT EXISTS idx_events_machine_message
       ON session_events(account_id, machine_id, message_id)
       WHERE message_id IS NOT NULL;
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_pending_head_machine_message
+      ON pending_session_head_advances(account_id, machine_id, message_id)
+      WHERE message_id IS NOT NULL;
   `);
     repairHistoricalEventTimestamps(db);
 }

package/apps/relay/dist/machine-handlers.js

@@ -142,6 +142,7 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
+        clearPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId);
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
@@ -272,6 +273,7 @@ export function handleMachineMessage(context, connection, message) {
          WHERE account_id = ? AND session_id = ? AND machine_id = ?`).run(connection.accountId, message.sessionId, connection.machineId);
             db.prepare(`DELETE FROM session_turn_aliases
          WHERE account_id = ? AND session_id = ? AND machine_id = ?`).run(connection.accountId, message.sessionId, connection.machineId);
+            clearPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId);
             for (const event of message.events) {
                 const result = db
                     .prepare(`INSERT INTO session_events
@@ -323,7 +325,10 @@ export function handleMachineMessage(context, connection, message) {
             db.exec("ROLLBACK");
             throw error;
         }
-        const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        const pendingSessionRow = inserted.length > 0
+            ? applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now())
+            : undefined;
+        const row = pendingSessionRow ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row) {
             const session = sessionSnapshot(row);
             broadcastControllers(connection.accountId, {
@@ -387,7 +392,8 @@ export function handleMachineMessage(context, connection, message) {
             db.exec("ROLLBACK");
             throw error;
         }
-        const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        const pendingSessionRow = applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now());
+        const row = pendingSessionRow ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row) {
             const session = sessionSnapshot(row);
             broadcastControllers(connection.accountId, {
@@ -403,10 +409,19 @@ export function handleMachineMessage(context, connection, message) {
         return;
     }
     if (message.type === "machine:sessionHeadAdvanced") {
-        const sessionRow = db
-            .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
-            .get(message.sessionId, connection.accountId, connection.machineId);
-        if (!sessionRow) {
+        const ts = now();
+        const input = {
+            accountId: connection.accountId,
+            sessionId: message.sessionId,
+            machineId: connection.machineId,
+            messageId,
+            currentHead: message.currentHead,
+            lastTurnId: message.lastTurnId,
+            basis: message.basis,
+            ...(message.encryptedMetadata ? { encryptedMetadata: message.encryptedMetadata } : {}),
+        };
+        const result = applySessionHeadAdvance(db, input, ts);
+        if (result.status === "session-not-found") {
             broadcastError(connection.accountId, {
                 type: "server:error",
                 code: "SESSION_NOT_FOUND",
@@ -415,16 +430,17 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
-        const basisEvent = resolveHeadAdvanceBasisEvent(db, connection.accountId, message.sessionId, connection.machineId, message.basis);
-        if (!basisEvent) {
+        if (result.status === "missing") {
+            storePendingSessionHeadAdvance(db, input, ts);
             broadcastError(connection.accountId, {
                 type: "server:error",
                 code: "SESSION_HEAD_BASIS_MISSING",
-                message: "Head advance basis event is not available yet",
+                message: "Head advance basis event is not available yet; update will be applied when the event arrives",
             });
+            acknowledgeMachineMessage();
             return;
         }
-        if (basisEvent.turn_id !== message.basis.turnId || basisEvent.turn_seq !== message.basis.turnSeq) {
+        if (result.status === "mismatch") {
             broadcastError(connection.accountId, {
                 type: "server:error",
                 code: "SESSION_HEAD_BASIS_MISMATCH",
@@ -433,25 +449,7 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
-        const nextOrder = logicalEventOrder(basisEvent);
-        const currentOrder = sessionHeadBasisOrder(db, sessionRow);
-        const rewriteFenced = typeof sessionRow.head_basis_message_id === "string" &&
-            sessionRow.head_basis_message_id.startsWith(REWRITE_HEAD_BASIS_PREFIX);
-        const shouldAdvance = !rewriteFenced && compareHeadBasisOrder(nextOrder, currentOrder) > 0;
-        const ts = now();
-        if (shouldAdvance) {
-            db.prepare(`UPDATE sessions
-         SET current_head = ?,
-             last_turn_id = ?,
-             head_basis_event_id = ?,
-             head_basis_message_id = ?,
-             head_basis_logical_time = ?,
-             head_basis_turn_seq = ?,
-             encrypted_metadata = COALESCE(?, encrypted_metadata),
-             updated_at = ?
-         WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.currentHead, message.lastTurnId, basisEvent.id, basisEvent.message_id, nextOrder.time, nextOrder.seq, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
-        }
-        const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        const row = result.session ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
         acknowledgeMachineMessage();
@@ -483,7 +481,10 @@ export function handleMachineMessage(context, connection, message) {
             occurredAt: message.occurredAt,
             payload: message.payload,
         });
+        const pendingSessionRow = applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now());
         broadcastControllers(connection.accountId, { type: "server:event", event });
+        if (pendingSessionRow)
+            broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(pendingSessionRow) });
         acknowledgeMachineMessage();
         return;
     }
@@ -582,6 +583,94 @@ export function handleMachineMessage(context, connection, message) {
 function machineMessageId(message) {
     return "messageId" in message && typeof message.messageId === "string" ? message.messageId : undefined;
 }
+function storePendingSessionHeadAdvance(db, input, ts) {
+    db.prepare(`INSERT INTO pending_session_head_advances
+     (account_id, session_id, machine_id, message_id, current_head, last_turn_id,
+      basis_turn_id, basis_event_message_id, basis_turn_seq, basis_occurred_at,
+      encrypted_metadata, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(account_id, machine_id, message_id) WHERE message_id IS NOT NULL
+     DO UPDATE SET
+       current_head = excluded.current_head,
+       last_turn_id = excluded.last_turn_id,
+       basis_turn_id = excluded.basis_turn_id,
+       basis_event_message_id = excluded.basis_event_message_id,
+       basis_turn_seq = excluded.basis_turn_seq,
+       basis_occurred_at = excluded.basis_occurred_at,
+       encrypted_metadata = excluded.encrypted_metadata,
+       updated_at = excluded.updated_at`).run(input.accountId, input.sessionId, input.machineId, input.messageId ?? null, input.currentHead, input.lastTurnId, input.basis.turnId, input.basis.eventMessageId, input.basis.turnSeq, input.basis.occurredAt ?? null, input.encryptedMetadata ? JSON.stringify(input.encryptedMetadata) : null, ts, ts);
+}
+function clearPendingSessionHeadAdvances(db, accountId, sessionId, machineId) {
+    db.prepare(`DELETE FROM pending_session_head_advances
+     WHERE account_id = ? AND session_id = ? AND machine_id = ?`).run(accountId, sessionId, machineId);
+}
+function applyPendingSessionHeadAdvances(db, accountId, sessionId, machineId, ts) {
+    const pending = db
+        .prepare(`SELECT * FROM pending_session_head_advances
+       WHERE account_id = ? AND session_id = ? AND machine_id = ?
+       ORDER BY created_at, id`)
+        .all(accountId, sessionId, machineId);
+    let latestSession;
+    for (const row of pending) {
+        const result = applySessionHeadAdvance(db, pendingRowToHeadAdvanceInput(row), ts);
+        if (result.status === "missing")
+            continue;
+        db.prepare("DELETE FROM pending_session_head_advances WHERE id = ?").run(row.id);
+        latestSession = result.session ?? latestSession;
+    }
+    return latestSession;
+}
+function pendingRowToHeadAdvanceInput(row) {
+    return {
+        accountId: row.account_id,
+        sessionId: row.session_id,
+        machineId: row.machine_id,
+        messageId: row.message_id ?? undefined,
+        currentHead: row.current_head,
+        lastTurnId: row.last_turn_id,
+        basis: {
+            turnId: row.basis_turn_id,
+            eventMessageId: row.basis_event_message_id,
+            turnSeq: row.basis_turn_seq,
+            ...(row.basis_occurred_at !== null ? { occurredAt: row.basis_occurred_at } : {}),
+        },
+        ...(row.encrypted_metadata ? { encryptedMetadata: JSON.parse(row.encrypted_metadata) } : {}),
+    };
+}
+function applySessionHeadAdvance(db, input, ts) {
+    const sessionRow = db
+        .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+        .get(input.sessionId, input.accountId, input.machineId);
+    if (!sessionRow)
+        return { status: "session-not-found" };
+    const basisEvent = resolveHeadAdvanceBasisEvent(db, input.accountId, input.sessionId, input.machineId, input.basis);
+    if (!basisEvent)
+        return { status: "missing", session: sessionRow };
+    if (basisEvent.turn_id !== input.basis.turnId || basisEvent.turn_seq !== input.basis.turnSeq) {
+        return { status: "mismatch", session: sessionRow };
+    }
+    const nextOrder = logicalEventOrder(basisEvent);
+    const currentOrder = sessionHeadBasisOrder(db, sessionRow);
+    const rewriteFenced = typeof sessionRow.head_basis_message_id === "string" &&
+        sessionRow.head_basis_message_id.startsWith(REWRITE_HEAD_BASIS_PREFIX);
+    const comparison = compareHeadBasisOrder(nextOrder, currentOrder);
+    const currentHeadIsBasisEvent = sessionRow.current_head === `event:${basisEvent.id}`;
+    const shouldAdvance = !rewriteFenced && (comparison > 0 || (comparison === 0 && currentHeadIsBasisEvent));
+    if (!shouldAdvance)
+        return { status: "noop", session: sessionRow };
+    db.prepare(`UPDATE sessions
+     SET current_head = ?,
+         last_turn_id = ?,
+         head_basis_event_id = ?,
+         head_basis_message_id = ?,
+         head_basis_logical_time = ?,
+         head_basis_turn_seq = ?,
+         encrypted_metadata = COALESCE(?, encrypted_metadata),
+         updated_at = ?
+     WHERE id = ? AND account_id = ? AND machine_id = ?`).run(input.currentHead, input.lastTurnId, basisEvent.id, basisEvent.message_id, nextOrder.time, nextOrder.seq, input.encryptedMetadata ? JSON.stringify(input.encryptedMetadata) : null, ts, input.sessionId, input.accountId, input.machineId);
+    const session = db.prepare("SELECT * FROM sessions WHERE id = ?").get(input.sessionId);
+    return { status: "applied", session };
+}
 function compareHeadBasisOrder(nextOrder, currentOrder) {
     if (!currentOrder)
         return 1;

package/apps/relay/dist/types.d.ts

@@ -63,6 +63,22 @@ export type EventRow = {
     created_at: number;
     occurred_at: number | null;
 };
+export type PendingSessionHeadAdvanceRow = {
+    id: number;
+    account_id: string;
+    session_id: string;
+    machine_id: string;
+    message_id: string | null;
+    current_head: string;
+    last_turn_id: string;
+    basis_turn_id: string;
+    basis_event_message_id: string;
+    basis_turn_seq: number;
+    basis_occurred_at: number | null;
+    encrypted_metadata: string | null;
+    created_at: number;
+    updated_at: number;
+};
 export type CommandResultRow = {
     account_id: string;
     request_id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.39",
+  "version": "0.1.0-beta.40",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {