cool-workflow 0.1.98 → 0.2.1

package/dist/{scheduler.js → shell/scheduler-io.js}

@@ -1,30 +1,75 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// shell/scheduler-io.ts — Scheduler (cw schedule/loop), the daemon tick
+// (cw schedule daemon), and routine triggers (cw routine).
+//
+// MILESTONE 10 (docs/rebuild/PLAN.md build order, step 10). Byte-exact port of the
+// old build's src/scheduler.ts + src/daemon.ts + src/triggers.ts. Reuses
+// shell/fs-atomic.ts's `withFileLock`/`readJson`/`writeJson`/`safeFileName`
+// directly (no reimplementation).
+//
+// Two separate systems, never merged (SPEC/scheduling-registry.md
+// "Rebuild risks" #4): `Scheduler`/`DesktopSchedulerDaemon`/
+// `RoutineTriggerBridge` here are WALL-CLOCK tasks under
+// `<cwd>/.cw/schedules/` and `<cwd>/.cw/routines/`; `cw sched` (leases
+// over `$CW_HOME/registry/queue.json`) is a completely different system
+// — see shell/scheduling-io.ts. `cw loop` is only sugar for
+// `schedule create --kind loop`.
+//
+// Evidence: SPEC/scheduling-registry.md sections A, B;
+// plugins/cool-workflow/src/scheduler.ts, src/daemon.ts, src/triggers.ts
+// (byte-exact source).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Scheduler = void 0;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const state_1 = require("./state");
+exports.RoutineTriggerBridge = exports.DesktopSchedulerDaemon = exports.Scheduler = void 0;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const fs_atomic_1 = require("./fs-atomic");
 const DEFAULT_TTL_DAYS = 7;
+// ---------------------------------------------------------------------------
+// Scheduler — cw schedule / cw loop
+// ---------------------------------------------------------------------------
 class Scheduler {
     cwd;
     storePath;
     constructor(cwd = process.cwd()) {
-        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.
+        this.cwd = path.resolve(cwd);
+        this.storePath = path.join(this.cwd, ".cw", "schedules", "tasks.json");
+    }
     locked(fn) {
-        return (0, state_1.withFileLock)(this.storePath, fn);
+        return (0, fs_atomic_1.withFileLock)(this.storePath, fn);
     }
     create(options) {
         const kind = normalizeKind(options.kind);
@@ -51,7 +96,7 @@ class Scheduler {
             cron,
             jitterSeconds,
             maxRuns: numberOption(options.maxRuns),
-            runCount: 0
+            runCount: 0,
         };
         return this.locked(() => {
             const store = this.load();
@@ -171,19 +216,17 @@ class Scheduler {
         });
     }
     load() {
-        if (!node_fs_1.default.existsSync(this.storePath))
+        if (!fs.existsSync(this.storePath))
             return { schemaVersion: 1, tasks: [], history: [] };
-        const value = (0, state_1.readJson)(this.storePath);
+        const value = (0, fs_atomic_1.readJson)(this.storePath);
         return {
             schemaVersion: 1,
             tasks: Array.isArray(value.tasks) ? value.tasks : [],
-            history: Array.isArray(value.history) ? value.history : []
+            history: Array.isArray(value.history) ? value.history : [],
         };
     }
     save(store) {
-        // Authoritative scheduler store — atomic + durable (v0.1.40). writeJson is now
-        // always atomic (temp → rename), so a crash mid-write can never truncate it.
-        (0, state_1.writeJson)(this.storePath, store, { durable: true });
+        (0, fs_atomic_1.writeJson)(this.storePath, store, { durable: true });
     }
 }
 exports.Scheduler = Scheduler;
@@ -203,7 +246,7 @@ function createHistoryRecord(task, status, cwd, now) {
         prompt: task.prompt,
         cwd,
         workflowId: task.workflowId,
-        runId: task.runId
+        runId: task.runId,
     };
 }
 function normalizeKind(value) {
@@ -259,47 +302,38 @@ function matchesCron(value, expr, min, max) {
         return Number.isInteger(parsed) && parsed >= min && parsed <= max && parsed === value;
     });
 }
-// Deterministic jitter (replay-determinism self-audit): the jittered Date is NOT a
-// runtime-only sleep — it lands in persisted/replayed state (task.nextRunAt and,
-// transitively, the schedule store), so a Math.random() offset broke replay
-// determinism. The spread (0..jitterSeconds) is now derived from a content hash of
-// the base instant, so the same base time + jitter window always yields the same
-// offset; distinct base times still spread out across the window. The base Date is
-// itself an edge timestamp that is recorded once.
+/** Deterministic jitter: `sha256(baseMs) mod (jitterSeconds+1)` seconds —
+ *  a pure function of the base time, no randomness, so it stays replay-
+ *  determinstic even though it lands in persisted state. */
 function addJitter(date, jitterSeconds) {
     if (!jitterSeconds)
         return date;
-    const digest = node_crypto_1.default.createHash("sha256").update(`${date.getTime()}`).digest();
+    const digest = crypto.createHash("sha256").update(`${date.getTime()}`).digest();
     const seconds = digest.readUInt32BE(0) % (jitterSeconds + 1);
     return new Date(date.getTime() + seconds * 1000);
 }
