@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

package/dist/heart/daemon/supercronic-supervisor.js

@@ -0,0 +1,282 @@
+"use strict";
+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.SupercronicSupervisor = void 0;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+const NAMESPACE = /^(?:habit|await):[a-z0-9](?:[a-z0-9._-]{0,62})$/u;
+const SAFE_JOB = /^[^\r\n\0]+$/u;
+const RESTART_DELAYS_MS = [1_000, 5_000, 15_000];
+function defaultDurableWrite(filePath, content, mode) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const temporary = `${filePath}.${process.pid}.tmp`;
+    const fd = fs.openSync(temporary, "w", mode);
+    try {
+        fs.writeFileSync(fd, content, "utf8");
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    fs.chmodSync(temporary, mode);
+    fs.renameSync(temporary, filePath);
+    const directory = fs.openSync(path.dirname(filePath), "r");
+    try {
+        fs.fsyncSync(directory);
+    }
+    finally {
+        fs.closeSync(directory);
+    }
+}
+function defaultDeps() {
+    return {
+        mkdir: (target) => fs.mkdirSync(target, { recursive: true }),
+        readFile: (target) => fs.readFileSync(target, "utf8"),
+        durableWrite: defaultDurableWrite,
+        removeFile: (target) => { try {
+            fs.unlinkSync(target);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        } },
+        processAlive: (pid) => { try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        } },
+        processCommand: (pid) => {
+            try {
+                return fs.readFileSync(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean).join(" ");
+            }
+            catch {
+                return null;
+            }
+        },
+        spawn: (binary, args) => (0, node_child_process_1.spawn)(binary, args, { stdio: ["ignore", "inherit", "inherit"] }),
+        setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
+        clearTimer: (timer) => clearTimeout(timer),
+    };
+}
+class SupercronicSupervisor {
+    deps;
+    binaryPath;
+    crontabPath;
+    pidPath;
+    onFatal;
+    manifests = new Map();
+    child = null;
+    restartTimer = null;
+    restartCount = 0;
+    stopping = false;
+    constructor(options) {
+        this.binaryPath = options.binaryPath;
+        this.crontabPath = options.crontabPath;
+        this.pidPath = options.pidPath ?? `${options.crontabPath}.pid`;
+        this.deps = options.deps ?? defaultDeps();
+        this.onFatal = options.onFatal ?? ((error) => { throw error; });
+    }
+    start() {
+        if (this.child || this.restartTimer)
+            return;
+        this.deps.mkdir(path.dirname(this.crontabPath));
+        const priorPid = this.readPriorPid();
+        if (priorPid !== null && this.isPriorSupercronic(priorPid))
+            throw new Error(`Supercronic is already running with PID ${priorPid}`);
+        if (priorPid !== null)
+            this.deps.removeFile(this.pidPath);
+        this.render();
+        this.stopping = false;
+        this.spawnChild();
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic supervisor started", meta: { crontabPath: this.crontabPath } });
+    }
+    namespace(namespace) {
+        if (!NAMESPACE.test(namespace))
+            throw new Error(`invalid Supercronic namespace: ${namespace}`);
+        return {
+            sync: (jobs) => {
+                const next = new Map();
+                for (const job of jobs) {
+                    if (!SAFE_JOB.test(job.id) || !SAFE_JOB.test(job.taskId) || !SAFE_JOB.test(job.schedule) || !SAFE_JOB.test(job.command)) {
+                        throw new Error("invalid Supercronic job");
+                    }
+                    if (next.has(job.id))
+                        throw new Error(`duplicate Supercronic job: ${job.id}`);
+                    next.set(job.id, structuredClone(job));
+                }
+                this.manifests.set(namespace, next);
+                this.render();
+                (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic manifest synchronized", meta: { namespace, jobCount: jobs.length } });
+            },
+            removeAll: () => {
+                this.manifests.delete(namespace);
+                this.render();
+            },
+            list: () => [...(this.manifests.get(namespace)?.values() ?? [])].map((job) => job.taskId).sort(),
+        };
+    }
+    verifyNamespace(namespace, jobs) {
+        if (!this.isHealthy())
+            return false;
+        const manifest = this.manifests.get(namespace);
+        if (!manifest || manifest.size !== jobs.length)
+            return false;
+        for (const job of jobs) {
+            const existing = manifest.get(job.id);
+            if (!existing || existing.schedule !== job.schedule || existing.command !== job.command)
+                return false;
+        }
+        try {
+            return this.deps.readFile(this.crontabPath) === this.renderedContent();
+        }
+        catch {
+            return false;
+        }
+    }
+    verificationOutput() {
+        if (!this.isHealthy())
+            return "";
+        const expected = this.renderedContent();
+        try {
+            return this.deps.readFile(this.crontabPath) === expected ? expected : "";
+        }
+        catch {
+            return "";
+        }
+    }
+    authenticatedSnapshot(namespace) {
+        if (!NAMESPACE.test(namespace))
+            throw new Error(`invalid Supercronic namespace: ${namespace}`);
+        if (!this.isHealthy() || typeof this.child?.pid !== "number")
+            throw new Error("Supercronic supervisor has no healthy child");
+        const manifest = this.manifests.get(namespace);
+        if (!manifest)
+            throw new Error(`Supercronic supervisor has no manifest for ${namespace}`);
+        const renderedCrontab = this.verificationOutput();
+        if (renderedCrontab.length === 0)
+            throw new Error("Supercronic supervisor crontab is not verified");
+        return {
+            schemaVersion: "supercronic-supervisor-snapshot-v1",
+            daemonPid: process.pid,
+            childCount: 1,
+            childPid: this.child.pid,
+            healthy: true,
+            binaryPath: this.binaryPath,
+            args: ["-split-logs", "-inotify", this.crontabPath],
+            crontabPath: this.crontabPath,
+            namespace,
+            manifest: [...manifest.values()].sort((left, right) => left.id.localeCompare(right.id)).map((job) => structuredClone(job)),
+            renderedCrontab,
+        };
+    }
+    isHealthy() {
+        return this.child !== null && typeof this.child.pid === "number" && this.deps.processAlive(this.child.pid);
+    }
+    async stop() {
+        this.stopping = true;
+        if (this.restartTimer)
+            this.deps.clearTimer(this.restartTimer);
+        this.restartTimer = null;
+        const child = this.child;
+        if (!child) {
+            this.deps.removeFile(this.pidPath);
+            return;
+        }
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => { if (settled)
+                return; settled = true; resolve(); };
+            child.once("exit", finish);
+            const timer = this.deps.setTimer(() => { child.kill("SIGKILL"); finish(); }, 10_000);
+            child.once("exit", () => this.deps.clearTimer(timer));
+            child.kill("SIGTERM");
+        });
+        this.child = null;
+        this.deps.removeFile(this.pidPath);
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.supercronic_state", message: "Supercronic supervisor stopped", meta: { crontabPath: this.crontabPath } });
+    }
+    readPriorPid() {
+        try {
+            const value = Number(this.deps.readFile(this.pidPath).trim());
+            return Number.isSafeInteger(value) && value > 0 ? value : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    isPriorSupercronic(pid) {
+        if (!this.deps.processAlive(pid))
+            return false;
+        return this.deps.processCommand(pid) === `${this.binaryPath} -split-logs -inotify ${this.crontabPath}`;
+    }
+    renderedContent() {
+        const lines = [];
+        for (const namespace of [...this.manifests.keys()].sort()) {
+            const jobs = [...this.manifests.get(namespace).values()].sort((left, right) => left.id.localeCompare(right.id));
+            for (const job of jobs)
+                lines.push(`# ouro:${namespace}:${job.id}`, `${job.schedule} ${job.command}`);
+        }
+        return lines.length > 0 ? `${lines.join("\n")}\n` : "";
+    }
+    render() {
+        this.deps.durableWrite(this.crontabPath, this.renderedContent(), 0o600);
+    }
+    spawnChild() {
+        const child = this.deps.spawn(this.binaryPath, ["-split-logs", "-inotify", this.crontabPath]);
+        if (!child.pid || child.pid <= 0)
+            throw new Error("Supercronic did not return a child PID");
+        this.child = child;
+        this.deps.durableWrite(this.pidPath, `${child.pid}\n`, 0o600);
+        child.once("exit", (code, signal) => {
+            if (this.child !== child)
+                return;
+            this.child = null;
+            this.deps.removeFile(this.pidPath);
+            if (this.stopping)
+                return;
+            if (this.restartCount >= RESTART_DELAYS_MS.length) {
+                this.onFatal(new Error(`Supercronic exited repeatedly (code=${String(code)}, signal=${String(signal)})`));
+                return;
+            }
+            const delay = RESTART_DELAYS_MS[this.restartCount++];
+            this.restartTimer = this.deps.setTimer(() => { this.restartTimer = null; this.spawnChild(); }, delay);
+        });
+    }
+}
+exports.SupercronicSupervisor = SupercronicSupervisor;

package/dist/heart/daemon/task-scheduler.js

@@ -38,7 +38,8 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
-const parser_1 = require("../../repertoire/tasks/parser");
+const frontmatter_1 = require("../../util/frontmatter");
+const cadence_1 = require("./cadence");
 function walkMarkdownFiles(root, readdirSync, existsSync, files) {
     if (!existsSync(root))
         return;
@@ -53,29 +54,6 @@ function walkMarkdownFiles(root, readdirSync, existsSync, files) {
         }
     }
 }
