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

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

@@ -0,0 +1,547 @@
+import { createHash } from "node:crypto";
+import { encryptJson, } from "../../../../packages/shared/dist/index.js";
+import { admitMachineCreateSession, admitMachinePrompt } from "../relay/admission.js";
+import { sessions, sessionTurns } from "../state.js";
+import { readScheduleStore, updateScheduleStore } from "./store.js";
+const activeScheduleRuns = new Set();
+const defaultStopOn = ["blocked", "failed", "permission"];
+export async function tickSchedules(config, onlineSinceMs) {
+    const store = await readScheduleStore();
+    const nowMs = Date.now();
+    for (const schedule of store.schedules) {
+        if (schedule.status !== "active")
+            continue;
+        const dueAt = schedule.nextRunAt ?? nextRunAtForSchedule(schedule, nowMs - 1);
+        if (!dueAt)
+            continue;
+        const occurrenceId = occurrenceIdFor(schedule, dueAt);
+        if (schedule.runs.some((run) => run.occurrenceId === occurrenceId))
+            continue;
+        const dueMs = Date.parse(dueAt);
+        if (!Number.isFinite(dueMs) || dueMs > nowMs)
+            continue;
+        if (isScheduleOccurrenceActive(schedule.id, occurrenceId))
+            continue;
+        if (dueMs < onlineSinceMs) {
+            const run = scheduleRun(schedule, occurrenceId, dueAt, "missed", "daemon was offline at due time");
+            await recordScheduleRun(schedule.id, run);
+            continue;
+        }
+        void runScheduleOccurrence(config, schedule, occurrenceId, dueAt, "due").catch(async (error) => {
+            const run = scheduleRun(schedule, occurrenceId, dueAt, "failed", error instanceof Error ? error.message : String(error));
+            await recordScheduleRun(schedule.id, run);
+        });
+    }
+}
+export async function runMissedScheduleOccurrence(config, schedule, occurrenceId) {
+    const existing = schedule.runs.find((run) => run.occurrenceId === occurrenceId);
+    if (!existing || existing.status !== "missed") {
+        const admitted = schedule.runs.find((run) => run.occurrenceId === occurrenceId && run.status === "admitted");
+        if (admitted)
+            return admitted;
+        throw new Error("Missed occurrence not found");
+    }
+    return await runScheduleOccurrence(config, schedule, occurrenceId, existing.dueAt, "manual");
+}
+export async function runScheduleNow(config, schedule) {
+    if (schedule.status === "deleted")
+        throw new Error("Schedule is deleted");
+    const dueAt = new Date().toISOString();
+    const occurrenceId = stableScheduleId("occ_manual", schedule.id, dueAt);
+    return await runScheduleOccurrence(config, schedule, occurrenceId, dueAt, "manual");
+}
+export async function runDueSchedulesNow(config) {
+    const store = await readScheduleStore();
+    const nowMs = Date.now();
+    const results = [];
+    for (const schedule of store.schedules) {
+        if (schedule.status !== "active")
+            continue;
+        const dueAt = schedule.nextRunAt ?? nextRunAtForSchedule(schedule, nowMs - 1);
+        if (!dueAt)
+            continue;
+        const occurrenceId = occurrenceIdFor(schedule, dueAt);
+        if (schedule.runs.some((run) => run.occurrenceId === occurrenceId))
+            continue;
+        const dueMs = Date.parse(dueAt);
+        if (!Number.isFinite(dueMs) || dueMs > nowMs)
+            continue;
+        if (isScheduleOccurrenceActive(schedule.id, occurrenceId))
+            continue;
+        const run = await runScheduleOccurrence(config, schedule, occurrenceId, dueAt, "manual");
+        results.push({ scheduleId: schedule.id, run });
+    }
+    return results;
+}
+export function occurrenceIdFor(schedule, dueAt) {
+    const occurrenceDueAt = dueAt ?? schedule.nextRunAt ?? schedule.dueAt;
+    if (!occurrenceDueAt)
+        throw new Error("Schedule has no due occurrence");
+    return stableScheduleId("occ", schedule.id, occurrenceDueAt);
+}
+function stableScheduleId(prefix, ...parts) {
+    const hash = createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 32);
+    return `${prefix}_${hash}`;
+}
+function activeScheduleRunKey(scheduleId, occurrenceId) {
+    return `${scheduleId}:${occurrenceId}`;
+}
+function isScheduleOccurrenceActive(scheduleId, occurrenceId) {
+    return activeScheduleRuns.has(activeScheduleRunKey(scheduleId, occurrenceId));
+}
+export async function __testWithActiveScheduleOccurrence(scheduleId, occurrenceId, action) {
+    const key = activeScheduleRunKey(scheduleId, occurrenceId);
+    activeScheduleRuns.add(key);
+    try {
+        return await action();
+    }
+    finally {
+        activeScheduleRuns.delete(key);
+    }
+}
+export function nextRunAtForSchedule(schedule, afterMs = Date.now()) {
+    const spec = normalizedSpec(schedule.schedule, schedule.dueAt);
+    if (spec.type === "manual")
+        return undefined;
+    if (spec.type === "oneshot") {
+        if (schedule.runs.some(runConsumesOccurrence))
+            return undefined;
+        return new Date(spec.runAt).toISOString();
+    }
+    if (spec.type === "interval") {
+        const lastDueMs = latestDueMs(schedule.runs) ?? afterMs;
+        return new Date(Math.max(afterMs, lastDueMs) + spec.everyMs).toISOString();
+    }
+    return nextCronRunAt(spec, afterMs);
+}
+export function nextRunPreviewForSchedule(schedule, count = 3, afterMs = Date.now()) {
+    const spec = normalizedSpec(schedule.schedule, schedule.dueAt);
+    if (spec.type === "manual")
+        return [];
+    const runs = [...schedule.runs];
+    const preview = [];
+    let cursor = afterMs;
+    for (let index = 0; index < count; index += 1) {
+        const next = nextRunAtForSchedule({ schedule: schedule.schedule, dueAt: schedule.dueAt, runs }, cursor);
+        if (!next)
+            break;
+        preview.push(next);
+        if (spec.type === "oneshot")
+            break;
+        runs.unshift({
+            occurrenceId: stableScheduleId("occ_preview", schedule.id, next),
+            dueAt: next,
+            requestId: stableScheduleId("sched_req_preview", schedule.id, next),
+            turnId: stableScheduleId("turn_sched_preview", schedule.id, next),
+            status: "scheduled",
+        });
+        cursor = Date.parse(next);
+    }
+    return preview;
+}
+export async function settleScheduleTurnTerminal(input) {
+    let settledRun;
+    const finishedAt = input.finishedAt ?? new Date().toISOString();
+    await updateScheduleStore((store) => {
+        let changed = false;
+        const schedules = store.schedules.map((schedule) => {
+            const existing = schedule.runs.find((run) => run.requestId === input.requestId ||
+                run.turnId === input.turnId);
+            if (!existing)
+                return schedule;
+            if (existing.status === "completed" || existing.status === "failed") {
+                settledRun = existing;
+                return schedule;
+            }
+            const status = input.status === "completed" ? "completed" : "failed";
+            const run = {
+                ...existing,
+                status,
+                finishedAt,
+                ...(input.outputPreview !== undefined ? { outputPreview: input.outputPreview } : {}),
+                ...(status === "failed" ? { error: input.error ?? input.status } : input.error ? { error: input.error } : {}),
+            };
+            const runs = [run, ...schedule.runs.filter((item) => item.occurrenceId !== run.occurrenceId)];
+            const spec = normalizedSpec(schedule.schedule, schedule.dueAt);
+            const oneshotCompleted = spec.type === "oneshot" && status === "completed";
+            const failedStop = status === "failed" && (schedule.stopOn ?? [...defaultStopOn]).includes("failed");
+            changed = true;
+            settledRun = run;
+            return {
+                ...schedule,
+                status: oneshotCompleted ? "completed" : failedStop ? "paused" : schedule.status,
+                nextRunAt: nextRunAtForSchedule({ ...schedule, runs }, Date.parse(run.dueAt)),
+                runCount: countScheduleRuns(runs),
+                lastRun: runs[0],
+                runs,
+                updatedAt: finishedAt,
+            };
+        });
+        return changed ? { ...store, schedules } : store;
+    });
+    return settledRun;
+}
+async function runScheduleOccurrence(config, schedule, occurrenceId, dueAt, reason) {
+    const key = activeScheduleRunKey(schedule.id, occurrenceId);
+    if (activeScheduleRuns.has(key)) {
+        throw new Error("Schedule occurrence is already running");
+    }
+    activeScheduleRuns.add(key);
+    try {
+        const executionSession = await resolveScheduleExecutionSession(config, schedule, occurrenceId);
+        const requestId = stableScheduleId("sched_req", schedule.id, occurrenceId);
+        const turnId = stableScheduleId("turn_sched", schedule.id, occurrenceId);
+        if (sessionTurns.activeTurnId(executionSession.sessionId)) {
+            const run = {
+                ...scheduleRun(schedule, occurrenceId, dueAt, "blocked", "target session already has a running turn"),
+                sessionId: executionSession.sessionId,
+                sourceSessionId: executionSession.sourceSessionId,
+            };
+            await recordScheduleRun(schedule.id, run);
+            return run;
+        }
+        let sent;
+        try {
+            sent = await admitMachinePrompt(config, {
+                requestId,
+                sessionId: executionSession.sessionId,
+                turnId,
+                encryptedPrompt: await encryptJson(config.accountSecret, `schedule:${schedule.id}:${occurrenceId}`, {
+                    type: "user_prompt",
+                    text: schedule.prompt,
+                }),
+                encryptedMemoryOptions: executionSession.memoryMode === "inherit"
+                    ? undefined
+                    : await encryptJson(config.accountSecret, `schedule:${schedule.id}:${occurrenceId}:memory`, {
+                        mode: executionSession.memoryMode,
+                        projectKey: scheduleMemoryProjectKey(config, schedule, executionSession.sourceSessionId ?? executionSession.sessionId),
+                        topN: 3,
+                    }),
+                permissionMode: permissionModeForSchedule(schedule),
+            });
+        }
+        catch (error) {
+            if (errorCode(error) === "SESSION_BUSY") {
+                const run = {
+                    ...scheduleRun(schedule, occurrenceId, dueAt, "blocked", "relay rejected schedule run because the target session is busy"),
+                    sessionId: executionSession.sessionId,
+                    sourceSessionId: executionSession.sourceSessionId,
+                };
+                await recordScheduleRun(schedule.id, run);
+                return run;
+            }
+            throw error;
+        }
+        const run = {
+            occurrenceId,
+            dueAt,
+            requestId,
+            turnId: sent.turnId ?? turnId,
+            status: "admitted",
+            sessionId: sent.sessionId ?? executionSession.sessionId,
+            sourceSessionId: executionSession.sourceSessionId,
+            admittedAt: new Date().toISOString(),
+            reason,
+        };
+        await recordScheduleRun(schedule.id, run);
+        return run;
+    }
+    finally {
+        activeScheduleRuns.delete(key);
+    }
+}
+async function recordScheduleRun(scheduleId, run) {
+    await updateScheduleStore((store) => ({
+        ...store,
+        schedules: store.schedules.map((schedule) => {
+            if (schedule.id !== scheduleId)
+                return schedule;
+            const runs = [run, ...schedule.runs.filter((item) => item.occurrenceId !== run.occurrenceId)];
+            const nextRunAt = nextRunAtForSchedule({ ...schedule, runs }, Date.parse(run.dueAt));
+            const completed = normalizedSpec(schedule.schedule, schedule.dueAt).type === "oneshot" && run.status === "completed";
+            const blocked = run.status === "blocked" && (schedule.stopOn ?? [...defaultStopOn]).includes("blocked");
+            return {
+                ...schedule,
+                status: completed ? "completed" : blocked ? "paused" : schedule.status,
+                ...(run.sourceSessionId ? { sourceSessionId: run.sourceSessionId, sessionId: run.sourceSessionId } : {}),
+                ...(run.sourceSessionId && schedule.target?.type === "project"
+                    ? { target: { ...schedule.target, sourceSessionId: run.sourceSessionId } }
+                    : {}),
+                nextRunAt,
+                runCount: countScheduleRuns(runs),
+                lastRun: runs[0],
+                runs,
+                updatedAt: new Date().toISOString(),
+            };
+        }),
+    }));
+}
+function scheduleRun(schedule, occurrenceId, dueAt, status, reason) {
+    return {
+        occurrenceId,
+        dueAt,
+        requestId: stableScheduleId("sched_req", schedule.id, occurrenceId),
+        turnId: stableScheduleId("turn_sched", schedule.id, occurrenceId),
+        status,
+        reason,
+        sessionId: schedule.sessionId,
+        sourceSessionId: schedule.sourceSessionId,
+        finishedAt: new Date().toISOString(),
+    };
+}
+function runConsumesOccurrence(run) {
+    return run.status === "admitted" ||
+        run.status === "completed" ||
+        run.status === "failed" ||
+        run.status === "blocked" ||
+        run.status === "missed";
+}
+function countScheduleRuns(runs) {
+    return runs.filter((run) => run.status === "admitted" ||
+        run.status === "completed" ||
+        run.status === "failed" ||
+        run.status === "blocked").length;
+}
+async function resolveScheduleExecutionSession(config, schedule, occurrenceId) {
+    const source = await ensureSourceSession(config, schedule);
+    const memoryMode = schedule.memoryMode ?? "inherit";
+    if ((schedule.execution ?? "continue") !== "isolated")
+        return { sessionId: source.sessionId, sourceSessionId: source.sessionId, memoryMode };
+    const target = schedule.target;
+    if (target?.type === "project") {
+        const sessionId = stableScheduleId("ses_sched_run", schedule.id, occurrenceId);
+        await admitMachineCreateSession(config, {
+            requestId: stableScheduleId("sched_run_create_req", schedule.id, occurrenceId),
+            sessionId,
+            agent: target.agent,
+            cwd: target.cwd,
+            name: `${schedule.name ?? "Schedule"} run`,
+            encryptedMetadata: await encryptJson(config.accountSecret, `session:${sessionId}:metadata`, {
+                agent: target.agent,
+                cwd: target.cwd,
+                name: `${schedule.name ?? "Schedule"} run`,
+                sourceSessionId: source.sessionId,
+                scheduleId: schedule.id,
+                scheduleExecution: "isolated",
+            }),
+        });
+        return { sessionId, sourceSessionId: source.sessionId, memoryMode };
+    }
+    const sourceState = sessions.get(source.sessionId);
+    if (!sourceState)
+        throw new Error("isolated schedule with source session requires the source session to be loaded on this daemon");
+    const sessionId = stableScheduleId("ses_sched_run", schedule.id, occurrenceId);
+    await admitMachineCreateSession(config, {
+        requestId: stableScheduleId("sched_run_create_req", schedule.id, occurrenceId),
+        sessionId,
+        agent: sourceState.agent,
+        cwd: sourceState.cwd,
+        name: `${schedule.name ?? sourceState.name} run`,
+        encryptedMetadata: await encryptJson(config.accountSecret, `session:${sessionId}:metadata`, {
+            agent: sourceState.agent,
+            cwd: sourceState.cwd,
+            name: `${schedule.name ?? sourceState.name} run`,
+            sourceSessionId: source.sessionId,
+            scheduleId: schedule.id,
+            scheduleExecution: "isolated",
+        }),
+    });
+    return { sessionId, sourceSessionId: source.sessionId, memoryMode };
+}
+async function ensureSourceSession(config, schedule) {
+    const target = schedule.target;
+    if (target?.type === "sourceSession")
+        return { sessionId: target.sourceSessionId };
+    if (schedule.sourceSessionId)
+        return { sessionId: schedule.sourceSessionId };
+    if (schedule.sessionId)
+        return { sessionId: schedule.sessionId };
+    if (target?.type !== "project")
+        throw new Error("Schedule target session is not available");
+    const sourceSessionId = target.sourceSessionId ?? stableScheduleId("ses_sched", schedule.id);
+    await admitMachineCreateSession(config, {
+        requestId: stableScheduleId("sched_create_req", schedule.id),
+        sessionId: sourceSessionId,
+        agent: target.agent,
+        cwd: target.cwd,
+        name: schedule.name ? `Schedule: ${schedule.name}` : "Scheduled automation",
+        encryptedMetadata: await encryptJson(config.accountSecret, `session:${sourceSessionId}:metadata`, {
+            agent: target.agent,
+            cwd: target.cwd,
+            name: schedule.name ? `Schedule: ${schedule.name}` : "Scheduled automation",
+            scheduleId: schedule.id,
+            scheduleOwned: true,
+        }),
+    });
+    await updateScheduleStore((store) => ({
+        ...store,
+        schedules: store.schedules.map((item) => {
+            if (item.id !== schedule.id)
+                return item;
+            return {
+                ...item,
+                sessionId: sourceSessionId,
+                sourceSessionId,
+                target: { ...target, sourceSessionId },
+                updatedAt: new Date().toISOString(),
+            };
+        }),
+    }));
+    return { sessionId: sourceSessionId };
+}
+function normalizedSpec(spec, legacyDueAt) {
+    if (spec)
+        return spec;
+    return legacyDueAt ? { type: "oneshot", runAt: legacyDueAt } : { type: "manual" };
+}
+function latestDueMs(runs) {
+    let latest;
+    for (const run of runs) {
+        const dueMs = Date.parse(run.dueAt);
+        if (!Number.isFinite(dueMs))
+            continue;
+        latest = latest === undefined ? dueMs : Math.max(latest, dueMs);
+    }
+    return latest;
+}
+function scheduleMemoryProjectKey(config, schedule, sessionId) {
+    const target = schedule.target;
+    if (target?.type === "project")
+        return `${target.machineId ?? config.machineId}:${target.cwd}`;
+    return `${sessionId}:schedule`;
+}
+function permissionModeForSchedule(schedule) {
+    return (schedule.stopOn ?? [...defaultStopOn]).includes("permission") ? "approve-reads" : "approve-all";
+}
+function errorCode(error) {
+    return error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+}
+function nextCronRunAt(spec, afterMs) {
+    const fields = parseCron(spec.expr);
+    if (!fields)
+        throw new Error(`Unsupported cron expression: ${spec.expr}`);
+    const timeZoneFormatter = spec.timezone ? cronTimeZoneFormatter(spec.timezone) : undefined;
+    const date = new Date(afterMs);
+    if (timeZoneFormatter) {
+        date.setUTCSeconds(0, 0);
+        date.setUTCMinutes(date.getUTCMinutes() + 1);
+    }
+    else {
+        date.setSeconds(0, 0);
+        date.setMinutes(date.getMinutes() + 1);
+    }
+    for (let i = 0; i < 366 * 24 * 60; i += 1) {
+        const parts = cronDateParts(date, timeZoneFormatter);
+        if (fields.minutes.has(parts.minute) &&
+            fields.hours.has(parts.hour) &&
+            fields.days.has(parts.day) &&
+            fields.months.has(parts.month) &&
+            fields.dows.has(parts.dow)) {
+            return date.toISOString();
+        }
+        if (timeZoneFormatter)
+            date.setUTCMinutes(date.getUTCMinutes() + 1);
+        else
+            date.setMinutes(date.getMinutes() + 1);
+    }
+    return undefined;
+}
+function cronTimeZoneFormatter(timeZone) {
+    try {
+        return new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hour12: false,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+        });
+    }
+    catch {
+        throw new Error(`Invalid cron timezone: ${timeZone}`);
+    }
+}
+function cronDateParts(date, formatter) {
+    if (!formatter) {
+        return {
+            minute: date.getMinutes(),
+            hour: date.getHours(),
+            day: date.getDate(),
+            month: date.getMonth() + 1,
+            dow: date.getDay(),
+        };
+    }
+    const parts = Object.fromEntries(formatter.formatToParts(date).map((part) => [part.type, part.value]));
+    const year = Number(parts.year);
+    const month = Number(parts.month);
+    const day = Number(parts.day);
+    const hour = Number(parts.hour) % 24;
+    const minute = Number(parts.minute);
+    if (![year, month, day, hour, minute].every(Number.isFinite))
+        throw new Error("Cron timezone formatting failed");
+    return {
+        minute,
+        hour,
+        day,
+        month,
+        dow: new Date(Date.UTC(year, month - 1, day)).getUTCDay(),
+    };
+}
+function parseCron(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return undefined;
+    const [minute, hour, day, month, dow] = parts;
+    const minutes = parseCronField(minute, 0, 59);
+    const hours = parseCronField(hour, 0, 23);
+    const days = parseCronField(day, 1, 31);
+    const months = parseCronField(month, 1, 12);
+    const dows = parseCronField(dow, 0, 7);
+    if (!minutes || !hours || !days || !months || !dows)
+        return undefined;
+    if (dows.has(7)) {
+        dows.add(0);
+        dows.delete(7);
+    }
+    return { minutes, hours, days, months, dows };
+}
+function parseCronField(field, min, max) {
+    const values = new Set();
+    for (const part of field.split(",")) {
+        if (part === "*") {
+            for (let value = min; value <= max; value += 1)
+                values.add(value);
+            continue;
+        }
+        const stepMatch = part.match(/^\*\/(\d+)$/);
+        if (stepMatch) {
+            const step = Number(stepMatch[1]);
+            if (!Number.isInteger(step) || step <= 0)
+                return undefined;
+            for (let value = min; value <= max; value += step)
+                values.add(value);
+            continue;
+        }
+        const rangeMatch = part.match(/^(\d+)-(\d+)(?:\/(\d+))?$/);
+        if (rangeMatch) {
+            const start = Number(rangeMatch[1]);
+            const end = Number(rangeMatch[2]);
+            const step = rangeMatch[3] ? Number(rangeMatch[3]) : 1;
+            if (!Number.isInteger(start) || !Number.isInteger(end) || !Number.isInteger(step) || step <= 0 || start < min || end > max || start > end)
+                return undefined;
+            for (let value = start; value <= end; value += step)
+                values.add(value);
+            continue;
+        }
+        const value = Number(part);
+        if (!Number.isInteger(value) || value < min || value > max)
+            return undefined;
+        values.add(value);
+    }
+    return values;
+}
+//# sourceMappingURL=runner.js.map

package/apps/daemon/dist/schedule/store.d.ts

@@ -0,0 +1,9 @@
+import type { ScheduleRecord } from "../../../../packages/shared/dist/index.js";
+export type ScheduleStore = {
+    version: 1;
+    schedules: ScheduleRecord[];
+};
+export declare function readScheduleStore(): Promise<ScheduleStore>;
+export declare function updateScheduleStore(update: (store: ScheduleStore) => ScheduleStore | Promise<ScheduleStore>): Promise<ScheduleStore>;
+export declare function compactSchedules(store: ScheduleStore): ScheduleRecord[];
+export declare function normalizeScheduleRecord(input: unknown): ScheduleRecord | undefined;