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

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

@@ -16,7 +16,7 @@ export async function handleRemote({ domain, action, positional, flags }) {
                 return true;
             }
             for (const device of result.devices) {
-                const state = device.revoked ? "revoked" : "active";
+                const state = device.revoked ? "revoked" : device.online === false ? "offline" : "online";
                 const current = device.current ? " current" : "";
                 console.log(`${device.deviceId}  ${device.kind}  ${state}${current}  ${displayName(device)}`);
             }
@@ -34,7 +34,8 @@ export async function handleRemote({ domain, action, positional, flags }) {
                 kind: device.kind,
                 current: device.current,
                 revoked: device.revoked,
-                lastSeen: device.revokedAt ?? device.createdAt,
+                online: device.online,
+                lastSeen: device.lastSeen ?? device.revokedAt ?? device.createdAt,
                 ...(device.machineId ? { machineId: device.machineId } : {}),
             })),
         });
@@ -138,6 +139,13 @@ export async function handleRemote({ domain, action, positional, flags }) {
         ok("remote.revoke", await new ControllerClient(config).revokeDevice(deviceId));
         return true;
     }
+    if (domain === "remote" && action === "rename") {
+        const config = await readConfig(flags);
+        const deviceId = requirePositional(positional[0], "deviceId");
+        const name = requireString(flags, "name");
+        ok("remote.rename", await new ControllerClient(config).renameDevice(deviceId, name));
+        return true;
+    }
     return false;
 }
 //# sourceMappingURL=remote.js.map

