skydive-cli 0.1.0-beta.163 → 0.1.0-beta.186

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.163";
+var version$1 = "0.1.0-beta.186";
 
 //#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-B-eA8M6t.mjs");
+		const { runChat } = await import("./boot-BEMmVR8C.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,65 +2478,18 @@ 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;
-			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));
-			}
-		},
+		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 (;;) {
@@ -2554,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(),
@@ -2878,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
@@ -2902,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
 	};
@@ -3179,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-B-eA8M6t.mjs");
+			const { runWorkspacePicker } = await import("./boot-BEMmVR8C.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -3233,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-B-eA8M6t.mjs → boot-BEMmVR8C.mjs}

@@ -1953,6 +1953,30 @@ function parseDroppedPaths(text) {
 	}
 	return paths;
 }
+/** Decide how to handle a paste. `kind: 'binary'` events carry the mime of
+* bytes the terminal forwarded; text events carry the decoded paste text.
+*
+* The empty-text case is the fix for "can't paste an image": on macOS the
+* reflex is Cmd+V, which the terminal turns into a bracketed *text* paste, so
+* a screenshot on the clipboard arrives as empty bytes. We route that to an OS
+* clipboard read instead of dropping it, matching the explicit ctrl+v path. */
+function routePaste(input) {
+	if (input.kind === "binary") {
+		if (input.mimeType?.startsWith("image/")) return {
+			kind: "binary-image",
+			mediaType: input.mimeType
+		};
+		return { kind: "text" };
+	}
+	const paths = parseDroppedPaths(input.text);
+	if (paths) return {
+		kind: "dropped-paths",
+		paths,
+		text: input.text
+	};
+	if (input.text.trim() === "") return { kind: "clipboard-image" };
+	return { kind: "text" };
+}
 /**
 * Resolve path candidates into images using the filesystem and file magic,
 * not extensions. The whole batch must be regular image files; otherwise the
@@ -5171,31 +5195,40 @@ function ChatScreen({ agent, conversation }) {
 	}, [stageImages]);
 	usePaste((event) => {
 		if (modelPickerOpen || themePickerOpen || helpOpen || credPromptOpen || grantPrompt) return;
-		const mime = event.metadata?.mimeType;
-		if (event.metadata?.kind === "binary") {
-			if (mime?.startsWith("image/")) {
+		const text = event.metadata?.kind === "binary" ? "" : decodePasteBytes(event.bytes);
+		const route = routePaste({
+			kind: event.metadata?.kind,
+			mimeType: event.metadata?.mimeType,
+			text
+		});
+		switch (route.kind) {
+			case "binary-image": {
 				event.preventDefault();
-				const ext = mime.split("/")[1]?.split("+")[0] ?? "png";
+				const ext = route.mediaType.split("/")[1]?.split("+")[0] ?? "png";
 				stageImages([{
 					fileName: `pasted-image-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.${ext}`,
-					mediaType: mime,
+					mediaType: route.mediaType,
 					data: event.bytes
 				}]);
-			}
-			return;
-		}
-		const text = decodePasteBytes(event.bytes);
-		const paths = parseDroppedPaths(text);
-		if (!paths) return;
-		event.preventDefault();
-		resolveDroppedImages(paths).then((images) => {
-			if (images) {
-				stageImages(images);
 				return;
 			}
-			composerRef.current?.insertText(text);
-			handleComposerChange();
-		});
+			case "clipboard-image":
+				event.preventDefault();
+				pasteImage();
+				return;
+			case "dropped-paths":
+				event.preventDefault();
+				resolveDroppedImages(route.paths).then((images) => {
+					if (images) {
+						stageImages(images);
+						return;
+					}
+					composerRef.current?.insertText(route.text);
+					handleComposerChange();
+				});
+				return;
+			case "text": return;
+		}
 	});
 	const applyComposerText = useCallback((text, caret) => {
 		const composer = composerRef.current;

package/package.json

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