-function parseCadence(raw) {
-    if (typeof raw !== "string")
-        return null;
-    const value = raw.trim();
-    if (!value)
-        return null;
-    // Cron format (minute hour day month weekday)
-    if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(value)) {
-        return value;
-    }
-    const cadenceMatch = /^(\d+)(m|h|d)$/.exec(value);
-    if (!cadenceMatch)
-        return null;
-    const interval = Number.parseInt(cadenceMatch[1], 10);
-    if (!Number.isFinite(interval) || interval <= 0)
-        return null;
-    const unit = cadenceMatch[2];
-    if (unit === "m")
-        return `*/${interval} * * * *`;
-    if (unit === "h")
-        return `0 */${interval} * * *`;
-    return `0 0 */${interval} * *`;
-}
 function parseScheduledAt(raw) {
     if (typeof raw !== "string")
         return null;
@@ -91,9 +69,70 @@ function parseScheduledAt(raw) {
     const month = date.getUTCMonth() + 1;
     return `${minute} ${hour} ${day} ${month} *`;
 }
-function removeRuntimeFrontmatter(frontmatter) {
-    const { _isCanonicalFilename, ...clean } = frontmatter;
-    return clean;
+/**
+ * Parse a task markdown file into the minimum scheduler-relevant projection.
+ * Inlines the previous `parseTaskFile` shape (only what the scheduler reads),
+ * so we don't depend on `src/repertoire/tasks/parser`. The shared
+ * `parseFrontmatter` util handles the YAML-ish frontmatter format.
+ */
+function parseSchedulerTask(content, filePath) {
+    (0, runtime_1.emitNervesEvent)({
+        event: "daemon.scheduler_task_parse",
+        component: "daemon",
+        message: "parsing scheduler task file",
+        meta: { filePath },
+    });
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---") {
+        throw new Error("task file missing frontmatter");
+    }
+    const closing = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+    if (closing === -1) {
+        throw new Error("task file has unterminated frontmatter");
+    }
+    const rawFrontmatter = lines.slice(1, closing).join("\n");
+    const body = lines.slice(closing + 1).join("\n").trim();
+    const frontmatter = (0, frontmatter_1.parseFrontmatter)(rawFrontmatter);
+    const name = path.basename(filePath);
+    const stem = name.replace(/\.md$/i, "");
+    const rawStatus = typeof frontmatter.status === "string" ? frontmatter.status : "";
+    return { stem, status: rawStatus, frontmatter, body };
+}
+function formatFrontmatterValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0)
+            return ["[]"];
+        return ["", ...value.map((entry) => `- ${String(entry)}`)];
+    }
+    if (value === null)
+        return ["null"];
+    return [String(value)];
+}
+/**
+ * Render a frontmatter+body markdown file. Inlined from the previous
+ * `renderTaskFile` (in `src/repertoire/tasks/parser`) so the scheduler can
+ * update `lastRun` without depending on the task module.
+ */
+function renderSchedulerTask(frontmatter, body) {
+    const keys = Object.keys(frontmatter);
+    const lines = ["---"];
+    for (const key of keys) {
+        const rendered = formatFrontmatterValue(frontmatter[key]);
+        if (rendered.length === 1) {
+            lines.push(`${key}: ${rendered[0]}`);
+        }
+        else {
+            lines.push(`${key}:`);
+            for (const entry of rendered.slice(1)) {
+                lines.push(entry);
+            }
+        }
+    }
+    lines.push("---");
+    lines.push("");
+    lines.push(body.trim());
+    lines.push("");
+    return lines.join("\n");
 }
 class TaskDrivenScheduler {
     agents;
@@ -135,29 +174,68 @@ class TaskDrivenScheduler {
         await this.recordTaskRun(job.agent, job.taskId);
         return { ok: true, message: `triggered ${jobId}` };
     }
+    /**
+     * Discover scheduler-eligible task files across both surfaces:
+     * - legacy: `<bundle>/tasks/{one-shots,ongoing}/**\/*.md`
+     * - desk:   `<bundle>/desk/<track>/<task-slug>/task.md`
+     *
+     * Dual-read is intentional during the W6 transition: old harnesses still
+     * write to `tasks/`; new harnesses + agents write to `desk/`. The scheduler
+     * accepts both.
+     */
+    collectTaskFiles(agent) {
+        const bundleRoot = path.join(this.bundlesRoot, `${agent}.ouro`);
+        const files = [];
+        // Legacy `tasks/{one-shots,ongoing}/` collections.
+        const legacyRoot = path.join(bundleRoot, "tasks");
+        for (const collection of ["one-shots", "ongoing"]) {
+            walkMarkdownFiles(path.join(legacyRoot, collection), this.readdirSync, this.existsSync, files);
+        }
+        // New `desk/<track>/<task-slug>/task.md` shape.
+        const deskRoot = path.join(bundleRoot, "desk");
+        if (this.existsSync(deskRoot)) {
+            for (const trackEntry of this.readdirSync(deskRoot, { withFileTypes: true })) {
+                if (!trackEntry.isDirectory())
+                    continue;
+                if (trackEntry.name.startsWith("_") || trackEntry.name.startsWith("."))
+                    continue;
+                const trackDir = path.join(deskRoot, trackEntry.name);
+                for (const taskEntry of this.readdirSync(trackDir, { withFileTypes: true })) {
+                    if (!taskEntry.isDirectory())
+                        continue;
+                    if (taskEntry.name.startsWith("_") || taskEntry.name.startsWith("."))
+                        continue;
+                    const taskFile = path.join(trackDir, taskEntry.name, "task.md");
+                    if (this.existsSync(taskFile))
+                        files.push(taskFile);
+                }
+            }
+        }
+        return files;
+    }
     async reconcile() {
         const nextJobs = new Map();
         const nextTaskPaths = new Map();
         for (const agent of this.agents) {
-            const taskRoot = path.join(this.bundlesRoot, `${agent}.ouro`, "tasks");
-            const collections = ["one-shots", "ongoing", "habits"];
-            const files = [];
-            for (const collection of collections) {
-                walkMarkdownFiles(path.join(taskRoot, collection), this.readdirSync, this.existsSync, files);
-            }
+            const files = this.collectTaskFiles(agent);
             for (const filePath of files) {
                 let task;
                 try {
-                    task = (0, parser_1.parseTaskFile)(this.readFileSync(filePath, "utf-8"), filePath);
+                    task = parseSchedulerTask(this.readFileSync(filePath, "utf-8"), filePath);
                 }
                 catch {
                     continue;
                 }
-                const taskId = task.stem;
+                // Desk task files live at `desk/<track>/<task-slug>/task.md`, so the
+                // markdown basename is "task" — use the parent directory name as the
+                // stable slug. Legacy `tasks/<collection>/<stem>.md` keeps the
+                // filename stem.
+                const isDeskTask = path.basename(filePath) === "task.md";
+                const taskId = isDeskTask ? path.basename(path.dirname(filePath)) : task.stem;
                 nextTaskPaths.set(`${agent}:${taskId}`, filePath);
                 if (task.status === "done")
                     continue;
-                const cadence = parseCadence(task.frontmatter.cadence);
+                const cadence = (0, cadence_1.parseCadenceToCron)(task.frontmatter.cadence);
                 if (cadence) {
                     const id = `${agent}:${taskId}:cadence`;
                     nextJobs.set(id, {
@@ -212,18 +290,18 @@ class TaskDrivenScheduler {
         }
         let parsed;
         try {
-            parsed = (0, parser_1.parseTaskFile)(this.readFileSync(taskPath, "utf-8"), taskPath);
+            parsed = parseSchedulerTask(this.readFileSync(taskPath, "utf-8"), taskPath);
         }
         catch {
             return;
         }
         const now = this.nowIso();
-        const frontmatter = removeRuntimeFrontmatter(parsed.frontmatter);
+        const frontmatter = { ...parsed.frontmatter };
         frontmatter.lastRun = now;
         if (typeof frontmatter.updated === "string") {
             frontmatter.updated = now.slice(0, 10);
         }
-        this.writeFileSync(taskPath, (0, parser_1.renderTaskFile)(frontmatter, parsed.body), "utf-8");
+        this.writeFileSync(taskPath, renderSchedulerTask(frontmatter, parsed.body), "utf-8");
         for (const job of this.jobs.values()) {
             if (job.agent === agent && job.taskId === taskId) {
                 job.lastRun = now;