@proagentstore/cli 0.4.39 → 0.4.41

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

@@ -1,110 +1,22 @@
 /**
- * Per-CLI behaviour for the coding runtime.
+ * Per-CLI facts the coding runtime needs before it can spawn an engine.
  *
- * Each AI coding CLI renders its TUI differently, so "is it ready for input?",
- * "is it still working?", and "where does its answer start/end in the pane?" are
- * CLI-specific. These handlers encapsulate that, ported from the AgentCoder
- * `bridge/src/agents/handlers/*`. A `generic` shell handler is included so the
- * runtime (and tests) can drive a plain shell deterministically.
+ * This file used to carry pane heuristics too — `isReady` / `isProcessing` / `extractResponse` /
+ * `completion`, ported from AgentCoder's `bridge/src/agents/handlers/*` — which answered
+ * "is it ready for input?" by matching strings a vendor prints in its TUI. They died with the
+ * tmux backend (commit c94642f): a session is a child process now, so Claude's turn boundary is a
+ * `result` event and a raw engine's is process exit. Nothing had called them since, and keeping
+ * them left a live-looking `pane.includes("ctrl+c to interrupt")` one vendor release away from
+ * being silently wrong — for anyone who wired it back up believing it worked.
+ *
+ * What remains is data: which binary this engine is, and which env var carries its key.
  */
