@narumitw/pi-chrome-devtools 0.53.0 → 0.53.2

package/src/browser-manager.ts

@@ -19,6 +19,7 @@ import {
 	type ManagedBrowser,
 	state,
 } from "./runtime.js";
+import type { EffectiveBrowserSettings } from "./settings.js";
 
 // Endpoint attachment, managed launch, dynamic-port publication, and shutdown intentionally remain
 // together because they form one ownership state machine behind the testable operations boundary.
@@ -54,6 +55,7 @@ const DEFAULT_BROWSER_MANAGER_OPERATIONS: BrowserManagerOperations = {
 let browserManagerOperations = DEFAULT_BROWSER_MANAGER_OPERATIONS;
 
 interface ManagedBrowserScope {
+	browser: EffectiveBrowserSettings;
 	controller: AbortController;
 	generation: number;
 	launchPromise?: Promise<void>;
@@ -64,13 +66,36 @@ interface ManagedBrowserScope {
 
 const managedBrowserScopes = new WeakMap<object, ManagedBrowserScope>();
 
+function cloneBrowserSettings(browser: EffectiveBrowserSettings): EffectiveBrowserSettings {
+	return { ...browser, extensionPaths: [...browser.extensionPaths] };
+}
+
+function runtimeBrowserSettings(): EffectiveBrowserSettings {
+	return {
+		endpoint: `http://${formatHostForUrl(state.host)}:${state.configuredPort}`,
+		host: state.host,
+		port: state.configuredPort,
+		hostConfigured: state.hostConfigured,
+		portConfigured: state.portConfigured,
+		autoLaunchEnabled: state.autoLaunchEnabled,
+		...(state.browserExecutable ? { executablePath: state.browserExecutable } : {}),
+		extensionPaths: [...state.extensionPaths],
+		endpointSource: state.endpointSource,
+		autoLaunchSource: state.autoLaunchSource,
+		executablePathSource: state.browserExecutableSource,
+		extensionPathsSource: state.extensionPathsSource,
+	};
+}
+
 function managedBrowserScope(owner: object) {
 	const existing = managedBrowserScopes.get(owner);
 	if (existing) return existing;
+	const browser = runtimeBrowserSettings();
 	const created: ManagedBrowserScope = {
+		browser,
 		controller: new AbortController(),
 		generation: 0,
-		port: state.configuredPort,
+		port: browser.port,
 	};
 	managedBrowserScopes.set(owner, created);
 	return created;
@@ -81,10 +106,27 @@ export function startManagedBrowserSession(owner: object) {
 	scope.controller.abort(new DOMException("Chrome DevTools session replaced", "AbortError"));
 	scope.controller = new AbortController();
 	scope.generation += 1;
-	scope.port = state.configuredPort;
 	scope.lastLaunchAttempt = undefined;
 }
 
+export function syncManagedBrowserSettings(owner: object, browser: EffectiveBrowserSettings) {
+	const scope = managedBrowserScope(owner);
+	scope.browser = cloneBrowserSettings(browser);
+	scope.port = browser.port;
+}
+
+export function browserSettingsForOwner(owner?: object) {
+	return owner ? managedBrowserScope(owner).browser : runtimeBrowserSettings();
+}
+
+export function managedBrowserExtensionPaths(owner?: object) {
+	return browserSettingsForOwner(owner).extensionPaths;
+}
+
+export function managedBrowserExtensionPathsSource(owner?: object) {
+	return browserSettingsForOwner(owner).extensionPathsSource;
+}
+
 export function managedBrowserForOwner(owner?: object) {
 	if (!owner) return state.managedBrowser;
 	const scopedBrowser = managedBrowserScope(owner).managedBrowser;
@@ -110,6 +152,14 @@ function managedBrowserPort(owner?: object) {
 	return owner ? managedBrowserScope(owner).port : state.port;
 }
 
+function managedBrowserConfiguredPort(owner?: object) {
+	return browserSettingsForOwner(owner).port;
+}
+
+function managedBrowserPortConfigured(owner?: object) {
+	return browserSettingsForOwner(owner).portConfigured;
+}
+
 function setManagedBrowserPort(owner: object | undefined, port: number) {
 	if (owner) managedBrowserScope(owner).port = port;
 	else state.port = port;
@@ -153,12 +203,12 @@ export async function ensureDevToolsEndpoint(
 	owner?: object,
 ) {
 	callerSignal?.throwIfAborted();
-	if (extensionsConfigured()) {
-		validateExtensionLaunchMode();
+	if (extensionsConfigured(owner)) {
+		validateExtensionLaunchMode(owner);
 		await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
 		return;
 	}
-	if (canAutoLaunchBrowser()) {
+	if (canAutoLaunchBrowser(owner)) {
 		try {
 			await withEndpointRetry(
 				() => fetchDevToolsJson<unknown>("/json/version", { signal: callerSignal }, owner),
@@ -167,7 +217,7 @@ export async function ensureDevToolsEndpoint(
 			);
 			return;
 		} catch (error) {
-			if (shouldAutoLaunchAfterEndpointError(error)) {
+			if (shouldAutoLaunchAfterEndpointError(error, owner)) {
 				await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
 				return;
 			}
@@ -183,18 +233,19 @@ export async function ensureDevToolsEndpoint(
 	}
 }
 
-function validateExtensionLaunchMode() {
-	if (!isLocalDevToolsHost(state.host)) {
+function validateExtensionLaunchMode(owner?: object) {
+	const browser = browserSettingsForOwner(owner);
+	if (!isLocalDevToolsHost(browser.host)) {
 		throw new DevToolsEndpointError(
 			"Unpacked extensions require a local extension-owned managed browser; remote CDP endpoints cannot be modified.",
 		);
 	}
-	if (!state.autoLaunchEnabled) {
+	if (!browser.autoLaunchEnabled) {
 		throw new DevToolsEndpointError(
 			"Auto-launch is required for unpacked extensions so Pi can create an isolated managed browser.",
 		);
 	}
-	if (!state.browserExecutable) {
+	if (!browser.executablePath) {
 		throw new DevToolsEndpointError(
 			"Unpacked extensions require browser.executablePath for Chrome for Testing or Chromium in pi-chrome-devtools.json.",
 		);
@@ -258,9 +309,9 @@ async function prepareManagedBrowserLaunch(
 		await shutdownManagedBrowser(existingBrowser, { awaitLaunch: false, owner });
 		throwIfBrowserLaunchCancelled(generation, signal, owner);
 	}
-	if (state.portConfigured) {
+	if (managedBrowserPortConfigured(owner)) {
 		const available = await browserManagerOperations.isPortAvailable(
-			state.host,
+			browserSettingsForOwner(owner).host,
 			managedBrowserPort(owner),
 		);
 		throwIfBrowserLaunchCancelled(generation, signal, owner);
@@ -280,7 +331,7 @@ async function launchManagedBrowser(
 	owner?: object,
 ) {
 	throwIfBrowserLaunchCancelled(generation, signal, owner);
-	const candidateDefinitions = browserCandidateDefinitions();
+	const candidateDefinitions = browserCandidateDefinitions(owner);
 	const candidates = await resolveBrowserCandidates(
 		candidateDefinitions,
 		generation,
@@ -290,25 +341,25 @@ async function launchManagedBrowser(
 	throwIfBrowserLaunchCancelled(generation, signal, owner);
 	setLastLaunchAttempt(owner, {
 		candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-		mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+		mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port",
 	});
 
 	if (candidates.length === 0) {
-		throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions));
+		throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions, owner));
 	}
 
 	let lastError: unknown;
 	for (const candidate of candidates) {
 		throwIfBrowserLaunchCancelled(generation, signal, owner);
 		try {
-			if (extensionsConfigured())
+			if (extensionsConfigured(owner))
 				await requireSupportedExtensionBrowser(candidate, generation, signal, owner);
 			await launchBrowserCandidate(candidate, waitMs, generation, signal, owner);
 			throwIfBrowserLaunchCancelled(generation, signal, owner);
 			setLastLaunchAttempt(owner, {
 				...lastLaunchAttempt(owner),
 				candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-				mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+				mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port",
 				selectedCandidate: formatBrowserCandidate(candidate),
 				userDataDir: managedBrowserForOwner(owner)?.userDataDir,
 			});
@@ -320,7 +371,7 @@ async function launchManagedBrowser(
 				setLastLaunchAttempt(owner, {
 					...(lastLaunchAttempt(owner) ?? {
 						candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-						mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+						mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port",
 					}),
 					lastError: formatError(cancellation),
 				});
@@ -330,20 +381,20 @@ async function launchManagedBrowser(
 			setLastLaunchAttempt(owner, {
 				...(lastLaunchAttempt(owner) ?? {
 					candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-					mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+					mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port",
 				}),
 				lastError: formatError(error),
 			});
 		}
 	}
 
-	if (lastError instanceof DevToolsEndpointError && extensionsConfigured()) throw lastError;
+	if (lastError instanceof DevToolsEndpointError && extensionsConfigured(owner)) throw lastError;
 	throw new DevToolsEndpointError(
 		[
 			"Unable to auto-launch a Chromium-family browser for Chrome DevTools.",
 			`Tried: ${candidates.map(formatBrowserCandidate).join(", ")}`,
 			lastError ? `Last error: ${formatError(lastError)}` : undefined,
-			launchHint(),
+			launchHint(owner),
 			endpointConfigHint(),
 		]
 			.filter(Boolean)
@@ -403,11 +454,13 @@ async function launchBrowserCandidate(
 	let managedBrowser: ManagedBrowser | undefined;
 	try {
 		throwIfBrowserLaunchCancelled(generation, signal, owner);
-		const portArgument = state.portConfigured ? String(managedBrowserPort(owner)) : "0";
+		const portArgument = managedBrowserPortConfigured(owner)
+			? String(managedBrowserPort(owner))
+			: "0";
 		const args = buildManagedBrowserLaunchArguments(
 			userDataDir,
 			portArgument,
-			state.extensionPaths,
+			managedBrowserExtensionPaths(owner),
 		);
 		const child = browserManagerOperations.spawn(candidate.resolvedExecutable, args, {
 			shell: false,
@@ -430,14 +483,17 @@ async function launchBrowserCandidate(
 			}
 			launchedBrowser.exited = true;
 			launchedBrowser.ready = false;
-			if (!state.portConfigured && launchedBrowser.port === managedBrowserPort(owner)) {
-				setManagedBrowserPort(owner, state.configuredPort);
+			if (
+				!managedBrowserPortConfigured(owner) &&
+				launchedBrowser.port === managedBrowserPort(owner)
+			) {
+				setManagedBrowserPort(owner, managedBrowserConfiguredPort(owner));
 			}
 		});
 
 		await waitForBrowserSpawn(child);
 		throwIfBrowserLaunchCancelled(generation, signal, owner);
-		if (state.portConfigured) {
+		if (managedBrowserPortConfigured(owner)) {
 			launchedBrowser.port = managedBrowserPort(owner);
 		} else {
 			launchedBrowser.port = await readManagedBrowserPort(
@@ -533,7 +589,7 @@ async function readManagedBrowserPort(
 				[
 					"Timed out waiting for auto-launched browser DevToolsActivePort.",
 					`Expected file: ${activePortFile}`,
-					launchHint(),
+					launchHint(owner),
 				].join("\n"),
 			);
 		}
@@ -565,7 +621,7 @@ async function waitForDevToolsEndpoint(
 			throw new DevToolsEndpointError(
 				[
 					`Timed out waiting for auto-launched browser at ${devToolsEndpoint(owner)}.`,
-					launchHint(),
+					launchHint(owner),
 				].join("\n"),
 			);
 		}
@@ -636,8 +692,8 @@ async function cleanupManagedBrowser(managedBrowser: ManagedBrowser, owner?: obj
 	await browserManagerOperations
 		.rm(managedBrowser.userDataDir, { recursive: true, force: true })
 		.catch(() => undefined);
-	if (!state.portConfigured && managedBrowser.port === managedBrowserPort(owner)) {
-		setManagedBrowserPort(owner, state.configuredPort);
+	if (!managedBrowserPortConfigured(owner) && managedBrowser.port === managedBrowserPort(owner)) {
+		setManagedBrowserPort(owner, managedBrowserConfiguredPort(owner));
 	}
 }
 
@@ -743,28 +799,29 @@ function isLaunchableEndpointError(error: unknown) {
 	return error instanceof DevToolsEndpointError && error.launchable;
 }
 
-function shouldAutoLaunchAfterEndpointError(error: unknown) {
-	if (!canAutoLaunchBrowser()) return false;
+function shouldAutoLaunchAfterEndpointError(error: unknown, owner?: object) {
+	if (!canAutoLaunchBrowser(owner)) return false;
 	if (isLaunchableEndpointError(error)) return true;
 
 	// After the attach-first attempt (including its retry window, when applicable) fails, treat any
 	// DevTools endpoint error on an unpinned port as a conflict we can avoid with a dynamic port.
-	return !state.portConfigured && error instanceof DevToolsEndpointError;
+	return !managedBrowserPortConfigured(owner) && error instanceof DevToolsEndpointError;
 }
 
-function canAutoLaunchBrowser() {
-	return state.autoLaunchEnabled && isLocalDevToolsHost(state.host);
+function canAutoLaunchBrowser(owner?: object) {
+	const browser = browserSettingsForOwner(owner);
+	return browser.autoLaunchEnabled && isLocalDevToolsHost(browser.host);
 }
 
-function extensionsConfigured() {
-	return state.extensionPaths.length > 0;
+function extensionsConfigured(owner?: object) {
+	return managedBrowserExtensionPaths(owner).length > 0;
 }
 
 function endpointConnectionErrorMessage(error: unknown, owner?: object) {
 	const reason = isTimeoutError(error) ? "request timed out" : "connection failed";
 	return [
 		`Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint(owner)} (${reason}).`,
-		launchHint(),
+		launchHint(owner),
 		endpointConfigHint(),
 	].join("\n");
 }
@@ -774,7 +831,7 @@ function isTimeoutError(error: unknown) {
 }
 
 export function devToolsEndpoint(owner?: object) {
-	return `http://${formatHostForUrl(state.host)}:${managedBrowserPort(owner)}`;
+	return `http://${formatHostForUrl(browserSettingsForOwner(owner).host)}:${managedBrowserPort(owner)}`;
 }
 
 export function formatHostForUrl(host: string) {
@@ -782,8 +839,8 @@ export function formatHostForUrl(host: string) {
 	return host.includes(":") ? `[${host}]` : host;
 }
 
-export function endpointSourceLabel() {
-	return state.endpointSource;
+export function endpointSourceLabel(owner?: object) {
+	return browserSettingsForOwner(owner).endpointSource;
 }
 
 export type BrowserLifecycleState = "starting" | "running" | "exited" | "failed" | "unobserved";
@@ -797,27 +854,28 @@ export function browserLifecycleState(owner?: object): BrowserLifecycleState {
 }
 
 export function launchModeLabel(owner?: object) {
+	const browser = browserSettingsForOwner(owner);
 	const managedBrowser = managedBrowserForOwner(owner);
-	if (extensionsConfigured()) {
-		if (!isLocalDevToolsHost(state.host)) return "invalid; extensions require a local endpoint";
-		if (!state.autoLaunchEnabled) return "invalid; extensions require auto-launch";
+	if (extensionsConfigured(owner)) {
+		if (!isLocalDevToolsHost(browser.host)) return "invalid; extensions require a local endpoint";
+		if (!browser.autoLaunchEnabled) return "invalid; extensions require auto-launch";
 		if (managedBrowser && !managedBrowser.exited) {
-			return state.portConfigured
+			return managedBrowserPortConfigured(owner)
 				? "extension-owned browser on explicit port"
 				: "extension-owned browser on dynamic port";
 		}
-		return state.portConfigured
+		return managedBrowserPortConfigured(owner)
 			? "force extension-owned launch on explicit port"
 			: "force extension-owned launch on dynamic port";
 	}
-	if (!isLocalDevToolsHost(state.host)) return "manual remote endpoint";
-	if (!state.autoLaunchEnabled) return "manual; auto-launch disabled";
+	if (!isLocalDevToolsHost(browser.host)) return "manual remote endpoint";
+	if (!browser.autoLaunchEnabled) return "manual; auto-launch disabled";
 	if (managedBrowser && !managedBrowser.exited) {
-		return state.portConfigured
+		return managedBrowserPortConfigured(owner)
 			? "auto-launched on explicit port"
 			: "auto-launched on dynamic port";
 	}
-	return state.portConfigured
+	return managedBrowserPortConfigured(owner)
 		? "attach first; auto-launch explicit port"
 		: "attach first; auto-launch dynamic port";
 }
@@ -837,34 +895,38 @@ export function launchAttemptLines(owner?: object) {
 	return lines;
 }
 
-export function launchHint() {
-	if (extensionsConfigured()) {
+export function launchHint(owner?: object) {
+	const browser = browserSettingsForOwner(owner);
+	if (extensionsConfigured(owner)) {
 		return "Configured unpacked extensions force an isolated extension-owned launch; existing CDP browsers are never reused, modified, or closed.";
 	}
-	if (!isLocalDevToolsHost(state.host)) {
-		return `Remote/non-local endpoints are not auto-launched. Start a browser with CDP enabled at ${devToolsEndpoint()}.`;
+	if (!isLocalDevToolsHost(browser.host)) {
+		return `Remote/non-local endpoints are not auto-launched. Start a browser with CDP enabled at ${devToolsEndpoint(owner)}.`;
 	}
-	if (!state.autoLaunchEnabled) {
-		return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand()}`;
+	if (!browser.autoLaunchEnabled) {
+		return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand(owner)}`;
 	}
-	const managedMode = state.portConfigured ? `port ${state.port}` : "a dynamic DevTools port";
-	return `If no endpoint is available, Pi will auto-launch a Chromium-family browser with ${managedMode} and an isolated temp profile. Manual command: ${chromeLaunchCommand()}`;
+	const managedMode = managedBrowserPortConfigured(owner)
+		? `port ${managedBrowserPort(owner)}`
+		: "a dynamic DevTools port";
+	return `If no endpoint is available, Pi will auto-launch a Chromium-family browser with ${managedMode} and an isolated temp profile. Manual command: ${chromeLaunchCommand(owner)}`;
 }
 
-export function browserCandidateHint() {
-	if (extensionsConfigured()) {
+export function browserCandidateHint(owner?: object) {
+	if (extensionsConfigured(owner)) {
 		return "Extension browser requirement: configure Chrome for Testing or Chromium with browser.executablePath; branded Chrome is rejected because it may ignore unpacked-extension flags.";
 	}
-	return `Browser candidates: ${browserCandidateDefinitions()
+	return `Browser candidates: ${browserCandidateDefinitions(owner)
 		.map((candidate) => candidate.label)
 		.join(", ")}`;
 }
 
-export function chromeLaunchCommand() {
-	const executable = state.browserExecutable ?? defaultManualBrowserExecutable();
+export function chromeLaunchCommand(owner?: object) {
+	const executable =
+		browserSettingsForOwner(owner).executablePath ?? defaultManualBrowserExecutable();
 	const dataDir =
 		process.platform === "win32" ? "%TEMP%\\pi-chrome-devtools" : "/tmp/pi-chrome-devtools";
-	return `${quoteCommandPart(executable)} --remote-debugging-port=${state.port} --user-data-dir=${dataDir}`;
+	return `${quoteCommandPart(executable)} --remote-debugging-port=${managedBrowserPort(owner)} --user-data-dir=${dataDir}`;
 }
 
 function defaultManualBrowserExecutable() {
@@ -888,22 +950,23 @@ export function isLocalDevToolsHost(host: string) {
 	return ["localhost", "127.0.0.1", "::1", "0:0:0:0:0:0:0:1"].includes(normalizedHost);
 }
 
-function browserCandidateDefinitions(): BrowserCandidateDefinition[] {
-	const explicitCandidate = explicitBrowserCandidateDefinition();
+function browserCandidateDefinitions(owner?: object): BrowserCandidateDefinition[] {
+	const explicitCandidate = explicitBrowserCandidateDefinition(owner);
 	if (explicitCandidate.length > 0) return explicitCandidate;
 
 	return uniqueBrowserCandidates(platformBrowserCandidateDefinitions());
 }
 
-function explicitBrowserCandidateDefinition(): BrowserCandidateDefinition[] {
-	if (!state.browserExecutable) return [];
+function explicitBrowserCandidateDefinition(owner?: object): BrowserCandidateDefinition[] {
+	const browser = browserSettingsForOwner(owner);
+	if (!browser.executablePath) return [];
 	return [
 		{
 			label:
-				state.browserExecutableSource === "environment"
+				browser.executablePathSource === "environment"
 					? "PI_CHROME_DEVTOOLS_BROWSER"
 					: "browser.executablePath",
-			executable: state.browserExecutable,
+			executable: browser.executablePath,
 			source: "env",
 		},
 	];
@@ -1070,8 +1133,11 @@ function formatBrowserCandidateDefinition(candidate: BrowserCandidateDefinition)
 	return `${candidate.label} (${candidate.executable})`;
 }
 
-function noBrowserCandidateMessage(candidateDefinitions: BrowserCandidateDefinition[]) {
-	if (extensionsConfigured()) {
+function noBrowserCandidateMessage(
+	candidateDefinitions: BrowserCandidateDefinition[],
+	owner?: object,
+) {
+	if (extensionsConfigured(owner)) {
 		return [
 			"Cannot launch unpacked extensions because the configured browser executable was not found or is not executable.",
 			`Tried: ${candidateDefinitions.map(formatBrowserCandidateDefinition).join(", ")}`,

package/src/browser-settings-menu.ts

@@ -1,7 +1,7 @@
 import { isAbsolute } from "node:path";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
-import { shutdownManagedBrowser } from "./browser-manager.js";
+import { shutdownManagedBrowser, syncManagedBrowserSettings } from "./browser-manager.js";
 import {
 	applyAvailableChromeDevtoolsTools,
 	configuredChromeDevtoolsTools,
@@ -276,6 +276,7 @@ async function saveAndApplyBrowserPatch(
 		const loaded = await loadSettings({ cwd: ctx.cwd, projectTrusted });
 		if (!isCurrent(generation, ownerSignal, actionSignal)) return false;
 		applyRuntimeBrowserSettings(loaded.effectiveBrowser, loaded.paths, projectTrusted);
+		syncManagedBrowserSettings(ctx.sessionManager, loaded.effectiveBrowser);
 		state.settingsNotice = loaded.notice;
 		return loaded;
 	} catch (error) {

package/src/cdp-client.ts

@@ -51,6 +51,7 @@ export interface CdpConnectOptions extends CdpOperationOptions {
 
 const MAX_BUFFERED_EVENTS_PER_METHOD = 32;
 const MAX_CDP_MESSAGE_BYTES = 8 * 1024 * 1024;
+const activePageIds = new WeakMap<object, string>();
 
 interface PageOperationOptions {
 	sessionOwner?: object;
@@ -84,13 +85,13 @@ export async function resolvePage(pageId?: string, options: PageOperationOptions
 	const pages = await listPages(options);
 	if (pageId) return requirePage(pageId, pages);
 
-	const page = resolveDefaultPage(pages);
+	const page = resolveDefaultPage(pages, options.sessionOwner);
 	if (!page) {
 		throw new Error(
 			[
 				`No Chrome pages found at ${devToolsEndpoint(options.sessionOwner)}.`,
 				"Use chrome_devtools_navigate with a URL to create a page, or open a Chrome tab manually.",
-				launchHint(),
+				launchHint(options.sessionOwner),
 			].join("\n"),
 		);
 	}
@@ -105,22 +106,32 @@ export async function resolvePageForNavigation(
 	const pages = await listPages(options);
 	if (pageId) return { created: false, page: requirePage(pageId, pages) };
 
-	const page = resolveDefaultPage(pages);
+	const page = resolveDefaultPage(pages, options.sessionOwner);
 	if (page) return { created: false, page };
 
 	return { created: true, page: await createPage("about:blank", options) };
 }
 
-function resolveDefaultPage(pages: DevToolsPage[]) {
-	if (!state.activePageId) return pages[0];
+function resolveDefaultPage(pages: DevToolsPage[], owner?: object) {
+	const activePageId = owner ? activePageIds.get(owner) : state.activePageId;
+	if (!activePageId) return pages[0];
 
-	const activePage = pages.find((candidate) => candidate.id === state.activePageId);
+	const activePage = pages.find((candidate) => candidate.id === activePageId);
 	if (activePage) return activePage;
 
-	state.activePageId = undefined;
+	setActivePageId(owner, undefined);
 	return pages[0];
 }
 
+export function setActivePageId(owner: object | undefined, pageId: string | undefined) {
+	if (!owner) {
+		state.activePageId = pageId;
+		return;
+	}
+	if (pageId) activePageIds.set(owner, pageId);
+	else activePageIds.delete(owner);
+}
+
 function requirePage(pageId: string, pages: DevToolsPage[]) {
 	const page = pages.find((candidate) => candidate.id === pageId);
 	if (page) return page;

package/src/chrome-devtools.ts

@@ -1,5 +1,10 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { shutdownManagedBrowser, startManagedBrowserSession } from "./browser-manager.js";
+import {
+	shutdownManagedBrowser,
+	startManagedBrowserSession,
+	syncManagedBrowserSettings,
+} from "./browser-manager.js";
+import { setActivePageId } from "./cdp-client.js";
 import {
 	availableChromeDevtoolsTools,
 	configureChromeDevtoolsToolExposure,
@@ -98,12 +103,14 @@ export default function chromeDevtools(pi: ExtensionAPI) {
 		});
 		startManagedBrowserSession(ctx.sessionManager);
 		if (generation !== state.sessionGeneration) return;
+		setActivePageId(ctx.sessionManager, undefined);
 		state.activePageId = undefined;
 		state.lastLaunchAttempt = undefined;
 		const projectTrusted = ctx.isProjectTrusted();
 		const settings = await loadSettings({ cwd: ctx.cwd, projectTrusted });
 		if (generation !== state.sessionGeneration) return;
 		applyRuntimeBrowserSettings(settings.effectiveBrowser, settings.paths, projectTrusted);
+		syncManagedBrowserSettings(ctx.sessionManager, settings.effectiveBrowser);
 		applyRuntimeWebMcpSetting(settings.effectiveWebMcpEnabled, ctx.sessionManager);
 		state.settingsNotice = settings.notice;
 		for (const warning of settings.warnings) {

package/src/display.ts

@@ -0,0 +1,38 @@
+const MAX_SANITIZER_INPUT_CODE_UNITS = 50_000;
+const graphemeSegmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export function sanitizeChromeDevtoolsDisplay(value: string, maxCharacters = 50_000) {
+	const inputWasTruncated = value.length > MAX_SANITIZER_INPUT_CODE_UNITS;
+	const boundedInput = inputWasTruncated
+		? truncateAtGraphemeBoundary(value, MAX_SANITIZER_INPUT_CODE_UNITS)
+		: value;
+	const normalizedLineEndings = boundedInput.replace(/\r\n/g, "\n");
+	// Neutralize controls without parsing untrusted terminal sequences; keep printable payload visible.
+	const sanitized = Array.from(normalizedLineEndings, (character) => {
+		const codePoint = character.codePointAt(0) ?? 0;
+		const unsafeControl =
+			(codePoint >= 0 && codePoint <= 8) ||
+			(codePoint >= 11 && codePoint <= 31) ||
+			(codePoint >= 127 && codePoint <= 159);
+		const unsafeBidi =
+			(codePoint >= 0x202a && codePoint <= 0x202e) || (codePoint >= 0x2066 && codePoint <= 0x2069);
+		const loneSurrogate = character.length === 1 && codePoint >= 0xd800 && codePoint <= 0xdfff;
+		return unsafeControl || unsafeBidi || loneSurrogate ? "�" : character;
+	}).join("");
+	const outputLimit = Math.min(maxCharacters, MAX_SANITIZER_INPUT_CODE_UNITS);
+	if (!inputWasTruncated && sanitized.length <= outputLimit) return sanitized;
+
+	return `${truncateAtGraphemeBoundary(sanitized, Math.max(0, outputLimit - 1))}…`;
+}
+
+function truncateAtGraphemeBoundary(value: string, maxCodeUnits: number) {
+	if (value.length <= maxCodeUnits) return value;
+	const boundedLookahead = value.slice(0, Math.max(0, maxCodeUnits) + 2);
+	let safeEnd = 0;
+	for (const { index, segment } of graphemeSegmenter.segment(boundedLookahead)) {
+		const segmentEnd = index + segment.length;
+		if (segmentEnd > maxCodeUnits) break;
+		safeEnd = segmentEnd;
+	}
+	return value.slice(0, safeEnd);
+}

package/src/render.ts

@@ -1,4 +1,6 @@
 import type { AgentToolResult, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { sanitizeChromeDevtoolsDisplay } from "./display.js";
 
 const STATUS_KEY = "chrome-devtools";
 interface StatusContext {
@@ -84,21 +86,18 @@ class PiTextComponent implements RenderComponent {
 	}
 
 	render(width: number) {
-		if (!this.text.trim()) return [];
-		return this.text
+		const sanitizedText = sanitizeChromeDevtoolsDisplay(this.text);
+		if (!sanitizedText.trim()) return [];
+		return sanitizedText
 			.replace(/\t/g, "   ")
 			.split(/\r?\n/)
 			.map((line) => {
-				const truncatedLine = truncateLine(line, Math.max(1, width));
+				const truncatedLine = truncateToWidth(line, Math.max(0, width), "");
 				return this.theme && this.color ? this.theme.fg(this.color, truncatedLine) : truncatedLine;
 			});
 	}
 }
 
-function truncateLine(line: string, maxWidth: number) {
-	return Array.from(line).slice(0, maxWidth).join("");
-}
-
 export async function withStatus<T>(
 	ctx: StatusContext,
 	status: string,