@proagentstore/cli 0.4.44 → 0.4.46

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

@@ -470,16 +470,15 @@ export class HeadlessSession {
         });
     }
     /**
-     * No TTY in headless mode; control is via messages. Kept for interface parity — the human
-     * takeover path can still route a keypress here.
-     *
-     * RECORDED rather than silently dropped. As a pure no-op it was indistinguishable from
-     * success: `act` returned an ordinary snapshot with an unchanged pane, so the caller could not
-     * tell "sent, nothing happened" from "never sent". The transcript is what the brain and the
-     * console both read, so the truth belongs there.
+     * No TTY in headless mode; control is via messages. RECORDED **and** REPORTED: recording came
+     * first (#391) because a pure no-op read as success and the transcript is what the brain and
+     * the console see — but a line in the pane is no answer to the caller, `runtime.act` had
+     * nothing to raise, so the route answered 200 (#448). A real PTY backend flips `delivered`.
      */
     key(keys) {
-        this.push(`[ignored keypress ${keys.slice(0, 40)} — this session has no terminal attached]`);
+        const reason = "this session has no terminal attached";
+        this.push(`[ignored keypress ${keys.slice(0, 40)} — ${reason}]`);
+        return { delivered: false, reason };
     }
     /** Abort the current turn (SIGINT, like Ctrl-C). The process stays usable. */
     interrupt() {

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

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
+import { RunnerInputError } from "../errors.js";
 import { defaultStatePath, HeadlessSession } from "./headless.js";
 import { InspectError, readGitRemoteOrigin, readRepoFile, repoTree, runRepoGit } from "./inspect.js";
 import { checkWorkdir, ensureRepo, sanitizeSessionName } from "./repo.js";
@@ -135,9 +136,16 @@ export class CodingRuntime {
             case "message":
                 session.input(action.text);
                 break;
-            case "keys":
-                session.key(action.keys);
-                break;
+            case "keys": {
+                // A snapshot is no longer the whole answer (#448). `key()` records the attempt and
+                // reports that it was not delivered; answering 200 with a pane that simply did not
+                // change is the defect this replaces — a caller cannot tell it apart from success.
+                // `RunnerInputError` (400) is the honest class: with no PTY, asking this runner for
+                // a keystroke is a bad request, not a runner fault. The cloud refuses it a step
+                // earlier with a 409, so in practice this only catches a direct runner caller.
+                const { reason } = session.key(action.keys);
+                throw new RunnerInputError(`Keystrokes are not deliverable: ${reason} — send an instruction instead, or take the session over.`);
+            }
             case "interrupt":
                 session.interrupt();
                 break;

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/runner.js

@@ -590,7 +590,25 @@ export class LocalRunner {
             // --remote-debugging-port=0 → Chrome picks a free CDP port and writes it to
             // DevToolsActivePort in the profile dir; the standard @playwright/mcp server
             // attaches to that endpoint so it drives THIS same real-profile browser.
-            args: ["--disable-blink-features=AutomationControlled", "--start-maximized", "--window-size=1512,982", "--remote-debugging-port=0"],
+            // The media-permission pair is POLICY, not a workaround (#425). Nothing in this package
+            // uses audio — `grep -niE "microphone|grantPermissions" src` finds nothing — and the
+            // runner navigates only to job/ATS pages, so any mic prompt from here is a third-party
+            // site asking for something no part of this product needs. Both flags, and in this
+            // order of reasoning:
+            //   --use-fake-ui-for-media-stream   auto-answers the prompt, so the UI never appears…
+            //   --use-fake-device-for-media-stream  …and hands over a SYNTHETIC device, because the
+            //     first flag ALONE auto-GRANTS the real microphone to whatever page asked. That is
+            //     strictly worse than the prompt it removes, which is why it must never ship alone.
+            // The console, where voice actually runs, is a different browser and is untouched: a
+            // real mic grant stays the user's decision.
+            args: [
+                "--disable-blink-features=AutomationControlled",
+                "--start-maximized",
+                "--window-size=1512,982",
+                "--remote-debugging-port=0",
+                "--use-fake-ui-for-media-stream",
+                "--use-fake-device-for-media-stream",
+            ],
         };
         // Prefer the real Chrome build (better TLS/fingerprint → fewer CAPTCHAs);
         // fall back to bundled Chromium if Chrome isn't installed. Disable with

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

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { createRequire as createRequire3 } from "module";
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/commands/check.ts
 import { existsSync, readFileSync } from "fs";
@@ -497,140 +497,21 @@ async function findFreePort() {
   });
 }
 