-// Deterministic schedule id (replay-determinism self-audit): the stamp is an edge
-// timestamp (recorded once). Set CW_DETERMINISTIC_RUN_IDS=1 to use a
-// content-hash-based id without wall-clock, so re-deriving the id for a recorded
-// schedule yields the byte-identical value. Distinct instants still get distinct
-// ids via the monotonic counter.
 let scheduleIdSequence = 0;
 function createScheduleId(kind) {
     const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
     scheduleIdSequence += 1;
     const deterministic = /^(1|true|yes|on)$/i.test(process.env.CW_DETERMINISTIC_RUN_IDS || "");
-    const suffix = node_crypto_1.default.createHash("sha256")
+    const suffix = crypto
+        .createHash("sha256")
         .update(deterministic ? `${kind}:${process.pid}:${scheduleIdSequence}` : `${kind}:${stamp}:${process.pid}:${scheduleIdSequence}`)
-        .digest("hex").slice(0, 6);
+        .digest("hex")
+        .slice(0, 6);
     return deterministic ? `${kind}-${suffix}` : `${kind}-${stamp}-${suffix}`;
 }
-// Deterministic schedule-run (history) id — same rationale as createScheduleId. The
-// history record stamp differs from the owning schedule's, so the hashed identity
-// (kind + run stamp) stays distinct from the schedule id while remaining a pure
-// function of already-recorded state.
 let scheduleRunIdSequence = 0;
 function createScheduleRunId(kind) {
     const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\..+/, "Z");
     scheduleRunIdSequence += 1;
     const deterministic = /^(1|true|yes|on)$/i.test(process.env.CW_DETERMINISTIC_RUN_IDS || "");
-    const suffix = node_crypto_1.default.createHash("sha256")
+    const suffix = crypto
+        .createHash("sha256")
         .update(deterministic ? `run:${kind}:${process.pid}:${scheduleRunIdSequence}` : `run:${kind}:${stamp}:${process.pid}:${scheduleRunIdSequence}`)
