skydive-cli 0.5.0-beta.4 → 0.5.0-beta.44

package/CHANGELOG.md

@@ -7,8 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- `npm i -g skydive-cli` (and yarn/pnpm/bun) now installs a tiny launcher plus one prebuilt, os/cpu-matched binary that carries its own runtime — so on the common platforms `skydive chat` and `skydive import` start instantly and **do not download a Bun runtime on first use**. On any platform without a prebuilt binary (or if the optional dependency is skipped), the CLI automatically falls back to the existing behavior: it runs under your Node and provisions Bun on first `chat`, exactly as before. Nothing about the commands, flags, config, or `SKYDIVE_*` environment variables changes, and `skydive update` still upgrades npm installs via your package manager and standalone-binary installs in place.
+
 ### Added
 
+- `platform ask` forms now render in the chat TUI. The card lists each question with lettered options (A/B/C/D plus Other); `ctrl+r` opens a full overlay picker (one question at a time, arrows + enter, Other as a typed row — the Claude Code interaction). The answer sends as a normal message. Headless `chat -p` prints the question as an `[action needed]` block instead of dropping it.
+- Every API request now reports this install's version (`x-skydive-cli-version`) so the server can refuse features the installed CLI cannot render — `platform ask` needs the #21411 canary (`0.5.0-beta.43` or newer), not 0.4.0 and not earlier 0.5.0 betas.
+- `/search` (alias `/find`) in the chat TUI — opens the conversation picker with its search field focused, so "find a conversation" has a discoverable command instead of being a feature you had to know the bare picker already had. Pass a query inline (`/search billing deep dive`) and the picker opens already narrowed to the matches; bare `/search` opens it ready for you to type. The search runs server-side across conversation titles, message bodies, and participant names, the same search the picker exposes.
+- First run in a workspace with no agents now sets you up automatically: instead of dropping you on an empty agent picker, `skydive` creates your first agent for you (with a suggested name and avatar, mirroring the web onboarding flow) and then offers to have it learn how you already work — reading the other coding agents set up on your machine (Claude Code, Cursor, Codex, and more), the same import that `skydive import` runs, with a plan shown first and credentials never copied. Decline and you go straight into the new agent's chat. You can replay this flow anytime with `skydive --onboarding` (or `SKYDIVE_FORCE_ONBOARDING=1`), even in a workspace that already has agents.
+- `/computer` in the chat TUI — a snapshot of the agent's sandbox drawn as colored bar graphs: CPU, memory, and disk usage. Bars turn amber past 75%% and red past 90%% so a glance tells you whether the box is under pressure. The numbers come from the Skydive API (the same live resource sample the web computer view reads), not by connecting to the sandbox — so the card shows instantly, never waking or hanging on a box that isn't running: when the agent has no live sandbox it simply reads "no sandbox running". The card keeps itself current quietly (a slow background refresh, no flicker or "updating" chrome); only the most recent card refreshes, and it silently stops while you're scrolled up (no wasted polls on a card you're not looking at) and resumes at the bottom.
+- `/computer restart` in the chat TUI — reboot the agent's sandbox from chat. It asks a `y`/`n` confirm first (the restart stops whatever run is going and brings up a fresh box), then enqueues the same restart the web "Restart" control does. Available to anyone with edit access to the agent; view-only members are told they can't.
 - `skydive fs` — a namespace for working with the files on an agent's computer (its sandbox) from your own machine. Its first subcommand, `skydive fs edit <path>`, reads a remote file down over the same relay `skydive sandbox` uses, opens it in your local editor (`$VISUAL`/`$EDITOR`, override with `--editor`, defaults to `vi`), and writes your changes back atomically when you save and close — so you can edit a remote file as if it were local without opening the chat TUI. A path that doesn't exist yet is created on save; no changes means nothing is written. Access is gated on EDIT permission for the agent, exactly like `skydive sandbox`. (A first-class `fs` relay channel and `skydive fs mount` land in follow-ups.)
 
 ## [0.4.0] - 2026-08-07

package/README.md

@@ -261,6 +261,16 @@ internal API. On launch it walks you through:
    formatting, collapsed reasoning, and rich rendering of tool calls
    (`bash`, `edit`/`write` diffs, `read`, `grep`/`glob`).
 
