claude-code-best 1.10.4 → 1.10.5

package/dist/chunks/udsMessaging-CqD2Z113.js

@@ -0,0 +1,598 @@
+import { n as __esmMin, r as __exportAll } from "./chunk-CyLJMB0t.js";
+import { n as getClaudeConfigHomeDir, s as init_envUtils } from "./envUtils-DVwWVCmJ.js";
+import { E as jsonStringify, J as init_cleanupRegistry, L as errorMessage, T as jsonParse, V as init_errors, Y as registerCleanup, d as logForDebugging, s as init_debug, w as init_slowOperations } from "./debug-CWVskDes.js";
+import { o as init_log, s as logError } from "./log-BtGcZqeW.js";
+import { n as init_ndjsonFramer, t as attachNdjsonFramer } from "./ndjsonFramer-CKtNKe0_.js";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { createHash, randomBytes, timingSafeEqual } from "crypto";
+import { chmod, lstat, mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { createServer } from "net";
+import { StringDecoder } from "node:string_decoder";
+//#region src/utils/udsResponseReader.ts
+function getChunkBytes(chunk) {
+	return typeof chunk === "string" ? Buffer.byteLength(chunk, "utf8") : chunk.byteLength;
+}
+function parseResponseLine(line) {
+	try {
+		return jsonParse(line);
+	} catch {
+		throw new Error("Invalid UDS response frame");
+	}
+}
+function attachUdsResponseReader(socket, options) {
+	let buffer = "";
+	let bufferBytes = 0;
+	let settled = false;
+	const decoder = new StringDecoder("utf8");
+	function cleanupListeners() {
+		socket.off("data", onData);
+		socket.off("error", onError);
+		socket.off("end", onEnd);
+		socket.off("close", onClose);
+	}
+	function finish(error) {
+		if (settled) return;
+		settled = true;
+		buffer = "";
+		bufferBytes = 0;
+		cleanupListeners();
+		if (error) socket.destroy();
+		else socket.end();
+		options.onSettled(error);
+	}
+	function onData(chunk) {
+		const decoded = decoder.write(chunk);
+		const decodedBytes = Buffer.byteLength(decoded, "utf8");
+		if (bufferBytes + decodedBytes > options.maxFrameBytes) {
+			finish(/* @__PURE__ */ new Error("UDS response frame exceeded size limit"));
+			return;
+		}
+		buffer += decoded;
+		bufferBytes += decodedBytes;
+		let newlineIndex = buffer.indexOf("\n");
+		while (newlineIndex !== -1) {
+			const line = buffer.slice(0, newlineIndex);
+			const consumed = buffer.slice(0, newlineIndex + 1);
+			buffer = buffer.slice(newlineIndex + 1);
+			bufferBytes -= Buffer.byteLength(consumed, "utf8");
+			if (!line.trim()) {
+				newlineIndex = buffer.indexOf("\n");
+				continue;
+			}
+			let response;
+			try {
+				response = parseResponseLine(line);
+			} catch (error) {
+				finish(error instanceof Error ? error : new Error(errorMessage(error)));
+				return;
+			}
+			if (response.type === "response" || options.acceptPong === true && response.type === "pong") {
+				finish();
+				return;
+			}
+			if (response.type === "error") {
+				finish(new Error(response.data ?? "UDS receiver rejected message"));
+				return;
+			}
+			newlineIndex = buffer.indexOf("\n");
+		}
+	}
+	function onError(error) {
+		finish(options.formatSocketError?.(error) ?? (error instanceof Error ? error : new Error(errorMessage(error))));
+	}
+	function onEnd() {
+		finish(/* @__PURE__ */ new Error("UDS socket ended before response"));
+	}
+	function onClose(hadError) {
+		if (hadError) return;
+		finish(/* @__PURE__ */ new Error("UDS socket closed before response"));
+	}
+	socket.on("data", onData);
+	socket.on("error", onError);
+	socket.on("end", onEnd);
+	socket.on("close", onClose);
+}
+var init_udsResponseReader = __esmMin((() => {
+	init_errors();
+	init_slowOperations();
+}));
+//#endregion
+//#region src/utils/udsMessaging.ts
+/**
+* UDS Messaging Layer — Unix Domain Socket IPC for Claude Code instances.
+*
+* Each session auto-creates a UDS server so peer sessions can send messages.
+* Protocol: newline-delimited JSON (NDJSON), one message per line.
+*
+* Socket path defaults to a tmpdir-based path derived from the session PID,
+* but can be overridden via --messaging-socket-path.
+*/
+var udsMessaging_exports = /* @__PURE__ */ __exportAll({
+	MAX_UDS_CLIENTS: () => 128,
+	MAX_UDS_FRAME_BYTES: () => MAX_UDS_FRAME_BYTES,
+	MAX_UDS_INBOX_BYTES: () => MAX_UDS_INBOX_BYTES,
+	MAX_UDS_INBOX_ENTRIES: () => MAX_UDS_INBOX_ENTRIES,
+	UDS_AUTH_TIMEOUT_MS: () => UDS_AUTH_TIMEOUT_MS,
+	UDS_IDLE_TIMEOUT_MS: () => UDS_IDLE_TIMEOUT_MS,
+	drainInbox: () => drainInbox,
+	formatUdsAddress: () => formatUdsAddress,
+	getDefaultUdsSocketPath: () => getDefaultUdsSocketPath,
+	getUdsMessagingSocketPath: () => getUdsMessagingSocketPath,
+	parseUdsTarget: () => parseUdsTarget,
+	readUdsCapabilityToken: () => readUdsCapabilityToken,
+	sendUdsMessage: () => sendUdsMessage,
+	setOnEnqueue: () => setOnEnqueue,
+	startUdsMessaging: () => startUdsMessaging,
+	stopUdsMessaging: () => stopUdsMessaging
+});
+/**
+* Default socket path based on PID, placed in a tmpdir subdirectory so it
+* survives across config-home changes and avoids polluting ~/.claude.
+*
+* On Windows, Node.js requires named pipe paths in the `\\.\pipe\` namespace;
+* file-system paths like `C:\...\Temp\x.sock` cause EACCES. Bun handles both
+* transparently, but we use the pipe format on Windows for Node.js compat.
+*/
+function getDefaultUdsSocketPath() {
+	if (defaultSocketPath) return defaultSocketPath;
+	const nonce = randomBytes(16).toString("hex");
+	if (process.platform === "win32") {
+		defaultSocketPath = `\\\\.\\pipe\\claude-code-${process.pid}-${nonce}`;
+		return defaultSocketPath;
+	}
+	defaultSocketPath = join(tmpdir(), "claude-code-socks", `${process.pid}-${nonce}`, "messaging.sock");
+	return defaultSocketPath;
+}
+/**
+* Returns the socket path of the currently running server, or undefined
+* if the server has not been started.
+*/
+function getUdsMessagingSocketPath() {
+	return socketPath ?? void 0;
+}
+function formatUdsAddress(socket) {
+	return `uds:${socket}`;
+}
+function parseUdsTarget(target) {
+	if (target.includes("#token=")) throw new Error("UDS target must not include an inline auth token; use the ListPeers address");
+	return { socketPath: target };
+}
+function getCapabilityDir() {
+	return join(getClaudeConfigHomeDir(), "messaging-capabilities");
+}
+function getCapabilityPath(socket) {
+	const digest = createHash("sha256").update(socket).digest("hex");
+	return join(getCapabilityDir(), `${digest}.json`);
+}
+function isNotFound(error) {
+	return typeof error === "object" && error !== null && error.code === "ENOENT";
+}
+async function assertPrivateCapabilityDir(dir) {
+	let stat;
+	try {
+		stat = await lstat(dir);
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+		await mkdir(dir, {
+			recursive: true,
+			mode: 448
+		});
+		stat = await lstat(dir);
+	}
+	assertPrivateDirectory(stat, dir, "capability directory");
+	await chmod(dir, 448);
+}
+function assertPrivateDirectory(stat, dir, label) {
+	if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`[udsMessaging] ${label} is not a private directory: ${dir}`);
+	if (process.platform !== "win32") {
+		if ((Number(stat.mode) & 63) !== 0) throw new Error(`[udsMessaging] ${label} permissions are too broad: ${dir}`);
+		if (typeof process.getuid === "function" && Number(stat.uid) !== process.getuid()) throw new Error(`[udsMessaging] ${label} owner does not match current user: ${dir}`);
+	}
+}
+async function writePrivateFileExclusive(path, content) {
+	const handle = await open(path, "wx", 384);
+	try {
+		await handle.writeFile(content, "utf-8");
+	} finally {
+		await handle.close();
+	}
+	await chmod(path, 384);
+}
+async function ensureSocketParent(path) {
+	const dir = dirname(path);
+	try {
+		const stat = await lstat(dir);
+		if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`[udsMessaging] socket parent is not a directory: ${dir}`);
+		assertPrivateDirectory(stat, dir, "socket parent");
+		return;
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+	await mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	await chmod(dir, 448);
+}
+async function writeCapabilityFile(socket, token) {
+	await assertPrivateCapabilityDir(getCapabilityDir());
+	const target = getCapabilityPath(socket);
+	const temp = `${target}.${process.pid}.${randomBytes(8).toString("hex")}.tmp`;
+	try {
+		await writePrivateFileExclusive(temp, jsonStringify({
+			socketPath: socket,
+			authToken: token
+		}));
+		await rename(temp, target);
+	} catch (error) {
+		try {
+			await unlink(temp);
+		} catch {}
+		throw error;
+	}
+	capabilityFilePath = target;
+}
+async function readUdsCapabilityToken(socket) {
+	try {
+		const parsed = jsonParse(await readFile(getCapabilityPath(socket), "utf-8"));
+		if (parsed.socketPath === socket && typeof parsed.authToken === "string") return parsed.authToken;
+	} catch {}
+}
+/**
+* Register a callback invoked whenever a message is enqueued into the inbox.
+* Used by the print/SDK query loop to kick off processing.
+*/
+function setOnEnqueue(cb) {
+	onEnqueueCb = cb;
+}
+/**
+* Drain all pending inbox messages and release retained history.
+*/
+function drainInbox() {
+	const pending = inbox.splice(0, inbox.length);
+	inboxBytes = 0;
+	for (const entry of pending) entry.status = "processed";
+	return pending;
+}
+function getMessageBytes(message) {
+	return Buffer.byteLength(jsonStringify(message), "utf8");
+}
+function enqueueInboxEntry(entry) {
+	const entryBytes = getMessageBytes(entry.message);
+	if (entryBytes > 65536 || inbox.length >= 1e3 || inboxBytes + entryBytes > 2097152) {
+		logError(/* @__PURE__ */ new Error(`[udsMessaging] inbox full (${inbox.length}/${MAX_UDS_INBOX_ENTRIES}, ${inboxBytes}/${MAX_UDS_INBOX_BYTES} bytes); dropping message type=${entry.message.type}`));
+		return false;
+	}
+	inbox.push(entry);
+	inboxBytes += entryBytes;
+	return true;
+}
+function ensureAuthToken() {
+	if (!authToken) authToken = randomBytes(32).toString("hex");
+	return authToken;
+}
+function getMessageAuthToken(message) {
+	const token = message.meta?.authToken;
+	return typeof token === "string" ? token : void 0;
+}
+function isAuthorizedMessage(message) {
+	const provided = getMessageAuthToken(message);
+	if (!provided || !authToken) return false;
+	const providedBuffer = Buffer.from(provided, "utf8");
+	const expectedBuffer = Buffer.from(authToken, "utf8");
+	if (providedBuffer.length !== expectedBuffer.length) return false;
+	return timingSafeEqual(providedBuffer, expectedBuffer);
+}
+function writeSocketMessage(socket, message) {
+	if (socket.destroyed) return;
+	socket.write(jsonStringify(message) + "\n");
+}
+function writeSocketMessageAndDestroy(socket, message) {
+	if (socket.destroyed) return;
+	socket.write(jsonStringify(message) + "\n", () => {
+		if (!socket.destroyed) socket.destroy();
+	});
+}
+function writeSocketErrorAndDestroy(socket, data) {
+	writeSocketMessageAndDestroy(socket, {
+		type: "error",
+		data,
+		ts: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function unrefTimer(timer) {
+	const maybeUnref = timer.unref;
+	if (typeof maybeUnref === "function") maybeUnref.call(timer);
+}
+async function closeServer(serverToClose) {
+	await new Promise((resolve) => {
+		serverToClose.close(() => resolve());
+	});
+}
+async function removeSocketPath(path) {
+	if (process.platform === "win32") return;
+	try {
+		await unlink(path);
+	} catch {}
+}
+function stripAuthToken(message) {
+	const { authToken: _authToken, ...metaWithoutAuth } = message.meta ?? {};
+	return {
+		...message,
+		meta: Object.keys(metaWithoutAuth).length > 0 ? metaWithoutAuth : void 0
+	};
+}
+function withRequestAuthToken(message, token) {
+	return {
+		...message,
+		meta: {
+			...message.meta,
+			authToken: token
+		}
+	};
+}
+/**
+* Start the UDS messaging server on the given socket path.
+*
+* Exports `CLAUDE_CODE_MESSAGING_SOCKET` into `process.env` so child
+* processes (hooks, spawned agents) can discover and connect back.
+*/
+async function startUdsMessaging(path, opts) {
+	if (server) {
+		logForDebugging("[udsMessaging] server already running, skipping start");
+		return;
+	}
+	if (process.platform !== "win32") await ensureSocketParent(path);
+	if (process.platform !== "win32") try {
+		await unlink(path);
+	} catch {}
+	const token = ensureAuthToken();
+	let startedServer = null;
+	let exportedSocketEnv = false;
+	try {
+		await new Promise((resolve, reject) => {
+			const srv = createServer((socket) => {
+				if (clients.size >= 128) {
+					logForDebugging(`[udsMessaging] rejected client: ${clients.size}/128 clients already connected`);
+					socket.destroy();
+					return;
+				}
+				clients.add(socket);
+				logForDebugging(`[udsMessaging] client connected (total: ${clients.size})`);
+				let authenticated = false;
+				let closing = false;
+				const closeWithError = (data) => {
+					if (closing || socket.destroyed) return;
+					closing = true;
+					socket.pause();
+					writeSocketErrorAndDestroy(socket, data);
+				};
+				const authTimer = setTimeout(() => {
+					if (authenticated || socket.destroyed) return;
+					logForDebugging("[udsMessaging] closing unauthenticated idle client");
+					closeWithError("authentication timeout");
+				}, UDS_AUTH_TIMEOUT_MS);
+				unrefTimer(authTimer);
+				socket.setTimeout(UDS_IDLE_TIMEOUT_MS, () => {
+					logForDebugging("[udsMessaging] closing idle client");
+					closeWithError("idle timeout");
+				});
+				attachNdjsonFramer(socket, (msg) => {
+					if (!isAuthorizedMessage(msg)) {
+						logForDebugging(`[udsMessaging] rejected unauthenticated message type=${msg.type}`);
+						closeWithError("unauthorized");
+						return;
+					}
+					if (!authenticated) {
+						authenticated = true;
+						clearTimeout(authTimer);
+					}
+					if (msg.type === "ping") {
+						writeSocketMessage(socket, {
+							type: "pong",
+							from: socketPath ?? void 0,
+							ts: (/* @__PURE__ */ new Date()).toISOString()
+						});
+						return;
+					}
+					const sanitizedMessage = stripAuthToken(msg);
+					const entry = {
+						id: `uds-${nextId++}`,
+						message: sanitizedMessage,
+						receivedAt: Date.now(),
+						status: "pending"
+					};
+					if (!enqueueInboxEntry(entry)) {
+						closeWithError("inbox full");
+						return;
+					}
+					logForDebugging(`[udsMessaging] enqueued message type=${msg.type} from=${msg.from ?? "unknown"}`);
+					writeSocketMessage(socket, {
+						type: "response",
+						data: "ok",
+						ts: (/* @__PURE__ */ new Date()).toISOString(),
+						meta: { id: entry.id }
+					});
+					onEnqueueCb?.();
+				}, (text) => jsonParse(text), {
+					maxFrameBytes: MAX_UDS_FRAME_BYTES,
+					onFrameError: (error) => {
+						logForDebugging(`[udsMessaging] ${error.message}`);
+						closeWithError(error.message);
+					},
+					onInvalidFrame: (error) => {
+						logForDebugging(`[udsMessaging] invalid client frame: ${errorMessage(error)}`);
+						closeWithError("invalid frame");
+					},
+					destroyOnFrameError: false
+				});
+				socket.on("close", () => {
+					clearTimeout(authTimer);
+					clients.delete(socket);
+				});
+				socket.on("error", (err) => {
+					clearTimeout(authTimer);
+					clients.delete(socket);
+					logForDebugging(`[udsMessaging] client error: ${errorMessage(err)}`);
+				});
+			});
+			const rejectBeforeListen = (error) => {
+				reject(error);
+			};
+			const logRuntimeError = (error) => {
+				logForDebugging(`[udsMessaging] server error on ${path}${opts?.isExplicit ? " (explicit)" : ""}: ${errorMessage(error)}`);
+			};
+			srv.once("error", rejectBeforeListen);
+			srv.listen(path, () => {
+				(async () => {
+					try {
+						if (process.platform !== "win32") await chmod(path, 384);
+						srv.off("error", rejectBeforeListen);
+						srv.on("error", logRuntimeError);
+						server = srv;
+						startedServer = srv;
+						resolve();
+					} catch (error) {
+						srv.off("error", rejectBeforeListen);
+						const closeError = error instanceof Error ? error : new Error(errorMessage(error));
+						let rejected = false;
+						const rejectOnce = () => {
+							if (rejected) return;
+							rejected = true;
+							reject(closeError);
+						};
+						const fallback = setTimeout(rejectOnce, 1e3);
+						unrefTimer(fallback);
+						srv.close(() => {
+							clearTimeout(fallback);
+							rejectOnce();
+						});
+					}
+				})();
+			});
+		});
+		await writeCapabilityFile(path, token);
+		socketPath = path;
+		process.env.CLAUDE_CODE_MESSAGING_SOCKET = path;
+		exportedSocketEnv = true;
+		logForDebugging(`[udsMessaging] server listening on ${path}${opts?.isExplicit ? " (explicit)" : ""}`);
+	} catch (error) {
+		if (capabilityFilePath) {
+			try {
+				await unlink(capabilityFilePath);
+			} catch {}
+			capabilityFilePath = null;
+		}
+		if (startedServer) await closeServer(startedServer);
+		if (server === startedServer) server = null;
+		await removeSocketPath(path);
+		if (exportedSocketEnv) delete process.env.CLAUDE_CODE_MESSAGING_SOCKET;
+		socketPath = null;
+		defaultSocketPath = null;
+		authToken = null;
+		throw error;
+	}
+	registerCleanup(async () => {
+		await stopUdsMessaging();
+	});
+}
+/**
+* Stop the UDS messaging server and clean up the socket file.
+*/
+async function stopUdsMessaging() {
+	defaultSocketPath = null;
+	if (!server) return;
+	for (const socket of clients) socket.destroy();
+	clients.clear();
+	await new Promise((resolve) => {
+		server.close(() => resolve());
+	});
+	server = null;
+	inbox.length = 0;
+	inboxBytes = 0;
+	onEnqueueCb = null;
+	if (socketPath) {
+		await removeSocketPath(socketPath);
+		delete process.env.CLAUDE_CODE_MESSAGING_SOCKET;
+		logForDebugging(`[udsMessaging] server stopped, socket removed: ${socketPath}`);
+		socketPath = null;
+		authToken = null;
+	}
+	if (capabilityFilePath) {
+		try {
+			await unlink(capabilityFilePath);
+		} catch {}
+		capabilityFilePath = null;
+	}
+}
+/**
+* Send a UDS message to a specific socket path (outbound — used when this
+* session wants to push a message to a peer's server).
+*/
+async function sendUdsMessage(targetSocketPath, message, opts = {}) {
+	const { createConnection } = await import("net");
+	const token = opts.authToken ?? authToken;
+	if (!token) throw new Error("Cannot send UDS message without auth token");
+	const outbound = withRequestAuthToken({
+		...message,
+		from: message.from ?? socketPath ?? void 0,
+		ts: message.ts ?? (/* @__PURE__ */ new Date()).toISOString()
+	}, token);
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let conn;
+		const finish = (error) => {
+			if (settled) return;
+			settled = true;
+			if (error) {
+				conn.destroy(error);
+				reject(error);
+			} else {
+				conn.end();
+				resolve();
+			}
+		};
+		conn = createConnection(targetSocketPath, () => {
+			conn.write(jsonStringify(outbound) + "\n", (err) => {
+				if (err) finish(err);
+			});
+		});
+		attachUdsResponseReader(conn, {
+			maxFrameBytes: MAX_UDS_FRAME_BYTES,
+			acceptPong: true,
+			onSettled: finish
+		});
+		conn.setTimeout(5e3, () => {
+			finish(/* @__PURE__ */ new Error("Connection timed out"));
+		});
+	});
+}
+var server, socketPath, onEnqueueCb, clients, inbox, nextId, defaultSocketPath, authToken, capabilityFilePath, inboxBytes, MAX_UDS_INBOX_ENTRIES, MAX_UDS_FRAME_BYTES, MAX_UDS_INBOX_BYTES, UDS_AUTH_TIMEOUT_MS, UDS_IDLE_TIMEOUT_MS;
+var init_udsMessaging = __esmMin((() => {
+	init_cleanupRegistry();
+	init_debug();
+	init_errors();
+	init_envUtils();
+	init_ndjsonFramer();
+	init_udsResponseReader();
+	init_log();
+	init_slowOperations();
+	server = null;
+	socketPath = null;
+	onEnqueueCb = null;
+	clients = /* @__PURE__ */ new Set();
+	inbox = [];
+	nextId = 1;
+	defaultSocketPath = null;
+	authToken = null;
+	capabilityFilePath = null;
+	inboxBytes = 0;
+	MAX_UDS_INBOX_ENTRIES = 1e3;
+	MAX_UDS_FRAME_BYTES = 64 * 1024;
+	MAX_UDS_INBOX_BYTES = 2 * 1024 * 1024;
+	UDS_AUTH_TIMEOUT_MS = 2e3;
+	UDS_IDLE_TIMEOUT_MS = 3e4;
+}));
+//#endregion
+export { udsMessaging_exports as _, UDS_IDLE_TIMEOUT_MS as a, init_udsResponseReader as b, getDefaultUdsSocketPath as c, parseUdsTarget as d, readUdsCapabilityToken as f, stopUdsMessaging as g, startUdsMessaging as h, UDS_AUTH_TIMEOUT_MS as i, getUdsMessagingSocketPath as l, setOnEnqueue as m, MAX_UDS_INBOX_BYTES as n, drainInbox as o, sendUdsMessage as p, MAX_UDS_INBOX_ENTRIES as r, formatUdsAddress as s, MAX_UDS_FRAME_BYTES as t, init_udsMessaging as u, attachUdsResponseReader as v, getChunkBytes as y };

package/dist/chunks/udsMessaging-DYuyH0-1.js

@@ -0,0 +1,3 @@
+import { c as getDefaultUdsSocketPath, d as parseUdsTarget, f as readUdsCapabilityToken, h as startUdsMessaging, l as getUdsMessagingSocketPath, u as init_udsMessaging } from "./udsMessaging-CqD2Z113.js";
+init_udsMessaging();
+export { getDefaultUdsSocketPath, getUdsMessagingSocketPath, parseUdsTarget, readUdsCapabilityToken, startUdsMessaging };

package/dist/chunks/{ultrareviewCommand-H9CSucZi.js → ultrareviewCommand-B3DtQHhh.js}

@@ -2,16 +2,16 @@ import { n as __esmMin, o as __toESM } from "./chunk-CyLJMB0t.js";
 import { n as axios, t as init_axios } from "./axios-i4OSNWFR.js";
 import { b as ThemedText, f as Dialog, t as init_src, x as ThemedBox } from "./src-D-Y8UkL2.js";
 import { n as require_react, t as require_jsx_runtime } from "./jsx-runtime-U0-f0qxU.js";
-import { S as init_growthbook, _ as getFeatureValue_CACHED_MAY_BE_STALE, dn as isClaudeAISubscriber, mn as isEnterpriseSubscriber, on as init_auth, xn as isTeamSubscriber } from "./paths-BK4d8glq.js";
+import { S as init_growthbook, _ as getFeatureValue_CACHED_MAY_BE_STALE, dn as isClaudeAISubscriber, mn as isEnterpriseSubscriber, on as init_auth, xn as isTeamSubscriber } from "./paths-IfmY9nZN.js";
 import { d as logForDebugging, s as init_debug } from "./debug-CWVskDes.js";
 import { n as init_analytics, r as logEvent } from "./analytics-BUe7uXWv.js";
-import { _ as gitExe, a as getDefaultBranch, v as init_git } from "./git-CNGxJWbO.js";
+import { _ as gitExe, a as getDefaultBranch, v as init_git } from "./git-CA2F_723.js";
 import { l as getOauthConfig, u as init_oauth } from "./oauth-DiKu2bJI.js";
 import { r as init_execFileNoThrow, t as execFileNoThrow } from "./execFileNoThrow-DslIaQ3v.js";
-import { $g as formatPreconditionError, Qg as checkRemoteAgentEligibility, Xx as Select, Zx as init_select, d_ as teleportToRemote, e_ as getRemoteTaskSessionUrl, n_ as registerRemoteAgentTask, o_ as init_teleport, t_ as init_RemoteAgentTask } from "./loadAgentsDir-10Jr53dd.js";
-import { a as init_detectRepository, r as detectCurrentRepositoryWithHost } from "./detectRepository-CKod-dqz.js";
-import { a as getOAuthHeaders, c as prepareApiRequest, o as init_api } from "./api-yTTqoYQQ.js";
-import { n as init_usage, t as fetchUtilization } from "./usage-Bq4VatK_.js";
+import { F_ as formatPreconditionError, H_ as init_teleport, I_ as getRemoteTaskSessionUrl, L_ as init_RemoteAgentTask, Nx as Select, P_ as checkRemoteAgentEligibility, Px as init_select, R_ as registerRemoteAgentTask, q_ as teleportToRemote } from "./loadAgentsDir-CvgrZXrt.js";
+import { a as init_detectRepository, r as detectCurrentRepositoryWithHost } from "./detectRepository-DePiwWvI.js";
+import { a as getOAuthHeaders, c as prepareApiRequest, o as init_api } from "./api-B8xNSO2s.js";
+import { n as init_usage, t as fetchUtilization } from "./usage-DY9nhq5T.js";
 //#region src/services/api/ultrareviewQuota.ts
 /**
 * Peek the ultrareview quota for display and nudge decisions. Consume

package/dist/chunks/{undercover-BqQEFYM_.js → undercover-DKEeZbP1.js}

@@ -1,7 +1,7 @@
 import { n as __esmMin } from "./chunk-CyLJMB0t.js";
 import { s as init_envUtils, u as isEnvTruthy } from "./envUtils-DVwWVCmJ.js";
-import { Dc as init_config, yc as getGlobalConfig } from "./paths-BK4d8glq.js";
-import { l as init_commitAttribution, s as getRepoClassCached } from "./commitAttribution-96_4kt9b.js";
+import { Dc as init_config, yc as getGlobalConfig } from "./paths-IfmY9nZN.js";
+import { l as init_commitAttribution, s as getRepoClassCached } from "./commitAttribution-D2pnNyaZ.js";
 //#region src/utils/undercover.ts
 function isUndercover() {
 	if (process.env.USER_TYPE === "ant") {

package/dist/chunks/{undercover-Dh4Dbbbr.js → undercover-_Km4wVxO.js}

@@ -1,3 +1,3 @@
-import { i as shouldShowUndercoverAutoNotice, n as init_undercover } from "./undercover-BqQEFYM_.js";
+import { i as shouldShowUndercoverAutoNotice, n as init_undercover } from "./undercover-DKEeZbP1.js";
 init_undercover();
 export { shouldShowUndercoverAutoNotice };

package/dist/chunks/{up-DgUz-Iid.js → up-C0eEOvrs.js}

@@ -1,4 +1,4 @@
-import { r as findGitRoot, v as init_git } from "./git-CNGxJWbO.js";
+import { r as findGitRoot, v as init_git } from "./git-CA2F_723.js";
 import { join } from "path";
 import { readFileSync } from "fs";
 import { spawnSync } from "child_process";

package/dist/chunks/{updateCCB-C6lRZp5E.js → updateCCB-DVbDv6RL.js}

@@ -2,7 +2,7 @@ import { Fn as chalk, In as init_source } from "./src-D-Y8UkL2.js";
 import { d as logForDebugging, s as init_debug } from "./debug-CWVskDes.js";
 import { o as writeToStdout, t as init_process } from "./process-LOMmIsyv.js";
 import { n as execFileNoThrowWithCwd, r as init_execFileNoThrow } from "./execFileNoThrow-DslIaQ3v.js";
-import { Ub as init_gracefulShutdown, Vb as gracefulShutdown } from "./loadAgentsDir-10Jr53dd.js";
+import { YT as init_gracefulShutdown, qT as gracefulShutdown } from "./loadAgentsDir-CvgrZXrt.js";
 import { dirname, join } from "node:path";
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";

package/dist/chunks/{upgrade-169SEycC.js → upgrade-B2OGKi2F.js}

@@ -1,9 +1,9 @@
 import { n as __esmMin } from "./chunk-CyLJMB0t.js";
 import { n as require_react, t as require_jsx_runtime } from "./jsx-runtime-U0-f0qxU.js";
-import { Jt as getClaudeAIOAuthTokens, dn as isClaudeAISubscriber, ga as init_getOauthProfile, ha as getOauthProfileFromOauthToken, on as init_auth } from "./paths-BK4d8glq.js";
+import { Jt as getClaudeAIOAuthTokens, dn as isClaudeAISubscriber, ga as init_getOauthProfile, ha as getOauthProfileFromOauthToken, on as init_auth } from "./paths-IfmY9nZN.js";
 import { o as init_log, s as logError } from "./log-BtGcZqeW.js";
-import { n as openBrowser, t as init_browser } from "./browser-DUiMTsmF.js";
-import { r as init_login, t as Login } from "./login-DqsUqLSu.js";
+import { n as openBrowser, t as init_browser } from "./browser-JbnSg475.js";
+import { r as init_login, t as Login } from "./login-DDXcrvYz.js";
 //#region src/commands/upgrade/upgrade.tsx
 async function call(onDone, context) {
 	try {

package/dist/chunks/{upload-DnQLvFF5.js → upload-CCRCHU9P.js}

@@ -5,7 +5,7 @@ import { t as init_v4 } from "./v4-pqEJ8Dq2.js";
 import { E as jsonStringify, d as logForDebugging, s as init_debug, w as init_slowOperations } from "./debug-CWVskDes.js";
 import { l as getOauthConfig, u as init_oauth } from "./oauth-DiKu2bJI.js";
 import { n as lazySchema, t as init_lazySchema } from "./lazySchema-DCmLE9e3.js";
-import { a as init_bridgeConfig, r as getBridgeBaseUrlOverride, t as getBridgeAccessToken } from "./bridgeConfig-CPm4YdPQ.js";
+import { a as init_bridgeConfig, r as getBridgeBaseUrlOverride, t as getBridgeAccessToken } from "./bridgeConfig-B2rD8AEm.js";
 import { basename, extname } from "path";
 import { randomUUID } from "crypto";
 import { readFile } from "fs/promises";