skydive-cli 0.5.0-beta.1 → 0.5.0-beta.11

package/dist/js/{client-Dd5sMXPv.mjs → client-DabRpc_T.mjs}

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
-import { t as HttpError } from "./http-error-DzyrsLAZ.mjs";
+import { a as mintPortalDeviceToken, c as unifyLegacyCliGrants, i as grantPortalAccess, n as fetchPortalDevices, r as findThisDevice } from "./api-DG5W6iwx.mjs";
 import os from "node:os";
 import { z } from "zod";
 import { execFile, spawn } from "node:child_process";
-import { WebSocket } from "ws";
+import net from "node:net";
+import { WebSocket, createWebSocketStream } from "ws";
 
 //#region ../portal-daemon/src/machine.ts
 /**
@@ -134,6 +135,18 @@ const ctrlMessageSchema = z.discriminatedUnion("t", [
 		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") }),
@@ -169,6 +182,62 @@ function decodeFrame(frame) {
 	};
 }
 
+//#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;
+	conns = /* @__PURE__ */ new Set();
+	constructor(opts) {
+		this.opts = opts;
+	}
+	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.server = server;
+	}
+	stop() {
+		this.server?.close();
+		this.server = null;
+		for (const sock of this.conns) sock.destroy();
+		this.conns.clear();
+	}
+};
+
 //#endregion
 //#region ../portal-daemon/src/exec.ts
 /**
@@ -181,6 +250,7 @@ function decodeFrame(frame) {
 */
 var JobManager = class {
 	jobs = /* @__PURE__ */ new Map();
+	reverse = /* @__PURE__ */ new Map();
 	constructor(opts) {
 		this.opts = opts;
 	}
@@ -200,12 +270,35 @@ var JobManager = class {
 			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;
@@ -217,12 +310,51 @@ var JobManager = class {
 				return;
 			case "cancel":
 				this.jobs.get(id)?.child.kill("SIGKILL");
+				this.stopReverse(id);
 				return;
 			case "close":
-			case "error": return;
+			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,
+				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;
@@ -296,111 +428,6 @@ var JobManager = class {
 	}
 };
 
-//#endregion
-//#region ../portal-daemon/src/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 handle the machine registers under, not the display
-* label.
-*/
-function findThisDevice(devices, machineName) {
-	return devices.find((device) => device.machineName === machineName) ?? null;
-}
-/**
-* One-time grant migration onto the merged device. Earlier CLI builds
-* registered a separate `<machineName>-cli` device, so a user's existing
-* approvals hang off that row; the merged device would start with zero grants
-* and every already-authorized agent would ask again. Copy any grant the
-* merged device is missing (the grant endpoint upserts, so re-runs are
-* no-ops). The legacy row is left in place — an old CLI build may still
-* connect under it. Returns how many grants were copied.
-*/
-async function unifyLegacyCliGrants(auth, machineName) {
-	const { devices } = await fetchPortalDevices(auth);
-	const merged = findThisDevice(devices, machineName);
-	const legacy = findThisDevice(devices, `${machineName}-cli`);
-	if (!merged || !legacy) return 0;
-	const have = new Set(merged.grantedAgentIds);
-	const missing = legacy.grantedAgentIds.filter((id) => !have.has(id));
-	for (const agentId of missing) await grantPortalAccess(auth, {
-		deviceId: merged.id,
-		agentId
-	});
-	return missing.length;
-}
-
 //#endregion
 //#region ../portal-daemon/src/client.ts
 const INITIAL_BACKOFF_MS = 500;
@@ -469,13 +496,19 @@ var PortalClient = class {
 		this.ws?.close();
 		this.ws = null;
 	}
-	/** Grant one agent access to this machine (default-deny; user-initiated). */
-	async grantAgent(agentId) {
+	/**
+	* 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
+			agentId,
+			conversationId
 		});
 		this.granted.add(agentId);
 		this.emit();
@@ -617,4 +650,4 @@ function sleep(ms) {
 }
 
 //#endregion
-export { registerPortalDevice as a, resolveMachineIdentity as c, grantPortalAccess as i, fetchPortalDevices as n, revokePortalAccess as o, findThisDevice as r, isRecord as s, PortalClient as t };
+export { isRecord as n, resolveMachineIdentity as r, PortalClient as t };

package/dist/js/{daemon-XCciQ1mS.mjs → daemon-CJNMbWMJ.mjs}

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import "./client-Dd5sMXPv.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-C6yadKp2.mjs";
+import "./client-DabRpc_T.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-DfeT8rGL.mjs";
+import "./api-DG5W6iwx.mjs";
 
 export { runPortalDaemon };

package/dist/js/{daemon-C6yadKp2.mjs → daemon-DfeT8rGL.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { s as isRecord, t as PortalClient } from "./client-Dd5sMXPv.mjs";
+import { n as isRecord, t as PortalClient } from "./client-DabRpc_T.mjs";
 import os from "node:os";
 import path from "node:path";
 import { z } from "zod";
@@ -8,6 +8,43 @@ import { createHash } from "node:crypto";
 import { connect, createServer } from "node:net";
 import { access, appendFile, mkdir, readFile, unlink, writeFile } from "node:fs/promises";
 
+//#region ../portal-daemon/src/build-stamp.ts
+/**
+* This build's stamp: the unix commit time (seconds) of the source it was
+* compiled from. Empty string when unstamped (a dev source run without the
+* env override).
+*
+* Why a commit time and not a package version: the daemon ships inside two
+* independently-versioned installers (the skydive CLI and the desktop app),
+* so their semvers are not comparable — but both build from this repo, so
+* the commit time of the built tree is one monotonic clock they share.
+*/
+function portalDaemonBuild() {
+	return "1786600334";
+}
+/**
+* Whether a client carrying `mine` should replace a running daemon carrying
+* `theirs` (newest build wins):
+*
+*  - an unstamped client never takes over — it can't prove it's newer;
+*  - a stamped client replaces an unstamped daemon — every stamped build
+*    postdates stamping, so the unstamped daemon is older by construction;
+*  - otherwise strictly greater wins; equal keeps the incumbent, so two
+*    identical builds never bounce the daemon between them.
+*/
+function isNewerBuild(mine, theirs) {
+	const mineAt = parseStamp(mine);
+	if (mineAt === null) return false;
+	const theirsAt = parseStamp(theirs);
+	if (theirsAt === null) return true;
+	return mineAt > theirsAt;
+}
+function parseStamp(stamp) {
+	if (!/^[0-9]+$/.test(stamp)) return null;
+	return Number(stamp);
+}
+
+//#endregion
 //#region ../portal-daemon/src/local-protocol.ts
 /**
 * Local IPC between the portal DAEMON and the `skydive` CLI processes attached
@@ -138,10 +175,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
@@ -220,6 +265,7 @@ const daemonStatusResultSchema = z.object({
 	v: z.number(),
 	pid: z.number(),
 	appUrl: z.string(),
+	build: z.string().default(""),
 	portal: z.object({
 		status: z.enum([
 			"off",
@@ -241,6 +287,12 @@ const daemonMessageSchema = z.discriminatedUnion("t", [
 	daemonHelloOkSchema,
 	daemonStatusResultSchema
 ]);
+/**
+* Encoding is the pre-parse direction, so it takes the schemas' INPUT types:
+* fields with a `.default()` (e.g. `hello.tokenKind`) are required after a
+* parse but optional on the wire, and a sender omitting one — an older CLI
+* build that predates the field — must stay expressible.
+*/
 function encodeLine(msg) {
 	return `${JSON.stringify(msg)}\n`;
 }
@@ -411,7 +463,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;
@@ -510,6 +562,7 @@ var PortalDaemon = class {
 			v: LOCAL_PROTOCOL_VERSION,
 			pid: process.pid,
 			appUrl: this.appUrl,
+			build: portalDaemonBuild(),
 			portal: {
 				status: portal?.status ?? "off",
 				machineName: portal?.machineName ?? "",
@@ -567,10 +620,23 @@ var PortalDaemon = class {
 * 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).
+*
+* Newest build wins: the daemon is embedded in two independently-updated
+* installers (the skydive CLI and the desktop app), and whoever spawned first
+* would otherwise hold the socket forever — a stale desktop daemon serving a
+* newer CLI indefinitely. So when a daemon is already listening, compare its
+* build stamp to ours: if ours is strictly newer, ask it to shut down (it
+* drains attached clients, who reconnect within ~500ms) and spawn from this
+* binary. Both spawners apply the same rule, so a host converges on the
+* newest installed build with at most one bounce.
 */
 async function ensureDaemonRunning(appUrl) {
 	const { socketPath } = daemonPaths(appUrl);
-	if (await isDaemonListening(socketPath)) return;
+	if (await isDaemonListening(socketPath)) {
+		const status = await queryDaemonStatus(appUrl);
+		if (!status || !isNewerBuild(portalDaemonBuild(), status.build)) return;
+		if (await stopDaemon(appUrl) === "failed") return;
+	}
 	const entry = process.argv[1];
 	const args = entry ? [
 		entry,

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

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import "./client-DabRpc_T.mjs";
+import "./daemon-DfeT8rGL.mjs";
+import "./api-DG5W6iwx.mjs";
+import { t as PortalDaemonClient } from "./daemon-client-eBSEPljJ.mjs";
+
+export { PortalDaemonClient };

package/dist/js/{daemon-client-Rr6PJvRg.mjs → daemon-client-eBSEPljJ.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-C6yadKp2.mjs";
+import { c as LOCAL_PROTOCOL_VERSION, d as encodeLine, f as makeLineParser, n as ensureDaemonRunning, p as parseDaemonMessage, u as daemonPaths } from "./daemon-DfeT8rGL.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/forward-18QoL5dO.mjs

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+import { t as fetchForwardTarget } from "./api-DG5W6iwx.mjs";
+import net from "node:net";
+import { WebSocket, createWebSocketStream } from "ws";
+
+//#region src/chat/portal/forward.ts
+const TARGET_REFRESH_SAFETY_MS = 12e4;
+/**
+* The reverse portal's client half: listen on the local machine's loopback and
+* pipe each TCP connection to the agent sandbox's daemon (`/portal/tcp`),
+* which pipes to the sandbox's own loopback. The daemon is reached through the
+* agent-webserver edge Worker (sandboxes have public ingress disabled; the
+* Worker owns boot-resolution and injects the sandbox edge-auth token), so a
+* sandbox recycle just costs the next connection a cold-start wait rather
+* than invalidating the forward.
+*/
+async function startForward({ auth, agentId, localPort, targetPort, log }) {
+	let target = await fetchForwardTarget(auth, agentId);
+	let mintedAt = Date.now();
+	async function freshTarget() {
+		const ttlMs = target.expiresInSeconds * 1e3;
+		if (Date.now() - mintedAt > ttlMs - TARGET_REFRESH_SAFETY_MS) {
+			target = await fetchForwardTarget(auth, agentId);
+			mintedAt = Date.now();
+		}
+		return target;
+	}
+	const server = net.createServer((sock) => {
+		sock.pause();
+		(async () => {
+			let resolved;
+			try {
+				resolved = await freshTarget();
+			} catch (err) {
+				log(`forward: token refresh failed: ${err instanceof Error ? err.message : String(err)}`);
+				sock.destroy();
+				return;
+			}
+			const ws = new WebSocket(`${resolved.daemonOrigin.replace(/^http/, "ws")}/portal/tcp?port=${targetPort}`, { headers: { authorization: `Bearer ${resolved.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) => {
+				log(`forward: tunnel connect failed: ${err.message}`);
+				sock.destroy();
+			});
+		})();
+	});
+	await new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(localPort, "127.0.0.1", () => {
+			server.removeListener("error", reject);
+			resolve();
+		});
+	});
+	const addr = server.address();
+	return {
+		port: addr && typeof addr === "object" ? addr.port : localPort,
+		close: () => new Promise((resolve) => server.close(() => resolve()))
+	};
+}
+
+//#endregion
+export { startForward };

package/dist/js/{print-ba_0hiV9.mjs → print-Bo06tvfV.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { a as runPrint, i as resolveAgent, n as messageGet, o as toPrintError, r as readStdin, t as collectRunText } from "./print-CbayCa87.mjs";
-import "./rest-BY2nADw5.mjs";
+import { a as runPrint, i as resolveAgent, n as messageGet, o as toPrintError, r as readStdin, t as collectRunText } from "./print-ClPkgR9z.mjs";
+import "./rest-I3imNduB.mjs";
 import "./billing-blocked-2wju4gC_.mjs";
 
 export { messageGet, readStdin, resolveAgent, runPrint };