skydive-cli 0.1.0-beta.353 → 0.1.0-beta.363

package/dist/js/bin.mjs

@@ -14,9 +14,10 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import zlib from "node:zlib";
 import os from "node:os";
+import { WebSocket } from "ws";
 
 //#region package.json
-var version$1 = "0.1.0-beta.353";
+var version$1 = "0.1.0-beta.363";
 
 //#endregion
 //#region src/types.ts
@@ -838,6 +839,10 @@ const authCommand = {
 
 //#endregion
 //#region src/chat/api/rest.ts
+var rest_exports = /* @__PURE__ */ __exportAll({
+	HttpError: () => HttpError,
+	createRestClient: () => createRestClient
+});
 var HttpError = class extends Error {
 	constructor(status, body) {
 		super(`HTTP ${status}: ${body.slice(0, 200)}`);
@@ -2611,7 +2616,7 @@ const chatCommand = {
 			printError(`Unknown theme "${themeId}". Valid themes: ${themes.map((t) => t.id).join(", ")}`);
 			process.exit(1);
 		}
-		const { runChat } = await import("./boot-DLHvjtxn.mjs");
+		const { runChat } = await import("./boot-C1WUzzUo.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -2653,7 +2658,7 @@ async function runPrintMode({ argv, appUrl }) {
 	}
 	let machineShare = null;
 	if (resolveShareMachine(argv)) {
-		const { PortalClient } = await import("./client-_OL8-XGH.mjs").then((n) => n.n);
+		const { PortalClient } = await import("./client-XFsd0Wy9.mjs").then((n) => n.n);
 		let signalConnected;
 		const connected = new Promise((resolve) => {
 			signalConnected = resolve;
@@ -3405,7 +3410,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-DLHvjtxn.mjs");
+			const { runWorkspacePicker } = await import("./boot-C1WUzzUo.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -3622,7 +3627,7 @@ const openCommand = {
 		const agent = argv.agent ? resolveAgent((await fetchPortalDevices(session)).agents, argv.agent) : null;
 		const cwd = argv.cwd ? path.resolve(argv.cwd) : process.cwd();
 		const { machineName } = machineIdentity();
-		const { PortalClient } = await import("./client-_OL8-XGH.mjs").then((n) => n.n);
+		const { PortalClient } = await import("./client-XFsd0Wy9.mjs").then((n) => n.n);
 		let lastLine = "";
 		let signalConnected;
 		const connected = new Promise((resolve) => {
@@ -3753,10 +3758,298 @@ const portalCommand = {
 	handler: () => {}
 };
 
+//#endregion
+//#region ../sandbox-stream-protocol/src/index.ts
+const SANDBOX_STREAM_PATH = "/api/v1/sandbox/stream";
+const FRAME = {
+	DATA: 1,
+	EXIT: 2,
+	ERROR: 3,
+	INPUT: 16,
+	RESIZE: 17
+};
+const MAX_INPUT_BYTES = 1 * 1024 * 1024;
+/** Query params for the upgrade URL, from a spec. Inverse of {@link parseStreamSpec}. */
+function streamSpecToQuery(spec) {
+	if (spec.mode === "pty") return {
+		agentId: spec.agentId,
+		mode: "pty",
+		cols: String(spec.cols),
+		rows: String(spec.rows)
+	};
+	return {
+		agentId: spec.agentId,
+		mode: "exec",
+		command: spec.command
+	};
+}
+function withType(type, payload) {
+	const frame = new Uint8Array(1 + payload.length);
+	frame[0] = type;
+	frame.set(payload, 1);
+	return frame;
+}
+/** client → server: keystroke bytes for the pty stdin. */
+function encodeInput(data) {
+	return withType(FRAME.INPUT, data);
+}
+/** client → server: the client terminal was resized. */
+function encodeResize(cols, rows) {
+	const frame = new Uint8Array(5);
+	frame[0] = FRAME.RESIZE;
+	const view = new DataView(frame.buffer);
+	view.setUint16(1, cols & 65535);
+	view.setUint16(3, rows & 65535);
+	return frame;
+}
+const view = (frame) => new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+/**
+* Decode a frame the server sent. Returns null for an empty, unknown, or
+* truncated frame — a peer speaking a newer protocol must not crash us.
+*/
+function decodeServerFrame(frame) {
+	const payload = frame.subarray(1);
+	switch (frame[0]) {
+		case FRAME.DATA: return {
+			type: "data",
+			payload
+		};
+		case FRAME.EXIT: return {
+			type: "exit",
+			code: payload.length >= 4 ? view(frame).getInt32(1) : 0
+		};
+		case FRAME.ERROR: return {
+			type: "error",
+			message: new TextDecoder().decode(payload)
+		};
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/chat/sandbox/client.ts
+function wsBase(appUrl) {
+	const base = appUrl.replace(/\/+$/, "");
+	if (base.startsWith("https://")) return `wss://${base.slice(8)}`;
+	if (base.startsWith("http://")) return `ws://${base.slice(7)}`;
+	return `wss://${base}`;
+}
+/**
+* A connected sandbox-stream session. Construct via `openSandboxStream`. Carries
+* the write side (keystrokes / resize for pty mode) and teardown.
+*/
+var SandboxStream = class SandboxStream {
+	ws;
+	closed = false;
+	constructor(ws, onEvent) {
+		this.ws = ws;
+		let ended = false;
+		const emitEnd = (event) => {
+			if (ended) return;
+			ended = true;
+			onEvent(event);
+		};
+		ws.on("message", (data, isBinary) => {
+			if (!isBinary) return;
+			const frame = decodeServerFrame(toBuffer(data));
+			if (!frame) return;
+			switch (frame.type) {
+				case "data":
+					onEvent({
+						type: "data",
+						bytes: new Uint8Array(frame.payload)
+					});
+					break;
+				case "exit":
+					emitEnd({
+						type: "exit",
+						code: frame.code
+					});
+					break;
+				case "error":
+					emitEnd({
+						type: "error",
+						message: frame.message
+					});
+					break;
+			}
+		});
+		let failure = null;
+		ws.on("error", (err) => {
+			failure = err.message;
+		});
+		ws.on("close", () => {
+			this.closed = true;
+			emitEnd({
+				type: "close",
+				failure
+			});
+		});
+	}
+	/** Feed keystroke bytes to the pty stdin. */
+	sendInput(data) {
+		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
+		this.ws.send(encodeInput(data));
+	}
+	/** Notify the pty of a terminal resize. */
+	resize(cols, rows) {
+		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
+		this.ws.send(encodeResize(cols, rows));
+	}
+	close() {
+		this.closed = true;
+		this.ws.close();
+	}
+	/** Open a stream. `mode` is 'pty' (interactive) or 'exec' (one-shot). */
+	static open(opts) {
+		const spec = opts.mode === "pty" ? {
+			mode: "pty",
+			agentId: opts.agentId,
+			cols: opts.cols,
+			rows: opts.rows
+		} : {
+			mode: "exec",
+			agentId: opts.agentId,
+			command: opts.command
+		};
+		const url = new URL(`${wsBase(opts.appUrl)}${SANDBOX_STREAM_PATH}`);
+		for (const [key, value] of Object.entries(streamSpecToQuery(spec))) url.searchParams.set(key, value);
+		return new SandboxStream(new WebSocket(url.toString(), { headers: { authorization: `Bearer ${opts.sessionToken}` } }), opts.onEvent);
+	}
+};
+function toBuffer(data) {
+	if (Buffer.isBuffer(data)) return data;
+	if (Array.isArray(data)) return Buffer.concat(data);
+	return Buffer.from(data);
+}
+
+//#endregion
+//#region src/commands/sandbox.ts
+/** POSIX single-quote one word so the remote shell treats it as one token. */
+function shellQuote(word) {
+	if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(word)) return word;
+	return `'${word.replace(/'/g, `'\\''`)}'`;
+}
+/**
+* Serialize the command words into the single shell string the relay runs.
+*
+* Words arrive already split by the caller's shell, so each must be re-quoted
+* or the remote shell re-splits any word containing spaces or metacharacters:
+* `sandbox -- sh -c 'echo hi; whoami'` would otherwise run `sh -c echo hi`
+* and then, separately, `whoami`. A pipeline still works the explicit way —
+* `sandbox -- sh -c 'ls | wc -l'` — which is what `docker`/`kubectl exec` ask
+* for too. yargs number-coerces bare numerals, so words are stringified.
+*/
+function joinCommandWords(words) {
+	return words.map(String).map(shellQuote).join(" ").trim();
+}
+/**
+* `skydive sandbox` — the standalone counterpart to the chat TUI's `/sandbox`
+* composer command (ANY-4928): a live terminal (or one-shot exec) in the
+* agent's own sandbox without opening the TUI. Runs under Node (no Bun/
+* OpenTUI): the PTY is a raw byte passthrough on the caller's real terminal.
+* The relay gates on EDIT access to the agent and the sandbox-terminal-enabled
+* kill switch, and boots the sandbox when it isn't running.
+*/
+const sandboxCommand = {
+	command: "sandbox [command..]",
+	describe: "Open a live terminal in an agent's sandbox, or run a one-shot command there",
+	builder: (y) => y.option("agent", {
+		type: "string",
+		describe: "Target agent, by id, slug, or name. Optional when the account has exactly one agent."
+	}).positional("command", {
+		type: "string",
+		array: true,
+		describe: "Command to run one-shot (streams output, exits with its exit code). Omit for a live interactive terminal. Put it after `--` if it has flags of its own."
+	}).example("skydive sandbox --agent grace", "Live terminal (Ctrl-] detaches)").example("skydive sandbox --agent grace -- tail -n 50 /tmp/harness.log", "One-shot command (use `--` so its flags reach the sandbox)").example("skydive sandbox --agent grace -- sh -c 'ls /tmp | wc -l'", "Shell features go through an explicit `sh -c`"),
+	handler: async (argv) => {
+		const session = requireSession(argv);
+		const { createRestClient } = await Promise.resolve().then(() => rest_exports);
+		const { resolveAgent } = await Promise.resolve().then(() => print_exports);
+		const client = createRestClient({
+			appUrl: session.appUrl,
+			sessionToken: session.sessionToken
+		});
+		let agent;
+		try {
+			agent = resolveAgent(await client.listAgents({
+				scope: "org",
+				onPage: null
+			}), argv.agent ?? null);
+		} catch (error) {
+			printError(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		const command = joinCommandWords([...argv.command ?? [], ...argv["--"] ?? []]);
+		const code = command ? await runExec({
+			session,
+			agentId: agent.id,
+			command
+		}) : await runPty({
+			session,
+			agentId: agent.id,
+			agentName: agent.name
+		});
+		process.exit(code);
+	}
+};
+/** One-shot exec: stream output to stdout, resolve to the command's exit code. */
+function runExec({ session, agentId, command }) {
+	console.error("Connecting to the sandbox…");
+	return new Promise((resolve) => {
+		const finish = (code) => {
+			process.stdout.write("", () => resolve(code));
+		};
+		SandboxStream.open({
+			mode: "exec",
+			appUrl: session.appUrl,
+			sessionToken: session.sessionToken,
+			agentId,
+			command,
+			onEvent: (e) => {
+				switch (e.type) {
+					case "data":
+						process.stdout.write(e.bytes);
+						break;
+					case "exit":
+						finish(e.code);
+						break;
+					case "error":
+						printError(e.message);
+						finish(1);
+						break;
+					case "close":
+						printError(e.failure ? `Could not run the command in the sandbox: ${e.failure}` : "The connection to the sandbox closed before the command finished.");
+						finish(1);
+						break;
+				}
+			}
+		});
+	});
+}
+/** Live terminal on the caller's real TTY. */
+async function runPty({ session, agentId, agentName }) {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		printError("A live sandbox terminal needs an interactive TTY. For scripted use, pass a command: `skydive sandbox -- <cmd>`.");
+		return 1;
+	}
+	console.error(`Connecting to ${agentName}'s sandbox… (Ctrl-] detaches)`);
+	const { runRawPtyPassthrough } = await import("./raw-pty-C1DXKms6.mjs").then((n) => n.t);
+	const result = await runRawPtyPassthrough({
+		stdin: process.stdin,
+		stdout: process.stdout,
+		appUrl: session.appUrl,
+		sessionToken: session.sessionToken,
+		agentId
+	});
+	if (result.reason === "detach") console.error("\nDetached.");
+	return result.code;
+}
+
 //#endregion
 //#region src/cli.ts
 function createCli(argv) {
-	return yargs(argv).scriptName("skydive").usage("$0 <command> [options]").example("skydive auth login", "Store your API key").example("skydive chat", "Open the interactive chat TUI (prod)").example("skydive chat --api-url http://localhost:4500", "Chat against a local dev API").example("skydive agents list", "List your agents").example("skydive keys create \"my-key\"", "Create an API key").example("skydive secrets set OPENAI_API_KEY --agent-id <id>", "Set a secret (value from stdin)").example("skydive workspace list", "List workspaces on your account").example("skydive workspace switch acme-team", "Switch the workspace all `skydive` commands act on").example("skydive portal open --agent grace", "Open the portal to this machine for an agent, headless (no TUI)").option("json", {
+	return yargs(argv).scriptName("skydive").usage("$0 <command> [options]").parserConfiguration({ "populate--": true }).example("skydive auth login", "Store your API key").example("skydive chat", "Open the interactive chat TUI (prod)").example("skydive chat --api-url http://localhost:4500", "Chat against a local dev API").example("skydive agents list", "List your agents").example("skydive keys create \"my-key\"", "Create an API key").example("skydive secrets set OPENAI_API_KEY --agent-id <id>", "Set a secret (value from stdin)").example("skydive workspace list", "List workspaces on your account").example("skydive workspace switch acme-team", "Switch the workspace all `skydive` commands act on").example("skydive portal open --agent grace", "Open the portal to this machine for an agent, headless (no TUI)").option("json", {
 		type: "boolean",
 		default: false,
 		global: true,
@@ -3770,7 +4063,7 @@ function createCli(argv) {
 		type: "string",
 		global: true,
 		describe: "Override API base URL"
-	}).command(authCommand).command(chatCommand).command(messagesCommand).command(conversationsCommand).command(agentsCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).command(portalCommand).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).command(portalCommand).command(sandboxCommand).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);
 	});
@@ -3844,4 +4137,4 @@ function resolveArgv(args, tty = {
 createCli(resolveArgv(hideBin(process.argv))).parse();
 
 //#endregion
-export { createRestClient as A, theme as C, themeVersion as D, themeModeFromColorFgBg as E, DEFAULT_APP_URL as F, getConfigPath as I, getSavedTheme as L, listWorkspaces as M, setActiveWorkspace as N, themesForMode as O, DEFAULT_API_URL as P, resolveWebUrl as R, noColorRequested as S, themeMode as T, isRecord as _, buildEnv as a, findTheme as b, resolveAgent as c, parseExternalOauthConnectParams as d, parseOauthConnectParams as f, errorMessage as g, parseConnectCard as h, mintPortalDeviceToken as i, getActiveWorkspaceId as j, HttpError as k, MASK_CHAR as l, resolveConnectUrl as m, findThisDevice as n, machineIdentity as o, reconcileMaskedInput as p, grantPortalAccess as r, portalWsUrl as s, fetchPortalDevices as t, cardActionErrorMessage as u, DEFAULT_THEME_ID as v, themeForMode as w, monoTheme as x, applyTheme as y, saveTheme as z };
+export { HttpError as A, saveTheme as B, noColorRequested as C, themeModeFromColorFgBg as D, themeMode as E, DEFAULT_API_URL as F, DEFAULT_APP_URL as I, getConfigPath as L, getActiveWorkspaceId as M, listWorkspaces as N, themeVersion as O, setActiveWorkspace as P, getSavedTheme as R, monoTheme as S, themeForMode as T, errorMessage as _, mintPortalDeviceToken as a, applyTheme as b, portalWsUrl as c, cardActionErrorMessage as d, parseExternalOauthConnectParams as f, parseConnectCard as g, resolveConnectUrl as h, grantPortalAccess as i, createRestClient as j, themesForMode as k, resolveAgent as l, reconcileMaskedInput as m, fetchPortalDevices as n, buildEnv as o, parseOauthConnectParams as p, findThisDevice as r, machineIdentity as s, SandboxStream as t, MASK_CHAR as u, isRecord as v, theme as w, findTheme as x, DEFAULT_THEME_ID as y, resolveWebUrl as z };

package/dist/js/{boot-DLHvjtxn.mjs → boot-C1WUzzUo.mjs}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
-import { A as createRestClient, C as theme, D as themeVersion, E as themeModeFromColorFgBg, F as DEFAULT_APP_URL, I as getConfigPath, L as getSavedTheme, M as listWorkspaces, N as setActiveWorkspace, O as themesForMode, P as DEFAULT_API_URL, R as resolveWebUrl, S as noColorRequested, T as themeMode, _ as isRecord, b as findTheme, c as resolveAgent, d as parseExternalOauthConnectParams, f as parseOauthConnectParams, g as errorMessage, h as parseConnectCard, j as getActiveWorkspaceId, k as HttpError, l as MASK_CHAR, m as resolveConnectUrl, p as reconcileMaskedInput, u as cardActionErrorMessage, v as DEFAULT_THEME_ID, w as themeForMode, x as monoTheme, y as applyTheme, z as saveTheme } from "./bin.mjs";
-import { t as PortalClient } from "./client-_OL8-XGH.mjs";
+import { A as HttpError, B as saveTheme, C as noColorRequested, D as themeModeFromColorFgBg, E as themeMode, F as DEFAULT_API_URL, I as DEFAULT_APP_URL, L as getConfigPath, M as getActiveWorkspaceId, N as listWorkspaces, O as themeVersion, P as setActiveWorkspace, R as getSavedTheme, S as monoTheme, T as themeForMode, _ as errorMessage, b as applyTheme, d as cardActionErrorMessage, f as parseExternalOauthConnectParams, g as parseConnectCard, h as resolveConnectUrl, j as createRestClient, k as themesForMode, l as resolveAgent, m as reconcileMaskedInput, p as parseOauthConnectParams, t as SandboxStream, u as MASK_CHAR, v as isRecord, w as theme, x as findTheme, y as DEFAULT_THEME_ID, z as resolveWebUrl } from "./bin.mjs";
+import { t as PortalClient } from "./client-XFsd0Wy9.mjs";
+import { n as runRawPtyPassthrough } from "./raw-pty-C1DXKms6.mjs";
 import path, { basename, extname, isAbsolute, join, win32 } from "node:path";
 import { z } from "zod";
 import open from "open";
@@ -13,7 +14,6 @@ import { MarkdownRenderable, RenderableEvents, SyntaxStyle, createCliRenderer, d
 import { createRoot, extend, useKeyboard, usePaste, useRenderer, useTerminalDimensions } from "@opentui/react";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { create } from "zustand";
-import { WebSocket } from "ws";
 import { createConnection } from "node:net";
 import { access, appendFile, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { Fragment, jsx, jsxs } from "@opentui/react/jsx-runtime";
@@ -5284,255 +5284,30 @@ function formatShellContext(command, output, exitCode) {
 	].join("\n");
 }
 
-//#endregion
-//#region ../sandbox-stream-protocol/src/index.ts
-const SANDBOX_STREAM_PATH = "/api/v1/sandbox/stream";
-const FRAME = {
-	DATA: 1,
-	EXIT: 2,
-	ERROR: 3,
-	INPUT: 16,
-	RESIZE: 17
-};
-const MAX_INPUT_BYTES = 1 * 1024 * 1024;
-/** Query params for the upgrade URL, from a spec. Inverse of {@link parseStreamSpec}. */
-function streamSpecToQuery(spec) {
-	if (spec.mode === "pty") return {
-		agentId: spec.agentId,
-		mode: "pty",
-		cols: String(spec.cols),
-		rows: String(spec.rows)
-	};
-	return {
-		agentId: spec.agentId,
-		mode: "exec",
-		command: spec.command
-	};
-}
-function withType(type, payload) {
-	const frame = new Uint8Array(1 + payload.length);
-	frame[0] = type;
-	frame.set(payload, 1);
-	return frame;
-}
-/** client → server: keystroke bytes for the pty stdin. */
-function encodeInput(data) {
-	return withType(FRAME.INPUT, data);
-}
-/** client → server: the client terminal was resized. */
-function encodeResize(cols, rows) {
-	const frame = new Uint8Array(5);
-	frame[0] = FRAME.RESIZE;
-	const view = new DataView(frame.buffer);
-	view.setUint16(1, cols & 65535);
-	view.setUint16(3, rows & 65535);
-	return frame;
-}
-const view = (frame) => new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
-/**
-* Decode a frame the server sent. Returns null for an empty, unknown, or
-* truncated frame — a peer speaking a newer protocol must not crash us.
-*/
-function decodeServerFrame(frame) {
-	const payload = frame.subarray(1);
-	switch (frame[0]) {
-		case FRAME.DATA: return {
-			type: "data",
-			payload
-		};
-		case FRAME.EXIT: return {
-			type: "exit",
-			code: payload.length >= 4 ? view(frame).getInt32(1) : 0
-		};
-		case FRAME.ERROR: return {
-			type: "error",
-			message: new TextDecoder().decode(payload)
-		};
-		default: return null;
-	}
-}
-
-//#endregion
-//#region src/chat/sandbox/client.ts
-function wsBase(appUrl) {
-	const base = appUrl.replace(/\/+$/, "");
-	if (base.startsWith("https://")) return `wss://${base.slice(8)}`;
-	if (base.startsWith("http://")) return `ws://${base.slice(7)}`;
-	return `wss://${base}`;
-}
-/**
-* A connected sandbox-stream session. Construct via `openSandboxStream`. Carries
-* the write side (keystrokes / resize for pty mode) and teardown.
-*/
-var SandboxStream = class SandboxStream {
-	ws;
-	closed = false;
-	constructor(ws, onEvent) {
-		this.ws = ws;
-		ws.on("message", (data, isBinary) => {
-			if (!isBinary) return;
-			const frame = decodeServerFrame(toBuffer(data));
-			if (!frame) return;
-			switch (frame.type) {
-				case "data":
-					onEvent({
-						type: "data",
-						bytes: new Uint8Array(frame.payload)
-					});
-					break;
-				case "exit":
-					onEvent({
-						type: "exit",
-						code: frame.code
-					});
-					break;
-				case "error":
-					onEvent({
-						type: "error",
-						message: frame.message
-					});
-					break;
-			}
-		});
-		ws.on("close", () => {
-			this.closed = true;
-			onEvent({ type: "close" });
-		});
-		ws.on("error", () => {});
-	}
-	/** Feed keystroke bytes to the pty stdin. */
-	sendInput(data) {
-		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
-		this.ws.send(encodeInput(data));
-	}
-	/** Notify the pty of a terminal resize. */
-	resize(cols, rows) {
-		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
-		this.ws.send(encodeResize(cols, rows));
-	}
-	close() {
-		this.closed = true;
-		this.ws.close();
-	}
-	/** Open a stream. `mode` is 'pty' (interactive) or 'exec' (one-shot). */
-	static open(opts) {
-		const spec = opts.mode === "pty" ? {
-			mode: "pty",
-			agentId: opts.agentId,
-			cols: opts.cols,
-			rows: opts.rows
-		} : {
-			mode: "exec",
-			agentId: opts.agentId,
-			command: opts.command
-		};
-		const url = new URL(`${wsBase(opts.appUrl)}${SANDBOX_STREAM_PATH}`);
-		for (const [key, value] of Object.entries(streamSpecToQuery(spec))) url.searchParams.set(key, value);
-		return new SandboxStream(new WebSocket(url.toString(), { headers: { authorization: `Bearer ${opts.sessionToken}` } }), opts.onEvent);
-	}
-};
-function toBuffer(data) {
-	if (Buffer.isBuffer(data)) return data;
-	if (Array.isArray(data)) return Buffer.concat(data);
-	return Buffer.from(data);
-}
-
 //#endregion
 //#region src/chat/sandbox/pty-session.ts
 /**
 * Runs a live interactive PTY into the agent's sandbox as a full-screen raw
-* terminal, by SUSPENDING the opentui renderer for the duration and doing a
-* direct byte passthrough:
-*
-*   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. On exit
-* (the shell exits, the socket drops, or the user hits the detach key) we
-* restore the terminal and resume the TUI.
-*
-* Detach key: Ctrl-] (0x1d), the classic telnet/ssh escape — leaves the shell
-* running server-side is NOT a goal here; detaching closes the session.
+* terminal from inside the chat TUI, by SUSPENDING the opentui renderer for
+* the duration (restoring the normal screen buffer and releasing the terminal
+* and its input to us) and handing the TTY to the shared raw passthrough
+* (raw-pty.ts). On exit (the shell exits, the socket drops, or the user hits
+* Ctrl-]) the terminal is restored and the TUI resumes.
 */
-const DETACH_BYTE = 29;
 async function runPtySession(opts) {
 	const { renderer } = opts;
-	const stdin = renderer.stdin;
-	const stdout = process.stdout;
-	const size = () => ({
-		cols: stdout.columns ?? 80,
-		rows: stdout.rows ?? 24
-	});
 	renderer.suspend();
-	return await new Promise((resolve) => {
-		let settled = false;
-		const initial = size();
-		const stream = SandboxStream.open({
-			mode: "pty",
+	try {
+		return await runRawPtyPassthrough({
+			stdin: renderer.stdin,
+			stdout: process.stdout,
 			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":
-						finish({
-							reason: "exit",
-							code: 0
-						});
-						break;
-				}
-			}
+			agentId: opts.agentId
 		});
-		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();
-			renderer.resume();
-			resolve(result);
-		}
-	});
+	} finally {
+		renderer.resume();
+	}
 }
 
 //#endregion
@@ -6142,6 +5917,10 @@ function ChatScreen({ agent, conversation }) {
 					append(`\n${e.message}`);
 					stamp(1);
 				} else if (e.type === "exit") stamp(e.code);
+				else if (e.type === "close") {
+					append(`\n${e.failure ? `connection failed: ${e.failure}` : "connection closed before the command finished"}`);
+					stamp(1);
+				}
 			}
 		});
 	}, [

package/dist/js/{client-_OL8-XGH.mjs → client-XFsd0Wy9.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as __exportAll } from "./rolldown-runtime-Cz4Tg37Z.mjs";
-import { a as buildEnv, g as errorMessage, i as mintPortalDeviceToken, n as findThisDevice, o as machineIdentity, r as grantPortalAccess, s as portalWsUrl, t as fetchPortalDevices } from "./bin.mjs";
+import { _ as errorMessage, a as mintPortalDeviceToken, c as portalWsUrl, i as grantPortalAccess, n as fetchPortalDevices, o as buildEnv, r as findThisDevice, s as machineIdentity } from "./bin.mjs";
 import { z } from "zod";
 import { spawn } from "node:child_process";
 import { WebSocket } from "ws";

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

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import { t as __exportAll } from "./rolldown-runtime-Cz4Tg37Z.mjs";
+import { t as SandboxStream } from "./bin.mjs";
+
+//#region src/chat/sandbox/raw-pty.ts
+var raw_pty_exports = /* @__PURE__ */ __exportAll({ runRawPtyPassthrough: () => runRawPtyPassthrough });
+/**
+* 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 n, raw_pty_exports as t };

package/package.json

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