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

package/dist/heart/daemon/ouro-uti.js

@@ -0,0 +1,212 @@
+"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.registerOuroBundleUti = registerOuroBundleUti;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+const LSREGISTER_PATH = "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister";
+const ICON_SIZES = [16, 32, 128, 256, 512];
+function resolveIconSourcePath(repoRoot) {
+    return path.resolve(repoRoot, "..", "ouroboros-website", "public", "images", "ouroboros.png");
+}
+function buildIconAsset(iconSourcePath, icnsPath, iconsetDir, deps) {
+    try {
+        deps.mkdirSync(iconsetDir, { recursive: true });
+        for (const size of ICON_SIZES) {
+            const basePng = path.join(iconsetDir, `icon_${size}x${size}.png`);
+            const retinaPng = path.join(iconsetDir, `icon_${size}x${size}@2x.png`);
+            deps.execFileSync("sips", ["-z", String(size), String(size), iconSourcePath, "--out", basePng]);
+            deps.execFileSync("sips", ["-z", String(size * 2), String(size * 2), iconSourcePath, "--out", retinaPng]);
+        }
+        deps.execFileSync("iconutil", ["-c", "icns", iconsetDir, "-o", icnsPath]);
+        deps.rmSync(iconsetDir, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        deps.rmSync(iconsetDir, { recursive: true, force: true });
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_uti_icon_error",
+            message: "failed building .ouro icon; continuing without custom icon",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+        return false;
+    }
+}
+function buildInfoPlist(iconInstalled) {
+    const iconTag = iconInstalled ? "\n    <key>CFBundleTypeIconFile</key>\n    <string>ouro</string>" : "";
+    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>CFBundleIdentifier</key>",
+        "  <string>bot.ouro.bundle-registry</string>",
+        "  <key>CFBundleName</key>",
+        "  <string>Ouro Bundle Registry</string>",
+        "  <key>CFBundlePackageType</key>",
+        "  <string>APPL</string>",
+        "  <key>UTExportedTypeDeclarations</key>",
+        "  <array>",
+        "    <dict>",
+        "      <key>UTTypeIdentifier</key>",
+        "      <string>bot.ouro.bundle</string>",
+        "      <key>UTTypeConformsTo</key>",
+        "      <array>",
+        "        <string>public.folder</string>",
+        "      </array>",
+        "      <key>UTTypeTagSpecification</key>",
+        "      <dict>",
+        "        <key>public.filename-extension</key>",
+        "        <array>",
+        "          <string>ouro</string>",
+        "        </array>",
+        "      </dict>",
+        "    </dict>",
+        "  </array>",
+        "  <key>CFBundleDocumentTypes</key>",
+        "  <array>",
+        "    <dict>",
+        "      <key>CFBundleTypeName</key>",
+        "      <string>Ouro Agent Bundle</string>",
+        "      <key>LSItemContentTypes</key>",
+        "      <array>",
+        "        <string>bot.ouro.bundle</string>",
+        "      </array>",
+        "      <key>CFBundleTypeRole</key>",
+        "      <string>Editor</string>",
+        `      ${iconTag.trim()}`,
+        "    </dict>",
+        "  </array>",
+        "</dict>",
+        "</plist>",
+        "",
+    ]
+        .filter((line) => line.length > 0)
+        .join("\n");
+}
+function registerOuroBundleUti(deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    if (platform !== "darwin") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_uti_register_skip",
+            message: "skipped .ouro UTI registration on non-macOS platform",
+            meta: { platform },
+        });
+        return {
+            attempted: false,
+            registered: false,
+            iconInstalled: false,
+            skippedReason: "non-macos",
+        };
+    }
+    const homeDir = deps.homeDir ?? os.homedir();
+    const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const rmSync = deps.rmSync ?? fs.rmSync;
+    const exec = deps.execFileSync ?? ((file, args) => (0, child_process_1.execFileSync)(file, args));
+    const supportRoot = path.join(homeDir, "Library", "Application Support", "ouro", "uti");
+    const appBundlePath = path.join(supportRoot, "OuroBundleRegistry.app");
+    const contentsDir = path.join(appBundlePath, "Contents");
+    const resourcesDir = path.join(contentsDir, "Resources");
+    const plistPath = path.join(contentsDir, "Info.plist");
+    const icnsPath = path.join(resourcesDir, "ouro.icns");
+    const iconsetDir = path.join(supportRoot, "ouro.iconset");
+    const iconSourcePath = resolveIconSourcePath(repoRoot);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_uti_register_start",
+        message: "registering .ouro UTI on macOS",
+        meta: { appBundlePath },
+    });
+    let iconInstalled = false;
+    try {
+        mkdirSync(resourcesDir, { recursive: true });
+        if (existsSync(iconSourcePath)) {
+            iconInstalled = buildIconAsset(iconSourcePath, icnsPath, iconsetDir, {
+                mkdirSync,
+                rmSync,
+                execFileSync: exec,
+            });
+        }
+        else {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.ouro_uti_icon_skip",
+                message: "icon source image missing; continuing without custom icon",
+                meta: { iconSourcePath },
+            });
+        }
+        writeFileSync(plistPath, buildInfoPlist(iconInstalled), "utf-8");
+        exec(LSREGISTER_PATH, ["-f", appBundlePath]);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_uti_register_end",
+            message: "registered .ouro UTI on macOS",
+            meta: { iconInstalled },
+        });
+        return {
+            attempted: true,
+            registered: true,
+            iconInstalled,
+            registrationBundlePath: appBundlePath,
+        };
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_uti_register_error",
+            message: "failed .ouro UTI registration; continuing non-blocking",
+            meta: { reason },
+        });
+        return {
+            attempted: true,
+            registered: false,
+            iconInstalled,
+            skippedReason: reason,
+            registrationBundlePath: appBundlePath,
+        };
+    }
+}

