skydive-cli 0.1.0-beta.186 → 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.186";
+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-BEMmVR8C.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-BEMmVR8C.mjs");
+			const { runWorkspacePicker } = await import("./boot-DGdoNlG2.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -3457,4 +3457,4 @@ function resolveArgv(args, tty = {
 createCli(resolveArgv(hideBin(process.argv))).parse();
 
 //#endregion
-export { resolveWebUrl as A, themesForMode as C, DEFAULT_API_URL as D, setActiveWorkspace as E, DEFAULT_APP_URL as O, themeVersion as S, listWorkspaces as T, noColorRequested as _, parseOauthConnectParams as a, themeMode as b, parseConnectCard as c, HttpError as d, createRestClient as f, monoTheme as g, findTheme as h, parseExternalOauthConnectParams as i, saveTheme as j, getSavedTheme as k, errorMessage as l, applyTheme as m, MASK_CHAR as n, reconcileMaskedInput as o, DEFAULT_THEME_ID as p, cardActionErrorMessage as r, resolveConnectUrl as s, resolveAgent as t, isRecord as u, theme as v, getActiveWorkspaceId as w, themeModeFromColorFgBg as x, themeForMode as y };
+export { getSavedTheme as A, themesForMode as C, DEFAULT_API_URL as D, setActiveWorkspace as E, saveTheme as M, DEFAULT_APP_URL as O, themeVersion as S, listWorkspaces as T, noColorRequested as _, parseOauthConnectParams as a, themeMode as b, parseConnectCard as c, HttpError as d, createRestClient as f, monoTheme as g, findTheme as h, parseExternalOauthConnectParams as i, resolveWebUrl as j, getConfigPath as k, errorMessage as l, applyTheme as m, MASK_CHAR as n, reconcileMaskedInput as o, DEFAULT_THEME_ID as p, cardActionErrorMessage as r, resolveConnectUrl as s, resolveAgent as t, isRecord as u, theme as v, getActiveWorkspaceId as w, themeModeFromColorFgBg as x, themeForMode as y };

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

@@ -1,17 +1,20 @@
 #!/usr/bin/env node
-import { A as resolveWebUrl, C as themesForMode, D as DEFAULT_API_URL, E as setActiveWorkspace, O as DEFAULT_APP_URL, S as themeVersion, T as listWorkspaces, _ as noColorRequested, a as parseOauthConnectParams, b as themeMode, c as parseConnectCard, d as HttpError, f as createRestClient, g as monoTheme, h as findTheme, i as parseExternalOauthConnectParams, j as saveTheme, k as getSavedTheme, l as errorMessage, m as applyTheme, n as MASK_CHAR, o as reconcileMaskedInput, p as DEFAULT_THEME_ID, r as cardActionErrorMessage, s as resolveConnectUrl, t as resolveAgent, u as isRecord, v as theme, w as getActiveWorkspaceId, x as themeModeFromColorFgBg, y as themeForMode } from "./bin.mjs";
+import { A as getSavedTheme, C as themesForMode, D as DEFAULT_API_URL, E as setActiveWorkspace, M as saveTheme, O as DEFAULT_APP_URL, S as themeVersion, T as listWorkspaces, _ as noColorRequested, a as parseOauthConnectParams, b as themeMode, c as parseConnectCard, d as HttpError, f as createRestClient, g as monoTheme, h as findTheme, i as parseExternalOauthConnectParams, j as resolveWebUrl, k as getConfigPath, l as errorMessage, m as applyTheme, n as MASK_CHAR, o as reconcileMaskedInput, p as DEFAULT_THEME_ID, r as cardActionErrorMessage, s as resolveConnectUrl, t as resolveAgent, u as isRecord, v as theme, w as getActiveWorkspaceId, x as themeModeFromColorFgBg, y as themeForMode } from "./bin.mjs";
 import path, { basename, isAbsolute, join, win32 } from "node:path";
 import { z } from "zod";
 import open from "open";
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
 import { MarkdownRenderable, RenderableEvents, SyntaxStyle, createCliRenderer, decodePasteBytes, detectLinks } from "@opentui/core";
 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 * as os$1 from "node:os";
 import os, { homedir, platform, release, tmpdir } from "node:os";
 import { createConnection } from "node:net";
-import { appendFile, mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { access, appendFile, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { Fragment, jsx, jsxs } from "@opentui/react/jsx-runtime";
 import { fileURLToPath } from "node:url";
 import { fileTypeFromBuffer } from "file-type";
@@ -59,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,
@@ -95,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
 	}),
@@ -531,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);
@@ -582,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);
@@ -3073,6 +3078,44 @@ function parseMatches(output) {
 	return null;
 }
 