+The chat TUI remembers the last agent you talked to: every conversation it
+opens records that agent as your default, and the next bare `skydive chat`
+drops straight into a new conversation with it — no picker. An explicit
+`--agent` or `--resume` still wins for that invocation, and the conversation
+it opens sets the default like any other. You can also seed or override the
+default by hand with `skydive config set defaultAgent <id|slug|name>`. A
+stored value that no longer matches (renamed or archived agent) falls back
+to the agent picker with a notice, and picking an agent there heals it
+automatically.
+
 You can change conversation without leaving chat. `/conversation` (aliases
 `/conversations`, `/conv`) reopens the conversation list, and
 `/conversation <id>` — an id, its `/c/<id>` link, or a pasted
@@ -463,15 +473,35 @@ skydive config path                 # print the config.json location
 
 Editable keys:
 
-| Key                   | Type    | Effect                                                                                                                                                                                                                          |
-| --------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `shareMachineDefault` | boolean | When `true`, `skydive chat` (TUI and `-p`) shares this machine over the portal on launch, as if `--share-machine` were passed. An explicit `--share-machine`/`--no-share-machine` overrides it per invocation. Default `false`. |
-| `updateCheck`         | boolean | When `false`, disables the daily background update check and its "Update available" notice. The persistent equivalent of setting `SKYDIVE_NO_UPDATE_CHECK` (or `NO_UPDATE_NOTIFIER`) in the environment. Default `true`.        |
+| Key                   | Type    | Effect                                                                                                                                                                                                                                                                                                                                                                                     |
+| --------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `shareMachineDefault` | boolean | When `true`, `skydive chat` (TUI and `-p`) shares this machine over the portal on launch, as if `--share-machine` were passed. An explicit `--share-machine`/`--no-share-machine` overrides it per invocation. Default `false`.                                                                                                                                                            |
+| `updateCheck`         | boolean | When `false`, disables the daily background update check and its "Update available" notice. The persistent equivalent of setting `SKYDIVE_NO_UPDATE_CHECK` (or `NO_UPDATE_NOTIFIER`) in the environment. Default `true`.                                                                                                                                                                   |
+| `defaultAgent`        | string  | Agent (id, slug, or name) a bare `skydive chat` opens a new conversation with, skipping the agent picker. Maintained automatically: every conversation the chat TUI opens records its agent here (last used wins). `skydive config set defaultAgent` seeds or overrides it; an explicit `--agent`/`--resume` wins per invocation; a value that no longer matches falls back to the picker. |
 
 The remaining keys (`apiKey`, `apiUrl`, `sessionToken`, `appUrl`, `themeDark`,
 `themeLight`, …) are credentials or flow-managed state — leave them to the
 CLI.
 
+## Diagnostic logs
+
+The CLI records local diagnostics by default. It keeps the latest 20 sessions
+beside the CLI config. Nothing uploads automatically.
+
+```sh
+skydive logs                    # list recent sessions
+skydive logs path               # print the latest session directory
+skydive logs export             # archive the latest session for sharing
+skydive logs export <session>   # archive one session from `logs list`
+```
+
+Automatic logs include request timing, TUI state changes, render performance,
+and process metadata. Command values and URL query values are removed.
+
+Set `SKYDIVE_PROFILE=<path>` to write a full profile to a chosen directory.
+Full profiles also include CPU data. Set `SKYDIVE_PROFILE=0` to disable all
+session diagnostics.
+
 ## Environment variables
 
 | Variable                | Effect                                           |
@@ -482,6 +512,7 @@ CLI.
 | `SKYDIVE_APP_URL`       | Chat app/session origin (overrides stored value) |
 | `SKYDIVE_THEME`         | Chat colorscheme id (flag `--theme` overrides)   |
 | `SKYDIVE_CONFIG_NAME`   | On-disk config profile name (default `skydive`)  |
+| `SKYDIVE_PROFILE`       | Full profile path; `0` disables diagnostics      |
 
 ## Testing the TUI
 

package/dist/js/api-TwLD7ibI.mjs

