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

package/README.md

@@ -142,18 +142,19 @@ skydive chat -p "status?" --agent grace --json               # structured envelo
   browser login — sign in first with `skydive auth login --web` or set
   `SKYDIVE_SESSION_TOKEN`.
 - `--json` prints `{ agentId, agentName, conversationId, isNewConversation,
-runId, text }` instead of streaming the raw text.
+messageId, text }` instead of streaming the raw text.
 - **Recovering a dropped run.** A long run's stream can be cut off at the edge
-  (a gateway 502/504) after the run was created. The run keeps going
-  server-side, so a blind retry would re-execute the agent. Instead, note the
-  `runId` (always in `--json` output) and fetch the result once it's done:
+  (a gateway 502/504) after the message was accepted. The agent keeps working
+  server-side, so a blind retry would re-execute it. Instead, note the
+  `messageId` (always in `--json` output) and fetch the result once it's done:
 
   ```sh
-  skydive runs get <runId>            # prints the reply; --json for the envelope
+  skydive messages get <messageId>    # prints the reply; --json for the envelope
   ```
 
-  `runs get` re-attaches to the run and replays its full reply whether it's
-  still streaming or already finished.
+  `messages get` re-attaches to the exchange behind that message id and replays
+  the full reply whether it's still streaming or already finished. Message ids
+  are the handle this API works in; run ids stay server-side.
 
 It defaults to the production API (`https://api.skydive.com`). For local
 dev, point it at your stack:

package/dist/js/bin.mjs

