agent-console-server 3.3.0

package/dist/readToken-CAukYBGj.js

@@ -0,0 +1,1377 @@
+import { M as todoStatusSchema, P as permissionModeSchema, i as commandSchema, t as EphemeralAgentEventTypes } from "./EphemeralAgentEventTypes-Cm5oNQXu.js";
+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 { homedir } from "node:os";
+import { join } from "node:path";
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { WebSocket, WebSocketServer } from "ws";
+import { once } from "node:events";
+import { createServer } from "node:http";
+//#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", "");
+	const createdAt = /* @__PURE__ */ new Date();
+	const closedId = getEventId(crypto.randomUUID(), "SessionState");
+	emit(sessionId, [...message ? [{
+		createdAt,
+		id: getEventId(closedId, "HostError"),
+		message,
+		type: "HostError"
+	}] : [], {
+		createdAt,
+		id: closedId,
+		state: "Closed",
+		type: "SessionState"
+	}]);
+	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"
+	};
+	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 stateEvent = {
+					createdAt,
+					id: message.uuid,
+					state: message.status === "compacting" ? "Compacting" : "Running",
+					type: "SessionState"
+				};
+				return message.permissionMode ? [stateEvent, updateSettings(getEventId(message.uuid, "SessionSettings"), createdAt, { permissionMode: message.permissionMode })] : [stateEvent];
+			} 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/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 sessionQuery = query({
+		options: {
+			canUseTool: createPermissionBridge(sessionId, pendingPermissionMap, emit),
+			cwd,
+			enableFileCheckpointing: true,
+			env: {
+				...process.env,
+				CLAUDE_CODE_ENABLE_TODO_TOOLS: "true"
+			},
+			includeHookEvents: true,
+			includePartialMessages: true,
+			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/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 {
+		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: 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];
+		},
+		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 })]);
+		}
+	};
+};
+//#endregion
+//#region src/services/server/constants.ts
+const HOST_NAME = "agent-console-server";
+const TOKEN_DIRECTORY_NAME = ".agent-console-server";
+const TOKEN_FILENAME = "token";
+const TOKEN_BYTE_LENGTH = 32;
+//#endregion
+//#region src/services/server/answerHttpRequest.ts
+const answerHttpRequest = ({ headers, method }, response) => {
+	response.setHeader("Access-Control-Allow-Origin", headers.origin ?? "*");
+	response.setHeader("Access-Control-Allow-Private-Network", "true");
+	response.setHeader("Vary", "Origin");
+	if (method === "OPTIONS") {
+		response.setHeader("Access-Control-Allow-Methods", "GET");
+		response.setHeader("Access-Control-Allow-Headers", headers["access-control-request-headers"] ?? "*");
+		response.writeHead(204).end();
+	} else if (method === "GET") response.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ name: HOST_NAME }));
+	else response.writeHead(405).end();
+};
+//#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/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/handleCommand.ts
+const handleCommand = async (driver, command) => {
+	switch (command.type) {
+		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 "";
+		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/server/createAgentConsoleServer.ts
+const createAgentConsoleServer = async ({ createDriver, hostname, port, token }) => {
+	const eventLog = createEventLog();
+	const taskRegistry = createTaskRegistry();
+	const webSocketServer = new WebSocketServer({ noServer: true });
+	const broadcast = (message) => {
+		for (const webSocket of webSocketServer.clients) 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 driver = createDriver({
+		onEvents: (sessionId, events) => {
+			const newEvents = eventLog.append(sessionId, events);
+			if (newEvents.length > 0) broadcast({
+				events: newEvents,
+				sessionId,
+				type: "Events"
+			});
+		},
+		onSessionOpen: (sessionId) => {
+			eventLog.reset(sessionId);
+			broadcast({
+				sessionId,
+				type: "SessionReset"
+			});
+		},
+		onSessionsChange: () => {
+			refreshSessions();
+		}
+	});
+	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) => {
+			sendServerMessage(webSocket, {
+				commandId: "",
+				message: error.message,
+				type: "CommandError"
+			});
+		}).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) => {
+			sendServerMessage(webSocket, {
+				commandId: command.id,
+				message: error.message,
+				type: "CommandError"
+			});
+		});
+	};
+	webSocketServer.on("connection", (webSocket) => {
+		for (const [sessionId, events] of eventLog.entries()) sendServerMessage(webSocket, {
+			events,
+			sessionId,
+			type: "Events"
+		});
+		refreshSessions();
+		webSocket.on("message", (data) => {
+			taskRegistry.run(() => receive(webSocket, data));
+		});
+	});
+	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");
+			return;
+		}
+		webSocketServer.handleUpgrade(request, socket, head, (webSocket) => {
+			webSocketServer.emit("connection", webSocket, request);
+		});
+	});
+	httpServer.listen(port, hostname);
+	await once(httpServer, "listening");
+	const address = httpServer.address();
+	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")
+			]);
+		},
+		port: typeof address === "object" && address ? address.port : port
+	};
+};
+//#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;
+};
+//#endregion
+export { mapTaskMessage as A, toPermissionRequestEvent as B, createSdkMessageMapper as C, mapUserContent as D, parseMessageBody as E, TodoToolName as F, SETTING_SOURCES as G, DEFAULT_DENY_MESSAGE as H, createStreamTracker as I, closeOpenSession as K, createFileOriginTracker as L, mapAssistantContent as M, toUnknownEvent as N, toToolResultText as O, createTodoTracker as P, createPermissionBridge as R, readSessionHistory as S, toSessionInitEvent as T, IGNORED_SDK_MESSAGE_TYPES as U, createInputQueue as V, SESSION_LIST_LIMIT as W, watchSession as _, createEventLog as a, getSessionTitle as b, HOST_NAME as c, TOKEN_FILENAME as d, createClaudeAgentSdkDriver as f, createSessionOpener as g, readSessionCwd as h, handleCommand as i, mapHookMessage as j, mapSystemMessage as k, TOKEN_BYTE_LENGTH as l, toContentBlockParam as m, createAgentConsoleServer as n, checkIsTokenValid as o, createTaskRegistry as p, getEventId as q, sendServerMessage as r, answerHttpRequest as s, readToken as t, TOKEN_DIRECTORY_NAME as u, toContextUsageEvent as v, toTurnResultEvents as w, readToolUseResultMap as x, toCapabilitiesEvent as y, toPermissionResult as z };