open-agents-ai 0.187.184 → 0.187.185

package/dist/index.js

@@ -321794,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) {
@@ -321821,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.184",
+  "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"