skydive-cli 0.1.0-beta.106 → 0.1.0-beta.122

package/dist/js/bin.mjs

@@ -11,9 +11,27 @@ import { spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import zlib from "node:zlib";
+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 package.json
-var version$1 = "0.1.0-beta.106";
+var version$1 = "0.1.0-beta.122";
 
 //#endregion
 //#region src/types.ts
@@ -553,7 +571,7 @@ async function loginWithDevice({ appUrl, openBrowser = true }) {
 	let intervalMs = (code.interval ?? 5) * 1e3 || DEFAULT_INTERVAL_MS;
 	const expiresAt = Date.now() + code.expires_in * 1e3;
 	while (Date.now() < expiresAt) {
-		await sleep(intervalMs);
+		await sleep$1(intervalMs);
 		const result = await pollDeviceToken({
 			appUrl,
 			deviceCode: code.device_code,
@@ -601,7 +619,7 @@ function formatUserCode(code) {
 	if (code.length !== 8) return code;
 	return `${code.slice(0, 4)}-${code.slice(4)}`;
 }
-function sleep(ms) {
+function sleep$1(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -794,7 +812,7 @@ function requireClient$2(argv) {
 	}
 	return new SkydiveApiClient(result.value);
 }
-const listCommand$3 = {
+const listCommand$4 = {
 	command: "list",
 	describe: "List agents",
 	builder: (y) => y.option("limit", {
@@ -824,17 +842,50 @@ const listCommand$3 = {
 			console.log("No agents found.");
 			return;
 		}
-		printTable([
+		const { headers, rows } = buildAgentTable(agents);
+		printTable(headers, rows);
+	}
+};
+const DESCRIPTION_MAX = 48;
+/**
+* Build the `agents list` table. A Description column is added only when at
+* least one agent actually has a description, so an all-empty column doesn't
+* add noise for accounts that never set them. Descriptions can be long, so
+* they are truncated to keep one verbose agent from blowing out the width.
+*/
+function buildAgentTable(agents) {
+	if (agents.some((a) => (a.description ?? "").trim().length > 0)) return {
+		headers: [
 			"Name",
+			"Description",
 			"URL",
 			"Model"
-		], agents.map((a) => [
+		],
+		rows: agents.map((a) => [
 			a.name,
+			truncate(a.description ?? "", DESCRIPTION_MAX),
 			a.url ?? "-",
 			a.model ?? "default"
-		]));
-	}
-};
+		])
+	};
+	return {
+		headers: [
+			"Name",
+			"URL",
+			"Model"
+		],
+		rows: agents.map((a) => [
+			a.name,
+			a.url ?? "-",
+			a.model ?? "default"
+		])
+	};
+}
+function truncate(value, max) {
+	const trimmed = value.trim();
+	if (trimmed.length <= max) return trimmed || "-";
+	return `${trimmed.slice(0, max - 1)}\u2026`;
+}
 const getCommand = {
 	command: "get <id>",
 	describe: "Get agent details",
@@ -905,7 +956,7 @@ const createCommand$1 = {
 const agentsCommand = {
 	command: "agents",
 	describe: "Manage agents",
-	builder: (y) => y.command(listCommand$3).command(getCommand).command(createCommand$1).demandCommand(1, "Specify a subcommand: list, get, create"),
+	builder: (y) => y.command(listCommand$4).command(getCommand).command(createCommand$1).demandCommand(1, "Specify a subcommand: list, get, create"),
 	handler: () => {}
 };
 
@@ -919,7 +970,7 @@ function requireClient$1(argv) {
 	}
 	return new SkydiveApiClient(result.value);
 }
-const listCommand$2 = {
+const listCommand$3 = {
 	command: "list",
 	describe: "List API keys for an agent",
 	handler: async (argv) => {
@@ -1008,7 +1059,7 @@ const keysCommand = {
 		type: "string",
 		demandOption: true,
 		describe: "Agent ID"
-	}).command(listCommand$2).command(createCommand).command(revokeCommand).demandCommand(1, "Specify a subcommand: list, create, revoke"),
+	}).command(listCommand$3).command(createCommand).command(revokeCommand).demandCommand(1, "Specify a subcommand: list, create, revoke"),
 	handler: () => {}
 };
 
@@ -1023,12 +1074,12 @@ function requireClient(argv) {
 	return new SkydiveApiClient(result.value);
 }
 /** Read all of stdin as UTF-8, trimming a single trailing newline. */
-async function readStdin() {
+async function readStdin$1() {
 	const chunks = [];
 	for await (const chunk of process.stdin) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
 	return Buffer.concat(chunks).toString("utf8").replace(/\n$/, "");
 }
-const listCommand$1 = {
+const listCommand$2 = {
 	command: "list",
 	describe: "List secret names for an agent (values are never shown)",
 	handler: async (argv) => {
@@ -1067,7 +1118,7 @@ const setCommand = {
 				printError("No value given. Pass it as an argument or pipe it on stdin, e.g. `echo -n \"$TOKEN\" | skydive secrets set MY_KEY --agent-id <id>`.");
 				process.exit(1);
 			}
-			value = await readStdin();
+			value = await readStdin$1();
 		}
 		if (!value) {
 			printError("Empty secret value.");
@@ -1114,7 +1165,7 @@ const secretsCommand = {
 		type: "string",
 		demandOption: true,
 		describe: "Agent ID"
-	}).command(listCommand$1).command(setCommand).command(rmCommand).demandCommand(1, "Specify a subcommand: list, set, rm"),
+	}).command(listCommand$2).command(setCommand).command(rmCommand).demandCommand(1, "Specify a subcommand: list, set, rm"),
 	handler: () => {}
 };
 
@@ -2101,7 +2152,7 @@ const chatCommand = {
 			printError(`Unknown theme "${themeId}". Valid themes: ${themes.map((t) => t.id).join(", ")}`);
 			process.exit(1);
 		}
-		const { runChat } = await import("./boot-DRWra2vY.mjs");
+		const { runChat } = await import("./boot-BvkqTAxQ.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -2119,7 +2170,7 @@ async function runPrintMode({ argv, appUrl }) {
 		printError(`${session.error.message} For non-interactive use, run \`skydive auth login --web\` first, or set SKYDIVE_SESSION_TOKEN.`);
 		process.exit(1);
 	}
-	const { runPrint, readStdin } = await import("./print-CQ8b7JUC.mjs").then((n) => n.t);
+	const { runPrint, readStdin } = await Promise.resolve().then(() => print_exports);
 	let prompt = (argv.print ?? "").trim();
 	if (!prompt) {
 		if (process.stdin.isTTY) {
@@ -2149,15 +2200,875 @@ async function runPrintMode({ argv, appUrl }) {
 }
 
 //#endregion
-//#region src/commands/workspace.ts
+//#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 all = [];
+			const maxConversations = limit ?? 5e3;
+			let cursor;
+			do {
+				const remaining = maxConversations - all.length;
+				const params = new URLSearchParams({
+					agentId,
+					includeTotal: "false"
+				});
+				params.set("limit", String(Math.min(remaining, 100)));
+				if (cursor) params.set("cursor", cursor);
+				const page = await get(`/api/v1/conversations?${params.toString()}`, listConversationsResponseSchema);
+				all.push(...page.conversations);
+				cursor = page.nextCursor ?? void 0;
+			} while (cursor && all.length < maxConversations);
+			return limit ? all.slice(0, limit) : all;
+		},
+		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
+//#region src/commands/session.ts
+/**
+* Resolve the signed-in chat session or exit with a friendly hint. Shared by
+* every command that talks to the authenticated REST API so the
+* resolve-or-exit block isn't copy-pasted per command.
+*/
 function requireSession(argv) {
-	const session = resolveSession({ appUrl: argv["api-url"] });
+	const session = resolveSession({ appUrl: resolveAppUrl({ appUrl: argv["api-url"] }) });
 	if (session.isErr()) {
-		printError("Not signed in for chat. Run `skydive auth login --web` first.");
+		printError(`${session.error.message} Run \`skydive auth login --web\` first, or set SKYDIVE_SESSION_TOKEN.`);
 		process.exit(1);
 	}
 	return session.value;
 }
+/** Resolve the session (see {@link requireSession}) and build a REST client. */
+function requireRestClient(argv) {
+	const session = requireSession(argv);
+	return createRestClient({
+		appUrl: session.appUrl,
+		sessionToken: session.sessionToken
+	});
+}
+
+//#endregion
+//#region src/commands/conversations.ts
+/**
+* Flatten a UiMessage's parts into plain text for the non-JSON view. Text and
+* reasoning parts are concatenated; tool calls are summarized to one line so a
+* transcript stays readable without the rich TUI rendering. This is a
+* lossy-but-legible view; `--json` carries the full structured parts for a
+* driving agent that wants everything.
+*/
+function messageToText(message) {
+	const chunks = [];
+	for (const part of message.parts) if (part.type === "text" && typeof part.text === "string") chunks.push(part.text);
+	else if (part.type === "reasoning" && typeof part.text === "string") chunks.push(part.text);
+	else if (part.type === "dynamic-tool" && "toolName" in part) {
+		const toolName = typeof part.toolName === "string" ? part.toolName : "tool";
+		chunks.push(`[tool: ${toolName}]`);
+	}
+	return chunks.join("\n").trim();
+}
+const listCommand$1 = {
+	command: "list",
+	describe: "List an agent's conversations",
+	builder: (y) => y.option("agent", {
+		type: "string",
+		describe: "Agent whose conversations to list, by id, slug, or name. Optional when the account has exactly one agent."
+	}).option("limit", {
+		type: "number",
+		describe: "Max conversations to return"
+	}),
+	handler: async (argv) => {
+		const client = requireRestClient(argv);
+		const agent = resolveAgent(await client.listAgents({
+			scope: "org",
+			onPage: null
+		}), argv.agent ?? null);
+		const conversations = await client.listConversations({
+			agentId: agent.id,
+			limit: argv.limit
+		});
+		if (argv.json) {
+			output(argv, conversations);
+			return;
+		}
+		if (conversations.length === 0) {
+			console.log("No conversations found.");
+			return;
+		}
+		printTable([
+			"ID",
+			"Title",
+			"Updated",
+			"Preview"
+		], conversations.map((c) => [
+			c.id,
+			c.title ?? "-",
+			c.updatedAt,
+			(c.preview ?? "").replace(/\s+/g, " ").slice(0, 48) || "-"
+		]));
+	}
+};
+const showCommand = {
+	command: "show <conversation-id>",
+	describe: "Print a conversation transcript",
+	builder: (y) => y.positional("conversation-id", {
+		type: "string",
+		demandOption: true,
+		describe: "Conversation id"
+	}).option("recap", {
+		type: "boolean",
+		default: false,
+		describe: "Print the conversation recap instead of the full transcript"
+	}),
+	handler: async (argv) => {
+		const client = requireRestClient(argv);
+		const conversationId = argv["conversation-id"];
+		if (argv.recap) {
+			const recap = await client.getRecap({ conversationId });
+			if (argv.json) {
+				output(argv, {
+					conversationId,
+					recap
+				});
+				return;
+			}
+			console.log(recap ?? "(no recap available)");
+			return;
+		}
+		const messages = await client.listMessages({ conversationId });
+		if (argv.json) {
+			output(argv, messages);
+			return;
+		}
+		if (messages.length === 0) {
+			console.log("No messages in this conversation.");
+			return;
+		}
+		for (const message of messages) {
+			const text = messageToText(message);
+			if (!text) continue;
+			console.log(`\n[${message.role}]`);
+			console.log(text);
+		}
+	}
+};
+const conversationsCommand = {
+	command: "conversations",
+	aliases: ["conv"],
+	describe: "List and read agent conversations",
+	builder: (y) => y.command(listCommand$1).command(showCommand).demandCommand(1, "Specify a subcommand: list, show"),
+	handler: () => {}
+};
+
+//#endregion
+//#region src/commands/workspace.ts
 /**
 * List the account's workspaces, marking the active one. Shared by the `list`
 * subcommand and the bare `workspace` invocation. When `hint` is true (the bare
@@ -2218,7 +3129,7 @@ const switchCommand = {
 				printError("The workspace picker needs the Bun runtime and it could not be set up automatically. Pass a workspace slug instead, or install Bun and retry.");
 				process.exit(1);
 			}
-			const { runWorkspacePicker } = await import("./boot-DRWra2vY.mjs");
+			const { runWorkspacePicker } = await import("./boot-BvkqTAxQ.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -2272,7 +3183,7 @@ function createCli(argv) {
 		type: "string",
 		global: true,
 		describe: "Override API base URL"
-	}).command(authCommand).command(chatCommand).command(agentsCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(version$1).alias("v", "version").alias("h", "help").help().fail((msg, err) => {
+	}).command(authCommand).command(chatCommand).command(conversationsCommand).command(agentsCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(version$1).alias("v", "version").alias("h", "help").help().fail((msg, err) => {
 		printError(err ? err instanceof Error ? err.message : String(err) : msg ?? "Unknown error");
 		process.exit(1);
 	});
@@ -2345,4 +3256,4 @@ function resolveArgv(args, tty = {
 createCli(resolveArgv(hideBin(process.argv))).parse();
 
 //#endregion
-export { getSavedTheme as _, noColorRequested as a, themeMode as c, themesForMode as d, getActiveWorkspaceId as f, DEFAULT_APP_URL as g, DEFAULT_API_URL as h, monoTheme as i, themeModeFromColorFgBg as l, setActiveWorkspace as m, applyTheme as n, theme as o, listWorkspaces as p, findTheme as r, themeForMode as s, DEFAULT_THEME_ID as t, themeVersion as u, resolveWebUrl as v, saveTheme as y };
+export { resolveWebUrl as A, themesForMode as C, DEFAULT_API_URL as D, setActiveWorkspace as E, DEFAULT_APP_URL as O, themeVersion as S, listWorkspaces as T, noColorRequested as _, parseOauthConnectParams as a, themeMode as b, parseConnectCard as c, HttpError as d, createRestClient as f, monoTheme as g, findTheme as h, parseExternalOauthConnectParams as i, saveTheme as j, getSavedTheme as k, errorMessage as l, applyTheme as m, MASK_CHAR as n, reconcileMaskedInput as o, DEFAULT_THEME_ID as p, cardActionErrorMessage as r, resolveConnectUrl as s, resolveAgent as t, isRecord as u, theme as v, getActiveWorkspaceId as w, themeModeFromColorFgBg as x, themeForMode as y };