skydive-cli 0.1.0 → 0.2.0-beta.421

package/dist/js/{print-BHbFMxQv.mjs → rest-CamHVOce.mjs}

@@ -2,23 +2,6 @@
 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) {
@@ -28,6 +11,20 @@ var HttpError = class extends Error {
 		this.name = "HttpError";
 	}
 };
+const ERROR_DETAIL_MAX_BODY = 2e3;
+/**
+* Fullest renderable text for a thrown value. `HttpError.message` clips the
+* response body to 200 chars (it flows into logs and one-line UIs); the
+* transcript renders errors collapsed to a single line, so it can afford the
+* whole body — capped with an explicit marker, never cut silently.
+*/
+function errorDetail(err) {
+	if (err instanceof HttpError) {
+		const body = err.body.length > ERROR_DETAIL_MAX_BODY ? `${err.body.slice(0, ERROR_DETAIL_MAX_BODY)}… (+${err.body.length - ERROR_DETAIL_MAX_BODY} chars)` : err.body;
+		return body ? `HTTP ${err.status}: ${body}` : `HTTP ${err.status}`;
+	}
+	return err instanceof Error ? err.message : String(err);
+}
 const MAX_STREAM_RECONNECTS = 5;
 function createRestClient({ appUrl, sessionToken }) {
 	const baseHeaders = {
@@ -58,6 +55,65 @@ function createRestClient({ appUrl, sessionToken }) {
 		});
 		if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
 	}