-// src/commands/mcp.ts
-import { spawn } from "child_process";
+// src/commands/machines.ts
 import { Command as Command4 } from "commander";
-var DEFAULT_MCP_URL = "https://mcp.proagentstore.online/mcp";
-function buildMcpRemoteArgs(opts, extraArgs = []) {
-  return ["-y", "mcp-remote", opts.url || DEFAULT_MCP_URL, ...extraArgs];
-}
-async function runMcpProxy(opts, extraArgs = []) {
-  const child = spawn("npx", buildMcpRemoteArgs(opts, extraArgs), {
-    stdio: "inherit",
-    env: process.env
-  });
-  await new Promise((resolve5, reject) => {
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code && code !== 0) reject(new Error(`mcp proxy exited with code ${code}`));
-      else resolve5();
-    });
-  });
-}
-var mcpCommand = new Command4("mcp").description("Run a local stdio proxy for the official ProAgentStore MCP server").option("--url <url>", "Remote MCP endpoint", DEFAULT_MCP_URL).argument("[args...]", "Extra arguments passed to mcp-remote").action(async (args, opts) => {
-  await runMcpProxy(opts, args);
-});
-
-// src/commands/publish.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { join as join4, resolve as resolve3 } from "path";
-import { Command as Command5 } from "commander";
-var publishCommand = new Command5("publish").description("Publish an agent to ProAgentStore").option("-d, --dir <path>", "Agent directory", ".").action(async (opts) => {
-  const dir = resolve3(opts.dir);
-  const manifestPath = join4(dir, "agent.json");
-  if (!existsSync4(manifestPath)) {
-    writeError("No agent.json found. Run `pags init` first.");
-    process.exit(1);
-  }
-  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");
-    process.exit(1);
-  }
-  writeLine(`
-  Publishing ${manifest.name} (${slug})...
-`);
-  writeLine("  Running compliance checks...");
-  try {
-    execFileSync("pags", ["check"], { cwd: dir, stdio: "inherit" });
-  } catch {
-    writeError("\n  Compliance checks failed. Fix issues and retry.\n");
-    process.exit(1);
-  }
-  const org = "ProAgentStore";
-  const repoName = slug;
-  writeLine(`
-  Checking GitHub repo: ${org}/${repoName}`);
-  let repoExists = false;
-  try {
-    execFileSync("gh", ["api", `repos/${org}/${repoName}`, "--jq", ".name"], {
-      stdio: "pipe"
-    });
-    repoExists = true;
-    writeLine("  Repo exists, pushing...");
-  } catch {
-    writeLine("  Creating repo...");
-    try {
-      execFileSync(
-        "gh",
-        ["repo", "create", `${org}/${repoName}`, "--public", `--source=${dir}`, "--push"],
-        { stdio: "inherit" }
-      );
-      repoExists = true;
-    } catch (e) {
-      writeError(`  Failed to create repo: ${e}`);
-      process.exit(1);
-    }
-  }
-  if (repoExists) {
-    try {
-      execFileSync("git", ["remote", "get-url", "origin"], {
-        cwd: dir,
-        stdio: "pipe"
-      });
-    } catch {
-      execFileSync(
-        "git",
-        ["remote", "add", "origin", `https://github.com/${org}/${repoName}.git`],
-        { cwd: dir }
-      );
-    }
-    try {
-      execFileSync("git", ["push", "-u", "origin", "main"], {
-        cwd: dir,
-        stdio: "inherit"
-      });
-    } 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...");
-  writeLine(`
-  Published! ${slug}.proagentstore.online`);
-  writeLine(`  Store: https://proagentstore.online/agents/${slug}/`);
-  writeLine(`  Repo:  https://github.com/${org}/${repoName}`);
-  writeLine();
-});
-
-// src/commands/runner/command.ts
-import { spawn as spawn3 } from "child_process";
-import { randomUUID as randomUUID2 } from "crypto";
-import { Command as Command6 } from "commander";
-
-// src/commands/runner/http.ts
-import { hostname as hostname2 } from "os";
 
 // src/machine.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2, hostname } from "os";
