skydive-cli 0.5.0-beta.30 → 0.5.0-beta.32

package/dist/js/{boot-0-dpPM1_.mjs → boot-yyXrIeVy.mjs}

@@ -1,15 +1,16 @@
 #!/usr/bin/env node
-import { A as takenAliasNames, C as themesForMode, D as dedupeAliasName, E as aliasActivationHint, F as getActiveWorkspaceId, L as listWorkspaces, N as detectShell, O as installAgentAlias, T as machineOsFromPlatform, _ as theme, a as installCrashHandler, b as themeModeFromColorFgBg, c as MARK_CELLS, d as splashFitsWidth, f as DEFAULT_THEME_ID, g as noColorRequested, h as monoTheme, i as writeArtifact, k as slugifyAliasName, l as WORDMARK, m as findTheme, n as profilingEnabled, o as buildCrashReport, p as applyTheme, r as record, s as writeCrashReport, v as themeForMode, x as themeVersion, y as themeMode, z as setActiveWorkspace } from "./profiler-BoO7ldO0.mjs";
-import { B as resolveWebUrl, C as getConfigPath, O as getReviewStateDir, P as recordDefaultAgent, U as saveTheme, b as DEFAULT_APP_URL, c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, h as specKeyFor, i as resolveAgent, k as getSavedTheme, l as parseExternalOauthConnectParams, m as parseConnectCard, p as computeSettledLabel, s as MASK_CHAR, u as parseOauthConnectParams, y as DEFAULT_API_URL } from "./print-DYiQC5IW.mjs";
-import { t as HttpError } from "./http-error-DzyrsLAZ.mjs";
-import { a as isRecord, i as errorMessage, n as errorDetail, r as sendErrorMessage, t as createRestClient } from "./rest-xXfqT4SX.mjs";
-import { i as billingBlockedOutcomeFromSendResponse } from "./billing-blocked-2wju4gC_.mjs";
-import { t as PortalClient } from "./client-DbqRBquD.mjs";
-import "./daemon-DuxaUuek.mjs";
-import "./api-DG5W6iwx.mjs";
-import { t as SandboxStream } from "./client-c4c5MmgN.mjs";
-import { t as PortalDaemonClient } from "./daemon-client-C4heMWTq.mjs";
-import { t as runRawPtyPassthrough } from "./raw-pty-DY4KelZW.mjs";
+import { A as takenAliasNames, C as themesForMode, D as dedupeAliasName, E as aliasActivationHint, F as getActiveWorkspaceId, L as listWorkspaces, N as detectShell, O as installAgentAlias, T as machineOsFromPlatform, _ as theme, a as installCrashHandler, b as themeModeFromColorFgBg, c as MARK_CELLS, d as splashFitsWidth, f as DEFAULT_THEME_ID, g as noColorRequested, h as monoTheme, i as writeArtifact, k as slugifyAliasName, l as WORDMARK, m as findTheme, n as profilingEnabled, o as buildCrashReport, p as applyTheme, r as record, s as writeCrashReport, v as themeForMode, x as themeVersion, y as themeMode, z as setActiveWorkspace } from "./profiler-CJMnC90G.mjs";
+import { B as resolveWebUrl, C as getConfigPath, O as getReviewStateDir, P as recordDefaultAgent, U as saveTheme, b as DEFAULT_APP_URL, c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, h as specKeyFor, i as resolveAgent, k as getSavedTheme, l as parseExternalOauthConnectParams, m as parseConnectCard, p as computeSettledLabel, s as MASK_CHAR, u as parseOauthConnectParams, y as DEFAULT_API_URL } from "./print-Clgq46GU.mjs";
+import { t as HttpError } from "./http-error-UHH3mVBF.mjs";
+import { a as isRecord, i as errorMessage, n as errorDetail, r as sendErrorMessage, t as createRestClient } from "./rest-C6E4mS2A.mjs";
+import { i as billingBlockedOutcomeFromSendResponse } from "./billing-blocked-D3l5kJlX.mjs";
+import { t as PortalClient } from "./client-d6K9qm6B.mjs";
+import "./daemon-CxFxH36O.mjs";
+import { t as defaultTlsCertSource } from "./tls-cert-CV-pwxVN.mjs";
+import "./api-DQCaztBg.mjs";
+import { t as SandboxStream } from "./client-BTQ1fwzM.mjs";
+import { t as PortalDaemonClient } from "./daemon-client-Br1NlkRp.mjs";
+import { t as runRawPtyPassthrough } from "./raw-pty-B9Bue8gg.mjs";
 import * as os$1 from "node:os";
 import { homedir, platform, release, tmpdir } from "node:os";
 import path, { basename, extname, isAbsolute, join, win32 } from "node:path";
