@proagentstore/cli 0.4.45 → 0.4.46

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

@@ -111,6 +111,47 @@ export function runCommand(target, command) {
     sendText(target, command);
     sendKey(target, "Enter");
 }
+/**
+ * Settle heuristic constants — mirror the Coder headless.ts values (1.5s quiet = idle;
+ * 8s absolute backstop for a slow-booting CLI). The short backstop covers send/run where
+ * the pane is already live; the long one is for new-session launches where the CLI may
+ * take several seconds to paint its first prompt.
+ */
+export const SETTLE_QUIET_MS = 750;
+export const SETTLE_POLL_MS = 120;
+export const SETTLE_TIMEOUT_MS = 8_000;
+/**
+ * Poll-capture a pane until its content is unchanged for `quietMs` ms, or until
+ * `timeoutMs` elapses (backstop so a continuously-animated pane can't hang the tool).
+ *
+ * Returns the final pane content. This is the write-side analogue of the read-side labels
+ * in `terminal-label.ts`: before returning "Sent", we verify the pane has reacted.
+ *
+ * Pure behaviour — no side effects beyond calling `capturePane`; tested in unit tests
+ * without a real tmux by passing a custom `captureFn`.
+ */
+export async function waitForPaneSettle(target, opts = {}) {
+    const quietMs = opts.quietMs ?? SETTLE_QUIET_MS;
+    const timeoutMs = opts.timeoutMs ?? SETTLE_TIMEOUT_MS;
+    const pollMs = opts.pollMs ?? SETTLE_POLL_MS;
+    const capture = opts.captureFn ?? ((t) => capturePane(t));
+    const deadline = Date.now() + timeoutMs;
+    let last = capture(target);
+    let lastChangedAt = Date.now();
+    while (true) {
+        await new Promise((r) => setTimeout(r, pollMs));
+        const now = Date.now();
+        const current = capture(target);
+        if (current !== last) {
+            last = current;
+            lastChangedAt = now;
+        }
+        const quietFor = now - lastChangedAt;
+        if (quietFor >= quietMs || now >= deadline) {
+            return last;
+        }
+    }
+}
 // biome-ignore lint/suspicious/noControlCharactersInRegex: matching ANSI escape codes from tmux output.
 const ANSI = /\x1B\[[0-?]*[ -/]*[@-~]/g;
 /** Strip ANSI escape codes. */

package/dist/browser-runner/server.js

@@ -305,24 +305,29 @@ async function route(runner, req, res) {
         return json(res, 200, { session, pane: capturePane(session, lines) });
     }
     if (req.method === "POST" && path === "/tmux/send") {
-        const { sendText, sendKey, capturePane, sessionExists } = await import("./coding/tmux.js");
+        const { sendText, sendKey, capturePane, sessionExists, waitForPaneSettle } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const session = String(b.session || "").trim();
         if (!session)
             return json(res, 400, { error: "A `session` name is required." });
         if (!sessionExists(session))
             return json(res, 404, { error: `No tmux session "${session}".` });
+        // Capture BEFORE the send so the caller can verify what changed (#481).
+        const paneBefore = capturePane(session, 200);
         if (b.text != null)
             sendText(session, String(b.text));
         for (const k of b.keys ?? [])
             sendKey(session, String(k));
+        // Wait for the pane to quiesce (750ms quiet / 3s backstop) instead of returning
+        // the pre-reaction snapshot. Mirrors the settle heuristic in headless.ts.
+        const pane = await waitForPaneSettle(session, { quietMs: 750, timeoutMs: 3_000 });
         // `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") });
+        return json(res, 200, { session, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(session, "tmux") });
     }
     if (req.method === "POST" && path === "/tmux/run") {
-        const { runCommand, capturePane, sessionExists } = await import("./coding/tmux.js");
+        const { runCommand, capturePane, sessionExists, waitForPaneSettle } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const session = String(b.session || "").trim();
         const command = String(b.command ?? "");
@@ -332,12 +337,14 @@ async function route(runner, req, res) {
             return json(res, 400, { error: "A `command` is required." });
         if (!sessionExists(session))
             return json(res, 404, { error: `No tmux session "${session}".` });
+        const paneBefore = capturePane(session, 200);
         runCommand(session, command);
+        const pane = await waitForPaneSettle(session, { quietMs: 750, timeoutMs: 3_000 });
         const { activeTerminalCommand } = await import("./coding/terminal.js");
-        return json(res, 200, { session, command, pane: capturePane(session, 200), activeCommand: activeTerminalCommand(session, "tmux") });
+        return json(res, 200, { session, command, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(session, "tmux") });
     }
     if (req.method === "POST" && path === "/tmux/session") {
-        const { createSession, killSession, sessionExists } = await import("./coding/tmux.js");
+        const { createSession, killSession, sessionExists, waitForPaneSettle } = await import("./coding/tmux.js");
         const { homedir } = await import("node:os");
         const b = await readJson(req);
         const session = String(b.session || "").trim();
@@ -352,6 +359,12 @@ async function route(runner, req, res) {
         const { resolve } = await import("node:path");
         const workDir = resolve(String(b.workDir || "~").replace(/^~(?=$|\/)/, homedir()));
         createSession(session, workDir, b.command ? String(b.command) : undefined);
+        // When the session starts a command (e.g. "claude"), wait until the pane quiesces
+        // (the CLI has painted its initial prompt) before returning "ready" (#481). Without a
+        // startup command the pane is already at a shell prompt — no settle needed.
+        if (b.command) {
+            await waitForPaneSettle(session, { quietMs: 750, timeoutMs: 8_000 });
+        }
         return json(res, 200, { session, created: true, workDir });
     }
     // ── generic terminal connector ──────────────────────────────────────────
@@ -373,7 +386,8 @@ 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, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { runTerminalCommand, captureTerminalTarget, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { waitForPaneSettle, SETTLE_QUIET_MS } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const target = String(b.target || "").trim();
         const command = String(b.command ?? "");
@@ -382,23 +396,48 @@ 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;
-        const pane = runTerminalCommand(target, command, backend);
+        // Capture BEFORE to detect whether the input landed (#481).
+        const paneBefore = captureTerminalTarget(target, { backend });
+        runTerminalCommand(target, command, backend);
+        // Settle: for tmux targets, use the tmux poll. For other backends, fall back to the
+        // just-run snapshot (they don't support a reliable settle poll).
+        let pane;
+        if (!backend && target.startsWith("tmux:") || backend === "tmux") {
+            const { splitTerminalTarget } = await import("./coding/terminal.js");
+            const t = splitTerminalTarget(target, backend);
+            pane = await waitForPaneSettle(t.id, { quietMs: SETTLE_QUIET_MS, timeoutMs: 3_000 });
+        }
+        else {
+            pane = captureTerminalTarget(target, { 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) });
+        return json(res, 200, { target, command, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(target, backend) });
     }
     if (req.method === "POST" && path === "/terminal/send") {
-        const { sendTerminalKeys, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { sendTerminalKeys, captureTerminalTarget, activeTerminalCommand } = await import("./coding/terminal.js");
+        const { waitForPaneSettle, SETTLE_QUIET_MS } = await import("./coding/tmux.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;
-        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) });
+        const paneBefore = captureTerminalTarget(target, { backend });
+        sendTerminalKeys(target, { backend, text: b.text == null ? undefined : String(b.text), keys: b.keys ?? [] });
+        let pane;
+        if (!backend && target.startsWith("tmux:") || backend === "tmux") {
+            const { splitTerminalTarget } = await import("./coding/terminal.js");
+            const t = splitTerminalTarget(target, backend);
+            pane = await waitForPaneSettle(t.id, { quietMs: SETTLE_QUIET_MS, timeoutMs: 3_000 });
+        }
+        else {
+            pane = captureTerminalTarget(target, { backend });
+        }
+        return json(res, 200, { target, pane, paneBefore, changed: pane !== paneBefore, activeCommand: activeTerminalCommand(target, backend) });
     }
     if (req.method === "POST" && path === "/terminal/session") {
         const { createTerminalTarget, killTerminalTarget } = await import("./coding/terminal.js");
+        const { waitForPaneSettle } = await import("./coding/tmux.js");
         const b = await readJson(req);
         const backend = b.backend === "tmux" || b.backend === "kitty" || b.backend === "iterm2" ? b.backend : undefined;
         if (b.action === "kill") {
@@ -410,6 +449,10 @@ async function route(runner, req, res) {
         if (!backend)
             return json(res, 400, { error: "`backend` must be tmux, kitty, or iterm2." });
         const target = createTerminalTarget({ backend, name: b.name, workDir: b.workDir, command: b.command });
+        // When the new target starts a command, wait until the pane quiesces (#481).
+        if (b.command && backend === "tmux" && !target.existed) {
+            await waitForPaneSettle(target.id, { quietMs: 750, timeoutMs: 8_000 });
+        }
         return json(res, 200, { target });
     }
     return json(res, 404, { error: "Not found" });

package/dist/index.js

@@ -549,6 +549,14 @@ function withClaimedNames(identity, claimed) {
     declined: (identity.declined ?? []).filter((n) => !add.includes(n))
   };
 }
+function withUnclaimedName(identity, name) {
+  const unclaim = name.trim();
+  if (!unclaim) return identity;
+  const names = identity.names.filter((n) => n !== unclaim);
+  const declined = [...identity.declined ?? []];
+  if (!declined.includes(unclaim)) declined.push(unclaim);
+  return { id: identity.id, names, declined: declined.slice(-MAX_DECLINED) };
+}
 function withDeclinedNames(identity, declined) {
   const out = [...identity.declined ?? []];
   for (const raw of declined) {
@@ -699,7 +707,7 @@ function renderCandidates(candidates, nowMs) {
   });
   lines.push("");
   lines.push("Selecting a name merges its agents, pins and sessions onto this machine.");
-  lines.push("Pick only names THIS machine has used \u2014 a claim cannot be undone from the CLI.");
+  lines.push("Pick only names THIS machine has used \u2014 use `pags machines unclaim <name>` to undo a wrong claim.");
   return lines;
 }
 async function fetchNodeSummaries(opts) {
@@ -777,6 +785,96 @@ async function defaultAsk(question) {
   }
 }
 
+// src/commands/runner/http.ts
+import { hostname as hostname2 } from "os";
+function clean(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function runnerBaseUrl(url) {
+  return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
+}
+function pagsApiBase(url) {
+  return (clean(url) || clean(process.env.PAGS_API_BASE) || "https://api.proagentstore.online").replace(/\/$/, "");
+}
+function pagsHeaders(token) {
+  const resolved = clean(token) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
+  return resolved ? { Authorization: `Bearer ${resolved}` } : {};
+}
+function runnerRequestHeaders(opts) {
+  const resolved = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN);
+  const headers = resolved ? { Authorization: `Bearer ${resolved}` } : {};
+  const instanceId = clean(opts.instanceId) || clean(process.env.PAGS_INSTANCE_ID);
+  if (instanceId) headers["X-PAGS-Instance-Id"] = instanceId;
+  return headers;
+}
+function apiPathSegment(value) {
+  return encodeURIComponent(value);
+}
+function buildRuntimeRegistrationBody(opts, capabilities = []) {
+  const node = hostname2();
+  const machine = loadMachineIdentity(node);
+  return {
+    endpointUrl: clean(opts.endpointUrl) || opts.endpointUrl,
+    token: clean(opts.runnerToken) || clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN),
+    placement: opts.placement === "managed" ? "managed" : "local",
+    capabilities,
+    runnerVersion: clean(opts.runnerVersion) || "",
+    runnerNode: node,
+    machineId: machine.id,
+    machineNames: machine.names
+  };
+}
+async function requestRunner(method, path, opts, body) {
+  const headers = {
+    ...runnerRequestHeaders(opts)
+  };
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const res = await fetch(`${runnerBaseUrl(opts.url)}${path}`, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const { text, data } = await readResponse(res);
+  if (!res.ok) {
+    const message = responseErrorMessage(data, text, res.statusText);
+    throw new Error(`${res.status} ${message}`);
+  }
+  return data;
+}
+async function requestPags(method, path, opts, body) {
+  const headers = {
+    ...pagsHeaders(opts.pagsToken)
+  };
+  if (!headers.Authorization) {
+    throw new Error("PAGS token required. Set PAGS_TOKEN or pass --pags-token.");
+  }
+  if (body !== void 0) headers["Content-Type"] = "application/json";
+  const res = await fetch(`${pagsApiBase(opts.apiBase)}${path}`, {
+    method,
+    headers,
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  });
+  const { text, data } = await readResponse(res);
+  if (!res.ok) {
+    const message = responseErrorMessage(data, text, res.statusText);
+    throw new Error(`${res.status} ${message}`);
+  }
+  return data;
+}
+async function readResponse(res) {
+  const text = await res.text();
+  if (!text) return { text, data: {} };
+  try {
+    return { text, data: JSON.parse(text) };
+  } catch {
+    return { text, data: {} };
+  }
+}
+function responseErrorMessage(data, text, statusText) {
+  return typeof data.error === "string" ? data.error : text || statusText;
+}
+
 // src/commands/machines.ts
 var API_BASE2 = "https://api.proagentstore.online";
 async function loadNodes(token) {
@@ -804,6 +902,7 @@ var listCommand = new Command4("list").description("List the machines ProAgentSt
   }
   writeLine("");
   writeLine("  Claim a name this machine has used before:  pags machines claim <name>");
+  writeLine("  Remove a wrong claim:                       pags machines unclaim <name>");
   writeLine("");
 });
 var claimCommand = new Command4("claim").description("Record that a machine name on this account is THIS machine").argument("<name...>", "Node name(s) to claim, as shown by `pags machines list`").action(async (names) => {
@@ -826,7 +925,51 @@ var claimCommand = new Command4("claim").description("Record that a machine name
   }
   writeLine(`  \u2713 Claimed ${claim.join(", ")}. Restart \`pags up\` to merge them onto this machine.`);
 });
-var machinesCommand = new Command4("machines").description("Show and claim the machine names ProAgentStore has for this account").addCommand(listCommand, { isDefault: true }).addCommand(claimCommand);
+var unclaimCommand = new Command4("unclaim").description("Remove a mistaken machine name claim from this machine (#467)").argument("<name...>", "Node name(s) to un-claim, as shown by `pags machines list`").action(async (names) => {
+  const session = requireSession();
+  const identity = loadMachineIdentity();
+  if (!identity.id) {
+    writeError("This machine has no id \u2014 `~/.config/proagentstore/` is not writable, so the claim record cannot be found.");
+    process.exit(1);
+  }
+  let anyFailed = false;
+  for (const raw of names) {
+    const name = raw.trim();
+    if (!name) continue;
+    if (name === identity.names[0]) {
+      writeError(`  \u2717 ${name}: this is the machine's CURRENT hostname. You cannot un-claim the name it is actively registering under \u2014 stop \`pags up\` and rename the machine first.`);
+      anyFailed = true;
+      continue;
+    }
+    if (!identity.names.includes(name)) {
+      writeError(`  \u2717 ${name}: this machine does not claim that name.`);
+      anyFailed = true;
+      continue;
+    }
+    try {
+      await requestPags(
+        "DELETE",
+        `/v1/terminals/nodes/${apiPathSegment(name)}/claim`,
+        { pagsToken: session.token, apiBase: pagsApiBase() },
+        { machineId: identity.id }
+      );
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      writeError(`  \u2717 ${name}: ${msg}`);
+      anyFailed = true;
+      continue;
+    }
+    const updated = withUnclaimedName(identity, name);
+    if (!saveMachineIdentity(updated)) {
+      writeError(`  \u2717 Server un-claimed ${name} but could not update ${machineFilePath()} \u2014 the next \`pags up\` may re-stamp it. Edit that file by hand and remove "${name}" from the names array.`);
+      anyFailed = true;
+      continue;
+    }
+    writeLine(`  \u2713 ${name} \u2014 un-claimed on server and removed from ${machineFilePath()}.`);
+  }
+  if (anyFailed) process.exit(1);
+});
+var machinesCommand = new Command4("machines").description("Show and claim the machine names ProAgentStore has for this account").addCommand(listCommand, { isDefault: true }).addCommand(claimCommand).addCommand(unclaimCommand);
 
 // src/commands/mcp.ts
 import { spawn } from "child_process";
@@ -951,96 +1094,6 @@ import { spawn as spawn3 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { Command as Command7 } from "commander";
 
-// src/commands/runner/http.ts
-import { hostname as hostname2 } from "os";
-function clean(value) {
-  const trimmed = value?.trim();
-  return trimmed || void 0;
-}
-function runnerBaseUrl(url) {
-  return (clean(url) || clean(process.env.PAGS_RUNNER_URL) || "http://127.0.0.1:49171").replace(/\/$/, "");
-}
-function pagsApiBase(url) {
-  return (clean(url) || clean(process.env.PAGS_API_BASE) || "https://api.proagentstore.online").replace(/\/$/, "");
-}
-function pagsHeaders(token) {
-  const resolved = clean(token) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
-  return resolved ? { Authorization: `Bearer ${resolved}` } : {};
-}
-function runnerRequestHeaders(opts) {
-  const resolved = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN);
-  const headers = resolved ? { Authorization: `Bearer ${resolved}` } : {};
-  const instanceId = clean(opts.instanceId) || clean(process.env.PAGS_INSTANCE_ID);
-  if (instanceId) headers["X-PAGS-Instance-Id"] = instanceId;
-  return headers;
-}
-function apiPathSegment(value) {
-  return encodeURIComponent(value);
-}
-function buildRuntimeRegistrationBody(opts, capabilities = []) {
-  const node = hostname2();
-  const machine = loadMachineIdentity(node);
-  return {
-    endpointUrl: clean(opts.endpointUrl) || opts.endpointUrl,
-    token: clean(opts.runnerToken) || clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN),
-    placement: opts.placement === "managed" ? "managed" : "local",
-    capabilities,
-    runnerVersion: clean(opts.runnerVersion) || "",
-    runnerNode: node,
-    machineId: machine.id,
-    machineNames: machine.names
-  };
-}
-async function requestRunner(method, path, opts, body) {
-  const headers = {
-    ...runnerRequestHeaders(opts)
-  };
-  if (body !== void 0) headers["Content-Type"] = "application/json";
-  const res = await fetch(`${runnerBaseUrl(opts.url)}${path}`, {
-    method,
-    headers,
-    body: body === void 0 ? void 0 : JSON.stringify(body)
-  });
-  const { text, data } = await readResponse(res);
-  if (!res.ok) {
-    const message = responseErrorMessage(data, text, res.statusText);
-    throw new Error(`${res.status} ${message}`);
-  }
-  return data;
-}
-async function requestPags(method, path, opts, body) {
-  const headers = {
-    ...pagsHeaders(opts.pagsToken)
-  };
-  if (!headers.Authorization) {
-    throw new Error("PAGS token required. Set PAGS_TOKEN or pass --pags-token.");
-  }
-  if (body !== void 0) headers["Content-Type"] = "application/json";
-  const res = await fetch(`${pagsApiBase(opts.apiBase)}${path}`, {
-    method,
-    headers,
-    body: body === void 0 ? void 0 : JSON.stringify(body)
-  });
-  const { text, data } = await readResponse(res);
-  if (!res.ok) {
-    const message = responseErrorMessage(data, text, res.statusText);
-    throw new Error(`${res.status} ${message}`);
-  }
-  return data;
-}
-async function readResponse(res) {
-  const text = await res.text();
-  if (!text) return { text, data: {} };
-  try {
-    return { text, data: JSON.parse(text) };
-  } catch {
-    return { text, data: {} };
-  }
-}
-function responseErrorMessage(data, text, statusText) {
-  return typeof data.error === "string" ? data.error : text || statusText;
-}
-
 // src/commands/runner/process.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync6 } from "fs";

package/package.json

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