@ouro.bot/cli 0.0.1-alpha.0 → 0.1.0-alpha.2

package/dist/heart/daemon/hatch-specialist.js

@@ -0,0 +1,107 @@
+"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.getSpecialistIdentitySourceDir = getSpecialistIdentitySourceDir;
+exports.getRepoSpecialistIdentitiesDir = getRepoSpecialistIdentitiesDir;
+exports.syncSpecialistIdentities = syncSpecialistIdentities;
+exports.pickRandomSpecialistIdentity = pickRandomSpecialistIdentity;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function getSpecialistIdentitySourceDir() {
+    return path.join(os.homedir(), "AgentBundles", "AdoptionSpecialist.ouro", "psyche", "identities");
+}
+function getRepoSpecialistIdentitiesDir() {
+    return path.join(process.cwd(), "AdoptionSpecialist.ouro", "psyche", "identities");
+}
+function listMarkdownIdentityFiles(dir) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter((entry) => entry.endsWith(".md"))
+        .sort((left, right) => left.localeCompare(right));
+}
+function syncSpecialistIdentities(input) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_sync_start",
+        message: "syncing specialist identity files",
+        meta: { sourceDir: input.sourceDir, targetDir: input.targetDir },
+    });
+    const files = listMarkdownIdentityFiles(input.sourceDir);
+    fs.mkdirSync(input.targetDir, { recursive: true });
+    for (const fileName of files) {
+        const sourcePath = path.join(input.sourceDir, fileName);
+        const targetPath = path.join(input.targetDir, fileName);
+        fs.copyFileSync(sourcePath, targetPath);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_sync_end",
+        message: "synced specialist identity files",
+        meta: { copiedCount: files.length },
+    });
+    return files;
+}
+function pickRandomSpecialistIdentity(input) {
+    const files = listMarkdownIdentityFiles(input.identitiesDir);
+    if (files.length === 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.hatch_identity_pick_error",
+            message: "no specialist identities were found",
+            meta: { identitiesDir: input.identitiesDir },
+        });
+        throw new Error(`No specialist identities found in ${input.identitiesDir}`);
+    }
+    const random = input.random ?? Math.random;
+    const index = Math.min(files.length - 1, Math.floor(random() * files.length));
+    const fileName = files[index];
+    const content = fs.readFileSync(path.join(input.identitiesDir, fileName), "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_identity_pick",
+        message: "picked specialist identity",
+        meta: { fileName },
+    });
+    return { fileName, content };
+}

package/dist/heart/daemon/health-monitor.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HealthMonitor = void 0;
+const runtime_1 = require("../../nerves/runtime");
+class HealthMonitor {
+    processManager;
+    scheduler;
+    alertSink;
+    diskUsagePercent;
+    constructor(options) {
+        this.processManager = options.processManager;
+        this.scheduler = options.scheduler;
+        this.alertSink = options.alertSink ?? (() => undefined);
+        this.diskUsagePercent = options.diskUsagePercent ?? (() => 0);
+    }
+    async runChecks() {
+        const results = [];
+        const snapshots = this.processManager.listAgentSnapshots();
+        const unhealthy = snapshots.filter((snapshot) => snapshot.status !== "running");
+        if (unhealthy.length > 0) {
+            results.push({
+                name: "agent-processes",
+                status: "critical",
+                message: `non-running agents: ${unhealthy.map((item) => item.name).join(", ")}`,
+            });
+        }
+        else {
+            results.push({ name: "agent-processes", status: "ok", message: "all managed agents running" });
+        }
+        const jobs = this.scheduler.listJobs();
+        const neverRan = jobs.filter((job) => !job.lastRun);
+        if (neverRan.length > 0) {
+            results.push({
+                name: "cron-health",
+                status: "warn",
+                message: `jobs never run: ${neverRan.map((job) => job.id).join(", ")}`,
+            });
+        }
+        else {
+            results.push({ name: "cron-health", status: "ok", message: "cron jobs are healthy" });
+        }
+        const diskPercent = this.diskUsagePercent();
+        if (diskPercent >= 90) {
+            results.push({
+                name: "disk-space",
+                status: "critical",
+                message: `disk usage critical (${diskPercent}%)`,
+            });
+        }
+        else if (diskPercent >= 80) {
+            results.push({
+                name: "disk-space",
+                status: "warn",
+                message: `disk usage high (${diskPercent}%)`,
+            });
+        }
+        else {
+            results.push({
+                name: "disk-space",
+                status: "ok",
+                message: `disk usage healthy (${diskPercent}%)`,
+            });
+        }
+        for (const result of results) {
+            (0, runtime_1.emitNervesEvent)({
+                level: result.status === "critical" ? "error" : result.status === "warn" ? "warn" : "info",
+                component: "daemon",
+                event: "daemon.health_result",
+                message: "daemon health check result",
+                meta: { name: result.name, status: result.status },
+            });
+            if (result.status === "critical") {
+                await this.alertSink(`[critical] ${result.name}: ${result.message}`);
+            }
+        }
+        return results;
+    }
+}
+exports.HealthMonitor = HealthMonitor;

