@narumitw/pi-chrome-devtools 0.50.1 → 0.52.0

package/src/settings.ts

@@ -23,11 +23,36 @@ export interface ChromeDevToolsSettings {
 	updatedAt: number;
 }
 
+export const DEFAULT_BROWSER_HOST = "127.0.0.1";
+export const DEFAULT_BROWSER_PORT = 9222;
+export const DEFAULT_BROWSER_ENDPOINT = `http://${DEFAULT_BROWSER_HOST}:${DEFAULT_BROWSER_PORT}`;
+
 export type BrowserSettingsSource = "default" | "environment" | "project" | "user";
 
+export interface UserBrowserSettings {
+	endpoint?: string;
+	autoLaunch?: boolean;
+	executablePath?: string;
+	extensionPaths?: string[];
+}
+
+export interface BrowserSettingsPatch {
+	endpoint?: string | null;
+	autoLaunch?: boolean | null;
+	executablePath?: string | null;
+}
+
 export interface EffectiveBrowserSettings {
+	endpoint: string;
+	host: string;
+	port: number;
+	hostConfigured: boolean;
+	portConfigured: boolean;
+	autoLaunchEnabled: boolean;
 	executablePath?: string;
 	extensionPaths: string[];
+	endpointSource: BrowserSettingsSource;
+	autoLaunchSource: BrowserSettingsSource;
 	executablePathSource: BrowserSettingsSource;
 	extensionPathsSource: BrowserSettingsSource;
 }
@@ -43,9 +68,14 @@ export interface SettingsLoadOptions {
 	projectTrusted?: boolean;
 }
 
+export type UserSettingsFileStatus =
+	| { kind: "missing" | "valid" }
+	| { kind: "invalid"; reason: string };
+
 interface SettingsLoadBase {
 	effectiveBrowser: EffectiveBrowserSettings;
 	paths: { user: string; project?: string };
+	userFile: UserSettingsFileStatus;
 	warnings: string[];
 	notice?: string;
 }
@@ -60,15 +90,10 @@ export interface SettingsFileOperations {
 	rename(source: string, destination: string): Promise<void>;
 }
 
