skydive-cli 0.1.0-beta.106

package/dist/js/print-CQ8b7JUC.mjs

@@ -0,0 +1,745 @@
+#!/usr/bin/env node
+import { z } from "zod";
+import { createParser } from "eventsource-parser";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/chat/api/rest.ts
+var HttpError = class extends Error {
+	constructor(status, body) {
+		super(`HTTP ${status}: ${body.slice(0, 200)}`);
+		this.status = status;
+		this.body = body;
+		this.name = "HttpError";
+	}
+};
+const MAX_STREAM_RECONNECTS = 5;
+function createRestClient({ appUrl, sessionToken }) {
+	const baseHeaders = {
+		authorization: `Bearer ${sessionToken}`,
+		accept: "application/json"
+	};
+	async function get(path, schema) {
+		const res = await fetch(`${appUrl}${path}`, { headers: baseHeaders });
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		return schema.parse(await res.json());
+	}
+	async function post(path, body, schema, method = "POST") {
+		const res = await fetch(`${appUrl}${path}`, {
+			method,
+			headers: {
+				...baseHeaders,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify(body)
+		});
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		return schema.parse(await res.json());
+	}
+	async function del(path) {
+		const res = await fetch(`${appUrl}${path}`, {
+			method: "DELETE",
+			headers: baseHeaders
+		});
+		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+	}
+	return {
+		listAgents: async ({ scope, onPage }) => {
+			const all = [];
+			let cursor;
+			const maxAgents = 2e3;
+			do {
+				const params = new URLSearchParams({
+					limit: "100",
+					scope,
+					sort: "mine_first_usage",
+					includeStats: "false"
+				});
+				if (cursor) params.set("cursor", cursor);
+				const page = await get(`/api/v1/agents?${params.toString()}`, listAgentsResponseSchema);
+				all.push(...page.agents);
+				cursor = page.nextCursor ?? void 0;
+				onPage?.([...all]);
+			} while (cursor && all.length < maxAgents);
+			return all;
+		},
+		createAgent: async ({ name }) => {
+			const { agent } = await post("/api/v1/agents", { name }, createAgentResponseSchema);
+			return agent;
+		},
+		getConversation: async ({ conversationId }) => {
+			const { conversation } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}`, getConversationResponseSchema);
+			return conversation;
+		},
+		listModels: async () => {
+			const { models } = await get("/api/v1/models", listModelsResponseSchema);
+			return models;
+		},
+		updateAgentModel: async ({ agentId, model }) => {
+			const { agent } = await post(`/api/v1/agents/${encodeURIComponent(agentId)}`, { model }, updateAgentResponseSchema, "PATCH");
+			return { model: agent.model ?? null };
+		},
+		listConversations: async ({ agentId, limit }) => {
+			const params = new URLSearchParams({
+				agentId,
+				includeTotal: "false"
+			});
+			if (limit) params.set("limit", String(limit));
+			const { conversations } = await get(`/api/v1/conversations?${params.toString()}`, listConversationsResponseSchema);
+			return conversations;
+		},
+		listMessages: async ({ conversationId }) => {
+			const { messages } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}/messages`, listMessagesResponseSchema);
+			return messages;
+		},
+		getRecap: async ({ conversationId }) => {
+			const { recap } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}/recap`, recapResponseSchema);
+			return recap?.text ?? null;
+		},
+		uploadAttachment: async ({ agentId, fileName, mediaType, data }) => {
+			const size = data.byteLength;
+			const presign = await post("/api/v1/attachments/presign", {
+				agentId,
+				fileName,
+				mediaType,
+				size
+			}, presignResponseSchema);
+			const putRes = await fetch(presign.uploadUrl, {
+				method: "PUT",
+				headers: { "content-type": mediaType },
+				body: new Uint8Array(data)
+			});
+			if (!putRes.ok) throw new HttpError(putRes.status, await putRes.text().catch(() => ""));
+			const finalized = await post(`/api/v1/attachments/${encodeURIComponent(presign.id)}/finalize`, {
+				agentId,
+				fileName: presign.fileName,
+				mediaType: presign.mediaType,
+				size
+			}, finalizeResponseSchema);
+			return {
+				id: presign.id,
+				fileName: finalized.fileName,
+				mediaType: finalized.mediaType,
+				sizeBytes: finalized.sizeBytes ?? size
+			};
+		},
+		deleteConversation: async ({ conversationId }) => {
+			await del(`/api/v1/conversations/${encodeURIComponent(conversationId)}`);
+		},
+		sendMessage: async ({ clientSurface, ...input }) => post("/api/v1/chat/send", {
+			...input,
+			clientSurface
+		}, sendResultSchema),
+		activeRun: async ({ conversationId }) => {
+			const { run } = await get(`/api/v1/chat/active-run?${new URLSearchParams({ conversationId }).toString()}`, activeRunResponseSchema);
+			return run;
+		},
+		cancelRun: async ({ runId }) => {
+			await post(`/api/v1/chat/runs/${encodeURIComponent(runId)}/cancel`, {}, z.object({ ok: z.boolean() }));
+		},
+		cancelSteer: async ({ directiveId }) => {
+			await post(`/api/v1/chat/steer/${encodeURIComponent(directiveId)}/cancel`, {}, z.object({ ok: z.boolean() }));
+		},
+		oauthConnect: async (input) => {
+			const { connectLink } = await post("/api/v1/oauth/connect", input, oauthConnectResponseSchema);
+			return { connectLink };
+		},
+		externalOauthConnect: async (input) => {
+			const { authorizationUrl } = await post("/api/v1/external-oauth/connect", input, externalOauthConnectResponseSchema);
+			return { authorizationUrl: authorizationUrl ?? null };
+		},
+		fulfillCredential: async ({ url, body }) => {
+			const target = new URL(url, appUrl).toString();
+			const res = await fetch(target, {
+				method: "POST",
+				headers: {
+					...baseHeaders,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(body)
+			});
+			if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+		},
+		streamRun: async ({ runId, signal, onEvent }) => {
+			let lastEventId = null;
+			let finished = false;
+			let reconnects = 0;
+			for (;;) {
+				if (signal.aborted) return;
+				try {
+					const headers = {
+						authorization: `Bearer ${sessionToken}`,
+						accept: "text/event-stream"
+					};
+					if (lastEventId) headers["last-event-id"] = lastEventId;
+					const res = await fetch(`${appUrl}/api/v1/chat/runs/${encodeURIComponent(runId)}/stream`, {
+						headers,
+						signal
+					});
+					if (!res.ok || !res.body) throw new HttpError(res.status, await res.text().catch(() => ""));
+					reconnects = 0;
+					const parser = createParser({ onEvent: (message) => {
+						if (message.id) lastEventId = message.id;
+						if (message.event === "error") {
+							const { error } = streamErrorSchema.parse(JSON.parse(message.data));
+							throw new Error(error);
+						}
+						const event = runStreamEventSchema.parse(JSON.parse(message.data));
+						if (event.kind === "finished") finished = true;
+						onEvent(event.kind === "finished" ? {
+							...event,
+							error: event.error ?? null
+						} : event);
+					} });
+					const decoder = new TextDecoder();
+					const reader = res.body.getReader();
+					try {
+						for (;;) {
+							const { done, value } = await reader.read();
+							if (done) break;
+							parser.feed(decoder.decode(value, { stream: true }));
+							if (finished) return;
+						}
+					} finally {
+						try {
+							await reader.cancel();
+						} catch (_error) {}
+					}
+				} catch (err) {
+					if (signal.aborted) return;
+					if (err instanceof HttpError && err.status >= 400 && err.status < 500) throw err;
+					reconnects += 1;
+					if (reconnects > MAX_STREAM_RECONNECTS) throw err;
+					await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+					continue;
+				}
+				if (finished) return;
+				reconnects += 1;
+				if (reconnects > MAX_STREAM_RECONNECTS) throw new Error("run stream ended unexpectedly");
+				await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+			}
+		}
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const agentSummarySchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	slug: z.string().nullable().optional(),
+	title: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
+	createdAt: z.string(),
+	creatorName: z.string().nullable().optional(),
+	model: z.string().nullable().optional(),
+	modelLocked: z.boolean().optional()
+});
+const platformModelSchema = z.object({
+	id: z.string(),
+	displayName: z.string(),
+	providerDisplay: z.string().optional(),
+	reasoning: z.boolean().optional(),
+	compliant: z.boolean().optional()
+}).passthrough();
+const listModelsResponseSchema = z.object({ models: z.array(platformModelSchema) });
+const updateAgentResponseSchema = z.object({ agent: z.object({ model: z.string().nullable().optional() }).passthrough() });
+const listAgentsResponseSchema = z.object({
+	agents: z.array(agentSummarySchema),
+	nextCursor: z.string().nullable().optional(),
+	totalCount: z.number().nullable().optional()
+});
+const createAgentResponseSchema = z.object({ agent: agentSummarySchema });
+const conversationSummarySchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	preview: z.string().nullable(),
+	channel: z.string().nullable(),
+	channelLabel: z.string().nullable(),
+	agent: z.object({
+		id: z.string().uuid(),
+		name: z.string(),
+		slug: z.string().nullable().optional(),
+		title: z.string().nullable().optional()
+	})
+});
+const conversationTitleSchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable()
+});
+const getConversationResponseSchema = z.object({ conversation: conversationTitleSchema });
+const listConversationsResponseSchema = z.object({
+	conversations: z.array(conversationSummarySchema),
+	nextCursor: z.string().nullable().optional(),
+	totalCount: z.number().optional()
+});
+const uiMessagePartSchema = z.union([
+	z.object({
+		type: z.literal("text"),
+		text: z.string()
+	}),
+	z.object({
+		type: z.literal("reasoning"),
+		text: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("dynamic-tool"),
+		toolCallId: z.string(),
+		toolName: z.string(),
+		input: z.unknown().optional(),
+		output: z.unknown().optional(),
+		state: z.string().optional(),
+		errorText: z.string().optional()
+	}),
+	z.object({ type: z.string() }).passthrough()
+]);
+const uiMessageSchema = z.object({
+	id: z.string(),
+	role: z.string(),
+	parts: z.array(uiMessagePartSchema)
+});
+const recapResponseSchema = z.object({ recap: z.object({ text: z.string() }).nullable() });
+const listMessagesResponseSchema = z.object({ messages: z.array(uiMessageSchema) });
+const sendResultSchema = z.object({
+	runId: z.string(),
+	conversationId: z.string().uuid(),
+	isNewConversation: z.boolean(),
+	steered: z.boolean().optional(),
+	directive: z.object({ id: z.string() }).passthrough().optional()
+});
+const presignResponseSchema = z.object({
+	id: z.string(),
+	uploadUrl: z.string(),
+	fileName: z.string(),
+	mediaType: z.string()
+});
+const finalizeResponseSchema = z.object({
+	fileName: z.string(),
+	mediaType: z.string(),
+	sizeBytes: z.number().nullable().optional()
+});
+const activeRunResponseSchema = z.object({ run: z.object({ runId: z.string() }).nullable() });
+const oauthConnectResponseSchema = z.object({ connectLink: z.string() }).passthrough();
+const externalOauthConnectResponseSchema = z.object({ authorizationUrl: z.string().optional() }).passthrough();
+const runStreamEventSchema = z.union([z.object({
+	kind: z.literal("chunk"),
+	chunk: z.record(z.unknown())
+}), z.object({
+	kind: z.literal("finished"),
+	status: z.string(),
+	error: z.string().nullish()
+})]);
+const streamErrorSchema = z.object({ error: z.string() });
+
+//#endregion
+//#region src/chat/util.ts
+/** Narrowing helper for the many `unknown` payloads the chat stream and
+* tool inputs/outputs carry. A type predicate (not an `as` cast), so call
+* sites can read properties without asserting. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Best-effort message from an unknown thrown value. */
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+
+//#endregion
+//#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
+var print_exports = /* @__PURE__ */ __exportAll({
+	readStdin: () => readStdin,
+	resolveAgent: () => resolveAgent,
+	runPrint: () => runPrint
+});
+/**
+* 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 }) {
+	const client = createRestClient({
+		appUrl,
+		sessionToken
+	});
+	const agent = resolveAgent(await client.listAgents({
+		scope: "org",
+		onPage: null
+	}), agentSelector);
+	const send = await client.sendMessage({
+		agentId: agent.id,
+		conversationId,
+		content: prompt,
+		attachmentIds: [],
+		clientSurface: "cli"
+	});
+	let text = "";
+	const controller = new AbortController();
+	let streamError = null;
+	const connectCards = [];
+	await client.streamRun({
+		runId: send.runId,
+		signal: controller.signal,
+		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 (!json) process.stdout.write(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);
+			}
+		}
+	});
+	if (streamError) throw new Error(streamError);
+	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,
+		runId: send.runId,
+		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 { parseExternalOauthConnectParams as a, resolveConnectUrl as c, isRecord as d, HttpError as f, cardActionErrorMessage as i, parseConnectCard as l, resolveAgent as n, parseOauthConnectParams as o, createRestClient as p, MASK_CHAR as r, reconcileMaskedInput as s, print_exports as t, errorMessage as u };