package/dist/heart/daemon/process-manager.js

@@ -0,0 +1,237 @@
+"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.DaemonProcessManager = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const identity_1 = require("../identity");
+const runtime_1 = require("../../nerves/runtime");
+function startOfHour(ms) {
+    return ms - 60 * 60 * 1000;
+}
+class DaemonProcessManager {
+    agents = new Map();
+    maxRestartsPerHour;
+    stabilityThresholdMs;
+    initialBackoffMs;
+    maxBackoffMs;
+    spawnFn;
+    now;
+    setTimeoutFn;
+    clearTimeoutFn;
+    constructor(options) {
+        this.maxRestartsPerHour = options.maxRestartsPerHour ?? 10;
+        this.stabilityThresholdMs = options.stabilityThresholdMs ?? 60_000;
+        this.initialBackoffMs = options.initialBackoffMs ?? 1_000;
+        this.maxBackoffMs = options.maxBackoffMs ?? 60_000;
+        this.spawnFn = options.spawn ?? ((command, args, spawnOptions) => (0, child_process_1.spawn)(command, args, spawnOptions));
+        this.now = options.now ?? (() => Date.now());
+        this.setTimeoutFn = options.setTimeoutFn ?? ((cb, delay) => setTimeout(cb, delay));
+        this.clearTimeoutFn = options.clearTimeoutFn ?? ((timer) => clearTimeout(timer));
+        for (const agent of options.agents) {
+            this.agents.set(agent.name, {
+                config: agent,
+                process: null,
+                restartTimer: null,
+                crashTimestamps: [],
+                stopRequested: false,
+                snapshot: {
+                    name: agent.name,
+                    channel: agent.channel,
+                    status: "stopped",
+                    pid: null,
+                    restartCount: 0,
+                    startedAt: null,
+                    lastCrashAt: null,
+                    backoffMs: this.initialBackoffMs,
+                },
+            });
+        }
+    }
+    async startAutoStartAgents() {
+        for (const state of this.agents.values()) {
+            if (state.config.autoStart) {
+                await this.startAgent(state.config.name);
+            }
+        }
+    }
+    async startAgent(agent) {
+        const state = this.requireAgent(agent);
+        if (state.process)
+            return;
+        this.clearRestartTimer(state);
+        state.stopRequested = false;
+        state.snapshot.status = "starting";
+        const runCwd = (0, identity_1.getRepoRoot)();
+        const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
+        const args = [entryScript, "--agent", agent, ...(state.config.args ?? [])];
+        const child = this.spawnFn("node", args, {
+            cwd: runCwd,
+            env: state.config.env ? { ...process.env, ...state.config.env } : process.env,
+            stdio: ["ignore", "ignore", "ignore", "ipc"],
+        });
+        state.process = child;
+        state.snapshot.status = "running";
+        state.snapshot.pid = child.pid ?? null;
+        state.snapshot.startedAt = new Date(this.now()).toISOString();
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.agent_started",
+            message: "daemon started managed agent process",
+            meta: { agent, pid: child.pid ?? null, cwd: runCwd },
+        });
+        child.once("exit", (code, signal) => {
+            this.onExit(state, code, signal);
+        });
+    }
+    async stopAgent(agent) {
+        const state = this.requireAgent(agent);
+        this.clearRestartTimer(state);
+        state.stopRequested = true;
+        if (!state.process) {
+            state.snapshot.status = "stopped";
+            state.snapshot.pid = null;
+            return;
+        }
+        const child = state.process;
+        state.process = null;
+        state.snapshot.status = "stopped";
+        state.snapshot.pid = null;
+        try {
+            child.kill("SIGTERM");
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_stop_error",
+                message: "failed to send SIGTERM to managed agent",
+                meta: { agent },
+            });
+        }
+    }
+    async restartAgent(agent) {
+        await this.stopAgent(agent);
+        await this.startAgent(agent);
+    }
+    async stopAll() {
+        for (const state of this.agents.values()) {
+            await this.stopAgent(state.config.name);
+        }
+    }
+    sendToAgent(agent, message) {
+        const state = this.requireAgent(agent);
+        if (!state.process)
+            return;
+        try {
+            state.process.send(message);
+        }
+        catch {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_ipc_send_error",
+                message: "failed to send IPC message to managed agent",
+                meta: { agent },
+            });
+        }
+    }
+    getAgentSnapshot(agent) {
+        return this.agents.get(agent)?.snapshot;
+    }
+    listAgentSnapshots() {
+        return [...this.agents.values()].map((state) => state.snapshot);
+    }
+    onExit(state, code, signal) {
+        if (!state.process)
+            return;
+        state.process = null;
+        state.snapshot.pid = null;
+        const crashed = !state.stopRequested && code !== 0;
+        const now = this.now();
+        const startedAt = state.snapshot.startedAt ? Date.parse(state.snapshot.startedAt) : now;
+        const runDuration = Math.max(0, now - startedAt);
+        (0, runtime_1.emitNervesEvent)({
+            level: crashed ? "warn" : "info",
+            component: "daemon",
+            event: "daemon.agent_exit",
+            message: "managed agent process exited",
+            meta: { agent: state.config.name, code, signal, crashed, runDurationMs: runDuration },
+        });
+        if (!crashed) {
+            state.snapshot.status = "stopped";
+            if (runDuration >= this.stabilityThresholdMs) {
+                state.snapshot.backoffMs = this.initialBackoffMs;
+            }
+            return;
+        }
+        state.snapshot.lastCrashAt = new Date(now).toISOString();
+        state.crashTimestamps = state.crashTimestamps.filter((crashTs) => crashTs >= startOfHour(now));
+        state.crashTimestamps.push(now);
+        if (state.crashTimestamps.length > this.maxRestartsPerHour) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_restart_exhausted",
+                message: "managed agent exceeded restart limit and is marked crashed",
+                meta: { agent: state.config.name, maxRestartsPerHour: this.maxRestartsPerHour },
+            });
+            return;
+        }
+        state.snapshot.status = "starting";
+        state.snapshot.restartCount += 1;
+        const waitMs = state.snapshot.backoffMs;
+        state.snapshot.backoffMs = Math.min(state.snapshot.backoffMs * 2, this.maxBackoffMs);
+        this.clearRestartTimer(state);
+        state.restartTimer = this.setTimeoutFn(() => {
+            void this.startAgent(state.config.name);
+        }, waitMs);
+    }
+    clearRestartTimer(state) {
+        if (state.restartTimer === null)
+            return;
+        this.clearTimeoutFn(state.restartTimer);
+        state.restartTimer = null;
+    }
+    requireAgent(agent) {
+        const state = this.agents.get(agent);
+        if (!state) {
+            throw new Error(`Unknown managed agent '${agent}'.`);
+        }
+        return state;
+    }
+}
+exports.DaemonProcessManager = DaemonProcessManager;