+//#endregion
+//#region src/chat/tui/chunks/shell-local.tsx
+/**
+* Renders a `! <cmd>` local-shell escape: the command the user ran on their own
+* machine, followed by its combined stdout/stderr. Visually distinct from agent
+* tool calls (which run in the sandbox) — a `!` sigil colored by outcome (dim
+* while running, success/error once done), so a glance tells you this executed
+* locally, not on the agent.
+*/
+function ShellLocalItem({ item }) {
+	const running = item.exit === null;
+	const failed = item.exit !== null && item.exit !== 0;
+	return /* @__PURE__ */ jsxs("box", {
+		style: { flexDirection: "column" },
+		children: [/* @__PURE__ */ jsxs("text", { children: [
+			/* @__PURE__ */ jsx("span", {
+				fg: running ? theme.dim : failed ? theme.error : theme.success,
+				children: "! "
+			}),
+			/* @__PURE__ */ jsx("span", {
+				fg: theme.tool,
+				children: item.command
+			}),
+			running ? /* @__PURE__ */ jsx("span", {
+				fg: theme.dim,
+				children: " · running…"
+			}) : null,
+			failed ? /* @__PURE__ */ jsxs("span", {
+				fg: theme.error,
+				children: [" · exit ", item.exit]
+			}) : null
+		] }), item.output ? /* @__PURE__ */ jsx(Indented, { children: /* @__PURE__ */ jsx("text", {
+			fg: theme.muted,
+			children: item.output.replace(/\n+$/, "")
+		}) }) : null]
+	});
+}
+
 //#endregion
 //#region src/chat/tui/chunks/index.tsx
 /**
@@ -3162,6 +3205,10 @@ function RenderItem({ item }) {
 				]
 			})
 		});
+		case "shell": return /* @__PURE__ */ jsx(Row, {
+			barColor: null,
+			children: /* @__PURE__ */ jsx(ShellLocalItem, { item })
+		});
 	}
 }
 function StreamingAssistantText({ text }) {
@@ -4661,6 +4708,568 @@ function ThemePicker({ onClose }) {
 	});
 }
 
