open-agents-ai 0.187.515 → 0.187.516

package/dist/index.js

@@ -595998,6 +595998,159 @@ function checkConcurrentJobLimit(auth) {
   }
   return null;
 }
+function adoptHandoffRuns() {
+  if (process.env["OA_DISABLE_RUN_HANDOFF"] === "1") return;
+  const fs7 = require3("node:fs");
+  const path8 = require3("node:path");
+  const home = require3("node:os").homedir();
+  const handoffPath2 = path8.join(home, ".open-agents", "runs-handoff.json");
+  if (!fs7.existsSync(handoffPath2)) return;
+  let handoff = {};
+  try {
+    const raw = fs7.readFileSync(handoffPath2, "utf-8");
+    handoff = JSON.parse(raw);
+  } catch (e2) {
+    process.stderr.write(`  WARN: handoff file unreadable (${e2.message}) — discarding.
+`);
+    try {
+      fs7.unlinkSync(handoffPath2);
+    } catch {
+    }
+    return;
+  }
+  try {
+    fs7.unlinkSync(handoffPath2);
+  } catch {
+  }
+  const runs = handoff.runs ?? [];
+  if (runs.length === 0) return;
+  const adopted = [];
+  const orphaned = [];
+  for (const r2 of runs) {
+    if (!r2.pid || r2.pid <= 0) continue;
+    let alive = false;
+    try {
+      process.kill(r2.pid, 0);
+      alive = true;
+    } catch {
+      alive = false;
+    }
+    const jobsDir3 = path8.join(home, ".open-agents", "jobs");
+    const jobFile = path8.join(jobsDir3, `${r2.jobId}.json`);
+    let job = null;
+    try {
+      if (fs7.existsSync(jobFile)) job = JSON.parse(fs7.readFileSync(jobFile, "utf-8"));
+    } catch {
+    }
+    if (!alive) {
+      orphaned.push(r2.jobId);
+      if (job) {
+        let finalJson = "";
+        try {
+          if (r2.outputFile && fs7.existsSync(r2.outputFile)) {
+            const raw = fs7.readFileSync(r2.outputFile, "utf-8");
+            const lines = raw.trim().split("\n");
+            for (let i2 = lines.length - 1; i2 >= 0; i2--) {
+              if (lines[i2].trimEnd() === "{" || lines[i2].startsWith("{") && !lines[i2].startsWith('{"type":"tool_call"')) {
+                finalJson = lines.slice(i2).join("\n");
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+        try {
+          const parsed = finalJson ? JSON.parse(finalJson) : null;
+          if (parsed && parsed.status) job.status = parsed.status;
+          else job.status = "failed";
+          job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (parsed?.summary) job.summary = parsed.summary;
+          if (parsed?.error) job.error = parsed.error;
+          job.adoptedAs = "orphaned";
+        } catch {
+          job.status = "failed";
+          job.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          job.adoptedAs = "orphaned";
+        }
+        try {
+          fs7.writeFileSync(jobFile, JSON.stringify(job, null, 2), "utf-8");
+        } catch {
+        }
+      }
+      continue;
+    }
+    adopted.push(r2.jobId);
+    const adoptedShim = {
+      pid: r2.pid,
+      // Stub stdio (we never read from it again — the child writes directly
+      // to the on-disk output file which /v1/runs/{id}/output already reads).
+      stdout: { on: () => {
+      } },
+      stderr: { on: () => {
+      } },
+      __adopted: true
+    };
+    runningProcesses.set(r2.jobId, adoptedShim);
+    if (job) {
+      job.adoptedAs = "live";
+      job.adoptedAt = (/* @__PURE__ */ new Date()).toISOString();
+      try {
+        fs7.writeFileSync(jobFile, JSON.stringify(job, null, 2), "utf-8");
+      } catch {
+      }
+    }
+    const pollHandle = setInterval(() => {
+      let stillAlive = false;
+      try {
+        process.kill(r2.pid, 0);
+        stillAlive = true;
+      } catch {
+        stillAlive = false;
+      }
+      if (stillAlive) return;
+      clearInterval(pollHandle);
+      runningProcesses.delete(r2.jobId);
+      try {
+        const jf = jobFile;
+        if (!fs7.existsSync(jf)) return;
+        const j = JSON.parse(fs7.readFileSync(jf, "utf-8"));
+        if (j.status !== "running") return;
+        let finalJson = "";
+        try {
+          if (r2.outputFile && fs7.existsSync(r2.outputFile)) {
+            const raw = fs7.readFileSync(r2.outputFile, "utf-8");
+            const lines = raw.trim().split("\n");
+            for (let i2 = lines.length - 1; i2 >= 0; i2--) {
+              if (lines[i2].trimEnd() === "{" || lines[i2].startsWith("{") && !lines[i2].startsWith('{"type":"tool_call"')) {
+                finalJson = lines.slice(i2).join("\n");
+                break;
+              }
+            }
+          }
+        } catch {
+        }
+        try {
+          const parsed = finalJson ? JSON.parse(finalJson) : null;
+          if (parsed && parsed.status) j.status = parsed.status;
+          else j.status = "completed";
+          j.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          if (parsed?.summary) j.summary = parsed.summary;
+          if (parsed?.error) j.error = parsed.error;
+          fs7.writeFileSync(jf, JSON.stringify(j, null, 2), "utf-8");
+        } catch {
+        }
+      } catch {
+      }
+    }, 3e3);
+    pollHandle.unref();
+  }
+  process.stderr.write(`  Adopted ${adopted.length} live run(s) from previous daemon, ${orphaned.length} orphaned.
+`);
+  if (adopted.length > 0) process.stderr.write(`    live: ${adopted.join(", ")}
+`);
+  if (orphaned.length > 0) process.stderr.write(`    orphaned: ${orphaned.join(", ")}
+`);
+}
 function incrementActiveJobs(user) {
   if (!user) return;
   getKeyUsage(user).activeJobs++;
@@ -601614,6 +601767,12 @@ function startApiServer(options2 = {}) {
 `);
     log22(`  Primary: ${config.backendUrl} (${config.backendType || "ollama"})
 `);
+    try {
+      adoptHandoffRuns();
+    } catch (e2) {
+      log22(`  WARN: handoff adoption crashed: ${e2.message}
+`);
+    }
     const _retCheck = process.env["OA_RUN_RETENTION_H"];
     const _retOff = _retCheck === "0";
     if (!_retOff) {
@@ -601660,8 +601819,96 @@ function startApiServer(options2 = {}) {
     }).catch(() => {
     });
   });
-  const shutdown = () => {
-    log22("\n  Shutting down API server...\n");
+  const shutdown = (signal) => {
+    const hardKill = signal === "SIGINT" || process.env["OA_DAEMON_HARD_SHUTDOWN"] === "1";
+    log22(`
+  Shutting down API server (signal=${signal}, mode=${hardKill ? "hard-kill" : "graceful-handoff"}) ...
+`);
+    if (!hardKill && runningProcesses.size > 0) {
+      try {
+        const handoffPath2 = (() => {
+          try {
+            const home = require3("node:os").homedir();
+            return require3("node:path").join(home, ".open-agents", "runs-handoff.json");
+          } catch {
+            return "";
+          }
+        })();
+        if (handoffPath2) {
+          const handoff = [];
+          for (const [id, child] of runningProcesses) {
+            const pid = child.pid;
+            if (!pid || pid <= 0) continue;
+            let outputFile = null;
+            let startedAt2 = null;
+            let user = null;
+            let scope = null;
+            let cwd5 = null;
+            try {
+              const fs7 = require3("node:fs");
+              const path8 = require3("node:path");
+              const home = require3("node:os").homedir();
+              const jobsDir3 = path8.join(home, ".open-agents", "jobs");
+              const jobFile = path8.join(jobsDir3, `${id}.json`);
+              if (fs7.existsSync(jobFile)) {
+                const j = JSON.parse(fs7.readFileSync(jobFile, "utf-8"));
+                outputFile = j.outputFile ?? path8.join(jobsDir3, `${id}.output`);
+                startedAt2 = j.startedAt ?? null;
+                user = j.user ?? null;
+                scope = j.scope ?? null;
+                cwd5 = j.cwd ?? null;
+              }
+            } catch {
+            }
+            handoff.push({ jobId: id, pid, outputFile, startedAt: startedAt2, user, scope, cwd: cwd5, handoffAt: (/* @__PURE__ */ new Date()).toISOString() });
+          }
+          if (handoff.length > 0) {
+            try {
+              const fs7 = require3("node:fs");
+              const path8 = require3("node:path");
+              const home = require3("node:os").homedir();
+              const dir = path8.join(home, ".open-agents");
+              fs7.mkdirSync(dir, { recursive: true });
+              fs7.writeFileSync(handoffPath2, JSON.stringify({
+                writtenAt: (/* @__PURE__ */ new Date()).toISOString(),
+                fromPid: process.pid,
+                runs: handoff
+              }, null, 2), "utf-8");
+              log22(`  Wrote handoff for ${handoff.length} in-flight run(s) → ${handoffPath2}
+`);
+              log22(`  Children will continue running; next daemon will adopt them.
+`);
+            } catch (e2) {
+              log22(`  WARN: failed to write handoff (${e2.message}) — falling back to hard-kill.
+`);
+              for (const [id, child] of runningProcesses) {
+                const pid = child.pid;
+                if (pid && pid > 0) {
+                  try {
+                    process.kill(-pid, "SIGTERM");
+                  } catch {
+                  }
+                  try {
+                    process.kill(pid, "SIGTERM");
+                  } catch {
+                  }
+                }
+                runningProcesses.delete(id);
+              }
+            }
+          }
+        }
+      } catch (e2) {
+        log22(`  WARN: handoff block crashed (${e2.message}) — proceeding to server.close()
+`);
+      }
+      server2.close(() => {
+        log22("  Server stopped (children preserved for adoption).\n");
+        process.exit(0);
+      });
+      setTimeout(() => process.exit(0), 8e3).unref();
+      return;
+    }
     for (const [id, child] of runningProcesses) {
       const pid = child.pid;
       if (pid && pid > 0) {
@@ -601697,8 +601944,8 @@ function startApiServer(options2 = {}) {
     });
     setTimeout(() => process.exit(1), 5e3).unref();
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
   return server2;
 }
 async function handleVisionEmbed(req2, res) {

package/dist/postinstall-daemon.cjs

@@ -145,6 +145,105 @@ function effectiveUser() {
   return process.env.USER || process.env.LOGNAME || os.userInfo().username;
 }
 
+// ─── Force-kill port holder (regardless of how it was launched) ────────────
+//
+// Critical for upgrade correctness: when an OLD daemon (started before this
+// install) is running, it holds port 11435 with stale in-memory code. The
+// systemctl/launchctl `restart` calls below CANNOT reach it because the
+// service manager doesn't own that process — it was started detached by
+// `oa serve --daemon` from a previous TUI session.
+//
+// Result without this kill: postinstall tries to start a NEW systemd
+// daemon, port-bind fails, old daemon stays alive serving stale code,
+// and the user's runs continue with broken patches.
+//
+// Strategy (matches packages/cli/src/daemon.ts:forceKillDaemon):
+//   1. SIGTERM via known PID files (~/.open-agents/daemon.pid + .oa/nexus/daemon.pid)
+//   2. lsof / fuser port probe — find ANY other holder
+//   3. 2s graceful grace, then SIGKILL stragglers
+//   4. Poll /health up to 5s for confirmation
+//
+// Skips when OA_DISABLE_FORCE_KILL_DAEMON=1 (escape valve).
+function forceKillPortHolder(port, cb) {
+  if (process.env.OA_DISABLE_FORCE_KILL_DAEMON === "1") {
+    log("OA_DISABLE_FORCE_KILL_DAEMON=1 — skipping port-holder kill (upgrades may not pick up new code).");
+    return cb(0);
+  }
+
+  var killed = 0;
+
+  // Step 1: SIGTERM via PID files (graceful)
+  var pidFiles = [
+    path.join(HOME, ".open-agents", "daemon.pid"),
+    path.join(process.cwd(), ".oa", "nexus", "daemon.pid"),
+  ];
+  pidFiles.forEach(function (pidFile) {
+    try {
+      if (!fs.existsSync(pidFile)) return;
+      var n = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+      if (!n || n <= 0) return;
+      try { process.kill(n, "SIGTERM"); killed++; log("SIGTERM old daemon (pid " + n + ", from " + pidFile + ")"); } catch (e) { /* dead */ }
+    } catch (e) { /* */ }
+  });
+
+  // Step 2: port probe — lsof/fuser to find ANY pid holding the port
+  try {
+    var out = "";
+    try {
+      out = cp.execSync("lsof -ti :" + port + " 2>/dev/null || fuser " + port + "/tcp 2>/dev/null || true", {
+        encoding: "utf8", timeout: 3000,
+      }).trim();
+    } catch (e) { /* tools unavailable */ }
+    if (out) {
+      var pids = out.split(/[\s\n]+/).map(function (s) { return parseInt(s, 10); }).filter(function (n) {
+        return Number.isFinite(n) && n > 0 && n !== process.pid;
+      });
+      pids.forEach(function (otherPid) {
+        try { process.kill(otherPid, "SIGTERM"); killed++; log("SIGTERM port-holder (pid " + otherPid + ")"); } catch (e) { /* */ }
+      });
+    }
+  } catch (e) { /* */ }
+
+  if (killed === 0) {
+    // Nothing to kill — port was already free.
+    return cb(0);
+  }
+
+  // Step 3: 2s grace, then SIGKILL stragglers
+  setTimeout(function () {
+    try {
+      var out = cp.execSync("lsof -ti :" + port + " 2>/dev/null || fuser " + port + "/tcp 2>/dev/null || true", {
+        encoding: "utf8", timeout: 3000,
+      }).trim();
+      if (out) {
+        var pids = out.split(/[\s\n]+/).map(function (s) { return parseInt(s, 10); }).filter(function (n) {
+          return Number.isFinite(n) && n > 0 && n !== process.pid;
+        });
+        pids.forEach(function (otherPid) {
+          try { process.kill(otherPid, "SIGKILL"); log("SIGKILL straggler (pid " + otherPid + ")"); } catch (e) { /* */ }
+        });
+      }
+    } catch (e) { /* */ }
+
+    // Step 4: poll until port is free (up to 5s) — required so the next
+    // service-manager restart binds without conflict.
+    var pollStart = Date.now();
+    function pollFree() {
+      if (Date.now() - pollStart > 5000) return cb(killed);
+      tryHealth(port, function (alive) {
+        if (!alive) return cb(killed);
+        setTimeout(pollFree, 200);
+      });
+    }
+    pollFree();
+
+    // Clean up PID files now that the processes are dead
+    pidFiles.forEach(function (pidFile) {
+      try { if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile); } catch (e) { /* */ }
+    });
+  }, 2000);
+}
+
 // ─── Nexus cleanup (preserve prior postinstall behaviour) ──────────────────
 
 function cleanNexus() {
@@ -572,7 +671,25 @@ function main() {
     return safeExit(0);
   }
 
+  // Force-kill any process holding the daemon port BEFORE we try to install
+  // a service. This handles the orphan-detached-daemon case (started by
+  // `oa serve --daemon` from a previous TUI session) — systemctl/launchctl
+  // restart can't reach it, so we have to clean up explicitly. Without this,
+  // the new service-managed daemon fails to bind port 11435 and the user
+  // ends up running stale in-memory code from the previous version.
+  forceKillPortHolder(PORT, function (killedCount) {
+    if (killedCount > 0) {
+      log("Killed " + killedCount + " stale daemon process(es) holding port " + PORT + ".");
+    }
+    runMainAfterKill();
+  });
+}
+
+function runMainAfterKill() {
   // Fast path: daemon already answering /health on the target port.
+  // After forceKillPortHolder, this should be false unless a service manager
+  // already auto-restarted (rare race). We still check so the rest of the
+  // flow stays idempotent.
   tryHealth(PORT, function (alreadyUp) {
     var user = effectiveUser();
     var nodeBin = resolveNodeBinary();
@@ -584,10 +701,10 @@ function main() {
     }
 
     if (alreadyUp) {
-      log("OA daemon already responding on port " + PORT + " — reinstalling service definition so it picks up the new build.");
-      // Fall through to (re)install service files; the serve command's
-      // daemon-mode /health pre-check will no-op if the existing daemon
-      // is still healthy.
+      log("OA daemon answering /health on port " + PORT + " — re-checking version drift before service (re)install.");
+      // Note: we already force-killed any stale process — anything answering
+      // now is a fresh service-managed daemon. Service (re)install below is
+      // idempotent and ensures the unit file matches the current bundle.
     }
 
     log("Installing OA API daemon service for port " + PORT + " ...");

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.515",
+  "version": "0.187.516",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "open-agents-ai",
-      "version": "0.187.515",
+      "version": "0.187.516",
       "hasInstallScript": true,
       "license": "CC-BY-NC-4.0",
       "dependencies": {
@@ -2081,9 +2081,9 @@
       }
     },
     "node_modules/b4a": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.0.tgz",
-      "integrity": "sha512-qRuSmNSkGQaHwNbM7J78Wwy+ghLEYF1zNrSeMxj4Kgw6y33O3mXcQ6Ie9fRvfU/YnxWkOchPXbaLb73TkIsfdg==",
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.8.1.tgz",
+      "integrity": "sha512-aiqre1Nr0B/6DgE2N5vwTc+2/oQZ4Wh1t4NznYY4E00y8LCt6NqdRv81so00oo27D8MVKTpUa/MwUUtBLXCoDw==",
       "license": "Apache-2.0",
       "optional": true,
       "peerDependencies": {
@@ -4789,9 +4789,9 @@
       "license": "Apache-2.0 OR MIT"
     },
     "node_modules/nanoid": {
-      "version": "5.1.9",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.9.tgz",
-      "integrity": "sha512-ZUvP7KeBLe3OZ1ypw6dI/TzYJuvHP77IM4Ry73waSQTLn8/g8rpdjfyVAh7t1/+FjBtG4lCP42MEbDxOsRpBMw==",
+      "version": "5.1.11",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-5.1.11.tgz",
+      "integrity": "sha512-v+KEsUv2ps74PaSKv0gHTxTCgMXOIfBEbaqa6w6ISIGC7ZsvHN4N9oJ8d4cmf0n5oTzQz2SLmThbQWhjd/8eKg==",
       "funding": [
         {
           "type": "github",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.515",
+  "version": "0.187.516",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",