agent-console-server 3.4.0 → 3.5.1

package/dist/{readToken-BSQZ8ZVf.js → spawnPtyShell-CtAiD2BH.js}

@@ -1,25 +1,147 @@
-import { M as todoStatusSchema, P as permissionModeSchema, i as commandSchema, t as EphemeralAgentEventTypes } from "./EphemeralAgentEventTypes-Cm5oNQXu.js";
+import { B as getSignedText, V as serverMessageSchema, _ as driverCommandSchema, et as agentEventSchema, ft as todoStatusSchema, in as DEFAULT_HOSTNAME, ln as SCHEME_PAIRING_CODE_DURATION, on as HOST_SCHEME, r as handshakeMessageSchema, t as EphemeralAgentEventTypes, u as commandSchema, un as SHELL_OUTPUT_LENGTH, wt as permissionModeSchema } from "./EphemeralAgentEventTypes-DGkHIIcW.js";
+import { createRequire } from "node:module";
 import { z } from "zod";
-import { ID_SEPARATOR, InvalidOperationError, Operation, exhaustiveGuard, getOrCreate, getResult, getResultAsync, noop } from "@esposter/shared";
-import { getSessionInfo, getSessionMessages, listSessions, query } from "@anthropic-ai/claude-agent-sdk";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { readFile, readdir } from "node:fs/promises";
+import { ID_SEPARATOR, InvalidOperationError, Operation, SITE_NAME, createUniqueArraySchema, exhaustiveGuard, getOrCreate, getResult, getResultAsync, noop, withFinalizerAsync } from "@esposter/shared";
 import { homedir } from "node:os";
-import { join } from "node:path";
-import { randomBytes, timingSafeEqual } from "node:crypto";
-import { WebSocket, WebSocketServer } from "ws";
+import { dirname, join, relative, win32 } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, sign, timingSafeEqual, verify } from "node:crypto";
 import { once } from "node:events";
+import { WebSocket, WebSocketServer } from "ws";
+import { getSessionInfo, getSessionMessages, listSessions, query } from "@anthropic-ai/claude-agent-sdk";
+import { readFile, readdir } from "node:fs/promises";
+import { getAssetKeys, getRawAsset, isSea } from "node:sea";
 import { createServer } from "node:http";
+import { execFileSync, spawn } from "node:child_process";
+//#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 = 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 [];
+	return z.array(deviceSchema).parse(JSON.parse(readFileSync(devicesPath, "utf8")));
+};
+//#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 src/services/drivers/claudeAgentSdk/getEventId.ts
 const getEventId = (sourceId, suffix) => `${sourceId}${ID_SEPARATOR}${suffix}`;
 //#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", "");
