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

package/apps/daemon/dist/session/runtime-handle.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeHandle, RuntimePrimitiveResult } from "@happy-elves/runtime";
+import type { RuntimeHandle, RuntimePrimitiveResult } from "../../../../packages/runtime/dist/index.js";
 export declare function primitiveResultHandle(result: RuntimePrimitiveResult | RuntimeHandle | void): RuntimeHandle | undefined;
 export declare function primitiveResultHead(result: RuntimePrimitiveResult | RuntimeHandle | void): {
     currentHead?: string;

package/apps/daemon/dist/start.js

@@ -1,6 +1,7 @@
 import { parseDaemonFlags } from "./args.js";
 import { readConfig } from "./config.js";
 import { DaemonCliError } from "./errors.js";
+import { startGatewayRuntime, stopGatewayRuntime } from "./gateway/runtime.js";
 import { assertRelayUrl } from "./relay-http.js";
 import { connectOnce } from "./relay/connection.js";
 import { localStatus, removePidIfCurrent, writePid } from "./process.js";
@@ -18,10 +19,13 @@ export async function start(argv) {
         throw new DaemonCliError(`Daemon is already running with pid ${existing.pid}`, "DAEMON_ALREADY_RUNNING");
     }
     await initializeRuntime(process.cwd());
+    await startGatewayRuntime(config).catch((error) => {
+        console.error(`Gateway runtime failed to start: ${error instanceof Error ? error.message : String(error)}`);
+    });
     await writePid();
     const cleanup = () => {
         disposeRuntime();
-        void removePidIfCurrent().finally(() => process.exit(0));
+        void stopGatewayRuntime().finally(() => removePidIfCurrent().finally(() => process.exit(0)));
     };
     process.once("SIGINT", cleanup);
     process.once("SIGTERM", cleanup);

package/apps/daemon/dist/state.d.ts

@@ -1,5 +1,5 @@
-import type { RuntimeTurn } from "@happy-elves/runtime";
-import type { MachineClientMessage } from "@happy-elves/shared";
+import type { RuntimeTurn } from "../../../packages/runtime/dist/index.js";
+import type { MachineClientMessage } from "../../../packages/shared/dist/index.js";
 import { BoundedTtlCache, SessionTurnCoordinator } from "./turn-coordinator.js";
 import type { SessionState } from "./types.js";
 export declare const sessions: Map<string, SessionState>;

package/apps/daemon/dist/turn-coordinator.d.ts

@@ -24,4 +24,5 @@ export declare class SessionTurnCoordinator<Turn> {
     release(sessionId: string, requestId: string): void;
     activeTurn(sessionId: string): Turn | undefined;
     activeTurnId(sessionId: string): string | undefined;
+    activeClaim(sessionId: string): SessionTurnClaim | undefined;
 }

package/apps/daemon/dist/turn-coordinator.js

@@ -76,5 +76,9 @@ export class SessionTurnCoordinator {
     activeTurnId(sessionId) {
         return this.activeTurnIds.get(sessionId);
     }
+    activeClaim(sessionId) {
+        const claim = this.claims.get(sessionId);
+        return claim ? { ...claim } : undefined;
+    }
 }
 //# sourceMappingURL=turn-coordinator.js.map

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

@@ -1,4 +1,5 @@
-import type { RuntimeHandle, RuntimeTurn } from "@happy-elves/runtime";
+import type { SessionHeadAdvanceBasis } from "../../../packages/shared/dist/index.js";
+import type { RuntimeHandle, RuntimeTurn } from "../../../packages/runtime/dist/index.js";
 export type DirectoryListResult = {
     machineId: string;
     path: string;
@@ -30,6 +31,8 @@ export type SessionState = {
     agent: string;
     cwd: string;
     name: string;
+    model?: string;
+    tags?: string[];
     handle: RuntimeHandle;
     historicalBackfill?: HistoricalBackfillState;
 };
@@ -37,15 +40,24 @@ type PermissionMode = "approve-all" | "approve-reads" | "deny-all";
 export type HistoricalBackfillStatus = "partial" | "completed";
 export type HistoricalBackfillState = {
     cursor: number;
+    head?: HistoricalHeadState;
     providerCursor?: string;
     status: HistoricalBackfillStatus;
     totalEvents: number;
 };
+export type HistoricalHeadState = {
+    basis: SessionHeadAdvanceBasis;
+    currentHead: string;
+    lastTurnId: string;
+};
 export type SessionMetadata = {
     agent?: string;
     cwd?: string;
     name?: string;
     providerName?: string;
+    model?: string;
+    tags?: string[];
+    tagKeys?: string[];
     requestedRuntimeName?: string;
     permissionMode?: PermissionMode;
     importedFromRuntimeSessionId?: string;
@@ -61,6 +73,7 @@ export type SessionMetadata = {
     historicalBackfillProviderCursor?: string;
     historicalBackfillStatus?: HistoricalBackfillStatus;
     historicalBackfillTotalEvents?: number;
+    historicalHead?: HistoricalHeadState;
     backfilledEvents?: number;
     availableHistoricalEvents?: number;
     truncatedHistoricalBackfill?: boolean;
@@ -75,6 +88,8 @@ export type SessionMetadata = {
     };
 };
 export type SessionFallback = Pick<SessionState, "agent" | "cwd" | "name"> & {
+    model?: string;
+    tags?: string[];
     emptyRuntimeSession?: boolean;
     historicalBackfill?: HistoricalBackfillState;
     runtime?: SessionMetadata["runtime"];

package/apps/daemon/package.json

@@ -1,28 +1,6 @@
 {
-  "name": "@happy-elves/daemon",
-  "version": "0.1.0",
+  "name": "@cydm/happy-elves-daemon",
+  "version": "0.1.0-beta.310",
   "private": true,
-  "type": "module",
-  "bin": {
-    "happy-elves-daemon": "./dist/cli.js"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "cli": "tsx src/cli.ts",
-    "dev": "tsx watch src/cli.ts start",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
-  },
-  "dependencies": {
-    "@happy-elves/runtime": "workspace:*",
-    "@happy-elves/runtime-acpx": "workspace:*",
-    "@happy-elves/runtime-cli": "workspace:*",
-    "@happy-elves/agent-sdk": "workspace:*",
-    "@happy-elves/pie-provider": "workspace:*",
-    "@happy-elves/shared": "workspace:*",
-    "acpx": "^0.7.0"
-  },
-  "devDependencies": {
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
-  }
+  "type": "module"
 }

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

@@ -5,7 +5,9 @@ export declare function createConnectionState(): {
     machinesByKey: Map<string, MachineConnection>;
     pendingCommandRequests: Map<string, {
         accountId: string;
+        command?: string;
         machineId: string;
         requestId: string;
+        sessionId?: string;
     }>;
 };

package/apps/relay/dist/controller-handlers.d.ts

@@ -1,28 +1,68 @@
 import type { DatabaseSync } from "node:sqlite";
-import { type ClientMessage, type EncryptedEnvelope, type MachineSnapshot, type ServerMessage, type SessionSnapshot } from "@happy-elves/shared";
+import { type ClientMessage, type EncryptedEnvelope, type MachineSnapshot, type ServerMessage, type SessionSnapshot } from "../../../packages/shared/dist/index.js";
 import type { ControllerConnection, MachineConnection, SessionRow, WebSocketLike } from "./types.js";
 type ControllerHandlerContext = {
     allowControllerAction(connection: ControllerConnection, action: string, requestId?: string): boolean;
     allowControllerMachine(connection: ControllerConnection, machineId: string, requestId?: string): boolean;
     allowControllerSession(connection: ControllerConnection, sessionId: string, requestId?: string): SessionRow | null;
+    activeSessionClaim(accountId: string, sessionId: string): {
+        request_id: string;
+        turn_id: string;
+    } | undefined;
     broadcastControllers(accountId: string, message: ServerMessage): void;
+    claimSessionTurn(params: {
+        accountId: string;
+        sessionId: string;
+        machineId: string;
+        requestId: string;
+        turnId: string;
+        commandType: "prompt";
+        createdAt?: number;
+    }): {
+        ok: true;
+    } | {
+        ok: false;
+        claim: {
+            request_id: string;
+            turn_id: string;
+        };
+    };
     connectedMachine(accountId: string, machineId: string): MachineConnection | undefined;
     db: DatabaseSync;
+    deliverOutboxCommand(accountId: string, requestId: string): "queued" | "delivered";
+    finishSessionClaim(params: {
+        accountId: string;
+        sessionId: string;
+        requestId?: string;
+        turnId?: string;
+        terminalStatus: "completed" | "cancelled" | "failed" | "error" | "unknown";
+        errorCode?: string;
+        finishedAt?: number;
+    }): unknown;
     insertEvent(params: {
         accountId: string;
         sessionId: string;
         machineId: string;
+        source: "controller" | "machine";
         turnId: string;
         turnSeq?: number;
         payload: EncryptedEnvelope;
+        updateSession?: boolean;
     }): Extract<ServerMessage, {
         type: "server:event";
     }>["event"];
     isCommandPending(accountId: string, requestId: string): boolean;
+    isSessionCommandPending(accountId: string, sessionId: string): boolean;
     machineCapabilities(accountId: string, machineId: string): MachineSnapshot["capabilities"] | undefined;
-    markCommandPending(accountId: string, machineId: string, requestId: string): void;
+    markCommandPending(accountId: string, machineId: string, requestId: string, options?: {
+        command?: string;
+        sessionId?: string;
+    }): void;
     now(): number;
     parseJson<T>(value: string | null | undefined, fallback: T): T;
+    previousAdmissionAck(accountId: string, requestId: string): Extract<ServerMessage, {
+        type: "server:ack";
+    }> | undefined;
     previousCommandResponse(accountId: string, requestId: string): ServerMessage | undefined;
     send(socket: WebSocketLike, message: ServerMessage): void;
     sendAck(connection: ControllerConnection, message: Extract<ServerMessage, {