skydive-cli 0.2.0 → 0.3.0

package/dist/js/{client-B3ZhhF7e.mjs → client-Dc7GZ3PG.mjs}

@@ -1,10 +1,66 @@
 #!/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 { a as errorMessage, t as HttpError } from "./rest-BlN_uWmL.mjs";
+import os from "node:os";
 import { z } from "zod";
 import { spawn } from "node:child_process";
 import { WebSocket } from "ws";
 
+//#region src/chat/portal/machine.ts
+/**
+* Identity this machine registers under when the CLI shares it via the portal.
+*
+* The `-cli` suffix / `(CLI)` label keep a CLI-shared machine a DISTINCT portal
+* device from the same host's Skydive Desktop app. `portal_device` is unique on
+* (org, user, machineName), and directives route to whichever socket holds the
+* device — if the CLI and desktop registered the same name they'd share a
+* device row and both execute every directive. Distinct names also make the
+* grant UI unambiguous about which surface is being authorized.
+*/
+function machineIdentity() {
+	const host = (os.hostname() || "machine").trim().replace(/\.local$/i, "") || "machine";
+	return {
+		machineName: `${host}-cli`,
+		friendlyName: `${host} (CLI)`
+	};
+}
+const INHERITED_ENV = [
+	"HOME",
+	"USER",
+	"LOGNAME",
+	"SHELL",
+	"LANG",
+	"LC_ALL",
+	"TMPDIR",
+	"TERM",
+	"PATH"
+];
+function buildEnv(extra) {
+	const env = {};
+	for (const key of INHERITED_ENV) {
+		const value = process.env[key];
+		if (value !== void 0) env[key] = value;
+	}
+	if (extra) for (const [key, value] of Object.entries(extra)) env[key] = value;
+	return env;
+}
+/**
+* Build the desktop-portal WebSocket URL from the chat origin. Mirrors the Rust
+* desktop client: http→ws, https→wss, scheme-less defaults to wss, and the
+* machine/label ride as query pairs (percent-encoded by URL).
+*/
+function portalWsUrl(appUrl, machine, label) {
+	const base = appUrl.replace(/\/+$/, "");
+	let wsBase;
+	if (base.startsWith("https://")) wsBase = `wss://${base.slice(8)}`;
+	else if (base.startsWith("http://")) wsBase = `ws://${base.slice(7)}`;
+	else wsBase = `wss://${base}`;
+	const url = new URL(`${wsBase}/api/v1/portal/desktop`);
+	url.searchParams.set("machine", machine);
+	url.searchParams.set("label", label);
+	return url.toString();
+}
+
+//#endregion
 //#region ../portal-protocol/src/index.ts
 const MAX_WS_FRAME_BYTES = 16 * 1024 * 1024;
 const T_DATA = 1;
@@ -31,7 +87,8 @@ const ctrlMessageSchema = z.discriminatedUnion("t", [
 	z.object({
 		t: z.literal("open"),
 		argv: z.array(z.string()),
-		env: z.record(z.string()).nullable()
+		env: z.record(z.string()).nullable(),
+		conversationId: z.string().nullable().optional()
 	}),
 	z.object({ t: z.literal("stdin_eof") }),
 	z.object({ t: z.literal("pause") }),
@@ -103,7 +160,7 @@ var JobManager = class {
 	handleCtrl(id, msg) {
 		switch (msg.t) {
 			case "open":
-				this.startJob(id, msg.argv, msg.env);
+				this.startJob(id, msg.argv, msg.env, msg.conversationId ?? null);
 				return;
 			case "stdin_eof":
 				this.jobs.get(id)?.child.stdin.end();
@@ -133,7 +190,7 @@ var JobManager = class {
 			job.child.stderr.resume();
 		}
 	}
-	startJob(id, argv, env) {
+	startJob(id, argv, env, conversationId) {
 		const [program, ...args] = argv;
 		if (!program) {
 			this.opts.send(encodeCtrl(id, {
@@ -145,7 +202,7 @@ var JobManager = class {
 		let child;
 		try {
 			child = spawn(program, args, {
-				cwd: this.opts.cwd,
+				cwd: this.opts.resolveCwd(conversationId),
 				env: buildEnv(env),
 				stdio: [
 					"pipe",
@@ -194,6 +251,89 @@ var JobManager = class {
 	}
 };
 
+//#endregion
+//#region src/chat/portal/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;
+}
+async function grantPortalAccess(auth, { deviceId, agentId }) {
+	await portalFetch(auth, `/api/v1/portal/devices/${encodeURIComponent(deviceId)}/grants`, {
+		method: "POST",
+		body: JSON.stringify({ agentId })
+	});
+}
+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 per-surface handle (`<host>-cli` vs the desktop's
+* `<host>`), not the display label.
+*/
+function findThisDevice(devices, machineName) {
+	return devices.find((device) => device.machineName === machineName) ?? null;
+}
+
 //#endregion
 //#region src/chat/portal/client.ts
 const INITIAL_BACKOFF_MS = 500;
@@ -309,7 +449,7 @@ var PortalClient = class {
 			});
 			this.ws = ws;
 			const jobs = new JobManager({
-				cwd: this.opts.cwd,
+				resolveCwd: this.opts.resolveCwd,
 				send: (frame) => {
 					if (ws.readyState === WebSocket.OPEN) ws.send(frame);
 				}
@@ -363,4 +503,4 @@ function sleep(ms) {
 }
 
 //#endregion
-export { PortalClient as t };
+export { registerPortalDevice as a, grantPortalAccess as i, fetchPortalDevices as n, revokePortalAccess as o, findThisDevice as r, machineIdentity as s, PortalClient as t };

package/dist/js/client-DuwxEDG4.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import "./rest-BlN_uWmL.mjs";
+import { t as PortalClient } from "./client-Dc7GZ3PG.mjs";
+
+export { PortalClient };

package/dist/js/daemon-Ch_MSDmQ.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./rest-BlN_uWmL.mjs";
+import "./client-Dc7GZ3PG.mjs";
+import { a as runPortalDaemon, i as queryDaemonStatus, n as ensureDaemonRunning, o as stopDaemon, r as isDaemonListening, t as PortalDaemon } from "./daemon-Co4CtpXZ.mjs";
+
+export { runPortalDaemon };