@cydm/happy-elves 0.1.0-beta.244 → 0.1.0-beta.247

package/apps/cli/dist/commands/lib/usage.js

@@ -149,7 +149,8 @@ Session prompts can run memory off, readonly, or readwrite; readwrite writes dai
 
 Schedule v1 is daemon-local repeat automation. Runs use normal Relay admission
 with deterministic requestId/turnId per occurrence. Offline due times are marked
-missed and are never auto-caught-up.
+missed and are never auto-caught-up. Commands that take a scheduleId auto-locate
+the owning online daemon when --machine is omitted.
 `,
     loop: `Usage:
   happy-elves loop create <sessionId> [--every 15m] (--prompt <text> | --prompt-file <path>) [--stop-on blocked] --json

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

@@ -60,40 +60,41 @@ export async function handleSchedule({ domain, action, positional, flags }) {
     if (action === "show") {
         const config = await readConfig(flags);
         const client = new ControllerClient(config);
-        const machineId = await resolveScheduleMachineId(client, flags);
+        const scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
         const result = await client.schedule({
             machineId,
             action: "show",
-            scheduleId: requirePositional(positional[0], "scheduleId"),
+            scheduleId,
         });
-        ok("schedule.show", { schedule: result.schedule });
+        ok("schedule.show", { machineId, schedule: result.schedule });
         return true;
     }
     if (action === "pause" || action === "resume" || action === "delete") {
         const config = await readConfig(flags);
         const client = new ControllerClient(config);
-        const machineId = await resolveScheduleMachineId(client, flags);
         const scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
         const result = await client.schedule({ machineId, action, scheduleId });
-        ok(`schedule.${action}`, { schedule: compactSchedule(result.schedule), scheduleId: result.scheduleId ?? scheduleId });
+        ok(`schedule.${action}`, { machineId, schedule: compactSchedule(result.schedule), scheduleId: result.scheduleId ?? scheduleId });
         return true;
     }
     if (action === "run" || action === "run-now") {
         const config = await readConfig(flags);
         const client = new ControllerClient(config);
-        const machineId = await resolveScheduleMachineId(client, flags);
         const scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
         const result = await client.schedule({ machineId, action: "run", scheduleId });
-        ok("schedule.run", { scheduleId: result.scheduleId ?? scheduleId, run: result.run });
+        ok("schedule.run", { machineId, scheduleId: result.scheduleId ?? scheduleId, run: result.run });
         return true;
     }
     if (action === "history") {
         const config = await readConfig(flags);
         const client = new ControllerClient(config);
-        const machineId = await resolveScheduleMachineId(client, flags);
         const scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
         const result = await client.schedule({ machineId, action: "history", scheduleId });
-        ok("schedule.history", { scheduleId: result.scheduleId ?? scheduleId, runs: result.history ?? [] });
+        ok("schedule.history", { machineId, scheduleId: result.scheduleId ?? scheduleId, runs: result.history ?? [] });
         return true;
     }
     if (action === "run-due") {
@@ -107,11 +108,11 @@ export async function handleSchedule({ domain, action, positional, flags }) {
     if (action === "run-missed") {
         const config = await readConfig(flags);
         const client = new ControllerClient(config);
-        const machineId = await resolveScheduleMachineId(client, flags);
         const scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
         const occurrenceId = requirePositional(positional[1], "occurrenceId");
         const result = await client.schedule({ machineId, action: "runMissed", scheduleId, occurrenceId });
-        ok("schedule.run-missed", { scheduleId: result.scheduleId ?? scheduleId, run: result.run });
+        ok("schedule.run-missed", { machineId, scheduleId: result.scheduleId ?? scheduleId, run: result.run });
         return true;
     }
     return false;
@@ -130,6 +131,42 @@ async function resolveScheduleMachineId(client, flags, sessionId) {
         throw new CliError("No daemon machine is available; pass --machine <machineId>", "MACHINE_NOT_FOUND");
     return machine.id;
 }
+async function resolveScheduleOwnerMachineId(client, flags, scheduleId) {
+    if (typeof flags.machine === "string" && flags.machine.length > 0)
+        return flags.machine;
+    const snapshot = await client.snapshot();
+    const machines = snapshot.machines.filter((machine) => machine.online);
+    if (machines.length === 0) {
+        throw new CliError(`Schedule ${scheduleId} cannot be located because no daemon machine is online; pass --machine <machineId> after starting the target daemon`, "MACHINE_NOT_FOUND");
+    }
+    const checks = await Promise.all(machines.map(async (machine) => {
+        try {
+            const result = await client.schedule({ machineId: machine.id, action: "list" });
+            return {
+                machineId: machine.id,
+                found: (result.schedules ?? []).some((schedule) => schedule.id === scheduleId),
+            };
+        }
+        catch (error) {
+            return {
+                machineId: machine.id,
+                found: false,
+                error,
+            };
+        }
+    }));
+    const matches = checks.filter((check) => check.found);
+    if (matches.length === 1)
+        return matches[0].machineId;
+    if (matches.length > 1) {
+        throw new CliError(`Schedule ${scheduleId} exists on multiple online daemons (${matches.map((match) => match.machineId).join(", ")}); pass --machine <machineId>`, "SCHEDULE_OWNER_AMBIGUOUS");
+    }
+    const failedChecks = checks.filter((check) => check.error);
+    const unavailable = failedChecks.length > 0
+        ? ` ${failedChecks.length}/${machines.length} online daemon(s) did not respond to schedule list.`
+        : "";
+    throw new CliError(`Schedule not found on any online daemon: ${scheduleId}.${unavailable} Pass --machine <machineId> if the owning daemon is offline or not visible.`, "SCHEDULE_NOT_FOUND");
+}
 function parseScheduleDueAt(value) {
     const date = new Date(value);
     if (!Number.isFinite(date.getTime()))

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.244",
+  "version": "0.1.0-beta.247",
   "private": true,
   "type": "module"
 }

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

@@ -8,6 +8,7 @@ export declare function runDueSchedulesNow(config: DaemonConfig): Promise<Array<
     run: ScheduleRunRecord;
 }>>;
 export declare function occurrenceIdFor(schedule: Pick<ScheduleRecord, "id" | "dueAt" | "nextRunAt">, dueAt?: string): string;
+export declare function __testWithActiveScheduleOccurrence<T>(scheduleId: string, occurrenceId: string, action: () => Promise<T> | T): Promise<T>;
 export declare function nextRunAtForSchedule(schedule: Pick<ScheduleRecord, "schedule" | "dueAt" | "runs">, afterMs?: number): string | undefined;
 export declare function nextRunPreviewForSchedule(schedule: Pick<ScheduleRecord, "id" | "schedule" | "dueAt" | "runs">, count?: number, afterMs?: number): string[];
 export declare function settleScheduleTurnTerminal(input: {

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

@@ -20,6 +20,8 @@ export async function tickSchedules(config, onlineSinceMs) {
         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);
@@ -64,6 +66,8 @@ export async function runDueSchedulesNow(config) {
         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 });
     }
@@ -79,6 +83,22 @@ 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")
@@ -162,7 +182,7 @@ export async function settleScheduleTurnTerminal(input) {
     return settledRun;
 }
 async function runScheduleOccurrence(config, schedule, occurrenceId, dueAt, reason) {
-    const key = `${schedule.id}:${occurrenceId}`;
+    const key = activeScheduleRunKey(schedule.id, occurrenceId);
     if (activeScheduleRuns.has(key)) {
         throw new Error("Schedule occurrence is already running");
     }

package/apps/daemon/package.json

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

package/package.json

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

package/packages/client/dist/transport.js

@@ -101,11 +101,14 @@ export async function sendCommand(context, command, waitForDone = false, timeout
     const targetTurnId = "turnId" in command ? command.turnId : undefined;
     return await new Promise((resolve, reject) => {
         let settled = false;
+        let retainedPoller;
         const finish = (result) => {
             if (settled)
                 return;
             settled = true;
             globalThis.clearTimeout(timer);
+            if (retainedPoller)
+                globalThis.clearInterval(retainedPoller);
             ws.close();
             resolve(result);
         };
@@ -114,6 +117,8 @@ export async function sendCommand(context, command, waitForDone = false, timeout
                 return;
             settled = true;
             globalThis.clearTimeout(timer);
+            if (retainedPoller)
+                globalThis.clearInterval(retainedPoller);
             ws.close();
             reject(error);
         };
@@ -125,7 +130,11 @@ export async function sendCommand(context, command, waitForDone = false, timeout
             dispatch: ackedDispatch,
             events,
         });
+        let retainedLookupInFlight = false;
         const resolveFromRetainedTurnIfDone = (sessionId, turnId) => {
+            if (retainedLookupInFlight)
+                return;
+            retainedLookupInFlight = true;
             void context.sessionEvents(sessionId, { limit: 1000 })
                 .then(({ events: retainedEvents }) => retainedEvents.filter((event) => event.turnId === turnId))
                 .then(async (turnEvents) => {
@@ -142,7 +151,19 @@ export async function sendCommand(context, command, waitForDone = false, timeout
                 events.sort((left, right) => left.id - right.id);
                 finish(commandResultFromAck());
             })
-                .catch(() => { });
+                .catch(() => { })
+                .finally(() => {
+                retainedLookupInFlight = false;
+            });
+        };
+        const startRetainedTurnPoller = (sessionId, turnId) => {
+            if (retainedPoller)
+                return;
+            resolveFromRetainedTurnIfDone(sessionId, turnId);
+            retainedPoller = globalThis.setInterval(() => {
+                if (!settled)
+                    resolveFromRetainedTurnIfDone(sessionId, turnId);
+            }, 2_000);
         };
         const timer = globalThis.setTimeout(() => {
             fail(new ControllerClientError("Timed out waiting for command result", "COMMAND_TIMEOUT", {
@@ -182,7 +203,7 @@ export async function sendCommand(context, command, waitForDone = false, timeout
                     finish(commandResultFromAck());
                 }
                 else if (targetSessionId && targetTurnId) {
-                    resolveFromRetainedTurnIfDone(targetSessionId, targetTurnId);
+                    startRetainedTurnPoller(targetSessionId, targetTurnId);
                 }
                 return;
             }