skydive-cli 0.1.0-beta.189 → 0.1.0-beta.199

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.189";
+var version$1 = "0.1.0-beta.199";
 
 //#endregion
 //#region src/types.ts
@@ -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-DaU-F_bM.mjs");
+		const { runChat } = await import("./boot-DGdoNlG2.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -3330,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-DaU-F_bM.mjs");
+			const { runWorkspacePicker } = await import("./boot-DGdoNlG2.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}

package/dist/js/{boot-DaU-F_bM.mjs → boot-DGdoNlG2.mjs}

@@ -62,6 +62,7 @@ const useStore = create((set, get) => ({
 	themeId: DEFAULT_THEME_ID.dark,
 	themeLocked: false,
 	appUrl: null,
+	sessionToken: null,
 	workspaceName: null,
 	rest: null,
 	promptHistoryPath: null,
@@ -98,8 +99,9 @@ const useStore = create((set, get) => ({
 			themeLocked: true
 		});
 	},
-	setClients: ({ appUrl, rest, promptHistoryPath }) => set({
+	setClients: ({ appUrl, sessionToken, rest, promptHistoryPath }) => set({
 		appUrl,
+		sessionToken,
 		rest,
 		promptHistoryPath
 	}),
@@ -534,7 +536,7 @@ var PortalClient = class {
 				this.refreshDevice();
 			});
 			ws.on("message", (data, isBinary) => {
-				if (isBinary) jobs.handleFrame(toBuffer(data));
+				if (isBinary) jobs.handleFrame(toBuffer$1(data));
 			});
 			ws.on("error", (err) => {
 				this.error = errorMessage(err);
@@ -585,7 +587,7 @@ var PortalClient = class {
 		});
 	}
 };
-function toBuffer(data) {
+function toBuffer$1(data) {
 	if (Buffer.isBuffer(data)) return data;
 	if (Array.isArray(data)) return Buffer.concat(data);
 	return Buffer.from(data);
@@ -5071,6 +5073,203 @@ function formatShellContext(command, output, exitCode) {
 	].join("\n");
 }
 
+//#endregion
+//#region src/chat/sandbox/client.ts
+/**
+* Client for the api's `/api/v1/sandbox/stream` WebSocket: relays a `/sandbox`
+* session into the agent's own sandbox — a live interactive PTY or a one-shot
+* streamed exec. Mirrors the transport shape of `portal/client.ts`, but dials a
+* different endpoint and speaks the sandbox-stream frame protocol (see the
+* server's sandbox-stream-ws.ts).
+*/
+const T = {
+	DATA: 1,
+	EXIT: 2,
+	ERROR: 3,
+	INPUT: 16,
+	RESIZE: 17
+};
+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 buf = toBuffer(data);
+			if (buf.length === 0) return;
+			const body = buf.subarray(1);
+			switch (buf[0]) {
+				case T.DATA:
+					onEvent({
+						type: "data",
+						bytes: new Uint8Array(body)
+					});
+					break;
+				case T.EXIT:
+					onEvent({
+						type: "exit",
+						code: body.length >= 4 ? body.readInt32BE(0) : 0
+					});
+					break;
+				case T.ERROR:
+					onEvent({
+						type: "error",
+						message: body.toString("utf8")
+					});
+					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(Buffer.concat([Buffer.from([T.INPUT]), Buffer.from(data)]));
+	}
+	/** Notify the pty of a terminal resize. */
+	resize(cols, rows) {
+		if (this.closed || this.ws.readyState !== WebSocket.OPEN) return;
+		const b = Buffer.allocUnsafe(5);
+		b[0] = T.RESIZE;
+		b.writeUInt16BE(cols & 65535, 1);
+		b.writeUInt16BE(rows & 65535, 3);
+		this.ws.send(b);
+	}
+	close() {
+		this.closed = true;
+		this.ws.close();
+	}
+	/** Open a stream. `mode` is 'pty' (interactive) or 'exec' (one-shot). */
+	static open(opts) {
+		const url = new URL(`${wsBase(opts.appUrl)}/api/v1/sandbox/stream`);
+		url.searchParams.set("agentId", opts.agentId);
+		url.searchParams.set("mode", opts.mode);
+		if (opts.mode === "pty") {
+			url.searchParams.set("cols", String(opts.cols));
+			url.searchParams.set("rows", String(opts.rows));
+		} else url.searchParams.set("command", opts.command);
+		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.
+*/
+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",
+			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;
+				}
+			}
+		});
+		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);
+		}
+	});
+}
+
 //#endregion
 //#region src/chat/tui/screens/chat.tsx
 /**
@@ -5133,6 +5332,7 @@ function ChatScreen({ agent, conversation }) {
 	const rest = useStore((s) => s.rest);
 	const history = usePromptHistory({ filePath: useStore((s) => s.promptHistoryPath) });
 	const appUrl = useStore((s) => s.appUrl);
+	const sessionToken = useStore((s) => s.sessionToken);
 	const goTo = useStore((s) => s.goTo);
 	const setChatTitle = useStore((s) => s.setChatTitle);
 	const portal = useStore((s) => s.portal);
@@ -5591,6 +5791,65 @@ function ChatScreen({ agent, conversation }) {
 		}
 		sendContent(formatShellContext(command, captured, exitCode), [], { echo: false });
 	}, [sendContent]);
+	const runSandboxExec = useCallback((command) => {
+		if (!appUrl || !sessionToken) return;
+		const id = crypto.randomUUID();
+		setItems((prev) => [...prev, {
+			kind: "shell",
+			id,
+			command: `☁ ${command}`,
+			output: "",
+			exit: null
+		}]);
+		const dec = new TextDecoder();
+		const append = (chunk) => setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
+			...m,
+			output: m.output + chunk
+		} : m));
+		const stamp = (exit) => setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
+			...m,
+			exit
+		} : m));
+		SandboxStream.open({
+			mode: "exec",
+			appUrl,
+			sessionToken,
+			agentId: agent.id,
+			command,
+			onEvent: (e) => {
+				if (e.type === "data") append(dec.decode(e.bytes));
+				else if (e.type === "error") {
+					append(`\n${e.message}`);
+					stamp(1);
+				} else if (e.type === "exit") stamp(e.code);
+			}
+		});
+	}, [
+		appUrl,
+		sessionToken,
+		agent.id
+	]);
+	const runSandboxPty = useCallback(async () => {
+		if (!appUrl || !sessionToken) return;
+		const result = await runPtySession({
+			renderer,
+			appUrl,
+			sessionToken,
+			agentId: agent.id
+		});
+		setItems((prev) => [...prev, {
+			kind: "shell",
+			id: crypto.randomUUID(),
+			command: "☁ sandbox terminal",
+			output: result.reason === "error" ? "terminal ended with an error" : result.reason === "detach" ? "detached" : "session ended",
+			exit: result.code
+		}]);
+	}, [
+		appUrl,
+		sessionToken,
+		agent.id,
+		renderer
+	]);
 	const submit = useCallback(() => {
 		const content = input.trim();
 		const attachments = pending;
@@ -5602,11 +5861,8 @@ function ChatScreen({ agent, conversation }) {
 			composerRef.current?.clear();
 			setComposerRows(1);
 			if (routed.kind === "local-shell") runLocalShell(routed.command);
-			else if (routed.kind === "sandbox-exec" || routed.kind === "sandbox-pty") setItems((prev) => [...prev, {
-				kind: "error",
-				id: crypto.randomUUID(),
-				text: "/sandbox is coming soon — run local commands with ! for now."
-			}]);
+			else if (routed.kind === "sandbox-exec") runSandboxExec(routed.command);
+			else if (routed.kind === "sandbox-pty") runSandboxPty();
 			return;
 		}
 		history.append(content);
@@ -5620,7 +5876,9 @@ function ChatScreen({ agent, conversation }) {
 		pending,
 		sendContent,
 		history,
-		runLocalShell
+		runLocalShell,
+		runSandboxExec,
+		runSandboxPty
 	]);
 	const handleComposerChange = useCallback(() => {
 		const composer = composerRef.current;
@@ -6311,6 +6569,7 @@ function App({ appUrl, sessionToken, shareMachine, promptHistoryPath, notificati
 		});
 		setClients({
 			appUrl,
+			sessionToken,
 			rest,
 			promptHistoryPath
 		});

package/package.json

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