@proagentstore/cli 0.4.43 → 0.4.45

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

@@ -154,10 +154,26 @@ export class HeadlessSession {
     get authResolved() {
         return resolveEngineAuth(this.config.clientType, mergeEnv(process.env, this.config.env));
     }
+    /**
+     * Did this engine launch with a conversation to continue (#408)?
+     *
+     * Reported back to the cloud by `/coding/start` so the sentence the agent says to the user is
+     * something this side CONFIRMED rather than something the cloud asked for. The distinction is
+     * not academic: a runner published before #408 ignores `resumeFrom` entirely and always starts
+     * clean, so a cloud that announced "resumed where we left off" on its own intent would be
+     * telling most of the fleet's users the opposite of what happened.
+     *
+     * False for a raw (non-Claude) engine under every circumstance — `--resume` is a Claude Code
+     * flag and {@link buildClaudeArgs} is only reached in stream-json mode.
+     */
+    get resumedConversation() {
+        return this.mode === "stream-json" && this.claudeSessionId !== null;
+    }
     constructor(config) {
         this.config = config;
         this.engineLabel = `${config.clientType}:${config.id}`;
-        this.claudeSessionId = readState(config.statePath, config.id);
+        // Our own key first, the cloud's nominated predecessor second. See `resumeFrom`.
+        this.claudeSessionId = readState(config.statePath, config.id) ?? (config.resumeFrom ? readState(config.statePath, config.resumeFrom) : null);
         // Claude is the structured engine; everything else is a raw CLI.
         this.mode = config.clientType === "claude" ? "stream-json" : "raw";
         const { bin, args } = parseCommand(config.command);
@@ -454,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";
@@ -89,12 +90,17 @@ export class CodingRuntime {
                 command: input.command,
                 env: input.env,
                 statePath: defaultStatePath(this.reposBaseDir),
+                resumeFrom: input.resumeFrom,
                 bin: input.bin,
             });
             this.sessions.set(input.sessionId, session);
         }
+        // Read BEFORE `start()`: a bad `--resume` can kill the process on spawn, and the engine
+        // clears its own key on that exit. Reporting after would say "started clean" about a launch
+        // that did carry a conversation, and the transcript (which shows the crash) would disagree.
+        const resumed = session.resumedConversation;
         session.start();
-        return this.snapshot(input.sessionId);
+        return { ...this.snapshot(input.sessionId), resumed };
     }
     /**
      * The pane the brain reasons over + the inferred run state.
@@ -130,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/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/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,9 +497,340 @@ async function findFreePort() {
   });
 }
 
+// src/commands/machines.ts
+import { Command as Command4 } from "commander";
+
+// src/machine.ts
+import { randomUUID } from "crypto";
+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 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);
+}
+function parseMachineFile(text) {
+  try {
+    const data = JSON.parse(text);
+    if (!isValidMachineId(data.id)) return null;
+    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), 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 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 (existsSync4(MACHINE_FILE)) stored = parseMachineFile(readFileSync3(MACHINE_FILE, "utf-8"));
+  } catch {
+  }
+  const next = withName(stored ?? { id: randomUUID(), names: [] }, now);
+  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 a claim cannot be undone from the CLI.");
+  return lines;
+}
+async function fetchNodeSummaries(opts) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  try {
+    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 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/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("");
+});
+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 machinesCommand = new Command4("machines").description("Show and claim the machine names ProAgentStore has for this account").addCommand(listCommand, { isDefault: true }).addCommand(claimCommand);
+
 // src/commands/mcp.ts
 import { spawn } from "child_process";
-import { Command as Command4 } from "commander";
+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];
@@ -517,25 +848,25 @@ async function runMcpProxy(opts, extraArgs = []) {
     });
   });
 }
-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) => {
+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 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) => {
+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 = join4(dir, "agent.json");
-  if (!existsSync4(manifestPath)) {
+  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(readFileSync3(manifestPath, "utf-8"));
+    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);
@@ -618,56 +949,10 @@ var publishCommand = new Command5("publish").description("Publish an agent to Pr
 // src/commands/runner/command.ts
 import { spawn as spawn3 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { Command as Command6 } from "commander";
+import { Command as Command7 } 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 { 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");
-var MAX_NAMES = 10;
-function isValidMachineId(value) {
-  return typeof value === "string" && /^[A-Za-z0-9_-]{8,64}$/.test(value);
-}
-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) };
-  } catch {
-    return null;
-  }
-}
-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) };
-}
-function loadMachineIdentity(now = hostname()) {
-  let stored = null;
-  try {
-    if (existsSync5(MACHINE_FILE)) stored = parseMachineFile(readFileSync4(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;
-  try {
-    mkdirSync3(CONFIG_DIR2, { recursive: true });
-    writeFileSync3(MACHINE_FILE, JSON.stringify(next, null, 2));
-    return next;
-  } catch {
-    return stored ?? { id: "", names: [] };
-  }
-}
-
-// src/commands/runner/http.ts
 function clean(value) {
   const trimmed = value?.trim();
   return trimmed || void 0;
@@ -1119,7 +1404,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 +1569,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 +1678,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 +1698,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 +1716,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 +1747,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 +1881,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 +1903,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 +1916,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.43",
+  "version": "0.4.45",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",