@ouro.bot/cli 0.1.0-alpha.24 → 0.1.0-alpha.240

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

@@ -51,15 +51,23 @@ class DaemonProcessManager {
     now;
     setTimeoutFn;
     clearTimeoutFn;
+    cooldownRecoveryMs;
+    maxCooldownRetries;
+    existsSyncFn;
+    configCheckFn;
     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.cooldownRecoveryMs = options.cooldownRecoveryMs ?? 5 * 60 * 1_000;
+        this.maxCooldownRetries = options.maxCooldownRetries ?? 3;
         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));
+        this.existsSyncFn = options.existsSync ?? null;
+        this.configCheckFn = options.configCheck ?? null;
         for (const agent of options.agents) {
             this.agents.set(agent.name, {
                 config: agent,
@@ -67,6 +75,9 @@ class DaemonProcessManager {
                 restartTimer: null,
                 crashTimestamps: [],
                 stopRequested: false,
+                cooldownTimer: null,
+                cooldownRetryCount: 0,
+                fastCrashCount: 0,
                 snapshot: {
                     name: agent.name,
                     channel: agent.channel,
@@ -76,6 +87,8 @@ class DaemonProcessManager {
                     startedAt: null,
                     lastCrashAt: null,
                     backoffMs: this.initialBackoffMs,
+                    lastExitCode: null,
+                    lastSignal: null,
                 },
             });
         }
@@ -94,14 +107,47 @@ class DaemonProcessManager {
         this.clearRestartTimer(state);
         state.stopRequested = false;
         state.snapshot.status = "starting";
+        if (this.configCheckFn) {
+            const result = this.configCheckFn(agent);
+            if (!result.ok) {
+                state.snapshot.status = "crashed";
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_config_invalid",
+                    message: result.error ?? "agent config validation failed",
+                    meta: { agent, fix: result.fix ?? null },
+                });
+                process.stderr.write(`[daemon] ${agent}: ${result.error}\n` +
+                    (result.fix ? `  Fix: ${result.fix}\n` : ""));
+                return;
+            }
+        }
         const runCwd = (0, identity_1.getRepoRoot)();
         const entryScript = path.join((0, identity_1.getRepoRoot)(), "dist", state.config.entry);
+        if (this.existsSyncFn && !this.existsSyncFn(entryScript)) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_entry_missing",
+                message: "agent entry script does not exist — cannot spawn. Run 'ouro daemon install' from the correct location.",
+                meta: { agent, entryScript },
+            });
+            return;
+        }
         const args = [entryScript, "--agent", state.config.agentArg ?? 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"],
         });
+        /* v8 ignore next 7 -- defensive: spawn should always return a ChildProcess @preserve */
+        if (!child) {
+            state.snapshot.status = "crashed";
+            (0, runtime_1.emitNervesEvent)({ level: "error", component: "daemon", event: "daemon.agent_spawn_failed", message: "spawn returned null", meta: { agent } });
+            return;
+        }
         state.process = child;
         state.snapshot.status = "running";
         state.snapshot.pid = child.pid ?? null;
@@ -112,6 +158,17 @@ class DaemonProcessManager {
             message: "daemon started managed agent process",
             meta: { agent, pid: child.pid ?? null, cwd: runCwd },
         });
+        /* v8 ignore start — child process error handler; requires real spawn to trigger */
+        child.on("error", (err) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.agent_process_error",
+                message: "managed agent process emitted error",
+                meta: { agent, error: err.message },
+            });
+        });
+        /* v8 ignore stop */
         child.once("exit", (code, signal) => {
             this.onExit(state, code, signal);
         });
