ai-agentmanager 1.3.0 → 1.3.1

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.3.1 (2026-10-31)
+
+- **Restart comes back:** `agentmgr restart` waits for the old daemon to exit (it closes every agent first, which takes a while with many), instead of giving up after 20 seconds and reporting success with no daemon left. `serve` started while one is shutting down waits for it instead of exiting, and `shutdown` returns once the daemon has stopped. `/api/health` says `closing` while it shuts down.
+- **Pull request status is current:** checking an agent's pull requests while a check is already running (after an update, a stop or a push) waits for it and checks again, instead of returning what that earlier check read, so a pull request ready to merge could still show as needing fixes.
+
 ## 1.3.0 (2026-10-31)
 
 - **Review changes:** each agent's changes in one screen: changed files, the diff file by file (new files included), line comments sent to the agent as one message, **Commit all**, and **Push & open PR** with `gh`. `agentmgr changes`, `comment`, `commit`, `pr`.

package/README.md

@@ -83,13 +83,13 @@ Runs on macOS and Linux; on Windows, use WSL2. Requires Node 20+, `git`, and the
 
 ```sh
 npm install -g ai-agentmanager          # the latest release
-npm install -g ai-agentmanager@1.3.0    # or a specific one
+npm install -g ai-agentmanager@1.3.1    # or a specific one
 ```
 
 Or from the repository, at a release tag:
 
 ```sh
-git clone --branch v1.3.0 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
+git clone --branch v1.3.1 --depth 1 https://github.com/jdmunta/ai-agentmanager-core.git
 cd ai-agentmanager-core
 npm install
 npm link            # optional: puts `agentmgr` on your PATH
@@ -109,7 +109,7 @@ npm link
 | Installed with | Update |
 | --- | --- |
 | npm | `npm install -g ai-agentmanager@latest` |
-| A clone at a release tag | `git fetch --tags && git checkout v1.3.0 && npm install` (the tag you want) |
+| A clone at a release tag | `git fetch --tags && git checkout v1.3.1 && npm install` (the tag you want) |
 | A clone of `main` | `git pull && npm install` |
 
 **Check your setup.** `agentmgr doctor` checks Node.js, Claude Code and its sign-in, git, `gh`, the data folder, the daemon's port and Chrome, and says how to fix anything missing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-agentmanager",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Run background coding agents (Claude Code, Codex) per intent, and keep track of them from a web UI, your phone or the CLI",
   "keywords": [
     "claude",

package/src/cli.js

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import { Command, Option } from 'commander';
 import WebSocket from 'ws';
 import { HOST, PORT } from './config.js';
-import { api, BASE, ensureDaemon, isRunning } from './client.js';
+import { api, BASE, ensureDaemon, health, isRunning, waitForExit } from './client.js';
 import { about, latestRelease } from './about.js';
 
 const tty = process.stdout.isTTY;
@@ -271,10 +271,16 @@ export async function main(argv) {
     .command('serve')
     .description('Run the agent daemon (API + web UI) in the foreground')
     .action(async () => {
-      if (await isRunning()) {
+      const h = await health();
+      if (h && !h.closing) {
         // Clean exit, so a login service doesn't keep retrying while another daemon owns the port.
         return console.log(`[agentmgr] a daemon is already running at ${BASE}; not starting another`);
       }
+      if (h?.closing) {
+        // One that is shutting down closes its agents first; start once it has exited.
+        console.log(`[agentmgr] waiting for the previous daemon (pid ${h.pid}) to finish shutting down`);
+        if (!(await waitForExit(h.pid))) return console.log(`[agentmgr] the previous daemon (pid ${h.pid}) is still shutting down; not starting`);
+      }
       const { startServer } = await import('./server.js');
       const { url } = await startServer();
       console.log(`[agentmgr] listening on ${url}`);
@@ -1789,10 +1795,11 @@ export async function main(argv) {
     .description('Register the daemon with launchd (macOS) or systemd --user (Linux) and start it')
     .action(async () => {
       const svc = await import('./service.js');
-      if (await isRunning()) {
+      const h = await health();
+      if (h) {
         // Hand over to the service-managed daemon; running agents are resumed by it.
-        await api('POST', '/shutdown');
-        for (let i = 0; i < 50 && (await isRunning()); i++) await new Promise((r) => setTimeout(r, 200));
+        if (!h.closing) await api('POST', '/shutdown');
+        await waitForExit(h.pid, { onWait: (s) => console.log(dim(`closing agents… (${s}s)`)) });
       }
       const res = await svc.install();
       for (let i = 0; i < 100 && !(await isRunning()); i++) await new Promise((r) => setTimeout(r, 200));
@@ -2001,7 +2008,8 @@ export async function main(argv) {
     .description('Flush, stop the daemon, and start it again; running agents resume their sessions')
     .action(async () => {
       const svc = await import('./service.js');
-      if (await isRunning()) {
+      const before = await health();
+      if (before && !before.closing) {
         try {
           const r = await api('POST', '/flush');
           console.log(dim(`saved ${r.agents} agents, scrollback for ${r.scrollback}`));
@@ -2011,13 +2019,21 @@ export async function main(argv) {
           console.log(dim('running daemon is an older version (no flush); restarting it to upgrade'));
         }
         await api('POST', '/shutdown');
-        for (let i = 0; i < 100 && (await isRunning()); i++) await new Promise((res) => setTimeout(res, 200));
+      }
+      // Wait for the old process itself to exit: it answers until every agent is closed.
+      if (before?.pid) {
+        const gone = await waitForExit(before.pid, { onWait: (s) => console.log(dim(`closing agents… (${s}s)`)) });
+        if (!gone) throw new Error(`The daemon (pid ${before.pid}) is still shutting down after 5 minutes; check the log`);
       }
       const st = await svc.status();
       if (st.loaded) await svc.kickstart();
       else await ensureDaemon({ quiet: true });
-      for (let i = 0; i < 100 && !(await isRunning()); i++) await new Promise((res) => setTimeout(res, 200));
-      if (!(await isRunning())) throw new Error('Daemon did not come back; check the log');
+      const back = async () => {
+        const h = await health();
+        return Boolean(h && !h.closing && h.pid !== before?.pid);
+      };
+      for (let i = 0; i < 150 && !(await back()); i++) await new Promise((res) => setTimeout(res, 200));
+      if (!(await back())) throw new Error('Daemon did not come back; check the log');
       const agents = await api('GET', '/agents');
       console.log(`${green('✓')} restarted${st.loaded ? ' (login service)' : ''}; ${agents.filter((a) => a.desired === 'running').length} agents set to resume`);
     });
@@ -2026,9 +2042,12 @@ export async function main(argv) {
     .command('shutdown')
     .description('Stop the daemon (running agents are closed; sessions are kept)')
     .action(async () => {
-      if (!(await isRunning())) return console.log('Daemon is not running');
-      await api('POST', '/shutdown');
-      console.log('Daemon stopped');
+      const h = await health();
+      if (!h) return console.log('Daemon is not running');
+      if (!h.closing) await api('POST', '/shutdown');
+      // It closes every agent before it exits; say stopped only once it has.
+      const gone = await waitForExit(h.pid, { onWait: (s) => console.log(dim(`closing agents… (${s}s)`)) });
+      console.log(gone ? 'Daemon stopped' : yellow(`The daemon (pid ${h.pid}) is still shutting down; check the log`));
     });
 
   try {

package/src/client.js

@@ -19,18 +19,58 @@ export async function api(method, route, body) {
   return data;
 }
 
+/** The daemon's /health answer ({ ok, pid, closing, … }), or null when nothing answers. */
+export async function health() {
+  try {
+    return await api('GET', '/health');
+  } catch {
+    return null;
+  }
+}
+
+/** A daemon that answers and isn't shutting down. */
 export async function isRunning() {
+  const h = await health();
+  return Boolean(h && !h.closing);
+}
+
+const alive = (pid) => {
   try {
-    await api('GET', '/health');
+    process.kill(pid, 0);
     return true;
-  } catch {
-    return false;
+  } catch (e) {
+    return e.code === 'EPERM';
+  }
+};
+
+/**
+ * Wait for a daemon process to exit. Shutting down closes every agent first (to save their
+ * sessions), which takes a while with many agents, and it answers /health until then.
+ * Returns true once it is gone, false after `timeoutMs`.
+ */
+export async function waitForExit(pid, { timeoutMs = 300_000, onWait = null } = {}) {
+  if (!pid) return true;
+  const start = Date.now();
+  let told = 0;
+  while (alive(pid)) {
+    if (Date.now() - start > timeoutMs) return false;
+    if (onWait && Date.now() - told > 10_000) {
+      told = Date.now();
+      onWait(Math.round((Date.now() - start) / 1000));
+    }
+    await new Promise((r) => setTimeout(r, 500));
   }
+  return true;
 }
 
-/** Start the daemon in the background if it is not already listening. */
+/** Start the daemon in the background if it is not already listening (waiting out one that is shutting down). */
 export async function ensureDaemon({ quiet = false } = {}) {
-  if (await isRunning()) return false;
+  const h = await health();
+  if (h && !h.closing) return false;
+  if (h?.closing) {
+    if (!quiet) process.stderr.write(`agentmgr: waiting for the daemon (pid ${h.pid}) to finish shutting down…\n`);
+    if (!(await waitForExit(h.pid))) throw new Error(`The daemon (pid ${h.pid}) is still shutting down; try again in a minute`);
+  }
   ensureHome();
   const log = fs.openSync(paths.log, 'a');
   const child = spawn(process.execPath, [BIN, 'serve'], {
@@ -39,7 +79,7 @@ export async function ensureDaemon({ quiet = false } = {}) {
     env: process.env,
   });
   child.unref();
-  for (let i = 0; i < 50; i++) {
+  for (let i = 0; i < 150; i++) {
     await new Promise((r) => setTimeout(r, 100));
     if (await isRunning()) {
       if (!quiet) process.stderr.write(`agentmgr: started daemon at ${BASE} (log: ${paths.log})\n`);

package/src/manager.js

@@ -1991,18 +1991,19 @@ export class AgentManager extends EventEmitter {
     const id = this.mustGet(ref).id;
     const running = this.refreshing.get(id);
     if (running) {
-      // A pull request check asked for during a plain refresh runs right after it.
-      if (!withPrs || running.withPrs) return running.promise.then(() => this.store.get(id) && this.view(this.store.get(id)));
-      await running.promise.catch(() => {});
-      return this.refresh(id, { withPrs });
-    }
-    const promise = this.doRefresh(id, { withPrs });
-    this.refreshing.set(id, { promise, withPrs });
-    try {
-      return await promise;
-    } finally {
-      this.refreshing.delete(id);
-    }
+      if (!withPrs) return running.promise.then(() => this.store.get(id) && this.view(this.store.get(id)));
+      // A pull request check runs again after the one in progress, which may have read PRs from
+      // before this request; callers arriving meanwhile share that next run.
+      running.next ??= running.promise.catch(() => {}).then(() => this.refresh(id, { withPrs }));
+      return running.next;
+    }
+    // Cleared before anyone waiting on it continues, so the next run starts afresh.
+    const entry = { withPrs };
+    entry.promise = this.doRefresh(id, { withPrs }).finally(() => {
+      if (this.refreshing.get(id) === entry) this.refreshing.delete(id);
+    });
+    this.refreshing.set(id, entry);
+    return entry.promise;
   }
 
   async doRefresh(id, { withPrs }) {

package/src/server.js

@@ -193,7 +193,8 @@ export async function startServer({ port = PORT, host = HOST } = {}) {
   };
   const fail = (status, message) => Object.assign(new Error(message), { status });
 
-  api.get('/health', wrap(() => ({ ok: true, pid: process.pid, home: paths.home, claudeBin: config.claudeBin })));
+  // `closing` while shutting down: it still answers until every agent is closed, then exits.
+  api.get('/health', wrap(() => ({ ok: true, pid: process.pid, home: paths.home, claudeBin: config.claudeBin, closing })));
   api.get('/agents', wrap(() => manager.list()));
   api.get('/engines', wrap(() => listEngines(config)));
   api.post(