@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

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

@@ -1,11 +1,17 @@
 import { controllerSessionCommandDecision, randomId, } from "../../../packages/shared/dist/index.js";
+import { findSessionRuntimeBinding, upsertSessionRuntimeBindings } from "./runtime-bindings.js";
 const legacyMachineAgents = [
     { id: "codex", label: "Codex" },
     { id: "claude", label: "Claude Code" },
 ];
 export function handleControllerMessage(context, connection, message) {
-    const { allowControllerAction, allowControllerMachine, allowControllerSession, broadcastControllers, connectedMachine, db, insertEvent, isCommandPending, machineCapabilities, markCommandPending, now, parseJson, previousCommandResponse, send, sendAck, sendError, sendMachineOffline, sessionSnapshot, setSessionStatus, } = context;
+    const { allowControllerAction, allowControllerMachine, allowControllerSession, activeSessionClaim, broadcastControllers, claimSessionTurn, connectedMachine, db, deliverOutboxCommand, finishSessionClaim, insertEvent, isCommandPending, isSessionCommandPending, machineCapabilities, markCommandPending, now, parseJson, previousAdmissionAck, previousCommandResponse, send, sendAck, sendError, sendMachineOffline, sessionSnapshot, setSessionStatus, } = context;
     if ("requestId" in message && typeof message.requestId === "string") {
+        const admission = previousAdmissionAck(connection.accountId, message.requestId);
+        if (admission) {
+            send(connection.socket, admission);
+            return;
+        }
         const previous = previousCommandResponse(connection.accountId, message.requestId);
         if (previous) {
             send(connection.socket, previous);
@@ -19,6 +25,12 @@ export function handleControllerMessage(context, connection, message) {
         const decision = controllerSessionCommandDecision(sessionRow.status, command);
         if (decision.allowed)
             return false;
+        if (decision.code === "SESSION_BUSY" &&
+            command === "prompt" &&
+            !activeSessionClaim(connection.accountId, sessionRow.id) &&
+            !sessionLooksTranscriptPending(db, sessionRow)) {
+            return false;
+        }
         sendError(connection, {
             type: "server:error",
             requestId,
@@ -27,6 +39,38 @@ export function handleControllerMessage(context, connection, message) {
         });
         return true;
     };
+    const rejectPendingSessionCommand = (sessionRow, requestId, command) => {
+        if (command === "cancel" || command === "close")
+            return false;
+        if (sessionRow.status === "closed")
+            return false;
+        const durableClaim = activeSessionClaim(connection.accountId, sessionRow.id);
+        const pending = isSessionCommandPending(connection.accountId, sessionRow.id);
+        if (!durableClaim && !pending)
+            return false;
+        sendError(connection, {
+            type: "server:error",
+            requestId,
+            code: "SESSION_BUSY",
+            message: "Session already has a pending operation",
+            sessionId: sessionRow.id,
+            ...(durableClaim ? { activeRequestId: durableClaim.request_id, activeTurnId: durableClaim.turn_id } : {}),
+        });
+        return true;
+    };
+    const rejectUnsupportedSessionPrimitive = (sessionRow, requestId, command) => {
+        const capability = sessionSnapshot(sessionRow).capabilities?.[command] ?? "unsupported";
+        if (capability !== "unsupported")
+            return false;
+        sendError(connection, {
+            type: "server:error",
+            requestId,
+            code: "CAPABILITY_UNAVAILABLE",
+            capability: `session.${command}`,
+            message: `session.${command} is not supported by this target`,
+        });
+        return true;
+    };
     const rejectUnsupportedAgent = (machineId, agentId, requestId) => {
         const capabilities = machineCapabilities(connection.accountId, machineId);
         const advertisedAgents = capabilities?.agents.length ? capabilities.agents : legacyMachineAgents;
@@ -60,27 +104,45 @@ export function handleControllerMessage(context, connection, message) {
         }
         if (rejectUnsupportedAgent(message.machineId, message.agent, message.requestId))
             return;
-        const machineConnection = connectedMachine(connection.accountId, message.machineId);
-        if (!machineConnection) {
-            sendMachineOffline(connection, message.requestId);
-            return;
-        }
         const sessionId = randomId("ses");
         const createdAt = now();
-        db.prepare(`INSERT INTO sessions
-       (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, created_at, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, createdAt, createdAt);
-        const session = sessionSnapshot(db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId));
-        broadcastControllers(connection.accountId, { type: "server:session", session });
-        sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true, sessionId });
-        send(machineConnection.socket, {
+        const machineCommand = {
             type: "machine:createSession",
             requestId: message.requestId,
             sessionId,
             agent: message.agent,
             cwd: message.cwd,
             name: message.name,
+            model: message.model,
             encryptedMetadata: message.encryptedMetadata,
+        };
+        db.exec("BEGIN");
+        try {
+            db.prepare(`INSERT INTO sessions
+         (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, createdAt, createdAt);
+            db.prepare(`INSERT INTO relay_admissions
+         (account_id, request_id, session_id, machine_id, kind, turn_id, admission, dispatch, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(connection.accountId, message.requestId, sessionId, message.machineId, "createSession", null, "accepted", "queued", createdAt, createdAt);
+            db.prepare(`INSERT INTO relay_dispatch_outbox
+         (account_id, request_id, machine_id, session_id, command_type, message, state, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(connection.accountId, message.requestId, message.machineId, sessionId, machineCommand.type, JSON.stringify(machineCommand), "queued", createdAt, createdAt);
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+        const session = sessionSnapshot(db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId));
+        broadcastControllers(connection.accountId, { type: "server:session", session });
+        const dispatch = deliverOutboxCommand(connection.accountId, message.requestId);
+        sendAck(connection, {
+            type: "server:ack",
+            requestId: message.requestId,
+            ok: true,
+            sessionId,
+            admission: "accepted",
+            dispatch,
         });
         return;
     }
@@ -90,28 +152,13 @@ export function handleControllerMessage(context, connection, message) {
         const sessionRow = allowControllerSession(connection, message.sessionId, message.requestId);
         if (!sessionRow)
             return;
-        if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "prompt"))
+        if (rejectPendingSessionCommand(sessionRow, message.requestId, "prompt"))
             return;
-        const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
-        if (!machineConnection) {
-            const session = setSessionStatus(sessionRow.id, "offline");
-            if (session)
-                broadcastControllers(connection.accountId, { type: "server:session", session });
-            sendMachineOffline(connection, message.requestId);
+        if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "prompt"))
             return;
-        }
-        const event = insertEvent({
-            accountId: connection.accountId,
-            sessionId: sessionRow.id,
-            machineId: sessionRow.machine_id,
-            turnId: message.turnId,
-            payload: message.encryptedPrompt,
-        });
-        broadcastControllers(connection.accountId, { type: "server:event", event });
-        const session = setSessionStatus(sessionRow.id, "running");
-        if (session)
-            broadcastControllers(connection.accountId, { type: "server:session", session });
-        send(machineConnection.socket, {
+        let event;
+        const createdAt = now();
+        const machineCommand = {
             type: "machine:prompt",
             requestId: message.requestId,
             sessionId: sessionRow.id,
@@ -119,9 +166,65 @@ export function handleControllerMessage(context, connection, message) {
             encryptedPrompt: message.encryptedPrompt,
             encryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
             permissionMode: message.permissionMode,
+            model: message.model,
+            encryptedMemoryOptions: message.encryptedMemoryOptions,
             timeoutMs: message.timeoutMs,
+        };
+        db.exec("BEGIN");
+        try {
+            const claim = claimSessionTurn({
+                accountId: connection.accountId,
+                sessionId: sessionRow.id,
+                machineId: sessionRow.machine_id,
+                requestId: message.requestId,
+                turnId: message.turnId,
+                commandType: "prompt",
+                createdAt,
+            });
+            if (!claim.ok) {
+                db.exec("ROLLBACK");
+                sendError(connection, {
+                    type: "server:error",
+                    requestId: message.requestId,
+                    code: "SESSION_BUSY",
+                    message: "Session already has a running turn",
+                    sessionId: sessionRow.id,
+                    activeRequestId: claim.claim.request_id,
+                    activeTurnId: claim.claim.turn_id,
+                });
+                return;
+            }
+            event = insertEvent({
+                accountId: connection.accountId,
+                sessionId: sessionRow.id,
+                machineId: sessionRow.machine_id,
+                source: "controller",
+                turnId: message.turnId,
+                payload: message.encryptedPrompt,
+            });
+            db.prepare(`INSERT INTO relay_admissions
+         (account_id, request_id, session_id, machine_id, kind, turn_id, admission, dispatch, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(connection.accountId, message.requestId, sessionRow.id, sessionRow.machine_id, "prompt", message.turnId, "accepted", "queued", createdAt, createdAt);
+            db.prepare(`INSERT INTO relay_dispatch_outbox
+         (account_id, request_id, machine_id, session_id, command_type, message, state, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(connection.accountId, message.requestId, sessionRow.machine_id, sessionRow.id, machineCommand.type, JSON.stringify(machineCommand), "queued", createdAt, createdAt);
+            db.exec("COMMIT");
+        }
+        catch (error) {
+            db.exec("ROLLBACK");
+            throw error;
+        }
+        broadcastControllers(connection.accountId, { type: "server:event", event });
+        const dispatch = deliverOutboxCommand(connection.accountId, message.requestId);
+        sendAck(connection, {
+            type: "server:ack",
+            requestId: message.requestId,
+            ok: true,
+            sessionId: sessionRow.id,
+            turnId: message.turnId,
+            admission: "accepted",
+            dispatch,
         });
-        sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
         return;
     }
     if (message.type === "controller:cancel") {
@@ -147,6 +250,72 @@ export function handleControllerMessage(context, connection, message) {
         sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
         return;
     }
+    if (message.type === "controller:optionResponse") {
+        if (!allowControllerAction(connection, "session.run", message.requestId))
+            return;
+        const sessionRow = allowControllerSession(connection, message.sessionId, message.requestId);
+        if (!sessionRow)
+            return;
+        if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "prompt"))
+            return;
+        const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
+        if (!machineConnection) {
+            sendMachineOffline(connection, message.requestId);
+            return;
+        }
+        send(machineConnection.socket, {
+            type: "machine:optionResponse",
+            requestId: message.requestId,
+            sessionId: message.sessionId,
+            turnId: message.turnId,
+            optionRequestId: message.optionRequestId,
+            selectedOptionId: message.selectedOptionId,
+            text: message.text,
+        });
+        sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
+        return;
+    }
+    if (message.type === "controller:reconcileTurn") {
+        if (!allowControllerAction(connection, "session.run", message.requestId))
+            return;
+        const sessionRow = allowControllerSession(connection, message.sessionId, message.requestId);
+        if (!sessionRow)
+            return;
+        if (sessionRow.status === "closed") {
+            sendError(connection, {
+                type: "server:error",
+                requestId: message.requestId,
+                code: "SESSION_CLOSED",
+                message: "Session is closed",
+            });
+            return;
+        }
+        const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
+        if (!machineConnection) {
+            sendMachineOffline(connection, message.requestId);
+            return;
+        }
+        const claim = activeSessionClaim(connection.accountId, sessionRow.id);
+        const alias = message.turnId
+            ? db.prepare(`SELECT request_turn_id, runtime_turn_id, request_id
+           FROM session_turn_aliases
+           WHERE account_id = ? AND session_id = ? AND machine_id = ?
+             AND (request_turn_id = ? OR runtime_turn_id = ?)
+           ORDER BY created_at DESC
+           LIMIT 1`).get(connection.accountId, sessionRow.id, sessionRow.machine_id, message.turnId, message.turnId)
+            : undefined;
+        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId, { command: "reconcile", sessionId: sessionRow.id });
+        send(machineConnection.socket, {
+            type: "machine:reconcileTurn",
+            requestId: message.requestId,
+            sessionId: message.sessionId,
+            turnId: alias?.request_turn_id ?? message.turnId ?? claim?.turn_id ?? sessionRow.last_turn_id ?? undefined,
+            providerTurnId: alias?.runtime_turn_id,
+            activeRequestId: alias?.request_id ?? claim?.request_id ?? undefined,
+            encryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
+        });
+        return;
+    }
     if (message.type === "controller:resume") {
         if (!allowControllerAction(connection, "session.resume", message.requestId))
             return;
@@ -155,6 +324,10 @@ export function handleControllerMessage(context, connection, message) {
             return;
         if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "resume"))
             return;
+        if (rejectPendingSessionCommand(sessionRow, message.requestId, "resume"))
+            return;
+        if (rejectUnsupportedSessionPrimitive(sessionRow, message.requestId, "resume"))
+            return;
         const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
         if (!machineConnection) {
             const session = setSessionStatus(sessionRow.id, "offline");
@@ -163,11 +336,12 @@ export function handleControllerMessage(context, connection, message) {
             sendMachineOffline(connection, message.requestId);
             return;
         }
-        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId);
+        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId, { command: "resume", sessionId: sessionRow.id });
         send(machineConnection.socket, {
             type: "machine:resume",
             requestId: message.requestId,
             sessionId: message.sessionId,
+            ...(message.syncDirection ? { syncDirection: message.syncDirection } : {}),
             encryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
         });
         return;
@@ -317,6 +491,78 @@ export function handleControllerMessage(context, connection, message) {
         });
         return;
     }
+    if (message.type === "controller:gateway") {
+        if (!allowControllerAction(connection, "gateway.manage", message.requestId))
+            return;
+        if (!allowControllerMachine(connection, message.machineId, message.requestId))
+            return;
+        const machineConnection = connectedMachine(connection.accountId, message.machineId);
+        if (!machineConnection) {
+            sendMachineOffline(connection, message.requestId);
+            return;
+        }
+        markCommandPending(connection.accountId, message.machineId, message.requestId, { command: "gateway" });
+        send(machineConnection.socket, {
+            type: "machine:gateway",
+            requestId: message.requestId,
+            machineId: message.machineId,
+            action: message.action,
+            channelId: message.channelId,
+            channel: message.channel,
+            externalConversationId: message.externalConversationId,
+            externalMessageId: message.externalMessageId,
+            text: message.text,
+        });
+        return;
+    }
+    if (message.type === "controller:schedule") {
+        if (!allowControllerAction(connection, "schedule.manage", message.requestId))
+            return;
+        if (!allowControllerMachine(connection, message.machineId, message.requestId))
+            return;
+        const machineConnection = connectedMachine(connection.accountId, message.machineId);
+        if (!machineConnection) {
+            sendMachineOffline(connection, message.requestId);
+            return;
+        }
+        markCommandPending(connection.accountId, message.machineId, message.requestId, { command: "schedule" });
+        send(machineConnection.socket, {
+            type: "machine:schedule",
+            requestId: message.requestId,
+            machineId: message.machineId,
+            action: message.action,
+            scheduleId: message.scheduleId,
+            occurrenceId: message.occurrenceId,
+            schedule: message.schedule,
+        });
+        return;
+    }
+    if (message.type === "controller:memory") {
+        if (!allowControllerAction(connection, "memory.manage", message.requestId))
+            return;
+        if (!allowControllerMachine(connection, message.machineId, message.requestId))
+            return;
+        const machineConnection = connectedMachine(connection.accountId, message.machineId);
+        if (!machineConnection) {
+            sendMachineOffline(connection, message.requestId);
+            return;
+        }
+        markCommandPending(connection.accountId, message.machineId, message.requestId, { command: "memory" });
+        send(machineConnection.socket, {
+            type: "machine:memory",
+            requestId: message.requestId,
+            machineId: message.machineId,
+            action: message.action,
+            projectKey: message.projectKey,
+            path: message.path,
+            query: message.query,
+            limit: message.limit,
+            mode: message.mode,
+            write: message.write,
+            promote: message.promote,
+        });
+        return;
+    }
     if (message.type === "controller:importHistoricalSession") {
         if (!allowControllerAction(connection, "session.import", message.requestId))
             return;
@@ -341,11 +587,50 @@ export function handleControllerMessage(context, connection, message) {
             sendMachineOffline(connection, message.requestId);
             return;
         }
+        const existingBinding = findSessionRuntimeBinding(db, {
+            accountId: connection.accountId,
+            machineId: message.machineId,
+            agent: message.agent,
+            runtimeSessionId: message.runtimeSessionId,
+        });
+        if (existingBinding) {
+            const existingSession = db
+                .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+                .get(existingBinding.session_id, connection.accountId, message.machineId);
+            if (existingSession && existingSession.status !== "closed" && existingBinding.status !== "closed") {
+                sendAck(connection, {
+                    type: "server:ack",
+                    requestId: message.requestId,
+                    ok: true,
+                    sessionId: existingSession.id,
+                });
+                return;
+            }
+            if (existingSession?.status === "closed" || existingBinding.status === "closed") {
+                sendError(connection, {
+                    type: "server:error",
+                    requestId: message.requestId,
+                    code: "RUNTIME_SESSION_ARCHIVED",
+                    message: "This runtime session is archived in Happy Elves. Restore the archived session before importing it again.",
+                    sessionId: existingSession?.id ?? existingBinding.session_id,
+                });
+                return;
+            }
+        }
         const sessionId = randomId("ses");
         const createdAt = now();
         db.prepare(`INSERT INTO sessions
        (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(sessionId, connection.accountId, message.machineId, message.agent, message.cwd, message.name, "new", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, createdAt, createdAt);
+        upsertSessionRuntimeBindings(db, {
+            accountId: connection.accountId,
+            machineId: message.machineId,
+            agent: message.agent,
+            sessionId,
+            runtimeSessionIds: [message.runtimeSessionId],
+            status: "active",
+            ts: createdAt,
+        });
         const session = sessionSnapshot(db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId));
         broadcastControllers(connection.accountId, { type: "server:session", session });
         markCommandPending(connection.accountId, message.machineId, message.requestId);
@@ -369,12 +654,16 @@ export function handleControllerMessage(context, connection, message) {
             return;
         if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "rewind"))
             return;
+        if (rejectPendingSessionCommand(sessionRow, message.requestId, "rewind"))
+            return;
+        if (rejectUnsupportedSessionPrimitive(sessionRow, message.requestId, "rewind"))
+            return;
         const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
         if (!machineConnection) {
             sendMachineOffline(connection, message.requestId);
             return;
         }
-        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId);
+        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId, { command: "rewind", sessionId: sessionRow.id });
         send(machineConnection.socket, {
             type: "machine:rewind",
             requestId: message.requestId,
@@ -392,13 +681,17 @@ export function handleControllerMessage(context, connection, message) {
             return;
         if (rejectDisallowedSessionCommand(sessionRow, message.requestId, "fork"))
             return;
+        if (rejectPendingSessionCommand(sessionRow, message.requestId, "fork"))
+            return;
+        if (rejectUnsupportedSessionPrimitive(sessionRow, message.requestId, "fork"))
+            return;
         const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
         if (!machineConnection) {
             sendMachineOffline(connection, message.requestId);
             return;
         }
         const targetSessionId = randomId("ses");
-        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId);
+        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId, { command: "fork", sessionId: sessionRow.id });
         send(machineConnection.socket, {
             type: "machine:fork",
             requestId: message.requestId,
@@ -447,6 +740,12 @@ export function handleControllerMessage(context, connection, message) {
         const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
         if (!machineConnection) {
             const session = setSessionStatus(sessionRow.id, "closed");
+            finishSessionClaim({
+                accountId: connection.accountId,
+                sessionId: sessionRow.id,
+                terminalStatus: "cancelled",
+                errorCode: "SESSION_CLOSED",
+            });
             if (session)
                 broadcastControllers(connection.accountId, { type: "server:session", session });
             sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
@@ -462,4 +761,17 @@ export function handleControllerMessage(context, connection, message) {
         });
     }
 }
+function sessionLooksTranscriptPending(db, sessionRow) {
+    if (sessionRow.status !== "running")
+        return false;
+    if (!sessionRow.source_session_id || !sessionRow.source_checkpoint_id)
+        return false;
+    const row = db
+        .prepare(`SELECT 1
+       FROM session_events
+       WHERE account_id = ? AND session_id = ? AND machine_id = ?
+       LIMIT 1`)
+        .get(sessionRow.account_id, sessionRow.id, sessionRow.machine_id);
+    return !row;
+}
 //# sourceMappingURL=controller-handlers.js.map