@@ -119,6 +176,7 @@ class DaemonProcessManager {
     async stopAgent(agent) {
         const state = this.requireAgent(agent);
         this.clearRestartTimer(state);
+        this.clearCooldownTimer(state);
         state.stopRequested = true;
         if (!state.process) {
             state.snapshot.status = "stopped";
@@ -179,6 +237,8 @@ class DaemonProcessManager {
             return;
         state.process = null;
         state.snapshot.pid = null;
+        state.snapshot.lastExitCode = code;
+        state.snapshot.lastSignal = signal;
         const crashed = !state.stopRequested && code !== 0;
         const now = this.now();
         const startedAt = state.snapshot.startedAt ? Date.parse(state.snapshot.startedAt) : now;
@@ -198,6 +258,29 @@ class DaemonProcessManager {
             return;
         }
         state.snapshot.lastCrashAt = new Date(now).toISOString();
+        // Fast-crash detection: if the agent dies within 5 seconds of starting, it's likely
+        // a configuration issue (missing credentials, bad provider, etc.) not a transient failure.
+        // After 3 consecutive fast crashes, stop retrying and mark as config-failed.
+        const FAST_CRASH_THRESHOLD_MS = 5000;
+        const FAST_CRASH_MAX = 3;
+        if (runDuration < FAST_CRASH_THRESHOLD_MS) {
+            state.fastCrashCount = state.fastCrashCount + 1;
+            if (state.fastCrashCount >= FAST_CRASH_MAX) {
+                state.snapshot.status = "crashed";
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "daemon",
+                    event: "daemon.agent_config_failure",
+                    message: `agent crashed ${FAST_CRASH_MAX} times within ${FAST_CRASH_THRESHOLD_MS}ms of startup — likely a configuration issue (missing credentials, bad provider). Not retrying. Fix the config and run \`ouro up\` to restart.`,
+                    meta: { agent: state.config.name, fastCrashCount: state.fastCrashCount, avgRunDurationMs: runDuration },
+                });
+                return; // Don't schedule cooldown recovery — this needs human/agent intervention
+            }
+        }
+        else {
+            // Reset fast-crash counter on a stable run
+            state.fastCrashCount = 0;
+        }
         state.crashTimestamps = state.crashTimestamps.filter((crashTs) => crashTs >= startOfHour(now));
         state.crashTimestamps.push(now);
         if (state.crashTimestamps.length > this.maxRestartsPerHour) {
@@ -209,6 +292,7 @@ class DaemonProcessManager {
                 message: "managed agent exceeded restart limit and is marked crashed",
                 meta: { agent: state.config.name, maxRestartsPerHour: this.maxRestartsPerHour },
             });
+            this.scheduleCooldownRecovery(state);
             return;
         }
         state.snapshot.status = "starting";
@@ -226,6 +310,45 @@ class DaemonProcessManager {
         this.clearTimeoutFn(state.restartTimer);
         state.restartTimer = null;
     }
+    scheduleCooldownRecovery(state) {
+        if (state.cooldownRetryCount >= this.maxCooldownRetries) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.agent_permanent_failure",
+                message: "managed agent exhausted all cooldown retries — permanently stopped",
+                meta: { agent: state.config.name, cooldownRetryCount: state.cooldownRetryCount, maxCooldownRetries: this.maxCooldownRetries },
+            });
+            return;
+        }
+        this.clearCooldownTimer(state);
+        state.cooldownTimer = this.setTimeoutFn(() => {
+            state.cooldownRetryCount += 1;
+            state.crashTimestamps = [];
+            state.snapshot.backoffMs = this.initialBackoffMs;
+            state.snapshot.status = "starting";
+            state.snapshot.restartCount += 1;
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.agent_cooldown_recovery",
+                message: "attempting cooldown recovery for managed agent",
+                meta: { agent: state.config.name, cooldownRetryCount: state.cooldownRetryCount },
+            });
+            void this.startAgent(state.config.name);
+        }, this.cooldownRecoveryMs);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.agent_cooldown_scheduled",
+            message: `scheduled cooldown recovery in ${this.cooldownRecoveryMs}ms`,
+            meta: { agent: state.config.name, cooldownRecoveryMs: this.cooldownRecoveryMs, cooldownRetryCount: state.cooldownRetryCount },
+        });
+    }
+    clearCooldownTimer(state) {
+        if (state.cooldownTimer === null)
+            return;
+        this.clearTimeoutFn(state.cooldownTimer);
+        state.cooldownTimer = null;
+    }
     requireAgent(agent) {
         const state = this.agents.get(agent);
         if (!state) {

package/dist/heart/daemon/run-hooks.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runHooks = runHooks;
 const runtime_1 = require("../../nerves/runtime");
 const bundle_meta_1 = require("./hooks/bundle-meta");
+const agent_config_v2_1 = require("./hooks/agent-config-v2");
 async function runHooks(deps) {
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
@@ -12,6 +13,7 @@ async function runHooks(deps) {
     });
     try {
         deps.registerUpdateHook(bundle_meta_1.bundleMetaHook);
+        deps.registerUpdateHook(agent_config_v2_1.agentConfigV2Hook);
         const currentVersion = deps.getPackageVersion();
         await deps.applyPendingUpdates(deps.bundlesRoot, currentVersion);
         (0, runtime_1.emitNervesEvent)({

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

@@ -35,52 +35,95 @@ var __importStar = (this && this.__importStar) || (function () {
 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 = {
+const identity_1 = require("../identity");
+const LEGACY_SHARED_RUNTIME_LOGGING = {
     level: "info",
     sinks: ["terminal", "ndjson"],
 };
-function defaultLevelForProcess(processName) {
-    return processName === "daemon" ? "info" : "warn";
+function defaultLoggingForProcess(processName) {
+    if (processName === "ouro" || processName === "ouro-bot") {
+        return {
+            level: "info",
+            sinks: ["ndjson"],
+        };
+    }
+    if (processName === "bluebubbles") {
+        return {
+            level: "warn",
+            sinks: ["terminal", "ndjson"],
+        };
+    }
+    return { ...LEGACY_SHARED_RUNTIME_LOGGING };
 }
 function isLogLevel(value) {
     return value === "debug" || value === "info" || value === "warn" || value === "error";
 }
+function normalizeSinks(value, fallback) {
+    if (!Array.isArray(value)) {
+        return [...fallback];
+    }
+    const sinks = value.filter((entry) => entry === "terminal" || entry === "ndjson");
+    return sinks.length > 0 ? [...new Set(sinks)] : [...fallback];
+}
+function isLegacySharedDefaultConfig(candidate, normalizedLevel, normalizedSinks) {
+    return normalizedLevel === LEGACY_SHARED_RUNTIME_LOGGING.level
+        && normalizedSinks.length === LEGACY_SHARED_RUNTIME_LOGGING.sinks.length
+        && LEGACY_SHARED_RUNTIME_LOGGING.sinks.every((sink) => normalizedSinks.includes(sink))
+        && Object.keys(candidate).every((key) => key === "level" || key === "sinks");
+}
 function resolveRuntimeLoggingConfig(configPath, processName) {
-    const defaultLevel = defaultLevelForProcess(processName);
+    const processDefault = defaultLoggingForProcess(processName);
     let parsed = null;
     try {
         const raw = fs.readFileSync(configPath, "utf-8");
         parsed = JSON.parse(raw);
     }
     catch {
-        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
+        return { ...processDefault };
     }
     if (!parsed || typeof parsed !== "object") {
-        return { ...DEFAULT_RUNTIME_LOGGING, level: defaultLevel };
+        return { ...processDefault };
     }
     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;
+    const level = isLogLevel(candidate.level) ? candidate.level : processDefault.level;
+    const sinks = normalizeSinks(candidate.sinks, processDefault.sinks);
+    if ((processName === "ouro" || processName === "ouro-bot")
+        && isLegacySharedDefaultConfig(candidate, level, sinks)) {
+        return { ...processDefault };
+    }
     return {
         level,
-        sinks: sinks.length > 0 ? [...new Set(sinks)] : [...DEFAULT_RUNTIME_LOGGING.sinks],
+        sinks,
     };
 }
+function resolveAgentNameForPaths(explicit) {
+    if (explicit && explicit.trim().length > 0)
+        return explicit.trim();
+    try {
+        return (0, identity_1.getAgentName)();
+    }
+    catch {
+        return "slugger";
+    }
+}
 function configureDaemonRuntimeLogger(processName, options = {}) {
-    const homeDir = options.homeDir ?? os.homedir();
-    const configPath = options.configPath ?? path.join(homeDir, ".agentstate", "daemon", "logging.json");
+    const agentName = resolveAgentNameForPaths(options.agentName);
+    const configPath = options.configPath
+        ?? (options.homeDir
+            ? path.join(options.homeDir, "AgentBundles", `${agentName}.ouro`, "state", "daemon", "logging.json")
+            : (0, identity_1.getAgentDaemonLoggingConfigPath)(agentName));
     const config = resolveRuntimeLoggingConfig(configPath, processName);
+    const logsDir = options.homeDir
+        ? path.join(options.homeDir, "AgentBundles", `${agentName}.ouro`, "state", "daemon", "logs")
+        : (0, identity_1.getAgentDaemonLogsDir)(agentName);
     const sinks = config.sinks.map((sinkName) => {
         if (sinkName === "terminal") {
             return (0, nerves_1.createTerminalSink)();
         }
-        const ndjsonPath = path.join(homeDir, ".agentstate", "daemon", "logs", `${processName}.ndjson`);
+        const ndjsonPath = path.join(logsDir, `${processName}.ndjson`);
         return (0, nerves_1.createNdjsonFileSink)(ndjsonPath);
     });
     const logger = (0, nerves_1.createLogger)({

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

@@ -34,7 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRuntimeMetadata = getRuntimeMetadata;
+const crypto_1 = require("crypto");
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const childProcess = __importStar(require("child_process"));
 const identity_1 = require("../identity");
@@ -85,10 +87,98 @@ function readLastUpdated(repoRoot, packageJsonPath, statSyncImpl, execFileSyncIm
         return { value: UNKNOWN_METADATA, source: "unknown" };
     }
 }
+function readHomeDir() {
+    const homedirImpl = optionalFunction(os, "homedir");
+    if (!homedirImpl) {
+        return null;
+    }
+    try {
+        return homedirImpl.call(os);
+    }
+    catch {
+        return null;
+    }
+}
+function listConfigTargets(bundlesRoot, secretsRoot, daemonLoggingPath, readdirSyncImpl) {
+    if (!readdirSyncImpl)
+        return [];
+    const targets = new Set();
+    if (daemonLoggingPath) {
+        targets.add(daemonLoggingPath);
+    }
+    try {
+        const bundleEntries = readdirSyncImpl(bundlesRoot, { withFileTypes: true });
+        for (const entry of bundleEntries) {
+            if (!entry.isDirectory() || !entry.name.endsWith(".ouro"))
+                continue;
+            targets.add(path.join(bundlesRoot, entry.name, "agent.json"));
+        }
+    }
+    catch {
+        // ignore unreadable bundle roots
+    }
+    if (secretsRoot) {
+        try {
+            const secretEntries = readdirSyncImpl(secretsRoot, { withFileTypes: true });
+            for (const entry of secretEntries) {
+                if (!entry.isDirectory())
+                    continue;
+                targets.add(path.join(secretsRoot, entry.name, "secrets.json"));
+            }
+        }
+        catch {
+            // ignore unreadable secrets roots
+        }
+    }
+    return [...targets].sort();
+}
+function readConfigFingerprint(targets, readFileSyncImpl, existsSyncImpl) {
+    if (!readFileSyncImpl || !existsSyncImpl) {
+        return {
+            value: UNKNOWN_METADATA,
+            source: "unknown",
+            trackedFiles: targets.length,
+            presentFiles: 0,
+        };
+    }
+    const hash = (0, crypto_1.createHash)("sha256");
+    let presentFiles = 0;
+    for (const target of targets) {
+        hash.update(target);
+        hash.update("\0");
+        if (!existsSyncImpl(target)) {
+            hash.update("missing");
+            hash.update("\0");
+            continue;
+        }
+        presentFiles += 1;
+        hash.update("present");
+        hash.update("\0");
+        try {
+            hash.update(readFileSyncImpl(target, "utf-8"));
+        }
+        catch {
+            hash.update("unreadable");
+        }
+        hash.update("\0");
+    }
+    return {
+        value: hash.digest("hex"),
+        source: "content-hash",
+        trackedFiles: targets.length,
+        presentFiles,
+    };
+}
 function getRuntimeMetadata(deps = {}) {
     const repoRoot = deps.repoRoot ?? (0, identity_1.getRepoRoot)();
+    const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
+    const homeDir = readHomeDir();
+    const secretsRoot = deps.secretsRoot ?? (homeDir ? path.join(homeDir, ".agentsecrets") : null);
+    const daemonLoggingPath = deps.daemonLoggingPath ?? (0, identity_1.getAgentDaemonLoggingConfigPath)();
     const readFileSyncImpl = deps.readFileSync ?? optionalFunction(fs, "readFileSync")?.bind(fs) ?? null;
     const statSyncImpl = deps.statSync ?? optionalFunction(fs, "statSync")?.bind(fs) ?? null;
+    const readdirSyncImpl = deps.readdirSync ?? optionalFunction(fs, "readdirSync")?.bind(fs) ?? null;
+    const existsSyncImpl = deps.existsSync ?? optionalFunction(fs, "existsSync")?.bind(fs) ?? null;
     const execFileSyncImpl = deps.execFileSync
         ?? optionalFunction(childProcess, "execFileSync")?.bind(childProcess)
         ?? null;
@@ -101,6 +191,8 @@ function getRuntimeMetadata(deps = {}) {
             throw new Error("git unavailable");
         }))
         : { value: UNKNOWN_METADATA, source: "unknown" };
+    const configTargets = listConfigTargets(bundlesRoot, secretsRoot, daemonLoggingPath, readdirSyncImpl);
+    const configFingerprint = readConfigFingerprint(configTargets, readFileSyncImpl, existsSyncImpl);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.runtime_metadata_read",
@@ -109,10 +201,19 @@ function getRuntimeMetadata(deps = {}) {
             version,
             lastUpdated: lastUpdated.value,
             lastUpdatedSource: lastUpdated.source,
+            repoRoot,
+            configFingerprint: configFingerprint.value === UNKNOWN_METADATA
+                ? UNKNOWN_METADATA
+                : configFingerprint.value.slice(0, 12),
+            configFingerprintSource: configFingerprint.source,
+            configTrackedFiles: configFingerprint.trackedFiles,
+            configPresentFiles: configFingerprint.presentFiles,
         },
     });
     return {
         version,
         lastUpdated: lastUpdated.value,
+        repoRoot,
+        configFingerprint: configFingerprint.value,
     };
 }

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

@@ -0,0 +1,67 @@
+"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.detectRuntimeMode = detectRuntimeMode;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function detectRuntimeMode(rootPath, deps = {}) {
+    const checkExists = deps.existsSync ?? fs.existsSync;
+    // 1. Production: installed via npm
+    if (rootPath.includes("node_modules/@ouro.bot/cli") ||
+        rootPath.includes("node_modules/ouro.bot")) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.runtime_mode_detected",
+            message: "detected runtime mode",
+            meta: { rootPath, mode: "production" },
+        });
+        return "production";
+    }
+    // 2-4. Everything else is dev: worktrees, git repos, unknown paths
+    // (conservative default: assume dev unless proven production)
+    const reason = rootPath.includes(".claude/worktrees/")
+        ? "worktree"
+        : checkExists(path.join(rootPath, ".git"))
+            ? "git-repo"
+            : "unknown";
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.runtime_mode_detected",
+        message: "detected runtime mode",
+        meta: { rootPath, mode: "dev", reason },
+    });
+    return "dev";
+}