@treeport/treeport 0.5.0 → 0.6.1

package/dist/node/server/index.js

@@ -1,11 +1,13 @@
-import { $ as repositoryTerminalPresetSchema, At as terminalSizeSchema, B as createWorktreeSchema, Ct as parseTerminalProgress, Dt as terminalLegacyTakeControlSchema, Et as terminalInputSchema, G as openWebPanelSchema, H as deleteWebPanelStorageSchema, I as browseDirectoryQuerySchema, J as packageReloadSchema, K as packageInstallSchema, L as createTerminalPresetSchema, M as parseDurationMs, Ot as terminalOutputAckSchema, P as TERMINAL_MAX_UPLOAD_BYTES, Q as removeWorktreeSchema, R as createTerminalSchema, St as parseTerminalAuth, Tt as terminalBinarySchema, U as formatCommandLine, V as deleteTerminalPresetSchema, W as getWebPanelStorageSchema, X as packageUpdateSchema, Y as packageRemoveSchema, Z as registerProjectSchema, _ as serviceStatus, _t as TERMINAL_SCROLL_EXIT_SEQUENCE, a as readLocalUpdateProgress, at as updateTerminalPresetSchema, bt as TERMINAL_SELECTION_START_SEQUENCE, c as createUpdateStartupReporter, dt as TERMINAL_CONTROLLER_GRACE_MS, et as repositoryTerminalPresetsFileSchema, ft as TERMINAL_MAX_CLIENT_MESSAGE_BYTES, gt as TERMINAL_OUTPUT_STALL_TIMEOUT_MS, i as isCanonicalTreeportVersion, it as updateProjectSchema, j as assertLoopbackHost, jt as terminalTakeControlSchema, kt as terminalResizeSchema, n as compareTreeportVersions, nt as setWebPanelStorageSchema, o as resolveLatestTreeportRelease, ot as updateTerminalSchema, q as packageProjectQuerySchema, r as inspectLocalUpdateInstallation, rt as terminalCaptureQuerySchema, st as webPanelInputSchema, tt as requestWorkspaceOpenSchema, ut as SOCKET_IO_PATH, vt as TERMINAL_SELECTION_CLEAR_SEQUENCE, wt as terminalBellAcknowledgementSchema, xt as TERMINAL_SELECTION_STOP_SEQUENCE, yt as TERMINAL_SELECTION_RESTORE_SEQUENCE, z as createWebPanelSchema } from "../../update-BW-a6Bd-.js";
+import { $ as TERMINAL_SELECTION_STOP_SEQUENCE, A as terminalCaptureQuerySchema, C as readTreeFileSchema, D as repositoryTerminalPresetsFileSchema, E as repositoryTerminalPresetSchema, F as updateTerminalPresetSchema, H as SOCKET_IO_PATH, I as updateTerminalSchema, J as TERMINAL_OUTPUT_STALL_TIMEOUT_MS, L as updateWebPanelPermissionGrantSchema, M as treeContextValuesSchema, N as treeFilePathSchema, O as requestWorkspaceOpenSchema, P as updateProjectSchema, Q as TERMINAL_SELECTION_START_SEQUENCE, R as webPanelInputSchema, S as packageUpdateSchema, T as removeWorktreeSchema, U as TERMINAL_CONTROLLER_GRACE_MS, W as TERMINAL_MAX_CLIENT_MESSAGE_BYTES, X as TERMINAL_SELECTION_CLEAR_SEQUENCE, Y as TERMINAL_SCROLL_EXIT_SEQUENCE, Z as TERMINAL_SELECTION_RESTORE_SEQUENCE, _ as openWebPanelSchema, _t as parseBrowserAuth, at as terminalLegacyTakeControlSchema, b as packageReloadSchema, bt as parseBrowserOwnerClientMessage, c as createTerminalPresetSchema, ct as terminalSizeSchema, d as createWorktreeSchema, et as parseTerminalAuth, f as deleteTerminalPresetSchema, ft as browserAgentCommandSchema, g as openBrowserPanelFromTerminalSchema, gt as browserUrlSchema, h as getWebPanelStorageSchema, ht as browserTicketRequestSchema, i as TREE_FILE_MAX_BYTES, it as terminalInputSchema, j as treeContextFieldDefinitionSchema, k as setWebPanelStorageSchema, l as createTerminalSchema, lt as terminalTakeControlSchema, m as formatCommandLine, mt as browserOwnerTicketRequestSchema, n as TERMINAL_MAX_UPLOAD_BYTES, nt as terminalBellAcknowledgementSchema, o as browseDirectoryQuerySchema, ot as terminalOutputAckSchema, p as deleteWebPanelStorageSchema, pt as browserOwnerEndpointSchema, r as TREE_FILE_LIST_MAX_ENTRIES, rt as terminalBinarySchema, s as createBrowserPanelSchema, st as terminalResizeSchema, tt as parseTerminalProgress, u as createWebPanelSchema, ut as webPanelPermissionSchema, v as packageInstallSchema, vt as parseBrowserClientMessage, w as registerProjectSchema, x as packageRemoveSchema, y as packageProjectQuerySchema, yt as parseBrowserOwnerAuth, z as writeTreeFileSchema } from "../../dist-Crk_Xr82.js";
+import { M as parseDurationMs, _ as serviceStatus, a as readLocalUpdateProgress, c as createUpdateStartupReporter, i as isCanonicalTreeportVersion, j as assertLoopbackHost, n as compareTreeportVersions, o as resolveLatestTreeportRelease, r as inspectLocalUpdateInstallation } from "../../update-qVp7yL5D.js";
 import { n as prepareShellIntegration } from "../../shell-integration-Be_c91lw.js";
+import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { execFile, spawn } from "node:child_process";
 import crypto from "node:crypto";
-import fsSync, { existsSync } from "node:fs";
+import fsSync, { constants, existsSync } from "node:fs";
 import os from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { createServer } from "node:http";
@@ -34,6 +36,7 @@ import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { requestId } from "hono/request-id";
 import { validator } from "hono/validator";
+import { getConnInfo } from "@hono/node-server/conninfo";
 import { serveStatic } from "@hono/node-server/serve-static";
 import { zValidator } from "@hono/zod-validator";
 import * as Fiber from "effect/Fiber";
