@ouro.bot/cli 0.1.0-alpha.282 → 0.1.0-alpha.283

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_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.283",
+      "changes": [
+        "chore(housekeeping): clean up ~3600 leaked test secret dirs in `~/.agentsecrets/`. The auth CLI test suite was creating ephemeral agent secret dirs (auth-local-*, auth-store-*, auth-no-switch-*, etc.) without cleaning them up, accreting over weeks into thousands of orphaned entries. Also purged three non-test orphans (`testagent`, `model-reviews`, `config-model-facing-*`) that were leftovers from manual probe sessions. Only `slugger` and `ouroboros` — the two real agents on this machine — remain.",
+        "chore(housekeeping): remove orphan bundle stubs from `~/AgentBundles/` (default.ouro, thoughts-test-*, an empty `friends/` dir, and a .DS_Store). These were skeletal test leftovers with no real identity — the daemon was already filtering them out of `listEnabledBundleAgents`, so deletion is invisible to the runtime but stops confusing anyone inspecting the bundles directory.",
+        "chore(tests): replace the `outlookServer.stop` v8 ignore band-aid in `daemon.ts` with a proper test. `OuroDaemonOptions` gains an `outlookServerFactory` seam that lets tests inject an in-memory stub handle instead of binding port 6876 (which a running production daemon holds on dev machines, causing EADDRINUSE flakes). New `daemon-outlook-lifecycle.test.ts` covers the happy path (factory runs, stop is called), the error path (factory throws, daemon logs warn and keeps going, stop is a no-op), and the double-start guard. The default production factory path (`createDefaultOutlookServer` — wires the real `startOutlookHttpServer` with bundlesRoot + view builders) is v8-ignored because it only runs under real bind on port 6876; `startOutlookHttpServer` itself has full coverage in `outlook-http.test.ts`. Removed the redundant `if (!this.outlookServer)` wrapper in `startInner()` that was guarding against an unreachable retry scenario. `daemon.ts` now hits 100% statements / branches / functions / lines with zero port binding in the test suite.",
+        "chore(ci): tighten the wrapper publish-sync check timing. The version-bump check and wrapper-publish-sync check now run BEFORE the ~2+ minute coverage gate, not after. Previously, a contributor would wait for the full test suite to pass only to then see a 'version already published' error. Now the fast checks surface in under a minute, and coverage only runs once version/wrapper gates have cleared. Same checks, same logic — just reordered steps in `.github/workflows/coverage.yml`."
+      ]
+    },
     {
       "version": "0.1.0-alpha.282",
       "changes": [

package/dist/heart/daemon/daemon.js

@@ -353,6 +353,7 @@ class OuroDaemon {
     mode;
     server = null;
     outlookServer = null;
+    outlookServerFactory;
     constructor(options) {
         this.socketPath = options.socketPath;
         this.processManager = options.processManager;
@@ -362,7 +363,42 @@ class OuroDaemon {
         this.senseManager = options.senseManager ?? null;
         this.bundlesRoot = options.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
         this.mode = options.mode ?? "production";
+        this.outlookServerFactory = options.outlookServerFactory ?? this.createDefaultOutlookServer.bind(this);
     }
+    /* v8 ignore start -- default outlook server wiring: production-only path, tests inject outlookServerFactory stub instead. startOutlookHttpServer itself has full coverage in outlook-http.test.ts @preserve */
+    createDefaultOutlookServer() {
+        return (0, outlook_http_1.startOutlookHttpServer)({
+            host: "127.0.0.1",
+            port: outlook_types_1.OUTLOOK_DEFAULT_PORT,
+            bundlesRoot: this.bundlesRoot,
+            readMachineState: () => (0, outlook_read_1.readOutlookMachineState)({ bundlesRoot: this.bundlesRoot }),
+            readMachineView: ({ machine }) => {
+                const overview = this.buildStatusPayload().overview;
+                return (0, outlook_view_1.buildOutlookMachineView)({
+                    machine,
+                    daemon: {
+                        status: overview.daemon,
+                        health: overview.health,
+                        mode: overview.mode,
+                        socketPath: overview.socketPath,
+                        outlookUrl: overview.outlookUrl,
+                        entryPath: overview.entryPath,
+                        workerCount: overview.workerCount,
+                        senseCount: overview.senseCount,
+                    },
+                });
+            },
+            readAgentState: (agentName) => (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot }),
+            readAgentView: (agentName) => {
+                const agent = (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot });
+                return (0, outlook_view_1.buildOutlookAgentView)({
+                    agent,
+                    viewer: { kind: "human" },
+                });
+            },
+        });
+    }
+    /* v8 ignore stop */
     buildStatusPayload() {
         const snapshots = this.processManager.listAgentSnapshots();
         const workers = buildWorkerRows(snapshots);
@@ -513,51 +549,21 @@ class OuroDaemon {
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();
         await this.drainPendingSenseMessages();
-        /* v8 ignore start — Outlook server startup, tested via outlook-http.test.ts */
-        if (!this.outlookServer) {
-            try {
-                this.outlookServer = await (0, outlook_http_1.startOutlookHttpServer)({
-                    host: "127.0.0.1",
-                    port: outlook_types_1.OUTLOOK_DEFAULT_PORT,
-                    bundlesRoot: this.bundlesRoot,
-                    readMachineState: () => (0, outlook_read_1.readOutlookMachineState)({ bundlesRoot: this.bundlesRoot }),
-                    readMachineView: ({ machine }) => {
-                        const overview = this.buildStatusPayload().overview;
-                        return (0, outlook_view_1.buildOutlookMachineView)({
-                            machine,
-                            daemon: {
-                                status: overview.daemon,
-                                health: overview.health,
-                                mode: overview.mode,
-                                socketPath: overview.socketPath,
-                                outlookUrl: overview.outlookUrl,
-                                entryPath: overview.entryPath,
-                                workerCount: overview.workerCount,
-                                senseCount: overview.senseCount,
-                            },
-                        });
-                    },
-                    readAgentState: (agentName) => (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot }),
-                    readAgentView: (agentName) => {
-                        const agent = (0, outlook_read_1.readOutlookAgentState)(agentName, { bundlesRoot: this.bundlesRoot });
-                        return (0, outlook_view_1.buildOutlookAgentView)({
-                            agent,
-                            viewer: { kind: "human" },
-                        });
-                    },
-                });
-            }
-            catch (error) {
-                (0, runtime_1.emitNervesEvent)({
-                    level: "warn",
-                    component: "daemon",
-                    event: "daemon.outlook_start_failed",
-                    message: `Outlook server failed to start: ${String(error)}`,
-                    meta: { port: outlook_types_1.OUTLOOK_DEFAULT_PORT },
-                });
-            }
+        // startInner is only reachable when this.server is null (guarded in
+        // start()), and stop() nulls out this.outlookServer alongside this.server,
+        // so outlookServer is guaranteed unset here — no need for a guard.
+        try {
+            this.outlookServer = await this.outlookServerFactory();
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.outlook_start_failed",
+                message: `Outlook server failed to start: ${String(error)}`,
+                meta: { port: outlook_types_1.OUTLOOK_DEFAULT_PORT },
+            });
         }
-        /* v8 ignore stop */
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }
@@ -815,12 +821,10 @@ class OuroDaemon {
             this.server.close();
             this.server = null;
         }
-        /* v8 ignore start -- outlookServer stop: only reachable when the outlook HTTP server successfully bound to port 6876 during start(). Coverage fluctuates locally because a running production daemon holds the port and tests get EADDRINUSE, leaving outlookServer null. In CI the port is free and this block runs. Not worth fighting port contention to cover two trivial lines. @preserve */
         if (this.outlookServer) {
             await this.outlookServer.stop();
             this.outlookServer = null;
         }
-        /* v8 ignore stop */
         if (fs.existsSync(this.socketPath)) {
             fs.unlinkSync(this.socketPath);
         }

package/package.json

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