-        .digest("hex").slice(0, 6);
+        .digest("hex")
+        .slice(0, 6);
     return deterministic ? `run-${kind}-${suffix}` : `run-${kind}-${stamp}-${suffix}`;
 }
 function requiredString(value, name) {
@@ -319,3 +353,178 @@ function numberOption(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+class DesktopSchedulerDaemon {
+    cwd;
+    intervalSeconds;
+    scheduler;
+    constructor(options = {}) {
+        this.cwd = path.resolve(String(options.cwd || process.cwd()));
+        this.intervalSeconds = Number(options.intervalSeconds || 60);
+        this.scheduler = new Scheduler(this.cwd);
+    }
+    tick() {
+        const due = this.scheduler.due();
+        const checkedAt = new Date().toISOString();
+        const inboxPath = path.join(this.cwd, ".cw", "schedules", "due-inbox.json");
+        (0, fs_atomic_1.writeJson)(inboxPath, { schemaVersion: 1, checkedAt, due });
+        return { checkedAt, dueCount: due.length, dueIds: due.map((task) => task.id), inboxPath };
+    }
+    async run() {
+        fs.mkdirSync(path.join(this.cwd, ".cw", "schedules"), { recursive: true });
+        process.stdout.write(`${JSON.stringify(this.tick())}\n`);
+        setInterval(() => {
+            process.stdout.write(`${JSON.stringify(this.tick())}\n`);
+        }, Math.max(1, this.intervalSeconds) * 1000);
+    }
+}
+exports.DesktopSchedulerDaemon = DesktopSchedulerDaemon;
+class RoutineTriggerBridge {
+    cwd;
+    storePath;
+    payloadsDir;
+    constructor(cwd = process.cwd()) {
+        this.cwd = path.resolve(cwd);
+        this.storePath = path.join(this.cwd, ".cw", "routines", "triggers.json");
+        this.payloadsDir = path.join(this.cwd, ".cw", "routines", "payloads");
+    }
+    locked(fn) {
+        return (0, fs_atomic_1.withFileLock)(this.storePath, fn);
+    }
+    create(options) {
+        return this.locked(() => {
+            const now = new Date().toISOString();
+            const store = this.load();
+            // Monotonic id, NOT triggers.length: delete shrinks the collection, so
+            // a length-based seq would reuse a live id after delete+create.
+            const seq = (store.nextTriggerSeq || 0) + 1;
+            store.nextTriggerSeq = seq;
+            const trigger = {
+                id: createTriggerId(normalizeTriggerKind(options.kind), seq),
+                kind: normalizeTriggerKind(options.kind),
+                createdAt: now,
+                updatedAt: now,
+                source: String(options.source || options.kind || "api"),
+                prompt: requiredString(options.prompt, "prompt"),
+                workflowId: stringOption(options.workflowId),
+                runId: stringOption(options.runId),
+                match: parseJsonObject(options.match),
+                metadata: parseJsonObject(options.metadata),
+            };
+            store.triggers.push(trigger);
+            this.save(store);
+            return trigger;
+        });
+    }
+    list(kind) {
+        const store = this.load();
+        return kind ? store.triggers.filter((trigger) => trigger.kind === kind) : store.triggers;
+    }
+    delete(id) {
+        return this.locked(() => {
+            const store = this.load();
+            const before = store.triggers.length;
+            store.triggers = store.triggers.filter((trigger) => trigger.id !== id);
+            this.save(store);
+            return { deleted: store.triggers.length !== before, id };
+        });
+    }
+    fire(kind, payload) {
+        return this.locked(() => {
+            const normalizedKind = normalizeTriggerKind(kind);
+            const store = this.load();
+            const now = new Date().toISOString();
+            const base = store.events.length;
+            const events = store.triggers
+                .filter((trigger) => trigger.kind === normalizedKind)
+                .map((trigger, index) => this.createEvent(trigger, payload, now, base + index + 1));
+            store.events.push(...events);
+            this.save(store);
+            return events;
+        });
+    }
+    events(triggerId) {
+        const store = this.load();
+        return triggerId ? store.events.filter((event) => event.triggerId === triggerId) : store.events;
+    }
+    createEvent(trigger, payload, receivedAt, seq) {
+        const matched = matchesTrigger(trigger.match, payload);
+        const eventId = createEventId(trigger.kind, seq);
+        const payloadPath = path.join(this.payloadsDir, `${(0, fs_atomic_1.safeFileName)(eventId)}.json`);
+        (0, fs_atomic_1.writeJson)(payloadPath, { schemaVersion: 1, trigger, receivedAt, matched, payload });
+        return {
+            id: eventId,
+            triggerId: trigger.id,
+            kind: trigger.kind,
+            receivedAt,
+            matched,
+            prompt: matched ? renderPrompt(trigger, payload) : undefined,
+            payloadPath,
+        };
+    }
+    load() {
+        if (!fs.existsSync(this.storePath))
+            return { schemaVersion: 1, triggers: [], events: [], nextTriggerSeq: 0 };
+        const value = (0, fs_atomic_1.readJson)(this.storePath);
+        const triggers = Array.isArray(value.triggers) ? value.triggers : [];
+        const maxExisting = triggers.reduce((max, trigger) => {
+            const n = Number((String(trigger.id).match(/(\d+)$/) || [])[1] || 0);
+            return Number.isFinite(n) && n > max ? n : max;
+        }, 0);
+        return {
+            schemaVersion: 1,
+            triggers,
+            events: Array.isArray(value.events) ? value.events : [],
+            nextTriggerSeq: Math.max(typeof value.nextTriggerSeq === "number" ? value.nextTriggerSeq : 0, maxExisting),
+        };
+    }
+    save(store) {
+        (0, fs_atomic_1.writeJson)(this.storePath, store);
+    }
+}
+exports.RoutineTriggerBridge = RoutineTriggerBridge;
+function normalizeTriggerKind(value) {
+    const kind = String(value || "api");
+    if (kind === "api" || kind === "github")
+        return kind;
+    throw new Error(`Unsupported routine trigger kind: ${kind}`);
+}
+function matchesTrigger(match, payload) {
+    if (!match || !Object.keys(match).length)
+        return true;
+    if (!payload || typeof payload !== "object")
+        return false;
+    return Object.entries(match).every(([key, expected]) => deepValue(payload, key) === expected);
+}
+function deepValue(value, key) {
+    return key.split(".").reduce((current, part) => {
+        if (!current || typeof current !== "object")
+            return undefined;
+        return current[part];
+    }, value);
+}
+function renderPrompt(trigger, payload) {
+    return `${trigger.prompt}\n\ncw:routine\n${JSON.stringify({ triggerId: trigger.id, kind: trigger.kind, source: trigger.source, workflowId: trigger.workflowId, runId: trigger.runId, payload }, null, 2)}`;
+}
+function parseJsonObject(value) {
+    if (!value || value === true)
+        return undefined;
+    if (typeof value === "object")
+        return value;
+    let parsed;
+    try {
+        parsed = JSON.parse(String(value));
+    }
+    catch {
+        throw new Error("Expected a JSON object, got invalid JSON");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Expected JSON object");
+    }
+    return parsed;
+}
+function createTriggerId(kind, seq) {
+    return `${kind}-${String(seq).padStart(4, "0")}`;
+}
+function createEventId(kind, seq) {
+    return `event-${kind}-${String(seq).padStart(4, "0")}`;
+}