package/dist/heart/daemon/runtime-logging.js

@@ -0,0 +1,102 @@
+"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.configureDaemonRuntimeLogger = configureDaemonRuntimeLogger;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const nerves_1 = require("../../nerves");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_RUNTIME_LOGGING = {
+    level: "info",
+    sinks: ["terminal", "ndjson"],
+};
+function defaultLevelForProcess(processName) {
+    return processName === "daemon" ? "info" : "warn";
+}
+function isLogLevel(value) {
+    return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+function resolveRuntimeLoggingConfig(configPath, processName) {
+    const defaultLevel = defaultLevelForProcess(processName);
+    let parsed = null;
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
+    }
+    if (!parsed || typeof parsed !== "object") {
+        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
+    }
+    const candidate = parsed;
+    const level = isLogLevel(candidate.level) ? candidate.level : defaultLevel;
+    const sinks = Array.isArray(candidate.sinks)
+        ? candidate.sinks.filter((entry) => entry === "terminal" || entry === "ndjson")
+        : DEFAULT_RUNTIME_LOGGING.sinks;
+    return {
+        level,
+        sinks: sinks.length > 0 ? [...new Set(sinks)] : [...DEFAULT_RUNTIME_LOGGING.sinks],
+    };
+}
+function configureDaemonRuntimeLogger(processName, options = {}) {
+    const homeDir = options.homeDir ?? os.homedir();
+    const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
+    const config = resolveRuntimeLoggingConfig(configPath, processName);
+    const sinks = config.sinks.map((sinkName) => {
+        if (sinkName === "terminal") {
+            return (0, nerves_1.createTerminalSink)();
+        }
+        const ndjsonPath = path.join(homeDir, ".agentstate", "daemon", "logs", `${processName}.ndjson`);
+        return (0, nerves_1.createNdjsonFileSink)(ndjsonPath);
+    });
+    const logger = (0, nerves_1.createLogger)({
+        level: config.level,
+        sinks,
+    });
+    (0, runtime_1.setRuntimeLogger)(logger);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_logger_configured",
+        message: "configured daemon runtime logger",
+        meta: {
+            processName,
+            level: config.level,
+            sinks: config.sinks,
+            configPath,
+        },
+    });
+}