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

package/dist/heart/daemon/daemon-entry.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const process_manager_1 = require("./process-manager");
+const daemon_1 = require("./daemon");
+const runtime_1 = require("../../nerves/runtime");
+const message_router_1 = require("./message-router");
+const health_monitor_1 = require("./health-monitor");
+const task_scheduler_1 = require("./task-scheduler");
+const runtime_logging_1 = require("./runtime-logging");
+function parseSocketPath(argv) {
+    const socketIndex = argv.indexOf("--socket");
+    if (socketIndex >= 0) {
+        const value = argv[socketIndex + 1];
+        if (value && value.trim().length > 0)
+            return value;
+    }
+    return "/tmp/ouroboros-daemon.sock";
+}
+const socketPath = parseSocketPath(process.argv);
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("daemon");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.entry_start",
+    message: "starting daemon entrypoint",
+    meta: { socketPath },
+});
+const processManager = new process_manager_1.DaemonProcessManager({
+    agents: [
+        { name: "ouroboros", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
+        { name: "slugger", entry: "heart/agent-entry.js", channel: "cli", autoStart: true },
+    ],
+});
+const scheduler = new task_scheduler_1.TaskDrivenScheduler({
+    agents: ["ouroboros", "slugger"],
+});
+const router = new message_router_1.FileMessageRouter();
+const healthMonitor = new health_monitor_1.HealthMonitor({
+    processManager,
+    scheduler,
+    alertSink: (message) => {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.health_alert",
+            message: "health monitor produced critical alert",
+            meta: { message },
+        });
+    },
+});
+const daemon = new daemon_1.OuroDaemon({
+    socketPath,
+    processManager,
+    scheduler,
+    healthMonitor,
+    router,
+});
+void daemon.start().catch(async () => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.entry_error",
+        message: "daemon entrypoint failed",
+        meta: {},
+    });
+    await daemon.stop();
+    process.exit(1);
+});
+process.on("SIGINT", () => {
+    void daemon.stop().then(() => process.exit(0));
+});
+process.on("SIGTERM", () => {
+    void daemon.stop().then(() => process.exit(0));
+});

package/dist/heart/daemon/daemon.js

