skydive-cli 0.5.0-beta.3 → 0.5.0-beta.31

package/dist/js/{daemon-client-Bewt98dE.mjs → daemon-client--A_yMKq6.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as LOCAL_PROTOCOL_VERSION, d as encodeLine, f as makeLineParser, n as ensureDaemonRunning, p as parseDaemonMessage, u as daemonPaths } from "./daemon-Bq93vOIk.mjs";
+import { c as LOCAL_PROTOCOL_VERSION, d as encodeLine, f as makeLineParser, n as ensureDaemonRunning, p as parseDaemonMessage, u as daemonPaths } from "./daemon-BTyg329O.mjs";
 import { randomUUID } from "node:crypto";
 import { connect } from "node:net";
 
@@ -12,7 +12,7 @@ var PortalDaemonClient = class {
 	lastBind = null;
 	fallbackCwd = null;
 	wantEnabled = false;
-	pendingGrants = /* @__PURE__ */ new Set();
+	pendingGrants = /* @__PURE__ */ new Map();
 	pendingDeclines = /* @__PURE__ */ new Map();
 	grantedAgentIds = /* @__PURE__ */ new Set();
 	constructor(opts) {
@@ -50,9 +50,10 @@ var PortalDaemonClient = class {
 				conversationId: this.lastBind.conversationId,
 				cwd: this.lastBind.cwd
 			});
-			for (const agentId of this.pendingGrants) this.send({
+			for (const [agentId, conversationId] of this.pendingGrants) this.send({
 				t: "grant",
-				agentId
+				agentId,
+				conversationId
 			});
 			for (const [agentId, declined] of this.pendingDeclines) this.send({
 				t: "decline",
@@ -157,13 +158,16 @@ var PortalDaemonClient = class {
 	* Authorize one agent to run commands on this machine. Resolves once the
 	* request is sent to the daemon (the daemon performs the grant and pushes the
 	* updated state); kept async so it's a drop-in for the old in-process client's
-	* awaited `grantAgent`.
+	* awaited `grantAgent`. `conversationId` names the conversation whose run
+	* asked, so the grant can wake the waiting agent; null when the grant is not
+	* answering an in-chat request.
 	*/
-	grantAgent(agentId) {
-		this.pendingGrants.add(agentId);
+	grantAgent(agentId, conversationId) {
+		this.pendingGrants.set(agentId, conversationId);
 		this.send({
 			t: "grant",
-			agentId
+			agentId,
+			conversationId
 		});
 		return Promise.resolve();
 	}

package/dist/js/daemon-client-C7emKKlj.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import "./client-DbqRBquD.mjs";
+import "./daemon-BTyg329O.mjs";
+import "./api-DG5W6iwx.mjs";
+import { t as PortalDaemonClient } from "./daemon-client--A_yMKq6.mjs";
+
+export { PortalDaemonClient };

package/dist/js/forward-DL6DYqyc.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+import { t as fetchForwardTarget } from "./api-DG5W6iwx.mjs";
+import net from "node:net";
+import { WebSocket, createWebSocketStream } from "ws";
+
+//#region src/chat/portal/tunnel-pool.ts
+const MAX_AGE_MS = 4e4;
+const SWEEP_INTERVAL_MS = 1e4;
+const REFILL_BACKOFF_MS = 15e3;
+/**
+* Pre-warmed tunnel pool for the forward portal's accept path.
+*
+* Dialing a tunnel costs a full edge round-trip (~300ms measured). The pool
+* pays that in the background so accept can adopt a warm tunnel and move the
+* first byte immediately. Target starts at `initialSize` and grows by one on
+* each miss, never above `maxSize` — a miss still cold-dials (today's path);
+* growth only helps the next wave. No decay: a runaway client can hold
+* `maxSize` idle edge sockets until `forward` exits.
+*
+* `dial` must resolve with a stream that is already paused, so any bytes a
+* server-first protocol sends before adoption buffer instead of dropping.
+*/
+function createTunnelPool({ initialSize, maxSize, dial, log }) {
+	let entries = [];
+	let dialsInFlight = 0;
+	let backoffUntil = 0;
+	let closed = false;
+	let targetSize = initialSize;
+	function refill() {
+		if (closed) return;
+		if (Date.now() < backoffUntil) return;
+		while (entries.length + dialsInFlight < targetSize) {
+			dialsInFlight += 1;
+			dial().then((tunnel) => {
+				dialsInFlight -= 1;
+				if (closed) {
+					tunnel.close();
+					return;
+				}
+				const entry = {
+					tunnel,
+					dialedAt: Date.now(),
+					dead: false
+				};
+				tunnel.stream.once("close", () => {
+					entry.dead = true;
+				});
+				tunnel.stream.once("error", () => {
+					entry.dead = true;
+				});
+				entries.push(entry);
+			}).catch((err) => {
+				dialsInFlight -= 1;
+				backoffUntil = Date.now() + REFILL_BACKOFF_MS;
+				log(`forward: pool dial failed (backing off): ${err instanceof Error ? err.message : String(err)}`);
+			});
+		}
+	}
+	function sweep() {
+		const now = Date.now();
+		const keep = [];
+		for (const entry of entries) if (entry.dead || now - entry.dialedAt > MAX_AGE_MS) entry.tunnel.close();
+		else keep.push(entry);
+		entries = keep;
+		refill();
+	}
+	const sweeper = setInterval(sweep, SWEEP_INTERVAL_MS);
+	sweeper.unref();
+	refill();
+	return {
+		take: () => {
+			while (entries.length > 0) {
+				const entry = entries.pop();
+				if (!entry) break;
+				if (entry.dead || entry.tunnel.stream.destroyed) continue;
+				refill();
+				return entry.tunnel;
+			}
+			if (targetSize < maxSize) targetSize += 1;
+			refill();
+			return null;
+		},
+		close: () => {
+			closed = true;
+			clearInterval(sweeper);
+			for (const entry of entries) entry.tunnel.close();
+			entries = [];
+		}
+	};
+}
+
+//#endregion
+//#region src/chat/portal/forward.ts
+const TARGET_REFRESH_SAFETY_MS = 12e4;
+const INITIAL_POOL_SIZE = 8;
+const MAX_POOL_SIZE = 16;
+/**
+* The reverse portal's client half: listen on the local machine's loopback and
+* pipe each TCP connection to the agent sandbox's daemon (`/portal/tcp`),
+* which pipes to the sandbox's own loopback. The daemon is reached through the
+* agent-webserver edge Worker (sandboxes have public ingress disabled; the
+* Worker owns boot-resolution and injects the sandbox edge-auth token), so a
+* sandbox recycle just costs the next connection a cold-start wait rather
+* than invalidating the forward.
+*/
+async function startForward({ auth, agentId, localPort, targetPort, log }) {
+	let target = await fetchForwardTarget(auth, agentId);
+	let mintedAt = Date.now();
+	async function freshTarget() {
+		const ttlMs = target.expiresInSeconds * 1e3;
+		if (Date.now() - mintedAt > ttlMs - TARGET_REFRESH_SAFETY_MS) {
+			target = await fetchForwardTarget(auth, agentId);
+			mintedAt = Date.now();
+		}
+		return target;
+	}
+	/**
+	* Dial one tunnel through the edge to the daemon's /portal/tcp. Resolves
+	* once the upgrade completes, with the duplex PAUSED — the pool holds it
+	* warm without dropping any early bytes, and adoption resumes it by piping.
+	*/
+	async function dialTunnel() {
+		const resolved = await freshTarget();
+		const ws = new WebSocket(`${resolved.daemonOrigin.replace(/^http/, "ws")}/portal/tcp?port=${targetPort}`, { headers: { authorization: `Bearer ${resolved.token}` } });
+		return new Promise((resolve, reject) => {
+			ws.once("error", reject);
+			ws.once("open", () => {
+				ws.removeListener("error", reject);
+				const stream = createWebSocketStream(ws);
+				stream.pause();
+				resolve({
+					stream,
+					close: () => stream.destroy()
+				});
+			});
+		});
+	}
+	const pool = createTunnelPool({
+		initialSize: INITIAL_POOL_SIZE,
+		maxSize: MAX_POOL_SIZE,
+		dial: dialTunnel,
+		log
+	});
+	const server = net.createServer((sock) => {
+		sock.pause();
+		const warm = pool.take();
+		if (warm) {
+			warm.stream.on("error", () => sock.destroy());
+			sock.on("error", () => warm.stream.destroy());
+			sock.pipe(warm.stream).pipe(sock);
+			sock.resume();
+			return;
+		}
+		(async () => {
+			let tunnel;
+			try {
+				tunnel = await dialTunnel();
+			} catch (err) {
+				log(`forward: tunnel connect failed: ${err instanceof Error ? err.message : String(err)}`);
+				sock.destroy();
+				return;
+			}
+			tunnel.stream.on("error", () => sock.destroy());
+			sock.on("error", () => tunnel.stream.destroy());
+			sock.pipe(tunnel.stream).pipe(sock);
+			sock.resume();
+		})();
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(localPort, "127.0.0.1", () => {
+			server.removeListener("error", reject);
+			resolve();
+		});
+	});
+	const addr = server.address();
+	return {
+		port: addr && typeof addr === "object" ? addr.port : localPort,
+		close: () => new Promise((resolve) => {
+			pool.close();
+			server.close(() => resolve());
+		})
+	};
+}
+
+//#endregion
+export { startForward };

package/dist/js/{print-CbayCa87.mjs → print-C_TnQSPg.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as HttpError } from "./http-error-DzyrsLAZ.mjs";
-import { a as isRecord, i as errorMessage, r as sendErrorMessage, t as createRestClient } from "./rest-BY2nADw5.mjs";
+import { a as isRecord, i as errorMessage, r as sendErrorMessage, t as createRestClient } from "./rest-CgfbKXst.mjs";
 import { i as billingBlockedOutcomeFromSendResponse, n as BillingBlockedError } from "./billing-blocked-2wju4gC_.mjs";
 import path from "node:path";
 import Conf from "conf";
@@ -9,7 +9,7 @@ import stableStringify from "safe-stable-stringify";
 
 //#region src/config.ts
 /** Default host for the public management API (`/v1`, API-key auth). */
-const DEFAULT_API_URL = "https://api.skydive.com";
+const DEFAULT_API_URL = typeof SKYDIVE_BUILD_API_URL === "string" ? SKYDIVE_BUILD_API_URL : "https://api.skydive.com";
 /**
 * Default origin for the interactive chat client (`skydive chat`).
 *
@@ -20,9 +20,9 @@ const DEFAULT_API_URL = "https://api.skydive.com";
 * `DEFAULT_API_URL`; override with `--api-url` / `SKYDIVE_APP_URL` for local
 * dev or while the DNS record is still being provisioned.
 */
-const DEFAULT_APP_URL = "https://api.skydive.com";
+const DEFAULT_APP_URL = DEFAULT_API_URL;
 /** Web front door, for pages opened in the user's browser. */
-const DEFAULT_WEB_URL = "https://skydive.com";
+const DEFAULT_WEB_URL = typeof SKYDIVE_BUILD_WEB_URL === "string" ? SKYDIVE_BUILD_WEB_URL : "https://skydive.com";
 function resolveWebUrl(appUrl) {
 	if (appUrl == null) return appUrl;
 	return appUrl === DEFAULT_APP_URL ? DEFAULT_WEB_URL : appUrl;
@@ -213,6 +213,32 @@ function saveUpdateCheck(value) {
 	}
 	store.set("updateCheck", value);
 }
+/**
+* Agent a bare `skydive chat` (no --agent/--resume) opens a new conversation
+* with. Any selector `--agent` accepts works: an id, or a unique
+* case-insensitive slug/name, resolved against the active workspace's roster
+* at launch. Null when unset (the launch falls back to the agent picker).
+* A hand-edited blank value counts as unset rather than as a selector no
+* agent could ever match.
+*/
+function getDefaultAgent() {
+	const value = store.get("defaultAgent")?.trim();
+	return value ? value : null;
+}
+function saveDefaultAgent(value) {
+	store.set("defaultAgent", value);
+}
+/**
+* Remember the agent the chat TUI just opened a conversation with, so the
+* next bare `skydive chat` returns to it (last used wins). Records the id —
+* stable across renames, unlike a slug/name selector. Skips the write when
+* the value already matches: this runs on every chat-screen entry, and an
+* unchanged default shouldn't rewrite config.json.
+*/
+function recordDefaultAgent(agentId) {
+	if (getDefaultAgent() === agentId) return;
+	store.set("defaultAgent", agentId);
+}
 function parseBoolean(raw) {
 	const v = raw.trim().toLowerCase();
 	if ([
@@ -229,25 +255,40 @@ function parseBoolean(raw) {
 	].includes(v)) return ok(false);
 	return err(`Expected a boolean (true/false), got "${raw}".`);
 }
-const PREFERENCES = [{
-	key: "shareMachineDefault",
-	type: "boolean",
-	describe: "Share this machine over the portal on `skydive chat` launch, as if --share-machine were passed. Default false.",
-	read: () => getShareMachineDefault(),
-	isSet: () => store.has("shareMachineDefault"),
-	parse: parseBoolean,
-	write: (value) => saveShareMachineDefault(value),
-	clear: () => store.delete("shareMachineDefault")
-}, {
-	key: "updateCheck",
-	type: "boolean",
-	describe: "Run the daily background update check and its \"Update available\" notice. Set false to disable. Default true.",
-	read: () => !getUpdateCheckDisabled(),
-	isSet: () => store.has("updateCheck"),
-	parse: parseBoolean,
-	write: (value) => saveUpdateCheck(value),
-	clear: () => store.delete("updateCheck")
-}];
+const PREFERENCES = [
+	{
+		key: "shareMachineDefault",
+		type: "boolean",
+		describe: "Share this machine over the portal on `skydive chat` launch, as if --share-machine were passed. Default false.",
+		read: () => getShareMachineDefault(),
+		isSet: () => store.has("shareMachineDefault"),
+		set: (raw) => parseBoolean(raw).map(saveShareMachineDefault),
+		clear: () => store.delete("shareMachineDefault")
+	},
+	{
+		key: "updateCheck",
+		type: "boolean",
+		describe: "Run the daily background update check and its \"Update available\" notice. Set false to disable. Default true.",
+		read: () => !getUpdateCheckDisabled(),
+		isSet: () => store.has("updateCheck"),
+		set: (raw) => parseBoolean(raw).map(saveUpdateCheck),
+		clear: () => store.delete("updateCheck")
+	},
+	{
+		key: "defaultAgent",
+		type: "string",
+		describe: "Agent (id, slug, or name) a bare `skydive chat` opens a new conversation with, skipping the agent picker. Unset by default.",
+		read: () => getDefaultAgent(),
+		isSet: () => getDefaultAgent() !== null,
+		set: (raw) => {
+			const value = raw.trim();
+			if (!value) return err("Expected an agent id, slug, or name (use `config unset defaultAgent` to clear it).");
+			saveDefaultAgent(value);
+			return ok(void 0);
+		},
+		clear: () => store.delete("defaultAgent")
+	}
+];
 function getPreference(key) {
 	return PREFERENCES.find((p) => p.key === key);
 }
@@ -282,14 +323,15 @@ function parseButton(element) {
 	const params = isRecord(press.params) ? press.params : {};
 	const primary = props.variant === "primary";
 	if (press.action === "approve_portal_access") {
-		const agentId = params.agentId;
-		if (typeof agentId !== "string" || !agentId) return null;
+		const agentId = optionalString(params.agentId);
+		if (!agentId) return null;
 		return {
 			label,
 			action: {
 				kind: "grant_portal",
 				agentId,
-				deviceId: typeof params.deviceId === "string" && params.deviceId ? params.deviceId : null
+				deviceId: optionalString(params.deviceId),
+				conversationId: optionalString(params.conversationId)
 			},
 			primary
 		};
@@ -323,12 +365,131 @@ function parseButton(element) {
 function specKeyFor(spec) {
 	return stableStringify(spec) ?? crypto.randomUUID();
 }
+const COMPUTE_TIER_NAMES = {
+	small: "Lite",
+	large: "Standard",
+	xlarge: "Pro",
+	xxlarge: "Max",
+	xxxlarge: "Ultra"
+};
+function computeTierLabel(tier, memoryGb) {
+	const name = typeof tier === "string" ? COMPUTE_TIER_NAMES[tier] ?? null : null;
+	const memory = Number(memoryGb);
+	const memoryLabel = Number.isFinite(memory) && memory > 0 ? `${Math.round(memory)} GB` : null;
+	if (name && memoryLabel) return `${name} (${memoryLabel})`;
+	if (name) return name;
+	if (memoryLabel) return memoryLabel;
+	return typeof tier === "string" && tier ? tier : "unknown tier";
+}
+/**
+* The card line for a settled decision, shared by the spec parser (a settled
+* re-emission) and the chat screen (the decision POST's response, which on
+* `alreadyDecided` reports whatever decision actually stuck). Wording follows
+* the web card's chips (Upgraded / Kept current / Withdrawn).
+*/
+/**
+* The full status domain the api emits on a compute request. Anything else —
+* missing, or a value this CLI predates — returns null so the caller can
+* refuse it instead of guessing at unknown semantics.
+*/
+function parseComputeRequestStatus(value) {
+	switch (value) {
+		case "pending":
+		case "approved":
+		case "denied":
+		case "cancelled": return value;
+		default: return null;
+	}
+}
+function computeSettledLabel(status) {
+	switch (status) {
+		case "approved": return "upgraded";
+		case "denied": return "kept the current tier";
+		case "cancelled": return "withdrawn";
+		default: return null;
+	}
+}
+/**
+* The `platform portal request` consent card. The server emits one
+* DesktopHandoffCard spec for every surface (api routes/portal.ts): the web
+* renders it as the "continue in the Skydive desktop app" handoff, but this
+* terminal's own portal daemon can provide the machine, so here it maps onto
+* the existing grant_portal approval instead of a pointer to the app. Without
+* this the spec is not a Card, parses to null, and the request is silently
+* dropped — `platform portal request` looks desktop-only from the CLI
+* (ANY-6521).
+*/
+function parseDesktopHandoffCard(rootEl) {
+	const props = isRecord(rootEl.props) ? rootEl.props : {};
+	const agentId = optionalString(props.agentId);
+	if (!agentId) return null;
+	const agentName = optionalString(props.agentName) ?? "This agent";
+	return {
+		title: `Let ${agentName} use your computer?`,
+		subtitle: null,
+		description: `Approving shares this machine with ${agentName} while you're signed in. Revoke anytime: skydive portal revoke --agent "${agentName}"`,
+		fields: [],
+		button: {
+			label: "Approve",
+			action: {
+				kind: "grant_portal",
+				agentId,
+				deviceId: optionalString(props.deviceId),
+				conversationId: optionalString(props.conversationId)
+			}
+		},
+		state: {},
+		computeRequestId: null,
+		settled: null
+	};
+}
+/**
+* The `platform compute request` approval card. The web renders it as the
+* Approve/Deny "More compute requested" card; here it maps onto a
+* decide_compute button (ctrl+r opens the y/n decision prompt). Without this
+* the spec is not a Card, parses to null, and the request is silently
+* dropped — the user never sees it and the agent waits on a decision the
+* terminal can't give (ANY-6653). A settled spec (the decision route re-emits
+* the card with its final status) parses to a button-less resolved card. A
+* status this CLI doesn't know also parses to null — rendering it as pending
+* would offer a decision on a request in a state we can't represent.
+*/
+function parseComputeRequestCard(rootEl) {
+	const props = isRecord(rootEl.props) ? rootEl.props : {};
+	const requestId = optionalString(props.requestId);
+	if (!requestId) return null;
+	const status = parseComputeRequestStatus(props.status);
+	if (status === null) return null;
+	const agentName = optionalString(props.agentName) ?? "This agent";
+	const from = computeTierLabel(props.fromTier, props.fromMemoryGb);
+	const to = computeTierLabel(props.requestedTier, props.requestedMemoryGb);
+	const settled = computeSettledLabel(status);
+	return {
+		title: "More compute requested",
+		subtitle: `${agentName}: ${from} → ${to}`,
+		description: optionalString(props.reason),
+		fields: [],
+		button: settled ? null : {
+			label: "Decide",
+			action: {
+				kind: "decide_compute",
+				requestId
+			}
+		},
+		state: {},
+		computeRequestId: requestId,
+		settled
+	};
+}
 function parseConnectCard(spec) {
 	if (!isRecord(spec)) return null;
 	const { root, elements } = spec;
 	if (typeof root !== "string" || !isRecord(elements)) return null;
 	const rootEl = elements[root];
-	if (!isRecord(rootEl) || rootEl.type !== "Card") return null;
+	if (!isRecord(rootEl)) return null;
+	if (rootEl.type === "DesktopHandoffCard") return parseDesktopHandoffCard(rootEl);
+	if (rootEl.type === "ComputeRequestCard") return parseComputeRequestCard(rootEl);
+	if (rootEl.type !== "Card") return null;
 	const rootProps = isRecord(rootEl.props) ? rootEl.props : {};
 	const title = optionalString(rootProps.title);
 	if (!title) return null;
@@ -366,7 +527,9 @@ function parseConnectCard(spec) {
 			label: preferred.label,
 			action: preferred.action
 		} : null,
-		state: isRecord(spec.state) ? spec.state : {}
+		state: isRecord(spec.state) ? spec.state : {},
+		computeRequestId: null,
+		settled: null
 	};
 }
 
@@ -507,6 +670,13 @@ function summarizeConnectCard(card, appUrl) {
 				agentId: act.agentId
 			}
 		};
+		case "decide_compute": return {
+			...base,
+			action: {
+				kind: "decide_compute",
+				requestId: act.requestId
+			}
+		};
 		default: return {
 			...base,
 			action: { kind: "unsupported" }
@@ -516,14 +686,16 @@ function summarizeConnectCard(card, appUrl) {
 /**
 * Parse a `data-anyone-render-spec` stream chunk into a connect-card summary,
 * or null if the chunk isn't a connect card (other render specs — training,
-* deep-learn, compute-request — parse to null, same as the TUI).
+* deep-learn — parse to null, same as the TUI). A card that arrives already
+* settled (a compute request's decided re-emission) is an FYI, not an action,
+* so it stays out of the "[action needed]" stream too.
 */
 function connectCardFromChunk(chunk, appUrl) {
 	if (chunk["type"] !== "data-anyone-render-spec") return null;
 	const data = chunk["data"];
 	if (!isRecord(data)) return null;
 	const card = parseConnectCard(data["spec"]);
-	if (!card) return null;
+	if (!card || card.settled !== null) return null;
 	return summarizeConnectCard(card, appUrl);
 }
 /** Render a connect-card summary as a human-readable action block. */
@@ -542,6 +714,9 @@ function formatConnectCard(card) {
 		case "approve_portal":
 			lines.push(`Approve local-machine access for agent ${card.action.agentId} in the TUI or web app.`);
 			break;
+		case "decide_compute":
+			lines.push("Approve or deny this compute increase in the interactive TUI or web app.");
+			break;
 		case "unsupported":
 			lines.push("Open this conversation in the web app to continue.");
 			break;
@@ -562,17 +737,18 @@ function formatConnectCard(card) {
 * disambiguate: an `--agent` selector must match exactly one agent, and
 * when it's omitted we only auto-pick if the account has exactly one.
 */
-async function runPrint({ appUrl, sessionToken, prompt, agentSelector, conversationId, json, machineShare, grantTargetAgent }) {
+async function runPrint({ appUrl, sessionToken, workspaceId, prompt, agentSelector, conversationId, json, machineShare, grantTargetAgent }) {
 	const client = createRestClient({
 		appUrl,
-		sessionToken
+		sessionToken,
+		workspaceId
 	});
 	const agent = resolveAgent(await client.listAgents({
 		scope: "org",
 		onPage: null
 	}), agentSelector);
 	if (machineShare) {
-		if (!machineShare.isGranted(agent.id) && grantTargetAgent) await machineShare.grantAgent(agent.id);
+		if (!machineShare.isGranted(agent.id) && grantTargetAgent) await machineShare.grantAgent(agent.id, null);
 		if (machineShare.isGranted(agent.id)) console.error(`portal: shared this machine with ${agent.name} for this run (grant persists until revoked)`);
 		else console.error(`portal: this machine is shared (shareMachineDefault), but ${agent.name} has no grant. Approve its request, or run \`skydive portal grant --agent ${agent.name}\`.`);
 	}
@@ -657,7 +833,7 @@ async function collectRunText({ client, appUrl, target, onText, messageIdForHint
 	const onEvent = (event) => {
 		if (event.kind === "finished") {
 			if (event.outcome) billingBlocked = event.outcome;
-			if (event.error) streamError = event.error;
+			if (event.error && streamError === null) streamError = event.error;
 			return;
 		}
 		const chunk = event.chunk;
@@ -760,4 +936,4 @@ async function readStdin() {
 }
 
 //#endregion
-export { getStoredApiKeyWorkspaceName as A, saveTheme as B, getLastSeenVersion as C, getSavedTheme as D, getReviewStateDir as E, resolveManagementAuth as F, resolveSession as I, resolveWebUrl as L, resolveAppUrl as M, resolveChatAuth as N, getShareMachineDefault as O, resolveConfig as P, saveConfig as R, getConfigPath as S, getPromptHistoryPath as T, setLastSeenVersion as V, API_KEY_PREFIX as _, runPrint as a, PREFERENCES as b, cardActionErrorMessage as c, reconcileMaskedInput as d, resolveConnectUrl as f, API_KEY_FAMILY_PREFIX as g, API_KEYS_URL as h, resolveAgent as i, getUpdateCheckDisabled as j, getStoredApiKeyId as k, parseExternalOauthConnectParams as l, specKeyFor as m, messageGet as n, toPrintError as o, parseConnectCard as p, readStdin as r, MASK_CHAR as s, collectRunText as t, parseOauthConnectParams as u, DEFAULT_API_URL as v, getPreference as w, deleteConfig as x, DEFAULT_APP_URL as y, saveSession as z };
+export { getShareMachineDefault as A, resolveWebUrl as B, getConfigPath as C, getPromptHistoryPath as D, getPreference as E, resolveAppUrl as F, saveSession as H, resolveChatAuth as I, resolveConfig as L, getStoredApiKeyWorkspaceName as M, getUpdateCheckDisabled as N, getReviewStateDir as O, recordDefaultAgent as P, resolveManagementAuth as R, deleteConfig as S, getLastSeenVersion as T, saveTheme as U, saveConfig as V, setLastSeenVersion as W, API_KEY_FAMILY_PREFIX as _, runPrint as a, DEFAULT_APP_URL as b, cardActionErrorMessage as c, reconcileMaskedInput as d, resolveConnectUrl as f, API_KEYS_URL as g, specKeyFor as h, resolveAgent as i, getStoredApiKeyId as j, getSavedTheme as k, parseExternalOauthConnectParams as l, parseConnectCard as m, messageGet as n, toPrintError as o, computeSettledLabel as p, readStdin as r, MASK_CHAR as s, collectRunText as t, parseOauthConnectParams as u, API_KEY_PREFIX as v, getDefaultAgent as w, PREFERENCES as x, DEFAULT_API_URL as y, resolveSession as z };

package/dist/js/{print-ba_0hiV9.mjs → print-DACzRUwQ.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as runPrint, i as resolveAgent, n as messageGet, o as toPrintError, r as readStdin, t as collectRunText } from "./print-CbayCa87.mjs";
-import "./rest-BY2nADw5.mjs";
+import { a as runPrint, i as resolveAgent, n as messageGet, o as toPrintError, r as readStdin, t as collectRunText } from "./print-C_TnQSPg.mjs";
+import "./rest-CgfbKXst.mjs";
 import "./billing-blocked-2wju4gC_.mjs";
 
 export { messageGet, readStdin, resolveAgent, runPrint };

package/dist/js/{print-share-C1LPsgTP.mjs → print-share-BH9gvCls.mjs}

@@ -14,7 +14,7 @@ import { n as printError } from "./output-DYzzdXYV.mjs";
 * the reply (and to --json).
 */
 async function connectMachineShare({ appUrl, sessionToken, timeoutHint }) {
-	const { PortalClient } = await import("./client-CKBQ8pft.mjs");
+	const { PortalClient } = await import("./client-hH2PJL8y.mjs");
 	let signalConnected;
 	const connected = new Promise((resolve) => {
 		signalConnected = resolve;
@@ -26,6 +26,8 @@ async function connectMachineShare({ appUrl, sessionToken, timeoutHint }) {
 			deviceToken: null
 		}),
 		resolveCwd: () => process.cwd(),
+		persistedMachineName: null,
+		onMachineName: () => {},
 		onState: (state) => {
 			if (state.status === "connected") signalConnected();
 			if (state.status === "error") console.error(`portal: connection error: ${state.error ?? "unknown"}; retrying`);