skydive-cli 0.1.0 → 0.2.0-beta.421

package/dist/js/client-B3ZhhF7e.mjs

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+import { t as errorMessage } from "./util-CeisaZVY.mjs";
+import { c as machineIdentity, i as mintPortalDeviceToken, l as portalWsUrl, n as findThisDevice, r as grantPortalAccess, s as buildEnv, t as fetchPortalDevices } from "./api-CDTKq_5Q.mjs";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { WebSocket } from "ws";
+
+//#region ../portal-protocol/src/index.ts
+const MAX_WS_FRAME_BYTES = 16 * 1024 * 1024;
+const T_DATA = 1;
+const T_CTRL = 2;
+const STREAM = {
+	stdout: 0,
+	stderr: 1,
+	stdin: 2
+};
+const uuidToBytes = (id) => Buffer.from(id.replace(/-/g, ""), "hex");
+const bytesToUuid = (b) => {
+	const h = b.toString("hex");
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+};
+function encodeData(id, stream, seq, payload) {
+	const head = Buffer.allocUnsafe(22);
+	head[0] = T_DATA;
+	uuidToBytes(id).copy(head, 1);
+	head[17] = stream;
+	head.writeUInt32BE(seq >>> 0, 18);
+	return Buffer.concat([head, payload]);
+}
+const ctrlMessageSchema = z.discriminatedUnion("t", [
+	z.object({
+		t: z.literal("open"),
+		argv: z.array(z.string()),
+		env: z.record(z.string()).nullable()
+	}),
+	z.object({ t: z.literal("stdin_eof") }),
+	z.object({ t: z.literal("pause") }),
+	z.object({ t: z.literal("resume") }),
+	z.object({ t: z.literal("cancel") }),
+	z.object({
+		t: z.literal("close"),
+		exitCode: z.number()
+	}),
+	z.object({
+		t: z.literal("error"),
+		message: z.string()
+	})
+]);
+function encodeCtrl(id, obj) {
+	const head = Buffer.allocUnsafe(17);
+	head[0] = T_CTRL;
+	uuidToBytes(id).copy(head, 1);
+	return Buffer.concat([head, Buffer.from(JSON.stringify(obj), "utf8")]);
+}
+function decodeFrame(frame) {
+	const id = bytesToUuid(frame.subarray(1, 17));
+	if (frame[0] === T_DATA) return {
+		kind: "data",
+		id,
+		stream: frame[17] ?? 0,
+		seq: frame.readUInt32BE(18),
+		payload: frame.subarray(22)
+	};
+	return {
+		kind: "ctrl",
+		id,
+		obj: ctrlMessageSchema.parse(JSON.parse(frame.subarray(17).toString("utf8")))
+	};
+}
+
+//#endregion
+//#region src/chat/portal/exec.ts
+/**
+* Runs portal `exec` directives locally. Each `open` spawns a child process
+* whose stdout/stderr stream back as data frames and whose stdin is fed by
+* inbound data frames, with pause/resume backpressure and cancel/teardown that
+* kill the child. This is the TypeScript counterpart of the desktop's Rust
+* `portal/mod.rs` job machinery, minus the connection supervision (which lives
+* in the client).
+*/
+var JobManager = class {
+	jobs = /* @__PURE__ */ new Map();
+	constructor(opts) {
+		this.opts = opts;
+	}
+	handleFrame(raw) {
+		let decoded;
+		try {
+			decoded = decodeFrame(raw);
+		} catch (_error) {
+			return;
+		}
+		if (decoded.kind === "ctrl") this.handleCtrl(decoded.id, decoded.obj);
+		else if (decoded.stream === STREAM.stdin) this.jobs.get(decoded.id)?.child.stdin.write(decoded.payload);
+	}
+	killAll() {
+		for (const job of this.jobs.values()) {
+			job.settled = true;
+			job.child.kill("SIGKILL");
+		}
+		this.jobs.clear();
+	}
+	handleCtrl(id, msg) {
+		switch (msg.t) {
+			case "open":
+				this.startJob(id, msg.argv, msg.env);
+				return;
+			case "stdin_eof":
+				this.jobs.get(id)?.child.stdin.end();
+				return;
+			case "pause":
+				this.setPaused(id, true);
+				return;
+			case "resume":
+				this.setPaused(id, false);
+				return;
+			case "cancel":
+				this.jobs.get(id)?.child.kill("SIGKILL");
+				return;
+			case "close":
+			case "error": return;
+			default: return msg;
+		}
+	}
+	setPaused(id, paused) {
+		const job = this.jobs.get(id);
+		if (!job) return;
+		if (paused) {
+			job.child.stdout.pause();
+			job.child.stderr.pause();
+		} else {
+			job.child.stdout.resume();
+			job.child.stderr.resume();
+		}
+	}
+	startJob(id, argv, env) {
+		const [program, ...args] = argv;
+		if (!program) {
+			this.opts.send(encodeCtrl(id, {
+				t: "error",
+				message: "empty argv"
+			}));
+			return;
+		}
+		let child;
+		try {
+			child = spawn(program, args, {
+				cwd: this.opts.cwd,
+				env: buildEnv(env),
+				stdio: [
+					"pipe",
+					"pipe",
+					"pipe"
+				]
+			});
+		} catch (err) {
+			this.opts.send(encodeCtrl(id, {
+				t: "error",
+				message: `spawn failed: ${errorMessage(err)}`
+			}));
+			return;
+		}
+		const job = {
+			child,
+			seq: 0,
+			settled: false
+		};
+		this.jobs.set(id, job);
+		child.on("error", (err) => {
+			if (job.settled) return;
+			job.settled = true;
+			this.jobs.delete(id);
+			this.opts.send(encodeCtrl(id, {
+				t: "error",
+				message: `spawn failed: ${errorMessage(err)}`
+			}));
+		});
+		child.stdout.on("data", (chunk) => this.sendData(job, id, STREAM.stdout, chunk));
+		child.stderr.on("data", (chunk) => this.sendData(job, id, STREAM.stderr, chunk));
+		child.on("close", (code) => {
+			if (job.settled) return;
+			job.settled = true;
+			this.jobs.delete(id);
+			this.opts.send(encodeCtrl(id, {
+				t: "close",
+				exitCode: code ?? -1
+			}));
+		});
+	}
+	sendData(job, id, stream, chunk) {
+		if (job.settled) return;
+		this.opts.send(encodeData(id, stream, job.seq, chunk));
+		job.seq = job.seq + 1 >>> 0;
+	}
+};
+
+//#endregion
+//#region src/chat/portal/client.ts
+const INITIAL_BACKOFF_MS = 500;
+const MAX_BACKOFF_MS = 1e4;
+/**
+* Shares the local machine with agents over the portal: dials OUT to the api's
+* desktop-portal WebSocket (authenticating with a short-lived device token
+* minted from the CLI session), then runs inbound `exec` directives via a
+* `JobManager`. Reconnects with backoff while enabled; disabling drops presence
+* and kills any in-flight children. No inbound port is ever opened.
+*
+* Access stays default-deny: connecting only makes the machine reachable — an
+* agent can't run anything until the user grants it (`grantAgent`).
+*/
+var PortalClient = class {
+	enabled = false;
+	disposed = false;
+	ws = null;
+	jobs = null;
+	status = "off";
+	error = null;
+	deviceId = null;
+	granted = /* @__PURE__ */ new Set();
+	machineName;
+	friendlyName;
+	constructor(opts) {
+		this.opts = opts;
+		const identity = machineIdentity();
+		this.machineName = identity.machineName;
+		this.friendlyName = identity.friendlyName;
+	}
+	isEnabled() {
+		return this.enabled;
+	}
+	isGranted(agentId) {
+		return this.granted.has(agentId);
+	}
+	enable() {
+		if (this.enabled || this.disposed) return;
+		this.enabled = true;
+		this.error = null;
+		this.connectLoop();
+	}
+	disable() {
+		if (!this.enabled) return;
+		this.enabled = false;
+		this.jobs?.killAll();
+		this.ws?.close();
+		this.ws = null;
+		this.deviceId = null;
+		this.granted = /* @__PURE__ */ new Set();
+		this.setStatus("off");
+	}
+	/**
+	* Tear down for good (app quit). Kills children synchronously and closes the
+	* socket so it stops holding the event loop open — otherwise the process
+	* would hang after the TUI is destroyed.
+	*/
+	dispose() {
+		this.disposed = true;
+		this.enabled = false;
+		this.jobs?.killAll();
+		this.jobs = null;
+		this.ws?.close();
+		this.ws = null;
+	}
+	/** Grant one agent access to this machine (default-deny; user-initiated). */
+	async grantAgent(agentId) {
+		const deviceId = await this.ensureDeviceId();
+		await grantPortalAccess(this.opts, {
+			deviceId,
+			agentId
+		});
+		this.granted.add(agentId);
+		this.emit();
+	}
+	setStatus(status, error = null) {
+		this.status = status;
+		this.error = error;
+		this.emit();
+	}
+	emit() {
+		this.opts.onState({
+			status: this.status,
+			machineName: this.machineName,
+			friendlyName: this.friendlyName,
+			error: this.error,
+			grantedAgentIds: [...this.granted]
+		});
+	}
+	async connectLoop() {
+		let backoff = INITIAL_BACKOFF_MS;
+		while (this.enabled && !this.disposed) {
+			this.setStatus("connecting");
+			try {
+				const token = await mintPortalDeviceToken(this.opts);
+				await this.runConnection(token);
+				backoff = INITIAL_BACKOFF_MS;
+			} catch (err) {
+				if (!this.enabled || this.disposed) break;
+				this.setStatus("error", errorMessage(err));
+			}
+			if (!this.enabled || this.disposed) break;
+			await sleep(backoff);
+			backoff = Math.min(backoff * 2, MAX_BACKOFF_MS);
+		}
+	}
+	runConnection(token) {
+		return new Promise((resolve) => {
+			const ws = new WebSocket(portalWsUrl(this.opts.appUrl, this.machineName, this.friendlyName), {
+				headers: { authorization: `Bearer ${token}` },
+				maxPayload: MAX_WS_FRAME_BYTES
+			});
+			this.ws = ws;
+			const jobs = new JobManager({
+				cwd: this.opts.cwd,
+				send: (frame) => {
+					if (ws.readyState === WebSocket.OPEN) ws.send(frame);
+				}
+			});
+			this.jobs = jobs;
+			ws.on("open", () => {
+				this.setStatus("connected");
+				this.refreshDevice();
+			});
+			ws.on("message", (data, isBinary) => {
+				if (isBinary) jobs.handleFrame(toBuffer(data));
+			});
+			ws.on("error", (err) => {
+				this.error = errorMessage(err);
+			});
+			ws.on("close", () => {
+				jobs.killAll();
+				if (this.jobs === jobs) this.jobs = null;
+				if (this.ws === ws) this.ws = null;
+				resolve();
+			});
+		});
+	}
+	async ensureDeviceId() {
+		if (this.deviceId) return this.deviceId;
+		for (let attempt = 0; attempt < 10; attempt += 1) {
+			await this.refreshDevice();
+			if (this.deviceId) return this.deviceId;
+			await sleep(300);
+		}
+		throw new Error("this machine is not connected yet");
+	}
+	async refreshDevice() {
+		try {
+			const { devices } = await fetchPortalDevices(this.opts);
+			const mine = findThisDevice(devices, this.machineName);
+			if (!mine) return;
+			this.deviceId = mine.id;
+			this.granted = new Set(mine.grantedAgentIds);
+			this.emit();
+		} catch (_error) {}
+	}
+};
+function toBuffer(data) {
+	if (Buffer.isBuffer(data)) return data;
+	if (Array.isArray(data)) return Buffer.concat(data);
+	return Buffer.from(data);
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { PortalClient as t };

package/dist/js/client-CpEvH2Pq.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { WebSocket } from "ws";
+
+//#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
+export { SandboxStream as t };

package/dist/js/client-D6NAkL9e.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./rest-CamHVOce.mjs";
+import "./api-CDTKq_5Q.mjs";
+import { t as PortalClient } from "./client-B3ZhhF7e.mjs";
+
+export { PortalClient };

package/dist/js/output-B4cW10Ph.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+//#region src/output.ts
+function output(argv, data) {
+	if (argv.json) {
+		console.log(JSON.stringify(data, null, 2));
+		return;
+	}
+	if (typeof data === "string") {
+		console.log(data);
+		return;
+	}
+	console.log(JSON.stringify(data, null, 2));
+}
+function printTable(headers, rows) {
+	const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
+	const pad = (s, w) => s.padEnd(w);
+	const line = (cells) => cells.map((c, i) => pad(c, widths[i] ?? 0)).join("  ");
+	console.log(line(headers));
+	console.log(widths.map((w) => "-".repeat(w)).join("  "));
+	for (const row of rows) console.log(line(row));
+}
+function printError(message) {
+	console.error(`Error: ${message}`);
+}
+
+//#endregion
+export { printError as n, printTable as r, output as t };

package/dist/js/print-B6AO13SA.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./rest-CamHVOce.mjs";
+import { a as runPrint, i as resolveAgent, n as messageGet, o as toPrintError, r as readStdin, t as collectRunText } from "./print-DausK_KZ.mjs";
+
+export { messageGet, readStdin, resolveAgent, runPrint };