skydive-cli 0.1.0-beta.239 → 0.1.0-beta.276

package/dist/js/client-_OL8-XGH.mjs

@@ -0,0 +1,367 @@
+#!/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 { 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
+var client_exports = /* @__PURE__ */ __exportAll({ PortalClient: () => PortalClient });
+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 { client_exports as n, PortalClient as t };

package/dist/js/rolldown-runtime-Cz4Tg37Z.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+export { __exportAll as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skydive-cli",
-  "version": "0.1.0-beta.239",
+  "version": "0.1.0-beta.276",
   "description": "Skydive CLI — manage AI agents from the command line",
   "homepage": "https://skydive.com",
   "license": "MIT",
@@ -33,6 +33,7 @@
     "diff": "9.0.0",
     "eventsource-parser": "^3.0.8",
     "file-type": "^21.3.4",
+    "fuzzysort": "^3.1.0",
     "neverthrow": "^8.2.0",
     "open": "^10.1.0",
     "react": "^19.0.0",