@@ -396,6 +397,9 @@ function createPortalClient(opts) {
 				deviceToken: null
 			}),
 			resolveCwd: () => process.cwd(),
+			tlsCertSource: defaultTlsCertSource(process.env, (msg) => {
+				console.error(msg);
+			}),
 			persistedMachineName: null,
 			onMachineName: () => {},
 			onState: (state) => opts.onState({
@@ -4805,28 +4809,38 @@ function useConversationContext() {
 /**
 * `/computer`: a live snapshot of the agent's sandbox as a set of bar graphs.
 *
-* The CLI runs on the USER's machine, so it can't read the sandbox's `/proc`
-* directly — it runs one small, portable shell command over the sandbox-exec
-* stream (`SandboxStream`, mode `exec`) and parses the output here. Everything
-* in this module is pure so the parse + layout are unit-testable without a
-* sandbox or a renderer.
+* The numbers come from the api, NOT from the CLI reaching into the sandbox.
+* The worker's fleet metrics sweep already samples every live box's CPU /
+* memory / disk from the provider and stores the latest per-sandbox snapshot;
+* the CLI reads that back over one plain REST call (`collectSandboxStats`). So
+* there is no exec into the box and no cold-start wake — when the agent has no
+* running sandbox the api answers "no snapshot" immediately instead of the card
+* hanging on a stream that never replies.
 *
-* The command reads `/proc` and `df` only (no tools that might be missing from
-* a minimal image), emitting a tagged, tab-separated block. The leading
-* `SKYDIVE_STATS_V1` sentinel lets the parser find the block even when a shell
-* rc file prints a banner first, and versions the wire shape.
+* Everything in this module is pure so the layout math is unit-testable without
+* an api or a renderer.
 */
-const SANDBOX_STATS_SENTINEL = "SKYDIVE_STATS_V1";
 /**
 * How often the live `/computer` card refreshes its snapshot, in ms.
 * Deliberately slow: the card is a background health readout, not a `top`, so
-* it refreshes quietly every 30s rather than flickering every second.
+* it refreshes quietly every 30s rather than flickering every second. Also
+* comfortably slower than the worker's ~60s sweep cadence, so we never poll for
+* a sample that can't have changed.
 */
 const COMPUTER_POLL_INTERVAL_MS = 3e4;
 /**
+* A snapshot older than this is stale enough that we no longer present it as
+* "current". The api sample carries the provider's measurement time; the sweep
+* that writes it runs ~every 60s and the Redis key TTLs at 5 min, so a sample
+* this old means the box likely stopped reporting (paused / gone). The card
+* treats it as "no current snapshot" rather than drawing minutes-old bars as if
+* they were live.
+*/
+const COMPUTER_STATS_STALE_MS = 5 * 6e4;
+/**
 * Whether a `/computer` card should refresh right now. Pure so the gating is
 * unit-testable. A card refreshes only when it is the most recent `/computer`
-* in the transcript (`isLatest`), the session can reach the sandbox
+* in the transcript (`isLatest`), the session can reach the api
 * (`canCollect`), and the transcript is at the bottom (`!scrolledUp`) — while
 * you're scrolled up reading something else it quietly stops (no wasted polls),
 * and resumes when you scroll back down. Older cards freeze regardless, so a
@@ -4836,180 +4850,6 @@ const COMPUTER_POLL_INTERVAL_MS = 3e4;
 function shouldPollComputer(opts) {
 	return opts.isLatest && opts.canCollect && !opts.scrolledUp;
 }
-/**
-* The command run in the sandbox to collect the snapshot. `sh`-portable, reads
-* only `/proc` and `df`. Each metric is one `key<TAB>value` line so the parser
-* never has to positionally align anything.
-*
-* The `port` lines enumerate LISTEN sockets the sandbox user's own processes
-* hold: one awk pass maps socket inodes from /proc/net/tcp{,6} to pids via
-* /proc/<pid>/fd, then a shell loop attaches each pid's cmdline. Platform
-* daemons run as root, so their /proc/<pid>/fd is unreadable here and they
-* never emit a line — the "user's servers only" filter falls out of
-* permissions rather than a curated list. Hex address:port is left for the
-* parser to decode (strtonum is gawk-only).
-*/
-const SANDBOX_STATS_COMMAND = [
-	`printf '${SANDBOX_STATS_SENTINEL}\\n'`,
-	`printf 'nproc\\t%s\\n' "$(nproc 2>/dev/null || echo 1)"`,
-	`printf 'loadavg\\t%s\\n' "$(cut -d' ' -f1-3 /proc/loadavg)"`,
-	`printf 'uptime\\t%s\\n' "$(cut -d' ' -f1 /proc/uptime)"`,
-	`awk '/^MemTotal:/{t=$2}/^MemAvailable:/{a=$2}END{printf "mem_total_kb\\t%d\\nmem_avail_kb\\t%d\\n",t,a}' /proc/meminfo`,
-	`awk '/^SwapTotal:/{t=$2}/^SwapFree:/{f=$2}END{printf "swap_total_kb\\t%d\\nswap_free_kb\\t%d\\n",t,f}' /proc/meminfo`,
-	`df -Pk / | awk 'NR==2{printf "disk_total_kb\\t%d\\ndisk_used_kb\\t%d\\n",$2,$3}'`,
-	`printf 'procs\\t%s\\n' "$(ls -1 /proc 2>/dev/null | grep -c '^[0-9]\\+$')"`,
-	`ls -l /proc/[0-9]*/fd 2>/dev/null | awk 'BEGIN { while ((getline l < "/proc/net/tcp") > 0) { split(l,f," "); if (f[4]=="0A") want[f[10]]=f[2] } close("/proc/net/tcp"); while ((getline l < "/proc/net/tcp6") > 0) { split(l,f," "); if (f[4]=="0A") want[f[10]]=f[2] } close("/proc/net/tcp6") } $0 ~ "^/proc/[0-9]+/fd:$" { pid=substr($0,7,length($0)-10) } match($0, /socket:\\[[0-9]+\\]/) { ino=substr($0,RSTART+8,RLENGTH-9); if (ino in want && !(ino in done)) { done[ino]=1; print want[ino] "\\t" pid } }' | while read addr pid; do cl=$(head -c 200 "/proc/$pid/cmdline" 2>/dev/null | tr "\\0" " "); printf 'port\\t%s\\t%s\\t%s\\n' "$addr" "$pid" "$cl"; done`
-].join(" ; ");
-const KB = 1024;
-const HIDDEN_PORTS = new Set([
-	38994,
-	49983,
-	38996
-]);
-const V6_LOOPBACK_HEX = "00000000000000000000000001000000";
-/**
-* Whether a /proc/net/tcp{,6} local-address hex field is a loopback bind.
-* v4 words are little-endian, so 127.0.0.1 is `0100007F` — the first octet
-* (127) is the LAST byte pair. Covers v4-mapped v6 (`::ffff:127.x.y.z`) via
-* the same tail check.
-*/
-function isLoopbackHex(addrHex) {
-	const hex = addrHex.toUpperCase();
-	if (hex.length === 8) return hex.slice(6) === "7F";
-	if (hex.length === 32) {
-		if (hex === V6_LOOPBACK_HEX) return true;
-		return hex.startsWith("0000000000000000FFFF0000") && hex.slice(30) === "7F";
-	}
-	return false;
-}
-const RUNTIME_NAMES = new Set([
-	"node",
-	"bun",
-	"deno",
-	"python",
-	"python3",
-	"sh",
-	"bash"
-]);
-const FLAGS_WITH_VALUE = new Set([
-	"--require",
-	"-r",
-	"--import",
-	"--loader",
-	"--experimental-loader"
-]);
-/**
-* A short display name from a raw cmdline: basename of argv[0], plus — when
-* argv[0] is a bare runtime — the basename of the first non-flag argument with
-* its extension dropped (`node …/vite/bin/vite.js` → `node vite`).
-*/
-function processDisplayName(cmdline) {
-	const argv = cmdline.trim().split(/\s+/).filter(Boolean);
-	const first = argv[0];
-	if (first === void 0) return null;
-	const base = (p) => p.split("/").pop() ?? p;
-	const name = base(first);
-	if (!RUNTIME_NAMES.has(name)) return name;
-	let script;
-	for (let i = 1; i < argv.length; i += 1) {
-		const arg = argv[i];
-		if (arg === void 0) break;
-		if (FLAGS_WITH_VALUE.has(arg)) {
-			i += 1;
-			continue;
-		}
-		if (arg.startsWith("-")) continue;
-		script = arg;
-		break;
-	}
-	if (!script) return name;
-	return `${name} ${base(script).replace(/\.(?:mjs|cjs|js|ts|tsx|py)$/, "")}`;
-}
-/**
-* Fold the collector's `port` lines (one per listen socket) into one entry
-* per port: v4/v6 binds of the same server dedupe, `loopbackOnly` only when
-* every bind is loopback, and the hidden platform ports drop out.
-*/
-function parsePortLines(lines) {
-	const byPort = /* @__PURE__ */ new Map();
-	for (const line of lines) {
-		const port = Number.parseInt(line.portHex, 16);
-		if (!Number.isFinite(port) || port <= 0 || HIDDEN_PORTS.has(port)) continue;
-		const entry = byPort.get(port);
-		if (entry) entry.loopback.push(isLoopbackHex(line.addrHex));
-		else byPort.set(port, {
-			loopback: [isLoopbackHex(line.addrHex)],
-			cmdline: line.cmdline
-		});
-	}
-	return [...byPort.entries()].map(([port, entry]) => ({
-		port,
-		loopbackOnly: entry.loopback.every(Boolean),
-		process: entry.cmdline ? processDisplayName(entry.cmdline) : null
-	})).sort((a, b) => a.port - b.port);
-}
-/**
-* Parse the collector's output into `SandboxStats`, or return null when the
-* block is absent or malformed (so the caller can show the raw output as an
-* error instead of a broken graph). Tolerant of extra lines before the
-* sentinel (shell banners) and of a missing swap section (swap totals default
-* to 0, which the renderer treats as "no swap").
-*/
-function parseSandboxStats(raw) {
-	const start = raw.indexOf(SANDBOX_STATS_SENTINEL);
-	if (start === -1) return null;
-	const fields = /* @__PURE__ */ new Map();
-	const portLines = [];
-	for (const line of raw.slice(start).split("\n")) {
-		const tab = line.indexOf("	");
-		if (tab === -1) continue;
-		const key = line.slice(0, tab).trim();
-		if (key === "port") {
-			const parts = line.split("	");
-			const [addrHex = "", portHex = ""] = (parts[1] ?? "").split(":");
-			if (addrHex && portHex) portLines.push({
-				addrHex,
-				portHex,
-				cmdline: parts.slice(3).join(" ").trim()
-			});
-			continue;
-		}
-		fields.set(key, line.slice(tab + 1).trim());
-	}
-	const num = (key) => {
-		const v = fields.get(key);
-		if (v === void 0) return null;
-		const n = Number(v);
-		return Number.isFinite(n) ? n : null;
-	};
-	const load = (fields.get("loadavg") ?? "").split(/\s+/).map(Number).filter((n) => Number.isFinite(n));
-	const nproc = num("nproc");
-	const uptime = num("uptime");
-	const memTotal = num("mem_total_kb");
-	const memAvail = num("mem_avail_kb");
-	const diskTotal = num("disk_total_kb");
-	const diskUsed = num("disk_used_kb");
-	const procs = num("procs");
-	const [load1, load5, load15] = load;
-	if (nproc === null || uptime === null || memTotal === null || memAvail === null || diskTotal === null || diskUsed === null || procs === null || load1 === void 0 || load5 === void 0 || load15 === void 0) return null;
-	return {
-		nproc: Math.max(1, Math.round(nproc)),
-		loadavg: [
-			load1,
-			load5,
-			load15
-		],
-		uptimeSeconds: uptime,
-		memTotalBytes: memTotal * KB,
-		memAvailBytes: memAvail * KB,
-		swapTotalBytes: (num("swap_total_kb") ?? 0) * KB,
-		swapFreeBytes: (num("swap_free_kb") ?? 0) * KB,
-		diskTotalBytes: diskTotal * KB,
-		diskUsedBytes: diskUsed * KB,
-		procs: Math.round(procs),
-		ports: parsePortLines(portLines)
-	};
-}
 function severityFor(fraction) {
 	if (fraction >= .9) return "crit";
 	if (fraction >= .75) return "warn";
@@ -5019,52 +4859,29 @@ const GiB = 1024 * 1024 * 1024;
 function gb(bytes) {
 	return (bytes / GiB).toFixed(1);
 }
-/** `120050` seconds -> `1d 9h 20m`. Always at least `0m`. */
-function formatUptime(seconds) {
-	const total = Math.max(0, Math.floor(seconds));
-	const d = Math.floor(total / 86400);
-	const h = Math.floor(total % 86400 / 3600);
-	const m = Math.floor(total % 3600 / 60);
-	const parts = [];
-	if (d > 0) parts.push(`${d}d`);
-	if (h > 0 || d > 0) parts.push(`${h}h`);
-	parts.push(`${m}m`);
-	return parts.join(" ");
-}
 /**
 * Reduce a snapshot to the ordered list of gauges the `/computer` card draws:
-* CPU load (normalized to core count), memory, swap (only when the box has
-* any), and disk. Load can exceed 1.0 (oversubscribed CPU) — the bar clamps
-* but the caption shows the true number so that's still legible.
+* CPU utilization, memory, and disk — the three signals the api's live-stats
+* read carries. CPU is a provider-measured utilization percent (already
+* normalized across cores), so it maps straight to a 0..1 bar; the caption
+* shows the vCPU count for context.
 */
 function toGauges(stats) {
 	const gauges = [];
-	const load1 = stats.loadavg[0];
-	const loadFraction = load1 / stats.nproc;
+	const cpuFraction = stats.cpuUsedPct / 100;
 	gauges.push({
-		label: "cpu load",
-		fraction: loadFraction,
-		detail: `${load1.toFixed(2)} / ${stats.nproc} cores`,
-		severity: severityFor(loadFraction)
+		label: "cpu",
+		fraction: cpuFraction,
+		detail: `${stats.cpuUsedPct.toFixed(0)}% · ${stats.cpuCount} vCPU`,
+		severity: severityFor(cpuFraction)
 	});
-	const memUsed = Math.max(0, stats.memTotalBytes - stats.memAvailBytes);
-	const memFraction = stats.memTotalBytes > 0 ? memUsed / stats.memTotalBytes : 0;
+	const memFraction = stats.memTotalBytes > 0 ? stats.memUsedBytes / stats.memTotalBytes : 0;
 	gauges.push({
 		label: "memory",
 		fraction: memFraction,
-		detail: `${gb(memUsed)} / ${gb(stats.memTotalBytes)} GB`,
+		detail: `${gb(stats.memUsedBytes)} / ${gb(stats.memTotalBytes)} GB`,
 		severity: severityFor(memFraction)
 	});
-	if (stats.swapTotalBytes > 0) {
-		const swapUsed = Math.max(0, stats.swapTotalBytes - stats.swapFreeBytes);
-		const swapFraction = swapUsed / stats.swapTotalBytes;
-		gauges.push({
-			label: "swap",
-			fraction: swapFraction,
-			detail: `${gb(swapUsed)} / ${gb(stats.swapTotalBytes)} GB`,
-			severity: severityFor(swapFraction)
-		});
-	}
 	const diskFraction = stats.diskTotalBytes > 0 ? stats.diskUsedBytes / stats.diskTotalBytes : 0;
 	gauges.push({
 		label: "disk",
@@ -5100,29 +4917,18 @@ function renderBar(fraction, width) {
 	const filled = "█".repeat(Math.min(full, cells)) + partial;
 	return (filled + "░".repeat(Math.max(0, cells - filled.length))).slice(0, cells);
 }
-/** How many port rows the card draws before folding the rest into `+N more`. */
-const MAX_PORT_ROWS = 8;
-const WELL_KNOWN_PORTS = new Map([[3e3, "agent harness"], [3001, "agent webserver"]]);
-/**
-* Reduce the snapshot's ports to drawable rows. The well-known note wins over
-* `local only` — a loopback-bound 3001 being unreachable is a distinct problem
-* the gauges' error path already surfaces, and one annotation per row keeps
-* the table scannable.
-*/
-function toPortRows(ports) {
-	return ports.map((p) => ({
-		port: p.port,
-		process: p.process ?? "?",
-		note: WELL_KNOWN_PORTS.get(p.port) ?? (p.loopbackOnly ? "local only" : null)
-	}));
-}
 
 //#endregion
 //#region src/chat/tui/chunks/computer.tsx
 /**
 * Renders the `/computer` card: a snapshot of the agent's sandbox as a stack of
-* colored bar graphs (cpu load, memory, swap, disk) plus a footer of scalar
-* facts (uptime, process count).
+* colored bar graphs (cpu, memory, disk).
+*
+* The numbers come from the api, not from reaching into the box: the card polls
+* `collectSandboxStats` (injected via context), which reads the live resource
+* sample the worker's fleet sweep already stores. So there's no exec and no
+* cold-start wake — when the agent has no running sandbox the read returns
+* "no snapshot" at once and the card shows an idle line instead of hanging.
 *
 * The card keeps itself current in place rather than making the user re-run the
 * command — but quietly: it refreshes on a slow interval with no "updating"
@@ -5130,9 +4936,8 @@ function toPortRows(ports) {
 * recent `/computer` card refreshes (older ones freeze at their last snapshot),
 * and the latest one silently stops while the transcript is scrolled up (no
 * wasted polls on a card you're not looking at) and resumes at the bottom — the
-* pause is never rendered. The refresh uses the same sandbox-exec relay
-* `/sandbox` uses, injected via context; the parse/layout math lives in
-* `sandbox-stats.ts` and this component only draws.
+* pause is never rendered. The parse/layout math lives in `sandbox-stats.ts` and
+* this component only draws.
 */
 function ComputerItem({ item }) {
 	const { collectSandboxStats, latestComputerId, scrolledUp } = useConversationContext();
@@ -5143,7 +4948,8 @@ function ComputerItem({ item }) {
 	});
 	const [stats, setStats] = useState(item.stats);
 	const [error, setError] = useState(item.error);
-	const hasStats = useRef(item.stats !== null);
+	const hasResolved = useRef(item.stats !== null || item.state !== "loading");
+	const [idle, setIdle] = useState(item.state !== "loading" && item.stats === null && item.error === null);
 	useEffect(() => {
 		if (!live || !collectSandboxStats) return;
 		let cancelled = false;
@@ -5156,11 +4962,12 @@ function ComputerItem({ item }) {
 			inFlight = null;
 			if (cancelled) return;
 			if (result.ok) {
-				hasStats.current = true;
+				hasResolved.current = true;
 				setStats(result.stats);
 				setError(null);
+				setIdle(result.stats === null);
 			} else if (!("aborted" in result)) {
-				if (!hasStats.current) setError(result.error);
+				if (!hasResolved.current) setError(result.error);
 			}
 			if (!cancelled) timer = setTimeout(tick, COMPUTER_POLL_INTERVAL_MS);
 		};
@@ -5171,43 +4978,26 @@ function ComputerItem({ item }) {
 			inFlight?.abort();
 		};
 	}, [live, collectSandboxStats]);
-	if (stats === null && error === null) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsx("text", {
+	if (stats === null && error === null && !idle) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsx("text", {
 		fg: theme.dim,
 		children: "reading sandbox stats…"
 	}) });
-	if (stats === null) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsxs("text", {
+	if (stats === null && error !== null) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsxs("text", {
 		fg: theme.error,
-		children: ["couldn't read sandbox stats", error ? `: ${error}` : ""]
+		children: ["couldn't read sandbox stats: ", error]
+	}) });
+	if (stats === null) return /* @__PURE__ */ jsx(Shell, { children: /* @__PURE__ */ jsx("text", {
+		fg: theme.dim,
+		children: "no sandbox running"
 	}) });
 	const gauges = toGauges(stats);
-	const portRows = toPortRows(stats.ports);
-	const labelWidth = Math.max(5, ...gauges.map((g) => g.label.length));
+	const labelWidth = Math.max(...gauges.map((g) => g.label.length));
 	const barWidth = 24;
-	return /* @__PURE__ */ jsxs(Shell, { children: [
-		gauges.map((g) => /* @__PURE__ */ jsx(GaugeRow, {
-			gauge: g,
-			labelWidth,
-			barWidth
-		}, g.label)),
-		/* @__PURE__ */ jsx(PortsSection, {
-			rows: portRows,
-			labelWidth
-		}),
-		/* @__PURE__ */ jsxs("text", {
-			fg: theme.dim,
-			children: [
-				`${"uptime".padEnd(labelWidth)}  `,
-				/* @__PURE__ */ jsx("span", {
-					fg: theme.muted,
-					children: formatUptime(stats.uptimeSeconds)
-				}),
-				/* @__PURE__ */ jsx("span", {
-					fg: theme.dim,
-					children: `  ·  ${stats.procs} processes`
-				})
-			]
-		})
-	] });
+	return /* @__PURE__ */ jsx(Shell, { children: gauges.map((g) => /* @__PURE__ */ jsx(GaugeRow, {
+		gauge: g,
+		labelWidth,
+		barWidth
+	}, g.label)) });
 }
 /** The card frame: a bold `computer` title over the graph rows. */
 function Shell({ children }) {
@@ -5255,42 +5045,6 @@ function GaugeRow({ gauge, labelWidth, barWidth }) {
 		})
 	] });
 }
-/**
-* The listening-ports table: one row per port the sandbox user's processes
-* hold, first row carrying the `ports` gutter label to line up with the
-* gauges. Folds past MAX_PORT_ROWS into a `+N more` line so a busy box can't
-* flood the transcript.
-*/
-function PortsSection({ rows, labelWidth }) {
-	if (rows.length === 0) return null;
-	const shown = rows.slice(0, MAX_PORT_ROWS);
-	const folded = rows.length - shown.length;
-	const gutter = " ".repeat(labelWidth);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [shown.map((row, i) => /* @__PURE__ */ jsxs("text", { children: [
-		/* @__PURE__ */ jsx("span", {
-			fg: theme.muted,
-			children: `${i === 0 ? "ports".padEnd(labelWidth) : gutter}  `
-		}),
-		/* @__PURE__ */ jsx("span", {
-			fg: theme.fg,
-			children: String(row.port).padStart(5)
-		}),
-		/* @__PURE__ */ jsx("span", {
-			fg: theme.muted,
-			children: `  ${row.process}`
-		}),
-		row.note ? /* @__PURE__ */ jsx("span", {
-			fg: theme.dim,
-			children: `  · ${row.note}`
-		}) : null
-	] }, row.port)), folded > 0 ? /* @__PURE__ */ jsxs("text", { children: [/* @__PURE__ */ jsx("span", {
-		fg: theme.muted,
-		children: `${gutter}  `
-	}), /* @__PURE__ */ jsx("span", {
-		fg: theme.dim,
-		children: `+${folded} more`
-	})] }) : null] });
-}
 
 //#endregion
 //#region src/chat/tui/chunks/index.tsx
