skydive-cli 0.1.0-beta.382 → 0.1.0-beta.389

package/dist/js/{boot-B48ty_OV.mjs → boot-CMhIv1BG.mjs}

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
-import { A as HttpError, B as getSavedTheme, C as noColorRequested, D as themeModeFromColorFgBg, E as themeMode, F as setActiveWorkspace, H as saveTheme, I as DEFAULT_API_URL, L as DEFAULT_APP_URL, M as errorDetail, N as getActiveWorkspaceId, O as themeVersion, P as listWorkspaces, R as getConfigPath, S as monoTheme, T as themeForMode, V as resolveWebUrl, _ as errorMessage, b as applyTheme, d as cardActionErrorMessage, f as parseExternalOauthConnectParams, g as parseConnectCard, h as resolveConnectUrl, j as createRestClient, k as themesForMode, l as resolveAgent, m as reconcileMaskedInput, p as parseOauthConnectParams, t as SandboxStream, u as MASK_CHAR, v as isRecord, w as theme, x as findTheme, y as DEFAULT_THEME_ID, z as getReviewStateDir } from "./bin.mjs";
-import { t as PortalClient } from "./client-XFsd0Wy9.mjs";
-import { n as runRawPtyPassthrough } from "./raw-pty-C1DXKms6.mjs";
+import { D as getReviewStateDir, I as resolveWebUrl, O as getSavedTheme, S as DEFAULT_APP_URL, T as getConfigPath, _ as setActiveWorkspace, a as noColorRequested, c as themeMode, f as themesForMode, g as listWorkspaces, i as monoTheme, l as themeModeFromColorFgBg, m as getActiveWorkspaceId, n as applyTheme, o as theme, r as findTheme, s as themeForMode, t as DEFAULT_THEME_ID, u as themeVersion, x as DEFAULT_API_URL, z as saveTheme } from "./theme-DRuLtrTy.mjs";
+import { n as createRestClient, r as errorDetail, t as HttpError } from "./rest-DTlkPko_.mjs";
+import { n as isRecord, t as errorMessage } from "./util-z9Pne47f.mjs";
+import { c as cardActionErrorMessage, d as reconcileMaskedInput, f as resolveConnectUrl, i as resolveAgent, l as parseExternalOauthConnectParams, p as parseConnectCard, s as MASK_CHAR, u as parseOauthConnectParams } from "./print-BhfjRrxI.mjs";
+import "./api-DRpbKHz6.mjs";
+import { t as SandboxStream } from "./client-BVOAwU8M.mjs";
+import { t as PortalClient } from "./client-DyRs3o5E.mjs";
+import { t as runRawPtyPassthrough } from "./raw-pty-Dbi2kb9v.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";