+//#endregion
+//#region src/chat/shell/snapshot.ts
+/**
+* Shell snapshot for the `!` local-shell escape.
+*
+* The chat composer runs on the user's own machine. When they type `! <cmd>`,
+* we want that command to see their real interactive-shell setup — aliases,
+* functions, shell options, PATH — the same way it would in their terminal.
+*
+* Aliases and functions live in ~/.zshrc / ~/.bashrc, which non-interactive
+* shells don't source (or source without alias expansion), and are never
+* exported to child processes. Re-sourcing the rc file on every command is slow
+* (100s of ms with nvm/rbenv/oh-my-zsh) and can hang on interactive prompts.
+*
+* So, once per session, we run the user's login shell, source their rc, and
+* serialize the resulting state into a standalone .sh file. Every `!` command
+* then sources that cheap file and runs. This mirrors the approach Claude Code
+* uses for its bash mode.
+*
+* The snapshot is cached on disk keyed by (shell, rc-file mtime), so it is
+* built once and reused across CLI sessions, and regenerated automatically when
+* the user edits their rc file. There is deliberately no `!!` sigil — a second
+* bang has a base shell meaning (history expansion) we do not override; the
+* agent-sandbox counterpart is the `/sandbox` slash command, not a sigil.
+*/
+const SNAPSHOT_CREATION_TIMEOUT_MS = 1e4;
+const SNAPSHOT_MAX_BUFFER = 1024 * 1024;
+/**
+* Resolve which shell the `!` escape uses. Order:
+*   $SKYDIVE_SHELL (if it names bash/zsh and is executable)
+*   $SHELL (if it names bash/zsh and is executable)
+*   `zsh` / `bash` found on $PATH
+*   `zsh` / `bash` in common install locations
+*   /bin/sh as a last resort
+* Preference is bash-first when $SHELL mentions bash, else zsh-first — matching
+* the user's actual login shell where we can tell.
+*/
+async function resolveShell(env = process.env) {
+	const override = env.SKYDIVE_SHELL;
+	if (override && /bash|zsh/.test(override) && await isExecutable(override)) return describeShell(override);
+	const shellEnv = env.SHELL;
+	if (shellEnv && /bash|zsh/.test(shellEnv) && await isExecutable(shellEnv)) return describeShell(shellEnv);
+	const candidates = !!shellEnv && shellEnv.includes("bash") ? ["bash", "zsh"] : ["zsh", "bash"];
+	for (const name of candidates) {
+		const found = await whichOnPath(name, env);
+		if (found) return describeShell(found);
+	}
+	const searchDirs = [
+		"/bin",
+		"/usr/bin",
+		"/usr/local/bin",
+		"/opt/homebrew/bin",
+		"/run/current-system/sw/bin"
+	];
+	for (const name of candidates) for (const dir of searchDirs) {
+		const full = path.join(dir, name);
+		if (await isExecutable(full)) return describeShell(full);
+	}
+	return describeShell("/bin/sh");
+}
+/**
+* Resolve `name` against $PATH, returning the first executable match, or
+* undefined. Pure filesystem lookup (no subprocess), matching `command -v`
+* semantics for a bare command name.
+*/
+async function whichOnPath(name, env) {
+	const pathVar = env.PATH ?? "";
+	if (!pathVar) return void 0;
+	for (const dir of pathVar.split(path.delimiter)) {
+		if (!dir) continue;
+		const full = path.join(dir, name);
+		if (await isExecutable(full)) return full;
+	}
+}
+function describeShell(bin) {
+	const kind = bin.includes("zsh") ? "zsh" : bin.includes("bash") ? "bash" : "sh";
+	const rcName = kind === "zsh" ? ".zshrc" : kind === "bash" ? ".bashrc" : ".profile";
+	return {
+		bin,
+		kind,
+		rcFile: path.join(os$1.homedir(), rcName)
+	};
+}
+async function isExecutable(p) {
+	try {
+		await access(p, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Directory where cached snapshots live (next to the CLI's Conf store). */
+function snapshotsDir() {
+	return path.join(path.dirname(getConfigPath()), "shell-snapshots");
+}
+/**
+* Cache key: the snapshot is valid as long as the shell binary and the rc
+* file's mtime are unchanged. Editing the rc regenerates on the next `!`.
+*/
+async function cacheKey(shell) {
+	let rcMtime = "none";
+	try {
+		rcMtime = String((await stat(shell.rcFile)).mtimeMs);
+	} catch {}
+	return createHash("sha256").update(`${shell.bin}\0${shell.rcFile}\0${rcMtime}`).digest("hex").slice(0, 16);
+}
+function cachePath(shell, key) {
+	return path.join(snapshotsDir(), `snapshot-${shell.kind}-${key}.sh`);
+}
+/**
+* Build the script we run inside the user's login shell to emit the snapshot.
+* Exported for tests — the generated script is the load-bearing surface.
+*/
+function buildSnapshotScript(shell, snapshotFilePath, rcFileExists, pathValue) {
+	const isZsh = shell.kind === "zsh";
+	const header = [
+		`SNAPSHOT_FILE=${shQuote(snapshotFilePath)}`,
+		rcFileExists ? `source ${shQuote(shell.rcFile)} < /dev/null` : "# no rc file to source",
+		`echo "# skydive shell snapshot" >| "$SNAPSHOT_FILE"`,
+		`echo "unalias -a 2>/dev/null || true" >> "$SNAPSHOT_FILE"`
+	].join("\n");
+	const functions = isZsh ? [
+		`echo "# functions" >> "$SNAPSHOT_FILE"`,
+		`typeset -f > /dev/null 2>&1`,
+		`typeset +f | grep -vE '^_[^_]' | while read func; do`,
+		`  typeset -f "$func" >> "$SNAPSHOT_FILE"`,
+		`done`
+	].join("\n") : [
+		`echo "# functions" >> "$SNAPSHOT_FILE"`,
+		`declare -f > /dev/null 2>&1`,
+		`declare -F | cut -d' ' -f3 | grep -vE '^_[^_]' | while read func; do`,
+		`  encoded_func=$(declare -f "$func" | base64)`,
+		`  echo "eval \\"\\$(echo '$encoded_func' | base64 -d)\\" > /dev/null 2>&1" >> "$SNAPSHOT_FILE"`,
+		`done`
+	].join("\n");
+	const options = isZsh ? [`echo "# options" >> "$SNAPSHOT_FILE"`, `setopt | sed 's/^/setopt /' | head -n 1000 >> "$SNAPSHOT_FILE"`].join("\n") : [
+		`echo "# options" >> "$SNAPSHOT_FILE"`,
+		`shopt -p | head -n 1000 >> "$SNAPSHOT_FILE"`,
+		`set -o | grep "on" | awk '{print "set -o " $1}' | head -n 1000 >> "$SNAPSHOT_FILE"`,
+		`echo "shopt -s expand_aliases" >> "$SNAPSHOT_FILE"`
+	].join("\n");
+	const aliases = [`echo "# aliases" >> "$SNAPSHOT_FILE"`, `alias | sed 's/^alias //g' | sed 's/^/alias -- /' | head -n 1000 >> "$SNAPSHOT_FILE"`].join("\n");
+	const pathPin = `echo "export PATH=${shQuote(pathValue)}" >> "$SNAPSHOT_FILE"`;
+	const bashNoRcExpand = !rcFileExists && shell.kind === "bash" ? `echo "shopt -s expand_aliases" >> "$SNAPSHOT_FILE"` : "# rc present or non-bash";
+	return [
+		header,
+		rcFileExists ? functions : "# no rc: skip functions",
+		rcFileExists ? options : bashNoRcExpand,
+		rcFileExists ? aliases : "# no rc: skip aliases",
+		pathPin,
+		`if [ ! -f "$SNAPSHOT_FILE" ]; then echo "snapshot not created" >&2; exit 1; fi`
+	].join("\n\n");
+}
+/**
+* Ensure a valid snapshot exists and return its path, or undefined if creation
+* failed (soft failure — the caller falls back to a login shell). Reuses a
+* cached snapshot when the rc file is unchanged.
+*/
+async function ensureSnapshot(shell, env = process.env) {
+	const out = cachePath(shell, await cacheKey(shell));
+	try {
+		await access(out);
+		return out;
+	} catch {}
+	let rcFileExists = false;
+	try {
+		await access(shell.rcFile);
+		rcFileExists = true;
+	} catch {
+		rcFileExists = false;
+	}
+	await mkdir(snapshotsDir(), { recursive: true });
+	const script = buildSnapshotScript(shell, out, rcFileExists, env.PATH ?? "");
+	if (!await new Promise((resolve) => {
+		execFile(shell.bin, [
+			"-c",
+			"-l",
+			script
+		], {
+			env: {
+				...env,
+				SHELL: shell.bin,
+				GIT_EDITOR: "true"
+			},
+			timeout: SNAPSHOT_CREATION_TIMEOUT_MS,
+			maxBuffer: SNAPSHOT_MAX_BUFFER,
+			encoding: "utf8"
+		}, (error) => resolve(!error));
+	})) return void 0;
+	try {
+		await readFile(out, "utf8");
+		return out;
+	} catch {
+		return;
+	}
+}
+/** Shell-quote a single string for safe interpolation (single-quote wrap). */
+function shQuote(s) {
+	return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+
+//#endregion
+//#region src/chat/shell/run.ts
+/**
+* Runs a single `! <cmd>` local-shell command with the user's snapshotted
+* shell environment (aliases / functions / options / PATH), and routes the
+* chat composer's raw input to the right destination.
+*
+* The per-command string is, joined by ` && `:
+*
+*   source '<snapshot>' 2>/dev/null || true
+*   shopt -u extglob 2>/dev/null || true        # zsh: setopt NO_EXTENDED_GLOB
+*   eval '<user command, shell-quoted>'
+*   pwd -P >| '<cwd file>'
+*
+* Two details carry the whole feature:
+*
+*  1. `eval` is REQUIRED. A shell parses an entire line before executing any of
+*     it, so aliases sourced on that same line are not yet available when the
+*     line is parsed. Routing the command through `eval` forces a second parse
+*     pass, at which point the aliases exist. `source snapshot && ll` would NOT
+*     expand `ll`; `source snapshot && eval 'll'` does. This is the trick.
+*
+*  2. `pwd -P >| <file>`, read back after the process exits, is how cwd persists
+*     across `!` commands — each command is a fresh process, so `! cd foo` then
+*     `! ls` only works if we carry the cwd forward ourselves.
+*
+* When no snapshot could be built we fall back to a login shell (`-c -l`) so the
+* user at least gets their rc-driven environment, just slower.
+*/
+/** Create a session: resolve the shell and build/reuse its snapshot once. */
+async function createShellSession(env = process.env) {
+	const shell = await resolveShell(env);
+	return {
+		shell,
+		snapshotPath: await ensureSnapshot(shell, env),
+		cwd: process.cwd()
+	};
+}
+/**
+* Assemble the `-c` command string for one command. Exported for tests — the
+* `eval` placement is the load-bearing bit and must be asserted directly.
+*/
+function buildCommandString(session, command, cwdFile) {
+	const parts = [];
+	if (session.snapshotPath) parts.push(`source ${shQuote(session.snapshotPath)} 2>/dev/null || true`);
+	parts.push(session.shell.kind === "zsh" ? "setopt NO_EXTENDED_GLOB 2>/dev/null || true" : "shopt -u extglob 2>/dev/null || true");
+	parts.push(`eval ${shQuote(command)}`);
+	parts.push(`pwd -P >| ${shQuote(cwdFile)}`);
+	return parts.join(" && ");
+}
+/**
+* Spawn args for one command. Exported for tests. With a snapshot we spawn
+* NON-login (fast — the snapshot already carries env); without one, fall back
+* to a login shell so rc init still happens.
+*/
+function spawnArgs(session, commandString) {
+	return session.snapshotPath ? ["-c", commandString] : [
+		"-c",
+		"-l",
+		commandString
+	];
+}
+/**
+* Run one command, streaming output via `onEvent`. Resolves with the exit code
+* once the process ends. Updates `session.cwd` from the persisted pwd so the
+* next command starts where this one left off.
+*/
+async function runShellCommand(session, command, onEvent, env = process.env) {
+	const tmp = await mkdtemp(path.join(os$1.tmpdir(), "skydive-sh-"));
+	const cwdFile = path.join(tmp, "cwd");
+	const commandString = buildCommandString(session, command, cwdFile);
+	return new Promise((resolve) => {
+		const child = spawn(session.shell.bin, spawnArgs(session, commandString), {
+			cwd: session.cwd,
+			env: {
+				...env,
+				SHELL: session.shell.bin,
+				GIT_EDITOR: "true"
+			}
+		});
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => onEvent({
+			type: "stdout",
+			chunk
+		}));
+		child.stderr.on("data", (chunk) => onEvent({
+			type: "stderr",
+			chunk
+		}));
+		const finish = async (code, signal) => {
+			try {
+				const next = (await readFile(cwdFile, "utf8")).trim();
+				if (next) session.cwd = next;
+			} catch {}
+			await rm(tmp, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			onEvent({
+				type: "exit",
+				code,
+				signal
+			});
+			resolve({
+				code,
+				signal
+			});
+		};
+		child.on("error", () => void finish(null, null));
+		child.on("close", (code, signal) => void finish(code, signal));
+	});
+}
+function routeInput(raw) {
+	const line = raw.trimEnd();
+	if (line.startsWith("!")) {
+		const command = line.slice(1).trim();
+		return command ? {
+			kind: "local-shell",
+			command
+		} : { kind: "noop" };
+	}
+	const sandbox = matchSlash(line, ["sandbox", "sbx"]);
+	if (sandbox !== null) return sandbox ? {
+		kind: "sandbox-exec",
+		command: sandbox
+	} : { kind: "sandbox-pty" };
+	return {
+		kind: "message",
+		content: raw
+	};
+}
+/**
+* If `line` is `/<name>` or `/<name> <rest>` for one of `names`, return the
+* trimmed rest (possibly ''); otherwise null. Case-insensitive on the name.
+*/
+function matchSlash(line, names) {
+	if (!line.startsWith("/")) return null;
+	const sp = line.indexOf(" ");
+	const name = (sp === -1 ? line.slice(1) : line.slice(1, sp)).toLowerCase();
+	if (!names.includes(name)) return null;
+	return sp === -1 ? "" : line.slice(sp + 1).trim();
+}
+/** Max characters of `!` output we forward to the agent as context. */
+const SHELL_CONTEXT_OUTPUT_CAP = 16e3;
+/**
+* Format a finished `! <cmd>` run as a context message for the agent: just the
+* command and its output, as a fenced console block (Claude Code parity — `!`
+* output enters the model's context). Trailing whitespace is trimmed and very
+* long output is truncated from the FRONT (the tail — errors, results — is
+* usually the informative part; the head is often progress noise). A non-zero
+* exit is annotated on the prompt line so the agent notices the failure.
+*/
+function formatShellContext(command, output, exitCode) {
+	let body = output.replace(/\s+$/, "");
+	if (body.length > SHELL_CONTEXT_OUTPUT_CAP) body = `[… truncated to last ${SHELL_CONTEXT_OUTPUT_CAP} chars …]\n${body.slice(body.length - SHELL_CONTEXT_OUTPUT_CAP)}`;
+	return [
+		"```console",
+		exitCode === 0 ? `$ ${command}` : `$ ${command}  # exit ${exitCode}`,
+		body,
+		"```"
+	].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
 /**
@@ -4723,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);
@@ -4756,6 +5366,7 @@ function ChatScreen({ agent, conversation }) {
 	inputRef.current = input;
 	const credPromptRef = useRef(credPrompt);
 	credPromptRef.current = credPrompt;
+	const shellSessionRef = useRef(null);
 	const hostState = grantPrompt || credPrompt ? "blocked" : run.kind === "idle" ? "idle" : "working";
 	useEffect(() => {
 		agentHost.transition({ state: hostState });
@@ -4907,12 +5518,13 @@ function ChatScreen({ agent, conversation }) {
 			cancelled = true;
 		};
 	}, []);
-	const sendContent = useCallback(async (content, attachments) => {
+	const sendContent = useCallback(async (content, attachments, opts) => {
 		if (!rest) return;
 		const trimmed = content.trim();
 		if (!trimmed && attachments.length === 0) return;
+		const echo = opts?.echo !== false;
 		const optimisticId = crypto.randomUUID();
-		setItems((prev) => [...prev, {
+		if (echo) setItems((prev) => [...prev, {
 			kind: "user",
 			id: optimisticId,
 			text: userItemText(trimmed, attachments)
@@ -4946,8 +5558,10 @@ function ChatScreen({ agent, conversation }) {
 				id: crypto.randomUUID(),
 				text: errorMessage(err)
 			}]);
-			setInput((existing) => existing ? existing : trimmed);
-			setPending((prev) => prev.length > 0 ? prev : attachments);
+			if (echo) {
+				setInput((existing) => existing ? existing : trimmed);
+				setPending((prev) => prev.length > 0 ? prev : attachments);
+			}
 			if (!wasStreaming) setRun({ kind: "idle" });
 		}
 	}, [
@@ -5139,10 +5753,118 @@ function ChatScreen({ agent, conversation }) {
 			}
 		})();
 	}, [rest, updateCard]);
+	const runLocalShell = useCallback(async (command) => {
+		const id = crypto.randomUUID();
+		setItems((prev) => [...prev, {
+			kind: "shell",
+			id,
+			command,
+			output: "",
+			exit: null
+		}]);
+		let captured = "";
+		const appendOutput = (chunk) => {
+			captured += chunk;
+			setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
+				...m,
+				output: m.output + chunk
+			} : m));
+		};
+		let exitCode;
+		try {
+			if (!shellSessionRef.current) shellSessionRef.current = await createShellSession();
+			const { code } = await runShellCommand(shellSessionRef.current, command, (e) => {
+				if (e.type === "stdout" || e.type === "stderr") appendOutput(e.chunk);
+			});
+			exitCode = code ?? 1;
+			setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
+				...m,
+				exit: exitCode
+			} : m));
+		} catch (err) {
+			appendOutput(`\n${errorMessage(err)}`);
+			exitCode = 1;
+			setItems((prev) => prev.map((m) => m.id === id && m.kind === "shell" ? {
+				...m,
+				exit: 1
+			} : m));
+		}
+		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;
 		if (!content && attachments.length === 0) return;
+		const routed = routeInput(content);
+		if (routed.kind !== "message") {
+			history.append(content);
+			setInput("");
+			composerRef.current?.clear();
+			setComposerRows(1);
+			if (routed.kind === "local-shell") runLocalShell(routed.command);
+			else if (routed.kind === "sandbox-exec") runSandboxExec(routed.command);
+			else if (routed.kind === "sandbox-pty") runSandboxPty();
+			return;
+		}
 		history.append(content);
 		setInput("");
 		composerRef.current?.clear();
@@ -5153,7 +5875,10 @@ function ChatScreen({ agent, conversation }) {
 		input,
 		pending,
 		sendContent,
-		history
+		history,
+		runLocalShell,
+		runSandboxExec,
+		runSandboxPty
 	]);
 	const handleComposerChange = useCallback(() => {
 		const composer = composerRef.current;
@@ -5844,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.186",
+  "version": "0.1.0-beta.199",
   "description": "Skydive CLI — manage AI agents from the command line",
   "homepage": "https://skydive.com",
   "license": "MIT",