skydive-cli 0.5.0-beta.4 → 0.5.0-beta.44

package/dist/js/{client-Cn2af31H.mjs → client-Btq6bMzX.mjs}

@@ -1,6 +1,108 @@
 #!/usr/bin/env node
 import { WebSocket } from "ws";
 
+//#region ../sandbox-stream-protocol/src/fs.ts
+/** fs frame type bytes. Disjoint from FRAME.* in ./index.ts. */
+const FS_FRAME = {
+	REQ: 32,
+	RES: 33
+};
+/** Filesystem operations the channel supports. One byte on the wire. */
+const FS_OP = {
+	LIST: 1,
+	STAT: 2,
+	READ: 3,
+	WRITE: 4,
+	MKDIR: 5,
+	RENAME: 6,
+	REMOVE: 7,
+	EXISTS: 8
+};
+/** Reply status. OK carries a result; ERR carries a message in `json.message`. */
+const FS_STATUS = {
+	OK: 0,
+	ERR: 1
+};
+const FS_MAX_BLOB_BYTES = 8 * 1024 * 1024;
+const OP_TO_CODE = {
+	list: FS_OP.LIST,
+	stat: FS_OP.STAT,
+	read: FS_OP.READ,
+	write: FS_OP.WRITE,
+	mkdir: FS_OP.MKDIR,
+	rename: FS_OP.RENAME,
+	remove: FS_OP.REMOVE,
+	exists: FS_OP.EXISTS
+};
+const CODE_TO_OP = new Map(Object.entries(OP_TO_CODE).map(([op, code]) => [code, op]));
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+function frame(type, reqId, byte2, json, blob) {
+	const jsonBytes = textEncoder.encode(JSON.stringify(json ?? {}));
+	const out = new Uint8Array(10 + jsonBytes.length + blob.length);
+	const dv = new DataView(out.buffer);
+	out[0] = type;
+	dv.setUint32(1, reqId >>> 0);
+	out[5] = byte2;
+	dv.setUint32(6, jsonBytes.length);
+	out.set(jsonBytes, 10);
+	out.set(blob, 10 + jsonBytes.length);
+	return out;
+}
+const EMPTY = new Uint8Array(0);
+/** client → server: encode an fs request. `blob` is the write payload, or null. */
+function encodeFsRequest(reqId, req, blob) {
+	return frame(FS_FRAME.REQ, reqId, OP_TO_CODE[req.op], req, blob ?? EMPTY);
+}
+/**
+* Decode a server fs reply frame. Returns null for a malformed frame so a peer
+* on a newer protocol can't crash the client.
+*/
+function decodeFsResponse(frameBytes) {
+	const parsed = parseFrame(FS_FRAME.RES, frameBytes);
+	if (!parsed) return null;
+	if (parsed.byte2 === FS_STATUS.ERR) {
+		const message = typeof parsed.json.message === "string" ? parsed.json.message : "fs operation failed";
+		return {
+			reqId: parsed.reqId,
+			status: "error",
+			message
+		};
+	}
+	return {
+		reqId: parsed.reqId,
+		status: "ok",
+		result: parsed.json,
+		blob: parsed.blob
+	};
+}
+function parseFrame(expectedType, frameBytes) {
+	if (frameBytes.length < 10) return null;
+	if (frameBytes[0] !== expectedType) return null;
+	const dv = new DataView(frameBytes.buffer, frameBytes.byteOffset, frameBytes.byteLength);
+	const reqId = dv.getUint32(1);
+	const byte2 = frameBytes[5] ?? 0;
+	const jsonLen = dv.getUint32(6);
+	const jsonStart = 10;
+	const jsonEnd = jsonStart + jsonLen;
+	if (jsonEnd > frameBytes.length) return null;
+	let json;
+	try {
+		const parsed = jsonLen ? JSON.parse(textDecoder.decode(frameBytes.subarray(jsonStart, jsonEnd))) : {};
+		if (typeof parsed !== "object" || parsed === null) return null;
+		json = parsed;
+	} catch {
+		return null;
+	}
+	return {
+		reqId,
+		byte2,
+		json,
+		blob: frameBytes.subarray(jsonEnd)
+	};
+}
+
+//#endregion
 //#region ../sandbox-stream-protocol/src/index.ts
 const SANDBOX_STREAM_PATH = "/api/v1/sandbox/stream";
 const FRAME = {
@@ -19,11 +121,15 @@ function streamSpecToQuery(spec) {
 		cols: String(spec.cols),
 		rows: String(spec.rows)
 	};
-	return {
+	if (spec.mode === "exec") return {
 		agentId: spec.agentId,
 		mode: "exec",
 		command: spec.command
 	};
+	return {
+		agentId: spec.agentId,
+		mode: "fs"
+	};
 }
 function withType(type, payload) {
 	const frame = new Uint8Array(1 + payload.length);
@@ -166,4 +272,4 @@ function toBuffer(data) {
 }
 
 //#endregion
-export { SandboxStream as t };
+export { encodeFsRequest as a, decodeFsResponse as i, SANDBOX_STREAM_PATH as n, streamSpecToQuery as r, SandboxStream as t };

package/dist/js/client-Cga4PJUc.mjs

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

package/dist/js/daemon-client-D5YCk5Hc.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import "./client-BnpgrtCC.mjs";
+import "./daemon-w8vtZ81t.mjs";
+import "./tls-cert-CV-pwxVN.mjs";
+import "./api-TwLD7ibI.mjs";
+import { t as PortalDaemonClient } from "./daemon-client-KKNss0NK.mjs";
+
+export { PortalDaemonClient };

package/dist/js/{daemon-client-DPjmvIDE.mjs → daemon-client-KKNss0NK.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { c as LOCAL_PROTOCOL_VERSION, d as encodeLine, f as makeLineParser, n as ensureDaemonRunning, p as parseDaemonMessage, u as daemonPaths } from "./daemon-BYlIJN6x.mjs";
+import { c as LOCAL_PROTOCOL_VERSION, d as encodeLine, f as makeLineParser, n as ensureDaemonRunning, p as parseDaemonMessage, u as daemonPaths } from "./daemon-w8vtZ81t.mjs";
 import { randomUUID } from "node:crypto";
 import { connect } from "node:net";
 
@@ -12,7 +12,7 @@ var PortalDaemonClient = class {
 	lastBind = null;
 	fallbackCwd = null;
 	wantEnabled = false;
-	pendingGrants = /* @__PURE__ */ new Set();
+	pendingGrants = /* @__PURE__ */ new Map();
 	pendingDeclines = /* @__PURE__ */ new Map();
 	grantedAgentIds = /* @__PURE__ */ new Set();
 	constructor(opts) {
@@ -50,9 +50,10 @@ var PortalDaemonClient = class {
 				conversationId: this.lastBind.conversationId,
 				cwd: this.lastBind.cwd
 			});
-			for (const agentId of this.pendingGrants) this.send({
+			for (const [agentId, conversationId] of this.pendingGrants) this.send({
 				t: "grant",
-				agentId
+				agentId,
+				conversationId
 			});
 			for (const [agentId, declined] of this.pendingDeclines) this.send({
 				t: "decline",
@@ -157,13 +158,16 @@ var PortalDaemonClient = class {
 	* Authorize one agent to run commands on this machine. Resolves once the
 	* request is sent to the daemon (the daemon performs the grant and pushes the
 	* updated state); kept async so it's a drop-in for the old in-process client's
-	* awaited `grantAgent`.
+	* awaited `grantAgent`. `conversationId` names the conversation whose run
+	* asked, so the grant can wake the waiting agent; null when the grant is not
+	* answering an in-chat request.
 	*/
-	grantAgent(agentId) {
-		this.pendingGrants.add(agentId);
+	grantAgent(agentId, conversationId) {
+		this.pendingGrants.set(agentId, conversationId);
 		this.send({
 			t: "grant",
-			agentId
+			agentId,
+			conversationId
 		});
 		return Promise.resolve();
 	}

package/dist/js/daemon-mLypjXdu.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import "./client-BnpgrtCC.mjs";
+import { a as runPortalDaemon, i as queryDaemonStatus, n as ensureDaemonRunning, o as startPortalDaemon, r as isDaemonListening, s as stopDaemon, t as PortalDaemon } from "./daemon-w8vtZ81t.mjs";
+import "./tls-cert-CV-pwxVN.mjs";
+import "./api-TwLD7ibI.mjs";
+
+export { runPortalDaemon };

package/dist/js/{daemon-BYlIJN6x.mjs → daemon-w8vtZ81t.mjs}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { s as isRecord, t as PortalClient } from "./client-Dd5sMXPv.mjs";
+import { n as isRecord, t as PortalClient } from "./client-BnpgrtCC.mjs";
+import { t as defaultTlsCertSource } from "./tls-cert-CV-pwxVN.mjs";
 import os from "node:os";
 import path from "node:path";
 import { z } from "zod";
@@ -20,7 +21,7 @@ import { access, appendFile, mkdir, readFile, unlink, writeFile } from "node:fs/
 * the commit time of the built tree is one monotonic clock they share.
 */
 function portalDaemonBuild() {
-	return "1786574791";
+	return "1786941153";
 }
 /**
 * Whether a client carrying `mine` should replace a running daemon carrying
@@ -175,10 +176,18 @@ const clientCwdSchema = z.object({
 	t: z.literal("cwd"),
 	cwd: z.string().min(1)
 });
-/** `grant` — authorize one agent to reach this machine (user-initiated). */
+/**
+* `grant` — authorize one agent to reach this machine (user-initiated).
+* `conversationId` names the conversation whose run asked for access (the
+* in-chat approval card); the grant carries it upstream so the server wakes
+* the waiting agent. Defaults to null on parse so hellos from CLI builds that
+* predate the field keep granting against a newer daemon — they just skip the
+* wake, same as before the field existed.
+*/
 const clientGrantSchema = z.object({
 	t: z.literal("grant"),
-	agentId: z.string().min(1)
+	agentId: z.string().min(1),
+	conversationId: z.string().nullish().default(null)
 });
 /**
 * `decline` — the user answered no to an agent's request for this machine
@@ -357,6 +366,7 @@ var PortalDaemon = class {
 	conns = /* @__PURE__ */ new Set();
 	cwds = /* @__PURE__ */ new Map();
 	declined = /* @__PURE__ */ new Set();
+	persistedMachineName = null;
 	fallbackCwd;
 	idleTimer = null;
 	sessionToken = null;
@@ -455,7 +465,7 @@ var PortalDaemon = class {
 			case "grant":
 				this.declined.delete(msg.agentId);
 				this.ensureClient();
-				this.client?.grantAgent(msg.agentId).catch((error) => {
+				this.client?.grantAgent(msg.agentId, msg.conversationId).catch((error) => {
 					this.logError("grantAgent failed", error);
 				});
 				return;
@@ -491,12 +501,29 @@ var PortalDaemon = class {
 				deviceToken: this.deviceToken
 			}),
 			resolveCwd: (conversationId) => this.resolveCwd(conversationId),
+			tlsCertSource: defaultTlsCertSource(process.env, (msg) => this.logInfo(msg)),
+			persistedMachineName: this.persistedMachineName,
+			onMachineName: (name, source) => this.onMachineName(name, source),
 			onState: (state) => {
 				this.lastState = state;
 				this.broadcastState();
 			}
 		});
 	}
+	/**
+	* The identity resolved on connect. Persist the name so a later scutil
+	* failure reuses it instead of adopting the volatile hostname, and log the
+	* source — a `hostname-fallback` after we'd previously registered under
+	* scutil is the tell that a flap just orphaned this machine's grants.
+	*/
+	onMachineName(name, source) {
+		if (source === "hostname-fallback" && this.persistedMachineName) this.logInfo(`portal identity WARNING: fell back to hostname "${name}" but had previously registered as "${this.persistedMachineName}" — grants may be orphaned`);
+		else this.logInfo(`portal identity: "${name}" (source=${source})`);
+		if (name && name !== this.persistedMachineName) {
+			this.persistedMachineName = name;
+			this.persistState();
+		}
+	}
 	/** The cwd an exec for `conversationId` runs in. */
 	resolveCwd(conversationId) {
 		if (conversationId) {
@@ -530,7 +557,14 @@ var PortalDaemon = class {
 	/** 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`;
+		this.logLine(`${context}: ${message}`);
+	}
+	/** Append an informational line to the daemon log file (best-effort). */
+	logInfo(message) {
+		this.logLine(message);
+	}
+	logLine(message) {
+		const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${message}\n`;
 		appendFile(this.paths.logPath, line).catch((_error) => {});
 	}
 	/** Close the listener without exiting the process (tests own the process). */
@@ -590,6 +624,7 @@ var PortalDaemon = class {
 				if (Array.isArray(parsed.declined)) {
 					for (const id of parsed.declined) if (typeof id === "string") this.declined.add(id);
 				}
+				if (typeof parsed.machineName === "string" && parsed.machineName) this.persistedMachineName = parsed.machineName;
 			}
 		} catch (_error) {}
 	}
@@ -597,7 +632,8 @@ var PortalDaemon = class {
 		const state = {
 			version: LOCAL_PROTOCOL_VERSION,
 			cwds: Object.fromEntries(this.cwds),
-			declined: [...this.declined]
+			declined: [...this.declined],
+			machineName: this.persistedMachineName ?? void 0
 		};
 		writeFile(this.paths.statePath, JSON.stringify(state)).catch((error) => {
 			this.logError("persistState failed", error);