-/** Shared "find the user's input line, return everything after it up to the next prompt". */
-function sliceAfterInput(captured, userInput, isPromptLine) {
-    const lines = captured.split("\n");
-    const needle = userInput.slice(0, 25);
-    let start = -1;
-    if (needle) {
-        for (let i = lines.length - 1; i >= 0; i--) {
-            if (lines[i].includes(needle)) {
-                start = i;
-                break;
-            }
-        }
-    }
-    if (start === -1)
-        return lines.slice(-200).join("\n").trim();
-    let end = lines.length;
-    for (let i = lines.length - 1; i > start; i--) {
-        if (isPromptLine(lines[i].trim())) {
-            end = i;
-            break;
-        }
-    }
-    return lines.slice(start + 1, end).join("\n").trim();
-}
-export class ClaudeHandler {
-    clientType = "claude";
-    cliCommand = "claude --dangerously-skip-permissions";
-    envVar = "ANTHROPIC_API_KEY";
-    isProcessing(pane) {
-        return pane.includes("ctrl+c to interrupt") || /Working|Thinking|Reading|Searching|Running|Editing|Writing/.test(pane);
-    }
-    isReady(pane) {
-        if (this.isProcessing(pane))
-            return false;
-        const tail = pane.split("\n").slice(-15).join("\n");
-        return (tail.includes("bypass permissions") ||
-            tail.includes("? for shortcuts") ||
-            /❯\s*$/.test(tail) ||
-            /❯ .*↵ send/.test(tail));
-    }
-    extractResponse(captured, userInput) {
-        return sliceAfterInput(captured, userInput, (l) => l === "❯" || l.startsWith("❯ "));
-    }
-    completion() {
-        return { minWait: 1000, stableThreshold: 0, forceCompleteAfter: 5 * 60 * 1000, pollInterval: 500 };
-    }
-}
-export class GeminiHandler {
-    clientType = "gemini";
-    cliCommand = "gemini";
-    envVar = "GEMINI_API_KEY";
-    isProcessing(pane) {
-        return /thinking|processing|generating|working|loading/i.test(pane);
-    }
-    isReady(pane) {
-        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
-        const hasPrompt = /[>$]\s*$/.test(last) || /^>/.test(last);
-        return hasPrompt && !this.isProcessing(pane);
-    }
-    extractResponse(captured, userInput) {
-        return sliceAfterInput(captured, userInput, (l) => /^[>$]\s*$/.test(l) || /^[>$]\s+\S/.test(l));
-    }
-    completion() {
-        return { stableThreshold: 1500, forceCompleteAfter: 5 * 60 * 1000, pollInterval: 500 };
-    }
-}
-/** Codex / Grok render close enough to a generic prompt; reuse the shell heuristics. */
-export class GenericHandler {
-    clientType;
-    cliCommand;
-    envVar;
-    constructor(clientType = "generic", cliCommand = "bash", envVar = "") {
-        this.clientType = clientType;
-        this.cliCommand = cliCommand;
-        this.envVar = envVar;
-    }
-    isProcessing(pane) {
-        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
-        return /\.\.\.$/.test(last);
-    }
-    isReady(pane) {
-        const last = pane.split("\n").slice(-1)[0]?.trim() ?? "";
-        // A shell prompt ends in $, #, >, or %  (optionally followed by a cursor space).
-        return /[$#>%]\s*$/.test(last) && !this.isProcessing(pane);
-    }
-    extractResponse(captured, userInput) {
-        return sliceAfterInput(captured, userInput, (l) => /[$#>%]\s*$/.test(l));
-    }
-    completion() {
-        return { stableThreshold: 800, forceCompleteAfter: 60 * 1000, pollInterval: 300 };
-    }
-}
 const HANDLERS = {
-    claude: new ClaudeHandler(),
-    gemini: new GeminiHandler(),
-    codex: new GenericHandler("codex", "codex", "OPENAI_API_KEY"),
-    grok: new GenericHandler("grok", "grok", "XAI_API_KEY"),
-    generic: new GenericHandler(),
+    claude: { clientType: "claude", cliCommand: "claude --dangerously-skip-permissions", envVar: "ANTHROPIC_API_KEY" },
+    gemini: { clientType: "gemini", cliCommand: "gemini --approval-mode yolo --skip-trust --prompt", envVar: "GEMINI_API_KEY" },
+    codex: { clientType: "codex", cliCommand: "codex exec --sandbox danger-full-access", envVar: "OPENAI_API_KEY" },
+    grok: { clientType: "grok", cliCommand: "grok --permission-mode bypassPermissions -p", envVar: "XAI_API_KEY" },
+    generic: { clientType: "generic", cliCommand: "bash", envVar: "" },
 };
 export function handlerFor(clientType) {
     return HANDLERS[clientType] ?? HANDLERS.generic;

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

@@ -44,6 +44,19 @@ const MAX_PENDING_USAGE = 200;
  * matter most, whereas the merge that started an incident is the one you cannot afford to lose.
  */
 const MAX_PENDING_ACTS = 100;
+/**
+ * Absolute ceiling on ONE one-shot turn (#391).
+ *
+ * The old idle heuristic carried a 15-minute backstop so a wedged engine could not sit "thinking"
+ * forever. Now that exit is the only thing that ends a one-shot turn, that ceiling has to be
+ * ENFORCED rather than inferred: a rule that merely relabels a still-running process as idle is
+ * the very defect #391 is about — it hands the next turn a repo another engine is still editing.
+ *
+ * So the timer ends the turn (SIGTERM) and says so in the transcript. Removing the ceiling
+ * outright would trade an early kill for a permanent hang, which is worse: nothing else on this
+ * path can unstick a process that never exits, and the console's Restart is a human noticing.
+ */
+const MAX_ONE_SHOT_TURN_MS = 15 * 60 * 1000;
 export class HeadlessSession {
     config;
     /**
@@ -67,11 +80,11 @@ export class HeadlessSession {
     cmdBin;
     cmdArgs;
     binName;
-    /** Wall-clock of the last stdout/stderr byte — drives the raw-mode idle heuristic. */
+    /** Wall-clock of the last stdout/stderr byte — drives the persistent-raw idle heuristic. */
     lastOutputAt = 0;
-    /** Raw-mode: has any output arrived since the current turn's input? */
+    /** Persistent-raw: has any output arrived since the current turn's input? */
     sawOutputSinceInput = false;
-    /** Raw-mode: when the current turn started (absolute idle backstop). */
+    /** Persistent-raw: when the current turn started (absolute idle backstop). */
     turnStartedAt = 0;
     /** Set by stop() — the only thing that ends a one-shot session (see `alive`). */
     stopped = false;
@@ -198,7 +211,27 @@ export class HeadlessSession {
     runState() {
         if (!this.alive)
             return "idle";
-        // Raw engines have no "turn over" event, so we INFER idle. Three rules, in order:
+        // A ONE-SHOT engine's turn IS a process, so its exit is an exact end-of-turn signal and no
+        // timer may pre-empt it (#391). Idle is set by the `close` handler; here the only question
+        // is whether that process is still running.
+        //
+        // This used to fall through to the timer rules below, which were written for a PERSISTENT
+        // interactive CLI — one with no other signal to read. Against a one-shot engine the 1.5s
+        // quiet rule could only ever fire EARLY: any pause inside a turn (a test suite, an install,
+        // a slow network fetch) read as "finished", the Pilot sent turn 2, and `runOneShot` killed
+        // turn 1 to keep two engines off one repo. The heuristic that existed to prevent a
+        // premature finish was causing one, and destroying the work in flight to do it.
+        //
+        // The ceiling that stops a wedged process is armed in `runOneShot` — it ENDS the turn
+        // rather than relabelling a live one as idle, which is the same mistake in slower form.
+        if (this.oneShot)
+            return this.procAlive ? "thinking" : "idle";
+        // Below: a PERSISTENT non-Claude engine — alive between turns, so exit says nothing about
+        // a turn and idle must be inferred. None ships today; every raw engine is one-shot. The
+        // gate is `!oneShot` rather than `mode === "raw"` because the latter now means the
+        // OPPOSITE of the condition these rules were written for.
+        //
+        // Three rules, in order:
         //  1. produced output, then went quiet for 1.5s → settled (the common case).
         //  2. NEVER produced output but 8s elapsed → a silent turn (just a prompt) is done.
         //  3. absolute 15-min backstop → never wedge "thinking" forever (e.g. a heartbeat
@@ -316,7 +349,7 @@ export class HeadlessSession {
         const now = Date.now();
         this.lastOutputAt = now;
         this.turnStartedAt = now;
-        this.sawOutputSinceInput = false; // arm the raw idle heuristic for THIS turn
+        this.sawOutputSinceInput = false; // arm the persistent-raw idle heuristic for THIS turn
         try {
             if (this.mode === "stream-json") {
                 const msg = JSON.stringify({ type: "user", message: { role: "user", content: [{ type: "text", text }] } });
@@ -353,11 +386,17 @@ export class HeadlessSession {
             env: mergeEnv(process.env, this.config.env),
             stdio: ["ignore", "pipe", "pipe"],
         });
-        // A turn already running is aborted before its replacement starts. `input()` never killed
-        // the previous process, and the raw idle heuristic declares idle after a >1.5s output
-        // pause — so a long build could be judged idle, the brain sends turn 2, and TWO engine
-        // processes edit the same repo at once.
+        // A turn already running is aborted before its replacement starts: `input()` accepts a turn
+        // at any time — a human typing in the console, a takeover, a Loop that stopped waiting —
+        // so without this TWO engine processes edit the same repo at once. Still needed after #391
+        // made exit authoritative: that stops the Pilot from being TOLD a running turn is over, it
+        // does not stop anyone from sending anyway.
+        //
+        // It SAYS what it destroyed, for the same reason the non-zero exit code goes into the
+        // transcript below: a turn's work vanishing with no line in the record is how the Pilot
+        // ends up reasoning about a turn that never finished, with nothing to explain the gap.
         if (this.procAlive) {
+            this.push(`[${this.config.clientType} turn aborted — a new instruction arrived while the previous one was still running]`);
             try {
                 this.proc?.kill();
             }
@@ -380,7 +419,23 @@ export class HeadlessSession {
         });
         proc.stdout?.on("data", (d) => this.onStdout(d.toString()));
         proc.stderr?.on("data", (d) => this.onStdout(d.toString()));
+        // The enforced ceiling (#391). `unref` so a pending timer can never keep the runner's
+        // event loop alive past its own shutdown.
+        const maxTurnMs = this.config.maxTurnMs ?? MAX_ONE_SHOT_TURN_MS;
+        const ceiling = setTimeout(() => {
+            if (this.proc !== proc)
+                return; // a newer turn owns the session; this one is already gone
+            this.push(`[${this.config.clientType} turn ended after ${Math.round(maxTurnMs / 60000)}m — the engine never exited, so the session was unwedged]`);
+            try {
+                proc.kill();
+            }
+            catch {
+                /* already gone */
+            }
+        }, maxTurnMs);
+        ceiling.unref();
         proc.on("close", (code) => {
+            clearTimeout(ceiling); // cleared before the staleness guard: the timer belongs to THIS process
             // A non-zero exit is the engine's own failure (bad flags, not signed in) and the
             // operator needs to see it — silently going idle is how "stdin is not a terminal"
             // looked like an idle session for a whole afternoon.

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

@@ -11,8 +11,8 @@ export class CodingRuntime {
     /**
      * Active human handoffs keyed by session id. `resolved` flips when the human
      * finishes (console "Resume" / submits a value); the brain workflow polls
-     * {@link takeoverStatus} and continues once it does — the tmux analogue of the
-     * browser runtime's handoff-status machinery.
+     * {@link takeoverStatus} and continues once it does — the coding-session analogue of
+     * the browser runtime's handoff-status machinery.
      */
     takeovers = new Map();
     /** Base directory under which repos are cloned (one subdir per repo). */

package/dist/index.js

@@ -617,11 +617,57 @@ 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 } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { Command as Command6 } from "commander";
 
 // src/commands/runner/http.ts
-import { hostname } from "os";
+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;
@@ -647,13 +693,17 @@ 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: hostname()
+    runnerNode: node,
+    machineId: machine.id,
+    machineNames: machine.names
   };
 }
 async function requestRunner(method, path, opts, body) {
@@ -708,7 +758,7 @@ function responseErrorMessage(data, text, statusText) {
 
 // src/commands/runner/process.ts
 import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { resolve as resolve4 } from "path";
 import { createServer as createServer2 } from "net";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -745,7 +795,7 @@ function buildRunnerArgs(opts) {
 function findWorkspaceRoot() {
   let dir = process.cwd();
   for (let i = 0; i < 8; i++) {
-    if (existsSync5(resolve4(dir, "pnpm-workspace.yaml"))) return dir;
+    if (existsSync6(resolve4(dir, "pnpm-workspace.yaml"))) return dir;
     const parent = resolve4(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -763,10 +813,10 @@ function runnerSpawnSpec(opts) {
   let cwd = root;
   let command = "pags-browser-runner";
   let args = runnerArgs;
-  if (existsSync5(localPackage)) {
+  if (existsSync6(localPackage)) {
     command = "pnpm";
     args = ["--filter", "@proagentstore/browser-runner", "dev", "--", ...runnerArgs];
-  } else if (existsSync5(bundledPackage)) {
+  } else if (existsSync6(bundledPackage)) {
     cwd = process.cwd();
     command = process.execPath;
     args = [bundledPackage, ...runnerArgs];
@@ -804,19 +854,19 @@ async function waitForLocalRunner(opts, timeoutMs = 15e3) {
 }
 
 // src/commands/runner/relay.ts
-import { hostname as hostname2 } from "os";
+import { hostname as hostname3 } from "os";
 
 // src/commands/runner/membership.ts
-function isEligible(inst, thisNode) {
+function isEligible(inst, thisNode, alsoKnownAs = []) {
   if (inst.status !== "active") return false;
   if (inst.capabilities?.runtime == null) return false;
   const pin = inst.config?.runnerNode;
-  if (pin && pin !== thisNode) return false;
+  if (pin && pin !== thisNode && !alsoKnownAs.includes(pin)) return false;
   return true;
 }
-function diffMembership(attached, eligible, thisNode, blocked = /* @__PURE__ */ new Set()) {
+function diffMembership(attached, eligible, thisNode, blocked = /* @__PURE__ */ new Set(), alsoKnownAs = []) {
   const have = new Set(attached);
-  const want = eligible.filter((i) => isEligible(i, thisNode));
+  const want = eligible.filter((i) => isEligible(i, thisNode, alsoKnownAs));
   const wantIds = new Set(want.map((i) => i.id));
   return {
     attach: want.filter((i) => !have.has(i.id) && !blocked.has(i.id)),
@@ -836,7 +886,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   const apiBase = pagsApiBase(opts.apiBase).replace(/^http/, "ws");
   const pagsToken = clean(opts.pagsToken) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
   if (!pagsToken) throw new Error("PAGS token required for WebSocket relay");
-  const runnerNode = hostname2();
+  const runnerNode = hostname3();
+  const machine = loadMachineIdentity(runnerNode);
   const capabilities = await requestRunner("GET", "/capabilities", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] });
   const caps = Array.isArray(capabilities.capabilities) ? capabilities.capabilities.filter((item) => typeof item === "string") : [];
   const registerRuntime = async (id) => {
@@ -848,6 +899,8 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         capabilities: caps,
         runnerVersion: CLI_VERSION,
         runnerNode,
+        machineId: machine.id,
+        machineNames: machine.names,
         force
       });
     } catch (e) {
@@ -881,7 +934,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   writeLine("Runtime registered with PAGS \u2713");
   writeLine("");
   writeLine("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
-  writeLine(`  \u2705 CONNECTED \u2014 WebSocket relay \xB7 ${hostname2()}`);
+  writeLine(`  \u2705 CONNECTED \u2014 WebSocket relay \xB7 ${hostname3()}`);
   writeLine(`  Agents:   ${instanceIds.length} instance${instanceIds.length === 1 ? "" : "s"}`);
   writeLine("  No cloudflared needed. Ctrl+C to disconnect.");
   writeLine("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
@@ -922,7 +975,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
             attached.keys(),
             res.instances ?? [],
             runnerNode,
-            blocked
+            blocked,
+            // The names this machine has also worn. Without them a pin made under a
+            // previous hostname reads as "pinned to another machine", and this poll
+            // detaches the agent twenty seconds after startup attached it (#379).
+            machine.names
           );
           for (const inst of toAttach) {
             await registerRuntime(inst.id);
@@ -963,7 +1020,7 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
       backoffMs = Math.min(backoffMs * 2, 3e4);
       return;
     }
-    const params = new URLSearchParams({ token: relayToken, node: hostname2() });
+    const params = new URLSearchParams({ token: relayToken, node: hostname3() });
     if (force) params.set("force", "1");
     const url = `${wsBase}/v1/relay/${encodeURIComponent(instanceId)}/connect?${params.toString()}`;
     const ws = new WebSocket(url);
@@ -1069,7 +1126,7 @@ function createRunnerCommand() {
     await startRunnerForeground(opts);
   });
   command.command("connect <instanceIds...>").description("Start ONE local runtime, connect via WebSocket relay, and register it for every given PAGS instance").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <port>", "Port to bind", "49171").option("--data-dir <path>", "Runner data directory").option("--token <token>", "Runner bearer token. Defaults to PAGS_RUNNER_TOKEN or a generated token").option("--headless", "Run Playwright headless").option("--api-base <url>", "PAGS API base URL").option("--pags-token <token>", "PAGS session token. Defaults to PAGS_TOKEN").option("--runner-version <version>", "Runner version").option("--force", "Take over from another connected machine").option("--watch-instances", "Attach newly eligible agents while running, without a restart").action(async (instanceIds, opts) => {
-    const runnerToken = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN) || `pags_runner_${randomUUID()}`;
+    const runnerToken = clean(opts.token) || clean(process.env.PAGS_RUNNER_TOKEN) || `pags_runner_${randomUUID2()}`;
     const host = clean(opts.host) || "127.0.0.1";
     const port = clean(opts.port) || String(await findFreePort2(49171));
     const localUrl = `http://${host}:${port}`;
@@ -1231,7 +1288,7 @@ import { Command as Command7 } from "commander";
 
 // src/tui.ts
 import chalk from "chalk";
-import { hostname as hostname3 } from "os";
+import { hostname as hostname4 } from "os";
 import readline from "readline";
 var ACCENT = "#7c3aed";
 var c = chalk.hex(ACCENT);
@@ -1273,7 +1330,7 @@ function printStatus(state) {
   clearScreen();
   printLogo(state.version);
   const connected = state.runner === "online" && state.tunnel === "online" && state.registration === "registered";
-  console.log(pad + d("Signed in as ") + w(state.user) + d("  \xB7  agent: ") + w(state.activeInstance) + d("  \xB7  node: ") + w(hostname3()));
+  console.log(pad + d("Signed in as ") + w(state.user) + d("  \xB7  agent: ") + w(state.activeInstance) + d("  \xB7  node: ") + w(hostname4()));
   console.log("");
   const row = (kind, s) => {
     const { icon, label, note } = describe(kind, s);

package/package.json

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