package/apps/cli/dist/commands/schedule.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleSchedule({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

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

@@ -0,0 +1,273 @@
+import { CliError, ControllerClient, ok, readConfig, readPromptTextFile, requirePositional, wantsJson, } from "./lib/index.js";
+export async function handleSchedule({ domain, action, positional, flags }) {
+    if (domain !== "schedule")
+        return false;
+    if (action === "create") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const sessionId = typeof flags.session === "string" && flags.session.trim() ? flags.session.trim() : undefined;
+        const machineId = await resolveScheduleMachineId(client, flags, sessionId);
+        const schedule = parseScheduleSpec(flags);
+        const target = parseScheduleTarget(flags, sessionId);
+        const execution = parseChoice(flags.execution, "execution", ["continue", "isolated"]) ?? "continue";
+        const memoryMode = parseScheduleMemoryMode(flags.memory ?? flags["memory-mode"]) ?? "inherit";
+        const prompt = typeof flags.prompt === "string"
+            ? flags.prompt
+            : typeof flags["prompt-file"] === "string"
+                ? await readPromptTextFile(flags["prompt-file"])
+                : "";
+        if (!prompt.trim())
+            throw new CliError("Missing --prompt or --prompt-file", "MISSING_ARGUMENT");
+        const scheduleInput = {
+            ...(typeof flags.name === "string" ? { name: flags.name } : {}),
+            ...(sessionId ? { sessionId, sourceSessionId: sessionId } : {}),
+            prompt,
+            schedule,
+            target,
+            execution,
+            memoryMode,
+            stopOn: parseStopOn(flags["stop-on"]),
+        };
+        if (schedule.type === "oneshot")
+            scheduleInput.dueAt = schedule.runAt;
+        const result = await client.schedule({
+            machineId,
+            action: "create",
+            schedule: scheduleInput,
+        });
+        ok("schedule.create", { schedule: compactSchedule(result.schedule) });
+        return true;
+    }
+    if (action === "list") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveScheduleMachineId(client, flags);
+        const result = await client.schedule({ machineId, action: "list" });
+        const schedules = result.schedules ?? [];
+        if (!wantsJson(flags)) {
+            if (schedules.length === 0)
+                console.log("No schedules.");
+            else
+                for (const schedule of schedules) {
+                    const preview = schedule.previewRunAt?.length ? `  preview:${schedule.previewRunAt.join(",")}` : "";
+                    console.log(`${schedule.id}  ${schedule.status}  ${cadenceLabel(schedule)}  next:${schedule.nextRunAt ?? "manual"}  source:${schedule.sourceSessionId ?? schedule.sessionId ?? "pending"}${preview}`);
+                }
+            return true;
+        }
+        ok("schedule.list", { machineId, schedules: schedules.map(compactSchedule) });
+        return true;
+    }
+    if (action === "show") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
+        const result = await client.schedule({
+            machineId,
+            action: "show",
+            scheduleId,
+        });
+        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 scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
+        const result = await client.schedule({ machineId, action, 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 scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
+        const result = await client.schedule({ machineId, action: "run", scheduleId });
+        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 scheduleId = requirePositional(positional[0], "scheduleId");
+        const machineId = await resolveScheduleOwnerMachineId(client, flags, scheduleId);
+        const result = await client.schedule({ machineId, action: "history", scheduleId });
+        ok("schedule.history", { machineId, scheduleId: result.scheduleId ?? scheduleId, runs: result.history ?? [] });
+        return true;
+    }
+    if (action === "run-due") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveScheduleMachineId(client, flags);
+        const result = await client.schedule({ machineId, action: "runDue" });
+        ok("schedule.run-due", { machineId, runs: result.runs ?? [] });
+        return true;
+    }
+    if (action === "run-missed") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        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", { machineId, scheduleId: result.scheduleId ?? scheduleId, run: result.run });
+        return true;
+    }
+    return false;
+}
+async function resolveScheduleMachineId(client, flags, sessionId) {
+    if (typeof flags.machine === "string" && flags.machine.length > 0)
+        return flags.machine;
+    if (sessionId) {
+        const session = await client.getSession(sessionId);
+        if (session)
+            return session.machineId;
+    }
+    const snapshot = await client.snapshot();
+    const machine = snapshot.machines.find((item) => item.online) ?? snapshot.machines[0];
+    if (!machine)
+        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()))
+        throw new CliError("Invalid --at date", "INVALID_ARGUMENT");
+    return date.toISOString();
+}
+function parseScheduleSpec(flags) {
+    if (flags.manual === true)
+        return { type: "manual" };
+    if (typeof flags.cron === "string" && flags.cron.trim()) {
+        return {
+            type: "cron",
+            expr: flags.cron.trim(),
+            ...(typeof flags.timezone === "string" && flags.timezone.trim() ? { timezone: flags.timezone.trim() } : {}),
+        };
+    }
+    if (typeof flags["every-ms"] === "string" || typeof flags.every === "string") {
+        const raw = typeof flags["every-ms"] === "string" ? flags["every-ms"] : typeof flags.every === "string" ? flags.every : "";
+        const everyMs = parseIntervalMs(raw);
+        return { type: "interval", everyMs };
+    }
+    if (typeof flags.at === "string" && flags.at.trim())
+        return { type: "oneshot", runAt: parseScheduleDueAt(flags.at) };
+    return { type: "manual" };
+}
+function parseScheduleTarget(flags, sessionId) {
+    if (sessionId)
+        return { type: "sourceSession", sourceSessionId: sessionId };
+    const cwd = typeof flags.cwd === "string" && flags.cwd.trim() ? flags.cwd.trim() : process.cwd();
+    const agent = typeof flags.agent === "string" && flags.agent.trim() ? flags.agent.trim() : "codex";
+    const machineId = typeof flags.machine === "string" && flags.machine.trim() ? flags.machine.trim() : undefined;
+    return { type: "project", cwd, agent, ...(machineId ? { machineId } : {}) };
+}
+function parseIntervalMs(value) {
+    const trimmed = value.trim();
+    const numeric = Number(trimmed);
+    if (Number.isFinite(numeric) && numeric > 0)
+        return Math.floor(numeric);
+    const match = trimmed.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/i);
+    if (!match)
+        throw new CliError("Invalid --every value; use milliseconds or 5m/1h style duration", "INVALID_ARGUMENT");
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const multiplier = unit === "ms" ? 1 : unit === "s" ? 1_000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000;
+    return Math.max(1, Math.floor(amount * multiplier));
+}
+function parseChoice(value, name, choices) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    if (choices.includes(value))
+        return value;
+    throw new CliError(`Invalid --${name}; expected ${choices.join("|")}`, "INVALID_ARGUMENT");
+}
+function parseScheduleMemoryMode(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/-/g, "");
+    if (normalized === "inherit" || normalized === "off" || normalized === "readonly" || normalized === "readwrite")
+        return normalized;
+    throw new CliError("Invalid --memory; expected inherit|off|readonly|readwrite|read-only|read-write", "INVALID_ARGUMENT");
+}
+function parseStopOn(value) {
+    if (typeof value !== "string" || !value.trim())
+        return ["blocked", "failed", "permission"];
+    const allowed = new Set(["blocked", "failed", "permission"]);
+    const parsed = value.split(",").map((item) => item.trim()).filter(Boolean);
+    if (parsed.length === 0 || parsed.some((item) => !allowed.has(item))) {
+        throw new CliError("Invalid --stop-on; expected comma-separated blocked,failed,permission", "INVALID_ARGUMENT");
+    }
+    return parsed;
+}
+function cadenceLabel(schedule) {
+    const spec = schedule.schedule ?? (schedule.dueAt ? { type: "oneshot", runAt: schedule.dueAt } : { type: "manual" });
+    if (spec.type === "manual")
+        return "manual";
+    if (spec.type === "oneshot")
+        return `once:${spec.runAt}`;
+    if (spec.type === "interval")
+        return `interval:${spec.everyMs}ms`;
+    return `cron:${spec.expr}`;
+}
+function compactSchedule(schedule) {
+    if (!schedule)
+        return undefined;
+    return {
+        id: schedule.id,
+        name: schedule.name,
+        sessionId: schedule.sessionId,
+        sourceSessionId: schedule.sourceSessionId,
+        target: schedule.target,
+        schedule: schedule.schedule,
+        execution: schedule.execution,
+        memoryMode: schedule.memoryMode,
+        stopOn: schedule.stopOn,
+        dueAt: schedule.dueAt,
+        nextRunAt: schedule.nextRunAt,
+        previewRunAt: schedule.previewRunAt,
+        status: schedule.status,
+        runCount: schedule.runCount ?? schedule.runs.length,
+        lastRun: schedule.lastRun ?? schedule.runs[0],
+        runs: schedule.runs,
+    };
+}
+//# sourceMappingURL=schedule.js.map