@proagentstore/cli 0.4.36 → 0.4.38

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

@@ -225,12 +225,35 @@ export class CodingRuntime {
     isUnderTakeover(sessionId) {
         return this.takeovers.has(sessionId);
     }
-    /** Stop every session (runner shutdown). */
+    /**
+     * Stop every session (runner shutdown).
+     *
+     * Each `stop()` is isolated (#274 lineage). `stop()` kills a child process, and killing an
+     * already-dead or wedged one throws — so a single bad session used to abort the loop, leaving
+     * every LATER session's engine running and skipping `sessions.clear()` entirely. The caller
+     * (`LocalRunner.close`) wraps this in a `catch {}`, so that escape was silent: the runner
+     * reported a clean shutdown while orphaned CLI processes kept editing the user's repo with
+     * nothing left holding their ids. Same shape as the `browserContext.close()` leak — a throw
+     * on the teardown path is what MAKES the leak, so every session is stopped independently and
+     * the maps always clear.
+     */
     closeAll() {
-        for (const s of this.sessions.values())
-            s.stop();
+        const failures = [];
+        for (const s of this.sessions.values()) {
+            try {
+                s.stop();
+            }
+            catch (e) {
+                failures.push(e);
+            }
+        }
         this.sessions.clear();
         this.takeovers.clear();
+        if (failures.length) {
+            // Cleared the state, then report: teardown completed as far as it could, but the
+            // operator needs to know a child process may have survived it.
+            throw new AggregateError(failures, `${failures.length} coding session(s) failed to stop`);
+        }
     }
     /** True if any session this runtime owns still has a live agent process. */
     hasLiveSessions() {

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

@@ -1,7 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import { capturePane, createSession, killSession, listSessionsDetailed, runCommand as tmuxRunCommand, sendKey as tmuxSendKey, sendText as tmuxSendText, sessionExists } from "./tmux.js";
+import { capturePane, createSession, killSession, listSessionsDetailed, runCommand as tmuxRunCommand, sendKey as tmuxSendKey, sendText as tmuxSendText, sessionExists, tmuxExec } from "./tmux.js";
 function shellPath() {
     return process.env.SHELL || "/bin/zsh";
 }
@@ -51,6 +51,76 @@ export function captureTerminalTarget(target, opts = {}) {
             return itermSessionScript(t.id, "return contents of theSession");
     }
 }
+/**
+ * The foreground command running in a target right now — `claude`, `node`, `zsh`, … (#348).
+ *
+ * The platform cannot measure what an AI CLI inside a pane spends: a pane holds rendered text, not
+ * the stream-json `result` event `headless.ts` reads. So the cloud records the drive as UNMETERED
+ * instead, and this is the one fact that makes that record specific rather than generic. It is a
+ * name, never a number — no cost figure is ever parsed out of pane output, because a scraped
+ * dollar amount would be a guess dressed as a measurement.
+ *
+ * Returns `null` when it cannot be read (no such target, iTerm2, a backend that will not say).
+ * `null` means UNREADABLE and must not be flattened into "nothing was running" upstream: the
+ * distinction is the entire point of recording this at all.
+ */
+export function activeTerminalCommand(target, backend) {
+    let t;
+    try {
+        t = splitTerminalTarget(target, backend);
+    }
+    catch {
+        return null;
+    }
+    try {
+        switch (t.backend) {
+            case "tmux": {
+                const out = tmuxExec(["display-message", "-p", "-t", t.id, "#{pane_current_command}"]).trim();
+                return out || null;
+            }
+            case "kitty":
+                return kittyForegroundCommand(t.id);
+            // iTerm2 exposes no cheap, reliable foreground-process query. Saying so is the honest
+            // answer; guessing from the pane's last line would not be.
+            case "iterm2":
+                return null;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+/** The foreground process of a kitty window, from `kitty @ ls`. Null if it can't be determined. */
+function kittyForegroundCommand(id) {
+    try {
+        const parsed = JSON.parse(kittyExec(["@", "ls"], 5000));
+        if (!Array.isArray(parsed))
+            return null;
+        for (const osWindow of parsed) {
+            const tabs = Array.isArray(osWindow.tabs) ? osWindow.tabs : [];
+            for (const tab of tabs) {
+                const windows = Array.isArray(tab.windows) ? tab.windows : [];
+                for (const win of windows) {
+                    const row = win;
+                    if (String(row.id ?? "") !== id)
+                        continue;
+                    const procs = Array.isArray(row.foreground_processes) ? row.foreground_processes : [];
+                    for (const p of procs) {
+                        const cmdline = p.cmdline;
+                        const first = Array.isArray(cmdline) ? String(cmdline[0] ?? "").trim() : "";
+                        if (first)
+                            return first;
+                    }
+                    return null;
+                }
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 export function runTerminalCommand(target, command, backend) {
     const t = splitTerminalTarget(target, backend);
     if (!command.trim())

package/dist/browser-runner/mcp-runtime.js

@@ -136,13 +136,25 @@ export class McpRuntime {
         this.client = new Client({ name: "pags-runner", version: "1.0.0" });
         await this.client.connect(clientTransport);
     }
+    /**
+     * The connected client, or a diagnosis. `client` is unset before `start()` AND cleared by
+     * `stop()`, so both call sites below are reachable with it missing — a use-after-stop is the
+     * likely one, since `stop()` runs on teardown while a slow in-flight action is still landing.
+     * A bare `this.client!` turned that into "Cannot read properties of undefined (reading
+     * 'callTool')" at the relay boundary, which names neither the runtime nor the lifecycle.
+     */
+    connected() {
+        if (!this.client)
+            throw new Error("MCP runtime is not running — call start() first (or it was already stopped).");
+        return this.client;
+    }
     /** The standard Playwright MCP tool schemas — advertised to the cloud brain verbatim. */
     async listTools() {
-        const res = await this.client.listTools();
+        const res = await this.connected().listTools();
         return res.tools;
     }
     async callTool(name, args = {}) {
-        return (await this.client.callTool({ name, arguments: args }));
+        return (await this.connected().callTool({ name, arguments: args }));
     }
     /** Text of the last tool result (the standard tools return their output as text content). */
     textOf(res) {

package/dist/browser-runner/runner.js

@@ -193,8 +193,12 @@ export class LocalRunner {
         try {
             this.coding.closeAll();
         }
-        catch {
-            // a stuck coding session must not block the browser teardown below
+        catch (e) {
+            // A stuck coding session must not block the browser teardown below — but it must not
+            // vanish either. `closeAll` now stops every session independently and only throws to
+            // report which ones refused, so reaching here means a child process may have outlived
+            // the runner. Silence here is what let that read as a clean shutdown.
+            console.warn(`[runner] ${e instanceof Error ? e.message : String(e)} — a CLI process may still be running; check \`ps\` if a repo keeps changing`);
         }
         await this.mcp?.stop().catch(() => undefined);
         this.mcp = null;

package/dist/browser-runner/server.js

@@ -304,7 +304,10 @@ async function route(runner, req, res) {
             sendText(session, String(b.text));
         for (const k of b.keys ?? [])
             sendKey(session, String(k));
-        return json(res, 200, { session, pane: capturePane(session, 200) });
+        // `activeCommand` rides along on every WRITE so the cloud can record what it just drove
+        // (#348). It is a process name, never a cost — see activeTerminalCommand's comment.
+        const { activeTerminalCommand } = await import("./coding/terminal.js");
+        return json(res, 200, { session, pane: capturePane(session, 200), activeCommand: activeTerminalCommand(session, "tmux") });
     }
     if (req.method === "POST" && path === "/tmux/run") {
         const { runCommand, capturePane, sessionExists } = await import("./coding/tmux.js");
@@ -318,7 +321,8 @@ async function route(runner, req, res) {
         if (!sessionExists(session))
             return json(res, 404, { error: `No tmux session "${session}".` });
         runCommand(session, command);
-        return json(res, 200, { session, command, pane: capturePane(session, 200) });
+        const { activeTerminalCommand } = await import("./coding/terminal.js");
+        return json(res, 200, { session, command, pane: capturePane(session, 200), activeCommand: activeTerminalCommand(session, "tmux") });
     }
     if (req.method === "POST" && path === "/tmux/session") {
         const { createSession, killSession, sessionExists } = await import("./coding/tmux.js");
@@ -357,7 +361,7 @@ async function route(runner, req, res) {
         return json(res, 200, { target, pane: captureTerminalTarget(target, { backend, lines: b.lines }) });
     }
     if (req.method === "POST" && path === "/terminal/run") {
-        const { runTerminalCommand } = await import("./coding/terminal.js");
+        const { runTerminalCommand, activeTerminalCommand } = await import("./coding/terminal.js");
         const b = await readJson(req);
         const target = String(b.target || "").trim();
         const command = String(b.command ?? "");
@@ -366,16 +370,20 @@ async function route(runner, req, res) {
         if (!command.trim())
             return json(res, 400, { error: "A `command` is required." });
         const backend = b.backend === "tmux" || b.backend === "kitty" || b.backend === "iterm2" ? b.backend : undefined;
-        return json(res, 200, { target, command, pane: runTerminalCommand(target, command, backend) });
+        const pane = runTerminalCommand(target, command, backend);
+        // Read AFTER the command lands, so `claude "fix x"` reports `claude` rather than the shell
+        // that was sitting there a moment earlier (#348).
+        return json(res, 200, { target, command, pane, activeCommand: activeTerminalCommand(target, backend) });
     }
     if (req.method === "POST" && path === "/terminal/send") {
-        const { sendTerminalKeys } = await import("./coding/terminal.js");
+        const { sendTerminalKeys, activeTerminalCommand } = await import("./coding/terminal.js");
         const b = await readJson(req);
         const target = String(b.target || "").trim();
         if (!target)
             return json(res, 400, { error: "A `target` is required." });
         const backend = b.backend === "tmux" || b.backend === "kitty" || b.backend === "iterm2" ? b.backend : undefined;
-        return json(res, 200, { target, pane: sendTerminalKeys(target, { backend, text: b.text == null ? undefined : String(b.text), keys: b.keys ?? [] }) });
+        const pane = sendTerminalKeys(target, { backend, text: b.text == null ? undefined : String(b.text), keys: b.keys ?? [] });
+        return json(res, 200, { target, pane, activeCommand: activeTerminalCommand(target, backend) });
     }
     if (req.method === "POST" && path === "/terminal/session") {
         const { createTerminalTarget, killTerminalTarget } = await import("./coding/terminal.js");

package/dist/index.js

@@ -533,7 +533,14 @@ var publishCommand = new Command5("publish").description("Publish an agent to Pr
     writeError("No agent.json found. Run `pags init` first.");
     process.exit(1);
   }
-  const manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+  } catch (e) {
+    writeError(`agent.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(1);
+    return;
+  }
   const slug = manifest.id;
   if (!slug) {
     writeError("agent.json missing id");
@@ -592,8 +599,12 @@ var publishCommand = new Command5("publish").description("Publish an agent to Pr
         cwd: dir,
         stdio: "inherit"
       });
-    } catch {
-      writeLine("  Push skipped (up to date or no commits)");
+    } catch (e) {
+      writeError(`
+  Push failed: ${e instanceof Error ? e.message : String(e)}`);
+      writeError("  Nothing was published \u2014 fix the push (pull/rebase, or check your GitHub auth) and retry.\n");
+      process.exit(1);
+      return;
     }
   }
   writeLine("\n  Registering agent in store...");
@@ -874,10 +885,23 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   writeLine(`  Agents:   ${instanceIds.length} instance${instanceIds.length === 1 ? "" : "s"}`);
   writeLine("  No cloudflared needed. Ctrl+C to disconnect.");
   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");
+  let heartbeatFailing = false;
   const heartbeat = () => {
     const timer = setTimeout(async () => {
+      let failure = null;
       for (const id of [...attached.keys()]) {
-        await requestPags("POST", `/v1/instances/${apiPathSegment(id)}/runtime/heartbeat`, opts, { runnerNode }).catch(() => void 0);
+        try {
+          await requestPags("POST", `/v1/instances/${apiPathSegment(id)}/runtime/heartbeat`, opts, { runnerNode });
+        } catch (e) {
+          failure = e instanceof Error ? e.message : String(e);
+        }
+      }
+      if (failure && !heartbeatFailing) {
+        heartbeatFailing = true;
+        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("Heartbeat recovered \u2014 this machine reads as online again.");
       }
       heartbeat();
     }, 3e4);
@@ -1499,7 +1523,10 @@ var upCommand = new Command7("up").description("Start the browser runner for all
             stdio: "inherit",
             env: process.env
           });
-        } catch {
+        } catch (e) {
+          const status = e.status;
+          writeLine(`  Restart failed${typeof status === "number" ? ` (exit ${status})` : ""} \u2014 the runner is NOT running. Run 'pags up' again.`);
+          process.exit(typeof status === "number" && status !== 0 ? status : 1);
         }
         process.exit(0);
       }

package/package.json

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