@@ -0,0 +1,313 @@
+"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.OuroDaemon = void 0;
+const fs = __importStar(require("fs"));
+const net = __importStar(require("net"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function formatStatusSummary(snapshots) {
+    if (snapshots.length === 0)
+        return "no managed agents";
+    return snapshots
+        .map((snapshot) => {
+        return `${snapshot.name}\t${snapshot.channel}\t${snapshot.status}\tpid=${snapshot.pid ?? "none"}\trestarts=${snapshot.restartCount}`;
+    })
+        .join("\n");
+}
+function parseIncomingCommand(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Invalid daemon command payload: expected JSON object.");
+    }
+    if (!parsed || typeof parsed !== "object" || !("kind" in parsed)) {
+        throw new Error("Invalid daemon command payload: missing kind.");
+    }
+    const kind = parsed.kind;
+    if (typeof kind !== "string") {
+        throw new Error("Invalid daemon command payload: kind must be a string.");
+    }
+    return parsed;
+}
+class OuroDaemon {
+    socketPath;
+    processManager;
+    scheduler;
+    healthMonitor;
+    router;
+    bundlesRoot;
+    server = null;
+    constructor(options) {
+        this.socketPath = options.socketPath;
+        this.processManager = options.processManager;
+        this.scheduler = options.scheduler;
+        this.healthMonitor = options.healthMonitor;
+        this.router = options.router;
+        this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    }
+    async start() {
+        if (this.server)
+            return;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.server_start",
+            message: "starting daemon server",
+            meta: { socketPath: this.socketPath },
+        });
+        await this.processManager.startAutoStartAgents();
+        this.scheduler.start?.();
+        await this.scheduler.reconcile?.();
+        await this.drainPendingBundleMessages();
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+        this.server = net.createServer((connection) => {
+            let raw = "";
+            let responded = false;
+            const flushResponse = async () => {
+                if (responded)
+                    return;
+                responded = true;
+                const response = await this.handleRawPayload(raw);
+                connection.end(response);
+            };
+            connection.on("data", (chunk) => {
+                raw += chunk.toString("utf-8");
+                void flushResponse();
+            });
+            connection.on("end", () => {
+                void flushResponse();
+            });
+        });
+        const server = this.server;
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(this.socketPath, () => resolve());
+        });
+    }
+    async drainPendingBundleMessages() {
+        if (!fs.existsSync(this.bundlesRoot))
+            return;
+        let bundleDirs;
+        try {
+            bundleDirs = fs.readdirSync(this.bundlesRoot, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const bundleDir of bundleDirs) {
+            if (!bundleDir.isDirectory() || !bundleDir.name.endsWith(".ouro"))
+                continue;
+            const pendingPath = path.join(this.bundlesRoot, bundleDir.name, "inbox", "pending.jsonl");
+            if (!fs.existsSync(pendingPath))
+                continue;
+            const raw = fs.readFileSync(pendingPath, "utf-8");
+            const lines = raw
+                .split("\n")
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0);
+            const retained = [];
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    if (typeof parsed.from !== "string" ||
+                        typeof parsed.to !== "string" ||
+                        typeof parsed.content !== "string") {
+                        retained.push(line);
+                        continue;
+                    }
+                    await this.router.send({
+                        from: parsed.from,
+                        to: parsed.to,
+                        content: parsed.content,
+                        priority: typeof parsed.priority === "string" ? parsed.priority : undefined,
+                        sessionId: typeof parsed.sessionId === "string" ? parsed.sessionId : undefined,
+                        taskRef: typeof parsed.taskRef === "string" ? parsed.taskRef : undefined,
+                    });
+                }
+                catch {
+                    retained.push(line);
+                }
+            }
+            const next = retained.length > 0 ? `${retained.join("\n")}\n` : "";
+            fs.writeFileSync(pendingPath, next, "utf-8");
+        }
+    }
+    async stop() {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.server_stop",
+            message: "stopping daemon server",
+            meta: { socketPath: this.socketPath },
+        });
+        this.scheduler.stop?.();
+        await this.processManager.stopAll();
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server?.close(() => resolve());
+            });
+            this.server = null;
+        }
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+    }
+    async handleRawPayload(raw) {
+        try {
+            const command = parseIncomingCommand(raw);
+            const response = await this.handleCommand(command);
+            return JSON.stringify(response);
+        }
+        catch (error) {
+            return JSON.stringify({
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async handleCommand(command) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.command_received",
+            message: "handling daemon command",
+            meta: { kind: command.kind },
+        });
+        switch (command.kind) {
+            case "daemon.start":
+                await this.start();
+                return { ok: true, message: "daemon started" };
+            case "daemon.stop":
+                await this.stop();
+                return { ok: true, message: "daemon stopped" };
+            case "daemon.status": {
+                const snapshots = this.processManager.listAgentSnapshots();
+                return {
+                    ok: true,
+                    summary: formatStatusSummary(snapshots),
+                    data: snapshots,
+                };
+            }
+            case "daemon.health": {
+                const checks = await this.healthMonitor.runChecks();
+                const summary = checks.map((check) => `${check.name}:${check.status}:${check.message}`).join("\n");
+                return { ok: true, summary, data: checks };
+            }
+            case "daemon.logs":
+                return {
+                    ok: true,
+                    summary: "logs: use `ouro logs` to tail daemon and agent output",
+                    message: "log streaming available via ouro logs",
+                    data: { logDir: "~/.agentstate/daemon/logs" },
+                };
+            case "agent.start":
+                await this.processManager.startAgent(command.agent);
+                return { ok: true, message: `started ${command.agent}` };
+            case "agent.stop":
+                await this.processManager.stopAgent?.(command.agent);
+                return { ok: true, message: `stopped ${command.agent}` };
+            case "agent.restart":
+                await this.processManager.restartAgent?.(command.agent);
+                return { ok: true, message: `restarted ${command.agent}` };
+            case "cron.list": {
+                const jobs = this.scheduler.listJobs();
+                const summary = jobs.length === 0
+                    ? "no cron jobs"
+                    : jobs.map((job) => `${job.id}\t${job.schedule}\tlast=${job.lastRun ?? "never"}`).join("\n");
+                return { ok: true, summary, data: jobs };
+            }
+            case "cron.trigger": {
+                const result = await this.scheduler.triggerJob(command.jobId);
+                return { ok: result.ok, message: result.message };
+            }
+            case "message.send": {
+                const receipt = await this.router.send({
+                    from: command.from,
+                    to: command.to,
+                    content: command.content,
+                    priority: command.priority,
+                    sessionId: command.sessionId,
+                    taskRef: command.taskRef,
+                });
+                this.processManager.sendToAgent?.(command.to, { type: "message" });
+                return { ok: true, message: `queued message ${receipt.id}`, data: receipt };
+            }
+            case "message.poll": {
+                const messages = this.router.pollInbox(command.agent);
+                return {
+                    ok: true,
+                    summary: `${messages.length} messages`,
+                    data: messages,
+                };
+            }
+            case "chat.connect":
+                await this.processManager.startAgent(command.agent);
+                return {
+                    ok: true,
+                    message: `connected to ${command.agent}`,
+                };
+            case "task.poke": {
+                const receipt = await this.router.send({
+                    from: "ouro-poke",
+                    to: command.agent,
+                    content: `poke ${command.taskId}`,
+                    priority: "high",
+                    taskRef: command.taskId,
+                });
+                await this.scheduler.recordTaskRun?.(command.agent, command.taskId);
+                this.processManager.sendToAgent?.(command.agent, { type: "poke", taskId: command.taskId });
+                return {
+                    ok: true,
+                    message: `queued poke ${receipt.id}`,
+                    data: receipt,
+                };
+            }
+            case "hatch.start":
+                return {
+                    ok: true,
+                    message: "hatch flow is stubbed in Gate 3 and completed in Gate 6",
+                };
+            default:
+                return {
+                    ok: false,
+                    error: `Unknown daemon command kind '${command.kind}'.`,
+                };
+        }
+    }
+}
+exports.OuroDaemon = OuroDaemon;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.playHatchAnimation = playHatchAnimation;
+const runtime_1 = require("../../nerves/runtime");
+const EGG = "\uD83E\uDD5A";
+const SNAKE = "\uD83D\uDC0D";
+const DOTS = " . . . ";
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Play the hatch animation: egg -> dots -> snake + name.
+ * The writer function receives each chunk. Default writer is process.stderr.write.
+ */
+async function playHatchAnimation(hatchlingName, writer) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.hatch_animation_start",
+        message: "playing hatch animation",
+        meta: { hatchlingName },
+    });
+    const write = writer ?? ((text) => process.stderr.write(text));
+    write(`\n  ${EGG}`);
+    await wait(400);
+    write(DOTS);
+    await wait(400);
+    write(`${SNAKE} \x1b[1m${hatchlingName}\x1b[0m\n\n`);
+}