@ouro.bot/cli 0.1.0-alpha.193 → 0.1.0-alpha.194

package/changelog.json

@@ -2,8 +2,14 @@
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
     {
-      "version": "0.1.0-alpha.193",
-      "changes": [
+      "version": "0.1.0-alpha.194",
+      "changes": [
+        "fix(daemon): self-spawn restart \u2014 no longer relies on launchd KeepAlive for staged restarts",
+        "fix(daemon): error boundary with circuit breaker \u2014 uncaught exceptions logged and survived, exits only after 10+ in 60s",
+        "fix(daemon): EPIPE suppression in uncaughtException handler",
+        "fix(daemon): 5-second force-exit timeouts on all shutdown paths",
+        "feat: human-facing and agent-facing provider configs",
+        "fix(auth): always refresh codex OAuth token, responses API verification",
         "feat: Outlook visibility \u2014 orientation, obligations, changes, self-fix, memory decisions, route migration to /"
       ]
     },

package/dist/heart/daemon/auth-flow.js

@@ -235,7 +235,7 @@ function readCodexAccessToken(homeDir) {
         const raw = fs.readFileSync(authPath, "utf8");
         const parsed = JSON.parse(raw);
         const token = parsed?.tokens?.access_token;
-        return typeof token === "string" ? token.trim() : "";
+        return typeof token === "string" ? token.trim() : /* v8 ignore next -- defensive: codex login always writes a string token @preserve */ "";
     }
     catch {
         return "";
@@ -302,25 +302,25 @@ async function collectRuntimeAuthCredentials(input, deps) {
         return { githubToken: token, baseUrl };
     }
     if (input.provider === "openai-codex") {
-        let token = readCodexAccessToken(homeDir);
+        // Always run codex login when auth is explicitly requested — stale tokens
+        // are indistinguishable from valid ones without an API call, and the user
+        // is asking to re-authenticate.
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.auth_codex_login_start",
+            message: "starting codex login for runtime auth",
+            meta: { agentName: input.agentName },
+        });
+        const result = spawnSync("codex", ["login"], { stdio: "inherit" });
+        if (result.error) {
+            throw new Error(`Failed to run 'codex login': ${result.error.message}`);
+        }
+        if (result.status !== 0) {
+            throw new Error(`'codex login' exited with status ${result.status}.`);
+        }
+        const token = readCodexAccessToken(homeDir);
         if (!token) {
-            (0, runtime_1.emitNervesEvent)({
-                component: "daemon",
-                event: "daemon.auth_codex_login_start",
-                message: "starting codex login for runtime auth",
-                meta: { agentName: input.agentName },
-            });
-            const result = spawnSync("codex", ["login"], { stdio: "inherit" });
-            if (result.error) {
-                throw new Error(`Failed to run 'codex login': ${result.error.message}`);
-            }
-            if (result.status !== 0) {
-                throw new Error(`'codex login' exited with status ${result.status}.`);
-            }
-            token = readCodexAccessToken(homeDir);
-            if (!token) {
-                throw new Error("Codex login completed but no token was found in ~/.codex/auth.json. Re-run `codex login` and try again.");
-            }
+            throw new Error("Codex login completed but no token was found in ~/.codex/auth.json. Re-run `codex login` and try again.");
         }
         return { oauthAccessToken: token };
     }

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

@@ -170,11 +170,9 @@ void daemon.start().then(() => {
         scheduler.watchForChanges();
         habitSchedulers.push(scheduler);
     }
+    /* v8 ignore start -- startup failure + signal handlers: call process.exit, untestable in vitest @preserve */
 }).catch(async (err) => {
-    /* v8 ignore stop */
-    /* v8 ignore start — instanceof branch defensive; catch always receives Error in practice @preserve */
     const error = err instanceof Error ? err : new Error(String(err));
-    /* v8 ignore stop */
     (0, daemon_tombstone_1.writeDaemonTombstone)("startupFailure", error);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
@@ -183,6 +181,7 @@ void daemon.start().then(() => {
         message: "daemon entrypoint failed",
         meta: { error: error.message },
     });
+    setTimeout(() => process.exit(1), 5_000).unref();
     await daemon.stop();
     process.exit(1);
 });
