skydive-cli 0.5.0-beta.5 → 0.5.0-beta.52

package/dist/js/client-aFwHzCPG.mjs

@@ -0,0 +1,963 @@
+#!/usr/bin/env node
+import { a as mintPortalDeviceToken, c as unifyLegacyCliGrants, i as grantPortalAccess, l as startTlsForward, n as fetchPortalDevices, r as findThisDevice } from "./api-TwLD7ibI.mjs";
+import os from "node:os";
+import { z } from "zod";
+import * as childProcess from "node:child_process";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import { WebSocket, createWebSocketStream } from "ws";
+
+//#region ../portal-daemon/src/machine.ts
+const SCUTIL_TIMEOUT_MS = 2e3;
+const SCUTIL_ATTEMPTS = 3;
+/**
+* Identity this machine registers under on the portal.
+*
+* One device row per (org, user, machine): the daemon owns the host's single
+* portal connection, and every surface (CLI, TUI, desktop app) shares that
+* row, so a grant applies to the machine no matter which surface the user
+* shared from. The name must therefore match what the desktop app registers —
+* on macOS that is `scutil --get LocalHostName` (the Rust client's own
+* derivation, stabler than the network-assigned hostname).
+*
+* The machine name is a durable IDENTITY, not a fresh network reading: every
+* grant hangs off the device row keyed by this name, so if it changes the
+* device flips to a brand-new row with ZERO grants and every agent re-prompts
+* across every open CLI. `os.hostname()` is NOT durable — macOS rewrites it
+* from DHCP/DNS per network — so it must never be allowed to silently replace
+* a name we already registered under. Resolution order:
+*
+*   1. `scutil --get LocalHostName` (retried) — the stable, correct source.
+*   2. `previous` — the name we last successfully registered under, persisted
+*      by the daemon. Preferred over the volatile hostname so a transient
+*      `scutil` failure keeps our existing identity (and grants) intact.
+*   3. `os.hostname()` — last resort for a machine that has NEVER resolved a
+*      name (first run, non-macOS, scutil permanently unavailable).
+*
+* Historically the CLI suffixed `-cli` to keep a device distinct from the
+* desktop's; `unifyLegacyCliGrants` migrates grants off those rows.
+*/
+async function resolveMachineIdentity(previous) {
+	const persisted = previous?.trim() || null;
+	if (process.platform !== "darwin") {
+		const machineName = persisted ?? fallbackHost();
+		return {
+			machineName,
+			friendlyName: machineName,
+			machineNameSource: persisted ? "persisted" : "hostname-fallback"
+		};
+	}
+	const local = await scutilRead("LocalHostName");
+	if (local) return {
+		machineName: local,
+		friendlyName: await scutilRead("ComputerName") ?? local,
+		machineNameSource: "scutil"
+	};
+	if (persisted) return {
+		machineName: persisted,
+		friendlyName: persisted,
+		machineNameSource: "persisted"
+	};
+	const fallback = fallbackHost();
+	return {
+		machineName: fallback,
+		friendlyName: fallback,
+		machineNameSource: "hostname-fallback"
+	};
+}
+function fallbackHost() {
+	return (os.hostname() || "machine").trim().replace(/\.local$/i, "") || "machine";
+}
+function scutilRead(key) {
+	return attempt(0);
+	function attempt(n) {
+		return new Promise((resolve) => {
+			childProcess.execFile("/usr/sbin/scutil", ["--get", key], { timeout: SCUTIL_TIMEOUT_MS }, (error, stdout) => {
+				if (error) {
+					if (n + 1 < SCUTIL_ATTEMPTS) {
+						resolve(attempt(n + 1));
+						return;
+					}
+					resolve(null);
+					return;
+				}
+				const value = stdout.trim();
+				resolve(value.length > 0 ? value : null);
+			});
+		});
+	}
+}
+const INHERITED_ENV = [
+	"HOME",
+	"USER",
+	"LOGNAME",
+	"SHELL",
+	"LANG",
+	"LC_ALL",
+	"TMPDIR",
+	"TERM",
+	"PATH"
+];
+const DARWIN_PATH_PREPEND = ["/opt/homebrew/bin", "/usr/local/bin"];
+function buildEnv(extra) {
+	const env = {};
+	for (const key of INHERITED_ENV) {
+		const value = process.env[key];
+		if (value !== void 0) env[key] = value;
+	}
+	if (process.platform === "darwin") {
+		const current = env.PATH ? env.PATH.split(":") : [];
+		const missing = DARWIN_PATH_PREPEND.filter((dir) => !current.includes(dir));
+		if (missing.length > 0) env.PATH = [...missing, ...current].join(":");
+	}
+	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-daemon/src/util.ts
+/** Narrowing helper for the unknown JSON payloads the daemon reads (persisted
+* state, wire frames). A type predicate (not an `as` cast), so call sites can
+* read properties without asserting. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Best-effort message from an unknown thrown value. */
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+
+//#endregion
+//#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(),
+		conversationId: z.string().nullable().optional()
+	}),
+	z.object({ t: z.literal("stdin_eof") }),
+	z.object({
+		t: z.literal("reverse_listen"),
+		listenPort: z.number().int().positive(),
+		targetPort: z.number().int().positive(),
+		dialOrigin: z.string().min(1),
+		token: z.string().min(1)
+	}),
+	z.object({ t: z.literal("reverse_listening") }),
+	z.object({
+		t: z.literal("reverse_token"),
+		token: z.string().min(1)
+	}),
+	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(),
+		frames: z.number().int().nonnegative().optional()
+	}),
+	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 ../portal-daemon/src/reverse-listener.ts
+/**
+* The desktop half of an agent-initiated expose tunnel (`platform portal
+* expose`): listen on the local loopback and pipe each accepted TCP
+* connection to the agent sandbox's daemon (`/portal/tcp`) through the
+* agent-webserver edge Worker — the same per-connection dial-and-pipe as the
+* user-initiated `skydive portal forward`, just started from a directive
+* instead of a terminal. Tunnel bytes never touch the directive stream that
+* created this listener; it only anchors the lifetime and carries the token.
+*
+* `target()` is read per connection so a token refresh (or any future
+* retarget) applies to the next dial without touching established pipes.
+*/
+var ReverseListener = class {
+	server = null;
+	tls = null;
+	conns = /* @__PURE__ */ new Set();
+	constructor(opts) {
+		this.opts = opts;
+	}
+	/**
+	* One tunnel to the sandbox target — the same per-connection edge dial the
+	* plain accept path inlines, shaped for the TLS listener's acquireTunnel
+	* seam. Resolves once the upgrade completes, with the duplex PAUSED so no
+	* early bytes drop before adoption.
+	*/
+	dialTunnel() {
+		const { dialOrigin, targetPort, token } = this.opts.target();
+		const ws = new WebSocket(`${dialOrigin.replace(/^http/, "ws")}/portal/tcp?port=${targetPort}`, { headers: { authorization: `Bearer ${token}` } });
+		return new Promise((resolve, reject) => {
+			ws.once("error", reject);
+			ws.once("unexpected-response", (_req, res) => {
+				res.destroy();
+				reject(/* @__PURE__ */ new Error(`tunnel rejected (HTTP ${res.statusCode ?? "?"})`));
+			});
+			ws.once("open", () => {
+				const stream = createWebSocketStream(ws);
+				stream.pause();
+				resolve({
+					stream,
+					close: () => stream.destroy()
+				});
+			});
+		});
+	}
+	start() {
+		const server = net.createServer((sock) => {
+			this.conns.add(sock);
+			sock.once("close", () => this.conns.delete(sock));
+			sock.pause();
+			const { dialOrigin, targetPort, token } = this.opts.target();
+			const ws = new WebSocket(`${dialOrigin.replace(/^http/, "ws")}/portal/tcp?port=${targetPort}`, { headers: { authorization: `Bearer ${token}` } });
+			ws.on("open", () => {
+				const stream = createWebSocketStream(ws);
+				stream.on("error", () => sock.destroy());
+				sock.on("error", () => stream.destroy());
+				sock.pipe(stream).pipe(sock);
+				sock.resume();
+			});
+			ws.on("error", (err) => {
+				this.opts.log(`expose: tunnel connect failed: ${err.message}`);
+				sock.destroy();
+			});
+			ws.on("unexpected-response", (_req, res) => {
+				this.opts.log(`expose: tunnel rejected (HTTP ${res.statusCode ?? "?"})`);
+				res.destroy();
+				sock.destroy();
+			});
+		});
+		server.once("error", (err) => this.opts.onListening(err));
+		server.listen(this.opts.listenPort, "127.0.0.1", () => {
+			this.opts.onListening(null);
+			this.startTls();
+		});
+		this.server = server;
+	}
+	/**
+	* The additive TLS+h2 twin (fire-and-forget from start): browsers negotiate
+	* h2 there, lifting the 6-connection cap that serializes module-heavy dev
+	* servers. Every failure logs once and leaves the plain listener — the
+	* product's default behavior — untouched. The ack (`reverse_listening`)
+	* deliberately stays keyed to the plain bind: TLS is an enhancement, never
+	* a condition of "the tunnel is up".
+	*/
+	startTls() {
+		const source = this.opts.tlsCertSource;
+		if (!source) return;
+		(async () => {
+			try {
+				const cert = await source();
+				if (!cert || this.server === null) return;
+				this.tls = await startTlsForward({
+					cert,
+					localPort: this.opts.listenPort,
+					targetPort: this.opts.target().targetPort,
+					acquireTunnel: () => this.dialTunnel(),
+					log: this.opts.log
+				});
+				if (this.server === null) {
+					const straggler = this.tls;
+					this.tls = null;
+					await straggler.close();
+					return;
+				}
+				this.opts.log(`expose: TLS origin up: https://${this.tls.hostname}:${this.tls.port} (HTTP/2)`);
+			} catch (error) {
+				this.opts.log(`expose: TLS origin unavailable (${error instanceof Error ? error.message : String(error)}); http listener unaffected`);
+			}
+		})();
+	}
+	stop() {
+		this.server?.close();
+		this.server = null;
+		const tls = this.tls;
+		this.tls = null;
+		if (tls) tls.close();
+		for (const sock of this.conns) sock.destroy();
+		this.conns.clear();
+	}
+};
+
+//#endregion
+//#region ../portal-daemon/src/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();
+	reverse = /* @__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();
+		for (const rev of this.reverse.values()) {
+			rev.settled = true;
+			rev.listener.stop();
+		}
+		this.reverse.clear();
+	}
+	handleCtrl(id, msg) {
+		switch (msg.t) {
+			case "open":
+				this.startJob(id, msg.argv, msg.env, msg.conversationId ?? null);
+				return;
+			case "reverse_listen":
+				this.startReverse(id, {
+					listenPort: msg.listenPort,
+					target: {
+						dialOrigin: msg.dialOrigin,
+						targetPort: msg.targetPort,
+						token: msg.token
+					}
+				});
+				return;
+			case "reverse_token": {
+				const rev = this.reverse.get(id);
+				if (rev) rev.target = {
+					...rev.target,
+					token: msg.token
+				};
+				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");
+				this.stopReverse(id);
+				return;
+			case "close":
+			case "error":
+			case "reverse_listening": return;
+			default: return msg;
+		}
+	}
+	startReverse(id, { listenPort, target }) {
+		const rev = {
+			settled: false,
+			target,
+			seq: 0,
+			listener: new ReverseListener({
+				listenPort,
+				target: () => rev.target,
+				tlsCertSource: this.opts.tlsCertSource,
+				log: (msg) => {
+					if (rev.settled) return;
+					this.opts.send(encodeData(id, STREAM.stderr, rev.seq, Buffer.from(msg)));
+					rev.seq = rev.seq + 1 >>> 0;
+				},
+				onListening: (err) => {
+					if (err) {
+						rev.settled = true;
+						this.reverse.delete(id);
+						this.opts.send(encodeCtrl(id, {
+							t: "error",
+							message: `reverse listen failed: ${err.message}`
+						}));
+						return;
+					}
+					this.opts.send(encodeCtrl(id, { t: "reverse_listening" }));
+				}
+			})
+		};
+		this.reverse.set(id, rev);
+		rev.listener.start();
+	}
+	stopReverse(id) {
+		const rev = this.reverse.get(id);
+		if (!rev) return;
+		rev.settled = true;
+		this.reverse.delete(id);
+		rev.listener.stop();
+	}
+	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, conversationId) {
+		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.resolveCwd(conversationId),
+				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,
+				frames: job.seq
+			}));
+		});
+	}
+	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 ../portal-daemon/src/client.ts
+const DEFAULT_HEARTBEAT = {
+	intervalMs: 15e3,
+	maxMissed: 2,
+	wakeTickMs: 2e3,
+	wakeGapThresholdMs: 1e4,
+	netWatchTickMs: 2e3,
+	initialBackoffMs: 500,
+	maxBackoffMs: 1e4
+};
+/**
+* A cheap fingerprint of the machine's network identity: every non-internal
+* interface name plus its IPv4 addresses. When it changes, the active network
+* changed (interface came/went, DHCP handed out a new address, VPN tunnel
+* up/down) and any live socket is riding a route that no longer exists.
+* IPv6 addresses are deliberately excluded: macOS rotates temporary IPv6
+* addresses on a schedule, which would fingerprint as a "change" and cause
+* spurious reconnects — the interface NAME still captures a v6-only tunnel
+* appearing or vanishing.
+*/
+function networkFingerprint() {
+	const parts = [];
+	for (const [name, addrs] of Object.entries(os.networkInterfaces())) {
+		let external = false;
+		for (const addr of addrs ?? []) {
+			if (addr.internal) continue;
+			external = true;
+			if (addr.family === "IPv4") parts.push(`${name}/${addr.address}`);
+		}
+		if (external) parts.push(name);
+	}
+	return parts.sort().join("|");
+}
+/**
+* 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 = "";
+	legacyGrantsChecked = false;
+	wakeWatch = null;
+	lastTick = Date.now();
+	netWatch = null;
+	netFingerprint = networkFingerprint();
+	backoffKick = null;
+	handingOff = false;
+	handoffResolve = null;
+	heartbeatConfig;
+	constructor(opts) {
+		this.opts = opts;
+		this.heartbeatConfig = {
+			...DEFAULT_HEARTBEAT,
+			...opts.heartbeat
+		};
+		this.startWakeWatch();
+		this.startNetWatch();
+	}
+	/**
+	* Detect wake-from-sleep without an Electron/`powerMonitor` dependency (the
+	* daemon also runs headless under the CLI). A repeating timer that should
+	* fire every WAKE_TICK_MS; when the actual gap since the last tick far
+	* exceeds that, the process was suspended (macOS sleep, laptop lid) and the
+	* current socket — if any — is a zombie against a server that has already
+	* reaped our presence. Terminate it now so `connectLoop` redials at once
+	* instead of waiting out the heartbeat deadline. Cheap: one no-op timer.
+	*/
+	startWakeWatch() {
+		this.lastTick = Date.now();
+		this.wakeWatch = setInterval(() => {
+			const now = Date.now();
+			const gap = now - this.lastTick;
+			this.lastTick = now;
+			if (gap > this.heartbeatConfig.wakeGapThresholdMs) this.forceReconnect("woke from sleep; reconnecting portal");
+		}, this.heartbeatConfig.wakeTickMs);
+		this.wakeWatch.unref?.();
+	}
+	/**
+	* Detect a network switch — the awake sibling of the wake detector. Changing
+	* Wi-Fi↔ethernet, switching SSID, or toggling a VPN kills the socket's route
+	* with no FIN/RST, so `ws` may never fire 'close' and the heartbeat's
+	* missed-pong deadline is the best case (~2 intervals), not a guarantee.
+	* Poll the network-identity fingerprint and, the moment it changes, terminate
+	* the socket so `connectLoop` redials over the new network immediately.
+	* Cheap: `os.networkInterfaces()` is one syscall-backed read per tick.
+	*/
+	startNetWatch() {
+		this.netWatch = setInterval(() => {
+			const fingerprint = networkFingerprint();
+			if (fingerprint === this.netFingerprint) return;
+			this.netFingerprint = fingerprint;
+			this.forceReconnect("network changed; reconnecting portal");
+		}, this.heartbeatConfig.netWatchTickMs);
+		this.netWatch.unref?.();
+	}
+	/**
+	* The one reaction every detector (wake, network change) converges on: make
+	* the connect loop re-evaluate NOW, whatever state it is in. With a live
+	* socket, terminate it — 'close' resolves `runConnection` and the loop
+	* redials. Between dials (backing off after a failure, e.g. while the
+	* network was down), cut the sleep short so the retry fires immediately — a
+	* dial that was pointless a moment ago is exactly right the moment the
+	* network comes back. These are per-machine local events, uncorrelated
+	* across the fleet, so the immediate retry can't herd; the backoff VALUE is
+	* untouched and still governs the next failure.
+	*/
+	forceReconnect(reason) {
+		if (this.ws) {
+			this.error = reason;
+			this.ws.terminate();
+			return;
+		}
+		this.kickBackoff();
+	}
+	kickBackoff() {
+		const kick = this.backoffKick;
+		this.backoffKick = null;
+		kick?.();
+	}
+	/** The between-redials sleep, interruptible by a detector (forceReconnect). */
+	backoffSleep(ms) {
+		return new Promise((resolve) => {
+			let done = false;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				this.backoffKick = null;
+				resolve();
+			};
+			const timer = setTimeout(finish, ms);
+			this.backoffKick = () => {
+				clearTimeout(timer);
+				finish();
+			};
+		});
+	}
+	isEnabled() {
+		return this.enabled;
+	}
+	isGranted(agentId) {
+		return this.granted.has(agentId);
+	}
+	/** Agents currently authorized on this machine (last known server state). */
+	grantedAgentIds() {
+		return [...this.granted];
+	}
+	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.kickBackoff();
+		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;
+		if (this.wakeWatch) {
+			clearInterval(this.wakeWatch);
+			this.wakeWatch = null;
+		}
+		if (this.netWatch) {
+			clearInterval(this.netWatch);
+			this.netWatch = null;
+		}
+		this.jobs?.killAll();
+		this.jobs = null;
+		this.ws?.close();
+		this.ws = null;
+		this.kickBackoff();
+		this.finishHandoff();
+	}
+	/**
+	* Begin a make-before-break handoff to a successor daemon. Keep the current
+	* portal socket (and thus this machine's presence claim) alive so there is no
+	* `registered but not connected` gap, but stop redialing once it closes — the
+	* successor's `claim()` supersedes us and the server closes our socket, which
+	* is our cue to step down. Resolves when the socket has closed (clean
+	* handoff) OR after `timeoutMs` (the successor never came up, so we release
+	* the slot rather than hold it forever). Idempotent.
+	*/
+	beginHandoff(timeoutMs) {
+		if (this.disposed) return Promise.resolve();
+		if (this.handingOff) return new Promise((resolve) => {
+			const prev = this.handoffResolve;
+			this.handoffResolve = () => {
+				prev?.();
+				resolve();
+			};
+		});
+		this.handingOff = true;
+		if (!this.ws) return Promise.resolve();
+		return new Promise((resolve) => {
+			let done = false;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				clearTimeout(timer);
+				resolve();
+			};
+			this.handoffResolve = finish;
+			const timer = setTimeout(() => {
+				this.disable();
+				this.finishHandoff();
+			}, timeoutMs);
+			if (typeof timer.unref === "function") timer.unref();
+		});
+	}
+	finishHandoff() {
+		const resolve = this.handoffResolve;
+		this.handoffResolve = null;
+		resolve?.();
+	}
+	/**
+	* Grant one agent access to this machine (default-deny; user-initiated).
+	* `conversationId` is the conversation whose run asked (null when the grant
+	* is not answering an in-chat request) — the server uses it to wake the
+	* waiting agent.
+	*/
+	async grantAgent(agentId, conversationId) {
+		const auth = this.sessionAuth();
+		if (!auth) throw new Error("granting needs a signed-in CLI session on this machine (the desktop connection alone cannot manage grants)");
+		await grantPortalAccess(auth, {
+			deviceId: await this.ensureDeviceId(),
+			agentId,
+			conversationId
+		});
+		this.granted.add(agentId);
+		this.emit();
+	}
+	/** Session-authed REST auth, or null when only a device token is held. */
+	sessionAuth() {
+		const { sessionToken } = this.opts.credentials();
+		return sessionToken ? {
+			appUrl: this.opts.appUrl,
+			sessionToken
+		} : null;
+	}
+	/**
+	* The bearer token for the portal WebSocket dial: minted from the session
+	* when one is held, otherwise the pre-minted device token as-is.
+	*/
+	async wsToken() {
+		const creds = this.opts.credentials();
+		if (creds.sessionToken) return mintPortalDeviceToken({
+			appUrl: this.opts.appUrl,
+			sessionToken: creds.sessionToken
+		});
+		if (creds.deviceToken) return creds.deviceToken;
+		throw new Error("no portal credentials (not signed in)");
+	}
+	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() {
+		if (!this.machineName) {
+			const identity = await resolveMachineIdentity(this.opts.persistedMachineName);
+			this.machineName = identity.machineName;
+			this.friendlyName = identity.friendlyName;
+			this.opts.onMachineName(identity.machineName, identity.machineNameSource);
+		}
+		let backoff = this.heartbeatConfig.initialBackoffMs;
+		while (this.enabled && !this.disposed && !this.handingOff) {
+			this.setStatus("connecting");
+			try {
+				const token = await this.wsToken();
+				if (await this.runConnection(token)) backoff = this.heartbeatConfig.initialBackoffMs;
+				else backoff = Math.min(backoff * 2, this.heartbeatConfig.maxBackoffMs);
+			} catch (err) {
+				if (!this.enabled || this.disposed || this.handingOff) break;
+				this.setStatus("error", errorMessage(err));
+				backoff = Math.min(backoff * 2, this.heartbeatConfig.maxBackoffMs);
+			}
+			if (!this.enabled || this.disposed || this.handingOff) break;
+			await this.backoffSleep(Math.random() * backoff);
+		}
+	}
+	runConnection(token) {
+		return new Promise((resolve) => {
+			let settled = false;
+			let healthy = false;
+			const settle = () => {
+				if (settled) return;
+				settled = true;
+				resolve(healthy);
+			};
+			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({
+				resolveCwd: this.opts.resolveCwd,
+				tlsCertSource: this.opts.tlsCertSource,
+				send: (frame) => {
+					if (ws.readyState === WebSocket.OPEN) ws.send(frame);
+				}
+			});
+			this.jobs = jobs;
+			let missed = 0;
+			const heartbeat = setInterval(() => {
+				if (ws.readyState !== WebSocket.OPEN && ws.readyState !== WebSocket.CONNECTING) return;
+				if (missed >= this.heartbeatConfig.maxMissed) {
+					this.error = ws.readyState === WebSocket.CONNECTING ? "portal handshake stalled; reconnecting" : "portal connection went silent (no pong); reconnecting";
+					ws.terminate();
+					return;
+				}
+				missed += 1;
+				if (ws.readyState === WebSocket.OPEN) ws.ping();
+			}, this.heartbeatConfig.intervalMs);
+			const markAlive = () => {
+				missed = 0;
+				healthy = true;
+			};
+			ws.on("open", () => {
+				missed = 0;
+				this.setStatus("connected");
+				this.syncDeviceState();
+			});
+			ws.on("pong", markAlive);
+			ws.on("ping", markAlive);
+			ws.on("message", (data, isBinary) => {
+				markAlive();
+				if (isBinary) jobs.handleFrame(toBuffer(data));
+			});
+			ws.on("error", (err) => {
+				this.error = errorMessage(err);
+			});
+			ws.on("close", () => {
+				clearInterval(heartbeat);
+				jobs.killAll();
+				if (this.jobs === jobs) this.jobs = null;
+				if (this.ws === ws) this.ws = null;
+				if (this.handingOff) this.finishHandoff();
+				settle();
+			});
+		});
+	}
+	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() {
+		const auth = this.sessionAuth();
+		if (!auth) return;
+		try {
+			const { devices } = await fetchPortalDevices(auth);
+			const mine = findThisDevice(devices, this.machineName);
+			if (!mine) return;
+			this.deviceId = mine.id;
+			this.granted = new Set(mine.grantedAgentIds);
+			this.emit();
+		} catch (_error) {}
+	}
+	/**
+	* Post-connect device sync: read our row, then (once per process) copy any
+	* grants still hanging off the legacy `<host>-cli` device onto this one so
+	* agents the user already approved keep their access under the merged
+	* identity.
+	*/
+	async syncDeviceState() {
+		await this.refreshDevice();
+		if (this.legacyGrantsChecked) return;
+		const auth = this.sessionAuth();
+		if (!auth) return;
+		this.legacyGrantsChecked = true;
+		try {
+			if (await unifyLegacyCliGrants(auth, this.machineName) > 0) await this.refreshDevice();
+		} 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 { isRecord as n, resolveMachineIdentity as r, PortalClient as t };