@@ -353,10 +356,12 @@ function loadConfig(env = process.env) {
 //#endregion
 //#region src/server/core/database-schema.ts
 var database_schema_exports = /* @__PURE__ */ __exportAll({
+	browserPanels: () => browserPanels,
 	operations: () => operations,
 	projects: () => projects,
 	terminalBellStates: () => terminalBellStates,
 	terminalPresets: () => terminalPresets,
+	webPanelPermissionGrants: () => webPanelPermissionGrants,
 	webPanelStorage: () => webPanelStorage,
 	webPanels: () => webPanels,
 	worktrees: () => worktrees
@@ -401,6 +406,7 @@ const worktrees = sqliteTable("worktrees", {
 	kind: text().notNull(),
 	tmuxSocketName: text("tmux_socket_name").notNull().unique(),
 	managedWrapperPath: text("managed_wrapper_path"),
+	treeContextJson: text("tree_context_json").notNull().default("{}"),
 	prState: text("pr_state").notNull().default("unknown"),
 	prNumber: integer("pr_number"),
 	prUrl: text("pr_url"),
@@ -425,6 +431,14 @@ const terminalBellStates = sqliteTable("terminal_bell_states", {
 	occurredAt: text("occurred_at").notNull(),
 	unread: integer().notNull()
 }, (table) => [check("terminal_bell_states_sequence_check", sql`${table.sequence} > 0`), check("terminal_bell_states_unread_check", sql`${table.unread} IN (0,1)`)]);
+const browserPanels = sqliteTable("browser_panels", {
+	id: text().primaryKey(),
+	worktreeId: text("worktree_id").notNull().references(() => worktrees.id, { onDelete: "cascade" }),
+	title: text().notNull(),
+	url: text().notNull(),
+	createdAt: text("created_at").notNull(),
+	updatedAt: text("updated_at").notNull()
+}, (table) => [index("browser_panels_worktree_order_idx").on(table.worktreeId, table.createdAt, table.id)]);
 const webPanels = sqliteTable("web_panels", {
 	id: text().primaryKey(),
 	worktreeId: text("worktree_id").notNull().references(() => worktrees.id, { onDelete: "cascade" }),
@@ -435,6 +449,13 @@ const webPanels = sqliteTable("web_panels", {
 	createdAt: text("created_at").notNull(),
 	updatedAt: text("updated_at").notNull()
 }, (table) => [index("web_panels_worktree_order_idx").on(table.worktreeId, table.createdAt, table.id)]);
+const webPanelPermissionGrants = sqliteTable("web_panel_permission_grants", {
+	sourceKey: text("source_key").primaryKey(),
+	definitionId: text("definition_id").notNull(),
+	permissionsJson: text("permissions_json").notNull(),
+	grantedAt: text("granted_at").notNull(),
+	updatedAt: text("updated_at").notNull()
+}, (table) => [index("web_panel_permission_definition_idx").on(table.definitionId)]);
 const webPanelStorage = sqliteTable("web_panel_storage", {
 	panelId: text("panel_id").notNull().references(() => webPanels.id, { onDelete: "cascade" }),
 	key: text().notNull(),
@@ -764,8 +785,10 @@ const BACKUP_RETENTION = 2;
 const createOperationRequestSchema = z.strictObject({
 	name: z.string(),
 	base: z.enum(["default", "current"]),
+	context: treeContextValuesSchema.optional(),
 	initialTerminal: z.strictObject({
 		name: z.string(),
+		initialTitle: z.string().optional(),
 		argv: z.array(z.string()).optional(),
 		returnToShell: z.boolean().optional(),
 		initialSize: z.strictObject({
@@ -1642,6 +1665,16 @@ var GitAdapter = class {
 	async dirtyState(cwd) {
 		return (await this.dirtyStatus(cwd)).dirty;
 	}
+	async worktreeFiles(cwd) {
+		const result = await this.checked(cwd, [
+			"ls-files",
+			"--cached",
+			"--others",
+			"--exclude-standard",
+			"-z"
+		]);
+		return [...new Set(result.stdout.split("\0").filter(Boolean))].sort();
+	}
 	async worktreeDiff(cwd, defaultBranch) {
 		const candidates = [`origin/${defaultBranch}`, defaultBranch];
 		let baseRef = "";
@@ -2066,7 +2099,7 @@ z.unknown();
 const manifestPatternsSchema = z.array(z.string());
 const webPanelManifestEntrySchema = z.union([z.string(), z.strictObject({
 	source: z.string(),
-	permissions: z.array(z.enum(["same-origin"])).optional()
+	permissions: z.array(webPanelPermissionSchema).optional()
 })]);
 const EMPTY_SETTINGS = {
 	raw: {},
@@ -2478,19 +2511,20 @@ var PackageSystem = class {
 				this.validateManifestPatterns([parsedSource.data], "webPanels", packageJsonPath);
 				return {
 					source: parsedSource.data,
-					allowSameOrigin: false
+					permissions: []
 				};
 			}
 			const { source, permissions = [] } = z.strictObject({
 				source: z.string(),
-				permissions: z.array(z.enum(["same-origin"])).optional()
+				permissions: z.array(webPanelPermissionSchema).optional()
 			}).parse(parsed.data);
 			if (source.startsWith("!")) throw new Error(`${packageJsonPath} contains an invalid web panel definition`);
 			this.validateManifestPatterns([source], "webPanels", packageJsonPath);
-			if (new Set(permissions).size !== permissions.length) throw new Error(`${packageJsonPath} contains an invalid web panel permission`);
+			const uniquePermissions = new Set(permissions);
+			if (uniquePermissions.size !== permissions.length) throw new Error(`${packageJsonPath} contains an invalid web panel permission`);
 			return {
 				source,
-				allowSameOrigin: permissions.includes("same-origin")
+				permissions: [...uniquePermissions]
 			};
 		});
 	}
@@ -2628,13 +2662,15 @@ var PackageSystem = class {
 		})).then((values) => values.find(Boolean)) : void 0;
 		const webPanels = applyNormalFilter(panelCandidates.map((candidate) => {
 			const resourceId = encodeURIComponent(path.posix.basename(candidate.relativePath));
-			const allowSameOrigin = manifest?.webPanels.some((entry) => entry.allowSameOrigin && this.manifestAllows(candidate.relativePath, [entry.source], "web-panel")) ?? false;
+			const permissions = [...new Set((manifest?.webPanels ?? []).filter((entry) => this.manifestAllows(candidate.relativePath, [entry.source], "web-panel")).flatMap((entry) => entry.permissions))];
 			const resolved = {
 				definition: {
 					id: `package:${parsed.packageId}:web-panel:${resourceId}`,
 					title: titleFromPath(candidate.relativePath),
 					source: metadata,
-					sandbox: { allowSameOrigin }
+					permissions,
+					permissionsGranted: permissions.length === 0,
+					sandbox: { allowSameOrigin: permissions.includes("same-origin") }
 				},
 				root: candidate.root,
 				entry: "index.html",
@@ -3276,6 +3312,120 @@ async function loadRepositoryTerminalPresets(projectId, worktreePath) {
 	};
 }
 //#endregion
+//#region src/server/core/tree-context.ts
+async function loadTreeContextFields({ dataDir, projectRoot }) {
+	const diagnostics = [];
+	const definitionsByScope = [];
+	const settingsFiles = [{
+		scope: "global",
+		path: path.join(dataDir, "settings.json")
+	}, {
+		scope: "project",
+		path: path.join(projectRoot, ".treeport", "settings.json")
+	}];
+	for (const settings of settingsFiles) {
+		const content = await fs.readFile(settings.path, "utf8").catch((error) => {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+			diagnostics.push({
+				scope: settings.scope,
+				path: settings.path,
+				message: `Could not read ${settings.path}: ${error instanceof Error ? error.message : String(error)}`
+			});
+			return null;
+		});
+		if (content === null || content.trim() === "") {
+			definitionsByScope.push([]);
+			continue;
+		}
+		let parsedJson;
+		try {
+			parsedJson = JSON.parse(content);
+		} catch (error) {
+			diagnostics.push({
+				scope: settings.scope,
+				path: settings.path,
+				message: `Could not parse ${settings.path}: ${error instanceof Error ? error.message : String(error)}`
+			});
+			definitionsByScope.push([]);
+			continue;
+		}
+		const parsedSettings = z.looseObject({ treeContext: z.unknown().optional() }).safeParse(parsedJson);
+		if (!parsedSettings.success) {
+			diagnostics.push({
+				scope: settings.scope,
+				path: settings.path,
+				message: `${settings.path} must contain a JSON object`
+			});
+			definitionsByScope.push([]);
+			continue;
+		}
+		if (parsedSettings.data.treeContext === void 0) {
+			definitionsByScope.push([]);
+			continue;
+		}
+		const parsedTreeContext = z.looseObject({ fields: z.unknown().optional() }).safeParse(parsedSettings.data.treeContext);
+		const parsedFields = z.array(z.unknown()).safeParse(parsedTreeContext.success ? parsedTreeContext.data.fields ?? [] : void 0);
+		if (!parsedTreeContext.success || !parsedFields.success) {
+			diagnostics.push({
+				scope: settings.scope,
+				path: settings.path,
+				message: `${settings.path} treeContext.fields must be an array`
+			});
+			definitionsByScope.push([]);
+			continue;
+		}
+		const fields = [];
+		const ids = /* @__PURE__ */ new Set();
+		for (const [index, input] of parsedFields.data.entries()) {
+			if (fields.length === 64) {
+				diagnostics.push({
+					scope: settings.scope,
+					path: settings.path,
+					message: `${settings.path} treeContext.fields cannot contain more than 64 fields`
+				});
+				break;
+			}
+			const parsedField = treeContextFieldDefinitionSchema.safeParse(input);
+			if (!parsedField.success) {
+				diagnostics.push({
+					scope: settings.scope,
+					path: settings.path,
+					message: `${settings.path} treeContext.fields[${index}] is invalid: ${parsedField.error.issues[0]?.message ?? "invalid field"}`
+				});
+				continue;
+			}
+			if (ids.has(parsedField.data.id)) {
+				diagnostics.push({
+					scope: settings.scope,
+					path: settings.path,
+					message: `${settings.path} contains duplicate tree context field ${parsedField.data.id}`
+				});
+				continue;
+			}
+			ids.add(parsedField.data.id);
+			fields.push(parsedField.data);
+		}
+		definitionsByScope.push(fields);
+	}
+	const fields = /* @__PURE__ */ new Map();
+	for (const [index, definitions] of definitionsByScope.entries()) for (const definition of definitions) {
+		if (!fields.has(definition.id) && fields.size === 64) {
+			const settings = settingsFiles[index];
+			diagnostics.push({
+				scope: settings.scope,
+				path: settings.path,
+				message: `Tree context cannot contain more than 64 fields`
+			});
+			break;
+		}
+		fields.set(definition.id, definition);
+	}
+	return {
+		fields: [...fields.values()],
+		diagnostics
+	};
+}
+//#endregion
 //#region src/server/core/setup.ts
 const DEFAULT_SETUP_TIMEOUT_MS = 30 * 6e4;
 const MAX_SETUP_OUTPUT = 4e3;
@@ -3415,16 +3565,19 @@ var dependencies = {
 	"@hono/node-server": "^2.0.10",
 	"@hono/zod-validator": "^0.9.0",
 	"@libsql/client": "^0.17.4",
+	"@playwright/cli": "0.1.18",
 	"@radix-ui/react-context-menu": "^2.3.7",
 	"@treeport/panel-sdk": "workspace:*",
 	"@vitejs/plugin-react": "5.2.0",
 	"@xterm/headless": "^6.0.0",
+	"cmdk": "^1.1.1",
 	"commander": "14.0.3",
 	"drizzle-orm": "^0.45.2",
 	"effect": "^3.22.0",
 	"hono": "^4.11.7",
 	"jsonc-parser": "^3.3.1",
 	"node-pty": "1.2.0-beta.14",
+	"playwright": "1.61.1",
 	"socket.io": "4.8.3",
 	"socket.io-client": "4.8.3",
 	"vite": "8.1.5",
@@ -3822,7 +3975,7 @@ const TMUX_SELECTION_RESTORE_KEY = TMUX_SELECTION_RESTORE_SEQUENCE.replace("\x1B
 const TMUX_CONFIG = `# Generated by Treeport. This does not read or modify ~/.tmux.conf.
 set -g status off
 set -g default-terminal "tmux-256color"
-set -s terminal-features[999] "xterm-256color:hyperlinks"
+set -s terminal-features[999] "xterm*:hyperlinks"
 set -g extended-keys on
 if-shell -F '#{>=:#{version},3.5}' 'set-option -s extended-keys-format csi-u'
 set -g history-limit 50000
@@ -3834,7 +3987,7 @@ set -g bell-action any
 set -g visual-bell off
 set -g mouse on
 set -g destroy-unattached off
-set -g mode-style "bg=#1f1f22"
+set -g mode-style "fg=#09090b,bg=#f4f4f5"
 set -s set-clipboard external
 set -s user-keys[0] "${TMUX_SCROLL_EXIT_KEY}"
 set -s user-keys[1] "${TMUX_SELECTION_START_SEQUENCE.replace("\x1B", "\\033")}"
@@ -3974,6 +4127,7 @@ var TmuxAdapter = class {
 					cwd: input.cwd,
 					env: environment
 				};
+				if (input.initialTitle) spec.initialTitle = input.initialTitle;
 				if (input.fallbackArgv) spec.fallbackArgv = [...input.fallbackArgv];
 				spec.tmuxExecutable = resolveExecutablePath(this.executable, this.hostEnvironment);
 				if (shellIntegrationReady) spec.shellIntegrationDir = this.shellIntegrationDir;
@@ -4413,7 +4567,18 @@ const id = (prefix) => `${prefix}_${crypto.randomUUID().replaceAll("-", "")}`;
 const WEB_PANEL_STORAGE_MAX_ENTRIES = 256;
 const WEB_PANEL_STORAGE_MAX_TOTAL_BYTES = 1024 * 1024;
 const WEB_PANEL_STORAGE_MAX_VALUE_BYTES = 64 * 1024;
-function mapWebPanel(row, allowSameOrigin = false) {
+function mapBrowserPanel(row) {
+	return {
+		id: row.id,
+		kind: "browser",
+		worktreeId: row.worktreeId,
+		title: row.title,
+		url: row.url,
+		createdAt: row.createdAt,
+		updatedAt: row.updatedAt
+	};
+}
+function mapWebPanel(row, permissions = [], permissionsGranted = permissions.length === 0) {
 	const parsedInput = webPanelInputSchema.nullable().safeParse(JSON.parse(row.inputJson));
 	if (!parsedInput.success) throw new Error(`Web panel ${row.id} has invalid stored launch input`);
 	return {
@@ -4426,7 +4591,8 @@ function mapWebPanel(row, allowSameOrigin = false) {
 			input: parsedInput.data,
 			cwd: row.launchCwd
 		},
-		sandbox: { allowSameOrigin },
+		permissions,
+		sandbox: { allowSameOrigin: permissionsGranted && permissions.includes("same-origin") },
 		createdAt: row.createdAt,
 		updatedAt: row.updatedAt
 	};
@@ -4468,6 +4634,7 @@ var TreeportService = class {
 	projectLocks = /* @__PURE__ */ new Set();
 	worktreeMutations = new KeyedTaskQueue();
 	terminalMutations = new KeyedTaskQueue();
+	treeFileMutations = new KeyedTaskQueue();
 	removeConfirmationKey = crypto.randomBytes(32);
 	terminalStates = /* @__PURE__ */ new Map();
 	closeOnSuccessTerminalIds = /* @__PURE__ */ new Set();
@@ -4709,18 +4876,25 @@ var TreeportService = class {
 				})]);
 				worktree.dirty = dirty;
 				worktree.terminals = terminals;
-				const storedWebPanels = await this.deps.database.db.select().from(webPanels).where(eq(webPanels.worktreeId, worktree.id)).orderBy(asc(webPanels.createdAt), asc(webPanels.id));
-				const definitions = project.availability.state === "available" && storedWebPanels.length > 0 ? await this.effectiveWebPanelDefinitions(worktree.id).catch(() => []) : [];
+				const [storedBrowserPanels, storedWebPanels] = await Promise.all([this.deps.database.db.select().from(browserPanels).where(eq(browserPanels.worktreeId, worktree.id)).orderBy(asc(browserPanels.createdAt), asc(browserPanels.id)), this.deps.database.db.select().from(webPanels).where(eq(webPanels.worktreeId, worktree.id)).orderBy(asc(webPanels.createdAt), asc(webPanels.id))]);
+				const definitions = project.availability.state === "available" && storedWebPanels.length > 0 ? await this.listWebPanelDefinitions(worktree.id).catch(() => []) : [];
 				const definitionsById = new Map(definitions.map((definition) => [definition.id, definition]));
-				worktree.panels = [...terminals.map((terminal) => ({
-					id: `panel_${terminal.id}`,
-					kind: "terminal",
-					worktreeId: worktree.id,
-					terminalId: terminal.id,
-					title: terminal.name,
-					createdAt: terminal.createdAt,
-					updatedAt: terminal.updatedAt
-				})), ...storedWebPanels.map((panel) => mapWebPanel(panel, definitionsById.get(panel.definitionId)?.sandbox.allowSameOrigin ?? false))].sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+				worktree.panels = [
+					...terminals.map((terminal) => ({
+						id: `panel_${terminal.id}`,
+						kind: "terminal",
+						worktreeId: worktree.id,
+						terminalId: terminal.id,
+						title: terminal.name,
+						createdAt: terminal.createdAt,
+						updatedAt: terminal.updatedAt
+					})),
+					...storedBrowserPanels.map(mapBrowserPanel),
+					...storedWebPanels.map((panel) => {
+						const definition = definitionsById.get(panel.definitionId);
+						return mapWebPanel(panel, definition?.permissions ?? [], definition?.permissionsGranted ?? false);
+					})
+				].sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
 			}));
 			return project;
 		}))).filter((project) => project !== null);
@@ -4828,7 +5002,21 @@ var TreeportService = class {
 	}
 	async removePackage(source, projectId) {
 		if (projectId) this.packages.syncProjects([await this.getProject(projectId)]);
+		const registeredProjects = projectId ? [await this.getProject(projectId)] : await this.storedProjects();
+		const collectPermissionSourceKeys = async () => {
+			const keys = /* @__PURE__ */ new Set();
+			for (const project of registeredProjects) {
+				const worktree = project.worktrees[0];
+				if (!worktree) continue;
+				const definitions = await this.effectiveWebPanelDefinitions(worktree.id).catch(() => []);
+				for (const definition of definitions) if (definition.permissions.length > 0) keys.add(await this.webPanelPermissionSourceKey(worktree.id, definition));
+			}
+			return keys;
+		};
+		const before = await collectPermissionSourceKeys();
 		const result = await this.packages.remove(source, projectId);
+		const after = await collectPermissionSourceKeys();
+		for (const sourceKey of before) if (!after.has(sourceKey)) await this.deps.database.db.delete(webPanelPermissionGrants).where(eq(webPanelPermissionGrants.sourceKey, sourceKey));
 		await this.webPanelRuntime.disposeDevelopmentServers();
 		await this.packageResourcesChanged(projectId);
 		return result;
@@ -4859,6 +5047,13 @@ var TreeportService = class {
 		this.events.publish("project.updated", { projectId });
 		return await this.getProject(projectId);
 	}
+	async listTreeContextFields(projectId) {
+		const project = await this.getProject(projectId);
+		return loadTreeContextFields({
+			dataDir: this.deps.config.dataDir,
+			projectRoot: project.rootPath
+		});
+	}
 	async listTerminalPresets() {
 		return (await this.deps.database.db.select().from(terminalPresets).orderBy(asc(terminalPresets.createdAt), asc(terminalPresets.id))).map(mapTerminalPreset);
 	}
@@ -4976,6 +5171,8 @@ var TreeportService = class {
 				id: `project:${encodeURIComponent(directory.name)}`,
 				title: words ? `${words[0].toLocaleUpperCase()}${words.slice(1)}` : directory.name,
 				source: { type: "project" },
+				permissions: [],
+				permissionsGranted: true,
 				sandbox: { allowSameOrigin: false },
 				root,
 				entry,
@@ -5005,8 +5202,83 @@ var TreeportService = class {
 			return resolved;
 		})];
 	}
+	async webPanelPermissionSourceKey(worktreeId, definition) {
+		const worktree = await this.getWorktree(worktreeId);
+		const source = definition.source.type === "project" ? {
+			type: "project",
+			projectId: worktree.projectId,
+			definitionId: definition.id
+		} : {
+			type: "package",
+			scope: definition.source.scope,
+			projectId: definition.source.scope === "project" ? worktree.projectId : null,
+			packageId: definition.source.packageId,
+			source: definition.source.source,
+			definitionId: definition.id
+		};
+		return crypto.createHash("sha256").update(JSON.stringify(source)).digest("hex");
+	}
+	async webPanelPermissionsGranted(worktreeId, definition) {
+		const sourceKey = await this.webPanelPermissionSourceKey(worktreeId, definition);
+		const [grant] = await this.deps.database.db.select({ permissionsJson: webPanelPermissionGrants.permissionsJson }).from(webPanelPermissionGrants).where(eq(webPanelPermissionGrants.sourceKey, sourceKey)).limit(1);
+		if (definition.permissions.length === 0) {
+			if (grant) await this.deps.database.db.delete(webPanelPermissionGrants).where(eq(webPanelPermissionGrants.sourceKey, sourceKey));
+			return true;
+		}
+		const matches = grant?.permissionsJson === JSON.stringify([...definition.permissions].sort());
+		if (grant && !matches) await this.deps.database.db.delete(webPanelPermissionGrants).where(eq(webPanelPermissionGrants.sourceKey, sourceKey));
+		return matches;
+	}
 	async listWebPanelDefinitions(worktreeId) {
-		return (await this.effectiveWebPanelDefinitions(worktreeId)).map(({ root: _root, entry: _entry, packageRoot: _packageRoot, development: _development, packageLockPath: _packageLockPath, definitionId: _definitionId, packageSource: _packageSource, allowNetworkRequests: _allowNetworkRequests, ...definition }) => definition);
+		const definitions = await this.effectiveWebPanelDefinitions(worktreeId);
+		return Promise.all(definitions.map(async ({ root: _root, entry: _entry, packageRoot: _packageRoot, development: _development, packageLockPath: _packageLockPath, definitionId: _definitionId, packageSource: _packageSource, allowNetworkRequests: _allowNetworkRequests, ...definition }) => ({
+			...definition,
+			permissionsGranted: await this.webPanelPermissionsGranted(worktreeId, definition)
+		})));
+	}
+	async setWebPanelPermissionGrant(worktreeId, definitionId, granted, expectedPermissions) {
+		await this.requireAvailableWorktree(worktreeId);
+		const definition = (await this.effectiveWebPanelDefinitions(worktreeId)).find((candidate) => candidate.id === definitionId);
+		if (!definition) throw new DomainError("WEB_PANEL_DEFINITION_NOT_FOUND", "Web panel definition not found", 404);
+		if (JSON.stringify([...definition.permissions].sort()) !== JSON.stringify([...expectedPermissions].sort())) throw new DomainError("WEB_PANEL_PERMISSIONS_CHANGED", "Web panel permissions changed; review them and try again", 409, { permissions: definition.permissions });
+		const sourceKey = await this.webPanelPermissionSourceKey(worktreeId, definition);
+		if (granted && definition.permissions.length > 0) {
+			const timestamp = now();
+			await this.deps.database.db.insert(webPanelPermissionGrants).values({
+				sourceKey,
+				definitionId,
+				permissionsJson: JSON.stringify([...definition.permissions].sort()),
+				grantedAt: timestamp,
+				updatedAt: timestamp
+			}).onConflictDoUpdate({
+				target: webPanelPermissionGrants.sourceKey,
+				set: {
+					permissionsJson: JSON.stringify([...definition.permissions].sort()),
+					updatedAt: timestamp
+				}
+			});
+		} else await this.deps.database.db.delete(webPanelPermissionGrants).where(eq(webPanelPermissionGrants.sourceKey, sourceKey));
+		const affectedPanels = await this.deps.database.db.select({ id: webPanels.id }).from(webPanels).where(and(eq(webPanels.worktreeId, worktreeId), eq(webPanels.definitionId, definitionId)));
+		this.invalidateProjectsSnapshot();
+		for (const panel of affectedPanels) this.events.publish("panel.updated", {
+			worktreeId,
+			panelId: panel.id
+		});
+		return {
+			id: definition.id,
+			title: definition.title,
+			source: definition.source,
+			permissions: definition.permissions,
+			permissionsGranted: definition.permissions.length === 0 ? true : granted,
+			sandbox: definition.sandbox
+		};
+	}
+	async requireWebPanelPermissions(worktreeId, definition) {
+		if (await this.webPanelPermissionsGranted(worktreeId, definition)) return;
+		throw new DomainError("WEB_PANEL_PERMISSION_REQUIRED", `Permission is required before ${definition.title} can open`, 403, {
+			definitionId: definition.id,
+			permissions: definition.permissions
+		});
 	}
 	async normalizeWebPanelLaunch(worktree, launch) {
 		const inputJson = JSON.stringify(launch.input);
@@ -5030,6 +5302,122 @@ var TreeportService = class {
 			inputJson
 		};
 	}
+	async createBrowserPanel(worktreeId, requestedUrl) {
+		await this.requireAvailableWorktree(worktreeId);
+		const parsedUrl = requestedUrl ? browserUrlSchema.safeParse(requestedUrl) : null;
+		if (parsedUrl && !parsedUrl.success) throw new DomainError("INVALID_BROWSER_URL", "Enter an absolute HTTP or HTTPS URL without credentials", 400);
+		const url = parsedUrl ? new URL(parsedUrl.data).href : "about:blank";
+		const timestamp = now();
+		const panel = {
+			id: id("panel"),
+			kind: "browser",
+			worktreeId,
+			title: url === "about:blank" ? "Browser" : new URL(url).host,
+			url,
+			createdAt: timestamp,
+			updatedAt: timestamp
+		};
+		await this.deps.database.db.insert(browserPanels).values({
+			id: panel.id,
+			worktreeId: panel.worktreeId,
+			title: panel.title,
+			url: panel.url,
+			createdAt: panel.createdAt,
+			updatedAt: panel.updatedAt
+		});
+		this.invalidateProjectsSnapshot();
+		this.events.publish("panel.created", {
+			worktreeId,
+			panelId: panel.id
+		});
+		return panel;
+	}
+	async openBrowserPanel(worktreeId, requestedUrl, sourceTerminalId = null, sourcePanelId = null) {
+		if (sourceTerminalId) {
+			const terminal = await this.getTerminalFromBindings(sourceTerminalId);
+			if (worktreeId && terminal.worktreeId !== worktreeId) throw new DomainError("INVALID_PANEL_OPEN_SOURCE", "The source terminal does not belong to the target tree", 400);
+			worktreeId ??= terminal.worktreeId;
+		}
+		if (sourcePanelId) {
+			const sourcePanel = await this.getBrowserPanel(sourcePanelId);
+			if (worktreeId && sourcePanel.worktreeId !== worktreeId) throw new DomainError("INVALID_PANEL_OPEN_SOURCE", "The source Browser does not belong to the target tree", 400);
+			worktreeId ??= sourcePanel.worktreeId;
+		}
+		if (!worktreeId) throw new DomainError("INVALID_PANEL_OPEN_SOURCE", "A target tree or panel source is required", 400);
+		const panel = await this.createBrowserPanel(worktreeId, requestedUrl);
+		this.events.publish("panel.open_requested", {
+			worktreeId,
+			panelId: panel.id,
+			panel,
+			sourceTerminalId,
+			sourcePanelId
+		});
+		return { panel };
+	}
+	async openBrowserPanelFromTerminal(terminalId, requestedUrl) {
+		return this.openBrowserPanel(null, requestedUrl, terminalId, null);
+	}
+	async openBrowserPanelFromPanel(panelId, requestedUrl) {
+		return this.openBrowserPanel(null, requestedUrl, null, panelId);
+	}
+	async getBrowserPanel(panelId) {
+		const [row] = await this.deps.database.db.select().from(browserPanels).where(eq(browserPanels.id, panelId)).limit(1);
+		if (!row) throw new DomainError("PANEL_NOT_FOUND", "Browser not found", 404);
+		await this.requireAvailableWorktree(row.worktreeId);
+		return mapBrowserPanel(row);
+	}
+	async authorizeBrowserPanel(panelId) {
+		const panel = await this.getBrowserPanel(panelId);
+		return {
+			panel,
+			worktreePath: (await this.getWorktree(panel.worktreeId)).path
+		};
+	}
+	async updateBrowserPanelState(panelId, state) {
+		const panel = await this.getBrowserPanel(panelId);
+		const parsedUrl = state.url === "about:blank" ? {
+			success: true,
+			data: "about:blank"
+		} : browserUrlSchema.safeParse(state.url);
+		if (!parsedUrl.success) throw new DomainError("INVALID_BROWSER_URL", "The hosted browser reported an unsupported URL", 400);
+		const url = parsedUrl.data === "about:blank" ? parsedUrl.data : new URL(parsedUrl.data).href;
+		const title = state.title.trim().slice(0, 256) || (url === "about:blank" ? "Browser" : new URL(url).host || "Browser");
+		if (panel.url === url && panel.title === title) return panel;
+		const observedAt = now();
+		const updatedAt = observedAt > panel.updatedAt ? observedAt : new Date(Date.parse(panel.updatedAt) + 1).toISOString();
+		await this.deps.database.db.update(browserPanels).set({
+			url,
+			title,
+			updatedAt
+		}).where(eq(browserPanels.id, panelId));
+		const updated = {
+			...panel,
+			url,
+			title,
+			updatedAt
+		};
+		this.invalidateProjectsSnapshot();
+		this.events.publish("panel.updated", {
+			worktreeId: panel.worktreeId,
+			panelId
+		});
+		return updated;
+	}
+	async deleteBrowserPanel(panelId) {
+		const [row] = await this.deps.database.db.select().from(browserPanels).where(eq(browserPanels.id, panelId)).limit(1);
+		if (!row) throw new DomainError("PANEL_NOT_FOUND", "Browser not found", 404);
+		await this.deps.database.db.delete(browserPanels).where(eq(browserPanels.id, panelId));
+		this.invalidateProjectsSnapshot();
+		this.events.publish("panel.removed", {
+			worktreeId: row.worktreeId,
+			panelId
+		});
+	}
+	async deletePanel(panelId, discardStoredData = false) {
+		const [browserPanel] = await this.deps.database.db.select({ id: browserPanels.id }).from(browserPanels).where(eq(browserPanels.id, panelId)).limit(1);
+		if (browserPanel) return this.deleteBrowserPanel(panelId);
+		return this.deleteWebPanel(panelId, discardStoredData);
+	}
 	async createWebPanel(worktreeId, definitionId, launch = {
 		input: null,
 		cwd: null
@@ -5037,6 +5425,7 @@ var TreeportService = class {
 		const worktree = await this.requireAvailableWorktree(worktreeId);
 		const definition = (await this.effectiveWebPanelDefinitions(worktreeId)).find((candidate) => candidate.id === definitionId);
 		if (!definition) throw new DomainError("WEB_PANEL_DEFINITION_NOT_FOUND", "Web panel definition not found", 404);
+		await this.requireWebPanelPermissions(worktreeId, definition);
 		const normalized = await this.normalizeWebPanelLaunch(worktree, launch);
 		const timestamp = now();
 		const panel = {
@@ -5046,6 +5435,7 @@ var TreeportService = class {
 			definitionId,
 			title: definition.title,
 			launch: normalized.launch,
+			permissions: definition.permissions,
 			sandbox: definition.sandbox,
 			createdAt: timestamp,
 			updatedAt: timestamp
@@ -5074,11 +5464,14 @@ var TreeportService = class {
 		const worktree = await this.requireAvailableWorktree(worktreeId);
 		const definition = (await this.effectiveWebPanelDefinitions(worktreeId)).find((candidate) => candidate.id === definitionId);
 		if (!definition) throw new DomainError("WEB_PANEL_DEFINITION_NOT_FOUND", "Web panel definition not found", 404);
+		await this.requireWebPanelPermissions(worktreeId, definition);
 		const finish = (result) => {
 			this.events.publish("panel.open_requested", {
 				worktreeId,
 				panelId: result.panel.id,
-				sourceTerminalId
+				panel: result.panel,
+				sourceTerminalId,
+				sourcePanelId: null
 			});
 			return result;
 		};
@@ -5108,7 +5501,7 @@ var TreeportService = class {
 			inputJson: normalized.inputJson,
 			launchCwd: normalized.launch.cwd,
 			updatedAt
-		}, definition.sandbox.allowSameOrigin);
+		}, definition.permissions, true);
 		this.invalidateProjectsSnapshot();
 		this.events.publish("panel.updated", {
 			worktreeId,
@@ -5133,10 +5526,149 @@ var TreeportService = class {
 			panelId
 		});
 	}
+	async requireWebPanelTreeFiles(panelId) {
+		const [panel] = await this.deps.database.db.select().from(webPanels).where(eq(webPanels.id, panelId)).limit(1);
+		if (!panel) throw new DomainError("PANEL_NOT_FOUND", "Panel not found", 404);
+		const definition = (await this.effectiveWebPanelDefinitions(panel.worktreeId)).find((candidate) => candidate.id === panel.definitionId);
+		if (!definition) throw new DomainError("WEB_PANEL_DEFINITION_NOT_FOUND", "The definition for this panel is unavailable", 404);
+		await this.requireWebPanelPermissions(panel.worktreeId, definition);
+		if (!definition.permissions.includes("tree-files")) throw new DomainError("WEB_PANEL_TREE_FILES_REQUIRED", "This panel does not have permission to access tree files", 403);
+		const worktree = await this.requireAvailableWorktree(panel.worktreeId);
+		return {
+			project: await this.getProject(worktree.projectId),
+			worktree
+		};
+	}
+	async resolveTreeFile(worktreePath, requestedPath) {
+		if (!treeFilePathSchema.safeParse(requestedPath).success) throw new DomainError("INVALID_TREE_FILE_PATH", "File path must be a relative path inside the tree", 400);
+		const root = await fs.realpath(worktreePath);
+		const candidate = path.resolve(root, requestedPath);
+		if (!isPathWithin(candidate, root)) throw new DomainError("INVALID_TREE_FILE_PATH", "File path must stay inside the tree", 400);
+		const canonicalPath = await fs.realpath(candidate).catch((error) => {
+			if (error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR")) return null;
+			throw error;
+		});
+		if (!canonicalPath) throw new DomainError("TREE_FILE_NOT_FOUND", "The selected file does not exist", 404);
+		if (!isPathWithin(canonicalPath, root)) throw new DomainError("INVALID_TREE_FILE_PATH", "File path must stay inside the tree", 400);
+		const stat = await fs.lstat(candidate);
+		if (stat.isSymbolicLink() || !stat.isFile()) throw new DomainError("TREE_FILE_UNSUPPORTED", "Only existing regular files can be edited", 415);
+		return {
+			canonicalPath,
+			path: path.relative(root, canonicalPath).split(path.sep).join("/")
+		};
+	}
+	async readTreeFileHandle(handle) {
+		const stat = await handle.stat();
+		if (!stat.isFile()) throw new DomainError("TREE_FILE_UNSUPPORTED", "Only existing regular files can be edited", 415);
+		if (stat.size > 2097152) throw new DomainError("TREE_FILE_TOO_LARGE", "Files larger than 2 MiB cannot be edited", 413);
+		const buffer = Buffer.alloc(TREE_FILE_MAX_BYTES + 1);
+		let bytesRead = 0;
+		while (bytesRead < buffer.length) {
+			const read = await handle.read(buffer, bytesRead, buffer.length - bytesRead, bytesRead);
+			if (read.bytesRead === 0) break;
+			bytesRead += read.bytesRead;
+		}
+		if (bytesRead > 2097152) throw new DomainError("TREE_FILE_TOO_LARGE", "Files larger than 2 MiB cannot be edited", 413);
+		const bytes = buffer.subarray(0, bytesRead);
+		let content;
+		try {
+			content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+		} catch {
+			throw new DomainError("TREE_FILE_UNSUPPORTED", "Only UTF-8 text files can be edited", 415);
+		}
+		if (content.includes("\0")) throw new DomainError("TREE_FILE_UNSUPPORTED", "Only UTF-8 text files can be edited", 415);
+		return {
+			bytes,
+			content
+		};
+	}
+	async listTreeFiles(panelId) {
+		const { project, worktree } = await this.requireWebPanelTreeFiles(panelId);
+		const root = await fs.realpath(worktree.path);
+		const paths = [];
+		if (project.kind === "repository") {
+			const candidates = await this.deps.git.worktreeFiles(root);
+			for (const relativePath of candidates) {
+				if (paths.length > 5e4) break;
+				const candidate = path.resolve(root, relativePath);
+				if (!isPathWithin(candidate, root)) continue;
+				const [canonicalPath, stat] = await Promise.all([fs.realpath(candidate).catch(() => null), fs.lstat(candidate).catch(() => null)]);
+				if (canonicalPath && isPathWithin(canonicalPath, root) && stat?.isFile() && !stat.isSymbolicLink()) paths.push(relativePath.split(path.sep).join("/"));
+			}
+		} else {
+			const directories = [""];
+			while (directories.length > 0 && paths.length <= 5e4) {
+				const relativeDirectory = directories.pop();
+				const entries = await fs.readdir(path.join(root, relativeDirectory), { withFileTypes: true }).then((values) => values.sort((left, right) => right.name.localeCompare(left.name)));
+				for (const entry of entries) {
+					if (entry.name === ".git" && entry.isDirectory()) continue;
+					const relativePath = path.join(relativeDirectory, entry.name);
+					if (entry.isDirectory()) directories.push(relativePath);
+					else if (entry.isFile()) {
+						paths.push(relativePath.split(path.sep).join("/"));
+						if (paths.length > 5e4) break;
+					}
+				}
+			}
+		}
+		paths.sort();
+		return {
+			paths: paths.slice(0, TREE_FILE_LIST_MAX_ENTRIES),
+			truncated: paths.length > TREE_FILE_LIST_MAX_ENTRIES
+		};
+	}
+	async readTreeFile(panelId, requestedPath) {
+		const { worktree } = await this.requireWebPanelTreeFiles(panelId);
+		const resolved = await this.resolveTreeFile(worktree.path, requestedPath);
+		const handle = await fs.open(resolved.canonicalPath, constants.O_RDONLY | constants.O_NOFOLLOW).catch((error) => {
+			if (error instanceof Error && "code" in error && error.code === "ENOENT") throw new DomainError("TREE_FILE_NOT_FOUND", "The selected file does not exist", 404);
+			throw error;
+		});
+		try {
+			const { bytes, content } = await this.readTreeFileHandle(handle);
+			return {
+				path: resolved.path,
+				content,
+				revision: crypto.createHash("sha256").update(bytes).digest("hex")
+			};
+		} finally {
+			await handle.close();
+		}
+	}
+	async writeTreeFile(panelId, input) {
+		const { worktree } = await this.requireWebPanelTreeFiles(panelId);
+		const content = Buffer.from(input.content, "utf8");
+		if (content.length > 2097152) throw new DomainError("TREE_FILE_TOO_LARGE", "Files larger than 2 MiB cannot be edited", 413);
+		if (input.content.includes("\0")) throw new DomainError("TREE_FILE_UNSUPPORTED", "Only UTF-8 text files can be edited", 415);
+		const resolved = await this.resolveTreeFile(worktree.path, input.path);
+		return this.treeFileMutations.enqueue(resolved.canonicalPath, async () => {
+			const handle = await fs.open(resolved.canonicalPath, constants.O_RDWR | constants.O_NOFOLLOW);
+			try {
+				const current = await this.readTreeFileHandle(handle);
+				if (crypto.createHash("sha256").update(current.bytes).digest("hex") !== input.expectedRevision) throw new DomainError("TREE_FILE_CHANGED", "The file changed after it was opened. Reload it before saving.", 409);
+				let offset = 0;
+				while (offset < content.length) {
+					const write = await handle.write(content, offset, content.length - offset, offset);
+					if (write.bytesWritten === 0) throw new Error("Could not write tree file");
+					offset += write.bytesWritten;
+				}
+				await handle.truncate(content.length);
+				await handle.sync();
+				return {
+					path: resolved.path,
+					revision: crypto.createHash("sha256").update(content).digest("hex")
+				};
+			} finally {
+				await handle.close();
+			}
+		});
+	}
 	async getWebPanelContext(panelId) {
 		const [panelRow] = await this.deps.database.db.select().from(webPanels).where(eq(webPanels.id, panelId)).limit(1);
 		if (!panelRow) throw new DomainError("PANEL_NOT_FOUND", "Panel not found", 404);
-		const panel = mapWebPanel(panelRow, (await this.effectiveWebPanelDefinitions(panelRow.worktreeId)).find((candidate) => candidate.id === panelRow.definitionId)?.sandbox.allowSameOrigin ?? false);
+		const definition = (await this.effectiveWebPanelDefinitions(panelRow.worktreeId)).find((candidate) => candidate.id === panelRow.definitionId);
+		const permissionsGranted = definition ? await this.webPanelPermissionsGranted(panelRow.worktreeId, definition) : false;
+		const panel = mapWebPanel(panelRow, definition?.permissions ?? [], permissionsGranted);
 		const worktree = await this.getWorktree(panel.worktreeId);
 		const project = await this.getProject(worktree.projectId);
 		return {
@@ -5164,6 +5696,19 @@ var TreeportService = class {
 		const worktree = await this.getWorktree(context.panel.worktreeId);
 		return this.deps.git.worktreeDiff(worktree.path, context.project.defaultBranch);
 	}
+	async getBrowserPanelListeners(panelId) {
+		const panel = await this.getBrowserPanel(panelId);
+		const worktree = await this.getWorktree(panel.worktreeId);
+		const panes = await this.deps.tmux.listPaneProcesses(worktree.tmuxSocketName, worktree.id);
+		return this.networkListeners.listeners({
+			worktreePath: worktree.path,
+			panes
+		});
+	}
+	async getPanelListeners(panelId) {
+		const [browserPanel] = await this.deps.database.db.select({ id: browserPanels.id }).from(browserPanels).where(eq(browserPanels.id, panelId)).limit(1);
+		return browserPanel ? this.getBrowserPanelListeners(panelId) : this.getWebPanelListeners(panelId);
+	}
 	async getWebPanelListeners(panelId) {
 		const context = await this.getWebPanelContext(panelId);
 		const worktree = await this.getWorktree(context.panel.worktreeId);
@@ -5214,17 +5759,30 @@ var TreeportService = class {
 		if (!panel) throw new DomainError("PANEL_NOT_FOUND", "Panel not found", 404);
 		const definition = (await this.effectiveWebPanelDefinitions(panel.worktreeId)).find((candidate) => candidate.id === panel.definitionId);
 		if (!definition) throw new DomainError("WEB_PANEL_DEFINITION_NOT_FOUND", "The definition for this panel is unavailable", 404);
+		await this.requireWebPanelPermissions(panel.worktreeId, definition);
 		const encodedPanelId = encodeURIComponent(panelId);
 		return this.webPanelRuntime.resolve(definition, requestedPath, `/api/web-panels/${encodedPanelId}/assets/`);
 	}
+	async listBrowserPanels() {
+		return this.deps.database.db.select().from(browserPanels).orderBy(asc(browserPanels.createdAt), asc(browserPanels.id)).then((rows) => rows.map(mapBrowserPanel));
+	}
 	async listWebPanels() {
-		return (await this.deps.database.db.select().from(webPanels).orderBy(asc(webPanels.createdAt), asc(webPanels.id))).map((row) => mapWebPanel(row));
+		const rows = await this.deps.database.db.select().from(webPanels).orderBy(asc(webPanels.createdAt), asc(webPanels.id));
+		return Promise.all(rows.map(async (row) => {
+			const definition = (await this.effectiveWebPanelDefinitions(row.worktreeId).catch(() => [])).find((candidate) => candidate.id === row.definitionId);
+			return mapWebPanel(row, definition?.permissions ?? [], definition ? await this.webPanelPermissionsGranted(row.worktreeId, definition) : false);
+		}));
 	}
 	async getWorktree(worktreeId) {
 		const worktree = await this.storedWorktree(worktreeId);
 		if (!worktree) throw new DomainError("WORKTREE_NOT_FOUND", "Tree not found", 404);
 		return worktree;
 	}
+	async getWorktreeContext(worktreeId) {
+		const [row] = await this.deps.database.db.select({ treeContextJson: worktrees.treeContextJson }).from(worktrees).where(eq(worktrees.id, worktreeId)).limit(1);
+		if (!row) throw new DomainError("WORKTREE_NOT_FOUND", "Tree not found", 404);
+		return treeContextValuesSchema.parse(JSON.parse(row.treeContextJson));
+	}
 	async requestWorkspaceOpen(worktreeId, sourceTerminalId) {
 		const worktree = await this.getWorktree(worktreeId);
 		await this.requireOpenProject(worktree.projectId);
@@ -5901,7 +6459,7 @@ var TreeportService = class {
 		if (filters.projectId) await this.requireOpenProject(filters.projectId);
 		return (await this.deps.database.db.select().from(operations).where(and(or(eq(operations.status, "pending"), eq(operations.status, "running")), ...filters.projectId ? [eq(operations.projectId, filters.projectId)] : [], ...filters.kind ? [eq(operations.kind, filters.kind)] : [])).orderBy(asc(operations.createdAt), asc(operations.id))).map(mapOperation);
 	}
-	async beginCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId) {
+	async beginCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId, treeContext) {
 		if ((await this.requireOpenProject(projectId)).kind === "folder") throw new DomainError("PROJECT_HAS_NO_GIT_REPOSITORY", "Linked worktrees require a Git repository project", 409);
 		let name;
 		try {
@@ -5918,6 +6476,7 @@ var TreeportService = class {
 		};
 		if (initialTerminal) request.initialTerminal = initialTerminal;
 		if (sourceWorktreeId) request.sourceWorktreeId = sourceWorktreeId;
+		if (treeContext && Object.keys(treeContext).length > 0) request.context = treeContext;
 		await this.deps.database.db.run(sql`
       INSERT INTO operations(
         id,kind,project_id,worktree_id,status,request_json,result_json,error,
@@ -5932,16 +6491,16 @@ var TreeportService = class {
 			projectId,
 			operationId
 		});
-		this.worktreeMutations.enqueue(projectId, () => this.executeCreateOperation(operationId, projectId, name, base, initialTerminal, sourceWorktreeId)).catch(() => void 0);
+		this.worktreeMutations.enqueue(projectId, () => this.executeCreateOperation(operationId, projectId, name, base, initialTerminal, sourceWorktreeId, treeContext)).catch(() => void 0);
 		return operation;
 	}
-	async executeCreateOperation(operationId, projectId, inputName, base, initialTerminal, sourceWorktreeId) {
+	async executeCreateOperation(operationId, projectId, inputName, base, initialTerminal, sourceWorktreeId, treeContext) {
 		await this.deps.database.db.run(sql`
       UPDATE operations SET status='running',updated_at=${now()}
       WHERE id=${operationId} AND status='pending'
     `);
 		try {
-			const result = await this.executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId);
+			const result = await this.executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId, treeContext);
 			const timestamp = now();
 			await this.deps.database.db.run(sql`
         UPDATE operations
@@ -5972,12 +6531,13 @@ var TreeportService = class {
 			});
 		}
 	}
-	async createWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId) {
+	async createWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId, treeContext) {
 		if ((await this.requireOpenProject(projectId)).kind === "folder") throw new DomainError("PROJECT_HAS_NO_GIT_REPOSITORY", "Linked worktrees require a Git repository project", 409);
 		if (this.projectLocks.has(projectId) && !this.worktreeMutations.has(projectId)) throw new DomainError("PROJECT_BUSY", "Project is already being modified", 409);
-		return this.worktreeMutations.enqueue(projectId, () => this.executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId));
+		return this.worktreeMutations.enqueue(projectId, () => this.executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId, treeContext));
 	}
-	async executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId) {
+	async executeCreateWorktree(projectId, inputName, base, initialTerminal, sourceWorktreeId, treeContext) {
+		const contextValues = treeContextValuesSchema.parse(treeContext ?? {});
 		await this.requireOpenProject(projectId);
 		if (this.projectLocks.has(projectId)) throw new DomainError("PROJECT_BUSY", "Project is already being modified", 409);
 		this.projectLocks.add(projectId);
@@ -6027,7 +6587,8 @@ var TreeportService = class {
 			await this.importWorktrees(project.id, project.repositoryPath, project.mainWorktreePath, true);
 			await this.deps.database.db.run(sql`
         UPDATE worktrees
-        SET managed_wrapper_path=${wrapperCreated ? wrapperPath : null}
+        SET managed_wrapper_path=${wrapperCreated ? wrapperPath : null},
+            tree_context_json=${JSON.stringify(contextValues)}
         WHERE path=${worktreePath}
       `);
 			const [worktreeRow] = await this.deps.database.db.select({
@@ -6047,6 +6608,7 @@ var TreeportService = class {
 			let setupError = null;
 			if (initialTerminal) {
 				const launchOptions = {};
+				if (initialTerminal.initialTitle) launchOptions.initialTitle = initialTerminal.initialTitle;
 				if (initialTerminal.returnToShell) launchOptions.returnToShell = true;
 				if (initialTerminal.initialSize) launchOptions.initialSize = initialTerminal.initialSize;
 				const initialTerminalCreation = this.executeCreateTerminal(worktree.id, initialTerminal.name, initialTerminal.argv, launchOptions);
@@ -6172,6 +6734,7 @@ var TreeportService = class {
 				TREEPORT_TERMINAL_ID: terminalId
 			}
 		};
+		if (options?.initialTitle) session.initialTitle = options.initialTitle;
 		if (options?.returnToShell && !interactiveShell) session.fallbackArgv = [this.deps.config.shell, "-l"];
 		if (options?.closeOnSuccess) session.closeOnSuccess = true;
 		if (options?.initialSize) session.initialSize = options.initialSize;
@@ -6706,7 +7269,11 @@ var TreeportService = class {
 		return terminated;
 	}
 	async drainMutations() {
-		await Promise.all([this.worktreeMutations.drain(), this.terminalMutations.drain()]);
+		await Promise.all([
+			this.worktreeMutations.drain(),
+			this.terminalMutations.drain(),
+			this.treeFileMutations.drain()
+		]);
 	}
 	async reconcile() {
 		const availableProjects = /* @__PURE__ */ new Set();
@@ -7831,52 +8398,217 @@ var TerminalMetadataManager = class {
 	}
 };
 //#endregion
-//#region src/server/app.ts
-const UPLOAD_MIME_EXTENSIONS = /* @__PURE__ */ new Map([
-	["application/pdf", "pdf"],
-	["image/gif", "gif"],
-	["image/jpeg", "jpg"],
-	["image/png", "png"],
-	["image/svg+xml", "svg"],
-	["image/webp", "webp"],
-	["text/plain", "txt"]
+//#region src/server/request-security.ts
+const MAX_HOST_BYTES = 512;
+const MAX_LOGIN_BYTES = 320;
+const MAX_NAME_BYTES = 512;
+const MAX_PROFILE_PICTURE_BYTES = 2048;
+const UNSAFE_METHODS = /* @__PURE__ */ new Set([
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
 ]);
-const UPLOAD_RETENTION_MS = 1440 * 6e4;
-const UPLOAD_DIRECTORY_MAX_BYTES = 512 * 1024 * 1024;
-const terminalPresetDefinitionsQuerySchema = z.object({
-	projectId: z.string().optional(),
-	worktreeId: z.string().optional()
-});
-const operationQuerySchema = z.object({
-	kind: z.enum([
-		"create",
-		"finish",
-		"discard",
-		"project_cleanup",
-		"remove",
-		"external_remove"
-	]).optional(),
-	projectId: z.string().optional()
-});
-const discardStoredDataQuerySchema = z.object({ discardStoredData: z.string().optional() });
-async function pruneTerminalUploads(directory, preservePath) {
-	const entries = await fs.readdir(directory, { withFileTypes: true });
-	const files = (await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.startsWith("treeport-upload-")).map(async (entry) => {
-		const filePath = path.join(directory, entry.name);
-		return fs.stat(filePath).then((stat) => ({
-			path: filePath,
-			size: stat.size,
-			mtimeMs: stat.mtimeMs
-		})).catch(() => null);
-	}))).filter((file) => file !== null).sort((left, right) => {
-		if (left.path === preservePath) return -1;
-		if (right.path === preservePath) return 1;
-		return right.mtimeMs - left.mtimeMs;
-	});
-	const expiredBefore = Date.now() - UPLOAD_RETENTION_MS;
-	let retainedBytes = 0;
-	for (const file of files) {
-		const expired = file.mtimeMs < expiredBefore;
+function denied(status, code, message) {
+	return {
+		allowed: false,
+		principal: null,
+		effectiveOrigin: null,
+		status,
+		code,
+		message
+	};
+}
+function headerValues(request, name) {
+	const values = [];
+	for (let index = 0; index < request.rawHeaders.length; index += 2) if (request.rawHeaders[index]?.toLowerCase() === name) values.push(request.rawHeaders[index + 1] ?? "");
+	if (values.length > 0) return values;
+	const value = request.headers[name];
+	if (value === void 0) return [];
+	return Array.isArray(value) ? value : [value];
+}
+function singleHeader(request, name) {
+	const values = headerValues(request, name);
+	return {
+		present: values.length > 0,
+		valid: values.length <= 1,
+		value: values.length === 1 ? values[0] ?? null : null
+	};
+}
+function hasControlCharacters(value) {
+	return [...value].some((character) => {
+		const code = character.codePointAt(0) ?? 0;
+		return code <= 31 || code === 127;
+	});
+}
+function parseHost(value) {
+	if (value.length === 0 || Buffer.byteLength(value) > MAX_HOST_BYTES || hasControlCharacters(value) || /[\s,/@?#\\]/u.test(value)) return null;
+	const candidate = `http://${value}`;
+	if (!URL.canParse(candidate)) return null;
+	const url = new URL(candidate);
+	if (!url.host || url.pathname !== "/") return null;
+	return {
+		host: url.host,
+		hostname: url.hostname.toLowerCase()
+	};
+}
+function isLoopbackHostname(hostname) {
+	return [
+		"127.0.0.1",
+		"localhost",
+		"[::1]",
+		"::1"
+	].includes(hostname);
+}
+function isLoopbackAddress(address) {
+	if (!address) return false;
+	const normalized = address.toLowerCase();
+	if (normalized === "::1") return true;
+	const octets = (normalized.startsWith("::ffff:") ? normalized.slice(7) : normalized).split(".");
+	return octets.length === 4 && octets[0] === "127" && octets.every((octet) => /^\d{1,3}$/u.test(octet) && Number(octet) <= 255);
+}
+function validIdentityValue(value, maximumBytes) {
+	return value.length > 0 && value === value.trim() && Buffer.byteLength(value) <= maximumBytes && !hasControlCharacters(value);
+}
+function effectiveOriginFor(request, source, incomingHost) {
+	if (source === "local") return `http://${incomingHost.host}`;
+	const forwardedHostHeader = singleHeader(request, "x-forwarded-host");
+	const forwardedProtocolHeader = singleHeader(request, "x-forwarded-proto");
+	if (!forwardedHostHeader.valid || !forwardedHostHeader.present || !forwardedProtocolHeader.valid || !forwardedProtocolHeader.present) return null;
+	const forwardedHost = parseHost(forwardedHostHeader.value ?? "");
+	if (!forwardedHost || forwardedProtocolHeader.value?.toLowerCase() !== "https") return null;
+	return `https://${forwardedHost.host}`;
+}
+function allowsOpaqueWebPanelOrigin(request, socketUpgrade) {
+	if (!["GET", "HEAD"].includes(request.method?.toUpperCase() ?? "")) return false;
+	const pathname = new URL(request.url ?? "/", "http://treeport.local").pathname;
+	if (socketUpgrade) return /^\/api\/web-panel-dev\/[a-f0-9]{24}\/@vite-hmr$/u.test(pathname);
+	return /^\/api\/web-panels\/panel_[a-f0-9]{32}\/assets(?:\/|$)/u.test(pathname) || /^\/api\/web-panel-dev\/[a-f0-9]{24}\//u.test(pathname);
+}
+function originIsAllowed(request, effectiveOrigin, socketUpgrade) {
+	const originHeader = singleHeader(request, "origin");
+	if (!originHeader.valid) return false;
+	if (originHeader.present) {
+		const value = originHeader.value ?? "";
+		if (value === "null") {
+			if (!allowsOpaqueWebPanelOrigin(request, socketUpgrade)) return false;
+		} else {
+			if (!URL.canParse(value)) return false;
+			const parsed = new URL(value);
+			if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.origin !== value || parsed.origin !== effectiveOrigin) return false;
+		}
+	}
+	const fetchSiteHeader = singleHeader(request, "sec-fetch-site");
+	if (!fetchSiteHeader.valid) return false;
+	if ((UNSAFE_METHODS.has(request.method?.toUpperCase() ?? "") || socketUpgrade) && fetchSiteHeader.value?.toLowerCase() === "cross-site") return false;
+	return true;
+}
+function authorizeRequest(request, options = {}) {
+	if (!isLoopbackAddress(request.socket.remoteAddress)) return denied(401, "AUTHENTICATION_REQUIRED", "Treeport accepts remote requests only through Tailscale Serve.");
+	const hostHeader = singleHeader(request, "host");
+	const incomingHost = hostHeader.valid && hostHeader.value ? parseHost(hostHeader.value.toLowerCase()) : null;
+	if (!incomingHost) return denied(400, "INVALID_REQUEST_HOST", "The request host is invalid.");
+	const loginHeader = singleHeader(request, "tailscale-user-login");
+	const nameHeader = singleHeader(request, "tailscale-user-name");
+	const profilePictureHeader = singleHeader(request, "tailscale-user-profile-pic");
+	const hasTailscaleIdentity = loginHeader.present || nameHeader.present || profilePictureHeader.present;
+	const headersHaveSingleValues = loginHeader.valid && nameHeader.valid && profilePictureHeader.valid;
+	let principal;
+	if (hasTailscaleIdentity) {
+		const login = loginHeader.value ?? "";
+		const name = nameHeader.value === "" ? null : nameHeader.value;
+		const profilePicture = profilePictureHeader.value === "" ? null : profilePictureHeader.value;
+		const validProfilePicture = profilePicture === null || validIdentityValue(profilePicture, MAX_PROFILE_PICTURE_BYTES) && URL.canParse(profilePicture) && ["http:", "https:"].includes(new URL(profilePicture).protocol);
+		if (!headersHaveSingleValues || !loginHeader.present || !validIdentityValue(login, MAX_LOGIN_BYTES) || name !== null && !validIdentityValue(name, MAX_NAME_BYTES) || !validProfilePicture) return denied(401, "INVALID_TAILSCALE_IDENTITY", "The Tailscale user identity is invalid.");
+		principal = {
+			source: "tailscale",
+			login,
+			name,
+			profilePicture
+		};
+	} else {
+		if (!isLoopbackHostname(incomingHost.hostname)) return denied(401, "AUTHENTICATION_REQUIRED", "Treeport accepts remote requests only through Tailscale Serve.");
+		principal = {
+			source: "local",
+			login: null,
+			name: null,
+			profilePicture: null
+		};
+	}
+	const effectiveOrigin = effectiveOriginFor(request, principal.source, incomingHost);
+	if (!effectiveOrigin) return denied(400, "INVALID_FORWARDED_ORIGIN", "The forwarded request origin is invalid.");
+	if (!originIsAllowed(request, effectiveOrigin, options.socketUpgrade === true)) return denied(403, "INVALID_ORIGIN", "The request origin is not allowed.");
+	return {
+		allowed: true,
+		principal,
+		effectiveOrigin,
+		status: 200,
+		code: null,
+		message: null
+	};
+}
+function rejectHttpRequest(request, response, decision) {
+	const apiRequest = request.url?.startsWith("/api/") === true;
+	const body = apiRequest ? `${JSON.stringify({ error: {
+		code: decision.code,
+		message: decision.message
+	} })}\n` : `${decision.message ?? "The request was rejected."}\n`;
+	response.statusCode = decision.status;
+	response.setHeader("cache-control", "no-store");
+	response.setHeader("content-type", apiRequest ? "application/json; charset=utf-8" : "text/plain; charset=utf-8");
+	response.end(request.method === "HEAD" ? void 0 : body);
+}
+//#endregion
+//#region src/server/app.ts
+const UPLOAD_MIME_EXTENSIONS = /* @__PURE__ */ new Map([
+	["application/pdf", "pdf"],
+	["image/gif", "gif"],
+	["image/jpeg", "jpg"],
+	["image/png", "png"],
+	["image/svg+xml", "svg"],
+	["image/webp", "webp"],
+	["text/plain", "txt"]
+]);
+const UPLOAD_RETENTION_MS = 1440 * 6e4;
+const UPLOAD_DIRECTORY_MAX_BYTES = 512 * 1024 * 1024;
+const terminalPresetDefinitionsQuerySchema = z.object({
+	projectId: z.string().optional(),
+	worktreeId: z.string().optional()
+});
+const treeContextFieldsQuerySchema = z.object({ projectId: z.string().min(1) });
+const operationQuerySchema = z.object({
+	kind: z.enum([
+		"create",
+		"finish",
+		"discard",
+		"project_cleanup",
+		"remove",
+		"external_remove"
+	]).optional(),
+	projectId: z.string().optional()
+});
+const deletePanelQuerySchema = z.object({
+	discardStoredData: z.string().optional(),
+	force: z.string().optional()
+});
+async function pruneTerminalUploads(directory, preservePath) {
+	const entries = await fs.readdir(directory, { withFileTypes: true });
+	const files = (await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.startsWith("treeport-upload-")).map(async (entry) => {
+		const filePath = path.join(directory, entry.name);
+		return fs.stat(filePath).then((stat) => ({
+			path: filePath,
+			size: stat.size,
+			mtimeMs: stat.mtimeMs
+		})).catch(() => null);
+	}))).filter((file) => file !== null).sort((left, right) => {
+		if (left.path === preservePath) return -1;
+		if (right.path === preservePath) return 1;
+		return right.mtimeMs - left.mtimeMs;
+	});
+	const expiredBefore = Date.now() - UPLOAD_RETENTION_MS;
+	let retainedBytes = 0;
+	for (const file of files) {
+		const expired = file.mtimeMs < expiredBefore;
 		const overQuota = retainedBytes + file.size > UPLOAD_DIRECTORY_MAX_BYTES;
 		if (file.path !== preservePath && (expired || overQuota)) {
 			await fs.rm(file.path, { force: true });
@@ -7895,7 +8627,13 @@ function queryInput(schema) {
 		if (!result.success) throw new DomainError("VALIDATION_ERROR", "Request validation failed", 400, z.flattenError(result.error));
 	});
 }
-function createApp({ service, config, tmux, applicationUpdate, terminalMetadata, webDist }) {
+function createTreeFilesApi(service) {
+	return new Hono().get("/api/panels/:panelId/files", async (context) => context.json(await service.listTreeFiles(context.req.param("panelId")))).post("/api/panels/:panelId/files/read", jsonInput(readTreeFileSchema), async (context) => {
+		const body = context.req.valid("json");
+		return context.json(await service.readTreeFile(context.req.param("panelId"), body.path));
+	}).put("/api/panels/:panelId/files", jsonInput(writeTreeFileSchema), async (context) => context.json(await service.writeTreeFile(context.req.param("panelId"), context.req.valid("json"))));
+}
+function createApp({ service, config, tmux, applicationUpdate, terminalMetadata, browserSessions, webDist }) {
 	const app = new Hono();
 	app.use("/api/*", requestId({
 		limitLength: 128,
@@ -7935,10 +8673,52 @@ function createApp({ service, config, tmux, applicationUpdate, terminalMetadata,
 			details: { requestId: requestIdentifier }
 		} }, 500);
 	});
+	const browserApi = new Hono().get("/api/browser/status", async (context) => {
+		if (!browserSessions) throw new DomainError("BROWSER_UNAVAILABLE", "Hosted browser service is unavailable", 503);
+		return context.json(await browserSessions.status());
+	}).post("/api/browser/install", async (context) => {
+		if (!browserSessions) throw new DomainError("BROWSER_UNAVAILABLE", "Hosted browser service is unavailable", 503);
+		return context.json({ message: await browserSessions.install() });
+	}).delete("/api/browser/install", async (context) => {
+		if (!browserSessions) throw new DomainError("BROWSER_UNAVAILABLE", "Hosted browser service is unavailable", 503);
+		await browserSessions.remove();
+		return context.json({ ok: true });
+	}).put("/api/worktrees/:worktreeId/web-panel-definitions/:definitionId/permission-grant", jsonInput(updateWebPanelPermissionGrantSchema), async (context) => {
+		const body = context.req.valid("json");
+		const definition = await service.setWebPanelPermissionGrant(context.req.param("worktreeId"), context.req.param("definitionId"), body.granted, body.permissions);
+		return context.json({ definition });
+	}).post("/api/panels/:panelId/browser-agent", jsonInput(browserAgentCommandSchema), async (context) => {
+		if (!browserSessions) throw new DomainError("BROWSER_UNAVAILABLE", "Hosted browser service is unavailable", 503);
+		const panelId = context.req.param("panelId");
+		const input = context.req.valid("json");
+		return context.json({ output: await browserSessions.agentCommand(panelId, input).catch((cause) => {
+			if (cause instanceof DomainError) throw cause;
+			throw new DomainError("BROWSER_COMMAND_FAILED", cause instanceof Error ? cause.message : "The Browser command failed.", 409, {
+				command: input.command,
+				recovery: input.command === "snapshot" ? `Retry \`treeport browser snapshot --panel ${panelId}\`.` : input.command === "screenshot" ? `Open Browser ${panelId} in Treeport, then retry the screenshot.` : `Run \`treeport browser snapshot --panel ${panelId}\`, then retry this Browser command.`
+			});
+		}) });
+	}).post("/api/panels/:panelId/browser-owner-ticket", jsonInput(browserOwnerTicketRequestSchema), async (context) => {
+		if (!browserSessions) throw new DomainError("BROWSER_UNAVAILABLE", "Browser service is unavailable", 503);
+		const remoteAddress = getConnInfo(context).remote.address;
+		const proxiedIdentity = [
+			"tailscale-user-login",
+			"tailscale-user-name",
+			"tailscale-user-profile-pic"
+		].some((name) => context.req.header(name) !== void 0);
+		if (!isLoopbackAddress(remoteAddress) || proxiedIdentity) throw new DomainError("BROWSER_LOCAL_OWNER_REQUIRED", "Only a local desktop app can own this Browser.", 403);
+		return context.json(await browserSessions.issueOwnerTicket(context.req.param("panelId"), context.req.valid("json").clientId));
+	}).post("/api/panels/:panelId/browser-ticket", jsonInput(browserTicketRequestSchema), async (context) => {
+		if (!browserSessions) throw new DomainError("BROWSER_UNAVAILABLE", "Hosted browser service is unavailable", 503);
+		const body = context.req.valid("json");
+		return context.json({ ticket: await browserSessions.issueTicket(context.req.param("panelId"), body.clientId, body.visible) });
+	});
+	app.route("/", browserApi);
+	app.route("/", createTreeFilesApi(service));
 	const api = new Hono().get("/api/health", (context) => context.json({
 		ok: true,
 		version: config.appVersion ?? "development",
-		protocolVersion: 2,
+		protocolVersion: 3,
 		hostname: os.hostname(),
 		pid: process.pid,
 		instanceId: config.instanceId ?? null,
@@ -7951,7 +8731,7 @@ function createApp({ service, config, tmux, applicationUpdate, terminalMetadata,
 	}).post("/api/update", async (context) => {
 		context.header("Cache-Control", "no-store");
 		return context.json(await applicationUpdate.start(), 202);
-	}).get("/api/terminal-presets", async (context) => context.json({ presets: await service.listTerminalPresets() })).get("/api/terminal-preset-definitions", queryInput(terminalPresetDefinitionsQuerySchema), async (context) => context.json(await service.listTerminalPresetDefinitions(context.req.valid("query")))).post("/api/terminal-presets", jsonInput(createTerminalPresetSchema), async (context) => {
+	}).get("/api/terminal-presets", async (context) => context.json({ presets: await service.listTerminalPresets() })).get("/api/tree-context-fields", queryInput(treeContextFieldsQuerySchema), async (context) => context.json(await service.listTreeContextFields(context.req.valid("query").projectId))).get("/api/terminal-preset-definitions", queryInput(terminalPresetDefinitionsQuerySchema), async (context) => context.json(await service.listTerminalPresetDefinitions(context.req.valid("query")))).post("/api/terminal-presets", jsonInput(createTerminalPresetSchema), async (context) => {
 		const body = context.req.valid("json");
 		return context.json({ preset: await service.createTerminalPreset(body) }, 201);
 	}).patch("/api/terminal-presets/:presetId", jsonInput(updateTerminalPresetSchema), async (context) => {
@@ -8003,19 +8783,23 @@ function createApp({ service, config, tmux, applicationUpdate, terminalMetadata,
 		let initialTerminal;
 		if (body.initialTerminal) {
 			initialTerminal = { name: body.initialTerminal.name };
+			if (body.initialTerminal.initialTitle) initialTerminal.initialTitle = body.initialTerminal.initialTitle;
 			if (body.initialTerminal.argv) initialTerminal.argv = body.initialTerminal.argv;
 			if (body.initialTerminal.returnToShell) initialTerminal.returnToShell = true;
 			if (body.initialTerminal.initialSize) initialTerminal.initialSize = body.initialTerminal.initialSize;
 		}
-		return context.json({ operation: await service.beginCreateWorktree(context.req.param("projectId"), body.name, body.base, initialTerminal, body.sourceWorktreeId) }, 202);
+		return context.json({ operation: await service.beginCreateWorktree(context.req.param("projectId"), body.name, body.base, initialTerminal, body.sourceWorktreeId, body.context) }, 202);
 	}).get("/api/worktrees/:worktreeId", async (context) => {
 		const worktreeId = context.req.param("worktreeId");
 		await service.refreshPr(worktreeId, false);
 		return context.json({ worktree: await service.getWorktreeSnapshot(worktreeId) });
-	}).post("/api/worktrees/:worktreeId/open", jsonInput(requestWorkspaceOpenSchema), async (context) => {
+	}).get("/api/worktrees/:worktreeId/context", async (context) => context.json({ context: await service.getWorktreeContext(context.req.param("worktreeId")) })).post("/api/worktrees/:worktreeId/open", jsonInput(requestWorkspaceOpenSchema), async (context) => {
 		await service.requestWorkspaceOpen(context.req.param("worktreeId"), context.req.valid("json").sourceTerminalId);
 		return context.json({ ok: true });
-	}).get("/api/worktrees/:worktreeId/web-panel-definitions", async (context) => context.json({ definitions: await service.listWebPanelDefinitions(context.req.param("worktreeId")) })).post("/api/worktrees/:worktreeId/panels", jsonInput(createWebPanelSchema), async (context) => {
+	}).post("/api/worktrees/:worktreeId/browser-panels", jsonInput(createBrowserPanelSchema), async (context) => {
+		const body = context.req.valid("json");
+		return context.json(await service.openBrowserPanel(context.req.param("worktreeId"), body.url, body.sourceTerminalId ?? null, null), 201);
+	}).post("/api/terminals/:terminalId/browser-panels/open", jsonInput(openBrowserPanelFromTerminalSchema), async (context) => context.json(await service.openBrowserPanelFromTerminal(context.req.param("terminalId"), context.req.valid("json").url), 201)).get("/api/worktrees/:worktreeId/web-panel-definitions", async (context) => context.json({ definitions: await service.listWebPanelDefinitions(context.req.param("worktreeId")) })).post("/api/worktrees/:worktreeId/panels", jsonInput(createWebPanelSchema), async (context) => {
 		const body = context.req.valid("json");
 		return context.json({ panel: await service.createWebPanel(context.req.param("worktreeId"), body.definitionId, {
 			input: body.input ?? null,
@@ -8027,10 +8811,13 @@ function createApp({ service, config, tmux, applicationUpdate, terminalMetadata,
 			input: body.input ?? null,
 			cwd: body.launchCwd ?? null
 		}, body.newInstance ?? false, body.sourceTerminalId ?? null));
-	}).delete("/api/panels/:panelId", queryInput(discardStoredDataQuerySchema), async (context) => {
-		await service.deleteWebPanel(context.req.param("panelId"), context.req.valid("query").discardStoredData === "true");
+	}).delete("/api/panels/:panelId", queryInput(deletePanelQuerySchema), async (context) => {
+		const panelId = context.req.param("panelId");
+		const query = context.req.valid("query");
+		if (await browserSessions?.requestPanelClose(panelId, query.force === "true") === false) throw new DomainError("BROWSER_BEFORE_UNLOAD", "Changes you made may not be saved.", 409);
+		await service.deletePanel(panelId, query.discardStoredData === "true");
 		return context.json({ ok: true });
-	}).get("/api/panels/:panelId/context", async (context) => context.json({ context: await service.getWebPanelContext(context.req.param("panelId")) })).get("/api/panels/:panelId/diff", async (context) => context.json({ diff: await service.getWebPanelDiff(context.req.param("panelId")) })).get("/api/panels/:panelId/network/listeners", async (context) => context.json({ discovery: await service.getWebPanelListeners(context.req.param("panelId")) })).get("/api/panels/:panelId/storage", async (context) => context.json({ hasData: await service.hasWebPanelStorage(context.req.param("panelId")) })).post("/api/panels/:panelId/storage/get", jsonInput(getWebPanelStorageSchema), async (context) => {
+	}).get("/api/panels/:panelId/context", async (context) => context.json({ context: await service.getWebPanelContext(context.req.param("panelId")) })).get("/api/panels/:panelId/diff", async (context) => context.json({ diff: await service.getWebPanelDiff(context.req.param("panelId")) })).get("/api/panels/:panelId/network/listeners", async (context) => context.json({ discovery: await service.getPanelListeners(context.req.param("panelId")) })).get("/api/panels/:panelId/storage", async (context) => context.json({ hasData: await service.hasWebPanelStorage(context.req.param("panelId")) })).post("/api/panels/:panelId/storage/get", jsonInput(getWebPanelStorageSchema), async (context) => {
 		const body = context.req.valid("json");
 		return context.json({ value: await service.getWebPanelStorage(context.req.param("panelId"), body.key) });
 	}).put("/api/panels/:panelId/storage", jsonInput(setWebPanelStorageSchema), async (context) => {
@@ -8091,6 +8878,7 @@ function createApp({ service, config, tmux, applicationUpdate, terminalMetadata,
 	}).post("/api/worktrees/:worktreeId/terminals", jsonInput(createTerminalSchema), async (context) => {
 		const body = context.req.valid("json");
 		const options = {};
+		if (body.initialTitle) options.initialTitle = body.initialTitle;
 		if (body.returnToShell) options.returnToShell = true;
 		if (body.closeOnSuccess) options.closeOnSuccess = true;
 		if (body.initialSize) options.initialSize = body.initialSize;
@@ -8445,18 +9233,1879 @@ function createApplicationUpdateManager(config, dependencies = {}) {
 				launchError = launchResult.error instanceof Error ? launchResult.error.message : "Treeport could not start the update process.";
 				throw new DomainError("APPLICATION_UPDATE_START_FAILED", "Treeport could not start the update process.", 500);
 			}
-			return status();
-		},
-		dispose() {
-			disposed = true;
-			pollingStarted = false;
-			if (pollTimer) {
-				clearTimeout(pollTimer);
-				pollTimer = null;
+			return status();
+		},
+		dispose() {
+			disposed = true;
+			pollingStarted = false;
+			if (pollTimer) {
+				clearTimeout(pollTimer);
+				pollTimer = null;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/server/playwright-browser.ts
+const DEFAULT_VIEWPORT = {
+	width: 1280,
+	height: 800
+};
+const DEFAULT_MAX_FRAME_RATE = 15;
+var PlaywrightBrowserHost = class {
+	cachePath;
+	profilePath;
+	browser = null;
+	context = null;
+	pages = /* @__PURE__ */ new Set();
+	operation = Promise.resolve();
+	constructor(cachePath, profilePath) {
+		this.cachePath = cachePath;
+		this.profilePath = profilePath;
+	}
+	get started() {
+		return this.context !== null;
+	}
+	schedule(operation) {
+		const result = this.operation.then(operation);
+		this.operation = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	openPage() {
+		return this.schedule(async () => {
+			let context = this.context;
+			let browser = this.browser;
+			let initialPage = null;
+			if (!context || !browser?.isConnected()) {
+				await fs.mkdir(this.profilePath, {
+					recursive: true,
+					mode: 448
+				});
+				await fs.chmod(this.profilePath, 448);
+				process.env.PLAYWRIGHT_BROWSERS_PATH = this.cachePath;
+				const { chromium } = await import("playwright");
+				context = await chromium.launchPersistentContext(this.profilePath, {
+					channel: "chromium",
+					headless: true,
+					acceptDownloads: false,
+					viewport: DEFAULT_VIEWPORT
+				});
+				browser = context.browser();
+				if (!browser) {
+					await context.close();
+					throw new Error("Playwright did not expose the hosted browser process.");
+				}
+				this.context = context;
+				this.browser = browser;
+				initialPage = context.pages()[0] ?? null;
+				browser.once("disconnected", () => {
+					if (this.browser === browser) {
+						this.browser = null;
+						this.context = null;
+						this.pages.clear();
+					}
+				});
+			}
+			const page = initialPage && !initialPage.isClosed() ? initialPage : await context.newPage();
+			this.pages.add(page);
+			return {
+				browser,
+				context,
+				page
+			};
+		});
+	}
+	closePage(page) {
+		return this.schedule(async () => {
+			this.pages.delete(page);
+			await page.close().catch(() => void 0);
+			if (this.pages.size > 0 || !this.context) return;
+			const context = this.context;
+			this.context = null;
+			this.browser = null;
+			await context.close().catch(() => void 0);
+		});
+	}
+	close() {
+		return this.schedule(async () => {
+			const context = this.context;
+			this.context = null;
+			this.browser = null;
+			this.pages.clear();
+			await context?.close().catch(() => void 0);
+		});
+	}
+};
+var LatestBrowserFrameProducer = class {
+	publish;
+	acknowledge;
+	maxFrameRate;
+	active = false;
+	pending = null;
+	timer = null;
+	lastPublishedAt = 0;
+	constructor(publish, acknowledge, maxFrameRate = DEFAULT_MAX_FRAME_RATE) {
+		this.publish = publish;
+		this.acknowledge = acknowledge;
+		this.maxFrameRate = maxFrameRate;
+	}
+	start() {
+		this.active = true;
+		this.lastPublishedAt = 0;
+	}
+	receive(frame) {
+		if (!this.active) {
+			this.acknowledge(frame.sessionId);
+			return;
+		}
+		if (this.pending) this.acknowledge(this.pending.sessionId);
+		this.pending = frame;
+		if (this.timer) return;
+		const minimumInterval = 1e3 / this.maxFrameRate;
+		const delay = Math.max(0, this.lastPublishedAt + minimumInterval - Date.now());
+		if (delay === 0) {
+			this.publishPending();
+			return;
+		}
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.publishPending();
+		}, delay);
+		this.timer.unref?.();
+	}
+	stop() {
+		this.active = false;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		if (this.pending) {
+			this.acknowledge(this.pending.sessionId);
+			this.pending = null;
+		}
+	}
+	publishPending() {
+		const frame = this.pending;
+		this.pending = null;
+		if (!frame) return;
+		if (!this.active) {
+			this.acknowledge(frame.sessionId);
+			return;
+		}
+		this.lastPublishedAt = Date.now();
+		try {
+			const data = Buffer.from(frame.data, "base64");
+			if (data.byteLength <= 8 * 1024 * 1024) this.publish({
+				mimeType: "image/jpeg",
+				timestamp: frame.metadata.timestamp ? frame.metadata.timestamp * 1e3 : Date.now(),
+				width: frame.metadata.deviceWidth,
+				height: frame.metadata.deviceHeight,
+				data
+			});
+		} finally {
+			this.acknowledge(frame.sessionId);
+		}
+	}
+};
+var PlaywrightBrowser = class {
+	host;
+	workspacePath;
+	callbacks;
+	browser = null;
+	context = null;
+	page = null;
+	cdp = null;
+	frameProducer = null;
+	screencasting = false;
+	screencastTail = Promise.resolve();
+	closing = false;
+	dialogHandler = null;
+	consoleMessages = [];
+	requests = [];
+	historyRevision = 0;
+	titleTimer = null;
+	stateValue = {
+		url: "about:blank",
+		title: "",
+		loading: false,
+		canGoBack: false,
+		canGoForward: false,
+		viewport: { ...DEFAULT_VIEWPORT }
+	};
+	constructor(host, workspacePath, callbacks) {
+		this.host = host;
+		this.workspacePath = workspacePath;
+		this.callbacks = callbacks;
+	}
+	static async status(cachePath) {
+		process.env.PLAYWRIGHT_BROWSERS_PATH = cachePath;
+		const [{ chromium }, packageJson] = await Promise.all([import("playwright"), import("playwright/package.json", { with: { type: "json" } })]);
+		const executablePath = chromium.executablePath();
+		const installed = await fs.access(executablePath).then(() => true, () => false);
+		const browserRevision = executablePath.split(/[/\\]/u).find((part) => part.startsWith("chromium-"));
+		let launchReady = false;
+		let launchError = null;
+		if (installed) {
+			const statusProfile = await fs.mkdtemp(path.join(cachePath, ".launch-status-"));
+			const context = await chromium.launchPersistentContext(statusProfile, {
+				channel: "chromium",
+				headless: true,
+				acceptDownloads: false
+			}).catch((error) => {
+				launchError = error instanceof Error ? error.message : String(error);
+				return null;
+			});
+			if (context) {
+				launchReady = true;
+				await context.close();
+			}
+			await fs.rm(statusProfile, {
+				recursive: true,
+				force: true
+			});
+		}
+		return {
+			installed,
+			executablePath,
+			playwrightVersion: String(packageJson.default.version),
+			browserRevision: browserRevision ?? "unknown",
+			channel: "chromium",
+			launchReady,
+			launchError
+		};
+	}
+	get state() {
+		return this.stateValue;
+	}
+	get connected() {
+		return this.browser?.isConnected() ?? false;
+	}
+	async launch() {
+		if (this.browser) return;
+		const { browser, context, page } = await this.host.openPage();
+		this.context = context;
+		this.browser = browser;
+		browser.once("disconnected", () => {
+			if (!this.closing) this.callbacks.crashed("The hosted browser process stopped.");
+		});
+		this.page = page;
+		await page.setViewportSize(this.stateValue.viewport);
+		const cdp = await context.newCDPSession(page);
+		this.cdp = cdp;
+		this.frameProducer = new LatestBrowserFrameProducer((frame) => this.callbacks.frame(frame), (sessionId) => {
+			cdp.send("Page.screencastFrameAck", { sessionId }).catch(() => void 0);
+		});
+		cdp.on("Page.screencastFrame", (frame) => this.frameProducer?.receive(frame));
+		page.on("popup", (candidate) => {
+			(async () => {
+				const supportedUrl = (value) => {
+					if (!URL.canParse(value)) return null;
+					const url = new URL(value);
+					return url.protocol === "http:" || url.protocol === "https:" ? url.href : null;
+				};
+				let popupUrl = supportedUrl(candidate.url());
+				if (!popupUrl) {
+					await candidate.waitForURL((url) => supportedUrl(url.href) !== null, { timeout: 5e3 }).catch(() => void 0);
+					popupUrl = supportedUrl(candidate.url());
+				}
+				if (popupUrl) this.callbacks.popup(popupUrl);
+				else this.callbacks.navigationError("The popup did not supply a supported HTTP or HTTPS URL.");
+				await candidate.close().catch(() => void 0);
+			})();
+		});
+		page.on("download", (download) => {
+			this.callbacks.navigationError("Downloads are not supported in Browser.");
+			download.cancel();
+		});
+		page.on("filechooser", (chooser) => {
+			this.callbacks.navigationError("File pickers are not supported in Browser.");
+			chooser.setFiles([]).catch(() => void 0);
+		});
+		page.on("close", () => {
+			if (!this.closing) this.callbacks.crashed("The hosted browser page closed.");
+		});
+		page.on("console", (message) => {
+			this.consoleMessages.push(`${message.type()}: ${message.text()}`);
+			if (this.consoleMessages.length > 1e3) this.consoleMessages.shift();
+		});
+		page.on("pageerror", (error) => {
+			this.consoleMessages.push(`error: ${error.message}`);
+			if (this.consoleMessages.length > 1e3) this.consoleMessages.shift();
+		});
+		page.on("request", (request) => {
+			this.requests.push(`${request.method()} ${request.url()}`);
+			if (this.requests.length > 2e3) this.requests.shift();
+			if (request.isNavigationRequest() && request.frame() === page.mainFrame()) this.updateState({ loading: true });
+		});
+		page.on("requestfailed", (request) => {
+			if (request.isNavigationRequest() && request.frame() === page.mainFrame()) {
+				this.updateState({ loading: false });
+				this.callbacks.navigationError(request.failure()?.errorText ?? "Navigation failed.");
+			}
+		});
+		page.on("framenavigated", (frame) => {
+			if (frame === page.mainFrame()) this.refreshPageState();
+		});
+		page.on("domcontentloaded", () => void this.refreshPageState());
+		page.on("load", () => {
+			this.updateState({ loading: false });
+			this.refreshPageState();
+		});
+		this.dialogHandler = (dialog) => void dialog.dismiss();
+		page.on("dialog", this.dialogHandler);
+		page.once("crash", () => this.callbacks.crashed("The hosted browser page crashed."));
+		this.cdp.on("Page.navigatedWithinDocument", () => {
+			this.refreshPageState();
+		});
+		await this.cdp.send("Page.enable");
+		this.titleTimer = setInterval(() => {
+			page.title().then((title) => {
+				if (title !== this.stateValue.title) this.updateState({ title });
+			}).catch(() => void 0);
+		}, 500);
+		this.titleTimer.unref();
+		await this.refreshPageState();
+	}
+	updateState(patch) {
+		this.stateValue = {
+			...this.stateValue,
+			...patch,
+			viewport: patch.viewport ?? this.stateValue.viewport
+		};
+		this.callbacks.state(this.stateValue);
+	}
+	async refreshPageState() {
+		const page = this.page;
+		const cdp = this.cdp;
+		if (!page || !cdp || page.isClosed()) return;
+		const revision = ++this.historyRevision;
+		const [title, history] = await Promise.all([page.title().catch(() => ""), cdp.send("Page.getNavigationHistory").catch(() => ({
+			currentIndex: 0,
+			entries: [{
+				id: 0,
+				url: page.url(),
+				userTypedURL: "",
+				title: "",
+				transitionType: "typed"
+			}]
+		}))]);
+		if (revision !== this.historyRevision || page.isClosed()) return;
+		this.updateState({
+			url: page.url(),
+			title,
+			canGoBack: history.currentIndex > 0,
+			canGoForward: history.currentIndex < history.entries.length - 1
+		});
+	}
+	async setScreencasting(enabled) {
+		const operation = this.screencastTail.then(async () => {
+			const page = this.page;
+			const cdp = this.cdp;
+			const frameProducer = this.frameProducer;
+			if (!page || page.isClosed() || !cdp || !frameProducer || enabled === this.screencasting) return;
+			this.screencasting = enabled;
+			if (!enabled) {
+				frameProducer.stop();
+				await cdp.send("Page.stopScreencast").catch(() => void 0);
+				return;
+			}
+			frameProducer.start();
+			await cdp.send("Page.startScreencast", {
+				format: "jpeg",
+				quality: 75,
+				maxWidth: this.stateValue.viewport.width,
+				maxHeight: this.stateValue.viewport.height,
+				everyNthFrame: 1
+			}).catch((error) => {
+				this.screencasting = false;
+				frameProducer.stop();
+				throw error;
+			});
+		});
+		this.screencastTail = operation.catch(() => void 0);
+		return operation;
+	}
+	async command(message) {
+		const page = this.page;
+		if (!page || page.isClosed()) throw new Error("The hosted browser page is unavailable.");
+		if (message.type === "navigate") {
+			this.updateState({ loading: true });
+			await page.goto(message.url, { waitUntil: "commit" }).catch((error) => {
+				this.updateState({ loading: false });
+				throw error;
+			});
+			await this.refreshPageState();
+			return;
+		}
+		if (message.type === "back") {
+			await page.goBack({ waitUntil: "commit" });
+			await this.refreshPageState();
+			return;
+		}
+		if (message.type === "forward") {
+			await page.goForward({ waitUntil: "commit" });
+			await this.refreshPageState();
+			return;
+		}
+		if (message.type === "reload") {
+			this.updateState({ loading: true });
+			await page.reload({ waitUntil: "commit" }).catch((error) => {
+				this.updateState({ loading: false });
+				throw error;
+			});
+			await this.refreshPageState();
+			return;
+		}
+		if (message.type === "stop") {
+			await this.cdp?.send("Page.stopLoading");
+			this.updateState({ loading: false });
+			return;
+		}
+		if (message.type === "resize") {
+			const wasScreencasting = this.screencasting;
+			if (wasScreencasting) await this.setScreencasting(false);
+			await page.setViewportSize({
+				width: message.width,
+				height: message.height
+			});
+			this.updateState({ viewport: {
+				width: message.width,
+				height: message.height
+			} });
+			if (wasScreencasting) await this.setScreencasting(true);
+			return;
+		}
+		if (message.type === "pointer") {
+			if (message.phase === "move") await page.mouse.move(message.x, message.y);
+			else if (message.phase === "down") {
+				await page.mouse.move(message.x, message.y);
+				await page.mouse.down({ button: message.button ?? "left" });
+			} else {
+				await page.mouse.move(message.x, message.y);
+				await page.mouse.up({ button: message.button ?? "left" });
+			}
+			return;
+		}
+		if (message.type === "wheel") {
+			await page.mouse.wheel(message.deltaX, message.deltaY);
+			return;
+		}
+		if (message.type === "key") {
+			if (message.phase === "down") await page.keyboard.down(message.key);
+			else await page.keyboard.up(message.key);
+			return;
+		}
+		if (message.type === "insertText") await page.keyboard.insertText(message.text);
+	}
+	async agentCommand(input) {
+		const page = this.page;
+		if (!page || page.isClosed()) throw new Error("The hosted browser page is unavailable.");
+		const target = (value) => page.locator(`aria-ref=${value}`);
+		if (input.command === "snapshot") return Reflect.apply(page.ariaSnapshot, page, [{ mode: "ai" }]);
+		if (input.command === "click") {
+			await target(input.args[0]).click();
+			return `Clicked ${input.args[0]}`;
+		}
+		if (input.command === "fill") {
+			await target(input.args[0]).fill(input.args[1]);
+			return `Filled ${input.args[0]}`;
+		}
+		if (input.command === "press") {
+			await page.keyboard.press(input.args[0]);
+			return `Pressed ${input.args[0]}`;
+		}
+		if (input.command === "console") {
+			const minimum = input.args[0] ?? "info";
+			const levels = [
+				"debug",
+				"info",
+				"warning",
+				"error"
+			];
+			const minimumIndex = Math.max(0, levels.indexOf(minimum));
+			return this.consoleMessages.filter((line) => {
+				const level = line.slice(0, line.indexOf(":"));
+				const index = levels.indexOf(level);
+				return index < 0 || index >= minimumIndex;
+			}).join("\n") || "No console messages.";
+		}
+		if (input.command === "requests") return this.requests.join("\n") || "No network requests.";
+		if (input.command === "screenshot") {
+			const screenshotPath = path.join(this.workspacePath, `screenshot-${Date.now()}.png`);
+			await page.screenshot({ path: screenshotPath });
+			return `Screenshot saved to ${screenshotPath}`;
+		}
+		if (input.command === "goto") {
+			await page.goto(input.args[0]);
+			await this.refreshPageState();
+			return `Navigated to ${page.url()}`;
+		}
+		if (input.command === "go-back") {
+			await page.goBack();
+			await this.refreshPageState();
+			return `Navigated to ${page.url()}`;
+		}
+		if (input.command === "go-forward") {
+			await page.goForward();
+			await this.refreshPageState();
+			return `Navigated to ${page.url()}`;
+		}
+		await page.reload();
+		await this.refreshPageState();
+		return `Reloaded ${page.url()}`;
+	}
+	async requestClose(force) {
+		const page = this.page;
+		if (!page || page.isClosed()) return true;
+		const previousClosing = this.closing;
+		this.closing = true;
+		if (this.dialogHandler) page.off("dialog", this.dialogHandler);
+		let timer = null;
+		let closeHandler = null;
+		let dialogHandler = null;
+		try {
+			return await new Promise((resolve, reject) => {
+				closeHandler = () => resolve(true);
+				dialogHandler = (dialog) => {
+					if (dialog.type() !== "beforeunload") {
+						dialog.dismiss().catch(reject);
+						return;
+					}
+					if (force) dialog.accept().catch(reject);
+					else dialog.dismiss().then(() => resolve(false), reject);
+				};
+				page.once("close", closeHandler);
+				page.on("dialog", dialogHandler);
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error("The page did not finish closing.")), 5e3);
+				timer.unref();
+				page.close({ runBeforeUnload: true }).catch(reject);
+			});
+		} finally {
+			if (timer) clearTimeout(timer);
+			if (closeHandler) page.off("close", closeHandler);
+			if (dialogHandler) page.off("dialog", dialogHandler);
+			if (!page.isClosed() && this.dialogHandler) page.on("dialog", this.dialogHandler);
+			this.closing = previousClosing;
+		}
+	}
+	async close() {
+		if (this.closing) return;
+		this.closing = true;
+		this.frameProducer?.stop();
+		await this.setScreencasting(false).catch(() => void 0);
+		if (this.titleTimer) {
+			clearInterval(this.titleTimer);
+			this.titleTimer = null;
+		}
+		await this.screencastTail;
+		const page = this.page;
+		if (page) await this.host.closePage(page);
+		this.page = null;
+		this.context = null;
+		this.cdp = null;
+		this.frameProducer = null;
+		this.browser = null;
+	}
+};
+//#endregion
+//#region src/server/browser-sessions.ts
+const MAX_BROWSER_ATTACHMENTS = 8;
+const MAX_BROWSER_TICKETS = 256;
+const LOCAL_BROWSER_OWNER_CONTROLLER = "local-owner";
+const attachmentController = (clientId) => `attachment:${clientId}`;
+const MAX_BROWSER_SCHEDULED_OPERATIONS = 64;
+const MAX_BROWSER_REGULAR_OPERATIONS = 46;
+const playwrightPackageSchema = z.object({ bin: z.object({ playwright: z.string() }).optional() });
+const defaultBrowserFactory = (host, workspacePath, _title, _panelId, _worktreeId, callbacks) => new PlaywrightBrowser(host, workspacePath, callbacks);
+const DEFAULT_STATE = {
+	url: "about:blank",
+	title: "",
+	loading: false,
+	canGoBack: false,
+	canGoForward: false,
+	viewport: {
+		width: 1280,
+		height: 800
+	}
+};
+var BrowserSessionManager = class {
+	service;
+	config;
+	browserFactory;
+	agentCliRunner;
+	connectLocalAutomation;
+	cachePath;
+	browserHost;
+	sessions = /* @__PURE__ */ new Map();
+	sessionCreations = /* @__PURE__ */ new Map();
+	tickets = /* @__PURE__ */ new Map();
+	ownerTickets = /* @__PURE__ */ new Map();
+	unsubscribe;
+	installing = null;
+	constructor(service, config, browserFactory = defaultBrowserFactory, agentCliRunner = null, connectLocalAutomation = async (endpoint) => {
+		const { chromium } = await import("playwright");
+		return chromium.connectOverCDP(endpoint, { timeout: 1e4 });
+	}) {
+		this.service = service;
+		this.config = config;
+		this.browserFactory = browserFactory;
+		this.agentCliRunner = agentCliRunner;
+		this.connectLocalAutomation = connectLocalAutomation;
+		this.cachePath = path.join(config.cacheDir, "playwright");
+		this.browserHost = new PlaywrightBrowserHost(this.cachePath, path.join(config.dataDir, "browser-profile"));
+		this.unsubscribe = service.events.subscribe((event) => {
+			if (event.type === "panel.removed") this.closePanel(String(event.data.panelId), "Panel closed");
+			else if (event.type === "worktree.removed" && event.data.worktreeId) for (const session of this.sessions.values()) this.service.authorizeBrowserPanel(session.panelId).catch(() => this.closePanel(session.panelId, "Worktree removed"));
+		});
+	}
+	async issueTicket(panelId, clientId, visible = true) {
+		await this.service.authorizeBrowserPanel(panelId);
+		for (const [value, ticket] of this.tickets) if (ticket.expiresAt < Date.now()) this.tickets.delete(value);
+		if (this.tickets.size >= MAX_BROWSER_TICKETS) throw new Error("Too many Browser attachment requests are pending.");
+		const ticket = crypto.randomBytes(32).toString("base64url");
+		this.tickets.set(ticket, {
+			panelId,
+			clientId,
+			visible,
+			expiresAt: Date.now() + 3e4
+		});
+		return ticket;
+	}
+	async issueOwnerTicket(panelId, clientId) {
+		await this.service.authorizeBrowserPanel(panelId);
+		for (const [value, ticket] of this.ownerTickets) if (ticket.expiresAt < Date.now()) this.ownerTickets.delete(value);
+		if (this.ownerTickets.size >= MAX_BROWSER_TICKETS) throw new Error("Too many Browser owner requests are pending.");
+		const ticket = crypto.randomBytes(32).toString("base64url");
+		const currentOwner = this.sessions.get(panelId)?.localOwner;
+		const challenge = currentOwner?.clientId === clientId ? currentOwner.challenge : crypto.randomBytes(32).toString("base64url");
+		this.ownerTickets.set(ticket, {
+			panelId,
+			clientId,
+			challenge,
+			expiresAt: Date.now() + 3e4
+		});
+		return {
+			ticket,
+			challenge
+		};
+	}
+	stateFor(session, attachment) {
+		return {
+			...session.state,
+			controlled: session.controllerId === attachmentController(attachment.clientId),
+			hasController: session.localOwner !== null || session.controllerId !== null,
+			controller: session.controllerId === attachmentController(attachment.clientId) ? "you" : session.controllerId === "agent" ? "agent" : session.localOwner || session.controllerId ? "other" : "none"
+		};
+	}
+	broadcastState(session, type = "state") {
+		for (const attachment of session.attachments.values()) attachment.transport.sendMessage({
+			type,
+			state: this.stateFor(session, attachment)
+		});
+	}
+	enqueueOperation(session, operation, allowWhenClosing = false) {
+		const scheduler = session.scheduler;
+		if (!scheduler.accepting && !allowWhenClosing) return false;
+		if (operation.coalesceKey) {
+			const existing = scheduler.coalesced.get(operation.coalesceKey);
+			if (existing) {
+				if (existing.message?.type === "wheel" && operation.message?.type === "wheel") existing.message = {
+					type: "wheel",
+					deltaX: Math.max(-1e4, Math.min(1e4, existing.message.deltaX + operation.message.deltaX)),
+					deltaY: Math.max(-1e4, Math.min(1e4, existing.message.deltaY + operation.message.deltaY))
+				};
+				else existing.message = operation.message;
+				existing.execute = operation.execute;
+				existing.completions.push(...operation.completions);
+				existing.required ||= operation.required;
+				return true;
+			}
+		}
+		if (scheduler.queue.length >= MAX_BROWSER_SCHEDULED_OPERATIONS || !operation.required && scheduler.queue.length >= MAX_BROWSER_REGULAR_OPERATIONS) return false;
+		scheduler.queue.push(operation);
+		if (operation.coalesceKey) scheduler.coalesced.set(operation.coalesceKey, operation);
+		this.runScheduler(session);
+		return true;
+	}
+	scheduleOperation(session, execute, options = {}) {
+		return new Promise((resolve, reject) => {
+			if (!this.enqueueOperation(session, {
+				coalesceKey: options.coalesceKey ?? null,
+				message: null,
+				execute: () => execute(),
+				completions: [{
+					resolve,
+					reject
+				}],
+				required: options.required ?? false
+			}, options.allowWhenClosing)) reject(/* @__PURE__ */ new Error(session.scheduler.accepting ? "The Browser command queue is full." : "The Browser session is closing."));
+		});
+	}
+	queueClientOperation(session, attachment, operation) {
+		if (!this.enqueueOperation(session, {
+			...operation,
+			completions: []
+		})) attachment.transport.sendMessage({
+			type: "navigationError",
+			message: session.scheduler.accepting ? "The Browser command queue is full. Wait and try again." : "The Browser session is closing."
+		});
+	}
+	runScheduler(session) {
+		const scheduler = session.scheduler;
+		if (scheduler.running) return;
+		scheduler.running = true;
+		(async () => {
+			while (scheduler.queue.length > 0) {
+				const operation = scheduler.queue.shift();
+				if (operation.coalesceKey) scheduler.coalesced.delete(operation.coalesceKey);
+				try {
+					await operation.execute(operation.message);
+					for (const completion of operation.completions) completion.resolve();
+				} catch (cause) {
+					const error = cause instanceof Error ? cause : new Error(String(cause));
+					for (const completion of operation.completions) completion.reject(error);
+				}
+			}
+			scheduler.running = false;
+		})();
+	}
+	stopScheduler(session, reason) {
+		session.scheduler.accepting = false;
+		const error = new Error(reason);
+		for (const operation of session.scheduler.queue.splice(0)) for (const completion of operation.completions) completion.reject(error);
+		session.scheduler.coalesced.clear();
+	}
+	broadcastNavigationError(session, message) {
+		for (const attachment of session.attachments.values()) attachment.transport.sendMessage({
+			type: "navigationError",
+			message
+		});
+	}
+	async openPopup(session, url) {
+		await this.service.openBrowserPanelFromPanel(session.panelId, url).catch((cause) => this.broadcastNavigationError(session, `Could not open the popup: ${cause instanceof Error ? cause.message : String(cause)}`));
+	}
+	queuePanelState(session, value) {
+		if (session.closing || !session.persistence.ready) return;
+		const parsed = value.url === "about:blank" ? {
+			success: true,
+			data: "about:blank"
+		} : browserUrlSchema.safeParse(value.url);
+		if (!parsed.success) return;
+		const url = parsed.data === "about:blank" ? parsed.data : new URL(parsed.data).href;
+		const title = value.title.trim().slice(0, 256) || (url === "about:blank" ? "Browser" : new URL(url).host || "Browser");
+		const persistence = session.persistence;
+		if (persistence.pending?.url === url && persistence.pending.title === title || persistence.persistedUrl === url && persistence.persistedTitle === title) return;
+		persistence.pending = {
+			url,
+			title
+		};
+		if (persistence.write) return;
+		const write = (async () => {
+			while (persistence.pending !== null) {
+				const pending = persistence.pending;
+				persistence.pending = null;
+				try {
+					const panel = await this.service.updateBrowserPanelState(session.panelId, pending);
+					persistence.persistedUrl = panel.url;
+					persistence.persistedTitle = panel.title;
+				} catch (cause) {
+					const message = cause instanceof Error ? cause.message : String(cause);
+					for (const attachment of session.attachments.values()) attachment.transport.sendMessage({
+						type: "navigationError",
+						message: `Could not save the Browser address and title: ${message}`
+					});
+					return;
+				}
+			}
+		})();
+		persistence.write = write;
+		write.finally(() => {
+			if (persistence.write !== write) return;
+			persistence.write = null;
+			const pending = persistence.pending;
+			persistence.pending = null;
+			if (pending !== null && !session.closing) this.queuePanelState(session, pending);
+		});
+	}
+	async waitForPanelState(session) {
+		while (session.persistence.write) await session.persistence.write;
+	}
+	async createSession(panelId) {
+		const authorized = await this.service.authorizeBrowserPanel(panelId);
+		const restoredUrl = authorized.panel.url === "about:blank" ? null : browserUrlSchema.parse(authorized.panel.url);
+		const agentDirectory = path.join(this.config.runtimeDir, "browsers", panelId);
+		await fs.rm(agentDirectory, {
+			recursive: true,
+			force: true
+		});
+		await fs.mkdir(agentDirectory, {
+			recursive: true,
+			mode: 448
+		});
+		await fs.chmod(agentDirectory, 448);
+		const session = {
+			panelId,
+			agentDirectory,
+			title: `Treeport ${authorized.panel.title}`,
+			browser: null,
+			launch: null,
+			localOwner: null,
+			localAutomation: null,
+			localAutomationLaunch: null,
+			generation: 0,
+			attachments: /* @__PURE__ */ new Map(),
+			controllerId: null,
+			state: {
+				...DEFAULT_STATE,
+				url: restoredUrl ?? DEFAULT_STATE.url,
+				title: authorized.panel.title === "Browser" ? "" : authorized.panel.title,
+				viewport: { ...DEFAULT_STATE.viewport }
+			},
+			sequence: 0,
+			latestFrame: null,
+			scheduler: {
+				queue: [],
+				coalesced: /* @__PURE__ */ new Map(),
+				running: false,
+				accepting: true
+			},
+			persistence: {
+				persistedUrl: authorized.panel.url,
+				persistedTitle: authorized.panel.title,
+				pending: null,
+				write: null,
+				ready: true
+			},
+			agentAttached: false,
+			agentSessionName: null,
+			agentProcess: null,
+			crashMessage: null,
+			closing: false,
+			closeOperation: null
+		};
+		this.sessions.set(panelId, session);
+		return session;
+	}
+	async ensurePlaywrightRuntime(session) {
+		if (session.localOwner) throw new Error("This Browser is open in a local Treeport desktop app.");
+		if (session.launch) return session.launch;
+		if ([...this.sessions.values()].filter((candidate) => candidate.localOwner || candidate.launch).length >= 6) throw new Error("Treeport supports at most six active Browser sessions. Close one and try again.");
+		const runtimeGeneration = ++session.generation;
+		const restoredUrl = session.state.url;
+		const restoredTitle = session.state.title;
+		const launch = (async () => {
+			await fs.rm(session.agentDirectory, {
+				recursive: true,
+				force: true
+			});
+			await fs.mkdir(session.agentDirectory, {
+				recursive: true,
+				mode: 448
+			});
+			await fs.chmod(session.agentDirectory, 448);
+			let runtimeReady = false;
+			const browser = this.browserFactory(this.browserHost, session.agentDirectory, session.title, session.panelId, (await this.service.authorizeBrowserPanel(session.panelId)).panel.worktreeId, {
+				state: (state) => {
+					if (!runtimeReady || session.browser !== browser || session.generation !== runtimeGeneration || session.localOwner) return;
+					session.state = state;
+					this.queuePanelState(session, state);
+					this.broadcastState(session);
+				},
+				frame: (frame) => {
+					if (runtimeReady && session.browser === browser && session.generation === runtimeGeneration && !session.localOwner) this.publishFrame(session, frame);
+				},
+				popup: (url) => {
+					if (!runtimeReady || session.browser !== browser || session.generation !== runtimeGeneration || session.localOwner) return;
+					this.openPopup(session, url);
+				},
+				navigationError: (message) => this.broadcastNavigationError(session, message),
+				crashed: (message) => {
+					if (!runtimeReady || session.browser !== browser || session.generation !== runtimeGeneration || session.localOwner) return;
+					session.crashMessage = message;
+					for (const attachment of session.attachments.values()) attachment.transport.sendMessage({
+						type: "browserCrashed",
+						message
+					});
+				}
+			});
+			session.browser = browser;
+			await browser.launch();
+			if (session.browser !== browser || session.generation !== runtimeGeneration || session.localOwner) {
+				await browser.close();
+				throw new Error("The Browser runtime changed during launch.");
+			}
+			session.state = browser.state;
+			if (restoredUrl !== "about:blank") session.state = await browser.command({
+				type: "navigate",
+				url: restoredUrl
+			}).then(() => true, () => false) ? browser.state : {
+				...browser.state,
+				url: restoredUrl,
+				title: restoredTitle
+			};
+			runtimeReady = true;
+			session.state = browser.state;
+			this.queuePanelState(session, session.state);
+			this.broadcastState(session);
+			return browser;
+		})();
+		session.launch = launch;
+		launch.catch(() => {
+			if (session.launch === launch) {
+				session.launch = null;
+				session.browser = null;
+			}
+		});
+		return launch;
+	}
+	browserFor(session) {
+		return this.ensurePlaywrightRuntime(session);
+	}
+	async getSession(panelId) {
+		const existing = this.sessions.get(panelId);
+		if (existing) {
+			await this.service.authorizeBrowserPanel(panelId);
+			return existing;
+		}
+		const pending = this.sessionCreations.get(panelId);
+		if (pending) return pending;
+		const creation = this.createSession(panelId).finally(() => {
+			if (this.sessionCreations.get(panelId) === creation) this.sessionCreations.delete(panelId);
+		});
+		this.sessionCreations.set(panelId, creation);
+		return creation;
+	}
+	async accept(ticketValue, transport) {
+		const ticket = this.tickets.get(ticketValue);
+		this.tickets.delete(ticketValue);
+		if (!ticket || ticket.expiresAt < Date.now()) throw new Error("INVALID_BROWSER_TICKET");
+		const session = await this.getSession(ticket.panelId);
+		const supersededAttachments = [...session.attachments.values()].filter((candidate) => candidate.clientId === ticket.clientId);
+		if (session.attachments.size - supersededAttachments.length >= MAX_BROWSER_ATTACHMENTS) {
+			transport.sendMessage({
+				type: "browserUnavailable",
+				message: "This Browser already has the maximum of eight attached clients.",
+				installCommand: null
+			});
+			return transport.id;
+		}
+		const attachment = {
+			id: transport.id,
+			clientId: ticket.clientId,
+			transport,
+			visible: ticket.visible,
+			closing: false,
+			awaitingFrame: null,
+			pendingFrame: null,
+			viewport: { ...session.state.viewport }
+		};
+		session.attachments.set(attachment.id, attachment);
+		try {
+			if (!session.localOwner) await this.browserFor(session);
+			if (!transport.isConnected()) {
+				this.close(attachment.id);
+				return attachment.id;
+			}
+			await this.scheduleOperation(session, async () => {
+				if (attachment.closing) return;
+				for (const superseded of supersededAttachments) {
+					if (session.attachments.get(superseded.id) !== superseded) continue;
+					superseded.closing = true;
+					session.attachments.delete(superseded.id);
+					superseded.transport.disconnect();
+				}
+				if (attachment.visible && session.controllerId === null) session.controllerId = attachmentController(attachment.clientId);
+				await this.updateScreencast(session);
+			}, { required: true });
+			transport.sendMessage({
+				type: "ready",
+				state: this.stateFor(session, attachment)
+			});
+			this.broadcastState(session, "controlChanged");
+			if (session.crashMessage) transport.sendMessage({
+				type: "browserCrashed",
+				message: session.crashMessage
+			});
+			this.sendLatestFrame(session, attachment);
+		} catch (error) {
+			attachment.closing = true;
+			session.attachments.delete(attachment.id);
+			if (session.controllerId === attachmentController(attachment.clientId) && ![...session.attachments.values()].some((candidate) => candidate.clientId === attachment.clientId)) session.controllerId = session.localOwner ? LOCAL_BROWSER_OWNER_CONTROLLER : null;
+			transport.sendMessage({
+				type: "browserUnavailable",
+				message: error instanceof Error ? error.message : String(error),
+				installCommand: session.localOwner ? null : "treeport browser install"
+			});
+			if (!session.localOwner) await this.closePlaywrightRuntime(session).catch(() => void 0);
+		}
+		return attachment.id;
+	}
+	async acceptOwner(auth, transport) {
+		const ticket = this.ownerTickets.get(auth.ticket);
+		this.ownerTickets.delete(auth.ticket);
+		if (!ticket || ticket.expiresAt < Date.now() || ticket.challenge !== auth.challenge || !browserOwnerEndpointSchema.safeParse(auth.endpoint).success) throw new Error("INVALID_BROWSER_OWNER_TICKET");
+		const identityResponse = await fetch(new URL("identity", auth.endpoint), {
+			signal: AbortSignal.timeout(3e3),
+			redirect: "error"
+		});
+		const identity = z.strictObject({
+			panelId: z.string().min(1).max(128),
+			challenge: z.string().min(32).max(256)
+		}).parse(await identityResponse.json());
+		if (!identityResponse.ok || identity.panelId !== ticket.panelId || identity.challenge !== ticket.challenge) throw new Error("INVALID_BROWSER_OWNER_IDENTITY");
+		const session = await this.getSession(ticket.panelId);
+		await this.scheduleOperation(session, async () => {
+			const previousOwner = session.localOwner;
+			if (previousOwner?.transport.isConnected()) {
+				transport.send({
+					type: "claimRejected",
+					message: "This Browser is open in another local desktop app."
+				});
+				transport.disconnect();
+				return;
+			}
+			if ([...this.sessions.values()].filter((candidate) => candidate !== session && (candidate.localOwner !== null || candidate.launch !== null)).length >= 6) {
+				transport.send({
+					type: "claimRejected",
+					message: "Treeport supports at most six active Browser sessions. Close one and try again."
+				});
+				transport.disconnect();
+				return;
+			}
+			let resolveReady = null;
+			const readyPromise = new Promise((resolve) => {
+				resolveReady = resolve;
+			});
+			const resumed = previousOwner?.clientId === ticket.clientId;
+			let owner;
+			if (previousOwner) {
+				previousOwner.resolveReady?.();
+				for (const request of previousOwner.requests.values()) {
+					clearTimeout(request.timer);
+					request.resolve(false);
+				}
+				previousOwner.requests.clear();
+				if (previousOwner.endpoint !== auth.endpoint) {
+					await this.closeLocalAutomation(session);
+					session.latestFrame = null;
+					session.sequence = 0;
+				}
+				previousOwner.transport = transport;
+				previousOwner.clientId = ticket.clientId;
+				previousOwner.endpoint = auth.endpoint;
+				previousOwner.challenge = auth.challenge;
+				previousOwner.generation = resumed ? previousOwner.generation : ++session.generation;
+				previousOwner.revision = -1;
+				previousOwner.ready = false;
+				previousOwner.controller = "none";
+				previousOwner.retainPaint = false;
+				previousOwner.readyPromise = readyPromise;
+				previousOwner.resolveReady = resolveReady;
+				owner = previousOwner;
+			} else {
+				await this.closePlaywrightRuntime(session);
+				owner = {
+					transport,
+					clientId: ticket.clientId,
+					endpoint: auth.endpoint,
+					challenge: auth.challenge,
+					generation: ++session.generation,
+					revision: -1,
+					ready: false,
+					controller: "none",
+					retainPaint: false,
+					readyPromise,
+					resolveReady,
+					requests: /* @__PURE__ */ new Map()
+				};
+				session.localOwner = owner;
+				session.controllerId = LOCAL_BROWSER_OWNER_CONTROLLER;
+				session.latestFrame = null;
+				session.sequence = 0;
+			}
+			if (!transport.isConnected()) return;
+			session.controllerId ??= LOCAL_BROWSER_OWNER_CONTROLLER;
+			transport.send({
+				type: "claimGranted",
+				panelId: session.panelId,
+				generation: owner.generation,
+				resumed,
+				state: session.state
+			});
+			if (!previousOwner) this.broadcastState(session, "controlChanged");
+		}, { required: true });
+		return transport.id;
+	}
+	ownerMessage(connectionId, value) {
+		const session = [...this.sessions.values()].find((candidate) => candidate.localOwner?.transport.id === connectionId);
+		const message = parseBrowserOwnerClientMessage(value);
+		const owner = session?.localOwner;
+		if (!session || !owner || !message) {
+			owner?.transport.disconnect();
+			return;
+		}
+		if (message.generation !== owner.generation) return;
+		if (message.type === "ready" || message.type === "state") {
+			if (message.revision <= owner.revision) return;
+			owner.revision = message.revision;
+			session.state = message.state;
+			this.queuePanelState(session, message.state);
+			this.broadcastState(session);
+			if (message.type === "ready" && !owner.ready) {
+				owner.ready = true;
+				owner.resolveReady?.();
+				owner.resolveReady = null;
+				this.scheduleOperation(session, () => this.updateScreencast(session), { required: true }).catch((cause) => this.broadcastNavigationError(session, cause instanceof Error ? cause.message : String(cause)));
+			}
+			return;
+		}
+		if (message.type === "takeControl") {
+			this.scheduleOperation(session, async () => {
+				if (session.localOwner !== owner) return;
+				await this.updateScreencast(session, LOCAL_BROWSER_OWNER_CONTROLLER);
+				if (session.localOwner !== owner) throw new Error("The local Browser owner changed.");
+				session.controllerId = LOCAL_BROWSER_OWNER_CONTROLLER;
+				this.broadcastState(session, "controlChanged");
+			}, { required: true }).catch(() => void 0);
+			return;
+		}
+		if (message.type === "released") {
+			this.scheduleOperation(session, () => this.releaseLocalOwner(session, owner), { required: true }).catch((cause) => this.broadcastNavigationError(session, cause instanceof Error ? cause.message : String(cause)));
+			return;
+		}
+		if (message.type === "popup") {
+			this.openPopup(session, message.url);
+			return;
+		}
+		if (message.type === "crashed") {
+			session.crashMessage = message.message;
+			for (const attachment of session.attachments.values()) attachment.transport.sendMessage({
+				type: "browserCrashed",
+				message: message.message
+			});
+			return;
+		}
+		const request = owner.requests.get(message.requestId);
+		if (!request) return;
+		owner.requests.delete(message.requestId);
+		clearTimeout(request.timer);
+		request.resolve(message.type === "runtimeControlResult" ? message.accepted : message.canClose);
+	}
+	closeOwner(connectionId) {
+		const session = [...this.sessions.values()].find((candidate) => candidate.localOwner?.transport.id === connectionId);
+		const owner = session?.localOwner;
+		if (!session || !owner) return;
+		owner.ready = false;
+		owner.resolveReady?.();
+		owner.resolveReady = null;
+		for (const request of owner.requests.values()) {
+			clearTimeout(request.timer);
+			request.resolve(false);
+		}
+		owner.requests.clear();
+	}
+	async releaseLocalOwner(session, owner) {
+		if (session.localOwner !== owner) return;
+		session.localOwner = null;
+		owner.ready = false;
+		owner.resolveReady?.();
+		owner.resolveReady = null;
+		for (const request of owner.requests.values()) {
+			clearTimeout(request.timer);
+			request.resolve(false);
+		}
+		owner.requests.clear();
+		await this.closeLocalAutomation(session);
+		session.generation += 1;
+		session.latestFrame = null;
+		session.sequence = 0;
+		if (session.controllerId === LOCAL_BROWSER_OWNER_CONTROLLER || session.controllerId === "agent") {
+			const attachment = [...session.attachments.values()].find((candidate) => !candidate.closing && candidate.visible && candidate.transport.isConnected());
+			session.controllerId = attachment ? attachmentController(attachment.clientId) : null;
+		}
+		session.agentProcess?.kill("SIGTERM");
+		session.agentProcess = null;
+		await this.detachAgent(session);
+		this.broadcastState(session, "controlChanged");
+		if (![...session.attachments.values()].some((attachment) => !attachment.closing && attachment.visible && attachment.transport.isConnected())) return;
+		const runtimeError = await this.browserFor(session).then(() => this.updateScreencast(session)).then(() => null, (cause) => cause);
+		if (runtimeError !== null) {
+			for (const attachment of session.attachments.values()) attachment.transport.sendMessage({
+				type: "browserUnavailable",
+				message: runtimeError instanceof Error ? runtimeError.message : String(runtimeError),
+				installCommand: "treeport browser install"
+			});
+			await this.closePlaywrightRuntime(session).catch(() => void 0);
+		}
+	}
+	requestLocalOwner(owner, message) {
+		if (!owner.transport.isConnected()) return Promise.resolve(false);
+		const requestId = crypto.randomUUID();
+		return new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				owner.requests.delete(requestId);
+				resolve(false);
+			}, 5e3);
+			timer.unref();
+			owner.requests.set(requestId, {
+				resolve,
+				timer
+			});
+			if (!owner.transport.send({
+				...message,
+				generation: owner.generation,
+				requestId
+			})) {
+				clearTimeout(timer);
+				owner.requests.delete(requestId);
+				resolve(false);
+			}
+		});
+	}
+	async setLocalOwnerRuntimeControl(session, owner, controller, retainPaint) {
+		if (owner.controller === controller && owner.retainPaint === retainPaint) return;
+		if (!await this.requestLocalOwner(owner, {
+			type: "runtimeControl",
+			controller,
+			retainPaint
+		}) || session.localOwner !== owner || session.generation !== owner.generation) throw new Error("The local Browser owner did not accept control.");
+		owner.controller = controller;
+		owner.retainPaint = retainPaint;
+	}
+	sendLatestFrame(session, attachment) {
+		const frame = session.latestFrame;
+		if (!frame || !attachment.visible || attachment.awaitingFrame !== null || !attachment.transport.isConnected()) return;
+		if (attachment.transport.sendFrame(frame)) attachment.awaitingFrame = frame.sequence;
+	}
+	publishFrame(session, value) {
+		if (value.data.byteLength > 8388608) return;
+		const frame = {
+			...value,
+			sequence: ++session.sequence
+		};
+		session.latestFrame = frame;
+		for (const attachment of session.attachments.values()) {
+			if (!attachment.visible || !attachment.transport.isConnected()) continue;
+			if (attachment.awaitingFrame !== null) {
+				attachment.pendingFrame = frame;
+				continue;
+			}
+			if (attachment.transport.sendFrame(frame)) attachment.awaitingFrame = frame.sequence;
+		}
+	}
+	message(connectionId, value) {
+		const entry = [...this.sessions.values()].map((session) => ({
+			session,
+			attachment: session.attachments.get(connectionId)
+		})).find((candidate) => candidate.attachment !== void 0);
+		if (!entry) return;
+		const message = parseBrowserClientMessage(value);
+		if (!message) {
+			entry.attachment.transport.disconnect();
+			return;
+		}
+		const { session, attachment } = entry;
+		if (attachment.closing) return;
+		if (message.type === "frameAck") {
+			if (attachment.awaitingFrame !== message.sequence) return;
+			attachment.awaitingFrame = null;
+			const pending = attachment.pendingFrame;
+			attachment.pendingFrame = null;
+			if (pending && attachment.transport.sendFrame(pending)) attachment.awaitingFrame = pending.sequence;
+			return;
+		}
+		if (message.type === "setVisible") {
+			attachment.visible = message.visible;
+			if (message.visible) this.sendLatestFrame(session, attachment);
+			else {
+				attachment.awaitingFrame = null;
+				attachment.pendingFrame = null;
+			}
+			this.queueClientOperation(session, attachment, {
+				coalesceKey: `screencast:${session.panelId}`,
+				message: null,
+				execute: async () => {
+					const previousController = session.controllerId;
+					let nextController = previousController;
+					if (attachment.visible && previousController === null) nextController = attachmentController(attachment.clientId);
+					else if (!attachment.visible && previousController === attachmentController(attachment.clientId)) {
+						const nextAttachment = [...session.attachments.values()].find((candidate) => candidate.id !== attachment.id && !candidate.closing && candidate.visible);
+						nextController = nextAttachment ? attachmentController(nextAttachment.clientId) : session.localOwner ? LOCAL_BROWSER_OWNER_CONTROLLER : null;
+					}
+					await this.updateScreencast(session, nextController);
+					session.controllerId = nextController;
+					if (nextController !== previousController) this.broadcastState(session, "controlChanged");
+				},
+				required: true
+			});
+			return;
+		}
+		if (message.type === "resize") {
+			attachment.viewport = {
+				width: message.width,
+				height: message.height
+			};
+			if (session.localOwner) return;
+			this.queueClientOperation(session, attachment, {
+				coalesceKey: `resize:${attachment.id}`,
+				message,
+				execute: async (queuedMessage) => {
+					if (queuedMessage?.type !== "resize" || attachment.closing || session.attachments.get(attachment.id) !== attachment || session.controllerId !== attachmentController(attachment.clientId)) return;
+					try {
+						await (await this.browserFor(session)).command(queuedMessage);
+					} catch (cause) {
+						attachment.transport.sendMessage({
+							type: "navigationError",
+							message: cause instanceof Error ? cause.message : String(cause)
+						});
+					}
+				},
+				required: false
+			});
+			return;
+		}
+		if (message.type === "takeControl") {
+			this.queueClientOperation(session, attachment, {
+				coalesceKey: null,
+				message: null,
+				execute: async () => {
+					if (attachment.closing || session.attachments.get(attachment.id) !== attachment) return;
+					const previousController = session.controllerId;
+					const nextController = attachmentController(attachment.clientId);
+					try {
+						if (session.localOwner) await this.updateScreencast(session, nextController);
+						else await (await this.browserFor(session)).command({
+							type: "resize",
+							...attachment.viewport
+						});
+						session.controllerId = nextController;
+						if (previousController !== nextController) this.broadcastState(session, "controlChanged");
+					} catch (cause) {
+						attachment.transport.sendMessage({
+							type: "navigationError",
+							message: cause instanceof Error ? cause.message : String(cause)
+						});
+					}
+				},
+				required: false
+			});
+			return;
+		}
+		const coalesceKey = message.type === "pointer" && message.phase === "move" ? `pointer-move:${attachment.id}` : message.type === "wheel" ? `wheel:${attachment.id}` : null;
+		this.queueClientOperation(session, attachment, {
+			coalesceKey,
+			message,
+			execute: async (queuedMessage) => {
+				if (!queuedMessage || attachment.closing || session.attachments.get(attachment.id) !== attachment) return;
+				if (session.controllerId !== attachmentController(attachment.clientId)) {
+					attachment.transport.sendMessage({
+						type: "navigationError",
+						message: "Take control before you interact with this browser."
+					});
+					return;
+				}
+				try {
+					const localOwner = session.localOwner;
+					if (localOwner) await this.executeLocalClientCommand(session, localOwner, queuedMessage);
+					else {
+						const browser = await this.browserFor(session);
+						await browser.command(queuedMessage);
+						this.queuePanelState(session, browser.state);
+						await this.waitForPanelState(session);
+					}
+				} catch (cause) {
+					attachment.transport.sendMessage({
+						type: "navigationError",
+						message: cause instanceof Error ? cause.message : String(cause)
+					});
+				}
+			},
+			required: false
+		});
+	}
+	async updateScreencast(session, controllerId = session.controllerId) {
+		const visible = [...session.attachments.values()].some((attachment) => !attachment.closing && attachment.visible && attachment.transport.isConnected());
+		const localOwner = session.localOwner;
+		if (localOwner) {
+			const controller = controllerId === "agent" ? "agent" : controllerId && controllerId !== LOCAL_BROWSER_OWNER_CONTROLLER ? "other" : "none";
+			const retainPaint = visible || controller === "agent";
+			if (visible) {
+				await this.setLocalOwnerRuntimeControl(session, localOwner, controller, retainPaint);
+				await this.setLocalScreencasting(session, localOwner, true);
+			} else {
+				await this.setLocalScreencasting(session, localOwner, false);
+				await this.setLocalOwnerRuntimeControl(session, localOwner, controller, retainPaint);
+			}
+			return;
+		}
+		if (!session.launch) return;
+		await (await session.launch.catch(() => null))?.setScreencasting(visible).catch(() => void 0);
+	}
+	async detachAgent(session) {
+		const name = session.agentSessionName;
+		if (!session.agentAttached || !name) return;
+		session.agentAttached = false;
+		session.agentSessionName = null;
+		await this.executeAgentCli(session, [`-s=${name}`, "detach"]).catch(() => void 0);
+	}
+	async closePlaywrightRuntime(session) {
+		await this.waitForPanelState(session);
+		await this.detachAgent(session);
+		const launch = session.launch;
+		await (await launch?.catch(() => session.browser))?.close();
+		if (session.launch === launch) {
+			session.launch = null;
+			session.browser = null;
+		}
+		session.latestFrame = null;
+		session.sequence = 0;
+		await fs.rm(session.agentDirectory, {
+			recursive: true,
+			force: true
+		});
+		await fs.mkdir(session.agentDirectory, {
+			recursive: true,
+			mode: 448
+		});
+		await fs.chmod(session.agentDirectory, 448);
+	}
+	async destroySession(session, reason) {
+		await this.waitForPanelState(session);
+		if (session.localOwner) {
+			const owner = session.localOwner;
+			session.localOwner = null;
+			owner.resolveReady?.();
+			owner.resolveReady = null;
+			await this.closeLocalAutomation(session);
+			for (const request of owner.requests.values()) {
+				clearTimeout(request.timer);
+				request.resolve(false);
+			}
+			owner.requests.clear();
+			owner.transport.send({
+				type: "closed",
+				reason
+			});
+			owner.transport.disconnect();
+		}
+		if (session.launch || session.browser) await this.closePlaywrightRuntime(session);
+		else await this.detachAgent(session);
+		await fs.rm(session.agentDirectory, {
+			recursive: true,
+			force: true
+		});
+		if (this.sessions.get(session.panelId) === session) this.sessions.delete(session.panelId);
+		for (const attachment of session.attachments.values()) {
+			attachment.closing = true;
+			attachment.transport.sendMessage({
+				type: "closed",
+				reason
+			});
+			attachment.transport.disconnect();
+		}
+	}
+	close(connectionId) {
+		for (const session of this.sessions.values()) {
+			const attachment = session.attachments.get(connectionId);
+			if (!attachment || attachment.closing) continue;
+			attachment.closing = true;
+			this.scheduleOperation(session, async () => {
+				session.attachments.delete(connectionId);
+				await this.updateScreencast(session);
+			}, { required: true }).catch(() => void 0);
+			return;
+		}
+	}
+	async requestPanelClose(panelId, force = false) {
+		const session = this.sessions.get(panelId) ?? await this.sessionCreations.get(panelId)?.catch(() => null);
+		if (!session) return true;
+		let canClose = false;
+		await this.scheduleOperation(session, async () => {
+			if (session.localOwner) canClose = await this.requestLocalOwner(session.localOwner, {
+				type: "closeRequest",
+				force
+			});
+			else if (session.launch || session.browser) canClose = await (await (session.launch ?? Promise.resolve(session.browser))).requestClose(force);
+			else canClose = true;
+			if (canClose) {
+				session.closing = true;
+				this.stopScheduler(session, "Browser closed.");
+			}
+		}, { required: true });
+		return canClose;
+	}
+	async closePanel(panelId, reason) {
+		const session = this.sessions.get(panelId) ?? await this.sessionCreations.get(panelId)?.catch(() => null);
+		if (!session) return;
+		if (session.closeOperation) return session.closeOperation;
+		session.closing = true;
+		this.stopScheduler(session, reason);
+		session.agentProcess?.kill("SIGTERM");
+		const closeOperation = this.scheduleOperation(session, () => this.destroySession(session, reason), {
+			required: true,
+			allowWhenClosing: true
+		});
+		session.closeOperation = closeOperation;
+		return closeOperation;
+	}
+	async playwrightCliPath() {
+		const packageJsonPath = createRequire(import.meta.url).resolve("@playwright/cli/package.json");
+		return path.join(path.dirname(packageJsonPath), "playwright-cli.js");
+	}
+	executeAgentCli(session, args) {
+		if (this.agentCliRunner) return this.agentCliRunner({
+			panelId: session.panelId,
+			agentDirectory: session.agentDirectory
+		}, args);
+		return this.runAgentCli(session, args);
+	}
+	async runAgentCli(session, args) {
+		const cli = await this.playwrightCliPath();
+		return new Promise((resolve, reject) => {
+			const child = spawn(process.execPath, [cli, ...args], {
+				cwd: session.agentDirectory,
+				env: process.env,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				timeout: 12e4,
+				killSignal: "SIGTERM"
+			});
+			session.agentProcess = child;
+			let output = "";
+			const append = (data) => {
+				if (output.length < 10 * 1024 * 1024) output += String(data);
+			};
+			child.stdout.on("data", append);
+			child.stderr.on("data", append);
+			child.once("error", (error) => {
+				if (session.agentProcess === child) session.agentProcess = null;
+				reject(error);
+			});
+			child.once("exit", (code) => {
+				if (session.agentProcess === child) session.agentProcess = null;
+				if (code === 0) resolve(output.trim());
+				else reject(new Error(output.trim() || `Playwright Agent CLI exited with ${code}`));
+			});
+		});
+	}
+	ensureLocalAutomation(session, owner) {
+		const current = session.localAutomation;
+		if (current?.generation === owner.generation && current.browser.isConnected()) return Promise.resolve(current);
+		if (session.localAutomationLaunch) return session.localAutomationLaunch;
+		if (current) {
+			session.localAutomation = null;
+			current.frameProducer.stop();
+		}
+		const launch = (async () => {
+			if (current) {
+				await current.cdp.send("Page.stopScreencast").catch(() => void 0);
+				await current.cdp.detach().catch(() => void 0);
+				await current.browser.close().catch(() => void 0);
+			}
+			if (!owner.ready) {
+				let readinessTimer = null;
+				await Promise.race([owner.readyPromise, new Promise((_resolve, reject) => {
+					readinessTimer = setTimeout(() => reject(/* @__PURE__ */ new Error("The visible local Browser did not become ready within 15 seconds.")), 15e3);
+					readinessTimer.unref();
+				})]).finally(() => {
+					if (readinessTimer) clearTimeout(readinessTimer);
+				});
+			}
+			if (!owner.ready || session.localOwner !== owner || session.generation !== owner.generation) throw new Error("The local Browser owner changed before it was ready.");
+			const browser = await this.connectLocalAutomation(owner.endpoint);
+			const context = browser.contexts()[0];
+			const page = context?.pages()[0];
+			if (!context || !page) {
+				await browser.close().catch(() => void 0);
+				throw new Error("The local Browser page is not available.");
+			}
+			if (session.localOwner !== owner || session.generation !== owner.generation) {
+				await browser.close().catch(() => void 0);
+				throw new Error("The local Browser owner changed.");
+			}
+			const cdp = await context.newCDPSession(page);
+			const frameProducer = new LatestBrowserFrameProducer((frame) => {
+				if (session.localOwner === owner && session.localAutomation?.generation === owner.generation) this.publishFrame(session, frame);
+			}, (sessionId) => {
+				cdp.send("Page.screencastFrameAck", { sessionId }).catch(() => void 0);
+			});
+			const automation = {
+				browser,
+				page,
+				cdp,
+				frameProducer,
+				generation: owner.generation,
+				console: [],
+				requests: [],
+				screencasting: false,
+				screencastTail: Promise.resolve()
+			};
+			cdp.on("Page.screencastFrame", (frame) => frameProducer.receive(frame));
+			browser.once("disconnected", () => {
+				if (session.localAutomation !== automation) return;
+				automation.frameProducer.stop();
+				automation.screencasting = false;
+				session.localAutomation = null;
+				this.scheduleOperation(session, () => this.updateScreencast(session), { required: true }).catch((cause) => this.broadcastNavigationError(session, cause instanceof Error ? cause.message : String(cause)));
+			});
+			await cdp.send("Page.enable");
+			page.on("console", (message) => {
+				automation.console.push(`${message.type()}: ${message.text()}`);
+				if (automation.console.length > 1e3) automation.console.shift();
+			});
+			page.on("pageerror", (error) => {
+				automation.console.push(`error: ${error.message}`);
+				if (automation.console.length > 1e3) automation.console.shift();
+			});
+			page.on("request", (request) => {
+				automation.requests.push(`${request.method()} ${request.url()}`);
+				if (automation.requests.length > 2e3) automation.requests.shift();
+			});
+			session.localAutomation = automation;
+			return automation;
+		})();
+		session.localAutomationLaunch = launch;
+		const clearLaunch = () => {
+			if (session.localAutomationLaunch === launch) session.localAutomationLaunch = null;
+		};
+		launch.then(clearLaunch, clearLaunch);
+		return launch;
+	}
+	async closeLocalAutomation(session) {
+		const launch = session.localAutomationLaunch;
+		const automation = session.localAutomation ?? await launch?.catch(() => null);
+		session.localAutomation = null;
+		session.localAutomationLaunch = null;
+		if (automation) {
+			automation.frameProducer.stop();
+			await automation.cdp.send("Page.stopScreencast").catch(() => void 0);
+			await automation.cdp.detach().catch(() => void 0);
+			await automation.browser.close().catch(() => void 0);
+		}
+	}
+	async setLocalScreencasting(session, owner, enabled) {
+		const automation = enabled ? await this.ensureLocalAutomation(session, owner) : session.localAutomation;
+		if (!automation || automation.generation !== owner.generation) return;
+		const operation = automation.screencastTail.then(async () => {
+			if (session.localOwner !== owner || session.localAutomation !== automation || automation.screencasting === enabled) return;
+			automation.screencasting = enabled;
+			if (!enabled) {
+				automation.frameProducer.stop();
+				await automation.cdp.send("Page.stopScreencast").catch(() => void 0);
+				return;
+			}
+			automation.frameProducer.start();
+			const width = Math.max(320, session.state.viewport.width || 1280);
+			const height = Math.max(200, session.state.viewport.height || 800);
+			await automation.cdp.send("Page.startScreencast", {
+				format: "jpeg",
+				quality: 75,
+				maxWidth: width,
+				maxHeight: height,
+				everyNthFrame: 1
+			}).catch((cause) => {
+				automation.screencasting = false;
+				automation.frameProducer.stop();
+				throw cause;
+			});
+		});
+		automation.screencastTail = operation.catch(() => void 0);
+		await operation;
+	}
+	async executeLocalClientCommand(session, owner, message) {
+		const automation = await this.ensureLocalAutomation(session, owner);
+		const page = automation.page;
+		if (message.type === "navigate") await page.goto(message.url, { waitUntil: "commit" });
+		else if (message.type === "back") await page.goBack({ waitUntil: "commit" });
+		else if (message.type === "forward") await page.goForward({ waitUntil: "commit" });
+		else if (message.type === "reload") await page.reload({ waitUntil: "commit" });
+		else if (message.type === "stop") await automation.cdp.send("Page.stopLoading");
+		else if (message.type === "pointer") {
+			await page.mouse.move(message.x, message.y);
+			if (message.phase === "down") await page.mouse.down({ button: message.button ?? "left" });
+			else if (message.phase === "up") await page.mouse.up({ button: message.button ?? "left" });
+		} else if (message.type === "wheel") await page.mouse.wheel(message.deltaX, message.deltaY);
+		else if (message.type === "key") if (message.phase === "down") await page.keyboard.down(message.key);
+		else await page.keyboard.up(message.key);
+		else if (message.type === "insertText") await page.keyboard.insertText(message.text);
+	}
+	async executeLocalAgentCommand(session, owner, input) {
+		const automation = await this.ensureLocalAutomation(session, owner);
+		const page = automation.page;
+		const target = (value) => page.locator(`aria-ref=${value}`);
+		if (input.command === "snapshot") return Reflect.apply(page.ariaSnapshot, page, [{ mode: "ai" }]);
+		if (input.command === "click") {
+			await target(input.args[0]).click();
+			return `Clicked ${input.args[0]}`;
+		}
+		if (input.command === "fill") {
+			await target(input.args[0]).fill(input.args[1]);
+			return `Filled ${input.args[0]}`;
+		}
+		if (input.command === "press") {
+			await page.keyboard.press(input.args[0]);
+			return `Pressed ${input.args[0]}`;
+		}
+		if (input.command === "console") {
+			const minimum = input.args[0] ?? "info";
+			const levels = [
+				"debug",
+				"info",
+				"warning",
+				"error"
+			];
+			const minimumIndex = Math.max(0, levels.indexOf(minimum));
+			return automation.console.filter((line) => {
+				const level = line.slice(0, line.indexOf(":"));
+				const index = levels.indexOf(level);
+				return index < 0 || index >= minimumIndex;
+			}).join("\n") || "No console messages.";
+		}
+		if (input.command === "requests") return automation.requests.join("\n") || "No network requests.";
+		if (input.command === "screenshot") {
+			const screenshotPath = path.join(session.agentDirectory, `screenshot-${Date.now()}.png`);
+			await page.screenshot({ path: screenshotPath });
+			return `Screenshot saved to ${screenshotPath}`;
+		}
+		if (input.command === "goto") {
+			await page.goto(input.args[0]);
+			return `Navigated to ${page.url()}`;
+		}
+		if (input.command === "go-back") {
+			await page.goBack();
+			return `Navigated to ${page.url()}`;
+		}
+		if (input.command === "go-forward") {
+			await page.goForward();
+			return `Navigated to ${page.url()}`;
+		}
+		await page.reload();
+		return `Reloaded ${page.url()}`;
+	}
+	async agentCommand(panelId, input) {
+		const session = await this.getSession(panelId);
+		let result = "";
+		await this.scheduleOperation(session, async () => {
+			const localOwner = session.localOwner;
+			const browser = localOwner ? null : await this.browserFor(session).catch(async (error) => {
+				await this.closePlaywrightRuntime(session).catch(() => void 0);
+				throw error;
+			});
+			const previousController = session.controllerId;
+			let agentControlled = false;
+			try {
+				if (localOwner) {
+					await this.updateScreencast(session, "agent");
+					if (session.localOwner !== localOwner || localOwner.generation !== session.generation) throw new Error("The local Browser owner changed.");
+				}
+				session.controllerId = "agent";
+				agentControlled = true;
+				this.broadcastState(session, "controlChanged");
+				if (localOwner) result = await this.executeLocalAgentCommand(session, localOwner, input);
+				else if (this.agentCliRunner) {
+					const name = session.agentSessionName ?? `treeport-${panelId}-${session.generation}-${crypto.randomBytes(6).toString("hex")}`;
+					session.agentSessionName = name;
+					if (!session.agentAttached) {
+						await this.executeAgentCli(session, [
+							"attach",
+							`treeport-${panelId}`,
+							"--session",
+							name
+						]);
+						session.agentAttached = true;
+					}
+					result = await this.executeAgentCli(session, [
+						`-s=${name}`,
+						input.command,
+						"--",
+						...input.args
+					]);
+					this.queuePanelState(session, browser.state);
+				} else {
+					result = await browser.agentCommand(input);
+					this.queuePanelState(session, browser.state);
+				}
+				await this.waitForPanelState(session);
+			} catch (cause) {
+				if (!localOwner) session.agentAttached = false;
+				throw cause;
+			} finally {
+				if (agentControlled) {
+					if (localOwner && session.localOwner === localOwner) {
+						const nextController = previousController && previousController !== "agent" ? previousController : LOCAL_BROWSER_OWNER_CONTROLLER;
+						if (await this.updateScreencast(session, nextController).then(() => true, () => false)) session.controllerId = nextController;
+					} else {
+						const nextAttachment = [...session.attachments.values()].find((attachment) => !attachment.closing && attachment.visible);
+						session.controllerId = previousController && previousController !== "agent" ? previousController : nextAttachment ? attachmentController(nextAttachment.clientId) : null;
+					}
+					this.broadcastState(session, "controlChanged");
+				}
 			}
+		});
+		return result;
+	}
+	async status() {
+		return PlaywrightBrowser.status(this.cachePath);
+	}
+	async install() {
+		if (this.installing) return this.installing;
+		this.installing = (async () => {
+			const packageJsonPath = createRequire(import.meta.url).resolve("playwright/package.json");
+			const packageJson = playwrightPackageSchema.parse(JSON.parse(await fs.readFile(packageJsonPath, "utf8")));
+			const cli = path.join(path.dirname(packageJsonPath), packageJson.bin?.playwright ?? "cli.js");
+			return new Promise((resolve, reject) => {
+				const child = spawn(process.execPath, [
+					cli,
+					"install",
+					"chromium",
+					"--no-shell"
+				], {
+					env: {
+						...process.env,
+						PLAYWRIGHT_BROWSERS_PATH: this.cachePath
+					},
+					stdio: [
+						"ignore",
+						"pipe",
+						"pipe"
+					]
+				});
+				let output = "";
+				child.stdout.on("data", (data) => output += String(data));
+				child.stderr.on("data", (data) => output += String(data));
+				child.once("error", reject);
+				child.once("exit", (code) => {
+					if (code === 0) resolve(output.trim() || "Chromium installed.");
+					else reject(new Error(output.trim() || `Playwright exited with ${code}`));
+				});
+			});
+		})();
+		try {
+			return await this.installing;
+		} finally {
+			this.installing = null;
 		}
-	};
-}
+	}
+	async remove() {
+		if (this.installing) throw new Error("Wait for the Browser installation to finish.");
+		if (this.browserHost.started || [...this.sessions.values()].some((session) => session.browser !== null || session.launch !== null)) throw new Error("Close daemon-owned Browser before you remove Chromium.");
+		await fs.rm(this.cachePath, {
+			recursive: true,
+			force: true
+		});
+	}
+	async dispose() {
+		this.unsubscribe();
+		this.tickets.clear();
+		this.ownerTickets.clear();
+		await Promise.all([...this.sessionCreations.values()].map((creation) => creation.catch(() => null)));
+		await Promise.all([...this.sessions.keys()].map((panelId) => this.closePanel(panelId, "Treeport is shutting down.")));
+		await this.browserHost.close();
+	}
+};
 //#endregion
 //#region src/server/daemon-ownership.ts
 function processExists(pid) {
@@ -8517,167 +11166,6 @@ async function acquireDaemonOwnership(config) {
 	};
 }
 //#endregion
-//#region src/server/request-security.ts
-const MAX_HOST_BYTES = 512;
-const MAX_LOGIN_BYTES = 320;
-const MAX_NAME_BYTES = 512;
-const MAX_PROFILE_PICTURE_BYTES = 2048;
-const UNSAFE_METHODS = /* @__PURE__ */ new Set([
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE"
-]);
-function denied(status, code, message) {
-	return {
-		allowed: false,
-		principal: null,
-		effectiveOrigin: null,
-		status,
-		code,
-		message
-	};
-}
-function headerValues(request, name) {
-	const values = [];
-	for (let index = 0; index < request.rawHeaders.length; index += 2) if (request.rawHeaders[index]?.toLowerCase() === name) values.push(request.rawHeaders[index + 1] ?? "");
-	if (values.length > 0) return values;
-	const value = request.headers[name];
-	if (value === void 0) return [];
-	return Array.isArray(value) ? value : [value];
-}
-function singleHeader(request, name) {
-	const values = headerValues(request, name);
-	return {
-		present: values.length > 0,
-		valid: values.length <= 1,
-		value: values.length === 1 ? values[0] ?? null : null
-	};
-}
-function hasControlCharacters(value) {
-	return [...value].some((character) => {
-		const code = character.codePointAt(0) ?? 0;
-		return code <= 31 || code === 127;
-	});
-}
-function parseHost(value) {
-	if (value.length === 0 || Buffer.byteLength(value) > MAX_HOST_BYTES || hasControlCharacters(value) || /[\s,/@?#\\]/u.test(value)) return null;
-	const candidate = `http://${value}`;
-	if (!URL.canParse(candidate)) return null;
-	const url = new URL(candidate);
-	if (!url.host || url.pathname !== "/") return null;
-	return {
-		host: url.host,
-		hostname: url.hostname.toLowerCase()
-	};
-}
-function isLoopbackHostname(hostname) {
-	return [
-		"127.0.0.1",
-		"localhost",
-		"[::1]",
-		"::1"
-	].includes(hostname);
-}
-function isLoopbackAddress(address) {
-	if (!address) return false;
-	const normalized = address.toLowerCase();
-	if (normalized === "::1") return true;
-	const octets = (normalized.startsWith("::ffff:") ? normalized.slice(7) : normalized).split(".");
-	return octets.length === 4 && octets[0] === "127" && octets.every((octet) => /^\d{1,3}$/u.test(octet) && Number(octet) <= 255);
-}
-function validIdentityValue(value, maximumBytes) {
-	return value.length > 0 && value === value.trim() && Buffer.byteLength(value) <= maximumBytes && !hasControlCharacters(value);
-}
-function effectiveOriginFor(request, source, incomingHost) {
-	if (source === "local") return `http://${incomingHost.host}`;
-	const forwardedHostHeader = singleHeader(request, "x-forwarded-host");
-	const forwardedProtocolHeader = singleHeader(request, "x-forwarded-proto");
-	if (!forwardedHostHeader.valid || !forwardedHostHeader.present || !forwardedProtocolHeader.valid || !forwardedProtocolHeader.present) return null;
-	const forwardedHost = parseHost(forwardedHostHeader.value ?? "");
-	if (!forwardedHost || forwardedProtocolHeader.value?.toLowerCase() !== "https") return null;
-	return `https://${forwardedHost.host}`;
-}
-function allowsOpaqueWebPanelOrigin(request, socketUpgrade) {
-	if (!["GET", "HEAD"].includes(request.method?.toUpperCase() ?? "")) return false;
-	const pathname = new URL(request.url ?? "/", "http://treeport.local").pathname;
-	if (socketUpgrade) return /^\/api\/web-panel-dev\/[a-f0-9]{24}\/@vite-hmr$/u.test(pathname);
-	return /^\/api\/web-panels\/panel_[a-f0-9]{32}\/assets(?:\/|$)/u.test(pathname) || /^\/api\/web-panel-dev\/[a-f0-9]{24}\//u.test(pathname);
-}
-function originIsAllowed(request, effectiveOrigin, socketUpgrade) {
-	const originHeader = singleHeader(request, "origin");
-	if (!originHeader.valid) return false;
-	if (originHeader.present) {
-		const value = originHeader.value ?? "";
-		if (value === "null") {
-			if (!allowsOpaqueWebPanelOrigin(request, socketUpgrade)) return false;
-		} else {
-			if (!URL.canParse(value)) return false;
-			const parsed = new URL(value);
-			if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.origin !== value || parsed.origin !== effectiveOrigin) return false;
-		}
-	}
-	const fetchSiteHeader = singleHeader(request, "sec-fetch-site");
-	if (!fetchSiteHeader.valid) return false;
-	if ((UNSAFE_METHODS.has(request.method?.toUpperCase() ?? "") || socketUpgrade) && fetchSiteHeader.value?.toLowerCase() === "cross-site") return false;
-	return true;
-}
-function authorizeRequest(request, options = {}) {
-	if (!isLoopbackAddress(request.socket.remoteAddress)) return denied(401, "AUTHENTICATION_REQUIRED", "Treeport accepts remote requests only through Tailscale Serve.");
-	const hostHeader = singleHeader(request, "host");
-	const incomingHost = hostHeader.valid && hostHeader.value ? parseHost(hostHeader.value.toLowerCase()) : null;
-	if (!incomingHost) return denied(400, "INVALID_REQUEST_HOST", "The request host is invalid.");
-	const loginHeader = singleHeader(request, "tailscale-user-login");
-	const nameHeader = singleHeader(request, "tailscale-user-name");
-	const profilePictureHeader = singleHeader(request, "tailscale-user-profile-pic");
-	const hasTailscaleIdentity = loginHeader.present || nameHeader.present || profilePictureHeader.present;
-	const headersHaveSingleValues = loginHeader.valid && nameHeader.valid && profilePictureHeader.valid;
-	let principal;
-	if (hasTailscaleIdentity) {
-		const login = loginHeader.value ?? "";
-		const name = nameHeader.value === "" ? null : nameHeader.value;
-		const profilePicture = profilePictureHeader.value === "" ? null : profilePictureHeader.value;
-		const validProfilePicture = profilePicture === null || validIdentityValue(profilePicture, MAX_PROFILE_PICTURE_BYTES) && URL.canParse(profilePicture) && ["http:", "https:"].includes(new URL(profilePicture).protocol);
-		if (!headersHaveSingleValues || !loginHeader.present || !validIdentityValue(login, MAX_LOGIN_BYTES) || name !== null && !validIdentityValue(name, MAX_NAME_BYTES) || !validProfilePicture) return denied(401, "INVALID_TAILSCALE_IDENTITY", "The Tailscale user identity is invalid.");
-		principal = {
-			source: "tailscale",
-			login,
-			name,
-			profilePicture
-		};
-	} else {
-		if (!isLoopbackHostname(incomingHost.hostname)) return denied(401, "AUTHENTICATION_REQUIRED", "Treeport accepts remote requests only through Tailscale Serve.");
-		principal = {
-			source: "local",
-			login: null,
-			name: null,
-			profilePicture: null
-		};
-	}
-	const effectiveOrigin = effectiveOriginFor(request, principal.source, incomingHost);
-	if (!effectiveOrigin) return denied(400, "INVALID_FORWARDED_ORIGIN", "The forwarded request origin is invalid.");
-	if (!originIsAllowed(request, effectiveOrigin, options.socketUpgrade === true)) return denied(403, "INVALID_ORIGIN", "The request origin is not allowed.");
-	return {
-		allowed: true,
-		principal,
-		effectiveOrigin,
-		status: 200,
-		code: null,
-		message: null
-	};
-}
-function rejectHttpRequest(request, response, decision) {
-	const apiRequest = request.url?.startsWith("/api/") === true;
-	const body = apiRequest ? `${JSON.stringify({ error: {
-		code: decision.code,
-		message: decision.message
-	} })}\n` : `${decision.message ?? "The request was rejected."}\n`;
-	response.statusCode = decision.status;
-	response.setHeader("cache-control", "no-store");
-	response.setHeader("content-type", apiRequest ? "application/json; charset=utf-8" : "text/plain; charset=utf-8");
-	response.end(request.method === "HEAD" ? void 0 : body);
-}
-//#endregion
 //#region src/server/terminal-attachments.ts
 var AttachmentInitializationError = class {
 	phase;
@@ -9290,7 +11778,7 @@ var TerminalAttachmentManager = class {
 };
 //#endregion
 //#region src/server/socket-server.ts
-function createSocketServer(httpServer, { service, config, tmux, terminalMetadata, attachmentManager }) {
+function createSocketServer(httpServer, { service, config, tmux, terminalMetadata, attachmentManager, browserSessions }) {
 	const io = new Server(httpServer, {
 		path: SOCKET_IO_PATH,
 		serveClient: false,
@@ -9301,6 +11789,7 @@ function createSocketServer(httpServer, { service, config, tmux, terminalMetadat
 	});
 	const metadataReady = terminalMetadata.initialize();
 	const attachments = attachmentManager ?? new TerminalAttachmentManager(service, tmux, config.tmuxPath, terminalMetadata);
+	const hostedBrowsers = browserSessions ?? new BrowserSessionManager(service, config);
 	io.of("/events").on("connection", (socket) => {
 		const queuedEvents = [];
 		let snapshotted = false;
@@ -9313,12 +11802,13 @@ function createSocketServer(httpServer, { service, config, tmux, terminalMetadat
 			if (!socket.connected) return;
 			const metadataSnapshot = terminalMetadata.snapshot();
 			const representedEventCount = queuedEvents.length;
-			service.listWebPanels().then((webPanels) => {
+			Promise.all([service.listWebPanels(), service.listBrowserPanels()]).then(([webPanels, browserPanels]) => {
 				if (!socket.connected) return;
 				socket.emit("snapshot", {
 					at: (/* @__PURE__ */ new Date()).toISOString(),
 					terminalMetadata: metadataSnapshot,
-					webPanels
+					webPanels,
+					browserPanels
 				});
 				queuedEvents.splice(0, representedEventCount);
 				while (queuedEvents.length && socket.connected) socket.emit("product_event", queuedEvents.shift());
@@ -9371,9 +11861,69 @@ function createSocketServer(httpServer, { service, config, tmux, terminalMetadat
 		socket.on("output_ack", (payload) => attachments.message(connectionId, "output_ack", payload));
 		socket.once("disconnect", () => attachments.close(connectionId));
 	});
+	const browsers = io.of("/browsers");
+	browsers.use((socket, next) => {
+		const auth = parseBrowserAuth(socket.handshake.auth);
+		if (!auth) {
+			next(/* @__PURE__ */ new Error("INVALID_BROWSER_AUTH"));
+			return;
+		}
+		socket.data.browserTicket = auth.ticket;
+		next();
+	});
+	browsers.on("connection", (socket) => {
+		const transport = {
+			id: socket.id,
+			isConnected: () => socket.connected,
+			sendMessage(message) {
+				if (!socket.connected) return false;
+				socket.emit("message", message);
+				return true;
+			},
+			sendFrame(frame) {
+				if (!socket.connected) return false;
+				socket.emit("frame", frame);
+				return true;
+			},
+			disconnect() {
+				socket.disconnect(true);
+			}
+		};
+		socket.on("command", (message) => hostedBrowsers.message(socket.id, message));
+		socket.once("disconnect", () => hostedBrowsers.close(socket.id));
+		hostedBrowsers.accept(socket.data.browserTicket, transport).catch(() => socket.disconnect(true));
+	});
+	const browserOwners = io.of("/browser-owners");
+	browserOwners.use((socket, next) => {
+		const auth = parseBrowserOwnerAuth(socket.handshake.auth);
+		if (!auth) {
+			next(/* @__PURE__ */ new Error("INVALID_BROWSER_OWNER_AUTH"));
+			return;
+		}
+		socket.data.browserOwnerAuth = auth;
+		next();
+	});
+	browserOwners.on("connection", (socket) => {
+		const transport = {
+			id: socket.id,
+			isConnected: () => socket.connected,
+			send(message) {
+				if (!socket.connected) return false;
+				socket.emit("ownerMessage", message);
+				return true;
+			},
+			disconnect() {
+				socket.disconnect(true);
+			}
+		};
+		socket.on("ownerMessage", (message) => hostedBrowsers.ownerMessage(socket.id, message));
+		socket.once("disconnect", () => hostedBrowsers.closeOwner(socket.id));
+		hostedBrowsers.acceptOwner(socket.data.browserOwnerAuth, transport).catch(() => socket.disconnect(true));
+	});
 	return {
 		io,
-		attachments
+		attachments,
+		browserSessions: hostedBrowsers
 	};
 }
 //#endregion
@@ -9406,12 +11956,14 @@ async function main() {
 		const terminalMetadata = new TerminalMetadataManager(service, tmux, config.tmuxPath);
 		await terminalMetadata.initialize();
 		const applicationUpdate = createApplicationUpdateManager(config);
+		const browserSessions = new BrowserSessionManager(service, config);
 		const honoListener = getRequestListener(createApp({
 			service,
 			config,
 			tmux,
 			applicationUpdate,
-			terminalMetadata
+			terminalMetadata,
+			browserSessions
 		}).fetch);
 		let vite = null;
 		const server = createServer((request, response) => {
@@ -9453,7 +12005,8 @@ async function main() {
 			service,
 			config,
 			tmux,
-			terminalMetadata
+			terminalMetadata,
+			browserSessions
 		});
 		await new Promise((resolve, reject) => {
 			server.once("error", reject);
@@ -9483,6 +12036,7 @@ async function main() {
 					terminalMetadata.drain(),
 					viteClosed
 				]).then(async () => {
+					await browserSessions.dispose();
 					await service.disposeWebPanelRuntime();
 					database.close();
 					await ownership.release();