open-agents-ai 0.187.183 → 0.187.185

package/dist/index.js

@@ -2652,14 +2652,16 @@ var init_glob_find = __esm({
 });
 
 // packages/execution/dist/tools/web-fetch.js
-var DEFAULT_MAX_LENGTH, SHORT_CONTENT_THRESHOLD, WebFetchTool;
+var DEFAULT_MAX_LENGTH, SHORT_CONTENT_THRESHOLD, CACHE_TTL_MS, WebFetchTool;
 var init_web_fetch = __esm({
   "packages/execution/dist/tools/web-fetch.js"() {
     "use strict";
     DEFAULT_MAX_LENGTH = 5e3;
     SHORT_CONTENT_THRESHOLD = 200;
+    CACHE_TTL_MS = 6e4;
     WebFetchTool = class {
       name = "web_fetch";
+      _fetchCache = /* @__PURE__ */ new Map();
       description = "Fetch a single web page and return its text content (HTML stripped to plain text). FASTEST web tool \u2014 use this for reading any single URL: documentation, articles, README files, API references, Stack Overflow answers. Limitations: no JavaScript rendering (SPAs/React apps return empty), no link following, no cookies/auth, no structured data extraction. If the page is blank or incomplete, switch to web_crawl with strategy='playwright'. For scraping/extracting structured data (prices, listings, tables), use web_crawl instead. For search engine queries, use web_search instead. For interactive browser sessions (login, form filling, clicking), use browser_action instead.";
       parameters = {
         type: "object",
@@ -2679,6 +2681,19 @@ var init_web_fetch = __esm({
         const url = args["url"];
         const maxLength = args["max_length"] ?? DEFAULT_MAX_LENGTH;
         const start2 = performance.now();
+        const cached = this._fetchCache.get(url);
+        if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+          const slicedCache = cached.text.length > maxLength ? `${cached.text.slice(0, maxLength)}
+
+[Content truncated to ${maxLength} characters]` : cached.text;
+          return {
+            success: true,
+            output: `[CACHED \u2014 already fetched this URL in this session; the content below is the full response. Do NOT re-fetch the same URL. If the content seems short, the page may just be short or require JavaScript \u2014 use browser_action with a headless browser instead.]
+
+` + slicedCache,
+            durationMs: performance.now() - start2
+          };
+        }
         try {
           const response = await fetch(url, {
             headers: {
@@ -2697,6 +2712,7 @@ var init_web_fetch = __esm({
           }
           const html = await response.text();
           const text = this.#stripHtml(html);
+          this._fetchCache.set(url, { text, fetchedAt: Date.now() });
           if (text.length < SHORT_CONTENT_THRESHOLD) {
             return {
               success: true,
@@ -2711,7 +2727,7 @@ var init_web_fetch = __esm({
             success: true,
             output: truncated ? `${text.slice(0, maxLength)}
 
-[Content truncated to ${maxLength} characters]` : text,
+[Content truncated to ${maxLength} characters. The full response is cached for this session \u2014 subsequent calls to the same URL return the cached content.]` : text,
             durationMs: performance.now() - start2
           };
         } catch (error) {
@@ -265405,6 +265421,35 @@ function cleanForStorage(text) {
   out = out.replace(/\s+/g, " ").trim();
   return out;
 }
+function extractTaskCompleteSummary(args) {
+  if (args == null)
+    return "";
+  if (typeof args === "string")
+    return stripThinkTags(args);
+  if (typeof args === "object") {
+    const obj = args;
+    if (typeof obj.summary === "string" && obj.summary.trim().length > 0) {
+      return stripThinkTags(obj.summary);
+    }
+    for (const alt of ["text", "message", "result", "output", "content", "response", "answer"]) {
+      if (typeof obj[alt] === "string" && obj[alt].trim().length > 0) {
+        return stripThinkTags(obj[alt]);
+      }
+    }
+    if (typeof obj[""] === "string" && obj[""].trim().length > 0) {
+      let value2 = obj[""];
+      value2 = value2.replace(/^[^>]*>\s*\n?/, "");
+      value2 = value2.replace(/\s*<\/[^>]+>\s*$/, "");
+      return stripThinkTags(value2.trim());
+    }
+    const stringValues = Object.values(obj).filter((v) => typeof v === "string" && v.trim().length > 0);
+    if (stringValues.length > 0) {
+      const longest = stringValues.reduce((a2, b) => a2.length >= b.length ? a2 : b);
+      return stripThinkTags(longest);
+    }
+  }
+  return "";
+}
 var SIGNPOST_RE, NEW_TASK_RE, RESTORED_BLOCK_RE, SYSTEM_BLOCK_RE, THINK_BLOCK_RE, ANSI_ESCAPE_RE;
 var init_textSanitize = __esm({
   "packages/orchestrator/dist/textSanitize.js"() {
@@ -266103,6 +266148,15 @@ import { join as join63 } from "node:path";
 import { mkdirSync as mkdirSync24, existsSync as existsSync47 } from "node:fs";
 import { randomUUID as randomUUID5 } from "node:crypto";
 import { createHash as createHash3 } from "node:crypto";
+function sanitizeImportance(raw, fallback = 5) {
+  if (typeof raw !== "number" || !Number.isFinite(raw))
+    return fallback;
+  if (raw < 0)
+    return 0;
+  if (raw > 10)
+    return 10;
+  return raw;
+}
 function autoImportance(toolName, modality, content) {
   if (toolName === "task_complete")
     return 9;
@@ -266203,7 +266257,8 @@ var init_episodeStore = __esm({
         const now = Date.now();
         const contentHash = createHash3("sha256").update(ep.content).digest("hex").slice(0, 16);
         const modality = ep.modality ?? "text";
-        const importance = ep.importance ?? autoImportance(ep.toolName ?? null, modality, ep.content);
+        const rawImportance = ep.importance ?? autoImportance(ep.toolName ?? null, modality, ep.content);
+        const importance = sanitizeImportance(rawImportance);
         const decayClass = ep.decayClass ?? autoDecayClass(ep.toolName ?? null, modality, ep.content);
         const existing = this.db.prepare("SELECT id FROM episodes WHERE content_hash = ? AND session_id = ? LIMIT 1").get(contentHash, ep.sessionId ?? null);
         if (existing)
@@ -266335,9 +266390,12 @@ var init_episodeStore = __esm({
           contentHash: row.content_hash,
           metadata: row.metadata ? JSON.parse(row.metadata) : null,
           embedding: row.embedding ? new Float32Array(new Uint8Array(row.embedding).buffer) : null,
-          importance: row.importance,
+          // Belt-and-braces: rows from pre-fix DBs may have null importance
+          // (from legacy inserts with NaN that SQLite coerced to NULL).
+          // Re-sanitize on read so downstream code always sees a valid number.
+          importance: sanitizeImportance(row.importance),
           decayClass: row.decay_class,
-          strength: row.strength,
+          strength: typeof row.strength === "number" && Number.isFinite(row.strength) ? row.strength : 1,
           lastRetrieved: row.last_retrieved,
           gist: row.gist,
           sourceEpisodeId: row.source_episode_id
@@ -269441,7 +269499,7 @@ ${sr.result.output}`;
                   messages2.push(this.buildToolMessage(output, matchTc.id));
                   if (matchTc.name === "task_complete") {
                     completed = true;
-                    summary = matchTc.arguments.summary || "";
+                    summary = extractTaskCompleteSummary(matchTc.arguments);
                     if (summary && !this._assistantTextEmitted) {
                       this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                       this._assistantTextEmitted = true;
@@ -269460,7 +269518,7 @@ ${sr.result.output}`;
                     messages2.push(this.buildToolMessage(r2.output, r2.tc.id));
                     if (r2.tc.name === "task_complete") {
                       completed = true;
-                      summary = r2.tc.arguments.summary || "";
+                      summary = extractTaskCompleteSummary(r2.tc.arguments);
                       if (summary && !this._assistantTextEmitted) {
                         this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                         this._assistantTextEmitted = true;
@@ -269489,7 +269547,7 @@ ${sr.result.output}`;
                     messages2.push(this.buildToolMessage(r2.output, r2.tc.id));
                     if (r2.tc.name === "task_complete") {
                       completed = true;
-                      summary = r2.tc.arguments.summary || "";
+                      summary = extractTaskCompleteSummary(r2.tc.arguments);
                       if (summary && !this._assistantTextEmitted) {
                         this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                         this._assistantTextEmitted = true;
@@ -269889,7 +269947,7 @@ Full content available via: repl_exec(code="data = retrieve('${handleId}')")  or
                 messages2.push(toolMsg);
                 if (tc.name === "task_complete") {
                   completed = true;
-                  summary = tc.arguments.summary || "";
+                  summary = extractTaskCompleteSummary(tc.arguments);
                   if (summary && !this._assistantTextEmitted) {
                     this.emit({ type: "assistant_text", content: summary, turn, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
                     this._assistantTextEmitted = true;
@@ -274045,6 +274103,7 @@ var init_coordinator = __esm({
     "use strict";
     init_agent_types();
     init_agent_task();
+    init_textSanitize();
   }
 });
 
@@ -307892,6 +307951,7 @@ var init_dmn_engine = __esm({
   "packages/cli/src/tui/dmn-engine.ts"() {
     "use strict";
     init_dist8();
+    init_dist8();
     init_dist4();
     init_project_context();
     init_render();
@@ -307951,7 +308011,9 @@ var init_dmn_engine = __esm({
       }
       /** Record a task failure for Reflexion-style learning */
       recordTaskFailure(summary, errorContext, category) {
-        const reflection = errorContext ? `FAILED: ${summary.slice(0, 200)} \u2014 Error: ${errorContext.slice(0, 300)}` : `FAILED: ${summary.slice(0, 500)}`;
+        const cleanSummary = cleanForStorage(summary);
+        const cleanError = errorContext ? cleanForStorage(errorContext) : "";
+        const reflection = cleanError ? `FAILED: ${cleanSummary.slice(0, 200)} \u2014 Error: ${cleanError.slice(0, 300)}` : `FAILED: ${cleanSummary.slice(0, 500)}`;
         this.state.reflectionBuffer.push(reflection);
         if (this.state.reflectionBuffer.length > 5) {
           this.state.reflectionBuffer.shift();
@@ -315295,7 +315357,8 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
         return { success: false, output: "", error: "task is required" };
       }
       const agentId = `sub-agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      const agentLabel = `sub_agent: ${task.slice(0, 40)}${task.length > 40 ? "..." : ""}`;
+      const cleanedLabelTask = cleanForStorage(task) || task;
+      const agentLabel = `sub_agent: ${cleanedLabelTask.slice(0, 40)}${cleanedLabelTask.length > 40 ? "..." : ""}`;
       if (onViewRegister) {
         onViewRegister(agentId, agentLabel);
       }
@@ -315355,7 +315418,7 @@ function createSubAgentTool(config, repoRoot, ctxWindowSize) {
           if (onComplete) onComplete(agentId, task, result2.completed ? 0 : 1, output2);
           return output2;
         });
-        const taskId = taskManager.trackPromise(`sub_agent: ${task.slice(0, 80)}`, promise);
+        const taskId = taskManager.trackPromise(`sub_agent: ${cleanedLabelTask.slice(0, 80)}`, promise);
         return {
           success: true,
           output: `Sub-agent started in background: ${taskId}
@@ -320982,7 +321045,8 @@ function statusCommand(jobId, repoPath) {
   const runtime = job.completedAt ? `${((new Date(job.completedAt).getTime() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s` : `${((Date.now() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s`;
   const icon = job.status === "completed" ? "\u2713" : job.status === "failed" ? "\u2717" : "\u25CF";
   console.log(`${icon} ${job.id} [${job.status}] ${runtime}`);
-  console.log(`  Task: ${job.task.slice(0, 80)}`);
+  const cleanTask = cleanForStorage(job.task) || job.task;
+  console.log(`  Task: ${cleanTask.slice(0, 80)}`);
   console.log(`  PID: ${job.pid}`);
   if (job.summary) console.log(`  Summary: ${job.summary}`);
   if (job.error) console.log(`  Error: ${job.error}`);
@@ -321001,7 +321065,8 @@ function jobsCommand(repoPath) {
       const job = JSON.parse(readFileSync61(join95(dir, file), "utf-8"));
       const icon = job.status === "completed" ? "\u2713" : job.status === "failed" ? "\u2717" : "\u25CF";
       const runtime = job.completedAt ? `${((new Date(job.completedAt).getTime() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s` : `${((Date.now() - new Date(job.startedAt).getTime()) / 1e3).toFixed(0)}s`;
-      console.log(`  ${icon} ${job.id} [${job.status}] ${runtime} \u2014 ${job.task.slice(0, 60)}`);
+      const cleanListTask = cleanForStorage(job.task) || job.task;
+      console.log(`  ${icon} ${job.id} [${job.status}] ${runtime} \u2014 ${cleanListTask.slice(0, 60)}`);
     } catch {
     }
   }
@@ -321010,6 +321075,7 @@ var init_run = __esm({
   "packages/cli/src/commands/run.ts"() {
     "use strict";
     init_interactive();
+    init_dist8();
   }
 });
 
@@ -321728,6 +321794,17 @@ async function serveCommand(opts, config) {
     printInfo(`Starting API server on port ${port}...`);
     printInfo(`Backend: ${config.backendType} (${ollamaUrl})`);
   }
+  if (isDaemon) {
+    try {
+      const resp = await fetch(`http://127.0.0.1:${port}/health`, {
+        signal: AbortSignal.timeout(1500)
+      });
+      if (resp.ok) {
+        return;
+      }
+    } catch {
+    }
+  }
   try {
     const server = startApiServer({ port, ollamaUrl, quiet: isQuiet });
     if (isDaemon) {
@@ -321755,6 +321832,9 @@ async function serveCommand(opts, config) {
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     if (msg.includes("EADDRINUSE")) {
+      if (isDaemon) {
+        return;
+      }
       if (!isQuiet) {
         printError(`Port ${port} already in use. Another OA instance may be running.`);
         printInfo(`Try: oa serve --port ${port + 1}`);

package/dist/postinstall-daemon.cjs

@@ -0,0 +1,486 @@
+#!/usr/bin/env node
+/* eslint-disable */
+/**
+ * postinstall-daemon.cjs — system-service installer for the OA API daemon.
+ *
+ * Runs after `npm install -g open-agents-ai`. Responsibilities:
+ *   1. Clean up stale nexus daemon files (preserving prior postinstall behaviour).
+ *   2. Register a per-user system service that runs `oa serve --daemon`
+ *      on port 11435, surviving reboots/logins.
+ *        Linux   → ~/.config/systemd/user/open-agents-daemon.service
+ *        macOS   → ~/Library/LaunchAgents/ai.open-agents.daemon.plist
+ *        Windows → Scheduled Task "OpenAgentsDaemon" (onlogon)
+ *   3. Start (or restart) the service so the daemon is live IMMEDIATELY —
+ *      no need to launch `oa` in any terminal.
+ *   4. Never exit non-zero. npm install must not fail because of a service
+ *      manager quirk or a permission quirk. We warn and move on.
+ *
+ * Opt-out: set env OA_SKIP_DAEMON_INSTALL=1 before `npm i -g`.
+ *
+ * ES5-safe pure CommonJS — runs on any Node version that survived preinstall.
+ */
+
+"use strict";
+
+var os = require("os");
+var path = require("path");
+var fs = require("fs");
+var cp = require("child_process");
+
+var HOME = os.homedir();
+var PLATFORM = os.platform(); // "linux", "darwin", "win32"
+var IS_WIN = PLATFORM === "win32";
+var IS_MAC = PLATFORM === "darwin";
+var IS_LINUX = PLATFORM === "linux";
+
+var PORT = parseInt(process.env.OA_PORT || "11435", 10);
+var SERVICE_LABEL = "open-agents-daemon";
+var LAUNCHD_LABEL = "ai.open-agents.daemon";
+var WIN_TASK_NAME = "OpenAgentsDaemon";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function log(msg) {
+  // Use stdout so npm captures it in the install log.
+  process.stdout.write("  " + msg + "\n");
+}
+function warn(msg) {
+  process.stdout.write("  [daemon] " + msg + "\n");
+}
+
+function runQuiet(cmd, opts) {
+  try {
+    cp.execSync(cmd, Object.assign({ stdio: "pipe", timeout: 15000 }, opts || {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function runCapture(cmd, opts) {
+  try {
+    return cp.execSync(cmd, Object.assign({ stdio: ["ignore", "pipe", "ignore"], encoding: "utf8", timeout: 15000 }, opts || {})).trim();
+  } catch (e) {
+    return "";
+  }
+}
+
+function hasCmd(name) {
+  if (IS_WIN) return runQuiet("where " + name);
+  return runQuiet("which " + name);
+}
+
+// Pre-check: is the port already serving an OA daemon?
+function tryHealth(port, cb) {
+  var http = require("http");
+  var req = http.request(
+    { host: "127.0.0.1", port: port, path: "/health", method: "GET", timeout: 1500 },
+    function (res) {
+      cb(res.statusCode === 200);
+      res.resume();
+    }
+  );
+  req.on("error", function () { cb(false); });
+  req.on("timeout", function () { req.destroy(); cb(false); });
+  req.end();
+}
+
+// Resolve the `oa` launcher script. On npm global install:
+//   Linux/macOS:  $(npm prefix -g)/bin/oa
+//   Windows:      %APPDATA%/npm/oa.cmd
+function resolveOaBinary() {
+  // 1. If npm set npm_config_prefix, use it.
+  var prefix = process.env.npm_config_prefix || "";
+  if (!prefix) {
+    // 2. Ask npm.
+    prefix = runCapture("npm prefix -g");
+  }
+
+  var candidates = [];
+  if (prefix) {
+    if (IS_WIN) {
+      candidates.push(path.join(prefix, "oa.cmd"));
+      candidates.push(path.join(prefix, "oa"));
+    } else {
+      candidates.push(path.join(prefix, "bin", "oa"));
+      candidates.push(path.join(prefix, "bin", "open-agents"));
+    }
+  }
+  // 3. PATH fallback via which/where.
+  var found = runCapture(IS_WIN ? "where oa" : "which oa").split(/\r?\n/)[0];
+  if (found) candidates.push(found);
+
+  // 4. Relative to this script: <pkg>/dist/launcher.cjs
+  try {
+    candidates.push(path.resolve(__dirname, "launcher.cjs"));
+  } catch (e) {}
+
+  for (var i = 0; i < candidates.length; i++) {
+    try {
+      if (candidates[i] && fs.existsSync(candidates[i])) return candidates[i];
+    } catch (e) {}
+  }
+  return null;
+}
+
+// Find a Node binary we can use in the service ExecStart.
+// On nvm systems this is important — /usr/bin/node is often too old.
+function resolveNodeBinary() {
+  try {
+    if (process.execPath && fs.existsSync(process.execPath)) return process.execPath;
+  } catch (e) {}
+  var found = runCapture(IS_WIN ? "where node" : "which node").split(/\r?\n/)[0];
+  if (found) return found;
+  return "node";
+}
+
+// Effective user for service ownership. Handle `sudo npm i -g` by preferring
+// SUDO_USER when running as root on Linux/macOS.
+function effectiveUser() {
+  if (!IS_WIN && process.getuid && process.getuid() === 0) {
+    var sudoUser = process.env.SUDO_USER;
+    if (sudoUser) return sudoUser;
+    return null; // Running as bare root — skip per-user service install
+  }
+  return process.env.USER || process.env.LOGNAME || os.userInfo().username;
+}
+
+// ─── Nexus cleanup (preserve prior postinstall behaviour) ──────────────────
+
+function cleanNexus() {
+  try {
+    var dirs = [
+      path.join(HOME, ".open-agents", ".oa", "nexus"),
+      path.join(process.cwd(), ".oa", "nexus"),
+    ];
+    dirs.forEach(function (d) {
+      var stale = path.join(d, "nexus-daemon.mjs");
+      try {
+        if (fs.existsSync(stale)) {
+          fs.unlinkSync(stale);
+          log("Cleaned stale nexus daemon: " + stale);
+        }
+      } catch (e) {}
+      var pidFile = path.join(d, "daemon.pid");
+      try {
+        if (fs.existsSync(pidFile)) {
+          var n = parseInt(fs.readFileSync(pidFile, "utf8"), 10);
+          if (n > 0) {
+            try { process.kill(n, "SIGTERM"); } catch (e) {}
+          }
+          fs.unlinkSync(pidFile);
+          log("Killed old nexus daemon: PID " + n);
+        }
+      } catch (e) {}
+    });
+  } catch (e) {}
+}
+
+// ─── Linux: systemd user unit ───────────────────────────────────────────────
+
+function installSystemd(nodeBin, oaScript, user) {
+  if (!IS_LINUX) return false;
+  if (!hasCmd("systemctl")) {
+    warn("systemctl not found — skipping systemd install.");
+    return false;
+  }
+
+  var userHome = user === process.env.USER ? HOME : path.join("/home", user);
+  try {
+    var pwdEntry = runCapture("getent passwd " + user);
+    if (pwdEntry) {
+      var parts = pwdEntry.split(":");
+      if (parts[5]) userHome = parts[5];
+    }
+  } catch (e) {}
+
+  var unitDir = path.join(userHome, ".config", "systemd", "user");
+  var unitPath = path.join(unitDir, SERVICE_LABEL + ".service");
+  var logDir = path.join(userHome, ".open-agents");
+
+  try { fs.mkdirSync(unitDir, { recursive: true }); } catch (e) {}
+  try { fs.mkdirSync(logDir, { recursive: true }); } catch (e) {}
+
+  // The unit runs: <node> <oaScript> serve --daemon --quiet
+  // with OA_DAEMON=1 so the serve command picks the daemon path.
+  var unit = [
+    "[Unit]",
+    "Description=Open Agents API Daemon (port " + PORT + ")",
+    "Documentation=https://github.com/robit-man/open-agents",
+    "After=network-online.target",
+    "Wants=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    "Environment=OA_DAEMON=1",
+    "Environment=OA_PORT=" + PORT,
+    "Environment=NODE_ENV=production",
+    "ExecStart=" + nodeBin + " " + oaScript + " serve --daemon --quiet",
+    "Restart=on-failure",
+    "RestartSec=3",
+    "StandardOutput=append:" + path.join(logDir, "daemon.log"),
+    "StandardError=append:" + path.join(logDir, "daemon.err.log"),
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    "",
+  ].join("\n");
+
+  try {
+    fs.writeFileSync(unitPath, unit, { encoding: "utf8" });
+    log("Wrote systemd user unit: " + unitPath);
+  } catch (e) {
+    warn("Failed to write systemd unit: " + (e && e.message));
+    return false;
+  }
+
+  // If we're root installing for another user, we need to wrap systemctl
+  // calls in `sudo -u USER XDG_RUNTIME_DIR=/run/user/UID systemctl --user`.
+  var asUserPrefix = "";
+  if (!IS_WIN && process.getuid && process.getuid() === 0 && user !== "root") {
+    // Try to resolve UID for the target user.
+    var uid = runCapture("id -u " + user);
+    if (uid && /^\d+$/.test(uid)) {
+      // Ensure loginctl linger so user services can run without a session.
+      runQuiet("loginctl enable-linger " + user);
+      asUserPrefix = "sudo -u " + user + " XDG_RUNTIME_DIR=/run/user/" + uid + " DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/" + uid + "/bus ";
+    }
+  } else if (!IS_WIN && process.getuid && process.getuid() !== 0) {
+    // Self-install: enable-linger ourselves if we can (best-effort; needs sudo on most distros).
+    runQuiet("loginctl enable-linger " + user);
+  }
+
+  var sysctl = asUserPrefix + "systemctl --user";
+  runQuiet(sysctl + " daemon-reload");
+  var enabled = runQuiet(sysctl + " enable " + SERVICE_LABEL + ".service");
+  var restarted = runQuiet(sysctl + " restart " + SERVICE_LABEL + ".service");
+
+  if (enabled) log("Enabled systemd unit: " + SERVICE_LABEL);
+  if (restarted) log("Started systemd unit: " + SERVICE_LABEL);
+  if (!enabled || !restarted) {
+    warn("Could not enable/start the unit via systemctl --user. The file is in place; run manually:");
+    warn("  systemctl --user daemon-reload");
+    warn("  systemctl --user enable --now " + SERVICE_LABEL + ".service");
+  }
+
+  return true;
+}
+
+// ─── macOS: launchd user agent ──────────────────────────────────────────────
+
+function installLaunchd(nodeBin, oaScript, user) {
+  if (!IS_MAC) return false;
+
+  var userHome = HOME;
+  if (user && user !== os.userInfo().username) {
+    try {
+      var home = runCapture("dscl . -read /Users/" + user + " NFSHomeDirectory").split(" ").pop();
+      if (home) userHome = home;
+    } catch (e) {}
+  }
+
+  var agentDir = path.join(userHome, "Library", "LaunchAgents");
+  var plistPath = path.join(agentDir, LAUNCHD_LABEL + ".plist");
+  var logDir = path.join(userHome, ".open-agents");
+
+  try { fs.mkdirSync(agentDir, { recursive: true }); } catch (e) {}
+  try { fs.mkdirSync(logDir, { recursive: true }); } catch (e) {}
+
+  var plist = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    '<dict>',
+    '  <key>Label</key><string>' + LAUNCHD_LABEL + '</string>',
+    '  <key>ProgramArguments</key>',
+    '  <array>',
+    '    <string>' + nodeBin + '</string>',
+    '    <string>' + oaScript + '</string>',
+    '    <string>serve</string>',
+    '    <string>--daemon</string>',
+    '    <string>--quiet</string>',
+    '  </array>',
+    '  <key>EnvironmentVariables</key>',
+    '  <dict>',
+    '    <key>OA_DAEMON</key><string>1</string>',
+    '    <key>OA_PORT</key><string>' + PORT + '</string>',
+    '    <key>PATH</key><string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>',
+    '  </dict>',
+    '  <key>RunAtLoad</key><true/>',
+    '  <key>KeepAlive</key><true/>',
+    '  <key>StandardOutPath</key><string>' + path.join(logDir, "daemon.log") + '</string>',
+    '  <key>StandardErrorPath</key><string>' + path.join(logDir, "daemon.err.log") + '</string>',
+    '</dict>',
+    '</plist>',
+    '',
+  ].join("\n");
+
+  try {
+    fs.writeFileSync(plistPath, plist, { encoding: "utf8" });
+    log("Wrote launchd plist: " + plistPath);
+  } catch (e) {
+    warn("Failed to write launchd plist: " + (e && e.message));
+    return false;
+  }
+
+  // Unload then load (idempotent). bootout/bootstrap prefer gui/<uid> on newer macOS.
+  var uid = runCapture("id -u " + user);
+  if (uid && /^\d+$/.test(uid)) {
+    runQuiet("launchctl bootout gui/" + uid + "/" + LAUNCHD_LABEL);
+    var booted = runQuiet("launchctl bootstrap gui/" + uid + " " + plistPath);
+    if (booted) log("Loaded launchd agent: " + LAUNCHD_LABEL);
+    runQuiet("launchctl kickstart -k gui/" + uid + "/" + LAUNCHD_LABEL);
+  } else {
+    runQuiet("launchctl unload " + plistPath);
+    runQuiet("launchctl load -w " + plistPath);
+  }
+  return true;
+}
+
+// ─── Windows: Scheduled Task ────────────────────────────────────────────────
+
+function installWindows(nodeBin, oaScript) {
+  if (!IS_WIN) return false;
+  if (!hasCmd("schtasks")) {
+    warn("schtasks not found — skipping Windows scheduled task install.");
+    return false;
+  }
+
+  // Build the task command — quote the paths.
+  var trCmd = '"' + nodeBin + '" "' + oaScript + '" serve --daemon --quiet';
+
+  // Delete any existing task first (idempotent).
+  runQuiet('schtasks /Delete /TN "' + WIN_TASK_NAME + '" /F');
+
+  var created = runQuiet(
+    'schtasks /Create /F /SC ONLOGON /RL HIGHEST /TN "' + WIN_TASK_NAME + '" /TR ' + JSON.stringify(trCmd)
+  );
+  if (!created) {
+    warn("Failed to create scheduled task. Try running `oa daemon install` from an elevated shell.");
+    return false;
+  }
+  log("Created scheduled task: " + WIN_TASK_NAME);
+  // Start it immediately.
+  runQuiet('schtasks /Run /TN "' + WIN_TASK_NAME + '"');
+  return true;
+}
+
+// ─── Fallback: spawn detached now (no persistence) ─────────────────────────
+
+function spawnDetached(nodeBin, oaScript) {
+  try {
+    var child = cp.spawn(nodeBin, [oaScript, "serve", "--daemon", "--quiet"], {
+      detached: true,
+      stdio: "ignore",
+      env: Object.assign({}, process.env, { OA_DAEMON: "1", OA_PORT: String(PORT) }),
+    });
+    child.unref();
+    if (child.pid) {
+      log("Spawned detached daemon (PID " + child.pid + "). It will NOT survive reboot — install a service manager to persist.");
+      return true;
+    }
+  } catch (e) {
+    warn("Failed to spawn detached daemon: " + (e && e.message));
+  }
+  return false;
+}
+
+// ─── Wait for /health ───────────────────────────────────────────────────────
+
+function waitForHealth(timeoutMs, cb) {
+  var start = Date.now();
+  function tick() {
+    tryHealth(PORT, function (ok) {
+      if (ok) return cb(true);
+      if (Date.now() - start > timeoutMs) return cb(false);
+      setTimeout(tick, 500);
+    });
+  }
+  tick();
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+function main() {
+  // Always do the nexus cleanup first, regardless of opt-out.
+  cleanNexus();
+
+  if (process.env.OA_SKIP_DAEMON_INSTALL === "1") {
+    log("OA_SKIP_DAEMON_INSTALL=1 — skipping daemon service install.");
+    return safeExit(0);
+  }
+
+  // Fast path: daemon already answering /health on the target port.
+  tryHealth(PORT, function (alreadyUp) {
+    var user = effectiveUser();
+    var nodeBin = resolveNodeBinary();
+    var oaScript = resolveOaBinary();
+
+    if (!oaScript) {
+      warn("Could not resolve `oa` launcher — daemon install skipped. After install completes, run `oa daemon install` manually.");
+      return safeExit(0);
+    }
+
+    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("Installing OA API daemon service for port " + PORT + " ...");
+    log("  node:       " + nodeBin);
+    log("  oa script:  " + oaScript);
+    log("  user:       " + (user || "(unknown)"));
+
+    if (!user) {
+      warn("Running as bare root with no SUDO_USER — skipping per-user service install.");
+      warn("Re-run as your user, or run: OA_SKIP_DAEMON_INSTALL=0 npm i -g open-agents-ai");
+      // Still spawn detached so the port is live right now.
+      spawnDetached(nodeBin, oaScript);
+      return safeExit(0);
+    }
+
+    var ok = false;
+    if (IS_LINUX) {
+      ok = installSystemd(nodeBin, oaScript, user);
+    } else if (IS_MAC) {
+      ok = installLaunchd(nodeBin, oaScript, user);
+    } else if (IS_WIN) {
+      ok = installWindows(nodeBin, oaScript);
+    } else {
+      warn("Unsupported platform: " + PLATFORM + " — falling back to detached spawn.");
+    }
+
+    if (!ok) {
+      // Fallback: spawn a detached child so at least the port is live NOW.
+      spawnDetached(nodeBin, oaScript);
+    }
+
+    // Wait up to 15s for /health to come up, but don't fail npm install.
+    waitForHealth(15000, function (healthy) {
+      if (healthy) {
+        log("OA API daemon is live: http://127.0.0.1:" + PORT + "/health");
+      } else {
+        warn("OA API daemon did not answer /health within 15s. Check logs:");
+        if (IS_LINUX) warn("  systemctl --user status " + SERVICE_LABEL);
+        if (IS_MAC) warn("  launchctl print gui/$(id -u)/" + LAUNCHD_LABEL);
+        if (IS_WIN) warn("  schtasks /Query /TN " + WIN_TASK_NAME + " /V /FO LIST");
+      }
+      safeExit(0);
+    });
+  });
+}
+
+function safeExit(code) {
+  // Never exit non-zero from postinstall — it breaks `npm i -g`.
+  process.exit(typeof code === "number" ? 0 : 0);
+}
+
+// Guard against any unhandled throw — postinstall must not crash npm.
+try {
+  main();
+} catch (e) {
+  warn("postinstall crashed (non-fatal): " + (e && e.message));
+  safeExit(0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.187.183",
+  "version": "0.187.185",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",
@@ -72,7 +72,7 @@
   "license": "CC-BY-NC-4.0",
   "scripts": {
     "preinstall": "node dist/preinstall.cjs",
-    "postinstall": "node -e \"try{var p=require('path'),f=require('fs'),h=require('os').homedir();var dirs=[p.join(h,'.open-agents','.oa','nexus'),p.join(process.cwd(),'.oa','nexus')];dirs.forEach(function(d){var s=p.join(d,'nexus-daemon.mjs');try{if(f.existsSync(s)){f.unlinkSync(s);console.log('  Cleaned stale daemon: '+s)}}catch(e){}var pid=p.join(d,'daemon.pid');try{if(f.existsSync(pid)){var n=parseInt(f.readFileSync(pid,'utf8'),10);if(n>0)try{process.kill(n,'SIGTERM')}catch(e){}f.unlinkSync(pid);console.log('  Killed old daemon: PID '+n)}}catch(e){}})}catch(e){}\""
+    "postinstall": "node dist/postinstall-daemon.cjs"
   },
   "engines": {
     "node": ">=22.0.0"