+//#region src/services/drivers/claudeAgentSdk/toSessionClosedEvents.ts
+const toSessionClosedEvents = (message) => {
 	const createdAt = /* @__PURE__ */ new Date();
 	const closedId = getEventId(crypto.randomUUID(), "SessionState");
-	emit(sessionId, [...message ? [{
+	return [...message ? [{
 		createdAt,
 		id: getEventId(closedId, "HostError"),
 		message,
@@ -29,7 +151,14 @@ const closeOpenSession = (sessionId, openSession, message, { emit, onSessionsCha
 		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();
 };
@@ -845,6 +974,20 @@ const watchSession = async (sessionId, openSession, { emit, onSessionsChange, op
 	]);
 };
 //#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/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();
@@ -852,6 +995,7 @@ const createSessionOpener = ({ emit, onSessionOpen, onSessionsChange, openSessio
 	const toolUseResultMap = resumeFrom ? await readToolUseResultMap(resumeFrom) : /* @__PURE__ */ new Map();
 	const input = createInputQueue();
 	const pendingPermissionMap = /* @__PURE__ */ new Map();
+	const claudeCodeExecutablePath = getClaudeCodeExecutablePath();
 	const sessionQuery = query({
 		options: {
 			canUseTool: createPermissionBridge(sessionId, pendingPermissionMap, emit),
@@ -863,6 +1007,7 @@ const createSessionOpener = ({ emit, onSessionOpen, onSessionsChange, openSessio
 			},
 			includeHookEvents: true,
 			includePartialMessages: true,
+			...claudeCodeExecutablePath ? { pathToClaudeCodeExecutable: claudeCodeExecutablePath } : {},
 			settingSources: SETTING_SOURCES,
 			systemPrompt: {
 				preset: "claude_code",
@@ -909,6 +1054,30 @@ const createSessionOpener = ({ emit, onSessionOpen, onSessionsChange, openSessio
 	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);
@@ -1051,6 +1220,9 @@ const createClaudeAgentSdkDriver = ({ onEvents, onSessionOpen, onSessionsChange
 		});
 	};
 	return {
+		backgroundTasks: async (sessionId) => {
+			await getOpenSession(sessionId).query.backgroundTasks();
+		},
 		close: async () => {
 			for (const sessionId of openSessionMap.keys()) closeSession(sessionId);
 			await taskRegistry.drain();
@@ -1076,28 +1248,7 @@ const createClaudeAgentSdkDriver = ({ onEvents, onSessionOpen, onSessionsChange
 		interrupt: async (sessionId) => {
 			await getOpenSession(sessionId).query.interrupt();
 		},
-		listSessions: async () => {
-			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];
-		},
+		listSessions: () => listSessionSummaries(openSessionMap),
 		prompt,
 		resolvePermission: (sessionId, requestId, behavior, message) => {
 			getOpenSession(sessionId).pendingPermissionMap.get(requestId)?.settle(behavior, message);
@@ -1143,22 +1294,86 @@ const createClaudeAgentSdkDriver = ({ onEvents, onSessionOpen, onSessionsChange
 			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/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();
+//#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 = Temporal.Duration.from({ seconds: 30 }).total("milliseconds");
+//#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["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/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,
+	childSessionOpenMessageSchema,
+	childSessionsChangeMessageSchema
+]);
+//#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
@@ -1169,38 +1384,312 @@ const checkIsTokenValid = (candidate, token) => {
 	return candidateBuffer.length === tokenBuffer.length && timingSafeEqual(candidateBuffer, tokenBuffer);
 };
 //#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;
+//#region src/services/drivers/window/createWindowDriver.ts
+const createWindowDriver = ({ onEvents, onSessionOpen, onSessionsChange }, { launchSessionWindow, 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();
+	});
+	httpServer.on("upgrade", (request, socket, head) => {
+		const secret = request.headers.authorization?.replace(/^Bearer /u, "") ?? "";
+		const pendingLaunchEntry = [...pendingLaunchMap].find(([launchSecret]) => checkIsTokenValid(secret, launchSecret));
+		if (!pendingLaunchEntry) {
+			socket.end("HTTP/1.1 401 Unauthorized\r\n\r\n");
+			return;
+		}
+		const [launchSecret, { connection, timeout }] = pendingLaunchEntry;
+		pendingLaunchMap.delete(launchSecret);
+		clearTimeout(timeout);
+		webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
+			connection.resolve(webSocket);
+		});
+	});
+	let listening;
+	const listen = async () => {
+		httpServer.listen(0, DEFAULT_HOSTNAME);
+		await once(httpServer, "listening");
+		const address = httpServer.address();
+		return typeof address === "object" && address ? address.port : 0;
+	};
+	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();
+	};
+	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;
 				}
-				if (sessionEvents.eventIds.has(event.id)) continue;
-				sessionEvents.eventIds.add(event.id);
-				sessionEvents.events.push(event);
-				newEvents.push(event);
+				onEvents(sessionId, events);
+				if (isHeld && windowSession.state === "Closed") closeWindowSession(sessionId, windowSession);
+				return;
 			}
-			return newEvents;
+			case "SessionOpen":
+				windowSessionMap.set(childMessage.sessionId, {
+					child,
+					cwd: child.cwd,
+					lastActivityAt: /* @__PURE__ */ new Date(),
+					state: "Idle",
+					title: ""
+				});
+				writeLine(`A session in ${child.cwd} opened in a window of its own.`);
+				onSessionOpen(childMessage.sessionId);
+				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);
+		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 openWindow = async (cwd) => {
+		const port = await (listening ??= listen());
+		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);
+		pendingLaunchMap.set(secret, {
+			connection,
+			timeout
+		});
+		launchSessionWindow({
+			port,
+			secret
+		});
+		const webSocket = await connection.promise;
+		const child = {
+			cwd,
+			pendingReplyMap: /* @__PURE__ */ new Map(),
+			webSocket
+		};
+		childSet.add(child);
+		webSocket.on("message", (data) => {
+			receive(child, data);
+		});
+		webSocket.on("close", () => {
+			removeChild(child);
+		});
+		return child;
+	};
+	const openInWindow = async (cwd, command) => {
+		const child = await openWindow(cwd);
+		return getResultAsync(() => sendChildCommand(child, command)).match((sessionId) => sessionId, (error) => {
+			child.webSocket.close();
+			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"
+			});
 		},
-		entries: () => Array.from(sessionEventMap, ([sessionId, { events }]) => [sessionId, events]),
-		reset: (sessionId) => {
-			sessionEventMap.delete(sessionId);
+		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();
+			const children = [...childSet];
+			for (const { webSocket } of children) webSocket.terminate();
+			await Promise.all(children.map(({ webSocket }) => once(webSocket, "close")));
+			await taskRegistry.drain();
+			if (!listening) return;
+			await listening;
+			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((_, index) => `"%${SESSION_COMMAND_ENVIRONMENT_VARIABLE_PREFIX}${index}%"`).join(" ");
+	spawn("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/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/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 "";
@@ -1230,6 +1719,281 @@ const handleCommand = async (driver, command) => {
 		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/drivers/window/serveSessionChild.ts
+const serveSessionChild = async (webSocket, createDriver, writeLine) => {
+	const taskRegistry = createTaskRegistry();
+	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);
+			}
+			send({
+				events,
+				sessionId,
+				type: "Events"
+			});
+		},
+		onSessionOpen: (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"
+			});
+		});
+	};
+	webSocket.on("message", (data) => {
+		taskRegistry.run(() => receive(readMessageText(data)));
+	});
+	await once(webSocket, "close");
+	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 webSocket = new WebSocket(`ws://${DEFAULT_HOSTNAME}:${port}`, { headers: { authorization: `Bearer ${secret}` } });
+	const serving = serveSessionChild(webSocket, createClaudeAgentSdkDriver, writeLine);
+	await once(webSocket, "open");
+	writeLine("This window shows one session as it runs. Type to it in the page.\nTo stop it, close this window.\n");
+	const stop = () => {
+		webSocket.close();
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGHUP", stop);
+	await serving;
+};
+//#endregion
+//#region src/services/installer/checkIsHostInstalled.ts
+const checkIsHostInstalled = () => relative(getHostInstallDirectory(), dirname(process.execPath)) === "";
+//#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 void 0;
+	return { code: url.searchParams.get("code") ?? "" };
+};
+//#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("reg", [
+		"add",
+		...registryArguments,
+		"/f"
+	], { stdio: "ignore" });
+	return installDirectory;
+};
+//#endregion
+//#region src/services/installer/uninstallHost.ts
+const uninstallHost = () => {
+	execFileSync("reg", [
+		"delete",
+		HOST_SCHEME_REGISTRY_KEY,
+		"/f"
+	], { stdio: "ignore" });
+	spawn("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",
+		windowsHide: true
+	}).unref();
+};
+//#endregion
+//#region src/services/device/hashCredential.ts
+const hashCredential = (credential) => createHash("sha256").update(credential).digest("base64url");
+//#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, duration) => {
+			clearTimeout(codeTimeoutMap.get(code));
+			codeTimeoutMap.set(code, setTimeout(() => {
+				codeTimeoutMap.delete(code);
+			}, duration));
+		},
+		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/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);
 	}
 };