@@ -31,7 +31,7 @@ var __exportAll = (all, no_symbols) => {
 
 //#endregion
 //#region package.json
-var version$1 = "0.1.0-beta.122";
+var version$1 = "0.1.0-beta.180";
 
 //#endregion
 //#region src/types.ts
@@ -886,7 +886,7 @@ function truncate(value, max) {
 	if (trimmed.length <= max) return trimmed || "-";
 	return `${trimmed.slice(0, max - 1)}\u2026`;
 }
-const getCommand = {
+const getCommand$1 = {
 	command: "get <id>",
 	describe: "Get agent details",
 	builder: (y) => y.positional("id", {
@@ -956,7 +956,7 @@ const createCommand$1 = {
 const agentsCommand = {
 	command: "agents",
 	describe: "Manage agents",
-	builder: (y) => y.command(listCommand$4).command(getCommand).command(createCommand$1).demandCommand(1, "Specify a subcommand: list, get, create"),
+	builder: (y) => y.command(listCommand$4).command(getCommand$1).command(createCommand$1).demandCommand(1, "Specify a subcommand: list, get, create"),
 	handler: () => {}
 };
 
@@ -2152,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-BvkqTAxQ.mjs");
+		const { runChat } = await import("./boot-B-eA8M6t.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -2199,6 +2199,60 @@ async function runPrintMode({ argv, appUrl }) {
 	}
 }
 
+//#endregion
+//#region src/commands/messages.ts
+/**
+* `skydive messages get <messageId>` re-attaches to an exchange by message id
+* and prints the agent's reply.
+*
+* This is the recovery path for `chat -p`: a long run's stream can drop at the
+* edge (Cloudflare 502/504) after the message was accepted, leaving the caller
+* with a messageId but no result. The agent keeps working server-side, so a
+* blind retry would double-execute an agent that may have write access.
+* Instead, fetch the finished result by message id here — the server resolves
+* the run behind the message and replays it from its persisted event log, so
+* this works whether the run is still live or already done.
+*
+* Message ids are the currency of this API: `chat -p --json` reports the
+* `messageId` and this command consumes it. Run ids stay server-side.
+*/
+const getCommand = {
+	command: "get <message-id>",
+	describe: "Fetch a message by id and print the reply (recovers a timed-out -p)",
+	builder: (y) => y.positional("message-id", {
+		type: "string",
+		demandOption: true,
+		describe: "Message id (the `messageId` from a prior `chat -p --json`)"
+	}),
+	handler: async (argv) => {
+		const appUrl = resolveAppUrl({ appUrl: argv["api-url"] });
+		const session = resolveSession({ appUrl });
+		if (session.isErr()) {
+			printError(`${session.error.message} Run \`skydive auth login --web\` first, or set SKYDIVE_SESSION_TOKEN.`);
+			process.exit(1);
+		}
+		const { messageGet } = await Promise.resolve().then(() => print_exports);
+		try {
+			const result = await messageGet({
+				appUrl,
+				sessionToken: session.value.sessionToken,
+				messageId: argv["message-id"],
+				json: argv.json
+			});
+			if (argv.json) output(argv, result);
+		} catch (error) {
+			printError(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+	}
+};
+const messagesCommand = {
+	command: "messages",
+	describe: "Inspect chat messages and re-fetch agent replies",
+	builder: (y) => y.command(getCommand).demandCommand(1, "Specify a subcommand: get"),
+	handler: () => {}
+};
+
 //#endregion
 //#region src/chat/api/rest.ts
 var HttpError = class extends Error {
@@ -2239,6 +2293,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 = [];
@@ -2365,36 +2478,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();
@@ -2403,7 +2515,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 {
@@ -2418,9 +2529,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));
 			}
 		}
@@ -2509,6 +2620,7 @@ const recapResponseSchema = z.object({ recap: z.object({ text: z.string() }).nul
 const listMessagesResponseSchema = z.object({ messages: z.array(uiMessageSchema) });
 const sendResultSchema = z.object({
 	runId: z.string(),
+	messageId: z.string().uuid().nullish(),
 	conversationId: z.string().uuid(),
 	isNewConversation: z.boolean(),
 	steered: z.boolean().optional(),
@@ -2537,6 +2649,11 @@ const runStreamEventSchema = z.union([z.object({
 	error: z.string().nullish()
 })]);
 const streamErrorSchema = z.object({ error: z.string() });
+const conversationStreamEventSchema = z.object({
+	kind: z.literal("conversation"),
+	id: z.string(),
+	title: z.string().nullable()
+});
 
 //#endregion
 //#region src/chat/util.ts
@@ -2828,9 +2945,12 @@ function formatConnectCard(card) {
 //#endregion
 //#region src/chat/print.ts
 var print_exports = /* @__PURE__ */ __exportAll({
+	collectRunText: () => collectRunText,
+	messageGet: () => messageGet,
 	readStdin: () => readStdin,
 	resolveAgent: () => resolveAgent,
-	runPrint: () => runPrint
+	runPrint: () => runPrint,
+	toPrintError: () => toPrintError
 });
 /**
 * Non-interactive chat, à la `claude -p`. Sends a single prompt to an
@@ -2852,48 +2972,129 @@ async function runPrint({ appUrl, sessionToken, prompt, agentSelector, conversat
 		scope: "org",
 		onPage: null
 	}), agentSelector);
-	const send = await client.sendMessage({
-		agentId: agent.id,
-		conversationId,
-		content: prompt,
-		attachmentIds: [],
-		clientSurface: "cli"
+	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 = [];
-	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);
+	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 {
-		agentId: agent.id,
-		agentName: agent.name,
-		conversationId: send.conversationId,
-		isNewConversation: send.isNewConversation,
-		runId: send.runId,
+		messageId,
 		text,
 		connectCards
 	};
@@ -3129,7 +3330,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-BvkqTAxQ.mjs");
+			const { runWorkspacePicker } = await import("./boot-B-eA8M6t.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -3183,7 +3384,7 @@ function createCli(argv) {
 		type: "string",
 		global: true,
 		describe: "Override API base URL"
-	}).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) => {
+	}).command(authCommand).command(chatCommand).command(messagesCommand).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);
 	});

package/dist/js/{boot-BvkqTAxQ.mjs → boot-B-eA8M6t.mjs}

@@ -508,7 +508,7 @@ var PortalClient = class {
 				this.setStatus("error", errorMessage(err));
 			}
 			if (!this.enabled || this.disposed) break;
-			await sleep$1(backoff);
+			await sleep(backoff);
 			backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
 		}
 	}
@@ -554,7 +554,7 @@ var PortalClient = class {
 		for (let attempt = 0; attempt < 10; attempt += 1) {
 			await this.refreshDevice();
 			if (this.deviceId) return this.deviceId;
-			await sleep$1(300);
+			await sleep(300);
 		}
 		throw new Error("this machine is not connected yet");
 	}
@@ -590,7 +590,7 @@ function toBuffer(data) {
 function shortBody(res) {
 	return res.text().then((text) => text.slice(0, 120)).catch(() => "");
 }
-function sleep$1(ms) {
+function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
@@ -4639,9 +4639,6 @@ function ThemePicker({ onClose }) {
 
 //#endregion
 //#region src/chat/tui/screens/chat.tsx
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
 /**
 * Composer key bindings: Enter sends the message (matching the rest of the
 * app), Shift+Enter inserts a hard newline. Everything else falls back to the
@@ -4858,41 +4855,18 @@ function ChatScreen({ agent, conversation }) {
 	]);
 	useEffect(() => {
 		if (!rest || !conversationId) return;
-		if (initialConversationId !== null) return;
-		let cancelled = false;
-		(async () => {
-			const delays = [
-				0,
-				800,
-				1500,
-				2500,
-				4e3,
-				6e3
-			];
-			let last = null;
-			for (const delay of delays) {
-				if (delay) await sleep(delay);
-				if (cancelled) return;
-				let title;
-				try {
-					({title} = await rest.getConversation({ conversationId }));
-				} catch (_error) {
-					continue;
-				}
-				if (cancelled) return;
-				if (title && title !== last) {
-					last = title;
-					setChatTitle(title);
-				}
+		const abort = new AbortController();
+		rest.streamConversation({
+			conversationId,
+			signal: abort.signal,
+			onEvent: (event) => {
+				if (event.title) setChatTitle(event.title);
 			}
-		})();
-		return () => {
-			cancelled = true;
-		};
+		}).catch(() => {});
+		return () => abort.abort();
 	}, [
 		rest,
 		conversationId,
-		initialConversationId,
 		setChatTitle
 	]);
 	useEffect(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skydive-cli",
-  "version": "0.1.0-beta.122",
+  "version": "0.1.0-beta.180",
   "description": "Skydive CLI — manage AI agents from the command line",
   "homepage": "https://skydive.com",
   "license": "MIT",