@@ -0,0 +1,315 @@
+#!/usr/bin/env node
+import { t as HttpError } from "./http-error-BF2NZZE3.mjs";
+import { z } from "zod";
+import http from "node:http";
+import http2 from "node:http2";
+
+//#region ../portal-daemon/src/tls-forward.ts
+const TLS_PORT_OFFSET = 1e4;
+const STRIP_HEADERS = new Set([
+	"connection",
+	"keep-alive",
+	"proxy-authenticate",
+	"proxy-authorization",
+	"proxy-connection",
+	"te",
+	"trailer",
+	"transfer-encoding",
+	"upgrade",
+	"http2-settings"
+]);
+/**
+* The opt-in TLS+h2 origin for a forwarded/exposed port (ANY-6872, additive
+* next to the plain listener — never a replacement). Browsers only negotiate
+* h2 over TLS, and h2's stream multiplexing is what lifts the
+* 6-connections-per-origin cap that makes unbundled dev servers crawl through
+* the tunnel; each h2 stream is converted here to an h1 request over a tunnel
+* from `acquireTunnel`. Used by BOTH tunnel surfaces: the CLI's
+* `skydive portal forward` and the desktop daemon's `platform portal expose`.
+*
+* The dev server keeps seeing `Host: localhost:<port>` — the browser's
+* authority is a public name it would reject (Vite 403s unknown hosts), and
+* "looks exactly like localhost" is the product contract. The original
+* authority travels in x-forwarded-host / x-forwarded-proto for apps that
+* want it.
+*/
+async function startTlsForward({ cert, localPort, targetPort, acquireTunnel, log }) {
+	const connectionShims = {
+		setNoDelay: () => {},
+		setKeepAlive: () => {},
+		setTimeout: () => {},
+		ref: () => {},
+		unref: () => {}
+	};
+	/**
+	* node's http client drives the tunnel: the agent's keep-alive free list
+	* gives request→request socket reuse on top of the pool's pre-paid dials,
+	* and a tunnel the daemon/dev-server side reaps while idle is evicted from
+	* the free list by its 'close' — the next request just adopts a fresh one.
+	* maxSockets mirrors the pool cap: every socket here holds an edge WS open,
+	* and ANY-6873 is the honest fix for wanting more concurrency than that.
+	*
+	* The base signature allows synchronous implementations to return the
+	* socket; this one is asynchronous, so it always uses the callback and
+	* returns undefined (the documented async contract). The agent core always
+	* passes the callback — the error branch below guards the contract anyway
+	* rather than assuming it.
+	*/
+	class TunnelAgent extends http.Agent {
+		createConnection(_options, callback) {
+			if (!callback) throw new Error("TunnelAgent.createConnection requires the async callback");
+			(async () => {
+				let tunnel;
+				try {
+					tunnel = await acquireTunnel();
+				} catch (error) {
+					callback(error instanceof Error ? error : new Error(String(error)));
+					return;
+				}
+				Object.assign(tunnel.stream, connectionShims);
+				tunnel.stream.resume();
+				callback(null, tunnel.stream);
+			})();
+		}
+	}
+	const agent = new TunnelAgent({
+		keepAlive: true,
+		maxSockets: 16
+	});
+	const server = http2.createSecureServer({
+		key: cert.key,
+		cert: cert.cert,
+		allowHTTP1: true
+	});
+	const liveSessions = /* @__PURE__ */ new Set();
+	server.on("session", (session) => {
+		liveSessions.add(session);
+		session.once("close", () => liveSessions.delete(session));
+	});
+	server.on("secureConnection", (socket) => {
+		liveSessions.add(socket);
+		socket.once("close", () => liveSessions.delete(socket));
+	});
+	server.on("request", (req, res) => {
+		const headers = {};
+		for (const [name, value] of Object.entries(req.headers)) {
+			if (name.startsWith(":") || STRIP_HEADERS.has(name)) continue;
+			if (value !== void 0) headers[name] = value;
+		}
+		headers.host = `localhost:${targetPort}`;
+		headers["x-forwarded-proto"] = "https";
+		headers["x-forwarded-host"] = cert.hostname;
+		const upstream = http.request({
+			host: "localhost",
+			port: targetPort,
+			method: req.method,
+			path: req.url,
+			headers,
+			agent
+		}, (upstreamRes) => {
+			const resHeaders = {};
+			for (const [name, value] of Object.entries(upstreamRes.headers)) {
+				if (STRIP_HEADERS.has(name)) continue;
+				if (value !== void 0) resHeaders[name] = value;
+			}
+			res.writeHead(upstreamRes.statusCode ?? 502, resHeaders);
+			upstreamRes.pipe(res);
+			upstreamRes.on("error", () => res.destroy());
+		});
+		upstream.on("error", (err) => {
+			log(`forward(tls): upstream request failed: ${err.message}`);
+			if (!res.headersSent) {
+				res.writeHead(502, { "content-type": "text/plain" });
+				res.end("portal forward: tunnel request failed");
+			} else res.destroy();
+		});
+		req.pipe(upstream);
+		req.on("error", () => upstream.destroy());
+	});
+	server.on("upgrade", (req, socket, head) => {
+		socket.pause();
+		(async () => {
+			let tunnel;
+			try {
+				tunnel = await acquireTunnel();
+			} catch (err) {
+				log(`forward(tls): upgrade tunnel failed: ${err instanceof Error ? err.message : String(err)}`);
+				socket.destroy();
+				return;
+			}
+			const lines = [`${req.method} ${req.url} HTTP/1.1`];
+			for (let i = 0; i < req.rawHeaders.length; i += 2) {
+				const name = req.rawHeaders[i];
+				const value = name?.toLowerCase() === "host" ? `localhost:${targetPort}` : req.rawHeaders[i + 1];
+				lines.push(`${name}: ${value}`);
+			}
+			tunnel.stream.write(lines.join("\r\n") + "\r\n\r\n");
+			if (head.length > 0) tunnel.stream.write(head);
+			tunnel.stream.on("error", () => socket.destroy());
+			tunnel.stream.on("close", () => socket.destroy());
+			socket.on("error", () => tunnel.stream.destroy());
+			socket.on("close", () => tunnel.stream.destroy());
+			socket.pipe(tunnel.stream).pipe(socket);
+			socket.resume();
+		})();
+	});
+	server.on("tlsClientError", (err, tlsSocket) => {
+		tlsSocket.destroy();
+		log(`forward(tls): handshake failed: ${err.message}`);
+	});
+	const preferredPort = localPort + TLS_PORT_OFFSET <= 65535 ? localPort + TLS_PORT_OFFSET : 0;
+	return {
+		port: await new Promise((resolve, reject) => {
+			const onError = (err) => {
+				if (err.code === "EADDRINUSE" && preferredPort !== 0) {
+					server.listen(0, "127.0.0.1");
+					return;
+				}
+				server.removeListener("error", onError);
+				reject(err);
+			};
+			server.on("error", onError);
+			server.on("listening", () => {
+				server.removeListener("error", onError);
+				const addr = server.address();
+				resolve(addr && typeof addr === "object" ? addr.port : preferredPort);
+			});
+			server.listen(preferredPort, "127.0.0.1");
+		}),
+		hostname: cert.hostname,
+		close: () => new Promise((resolve) => {
+			agent.destroy();
+			server.close(() => resolve());
+			for (const live of liveSessions) live.destroy();
+		})
+	};
+}
+
+//#endregion
+//#region ../portal-daemon/src/api.ts
+/**
+* The portal's session-authed REST surface, shared by `PortalClient` (the
+* TUI/`portal open` connection) and the `skydive portal` management
+* commands, so the endpoint contracts and response schemas live in exactly
+* one place.
+*/
+const deviceSchema = z.object({
+	id: z.string(),
+	machineName: z.string(),
+	friendlyName: z.string(),
+	connected: z.boolean(),
+	lastSeen: z.string().nullable(),
+	grantedAgentIds: z.array(z.string())
+});
+const devicesResponseSchema = z.object({
+	devices: z.array(deviceSchema),
+	agents: z.array(z.object({
+		id: z.string(),
+		name: z.string()
+	}))
+});
+const deviceTokenSchema = z.object({ token: z.string().min(1) });
+async function portalFetch(auth, path, init) {
+	const res = await fetch(`${auth.appUrl}${path}`, {
+		method: init.method,
+		headers: {
+			authorization: `Bearer ${auth.sessionToken}`,
+			accept: "application/json",
+			...init.body ? { "content-type": "application/json" } : {}
+		},
+		...init.body ? { body: init.body } : {}
+	});
+	if (!res.ok) {
+		const body = await res.text().catch(() => "");
+		throw new HttpError(res.status, body);
+	}
+	return res.json();
+}
+async function fetchPortalDevices(auth) {
+	const json = await portalFetch(auth, "/api/v1/portal/devices", { method: "GET" });
+	return devicesResponseSchema.parse(json);
+}
+const registerResponseSchema = z.object({ device: z.object({ id: z.string() }) });
+/**
+* Register this machine's device row without connecting. Connecting registers
+* as a side effect; this covers granting an agent on a machine that has never
+* shared yet (the grant references the device row).
+*/
+async function registerPortalDevice(auth, { machineName, friendlyName }) {
+	const json = await portalFetch(auth, "/api/v1/portal/devices", {
+		method: "POST",
+		body: JSON.stringify({
+			machineName,
+			friendlyName
+		})
+	});
+	return registerResponseSchema.parse(json).device;
+}
+/** Short-lived token the machine presents when dialing the portal WebSocket. */
+async function mintPortalDeviceToken(auth) {
+	const json = await portalFetch(auth, "/api/v1/portal/device-token", { method: "POST" });
+	return deviceTokenSchema.parse(json).token;
+}
+const forwardTargetSchema = z.object({
+	daemonOrigin: z.string().min(1),
+	token: z.string().min(1),
+	expiresInSeconds: z.number()
+});
+/**
+* Everything `portal forward` needs to dial an agent's sandbox daemon through
+* the agent-webserver edge Worker: the daemon's stable public origin and a
+* daemon auth token (canUse-gated server-side).
+*/
+async function fetchForwardTarget(auth, agentId) {
+	const json = await portalFetch(auth, "/api/v1/portal/forward-target", {
+		method: "POST",
+		body: JSON.stringify({ agentId })
+	});
+	return forwardTargetSchema.parse(json);
+}
+async function grantPortalAccess(auth, { deviceId, agentId, conversationId }) {
+	await portalFetch(auth, `/api/v1/portal/devices/${encodeURIComponent(deviceId)}/grants`, {
+		method: "POST",
+		body: JSON.stringify({
+			agentId,
+			conversationId
+		})
+	});
+}
+async function revokePortalAccess(auth, { deviceId, agentId }) {
+	await portalFetch(auth, `/api/v1/portal/devices/${encodeURIComponent(deviceId)}/grants/${encodeURIComponent(agentId)}`, { method: "DELETE" });
+}
+/**
+* The device row for a given machine identity. Matching is by `machineName`
+* equality — the stable handle the machine registers under, not the display
+* label.
+*/
+function findThisDevice(devices, machineName) {
+	return devices.find((device) => device.machineName === machineName) ?? null;
+}
+/**
+* One-time grant migration onto the merged device. Earlier CLI builds
+* registered a separate `<machineName>-cli` device, so a user's existing
+* approvals hang off that row; the merged device would start with zero grants
+* and every already-authorized agent would ask again. Copy any grant the
+* merged device is missing (the grant endpoint upserts, so re-runs are
+* no-ops). The legacy row is left in place — an old CLI build may still
+* connect under it. Returns how many grants were copied.
+*/
+async function unifyLegacyCliGrants(auth, machineName) {
+	const { devices } = await fetchPortalDevices(auth);
+	const merged = findThisDevice(devices, machineName);
+	const legacy = findThisDevice(devices, `${machineName}-cli`);
+	if (!merged || !legacy) return 0;
+	const have = new Set(merged.grantedAgentIds);
+	const missing = legacy.grantedAgentIds.filter((id) => !have.has(id));
+	for (const agentId of missing) await grantPortalAccess(auth, {
+		deviceId: merged.id,
+		agentId,
+		conversationId: null
+	});
+	return missing.length;
+}
+
+//#endregion
+export { mintPortalDeviceToken as a, unifyLegacyCliGrants as c, grantPortalAccess as i, startTlsForward as l, fetchPortalDevices as n, registerPortalDevice as o, findThisDevice as r, revokePortalAccess as s, fetchForwardTarget as t };

package/dist/js/{billing-blocked-Dgu5-oDy.mjs → billing-blocked-SE6tySLd.mjs}

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { a as billingBlockedOutcomeSchema, i as billingBlockedOutcomeFromSendResponse, n as BillingBlockedError, r as billingBlockedJsonResult, t as BILLING_BLOCKED_EXIT_CODE } from "./billing-blocked-2wju4gC_.mjs";
+import { a as billingBlockedOutcomeSchema, i as billingBlockedOutcomeFromSendResponse, n as BillingBlockedError, r as billingBlockedJsonResult, t as BILLING_BLOCKED_EXIT_CODE } from "./billing-blocked-D3l5kJlX.mjs";
 
 export { BILLING_BLOCKED_EXIT_CODE, BillingBlockedError, billingBlockedJsonResult };