+	const streamEvents = async ({ path, label, 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}${path}`, {
+					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(`${label} stream ended unexpectedly`);
+			await sleep(Math.min(500 * 2 ** reconnects, 5e3));
+		}
+	};
 	return {
 		listAgents: async ({ scope, onPage }) => {
 			const all = [];
@@ -94,19 +150,51 @@ function createRestClient({ appUrl, sessionToken }) {
 			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;
+		listConversations: async ({ agentId, limit, channels, onPage }) => {
+			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);
+				for (const channel of channels ?? []) params.append("channels", channel);
+				const page = await get(`/api/v1/conversations?${params.toString()}`, listConversationsResponseSchema);
+				all.push(...page.conversations);
+				cursor = page.nextCursor ?? void 0;
+				onPage?.(limit ? all.slice(0, limit) : [...all]);
+			} 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;
 		},
+		listWorkspaceFiles: async ({ agentId }) => {
+			const { files } = await get(`/api/v1/workspace-files?${new URLSearchParams({ agentId }).toString()}`, listWorkspaceFilesResponseSchema);
+			return files;
+		},
+		readWorkspaceFile: async ({ fileId, maxBytes = 512 * 1024 }) => {
+			const res = await fetch(`${appUrl}/api/v1/workspace-files/${encodeURIComponent(fileId)}/download?disposition=inline`, { headers: {
+				...baseHeaders,
+				Range: `bytes=0-${maxBytes}`
+			} });
+			if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
+			const bytes = new Uint8Array(await res.arrayBuffer());
+			const truncated = bytes.byteLength > maxBytes;
+			return {
+				text: new TextDecoder().decode(bytes.subarray(0, maxBytes)),
+				truncated
+			};
+		},
+		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", {
@@ -137,11 +225,10 @@ function createRestClient({ appUrl, sessionToken }) {
 		deleteConversation: async ({ conversationId }) => {
 			await del(`/api/v1/conversations/${encodeURIComponent(conversationId)}`);
 		},
-		sendMessage: async (input) => post("/api/v1/chat/send", input, sendResultSchema),
-		activeRun: async ({ conversationId }) => {
-			const { run } = await get(`/api/v1/chat/active-run?${new URLSearchParams({ conversationId }).toString()}`, activeRunResponseSchema);
-			return run;
-		},
+		sendMessage: async ({ clientSurface, ...input }) => post("/api/v1/chat/send", {
+			...input,
+			clientSurface
+		}, sendResultSchema),
 		cancelRun: async ({ runId }) => {
 			await post(`/api/v1/chat/runs/${encodeURIComponent(runId)}/cancel`, {}, z.object({ ok: z.boolean() }));
 		},
@@ -168,36 +255,35 @@ function createRestClient({ appUrl, sessionToken }) {
 			});
 			if (!res.ok) throw new HttpError(res.status, await res.text().catch(() => ""));
 		},
-		streamRun: async ({ runId, signal, onEvent }) => {
-			let lastEventId = null;
-			let finished = false;
+		streamRun: async ({ runId, signal, onEvent }) => streamEvents({
+			path: `/api/v1/chat/runs/${encodeURIComponent(runId)}/stream`,
+			label: "run",
+			signal,
+			onEvent
+		}),
+		streamMessage: async ({ messageId, signal, onEvent }) => streamEvents({
+			path: `/api/v1/chat/messages/${encodeURIComponent(messageId)}/stream`,
+			label: "message",
+			signal,
+			onEvent
+		}),
+		streamConversation: async ({ conversationId, signal, onEvent }) => {
 			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,
+					const res = await fetch(`${appUrl}/api/v1/chat/conversations/${encodeURIComponent(conversationId)}/stream`, {
+						headers: {
+							authorization: `Bearer ${sessionToken}`,
+							accept: "text/event-stream"
+						},
 						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 parsed = conversationStreamEventSchema.safeParse(JSON.parse(message.data));
+						if (parsed.success) onEvent(parsed.data);
 					} });
 					const decoder = new TextDecoder();
 					const reader = res.body.getReader();
@@ -206,7 +292,6 @@ function createRestClient({ appUrl, sessionToken }) {
 							const { done, value } = await reader.read();
 							if (done) break;
 							parser.feed(decoder.decode(value, { stream: true }));
-							if (finished) return;
 						}
 					} finally {
 						try {
@@ -221,9 +306,9 @@ function createRestClient({ appUrl, sessionToken }) {
 					await sleep(Math.min(500 * 2 ** reconnects, 5e3));
 					continue;
 				}
-				if (finished) return;
+				if (signal.aborted) return;
 				reconnects += 1;
-				if (reconnects > MAX_STREAM_RECONNECTS) throw new Error("run stream ended unexpectedly");
+				if (reconnects > MAX_STREAM_RECONNECTS) throw new Error("conversation stream ended unexpectedly");
 				await sleep(Math.min(500 * 2 ** reconnects, 5e3));
 			}
 		}
@@ -273,11 +358,14 @@ const conversationSummarySchema = z.object({
 		title: z.string().nullable().optional()
 	})
 });
-const conversationTitleSchema = z.object({
+const conversationDetailSchema = z.object({
 	id: z.string().uuid(),
-	title: z.string().nullable()
+	title: z.string().nullable(),
+	agentId: z.string().uuid(),
+	createdAt: z.string(),
+	updatedAt: z.string()
 });
-const getConversationResponseSchema = z.object({ conversation: conversationTitleSchema });
+const getConversationResponseSchema = z.object({ conversation: conversationDetailSchema });
 const listConversationsResponseSchema = z.object({
 	conversations: z.array(conversationSummarySchema),
 	nextCursor: z.string().nullable().optional(),
@@ -306,13 +394,31 @@ const uiMessagePartSchema = z.union([
 const uiMessageSchema = z.object({
 	id: z.string(),
 	role: z.string(),
-	parts: z.array(uiMessagePartSchema)
+	parts: z.array(uiMessagePartSchema),
+	metadata: z.object({ custom: z.object({
+		agentId: z.string().nullish(),
+		agentName: z.string().nullish()
+	}).passthrough().optional() }).passthrough().optional()
 });
+const recapResponseSchema = z.object({ recap: z.object({ text: z.string() }).nullable() });
 const listMessagesResponseSchema = z.object({ messages: z.array(uiMessageSchema) });
+const workspaceFileSchema = z.object({
+	id: z.string(),
+	path: z.string(),
+	mediaType: z.string(),
+	sizeBytes: z.number(),
+	contentHash: z.string(),
+	updatedAt: z.string(),
+	shareUrl: z.string()
+});
+const listWorkspaceFilesResponseSchema = z.object({ files: z.array(workspaceFileSchema) });
 const sendResultSchema = z.object({
 	runId: z.string(),
+	messageId: z.string().uuid().nullish(),
 	conversationId: z.string().uuid(),
 	isNewConversation: z.boolean(),
+	agentId: z.string().nullish(),
+	agentName: z.string().nullish(),
 	steered: z.boolean().optional(),
 	directive: z.object({ id: z.string() }).passthrough().optional()
 });
@@ -327,7 +433,6 @@ const finalizeResponseSchema = z.object({
 	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({
@@ -339,104 +444,14 @@ const runStreamEventSchema = z.union([z.object({
 	error: z.string().nullish()
 })]);
 const streamErrorSchema = z.object({ error: z.string() });
+const conversationStreamEventSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("conversation"),
+	id: z.string(),
+	title: z.string().nullable()
+}), z.object({
+	kind: z.literal("run"),
+	runId: z.string()
+})]);
 
 //#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: []
-	});
-	let text = "";
-	const controller = new AbortController();
-	let streamError = null;
-	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";
-		}
-	});
-	if (streamError) throw new Error(streamError);
-	if (!json && text && !text.endsWith("\n")) process.stdout.write("\n");
-	return {
-		agentId: agent.id,
-		agentName: agent.name,
-		conversationId: send.conversationId,
-		isNewConversation: send.isNewConversation,
-		runId: send.runId,
-		text
-	};
-}
-/**
-* 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 { createRestClient as i, resolveAgent as n, HttpError as r, print_exports as t };
+export { createRestClient as n, errorDetail as r, HttpError as t };