@proagentstore/cli 0.4.46 → 0.4.47

package/dist/browser-runner/coding/terminal.js

@@ -76,7 +76,14 @@ export function activeTerminalCommand(target, backend) {
         switch (t.backend) {
             case "tmux": {
                 const out = tmuxExec(["display-message", "-p", "-t", t.id, "#{pane_current_command}"]).trim();
-                return out || null;
+                // `#{pane_current_command}` reads the pane process's argv, and Claude Code rewrites
+                // its own — measured on this platform's flagship case, tmux answered `2.1.226` (the
+                // version) for a pane whose process `comm` was `claude`. So `aiCliDrives` was 0 for a
+                // week of driving Claude Code through a tmux Operator. `comm` is the executable name
+                // and no title rewrite touches it, so ask the process tree when the argv is not a
+                // name (#498). Only then: a pane reporting `zsh` genuinely has nothing in the
+                // foreground, and promoting a background child would be an invention.
+                return resolvePaneCommand(out, () => paneDescendantComms(t.id));
             }
             case "kitty":
                 return kittyForegroundCommand(t.id);
@@ -90,6 +97,102 @@ export function activeTerminalCommand(target, backend) {
         return null;
     }
 }
+/** Shell names that mean "the pane is at a prompt", not "this program is running". */
+const SHELL_NAMES = new Set(["sh", "bash", "zsh", "fish", "dash", "ksh", "tcsh", "csh", "login", "screen", "tmux"]);
+/** A program name is a bare token. A version (`2.1.226`) and a sentence are both NOT one. */
+export function looksLikeCommandName(raw) {
+    const value = String(raw ?? "").trim();
+    if (!value || value.length > 60)
+        return false;
+    if (/^v?\d+(\.\d+)+$/.test(value))
+        return false; // a version string is not a program name
+    return /^[A-Za-z_][\w.@+-]*$/.test(value);
+}
+/**
+ * What the pane is running, given what tmux SAID and a way to ask the process tree (#498).
+ *
+ * Pure so the measured fixture — tmux says `2.1.226`, the pane's child `comm` is `claude` — is a
+ * unit test rather than a story. Keeps tmux's answer whenever it is a name: that is the fast path,
+ * it costs no extra exec, and the descendant walk can only ever be a second-best guess.
+ */
+export function resolvePaneCommand(reported, listDescendantComms) {
+    const value = String(reported ?? "").trim();
+    if (looksLikeCommandName(value))
+        return value;
+    // The probe is best-effort by construction: `pgrep`/`ps` availability differs by platform, and
+    // a missing one must degrade to what tmux said, not lose it.
+    let descendants = [];
+    try {
+        descendants = listDescendantComms();
+    }
+    catch {
+        descendants = [];
+    }
+    for (const raw of descendants) {
+        const name = (String(raw ?? "").trim().split("/").pop() ?? "").trim();
+        if (!looksLikeCommandName(name))
+            continue;
+        if (SHELL_NAMES.has(name.toLowerCase()))
+            continue;
+        return name;
+    }
+    // Nothing better found: hand back exactly what tmux said. The cloud decides what an
+    // unreadable value means; this module does not invent a name it did not read.
+    return value || null;
+}
+/** Bounded, so a probe on a path a Loop drives continuously can never become the slow part. */
+const PROBE_TIMEOUT_MS = 1_000;
+/** `comm` for the pane's descendant processes, nearest first. `[]` on any failure. */
+function paneDescendantComms(paneId) {
+    let pid = "";
+    try {
+        pid = tmuxExec(["display-message", "-p", "-t", paneId, "#{pane_pid}"], PROBE_TIMEOUT_MS).trim();
+    }
+    catch {
+        return [];
+    }
+    if (!/^\d+$/.test(pid))
+        return [];
+    const found = [];
+    let frontier = [pid];
+    // Two levels is enough for `zsh → claude` and for one wrapper in between, and it bounds the
+    // work: `pgrep`/`ps` availability differs by platform, so every step degrades to today's
+    // answer rather than throwing (the runner is macOS/Linux; kitty and iTerm2 are untouched).
+    for (let depth = 0; depth < 2 && frontier.length > 0; depth++) {
+        const children = childPids(frontier);
+        if (children.length === 0)
+            break;
+        found.push(...commsFor(children));
+        frontier = children;
+    }
+    return found;
+}
+function childPids(parents) {
+    try {
+        const out = execFileSync("pgrep", ["-P", parents.join(",")], {
+            encoding: "utf8",
+            timeout: PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.split("\n").map((s) => s.trim()).filter((s) => /^\d+$/.test(s)).slice(0, 16);
+    }
+    catch {
+        return []; // pgrep exits non-zero when nothing matches — that is an answer, not an error
+    }
+}
+function commsFor(pids) {
+    try {
+        const out = execFileSync("ps", ["-o", "comm=", "-p", pids.join(",")], {
+            encoding: "utf8",
+            timeout: PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.split("\n").map((s) => s.trim()).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 /** The foreground process of a kitty window, from `kitty @ ls`. Null if it can't be determined. */
 function kittyForegroundCommand(id) {
     try {

package/dist/index.js

@@ -1214,11 +1214,44 @@ function diffMembership(attached, eligible, thisNode, blocked = /* @__PURE__ */
     detach: [...have].filter((id) => !wantIds.has(id))
   };
 }
+function shouldRegisterOnOpen(reconnect, alreadyRegistered) {
+  return reconnect || !alreadyRegistered;
+}
 function instanceLabel(inst) {
   const short = `${inst.id.slice(0, 8)}\u2026`;
   return inst.name ? `${inst.name} (${short})` : short;
 }
 
+// src/commands/runner/status-line.ts
+var STATUS_PREFIX = "PAGS-STATUS";
+function formatStatusLine(status) {
+  const parts = [];
+  if (status.registration) parts.push(`registration=${status.registration}`);
+  if (status.heartbeat) parts.push(`heartbeat=${status.heartbeat}`);
+  if (status.agents) parts.push(`agents=${status.agents}`);
+  if (status.reason) parts.push(`reason=${status.reason.replace(/\s+/g, " ").trim().slice(0, 200)}`);
+  return `${STATUS_PREFIX} ${parts.join(" ")}`;
+}
+function parseStatusLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith(`${STATUS_PREFIX} `)) return null;
+  const body = trimmed.slice(STATUS_PREFIX.length + 1);
+  const status = {};
+  const reasonAt = body.indexOf("reason=");
+  const head = reasonAt >= 0 ? body.slice(0, reasonAt) : body;
+  if (reasonAt >= 0) {
+    const reason = body.slice(reasonAt + "reason=".length).trim();
+    if (reason) status.reason = reason;
+  }
+  for (const token of head.split(/\s+/).filter(Boolean)) {
+    const [key, value] = token.split("=", 2);
+    if (key === "registration" && (value === "ok" || value === "partial" || value === "fail")) status.registration = value;
+    else if (key === "heartbeat" && (value === "ok" || value === "fail")) status.heartbeat = value;
+    else if (key === "agents" && value) status.agents = value;
+  }
+  return status;
+}
+
 // src/commands/runner/relay.ts
 async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force = false, watchInstances = false) {
   const apiBase = pagsApiBase(opts.apiBase).replace(/^http/, "ws");
@@ -1228,7 +1261,9 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   const machine = loadMachineIdentity(runnerNode);
   const capabilities = await requestRunner("GET", "/capabilities", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] });
   const caps = Array.isArray(capabilities.capabilities) ? capabilities.capabilities.filter((item) => typeof item === "string") : [];
-  const registerRuntime = async (id) => {
+  const registered = /* @__PURE__ */ new Set();
+  let lastRegisterError = "";
+  const registerRuntime = async (id, forceClaim = force) => {
     try {
       await requestPags("POST", `/v1/instances/${apiPathSegment(id)}/runtime`, opts, {
         endpointUrl: localUrl,
@@ -1239,13 +1274,23 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         runnerNode,
         machineId: machine.id,
         machineNames: machine.names,
-        force
+        force: forceClaim
       });
+      registered.add(id);
+      return true;
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
+      registered.delete(id);
+      lastRegisterError = msg;
       writeError(`register ${id.slice(0, 8)}\u2026 failed: ${msg}`);
+      return false;
     }
   };
+  const reportRegistration = () => {
+    const agents = `${registered.size}/${instanceIds.length}`;
+    const state = registered.size === instanceIds.length ? "ok" : registered.size === 0 ? "fail" : "partial";
+    writeLine(formatStatusLine({ registration: state, agents, reason: state === "ok" ? void 0 : lastRegisterError }));
+  };
   for (const id of instanceIds) await registerRuntime(id);
   const attached = /* @__PURE__ */ new Map();
   const blocked = /* @__PURE__ */ new Set();
@@ -1254,10 +1299,31 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     const mintToken = () => requestPags("POST", `/v1/relay/${apiPathSegment(id)}/token`, { ...opts, pagsToken }, {}).then((r) => r.token);
     attached.set(
       id,
-      openRelaySocket(id, apiBase, mintToken, localUrl, runnerToken, force, (conflicted) => {
-        blocked.add(conflicted);
-        attached.delete(conflicted);
-      })
+      openRelaySocket(
+        id,
+        apiBase,
+        mintToken,
+        localUrl,
+        runnerToken,
+        force,
+        (conflicted) => {
+          blocked.add(conflicted);
+          attached.delete(conflicted);
+        },
+        // Registration rides the RECONNECT, which is the whole wake case (#497). The socket
+        // retries with backoff; `POST …/runtime` did not, so after a sleep the machine had a
+        // live relay and no runtime row — and `resumeSessionsForNode`, which lives inside that
+        // route, never ran either, so its own suspended coding sessions stayed suspended. The
+        // upsert is idempotent, so re-registering on every reconnect is safe. The first open
+        // is skipped when the register already succeeded above (or in the discovery pass),
+        // and taken when it did not — which is how a register lost to a boot-time
+        // `fetch failed` finally gets a second chance.
+        async (openedId, reconnect) => {
+          if (!shouldRegisterOnOpen(reconnect, registered.has(openedId))) return;
+          await registerRuntime(openedId, reconnect ? false : force);
+          reportRegistration();
+        }
+      )
     );
     if (label) writeLine(`Attached agent: ${label}`);
   };
@@ -1269,7 +1335,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     writeLine(`Detached agent: ${label}`);
   };
   for (const id of instanceIds) attach(id, "");
-  writeLine("Runtime registered with PAGS \u2713");
+  reportRegistration();
+  writeLine(registered.size === instanceIds.length ? `Runtime registered with PAGS \u2713 (${registered.size}/${instanceIds.length} agents)` : `Runtime registration incomplete: ${registered.size}/${instanceIds.length} agents \u2014 retried on each relay (re)connect.`);
   writeLine("");
   writeLine("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
   writeLine(`  \u2705 CONNECTED \u2014 WebSocket relay \xB7 ${hostname3()}`);
@@ -1289,9 +1356,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       }
       if (failure && !heartbeatFailing) {
         heartbeatFailing = true;
+        writeLine(formatStatusLine({ heartbeat: "fail", reason: failure }));
         writeError(`Heartbeat failed: ${failure} \u2014 the console will show this machine as OFFLINE until it recovers. The relay itself is still connected; don't run \`pags up --force\` elsewhere.`);
       } else if (!failure && heartbeatFailing) {
         heartbeatFailing = false;
+        writeLine(formatStatusLine({ heartbeat: "ok" }));
         writeLine("Heartbeat recovered \u2014 this machine reads as online again.");
       }
       heartbeat();
@@ -1300,10 +1369,23 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   };
   heartbeat();
   if (watchInstances) startDiscovery();
+  async function clearFinishedConflicts() {
+    for (const id of [...blocked]) {
+      const free = await requestPags(
+        "GET",
+        `/v1/relay/${apiPathSegment(id)}/status`,
+        { ...opts, pagsToken }
+      ).then((r) => r.connected === false).catch(() => false);
+      if (!free) continue;
+      blocked.delete(id);
+      writeLine(`Relay conflict cleared: ${id.slice(0, 8)}\u2026 \u2014 the other runner is gone; reattaching.`);
+    }
+  }
   function startDiscovery() {
     const tick = () => {
       const timer = setTimeout(async () => {
         try {
+          await clearFinishedConflicts();
           const res = await requestPags(
             "GET",
             "/v1/instances/my/instances",
@@ -1333,10 +1415,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     tick();
   }
 }
-function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict) {
+function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen) {
   let backoffMs = 1e3;
   let reconnecting = false;
   let closed = false;
+  let opened = false;
   let socket = null;
   let retryTimer = null;
   const connect = async () => {
@@ -1365,7 +1448,10 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
     socket = ws;
     ws.onopen = () => {
       backoffMs = 1e3;
+      const reconnect = opened;
+      opened = true;
       writeLine(`Relay connected: ${instanceId.slice(0, 8)}\u2026`);
+      void Promise.resolve(onOpen?.(instanceId, reconnect)).catch(() => void 0);
     };
     ws.onmessage = async (event) => {
       const text = typeof event.data === "string" ? event.data : String(event.data);
@@ -1652,31 +1738,42 @@ function printLogo(version2) {
   console.log(pad + d("  Browser runner") + (version2 ? d(`  \xB7  v${version2}`) : ""));
   console.log("");
 }
+var STATUS_ROWS = {
+  runner: { label: "Browser", ok: "running on your computer", busy: "starting up\u2026", bad: "stopped \u2014 press r to retry" },
+  tunnel: { label: "Secure link", ok: "connected to ProAgentStore", busy: "opening\u2026", bad: "offline" },
+  pags: { label: "ProAgentStore", ok: "connected \u2014 ready for jobs", busy: "registering\u2026", bad: "not registered (retries automatically)" }
+};
+var LABEL_WIDTH = Math.max(...Object.values(STATUS_ROWS).map((r) => r.label.length)) + 2;
 function describe(kind, s) {
   const ok = s === "online" || s === "registered";
   const busy = s === "starting" || s === "pending";
   const icon = ok ? chalk.green("\u2713") : busy ? chalk.yellow("\u2026") : chalk.red("\u2717");
-  const map = {
-    runner: { label: "Browser", ok: "running on your computer", busy: "starting up\u2026", bad: "stopped \u2014 press r to retry" },
-    tunnel: { label: "Secure link", ok: "connected to ProAgentStore", busy: "opening\u2026", bad: "offline" },
-    pags: { label: "ProAgentStore", ok: "connected \u2014 ready for jobs", busy: "registering\u2026", bad: "not registered (retries automatically)" }
-  };
-  const m = map[kind];
+  const m = STATUS_ROWS[kind];
   return { icon, label: m.label, note: ok ? m.ok : busy ? m.busy : m.bad };
 }
+function connectingNote(elapsedMs) {
+  if (elapsedMs < 3e4) return "Setting things up\u2026 this takes a few seconds. Keep this window open.";
+  const mins = Math.floor(elapsedMs / 6e4);
+  const elapsed = mins >= 1 ? `${mins}m` : `${Math.floor(elapsedMs / 1e3)}s`;
+  return `Still connecting \u2014 ${elapsed} elapsed. Press l for logs.`;
+}
+function pagsNote(registration, heartbeat) {
+  if (registration !== "registered" || heartbeat !== "failing") return void 0;
+  return "registered \u2014 but the heartbeat is failing, so the website reads this machine as offline";
+}
 function printStatus(state) {
   clearScreen();
   printLogo(state.version);
   const connected = state.runner === "online" && state.tunnel === "online" && state.registration === "registered";
   console.log(pad + d("Signed in as ") + w(state.user) + d("  \xB7  agent: ") + w(state.activeInstance) + d("  \xB7  node: ") + w(hostname4()));
   console.log("");
-  const row = (kind, s) => {
+  const row = (kind, s, override) => {
     const { icon, label, note } = describe(kind, s);
-    console.log(pad + icon + " " + w(label.padEnd(13)) + d(note));
+    console.log(pad + icon + " " + w(label.padEnd(LABEL_WIDTH)) + d(override ?? note));
   };
   row("runner", state.runner);
   row("tunnel", state.tunnel);
-  row("pags", state.registration);
+  row("pags", state.registration, pagsNote(state.registration, state.heartbeat));
   console.log("");
   if (connected) {
     console.log(pad + chalk.green("\u2713 You're all set!") + d(" Your agent can now act on the web."));
@@ -1688,7 +1785,7 @@ function printStatus(state) {
     console.log("");
     console.log(pad + d("The website can take a few seconds to show \u201Conline\u201D \u2014 that's normal."));
   } else {
-    console.log(pad + d("Setting things up\u2026 this takes a few seconds. Keep this window open."));
+    console.log(pad + d(connectingNote(state.startedAt ? Date.now() - state.startedAt : 0)));
     if (state.lastEvent) console.log(pad + d("Status: ") + d(state.lastEvent));
   }
   console.log("");
@@ -1761,9 +1858,13 @@ var upCommand = new Command8("up").description("Start the browser runner for all
     tunnel: "offline",
     tunnelUrl: "",
     registration: "pending",
+    heartbeat: "ok",
     lastEvent: "Fetching instances...",
     taskCount: 0,
-    version: CLI_VERSION2
+    version: CLI_VERSION2,
+    // What "a few seconds" is measured against: a state that never resolves was described
+    // as taking a few seconds, indefinitely, because nothing counted (#497).
+    startedAt: Date.now()
   };
   clearScreen();
   printLogo(CLI_VERSION2);
@@ -1826,6 +1927,19 @@ var upCommand = new Command8("up").description("Start the browser runner for all
       if (!trimmed) continue;
       logs.push(trimmed);
       if (logs.length > 200) logs.shift();
+      const status = parseStatusLine(trimmed);
+      if (status) {
+        if (status.registration) {
+          state.registration = status.registration === "ok" ? "registered" : "failed";
+          state.lastEvent = status.registration === "ok" ? `Registered with PAGS \u2014 ${status.agents ?? "all"} agents ready` : `PAGS registration ${status.registration}${status.agents ? ` (${status.agents} agents)` : ""}${status.reason ? `: ${status.reason}` : ""}`;
+        }
+        if (status.heartbeat) {
+          state.heartbeat = status.heartbeat === "ok" ? "ok" : "failing";
+          state.lastEvent = status.heartbeat === "ok" ? "Heartbeat recovered \u2014 this machine reads as online again" : `Heartbeat failing${status.reason ? `: ${status.reason}` : ""} \u2014 the console will show this machine offline`;
+        }
+        printStatus(state);
+        continue;
+      }
       if (trimmed.includes("Relay connected:")) {
         state.tunnel = "online";
         state.tunnelUrl = "WebSocket relay";
@@ -1836,7 +1950,6 @@ var upCommand = new Command8("up").description("Start the browser runner for all
       if (trimmed.includes("WebSocket relay")) {
         state.tunnel = "online";
         state.tunnelUrl = "WebSocket relay";
-        state.registration = "registered";
         state.lastEvent = "Connected via WebSocket relay";
         printStatus(state);
         continue;
@@ -1847,21 +1960,13 @@ var upCommand = new Command8("up").description("Start the browser runner for all
         printStatus(state);
         continue;
       }
-      if (trimmed.includes("Runtime registered") || trimmed.includes("CONNECTED")) {
-        state.registration = "registered";
-        state.lastEvent = "Registered with PAGS \u2014 ready for tasks";
-        printStatus(state);
-        continue;
-      }
-      if (trimmed.includes("Another machine")) {
-        state.registration = "failed";
-        state.lastEvent = trimmed.slice(0, 80);
+      if (trimmed.includes("Relay conflict:")) {
+        state.lastEvent = "Another runner holds this agent \u2014 run `pags up --force` here to take it over";
         printStatus(state);
         continue;
       }
-      if (trimmed.includes("fetch failed")) {
-        state.registration = "failed";
-        state.lastEvent = "PAGS registration failed";
+      if (trimmed.includes("Relay conflict cleared:")) {
+        state.lastEvent = "Relay conflict cleared \u2014 reattaching";
         printStatus(state);
         continue;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.46",
+  "version": "0.4.47",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",