skydive-cli 0.2.0 → 0.3.0

package/dist/js/{print-Bin4u16d.mjs → print-Cd-bVSEJ.mjs}

@@ -1,7 +1,191 @@
 #!/usr/bin/env node
-import { n as createRestClient, t as HttpError } from "./rest-CamHVOce.mjs";
-import { n as isRecord, t as errorMessage } from "./util-CeisaZVY.mjs";
+import { a as errorMessage, i as sendErrorMessage, n as createRestClient, o as isRecord, t as HttpError } from "./rest-BlN_uWmL.mjs";
+import path from "node:path";
+import Conf from "conf";
+import { err, ok } from "neverthrow";
+import stableStringify from "safe-stable-stringify";
 
+//#region src/config.ts
+/** Default host for the public management API (`/v1`, API-key auth). */
+const DEFAULT_API_URL = "https://api.skydive.com";
+/**
+* Default origin for the interactive chat client (`skydive chat`).
+*
+* The API host that serves better-auth (`/api/auth/*`) and the internal tRPC
+* API (`/api/v1/trpc`) that chat streams over. We target the API host
+* directly (not the web front door) because chat opens a WebSocket and
+* authenticates with a bearer token on the upgrade request. Same host as
+* `DEFAULT_API_URL`; override with `--api-url` / `SKYDIVE_APP_URL` for local
+* dev or while the DNS record is still being provisioned.
+*/
+const DEFAULT_APP_URL = "https://api.skydive.com";
+/** Web front door, for pages opened in the user's browser. */
+const DEFAULT_WEB_URL = "https://skydive.com";
+function resolveWebUrl(appUrl) {
+	if (appUrl == null) return appUrl;
+	return appUrl === DEFAULT_APP_URL ? DEFAULT_WEB_URL : appUrl;
+}
+/** Prefix on workspace-scoped Skydive API keys. Kept in sync with the API's
+* `API_KEY_PREFIX` (`apps/anyone/api/src/lib/api-key.ts`); the CLI is a
+* standalone published package so it can't import the backend constant. */
+const API_KEY_PREFIX = "sky_live_";
+/**
+* Common prefix across all Skydive API key kinds — `sky_live_…` workspace
+* keys today, `sky_user_…` account keys when ANY-5105 lands. The CLI only
+* sanity-checks the family on `--api-key`; the server authoritatively rejects
+* a kind that can't drive a given route, with a clearer message than the
+* client could produce.
+*/
+const API_KEY_FAMILY_PREFIX = "sky_";
+/** Where users mint and copy API keys. Shown in the login prompt. */
+const API_KEYS_URL = "skydive.com/settings/account";
+const store = new Conf({
+	projectName: process.env["SKYDIVE_CONFIG_NAME"] ?? "skydive",
+	projectSuffix: "",
+	configFileMode: 384
+});
+function resolveConfig(opts) {
+	const apiKey = process.env["SKYDIVE_API_KEY"] ?? store.get("apiKey");
+	const apiUrl = process.env["SKYDIVE_API_URL"] ?? opts.apiUrl ?? store.get("apiUrl") ?? DEFAULT_API_URL;
+	if (!apiKey) return err({ message: "Not authenticated. Run `skydive auth login` first." });
+	return ok({
+		apiKey,
+		apiUrl
+	});
+}
+/**
+* Resolve the bearer credential for the management API (`agents` / `keys` /
+* `secrets`). The server's `/v1` gate accepts either an API key or the
+* device-flow session bearer, so both work — but only one of them tracks the
+* active workspace.
+*
+* An API key is pinned server-side to the organization that minted it and
+* ignores the workspace header by design, so it can never follow `skydive
+* workspace switch`. A key is also a strictly narrower credential than its
+* owner's session. So the session wins whenever there is one, and a key is
+* what's left for machines that never ran an interactive login.
+*
+* `SKYDIVE_SESSION_TOKEN=` (empty) suppresses session auth for one
+* invocation, to drive a specific organization's key while signed in.
+*/
+function resolveManagementAuth(opts) {
+	const session = resolveSession({ appUrl: opts.apiUrl });
+	if (session.isOk()) return ok({
+		token: session.value.sessionToken,
+		apiUrl: session.value.appUrl,
+		kind: "session",
+		pinnedWorkspaceName: null
+	});
+	const envKey = process.env["SKYDIVE_API_KEY"];
+	const storedKey = store.get("apiKey");
+	const apiKey = envKey ?? storedKey;
+	if (apiKey) return ok({
+		token: apiKey,
+		apiUrl: process.env["SKYDIVE_API_URL"] ?? opts.apiUrl ?? store.get("apiUrl") ?? DEFAULT_API_URL,
+		kind: "api-key",
+		pinnedWorkspaceName: !envKey && storedKey ? store.get("apiKeyWorkspaceName") ?? null : null
+	});
+	return err({ message: "Not authenticated. Run `skydive auth login`." });
+}
+function saveConfig(config) {
+	store.set("apiKey", config.apiKey);
+	store.set("apiUrl", config.apiUrl);
+	if (config.apiKeyId) store.set("apiKeyId", config.apiKeyId);
+	else store.delete("apiKeyId");
+	if (config.workspaceName) store.set("apiKeyWorkspaceName", config.workspaceName);
+	else store.delete("apiKeyWorkspaceName");
+}
+/** Server-side id of the auto-minted key, if login minted one. */
+function getStoredApiKeyId() {
+	return store.get("apiKeyId") ?? null;
+}
+/** Workspace the auto-minted key is pinned to, if login recorded one. */
+function getStoredApiKeyWorkspaceName() {
+	return store.get("apiKeyWorkspaceName") ?? null;
+}
+function deleteConfig() {
+	store.clear();
+}
+function getConfigPath() {
+	return store.path;
+}
+/**
+* Where the chat TUI persists its prompt history (up-arrow recall). Kept
+* beside the config file so all CLI state lives in one directory.
+*/
+function getLastSeenVersion() {
+	return store.get("lastSeenVersion");
+}
+function setLastSeenVersion(version) {
+	store.set("lastSeenVersion", version);
+}
+function getPromptHistoryPath() {
+	return path.join(path.dirname(store.path), "prompt-history.jsonl");
+}
+/**
+* Where the chat TUI persists pending review comments — one JSON file per
+* conversation, so a pending comment survives conversation switches and
+* process death. Kept beside the config file like prompt history.
+*/
+function getReviewStateDir() {
+	return path.join(path.dirname(store.path), "review");
+}
+/**
+* Resolve the chat/auth origin. Precedence: `SKYDIVE_APP_URL` env > explicit
+* `--api-url` style override > stored value > `SKYDIVE_API_URL` env >
+* `DEFAULT_APP_URL`.
+*
+* The `SKYDIVE_API_URL` fallback matters for previews: the device/`--web`
+* flow and chat hit the same api service as the management API, so pointing
+* `SKYDIVE_API_URL` at a preview stack is enough — you don't also have to set
+* `SKYDIVE_APP_URL`. Otherwise auth would silently fall through to prod
+* (`DEFAULT_APP_URL`) and hand back a prod verification URL.
+*/
+function resolveAppUrl(opts) {
+	return process.env["SKYDIVE_APP_URL"] ?? opts.appUrl ?? store.get("appUrl") ?? process.env["SKYDIVE_API_URL"] ?? DEFAULT_APP_URL;
+}
+function resolveSession(opts) {
+	const sessionToken = process.env["SKYDIVE_SESSION_TOKEN"] ?? store.get("sessionToken");
+	const appUrl = resolveAppUrl(opts);
+	if (!sessionToken) return err({ message: "Not signed in for chat. Run `skydive chat` to sign in." });
+	return ok({
+		sessionToken,
+		appUrl
+	});
+}
+function saveSession(session) {
+	store.set("sessionToken", session.sessionToken);
+	store.set("sessionObtainedAt", (/* @__PURE__ */ new Date()).toISOString());
+	store.set("appUrl", session.appUrl);
+}
+function getSavedTheme(mode) {
+	return store.get(mode === "dark" ? "themeDark" : "themeLight");
+}
+function saveTheme(mode, themeId) {
+	store.set(mode === "dark" ? "themeDark" : "themeLight", themeId);
+}
+/**
+* Whether `skydive chat` should enable portal machine sharing on launch
+* without `--share-machine`. Set by hand-editing `shareMachineDefault` in
+* config.json — deliberately no CLI command (kept off the API surface).
+* Sharing only makes the machine reachable — agents still need a
+* (persistent) grant to run anything, so this default skips the per-session
+* enable step, not the consent step.
+*/
+function getShareMachineDefault() {
+	return store.get("shareMachineDefault") ?? false;
+}
+/**
+* Whether the update check is disabled via config.json (`"updateCheck":
+* false`). The persistent counterpart to the SKYDIVE_NO_UPDATE_CHECK /
+* NO_UPDATE_NOTIFIER env opt-outs; like shareMachineDefault, set by editing
+* config.json — deliberately no CLI command.
+*/
+function getUpdateCheckDisabled() {
+	return store.get("updateCheck") === false;
+}
+
+//#endregion
 //#region src/chat/tui/chat/card.ts
 const urlActionKinds = [
 	"open_oauth",
@@ -55,6 +239,23 @@ function parseButton(element) {
 		primary
 	};
 }