package/dist/heart/daemon/log-tailer.js

@@ -0,0 +1,146 @@
+"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.discoverLogFiles = discoverLogFiles;
+exports.readLastLines = readLastLines;
+exports.formatLogLine = formatLogLine;
+exports.tailLogs = tailLogs;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const nerves_1 = require("../../nerves");
+const runtime_1 = require("../../nerves/runtime");
+const LEVEL_COLORS = {
+    debug: "\x1b[2m",
+    info: "\x1b[36m",
+    warn: "\x1b[33m",
+    error: "\x1b[31m",
+};
+function discoverLogFiles(options) {
+    /* v8 ignore start -- integration: default DI stubs for real OS @preserve */
+    const homeDir = options.homeDir ?? os.homedir();
+    const existsSync = options.existsSync ?? (() => false);
+    const readdirSync = options.readdirSync ?? (() => []);
+    /* v8 ignore stop */
+    const logDir = path.join(homeDir, ".agentstate", "daemon", "logs");
+    const files = [];
+    if (existsSync(logDir)) {
+        for (const name of readdirSync(logDir)) {
+            if (!name.endsWith(".ndjson"))
+                continue;
+            if (options.agentFilter && !name.includes(options.agentFilter))
+                continue;
+            files.push(path.join(logDir, name));
+        }
+    }
+    return files.sort();
+}
+function readLastLines(filePath, count, readFileSync) {
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    return lines.slice(-count);
+}
+function formatLogLine(ndjsonLine) {
+    try {
+        const entry = JSON.parse(ndjsonLine);
+        const formatted = (0, nerves_1.formatTerminalEntry)(entry);
+        const color = LEVEL_COLORS[entry.level] ?? "";
+        return `${color}${formatted}\x1b[0m`;
+    }
+    catch {
+        return ndjsonLine;
+    }
+}
+function tailLogs(options = {}) {
+    /* v8 ignore start -- integration: default DI stubs for real OS @preserve */
+    const writer = options.writer ?? ((text) => process.stdout.write(text));
+    const lineCount = options.lines ?? 20;
+    const readFileSync = options.readFileSync ?? (() => "");
+    /* v8 ignore stop */
+    const watchFile = options.watchFile;
+    const unwatchFile = options.unwatchFile;
+    const files = discoverLogFiles(options);
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.log_tailer_started", message: "log tailer started", meta: { fileCount: files.length, follow: !!options.follow } });
+    const fileSizes = new Map();
+    // Read initial lines
+    for (const file of files) {
+        const lines = readLastLines(file, lineCount, readFileSync);
+        for (const line of lines) {
+            writer(`${formatLogLine(line)}\n`);
+        }
+        try {
+            const content = readFileSync(file, "utf-8");
+            fileSizes.set(file, content.length);
+        }
+        catch {
+            fileSizes.set(file, 0);
+        }
+    }
+    // Follow mode
+    if (options.follow && watchFile && unwatchFile) {
+        for (const file of files) {
+            watchFile(file, () => {
+                let content;
+                try {
+                    content = readFileSync(file, "utf-8");
+                }
+                catch {
+                    return;
+                }
+                /* v8 ignore next -- defensive: fileSizes always populated above @preserve */
+                const prevSize = fileSizes.get(file) ?? 0;
+                if (content.length <= prevSize)
+                    return;
+                fileSizes.set(file, content.length);
+                const newContent = content.slice(prevSize);
+                const newLines = newContent.split("\n").filter((l) => l.trim().length > 0);
+                for (const line of newLines) {
+                    writer(`${formatLogLine(line)}\n`);
+                }
+            });
+        }
+        return () => {
+            for (const file of files) {
+                unwatchFile(file);
+            }
+        };
+    }
+    return () => { };
+}

package/dist/heart/daemon/message-router.js

