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

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../../nerves/runtime");
+const runtime_logging_1 = require("./runtime-logging");
+const ouro_bot_wrapper_1 = require("./ouro-bot-wrapper");
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("ouro-bot");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.ouro_bot_entry_start",
+    message: "starting ouro.bot wrapper entrypoint",
+    meta: { args: process.argv.slice(2) },
+});
+void (0, ouro_bot_wrapper_1.runOuroBotWrapper)(process.argv.slice(2)).catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.ouro_bot_entry_error",
+        message: "ouro.bot wrapper entrypoint failed",
+        meta: { error: error instanceof Error ? error.message : String(error) },
+    });
+    process.exit(1);
+});

package/dist/heart/daemon/ouro-bot-wrapper.js

@@ -0,0 +1,90 @@
+"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.runOuroBotWrapper = runOuroBotWrapper;
+const runtime_1 = require("../../nerves/runtime");
+const daemon_cli_1 = require("./daemon-cli");
+async function defaultLoadCanonicalRunner() {
+    const packageName = "@ouro.bot/cli";
+    const specifier = packageName;
+    const loaded = await Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
+    const candidate = Object.prototype.hasOwnProperty.call(loaded, "runOuroCli")
+        ? loaded["runOuroCli"]
+        : undefined;
+    if (typeof candidate === "function") {
+        return candidate;
+    }
+    throw new Error("@ouro.bot/cli does not export runOuroCli");
+}
+function defaultWriteStdout(_text) {
+    // Wrapper is intentionally silent by default to avoid duplicate terminal output.
+}
+async function runOuroBotWrapper(args, deps = {}) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_wrapper_start",
+        message: "starting ouro.bot wrapper delegation",
+        meta: { args },
+    });
+    const loadCanonicalRunner = deps.loadCanonicalRunner ?? defaultLoadCanonicalRunner;
+    const fallbackRunCli = deps.fallbackRunCli ?? daemon_cli_1.runOuroCli;
+    const writeStdout = deps.writeStdout ?? defaultWriteStdout;
+    let delegatedTo = "@ouro.bot/cli";
+    let runner = fallbackRunCli;
+    try {
+        runner = await loadCanonicalRunner();
+    }
+    catch (error) {
+        delegatedTo = "local-fallback";
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_bot_wrapper_fallback",
+            message: "canonical ouro.bot package unavailable; falling back to local CLI",
+            meta: { error: error instanceof Error ? error.message : String(error) },
+        });
+    }
+    const result = await runner(args);
+    if (result.trim().length > 0) {
+        writeStdout(result);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_wrapper_end",
+        message: "completed ouro.bot wrapper delegation",
+        meta: { delegatedTo },
+    });
+    return result;
+}

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

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const runtime_1 = require("../../nerves/runtime");
+const daemon_cli_1 = require("./daemon-cli");
+const runtime_logging_1 = require("./runtime-logging");
+(0, runtime_logging_1.configureDaemonRuntimeLogger)("ouro");
+(0, runtime_1.emitNervesEvent)({
+    component: "daemon",
+    event: "daemon.cli_entry_start",
+    message: "starting ouro CLI entrypoint",
+    meta: { args: process.argv.slice(2) },
+});
+void (0, daemon_cli_1.runOuroCli)(process.argv.slice(2)).catch((error) => {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "daemon",
+        event: "daemon.cli_entry_error",
+        message: "ouro CLI entrypoint failed",
+        meta: { error: error instanceof Error ? error.message : String(error) },
+    });
+    process.exit(1);
+});

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,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.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 isLogLevel(value) {
+    return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+function resolveRuntimeLoggingConfig(configPath) {
+    let parsed = null;
+    try {
+        const raw = fs.readFileSync(configPath, "utf-8");
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { ...DEFAULT_RUNTIME_LOGGING };
+    }
+    if (!parsed || typeof parsed !== "object") {
+        return { ...DEFAULT_RUNTIME_LOGGING };
+    }
+    const candidate = parsed;
+    const level = isLogLevel(candidate.level) ? candidate.level : DEFAULT_RUNTIME_LOGGING.level;
+    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);
+    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,
+        },
+    });
+}