skydive-cli 0.2.0 → 0.3.0

package/dist/js/daemon-Co4CtpXZ.mjs

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+import { o as isRecord } from "./rest-BlN_uWmL.mjs";
+import { t as PortalClient } from "./client-Dc7GZ3PG.mjs";
+import os from "node:os";
+import path from "node:path";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { connect, createServer } from "node:net";
+import { access, appendFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+
+//#region src/chat/portal/local-protocol.ts
+/**
+* Local IPC between the portal DAEMON and the `skydive` CLI processes attached
+* to it, on one host.
+*
+* Why a daemon at all: every `skydive` process used to open its OWN portal
+* WebSocket and register under the identical `<host>-cli` machine name. Portal
+* presence is a single key per (org, machineName), so N processes overwrote it
+* on every heartbeat and the server superseded them in turn — the portal
+* flapped "connected / reconnecting" once per heartbeat while never settling.
+*
+* The daemon fixes this by construction: ONE long-lived process per (user,
+* appUrl) owns the single portal WebSocket and is the only writer of the
+* presence key, so there is nothing to fight over. Every `skydive` process is a
+* thin CLIENT: on startup it spawns the daemon if absent, connects to this Unix
+* socket, registers its conversation→cwd binding, and otherwise ignores the
+* portal entirely.
+*
+* Per-conversation cwd: an agent's `platform portal exec` carries the
+* originating `ANYONE_CONVERSATION_ID`; the server threads it into the `open`
+* directive; the daemon looks the conversation up in its live `conversationId →
+* cwd` map (populated + updated by the attached CLI, including after `!cd`) and
+* runs the child there. So exec for a conversation always lands in that
+* conversation's current shell directory, deterministically, regardless of how
+* many terminals are open.
+*
+* Wire format: newline-delimited JSON, one object per line, both directions —
+* the same shape as the cmux control socket already used elsewhere in the CLI.
+*/
+/** Bump when the client/daemon message shapes change incompatibly. */
+const LOCAL_PROTOCOL_VERSION = 1;
+/**
+* argv flag that makes the CLI entry run AS the portal daemon instead of
+* dispatching a normal command. `ensureDaemonRunning` respawns this same
+* executable with `<flag> <appUrl>`; `bin.ts` routes it before yargs, mirroring
+* the update-check worker. Kept here so both the spawner and the entry agree.
+*/
+const PORTAL_DAEMON_FLAG = "--skydive-internal-portal-daemon";
+/**
+* Per-user, per-app daemon socket + state paths. Scoped by OS user and a hash
+* of the appUrl so two logins or two deployments (prod vs a PR preview) get
+* distinct daemons and never share a portal identity. Kept under the OS temp
+* dir because Unix socket paths are length-limited (~104 bytes on macOS).
+*/
+function daemonPaths(appUrl) {
+	const user = safeSegment(os.userInfo().username || "user");
+	const app = createHash("sha256").update(appUrl).digest("hex").slice(0, 12);
+	const dir = path.join(os.tmpdir(), `skydive-portal-${user}-${app}`);
+	return {
+		dir,
+		socketPath: path.join(dir, "daemon.sock"),
+		statePath: path.join(dir, "state.json"),
+		logPath: path.join(dir, "daemon.log")
+	};
+}
+function safeSegment(value) {
+	return value.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 24) || "user";
+}
+/**
+* `hello` — a CLI attaches. `sessionId` is unique per CLI process; `token` is
+* the CLI's session token, which the daemon needs to mint the portal device
+* token (the daemon is spawned lazily and holds no session of its own). The
+* daemon uses the FIRST hello's token to connect and refreshes from later
+* hellos so a long-lived daemon can outlive the CLI that spawned it.
+*/
+const clientHelloSchema = z.object({
+	t: z.literal("hello"),
+	v: z.number(),
+	sessionId: z.string().min(1),
+	token: z.string().min(1)
+});
+/**
+* `bind` — associate a conversation with a working directory. Sent on chat
+* start and re-sent whenever the conversation's shell cwd changes (e.g. after
+* `!cd`), so the daemon always runs that conversation's exec in the right
+* place. `conversationId` may be null for a brand-new conversation with no id
+* yet; the CLI re-binds once the server assigns one.
+*/
+const clientBindSchema = z.object({
+	t: z.literal("bind"),
+	sessionId: z.string().min(1),
+	conversationId: z.string().min(1),
+	cwd: z.string().min(1)
+});
+/** `enable`/`disable` — turn machine sharing on/off (user-initiated). */
+const clientEnableSchema = z.object({ t: z.literal("enable") });
+const clientDisableSchema = z.object({ t: z.literal("disable") });
+/** `grant` — authorize one agent to reach this machine (user-initiated). */
+const clientGrantSchema = z.object({
+	t: z.literal("grant"),
+	agentId: z.string().min(1)
+});
+/** `bye` — a CLI detaches cleanly (its conversations drop from the map). */
+const clientByeSchema = z.object({
+	t: z.literal("bye"),
+	sessionId: z.string().min(1)
+});
+/**
+* `status` — an operator control request (`skydive portal daemon status`). The
+* daemon replies with a single `status_result` and the connection closes; it is
+* not a full attach, so it carries no sessionId and never becomes a client.
+*/
+const clientStatusSchema = z.object({ t: z.literal("status") });
+/**
+* `shutdown` — an operator hard-takedown (`skydive portal daemon stop`). The
+* daemon closes the portal connection, disconnects every attached client, and
+* exits — cutting live exec/tunnel connections, not just refusing new ones.
+*/
+const clientShutdownSchema = z.object({ t: z.literal("shutdown") });
+const clientMessageSchema = z.discriminatedUnion("t", [
+	clientHelloSchema,
+	clientBindSchema,
+	clientEnableSchema,
+	clientDisableSchema,
+	clientGrantSchema,
+	clientByeSchema,
+	clientStatusSchema,
+	clientShutdownSchema
+]);
+/**
+* `state` — the shared portal status, pushed to every attached client so each
+* process shows the same connected/error/grant state the daemon holds.
+*/
+const daemonStateSchema = z.object({
+	t: z.literal("state"),
+	status: z.enum([
+		"off",
+		"connecting",
+		"connected",
+		"error"
+	]),
+	machineName: z.string(),
+	friendlyName: z.string(),
+	error: z.string().nullable(),
+	grantedAgentIds: z.array(z.string())
+});
+/** `hello_ok` — the daemon accepts an attach and reports its protocol version. */
+const daemonHelloOkSchema = z.object({
+	t: z.literal("hello_ok"),
+	v: z.number()
+});
+/**
+* `status_result` — the daemon's reply to a `status` control request: a snapshot
+* of everything an operator wants from `skydive portal daemon status` — the
+* portal connection state, how many CLIs are attached, and the conversation→cwd
+* routing map. The daemon sends one and the control connection closes.
+*/
+const daemonStatusResultSchema = z.object({
+	t: z.literal("status_result"),
+	v: z.number(),
+	pid: z.number(),
+	appUrl: z.string(),
+	portal: z.object({
+		status: z.enum([
+			"off",
+			"connecting",
+			"connected",
+			"error"
+		]),
+		machineName: z.string(),
+		friendlyName: z.string(),
+		error: z.string().nullable(),
+		grantedAgentIds: z.array(z.string())
+	}),
+	clientCount: z.number(),
+	cwds: z.record(z.string(), z.string())
+});
+const daemonMessageSchema = z.discriminatedUnion("t", [
+	daemonStateSchema,
+	daemonHelloOkSchema,
+	daemonStatusResultSchema
+]);
+function encodeLine(msg) {
+	return `${JSON.stringify(msg)}\n`;
+}
+/**
+* Stateful line splitter: feed raw socket chunks, get back complete JSON lines.
+* A partial trailing line is buffered until its newline arrives.
+*/
+function makeLineParser() {
+	let buf = "";
+	return (chunk) => {
+		buf += chunk;
+		const lines = [];
+		let nl = buf.indexOf("\n");
+		while (nl !== -1) {
+			lines.push(buf.slice(0, nl));
+			buf = buf.slice(nl + 1);
+			nl = buf.indexOf("\n");
+		}
+		return lines;
+	};
+}
+/** Parse one line into a client message, or null if malformed. */
+function parseClientMessage(line) {
+	try {
+		return clientMessageSchema.parse(JSON.parse(line));
+	} catch (_error) {
+		return null;
+	}
+}
+/** Parse one line into a daemon message, or null if malformed. */
+function parseDaemonMessage(line) {
+	try {
+		return daemonMessageSchema.parse(JSON.parse(line));
+	} catch (_error) {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/chat/portal/daemon.ts
+/**
+* The portal DAEMON: one long-lived process per (user, appUrl) that owns the
+* SINGLE portal WebSocket to the server and is the only writer of the machine's
+* presence key. Every `skydive` CLI attaches to it over a Unix socket instead
+* of opening its own portal connection, so N concurrent CLIs can no longer
+* fight over one machine identity (the flap) — there is exactly one identity by
+* construction.
+*
+* State it owns:
+*  - the one `PortalClient` (portal WS + device registration + grants);
+*  - a live `conversationId -> cwd` map, populated and updated by attached CLIs
+*    (including after `!cd`), and PERSISTED so a daemon restart doesn't lose
+*    where a conversation's exec should run. An exec directive carries its
+*    originating conversation id; the daemon runs the child in that
+*    conversation's cwd.
+*
+* Lifecycle: spawned lazily by the first CLI that finds no daemon listening.
+* It exits on its own once the last CLI detaches (after a short linger, so it
+* survives rapid session churn), so there is never an orphan holding the portal
+* open after every chat is closed.
+*/
+/** Grace period after the last client detaches before the daemon exits. */
+const IDLE_SHUTDOWN_MS = 3e4;
+var PortalDaemon = class {
+	paths;
+	server = null;
+	client = null;
+	lastState = null;
+	conns = /* @__PURE__ */ new Set();
+	cwds = /* @__PURE__ */ new Map();
+	fallbackCwd;
+	idleTimer = null;
+	sessionToken = null;
+	constructor(appUrl) {
+		this.appUrl = appUrl;
+		this.paths = daemonPaths(appUrl);
+		this.fallbackCwd = process.env.HOME ?? process.cwd();
+	}
+	/** Start listening. Rejects if the socket is already held by another daemon. */
+	async listen() {
+		await mkdir(this.paths.dir, { recursive: true });
+		await this.loadState();
+		await this.clearStaleSocket();
+		return new Promise((resolve, reject) => {
+			const server = createServer((socket) => this.onClientConnect(socket));
+			server.on("error", reject);
+			server.listen(this.paths.socketPath, () => {
+				this.server = server;
+				this.armIdleTimer();
+				resolve();
+			});
+		});
+	}
+	async clearStaleSocket() {
+		if (!await pathExists(this.paths.socketPath)) return;
+		if (await new Promise((resolve) => {
+			const probe = connect(this.paths.socketPath);
+			probe.on("connect", () => {
+				probe.destroy();
+				resolve(true);
+			});
+			probe.on("error", () => resolve(false));
+		})) throw new Error("daemon already running");
+		await unlink(this.paths.socketPath).catch((_error) => {});
+	}
+	onClientConnect(socket) {
+		const conn = {
+			socket,
+			sessionId: null,
+			conversations: /* @__PURE__ */ new Set()
+		};
+		this.conns.add(conn);
+		this.clearIdleTimer();
+		socket.setEncoding("utf8");
+		const parse = makeLineParser();
+		socket.on("data", (chunk) => {
+			for (const line of parse(chunk)) this.onClientLine(conn, line);
+		});
+		const drop = () => this.onClientClose(conn);
+		socket.on("close", drop);
+		socket.on("error", drop);
+	}
+	onClientLine(conn, line) {
+		const msg = parseClientMessage(line);
+		if (!msg) return;
+		switch (msg.t) {
+			case "hello":
+				conn.sessionId = msg.sessionId;
+				this.sessionToken = msg.token;
+				this.ensureClient();
+				this.send(conn, {
+					t: "hello_ok",
+					v: LOCAL_PROTOCOL_VERSION
+				});
+				if (this.lastState) this.send(conn, stateMessage(this.lastState));
+				return;
+			case "bind":
+				conn.conversations.add(msg.conversationId);
+				this.cwds.set(msg.conversationId, msg.cwd);
+				this.fallbackCwd = msg.cwd;
+				this.persistState();
+				return;
+			case "enable":
+				this.ensureClient();
+				this.client?.enable();
+				return;
+			case "disable":
+				this.client?.disable();
+				return;
+			case "grant":
+				this.ensureClient();
+				this.client?.grantAgent(msg.agentId).catch((error) => {
+					this.logError("grantAgent failed", error);
+				});
+				return;
+			case "bye":
+				this.onClientClose(conn);
+				return;
+			case "status":
+				this.send(conn, this.statusResult());
+				return;
+			case "shutdown":
+				this.forceShutdown();
+				return;
+			default: return msg;
+		}
+	}
+	onClientClose(conn) {
+		if (!this.conns.has(conn)) return;
+		this.conns.delete(conn);
+		try {
+			conn.socket.destroy();
+		} catch (_error) {}
+		if (this.conns.size === 0) this.armIdleTimer();
+	}
+	/** Create the single PortalClient the first time a client needs the portal. */
+	ensureClient() {
+		if (this.client || !this.sessionToken) return;
+		this.client = new PortalClient({
+			appUrl: this.appUrl,
+			sessionToken: this.sessionToken,
+			resolveCwd: (conversationId) => this.resolveCwd(conversationId),
+			onState: (state) => {
+				this.lastState = state;
+				this.broadcast(stateMessage(state));
+			}
+		});
+	}
+	/** The cwd an exec for `conversationId` runs in. */
+	resolveCwd(conversationId) {
+		if (conversationId) {
+			const cwd = this.cwds.get(conversationId);
+			if (cwd) return cwd;
+		}
+		return this.fallbackCwd;
+	}
+	send(conn, msg) {
+		if (conn.socket.writable) conn.socket.write(encodeLine(msg));
+	}
+	broadcast(msg) {
+		for (const conn of this.conns) this.send(conn, msg);
+	}
+	armIdleTimer() {
+		this.clearIdleTimer();
+		this.idleTimer = setTimeout(() => this.shutdown(), IDLE_SHUTDOWN_MS);
+		this.idleTimer.unref();
+	}
+	clearIdleTimer() {
+		if (this.idleTimer) {
+			clearTimeout(this.idleTimer);
+			this.idleTimer = null;
+		}
+	}
+	/** Append a line to the daemon log file (best-effort, for post-hoc debugging). */
+	logError(context, error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${context}: ${message}\n`;
+		appendFile(this.paths.logPath, line).catch((_error) => {});
+	}
+	shutdown() {
+		if (this.conns.size > 0) return;
+		this.client?.dispose();
+		this.server?.close();
+		process.exit(0);
+	}
+	/** Snapshot for a `status` control request. */
+	statusResult() {
+		const portal = this.lastState;
+		return {
+			t: "status_result",
+			v: LOCAL_PROTOCOL_VERSION,
+			pid: process.pid,
+			appUrl: this.appUrl,
+			portal: {
+				status: portal?.status ?? "off",
+				machineName: portal?.machineName ?? "",
+				friendlyName: portal?.friendlyName ?? "",
+				error: portal?.error ?? null,
+				grantedAgentIds: portal?.grantedAgentIds ?? []
+			},
+			clientCount: [...this.conns].filter((c) => c.sessionId !== null).length,
+			cwds: Object.fromEntries(this.cwds)
+		};
+	}
+	/**
+	* Operator-initiated hard takedown: unlike the idle `shutdown`, this ignores
+	* the client-count guard, actively disconnects every attached CLI (cutting
+	* their live exec/tunnel relays), drops the portal connection, and exits.
+	*/
+	forceShutdown() {
+		for (const conn of this.conns) try {
+			conn.socket.destroy();
+		} catch (_error) {}
+		this.conns.clear();
+		this.client?.dispose();
+		this.server?.close();
+		process.exit(0);
+	}
+	async loadState() {
+		try {
+			const raw = await readFile(this.paths.statePath, "utf8");
+			const parsed = JSON.parse(raw);
+			if (isRecord(parsed) && parsed.version === LOCAL_PROTOCOL_VERSION && isRecord(parsed.cwds)) {
+				for (const [id, cwd] of Object.entries(parsed.cwds)) if (typeof cwd === "string") this.cwds.set(id, cwd);
+			}
+		} catch (_error) {}
+	}
+	persistState() {
+		const state = {
+			version: LOCAL_PROTOCOL_VERSION,
+			cwds: Object.fromEntries(this.cwds)
+		};
+		writeFile(this.paths.statePath, JSON.stringify(state)).catch((error) => {
+			this.logError("persistState failed", error);
+		});
+	}
+};
+/**
+* Spawn a detached daemon process for this appUrl if one isn't already running.
+* The CLI calls this on startup; it returns once the daemon is listening (or
+* immediately if one already is). It respawns THIS executable (the bundled CLI
+* entry) with PORTAL_DAEMON_FLAG, which `bin.ts` routes to `runPortalDaemon`
+* before dispatching a normal command — the same pattern the update-check
+* worker uses, so it survives bundling (import.meta.url points at the bundle,
+* not a standalone daemon module).
+*/
+async function ensureDaemonRunning(appUrl) {
+	const { socketPath } = daemonPaths(appUrl);
+	if (await isDaemonListening(socketPath)) return;
+	const entry = process.argv[1];
+	const args = entry ? [
+		entry,
+		PORTAL_DAEMON_FLAG,
+		appUrl
+	] : [PORTAL_DAEMON_FLAG, appUrl];
+	spawn(process.execPath, args, {
+		detached: true,
+		stdio: "ignore",
+		env: process.env
+	}).unref();
+	for (let i = 0; i < 50; i += 1) {
+		if (await isDaemonListening(socketPath)) return;
+		await sleep(100);
+	}
+}
+/**
+* Entry the CLI calls when launched with PORTAL_DAEMON_FLAG: become the daemon.
+* `appUrl` is the argv token right after the flag.
+*/
+function runPortalDaemon(argv) {
+	const appUrl = argv[argv.indexOf(PORTAL_DAEMON_FLAG) + 1];
+	if (!appUrl) process.exit(1);
+	new PortalDaemon(appUrl).listen().catch(() => process.exit(1));
+}
+async function isDaemonListening(socketPath) {
+	if (!await pathExists(socketPath)) return false;
+	return new Promise((resolve) => {
+		const probe = connect(socketPath);
+		probe.on("connect", () => {
+			probe.destroy();
+			resolve(true);
+		});
+		probe.on("error", () => resolve(false));
+	});
+}
+async function pathExists(p) {
+	try {
+		await access(p);
+		return true;
+	} catch (_error) {
+		return false;
+	}
+}
+/** Open a short-lived control connection to the daemon, or null if none. */
+function connectControl(socketPath) {
+	return new Promise((resolve) => {
+		const sock = connect(socketPath);
+		sock.once("connect", () => resolve(sock));
+		sock.once("error", () => resolve(null));
+	});
+}
+/**
+* Query a running daemon for its status snapshot. Returns null when no daemon is
+* listening (so callers can print "not running") or if it doesn't reply in time.
+*/
+async function queryDaemonStatus(appUrl) {
+	const { socketPath } = daemonPaths(appUrl);
+	const sock = await connectControl(socketPath);
+	if (!sock) return null;
+	return new Promise((resolve) => {
+		const parse = makeLineParser();
+		let settled = false;
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			sock.destroy();
+			resolve(result);
+		};
+		const timer = setTimeout(() => finish(null), 3e3);
+		sock.setEncoding("utf8");
+		sock.on("data", (chunk) => {
+			for (const line of parse(chunk)) {
+				const msg = parseDaemonMessage(line);
+				if (msg?.t === "status_result") finish(msg);
+			}
+		});
+		sock.on("error", () => finish(null));
+		sock.on("close", () => finish(null));
+		sock.write(encodeLine({ t: "status" }));
+	});
+}
+/**
+* Hard-stop a running daemon. Preferred path: send `shutdown` over the control
+* socket so it drains clients and exits cleanly. If the socket is unresponsive
+* (a wedged daemon), fall back to SIGTERM then SIGKILL by the pid the status
+* reports. Returns what actually happened.
+*/
+async function stopDaemon(appUrl) {
+	const { socketPath } = daemonPaths(appUrl);
+	if (!await isDaemonListening(socketPath)) return "not-running";
+	const status = await queryDaemonStatus(appUrl);
+	const sock = await connectControl(socketPath);
+	if (sock) {
+		sock.write(encodeLine({ t: "shutdown" }));
+		for (let i = 0; i < 30; i += 1) {
+			await sleep(100);
+			if (!await isDaemonListening(socketPath)) {
+				sock.destroy();
+				return "stopped";
+			}
+		}
+		sock.destroy();
+	}
+	const pid = status?.pid;
+	if (typeof pid === "number") try {
+		process.kill(pid, "SIGTERM");
+		for (let i = 0; i < 20; i += 1) {
+			await sleep(100);
+			if (!await isDaemonListening(socketPath)) return "killed";
+		}
+		process.kill(pid, "SIGKILL");
+		return "killed";
+	} catch (_error) {
+		return await isDaemonListening(socketPath) ? "failed" : "killed";
+	}
+	return await isDaemonListening(socketPath) ? "failed" : "stopped";
+}
+function stateMessage(state) {
+	return {
+		t: "state",
+		status: state.status,
+		machineName: state.machineName,
+		friendlyName: state.friendlyName,
+		error: state.error,
+		grantedAgentIds: state.grantedAgentIds
+	};
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+export { runPortalDaemon as a, PORTAL_DAEMON_FLAG as c, makeLineParser as d, parseDaemonMessage as f, queryDaemonStatus as i, daemonPaths as l, ensureDaemonRunning as n, stopDaemon as o, isDaemonListening as r, LOCAL_PROTOCOL_VERSION as s, PortalDaemon as t, encodeLine as u };