skydive-cli 0.1.0 → 0.2.0-beta.421

package/dist/js/print-DausK_KZ.mjs

@@ -0,0 +1,484 @@
+#!/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 stableStringify from "safe-stable-stringify";
+
+//#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
+	};
+}
+/**
+* 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;
+	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
+/**
+* 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, machineShare, grantTargetAgent }) {
+	const client = createRestClient({
+		appUrl,
+		sessionToken
+	});
+	const agent = resolveAgent(await client.listAgents({
+		scope: "org",
+		onPage: null
+	}), agentSelector);
+	if (machineShare) {
+		if (!machineShare.isGranted(agent.id) && grantTargetAgent) await machineShare.grantAgent(agent.id);
+		if (machineShare.isGranted(agent.id)) console.error(`portal: shared this machine with ${agent.name} for this run (grant persists until revoked)`);
+		else console.error(`portal: this machine is shared (shareMachineDefault), but ${agent.name} has no grant — approve its request, or run \`skydive portal grant --agent ${agent.name}\`.`);
+	}
+	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 = [];
+	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 {
+		messageId,
+		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
+export { runPrint as a, cardActionErrorMessage as c, reconcileMaskedInput as d, resolveConnectUrl as f, resolveAgent as i, 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 };

package/dist/js/print-share-D7OSxvE2.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { n as printError } from "./output-B4cW10Ph.mjs";
+
+//#region src/chat/print-share.ts
+/**
+* Machine sharing for a scripted one-shot run (`chat -p --share-machine`,
+* `import -p`): connect the portal from launch and hand back the client so
+* the caller can pass it to `runPrint` (which grants the resolved target
+* agent) and dispose it when the run ends.
+*
+* The client retries forever by design; a scripted one-shot needs a bounded
+* failure instead of a silent hang, so a 30s connect timeout exits the
+* process with guidance. Portal telemetry goes to stderr — stdout belongs to
+* the reply (and to --json).
+*/
+async function connectMachineShare({ appUrl, sessionToken, timeoutHint }) {
+	const { PortalClient } = await import("./client-D6NAkL9e.mjs");
+	let signalConnected;
+	const connected = new Promise((resolve) => {
+		signalConnected = resolve;
+	});
+	const machineShare = new PortalClient({
+		appUrl,
+		sessionToken,
+		cwd: process.cwd(),
+		onState: (state) => {
+			if (state.status === "connected") signalConnected();
+			if (state.status === "error") console.error(`portal: connection error: ${state.error ?? "unknown"} — retrying`);
+		}
+	});
+	machineShare.enable();
+	if (await Promise.race([connected.then(() => false), new Promise((resolve) => setTimeout(() => resolve(true), 3e4).unref())])) {
+		machineShare.dispose();
+		printError(`Could not connect the portal within 30s — machine sharing is unavailable (network, or the portal kill switch is off). ${timeoutHint ?? "Check `skydive portal status`."}`);
+		process.exit(1);
+	}
+	return machineShare;
+}
+
+//#endregion
+export { connectMachineShare };

package/dist/js/raw-pty-2_VA1kw_.mjs

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

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

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+import { t as SandboxStream } from "./client-CpEvH2Pq.mjs";
+
+//#region src/chat/sandbox/raw-pty.ts
+/**
+* The transport-and-TTY core of a live sandbox terminal: direct byte
+* passthrough between a raw local TTY and the remote pty.
+*
+*   local stdin  → INPUT frames → sandbox pty
+*   sandbox pty  → DATA frames  → local stdout
+*
+* This is the correct shape for a real terminal: we don't reimplement a
+* terminal emulator, we hand the actual TTY to the remote shell. Callers own
+* the surrounding lifecycle — the chat TUI suspends/resumes its renderer
+* around this (pty-session.ts), the standalone `skydive sandbox` command runs
+* it bare.
+*
+* Detach key: Ctrl-] (0x1d), the classic telnet/ssh escape. Leaving the shell
+* running server-side is NOT a goal here; detaching closes the session.
+*/
+const DETACH_BYTE = 29;
+async function runRawPtyPassthrough(opts) {
+	const { stdin, stdout } = opts;
+	const size = () => ({
+		cols: stdout.columns ?? 80,
+		rows: stdout.rows ?? 24
+	});
+	return await new Promise((resolve) => {
+		let settled = false;
+		const initial = size();
+		const stream = SandboxStream.open({
+			mode: "pty",
+			appUrl: opts.appUrl,
+			sessionToken: opts.sessionToken,
+			agentId: opts.agentId,
+			cols: initial.cols,
+			rows: initial.rows,
+			onEvent: (e) => {
+				switch (e.type) {
+					case "data":
+						stdout.write(e.bytes);
+						break;
+					case "error":
+						stdout.write(`\r\n\x1b[31m${e.message}\x1b[0m\r\n`);
+						finish({
+							reason: "error",
+							code: 1
+						});
+						break;
+					case "exit":
+						finish({
+							reason: "exit",
+							code: e.code
+						});
+						break;
+					case "close":
+						stdout.write(`\r\n\x1b[31m${e.failure ? `Could not open the sandbox terminal: ${e.failure}` : "The sandbox terminal connection closed unexpectedly."}\x1b[0m\r\n`);
+						finish({
+							reason: "error",
+							code: 1
+						});
+						break;
+				}
+			}
+		});
+		const onStdin = (chunk) => {
+			if (chunk.length === 1 && chunk[0] === DETACH_BYTE) {
+				finish({
+					reason: "detach",
+					code: 0
+				});
+				return;
+			}
+			stream.sendInput(new Uint8Array(chunk));
+		};
+		const onResize = () => {
+			const s = size();
+			stream.resize(s.cols, s.rows);
+		};
+		const wasRaw = stdin.isRaw ?? false;
+		stdin.setRawMode?.(true);
+		stdin.resume();
+		stdin.on("data", onStdin);
+		stdout.on("resize", onResize);
+		stream.resize(initial.cols, initial.rows);
+		function finish(result) {
+			if (settled) return;
+			settled = true;
+			stdin.off("data", onStdin);
+			stdout.off("resize", onResize);
+			stdin.setRawMode?.(wasRaw);
+			stream.close();
+			resolve(result);
+		}
+	});
+}
+
+//#endregion
+export { runRawPtyPassthrough as t };

package/dist/js/rest-COkLEZOB.mjs

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