@hank-warren/pi-loop 0.7.0 → 0.9.0

package/src/schedule/store.ts

@@ -1,183 +0,0 @@
-/**
- * Persistence for `run` tasks (`~/.pi/agent/loop/schedules.json`) and the
- * single-writer lease that decides which live Pi session is allowed to fire
- * them.
- *
- * The lease exists because headless tasks are shared state: every open
- * session reads the same file, and without arbitration a task scheduled for
- * 09:00 fires once per session that happens to be running. A lockfile holding
- * a pid and a heartbeat is enough — a holder that dies stops renewing, and
- * the next session takes over after the stale window. Deliberately not a real
- * distributed lock: the failure it must prevent is *duplicate work*, and the
- * worst case it can produce is one skipped tick.
- *
- * Everything here is best-effort. A read-only home directory means "no
- * headless scheduling", never a crash.
- */
-
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { randomUUID } from "node:crypto";
-import { dirname, join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { normalizeTask, type ScheduledTask } from "./model.js";
-
-export const SCHEDULES_FILE = "schedules.json";
-export const LEASE_FILE = "schedules.lease";
-export const RUNS_DIR = "runs";
-
-/** A lease older than this is assumed abandoned. */
-export const LEASE_STALE_MS = 90_000;
-/** How often the holder refreshes it. */
-export const LEASE_HEARTBEAT_MS = 30_000;
-
-export interface SchedulePaths {
-	dir: string;
-	schedules: string;
-	lease: string;
-	runs: string;
-}
-
-export function schedulePaths(agentDir = getAgentDir()): SchedulePaths {
-	const dir = join(agentDir, "loop");
-	return {
-		dir,
-		schedules: join(dir, SCHEDULES_FILE),
-		lease: join(dir, LEASE_FILE),
-		runs: join(dir, RUNS_DIR),
-	};
-}
-
-/** Read persisted tasks, fail-open: an unreadable file means no tasks. */
-export function readTasks(paths: SchedulePaths): ScheduledTask[] {
-	let contents: string;
-	try {
-		contents = readFileSync(paths.schedules, "utf8");
-	} catch {
-		return [];
-	}
-	try {
-		const parsed: unknown = JSON.parse(contents);
-		if (!Array.isArray(parsed)) return [];
-		// One malformed entry drops itself, not the whole schedule.
-		return parsed
-			.map((value) => normalizeTask(value))
-			.filter((task): task is ScheduledTask => task !== undefined);
-	} catch {
-		return [];
-	}
-}
-
-/** Atomically replace the persisted tasks. Returns a failure reason, if any. */
-export function writeTasks(paths: SchedulePaths, tasks: ScheduledTask[]): string | undefined {
-	const document = `${JSON.stringify(tasks, null, 2)}\n`;
-	const temporary = join(paths.dir, `.${SCHEDULES_FILE}.${randomUUID()}.tmp`);
-	try {
-		mkdirSync(paths.dir, { recursive: true });
-		writeFileSync(temporary, document, { encoding: "utf8", flag: "wx" });
-		renameSync(temporary, paths.schedules);
-		return undefined;
-	} catch (error) {
-		return error instanceof Error ? error.message : String(error);
-	} finally {
-		try {
-			rmSync(temporary, { force: true });
-		} catch {
-			// Best-effort cleanup must not replace the write result.
-		}
-	}
-}
-
-export interface LeaseRecord {
-	pid: number;
-	heartbeat: number;
-	owner: string;
-}
-
-/**
- * Take or renew the lease. Returns true when this process may fire headless
- * tasks. `owner` identifies this runtime so a restarted process with a reused
- * pid cannot mistake someone else's lease for its own.
- */
-export function acquireLease(
-	paths: SchedulePaths,
-	owner: string,
-	now: number,
-	pid: number = process.pid,
-): boolean {
-	const current = readLease(paths);
-	if (current && current.owner !== owner) {
-		const fresh = now - current.heartbeat < LEASE_STALE_MS;
-		if (fresh && isProcessAlive(current.pid)) return false;
-	}
-	return writeLease(paths, { pid, heartbeat: now, owner });
-}
-
-/** Release the lease if this owner holds it. */
-export function releaseLease(paths: SchedulePaths, owner: string): void {
-	const current = readLease(paths);
-	if (!current || current.owner !== owner) return;
-	try {
-		rmSync(paths.lease, { force: true });
-	} catch {
-		// A lease we cannot delete simply goes stale.
-	}
-}
-
-export function readLease(paths: SchedulePaths): LeaseRecord | undefined {
-	try {
-		const parsed: unknown = JSON.parse(readFileSync(paths.lease, "utf8"));
-		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
-		const record = parsed as Record<string, unknown>;
-		if (
-			typeof record.pid !== "number" ||
-			typeof record.heartbeat !== "number" ||
-			typeof record.owner !== "string" ||
-			!record.owner
-		) {
-			return undefined;
-		}
-		return { pid: record.pid, heartbeat: record.heartbeat, owner: record.owner };
-	} catch {
-		return undefined;
-	}
-}
-
-function writeLease(paths: SchedulePaths, lease: LeaseRecord): boolean {
-	const temporary = join(dirname(paths.lease), `.${LEASE_FILE}.${randomUUID()}.tmp`);
-	try {
-		mkdirSync(paths.dir, { recursive: true });
-		writeFileSync(temporary, `${JSON.stringify(lease)}\n`, { encoding: "utf8", flag: "wx" });
-		renameSync(temporary, paths.lease);
-		return true;
-	} catch {
-		return false;
-	} finally {
-		try {
-			rmSync(temporary, { force: true });
-		} catch {
-			// Best-effort.
-		}
-	}
-}
-
-function isProcessAlive(pid: number): boolean {
-	if (!Number.isSafeInteger(pid) || pid <= 0) return false;
-	try {
-		// Signal 0 tests for existence without delivering anything.
-		process.kill(pid, 0);
-		return true;
-	} catch (error) {
-		// EPERM means it exists and belongs to someone else.
-		return isNodeError(error) && error.code === "EPERM";
-	}
-}
-
-function isNodeError(error: unknown): error is NodeJS.ErrnoException {
-	return error instanceof Error && "code" in error;
-}
-
-/** Where a headless run's output is logged. */
-export function runLogPath(paths: SchedulePaths, taskId: string, at: number): string {
-	const stamp = new Date(at).toISOString().replace(/[:.]/g, "-");
-	return join(paths.runs, taskId, `${stamp}.log`);
-}