skydive-cli 0.5.0-beta.32 → 0.5.0-beta.36

package/dist/js/{client-BTQ1fwzM.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/{daemon-CxFxH36O.mjs → daemon-CH95gDij.mjs}

@@ -21,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 "1786765910";
+	return "1786860400";
 }
 /**
 * Whether a client carrying `mine` should replace a running daemon carrying

package/dist/js/{daemon-Btd2436i.mjs → daemon-Dg89tpOE.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import "./client-d6K9qm6B.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-CxFxH36O.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-CH95gDij.mjs";
 import "./tls-cert-CV-pwxVN.mjs";
 import "./api-DQCaztBg.mjs";
 

package/dist/js/{daemon-client-Br1NlkRp.mjs → daemon-client-BNDnEGw6.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-CxFxH36O.mjs";
+import { c as LOCAL_PROTOCOL_VERSION, d as encodeLine, f as makeLineParser, n as ensureDaemonRunning, p as parseDaemonMessage, u as daemonPaths } from "./daemon-CH95gDij.mjs";
 import { randomUUID } from "node:crypto";
 import { connect } from "node:net";
 

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

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

package/dist/js/{profiler-CJMnC90G.mjs → install-aZ751iYf.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as getConfigPath } from "./print-Clgq46GU.mjs";
+import { C as getConfigPath } from "./print-h22UbIfZ.mjs";
 import os from "node:os";
 import path from "node:path";
 import { err, ok } from "neverthrow";
@@ -8,7 +8,7 @@ import fs from "node:fs";
 
 //#region package.json
 var name = "skydive-cli";
-var version$1 = "0.5.0-beta.32";
+var version$1 = "0.5.0-beta.36";
 
 //#endregion
 //#region src/auth/organization.ts
@@ -1050,6 +1050,277 @@ function applyTheme(def) {
 	version++;
 }
 
+//#endregion
+//#region src/profiling/profiler.ts
+/**
+* Session diagnostics. Every invocation records enough context to reconstruct
+* what happened after the fact. SKYDIVE_PROFILE can select a custom directory
+* or disable recording with `0`.
+*
+* Default sessions live under the CLI's system state directory. Explicit
+* profiles keep the original cwd/custom-path behavior and add a CPU profile.
+* Each directory is designed to be handed to an agent (or a human) and read
+* without special tooling:
+*
+*   network.ndjson   every fetch: method, url, status, timing, content type
+*   state.ndjson     TUI state transitions (screen changes, store updates)
+*   commits.ndjson   React commits: which subtree rendered, when, how long
+*   render.ndjson    OpenTUI renderer samples: fps, frame times, cells drawn
+*   render.json      final renderer stats dump (full frame-time series)
+*   cpu-<pid>.cpuprofile  V8 CPU profile (Node-run commands only)
+*   meta-<pid>.json  argv, versions, runtime, exit code, wall time
+*
+* Every ndjson event carries a wall-clock `t` (epoch ms) and `pid`, so
+* records from the Node parent and the Bun-re-exec'd chat TUI land in the
+* same files and stay correlatable on one clock. The profile directory is
+* created by the first process and shared with children through
+* SKYDIVE_PROFILE_DIR (the chat re-exec inherits the environment).
+*
+*/
+const ENV_FLAG = "SKYDIVE_PROFILE";
+const ENV_DIR = "SKYDIVE_PROFILE_DIR";
+const DEFAULT_SESSION_LIMIT = 20;
+let activeDir = null;
+let startedAtMs = 0;
+/**
+* Buffered event lines per stream, flushed asynchronously. Events are
+* appended to an in-memory buffer and written with fs.promises off the
+* hot path, so recording never blocks the TUI's event loop — high-rate
+* streams (React commits, renderer samples) stay cheap. Whatever is
+* still buffered when the process exits is drained synchronously in the
+* exit handler, where async I/O would never flush.
+*/
+const pendingLines = /* @__PURE__ */ new Map();
+let flushScheduled = false;
+let flushing = Promise.resolve();
+function drainBuffersSync() {
+	if (activeDir === null) return;
+	for (const [stream, lines] of pendingLines) {
+		if (lines.length === 0) continue;
+		pendingLines.set(stream, []);
+		try {
+			fs.appendFileSync(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
+		} catch (_error) {}
+	}
+}
+function scheduleFlush() {
+	if (flushScheduled || activeDir === null) return;
+	flushScheduled = true;
+	setTimeout(() => {
+		flushScheduled = false;
+		flushing = flushing.then(async () => {
+			if (activeDir === null) return;
+			for (const [stream, lines] of pendingLines) {
+				if (lines.length === 0) continue;
+				pendingLines.set(stream, []);
+				try {
+					await fs.promises.appendFile(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
+				} catch (_error) {}
+			}
+		});
+	}, 100).unref?.();
+}
+function profilingEnabled() {
+	return process.env[ENV_FLAG] !== "0";
+}
+function explicitProfilingEnabled() {
+	const value = process.env[ENV_FLAG];
+	return value !== void 0 && value !== "" && value !== "0";
+}
+function profileDir() {
+	return activeDir;
+}
+function automaticLogsDir(platform, env, home) {
+	const appName = env["SKYDIVE_CONFIG_NAME"] ?? "skydive";
+	if (platform === "darwin") return path.join(home, "Library", "Logs", appName);
+	if (platform === "linux") {
+		const stateHome = env["XDG_STATE_HOME"] || path.join(home, ".local", "state");
+		return path.join(stateHome, appName);
+	}
+	return path.join(path.dirname(getConfigPath()), "logs");
+}
+function getAutomaticLogsDir() {
+	return automaticLogsDir(process.platform, process.env, os.homedir());
+}
+function sanitizeToken(token) {
+	return token.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
+}
+function commandName(argv) {
+	return argv.find((arg) => !arg.startsWith("-")) ?? "chat";
+}
+function sessionName(argv) {
+	const command = commandName(argv);
+	return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19)}-${sanitizeToken(command)}-${process.pid}`;
+}
+/**
+* Automatic logs retain command shape, not values. Positional arguments and
+* flag values can contain prompts, secrets, paths, and other private data.
+*/
+function safeAutomaticArgv(argv) {
+	return [commandName(argv), ...argv.filter((arg) => arg.startsWith("-")).map((arg) => arg.split("=", 1)[0] ?? arg)];
+}
+/** Keeps automatic diagnostics bounded without touching explicit profiles. */
+function pruneAutomaticSessions(root, activeSession) {
+	try {
+		const sessions = fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== activeSession).map((entry) => entry.name).sort().reverse();
+		for (const stale of sessions.slice(DEFAULT_SESSION_LIMIT - 1)) fs.rmSync(path.join(root, stale), {
+			recursive: true,
+			force: true
+		});
+	} catch (_error) {}
+}
+/**
+* Appends one event to a stream file. Buffered and written asynchronously
+* so recording never blocks the event loop; the exit handler drains any
+* remainder synchronously so abrupt exits still keep their events.
+*/
+function record(stream, event) {
+	if (activeDir === null) return;
+	const line = JSON.stringify({
+		t: Date.now(),
+		pid: process.pid,
+		...event
+	});
+	const lines = pendingLines.get(stream);
+	if (lines === void 0) pendingLines.set(stream, [line]);
+	else lines.push(line);
+	scheduleFlush();
+}
+/** Writes a JSON artifact (non-append) into the profile directory. */
+function writeArtifact(name, data) {
+	if (activeDir === null) return;
+	try {
+		fs.writeFileSync(path.join(activeDir, name), JSON.stringify(data, null, 2));
+	} catch (_error) {}
+}
+function safeAutomaticUrl(value) {
+	try {
+		const url = new URL(value);
+		for (const key of url.searchParams.keys()) url.searchParams.set(key, "<redacted>");
+		url.hash = "";
+		return url.href;
+	} catch (_error) {
+		return "<invalid-url>";
+	}
+}
+/**
+* Patches globalThis.fetch to record request timing. A wrapper (not
+* undici's diagnostics_channel) because chat re-execs under Bun, where
+* fetch is Bun-native and undici events never fire; the wrapper behaves
+* identically in both runtimes.
+*/
+function installFetchRecorder(explicit) {
+	const original = globalThis.fetch;
+	const wrapped = async (...args) => {
+		const [input, init] = args;
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+		const started = Date.now();
+		try {
+			const res = await original(...args);
+			const contentType = res.headers.get("content-type") ?? "";
+			record("network", {
+				method,
+				url: explicit ? url : safeAutomaticUrl(url),
+				status: res.status,
+				durationMs: Date.now() - started,
+				contentType,
+				streamed: contentType.includes("text/event-stream")
+			});
+			return res;
+		} catch (err) {
+			record("network", {
+				method,
+				url: explicit ? url : safeAutomaticUrl(url),
+				status: 0,
+				durationMs: Date.now() - started,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		}
+	};
+	globalThis.fetch = Object.assign(wrapped, original);
+}
+function isBunRuntime() {
+	return typeof process !== "undefined" && "bun" in process.versions;
+}
+/**
+* Starts the V8 CPU profiler via node:inspector. Node-run commands only —
+* Bun does not implement the inspector Profiler domain, so the chat TUI
+* skips this artifact.
+*/
+function startCpuProfile() {
+	if (isBunRuntime()) return;
+	(async () => {
+		try {
+			const { Session } = await import("node:inspector/promises");
+			const session = new Session();
+			session.connect();
+			await session.post("Profiler.enable");
+			await session.post("Profiler.start");
+			process.once("beforeExit", () => {
+				(async () => {
+					try {
+						const { profile } = await session.post("Profiler.stop");
+						writeArtifact(`cpu-${process.pid}.cpuprofile`, profile);
+						session.disconnect();
+					} catch (_error) {}
+				})();
+			});
+		} catch (_error) {}
+	})();
+}
+/**
+* Starts diagnostics unless SKYDIVE_PROFILE=0. Creates a system-state session
+* directory (or joins the one a parent process created), patches fetch, and
+* registers the exit-time metadata dump. Explicit profiles also capture CPU.
+*/
+function maybeStartProfiling(argv, cliVersion) {
+	if (!profilingEnabled() || activeDir !== null) return;
+	const inherited = process.env[ENV_DIR];
+	const explicit = explicitProfilingEnabled();
+	let automaticRoot = null;
+	let automaticSession = null;
+	if (inherited !== void 0 && inherited !== "") activeDir = inherited;
+	else if (explicit) {
+		const flagValue = process.env[ENV_FLAG] ?? "1";
+		activeDir = flagValue === "1" || flagValue.toLowerCase() === "true" ? path.resolve(process.cwd(), `skydive-profile-${sessionName(argv)}`) : path.resolve(process.cwd(), flagValue);
+		process.env[ENV_DIR] = activeDir;
+	} else {
+		automaticRoot = getAutomaticLogsDir();
+		automaticSession = sessionName(argv);
+		activeDir = path.join(automaticRoot, automaticSession);
+		process.env[ENV_DIR] = activeDir;
+	}
+	try {
+		fs.mkdirSync(activeDir, {
+			recursive: true,
+			mode: 448
+		});
+		if (automaticRoot !== null && automaticSession !== null) pruneAutomaticSessions(automaticRoot, automaticSession);
+	} catch (_error) {
+		activeDir = null;
+		return;
+	}
+	startedAtMs = Date.now();
+	installFetchRecorder(explicit);
+	if (explicit) startCpuProfile();
+	process.on("exit", (code) => {
+		drainBuffersSync();
+		writeArtifact(`meta-${process.pid}.json`, {
+			argv: explicit ? argv : safeAutomaticArgv(argv),
+			cliVersion,
+			runtime: isBunRuntime() ? `bun ${process.versions["bun"]}` : `node ${process.version}`,
+			platform: process.platform,
+			pid: process.pid,
+			exitCode: code,
+			startedAt: new Date(startedAtMs).toISOString(),
+			wallTimeMs: Date.now() - startedAtMs
+		});
+		if (explicit && process.env[ENV_DIR] === activeDir && inherited === void 0) process.stderr.write(`\nprofile written to ${activeDir}\n`);
+	});
+}
+
 //#endregion
 //#region src/brand.ts
 const MARK_CELLS = [
@@ -1311,211 +1582,4 @@ function printFatalNotice(file, memory) {
 }
 
 //#endregion
-//#region src/profiling/profiler.ts
-/**
-* Opt-in session profiling. When SKYDIVE_PROFILE is set, an invocation
-* records everything needed to reconstruct what happened performance-wise —
-* designed so the whole directory can be handed to an agent (or a human)
-* and read without special tooling:
-*
-*   network.ndjson   every fetch: method, url, status, timing, content type
-*   state.ndjson     TUI state transitions (screen changes, store updates)
-*   commits.ndjson   React commits: which subtree rendered, when, how long
-*   render.ndjson    OpenTUI renderer samples: fps, frame times, cells drawn
-*   render.json      final renderer stats dump (full frame-time series)
-*   cpu-<pid>.cpuprofile  V8 CPU profile (Node-run commands only)
-*   meta-<pid>.json  argv, versions, runtime, exit code, wall time
-*
-* Every ndjson event carries a wall-clock `t` (epoch ms) and `pid`, so
-* records from the Node parent and the Bun-re-exec'd chat TUI land in the
-* same files and stay correlatable on one clock. The profile directory is
-* created by the first process and shared with children through
-* SKYDIVE_PROFILE_DIR (the chat re-exec inherits the environment).
-*
-* Inert unless SKYDIVE_PROFILE is set: no patched fetch, no subscriptions,
-* no inspector session.
-*/
-const ENV_FLAG = "SKYDIVE_PROFILE";
-const ENV_DIR = "SKYDIVE_PROFILE_DIR";
-let activeDir = null;
-let startedAtMs = 0;
-/**
-* Buffered event lines per stream, flushed asynchronously. Events are
-* appended to an in-memory buffer and written with fs.promises off the
-* hot path, so recording never blocks the TUI's event loop — high-rate
-* streams (React commits, renderer samples) stay cheap. Whatever is
-* still buffered when the process exits is drained synchronously in the
-* exit handler, where async I/O would never flush.
-*/
-const pendingLines = /* @__PURE__ */ new Map();
-let flushScheduled = false;
-let flushing = Promise.resolve();
-function drainBuffersSync() {
-	if (activeDir === null) return;
-	for (const [stream, lines] of pendingLines) {
-		if (lines.length === 0) continue;
-		pendingLines.set(stream, []);
-		try {
-			fs.appendFileSync(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
-		} catch (_error) {}
-	}
-}
-function scheduleFlush() {
-	if (flushScheduled || activeDir === null) return;
-	flushScheduled = true;
-	setTimeout(() => {
-		flushScheduled = false;
-		flushing = flushing.then(async () => {
-			if (activeDir === null) return;
-			for (const [stream, lines] of pendingLines) {
-				if (lines.length === 0) continue;
-				pendingLines.set(stream, []);
-				try {
-					await fs.promises.appendFile(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
-				} catch (_error) {}
-			}
-		});
-	}, 100).unref?.();
-}
-function profilingEnabled() {
-	const v = process.env[ENV_FLAG];
-	return v !== void 0 && v !== "" && v !== "0";
-}
-function sanitizeToken(token) {
-	return token.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-}
-/**
-* Appends one event to a stream file. Buffered and written asynchronously
-* so recording never blocks the event loop; the exit handler drains any
-* remainder synchronously so abrupt exits still keep their events.
-*/
-function record(stream, event) {
-	if (activeDir === null) return;
-	const line = JSON.stringify({
-		t: Date.now(),
-		pid: process.pid,
-		...event
-	});
-	const lines = pendingLines.get(stream);
-	if (lines === void 0) pendingLines.set(stream, [line]);
-	else lines.push(line);
-	scheduleFlush();
-}
-/** Writes a JSON artifact (non-append) into the profile directory. */
-function writeArtifact(name, data) {
-	if (activeDir === null) return;
-	try {
-		fs.writeFileSync(path.join(activeDir, name), JSON.stringify(data, null, 2));
-	} catch (_error) {}
-}
-/**
-* Patches globalThis.fetch to record request timing. A wrapper (not
-* undici's diagnostics_channel) because chat re-execs under Bun, where
-* fetch is Bun-native and undici events never fire; the wrapper behaves
-* identically in both runtimes.
-*/
-function installFetchRecorder() {
-	const original = globalThis.fetch;
-	const wrapped = async (...args) => {
-		const [input, init] = args;
-		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-		const method = init?.method ?? (input instanceof Request ? input.method : "GET");
-		const started = Date.now();
-		try {
-			const res = await original(...args);
-			const contentType = res.headers.get("content-type") ?? "";
-			record("network", {
-				method,
-				url,
-				status: res.status,
-				durationMs: Date.now() - started,
-				contentType,
-				streamed: contentType.includes("text/event-stream")
-			});
-			return res;
-		} catch (err) {
-			record("network", {
-				method,
-				url,
-				status: 0,
-				durationMs: Date.now() - started,
-				error: err instanceof Error ? err.message : String(err)
-			});
-			throw err;
-		}
-	};
-	globalThis.fetch = Object.assign(wrapped, original);
-}
-function isBunRuntime() {
-	return typeof process !== "undefined" && "bun" in process.versions;
-}
-/**
-* Starts the V8 CPU profiler via node:inspector. Node-run commands only —
-* Bun does not implement the inspector Profiler domain, so the chat TUI
-* skips this artifact.
-*/
-function startCpuProfile() {
-	if (isBunRuntime()) return;
-	(async () => {
-		try {
-			const { Session } = await import("node:inspector/promises");
-			const session = new Session();
-			session.connect();
-			await session.post("Profiler.enable");
-			await session.post("Profiler.start");
-			process.once("beforeExit", () => {
-				(async () => {
-					try {
-						const { profile } = await session.post("Profiler.stop");
-						writeArtifact(`cpu-${process.pid}.cpuprofile`, profile);
-						session.disconnect();
-					} catch (_error) {}
-				})();
-			});
-		} catch (_error) {}
-	})();
-}
-/**
-* Activates profiling for this process if SKYDIVE_PROFILE is set. Creates
-* the profile directory (or joins the one a parent process created),
-* patches fetch, starts the CPU profiler, and registers the exit-time
-* meta dump. Call once, as early as possible.
-*/
-function maybeStartProfiling(argv, cliVersion) {
-	if (!profilingEnabled() || activeDir !== null) return;
-	const inherited = process.env[ENV_DIR];
-	if (inherited !== void 0 && inherited !== "") activeDir = inherited;
-	else {
-		const flagValue = process.env[ENV_FLAG] ?? "1";
-		const command = argv.find((a) => !a.startsWith("-")) ?? "chat";
-		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-		activeDir = flagValue === "1" || flagValue.toLowerCase() === "true" ? path.resolve(process.cwd(), `skydive-profile-${sanitizeToken(command)}-${stamp}`) : path.resolve(process.cwd(), flagValue);
-		process.env[ENV_DIR] = activeDir;
-	}
-	try {
-		fs.mkdirSync(activeDir, { recursive: true });
-	} catch (_error) {
-		activeDir = null;
-		return;
-	}
-	startedAtMs = Date.now();
-	installFetchRecorder();
-	startCpuProfile();
-	process.on("exit", (code) => {
-		drainBuffersSync();
-		writeArtifact(`meta-${process.pid}.json`, {
-			argv,
-			cliVersion,
-			runtime: isBunRuntime() ? `bun ${process.versions["bun"]}` : `node ${process.version}`,
-			platform: process.platform,
-			pid: process.pid,
-			exitCode: code,
-			startedAt: new Date(startedAtMs).toISOString(),
-			wallTimeMs: Date.now() - startedAtMs
-		});
-		if (process.env[ENV_DIR] === activeDir && inherited === void 0) process.stderr.write(`\nprofile written to ${activeDir}\n`);
-	});
-}
-
-//#endregion
-export { takenAliasNames as A, name as B, themesForMode as C, dedupeAliasName as D, aliasActivationHint as E, getActiveWorkspaceId as F, getSessionIdentity as I, listWorkspaces as L, defaultInstallEnv as M, detectShell as N, installAgentAlias as O, ensureActiveOrganization as P, resolveWorkspaceId as R, themes as S, machineOsFromPlatform as T, version$1 as V, theme as _, installCrashHandler as a, themeModeFromColorFgBg as b, MARK_CELLS as c, splashFitsWidth as d, DEFAULT_THEME_ID as f, noColorRequested as g, monoTheme as h, writeArtifact as i, SUPPORTED_SHELLS as j, slugifyAliasName as k, WORDMARK as l, findTheme as m, profilingEnabled as n, buildCrashReport as o, applyTheme as p, record as r, writeCrashReport as s, maybeStartProfiling as t, brandHelpArt as u, themeForMode as v, buildImportSeedPrompt as w, themeVersion as x, themeMode as y, setActiveWorkspace as z };
+export { installAgentAlias as A, resolveWorkspaceId as B, themeVersion as C, machineOsFromPlatform as D, buildImportSeedPrompt as E, detectShell as F, name as H, ensureActiveOrganization as I, getActiveWorkspaceId as L, takenAliasNames as M, SUPPORTED_SHELLS as N, aliasActivationHint as O, defaultInstallEnv as P, getSessionIdentity as R, themeModeFromColorFgBg as S, themesForMode as T, version$1 as U, setActiveWorkspace as V, monoTheme as _, WORDMARK as a, themeForMode as b, getAutomaticLogsDir as c, profilingEnabled as d, record as f, findTheme as g, applyTheme as h, MARK_CELLS as i, slugifyAliasName as j, dedupeAliasName as k, maybeStartProfiling as l, DEFAULT_THEME_ID as m, buildCrashReport as n, brandHelpArt as o, writeArtifact as p, writeCrashReport as r, splashFitsWidth as s, installCrashHandler as t, profileDir as u, noColorRequested as v, themes as w, themeMode as x, theme as y, listWorkspaces as z };