-import { join as join5 } from "path";
-var CONFIG_DIR2 = join5(homedir2(), ".config", "proagentstore");
-var MACHINE_FILE = join5(CONFIG_DIR2, "machine.json");
+import { join as join4 } from "path";
+var CONFIG_DIR2 = join4(homedir2(), ".config", "proagentstore");
+var MACHINE_FILE = join4(CONFIG_DIR2, "machine.json");
 var MAX_NAMES = 10;
+var MAX_DECLINED = 40;
+function machineFilePath() {
+  return MACHINE_FILE;
+}
 function isValidMachineId(value) {
   return typeof value === "string" && /^[A-Za-z0-9_-]{8,64}$/.test(value);
 }
@@ -638,36 +519,274 @@ function parseMachineFile(text) {
   try {
     const data = JSON.parse(text);
     if (!isValidMachineId(data.id)) return null;
-    const names = Array.isArray(data.names) ? data.names.filter((n) => typeof n === "string" && n.trim().length > 0).map((n) => n.trim()) : [];
-    return { id: data.id, names: names.slice(0, MAX_NAMES) };
+    return {
+      id: data.id,
+      names: stringList(data.names).slice(0, MAX_NAMES),
+      declined: stringList(data.declined).slice(0, MAX_DECLINED)
+    };
   } catch {
     return null;
   }
 }