-interface NormalizedBrowserSection {
-	executablePath?: string;
-	extensionPaths?: string[];
-}
-
 interface NormalizedSettingsDocument {
 	tools?: ChromeDevToolsToolName[];
 	updatedAt?: number;
-	browser?: NormalizedBrowserSection;
+	browser?: UserBrowserSettings;
 }
 
 interface SettingsDocumentResult {
@@ -86,6 +111,10 @@ const DEFAULT_FILE_OPERATIONS: SettingsFileOperations = {
 
 let settingsSaveQueue = Promise.resolve();
 
+export async function waitForSettingsWrites() {
+	await settingsSaveQueue;
+}
+
 export async function loadSettings(options: SettingsLoadOptions = {}): Promise<SettingsLoadResult> {
 	await settingsSaveQueue;
 	const userPath = settingsFilePath();
@@ -127,10 +156,11 @@ export async function loadSettings(options: SettingsLoadOptions = {}): Promise<S
 		warnings.push(...project.warnings);
 	}
 
-	const effectiveBrowser = resolveEffectiveBrowser(
-		user.normalized?.browser,
-		project.normalized?.browser,
-	);
+	const environmentWarning = deprecatedEnvironmentWarning();
+	if (environmentWarning) warnings.push(environmentWarning);
+
+	const userBrowser = user.normalized?.browser ?? {};
+	const effectiveBrowser = resolveEffectiveBrowser(userBrowser, project.normalized?.browser);
 	const settings = resolveSettings(user.normalized, project.normalized, effectiveBrowser);
 	const recognized =
 		settings.tools !== undefined ||
@@ -140,9 +170,17 @@ export async function loadSettings(options: SettingsLoadOptions = {}): Promise<S
 		.filter((result) => result.kind === "invalid")
 		.map((result) => result.reason)
 		.filter((reason): reason is string => Boolean(reason));
+	const userFile: UserSettingsFileStatus =
+		user.kind === "invalid"
+			? {
+					kind: "invalid",
+					reason: user.reason ?? `${userPath}: invalid settings`,
+				}
+			: { kind: user.kind };
 	const base = {
 		effectiveBrowser,
 		paths,
+		userFile,
 		warnings,
 		...(warnings.length > 0 ? { notice: warnings.join("\n") } : {}),
 	};
@@ -166,28 +204,69 @@ function resolveSettings(
 }
 
 function resolveEffectiveBrowser(
-	user: NormalizedBrowserSection | undefined,
-	project: NormalizedBrowserSection | undefined,
+	user: UserBrowserSettings,
+	project: UserBrowserSettings | undefined,
 ): EffectiveBrowserSettings {
+	const configuredEndpoint = parseBrowserEndpoint(user.endpoint ?? DEFAULT_BROWSER_ENDPOINT);
+	const environmentHost = process.env.PI_CHROME_DEVTOOLS_HOST;
+	const environmentPortValue = process.env.PI_CHROME_DEVTOOLS_PORT;
+	const environmentPort = parseConfiguredPort(environmentPortValue);
+	const environmentEndpointConfigured =
+		environmentHost !== undefined || environmentPort !== undefined;
+	const host = environmentHost ?? configuredEndpoint.host;
+	const port = environmentPort ?? configuredEndpoint.port;
+	const environmentAutoLaunch = process.env.PI_CHROME_DEVTOOLS_AUTO_LAUNCH;
 	const environmentExecutable = process.env.PI_CHROME_DEVTOOLS_BROWSER;
-	const executablePath = environmentExecutable || user?.executablePath;
-	const extensionPaths = project?.extensionPaths ?? user?.extensionPaths ?? [];
+	const executablePath = environmentExecutable || user.executablePath;
+	const extensionPaths = project?.extensionPaths ?? user.extensionPaths ?? [];
+	const endpointSource: BrowserSettingsSource = environmentEndpointConfigured
+		? "environment"
+		: user.endpoint
+			? "user"
+			: "default";
 	return {
+		endpoint: formatBrowserEndpoint(host, port),
+		host,
+		port,
+		hostConfigured: environmentHost !== undefined || user.endpoint !== undefined,
+		portConfigured: environmentPort !== undefined || user.endpoint !== undefined,
+		autoLaunchEnabled:
+			environmentAutoLaunch === undefined
+				? (user.autoLaunch ?? true)
+				: environmentAutoLaunch !== "0",
 		...(executablePath ? { executablePath } : {}),
 		extensionPaths: [...extensionPaths],
+		endpointSource,
+		autoLaunchSource:
+			environmentAutoLaunch !== undefined
+				? "environment"
+				: user.autoLaunch !== undefined
+					? "user"
+					: "default",
 		executablePathSource: environmentExecutable
 			? "environment"
-			: user?.executablePath
+			: user.executablePath
 				? "user"
 				: "default",
 		extensionPathsSource: project?.extensionPaths
 			? "project"
-			: user?.extensionPaths
+			: user.extensionPaths
 				? "user"
 				: "default",
 	};
 }
 
+function deprecatedEnvironmentWarning() {
+	const configuredNames = [
+		"PI_CHROME_DEVTOOLS_HOST",
+		"PI_CHROME_DEVTOOLS_PORT",
+		"PI_CHROME_DEVTOOLS_AUTO_LAUNCH",
+		"PI_CHROME_DEVTOOLS_BROWSER",
+	].filter((name) => process.env[name] !== undefined);
+	if (configuredNames.length === 0) return undefined;
+	return `Chrome DevTools environment settings are deprecated and will be removed in a future version: ${configuredNames.join(", ")}. Move them to browser.endpoint, browser.autoLaunch, and browser.executablePath in ${settingsFilePath()}. Environment values remain active overrides during the deprecation period.`;
+}
+
 async function readSettingsDocument(
 	filePath: string,
 	scope: "project" | "user",
@@ -214,7 +293,7 @@ async function readSettingsDocument(
 		return { kind: "invalid", reason, warnings: [`Chrome DevTools settings ignored: ${reason}`] };
 	}
 
-	const scopeWarnings = projectExecutableWarnings(parsed, scope, filePath);
+	const scopeWarnings = projectMachineSettingsWarnings(parsed, scope, filePath);
 	try {
 		const normalized = await normalizeSettingsDocument(parsed, scope, filePath, cwd);
 		return { kind: "valid", document: { ...parsed }, normalized, warnings: scopeWarnings };
@@ -228,21 +307,19 @@ async function readSettingsDocument(
 	}
 }
 
-function projectExecutableWarnings(
+function projectMachineSettingsWarnings(
 	document: Record<string, unknown>,
 	scope: "project" | "user",
 	filePath: string,
 ) {
-	if (
-		scope !== "project" ||
-		!isRecord(document.browser) ||
-		document.browser.executablePath === undefined
-	) {
-		return [];
-	}
-	return [
-		`Chrome DevTools project browser.executablePath ignored in ${filePath}; configure the machine-owned executable in ${settingsFilePath()}.`,
-	];
+	if (scope !== "project" || !isRecord(document.browser)) return [];
+	const browser = document.browser;
+	return ["endpoint", "autoLaunch", "executablePath"]
+		.filter((field) => browser[field] !== undefined)
+		.map(
+			(field) =>
+				`Chrome DevTools project browser.${field} ignored in ${filePath}; configure this machine-owned setting in ${settingsFilePath()}.`,
+		);
 }
 
 async function normalizeSettingsDocument(
@@ -277,8 +354,20 @@ async function normalizeBrowserSection(
 	scope: "project" | "user",
 	_filePath: string,
 	cwd?: string,
-): Promise<NormalizedBrowserSection> {
-	const normalized: NormalizedBrowserSection = {};
+): Promise<UserBrowserSettings> {
+	const normalized: UserBrowserSettings = {};
+	if (scope === "user" && browser.endpoint !== undefined) {
+		if (typeof browser.endpoint !== "string") {
+			throw new Error("expected browser.endpoint to be an HTTP URL with an explicit port");
+		}
+		normalized.endpoint = parseBrowserEndpoint(browser.endpoint).endpoint;
+	}
+	if (scope === "user" && browser.autoLaunch !== undefined) {
+		if (typeof browser.autoLaunch !== "boolean") {
+			throw new Error("expected browser.autoLaunch to be a boolean");
+		}
+		normalized.autoLaunch = browser.autoLaunch;
+	}
 	if (scope === "user" && browser.executablePath !== undefined) {
 		if (typeof browser.executablePath !== "string" || browser.executablePath.length === 0) {
 			throw new Error("expected browser.executablePath to be a non-empty absolute path");
@@ -350,6 +439,52 @@ async function validateUnpackedExtensionPath(extensionPath: string) {
 	return canonicalPath;
 }
 
+export function parseBrowserEndpoint(value: string) {
+	const trimmedValue = value.trim();
+	const explicitPort = trimmedValue.match(/^http:\/\/(?:\[[^\]]+\]|[^/:?#]+):(\d+)\/?$/i)?.[1];
+	let endpoint: URL;
+	try {
+		endpoint = new URL(trimmedValue);
+	} catch {
+		throw new Error("browser.endpoint must be a valid HTTP URL with an explicit port");
+	}
+	if (
+		endpoint.protocol !== "http:" ||
+		endpoint.username ||
+		endpoint.password ||
+		!endpoint.hostname ||
+		!explicitPort ||
+		(endpoint.pathname !== "/" && endpoint.pathname !== "") ||
+		endpoint.search ||
+		endpoint.hash
+	) {
+		throw new Error(
+			"browser.endpoint must be an HTTP origin with an explicit port and no credentials, path, query, or fragment",
+		);
+	}
+	const port = parseConfiguredPort(explicitPort);
+	if (port === undefined) {
+		throw new Error("browser.endpoint must use a port from 1 through 65535");
+	}
+	const host = endpoint.hostname;
+	return { endpoint: formatBrowserEndpoint(host, port), host, port };
+}
+
+export function parseConfiguredPort(value: string | undefined) {
+	if (value === undefined) return undefined;
+	const trimmedValue = value.trim();
+	if (!/^\d+$/.test(trimmedValue)) return undefined;
+	const port = Number(trimmedValue);
+	if (!Number.isInteger(port) || port < 1 || port > 65_535) return undefined;
+	return port;
+}
+
+function formatBrowserEndpoint(host: string, port: number) {
+	const formattedHost =
+		host.startsWith("[") && host.endsWith("]") ? host : host.includes(":") ? `[${host}]` : host;
+	return `http://${formattedHost}:${port}`;
+}
+
 export function normalizeChromeDevtoolsSettings(
 	value: unknown,
 ): ChromeDevToolsSettings | undefined {
@@ -381,13 +516,48 @@ export function saveSettings(
 	settings: ChromeDevToolsSettings,
 	operations: Partial<SettingsFileOperations> = {},
 ): Promise<void> {
-	const operation = settingsSaveQueue.then(() => saveSettingsNow(settings, operations));
+	return queueSettingsMutation(
+		(current) => ({
+			...current,
+			tools: [...settings.tools],
+			updatedAt: settings.updatedAt,
+		}),
+		operations,
+	);
+}
+
+export function saveBrowserSettings(
+	patch: BrowserSettingsPatch,
+	operations: Partial<SettingsFileOperations> = {},
+): Promise<void> {
+	return queueSettingsMutation(async (current) => {
+		const browser = isRecord(current.browser) ? { ...current.browser } : {};
+		for (const field of ["endpoint", "autoLaunch", "executablePath"] as const) {
+			const value = patch[field];
+			if (value === undefined) continue;
+			if (value === null) delete browser[field];
+			else browser[field] = value;
+		}
+		await normalizeBrowserSection(browser, "user", settingsFilePath());
+		return { ...current, browser };
+	}, operations);
+}
+
+function queueSettingsMutation(
+	mutate: (
+		current: Record<string, unknown>,
+	) => Record<string, unknown> | Promise<Record<string, unknown>>,
+	operations: Partial<SettingsFileOperations>,
+) {
+	const operation = settingsSaveQueue.then(() => saveSettingsMutationNow(mutate, operations));
 	settingsSaveQueue = operation.catch(() => undefined);
 	return operation;
 }
 
-async function saveSettingsNow(
-	settings: ChromeDevToolsSettings,
+async function saveSettingsMutationNow(
+	mutate: (
+		current: Record<string, unknown>,
+	) => Record<string, unknown> | Promise<Record<string, unknown>>,
 	operations: Partial<SettingsFileOperations>,
 ): Promise<void> {
 	const filePath = settingsFilePath();
@@ -397,11 +567,7 @@ async function saveSettingsNow(
 	if (current.kind === "invalid") {
 		throw new Error(`Cannot save Chrome DevTools settings until you repair ${current.reason}`);
 	}
-	const nextDocument = {
-		...(current.document ?? {}),
-		tools: [...settings.tools],
-		updatedAt: settings.updatedAt,
-	};
+	const nextDocument = await mutate(current.document ?? {});
 	await mkdir(dirname(filePath), { recursive: true });
 	const tempFile = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
 	try {

package/src/tool-selector.ts

@@ -10,6 +10,11 @@ import {
 	launchHint,
 	launchModeLabel,
 } from "./browser-manager.js";
+import {
+	applyAvailableChromeDevtoolsTools,
+	availableChromeDevtoolsTools,
+	CHROME_DEVTOOLS_LOAD_TOOL_NAME,
+} from "./lazy-tools.js";
 import { state } from "./runtime.js";
 import { loadSettings, saveSettings, settingsFilePath } from "./settings.js";
 import { CHROME_DEVTOOLS_TOOL_NAMES, type ChromeDevToolsToolName } from "./tool-names.js";
@@ -25,8 +30,9 @@ function formatError(error: unknown) {
 }
 
 interface ToolStatusSummary {
-	runtimeStatus: "enabled" | "disabled" | "partial";
-	activeChromeToolCount: number;
+	availabilityStatus: "enabled" | "disabled" | "partial";
+	availableChromeToolCount: number;
+	loadedChromeToolCount: number;
 	activeNonChromeToolCount: number;
 }
 
@@ -43,7 +49,7 @@ export async function updateChromeDevtoolsTools(
 	if (result !== "saved" || generation !== state.sessionGeneration) return;
 	const status = await buildToolStatusMessage(pi);
 	if (generation !== state.sessionGeneration) return;
-	ctx.ui.notify(`Chrome DevTools tools ${action}.\n\n${status}`, "info");
+	ctx.ui.notify(`Chrome DevTools lazy catalog ${action}.\n\n${status}`, "info");
 }
 
 export async function setSelectedChromeDevtoolsTools(
@@ -92,7 +98,7 @@ async function transactSelectedToolsNow(
 	expectedActiveTools?: readonly ChromeDevToolsToolName[],
 ): Promise<ToolSelectionSaveResult> {
 	if (expectedGeneration !== state.sessionGeneration) return "failed";
-	if (expectedActiveTools && !arraysEqual(activeChromeDevtoolsTools(pi), expectedActiveTools)) {
+	if (expectedActiveTools && !arraysEqual(availableChromeDevtoolsTools(pi), expectedActiveTools)) {
 		ctx.ui.notify(
 			"Browser tool selection changed while review was open. Review the current state, then apply again.",
 			"warning",
@@ -100,6 +106,7 @@ async function transactSelectedToolsNow(
 		return "active-tools-changed";
 	}
 	const previousActiveTools = pi.getActiveTools();
+	const previousAvailableTools = availableChromeDevtoolsTools(pi);
 	try {
 		applyChromeDevtoolsTools(pi, selectedTools);
 		await persistSettings(selectedTools);
@@ -107,10 +114,14 @@ async function transactSelectedToolsNow(
 	} catch (error) {
 		let rollbackError: unknown;
 		try {
-			const previousChromeTools = previousActiveTools.filter((name) =>
+			applyAvailableChromeDevtoolsTools(pi, previousAvailableTools);
+			const currentNonChromeTools = pi
+				.getActiveTools()
+				.filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name as ChromeDevToolsToolName));
+			const previousLoadedChromeTools = previousActiveTools.filter((name) =>
 				CHROME_DEVTOOLS_TOOL_NAMES.includes(name as ChromeDevToolsToolName),
-			) as ChromeDevToolsToolName[];
-			applyChromeDevtoolsTools(pi, previousChromeTools);
+			);
+			pi.setActiveTools(unique([...currentNonChromeTools, ...previousLoadedChromeTools]));
 		} catch (caught) {
 			rollbackError = caught;
 		}
@@ -127,11 +138,6 @@ async function transactSelectedToolsNow(
 	}
 }
 
-function activeChromeDevtoolsTools(pi: ExtensionAPI) {
-	const active = new Set(pi.getActiveTools());
-	return CHROME_DEVTOOLS_TOOL_NAMES.filter((toolName) => active.has(toolName));
-}
-
 function arraysEqual<T>(left: readonly T[], right: readonly T[]) {
 	return left.length === right.length && left.every((value, index) => value === right[index]);
 }
@@ -140,29 +146,32 @@ export function applyChromeDevtoolsTools(
 	pi: ExtensionAPI,
 	selectedTools: readonly ChromeDevToolsToolName[],
 ) {
-	const activeToolNames = pi.getActiveTools();
-	const chromeToolNames = new Set<string>(CHROME_DEVTOOLS_TOOL_NAMES);
-	const activeNonChromeToolNames = activeToolNames.filter((name) => !chromeToolNames.has(name));
-	pi.setActiveTools(unique([...activeNonChromeToolNames, ...selectedTools]));
+	applyAvailableChromeDevtoolsTools(pi, selectedTools);
 }
 
 function getToolStatusSummary(pi: ExtensionAPI): ToolStatusSummary {
 	const chromeToolNames = new Set<string>(CHROME_DEVTOOLS_TOOL_NAMES);
 	const activeToolNames = new Set(pi.getActiveTools());
-	const activeChromeToolCount = CHROME_DEVTOOLS_TOOL_NAMES.filter((name) =>
+	const loadedChromeToolCount = CHROME_DEVTOOLS_TOOL_NAMES.filter((name) =>
 		activeToolNames.has(name),
 	).length;
+	const availableChromeToolCount = availableChromeDevtoolsTools(pi).length;
 	const activeNonChromeToolCount = Array.from(activeToolNames).filter(
-		(name) => !chromeToolNames.has(name),
+		(name) => !chromeToolNames.has(name) && name !== CHROME_DEVTOOLS_LOAD_TOOL_NAME,
 	).length;
-	const runtimeStatus =
-		activeChromeToolCount === CHROME_DEVTOOLS_TOOL_NAMES.length
+	const availabilityStatus =
+		availableChromeToolCount === CHROME_DEVTOOLS_TOOL_NAMES.length
 			? "enabled"
-			: activeChromeToolCount === 0
+			: availableChromeToolCount === 0
 				? "disabled"
 				: "partial";
 
-	return { runtimeStatus, activeChromeToolCount, activeNonChromeToolCount };
+	return {
+		availabilityStatus,
+		availableChromeToolCount,
+		loadedChromeToolCount,
+		activeNonChromeToolCount,
+	};
 }
 
 export async function buildToolStatusMessage(pi: ExtensionAPI) {
@@ -170,8 +179,10 @@ export async function buildToolStatusMessage(pi: ExtensionAPI) {
 	const persistedSetting = await persistedSettingLabel();
 	return sanitizeChromeDevtoolsDisplay(
 		[
-			`Chrome DevTools tools: ${formatRuntimeStatus(summary)}`,
-			`Persisted selection: ${persistedSetting}`,
+			`Chrome DevTools tools available to lazy-load: ${formatRuntimeStatus(summary)}`,
+			`Loaded capability tools this session: ${summary.loadedChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length}`,
+			`Loader: ${pi.getActiveTools().includes(CHROME_DEVTOOLS_LOAD_TOOL_NAME) ? "active" : "inactive"}`,
+			`Persisted lazy catalog: ${persistedSetting}`,
 			...browserSettingsStatusLines(),
 			...(state.settingsNotice ? [`Settings note: ${state.settingsNotice}`] : []),
 			`Other active tools preserved: ${summary.activeNonChromeToolCount}`,
@@ -257,10 +268,11 @@ function browserSettingsStatusLines() {
 					`Project settings: ${state.projectSettingsFilePath} (${state.projectSettingsTrusted ? "trusted" : "untrusted; ignored"})`,
 				]
 			: []),
+		`Auto-launch: ${state.autoLaunchEnabled ? "on" : "off"} (${state.autoLaunchSource})`,
 		`Browser executable: ${state.browserExecutable ?? "automatic discovery"} (${state.browserExecutableSource})`,
 		`Unpacked extensions (${state.extensionPathsSource}):`,
 		...extensionLines,
-		"Settings changes apply to a new managed browser after /reload or session replacement.",
+		"Confirmed menu settings apply before the next browser connection; manual JSON edits require /reload or session replacement.",
 		...(state.extensionPaths.length > 0
 			? [
 					"Unpacked extensions require Chrome for Testing or Chromium and execute trusted browser code.",
@@ -276,10 +288,11 @@ export function buildCommandGuide() {
 		"/chrome-devtools help — show command usage",
 		"/chrome-devtools quickstart — show endpoint and launch help",
 		"/chrome-devtools status — show tool and settings status",
-		"/chrome-devtools tools — select individual Chrome DevTools tools",
+		"/chrome-devtools settings — edit browser connection settings",
+		"/chrome-devtools tools — choose tools available to lazy-load",
 		"/chrome-devtools toggle|select — compatibility aliases for tools",
-		"/chrome-devtools enable|on — enable all Chrome DevTools tools immediately",
-		"/chrome-devtools disable|off — disable all Chrome DevTools tools immediately",
+		"/chrome-devtools enable|on — make all Chrome DevTools tools available to lazy-load",
+		"/chrome-devtools disable|off — make all Chrome DevTools capability tools unavailable",
 	].join("\n");
 }
 
@@ -292,7 +305,7 @@ export function orderedChromeDevtoolsTools(selectedTools: ReadonlySet<ChromeDevT
 }
 
 function formatRuntimeStatus(summary: ToolStatusSummary) {
-	return `${summary.runtimeStatus} (${summary.activeChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length} active)`;
+	return `${summary.availabilityStatus} (${summary.availableChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length} available)`;
 }
 
 async function persistedSettingLabel() {
@@ -308,9 +321,10 @@ async function persistedSettingLabel() {
 
 function formatPersistedSelection(tools: readonly ChromeDevToolsToolName[]) {
 	if (tools.length === CHROME_DEVTOOLS_TOOL_NAMES.length) {
-		return `all enabled (${tools.length}/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected)`;
+		return `all available (${tools.length}/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected)`;
 	}
-	if (tools.length === 0) return `all disabled (0/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected)`;
+	if (tools.length === 0)
+		return `all unavailable (0/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected)`;
 	return `${tools.length}/${CHROME_DEVTOOLS_TOOL_NAMES.length} selected: ${tools.join(", ")}`;
 }
 

package/src/tools.ts

@@ -18,7 +18,6 @@ export const listPagesTool = defineTool({
 	name: CHROME_DEVTOOLS_TOOL_NAMES[0],
 	label: "Chrome DevTools: List Pages",
 	description: "List Chrome tabs/pages from a running Chrome DevTools Protocol endpoint.",
-	promptSnippet: "List Chrome tabs/pages available over Chrome DevTools Protocol",
 	parameters: Type.Object({}),
 	renderCall: renderToolCall("list pages"),
 	renderResult: renderTextResult,
@@ -34,7 +33,6 @@ export const selectPageTool = defineTool({
 	name: CHROME_DEVTOOLS_TOOL_NAMES[1],
 	label: "Chrome DevTools: Select Page",
 	description: "Select the active Chrome page for later chrome_devtools_* tool calls.",
-	promptSnippet: "Select the Chrome tab/page to inspect or control",
 	parameters: Type.Object({
 		pageId: Type.String({ description: "Page id from chrome_devtools_list_pages." }),
 	}),
@@ -56,7 +54,6 @@ export const navigateTool = defineTool({
 	label: "Chrome DevTools: Navigate",
 	description:
 		"Navigate a Chrome page to a URL through Chrome DevTools Protocol, creating a page first if none is available.",
-	promptSnippet: "Navigate the selected or first Chrome tab to a URL, creating one if needed",
 	parameters: Type.Object({
 		url: Type.String({ description: "URL to navigate to." }),
 		pageId: Type.Optional(
@@ -88,7 +85,6 @@ export const evaluateTool = defineTool({
 	name: CHROME_DEVTOOLS_TOOL_NAMES[3],
 	label: "Chrome DevTools: Evaluate",
 	description: "Evaluate JavaScript in a Chrome page through Chrome DevTools Protocol.",
-	promptSnippet: "Evaluate JavaScript in the selected Chrome tab",
 	parameters: Type.Object({
 		expression: Type.String({ description: "JavaScript expression to evaluate." }),
 		pageId: Type.Optional(
@@ -121,7 +117,6 @@ export const screenshotTool = defineTool({
 	name: CHROME_DEVTOOLS_TOOL_NAMES[4],
 	label: "Chrome DevTools: Screenshot",
 	description: "Capture a PNG screenshot from a Chrome page through Chrome DevTools Protocol.",
-	promptSnippet: "Capture a screenshot from the selected Chrome tab",
 	parameters: Type.Object({
 		pageId: Type.Optional(
 			Type.String({ description: "Optional page id. Defaults to selected or first page." }),