@cydm/happy-elves 0.1.0-beta.49 → 0.1.0-beta.50

package/apps/cli/dist/commands/session.js

@@ -213,6 +213,8 @@ function diagnosticSessionMetadata(metadata) {
         historicalOlderBackfilledEvents: numberMetadata(metadata, "historicalOlderBackfilledEvents"),
         historicalTailRepairedEvents: numberMetadata(metadata, "historicalTailRepairedEvents"),
         truncatedHistoricalBackfill: metadata.truncatedHistoricalBackfill === true,
+        runtimeResumeStatus: stringMetadata(metadata, "runtimeResumeStatus"),
+        runtimeResumeError: stringMetadata(metadata, "runtimeResumeError"),
         importRequestId: stringMetadata(metadata, "importRequestId"),
         currentHead: stringMetadata(metadata, "currentHead"),
         emptyRuntimeSession: metadata.emptyRuntimeSession === true,

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

@@ -342,6 +342,27 @@ export function createExternalAgentRuntimeProvider(options) {
             }), "ensureSession result handle");
             return toRuntimeHandle(input.sessionKey, handle, input.cwd);
         },
+        async attachSession(input) {
+            const client = requireClientForAgent(input.agent);
+            if (!client) {
+                if (typeof options.fallback.attachSession === "function")
+                    return await options.fallback.attachSession(input);
+                return await options.fallback.ensureSession({
+                    sessionKey: input.sessionKey,
+                    agent: input.agent,
+                    mode: "persistent",
+                    resumeSessionId: input.runtimeSessionId,
+                    cwd: input.cwd,
+                });
+            }
+            const handle = validatedProviderHandle(client.id, {
+                provider: client.id,
+                agent: input.agent,
+                sessionId: input.runtimeSessionId,
+                cwd: input.cwd,
+            }, "historical runtime handle");
+            return toRuntimeHandle(input.sessionKey, handle, input.cwd);
+        },
         async listHistoricalSessions(input) {
             return (await listHistoricalSessionPage(input)).sessions;
         },

package/apps/daemon/dist/session/lifecycle.js