+function stringList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((n) => typeof n === "string" && n.trim().length > 0).map((n) => n.trim());
+}
 function withName(identity, name) {
   const current = name.trim();
   const prev = identity?.names ?? [];
   const names = current ? [current, ...prev.filter((n) => n !== current)] : [...prev];
-  return { id: identity?.id ?? "", names: names.slice(0, MAX_NAMES) };
+  return { id: identity?.id ?? "", names: names.slice(0, MAX_NAMES), declined: identity?.declined ?? [] };
+}
+function withClaimedNames(identity, claimed) {
+  const add = claimed.map((n) => n.trim()).filter(Boolean);
+  const ordered = [identity.names[0], ...add, ...identity.names.slice(1)].filter((n) => !!n);
+  const names = [];
+  for (const n of ordered) if (!names.includes(n)) names.push(n);
+  return {
+    id: identity.id,
+    names: names.slice(0, MAX_NAMES),
+    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) {
+    const name = raw.trim();
+    if (!name || out.includes(name) || identity.names.includes(name)) continue;
+    out.push(name);
+  }
+  return { id: identity.id, names: identity.names, declined: out.slice(-MAX_DECLINED) };
+}
+function saveMachineIdentity(identity) {
+  try {
+    mkdirSync3(CONFIG_DIR2, { recursive: true });
+    writeFileSync3(MACHINE_FILE, JSON.stringify(identity, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function sameIdentity(a, b) {
+  return a.id === b.id && a.names.join("\0") === b.names.join("\0") && (a.declined ?? []).join("\0") === (b.declined ?? []).join("\0");
 }
 function loadMachineIdentity(now = hostname()) {
   let stored = null;
   try {
-    if (existsSync5(MACHINE_FILE)) stored = parseMachineFile(readFileSync4(MACHINE_FILE, "utf-8"));
+    if (existsSync4(MACHINE_FILE)) stored = parseMachineFile(readFileSync3(MACHINE_FILE, "utf-8"));
   } catch {
   }
   const next = withName(stored ?? { id: randomUUID(), names: [] }, now);
-  if (stored && stored.id === next.id && stored.names.join("\0") === next.names.join("\0")) return next;
+  if (stored && sameIdentity(stored, next)) return next;
+  if (saveMachineIdentity(next)) return next;
+  return stored ?? { id: "", names: [] };
+}
+
+// src/machine-claim.ts
+function claimPromptSkipReason(gate) {
+  if (gate.headless) return "headless";
+  if (gate.suppressed) return "suppressed";
+  if (gate.ci) return "ci";
+  if (!gate.isTTY) return "no-tty";
+  return null;
+}
+function stampMs(value) {
+  if (!value) return 0;
+  const t = Date.parse(value.includes("T") ? value : `${value.replace(" ", "T")}Z`);
+  return Number.isFinite(t) ? t : 0;
+}
+function parseNodesResponse(data) {
+  const nodes = data?.nodes;
+  if (!Array.isArray(nodes)) return [];
+  const out = [];
+  for (const raw of nodes) {
+    const n = raw;
+    const node = typeof n?.node === "string" ? n.node.trim() : "";
+    if (!node) continue;
+    out.push({
+      node,
+      machineId: typeof n.machineId === "string" && n.machineId.trim() ? n.machineId.trim() : null,
+      lastSeenAt: typeof n.lastSeenAt === "string" ? n.lastSeenAt : null,
+      connected: n.connected === true,
+      agentCount: Array.isArray(n.instances) ? n.instances.length : 0
+    });
+  }
+  return out;
+}
+function claimCandidates(nodes, identity) {
+  const mine = new Set(identity.names);
+  const declined = new Set(identity.declined ?? []);
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const n of nodes) {
+    const name = n.node.trim();
+    if (!name || seen.has(name)) continue;
+    if (n.machineId) continue;
+    if (mine.has(name)) continue;
+    if (declined.has(name)) continue;
+    if (n.connected) continue;
+    seen.add(name);
+    out.push(n);
+  }
+  return out.sort((a, b) => stampMs(b.lastSeenAt) - stampMs(a.lastSeenAt));
+}
+function resolveClaimByName(requested, nodes, identity) {
+  const byName = new Map(nodes.map((n) => [n.node, n]));
+  const claim = [];
+  const problems = [];
+  for (const raw of requested) {
+    const name = raw.trim();
+    if (!name || claim.includes(name)) continue;
+    if (identity.names.includes(name)) {
+      problems.push(`${name}: this machine already claims that name.`);
+      continue;
+    }
+    const node = byName.get(name);
+    if (!node) {
+      problems.push(`${name}: no machine on this account is registered under that name.`);
+      continue;
+    }
+    if (node.machineId) {
+      problems.push(`${name}: already claimed by another machine (${node.machineId}).`);
+      continue;
+    }
+    if (node.connected) {
+      problems.push(`${name}: a runner is connected there right now, so it is a different machine. Stop it first if it is not.`);
+      continue;
+    }
+    claim.push(name);
+  }
+  return { claim, problems };
+}
+function relativeAge(lastSeenAt, nowMs) {
+  const at = stampMs(lastSeenAt);
+  if (!at) return "last seen unknown";
+  const mins = Math.max(0, Math.round((nowMs - at) / 6e4));
+  if (mins < 60) return `last seen ${mins} min ago`;
+  const hours = Math.round(mins / 60);
+  if (hours < 48) return `last seen ${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.round(hours / 24);
+  if (days < 45) return `last seen ${days} days ago`;
+  return `last seen ${Math.round(days / 30)} months ago`;
+}
+function describeCandidate(candidate, nowMs) {
+  const agents = `${candidate.agentCount} agent${candidate.agentCount === 1 ? "" : "s"}`;
+  return `${relativeAge(candidate.lastSeenAt, nowMs)} \xB7 ${agents}`;
+}
+function parseSelection(input, count) {
+  const raw = input.trim().toLowerCase();
+  if (!raw || raw === "n" || raw === "no" || raw === "s" || raw === "skip" || raw === "none") return { kind: "skip" };
+  if (raw === "a" || raw === "all") return { kind: "pick", indices: Array.from({ length: count }, (_, i) => i) };
+  const parts = raw.split(/[\s,]+/).filter(Boolean);
+  const indices = [];
+  for (const part of parts) {
+    if (!/^\d+$/.test(part)) return { kind: "invalid", message: `"${part}" is not a number.` };
+    const n = Number.parseInt(part, 10);
+    if (n < 1 || n > count) return { kind: "invalid", message: `${n} is not on the list (1\u2013${count}).` };
+    if (!indices.includes(n - 1)) indices.push(n - 1);
+  }
+  return indices.length ? { kind: "pick", indices } : { kind: "skip" };
+}
+function renderCandidates(candidates, nowMs) {
+  const width = candidates.reduce((w2, c2) => Math.max(w2, c2.node.length), 0);
+  const lines = [
+    `PAGS knows ${candidates.length} machine name${candidates.length === 1 ? "" : "s"} on this account that no machine has claimed.`,
+    "Is this machine also known as:",
+    ""
+  ];
+  candidates.forEach((c2, i) => {
+    lines.push(`  ${i + 1}) ${c2.node.padEnd(width)}   ${describeCandidate(c2, 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 use `pags machines unclaim <name>` to undo a wrong claim.");
+  return lines;
+}
+async function fetchNodeSummaries(opts) {
+  const doFetch = opts.fetchImpl ?? fetch;
   try {
-    mkdirSync3(CONFIG_DIR2, { recursive: true });
-    writeFileSync3(MACHINE_FILE, JSON.stringify(next, null, 2));
-    return next;
+    const res = await doFetch(`${opts.apiBase.replace(/\/$/, "")}/v1/terminals/nodes`, {
+      headers: { Authorization: `Bearer ${opts.token}` },
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 5e3)
+    });
+    if (!res.ok) return null;
+    return parseNodesResponse(await res.json());
   } catch {
-    return stored ?? { id: "", names: [] };
+    return null;
+  }
+}
+async function maybeClaimMachineNames(opts) {
+  const env = opts.env ?? process.env;
+  const skip = claimPromptSkipReason({
+    headless: opts.headless,
+    isTTY: opts.isTTY ?? process.stdin.isTTY,
+    ci: !!env.CI,
+    suppressed: !!env.PAGS_NO_PROMPT
+  });
+  if (skip) return { prompted: false, reason: skip };
+  const identity = loadMachineIdentity();
+  if (!identity.id) return { prompted: false, reason: "no-identity" };
+  const nodes = await fetchNodeSummaries(opts);
+  if (!nodes) return { prompted: false, reason: "unavailable" };
+  const candidates = claimCandidates(nodes, identity);
+  if (!candidates.length) return { prompted: false, reason: "nothing-unclaimed" };
+  const nowMs = opts.now ?? Date.now();
+  writeLine("");
+  for (const line of renderCandidates(candidates, nowMs)) writeLine(`  ${line}`);
+  writeLine("");
+  const ask = opts.ask ?? defaultAsk;
+  let selection = { kind: "skip" };
+  for (let attempt = 0; attempt < 2; attempt++) {
+    let answer = "";
+    try {
+      answer = await ask("  Numbers to claim (e.g. 1,2 or all), or Enter to skip: ");
+    } catch {
+      return { prompted: false, reason: "no-tty" };
+    }
+    selection = parseSelection(answer, candidates.length);
+    if (selection.kind !== "invalid") break;
+    writeLine(`  ${selection.message} Enter to skip.`);
+  }
+  if (selection.kind === "invalid") {
+    writeLine("  Nothing claimed \u2014 run `pags machines claim <name>` when you know which.");
+    writeLine("");
+    return { prompted: false, reason: "unanswered" };
+  }
+  const names = candidates.map((c2) => c2.node);
+  if (selection.kind !== "pick") {
+    saveMachineIdentity(withDeclinedNames(identity, names));
+    writeLine(`  Skipped \u2014 these names will not be offered again (${machineFilePath()}).`);
+    writeLine("");
+    return { prompted: true, reason: "declined", claimed: [], declined: names };
+  }
+  const claimed = selection.indices.map((i) => names[i]);
+  const rest = names.filter((n) => !claimed.includes(n));
+  saveMachineIdentity(withDeclinedNames(withClaimedNames(identity, claimed), rest));
+  writeLine(`  Claiming ${claimed.join(", ")} \u2014 merged on the next register.`);
+  writeLine("");
+  return { prompted: true, reason: "claimed", claimed, declined: rest };
+}
+async function defaultAsk(question) {
+  const { createInterface } = await import("readline/promises");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const closed = new Promise((resolve5) => rl.once("close", () => resolve5("")));
+    return await Promise.race([rl.question(question), closed]);
+  } finally {
+    rl.close();
   }
 }
 
 // src/commands/runner/http.ts
+import { hostname as hostname2 } from "os";
 function clean(value) {
   const trimmed = value?.trim();
   return trimmed || void 0;
@@ -756,6 +875,225 @@ 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) {
+  const nodes = await fetchNodeSummaries({ token, apiBase: API_BASE2 });
+  if (!nodes) {
+    writeError("Could not reach ProAgentStore to list your machines.");
+    process.exit(1);
+  }
+  return nodes;
+}
+var listCommand = new Command4("list").description("List the machines ProAgentStore has seen on this account").action(async () => {
+  const session = requireSession();
+  const nodes = await loadNodes(session.token);
+  const identity = loadMachineIdentity();
+  writeLine("");
+  writeLine(`  This machine: ${identity.names[0] ?? "unknown"}  ${identity.id ? `(id ${identity.id})` : "(no id \u2014 check that ~/.config/proagentstore/ is writable)"}`);
+  if (identity.names.length > 1) writeLine(`  Also claims: ${identity.names.slice(1).join(", ")}`);
+  writeLine("");
+  if (!nodes.length) writeLine("  No machines registered yet \u2014 run `pags up`.");
+  const now = Date.now();
+  for (const n of nodes) {
+    const owner = n.machineId ? n.machineId === identity.id ? "this machine" : "claimed" : "unclaimed";
+    writeLine(`  ${n.node}`);
+    writeLine(`      ${describeCandidate(n, now)} \xB7 ${n.connected ? "connected" : "offline"} \xB7 ${owner}`);
+  }
+  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) => {
+  const session = requireSession();
+  const identity = loadMachineIdentity();
+  if (!identity.id) {
+    writeError("This machine has no id \u2014 `~/.config/proagentstore/` is not writable, so a claim could not be sent.");
+    process.exit(1);
+  }
+  const nodes = await loadNodes(session.token);
+  const { claim, problems } = resolveClaimByName(names, nodes, identity);
+  for (const p of problems) writeError(`  \u2717 ${p}`);
+  if (!claim.length) {
+    writeError("  Nothing claimed.");
+    process.exit(problems.length ? 1 : 0);
+  }
+  if (!saveMachineIdentity(withClaimedNames(identity, claim))) {
+    writeError(`  \u2717 Could not write ${machineFilePath()} \u2014 nothing claimed.`);
+    process.exit(1);
+  }
+  writeLine(`  \u2713 Claimed ${claim.join(", ")}. Restart \`pags up\` to merge them onto this machine.`);
+});
+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";
+import { Command as Command5 } from "commander";
+var DEFAULT_MCP_URL = "https://mcp.proagentstore.online/mcp";
+function buildMcpRemoteArgs(opts, extraArgs = []) {
+  return ["-y", "mcp-remote", opts.url || DEFAULT_MCP_URL, ...extraArgs];
+}
+async function runMcpProxy(opts, extraArgs = []) {
+  const child = spawn("npx", buildMcpRemoteArgs(opts, extraArgs), {
+    stdio: "inherit",
+    env: process.env
+  });
+  await new Promise((resolve5, reject) => {
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code && code !== 0) reject(new Error(`mcp proxy exited with code ${code}`));
+      else resolve5();
+    });
+  });
+}
+var mcpCommand = new Command5("mcp").description("Run a local stdio proxy for the official ProAgentStore MCP server").option("--url <url>", "Remote MCP endpoint", DEFAULT_MCP_URL).argument("[args...]", "Extra arguments passed to mcp-remote").action(async (args, opts) => {
+  await runMcpProxy(opts, args);
+});
+
+// src/commands/publish.ts
+import { execFileSync } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { join as join5, resolve as resolve3 } from "path";
+import { Command as Command6 } from "commander";
+var publishCommand = new Command6("publish").description("Publish an agent to ProAgentStore").option("-d, --dir <path>", "Agent directory", ".").action(async (opts) => {
+  const dir = resolve3(opts.dir);
+  const manifestPath = join5(dir, "agent.json");
+  if (!existsSync5(manifestPath)) {
+    writeError("No agent.json found. Run `pags init` first.");
+    process.exit(1);
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync4(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");
+    process.exit(1);
+  }
+  writeLine(`
+  Publishing ${manifest.name} (${slug})...
+`);
+  writeLine("  Running compliance checks...");
+  try {
+    execFileSync("pags", ["check"], { cwd: dir, stdio: "inherit" });
+  } catch {
+    writeError("\n  Compliance checks failed. Fix issues and retry.\n");
+    process.exit(1);
+  }
+  const org = "ProAgentStore";
+  const repoName = slug;
+  writeLine(`
+  Checking GitHub repo: ${org}/${repoName}`);
+  let repoExists = false;
+  try {
+    execFileSync("gh", ["api", `repos/${org}/${repoName}`, "--jq", ".name"], {
+      stdio: "pipe"
+    });
+    repoExists = true;
+    writeLine("  Repo exists, pushing...");
+  } catch {
+    writeLine("  Creating repo...");
+    try {
+      execFileSync(
+        "gh",
+        ["repo", "create", `${org}/${repoName}`, "--public", `--source=${dir}`, "--push"],
+        { stdio: "inherit" }
+      );
+      repoExists = true;
+    } catch (e) {
+      writeError(`  Failed to create repo: ${e}`);
+      process.exit(1);
+    }
+  }
+  if (repoExists) {
+    try {
+      execFileSync("git", ["remote", "get-url", "origin"], {
+        cwd: dir,
+        stdio: "pipe"
+      });
+    } catch {
+      execFileSync(
+        "git",
+        ["remote", "add", "origin", `https://github.com/${org}/${repoName}.git`],
+        { cwd: dir }
+      );
+    }
+    try {
+      execFileSync("git", ["push", "-u", "origin", "main"], {
+        cwd: dir,
+        stdio: "inherit"
+      });
+    } 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...");
+  writeLine(`
+  Published! ${slug}.proagentstore.online`);
+  writeLine(`  Store: https://proagentstore.online/agents/${slug}/`);
+  writeLine(`  Repo:  https://github.com/${org}/${repoName}`);
+  writeLine();
+});
+
+// src/commands/runner/command.ts
+import { spawn as spawn3 } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { Command as Command7 } from "commander";
+
 // src/commands/runner/process.ts
 import { spawn as spawn2 } from "child_process";
 import { existsSync as existsSync6 } from "fs";
@@ -1119,7 +1457,7 @@ function collectCapability(value, previous = []) {
   return [...previous, value];
 }
 function createRunnerCommand() {
-  const command = new Command6("runner").description(
+  const command = new Command7("runner").description(
     "Manage the local ProAgentStore browser runtime for ProAgentStore agents"
   );
   command.command("start").description("Start the local ProAgentStore browser runtime in the foreground").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind (default: first free port from 49171)").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Require this bearer token").option("--instance-id <id>", "Bind runner requests to a PAGS instance id").option("--headless", "Run Playwright headless").action(async (opts) => {
@@ -1284,7 +1622,7 @@ var runnerCommand = createRunnerCommand();
 
 // src/commands/up.ts
 import { createRequire as createRequire2 } from "module";
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 
 // src/tui.ts
 import chalk from "chalk";
@@ -1393,7 +1731,7 @@ async function waitForKey(keys, onInterrupt) {
 }
 
 // src/commands/up.ts
-var API_BASE2 = "https://api.proagentstore.online";
+var API_BASE3 = "https://api.proagentstore.online";
 var CLI_VERSION2 = createRequire2(import.meta.url)("../package.json").version;
 async function stopRunnerProcesses() {
   if (process.platform === "win32") return false;
@@ -1413,7 +1751,7 @@ async function stopRunnerProcesses() {
   }
   return stopped;
 }
-var upCommand = new Command7("up").description("Start the browser runner for all your agent instances").option("--headless", "Run browser in headless mode").option("--instance <id>", "Connect to a specific instance only").option("--force", "Take over from another connected machine").action(async (opts) => {
+var upCommand = new Command8("up").description("Start the browser runner for all your agent instances").option("--headless", "Run browser in headless mode").option("--instance <id>", "Connect to a specific instance only").option("--force", "Take over from another connected machine").action(async (opts) => {
   const session = requireSession();
   const state = {
     user: session.user.login,
@@ -1431,7 +1769,7 @@ var upCommand = new Command7("up").description("Start the browser runner for all
   printLogo(CLI_VERSION2);
   printStep("Signed in as " + session.user.login, "ok");
   printStep("Fetching instances...", "wait");
-  const res = await fetch(`${API_BASE2}/v1/instances/my/instances`, {
+  const res = await fetch(`${API_BASE3}/v1/instances/my/instances`, {
     headers: { Authorization: `Bearer ${session.token}` }
   });
   if (!res.ok) {
@@ -1462,6 +1800,11 @@ var upCommand = new Command7("up").description("Start the browser runner for all
   for (const inst of state.instances) {
     writeLine(`    ${inst.name} (${inst.id.slice(0, 8)}...)`);
   }
+  await maybeClaimMachineNames({
+    token: session.token,
+    apiBase: API_BASE3,
+    headless: opts.headless
+  }).catch(() => void 0);
   state.activeInstance = instances.length === 1 ? instances[0].name || instances[0].slug || instances[0].id.slice(0, 8) : `${instances.length} agents`;
   printStep(`Connecting ${state.activeInstance}\u2026`, "wait");
   await stopRunnerProcesses();
@@ -1591,7 +1934,7 @@ var upCommand = new Command7("up").description("Start the browser runner for all
     }
   }
 });
-var downCommand = new Command7("down").description("Stop the browser runner and disconnect").action(async () => {
+var downCommand = new Command8("down").description("Stop the browser runner and disconnect").action(async () => {
   clearScreen();
   printLogo(CLI_VERSION2);
   if (process.platform === "win32") {
@@ -1613,7 +1956,7 @@ var downCommand = new Command7("down").description("Stop the browser runner and
 // src/index.ts
 var require2 = createRequire3(import.meta.url);
 var { version } = require2("../package.json");
-var program = new Command8();
+var program = new Command9();
 program.name("pags").description(
   "ProAgentStore CLI \u2014 create and publish server-powered AI agents"
 ).version(version);
@@ -1626,6 +1969,7 @@ program.addCommand(initCommand);
 program.addCommand(checkCommand);
 program.addCommand(publishCommand);
 program.addCommand(runnerCommand);
+program.addCommand(machinesCommand);
 program.addCommand(mcpCommand);
 try {
   await program.parseAsync();

package/package.json

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