@@ -0,0 +1,98 @@
+"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.FileMessageRouter = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function messageId(nowIso) {
+    return `msg-${nowIso.replace(/[^0-9]/g, "")}`;
+}
+class FileMessageRouter {
+    baseDir;
+    now;
+    constructor(options = {}) {
+        this.baseDir = options.baseDir ?? path.join(os.homedir(), ".agentstate", "messages");
+        this.now = options.now ?? (() => new Date().toISOString());
+        fs.mkdirSync(this.baseDir, { recursive: true });
+    }
+    async send(input) {
+        const queuedAt = this.now();
+        const id = messageId(queuedAt);
+        const message = {
+            id,
+            from: input.from,
+            to: input.to,
+            content: input.content,
+            queuedAt,
+            priority: input.priority ?? "normal",
+            sessionId: input.sessionId,
+            taskRef: input.taskRef,
+        };
+        const inboxPath = this.inboxPath(input.to);
+        fs.appendFileSync(inboxPath, `${JSON.stringify(message)}\n`, "utf-8");
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.message_queued",
+            message: "queued inter-agent message",
+            meta: { id, from: input.from, to: input.to },
+        });
+        return { id, queuedAt };
+    }
+    pollInbox(agent) {
+        const inboxPath = this.inboxPath(agent);
+        if (!fs.existsSync(inboxPath))
+            return [];
+        const raw = fs.readFileSync(inboxPath, "utf-8");
+        fs.writeFileSync(inboxPath, "", "utf-8");
+        const messages = raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .map((line) => JSON.parse(line));
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.message_polled",
+            message: "polled inter-agent inbox",
+            meta: { agent, messageCount: messages.length },
+        });
+        return messages;
+    }
+    inboxPath(agent) {
+        return path.join(this.baseDir, `${agent}-inbox.jsonl`);
+    }
+}
+exports.FileMessageRouter = FileMessageRouter;

package/dist/heart/daemon/os-cron.js

