@ouro.bot/cli 0.1.0-alpha.121 → 0.1.0-alpha.122

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.122",
+      "changes": [
+        "Daemon now uses a pidfile (~/.ouro-cli/daemon.pids) for process cleanup instead of fragile ps-based name matching. All managed PIDs (daemon, agents, senses) are written on startup and reaped on next restart.",
+        "Failover reply matching now uses includes() instead of exact match, fixing switch commands in BlueBubbles where channel metadata prefixes the user text."
+      ]
+    },
     {
       "version": "0.1.0-alpha.121",
       "changes": [

package/dist/heart/daemon/daemon.js

@@ -35,8 +35,10 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OuroDaemon = void 0;
 exports.killOrphanProcesses = killOrphanProcesses;
+exports.writePidfile = writePidfile;
 const fs = __importStar(require("fs"));
 const net = __importStar(require("net"));
+const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
@@ -51,28 +53,41 @@ const child_process_1 = require("child_process");
 const pending_1 = require("../../mind/pending");
 const channel_1 = require("../../mind/friends/channel");
 const mcp_manager_1 = require("../../repertoire/mcp-manager");
+const PIDFILE_PATH = path.join(os.homedir(), ".ouro-cli", "daemon.pids");
 /**
- * Kill ALL orphaned ouro processes from previous daemon instances.
- * On each `ouro up`, old daemon AND agent processes persist because:
- * - Daemons are spawned detached and never killed on restart
- * - Each old daemon keeps respawning agents from its own (stale) code
- * This scans for both daemon-entry.js and agent-entry.js processes
- * and kills everything except the current process.
+ * Kill all ouro processes from the previous daemon instance using the pidfile.
+ * On startup, reads PIDs from ~/.ouro-cli/daemon.pids, kills them all, then
+ * deletes the file. The new daemon writes its own PIDs after spawning.
+ *
+ * Falls back to ps-based scanning if the pidfile doesn't exist (first run
+ * or manual cleanup).
  */
-/* v8 ignore start -- orphan cleanup: uses ps/kill, tested via deployment @preserve */
+/* v8 ignore start -- process lifecycle: uses kill/ps, tested via deployment @preserve */
 function killOrphanProcesses() {
     try {
-        const myPid = process.pid;
-        const result = (0, child_process_1.execSync)("ps -eo pid,command", { encoding: "utf-8", timeout: 5000 });
-        const pidsToKill = [];
-        for (const line of result.split("\n")) {
-            if (!line.includes("agent-entry.js") && !line.includes("daemon-entry.js") && !line.includes("-entry.js --agent"))
-                continue;
-            const trimmed = line.trim();
-            const pid = parseInt(trimmed, 10);
-            if (isNaN(pid) || pid === myPid)
-                continue;
-            pidsToKill.push(pid);
+        let pidsToKill = [];
+        // Primary: read pidfile from previous daemon
+        try {
+            const raw = fs.readFileSync(PIDFILE_PATH, "utf-8");
+            pidsToKill = raw.split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n) && n !== process.pid);
+            fs.unlinkSync(PIDFILE_PATH);
+        }
+        catch {
+            // No pidfile — fall back to ps scan
+        }
+        // Fallback: scan ps for any ouro entry processes we missed
+        if (pidsToKill.length === 0) {
+            try {
+                const result = (0, child_process_1.execSync)("ps -eo pid,command", { encoding: "utf-8", timeout: 5000 });
+                for (const line of result.split("\n")) {
+                    if (!line.includes("agent-entry.js") && !line.includes("daemon-entry.js") && !line.includes("-entry.js --agent"))
+                        continue;
+                    const pid = parseInt(line.trim(), 10);
+                    if (!isNaN(pid) && pid !== process.pid)
+                        pidsToKill.push(pid);
+                }
+            }
+            catch { /* ps failed — best effort */ }
         }
         if (pidsToKill.length > 0) {
             for (const pid of pidsToKill) {
@@ -99,6 +114,18 @@ function killOrphanProcesses() {
         });
     }
 }
+/**
+ * Write all managed PIDs (daemon + children) to the pidfile.
+ * Called after all agents and senses are spawned.
+ */
+function writePidfile(extraPids = []) {
+    try {
+        const pids = [process.pid, ...extraPids].filter(Boolean);
+        fs.mkdirSync(path.dirname(PIDFILE_PATH), { recursive: true });
+        fs.writeFileSync(PIDFILE_PATH, pids.join("\n") + "\n", "utf-8");
+    }
+    catch { /* best effort */ }
+}
 function buildWorkerRows(snapshots) {
     return snapshots.map((snapshot) => ({
         agent: snapshot.name,
@@ -207,9 +234,17 @@ class OuroDaemon {
         // Pre-initialize MCP connections so they're ready for the first command (non-blocking)
         /* v8 ignore next -- catch callback: getSharedMcpManager logs errors internally @preserve */
         (0, mcp_manager_1.getSharedMcpManager)().catch(() => { });
+        /* v8 ignore start -- orphan cleanup + pidfile: calls process management functions @preserve */
         killOrphanProcesses();
+        /* v8 ignore stop */
         await this.processManager.startAutoStartAgents();
         await this.senseManager?.startAutoStartSenses();
+        // Write all managed PIDs to disk so the next daemon can clean up
+        /* v8 ignore start -- pidfile write: collects PIDs from process managers @preserve */
+        const agentPids = this.processManager.listAgentSnapshots().map((s) => s.pid).filter((p) => p !== null);
+        const sensePids = this.senseManager?.listManagedPids?.() ?? [];
+        writePidfile([...agentPids, ...sensePids]);
+        /* v8 ignore stop */
         this.scheduler.start?.();
         await this.scheduler.reconcile?.();
         await this.drainPendingBundleMessages();

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

@@ -251,6 +251,13 @@ class DaemonSenseManager {
     async stopAll() {
         await this.processManager.stopAll();
     }
+    /* v8 ignore start -- pid collection for orphan cleanup pidfile @preserve */
+    listManagedPids() {
+        return this.processManager.listAgentSnapshots()
+            .map((s) => s.pid)
+            .filter((pid) => pid !== null && pid !== undefined);
+    }
+    /* v8 ignore stop */
     listSenseRows() {
         const runtime = new Map();
         for (const snapshot of this.processManager.listAgentSnapshots()) {

package/dist/heart/provider-failover.js

@@ -80,7 +80,7 @@ function buildFailoverContext(_errorMessage, classification, currentProvider, cu
 function handleFailoverReply(reply, context) {
     const lower = reply.toLowerCase().trim();
     for (const provider of context.workingProviders) {
-        if (lower === `switch to ${provider}` || lower === provider) {
+        if (lower.includes(`switch to ${provider}`) || lower === provider) {
             return { action: "switch", provider };
         }
     }

package/package.json

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