+/**
+* Content identity for a card's spec, which is what separates a re-delivery of
+* one card from two distinct cards: the same card reaches us twice (live on the
+* run stream and again as the persisted message part when history is loaded for
+* an in-flight run), while a single tool call can legitimately post SEVERAL
+* different cards — `platform` subprocesses chained in one bash command all
+* read the same TOOL_CALL_ID, so `toolCallId` alone identifies neither. Applies
+* the same identity rule as the web client (web/src/features/chat-v2/turn-segments.ts).
+*
+* The serialization has to be key-order-independent, because the persisted copy
+* of a spec comes back through a jsonb round-trip that can reorder keys and
+* order-sensitive `JSON.stringify` would read that as a different card.
+* `safe-stable-stringify` sorts keys and tolerates cycles.
+*/
+function specKeyFor(spec) {
+	return stableStringify(spec) ?? crypto.randomUUID();
+}
 function parseConnectCard(spec) {
 	if (!isRecord(spec)) return null;
 	const { root, elements } = spec;
@@ -210,14 +411,20 @@ function summarizeConnectCard(card, appUrl) {
 	const act = button.action;
 	switch (act.kind) {
 		case "open_oauth":
-		case "open_external_oauth":
-		case "open_github_app": return {
+		case "open_external_oauth": return {
 			...base,
 			action: {
 				kind: "open_url",
 				url: resolveConnectUrl(act.url, appUrl)
 			}
 		};
+		case "open_github_app": return {
+			...base,
+			action: {
+				kind: "open_url",
+				url: resolveConnectUrl(act.url, resolveWebUrl(appUrl))
+			}
+		};
 		case "submit_credential": return {
 			...base,
 			action: {
@@ -337,17 +544,24 @@ async function runPrint({ appUrl, sessionToken, prompt, agentSelector, conversat
 	};
 }
 /**
-* 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).
+* Turn a transport failure into an actionable CLI error. Two failure classes
+* reach here, both of which otherwise leak a raw HTML/JSON error page to stdout:
+*
+*  - A Cloudflare edge 5xx (502/504) on a long run. 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).
+*  - A 4xx from the send/stream endpoints (a validation 400 whose body is a raw
+*    Zod issues array, a billing/permission block, an expired session). These
+*    go through {@link sendErrorMessage} so the `-p` path prints the same plain,
+*    actionable copy the interactive TUI shows instead of an obtuse blob.
 */
 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}`);
 	}
+	if (err instanceof HttpError) return new Error(sendErrorMessage(err));
 	return err instanceof Error ? err : new Error(String(err));
 }
 /**
@@ -463,4 +677,4 @@ async function readStdin() {
 }
 
 //#endregion
-export { runPrint as a, cardActionErrorMessage as c, reconcileMaskedInput as d, resolveConnectUrl as f, resolveAgent as i, parseExternalOauthConnectParams as l, messageGet as n, toPrintError as o, parseConnectCard as p, readStdin as r, MASK_CHAR as s, collectRunText as t, parseOauthConnectParams as u };
+export { resolveAppUrl as A, getPromptHistoryPath as C, getStoredApiKeyId as D, getShareMachineDefault as E, saveConfig as F, saveSession as I, saveTheme as L, resolveManagementAuth as M, resolveSession as N, getStoredApiKeyWorkspaceName as O, resolveWebUrl as P, setLastSeenVersion as R, getLastSeenVersion as S, getSavedTheme as T, API_KEY_PREFIX as _, runPrint as a, deleteConfig as b, cardActionErrorMessage as c, reconcileMaskedInput as d, resolveConnectUrl as f, API_KEY_FAMILY_PREFIX as g, API_KEYS_URL as h, resolveAgent as i, resolveConfig as j, getUpdateCheckDisabled as k, parseExternalOauthConnectParams as l, specKeyFor as m, messageGet as n, toPrintError as o, parseConnectCard as p, readStdin as r, MASK_CHAR as s, collectRunText as t, parseOauthConnectParams as u, DEFAULT_API_URL as v, getReviewStateDir as w, getConfigPath as x, DEFAULT_APP_URL as y };

package/dist/js/{print-share-D7OSxvE2.mjs → print-share-7qfpQtWK.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as printError } from "./output-B4cW10Ph.mjs";
+import { n as printError } from "./output-DYzzdXYV.mjs";
 
 //#region src/chat/print-share.ts
 /**
@@ -14,7 +14,7 @@ import { n as printError } from "./output-B4cW10Ph.mjs";
 * the reply (and to --json).
 */
 async function connectMachineShare({ appUrl, sessionToken, timeoutHint }) {
-	const { PortalClient } = await import("./client-D6NAkL9e.mjs");
+	const { PortalClient } = await import("./client-DuwxEDG4.mjs");
 	let signalConnected;
 	const connected = new Promise((resolve) => {
 		signalConnected = resolve;
@@ -22,7 +22,7 @@ async function connectMachineShare({ appUrl, sessionToken, timeoutHint }) {
 	const machineShare = new PortalClient({
 		appUrl,
 		sessionToken,
-		cwd: process.cwd(),
+		resolveCwd: () => process.cwd(),
 		onState: (state) => {
 			if (state.status === "connected") signalConnected();
 			if (state.status === "error") console.error(`portal: connection error: ${state.error ?? "unknown"} — retrying`);

package/dist/js/{raw-pty-GAvxm2ol.mjs → raw-pty-BcjbTjHJ.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as SandboxStream } from "./client-CpEvH2Pq.mjs";
+import { t as SandboxStream } from "./client-DfcJFEbh.mjs";
 
 //#region src/chat/sandbox/raw-pty.ts
 /**

package/dist/js/raw-pty-ChUHav4d.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./client-DfcJFEbh.mjs";
+import { t as runRawPtyPassthrough } from "./raw-pty-BcjbTjHJ.mjs";
+
+export { runRawPtyPassthrough };

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

@@ -2,6 +2,19 @@
 import { z } from "zod";
 import { createParser } from "eventsource-parser";
 
+//#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/api/rest.ts
 var HttpError = class extends Error {
 	constructor(status, body) {
@@ -25,12 +38,76 @@ function errorDetail(err) {
 	}
 	return err instanceof Error ? err.message : String(err);
 }
+/**
+* The server's human-readable line out of an error response body, or null when
+* the body carries none. Two shapes reach the CLI on a failed send:
+*
+*  - `{ error: string }` — the chat route's own errors (a ChatClientError like
+*    "agent not found" / "attachment not found: <id>", the 429 "Too many
+*    requests", the generic "send failed"). Returned verbatim; these are
+*    written to be shown.
+*  - `{ success: false, error: { issues: [{ message }, …] } }` — a Zod request
+*    validation failure from `zValidator` (e.g. the message-too-long copy).
+*    Without this the CLI printed the whole issues array as a raw JSON blob,
+*    which is the "obtuse 400 with no recourse" a user sees. We lift the first
+*    issue's message, which the schema authors wrote for humans.
+*
+* Anything else (a Cloudflare/ALB HTML error page, an empty body) yields null
+* so the caller can fall back to a status-based line.
+*/
+function serverErrorMessage(body) {
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch (_error) {
+		return null;
+	}
+	if (!isRecord(parsed)) return null;
+	if (typeof parsed.error === "string" && parsed.error.length > 0) return parsed.error;
+	if (isRecord(parsed.error) && Array.isArray(parsed.error.issues)) {
+		const first = parsed.error.issues.find((issue) => isRecord(issue) && typeof issue.message === "string" && !!issue.message);
+		if (first) return first.message;
+	}
+	return null;
+}
+/**
+* A short, actionable line for a failed chat send, for both the interactive
+* TUI error row and the headless `-p` path. The raw transport error is an
+* `HTTP 400: {"success":false,"error":{"issues":[…]}}` blob that a user can do
+* nothing with; this maps every send failure the server can produce to plain
+* language and, where possible, a next step.
+*
+* Precedence: a message the SERVER wrote for humans always wins (validation
+* copy, "agent not found", a billing/permission reason) — we only synthesize a
+* line from the HTTP status when the body carried nothing usable. This keeps
+* new server-side error copy flowing through without a CLI change, while never
+* leaving the user staring at a bare status code.
+*/
+function sendErrorMessage(err) {
+	if (!(err instanceof HttpError)) return `Couldn't reach Skydive (${err instanceof Error ? err.message : String(err)}). Check your connection and try again.`;
+	const fromServer = serverErrorMessage(err.body);
+	switch (err.status) {
+		case 401: return "Your session has expired. Run `skydive auth login --web`, then send again.";
+		case 403: return fromServer ?? "You don't have permission to send to this agent in the current workspace.";
+		case 404: return fromServer ?? "This conversation or agent no longer exists.";
+		case 413: return fromServer ?? "That message is too large to send. Attach it as a file instead of pasting it inline.";
+		case 429: return "You're sending messages too quickly. Wait a moment and try again.";
+		default: break;
+	}
+	if (err.status >= 500) return `Skydive had a problem sending that (HTTP ${err.status}). Wait a moment and try again.`;
+	if (err.status === 400) {
+		if (fromServer && fromServer !== "send failed") return fromServer;
+		return "Skydive couldn't send that message. Try again in a moment.";
+	}
+	return fromServer ?? `Send failed (HTTP ${err.status}).`;
+}
 const MAX_STREAM_RECONNECTS = 5;
-function createRestClient({ appUrl, sessionToken }) {
+function createRestClient({ appUrl, sessionToken, workspaceId }) {
 	const baseHeaders = {
 		authorization: `Bearer ${sessionToken}`,
 		accept: "application/json"
 	};
+	if (workspaceId) baseHeaders["x-workspace-id"] = workspaceId;
 	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(() => ""));
@@ -66,6 +143,7 @@ function createRestClient({ appUrl, sessionToken }) {
 					authorization: `Bearer ${sessionToken}`,
 					accept: "text/event-stream"
 				};
+				if (workspaceId) headers["x-workspace-id"] = workspaceId;
 				if (lastEventId) headers["last-event-id"] = lastEventId;
 				const res = await fetch(`${appUrl}${path}`, {
 					headers,
@@ -138,6 +216,17 @@ function createRestClient({ appUrl, sessionToken }) {
 			const { agent } = await post("/api/v1/agents", { name }, createAgentResponseSchema);
 			return agent;
 		},
+		getAgent: async ({ agentId }) => {
+			const { agent } = await get(`/api/v1/agents/${encodeURIComponent(agentId)}`, getAgentResponseSchema);
+			return {
+				id: agent.id,
+				name: agent.name
+			};
+		},
+		suggestAgentIdentity: async () => {
+			const { suggestion } = await get("/api/v1/agents/suggest", suggestAgentResponseSchema);
+			return suggestion;
+		},
 		getConversation: async ({ conversationId }) => {
 			const { conversation } = await get(`/api/v1/conversations/${encodeURIComponent(conversationId)}`, getConversationResponseSchema);
 			return conversation;
@@ -150,7 +239,8 @@ 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, channels, onPage }) => {
+		listConversations: async ({ agentId, limit, channels, archived, query, onPage }) => {
+			const trimmedQuery = query?.trim();
 			const all = [];
 			const maxConversations = limit ?? 5e3;
 			let cursor;
@@ -162,6 +252,8 @@ function createRestClient({ appUrl, sessionToken }) {
 				});
 				params.set("limit", String(Math.min(remaining, 100)));
 				if (cursor) params.set("cursor", cursor);
+				if (archived) params.set("archived", archived);
+				if (trimmedQuery) params.set("query", trimmedQuery);
 				for (const channel of channels ?? []) params.append("channels", channel);
 				const page = await get(`/api/v1/conversations?${params.toString()}`, listConversationsResponseSchema);
 				all.push(...page.conversations);
@@ -222,9 +314,19 @@ function createRestClient({ appUrl, sessionToken }) {
 				sizeBytes: finalized.sizeBytes ?? size
 			};
 		},
+		forkConversation: async ({ conversationId }) => {
+			const { conversation } = await post(`/api/v1/conversations/${encodeURIComponent(conversationId)}/fork`, {}, forkConversationResponseSchema);
+			return conversation;
+		},
+		compactConversation: async ({ conversationId }) => {
+			await post(`/api/v1/conversations/${encodeURIComponent(conversationId)}/compact`, {}, z.object({ status: z.string() }));
+		},
 		deleteConversation: async ({ conversationId }) => {
 			await del(`/api/v1/conversations/${encodeURIComponent(conversationId)}`);
 		},
+		setConversationArchived: async ({ conversationId, archived }) => {
+			await post(`/api/v1/conversations/${encodeURIComponent(conversationId)}/archive`, { archived }, z.object({ archived: z.boolean() }));
+		},
 		sendMessage: async ({ clientSurface, ...input }) => post("/api/v1/chat/send", {
 			...input,
 			clientSurface
@@ -275,7 +377,8 @@ function createRestClient({ appUrl, sessionToken }) {
 					const res = await fetch(`${appUrl}/api/v1/chat/conversations/${encodeURIComponent(conversationId)}/stream`, {
 						headers: {
 							authorization: `Bearer ${sessionToken}`,
-							accept: "text/event-stream"
+							accept: "text/event-stream",
+							...workspaceId ? { "x-workspace-id": workspaceId } : {}
 						},
 						signal
 					});
@@ -343,6 +446,18 @@ const listAgentsResponseSchema = z.object({
 	totalCount: z.number().nullable().optional()
 });
 const createAgentResponseSchema = z.object({ agent: agentSummarySchema });
+const getAgentResponseSchema = z.object({ agent: z.object({
+	id: z.string(),
+	name: z.string()
+}).passthrough() });
+const agentSuggestionSchema = z.object({ name: z.string() });
+const suggestAgentResponseSchema = z.object({ suggestion: agentSuggestionSchema.nullable() });
+const conversationAgentSchema = z.object({
+	id: z.string().uuid(),
+	name: z.string(),
+	slug: z.string().nullable().optional(),
+	title: z.string().nullable().optional()
+});
 const conversationSummarySchema = z.object({
 	id: z.string().uuid(),
 	title: z.string().nullable(),
@@ -351,20 +466,24 @@ const conversationSummarySchema = z.object({
 	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()
-	})
+	viewerArchivedAt: z.string().nullable().optional(),
+	agent: conversationAgentSchema,
+	agents: z.array(conversationAgentSchema).optional()
 });
 const conversationDetailSchema = z.object({
 	id: z.string().uuid(),
 	title: z.string().nullable(),
 	agentId: z.string().uuid(),
 	createdAt: z.string(),
-	updatedAt: z.string()
+	updatedAt: z.string(),
+	channel: z.string().nullable(),
+	channelLabel: z.string().nullable()
+});
+const conversationTitleSchema = z.object({
+	id: z.string().uuid(),
+	title: z.string().nullable()
 });
+const forkConversationResponseSchema = z.object({ conversation: conversationTitleSchema });
 const getConversationResponseSchema = z.object({ conversation: conversationDetailSchema });
 const listConversationsResponseSchema = z.object({
 	conversations: z.array(conversationSummarySchema),
@@ -444,14 +563,26 @@ 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()
-})]);
+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(),
+		createdAt: z.string().nullish()
+	}),
+	z.object({
+		kind: z.literal("compaction"),
+		status: z.enum([
+			"started",
+			"completed",
+			"failed"
+		])
+	})
+]);
 
 //#endregion
-export { createRestClient as n, errorDetail as r, HttpError as t };
+export { errorMessage as a, sendErrorMessage as i, createRestClient as n, isRecord as o, errorDetail as r, HttpError as t };

package/dist/js/rest-CDTXCmUb.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { i as sendErrorMessage, n as createRestClient, r as errorDetail, t as HttpError } from "./rest-BlN_uWmL.mjs";
+
+export { createRestClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skydive-cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Skydive CLI — cloud agents from the command line",
   "homepage": "https://skydive.com",
   "license": "MIT",
@@ -25,6 +25,7 @@
     "test:ci": "vitest run --coverage --coverage.reporter=lcovonly --reporter=default --reporter=github-actions --minWorkers=1 --maxWorkers=2 --passWithNoTests && yarn test:tui",
     "test:tui": "bun test .tui.test",
     "render:frames": "bun scripts/render-frames.tsx",
+    "render:send-errors": "bun scripts/render-send-errors.tsx",
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
@@ -38,6 +39,7 @@
     "open": "^10.1.0",
     "react": "^19.0.0",
     "react-devtools-core": "^7.0.1",
+    "safe-stable-stringify": "^2.3.1",
     "semver": "^7.7.4",
     "web-tree-sitter": "0.25.10",
     "ws": "^8.21.0",