package/dist/js/client-BVOAwU8M.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { WebSocket } from "ws";
+
+//#region ../sandbox-stream-protocol/src/index.ts
+const SANDBOX_STREAM_PATH = "/api/v1/sandbox/stream";
+const FRAME = {
+	DATA: 1,
+	EXIT: 2,
+	ERROR: 3,
+	INPUT: 16,
+	RESIZE: 17
+};
+const MAX_INPUT_BYTES = 1 * 1024 * 1024;
+/** Query params for the upgrade URL, from a spec. Inverse of {@link parseStreamSpec}. */
+function streamSpecToQuery(spec) {
+	if (spec.mode === "pty") return {
+		agentId: spec.agentId,
+		mode: "pty",
+		cols: String(spec.cols),
+		rows: String(spec.rows)
+	};
+	return {
+		agentId: spec.agentId,
+		mode: "exec",
+		command: spec.command
+	};
+}
+function withType(type, payload) {
+	const frame = new Uint8Array(1 + payload.length);
+	frame[0] = type;
+	frame.set(payload, 1);
+	return frame;
+}
+/** client → server: keystroke bytes for the pty stdin. */
+function encodeInput(data) {
+	return withType(FRAME.INPUT, data);
+}
+/** client → server: the client terminal was resized. */
+function encodeResize(cols, rows) {
+	const frame = new Uint8Array(5);
+	frame[0] = FRAME.RESIZE;
+	const view = new DataView(frame.buffer);
+	view.setUint16(1, cols & 65535);
+	view.setUint16(3, rows & 65535);
+	return frame;
+}
+const view = (frame) => new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+/**
+* Decode a frame the server sent. Returns null for an empty, unknown, or
+* truncated frame — a peer speaking a newer protocol must not crash us.
+*/
+function decodeServerFrame(frame) {
+	const payload = frame.subarray(1);
+	switch (frame[0]) {
+		case FRAME.DATA: return {
+			type: "data",
+			payload
+		};
+		case FRAME.EXIT: return {
+			type: "exit",
+			code: payload.length >= 4 ? view(frame).getInt32(1) : 0
+		};
+		case FRAME.ERROR: return {
+			type: "error",
+			message: new TextDecoder().decode(payload)
+		};
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/chat/sandbox/client.ts
+function wsBase(appUrl) {
+	const base = appUrl.replace(/\/+$/, "");
+	if (base.startsWith("https://")) return `wss://${base.slice(8)}`;
+	if (base.startsWith("http://")) return `ws://${base.slice(7)}`;
+	return `wss://${base}`;
+}
+/**
+* A connected sandbox-stream session. Construct via `openSandboxStream`. Carries
+* the write side (keystrokes / resize for pty mode) and teardown.
+*/
+var SandboxStream = class SandboxStream {
+	ws;
+	closed = false;
+	constructor(ws, onEvent) {
+		this.ws = ws;
+		let ended = false;
+		const emitEnd = (event) => {
+			if (ended) return;
+			ended = true;
+			onEvent(event);
+		};
+		ws.on("message", (data, isBinary) => {
+			if (!isBinary) return;
+			const frame = decodeServerFrame(toBuffer(data));
+			if (!frame) return;
+			switch (frame.type) {
+				case "data":
+					onEvent({
+						type: "data",
+						bytes: new Uint8Array(frame.payload)
+					});
+					break;
+				case "exit":
+					emitEnd({
+						type: "exit",
+						code: frame.code
+					});
+					break;
+				case "error":
+					emitEnd({
+						type: "error",
+						message: frame.message
+					});
+					break;
+			}
+		});
+		let failure = null;
+		ws.on("error", (err) => {
+			failure = err.message;
+		});
+		ws.on("close", () => {
+			this.closed = true;
+			emitEnd({
+				type: "close",
+				failure
+			});
+		});
+	}
+	/** Feed keystroke bytes to the pty stdin. */
+	sendInput(data) {
+		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
+		this.ws.send(encodeInput(data));
+	}
+	/** Notify the pty of a terminal resize. */
+	resize(cols, rows) {
+		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
+		this.ws.send(encodeResize(cols, rows));
+	}
+	close() {
+		this.closed = true;
+		this.ws.close();
+	}
+	/** Open a stream. `mode` is 'pty' (interactive) or 'exec' (one-shot). */
+	static open(opts) {
+		const spec = opts.mode === "pty" ? {
+			mode: "pty",
+			agentId: opts.agentId,
+			cols: opts.cols,
+			rows: opts.rows
+		} : {
+			mode: "exec",
+			agentId: opts.agentId,
+			command: opts.command
+		};
+		const url = new URL(`${wsBase(opts.appUrl)}${SANDBOX_STREAM_PATH}`);
+		for (const [key, value] of Object.entries(streamSpecToQuery(spec))) url.searchParams.set(key, value);
+		return new SandboxStream(new WebSocket(url.toString(), { headers: { authorization: `Bearer ${opts.sessionToken}` } }), opts.onEvent);
+	}
+};
+function toBuffer(data) {
+	if (Buffer.isBuffer(data)) return data;
+	if (Array.isArray(data)) return Buffer.concat(data);
+	return Buffer.from(data);
+}
+
+//#endregion
+export { SandboxStream as t };

package/dist/js/client-C-s6b9Yu.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./rest-DTlkPko_.mjs";
+import "./api-DRpbKHz6.mjs";
+import { t as PortalClient } from "./client-DyRs3o5E.mjs";
+
+export { PortalClient };

package/dist/js/{client-XFsd0Wy9.mjs → client-DyRs3o5E.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { t as __exportAll } from "./rolldown-runtime-Cz4Tg37Z.mjs";
-import { _ as errorMessage, a as mintPortalDeviceToken, c as portalWsUrl, i as grantPortalAccess, n as fetchPortalDevices, o as buildEnv, r as findThisDevice, s as machineIdentity } from "./bin.mjs";
+import { t as errorMessage } from "./util-z9Pne47f.mjs";
+import { c as machineIdentity, i as mintPortalDeviceToken, l as portalWsUrl, n as findThisDevice, r as grantPortalAccess, s as buildEnv, t as fetchPortalDevices } from "./api-DRpbKHz6.mjs";
 import { z } from "zod";
 import { spawn } from "node:child_process";
 import { WebSocket } from "ws";
@@ -196,7 +196,6 @@ var JobManager = class {
 
 //#endregion
 //#region src/chat/portal/client.ts
-var client_exports = /* @__PURE__ */ __exportAll({ PortalClient: () => PortalClient });
 const INITIAL_BACKOFF_MS = 500;
 const MAX_BACKOFF_MS = 1e4;
 /**
@@ -364,4 +363,4 @@ function sleep(ms) {
 }
 
 //#endregion
-export { client_exports as n, PortalClient as t };
+export { PortalClient as t };

package/dist/js/print-BhfjRrxI.mjs

@@ -0,0 +1,466 @@
+#!/usr/bin/env node
+import { n as createRestClient, t as HttpError } from "./rest-DTlkPko_.mjs";
+import { n as isRecord, t as errorMessage } from "./util-z9Pne47f.mjs";
+
+//#region src/chat/tui/chat/card.ts
+const urlActionKinds = [
+	"open_oauth",
+	"open_external_oauth",
+	"open_github_app",
+	"submit_credential"
+];
+function isUrlActionKind(value) {
+	return typeof value === "string" && urlActionKinds.includes(value);
+}
+function optionalString(value) {
+	return typeof value === "string" && value ? value : null;
+}
+function bindStateKey(props) {
+	const value = props.value;
+	if (!isRecord(value)) return null;
+	const pointer = value.$bindState;
+	if (typeof pointer !== "string") return null;
+	return pointer.startsWith("/") ? pointer.slice(1) : pointer;
+}
+function parseButton(element) {
+	const props = isRecord(element.props) ? element.props : {};
+	const label = optionalString(props.label) ?? "Connect";
+	const on = isRecord(element.on) ? element.on : null;
+	const press = on && isRecord(on.press) ? on.press : null;
+	if (!press) return null;
+	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;
+		return {
+			label,
+			action: {
+				kind: "grant_portal",
+				agentId,
+				deviceId: typeof params.deviceId === "string" && params.deviceId ? params.deviceId : null
+			},
+			primary
+		};
+	}
+	if (!isUrlActionKind(press.action)) return null;
+	const url = params.url;
+	if (typeof url !== "string" || !url) return null;
+	return {
+		label,
+		action: {
+			kind: press.action,
+			url
+		},
+		primary
+	};
+}
+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;
+	const rootProps = isRecord(rootEl.props) ? rootEl.props : {};
+	const title = optionalString(rootProps.title);
+	if (!title) return null;
+	const fields = [];
+	const buttons = [];
+	const children = Array.isArray(rootEl.children) ? rootEl.children : [];
+	for (const childId of children) {
+		if (typeof childId !== "string") continue;
+		const el = elements[childId];
+		if (!isRecord(el)) continue;
+		if (el.type === "TextInput" || el.type === "SecretInput") {
+			const props = isRecord(el.props) ? el.props : {};
+			const key = bindStateKey(props);
+			if (!key) continue;
+			fields.push({
+				key,
+				label: optionalString(props.label) ?? key,
+				placeholder: optionalString(props.placeholder),
+				secret: el.type === "SecretInput"
+			});
+			continue;
+		}
+		if (el.type === "Button") {
+			const button = parseButton(el);
+			if (button) buttons.push(button);
+		}
+	}
+	const preferred = buttons.find((b) => b.primary) ?? buttons[0] ?? null;
+	return {
+		title,
+		subtitle: optionalString(rootProps.subtitle),
+		description: optionalString(rootProps.description),
+		fields,
+		button: preferred ? {
+			label: preferred.label,
+			action: preferred.action
+		} : null,
+		state: isRecord(spec.state) ? spec.state : {}
+	};
+}
+
+//#endregion
+//#region src/chat/tui/chat/card-actions.ts
+function safeUrl(url) {
+	try {
+		return new URL(url, "http://localhost");
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Resolve a connect URL to an absolute one the OS can open in a browser.
+*
+* The server builds lazy connect links as server-relative paths (e.g.
+* `/api/v1/oauth/start/slack?connect_session_token=...`). The web client
+* resolves these against its own origin implicitly; the TUI runs outside a
+* browser, so `open()` on a scheme-less path is a silent no-op — the browser
+* never launches and the connect card sits in `launched` forever (the Slack
+* channel-connect deadlock). Resolve against `appUrl` first, mirroring the
+* `open_github_app` / `fulfillCredential` branches, so both the browser we
+* launch and the URL shown on the card are absolute. An already-absolute URL
+* passes through unchanged; if `appUrl` is missing we return the input as-is.
+*/
+function resolveConnectUrl(url, appUrl) {
+	if (!appUrl) return url;
+	try {
+		return new URL(url, appUrl).toString();
+	} catch (_error) {
+		return url;
+	}
+}
+function parseOauthConnectParams(url) {
+	const parsed = safeUrl(url);
+	if (!parsed) return null;
+	const integrationKey = parsed.searchParams.get("integration");
+	const agentId = parsed.searchParams.get("agent_id");
+	const authConfigId = parsed.searchParams.get("auth_config_id");
+	const conversationId = parsed.searchParams.get("conversation_id");
+	if (!integrationKey || !agentId || !authConfigId || !conversationId) return null;
+	return {
+		integrationKey,
+		agentId,
+		authConfigId,
+		conversationId,
+		scopes: parsed.searchParams.get("scopes")
+	};
+}
+function parseExternalOauthConnectParams(url) {
+	const parsed = safeUrl(url);
+	if (!parsed) return null;
+	const agentId = parsed.searchParams.get("agent_id");
+	const conversationId = parsed.searchParams.get("conversation_id");
+	const serverUrl = parsed.searchParams.get("server_url");
+	if (!agentId || !conversationId || !serverUrl) return null;
+	return {
+		agentId,
+		conversationId,
+		serverUrl
+	};
+}
+/**
+* A short human line for a failed card action. Fulfill/connect endpoints
+* return `{ error: string }` bodies (e.g. "already fulfilled") — prefer that
+* over the generic HttpError message.
+*/
+function cardActionErrorMessage(err) {
+	if (err instanceof HttpError) {
+		try {
+			const parsed = JSON.parse(err.body);
+			if (isRecord(parsed) && typeof parsed.error === "string") return parsed.error;
+		} catch (_error) {}
+		return `request failed (HTTP ${err.status})`;
+	}
+	return errorMessage(err);
+}
+const MASK_CHAR = "•";
+/**
+* Recover the real secret from the masked input's displayed text. The input
+* is controlled: after every edit we render bullets, which forces the cursor
+* to the end, so the next edit is always a tail edit — the displayed text is
+* some prefix of the old mask (kept characters) followed by newly typed or
+* pasted plaintext. Characters beyond the retained bullets are the new tail.
+*/
+function reconcileMaskedInput(previousValue, displayed) {
+	let kept = 0;
+	while (kept < displayed.length && kept < previousValue.length && displayed[kept] === MASK_CHAR) kept++;
+	return previousValue.slice(0, kept) + displayed.slice(kept);
+}
+
+//#endregion
+//#region src/chat/connect-cards.ts
+/**
+* Turn a parsed ConnectCard into the headless summary, resolving any relative
+* connect URL against the app origin so the emitted URL is directly openable.
+*/
+function summarizeConnectCard(card, appUrl) {
+	const base = {
+		title: card.title,
+		subtitle: card.subtitle,
+		description: card.description
+	};
+	const button = card.button;
+	if (!button) return {
+		...base,
+		action: { kind: "unsupported" }
+	};
+	const act = button.action;
+	switch (act.kind) {
+		case "open_oauth":
+		case "open_external_oauth":
+		case "open_github_app": return {
+			...base,
+			action: {
+				kind: "open_url",
+				url: resolveConnectUrl(act.url, appUrl)
+			}
+		};
+		case "submit_credential": return {
+			...base,
+			action: {
+				kind: "submit_credential",
+				url: resolveConnectUrl(act.url, appUrl),
+				fields: card.fields.map((f) => f.label)
+			}
+		};
+		case "grant_portal": return {
+			...base,
+			action: {
+				kind: "approve_portal",
+				agentId: act.agentId
+			}
+		};
+		default: return {
+			...base,
+			action: { kind: "unsupported" }
+		};
+	}
+}
+/**
+* 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).
+*/
+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;
+	return summarizeConnectCard(card, appUrl);
+}
+/** Render a connect-card summary as a human-readable action block. */
+function formatConnectCard(card) {
+	const lines = [];
+	lines.push(`\n[action needed] ${card.title}`);
+	if (card.subtitle) lines.push(card.subtitle);
+	if (card.description) lines.push(card.description);
+	switch (card.action.kind) {
+		case "open_url":
+			lines.push(`Open to continue: ${card.action.url}`);
+			break;
+		case "submit_credential":
+			lines.push(`Provide credential (${card.action.fields.join(", ") || "value"}) at: ${card.action.url}`);
+			break;
+		case "approve_portal":
+			lines.push(`Approve local-machine access for agent ${card.action.agentId} in the TUI or web app.`);
+			break;
+		case "unsupported":
+			lines.push("Open this conversation in the web app to continue.");
+			break;
+	}
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/chat/print.ts
+/**
+* Non-interactive chat, à la `claude -p`. Sends a single prompt to an
+* agent, streams the run, and prints the assistant's reply to stdout
+* before exiting. No OpenTUI, no Bun requirement — this rides the same
+* Node-friendly REST client the TUI uses, so it runs anywhere the
+* management commands do (CI, pipes, scripts).
+*
+* Resolution rules kept deliberately strict because there's no human to
+* 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 }) {
+	const client = createRestClient({
+		appUrl,
+		sessionToken
+	});
+	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)) 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}\`.`);
+	}
+	let send;
+	try {
+		send = await client.sendMessage({
+			agentId: agent.id,
+			conversationId,
+			content: prompt,
+			attachmentIds: [],
+			clientSurface: "cli"
+		});
+	} catch (err) {
+		throw toPrintError(err);
+	}
+	const { text, connectCards } = await collectRunText({
+		client,
+		appUrl,
+		target: {
+			kind: "run",
+			id: send.runId
+		},
+		onText: json ? null : (delta) => process.stdout.write(delta),
+		messageIdForHint: send.messageId ?? null
+	});
+	if (!json && text && !text.endsWith("\n")) process.stdout.write("\n");
+	if (!json) for (const card of connectCards) process.stdout.write(`${formatConnectCard(card)}\n`);
+	return {
+		agentId: agent.id,
+		agentName: agent.name,
+		conversationId: send.conversationId,
+		isNewConversation: send.isNewConversation,
+		messageId: send.messageId ?? null,
+		text,
+		connectCards
+	};
+}
+/**
+* Turn a transport failure into an actionable CLI error. A Cloudflare edge
+* 5xx (502/504) on a long run otherwise leaks a raw HTML/JSON error page to
+* stdout, which is impossible to act on. When a messageId is known and
+* recoverable we point the user at `skydive messages get <messageId>` rather
+* than a blind retry (a retry re-executes an agent that may have write access).
+*/
+function toPrintError(err, messageId) {
+	if (err instanceof HttpError && err.status >= 500) {
+		const recovery = messageId ? ` The run may still be completing server-side. Do NOT blindly retry (it would re-run the agent). Fetch the result with: skydive messages get ${messageId}` : "";
+		return /* @__PURE__ */ new Error(`The request to Skydive timed out at the edge (HTTP ${err.status}).${recovery}`);
+	}
+	return err instanceof Error ? err : new Error(String(err));
+}
+/**
+* Stream a run to completion, folding text-delta chunks into the reply and
+* collecting any connect cards (OAuth / MCP / credential requests) the run
+* posts. Shared by `chat -p` (streaming the run it just created) and `messages
+* get` (re-attaching by message id — the server replays a finished run from its
+* persisted log, so this works whether the run is live or already done).
+*/
+async function collectRunText({ client, appUrl, target, onText, messageIdForHint }) {
+	let text = "";
+	const controller = new AbortController();
+	let streamError = null;
+	const connectCards = [];
+	const onEvent = (event) => {
+		if (event.kind === "finished") {
+			if (event.error) streamError = event.error;
+			return;
+		}
+		const chunk = event.chunk;
+		if (chunk["type"] === "text-delta") {
+			const delta = typeof chunk["delta"] === "string" ? chunk["delta"] : typeof chunk["text"] === "string" ? chunk["text"] : "";
+			if (delta) {
+				text += delta;
+				if (onText) onText(delta);
+			}
+		} else if (chunk["type"] === "error") streamError = typeof chunk["errorText"] === "string" ? chunk["errorText"] : "unknown error";
+		else {
+			const card = connectCardFromChunk(chunk, appUrl);
+			if (card) connectCards.push(card);
+		}
+	};
+	try {
+		if (target.kind === "message") await client.streamMessage({
+			messageId: target.id,
+			signal: controller.signal,
+			onEvent
+		});
+		else await client.streamRun({
+			runId: target.id,
+			signal: controller.signal,
+			onEvent
+		});
+	} catch (err) {
+		throw toPrintError(err, messageIdForHint);
+	}
+	if (streamError) throw new Error(streamError);
+	return {
+		text,
+		connectCards
+	};
+}
+/**
+* Re-attach to an exchange by message id and print its reply. Backs `skydive
+* messages get <messageId>` — the recovery path when a `chat -p` stream dropped
+* at the edge after the message was accepted. The server resolves the run
+* behind the message and replays it from its persisted event log, so this
+* returns the full reply whether the run is still live or already done.
+*/
+async function messageGet({ appUrl, sessionToken, messageId, json }) {
+	const { text, connectCards } = await collectRunText({
+		client: createRestClient({
+			appUrl,
+			sessionToken
+		}),
+		appUrl,
+		target: {
+			kind: "message",
+			id: messageId
+		},
+		onText: json ? null : (delta) => process.stdout.write(delta),
+		messageIdForHint: null
+	});
+	if (!json && text && !text.endsWith("\n")) process.stdout.write("\n");
+	if (!json) for (const card of connectCards) process.stdout.write(`${formatConnectCard(card)}\n`);
+	return {
+		messageId,
+		text,
+		connectCards
+	};
+}
+/**
+* Pick the target agent. With no selector, auto-pick only when the
+* account has exactly one agent; otherwise the user must name one (there's
+* no picker in non-interactive mode). A selector matches by id first, then
+* a unique case-insensitive slug/name; ambiguous or missing matches throw
+* with the candidate list so the caller knows what to pass.
+*/
+function resolveAgent(agents, selector) {
+	if (!selector) {
+		const [only, ...rest] = agents;
+		if (!only) throw new Error("No agents on this account.");
+		if (rest.length === 0) return only;
+		throw new Error(`Multiple agents on this account — pass --agent <id|slug|name>. Candidates:\n${formatCandidates(agents)}`);
+	}
+	const byId = agents.find((a) => a.id === selector);
+	if (byId) return byId;
+	const needle = selector.toLowerCase();
+	const matches = agents.filter((a) => a.slug && a.slug.toLowerCase() === needle || a.name.toLowerCase() === needle);
+	const [firstMatch, ...restMatches] = matches;
+	if (firstMatch && restMatches.length === 0) return firstMatch;
+	if (restMatches.length > 0) throw new Error(`Multiple agents match "${selector}" — pass the id instead. Candidates:\n${formatCandidates(matches)}`);
+	throw new Error(`No agent matches "${selector}". Candidates:\n${formatCandidates(agents)}`);
+}
+function formatCandidates(agents) {
+	return agents.slice(0, 25).map((a) => `  ${a.id}  ${a.slug ?? a.name}`).join("\n");
+}
+/** Read all of stdin as UTF-8. Used when `-p` is passed with no value. */
+async function readStdin() {
+	const chunks = [];
+	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+	return Buffer.concat(chunks).toString("utf8");
+}
+
+//#endregion
+export { runPrint as a, cardActionErrorMessage as c, reconcileMaskedInput as d, resolveConnectUrl as f, resolveAgent as i, parseExternalOauthConnectParams as l, messageGet as n, toPrintError as o, parseConnectCard as p, readStdin as r, MASK_CHAR as s, collectRunText as t, parseOauthConnectParams as u };

package/dist/js/print-DFPzQQk8.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./rest-DTlkPko_.mjs";
+import { a as runPrint, i as resolveAgent, n as messageGet, o as toPrintError, r as readStdin, t as collectRunText } from "./print-BhfjRrxI.mjs";
+
+export { messageGet, readStdin, resolveAgent, runPrint };