@@ -1239,13 +2003,91 @@ 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, hostname, port, token }) => {
+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 webSocketServer.clients) sendServerMessage(webSocket, message);
+		for (const webSocket of socketDeviceIdMap.keys()) sendServerMessage(webSocket, message);
 	};
 	let isRefreshing = false;
 	let isRefreshStale = false;
@@ -1268,6 +2110,22 @@ const createAgentConsoleServer = async ({ createDriver, hostname, port, token })
 			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);
@@ -1276,8 +2134,10 @@ const createAgentConsoleServer = async ({ createDriver, hostname, port, token })
 				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,
@@ -1289,8 +2149,7 @@ const createAgentConsoleServer = async ({ createDriver, hostname, port, token })
 		}
 	});
 	const receive = async (webSocket, data) => {
-		const text = Buffer.isBuffer(data) ? data.toString() : Array.isArray(data) ? Buffer.concat(data).toString() : Buffer.from(data).toString();
-		const command = getResult(() => commandSchema.parse(JSON.parse(text))).orTee((error) => {
+		const command = getResult(() => commandSchema.parse(JSON.parse(readMessageText(data)))).orTee((error) => {
 			sendServerMessage(webSocket, {
 				commandId: "",
 				message: error.message,
@@ -1298,39 +2157,147 @@ const createAgentConsoleServer = async ({ createDriver, hostname, port, token })
 			});
 		}).unwrapOr(void 0);
 		if (!command) return;
-		await getResultAsync(() => handleCommand(driver, command)).match((sessionId) => {
-			if (sessionId) sendServerMessage(webSocket, {
-				commandId: command.id,
-				sessionId,
-				type: "SessionOpened"
-			});
-			else if (command.type === "ListSessions") refreshSessions();
-		}, (error) => {
+		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;
+			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);
+		}
 	};
-	webSocketServer.on("connection", (webSocket) => {
+	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);
+				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) => {
-			taskRegistry.run(() => receive(webSocket, 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) => {
-		const url = new URL(request.url ?? "/", "http://localhost");
-		if (!checkIsTokenValid(url.searchParams.get("token") ?? "", token)) {
-			socket.end("HTTP/1.1 401 Unauthorized\r\n\r\n");
+		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) => {
@@ -1340,38 +2307,60 @@ const createAgentConsoleServer = async ({ createDriver, hostname, port, token })
 	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 {
-		close: async () => {
-			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")
-			]);
-		},
+		addPairingCode: pairingCodes.add,
+		close: () => closing ??= close(),
 		port: typeof address === "object" && address ? address.port : port
 	};
 };
 //#endregion
-//#region src/services/server/constants.ts
-const TOKEN_DIRECTORY_NAME = ".agent-console-server";
-const TOKEN_FILENAME = "token";
-const TOKEN_BYTE_LENGTH = 32;
-//#endregion
-//#region src/services/server/readToken.ts
-const readToken = () => {
-	const tokenDirectory = join(homedir(), TOKEN_DIRECTORY_NAME);
-	const tokenPath = join(tokenDirectory, TOKEN_FILENAME);
-	const storedToken = existsSync(tokenPath) ? readFileSync(tokenPath, "utf8").trim() : "";
-	if (storedToken) return storedToken;
-	const token = randomBytes(32).toString("base64url");
-	mkdirSync(tokenDirectory, { recursive: true });
-	rmSync(tokenPath, { force: true });
-	writeFileSync(tokenPath, token, { mode: 384 });
-	return token;
+//#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/shell/getShellFile.ts
+const getShellFile = () => process.platform === "win32" ? "powershell.exe" : process.env.SHELL ?? "/bin/sh";
+//#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");
+	});
+	return spawn(getShellFile(), [], {
+		cols,
+		cwd,
+		env: process.env,
+		name: "xterm-256color",
+		rows
+	});
 };
 //#endregion
-export { mapHookMessage as A, createInputQueue as B, toTurnResultEvents as C, toToolResultText as D, mapUserContent as E, createStreamTracker as F, closeOpenSession as G, IGNORED_SDK_MESSAGE_TYPES as H, createFileOriginTracker as I, getEventId as K, createPermissionBridge as L, toUnknownEvent as M, createTodoTracker as N, mapSystemMessage as O, TodoToolName as P, toPermissionResult as R, createSdkMessageMapper as S, parseMessageBody as T, SESSION_LIST_LIMIT as U, DEFAULT_DENY_MESSAGE as V, SETTING_SOURCES as W, toContextUsageEvent as _, createAgentConsoleServer as a, readToolUseResultMap as b, createEventLog as c, createClaudeAgentSdkDriver as d, createTaskRegistry as f, watchSession as g, createSessionOpener as h, TOKEN_FILENAME as i, mapAssistantContent as j, mapTaskMessage as k, checkIsTokenValid as l, readSessionCwd as m, TOKEN_BYTE_LENGTH as n, sendServerMessage as o, toContentBlockParam as p, TOKEN_DIRECTORY_NAME as r, handleCommand as s, readToken as t, answerHttpRequest as u, toCapabilitiesEvent as v, toSessionInitEvent as w, readSessionHistory as x, getSessionTitle as y, toPermissionRequestEvent as z };
+export { HOST_DIRECTORY_ENVIRONMENT_VARIABLE as $, sendChildCommand as A, IGNORED_SDK_MESSAGE_TYPES as At, SESSION_SECRET_BYTE_LENGTH as B, signNonce as Bt, serveSessionChild as C, createStreamTracker as Ct, createWindowDriver as D, toPermissionRequestEvent as Dt, launchSessionWindow as E, toPermissionResult as Et, childCommandResultMessageSchema as F, getEventId as Ft, createTaskRegistry as G, readHostKey as Gt, SESSION_SUBCOMMAND as H, writeDevices as Ht, childCommandErrorMessageSchema as I, runDevicesCommand as It, listSessionSummaries as J, DEVICES_FILENAME as Jt, toContentBlockParam as K, writeStateFile as Kt, ChildMessageType as L, sendToRunningHost as Lt, childSessionsChangeMessageSchema as M, SETTING_SOURCES as Mt, childSessionOpenMessageSchema as N, closeOpenSession as Nt, checkIsTokenValid as O, createInputQueue as Ot, childEventsMessageSchema as P, toSessionClosedEvents as Pt, CLAUDE_CODE_EXECUTABLE_FILENAME as Q, STATE_DIRECTORY_NAME as Qt, childMessageTypeSchema as R, readMessageText as Rt, runSessionChild as S, TodoToolName as St, formatSessionLogLine as T, createPermissionBridge as Tt, SESSION_WINDOW_CONNECT_TIMEOUT as U, readDevices as Ut, SESSION_SECRET_ENVIRONMENT_VARIABLE as V, checkIsSignatureValid as Vt, createClaudeAgentSdkDriver as W, deviceSchema as Wt, getClaudeCodeExecutablePath as X, PRINTED_PAIRING_CODE_DURATION as Xt, createSessionOpener as Y, HOST_KEY_FILENAME as Yt, getHostInstallDirectory as Z, SECRET_BYTE_LENGTH as Zt, uninstallHost as _, mapTaskMessage as _t, CONSOLE_LIST_AGENT_NAME as a, toContextUsageEvent as at, checkIsSchemeLaunchTampered as b, toUnknownEvent as bt, sendServerMessage as c, readToolUseResultMap as ct, createEventLog as d, toTurnResultEvents as dt, HOST_EXECUTABLE_FILENAME as et, answerHttpRequest as f, toSessionInitEvent as ft, hashCredential as g, mapSystemMessage as gt, findDevice as h, toToolResultText as ht, runConsoleListAgent as i, watchSession as it, childMessageSchema as j, SESSION_LIST_LIMIT as jt, takeChildReply as k, DEFAULT_DENY_MESSAGE as kt, handleShellCommand as l, readSessionHistory as lt, getDeviceName as m, mapUserContent as mt, loadNodePty as n, HOST_SCHEME_REGISTRY_KEY as nt, createAgentConsoleServer as o, toCapabilitiesEvent as ot, getPublicKeyText as p, parseMessageBody as pt, readSessionCwd as q, getStateDirectory as qt, getShellFile as r, NODE_PTY_DIRECTORY_NAME as rt, createShellRegistry as s, getSessionTitle as st, spawnPtyShell as t, HOST_INSTALL_DIRECTORY_SEGMENTS as tt, createPairingCodes as u, createSdkMessageMapper as ut, installHost as v, mapHookMessage as vt, handleCommand as w, createFileOriginTracker as wt, checkIsHostInstalled as x, createTodoTracker as xt, getSchemeLaunch as y, mapAssistantContent as yt, createBaseChildMessageSchema as z, HOST_PROBE_TIMEOUT_MS as zt };