@@ -85,14 +85,14 @@ export async function handleImportHistoricalSession(ws, config, command) {
         return;
     const cwd = command.cwd || process.cwd();
     try {
-        const handle = await getRuntime(cwd).ensureSession({
-            sessionKey: command.sessionId,
+        const runtime = getRuntime(cwd);
+        const importedMetadata = await commandSessionMetadata(config, command.encryptedMetadata);
+        const handle = await attachHistoricalRuntimeSession(runtime, {
+            sessionId: command.sessionId,
             agent: command.agent,
-            mode: "persistent",
-            resumeSessionId: command.runtimeSessionId,
             cwd,
+            runtimeSessionId: command.runtimeSessionId,
         });
-        assertImportedRuntimeHandleMatches(command.runtimeSessionId, handle);
         const state = {
             sessionId: command.sessionId,
             agent: command.agent,
@@ -100,7 +100,6 @@ export async function handleImportHistoricalSession(ws, config, command) {
             name: command.name,
             handle,
         };
-        const importedMetadata = await commandSessionMetadata(config, command.encryptedMetadata);
         sessions.set(command.sessionId, state);
         const importedAt = new Date().toISOString();
         const importedMetadataBase = {
@@ -133,14 +132,41 @@ export async function handleImportHistoricalSession(ws, config, command) {
                 ...historicalBackfillMetadata(backfill),
             },
         });
+        let readyState = backfilledState;
+        let runtimeResumeError;
+        try {
+            const resumedHandle = await runtime.ensureSession({
+                sessionKey: command.sessionId,
+                agent: command.agent,
+                mode: "persistent",
+                resumeSessionId: command.runtimeSessionId,
+                cwd,
+            });
+            assertImportedRuntimeHandleMatches(command.runtimeSessionId, resumedHandle);
+            readyState = { ...backfilledState, handle: resumedHandle };
+            sessions.set(command.sessionId, readyState);
+        }
+        catch (error) {
+            runtimeResumeError = errorMessage(error);
+            await appendAudit({
+                sessionId: command.sessionId,
+                machineId: config.machineId,
+                actor: "system",
+                action: "session.import.runtime_resume_unavailable",
+                summary: `Imported historical transcript but could not resume runtime session ${command.runtimeSessionId}`,
+                evidence: { requestId: command.requestId, runtimeSessionId: command.runtimeSessionId, error: runtimeResumeError },
+            });
+        }
         await sendCommandResponse(ws, {
             type: "machine:sessionReady",
             requestId: command.requestId,
             sessionId: command.sessionId,
-            encryptedMetadata: await encryptedSessionMetadata(config, command.sessionId, backfilledState, {
+            encryptedMetadata: await encryptedSessionMetadata(config, command.sessionId, readyState, {
                 ...importedMetadataBase,
                 ...historicalBackfillMetadata(backfill),
                 historicalBackfilledAt: new Date().toISOString(),
+                runtimeResumeStatus: runtimeResumeError ? "unavailable" : "available",
+                ...(runtimeResumeError ? { runtimeResumeError } : {}),
             }),
         });
     }
@@ -162,6 +188,49 @@ export async function handleImportHistoricalSession(ws, config, command) {
         });
     }
 }
+async function attachHistoricalRuntimeSession(runtime, input) {
+    if (typeof runtime.attachSession === "function") {
+        const handle = await runtime.attachSession({
+            sessionKey: input.sessionId,
+            agent: input.agent,
+            cwd: input.cwd,
+            runtimeSessionId: input.runtimeSessionId,
+        });
+        assertImportedRuntimeHandleMatches(input.runtimeSessionId, handle);
+        return handle;
+    }
+    const handle = await runtime.ensureSession({
+        sessionKey: input.sessionId,
+        agent: input.agent,
+        mode: "persistent",
+        resumeSessionId: input.runtimeSessionId,
+        cwd: input.cwd,
+    });
+    assertImportedRuntimeHandleMatches(input.runtimeSessionId, handle);
+    return handle;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function resumeImportMetadata(fallback, runtimeResumeError, runtimeResumeAttempted = false) {
+    const metadata = {};
+    if (fallback?.importedFromRuntimeSessionId)
+        metadata.importedFromRuntimeSessionId = fallback.importedFromRuntimeSessionId;
+    if (runtimeResumeError) {
+        metadata.runtimeResumeStatus = "unavailable";
+        metadata.runtimeResumeError = runtimeResumeError;
+    }
+    else if (runtimeResumeAttempted && fallback?.importedFromRuntimeSessionId) {
+        metadata.runtimeResumeStatus = "available";
+    }
+    else {
+        if (fallback?.runtimeResumeStatus)
+            metadata.runtimeResumeStatus = fallback.runtimeResumeStatus;
+        if (fallback?.runtimeResumeError)
+            metadata.runtimeResumeError = fallback.runtimeResumeError;
+    }
+    return metadata;
+}
 export async function handleListHistoricalSessions(ws, config, command) {
     if (command.type !== "machine:listHistoricalSessions")
         return;
@@ -252,7 +321,7 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
     if (existing) {
         const refreshed = await refreshRuntimeSessionName(existing);
         const nameChanged = refreshed.name !== existing.name;
-        const backfill = await backfillHistoricalEvents(ws, config, refreshed, undefined, refreshed.historicalBackfill ?? fallback?.historicalBackfill);
+        const backfill = await backfillHistoricalEvents(ws, config, refreshed, fallback?.importedFromRuntimeSessionId, refreshed.historicalBackfill ?? fallback?.historicalBackfill);
         const resumed = withHistoricalBackfill(refreshed, backfill);
         sessions.set(sessionId, resumed);
         await appendAudit({
@@ -277,6 +346,7 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
                 ...(nameChanged ? { name: resumed.name } : {}),
                 encryptedMetadata: await encryptedSessionMetadata(config, sessionId, resumed, {
                     resumedAt: new Date().toISOString(),
+                    ...resumeImportMetadata(fallback),
                     ...historicalBackfillMetadata(backfill),
                     ...(nameChanged ? { providerName: resumed.name, runtimeNameSyncedAt: new Date().toISOString() } : {}),
                 }),
@@ -289,20 +359,45 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
     const name = fallback?.name ?? sessionId;
     const resumeSessionId = fallback?.runtime?.backendSessionId || fallback?.runtime?.agentSessionId;
     const resumeHandle = runtimeHandleFromFallback(sessionId, agent, cwd, fallback);
+    const historicalRuntimeSessionId = fallback?.importedFromRuntimeSessionId ?? resumeSessionId;
     try {
-        const handle = await getRuntime(cwd).ensureSession({
-            sessionKey: sessionId,
-            agent,
-            mode: "persistent",
-            resumeSessionId,
-            resumeHandle,
-            cwd,
-            restartableEmptySession: fallback?.emptyRuntimeSession === true,
-        });
+        const runtime = getRuntime(cwd);
+        let runtimeResumeError;
+        let handle;
+        try {
+            handle = await runtime.ensureSession({
+                sessionKey: sessionId,
+                agent,
+                mode: "persistent",
+                resumeSessionId,
+                resumeHandle,
+                cwd,
+                restartableEmptySession: fallback?.emptyRuntimeSession === true,
+            });
+        }
+        catch (error) {
+            if (!fallback?.importedFromRuntimeSessionId)
+                throw error;
+            runtimeResumeError = errorMessage(error);
+            handle = await attachHistoricalRuntimeSession(runtime, {
+                sessionId,
+                agent,
+                cwd,
+                runtimeSessionId: fallback.importedFromRuntimeSessionId,
+            });
+            await appendAudit({
+                sessionId,
+                machineId: config.machineId,
+                actor: "system",
+                action: "session.resume.runtime_resume_unavailable",
+                summary: `Resumed historical transcript but could not resume runtime session ${fallback.importedFromRuntimeSessionId}`,
+                evidence: { requestId, runtimeSessionId: fallback.importedFromRuntimeSessionId, error: runtimeResumeError },
+            });
+        }
         const state = await refreshRuntimeSessionName({ sessionId, agent, cwd, name, handle });
         sessions.set(sessionId, state);
         const nameChanged = state.name !== name;
-        const backfill = await backfillHistoricalEvents(ws, config, state, resumeSessionId, fallback?.historicalBackfill);
+        const backfill = await backfillHistoricalEvents(ws, config, state, historicalRuntimeSessionId, fallback?.historicalBackfill);
         const resumed = withHistoricalBackfill(state, backfill);
         sessions.set(sessionId, resumed);
         await appendAudit({
@@ -327,6 +422,7 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
                 ...(nameChanged ? { name: resumed.name } : {}),
                 encryptedMetadata: await encryptedSessionMetadata(config, sessionId, resumed, {
                     resumedAt: new Date().toISOString(),
+                    ...resumeImportMetadata(fallback, runtimeResumeError, true),
                     ...historicalBackfillMetadata(backfill),
                     ...(nameChanged ? { providerName: resumed.name, runtimeNameSyncedAt: new Date().toISOString() } : {}),
                 }),

package/apps/daemon/dist/session/metadata.js

@@ -37,6 +37,9 @@ export async function sessionFallbackFromCommand(config, command) {
             cwd: metadata.cwd || process.cwd(),
             name: metadata.name ?? command.sessionId,
             emptyRuntimeSession: metadata.emptyRuntimeSession === true,
+            importedFromRuntimeSessionId: metadata.importedFromRuntimeSessionId,
+            runtimeResumeStatus: metadata.runtimeResumeStatus,
+            runtimeResumeError: metadata.runtimeResumeError,
             historicalBackfill: historicalBackfillStateFromMetadata(metadata),
             runtime: metadata.runtime,
         };

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

@@ -65,6 +65,8 @@ export type SessionMetadata = {
     rewoundTo?: string;
     currentHead?: string;
     emptyRuntimeSession?: boolean;
+    runtimeResumeStatus?: "available" | "unavailable";
+    runtimeResumeError?: string;
     historicalBackfill?: "running" | HistoricalBackfillStatus;
     historicalBackfillCursor?: number;
     historicalBackfillProviderCursor?: string;
@@ -86,6 +88,9 @@ export type SessionMetadata = {
 };
 export type SessionFallback = Pick<SessionState, "agent" | "cwd" | "name"> & {
     emptyRuntimeSession?: boolean;
+    importedFromRuntimeSessionId?: string;
+    runtimeResumeStatus?: "available" | "unavailable";
+    runtimeResumeError?: string;
     historicalBackfill?: HistoricalBackfillState;
     runtime?: SessionMetadata["runtime"];
 };

package/apps/daemon/package.json

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

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.49",
+  "version": "0.1.0-beta.50",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.49",
+      "version": "0.1.0-beta.50",
       "license": "Apache-2.0",
       "dependencies": {
         "@fastify/cors": "11.2.0",
@@ -775,9 +775,9 @@
       }
     },
     "node_modules/bare-fs": {
-      "version": "4.7.2",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.2.tgz",
-      "integrity": "sha512-aTvMFUWkBmjzKtEQMDGGDNF8bkfpD5N1b/FCwt7A3wrU4t1o/e/85Wzkluh6JlODCjqVESYCkQCdTXqZ9G7VFg==",
+      "version": "4.7.3",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.3.tgz",
+      "integrity": "sha512-xRgplks8SvcKkdlv2M6Z2LZmRsmqd+x0nXXGXeMEjwdibj1HSDrlnqBRLeYdMvsgCox7Bq0e+DHwfczOfsn6IA==",
       "license": "Apache-2.0",
       "dependencies": {
         "bare-events": "^2.5.4",
@@ -1552,9 +1552,9 @@
       }
     },
     "node_modules/tsx": {
-      "version": "4.22.4",
-      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.22.4.tgz",
-      "integrity": "sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==",
+      "version": "4.22.5",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.22.5.tgz",
+      "integrity": "sha512-F7JnSfPl5ASt6LqwWyUQ3T8BwN3q0eQEbFMYa2iRWaVQmmudo0d7fRmwM4O002gsvW1bs0yBYioutsAjqLJMvQ==",
       "license": "MIT",
       "dependencies": {
         "esbuild": "~0.28.0"

package/package.json

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

package/packages/runtime/dist/index.d.ts

@@ -58,6 +58,12 @@ export interface HappyElvesRuntime {
         permissionMode?: RuntimePermissionMode;
         restartableEmptySession?: boolean;
     }): Promise<RuntimeHandle>;
+    attachSession?(input: {
+        sessionKey: string;
+        agent: string;
+        cwd?: string;
+        runtimeSessionId: string;
+    }): RuntimeHandle | Promise<RuntimeHandle>;
     listHistoricalSessions?(input: {
         agent?: string;
         cwd?: string;

package/packages/runtime-cli/dist/codex-history.js

@@ -474,40 +474,78 @@ async function findCodexRolloutPathBySessionId(directories, sessionId, fileCache
     return undefined;
 }
 async function readCodexRolloutMeta(path) {
-    const firstLine = await readFirstLine(path);
-    const record = firstLine ? parseJsonRecord(firstLine) : undefined;
-    if (!record || record.type !== "session_meta")
-        return undefined;
-    const payload = recordFrom(record.payload);
-    const id = stringField(payload, "id");
-    if (!id)
+    const fallbackId = codexRolloutIdFromPath(path);
+    const lines = await readInitialLines(path, 64, 256 * 1024);
+    let createdAt;
+    let cwd;
+    for (const line of lines) {
+        const record = line ? parseJsonRecord(line) : undefined;
+        if (!record)
+            continue;
+        createdAt ??= timestampMs(record.timestamp);
+        const payload = recordFrom(record.payload);
+        cwd ??= stringField(payload, "cwd");
+        if (record.type !== "session_meta")
+            continue;
+        const id = stringField(payload, "id") ?? fallbackId;
+        if (!id)
+            return undefined;
+        return {
+            id,
+            cwd,
+            createdAt: timestampMs(payload.timestamp ?? record.timestamp) ?? createdAt,
+        };
+    }
+    if (!fallbackId)
         return undefined;
+    const id = fallbackId;
     return {
         id,
-        cwd: stringField(payload, "cwd"),
-        createdAt: timestampMs(payload.timestamp ?? record.timestamp),
+        cwd,
+        createdAt,
     };
 }
-async function readFirstLine(path) {
-    return await new Promise((resolveLine) => {
+function codexRolloutIdFromPath(path) {
+    const match = basename(path).match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/iu);
+    return match?.[1];
+}
+async function readInitialLines(path, maxLines, maxBytes) {
+    return await new Promise((resolveLines) => {
         const stream = createReadStream(path, { encoding: "utf8" });
         let buffer = "";
+        let readBytes = 0;
+        const lines = [];
         let settled = false;
-        const settle = (line = "") => {
+        const settle = () => {
             if (settled)
                 return;
             settled = true;
             stream.destroy();
-            resolveLine(line);
+            resolveLines(lines);
         };
         stream.on("data", (chunk) => {
+            readBytes += chunk.length;
             buffer += chunk;
-            const newlineIndex = buffer.indexOf("\n");
-            if (newlineIndex >= 0)
-                settle(buffer.slice(0, newlineIndex));
+            let newlineIndex = buffer.indexOf("\n");
+            while (newlineIndex >= 0) {
+                lines.push(buffer.slice(0, newlineIndex));
+                buffer = buffer.slice(newlineIndex + 1);
+                if (lines.length >= maxLines)
+                    return settle();
+                newlineIndex = buffer.indexOf("\n");
+            }
+            if (readBytes >= maxBytes) {
+                if (buffer)
+                    lines.push(buffer);
+                settle();
+            }
         });
         stream.on("error", () => settle());
-        stream.on("end", () => settle(buffer));
+        stream.on("end", () => {
+            if (buffer)
+                lines.push(buffer);
+            settle();
+        });
     });
 }
 async function readCodexRolloutPreview(path) {

package/packages/runtime-cli/dist/index.js

@@ -81,6 +81,14 @@ export function createCliRuntimeProvider(options) {
             assertNotExternalProviderHandle(input.resumeHandle);
             return (await sessions.ensure(input)).handle;
         },
+        attachSession(input) {
+            const cwd = input.cwd || options.cwd;
+            if (input.agent === "codex")
+                return sessions.createLoadedCodex(input.sessionKey, cwd, input.runtimeSessionId).handle;
+            if (input.agent === "claude")
+                return sessions.createLoadedClaude(input.sessionKey, cwd, input.runtimeSessionId).handle;
+            throw new Error(`Unsupported CLI runtime agent: ${input.agent}`);
+        },
         async listHistoricalSessions(input) {
             return (await listHistoricalSessionPage(input)).sessions;
         },

package/packages/runtime-cli/dist/session-store.d.ts

@@ -3,6 +3,7 @@ import { CodexAppServerSession } from "./codex-app-server.js";
 export type CliSession = {
     handle: RuntimeHandle;
     codex?: CodexAppServerSession;
+    codexEnsured?: boolean;
     activeClaudeTurn?: RuntimeTurn;
     claudeStarted?: boolean;
     pendingClaudeName?: string;

package/packages/runtime-cli/dist/session-store.js

@@ -17,8 +17,14 @@ export class CliSessionStore {
     }
     async ensure(input) {
         const existing = this.sessions.get(input.sessionKey);
-        if (existing)
+        if (existing) {
+            if (existing.codex && existing.codexEnsured !== true) {
+                const threadId = await existing.codex.ensure(input.permissionMode);
+                existing.handle.backendSessionId = threadId;
+                existing.codexEnsured = true;
+            }
             return existing;
+        }
         const cwd = input.cwd ?? this.input.cwd;
         const agent = cliAgent(input.agent);
         if (agent === "codex") {
@@ -71,6 +77,7 @@ export class CliSessionStore {
         const threadId = await codex.ensure(permissionMode);
         session.handle.backendSessionId = threadId;
         session.codex = codex;
+        session.codexEnsured = true;
         this.sessions.set(sessionKey, session);
         return session;
     }