@ouro.bot/cli 0.1.0-alpha.252 → 0.1.0-alpha.253

package/changelog.json

@@ -1,6 +1,13 @@
 {
   "_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.253",
+      "changes": [
+        "fix(daemon): test-isolation guard \u2014 stop tests from leaking real `inner.wake` commands into the running daemon. A pattern in 36+ test files mocks `getAgentName` to the literal `\"testagent\"` but does NOT mock `socket-client`, so any code path through pondering / rest / coding feedback fires a real socket connection at /tmp/ouroboros-daemon.sock with `inner.wake testagent`. The daemon errored on every command (`Unknown managed agent 'testagent'`) and at flood volumes that contributed to a real outage on the developer's machine. The fix is in `socket-client.ts` itself: detect vitest via `process.argv` (no env vars) and convert all socket operations into safe no-ops. Tests that legitimately exercise the real transport (socket-client.test.ts, daemon-cli-defaults.test.ts) opt out of the guard via a new `__bypassVitestGuardForTests()` setter that lives on globalThis to survive `vi.resetModules()`. New nerves events: `daemon.socket_command_test_blocked`, `daemon.inner_wake_test_blocked`.",
+        "test(contract): new test-isolation contract test ratchets two anti-patterns: (1) test files using `name: \"testagent\"` without mocking socket-client, and (2) test files constructing write paths under the real `~/AgentBundles` via `os.homedir()`. Existing offenders are grandfathered in two allowlists; new offenders fail the build. Follow-up PRs shrink the allowlists toward zero."
+      ]
+    },
     {
       "version": "0.1.0-alpha.252",
       "changes": [

package/dist/heart/daemon/socket-client.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DAEMON_SOCKET_PATH = void 0;
+exports.__bypassVitestGuardForTests = __bypassVitestGuardForTests;
 exports.sendDaemonCommand = sendDaemonCommand;
 exports.checkDaemonSocketAlive = checkDaemonSocketAlive;
 exports.requestInnerWake = requestInnerWake;
@@ -41,7 +42,50 @@ const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
 const runtime_1 = require("../../nerves/runtime");
 exports.DEFAULT_DAEMON_SOCKET_PATH = "/tmp/ouroboros-daemon.sock";
+/**
+ * Defense-in-depth: detect if we're running under vitest. Tests that forget
+ * to `vi.mock("../../heart/daemon/socket-client")` would otherwise leak real
+ * `inner.wake` commands (with whatever literal agent name the test uses,
+ * commonly "testagent") into whichever real daemon happens to be running on
+ * the developer's machine. That has caused real outages when test loops
+ * flooded the production-on-localhost daemon.
+ *
+ * We detect vitest via `process.argv` (not env vars — the project bans those)
+ * and convert all socket operations into safe no-ops. Individual tests are
+ * still expected to vi.mock this module so they can assert on call counts,
+ * but this guard guarantees that "I forgot to mock" can never again take
+ * down the daemon.
+ *
+ * The socket-client's OWN tests (which exercise the real functions against a
+ * test socket) call `__bypassVitestGuardForTests(true)` to opt out of the
+ * guard. We persist that flag on globalThis so it survives `vi.resetModules`
+ * (which clears the module cache between tests).
+ */
+const BYPASS_KEY = "__ouro_socket_client_bypass_vitest_guard__";
+/** ONLY for socket-client.test.ts. Do not call from any other test or production code. */
+function __bypassVitestGuardForTests(bypass) {
+    ;
+    globalThis[BYPASS_KEY] = bypass;
+}
+function isUnderVitest() {
+    if (globalThis[BYPASS_KEY] === true)
+        return false;
+    /* v8 ignore next -- defensive: process and process.argv always exist in node @preserve */
+    if (typeof process === "undefined" || !Array.isArray(process.argv))
+        return false;
+    return process.argv.some((arg) => typeof arg === "string" && arg.includes("vitest"));
+}
 function sendDaemonCommand(socketPath, command) {
+    if (isUnderVitest()) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.socket_command_test_blocked",
+            message: "blocked socket command from leaking into real daemon under vitest",
+            meta: { socketPath, kind: command.kind },
+        });
+        return Promise.resolve({ ok: true, message: "test mode: socket call suppressed" });
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.socket_command_start",
@@ -132,6 +176,9 @@ function sendDaemonCommand(socketPath, command) {
     });
 }
 function checkDaemonSocketAlive(socketPath) {
+    if (isUnderVitest()) {
+        return Promise.resolve(false);
+    }
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.socket_alive_check_start",
@@ -184,6 +231,16 @@ function checkDaemonSocketAlive(socketPath) {
     });
 }
 async function requestInnerWake(agent, socketPath = exports.DEFAULT_DAEMON_SOCKET_PATH) {
+    if (isUnderVitest()) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.inner_wake_test_blocked",
+            message: "blocked inner wake from leaking into real daemon under vitest",
+            meta: { agent, socketPath },
+        });
+        return null;
+    }
     const socketAvailable = fs.existsSync(socketPath);
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",

package/package.json

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