cool-workflow 0.1.82 → 0.1.83

package/dist/run-registry/queue.js

@@ -33,15 +33,14 @@ function queueFilePath(host) {
 }
 function loadQueue(host) {
     const file = queueFilePath(host);
+    // Absent => empty queue. A present-but-corrupt queue must FAIL CLOSED rather
+    // than read as empty: silently draining to [] would lose every queued run and
+    // let scheduling/lease ops proceed as if the store were clean. readJson throws
+    // `Invalid JSON in <file>` on a present, unparseable store; let it propagate.
     if (!node_fs_1.default.existsSync(file))
         return [];
-    try {
-        const parsed = (0, state_1.readJson)(file);
-        return Array.isArray(parsed.entries) ? parsed.entries : [];
-    }
-    catch {
-        return [];
-    }
+    const parsed = (0, state_1.readJson)(file);
+    return Array.isArray(parsed.entries) ? parsed.entries : [];
 }
 function saveQueue(host, entries) {
     (0, state_1.writeJson)(queueFilePath(host), { schemaVersion: 1, entries }, { durable: true });

package/dist/run-registry.js

@@ -162,29 +162,36 @@ class RunRegistry {
         return node_path_1.default.join(this.homeRoot, "registry");
     }
     // ---- per-repo overlays (plain files) ------------------------------------
+    // Overlay reads distinguish ABSENT (clean default) from PRESENT-but-corrupt
+    // (fail closed). readJson throws `Invalid JSON in <file>` on a present file
+    // that won't parse; we let that propagate instead of swallowing it. Swallowing
+    // is the absent-vs-corrupt conflation telemetry-ledger.ts flags as the bug that
+    // "let a corrupt overlay verify green" — here it would silently un-archive every
+    // archived run / drop every provenance link. This is authoritative durable state.
+    // A present overlay must parse to a JSON OBJECT. readJson already fails closed
+    // on unparseable bytes; this catches the next shape over: valid JSON that is
+    // `null`, an array, or a scalar. Without it `parsed.archived` throws a cryptic
+    // TypeError (null) or silently reads `undefined` (array) and the whole registry
+    // scan breaks. Fail closed with a clear message instead.
+    requireOverlayObject(parsed, file) {
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`Corrupt overlay ${file}: expected a JSON object, got ${Array.isArray(parsed) ? "array" : parsed === null ? "null" : typeof parsed}`);
+        }
+        return parsed;
+    }
     loadArchiveOverlay(repo) {
         const file = node_path_1.default.join(this.repoRegistryDir(repo), "archive.json");
         if (!node_fs_1.default.existsSync(file))
             return { schemaVersion: 1, archived: {} };
-        try {
-            const parsed = (0, state_1.readJson)(file);
-            return { schemaVersion: 1, archived: parsed.archived || {} };
-        }
-        catch {
-            return { schemaVersion: 1, archived: {} };
-        }
+        const parsed = this.requireOverlayObject((0, state_1.readJson)(file), file);
+        return { schemaVersion: 1, archived: parsed.archived || {} };
     }
     loadProvenanceOverlay(repo) {
         const file = node_path_1.default.join(this.repoRegistryDir(repo), "provenance.json");
         if (!node_fs_1.default.existsSync(file))
             return { schemaVersion: 1, links: {} };
-        try {
-            const parsed = (0, state_1.readJson)(file);
-            return { schemaVersion: 1, links: parsed.links || {} };
-        }
-        catch {
-            return { schemaVersion: 1, links: {} };
-        }
+        const parsed = this.requireOverlayObject((0, state_1.readJson)(file), file);
+        return { schemaVersion: 1, links: parsed.links || {} };
     }
     loadRepoOverlays(repo) {
         return {
@@ -203,15 +210,14 @@ class RunRegistry {
     }
     loadRepos() {
         const file = this.reposFilePath();
+        // Absent => no registered repos. Present-but-corrupt must fail closed: a
+        // swallowed parse error here silently drops every cross-repo root the
+        // operator registered, shrinking the home index to the current repo with no
+        // signal. Let readJson's `Invalid JSON` throw surface the corruption.
         if (!node_fs_1.default.existsSync(file))
             return { schemaVersion: 1, repos: [] };
-        try {
-            const parsed = (0, state_1.readJson)(file);
-            return { schemaVersion: 1, repos: Array.isArray(parsed.repos) ? parsed.repos : [] };
-        }
-        catch {
-            return { schemaVersion: 1, repos: [] };
-        }
+        const parsed = this.requireOverlayObject((0, state_1.readJson)(file), file);
+        return { schemaVersion: 1, repos: Array.isArray(parsed.repos) ? parsed.repos : [] };
     }
     /** Persisted union of registered repo roots and the current repo, deduped and
      *  sorted. Read-only: does NOT write repos.json (reads stay pure). */
@@ -745,9 +751,14 @@ class RunRegistry {
         // Record provenance in the per-repo overlay (derived metadata), NOT in the
         // original run's source state — the past is never mutated.
         const provFile = node_path_1.default.join(this.repoRegistryDir(original.repo), "provenance.json");
-        const provOverlay = this.loadProvenanceOverlay(original.repo);
-        provOverlay.links[newRun.id] = provenance;
-        (0, state_1.writeJson)(provFile, provOverlay, { durable: true });
+        // Lock the read-modify-write: a concurrent rerun/archive on the same repo
+        // overlay would otherwise last-writer-wins and drop a provenance link. The
+        // sibling writers (registerRepo, archive) already serialize via withFileLock.
+        (0, state_1.withFileLock)(provFile, () => {
+            const provOverlay = this.loadProvenanceOverlay(original.repo);
+            provOverlay.links[newRun.id] = provenance;
+            (0, state_1.writeJson)(provFile, provOverlay, { durable: true });
+        });
         return {
             schemaVersion: 1,
             originalRunId: runId,

package/dist/scheduler.js

@@ -16,6 +16,16 @@ class Scheduler {
         this.cwd = node_path_1.default.resolve(cwd);
         this.storePath = node_path_1.default.join(this.cwd, ".cw", "schedules", "tasks.json");
     }
+    // Every mutation is a cross-process read-modify-write of the one store file
+    // (the daemon polls `due` while CLI calls create/complete/delete concurrently).
+    // Without serialization two writers both load, both atomically rename their
+    // copy back, and the second silently clobbers the first's new task / status /
+    // history record. `locked` holds the same advisory lock the queue and
+    // reclamation stores already use. Reads (list/history) need no lock: the atomic
+    // rename means a reader always sees a whole old-or-new store.
+    locked(fn) {
+        return (0, state_1.withFileLock)(this.storePath, fn);
+    }
     create(options) {
         const kind = normalizeKind(options.kind);
         const now = new Date();
@@ -43,23 +53,30 @@ class Scheduler {
             maxRuns: numberOption(options.maxRuns),
             runCount: 0
         };
-        const store = this.load();
-        store.tasks.push(task);
-        this.save(store);
-        return task;
+        return this.locked(() => {
+            const store = this.load();
+            store.tasks.push(task);
+            this.save(store);
+            return task;
+        });
     }
     list(status) {
         const store = this.load();
         return status ? store.tasks.filter((task) => task.status === status) : store.tasks;
     }
     delete(id) {
-        const store = this.load();
-        const before = store.tasks.length;
-        store.tasks = store.tasks.filter((task) => task.id !== id);
-        this.save(store);
-        return { deleted: store.tasks.length !== before, id };
+        return this.locked(() => {
+            const store = this.load();
+            const before = store.tasks.length;
+            store.tasks = store.tasks.filter((task) => task.id !== id);
+            this.save(store);
+            return { deleted: store.tasks.length !== before, id };
+        });
     }
     due(now = new Date()) {
+        return this.locked(() => this.dueLocked(now));
+    }
+    dueLocked(now) {
         const store = this.load();
         let changed = false;
         for (const task of store.tasks) {
@@ -87,63 +104,71 @@ class Scheduler {
         return dueTasks;
     }
     complete(id, options = {}) {
-        const store = this.load();
-        const task = store.tasks.find((candidate) => candidate.id === id);
-        if (!task)
-            throw new Error(`Scheduled task not found: ${id}`);
-        const now = new Date();
-        task.runCount += 1;
-        task.lastRunAt = now.toISOString();
-        task.updatedAt = now.toISOString();
-        const maxRuns = numberOption(options.maxRuns) ?? task.maxRuns;
-        if (maxRuns !== undefined)
-            task.maxRuns = maxRuns;
-        if (task.kind === "reminder" || (task.maxRuns !== undefined && task.runCount >= task.maxRuns)) {
-            task.status = "completed";
-        }
-        else {
-            task.nextRunAt = computeNextRunAt(task, now).toISOString();
-        }
-        this.save(store);
-        return task;
+        return this.locked(() => {
+            const store = this.load();
+            const task = store.tasks.find((candidate) => candidate.id === id);
+            if (!task)
+                throw new Error(`Scheduled task not found: ${id}`);
+            const now = new Date();
+            task.runCount += 1;
+            task.lastRunAt = now.toISOString();
+            task.updatedAt = now.toISOString();
+            const maxRuns = numberOption(options.maxRuns) ?? task.maxRuns;
+            if (maxRuns !== undefined)
+                task.maxRuns = maxRuns;
+            if (task.kind === "reminder" || (task.maxRuns !== undefined && task.runCount >= task.maxRuns)) {
+                task.status = "completed";
+            }
+            else {
+                task.nextRunAt = computeNextRunAt(task, now).toISOString();
+            }
+            this.save(store);
+            return task;
+        });
     }
     pause(id) {
         return this.setStatus(id, "paused");
     }
     resume(id) {
-        const store = this.load();
-        const task = findTask(store, id);
-        const now = new Date();
-        task.status = "active";
-        task.updatedAt = now.toISOString();
-        if (new Date(task.nextRunAt).getTime() <= now.getTime()) {
-            task.nextRunAt = computeNextRunAt(task, now).toISOString();
-        }
-        this.save(store);
-        return task;
+        return this.locked(() => {
+            const store = this.load();
+            const task = findTask(store, id);
+            const now = new Date();
+            task.status = "active";
+            task.updatedAt = now.toISOString();
+            if (new Date(task.nextRunAt).getTime() <= now.getTime()) {
+                task.nextRunAt = computeNextRunAt(task, now).toISOString();
+            }
+            this.save(store);
+            return task;
+        });
     }
     runNow(id) {
-        const store = this.load();
-        const task = findTask(store, id);
-        const now = new Date();
-        task.lastDueAt = now.toISOString();
-        task.updatedAt = now.toISOString();
-        const record = createHistoryRecord(task, "started", this.cwd, now);
-        store.history.push(record);
-        this.save(store);
-        return record;
+        return this.locked(() => {
+            const store = this.load();
+            const task = findTask(store, id);
+            const now = new Date();
+            task.lastDueAt = now.toISOString();
+            task.updatedAt = now.toISOString();
+            const record = createHistoryRecord(task, "started", this.cwd, now);
+            store.history.push(record);
+            this.save(store);
+            return record;
+        });
     }
     history(id) {
         const store = this.load();
         return id ? store.history.filter((record) => record.scheduleId === id) : store.history;
     }
     setStatus(id, status) {
-        const store = this.load();
-        const task = findTask(store, id);
-        task.status = status;
-        task.updatedAt = new Date().toISOString();
-        this.save(store);
-        return task;
+        return this.locked(() => {
+            const store = this.load();
+            const task = findTask(store, id);
+            task.status = status;
+            task.updatedAt = new Date().toISOString();
+            this.save(store);
+            return task;
+        });
     }
     load() {
         if (!node_fs_1.default.existsSync(this.storePath))

package/dist/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MIN_SUPPORTED_RUN_STATE_SCHEMA_VERSION = exports.LEGACY_RUN_STATE_SCHEMA_VERSION = exports.CURRENT_RUN_STATE_SCHEMA_VERSION = exports.WORKFLOW_APP_SCHEMA_VERSION = exports.CURRENT_COOL_WORKFLOW_VERSION = void 0;
-exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.82";
+exports.CURRENT_COOL_WORKFLOW_VERSION = "0.1.83";
 exports.WORKFLOW_APP_SCHEMA_VERSION = 1;
 exports.CURRENT_RUN_STATE_SCHEMA_VERSION = 1;
 exports.LEGACY_RUN_STATE_SCHEMA_VERSION = 0;

package/dist/worker-isolation.js

@@ -270,7 +270,15 @@ function getWorkerScope(run, workerId) {
     const file = node_path_1.default.join(workerRoot(run), (0, state_1.safeFileName)(workerId), paths_1.WORKER_SCOPE_FILE);
     if (!node_fs_1.default.existsSync(file))
         return undefined;
-    const scope = (0, validation_1.validateWorkerScope)(JSON.parse(node_fs_1.default.readFileSync(file, "utf8")));
+    let scope;
+    try {
+        scope = (0, validation_1.validateWorkerScope)(JSON.parse(node_fs_1.default.readFileSync(file, "utf8")));
+    }
+    catch (error) {
+        // A present-but-corrupt scope fails closed with context, not a raw
+        // SyntaxError/validation throw bubbling up from deep in the call stack.
+        throw new Error(`Corrupt worker scope ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
     upsertWorkerScope(run, scope);
     return scope;
 }
@@ -871,7 +879,19 @@ function loadWorkerScopesFromDisk(run) {
         .filter((entry) => entry.isDirectory())
         .map((entry) => node_path_1.default.join(workerRoot(run), entry.name, paths_1.WORKER_SCOPE_FILE))
         .filter((file) => node_fs_1.default.existsSync(file))
-        .map((file) => (0, validation_1.validateWorkerScope)(JSON.parse(node_fs_1.default.readFileSync(file, "utf8"))));
+        .map((file) => {
+        // One corrupt/partially-written worker.json must not blank the whole
+        // listing (summarizeWorkers/listWorkerScopes) — skip it with a diagnostic
+        // and surface every worker that IS readable.
+        try {
+            return (0, validation_1.validateWorkerScope)(JSON.parse(node_fs_1.default.readFileSync(file, "utf8")));
+        }
+        catch (error) {
+            process.stderr.write(`cw: skipping unreadable worker scope ${file}: ${error instanceof Error ? error.message : String(error)}\n`);
+            return undefined;
+        }
+    })
+        .filter((scope) => scope !== undefined);
 }
 function requireWorkerScope(run, workerId) {
     const scope = getWorkerScope(run, workerId);