@@ -0,0 +1,260 @@
+"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.CrontabCronManager = exports.LaunchdCronManager = void 0;
+exports.createOsCronManager = createOsCronManager;
+exports.cadenceToSeconds = cadenceToSeconds;
+exports.scheduleToCalendarInterval = scheduleToCalendarInterval;
+exports.generatePlistXml = generatePlistXml;
+exports.plistLabel = plistLabel;
+exports.crontabLine = crontabLine;
+const os = __importStar(require("os"));
+const runtime_1 = require("../../nerves/runtime");
+const PLIST_PREFIX = "bot.ouro.";
+function plistLabel(job) {
+    return `${PLIST_PREFIX}${job.agent}.${job.taskId}`;
+}
+function cadenceToSeconds(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const [minute, hour, day, month, weekday] = parts;
+    // Simple interval patterns only
+    if (month !== "*" || weekday !== "*" || day !== "*")
+        return null;
+    const everyNMinutes = /^\*\/(\d+)$/.exec(minute);
+    if (everyNMinutes && hour === "*") {
+        return parseInt(everyNMinutes[1], 10) * 60;
+    }
+    const everyNHours = /^\*\/(\d+)$/.exec(hour);
+    if (everyNHours && minute === "0") {
+        return parseInt(everyNHours[1], 10) * 3600;
+    }
+    return null;
+}
+function scheduleToCalendarInterval(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const [minute, hour, day, month] = parts;
+    const result = {};
+    if (minute !== "*" && !/^\*\//.test(minute))
+        result.Minute = parseInt(minute, 10);
+    if (hour !== "*" && !/^\*\//.test(hour))
+        result.Hour = parseInt(hour, 10);
+    if (day !== "*")
+        result.Day = parseInt(day, 10);
+    if (month !== "*")
+        result.Month = parseInt(month, 10);
+    return Object.keys(result).length > 0 ? result : null;
+}
+function generatePlistXml(job) {
+    const label = plistLabel(job);
+    const seconds = cadenceToSeconds(job.schedule);
+    const calendar = seconds === null ? scheduleToCalendarInterval(job.schedule) : null;
+    let triggerXml;
+    if (seconds !== null) {
+        triggerXml = `  <key>StartInterval</key>\n  <integer>${seconds}</integer>`;
+    }
+    else if (calendar !== null) {
+        const entries = Object.entries(calendar)
+            .map(([k, v]) => `      <key>${k}</key>\n      <integer>${v}</integer>`)
+            .join("\n");
+        triggerXml = `  <key>StartCalendarInterval</key>\n  <dict>\n${entries}\n  </dict>`;
+    }
+    else {
+        triggerXml = `  <key>StartInterval</key>\n  <integer>1800</integer>`;
+    }
+    return [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
+        `<plist version="1.0">`,
+        `<dict>`,
+        `  <key>Label</key>`,
+        `  <string>${label}</string>`,
+        `  <key>ProgramArguments</key>`,
+        `  <array>`,
+        `    <string>${job.command.split(" ")[0]}</string>`,
+        ...job.command.split(" ").slice(1).map((arg) => `    <string>${arg}</string>`),
+        `  </array>`,
+        triggerXml,
+        `  <key>StandardOutPath</key>`,
+        `  <string>/tmp/${label}.stdout.log</string>`,
+        `  <key>StandardErrorPath</key>`,
+        `  <string>/tmp/${label}.stderr.log</string>`,
+        `</dict>`,
+        `</plist>`,
+        ``,
+    ].join("\n");
+}
+class LaunchdCronManager {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get launchAgentsDir() {
+        return `${this.deps.homeDir}/Library/LaunchAgents`;
+    }
+    sync(jobs) {
+        this.deps.mkdirp(this.launchAgentsDir);
+        const desiredLabels = new Set(jobs.map(plistLabel));
+        // Remove stale plists
+        const existing = this.listPlistFiles();
+        for (const filename of existing) {
+            const label = filename.replace(".plist", "");
+            if (!desiredLabels.has(label)) {
+                const fullPath = `${this.launchAgentsDir}/${filename}`;
+                try {
+                    this.deps.exec(`launchctl unload "${fullPath}"`);
+                }
+                catch { /* best effort */ }
+                this.deps.removeFile(fullPath);
+            }
+        }
+        // Write current plists
+        for (const job of jobs) {
+            const label = plistLabel(job);
+            const filename = `${label}.plist`;
+            const fullPath = `${this.launchAgentsDir}/${filename}`;
+            const xml = generatePlistXml(job);
+            try {
+                this.deps.exec(`launchctl unload "${fullPath}"`);
+            }
+            catch { /* best effort */ }
+            this.deps.writeFile(fullPath, xml);
+            try {
+                this.deps.exec(`launchctl load "${fullPath}"`);
+            }
+            catch { /* best effort */ }
+        }
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.os_cron_synced", message: "synced OS cron entries", meta: { platform: "darwin", jobCount: jobs.length } });
+    }
+    removeAll() {
+        const existing = this.listPlistFiles();
+        for (const filename of existing) {
+            const fullPath = `${this.launchAgentsDir}/${filename}`;
+            try {
+                this.deps.exec(`launchctl unload "${fullPath}"`);
+            }
+            catch { /* best effort */ }
+            this.deps.removeFile(fullPath);
+        }
+    }
+    list() {
+        return this.listPlistFiles().map((f) => f.replace(".plist", ""));
+    }
+    listPlistFiles() {
+        if (!this.deps.existsFile(this.launchAgentsDir))
+            return [];
+        return this.deps.listDir(this.launchAgentsDir).filter((f) => f.startsWith(PLIST_PREFIX) && f.endsWith(".plist"));
+    }
+}
+exports.LaunchdCronManager = LaunchdCronManager;
+const CRONTAB_MARKER_PREFIX = "# ouro:";
+function crontabLine(job) {
+    return `${CRONTAB_MARKER_PREFIX}${job.id}\n${job.schedule} ${job.command}`;
+}
+class CrontabCronManager {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    sync(jobs) {
+        const currentLines = this.readCrontab();
+        const cleaned = this.removeOuroLines(currentLines);
+        const newLines = jobs.map(crontabLine);
+        const combined = [...cleaned, ...newLines].join("\n").trim();
+        this.deps.execWrite("crontab -", combined ? `${combined}\n` : "");
+    }
+    removeAll() {
+        const currentLines = this.readCrontab();
+        const cleaned = this.removeOuroLines(currentLines);
+        const combined = cleaned.join("\n").trim();
+        this.deps.execWrite("crontab -", combined ? `${combined}\n` : "");
+    }
+    list() {
+        const lines = this.readCrontab();
+        return lines
+            .filter((l) => l.startsWith(CRONTAB_MARKER_PREFIX))
+            .map((l) => l.slice(CRONTAB_MARKER_PREFIX.length));
+    }
+    readCrontab() {
+        try {
+            return this.deps.execOutput("crontab -l").split("\n");
+        }
+        catch {
+            return [];
+        }
+    }
+    removeOuroLines(lines) {
+        const result = [];
+        let skipNext = false;
+        for (const line of lines) {
+            if (line.startsWith(CRONTAB_MARKER_PREFIX)) {
+                skipNext = true;
+                continue;
+            }
+            if (skipNext) {
+                skipNext = false;
+                continue;
+            }
+            result.push(line);
+        }
+        return result;
+    }
+}
+exports.CrontabCronManager = CrontabCronManager;
+function createOsCronManager(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "darwin") {
+        /* v8 ignore start -- integration: default stubs for real OS operations @preserve */
+        const deps = options.launchdDeps ?? {
+            exec: () => { },
+            writeFile: () => { },
+            removeFile: () => { },
+            existsFile: () => false,
+            listDir: () => [],
+            mkdirp: () => { },
+            homeDir: os.homedir(),
+        };
+        /* v8 ignore stop */
+        return new LaunchdCronManager(deps);
+    }
+    const deps = options.crontabDeps ?? {
+        execOutput: () => "",
+        execWrite: () => { },
+    };
+    return new CrontabCronManager(deps);
+}