@@ -191,6 +190,7 @@ process.on("SIGINT", () => {
         s.stopWatching();
         s.stop();
     }
+    setTimeout(() => process.exit(1), 5_000).unref();
     void daemon.stop().then(() => process.exit(0));
 });
 process.on("SIGTERM", () => {
@@ -198,29 +198,46 @@ process.on("SIGTERM", () => {
         s.stopWatching();
         s.stop();
     }
+    setTimeout(() => process.exit(1), 5_000).unref();
     void daemon.stop().then(() => process.exit(0));
 });
+/* v8 ignore stop */
 // Suppress EPIPE on stdout/stderr — normal when detached daemon's parent exits
 /* v8 ignore start -- EPIPE suppression: only fires when parent process exits @preserve */
 process.stdout?.on?.("error", () => { });
 process.stderr?.on?.("error", () => { });
 /* v8 ignore stop */
 /* v8 ignore start -- global exception handlers: genuinely untestable in vitest; exercised by real daemon crashes @preserve */
+let _uncaughtCount = 0;
+const CIRCUIT_BREAKER_WINDOW_MS = 60_000;
+const CIRCUIT_BREAKER_MAX = 10;
 process.on("uncaughtException", (error) => {
     // EPIPE is normal for detached daemon processes — parent closed the pipe
     if (error.code === "EPIPE")
         return;
+    _uncaughtCount++;
+    setTimeout(() => { _uncaughtCount--; }, CIRCUIT_BREAKER_WINDOW_MS).unref();
     (0, daemon_tombstone_1.writeDaemonTombstone)("uncaughtException", error);
     (0, runtime_1.emitNervesEvent)({
         level: "error",
         component: "daemon",
         event: "daemon.uncaught_exception",
-        message: "uncaught exception in daemon process",
-        meta: { error: error.message, stack: error.stack ?? null },
+        message: "uncaught exception in daemon process (continuing)",
+        meta: { error: error.message, stack: error.stack ?? null, uncaughtCount: _uncaughtCount },
     });
-    // Graceful 5-second shutdown window
-    setTimeout(() => process.exit(1), 5_000).unref();
-    void daemon.stop().then(() => process.exit(1));
+    // Circuit breaker: if too many exceptions in a short window, the process
+    // is in a bad state — exit so launchd/self-spawn can restart fresh.
+    if (_uncaughtCount >= CIRCUIT_BREAKER_MAX) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.circuit_breaker_exit",
+            message: `daemon exiting: ${_uncaughtCount} uncaught exceptions in ${CIRCUIT_BREAKER_WINDOW_MS / 1000}s`,
+            meta: { uncaughtCount: _uncaughtCount },
+        });
+        setTimeout(() => process.exit(1), 5_000).unref();
+        void daemon.stop().then(() => process.exit(1));
+    }
 });
 process.on("unhandledRejection", (reason) => {
     (0, runtime_1.emitNervesEvent)({

package/dist/heart/daemon/daemon.js

@@ -236,6 +236,7 @@ class OuroDaemon {
         // Start periodic update checker (polls npm registry every 30 minutes)
         // Skip in dev mode — dev builds should not auto-update from npm
         const bundlesRoot = this.bundlesRoot;
+        const daemonSocketPath = this.socketPath;
         if (this.mode === "dev") {
             (0, runtime_1.emitNervesEvent)({
                 component: "daemon",
@@ -271,8 +272,19 @@ class OuroDaemon {
                             }
                         },
                         gracefulShutdown: () => daemon.stop(),
+                        spawnNewDaemon: (entryPath, sock) => {
+                            const outFd = fs.openSync(os.devNull, "w");
+                            const errFd = fs.openSync(os.devNull, "w");
+                            const child = (0, child_process_1.spawn)(process.execPath, [entryPath, "--socket", sock], {
+                                detached: true,
+                                stdio: ["ignore", outFd, errFd],
+                            });
+                            child.unref();
+                            return { pid: child.pid ?? null };
+                        },
                         nodePath: process.execPath,
                         bundlesRoot,
+                        socketPath: daemonSocketPath,
                     });
                 },
                 /* v8 ignore stop */

package/dist/heart/daemon/staged-restart.js

@@ -90,25 +90,49 @@ async function performStagedRestart(version, deps) {
         });
         return { ok: false, error: `hook runner exited with code ${spawnResult.status}` };
     }
-    // Step 4: Graceful shutdown (launchd will restart with new code)
+    // Step 4: Graceful shutdown then self-spawn new daemon
+    // We can't rely on launchd KeepAlive — the plist may not be loaded.
+    // Instead: shut down (releases socket), spawn new daemon from updated code.
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.staged_restart_hooks_passed",
-        message: "hooks passed, shutting down for restart",
+        message: "hooks passed, shutting down and spawning new daemon",
         meta: { version },
     });
+    let shutdownError;
     try {
         await deps.gracefulShutdown();
     }
     catch (err) {
-        const shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.staged_restart_shutdown_error",
-            message: "graceful shutdown encountered error",
+            message: "graceful shutdown encountered error (continuing with spawn)",
             meta: { version, error: shutdownError },
         });
-        return { ok: true, shutdownError };
     }
-    return { ok: true };
+    // Spawn new daemon from updated code path
+    const newEntry = path.join(newCodePath, "dist", "heart", "daemon", "daemon-entry.js");
+    const socketArg = deps.socketPath ?? "/tmp/ouroboros-daemon.sock";
+    try {
+        const { pid } = deps.spawnNewDaemon(newEntry, socketArg);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_spawned",
+            message: "new daemon spawned successfully",
+            meta: { version, pid, entry: newEntry },
+        });
+    }
+    catch (err) {
+        const spawnError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_respawn_failed",
+            message: "failed to spawn new daemon after shutdown",
+            meta: { version, error: spawnError, entry: newEntry },
+        });
+        return { ok: false, error: `shutdown succeeded but failed to spawn new daemon: ${spawnError}`, shutdownError };
+    }
+    return { ok: true, shutdownError };
 }

package/dist/heart/provider-ping.js

@@ -123,8 +123,14 @@ async function pingProvider(provider, config) {
                 const client = runtime.client;
                 await client.messages.create({ model: "claude-haiku-4-5-20251001", max_tokens: 1, messages: [{ role: "user", content: "ping" }] }, { signal: controller.signal, headers: { "anthropic-beta": "claude-code-20250219,oauth-2025-04-20" } });
             }
+            else if (provider === "openai-codex") {
+                // Codex uses the Responses API (chatgpt.com/backend-api/codex/responses),
+                // not the Chat Completions API. Ping via responses endpoint.
+                const client = runtime.client;
+                await client.responses.create({ model: runtime.model, input: "ping", store: false }, { signal: controller.signal });
+            }
             else {
-                // OpenAI-compatible providers (azure, codex, minimax, github-copilot)
+                // OpenAI-compatible providers (azure, minimax, github-copilot)
                 const client = runtime.client;
                 await client.chat.completions.create({ model: runtime.model, max_tokens: 1, messages: [{ role: "user", content: "ping" }] }, { signal: controller.signal });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.193",
+  "version": "0.1.0-alpha.194",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",