agent-console-server 4.1.1 → 4.2.0

package/dist/agentConsoleServerCommand-B7491RR7.js

@@ -1,3275 +0,0 @@
-import { H as getSignedText, Ot as permissionModeSchema, U as serverMessageSchema, _n as SHELL_OUTPUT_LENGTH, dn as DEFAULT_HOSTNAME, fn as DEFAULT_PORT, gn as SCHEME_PAIRING_CODE_DURATION_MS, gt as todoStatusSchema, hn as PAIRING_HASH_PARAMETER, it as agentEventSchema, mn as PAIRING_CODE_PARAMETER, pn as HOST_SCHEME, r as handshakeMessageSchema, t as EphemeralAgentEventTypes, u as commandSchema, un as DEFAULT_APP_ORIGIN, y as driverCommandSchema } from "./EphemeralAgentEventTypes-Spjnk48Y.js";
-import { createRequire } from "node:module";
-import { homedir, hostname } from "node:os";
-import { ID_SEPARATOR, InvalidOperationError, Operation, RoutePath, SITE_NAME, createUniqueArraySchema, exhaustiveGuard, getOrCreate, getResult, getResultAsync, noop, withFinalizerAsync } from "@esposter/shared";
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
-import { execFile, execFileSync, spawn } from "node:child_process";
-import { parseArgs, promisify } from "node:util";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { getAssetKeys, getRawAsset, isSea } from "node:sea";
-import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, sign, timingSafeEqual, verify } from "node:crypto";
-import { z } from "zod";
-import { once } from "node:events";
-import { WebSocket, WebSocketServer } from "ws";
-import { getSessionInfo, getSessionMessages, listSessions, query } from "@anthropic-ai/claude-agent-sdk";
-import { readFile, readdir, realpath, stat } from "node:fs/promises";
-import { createServer } from "node:http";
-import { setTimeout as setTimeout$1 } from "node:timers/promises";
-//#region src/services/cli/getReachableHostname.ts
-const getReachableHostname = (hostname$1) => hostname$1 === "0.0.0.0" ? hostname() : hostname$1;
-//#endregion
-//#region src/services/cli/hostArgs.ts
-const hostArgs = {
-	hostname: {
-		default: DEFAULT_HOSTNAME,
-		description: "The address the host listens on",
-		type: "string"
-	},
-	origin: {
-		default: DEFAULT_APP_ORIGIN,
-		description: "The app's origin the printed link opens",
-		type: "string"
-	},
-	port: {
-		default: String(DEFAULT_PORT),
-		description: "The port the host listens on",
-		type: "string"
-	}
-};
-//#endregion
-//#region src/services/installer/constants.ts
-const HOST_EXECUTABLE_FILENAME = "agent-console-host.exe";
-const CLAUDE_CODE_EXECUTABLE_FILENAME = "claude.exe";
-const HOST_SCHEME_REGISTRY_KEY = win32.join("HKCU", "Software", "Classes", HOST_SCHEME);
-const HOST_DIRECTORY_ENVIRONMENT_VARIABLE = `${SITE_NAME.toUpperCase()}_HOST_DIRECTORY`;
-const HOST_INSTALL_DIRECTORY_SEGMENTS = [SITE_NAME, "Host"];
-const NODE_PTY_DIRECTORY_NAME = "node-pty";
-//#endregion
-//#region src/services/installer/getHostInstallDirectory.ts
-const getHostInstallDirectory = () => join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), ...HOST_INSTALL_DIRECTORY_SEGMENTS);
-//#endregion
-//#region src/services/installer/checkIsHostInstalled.ts
-const checkIsHostInstalled = () => relative(getHostInstallDirectory(), dirname(process.execPath)) === "";
-//#endregion
-//#region ../shared-node/dist/execSync-CtM99iYq.js
-const withHiddenWindow = (parameters) => {
-	const optionsIndex = Array.isArray(parameters[0]) || parameters[0] === void 0 && parameters.length > 1 ? 1 : 0;
-	const options = parameters[optionsIndex];
-	if (typeof options === "object" && options !== null) return parameters.toSpliced(optionsIndex, 1, {
-		...options,
-		windowsHide: true
-	});
-	const isPlaceholder = options === void 0 && optionsIndex < parameters.length;
-	return parameters.toSpliced(optionsIndex, Number(isPlaceholder), { windowsHide: true });
-};
-//#endregion
-//#region ../shared-node/dist/child-process.js
-const execFile$1 = ((file, ...parameters) => execFile(file, ...withHiddenWindow(parameters)));
-Object.defineProperty(execFile$1, promisify.custom, { value: (file, ...parameters) => promisify(execFile)(file, ...withHiddenWindow(parameters)) });
-const execFileSync$1 = ((file, ...parameters) => execFileSync(file, ...withHiddenWindow(parameters)));
-const spawn$1 = ((file, ...parameters) => spawn(file, ...withHiddenWindow(parameters)));
-//#endregion
-//#region src/services/installer/installHost.ts
-const installHost = () => {
-	const installDirectory = getHostInstallDirectory();
-	const executablePath = join(installDirectory, HOST_EXECUTABLE_FILENAME);
-	mkdirSync(installDirectory, { recursive: true });
-	copyFileSync(process.execPath, executablePath);
-	writeFileSync(join(installDirectory, CLAUDE_CODE_EXECUTABLE_FILENAME), new Uint8Array(getRawAsset(CLAUDE_CODE_EXECUTABLE_FILENAME)));
-	for (const assetKey of getAssetKeys().filter((key) => key.startsWith(`${NODE_PTY_DIRECTORY_NAME}/`))) {
-		const assetPath = join(installDirectory, ...assetKey.split("/"));
-		mkdirSync(dirname(assetPath), { recursive: true });
-		writeFileSync(assetPath, new Uint8Array(getRawAsset(assetKey)));
-	}
-	for (const registryArguments of [
-		[
-			HOST_SCHEME_REGISTRY_KEY,
-			"/ve",
-			"/d",
-			`URL:${SITE_NAME} Host`
-		],
-		[
-			HOST_SCHEME_REGISTRY_KEY,
-			"/v",
-			"URL Protocol",
-			"/d",
-			""
-		],
-		[
-			win32.join(HOST_SCHEME_REGISTRY_KEY, "shell", "open", "command"),
-			"/ve",
-			"/d",
-			`"${executablePath}" "%1"`
-		]
-	]) execFileSync$1("reg", [
-		"add",
-		...registryArguments,
-		"/f"
-	], { stdio: "ignore" });
-	return installDirectory;
-};
-//#endregion
-//#region src/services/cli/installDownloadedHost.ts
-const installDownloadedHost = () => {
-	if (!isSea() || checkIsHostInstalled()) return;
-	getResult(() => installHost()).match((installDirectory) => {
-		process.stdout.write(`Installed the host in ${installDirectory}. The page's Connect starts it from now on.\n\n`);
-	}, (error) => {
-		process.stderr.write(`Could not install the host: ${error.message}\nClose any other host window, then open this file again.\n`);
-		process.exit(1);
-	});
-};
-//#endregion
-//#region src/services/cli/writeLine.ts
-const writeLine = (line) => {
-	process.stdout.write(`${line}\n`);
-};
-//#endregion
-//#region src/services/device/constants.ts
-const STATE_DIRECTORY_NAME = ".agent-console-server";
-const DEVICES_FILENAME = "devices.json";
-const HOST_KEY_FILENAME = "host-key.pem";
-const SECRET_BYTE_LENGTH = 32;
-const PRINTED_PAIRING_CODE_DURATION_MS = Temporal.Duration.from({ minutes: 10 }).total("milliseconds");
-//#endregion
-//#region src/services/device/getStateDirectory.ts
-const getStateDirectory = () => join(homedir(), STATE_DIRECTORY_NAME);
-//#endregion
-//#region src/services/device/writeStateFile.ts
-const writeStateFile = (stateDirectory, filename, content) => {
-	const filePath = join(stateDirectory, filename);
-	const temporaryFilePath = `${filePath}.${crypto.randomUUID()}.tmp`;
-	mkdirSync(stateDirectory, { recursive: true });
-	getResult(() => {
-		writeFileSync(temporaryFilePath, content, {
-			flag: "wx",
-			mode: 384
-		});
-		renameSync(temporaryFilePath, filePath);
-	}).match(noop, (error) => {
-		getResult(() => {
-			rmSync(temporaryFilePath, { force: true });
-		}).match(noop, console.error);
-		throw error;
-	});
-};
-//#endregion
-//#region src/services/device/readHostKey.ts
-const readHostKey = (stateDirectory) => {
-	const hostKeyPath = join(stateDirectory, HOST_KEY_FILENAME);
-	if (existsSync(hostKeyPath)) return createPrivateKey(readFileSync(hostKeyPath, "utf8"));
-	const { privateKey } = generateKeyPairSync("ed25519");
-	writeStateFile(stateDirectory, HOST_KEY_FILENAME, privateKey.export({
-		format: "pem",
-		type: "pkcs8"
-	}));
-	return privateKey;
-};
-//#endregion
-//#region src/models/device/Device.ts
-const deviceSchema = z.object({
-	createdAt: z.coerce.date(),
-	credentialHash: z.string().min(1),
-	id: z.string().min(1),
-	name: z.string(),
-	origin: z.string()
-});
-//#endregion
-//#region src/services/device/readDevices.ts
-const readDevices = (stateDirectory) => {
-	const devicesPath = join(stateDirectory, DEVICES_FILENAME);
-	if (existsSync(devicesPath)) return z.array(deviceSchema).parse(JSON.parse(readFileSync(devicesPath, "utf8")));
-	else return [];
-};
-//#endregion
-//#region src/services/device/writeDevices.ts
-const writeDevices = (stateDirectory, devices) => {
-	writeStateFile(stateDirectory, DEVICES_FILENAME, JSON.stringify(devices, void 0, 2));
-};
-//#endregion
-//#region src/services/handshake/checkIsSignatureValid.ts
-const checkIsSignatureValid = (key, purpose, port, nonce, signature) => verify(void 0, Buffer.from(getSignedText(purpose, port, nonce)), key, Buffer.from(signature, "base64url"));
-//#endregion
-//#region src/services/handshake/signNonce.ts
-const signNonce = (privateKey, purpose, port, nonce) => sign(void 0, Buffer.from(getSignedText(purpose, port, nonce)), privateKey).toString("base64url");
-//#endregion
-//#region src/services/server/constants.ts
-const HOST_PROBE_TIMEOUT_MS = 2e3;
-//#endregion
-//#region src/services/shared/readMessageText.ts
-const readMessageText = (data) => Buffer.isBuffer(data) ? data.toString() : Array.isArray(data) ? Buffer.concat(data).toString() : Buffer.from(data).toString();
-//#endregion
-//#region src/services/server/sendToRunningHost.ts
-const sendToRunningHost = async (hostname, port, hostKey, createMessage) => {
-	const nonce = randomBytes(32).toString("base64url");
-	const webSocket = new WebSocket(`ws://${hostname}:${port}`, { handshakeTimeout: HOST_PROBE_TIMEOUT_MS });
-	const isHost = await getResultAsync(async () => {
-		const signal = AbortSignal.timeout(HOST_PROBE_TIMEOUT_MS);
-		await once(webSocket, "open", { signal });
-		const pendingMessage = once(webSocket, "message", { signal });
-		webSocket.send(JSON.stringify({
-			nonce,
-			type: "Challenge"
-		}));
-		const [data] = await pendingMessage;
-		const serverMessage = serverMessageSchema.parse(JSON.parse(readMessageText(data)));
-		if (serverMessage.type !== "Proof" || serverMessage.port !== port || !checkIsSignatureValid(createPublicKey(hostKey), "HostProof", port, nonce, serverMessage.signature)) return false;
-		if (!createMessage) return true;
-		const pendingClose = once(webSocket, "close", { signal });
-		webSocket.send(JSON.stringify(createMessage(signNonce(hostKey, "OwnerProof", port, serverMessage.nonce))));
-		await pendingClose;
-		return true;
-	}).match((isHolderHost) => isHolderHost, () => false);
-	webSocket.terminate();
-	return isHost;
-};
-//#endregion
-//#region src/services/device/runDevicesCommand.ts
-const runDevicesCommand = async ({ hostKey, hostname, port, revokeDeviceId, stateDirectory }, writeLine) => {
-	const devices = readDevices(stateDirectory);
-	if (!revokeDeviceId) {
-		if (devices.length === 0) writeLine("No page is connected to this host.");
-		for (const { createdAt, id, name, origin } of devices) writeLine(`${id}  ${name}  ${origin}  since ${createdAt.toISOString()}`);
-		return true;
-	}
-	if (!devices.some(({ id }) => id === revokeDeviceId)) {
-		writeLine(`No device has the id ${revokeDeviceId}.`);
-		return false;
-	}
-	writeDevices(stateDirectory, devices.filter(({ id }) => id !== revokeDeviceId));
-	await sendToRunningHost(hostname, port, hostKey, (signature) => ({
-		deviceId: revokeDeviceId,
-		signature,
-		type: "Revoke"
-	}));
-	writeLine(`Removed ${revokeDeviceId}. It has to connect again to use this host.`);
-	return true;
-};
-//#endregion
-//#region ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/_chunks/libs/scule.mjs
-const NUMBER_CHAR_RE = /\d/;
-const STR_SPLITTERS = [
-	"-",
-	"_",
-	"/",
-	"."
-];
-function isUppercase(char = "") {
-	if (NUMBER_CHAR_RE.test(char)) return;
-	return char !== char.toLowerCase();
-}
-function splitByCase(str, separators) {
-	const splitters = separators ?? STR_SPLITTERS;
-	const parts = [];
-	if (!str || typeof str !== "string") return parts;
-	let buff = "";
-	let previousUpper;
-	let previousSplitter;
-	for (const char of str) {
-		const isSplitter = splitters.includes(char);
-		if (isSplitter === true) {
-			parts.push(buff);
-			buff = "";
-			previousUpper = void 0;
-			continue;
-		}
-		const isUpper = isUppercase(char);
-		if (previousSplitter === false) {
-			if (previousUpper === false && isUpper === true) {
-				parts.push(buff);
-				buff = char;
-				previousUpper = isUpper;
-				continue;
-			}
-			if (previousUpper === true && isUpper === false && buff.length > 1) {
-				const lastChar = buff.at(-1);
-				parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
-				buff = lastChar + char;
-				previousUpper = isUpper;
-				continue;
-			}
-		}
-		buff += char;
-		previousUpper = isUpper;
-		previousSplitter = isSplitter;
-	}
-	parts.push(buff);
-	return parts;
-}
-function upperFirst(str) {
-	return str ? str[0].toUpperCase() + str.slice(1) : "";
-}
-function lowerFirst(str) {
-	return str ? str[0].toLowerCase() + str.slice(1) : "";
-}
-function pascalCase(str, opts) {
-	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
-}
-function camelCase(str, opts) {
-	return lowerFirst(pascalCase(str || "", opts));
-}
-function kebabCase(str, joiner) {
-	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
-}
-function snakeCase(str) {
-	return kebabCase(str || "", "_");
-}
-//#endregion
-//#region ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.mjs
-function toArray(val) {
-	if (Array.isArray(val)) return val;
-	return val === void 0 ? [] : [val];
-}
-function formatLineColumns(lines, linePrefix = "") {
-	const maxLength = [];
-	for (const line of lines) for (const [i, element] of line.entries()) maxLength[i] = Math.max(maxLength[i] || 0, element.length);
-	return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join("\n");
-}
-function resolveValue(input) {
-	return typeof input === "function" ? input() : input;
-}
-var CLIError = class extends Error {
-	code;
-	constructor(message, code) {
-		super(message);
-		this.name = "CLIError";
-		this.code = code;
-	}
-};
-function parseRawArgs(args = [], opts = {}) {
-	const booleans = new Set(opts.boolean || []);
-	const strings = new Set(opts.string || []);
-	const aliasMap = opts.alias || {};
-	const defaults = opts.default || {};
-	const aliasToMain = /* @__PURE__ */ new Map();
-	const mainToAliases = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(aliasMap)) {
-		const targets = value;
-		for (const target of targets) {
-			aliasToMain.set(key, target);
-			if (!mainToAliases.has(target)) mainToAliases.set(target, []);
-			mainToAliases.get(target).push(key);
-			aliasToMain.set(target, key);
-			if (!mainToAliases.has(key)) mainToAliases.set(key, []);
-			mainToAliases.get(key).push(target);
-		}
-	}
-	const options = {};
-	function getType(name) {
-		if (booleans.has(name)) return "boolean";
-		const aliases = mainToAliases.get(name) || [];
-		for (const alias of aliases) if (booleans.has(alias)) return "boolean";
-		return "string";
-	}
-	function isStringType(name) {
-		if (strings.has(name)) return true;
-		const aliases = mainToAliases.get(name) || [];
-		for (const alias of aliases) if (strings.has(alias)) return true;
-		return false;
-	}
-	const allOptions = /* @__PURE__ */ new Set([
-		...booleans,
-		...strings,
-		...Object.keys(aliasMap),
-		...Object.values(aliasMap).flat(),
-		...Object.keys(defaults)
-	]);
-	for (const name of allOptions) if (!options[name]) options[name] = {
-		type: getType(name),
-		default: defaults[name]
-	};
-	for (const [alias, main] of aliasToMain.entries()) if (alias.length === 1 && options[main] && !options[main].short) options[main].short = alias;
-	const processedArgs = [];
-	const negatedFlags = {};
-	for (let i = 0; i < args.length; i++) {
-		const arg = args[i];
-		if (arg === "--") {
-			processedArgs.push(...args.slice(i));
-			break;
-		}
-		if (arg.startsWith("--no-")) {
-			const flagName = arg.slice(5);
-			negatedFlags[flagName] = true;
-			continue;
-		}
-		processedArgs.push(arg);
-	}
-	let parsed;
-	try {
-		parsed = parseArgs({
-			args: processedArgs,
-			options: Object.keys(options).length > 0 ? options : void 0,
-			allowPositionals: true,
-			strict: false
-		});
-	} catch {
-		parsed = {
-			values: {},
-			positionals: processedArgs
-		};
-	}
-	const out = { _: [] };
-	out._ = parsed.positionals;
-	for (const [key, value] of Object.entries(parsed.values)) {
-		let coerced = value;
-		if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
-		else if (isStringType(key) && typeof value === "boolean") coerced = "";
-		out[key] = coerced;
-	}
-	for (const [name] of Object.entries(negatedFlags)) {
-		out[name] = false;
-		const mainName = aliasToMain.get(name);
-		if (mainName) out[mainName] = false;
-		const aliases = mainToAliases.get(name);
-		if (aliases) for (const alias of aliases) out[alias] = false;
-	}
-	for (const [alias, main] of aliasToMain.entries()) {
-		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
-		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
-		if (out[alias] !== out[main] && defaults[main] === out[main]) out[main] = out[alias];
-	}
-	return out;
-}
-const noColor = /* @__PURE__ */ (() => {
-	const env = globalThis.process?.env ?? {};
-	return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
-})();
-const _c = (c, r = 39) => (t) => noColor ? t : `\u001B[${c}m${t}\u001B[${r}m`;
-const bold = /* @__PURE__ */ _c(1, 22);
-const cyan = /* @__PURE__ */ _c(36);
-const gray = /* @__PURE__ */ _c(90);
-const underline = /* @__PURE__ */ _c(4, 24);
-function parseArgs$1(rawArgs, argsDef) {
-	const parseOptions = {
-		boolean: [],
-		string: [],
-		alias: {},
-		default: {}
-	};
-	const args = resolveArgs(argsDef);
-	for (const arg of args) {
-		if (arg.type === "positional") continue;
-		if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
-		else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
-		if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
-		if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
-		const camelName = camelCase(arg.name);
-		const kebabName = kebabCase(arg.name);
-		if (camelName !== arg.name || kebabName !== arg.name) {
-			const existingAliases = toArray(parseOptions.alias[arg.name] || []);
-			if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
-			if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
-			if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
-		}
-	}
-	const parsed = parseRawArgs(rawArgs, parseOptions);
-	const [ ...positionalArguments] = parsed._;
-	const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
-		return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
-	} });
-	for (const [, arg] of args.entries()) if (arg.type === "positional") {
-		const nextPositionalArgument = positionalArguments.shift();
-		if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
-		else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
-		else parsedArgsProxy[arg.name] = arg.default;
-	} else if (arg.type === "enum") {
-		const argument = parsedArgsProxy[arg.name];
-		const options = arg.options || [];
-		if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
-	} else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
-	return parsedArgsProxy;
-}
-function resolveArgs(argsDef) {
-	const args = [];
-	for (const [name, argDef] of Object.entries(argsDef || {})) args.push({
-		...argDef,
-		name,
-		alias: toArray(argDef.alias)
-	});
-	return args;
-}
-async function resolvePlugins(plugins) {
-	return Promise.all(plugins.map((p) => resolveValue(p)));
-}
-function defineCommand(def) {
-	return def;
-}
-async function runCommand(cmd, opts) {
-	const cmdArgs = await resolveValue(cmd.args || {});
-	const parsedArgs = parseArgs$1(opts.rawArgs, cmdArgs);
-	const context = {
-		rawArgs: opts.rawArgs,
-		args: parsedArgs,
-		data: opts.data,
-		cmd
-	};
-	const plugins = await resolvePlugins(cmd.plugins ?? []);
-	let result;
-	let runError;
-	try {
-		for (const plugin of plugins) await plugin.setup?.(context);
-		if (typeof cmd.setup === "function") await cmd.setup(context);
-		const subCommands = await resolveValue(cmd.subCommands);
-		if (subCommands && Object.keys(subCommands).length > 0) {
-			const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
-			const explicitName = opts.rawArgs[subCommandArgIndex];
-			if (explicitName) {
-				const subCommand = await _findSubCommand(subCommands, explicitName);
-				if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
-				await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
-			} else {
-				const defaultSubCommand = await resolveValue(cmd.default);
-				if (defaultSubCommand) {
-					if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
-					const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
-					if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
-					await runCommand(subCommand, { rawArgs: opts.rawArgs });
-				} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
-			}
-		}
-		if (typeof cmd.run === "function") result = await cmd.run(context);
-	} catch (error) {
-		runError = error;
-	}
-	const cleanupErrors = [];
-	if (typeof cmd.cleanup === "function") try {
-		await cmd.cleanup(context);
-	} catch (error) {
-		cleanupErrors.push(error);
-	}
-	for (const plugin of [...plugins].reverse()) try {
-		await plugin.cleanup?.(context);
-	} catch (error) {
-		cleanupErrors.push(error);
-	}
-	if (runError) throw runError;
-	if (cleanupErrors.length === 1) throw cleanupErrors[0];
-	if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
-	return { result };
-}
-async function resolveSubCommand(cmd, rawArgs, parent) {
-	const subCommands = await resolveValue(cmd.subCommands);
-	if (subCommands && Object.keys(subCommands).length > 0) {
-		const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
-		const subCommandName = rawArgs[subCommandArgIndex];
-		const subCommand = await _findSubCommand(subCommands, subCommandName);
-		if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
-	}
-	return [cmd, parent];
-}
-async function _findSubCommand(subCommands, name) {
-	if (name in subCommands) return resolveValue(subCommands[name]);
-	for (const sub of Object.values(subCommands)) {
-		const resolved = await resolveValue(sub);
-		const meta = await resolveValue(resolved?.meta);
-		if (meta?.alias) {
-			if (toArray(meta.alias).includes(name)) return resolved;
-		}
-	}
-}
-function findSubCommandIndex(rawArgs, argsDef) {
-	for (let i = 0; i < rawArgs.length; i++) {
-		const arg = rawArgs[i];
-		if (arg === "--") return -1;
-		if (arg.startsWith("-")) {
-			if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i++;
-			continue;
-		}
-		return i;
-	}
-	return -1;
-}
-function _isValueFlag(flag, argsDef) {
-	const name = flag.replace(/^-{1,2}/, "");
-	const normalized = camelCase(name);
-	for (const [key, def] of Object.entries(argsDef)) {
-		if (def.type !== "string" && def.type !== "enum") continue;
-		if (normalized === camelCase(key)) return true;
-		if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
-	}
-	return false;
-}
-async function showUsage(cmd, parent) {
-	try {
-		console.log(await renderUsage(cmd, parent) + "\n");
-	} catch (error) {
-		console.error(error);
-	}
-}
-const negativePrefixRe = /^no[-A-Z]/;
-async function renderUsage(cmd, parent) {
-	const cmdMeta = await resolveValue(cmd.meta || {});
-	const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
-	const parentMeta = await resolveValue(parent?.meta || {});
-	const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
-	const argLines = [];
-	const posLines = [];
-	const commandsLines = [];
-	const usageLine = [];
-	for (const arg of cmdArgs) if (arg.type === "positional") {
-		const name = arg.name.toUpperCase();
-		const isRequired = arg.required !== false && arg.default === void 0;
-		posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
-		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
-	} else {
-		const isRequired = arg.required === true && arg.default === void 0;
-		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
-		argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
-		/**
-		* print negative boolean arg variant usage when
-		* - enabled by default or has `negativeDescription`
-		* - not prefixed with `no-` or `no[A-Z]`
-		*/
-		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
-			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
-			argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
-		}
-		if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
-	}
-	if (cmd.subCommands) {
-		const commandNames = [];
-		const subCommands = await resolveValue(cmd.subCommands);
-		for (const [name, sub] of Object.entries(subCommands)) {
-			const meta = await resolveValue((await resolveValue(sub))?.meta);
-			if (meta?.hidden) continue;
-			const aliases = toArray(meta?.alias);
-			const label = [name, ...aliases].join(", ");
-			commandsLines.push([cyan(label), meta?.description || ""]);
-			commandNames.push(name, ...aliases);
-		}
-		usageLine.push(commandNames.join("|"));
-	}
-	const usageLines = [];
-	const version = cmdMeta.version || parentMeta.version;
-	usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
-	const hasOptions = argLines.length > 0 || posLines.length > 0;
-	usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
-	if (posLines.length > 0) {
-		usageLines.push(underline(bold("ARGUMENTS")), "");
-		usageLines.push(formatLineColumns(posLines, "  "));
-		usageLines.push("");
-	}
-	if (argLines.length > 0) {
-		usageLines.push(underline(bold("OPTIONS")), "");
-		usageLines.push(formatLineColumns(argLines, "  "));
-		usageLines.push("");
-	}
-	if (commandsLines.length > 0) {
-		usageLines.push(underline(bold("COMMANDS")), "");
-		usageLines.push(formatLineColumns(commandsLines, "  "));
-		usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
-	}
-	return usageLines.filter((l) => typeof l === "string").join("\n");
-}
-function renderValueHint(arg) {
-	const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
-	const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
-	if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
-	if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
-	return fallbackValueHint;
-}
-function renderDescription(arg, required) {
-	const requiredHint = required ? gray("(Required)") : "";
-	const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
-	return [
-		arg.description,
-		requiredHint,
-		defaultHint
-	].filter(Boolean).join(" ");
-}
-async function runMain(cmd, opts = {}) {
-	const rawArgs = opts.rawArgs || process.argv.slice(2);
-	const showUsage$1 = opts.showUsage || showUsage;
-	try {
-		const builtinFlags = await _resolveBuiltinFlags(cmd);
-		if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
-			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-			process.exit(0);
-		} else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
-			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
-			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
-			console.log(meta.version);
-		} else await runCommand(cmd, { rawArgs });
-	} catch (error) {
-		if (error instanceof CLIError) {
-			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-			console.error(error.message);
-		} else console.error(error, "\n");
-		process.exit(1);
-	}
-}
-async function _resolveBuiltinFlags(cmd) {
-	const argsDef = await resolveValue(cmd.args || {});
-	const userNames = /* @__PURE__ */ new Set();
-	const userAliases = /* @__PURE__ */ new Set();
-	for (const [name, def] of Object.entries(argsDef)) {
-		userNames.add(name);
-		for (const alias of toArray(def.alias)) userAliases.add(alias);
-	}
-	return {
-		help: _getBuiltinFlags("help", "h", userNames, userAliases),
-		version: _getBuiltinFlags("version", "v", userNames, userAliases)
-	};
-}
-function _getBuiltinFlags(long, short, userNames, userAliases) {
-	if (userNames.has(long) || userAliases.has(long)) return [];
-	if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
-	return [`--${long}`, `-${short}`];
-}
-//#endregion
-//#region src/services/cli/commands/devicesCommand.ts
-const devicesCommand = defineCommand({
-	args: {
-		hostname: hostArgs.hostname,
-		port: hostArgs.port,
-		revoke: {
-			default: "",
-			description: "A paired page's id, to remove it",
-			type: "string"
-		}
-	},
-	meta: {
-		description: "List the pages paired with this host, or remove one",
-		name: "devices"
-	},
-	run: async ({ args }) => {
-		installDownloadedHost();
-		const stateDirectory = getStateDirectory();
-		const isDone = await runDevicesCommand({
-			hostKey: readHostKey(stateDirectory),
-			hostname: getReachableHostname(args.hostname),
-			port: Number(args.port),
-			revokeDeviceId: args.revoke,
-			stateDirectory
-		}, writeLine);
-		process.exit(isDone ? 0 : 1);
-	}
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/getEventId.ts
-const getEventId = (sourceId, suffix) => `${sourceId}${ID_SEPARATOR}${suffix}`;
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toSessionClosedEvents.ts
-const toSessionClosedEvents = (message) => {
-	const createdAt = /* @__PURE__ */ new Date();
-	const closedId = getEventId(crypto.randomUUID(), "SessionState");
-	return [...message ? [{
-		createdAt,
-		id: getEventId(closedId, "HostError"),
-		message,
-		type: "HostError"
-	}] : [], {
-		createdAt,
-		id: closedId,
-		state: "Closed",
-		type: "SessionState"
-	}];
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/closeOpenSession.ts
-const closeOpenSession = (sessionId, openSession, message, { emit, onSessionsChange, openSessionMap }) => {
-	if (openSessionMap.get(sessionId) !== openSession) return;
-	for (const pendingPermission of openSession.pendingPermissionMap.values()) pendingPermission.settle("Deny", "");
-	emit(sessionId, toSessionClosedEvents(message));
-	openSessionMap.delete(sessionId);
-	onSessionsChange();
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/constants.ts
-const IGNORED_SDK_MESSAGE_TYPES = ["command_lifecycle"];
-const DEFAULT_DENY_MESSAGE = "The user denied this tool call.";
-const SETTING_SOURCES = [
-	"user",
-	"project",
-	"local"
-];
-const SESSION_LIST_LIMIT = 50;
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createInputQueue.ts
-const createInputQueue = () => {
-	let items = [];
-	let pendingReads = [];
-	let isClosed = false;
-	const next = () => {
-		const [item, ...restItems] = items;
-		if (item !== void 0) {
-			items = restItems;
-			return Promise.resolve({
-				done: false,
-				value: item
-			});
-		} else if (isClosed) return Promise.resolve({
-			done: true,
-			value: void 0
-		});
-		else return new Promise((resolve) => {
-			pendingReads = [...pendingReads, resolve];
-		});
-	};
-	return {
-		close: () => {
-			isClosed = true;
-			const closedReads = pendingReads;
-			pendingReads = [];
-			for (const closedRead of closedReads) closedRead({
-				done: true,
-				value: void 0
-			});
-		},
-		iterable: { [Symbol.asyncIterator]: () => ({ next }) },
-		push: (item) => {
-			const [pendingRead, ...restPendingReads] = pendingReads;
-			if (pendingRead) {
-				pendingReads = restPendingReads;
-				pendingRead({
-					done: false,
-					value: item
-				});
-			} else items = [...items, item];
-		}
-	};
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toPermissionRequestEvent.ts
-const toPermissionRequestEvent = (toolName, input, options, createdAt) => {
-	const requestId = options.requestId ?? crypto.randomUUID();
-	return {
-		blockedPath: options.blockedPath ?? "",
-		createdAt,
-		decisionReason: options.decisionReason ?? "",
-		hasSuggestions: Boolean(options.suggestions?.length),
-		id: requestId,
-		input,
-		requestId,
-		title: options.title ?? options.description ?? "",
-		toolName,
-		toolUseId: options.toolUseID ?? "",
-		type: "PermissionRequest"
-	};
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toPermissionResult.ts
-const toPermissionResult = (input, suggestions, behavior, message) => {
-	switch (behavior) {
-		case "Allow": return {
-			behavior: "allow",
-			updatedInput: input
-		};
-		case "AllowAlways": return {
-			behavior: "allow",
-			updatedInput: input,
-			updatedPermissions: suggestions
-		};
-		case "Deny": return {
-			behavior: "deny",
-			message: message || "The user denied this tool call."
-		};
-		default: return exhaustiveGuard(behavior);
-	}
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createPermissionBridge.ts
-const createPermissionBridge = (sessionId, pendingPermissionMap, emit) => (toolName, input, options) => new Promise((resolve) => {
-	const requestEvent = toPermissionRequestEvent(toolName, input, options, /* @__PURE__ */ new Date());
-	const { requestId } = requestEvent;
-	const resolutionId = getEventId(requestId, "PermissionResolution");
-	pendingPermissionMap.set(requestId, { settle: (behavior, message) => {
-		if (!pendingPermissionMap.delete(requestId)) return;
-		resolve(toPermissionResult(input, options.suggestions ?? [], behavior, message));
-		const createdAt = /* @__PURE__ */ new Date();
-		emit(sessionId, [{
-			behavior,
-			createdAt,
-			id: resolutionId,
-			requestId,
-			type: "PermissionResolution"
-		}, {
-			createdAt,
-			id: getEventId(resolutionId, "SessionState"),
-			state: "Running",
-			type: "SessionState"
-		}]);
-	} });
-	options.signal.addEventListener("abort", () => {
-		pendingPermissionMap.get(requestId)?.settle("Deny", "");
-	}, { once: true });
-	emit(sessionId, [requestEvent, {
-		createdAt: requestEvent.createdAt,
-		id: getEventId(requestId, "SessionState"),
-		state: "RequiresAction",
-		type: "SessionState"
-	}]);
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createFileOriginTracker.ts
-const fileEditResultSchema = z.object({
-	filePath: z.string().min(1),
-	originalFile: z.string().nullable(),
-	type: z.enum(["create", "update"]).optional()
-});
-const createFileOriginTracker = () => {
-	const changedFilePaths = /* @__PURE__ */ new Set();
-	return { readToolResult: (event, toolUseResult) => {
-		const fileEditResult = fileEditResultSchema.safeParse(toolUseResult);
-		if (event.isError || !fileEditResult.success) return event;
-		const { filePath, originalFile, type } = fileEditResult.data;
-		if (changedFilePaths.has(filePath)) return event;
-		changedFilePaths.add(filePath);
-		const originalText = originalFile ?? (type === "create" ? "" : void 0);
-		return originalText === void 0 ? event : {
-			...event,
-			originalText
-		};
-	} };
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createStreamTracker.ts
-const toTurnUsageEvent = (id, createdAt, outputTokens) => ({
-	createdAt,
-	id,
-	outputTokens,
-	type: "TurnUsage"
-});
-const createStreamTracker = () => {
-	let messageId = "";
-	let finishedOutputTokens = 0;
-	return {
-		readStreamEvent: ({ event, parent_tool_use_id, uuid }, createdAt) => {
-			if (parent_tool_use_id) return [];
-			switch (event.type) {
-				case "content_block_delta":
-					if (event.delta.type !== "text_delta" && event.delta.type !== "thinking_delta") return [];
-					return [{
-						blockId: getEventId(messageId, event.index),
-						createdAt,
-						id: uuid,
-						isThinking: event.delta.type === "thinking_delta",
-						text: event.delta.type === "text_delta" ? event.delta.text : event.delta.thinking,
-						type: "StreamDelta"
-					}];
-				case "message_delta":
-					finishedOutputTokens += event.usage.output_tokens;
-					return [toTurnUsageEvent(uuid, createdAt, finishedOutputTokens)];
-				case "message_start":
-					({id: messageId} = event.message);
-					return [];
-				default: return [];
-			}
-		},
-		readThinkingTokens: ({ estimated_tokens, uuid }, createdAt) => [toTurnUsageEvent(uuid, createdAt, finishedOutputTokens + estimated_tokens)],
-		reset: () => {
-			finishedOutputTokens = 0;
-		}
-	};
-};
-//#endregion
-//#region src/models/claudeAgentSdk/TodoToolName.ts
-let TodoToolName = /* @__PURE__ */ function(TodoToolName) {
-	TodoToolName["TaskCreate"] = "TaskCreate";
-	TodoToolName["TaskUpdate"] = "TaskUpdate";
-	TodoToolName["TodoWrite"] = "TodoWrite";
-	return TodoToolName;
-}({});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createTodoTracker.ts
-const todoWriteInputSchema = z.object({ todos: z.object({
-	activeForm: z.string(),
-	content: z.string(),
-	status: todoStatusSchema
-}).array() });
-const taskCreateInputSchema = z.object({
-	activeForm: z.string().optional(),
-	subject: z.string()
-});
-const taskCreateResultSchema = z.object({ task: z.object({ id: z.string().min(1) }) });
-const taskUpdateInputSchema = z.object({
-	activeForm: z.string().optional(),
-	status: z.union([todoStatusSchema, z.literal("deleted")]).optional(),
-	subject: z.string().optional(),
-	taskId: z.string().min(1)
-});
-const createTodoTracker = () => {
-	let todos = [];
-	const pendingTodoMap = /* @__PURE__ */ new Map();
-	const toTodoUpdateEvent = (sourceId, createdAt) => ({
-		createdAt,
-		id: getEventId(sourceId, "TodoUpdate"),
-		todos,
-		type: "TodoUpdate"
-	});
-	return {
-		readToolResult: (event, toolUseResult) => {
-			const pendingTodo = pendingTodoMap.get(event.toolUseId);
-			if (!pendingTodo) return void 0;
-			pendingTodoMap.delete(event.toolUseId);
-			const taskCreateResult = taskCreateResultSchema.safeParse(toolUseResult);
-			if (!taskCreateResult.success || event.isError) return void 0;
-			todos = [...todos, {
-				...pendingTodo,
-				id: taskCreateResult.data.task.id
-			}];
-			return toTodoUpdateEvent(event.id, event.createdAt);
-		},
-		readToolUse: (event) => {
-			if (event.parentToolUseId) return void 0;
-			switch (event.name) {
-				case "TaskCreate": {
-					const input = taskCreateInputSchema.safeParse(event.input);
-					if (!input.success) return void 0;
-					const { activeForm, subject } = input.data;
-					pendingTodoMap.set(event.toolUseId, {
-						activeForm: activeForm ?? subject,
-						content: subject,
-						status: "pending"
-					});
-					return;
-				}
-				case "TaskUpdate": {
-					const input = taskUpdateInputSchema.safeParse(event.input);
-					if (!input.success) return void 0;
-					const { activeForm, status, subject, taskId } = input.data;
-					todos = status === "deleted" ? todos.filter(({ id }) => id !== taskId) : todos.map((todo) => todo.id === taskId ? {
-						activeForm: activeForm ?? todo.activeForm,
-						content: subject ?? todo.content,
-						id: todo.id,
-						status: status ?? todo.status
-					} : todo);
-					return toTodoUpdateEvent(event.id, event.createdAt);
-				}
-				case "TodoWrite": {
-					const input = todoWriteInputSchema.safeParse(event.input);
-					if (!input.success) return void 0;
-					todos = input.data.todos.map(({ activeForm, content, status }, index) => ({
-						activeForm,
-						content,
-						id: String(index),
-						status
-					}));
-					return toTodoUpdateEvent(event.id, event.createdAt);
-				}
-				default: return;
-			}
-		}
-	};
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toUnknownEvent.ts
-const toUnknownEvent = (id, sdkType, raw, createdAt) => ({
-	createdAt,
-	id,
-	raw,
-	sdkType,
-	type: "Unknown"
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/mapAssistantContent.ts
-const mapAssistantContent = (content, context) => content.map((block, index) => {
-	const id = getEventId(context.messageUuid, index);
-	switch (block.type) {
-		case "document":
-		case "image":
-		case "tool_result": return toUnknownEvent(id, block.type, JSON.stringify(block), context.createdAt);
-		case "other": return toUnknownEvent(id, block.blockType, block.raw, context.createdAt);
-		case "text": return {
-			...context,
-			id,
-			text: block.text,
-			type: "AssistantMessage"
-		};
-		case "thinking": return {
-			...context,
-			id,
-			thinking: block.thinking,
-			type: "Thinking"
-		};
-		case "tool_use": return {
-			...context,
-			id,
-			input: block.input,
-			name: block.name,
-			toolUseId: block.id,
-			type: "ToolUse"
-		};
-		default: return exhaustiveGuard(block);
-	}
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/mapHookMessage.ts
-const HookPhaseMap = {
-	hook_progress: "Progress",
-	hook_response: "Response",
-	hook_started: "Started"
-};
-const mapHookMessage = (message, createdAt) => ({
-	createdAt,
-	exitCode: "exit_code" in message ? message.exit_code ?? 0 : 0,
-	hookEvent: message.hook_event,
-	hookId: message.hook_id,
-	hookName: message.hook_name,
-	id: message.uuid,
-	outcome: "outcome" in message ? message.outcome : "",
-	output: "output" in message ? message.output : "",
-	phase: HookPhaseMap[message.subtype],
-	stderr: "stderr" in message ? message.stderr : "",
-	stdout: "stdout" in message ? message.stdout : "",
-	type: "Hook"
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/mapTaskMessage.ts
-const SubagentStatusMap = {
-	completed: "Completed",
-	failed: "Failed",
-	killed: "Stopped",
-	paused: "Running",
-	pending: "Started",
-	running: "Running",
-	stopped: "Stopped"
-};
-const mapTaskMessage = (message, createdAt) => {
-	const base = {
-		createdAt,
-		description: "",
-		durationMs: 0,
-		id: message.uuid,
-		lastToolName: "",
-		subagentType: "",
-		summary: "",
-		taskId: message.task_id,
-		toolUseId: "tool_use_id" in message ? message.tool_use_id ?? "" : "",
-		toolUses: 0,
-		totalTokens: 0,
-		type: "Subagent"
-	};
-	switch (message.subtype) {
-		case "task_notification": return {
-			...base,
-			durationMs: message.usage?.duration_ms ?? 0,
-			status: SubagentStatusMap[message.status],
-			summary: message.summary,
-			toolUses: message.usage?.tool_uses ?? 0,
-			totalTokens: message.usage?.total_tokens ?? 0
-		};
-		case "task_progress": return {
-			...base,
-			description: message.description,
-			durationMs: message.usage.duration_ms,
-			lastToolName: message.last_tool_name ?? "",
-			status: "Running",
-			subagentType: message.subagent_type ?? "",
-			summary: message.summary ?? "",
-			toolUses: message.usage.tool_uses,
-			totalTokens: message.usage.total_tokens
-		};
-		case "task_started": return {
-			...base,
-			description: message.description,
-			status: "Started",
-			subagentType: message.subagent_type ?? ""
-		};
-		case "task_updated": return {
-			...base,
-			description: message.patch.description ?? "",
-			status: message.patch.status ? SubagentStatusMap[message.patch.status] : "Running",
-			summary: message.patch.error ?? ""
-		};
-		default: return exhaustiveGuard(message);
-	}
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/mapSystemMessage.ts
-const SessionStateMap = {
-	idle: "Idle",
-	requires_action: "RequiresAction",
-	running: "Running"
-};
-const mapSystemMessage = (message, createdAt) => {
-	switch (message.subtype) {
-		case "compact_boundary": return [{
-			createdAt,
-			id: message.uuid,
-			postTokens: message.compact_metadata.post_tokens ?? 0,
-			preTokens: message.compact_metadata.pre_tokens,
-			trigger: message.compact_metadata.trigger === "auto" ? "auto" : "manual",
-			type: "Compaction"
-		}];
-		case "hook_progress":
-		case "hook_response":
-		case "hook_started": return [mapHookMessage(message, createdAt)];
-		case "local_command_output": return [{
-			content: message.content,
-			createdAt,
-			id: message.uuid,
-			type: "CommandOutput"
-		}];
-		case "session_state_changed": return [{
-			createdAt,
-			id: message.uuid,
-			state: SessionStateMap[message.state],
-			type: "SessionState"
-		}];
-		case "task_notification":
-		case "task_progress":
-		case "task_started":
-		case "task_updated": return [mapTaskMessage(message, createdAt)];
-		default: return [toUnknownEvent(message.uuid, `system:${message.subtype}`, JSON.stringify(message), createdAt)];
-	}
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toToolResultText.ts
-const toToolResultText = (content) => typeof content === "string" ? content : content.map((part) => part.text === void 0 ? `[${part.type}]` : part.text).join("\n");
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/mapUserContent.ts
-const mapUserContent = (content, context) => {
-	if (typeof content === "string") return [{
-		...context,
-		attachmentCount: 0,
-		id: context.messageUuid,
-		text: content,
-		type: "UserMessage"
-	}];
-	const events = [];
-	const texts = [];
-	let attachmentCount = 0;
-	for (const [index, block] of content.entries()) {
-		const id = getEventId(context.messageUuid, index);
-		switch (block.type) {
-			case "document":
-			case "image":
-				attachmentCount++;
-				break;
-			case "other":
-				events.push(toUnknownEvent(id, block.blockType, block.raw, context.createdAt));
-				break;
-			case "text":
-				texts.push(block.text);
-				break;
-			case "thinking":
-			case "tool_use":
-				events.push(toUnknownEvent(id, block.type, JSON.stringify(block), context.createdAt));
-				break;
-			case "tool_result":
-				events.push({
-					content: toToolResultText(block.content),
-					createdAt: context.createdAt,
-					id,
-					isError: Boolean(block.is_error),
-					parentToolUseId: context.parentToolUseId,
-					toolUseId: block.tool_use_id,
-					type: "ToolResult"
-				});
-				break;
-			default: exhaustiveGuard(block);
-		}
-	}
-	return texts.length > 0 || attachmentCount > 0 ? [{
-		...context,
-		attachmentCount,
-		id: context.messageUuid,
-		text: texts.join("\n\n"),
-		type: "UserMessage"
-	}, ...events] : events;
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/parseMessageBody.ts
-const documentBlockSchema = z.object({ type: z.literal("document") });
-const imageBlockSchema = z.object({ type: z.literal("image") });
-const textBlockSchema = z.object({
-	text: z.string(),
-	type: z.literal("text")
-});
-const thinkingBlockSchema = z.object({
-	thinking: z.string(),
-	type: z.literal("thinking")
-});
-const toolResultBlockSchema = z.object({
-	content: z.union([z.string(), z.looseObject({
-		text: z.string().optional(),
-		type: z.string()
-	}).array()]),
-	is_error: z.boolean().optional(),
-	tool_use_id: z.string().min(1),
-	type: z.literal("tool_result")
-});
-const toolUseBlockSchema = z.object({
-	id: z.string().min(1),
-	input: z.record(z.string(), z.unknown()),
-	name: z.string().min(1),
-	type: z.literal("tool_use")
-});
-const otherBlockSchema = z.looseObject({ type: z.string() }).transform((block) => ({
-	blockType: block.type,
-	raw: JSON.stringify(block),
-	type: "other"
-}));
-const contentBlockSchema = z.union([
-	documentBlockSchema,
-	imageBlockSchema,
-	textBlockSchema,
-	thinkingBlockSchema,
-	toolResultBlockSchema,
-	toolUseBlockSchema,
-	otherBlockSchema
-]);
-const messageBodySchema = z.looseObject({ content: z.union([contentBlockSchema.array(), z.string()]) });
-const parseMessageBody = (value) => {
-	const result = messageBodySchema.safeParse(value);
-	return result.success ? result.data : void 0;
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toSessionInitEvent.ts
-const toSessionInitEvent = (message, permissionMode, createdAt) => ({
-	agents: [...new Set(message.agents)],
-	claudeCodeVersion: message.claude_code_version,
-	createdAt,
-	cwd: message.cwd,
-	id: message.uuid,
-	mcpServers: [...new Map(message.mcp_servers.map(({ name, status }) => [name, {
-		name,
-		status
-	}])).values()],
-	model: message.model,
-	outputStyle: message.output_style,
-	permissionMode,
-	plugins: [...new Set(message.plugins.map(({ name }) => name))],
-	skills: [...new Set(message.skills)],
-	slashCommands: [...new Set(message.slash_commands)],
-	tools: [...new Set(message.tools)],
-	type: "SessionInit"
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toTurnResultEvents.ts
-const toTurnResultEvents = (message, createdAt) => [{
-	createdAt,
-	durationApiMs: message.duration_api_ms,
-	durationMs: message.duration_ms,
-	errors: message.subtype === "success" ? [] : message.errors,
-	id: message.uuid,
-	isError: message.is_error,
-	numTurns: message.num_turns,
-	result: message.subtype === "success" ? message.result : "",
-	subtype: message.subtype,
-	totalCostUsd: message.total_cost_usd,
-	type: "TurnResult",
-	usage: {
-		cacheCreationInputTokens: message.usage.cache_creation_input_tokens,
-		cacheReadInputTokens: message.usage.cache_read_input_tokens,
-		inputTokens: message.usage.input_tokens,
-		outputTokens: message.usage.output_tokens
-	}
-}, {
-	createdAt,
-	id: getEventId(message.uuid, "SessionState"),
-	state: "Idle",
-	type: "SessionState"
-}];
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createSdkMessageMapper.ts
-const createSdkMessageMapper = () => {
-	const fileOriginTracker = createFileOriginTracker();
-	const streamTracker = createStreamTracker();
-	const todoTracker = createTodoTracker();
-	const settings = {
-		model: "",
-		permissionMode: "default"
-	};
-	let isCompacting = false;
-	const updateSettings = (id, createdAt, { model, permissionMode }) => {
-		if (model) settings.model = model;
-		const parsedPermissionMode = permissionModeSchema.safeParse(permissionMode);
-		if (parsedPermissionMode.success) settings.permissionMode = parsedPermissionMode.data;
-		return {
-			createdAt,
-			id,
-			...settings,
-			type: "SessionSettings"
-		};
-	};
-	const mapContent = ({ body, error, messageType, messageUuid, parentToolUseId, toolUseResult }, createdAt) => {
-		const messageBody = parseMessageBody(body);
-		if (!messageBody) return [toUnknownEvent(messageUuid, messageType, JSON.stringify(body), createdAt)];
-		const context = {
-			createdAt,
-			messageUuid,
-			parentToolUseId
-		};
-		const { content } = messageBody;
-		const contentEvents = messageType === "assistant" ? mapAssistantContent(typeof content === "string" ? [{
-			text: content,
-			type: "text"
-		}] : content, context) : mapUserContent(content, context);
-		const events = [];
-		for (const event of contentEvents) if (event.type === "ToolUse") {
-			events.push(event);
-			const todoUpdateEvent = todoTracker.readToolUse(event);
-			if (todoUpdateEvent) events.push(todoUpdateEvent);
-		} else if (event.type === "ToolResult") {
-			events.push(fileOriginTracker.readToolResult(event, toolUseResult));
-			const todoUpdateEvent = todoTracker.readToolResult(event, toolUseResult);
-			if (todoUpdateEvent) events.push(todoUpdateEvent);
-		} else events.push(event);
-		if (error) events.push({
-			createdAt,
-			id: getEventId(messageUuid, "HostError"),
-			message: error,
-			type: "HostError"
-		});
-		return events;
-	};
-	const mapMessage = (message, createdAt) => {
-		const sdkType = message.type;
-		if (IGNORED_SDK_MESSAGE_TYPES.includes(sdkType)) return [];
-		switch (message.type) {
-			case "assistant": return mapContent({
-				body: message.message,
-				error: message.error ?? "",
-				messageType: message.type,
-				messageUuid: message.uuid,
-				parentToolUseId: message.parent_tool_use_id ?? "",
-				toolUseResult: void 0
-			}, createdAt);
-			case "rate_limit_event": {
-				const { rateLimitType, resetsAt, status, utilization } = message.rate_limit_info;
-				return [{
-					createdAt,
-					id: message.uuid,
-					rateLimitType: rateLimitType ?? "",
-					resetsAt: resetsAt === void 0 ? void 0 : new Date(Temporal.Duration.from({ seconds: resetsAt }).total("milliseconds")),
-					status,
-					type: "RateLimit",
-					utilization
-				}];
-			}
-			case "result":
-				streamTracker.reset();
-				return toTurnResultEvents(message, createdAt);
-			case "stream_event": return streamTracker.readStreamEvent(message, createdAt);
-			case "tool_progress": return [{
-				createdAt,
-				elapsedSeconds: message.elapsed_time_seconds,
-				id: message.uuid,
-				parentToolUseId: message.parent_tool_use_id ?? "",
-				toolUseId: message.tool_use_id,
-				type: "ToolProgress"
-			}];
-			case "user": return mapContent({
-				body: message.message,
-				error: "",
-				messageType: message.type,
-				messageUuid: message.uuid ?? crypto.randomUUID(),
-				parentToolUseId: message.parent_tool_use_id ?? "",
-				toolUseResult: message.tool_use_result
-			}, createdAt);
-			case "system": if (message.subtype === "init") {
-				const settingsEvent = updateSettings(getEventId(message.uuid, "SessionSettings"), createdAt, {
-					model: message.model,
-					permissionMode: message.permissionMode
-				});
-				return [toSessionInitEvent(message, settingsEvent.permissionMode, createdAt), settingsEvent];
-			} else if (message.subtype === "status") {
-				const wasCompacting = isCompacting;
-				isCompacting = message.status === "compacting";
-				const events = [];
-				if (isCompacting !== wasCompacting) events.push({
-					createdAt,
-					id: message.uuid,
-					state: isCompacting ? "Compacting" : "Running",
-					type: "SessionState"
-				});
-				if (message.permissionMode) events.push(updateSettings(getEventId(message.uuid, "SessionSettings"), createdAt, { permissionMode: message.permissionMode }));
-				return events;
-			} else if (message.subtype === "thinking_tokens") return streamTracker.readThinkingTokens(message, createdAt);
-			else return mapSystemMessage(message, createdAt);
-			default: return [toUnknownEvent(message.uuid, message.type, JSON.stringify(message), createdAt)];
-		}
-	};
-	return {
-		mapHistory: ({ message, parent_tool_use_id, type, uuid }, createdAt, toolUseResult) => type === "system" ? [toUnknownEvent(uuid, type, JSON.stringify(message), createdAt)] : mapContent({
-			body: message,
-			error: "",
-			messageType: type,
-			messageUuid: uuid,
-			parentToolUseId: parent_tool_use_id ?? "",
-			toolUseResult
-		}, createdAt),
-		mapMessage,
-		updateSettings
-	};
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/readSessionHistory.ts
-const readSessionHistory = async (sessionId, cwd, resumeAt) => {
-	const sessionMessages = await getSessionMessages(sessionId, { dir: cwd });
-	if (!resumeAt) return sessionMessages;
-	const resumeAtIndex = sessionMessages.findIndex(({ uuid }) => uuid === resumeAt);
-	if (resumeAtIndex === -1) throw new InvalidOperationError(Operation.Read, sessionId, `the transcript holds no message ${resumeAt}`);
-	return sessionMessages.slice(0, resumeAtIndex + 1);
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/readToolUseResultMap.ts
-const transcriptEntrySchema = z.object({
-	toolUseResult: z.unknown(),
-	uuid: z.string()
-});
-const readToolUseResultMap = async (sessionId) => {
-	const toolUseResultMap = /* @__PURE__ */ new Map();
-	const projectsDirectory = join(process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects");
-	if (!existsSync(projectsDirectory)) return toolUseResultMap;
-	const transcriptPath = (await readdir(projectsDirectory)).map((projectDirectory) => join(projectsDirectory, projectDirectory, `${sessionId}.jsonl`)).find((path) => existsSync(path));
-	if (!transcriptPath) return toolUseResultMap;
-	for (const line of (await readFile(transcriptPath, "utf8")).split("\n")) getResult(() => transcriptEntrySchema.parse(JSON.parse(line))).match(({ toolUseResult, uuid }) => {
-		if (toolUseResult !== void 0) toolUseResultMap.set(uuid, toolUseResult);
-	}, noop);
-	return toolUseResultMap;
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/getSessionTitle.ts
-const getSessionTitle = ({ customTitle, firstPrompt, summary }) => customTitle || summary || firstPrompt || "";
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toCapabilitiesEvent.ts
-const toCapabilitiesEvent = (id, slashCommands, models, createdAt) => ({
-	commands: [...new Map(slashCommands.map(({ argumentHint, description, name }) => [name, {
-		argumentHint,
-		description,
-		name
-	}])).values()],
-	createdAt,
-	id,
-	models: [...new Map(models.map(({ description, displayName, value }) => [value, {
-		description,
-		displayName,
-		value
-	}])).values()],
-	type: "Capabilities"
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toContextUsageEvent.ts
-const toContextUsageEvent = (id, { autoCompactThreshold, isAutoCompactEnabled, maxTokens, percentage, totalTokens }, createdAt) => ({
-	autoCompactThreshold: autoCompactThreshold ?? 0,
-	createdAt,
-	id,
-	isAutoCompactEnabled,
-	maxTokens,
-	percentage,
-	totalTokens,
-	type: "ContextUsage"
-});
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/watchSession.ts
-const watchSession = async (sessionId, openSession, { emit, onSessionsChange, openSessionMap }) => {
-	const { cwd, mapper, query } = openSession;
-	const readContextUsage = () => getResultAsync(() => query.getContextUsage()).match((contextUsage) => {
-		emit(sessionId, [toContextUsageEvent(crypto.randomUUID(), contextUsage, /* @__PURE__ */ new Date())]);
-	}, console.error);
-	const readTitle = () => getResultAsync(() => getSessionInfo(sessionId, { dir: cwd })).match((sessionInfo) => {
-		if (!sessionInfo) return;
-		openSession.title = getSessionTitle(sessionInfo) || openSession.title;
-		onSessionsChange();
-	}, console.error);
-	await Promise.all([
-		getResultAsync(() => Promise.all([query.supportedCommands(), query.supportedModels()])).match(([slashCommands, models]) => {
-			emit(sessionId, [toCapabilitiesEvent(crypto.randomUUID(), slashCommands, models, /* @__PURE__ */ new Date())]);
-		}, console.error),
-		readContextUsage(),
-		getResultAsync(async () => {
-			for await (const message of query) {
-				emit(sessionId, mapper.mapMessage(message, /* @__PURE__ */ new Date()));
-				if (message.type === "result") await Promise.all([readContextUsage(), readTitle()]);
-			}
-		}).match(() => {
-			closeOpenSession(sessionId, openSession, "", {
-				emit,
-				onSessionsChange,
-				openSessionMap
-			});
-		}, (error) => {
-			closeOpenSession(sessionId, openSession, error.message, {
-				emit,
-				onSessionsChange,
-				openSessionMap
-			});
-		})
-	]);
-};
-//#endregion
-//#region src/services/installer/getClaudeCodeExecutablePath.ts
-const getClaudeCodeExecutablePath = () => isSea() ? join(getHostInstallDirectory(), CLAUDE_CODE_EXECUTABLE_FILENAME) : void 0;
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createSessionOpener.ts
-const createSessionOpener = ({ emit, onSessionOpen, onSessionsChange, openSessionMap, taskRegistry }) => async ({ cwd, isFork, resumeAt, resumeFrom, sessionId }) => {
-	const mapper = createSdkMessageMapper();
-	const history = resumeFrom ? await readSessionHistory(resumeFrom, cwd, resumeAt) : [];
-	const toolUseResultMap = resumeFrom ? await readToolUseResultMap(resumeFrom) : /* @__PURE__ */ new Map();
-	const input = createInputQueue();
-	const pendingPermissionMap = /* @__PURE__ */ new Map();
-	const claudeCodeExecutablePath = getClaudeCodeExecutablePath();
-	const sessionQuery = query({
-		options: {
-			allowDangerouslySkipPermissions: true,
-			canUseTool: createPermissionBridge(sessionId, pendingPermissionMap, emit),
-			cwd,
-			enableFileCheckpointing: true,
-			env: {
-				...process.env,
-				CLAUDE_CODE_ENABLE_TODO_TOOLS: "true"
-			},
-			includeHookEvents: true,
-			includePartialMessages: true,
-			...claudeCodeExecutablePath ? { pathToClaudeCodeExecutable: claudeCodeExecutablePath } : {},
-			settingSources: SETTING_SOURCES,
-			systemPrompt: {
-				preset: "claude_code",
-				type: "preset"
-			},
-			thinking: {
-				display: "summarized",
-				type: "adaptive"
-			},
-			...resumeFrom ? { resume: resumeFrom } : {},
-			...resumeAt ? { resumeSessionAt: resumeAt } : {},
-			...!resumeFrom || isFork ? {
-				forkSession: isFork,
-				sessionId
-			} : {}
-		},
-		prompt: input.iterable
-	});
-	const openSession = {
-		cwd,
-		input,
-		lastActivityAt: /* @__PURE__ */ new Date(),
-		mapper,
-		pendingPermissionMap,
-		query: sessionQuery,
-		state: "Idle",
-		title: ""
-	};
-	onSessionOpen(sessionId);
-	openSessionMap.set(sessionId, openSession);
-	const createdAt = /* @__PURE__ */ new Date();
-	emit(sessionId, [...history.flatMap((sessionMessage) => mapper.mapHistory(sessionMessage, createdAt, toolUseResultMap.get(sessionMessage.uuid))), {
-		createdAt,
-		id: getEventId(crypto.randomUUID(), "SessionState"),
-		state: "Idle",
-		type: "SessionState"
-	}]);
-	onSessionsChange();
-	taskRegistry.run(() => watchSession(sessionId, openSession, {
-		emit,
-		onSessionsChange,
-		openSessionMap
-	}));
-	return sessionId;
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/listSessionSummaries.ts
-const listSessionSummaries = async (openSessionMap) => {
-	const sessionInfos = await listSessions({ limit: 50 });
-	const savedSessionIds = new Set(sessionInfos.map(({ sessionId }) => sessionId));
-	const unsavedSessions = [...openSessionMap].filter(([id]) => !savedSessionIds.has(id)).map(([id, { cwd, lastActivityAt, state, title }]) => ({
-		cwd,
-		id,
-		lastActivityAt,
-		state,
-		title
-	}));
-	const savedSessions = sessionInfos.map((sessionInfo) => {
-		const openSession = openSessionMap.get(sessionInfo.sessionId);
-		return {
-			cwd: sessionInfo.cwd ?? "",
-			id: sessionInfo.sessionId,
-			lastActivityAt: openSession?.lastActivityAt ?? new Date(sessionInfo.lastModified),
-			state: openSession?.state ?? "Closed",
-			title: openSession?.title || getSessionTitle(sessionInfo)
-		};
-	});
-	return [...unsavedSessions, ...savedSessions];
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/readSessionCwd.ts
-const readSessionCwd = async (sessionId) => {
-	const sessionInfo = await getSessionInfo(sessionId);
-	if (!sessionInfo?.cwd) throw new InvalidOperationError(Operation.Read, sessionId, "no session with this id on disk");
-	return sessionInfo.cwd;
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/toContentBlockParam.ts
-const toContentBlockParam = ({ data, mediaType, name }) => {
-	switch (mediaType) {
-		case "image/gif":
-		case "image/jpeg":
-		case "image/png":
-		case "image/webp": return {
-			source: {
-				data,
-				media_type: mediaType,
-				type: "base64"
-			},
-			type: "image"
-		};
-		case "application/pdf": return {
-			source: {
-				data,
-				media_type: mediaType,
-				type: "base64"
-			},
-			title: name,
-			type: "document"
-		};
-		case "text/plain": return {
-			source: {
-				data,
-				media_type: mediaType,
-				type: "text"
-			},
-			title: name,
-			type: "document"
-		};
-		default: return exhaustiveGuard(mediaType);
-	}
-};
-//#endregion
-//#region src/services/shared/createTaskRegistry.ts
-const createTaskRegistry = () => {
-	const pendingSet = /* @__PURE__ */ new Set();
-	return {
-		drain: async () => {
-			await Promise.all(pendingSet);
-		},
-		run: (task) => {
-			const pending = task().finally(() => {
-				pendingSet.delete(pending);
-			});
-			pendingSet.add(pending);
-		}
-	};
-};
-//#endregion
-//#region src/services/drivers/claudeAgentSdk/createClaudeAgentSdkDriver.ts
-const createClaudeAgentSdkDriver = ({ onEvents, onSessionOpen, onSessionsChange }) => {
-	const openSessionMap = /* @__PURE__ */ new Map();
-	const taskRegistry = createTaskRegistry();
-	const emit = (sessionId, events) => {
-		const openSession = openSessionMap.get(sessionId);
-		let isStateChanged = false;
-		if (openSession) {
-			openSession.lastActivityAt = /* @__PURE__ */ new Date();
-			for (const event of events) if (event.type === "SessionState" && event.state !== openSession.state) {
-				openSession.state = event.state;
-				isStateChanged = true;
-			}
-		}
-		onEvents(sessionId, events);
-		if (isStateChanged) onSessionsChange();
-	};
-	const getOpenSession = (sessionId) => {
-		const openSession = openSessionMap.get(sessionId);
-		if (!openSession) throw new InvalidOperationError(Operation.Read, sessionId, "the session is not open on this host");
-		return openSession;
-	};
-	const openSessionQuery = createSessionOpener({
-		emit,
-		onSessionOpen,
-		onSessionsChange,
-		openSessionMap,
-		taskRegistry
-	});
-	const closeSession = (sessionId) => {
-		const closingSession = getOpenSession(sessionId);
-		closeOpenSession(sessionId, closingSession, "", {
-			emit,
-			onSessionsChange,
-			openSessionMap
-		});
-		closingSession.input.close();
-		closingSession.query.close();
-	};
-	const prompt = (sessionId, text, attachments) => {
-		const openSession = getOpenSession(sessionId);
-		const uuid = crypto.randomUUID();
-		const createdAt = /* @__PURE__ */ new Date();
-		openSession.input.push({
-			message: {
-				content: [...attachments.map((attachment) => toContentBlockParam(attachment)), {
-					text,
-					type: "text"
-				}],
-				role: "user"
-			},
-			parent_tool_use_id: null,
-			type: "user",
-			uuid
-		});
-		openSession.title ||= text;
-		emit(sessionId, [{
-			attachmentCount: attachments.length,
-			createdAt,
-			id: uuid,
-			messageUuid: uuid,
-			parentToolUseId: "",
-			text,
-			type: "UserMessage"
-		}, {
-			createdAt,
-			id: getEventId(uuid, "SessionState"),
-			state: "Running",
-			type: "SessionState"
-		}]);
-	};
-	const resumeSession = async (sessionId) => {
-		if (openSessionMap.has(sessionId)) return sessionId;
-		const cwd = await readSessionCwd(sessionId);
-		return openSessionQuery({
-			cwd,
-			isFork: false,
-			resumeAt: "",
-			resumeFrom: sessionId,
-			sessionId
-		});
-	};
-	return {
-		backgroundTasks: async (sessionId) => {
-			await getOpenSession(sessionId).query.backgroundTasks();
-		},
-		close: async () => {
-			for (const sessionId of openSessionMap.keys()) closeSession(sessionId);
-			await taskRegistry.drain();
-		},
-		closeSession,
-		createSession: (cwd) => openSessionQuery({
-			cwd,
-			isFork: false,
-			resumeAt: "",
-			resumeFrom: "",
-			sessionId: crypto.randomUUID()
-		}),
-		forkSession: async (sessionId, messageUuid) => {
-			const cwd = await readSessionCwd(sessionId);
-			return openSessionQuery({
-				cwd,
-				isFork: true,
-				resumeAt: messageUuid,
-				resumeFrom: sessionId,
-				sessionId: crypto.randomUUID()
-			});
-		},
-		interrupt: async (sessionId) => {
-			await getOpenSession(sessionId).query.interrupt();
-		},
-		listSessions: () => listSessionSummaries(openSessionMap),
-		prompt,
-		resolvePermission: (sessionId, requestId, behavior, message) => {
-			getOpenSession(sessionId).pendingPermissionMap.get(requestId)?.settle(behavior, message);
-		},
-		resumeAt: async (sessionId, messageUuid) => {
-			const cwd = await readSessionCwd(sessionId);
-			if (openSessionMap.has(sessionId)) closeSession(sessionId);
-			return openSessionQuery({
-				cwd,
-				isFork: false,
-				resumeAt: messageUuid,
-				resumeFrom: sessionId,
-				sessionId
-			});
-		},
-		resumeSession,
-		rewindFiles: async (sessionId, messageUuid) => {
-			await resumeSession(sessionId);
-			const { query } = getOpenSession(sessionId);
-			const { canRewind, deletions, error, filesChanged, insertions } = await query.rewindFiles(messageUuid, { dryRun: true });
-			if (!canRewind) throw new InvalidOperationError(Operation.Update, sessionId, error ?? "nothing to rewind");
-			const rewindResult = await query.rewindFiles(messageUuid);
-			if (rewindResult.error) throw new InvalidOperationError(Operation.Update, sessionId, rewindResult.error);
-			emit(sessionId, [{
-				createdAt: /* @__PURE__ */ new Date(),
-				deletions: deletions ?? 0,
-				filePaths: filesChanged ?? [],
-				id: crypto.randomUUID(),
-				insertions: insertions ?? 0,
-				messageUuid,
-				type: "FileRewind"
-			}]);
-		},
-		runSlashCommand: (sessionId, name, commandArguments) => {
-			prompt(sessionId, commandArguments ? `/${name} ${commandArguments}` : `/${name}`, []);
-		},
-		setModel: async (sessionId, model) => {
-			const { mapper, query } = getOpenSession(sessionId);
-			await query.setModel(model);
-			emit(sessionId, [mapper.updateSettings(crypto.randomUUID(), /* @__PURE__ */ new Date(), { model })]);
-		},
-		setPermissionMode: async (sessionId, permissionMode) => {
-			const { mapper, query } = getOpenSession(sessionId);
-			await query.setPermissionMode(permissionMode);
-			emit(sessionId, [mapper.updateSettings(crypto.randomUUID(), /* @__PURE__ */ new Date(), { permissionMode })]);
-		},
-		stopTask: async (sessionId, taskId) => {
-			await getOpenSession(sessionId).query.stopTask(taskId);
-		}
-	};
-};
-//#endregion
-//#region src/models/window/BaseChildMessage.ts
-const createBaseChildMessageSchema = (typeSchema) => z.object({ type: typeSchema });
-//#endregion
-//#region src/models/window/ChildMessageType.ts
-let ChildMessageType = /* @__PURE__ */ function(ChildMessageType) {
-	ChildMessageType["CommandError"] = "CommandError";
-	ChildMessageType["CommandResult"] = "CommandResult";
-	ChildMessageType["Events"] = "Events";
-	ChildMessageType["Rejoin"] = "Rejoin";
-	ChildMessageType["SessionOpen"] = "SessionOpen";
-	ChildMessageType["SessionsChange"] = "SessionsChange";
-	return ChildMessageType;
-}({});
-const childMessageTypeSchema = z.enum(ChildMessageType);
-//#endregion
-//#region src/models/window/ChildCommandErrorMessage.ts
-const childCommandErrorMessageSchema = z.object({
-	...createBaseChildMessageSchema(z.literal("CommandError")).shape,
-	commandId: z.string(),
-	message: z.string().min(1)
-});
-//#endregion
-//#region src/models/window/ChildCommandResultMessage.ts
-const childCommandResultMessageSchema = z.object({
-	...createBaseChildMessageSchema(z.literal("CommandResult")).shape,
-	commandId: z.string().min(1),
-	sessionId: z.string()
-});
-//#endregion
-//#region src/models/window/ChildEventsMessage.ts
-const childEventsMessageSchema = z.object({
-	...createBaseChildMessageSchema(z.literal("Events")).shape,
-	events: createUniqueArraySchema(agentEventSchema, "id"),
-	sessionId: z.string().min(1)
-});
-//#endregion
-//#region src/models/window/RejoiningSession.ts
-const rejoiningSessionSchema = z.object({
-	events: createUniqueArraySchema(agentEventSchema, "id"),
-	sessionId: z.string().min(1)
-});
-//#endregion
-//#region src/models/window/ChildRejoinMessage.ts
-const childRejoinMessageSchema = z.object({
-	...createBaseChildMessageSchema(z.literal("Rejoin")).shape,
-	sessions: createUniqueArraySchema(rejoiningSessionSchema, "sessionId")
-});
-//#endregion
-//#region src/models/window/ChildSessionOpenMessage.ts
-const childSessionOpenMessageSchema = z.object({
-	...createBaseChildMessageSchema(z.literal("SessionOpen")).shape,
-	sessionId: z.string().min(1)
-});
-//#endregion
-//#region src/models/window/ChildSessionsChangeMessage.ts
-const childSessionsChangeMessageSchema = z.object({ ...createBaseChildMessageSchema(z.literal("SessionsChange")).shape });
-//#endregion
-//#region src/models/window/ChildMessage.ts
-const childMessageSchema = z.discriminatedUnion("type", [
-	childCommandErrorMessageSchema,
-	childCommandResultMessageSchema,
-	childEventsMessageSchema,
-	childRejoinMessageSchema,
-	childSessionOpenMessageSchema,
-	childSessionsChangeMessageSchema
-]);
-//#endregion
-//#region src/models/window/SessionWindowCloseCode.ts
-let SessionWindowCloseCode = /* @__PURE__ */ function(SessionWindowCloseCode) {
-	SessionWindowCloseCode[SessionWindowCloseCode["SessionEnded"] = 4e3] = "SessionEnded";
-	return SessionWindowCloseCode;
-}({});
-//#endregion
-//#region src/services/device/hashCredential.ts
-const hashCredential = (credential) => createHash("sha256").update(credential).digest("base64url");
-//#endregion
-//#region src/services/drivers/window/constants.ts
-const SESSION_SUBCOMMAND = "session";
-const SESSION_SECRET_ENVIRONMENT_VARIABLE = `${SITE_NAME.toUpperCase()}_SESSION_SECRET`;
-const SESSION_SECRET_BYTE_LENGTH = 32;
-const SESSION_WINDOW_CONNECT_TIMEOUT_MS = Temporal.Duration.from({ seconds: 30 }).total("milliseconds");
-const SESSION_WINDOWS_FILENAME = "session-windows.json";
-const SESSION_WINDOW_REJOIN_DURATION_MS = Temporal.Duration.from({ minutes: 1 }).total("milliseconds");
-const SESSION_WINDOW_RECONNECT_DELAY_MS = Temporal.Duration.from({ seconds: 1 }).total("milliseconds");
-//#endregion
-//#region src/models/window/SessionWindows.ts
-const sessionWindowsSchema = z.object({
-	port: z.int().min(0),
-	secretHashes: z.array(z.string().min(1))
-});
-//#endregion
-//#region src/services/drivers/window/readSessionWindows.ts
-const readSessionWindows = (stateDirectory) => getResult(() => sessionWindowsSchema.parse(JSON.parse(readFileSync(join(stateDirectory, SESSION_WINDOWS_FILENAME), "utf8")))).unwrapOr({
-	port: 0,
-	secretHashes: []
-});
-//#endregion
-//#region src/services/drivers/window/sendChildCommand.ts
-const sendChildCommand = (child, command) => {
-	if (child.webSocket.readyState !== WebSocket.OPEN) throw new InvalidOperationError(Operation.Update, child.cwd, "the session's window closed");
-	const reply = Promise.withResolvers();
-	child.pendingReplyMap.set(command.id, reply);
-	child.webSocket.send(JSON.stringify(command));
-	return reply.promise;
-};
-//#endregion
-//#region src/services/drivers/window/takeChildReply.ts
-const takeChildReply = ({ pendingReplyMap }, commandId) => {
-	const reply = pendingReplyMap.get(commandId);
-	pendingReplyMap.delete(commandId);
-	return reply;
-};
-//#endregion
-//#region src/services/server/checkIsTokenValid.ts
-const checkIsTokenValid = (candidate, token) => {
-	if (!token) return false;
-	const candidateBuffer = Buffer.from(candidate);
-	const tokenBuffer = Buffer.from(token);
-	return candidateBuffer.length === tokenBuffer.length && timingSafeEqual(candidateBuffer, tokenBuffer);
-};
-//#endregion
-//#region src/services/drivers/window/createWindowDriver.ts
-const createWindowDriver = ({ onEvents, onSessionOpen, onSessionsChange }, { launchSessionWindow, stateDirectory, writeLine }) => {
-	const windowSessionMap = /* @__PURE__ */ new Map();
-	const childSet = /* @__PURE__ */ new Set();
-	const pendingLaunchMap = /* @__PURE__ */ new Map();
-	const taskRegistry = createTaskRegistry();
-	const webSocketServer = new WebSocketServer({ noServer: true });
-	const httpServer = createServer((_request, response) => {
-		response.writeHead(405).end();
-	});
-	const rejoinSecretHashSet = new Set(readSessionWindows(stateDirectory).secretHashes);
-	let port = 0;
-	const saveSessionWindows = () => {
-		const secretHashes = [...Array.from(childSet, ({ secretHash }) => secretHash), ...rejoinSecretHashSet];
-		getResult(() => {
-			writeStateFile(stateDirectory, SESSION_WINDOWS_FILENAME, JSON.stringify({
-				port,
-				secretHashes
-			}));
-		}).match(noop, console.error);
-	};
-	const rejoinTimeout = setTimeout(() => {
-		rejoinSecretHashSet.clear();
-		saveSessionWindows();
-	}, SESSION_WINDOW_REJOIN_DURATION_MS);
-	const getWindowSession = (sessionId) => {
-		const windowSession = windowSessionMap.get(sessionId);
-		if (!windowSession) throw new InvalidOperationError(Operation.Read, sessionId, "the session is not open on this host");
-		return windowSession;
-	};
-	const closeWindowSession = (sessionId, windowSession) => {
-		if (windowSessionMap.get(sessionId) !== windowSession) return;
-		windowSessionMap.delete(sessionId);
-		if (windowSession.state !== "Closed") onEvents(sessionId, toSessionClosedEvents(""));
-		writeLine(`A session in ${windowSession.child.cwd} closed, and its window with it.`);
-		onSessionsChange();
-		windowSession.child.webSocket.close(4e3);
-	};
-	const holdSession = (child, sessionId) => {
-		windowSessionMap.set(sessionId, {
-			child,
-			cwd: child.cwd,
-			lastActivityAt: /* @__PURE__ */ new Date(),
-			state: "Idle",
-			title: ""
-		});
-		onSessionOpen(sessionId);
-	};
-	const handleChildMessage = (child, childMessage) => {
-		switch (childMessage.type) {
-			case "CommandError": {
-				const reply = takeChildReply(child, childMessage.commandId);
-				if (reply) reply.reject(new Error(childMessage.message));
-				else console.error(childMessage.message);
-				return;
-			}
-			case "CommandResult":
-				takeChildReply(child, childMessage.commandId)?.resolve(childMessage.sessionId);
-				return;
-			case "Events": {
-				const { events, sessionId } = childMessage;
-				const windowSession = windowSessionMap.get(sessionId);
-				const isHeld = windowSession?.child === child;
-				if (isHeld) {
-					windowSession.lastActivityAt = /* @__PURE__ */ new Date();
-					for (const event of events) if (event.type === "SessionState") windowSession.state = event.state;
-				}
-				onEvents(sessionId, events);
-				if (isHeld && windowSession.state === "Closed") closeWindowSession(sessionId, windowSession);
-				return;
-			}
-			case "Rejoin":
-				for (const { events, sessionId } of childMessage.sessions) {
-					child.cwd = events.findLast((event) => event.type === "SessionInit")?.cwd ?? child.cwd;
-					holdSession(child, sessionId);
-					writeLine(`A session in ${child.cwd} came back from its window.`);
-					handleChildMessage(child, {
-						events,
-						sessionId,
-						type: "Events"
-					});
-				}
-				onSessionsChange();
-				return;
-			case "SessionOpen":
-				holdSession(child, childMessage.sessionId);
-				writeLine(`A session in ${child.cwd} opened in a window of its own.`);
-				return;
-			case "SessionsChange":
-				onSessionsChange();
-				return;
-			default: exhaustiveGuard(childMessage);
-		}
-	};
-	const receive = (child, data) => {
-		getResult(() => childMessageSchema.parse(JSON.parse(readMessageText(data)))).match((childMessage) => {
-			handleChildMessage(child, childMessage);
-		}, console.error);
-	};
-	const removeChild = (child) => {
-		childSet.delete(child);
-		saveSessionWindows();
-		for (const reply of child.pendingReplyMap.values()) reply.reject(new InvalidOperationError(Operation.Update, child.cwd, "the session's window closed"));
-		child.pendingReplyMap.clear();
-		for (const [sessionId, windowSession] of windowSessionMap) if (windowSession.child === child) closeWindowSession(sessionId, windowSession);
-	};
-	const addChild = (webSocket, cwd, secretHash) => {
-		const child = {
-			cwd,
-			pendingReplyMap: /* @__PURE__ */ new Map(),
-			secretHash,
-			webSocket
-		};
-		childSet.add(child);
-		saveSessionWindows();
-		webSocket.on("message", (data) => {
-			receive(child, data);
-		});
-		webSocket.on("close", () => {
-			removeChild(child);
-		});
-		return child;
-	};
-	httpServer.on("upgrade", (request, socket, head) => {
-		const secret = request.headers.authorization?.replace(/^Bearer /u, "") ?? "";
-		const pendingLaunchEntry = [...pendingLaunchMap].find(([launchSecret]) => checkIsTokenValid(secret, launchSecret));
-		if (pendingLaunchEntry) {
-			const [launchSecret, { connection, timeout }] = pendingLaunchEntry;
-			pendingLaunchMap.delete(launchSecret);
-			clearTimeout(timeout);
-			webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
-				connection.resolve(webSocket);
-			});
-			return;
-		}
-		const secretHash = hashCredential(secret);
-		if (!secret || !rejoinSecretHashSet.delete(secretHash)) {
-			socket.end("HTTP/1.1 401 Unauthorized\r\n\r\n");
-			return;
-		}
-		webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
-			addChild(webSocket, "", secretHash);
-		});
-	});
-	const listen = async () => {
-		httpServer.listen(0, DEFAULT_HOSTNAME);
-		await once(httpServer, "listening");
-		const address = httpServer.address();
-		port = typeof address === "object" && address ? address.port : 0;
-		saveSessionWindows();
-	};
-	const listening = listen();
-	const openWindow = async (cwd) => {
-		await listening;
-		const secret = randomBytes(32).toString("base64url");
-		const connection = Promise.withResolvers();
-		const timeout = setTimeout(() => {
-			pendingLaunchMap.delete(secret);
-			connection.reject(new InvalidOperationError(Operation.Create, cwd, "the session's window did not start"));
-		}, SESSION_WINDOW_CONNECT_TIMEOUT_MS);
-		pendingLaunchMap.set(secret, {
-			connection,
-			timeout
-		});
-		launchSessionWindow({
-			port,
-			secret
-		});
-		const webSocket = await connection.promise;
-		return addChild(webSocket, cwd, hashCredential(secret));
-	};
-	const openInWindow = async (cwd, command) => {
-		const child = await openWindow(cwd);
-		return getResultAsync(() => sendChildCommand(child, command)).match((sessionId) => sessionId, (error) => {
-			child.webSocket.close(4e3);
-			throw error;
-		});
-	};
-	const forward = (sessionId, command) => sendChildCommand(getWindowSession(sessionId).child, command);
-	const forwardInBackground = (sessionId, command) => {
-		const reply = forward(sessionId, command);
-		taskRegistry.run(() => getResultAsync(() => reply).match(noop, console.error));
-	};
-	const resumeSession = async (sessionId) => {
-		if (windowSessionMap.has(sessionId)) return sessionId;
-		return openInWindow(await readSessionCwd(sessionId), {
-			id: crypto.randomUUID(),
-			sessionId,
-			type: "Resume"
-		});
-	};
-	return {
-		backgroundTasks: async (sessionId) => {
-			await forward(sessionId, {
-				id: crypto.randomUUID(),
-				sessionId,
-				type: "BackgroundTasks"
-			});
-		},
-		close: async () => {
-			for (const { connection, timeout } of pendingLaunchMap.values()) {
-				clearTimeout(timeout);
-				connection.reject(new InvalidOperationError(Operation.Create, createWindowDriver.name, "the host is stopping"));
-			}
-			pendingLaunchMap.clear();
-			clearTimeout(rejoinTimeout);
-			rejoinSecretHashSet.clear();
-			const children = [...childSet];
-			for (const { webSocket } of children) webSocket.close(4e3);
-			await Promise.all(children.map(({ webSocket }) => once(webSocket, "close")));
-			await taskRegistry.drain();
-			await listening;
-			saveSessionWindows();
-			httpServer.close();
-			await once(httpServer, "close");
-		},
-		closeSession: (sessionId) => {
-			closeWindowSession(sessionId, getWindowSession(sessionId));
-		},
-		createSession: (cwd) => openInWindow(cwd, {
-			cwd,
-			id: crypto.randomUUID(),
-			type: "CreateSession"
-		}),
-		forkSession: async (sessionId, messageUuid) => openInWindow(await readSessionCwd(sessionId), {
-			id: crypto.randomUUID(),
-			messageUuid,
-			sessionId,
-			type: "Fork"
-		}),
-		interrupt: async (sessionId) => {
-			await forward(sessionId, {
-				id: crypto.randomUUID(),
-				sessionId,
-				type: "Interrupt"
-			});
-		},
-		listSessions: () => listSessionSummaries(windowSessionMap),
-		prompt: (sessionId, text, attachments) => {
-			forwardInBackground(sessionId, {
-				attachments,
-				id: crypto.randomUUID(),
-				sessionId,
-				text,
-				type: "Prompt"
-			});
-		},
-		resolvePermission: (sessionId, requestId, behavior, message) => {
-			forwardInBackground(sessionId, {
-				behavior,
-				id: crypto.randomUUID(),
-				message,
-				requestId,
-				sessionId,
-				type: "PermissionVerdict"
-			});
-		},
-		resumeAt: async (sessionId, messageUuid) => {
-			const cwd = await readSessionCwd(sessionId);
-			const windowSession = windowSessionMap.get(sessionId);
-			if (windowSession) closeWindowSession(sessionId, windowSession);
-			return openInWindow(cwd, {
-				id: crypto.randomUUID(),
-				messageUuid,
-				sessionId,
-				type: "ResumeAt"
-			});
-		},
-		resumeSession,
-		rewindFiles: async (sessionId, messageUuid) => {
-			await resumeSession(sessionId);
-			await forward(sessionId, {
-				id: crypto.randomUUID(),
-				messageUuid,
-				sessionId,
-				type: "RewindFiles"
-			});
-		},
-		runSlashCommand: (sessionId, name, commandArguments) => {
-			forwardInBackground(sessionId, {
-				arguments: commandArguments,
-				id: crypto.randomUUID(),
-				name,
-				sessionId,
-				type: "SlashCommand"
-			});
-		},
-		setModel: async (sessionId, model) => {
-			await forward(sessionId, {
-				id: crypto.randomUUID(),
-				model,
-				sessionId,
-				type: "SetModel"
-			});
-		},
-		setPermissionMode: async (sessionId, permissionMode) => {
-			await forward(sessionId, {
-				id: crypto.randomUUID(),
-				permissionMode,
-				sessionId,
-				type: "SetPermissionMode"
-			});
-		},
-		stopTask: async (sessionId, taskId) => {
-			await forward(sessionId, {
-				id: crypto.randomUUID(),
-				sessionId,
-				taskId,
-				type: "StopTask"
-			});
-		}
-	};
-};
-//#endregion
-//#region src/services/drivers/window/launchSessionWindow.ts
-const SESSION_COMMAND_ENVIRONMENT_VARIABLE_PREFIX = `${SITE_NAME.toUpperCase()}_SESSION_COMMAND_`;
-const launchSessionWindow = ({ port, secret }) => {
-	const hostCommand = isSea() ? [process.execPath] : [process.execPath, process.argv[1] ?? ""];
-	const quotedHostCommand = hostCommand.map((_value, index) => `"%${SESSION_COMMAND_ENVIRONMENT_VARIABLE_PREFIX}${index}%"`).join(" ");
-	spawn$1("cmd.exe", [
-		"/d",
-		"/s",
-		"/c",
-		`"start "" ${quotedHostCommand} ${SESSION_SUBCOMMAND} --port ${port}"`
-	], {
-		env: {
-			...process.env,
-			...Object.fromEntries(hostCommand.map((part, index) => [`${SESSION_COMMAND_ENVIRONMENT_VARIABLE_PREFIX}${index}`, part])),
-			[SESSION_SECRET_ENVIRONMENT_VARIABLE]: secret
-		},
-		stdio: "ignore",
-		windowsVerbatimArguments: true
-	}).on("error", console.error);
-};
-//#endregion
-//#region src/services/device/findDevice.ts
-const findDevice = (devices, credential) => {
-	const credentialHash = hashCredential(credential);
-	return devices.find((device) => checkIsTokenValid(credentialHash, device.credentialHash));
-};
-//#endregion
-//#region src/services/device/getDeviceName.ts
-const BrowserNames = [
-	[/Edg\//u, "Edge"],
-	[/Firefox\//u, "Firefox"],
-	[/Chrome\//u, "Chrome"],
-	[/Safari\//u, "Safari"]
-];
-const SystemNames = [
-	[/Windows/u, "Windows"],
-	[/Android/u, "Android"],
-	[/iPhone|iPad/u, "iOS"],
-	[/Mac OS X/u, "macOS"],
-	[/Linux/u, "Linux"]
-];
-const getDeviceName = (userAgent) => {
-	const browserName = BrowserNames.find(([pattern]) => pattern.test(userAgent))?.[1] ?? "A browser";
-	const systemName = SystemNames.find(([pattern]) => pattern.test(userAgent))?.[1];
-	return systemName ? `${browserName} on ${systemName}` : browserName;
-};
-//#endregion
-//#region src/services/handshake/getPublicKeyText.ts
-const getPublicKeyText = (privateKey) => createPublicKey(privateKey).export({ format: "jwk" }).x ?? "";
-//#endregion
-//#region src/services/server/answerHttpRequest.ts
-const answerHttpRequest = ({ headers, method }, response) => {
-	if (method !== "OPTIONS") {
-		response.writeHead(405).end();
-		return;
-	}
-	response.setHeader("Access-Control-Allow-Origin", headers.origin ?? "*");
-	response.setHeader("Access-Control-Allow-Private-Network", "true");
-	response.setHeader("Access-Control-Allow-Methods", "GET");
-	response.setHeader("Access-Control-Allow-Headers", headers["access-control-request-headers"] ?? "*");
-	response.setHeader("Vary", "Origin");
-	response.writeHead(204).end();
-};
-//#endregion
-//#region src/services/server/createEventLog.ts
-const createEventLog = () => {
-	const sessionEventMap = /* @__PURE__ */ new Map();
-	return {
-		append: (sessionId, events) => {
-			const sessionEvents = getOrCreate(sessionEventMap, sessionId, () => ({
-				eventIds: /* @__PURE__ */ new Set(),
-				events: []
-			}));
-			const newEvents = [];
-			for (const event of events) {
-				if (EphemeralAgentEventTypes.includes(event.type)) {
-					newEvents.push(event);
-					continue;
-				}
-				if (sessionEvents.eventIds.has(event.id)) continue;
-				sessionEvents.eventIds.add(event.id);
-				sessionEvents.events.push(event);
-				newEvents.push(event);
-			}
-			return newEvents;
-		},
-		entries: () => Array.from(sessionEventMap, ([sessionId, { events }]) => [sessionId, events]),
-		reset: (sessionId) => {
-			sessionEventMap.delete(sessionId);
-		}
-	};
-};
-//#endregion
-//#region src/services/server/createPairingCodes.ts
-const createPairingCodes = () => {
-	const codeTimeoutMap = /* @__PURE__ */ new Map();
-	return {
-		add: (code, durationMs) => {
-			clearTimeout(codeTimeoutMap.get(code));
-			codeTimeoutMap.set(code, setTimeout(() => {
-				codeTimeoutMap.delete(code);
-			}, durationMs));
-		},
-		clear: () => {
-			for (const timeout of codeTimeoutMap.values()) clearTimeout(timeout);
-			codeTimeoutMap.clear();
-		},
-		take: (code) => {
-			const heldCode = [...codeTimeoutMap.keys()].find((candidate) => checkIsTokenValid(code, candidate));
-			if (heldCode === void 0) return false;
-			clearTimeout(codeTimeoutMap.get(heldCode));
-			codeTimeoutMap.delete(heldCode);
-			return true;
-		}
-	};
-};
-//#endregion
-//#region src/services/server/handleCommand.ts
-const handleCommand = async (driver, command) => {
-	switch (command.type) {
-		case "BackgroundTasks":
-			await driver.backgroundTasks(command.sessionId);
-			return "";
-		case "CloseSession":
-			driver.closeSession(command.sessionId);
-			return "";
-		case "CreateSession": return driver.createSession(command.cwd);
-		case "Fork": return driver.forkSession(command.sessionId, command.messageUuid);
-		case "Interrupt":
-			await driver.interrupt(command.sessionId);
-			return "";
-		case "ListSessions": return "";
-		case "PermissionVerdict":
-			driver.resolvePermission(command.sessionId, command.requestId, command.behavior, command.message);
-			return "";
-		case "Prompt":
-			driver.prompt(command.sessionId, command.text, command.attachments);
-			return "";
-		case "Resume": return driver.resumeSession(command.sessionId);
-		case "ResumeAt": return driver.resumeAt(command.sessionId, command.messageUuid);
-		case "RewindFiles":
-			await driver.rewindFiles(command.sessionId, command.messageUuid);
-			return "";
-		case "SetModel":
-			await driver.setModel(command.sessionId, command.model);
-			return "";
-		case "SetPermissionMode":
-			await driver.setPermissionMode(command.sessionId, command.permissionMode);
-			return "";
-		case "SlashCommand":
-			driver.runSlashCommand(command.sessionId, command.name, command.arguments);
-			return "";
-		case "StopTask":
-			await driver.stopTask(command.sessionId, command.taskId);
-			return "";
-		default: return exhaustiveGuard(command);
-	}
-};
-//#endregion
-//#region src/services/files/getSessionCwd.ts
-const getSessionCwd = async (driver, sessionId) => {
-	const session = (await driver.listSessions()).find(({ id }) => id === sessionId);
-	if (!session) throw new InvalidOperationError(Operation.Read, sessionId, "the session is not open on this host");
-	return session.cwd;
-};
-//#endregion
-//#region src/services/files/constants.ts
-const REPOSITORY_FILE_MAX_BYTE_LENGTH = 524288;
-const REPOSITORY_WALK_IGNORED_NAMES = /* @__PURE__ */ new Set([".git", "node_modules"]);
-//#endregion
-//#region src/services/files/listRepositoryFiles.ts
-const execFileAsync = promisify(execFile$1);
-const listGitFiles = async (cwd) => {
-	const { stdout } = await execFileAsync("git", [
-		"ls-files",
-		"-co",
-		"--exclude-standard",
-		"-z"
-	], { cwd });
-	return stdout.split("\0").filter(Boolean);
-};
-const walkFiles = async (root, directory) => {
-	const entries = await readdir(directory, { withFileTypes: true });
-	const files = entries.filter((entry) => entry.isFile()).map((entry) => relative(root, join(directory, entry.name)));
-	const subdirectories = entries.filter((entry) => entry.isDirectory() && !REPOSITORY_WALK_IGNORED_NAMES.has(entry.name));
-	const nested = await Promise.all(subdirectories.map((entry) => walkFiles(root, join(directory, entry.name))));
-	return [...files, ...nested.flat()];
-};
-const listRepositoryFiles = async (cwd) => {
-	return (await getResultAsync(() => listGitFiles(cwd)).unwrapOr(void 0) ?? await walkFiles(cwd, cwd)).map((file) => file.split(sep).join("/")).toSorted();
-};
-//#endregion
-//#region src/services/files/resolveRepositoryPath.ts
-const resolveRepositoryPath = async (cwd, path) => {
-	const root = await realpath(cwd);
-	const target = await realpath(resolve(root, path));
-	const relation = relative(root, target);
-	if (relation === ".." || relation.startsWith(`..${sep}`) || isAbsolute(relation)) throw new InvalidOperationError(Operation.Read, path, "the file is outside the session's working directory");
-	return target;
-};
-//#endregion
-//#region src/services/files/readRepositoryFile.ts
-const readRepositoryFile = async (cwd, path) => {
-	const target = await resolveRepositoryPath(cwd, path);
-	const { size } = await stat(target);
-	if (size > 524288) return {
-		content: "",
-		notice: "The file is too large to show."
-	};
-	const buffer = await readFile(target);
-	if (buffer.includes(0)) return {
-		content: "",
-		notice: "The file is not text, so it cannot be shown."
-	};
-	return {
-		content: buffer.toString("utf8"),
-		notice: ""
-	};
-};
-//#endregion
-//#region src/services/server/handleFileCommand.ts
-const handleFileCommand = async (driver, command) => {
-	const cwd = await getSessionCwd(driver, command.sessionId);
-	switch (command.type) {
-		case "ListFiles": return {
-			commandId: command.id,
-			files: await listRepositoryFiles(cwd),
-			type: "Files"
-		};
-		case "ReadFile": {
-			const file = await readRepositoryFile(cwd, command.path);
-			return {
-				commandId: command.id,
-				content: file.content,
-				notice: file.notice,
-				path: command.path,
-				type: "FileContent"
-			};
-		}
-		default: return exhaustiveGuard(command);
-	}
-};
-//#endregion
-//#region src/services/server/handleShellCommand.ts
-const handleShellCommand = async (shellRegistry, command) => {
-	switch (command.type) {
-		case "CloseShell":
-			shellRegistry.close(command.shellId);
-			return "";
-		case "OpenShell": return await shellRegistry.open(command.sessionId, {
-			cols: command.cols,
-			cwd: command.cwd,
-			rows: command.rows
-		});
-		case "ShellInput":
-			shellRegistry.write(command.shellId, command.data);
-			return "";
-		case "ShellResize":
-			shellRegistry.resize(command.shellId, command.cols, command.rows);
-			return "";
-		default: return exhaustiveGuard(command);
-	}
-};
-//#endregion
-//#region src/services/server/sendServerMessage.ts
-const sendServerMessage = (webSocket, message) => {
-	if (webSocket.readyState === WebSocket.OPEN) webSocket.send(JSON.stringify(message));
-};
-//#endregion
-//#region src/services/shell/createShellRegistry.ts
-const createShellRegistry = ({ onClose, onOutput, spawnShell }) => {
-	const shellMap = /* @__PURE__ */ new Map();
-	const pendingShells = /* @__PURE__ */ new Set();
-	const closedSessionIds = /* @__PURE__ */ new Set();
-	let isStopped = false;
-	const getTerminal = (shellId) => {
-		const shell = shellMap.get(shellId);
-		if (!shell) throw new InvalidOperationError(Operation.Read, shellId, "the shell is not running on this host");
-		return shell.terminal;
-	};
-	return {
-		close: (shellId) => {
-			getTerminal(shellId).kill();
-		},
-		closeAll: () => {
-			isStopped = true;
-			for (const pendingShell of pendingShells) pendingShell.isClosed = true;
-			for (const { terminal } of shellMap.values()) terminal.kill();
-		},
-		closeSession: (sessionId) => {
-			closedSessionIds.add(sessionId);
-			for (const pendingShell of pendingShells) if (pendingShell.sessionId === sessionId) pendingShell.isClosed = true;
-			for (const shell of shellMap.values()) if (shell.sessionId === sessionId) shell.terminal.kill();
-		},
-		entries: () => Array.from(shellMap, ([shellId, { output, sessionId }]) => ({
-			output,
-			sessionId,
-			shellId
-		})),
-		open: async (sessionId, options) => {
-			if (isStopped) throw new InvalidOperationError(Operation.Create, sessionId, "the host is stopping");
-			if (closedSessionIds.has(sessionId)) throw new InvalidOperationError(Operation.Create, sessionId, "the session is closed");
-			const pendingShell = {
-				isClosed: false,
-				sessionId
-			};
-			pendingShells.add(pendingShell);
-			const terminal = await withFinalizerAsync(() => spawnShell(options), () => {
-				pendingShells.delete(pendingShell);
-			});
-			if (pendingShell.isClosed) {
-				terminal.kill();
-				throw new InvalidOperationError(Operation.Create, sessionId, "the shell's session or host closed as it started");
-			}
-			const shellId = crypto.randomUUID();
-			const shell = {
-				output: "",
-				sessionId,
-				terminal
-			};
-			shellMap.set(shellId, shell);
-			terminal.onData((data) => {
-				shell.output = `${shell.output}${data}`.slice(-SHELL_OUTPUT_LENGTH);
-				onOutput(shellId, data);
-			});
-			terminal.onExit(() => {
-				shellMap.delete(shellId);
-				onClose(shellId);
-			});
-			return shellId;
-		},
-		openSession: (sessionId) => {
-			closedSessionIds.delete(sessionId);
-		},
-		resize: (shellId, cols, rows) => {
-			getTerminal(shellId).resize(cols, rows);
-		},
-		write: (shellId, data) => {
-			getTerminal(shellId).write(data);
-		}
-	};
-};
-//#endregion
-//#region src/services/server/createAgentConsoleServer.ts
-const createAgentConsoleServer = async ({ createDriver, hostKey, hostname, origin, port, spawnShell, stateDirectory, writeLine }) => {
-	const eventLog = createEventLog();
-	const taskRegistry = createTaskRegistry();
-	const pairingCodes = createPairingCodes();
-	const publicKey = createPublicKey(hostKey);
-	const publicKeyText = getPublicKeyText(hostKey);
-	const webSocketServer = new WebSocketServer({ noServer: true });
-	const socketDeviceIdMap = /* @__PURE__ */ new Map();
-	const broadcast = (message) => {
-		for (const webSocket of socketDeviceIdMap.keys()) sendServerMessage(webSocket, message);
-	};
-	let isRefreshing = false;
-	let isRefreshStale = false;
-	const refreshSessions = () => {
-		if (isRefreshing) {
-			isRefreshStale = true;
-			return;
-		}
-		isRefreshing = true;
-		taskRegistry.run(async () => {
-			do {
-				isRefreshStale = false;
-				await getResultAsync(() => driver.listSessions()).match((sessions) => {
-					broadcast({
-						sessions,
-						type: "Sessions"
-					});
-				}, console.error);
-			} while (isRefreshStale);
-			isRefreshing = false;
-		});
-	};
-	const shellRegistry = createShellRegistry({
-		onClose: (shellId) => {
-			broadcast({
-				shellId,
-				type: "ShellClosed"
-			});
-		},
-		onOutput: (shellId, data) => {
-			broadcast({
-				data,
-				shellId,
-				type: "ShellOutput"
-			});
-		},
-		spawnShell
-	});
-	const driver = createDriver({
-		onEvents: (sessionId, events) => {
-			const newEvents = eventLog.append(sessionId, events);
-			if (newEvents.length > 0) broadcast({
-				events: newEvents,
-				sessionId,
-				type: "Events"
-			});
-			if (events.some((event) => event.type === "SessionState" && event.state === "Closed")) shellRegistry.closeSession(sessionId);
-		},
-		onSessionOpen: (sessionId) => {
-			shellRegistry.openSession(sessionId);
-			eventLog.reset(sessionId);
-			broadcast({
-				sessionId,
-				type: "SessionReset"
-			});
-		},
-		onSessionsChange: () => {
-			refreshSessions();
-		}
-	});
-	const receive = async (webSocket, data) => {
-		const command = getResult(() => commandSchema.parse(JSON.parse(readMessageText(data)))).orTee((error) => {
-			sendServerMessage(webSocket, {
-				commandId: "",
-				message: error.message,
-				type: "CommandError"
-			});
-		}).unwrapOr(void 0);
-		if (!command) return;
-		const sendCommandError = (error) => {
-			sendServerMessage(webSocket, {
-				commandId: command.id,
-				message: error.message,
-				type: "CommandError"
-			});
-		};
-		switch (command.type) {
-			case "CloseShell":
-			case "OpenShell":
-			case "ShellInput":
-			case "ShellResize":
-				await getResultAsync(() => handleShellCommand(shellRegistry, command)).match((shellId) => {
-					if (command.type === "OpenShell") sendServerMessage(webSocket, {
-						commandId: command.id,
-						sessionId: command.sessionId,
-						shellId,
-						type: "ShellOpened"
-					});
-				}, sendCommandError);
-				return;
-			case "ListFiles":
-			case "ReadFile":
-				await getResultAsync(() => handleFileCommand(driver, command)).match((message) => {
-					sendServerMessage(webSocket, message);
-				}, sendCommandError);
-				return;
-			default: await getResultAsync(() => handleCommand(driver, command)).match((sessionId) => {
-				if (sessionId) sendServerMessage(webSocket, {
-					commandId: command.id,
-					sessionId,
-					type: "SessionOpened"
-				});
-				else if (command.type === "ListSessions") refreshSessions();
-			}, sendCommandError);
-		}
-	};
-	const admit = (webSocket, deviceId) => {
-		socketDeviceIdMap.set(webSocket, deviceId);
-		for (const [sessionId, events] of eventLog.entries()) sendServerMessage(webSocket, {
-			events,
-			sessionId,
-			type: "Events"
-		});
-		for (const { output, sessionId, shellId } of shellRegistry.entries()) {
-			sendServerMessage(webSocket, {
-				commandId: "",
-				sessionId,
-				shellId,
-				type: "ShellOpened"
-			});
-			if (output) sendServerMessage(webSocket, {
-				data: output,
-				shellId,
-				type: "ShellOutput"
-			});
-		}
-		refreshSessions();
-	};
-	const pair = (webSocket, request, code) => {
-		if (request.headers.origin !== origin || !pairingCodes.take(code)) {
-			webSocket.close(4403);
-			return;
-		}
-		const credential = randomBytes(32).toString("base64url");
-		const device = {
-			createdAt: /* @__PURE__ */ new Date(),
-			credentialHash: hashCredential(credential),
-			id: crypto.randomUUID(),
-			name: getDeviceName(request.headers["user-agent"] ?? ""),
-			origin
-		};
-		writeDevices(stateDirectory, [...readDevices(stateDirectory), device]);
-		writeLine(`${device.name} connected. To remove it: devices --revoke ${device.id}`);
-		sendServerMessage(webSocket, {
-			credential,
-			deviceId: device.id,
-			publicKey: publicKeyText,
-			type: "Paired"
-		});
-		admit(webSocket, device.id);
-	};
-	const receiveHandshake = (webSocket, request, hostNonce, handshakeMessage) => {
-		const localPort = request.socket.localPort ?? 0;
-		switch (handshakeMessage.type) {
-			case "Authenticate": {
-				const device = findDevice(readDevices(stateDirectory), handshakeMessage.credential);
-				if (!device) {
-					webSocket.close(4401);
-					return;
-				}
-				sendServerMessage(webSocket, { type: "Authenticated" });
-				admit(webSocket, device.id);
-				return;
-			}
-			case "Challenge":
-				sendServerMessage(webSocket, {
-					nonce: hostNonce,
-					port: localPort,
-					signature: signNonce(hostKey, "HostProof", localPort, handshakeMessage.nonce),
-					type: "Proof"
-				});
-				return;
-			case "HandOff":
-			case "Revoke":
-				if (!checkIsSignatureValid(publicKey, "OwnerProof", localPort, hostNonce, handshakeMessage.signature)) {
-					webSocket.close(4404);
-					return;
-				}
-				if (handshakeMessage.type === "HandOff") pairingCodes.add(handshakeMessage.code, SCHEME_PAIRING_CODE_DURATION_MS);
-				else {
-					writeDevices(stateDirectory, readDevices(stateDirectory).filter(({ id }) => id !== handshakeMessage.deviceId));
-					for (const [deviceWebSocket, deviceId] of socketDeviceIdMap) if (deviceId === handshakeMessage.deviceId) deviceWebSocket.close(4401);
-					writeLine("A device was removed, and its connection closed.");
-				}
-				webSocket.close();
-				return;
-			case "Pair":
-				pair(webSocket, request, handshakeMessage.code);
-				return;
-			default: exhaustiveGuard(handshakeMessage);
-		}
-	};
-	webSocketServer.on("connection", (webSocket, request) => {
-		const hostNonce = randomBytes(32).toString("base64url");
-		webSocket.on("message", (data) => {
-			if (socketDeviceIdMap.has(webSocket)) {
-				taskRegistry.run(() => receive(webSocket, data));
-				return;
-			}
-			getResult(() => {
-				receiveHandshake(webSocket, request, hostNonce, handshakeMessageSchema.parse(JSON.parse(readMessageText(data))));
-			}).match(noop, (error) => {
-				console.error(error);
-				webSocket.close(4400);
-			});
-		});
-		webSocket.on("close", () => {
-			socketDeviceIdMap.delete(webSocket);
-		});
-	});
-	const httpServer = createServer((request, response) => {
-		answerHttpRequest(request, response);
-	});
-	httpServer.on("upgrade", (request, socket, head) => {
-		if (request.headers.origin !== void 0 && request.headers.origin !== origin) {
-			socket.end("HTTP/1.1 403 Forbidden\r\n\r\n");
-			return;
-		}
-		webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
-			webSocketServer.emit("connection", webSocket, request);
-		});
-	});
-	httpServer.listen(port, hostname);
-	await once(httpServer, "listening");
-	const address = httpServer.address();
-	let closing;
-	const close = async () => {
-		broadcast({ type: "HostStopping" });
-		pairingCodes.clear();
-		shellRegistry.closeAll();
-		await driver.close();
-		for (const webSocket of webSocketServer.clients) webSocket.terminate();
-		webSocketServer.close();
-		httpServer.close();
-		await Promise.all([
-			taskRegistry.drain(),
-			once(webSocketServer, "close"),
-			once(httpServer, "close")
-		]);
-	};
-	return {
-		addPairingCode: pairingCodes.add,
-		close: () => closing ??= close(),
-		port: typeof address === "object" && address ? address.port : port
-	};
-};
-//#endregion
-//#region src/services/shell/getShellFile.ts
-const POWERSHELL_FILE = "pwsh.exe";
-const WINDOWS_POWERSHELL_FILE = "powershell.exe";
-const getShellFile = () => {
-	if (process.platform !== "win32") return process.env.SHELL ?? "/bin/sh";
-	return (process.env.PATH ?? "").split(delimiter).filter(Boolean).some((pathDirectory) => existsSync(join(pathDirectory, POWERSHELL_FILE))) ? POWERSHELL_FILE : WINDOWS_POWERSHELL_FILE;
-};
-//#endregion
-//#region src/services/shell/loadNodePty.ts
-const loadNodePty = () => {
-	if (!isSea()) return import("node-pty");
-	const installDirectory = getHostInstallDirectory();
-	return Promise.resolve(createRequire(join(installDirectory, "package.json"))(join(installDirectory, NODE_PTY_DIRECTORY_NAME)));
-};
-//#endregion
-//#region src/services/shell/spawnPtyShell.ts
-const spawnPtyShell = async ({ cols, cwd, rows }) => {
-	const { spawn } = await getResultAsync(() => loadNodePty()).match((nodePty) => nodePty, () => {
-		throw new InvalidOperationError(Operation.Create, cwd, "this host has no terminal support, so no shell can start");
-	});
-	const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.toLowerCase() !== "psmodulepath"));
-	return spawn(getShellFile(), [], {
-		cols,
-		cwd,
-		env,
-		name: "xterm-256color",
-		rows
-	});
-};
-//#endregion
-//#region src/services/cli/serveHost.ts
-const serveHost = async ({ hostname, origin, port, schemeLaunch }) => {
-	installDownloadedHost();
-	const stateDirectory = getStateDirectory();
-	const hostKey = readHostKey(stateDirectory);
-	const reachableHostname = getReachableHostname(hostname);
-	const server = await getResultAsync(() => createAgentConsoleServer({
-		createDriver: (callbacks) => process.platform === "win32" && hostname === "127.0.0.1" ? createWindowDriver(callbacks, {
-			launchSessionWindow,
-			stateDirectory,
-			writeLine
-		}) : createClaudeAgentSdkDriver(callbacks),
-		hostKey,
-		hostname,
-		origin,
-		port,
-		spawnShell: spawnPtyShell,
-		stateDirectory,
-		writeLine
-	})).match((agentConsoleServer) => agentConsoleServer, async (error) => {
-		if (!schemeLaunch || !("code" in error) || error.code !== "EADDRINUSE") throw error;
-		const { code } = schemeLaunch;
-		if (await sendToRunningHost(reachableHostname, port, hostKey, code ? (signature) => ({
-			code,
-			signature,
-			type: "HandOff"
-		}) : void 0)) {
-			process.stdout.write("The host is already running in another window.\n");
-			process.exit(0);
-		}
-		process.stderr.write(`Another program is using port ${port}, so the host cannot start. Close it and connect again.\n`);
-		process.exit(1);
-	});
-	if (schemeLaunch) {
-		if (schemeLaunch.code) server.addPairingCode(schemeLaunch.code, SCHEME_PAIRING_CODE_DURATION_MS);
-		process.stdout.write("The host is running. Keep this window open.\n\nTo stop, close this window.\n");
-	} else {
-		const code = randomBytes(32).toString("base64url");
-		server.addPairingCode(code, PRINTED_PAIRING_CODE_DURATION_MS);
-		const hostAddress = `ws://${reachableHostname}:${server.port}`;
-		const pairingUrl = `${origin}${RoutePath.Genshin}#${new URLSearchParams({
-			[PAIRING_CODE_PARAMETER]: code,
-			[PAIRING_HASH_PARAMETER]: hostAddress
-		})}`;
-		process.stdout.write(`The host is running. Keep this window open.\n\nTo connect, press Connect on the page, or hold Ctrl and click this link in the next ten minutes:\n  ${pairingUrl}\n\nTo add this machine from another computer, enter its address and this code in the page's sessions tab:\n  ${code}\n\nTo stop, close this window.\n`);
-	}
-	await Promise.race([once(process, "SIGINT"), once(process, "SIGHUP")]);
-	await server.close();
-};
-//#endregion
-//#region src/services/cli/commands/serveCommand.ts
-const serveCommand = defineCommand({
-	args: { ...hostArgs },
-	meta: {
-		description: "Start the host and print the link that pairs a page with it",
-		name: "serve"
-	},
-	run: ({ args }) => serveHost({
-		hostname: args.hostname,
-		origin: args.origin,
-		port: Number(args.port)
-	})
-});
-//#endregion
-//#region src/services/drivers/window/formatSessionLogLine.ts
-const formatSessionLogLine = (event) => {
-	switch (event.type) {
-		case "AssistantMessage": return event.parentToolUseId ? "" : `Claude: ${event.text}`;
-		case "HostError": return `Error: ${event.message}`;
-		case "PermissionRequest": return `Claude asks to use ${event.toolName}. Answer in the page.`;
-		case "ToolUse": return event.parentToolUseId ? "" : `Claude uses ${event.name}`;
-		case "UserMessage": return event.parentToolUseId ? "" : `You: ${event.text}`;
-		default: return "";
-	}
-};
-//#endregion
-//#region src/services/drivers/window/serveSessionChild.ts
-const serveSessionChild = async (connect, createDriver, writeLine, signal) => {
-	const taskRegistry = createTaskRegistry();
-	const sessionEventMap = /* @__PURE__ */ new Map();
-	let webSocket;
-	const send = (childMessage) => {
-		if (webSocket?.readyState === WebSocket.OPEN) webSocket.send(JSON.stringify(childMessage));
-	};
-	const driver = createDriver({
-		onEvents: (sessionId, events) => {
-			for (const event of events) {
-				const line = formatSessionLogLine(event);
-				if (line) writeLine(line);
-			}
-			getOrCreate(sessionEventMap, sessionId, () => []).push(...events.filter(({ type }) => !EphemeralAgentEventTypes.includes(type)));
-			if (events.some((event) => event.type === "SessionState" && event.state === "Closed")) sessionEventMap.delete(sessionId);
-			send({
-				events,
-				sessionId,
-				type: "Events"
-			});
-		},
-		onSessionOpen: (sessionId) => {
-			sessionEventMap.set(sessionId, []);
-			send({
-				sessionId,
-				type: "SessionOpen"
-			});
-		},
-		onSessionsChange: () => {
-			send({ type: "SessionsChange" });
-		}
-	});
-	const receive = async (text) => {
-		const command = getResult(() => driverCommandSchema.parse(JSON.parse(text))).orTee((error) => {
-			send({
-				commandId: "",
-				message: error.message,
-				type: "CommandError"
-			});
-		}).unwrapOr(void 0);
-		if (!command) return;
-		await getResultAsync(() => handleCommand(driver, command)).match((sessionId) => {
-			send({
-				commandId: command.id,
-				sessionId,
-				type: "CommandResult"
-			});
-		}, (error) => {
-			send({
-				commandId: command.id,
-				message: error.message,
-				type: "CommandError"
-			});
-		});
-	};
-	signal.addEventListener("abort", () => {
-		webSocket?.close();
-	});
-	let isRejoining = false;
-	while (!signal.aborted) {
-		const currentWebSocket = connect();
-		webSocket = currentWebSocket;
-		let isRefused = false;
-		currentWebSocket.on("message", (data) => {
-			taskRegistry.run(() => receive(readMessageText(data)));
-		});
-		currentWebSocket.on("error", noop);
-		currentWebSocket.on("unexpected-response", () => {
-			isRefused = true;
-			currentWebSocket.terminate();
-		});
-		if (isRejoining) currentWebSocket.once("open", () => {
-			writeLine("The host is back, and has this session again.");
-			send({
-				sessions: Array.from(sessionEventMap, ([sessionId, events]) => ({
-					events,
-					sessionId
-				})),
-				type: "Rejoin"
-			});
-		});
-		const [code] = await once(currentWebSocket, "close");
-		if (isRefused && isRejoining) writeLine("The host did not take this session back, so it ends here.");
-		if (signal.aborted || isRefused || code === 4e3 || sessionEventMap.size === 0) break;
-		if (!isRejoining) writeLine("The host went away. This session keeps running, and comes back when the host is started again.");
-		isRejoining = true;
-		await setTimeout$1(SESSION_WINDOW_RECONNECT_DELAY_MS);
-	}
-	await driver.close();
-	await taskRegistry.drain();
-};
-//#endregion
-//#region src/services/drivers/window/runSessionChild.ts
-const runSessionChild = async (port, writeLine) => {
-	const secret = process.env[SESSION_SECRET_ENVIRONMENT_VARIABLE] ?? "";
-	Reflect.deleteProperty(process.env, SESSION_SECRET_ENVIRONMENT_VARIABLE);
-	process.title = `${SITE_NAME} session`;
-	const stateDirectory = getStateDirectory();
-	let isFirstConnection = true;
-	const connect = () => {
-		const hostPort = isFirstConnection ? port : readSessionWindows(stateDirectory).port;
-		isFirstConnection = false;
-		return new WebSocket(`ws://${DEFAULT_HOSTNAME}:${hostPort}`, { headers: { authorization: `Bearer ${secret}` } });
-	};
-	const abortController = new AbortController();
-	const stop = () => {
-		abortController.abort();
-	};
-	process.once("SIGINT", stop);
-	process.once("SIGHUP", stop);
-	writeLine("This window shows one session as it runs. Type to it in the page.\nTo stop it, close this window.\n");
-	await serveSessionChild(connect, createClaudeAgentSdkDriver, writeLine, abortController.signal);
-};
-//#endregion
-//#region src/services/cli/commands/sessionCommand.ts
-const sessionCommand = defineCommand({
-	args: { port: {
-		description: "The port of the host that started this window",
-		required: true,
-		type: "string"
-	} },
-	meta: {
-		description: "Serve one session in a window of its own, for the host that started it",
-		name: SESSION_SUBCOMMAND
-	},
-	run: async ({ args }) => {
-		await runSessionChild(Number(args.port), writeLine);
-		process.exit(0);
-	}
-});
-//#endregion
-//#region src/services/installer/uninstallHost.ts
-const uninstallHost = () => {
-	execFileSync$1("reg", [
-		"delete",
-		HOST_SCHEME_REGISTRY_KEY,
-		"/f"
-	], { stdio: "ignore" });
-	spawn$1("powershell.exe", [
-		"-NoProfile",
-		"-Command",
-		`Start-Sleep -Seconds 2; Remove-Item -LiteralPath $env:${HOST_DIRECTORY_ENVIRONMENT_VARIABLE} -Recurse -Force`
-	], {
-		detached: true,
-		env: {
-			...process.env,
-			[HOST_DIRECTORY_ENVIRONMENT_VARIABLE]: getHostInstallDirectory()
-		},
-		stdio: "ignore"
-	}).unref();
-};
-//#endregion
-//#region src/services/cli/commands/uninstallCommand.ts
-const uninstallCommand = defineCommand({
-	meta: {
-		description: "Remove the installed host, its link and its folder",
-		name: "uninstall"
-	},
-	run: () => {
-		uninstallHost();
-		process.stdout.write("The host is uninstalled, and its folder is removed once this window closes.\n");
-		process.exit(0);
-	}
-});
-//#endregion
-//#region src/services/installer/checkIsSchemeLaunchTampered.ts
-const checkIsSchemeLaunchTampered = (commandLineArguments) => commandLineArguments.length > 1 && commandLineArguments.some((commandLineArgument) => commandLineArgument.startsWith(`${HOST_SCHEME}:`));
-//#endregion
-//#region src/services/installer/getSchemeLaunch.ts
-const getSchemeLaunch = (argument) => {
-	if (!URL.canParse(argument)) return void 0;
-	const url = new URL(argument);
-	if (url.protocol === `${HOST_SCHEME}:`) return { code: url.searchParams.get("code") ?? "" };
-	else return void 0;
-};
-//#endregion
-//#region src/services/shell/constants.ts
-const CONSOLE_LIST_AGENT_NAME = "conpty_console_list_agent";
-//#endregion
-//#region src/services/shell/runConsoleListAgent.ts
-const runConsoleListAgent = (shellPid) => {
-	const installDirectory = getHostInstallDirectory();
-	const { getConsoleProcessList } = createRequire(join(installDirectory, "package.json"))(join(installDirectory, NODE_PTY_DIRECTORY_NAME, "prebuilds", "win32-x64", "conpty_console_list.node"));
-	process.send?.({ consoleProcessList: getConsoleProcessList(shellPid) });
-};
-//#endregion
-//#region src/services/cli/commands/agentConsoleServerCommand.ts
-const agentConsoleServerCommand = defineCommand({
-	default: "serve",
-	meta: {
-		description: "The agent console's host: Claude Code sessions for a paired page",
-		name: "agent-console-server"
-	},
-	setup: async ({ rawArgs }) => {
-		if (checkIsSchemeLaunchTampered(rawArgs)) {
-			process.stderr.write("This link tried to start the host with settings of its own, so it was not started.\n");
-			process.exit(1);
-		}
-		const [firstArgument = "", secondArgument = ""] = rawArgs;
-		if (basename(firstArgument) === "conpty_console_list_agent") {
-			runConsoleListAgent(Number(secondArgument));
-			process.exit(0);
-		}
-		const schemeLaunch = getSchemeLaunch(firstArgument);
-		if (!schemeLaunch) return;
-		await serveHost({
-			hostname: DEFAULT_HOSTNAME,
-			origin: DEFAULT_APP_ORIGIN,
-			port: DEFAULT_PORT,
-			schemeLaunch
-		});
-		process.exit(0);
-	},
-	subCommands: {
-		devices: devicesCommand,
-		serve: serveCommand,
-		[SESSION_SUBCOMMAND]: sessionCommand,
-		uninstall: uninstallCommand
-	}
-});
-//#endregion
-export { childSessionOpenMessageSchema as $, signNonce as $t, createEventLog as A, mapAssistantContent as At, readSessionWindows as B, DEFAULT_DENY_MESSAGE as Bt, resolveRepositoryPath as C, hostArgs as Cn, toSessionInitEvent as Ct, getSessionCwd as D, mapSystemMessage as Dt, REPOSITORY_WALK_IGNORED_NAMES as E, toToolResultText as Et, launchSessionWindow as F, createFileOriginTracker as Ft, SESSION_WINDOWS_FILENAME as G, toSessionClosedEvents as Gt, SESSION_SECRET_BYTE_LENGTH as H, SESSION_LIST_LIMIT as Ht, createWindowDriver as I, createPermissionBridge as It, SESSION_WINDOW_REJOIN_DURATION_MS as J, runMain as Jt, SESSION_WINDOW_CONNECT_TIMEOUT_MS as K, getEventId as Kt, checkIsTokenValid as L, toPermissionResult as Lt, getPublicKeyText as M, createTodoTracker as Mt, getDeviceName as N, TodoToolName as Nt, handleCommand as O, mapTaskMessage as Ot, findDevice as P, createStreamTracker as Pt, childSessionsChangeMessageSchema as Q, HOST_PROBE_TIMEOUT_MS as Qt, takeChildReply as R, toPermissionRequestEvent as Rt, readRepositoryFile as S, NODE_PTY_DIRECTORY_NAME as Sn, toTurnResultEvents as St, REPOSITORY_FILE_MAX_BYTE_LENGTH as T, mapUserContent as Tt, SESSION_SECRET_ENVIRONMENT_VARIABLE as U, SETTING_SOURCES as Ut, sessionWindowsSchema as V, IGNORED_SDK_MESSAGE_TYPES as Vt, SESSION_SUBCOMMAND as W, closeOpenSession as Wt, SessionWindowCloseCode as X, sendToRunningHost as Xt, hashCredential as Y, runDevicesCommand as Yt, childMessageSchema as Z, readMessageText as Zt, createAgentConsoleServer as _, CLAUDE_CODE_EXECUTABLE_FILENAME as _n, toCapabilitiesEvent as _t, checkIsSchemeLaunchTampered as a, writeStateFile as an, ChildMessageType as at, handleShellCommand as b, HOST_INSTALL_DIRECTORY_SEGMENTS as bn, readSessionHistory as bt, sessionCommand as c, HOST_KEY_FILENAME as cn, createClaudeAgentSdkDriver as ct, formatSessionLogLine as d, STATE_DIRECTORY_NAME as dn, readSessionCwd as dt, checkIsSignatureValid as en, childRejoinMessageSchema as et, serveCommand as f, writeLine as fn, listSessionSummaries as ft, getShellFile as g, getHostInstallDirectory as gn, toContextUsageEvent as gt, loadNodePty as h, checkIsHostInstalled as hn, watchSession as ht, getSchemeLaunch as i, readHostKey as in, childCommandErrorMessageSchema as it, answerHttpRequest as j, toUnknownEvent as jt, createPairingCodes as k, mapHookMessage as kt, runSessionChild as l, PRINTED_PAIRING_CODE_DURATION_MS as ln, createTaskRegistry as lt, spawnPtyShell as m, installHost as mn, getClaudeCodeExecutablePath as mt, runConsoleListAgent as n, readDevices as nn, childEventsMessageSchema as nt, uninstallCommand as o, getStateDirectory as on, childMessageTypeSchema as ot, serveHost as p, installDownloadedHost as pn, createSessionOpener as pt, SESSION_WINDOW_RECONNECT_DELAY_MS as q, devicesCommand as qt, CONSOLE_LIST_AGENT_NAME as r, deviceSchema as rn, childCommandResultMessageSchema as rt, uninstallHost as s, DEVICES_FILENAME as sn, createBaseChildMessageSchema as st, agentConsoleServerCommand as t, writeDevices as tn, rejoiningSessionSchema as tt, serveSessionChild as u, SECRET_BYTE_LENGTH as un, toContentBlockParam as ut, createShellRegistry as v, HOST_DIRECTORY_ENVIRONMENT_VARIABLE as vn, getSessionTitle as vt, listRepositoryFiles as w, getReachableHostname as wn, parseMessageBody as wt, handleFileCommand as x, HOST_SCHEME_REGISTRY_KEY as xn, createSdkMessageMapper as xt, sendServerMessage as y, HOST_EXECUTABLE_FILENAME as yn, readToolUseResultMap as yt, sendChildCommand as z, createInputQueue as zt };