agentglow 0.3.1 → 0.3.2

package/cli/agentglow.mjs

@@ -10,11 +10,11 @@ import {
   baseUrl, claudeSettings, installSettingsFile, isOurHook, pluginIdsIn, readState, startHookCommand, uninstallSettingsFile,
 } from "./lib/settings.mjs";
 import {
-  clearLock, installCliCopy, localBase, readLock, readPid, removeCliCopies, serveForeground, spawnStarter,
+  clearLock, installCliCopy, localBase, readLock, readPid, refreshStaleServer, removeCliCopies, serveForeground, spawnStarter,
   startBackground, stopServer,
 } from "./lib/server.mjs";
 import { which } from "./lib/uv.mjs";
-import { hasAutostart, installAutostart, launchdLogPath, loginPath, removeAutostart, stopLoginItem } from "./lib/autostart.mjs";
+import { hasAutostart, installAutostart, launchdLogPath, loginPath, removeAutostart, restartLoginItem, stopLoginItem } from "./lib/autostart.mjs";
 
 const SELF = fileURLToPath(import.meta.url);
 const here = path.dirname(SELF);
@@ -180,8 +180,12 @@ async function cmdSetup(o) {
     const wantLogin = o.autostart === true || (o.autostart !== false && process.platform !== "win32");
     const login = wantLogin ? installLoginItem(port) : null;
     try {
-      if (login?.startsNow && (await waitHealthy(port, 120000))) console.log(`AgentGlow server is running on port ${port} (managed by ${login.method}).`);
-      else {
+      if (login?.startsNow && (await waitHealthy(port, 120000))) {
+        // an older server may still hold the port (the login item's new `start` then exits at once): replace it
+        const r = await refreshStaleServer({ port, expected: VERSION, deps: { restart: () => restartLoginItem() } });
+        if (r === "stale") console.error(`agentglow: warning: an older AgentGlow server still runs on port ${port}; stop it: npx agentglow stop${portFlag(port)}`);
+        console.log(`AgentGlow server ${r === "down" ? "is starting" : "is running"} on port ${port} (managed by ${login.method}).`);
+      } else {
         const s2 = await startLocal(port);
         console.log(s2.started ? `Started the AgentGlow server on port ${port}.` : `AgentGlow server already running on port ${port}.`);
       }

package/cli/lib/autostart.mjs

@@ -143,6 +143,29 @@ export function stopLoginItem({ platform = process.platform } = {}) {
   }
 }
 
+/** argv that restarts the login-item server now (kills the running one first); null on Windows (two schtasks calls). */
+export function restartArgv({ platform = process.platform, uid = process.getuid?.() ?? 0 } = {}) {
+  if (platform === "darwin") return ["launchctl", "kickstart", "-k", `gui/${uid}/${LABEL}`];
+  if (platform === "win32") return null;
+  return ["systemctl", "--user", "restart", "agentglow"];
+}
+
+/** Restart the login-item server (e.g. setup installed a newer version while an older one runs). Never throws. */
+export function restartLoginItem({ platform = process.platform } = {}) {
+  try {
+    if (platform === "win32") {
+      try { execFileSync("schtasks", ["/end", "/tn", TASK_NAME], { stdio: "pipe" }); } catch { /* not running */ }
+      execFileSync("schtasks", ["/run", "/tn", TASK_NAME], { stdio: "pipe" });
+    } else {
+      const [cmd, ...args] = restartArgv({ platform });
+      execFileSync(cmd, args, { stdio: "pipe" });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 /** Best-effort check: is the autostart entry currently installed? Never throws. */
 export function hasAutostart({ platform = process.platform, home = os.homedir() } = {}) {
   try {

package/cli/lib/server.mjs

@@ -121,6 +121,55 @@ export function killTree(pid) {
   try { process.kill(-pid, "SIGTERM"); } catch { try { process.kill(pid, "SIGTERM"); } catch { /* gone */ } }
 }
 
+/** Version the server on `port` reports in /live/health ("" when down or unknown). */
+export async function serverVersion(port) {
+  try { return JSON.parse((await fetchText(localBase(port) + "/live/health", 2000))?.body || "{}").version || ""; } catch { return ""; }
+}
+
+/** PIDs listening on a local TCP port (lsof; macOS / Linux). [] when unknown. */
+export function listenerPids(port) {
+  if (process.platform === "win32") return [];
+  const r = spawnSync("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { encoding: "utf8" });
+  return (r.stdout || "").split(/\s+/).map(Number).filter((n) => n > 0 && n !== process.pid);
+}
+
+/**
+ * After `setup` (re)installed the login item: a server of another version still answering on the port (started by
+ * an older CLI, the SessionStart hook, or a login item launchd/systemd did not restart) is replaced by this version.
+ * Steps, each only while the old version still answers: stop the server this CLI started (pid file), restart the
+ * login item (launchctl kickstart -k / systemctl --user restart), then terminate whatever AgentGlow server still
+ * listens on the port. Waits for `expected` to answer. Returns "current" | "restarted" | "stale" (old one still up)
+ * | "down". Dependencies are injectable (tests).
+ */
+export async function refreshStaleServer({ port, expected, log = console.log, deps = {} }) {
+  const d = {
+    version: serverVersion, stop: stopServer, restart: () => false, listeners: listenerPids, kill: (pid) => process.kill(pid, "SIGTERM"),
+    sleep, timeoutMs: 120000, ...deps,
+  };
+  const running = await d.version(port);
+  if (!running || !expected || running === expected) return "current";
+  log(`The AgentGlow server on port ${port} is ${running}; this CLI is ${expected}. Restarting it ...`);
+  const waitFor = async (ms) => {
+    for (const t0 = Date.now(); Date.now() - t0 < ms; await d.sleep(500)) {
+      const v = await d.version(port);
+      if (v === expected) return v;
+      if (v && v !== running) return v;
+    }
+    return d.version(port);
+  };
+  await d.stop(port);
+  let v = await d.version(port);
+  if (v === running && d.restart()) v = await waitFor(8000);
+  if (v === running) {  // nobody manages it (or the supervisor left it): it is AgentGlow (it answered), stop it
+    for (const pid of d.listeners(port)) { try { d.kill(pid); } catch { /* gone */ } }
+    await d.sleep(1000);
+    if (!d.restart()) log("  (no login item to restart: the next claude session starts the server)");
+  }
+  v = await waitFor(d.timeoutMs);
+  if (v === expected) return "restarted";
+  return v ? "stale" : "down";
+}
+
 /** Stop a server this CLI started. Returns "stopped" | "not-ours" | "none". */
 export async function stopServer(port) {
   const starter = readLock(port);