@@ -7042,55 +6796,45 @@ function formatShare(share) {
 
 //#endregion
 //#region src/chat/sandbox/collect-stats.ts
+/**
+* Drop a snapshot the api hasn't refreshed recently: the sweep that writes it
+* runs ~every 60s, so a sample older than {@link COMPUTER_STATS_STALE_MS} means
+* the box stopped reporting (paused / gone) and its numbers are no longer live.
+* Presenting it as current would be a lie, so treat it as "no snapshot".
+*/
+function freshOrNull(stats, now) {
+	if (!stats) return null;
+	return now - stats.sampledAt <= COMPUTER_STATS_STALE_MS ? stats : null;
+}
 function collectSandboxStats(cfg) {
-	const open = cfg.open ?? SandboxStream.open;
-	const dec = new TextDecoder();
-	let buffer = "";
-	let settled = false;
-	let stream = null;
+	let aborted = false;
 	let resolveRef = null;
+	let settled = false;
+	const settle = (r) => {
+		if (settled) return;
+		settled = true;
+		resolveRef?.(r);
+	};
 	return {
 		result: new Promise((resolve) => {
 			resolveRef = resolve;
-			const settle = (r) => {
-				if (settled) return;
-				settled = true;
-				resolve(r);
-			};
-			stream = open({
-				mode: "exec",
-				appUrl: cfg.appUrl,
-				sessionToken: cfg.sessionToken,
-				agentId: cfg.agentId,
-				command: SANDBOX_STATS_COMMAND,
-				onEvent: (e) => {
-					if (e.type === "data") buffer += dec.decode(e.bytes);
-					else if (e.type === "error") settle({
-						ok: false,
-						error: e.message
-					});
-					else if (e.type === "exit") {
-						const stats = parseSandboxStats(buffer);
-						if (stats) settle({
-							ok: true,
-							stats
-						});
-						else settle({
-							ok: false,
-							error: e.code === 0 ? "unexpected output from the sandbox" : `sandbox command exited ${e.code}`
-						});
-					} else if (e.type === "close") settle({
-						ok: false,
-						error: e.failure ?? "connection closed before the snapshot finished"
-					});
-				}
+			cfg.read().then((stats) => {
+				if (aborted) return;
+				settle({
+					ok: true,
+					stats: freshOrNull(stats, cfg.now())
+				});
+			}).catch((err) => {
+				if (aborted) return;
+				settle({
+					ok: false,
+					error: err instanceof Error ? err.message : String(err)
+				});
 			});
 		}),
 		abort: () => {
-			if (settled) return;
-			settled = true;
-			stream?.close();
-			resolveRef?.({
+			aborted = true;
+			settle({
 				ok: false,
 				aborted: true,
 				error: "aborted"
@@ -13123,17 +12867,12 @@ function ChatScreen({ agent, conversation }) {
 		return null;
 	}, [items]);
 	const boundCollectSandboxStats = useMemo(() => {
-		if (!appUrl || !sessionToken) return null;
+		if (!rest) return null;
 		return () => collectSandboxStats({
-			appUrl,
-			sessionToken,
-			agentId: agent.id
+			read: () => rest.computeLiveStats(),
+			now: () => Date.now()
 		});
-	}, [
-		appUrl,
-		sessionToken,
-		agent.id
-	]);
+	}, [rest]);
 	const conversationContext = useMemo(() => ({
 		rest,
 		conversationId,

package/dist/js/chunk-BbwQpWto.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require as n, __toESM as r, __commonJSMin as t };