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

package/apps/daemon/dist/schedule/store.js

@@ -0,0 +1,143 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import { configDir, scheduleStorePath } from "../paths.js";
+function emptyScheduleStore() {
+    return { version: 1, schedules: [] };
+}
+export async function readScheduleStore() {
+    try {
+        const parsed = JSON.parse(await fs.readFile(scheduleStorePath, "utf8"));
+        if (parsed.version !== 1 || !Array.isArray(parsed.schedules))
+            return emptyScheduleStore();
+        return { version: 1, schedules: parsed.schedules.map(normalizeScheduleRecord).filter(Boolean) };
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return emptyScheduleStore();
+        throw error;
+    }
+}
+async function writeScheduleStore(store) {
+    await fs.mkdir(configDir, { recursive: true });
+    await backupLegacyScheduleStoreOnce();
+    const tmpPath = `${scheduleStorePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tmpPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(tmpPath, scheduleStorePath);
+    await fs.chmod(scheduleStorePath, 0o600);
+}
+async function backupLegacyScheduleStoreOnce() {
+    const backupPath = `${scheduleStorePath}.cli-local.bak`;
+    try {
+        await fs.copyFile(scheduleStorePath, backupPath, fsConstants.COPYFILE_EXCL);
+        await fs.chmod(backupPath, 0o600);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "EEXIST")
+            return;
+        throw error;
+    }
+}
+export async function updateScheduleStore(update) {
+    const run = scheduleStoreUpdateChain.then(async () => {
+        const current = await readScheduleStore();
+        const next = await update(current);
+        await writeScheduleStore(next);
+        return next;
+    });
+    scheduleStoreUpdateChain = run.catch(() => undefined);
+    return await run;
+}
+let scheduleStoreUpdateChain = Promise.resolve();
+export function compactSchedules(store) {
+    return store.schedules.filter((schedule) => schedule.status !== "deleted");
+}
+export function normalizeScheduleRecord(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return undefined;
+    const record = input;
+    if (typeof record.id !== "string" || record.id.length === 0)
+        return undefined;
+    if (typeof record.prompt !== "string")
+        return undefined;
+    const now = new Date().toISOString();
+    const legacySessionId = typeof record.sessionId === "string" && record.sessionId.length > 0 ? record.sessionId : undefined;
+    const target = normalizeScheduleTarget(record.target, legacySessionId);
+    const schedule = normalizeScheduleSpec(record.schedule, record.dueAt);
+    const runs = Array.isArray(record.runs) ? record.runs.filter((run) => Boolean(run && typeof run === "object" && typeof run.occurrenceId === "string")) : [];
+    const sourceSessionId = record.sourceSessionId ?? legacySessionId ?? (target?.type === "project" ? target.sourceSessionId : target?.sourceSessionId);
+    const sessionId = legacySessionId ?? sourceSessionId;
+    return {
+        id: record.id,
+        ...(typeof record.name === "string" && record.name ? { name: record.name } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        ...(sourceSessionId ? { sourceSessionId } : {}),
+        ...(target ? { target } : {}),
+        prompt: record.prompt,
+        ...(record.dueAt ? { dueAt: record.dueAt } : {}),
+        ...(schedule ? { schedule } : {}),
+        execution: record.execution === "isolated" ? "isolated" : "continue",
+        memoryMode: normalizeMemoryMode(record.memoryMode),
+        stopOn: normalizeStopOn(record.stopOn),
+        status: record.status === "paused" || record.status === "completed" || record.status === "deleted" ? record.status : "active",
+        ...(record.nextRunAt ? { nextRunAt: record.nextRunAt } : {}),
+        ...(record.pendingRunId ? { pendingRunId: record.pendingRunId } : {}),
+        runCount: typeof record.runCount === "number" ? record.runCount : countScheduleRuns(runs),
+        ...(record.lastRun ? { lastRun: record.lastRun } : runs[0] ? { lastRun: runs[0] } : {}),
+        createdAt: record.createdAt ?? now,
+        updatedAt: record.updatedAt ?? now,
+        runs,
+    };
+}
+function countScheduleRuns(runs) {
+    return runs.filter((run) => run.status === "admitted" ||
+        run.status === "completed" ||
+        run.status === "failed" ||
+        run.status === "blocked").length;
+}
+function normalizeScheduleSpec(input, legacyDueAt) {
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+        const spec = input;
+        if (spec.type === "manual")
+            return { type: "manual" };
+        if (spec.type === "oneshot" && typeof spec.runAt === "string" && spec.runAt)
+            return { type: "oneshot", runAt: spec.runAt };
+        if (spec.type === "interval" && typeof spec.everyMs === "number" && spec.everyMs > 0)
+            return { type: "interval", everyMs: spec.everyMs };
+        if (spec.type === "cron" && typeof spec.expr === "string" && spec.expr) {
+            return { type: "cron", expr: spec.expr, ...(typeof spec.timezone === "string" && spec.timezone ? { timezone: spec.timezone } : {}) };
+        }
+    }
+    if (typeof legacyDueAt === "string" && legacyDueAt)
+        return { type: "oneshot", runAt: legacyDueAt };
+    return { type: "manual" };
+}
+function normalizeScheduleTarget(input, legacySessionId) {
+    if (input && typeof input === "object" && !Array.isArray(input)) {
+        const target = input;
+        if (target.type === "sourceSession" && typeof target.sourceSessionId === "string" && target.sourceSessionId) {
+            return { type: "sourceSession", sourceSessionId: target.sourceSessionId };
+        }
+        if (target.type === "project" && typeof target.cwd === "string" && target.cwd && typeof target.agent === "string" && target.agent) {
+            return {
+                type: "project",
+                cwd: target.cwd,
+                agent: target.agent,
+                ...(typeof target.machineId === "string" && target.machineId ? { machineId: target.machineId } : {}),
+                ...(typeof target.sourceSessionId === "string" && target.sourceSessionId ? { sourceSessionId: target.sourceSessionId } : {}),
+            };
+        }
+    }
+    return legacySessionId ? { type: "sourceSession", sourceSessionId: legacySessionId } : undefined;
+}
+function normalizeMemoryMode(value) {
+    return value === "off" || value === "readonly" || value === "readwrite" ? value : "inherit";
+}
+function normalizeStopOn(value) {
+    const allowed = new Set(["blocked", "failed", "permission"]);
+    if (!Array.isArray(value))
+        return ["blocked", "failed", "permission"];
+    const filtered = value.filter((item) => allowed.has(item));
+    return filtered.length > 0 ? filtered : ["blocked", "failed", "permission"];
+}
+//# sourceMappingURL=store.js.map

package/apps/daemon/dist/session/create-session.d.ts

@@ -1,4 +1,4 @@
-import type { MachineClientMessage, MachineCommand } from "@happy-elves/shared";
+import type { MachineClientMessage, MachineCommand } from "../../../../packages/shared/dist/index.js";
 type CreateSessionCommand = Extract<MachineCommand, {
     type: "machine:createSession";
 }>;

package/apps/daemon/dist/session/directory.d.ts

@@ -1,3 +1,3 @@
-import type { MachineCommand } from "@happy-elves/shared";
+import type { MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function handleListDirectory(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;

package/apps/daemon/dist/session/events.d.ts

@@ -1,12 +1,15 @@
-import { type EncryptedEnvelope, type SessionEventPayload } from "@happy-elves/shared";
-import type { RuntimeEvent, RuntimeHistoricalEvent } from "@happy-elves/runtime";
+import { type EncryptedEnvelope, type SessionEventPayload, type SessionHeadAdvanceBasis } from "../../../../packages/shared/dist/index.js";
+import type { RuntimeEvent, RuntimeHistoricalEvent } from "../../../../packages/runtime/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function emitEvent(ws: WebSocket, config: DaemonConfig, sessionId: string, turnId: string, payload: SessionEventPayload): Promise<void>;
 export declare function emitHistoricalEvents(ws: WebSocket, config: DaemonConfig, sessionId: string, events: RuntimeHistoricalEvent[], startIndex?: number): Promise<void>;
 export declare function emitRuntimeTailEvents(ws: WebSocket, config: DaemonConfig, sessionId: string, events: RuntimeHistoricalEvent[], startIndex?: number): Promise<void>;
+export declare function emitSessionHeadAdvanced(ws: WebSocket, sessionId: string, head: HistoricalSessionHead, encryptedMetadata?: EncryptedEnvelope, status?: "completed" | "cancelled" | "failed"): Promise<void>;
 export declare function emitTranscriptReplacement(ws: WebSocket, config: DaemonConfig, sessionId: string, events: RuntimeHistoricalEvent[], input?: {
+    requestId?: string;
     currentHead?: string;
     lastTurnId?: string;
+    replacementKind?: "command" | "sync";
     status?: "completed" | "cancelled" | "failed";
     encryptedMetadata?: EncryptedEnvelope;
     hasMoreBefore?: boolean;
@@ -17,4 +20,14 @@ export declare function emitTranscriptPrepended(ws: WebSocket, config: DaemonCon
     hasMoreBefore?: boolean;
     nextBefore?: string;
 }): Promise<void>;
+export type HistoricalSessionHead = {
+    currentHead: string;
+    lastTurnId: string;
+    basis: SessionHeadAdvanceBasis;
+};
+export declare function latestCompletedHistoricalHead(sessionId: string, events: RuntimeHistoricalEvent[], _input?: {
+    preferTailBasisForExistingEvents?: boolean;
+    previousTotalEvents?: number;
+    tailStartIndex?: number;
+}): HistoricalSessionHead | undefined;
 export declare function runtimeEventToPayload(event: RuntimeEvent): SessionEventPayload;

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

@@ -23,7 +23,7 @@ export async function emitHistoricalEvents(ws, config, sessionId, events, startI
     }
 }
 export async function emitRuntimeTailEvents(ws, config, sessionId, events, startIndex = 0) {
-    const encryptedEvents = await encryptedRuntimeTailEvents(config, sessionId, events, startIndex);
+    const encryptedEvents = await encryptedHistoricalEvents(config, sessionId, events, startIndex);
     for (const event of encryptedEvents) {
         await sendReliable({
             type: "machine:event",
@@ -32,12 +32,28 @@ export async function emitRuntimeTailEvents(ws, config, sessionId, events, start
         }, ws);
     }
 }
+export async function emitSessionHeadAdvanced(ws, sessionId, head, encryptedMetadata, status) {
+    await sendReliable({
+        type: "machine:sessionHeadAdvanced",
+        sessionId,
+        currentHead: head.currentHead,
+        lastTurnId: head.lastTurnId,
+        basis: head.basis,
+        status,
+        encryptedMetadata,
+    }, ws);
+}
 export async function emitTranscriptReplacement(ws, config, sessionId, events, input = {}) {
+    const head = latestCompletedHistoricalHead(sessionId, events);
+    const fallbackHead = transcriptHead(events);
     await sendReliable({
         type: "machine:sessionTranscriptReplaced",
         sessionId,
-        currentHead: input.currentHead ?? transcriptHead(events).currentHead,
-        lastTurnId: input.lastTurnId ?? transcriptHead(events).lastTurnId,
+        requestId: input.requestId,
+        currentHead: input.currentHead ?? head?.currentHead ?? fallbackHead.currentHead,
+        lastTurnId: input.lastTurnId ?? head?.lastTurnId ?? fallbackHead.lastTurnId,
+        basis: head?.basis,
+        replacementKind: input.replacementKind,
         status: input.status,
         hasMoreBefore: input.hasMoreBefore,
         nextBefore: input.nextBefore,
@@ -70,20 +86,6 @@ async function encryptedHistoricalEvents(config, sessionId, events, startIndex =
     }
     return encrypted;
 }
-async function encryptedRuntimeTailEvents(config, sessionId, events, startIndex = 0) {
-    const encrypted = [];
-    for (const [index, event] of events.entries()) {
-        const globalIndex = startIndex + index;
-        const stableTailSeq = event.seq ?? globalIndex + 1;
-        encrypted.push({
-            turnId: event.turnId,
-            seq: stableTailSeq,
-            messageId: runtimeTailEventMessageId(sessionId, event, stableTailSeq),
-            payload: await encryptJson(config.accountSecret, `event:${sessionId}:${event.turnId}:${stableTailSeq}`, event.payload),
-        });
-    }
-    return encrypted;
-}
 function transcriptHead(events) {
     for (let index = events.length - 1; index >= 0; index -= 1) {
         const event = events[index];
@@ -98,6 +100,28 @@ function transcriptHead(events) {
     }
     return events.at(-1)?.turnId ? { currentHead: events.at(-1)?.turnId, lastTurnId: events.at(-1)?.turnId } : {};
 }
+export function latestCompletedHistoricalHead(sessionId, events, _input = {}) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (!event || event.payload.type !== "done" || event.payload.status !== "completed")
+            continue;
+        const seq = event.seq ?? index + 1;
+        const eventMessageId = historicalEventMessageId(sessionId, event, seq);
+        const currentHead = event.payload.currentHead ?? event.payload.lastTurnId ?? event.turnId;
+        const lastTurnId = event.payload.lastTurnId ?? event.payload.currentHead ?? event.turnId;
+        return {
+            currentHead,
+            lastTurnId,
+            basis: {
+                turnId: event.turnId,
+                eventMessageId,
+                turnSeq: seq,
+                ...(event.occurredAt !== undefined ? { occurredAt: event.occurredAt } : {}),
+            },
+        };
+    }
+    return undefined;
+}
 function historicalEventMessageId(sessionId, event, seq) {
     const digest = createHash("sha256")
         .update(JSON.stringify({ occurredAt: event.occurredAt, payload: event.payload, seq }))
@@ -105,13 +129,6 @@ function historicalEventMessageId(sessionId, event, seq) {
         .slice(0, 18);
     return `hist_${sessionId}_${event.turnId}_${seq}_${digest}`;
 }
-function runtimeTailEventMessageId(sessionId, event, seq) {
-    const digest = createHash("sha256")
-        .update(JSON.stringify({ payload: event.payload, seq }))
-        .digest("base64url")
-        .slice(0, 18);
-    return `tail_${sessionId}_${event.turnId}_${seq}_${digest}`;
-}
 export function runtimeEventToPayload(event) {
     if (event.type === "text_delta") {
         return {
@@ -130,9 +147,44 @@ export function runtimeEventToPayload(event) {
             title: event.title,
         };
     }
+    if (event.type === "option_request") {
+        return {
+            type: "option_request",
+            optionRequestId: event.optionRequestId,
+            ...(event.title ? { title: event.title } : {}),
+            message: event.message,
+            options: event.options,
+            ...(event.allowFreeText ? { allowFreeText: true } : {}),
+        };
+    }
     if (event.type === "status") {
+        if (typeof event.used === "number" && Number.isFinite(event.used)) {
+            return {
+                type: "session_usage",
+                usage: {
+                    source: "provider",
+                    usedTokens: Math.max(0, Math.round(event.used)),
+                    ...(typeof event.size === "number" && Number.isFinite(event.size) ? { contextWindowTokens: Math.max(0, Math.round(event.size)) } : {}),
+                },
+            };
+        }
         return { type: "status", text: event.text, tag: event.tag };
     }
+    if (event.type === "session_usage") {
+        return {
+            type: "session_usage",
+            usage: {
+                source: event.source,
+                usedTokens: Math.max(0, Math.round(event.usedTokens)),
+                ...(typeof event.contextWindowTokens === "number" && Number.isFinite(event.contextWindowTokens) ? { contextWindowTokens: Math.max(0, Math.round(event.contextWindowTokens)) } : {}),
+                ...(typeof event.inputTokens === "number" && Number.isFinite(event.inputTokens) ? { inputTokens: Math.max(0, Math.round(event.inputTokens)) } : {}),
+                ...(typeof event.outputTokens === "number" && Number.isFinite(event.outputTokens) ? { outputTokens: Math.max(0, Math.round(event.outputTokens)) } : {}),
+                ...(typeof event.cachedInputTokens === "number" && Number.isFinite(event.cachedInputTokens) ? { cachedInputTokens: Math.max(0, Math.round(event.cachedInputTokens)) } : {}),
+                ...(typeof event.reasoningOutputTokens === "number" && Number.isFinite(event.reasoningOutputTokens) ? { reasoningOutputTokens: Math.max(0, Math.round(event.reasoningOutputTokens)) } : {}),
+                ...(typeof event.totalTokens === "number" && Number.isFinite(event.totalTokens) ? { totalTokens: Math.max(0, Math.round(event.totalTokens)) } : {}),
+            },
+        };
+    }
     if (event.type === "error") {
         return { type: "done", status: "failed", error: event.message };
     }

package/apps/daemon/dist/session/file-preview.d.ts

@@ -1,4 +1,4 @@
-import type { FilePreviewMode, FilePreviewResult, MachineCommand } from "@happy-elves/shared";
+import type { FilePreviewMode, FilePreviewResult, MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function handlePreviewFile(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function buildFilePreview(config: DaemonConfig, rootPath: string, requestedPath: string, mode?: FilePreviewMode): Promise<FilePreviewResult>;

package/apps/daemon/dist/session/lifecycle.d.ts

@@ -1,5 +1,8 @@
-import { type MachineCommand } from "@happy-elves/shared";
-import type { DaemonConfig, HistoricalBackfillStatus, SessionFallback, SessionState } from "../types.js";
+import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig, HistoricalBackfillState, HistoricalBackfillStatus, SessionFallback, SessionState } from "../types.js";
+import { type HistoricalSessionHead } from "./events.js";
+export type HistoricalBackfillDirection = "latest" | "older";
+type HistoricalBackfillMode = HistoricalBackfillDirection | "auto";
 export type HistoricalBackfillResult = {
     availableEvents: number;
     cursor: number;
@@ -10,17 +13,37 @@ export type HistoricalBackfillResult = {
     tailRepairedEvents: number;
     totalEvents: number;
     truncated: boolean;
+    head?: HistoricalSessionHead;
 };
 export declare function handleCreateSession(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleImportHistoricalSession(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleListHistoricalSessions(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
-export declare function resumeSession(ws: WebSocket, config: DaemonConfig, sessionId: string, requestId: string, fallback?: SessionFallback, announceSuccess?: boolean): Promise<SessionState | null>;
+export declare function resumeSession(ws: WebSocket, config: DaemonConfig, sessionId: string, requestId: string, fallback?: SessionFallback, announceSuccess?: boolean, syncDirection?: HistoricalBackfillMode): Promise<SessionState | null>;
 export declare function usesAuthoritativeTranscript(session: SessionState): boolean;
 export declare function replaceAuthoritativeTranscript(ws: WebSocket, config: DaemonConfig, session: SessionState, runtimeSessionId?: string | undefined, input?: {
     currentHead?: string;
     lastTurnId?: string;
+    replacementKind?: "command" | "sync";
+    requestId?: string;
     status?: "completed" | "cancelled" | "failed";
     strict?: boolean;
 }): Promise<HistoricalBackfillResult>;
+export declare function planAppendOnlyHistoricalBackfill<T extends {
+    turnId: string;
+}>(historicalEvents: T[], previousBackfill: HistoricalBackfillState | undefined, direction?: HistoricalBackfillMode, maxEvents?: number): {
+    cursor: number;
+    olderWindow: {
+        events: T[];
+        nextCursor: number;
+        startIndex: number;
+    };
+    status: HistoricalBackfillStatus;
+    tailWindow: {
+        events: T[];
+        startIndex: number;
+    };
+    truncated: boolean;
+};
 export declare function handleResume(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleClose(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export {};