@narumitw/pi-chrome-devtools 0.51.0 → 0.52.0

package/README.md

@@ -27,7 +27,8 @@ This package is inspired by [`chrome-devtools-mcp`](https://github.com/ChromeDev
 - Retries briefly while Chrome is starting and reports actionable endpoint errors.
 - Shows statusline activity only while Chrome DevTools tools are running.
 - Keeps one loader tool active and exposes matching browser capabilities only when the agent needs them.
-- Provides a state-first `/chrome-devtools` menu for tool availability, browser status, setup, and help.
+- Provides a state-first `/chrome-devtools` menu for tool availability, editable browser settings,
+  browser status, setup, and help.
 - Stages menu-based availability changes for exact review before one confirmed apply.
 - Uses `@narumitw/pi-tui-kit` for width-safe TUI menus and equivalent RPC dialogs.
 - Persists the Chrome DevTools lazy-load catalog across Pi restarts.
@@ -52,15 +53,33 @@ pi -e ./packages/pi-chrome-devtools
 
 ## 🚀 Browser startup
 
-Without unpacked extensions, the extension first tries the configured endpoint, defaulting to
-`127.0.0.1:9222`. If that local endpoint is unavailable, it lazily launches an extension-owned
-Chromium-family browser with an isolated temp profile and retries the CDP request. Existing endpoints
-are reused and are never terminated by the extension.
+Without unpacked extensions, the extension first tries `browser.endpoint`, defaulting to
+`http://127.0.0.1:9222`. If that local endpoint is unavailable and `browser.autoLaunch` is `true`, it
+lazily launches an extension-owned Chromium-family browser with an isolated temp profile and retries
+the CDP request. Existing endpoints are reused and are never terminated by the extension.
 
-When `PI_CHROME_DEVTOOLS_PORT` is not set, auto-launch uses Chrome's dynamic DevTools port mode
-(`--remote-debugging-port=0`) and reads `DevToolsActivePort` from the temp profile. If you set a valid
-`PI_CHROME_DEVTOOLS_PORT` (`1`-`65535`), the extension uses that explicit port. Empty or invalid values
-fall back to the default attach-first behavior.
+Configure the canonical user file at
+`${PI_CODING_AGENT_DIR:-~/.pi/agent}/pi-chrome-devtools.json`:
+
+```json
+{
+  "browser": {
+    "endpoint": "http://127.0.0.1:9222",
+    "autoLaunch": true,
+    "executablePath": "/absolute/path/to/chromium"
+  }
+}
+```
+
+`browser.endpoint` must be an HTTP origin with an explicit port and no credentials, path, query, or
+fragment. Omitting it keeps attach-first behavior on `127.0.0.1:9222` and lets a managed launch use
+Chrome's dynamic DevTools port mode (`--remote-debugging-port=0`). Explicitly saving an endpoint pins
+managed launches to that port. `browser.autoLaunch` defaults to `true`. `browser.executablePath` is
+optional and must be an absolute path; when absent, normal browser discovery applies.
+
+The configured endpoint must expose the standard CDP HTTP discovery routes such as `/json/version`
+and `/json/list`. Chrome's newer built-in permission flow can listen on port `9222` while returning
+`404` from those routes; setting the same HTTP origin does not by itself make that flow compatible.
 
 ### Unpacked extensions
 
@@ -68,8 +87,7 @@ fall back to the default attach-first behavior.
 > An unpacked extension executes privileged browser code. Load only code you trust. Project settings
 > are honored only when Pi reports the project as trusted.
 
-Configure the canonical user file at
-`${PI_CODING_AGENT_DIR:-~/.pi/agent}/pi-chrome-devtools.json`:
+Add trusted unpacked-extension paths to the same canonical user file:
 
 ```json
 {
@@ -101,9 +119,10 @@ A trusted project can replace the user extension list in
 ```
 
 Project `extensionPaths` replace, rather than append to, the user array. A project file cannot
-override `browser.executablePath`; browser selection remains machine-owned user configuration.
-Effective precedence is defaults, user settings, trusted project override, then existing explicit
-runtime environment overrides. No new environment variable is required.
+override `browser.endpoint`, `browser.autoLaunch`, or `browser.executablePath`; browser connection
+settings remain machine-owned user configuration. Effective precedence is defaults, user settings,
+trusted project extension paths, then deprecated environment overrides. No new environment variable
+is required.
 
 When `extensionPaths` is non-empty, the extension skips attach-first behavior and starts an isolated,
 extension-owned managed browser with `--disable-extensions-except` and `--load-extension`. It fails
@@ -116,24 +135,17 @@ old managed browser is closed before the new configuration is applied. Missing f
 existing no-extension behavior. Invalid JSON, invalid browser values, and missing manifests are left
 unchanged and ignored with an actionable warning.
 
-### Environment overrides and manual endpoints
-
-`PI_CHROME_DEVTOOLS_BROWSER` remains the explicit runtime executable override. Without unpacked
-extensions, browser discovery still checks platform-specific Chrome, Chromium, Brave, and Microsoft
-Edge candidates. Disable auto-launch to keep the manual flow:
+### Deprecated environment overrides and manual endpoints
 
-```bash
-PI_CHROME_DEVTOOLS_AUTO_LAUNCH=0 pi -e ./packages/pi-chrome-devtools
-```
+The existing `PI_CHROME_DEVTOOLS_HOST`, `PI_CHROME_DEVTOOLS_PORT`,
+`PI_CHROME_DEVTOOLS_AUTO_LAUNCH`, and `PI_CHROME_DEVTOOLS_BROWSER` variables remain temporary
+compatibility overrides. They still take precedence over JSON, but every session that sees one emits
+a deprecation warning. Move their values to `browser.endpoint`, `browser.autoLaunch`, and
+`browser.executablePath`; the variables will be removed in a future version.
 
-Force an executable or endpoint if needed:
-
-```bash
-PI_CHROME_DEVTOOLS_BROWSER=/usr/bin/chromium pi -e ./packages/pi-chrome-devtools
-PI_CHROME_DEVTOOLS_HOST=127.0.0.1 PI_CHROME_DEVTOOLS_PORT=9223 pi -e ./packages/pi-chrome-devtools
-```
-
-Manual launch remains available when no unpacked extensions are configured:
+Without unpacked extensions, browser discovery still checks platform-specific Chrome, Chromium,
+Brave, and Microsoft Edge candidates. Manual launch remains available when no unpacked extensions are
+configured:
 
 ```bash
 google-chrome --remote-debugging-port=9222 --user-data-dir=/tmp/pi-chrome-devtools
@@ -212,7 +224,9 @@ an action. The five actions stay on one level:
   context-appropriate bulk change before applying it.
 - **Browser status** — inspect runtime, endpoint, launch mode, and the last launch attempt without
   probing the endpoint or starting Chrome.
-- **Settings & setup** — inspect effective files, sources, trust, reload steps, and recovery guidance.
+- **Browser settings** — immediately save the endpoint, auto-launch policy, or browser executable;
+  inspect unpacked-extension paths and effective sources. A deprecated environment override remains
+  effective until removed even when its underlying JSON value changes.
 - **Help** — view command usage and return to the menu.
 
 In the tool screen, **Select all** and **Select none** are unambiguous shortcuts; individual rows use
@@ -229,6 +243,7 @@ Direct subcommands are also available:
 /chrome-devtools help
 /chrome-devtools quickstart
 /chrome-devtools status
+/chrome-devtools settings
 /chrome-devtools tools
 /chrome-devtools toggle
 /chrome-devtools enable
@@ -244,6 +259,7 @@ Compatibility aliases remain available: `toggle` and `select` mean `tools`, `on`
 - `status` shows available and loaded capability counts, loader state, the persisted catalog,
   settings file path, endpoint source, launch mode, last launch attempt, and active non-Chrome tool
   count.
+- `settings` opens the same immediate-save browser settings flow used by the menu.
 - `tools` opens the same staged, width-safe availability and review flow used by the menu.
 - `toggle` and `select` are compatibility aliases for `tools`.
 - `enable` makes all five capability tools available to the loader and saves that catalog; `on` is a
@@ -251,11 +267,13 @@ Compatibility aliases remain available: `toggle` and `select` mean `tools`, `on`
 - `disable` makes all five capability tools unavailable and saves the empty catalog; `off` is a
   compatibility alias. The slash command and `chrome_devtools_load` remain available.
 
-The menu, `tools`, `help`, `quickstart`, and `status` require TUI or RPC mode so their result is
-observable. TUI uses keyboard navigation and injected Pi keybindings; RPC receives equivalent
-standard dialogs. In print and JSON modes, interactive and informational routes reject explicitly
-instead of silently opening unavailable UI. The immediate `enable`/`disable` routes remain available
-for deterministic non-interactive use.
+The menu, `settings`, `tools`, `help`, `quickstart`, and `status` require TUI or RPC mode so their
+result is observable. TUI uses keyboard navigation and injected Pi keybindings; RPC receives
+equivalent standard dialogs. In print and JSON modes, interactive and informational routes reject
+explicitly instead of silently opening unavailable UI. The immediate `enable`/`disable` routes remain
+available for deterministic non-interactive use.
+
+## ⚙️ Settings
 
 The available capability names are saved to:
 
@@ -263,14 +281,19 @@ The available capability names are saved to:
 ${PI_CODING_AGENT_DIR:-~/.pi/agent}/pi-chrome-devtools.json
 ```
 
+The same file owns `browser.endpoint`, `browser.autoLaunch`, `browser.executablePath`, and
+`browser.extensionPaths`. Browser connection fields are machine-owned user settings; trusted project
+files may replace only `browser.extensionPaths`. Confirmed menu changes apply before the next browser
+connection and close only an extension-owned managed browser. Manual JSON edits and unpacked-extension
+changes apply after `/reload` or session replacement.
+
 When the file is missing or invalid, the extension preserves Pi's current Chrome DevTools
 availability policy instead of replacing it. A valid saved catalog is restored on Pi startup and
 `/reload`, while its capability definitions remain deferred. A missing file is created by the first
-confirmed menu apply or successful direct availability change. Within one Pi process, catalog saves
-run in invocation order, reread the latest valid document, and preserve unknown fields. Malformed
-JSON or invalid recognized fields make menu mutation unavailable and block direct saves without
-replacement; a failed save restores the prior Chrome DevTools availability and loaded-tool state
-while preserving other extensions' current tools.
+confirmed browser or tool setting. Within one Pi process, all browser and tool saves run in invocation
+order, reread the latest valid document, publish by temporary-file rename, and preserve unknown
+fields. Malformed JSON or invalid recognized fields make menu mutation unavailable and block direct
+saves without replacement; a failed save restores the prior displayed and effective state.
 
 Compatibility: older versions used `pi-chrome-devtools-settings.json`. A legacy-only file remains
 readable with a warning and is never modified automatically; rename it to

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-chrome-devtools",
-	"version": "0.51.0",
+	"version": "0.52.0",
 	"description": "Pi extension that exposes Chrome DevTools Protocol tools.",
 	"type": "module",
 	"license": "MIT",

package/src/browser-manager.ts

@@ -143,7 +143,7 @@ async function prepareManagedBrowserLaunch(
 		throwIfBrowserLaunchCancelled(generation, signal);
 		if (!available) {
 			throw new DevToolsEndpointError(
-				`Cannot launch the extension-owned browser because explicit port ${state.port} is already in use. Choose a free PI_CHROME_DEVTOOLS_PORT or remove the override for a dynamic port.`,
+				`Cannot launch the extension-owned browser because explicit port ${state.port} is already in use. Choose a free browser.endpoint port or reset the endpoint to use a dynamic managed port.`,
 			);
 		}
 	}
@@ -609,9 +609,7 @@ export function formatHostForUrl(host: string) {
 }
 
 export function endpointSourceLabel() {
-	const hostSource = state.hostConfigured ? "PI_CHROME_DEVTOOLS_HOST" : "default host";
-	const portSource = state.portConfigured ? "PI_CHROME_DEVTOOLS_PORT" : "default/dynamic port";
-	return `${hostSource}; ${portSource}`;
+	return state.endpointSource;
 }
 
 export type BrowserLifecycleState = "starting" | "running" | "exited" | "failed" | "unobserved";
@@ -710,7 +708,7 @@ export function quoteCommandPart(value: string) {
 }
 
 export function endpointConfigHint() {
-	return "Set PI_CHROME_DEVTOOLS_HOST and PI_CHROME_DEVTOOLS_PORT for a manual endpoint, PI_CHROME_DEVTOOLS_BROWSER to choose an executable, or PI_CHROME_DEVTOOLS_AUTO_LAUNCH=0 to disable auto-launch.";
+	return "Configure browser.endpoint, browser.executablePath, and browser.autoLaunch in pi-chrome-devtools.json or the /chrome-devtools Settings flow.";
 }
 
 export function isLocalDevToolsHost(host: string) {

package/src/browser-settings-menu.ts

@@ -0,0 +1,311 @@
+import { isAbsolute } from "node:path";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { defineMenu, runMenu } from "@narumitw/pi-tui-kit";
+import { shutdownManagedBrowser } from "./browser-manager.js";
+import { applyRuntimeBrowserSettings, state } from "./runtime.js";
+import {
+	type BrowserSettingsPatch,
+	type BrowserSettingsSource,
+	loadSettings,
+	parseBrowserEndpoint,
+	type SettingsLoadResult,
+	saveBrowserSettings,
+} from "./settings.js";
+import { sanitizeChromeDevtoolsDisplay } from "./tool-selector.js";
+
+type BrowserSettingsScreen = "settings" | "endpoint" | "executable" | "extensions";
+type BrowserSettingsAction =
+	| "open-endpoint"
+	| "save-endpoint"
+	| "set-auto-launch"
+	| "open-executable"
+	| "save-executable"
+	| "show-extensions";
+
+interface BrowserSettingsMenuState {
+	load: SettingsLoadResult;
+}
+
+type CommandContext = ExtensionCommandContext;
+
+export async function showChromeDevtoolsBrowserSettings(
+	ctx: CommandContext,
+	generation: number,
+): Promise<{ closeParent: boolean }> {
+	const ownerSignal = state.sessionController.signal;
+	const isCurrent = () => generation === state.sessionGeneration && !ownerSignal.aborted;
+	const projectTrusted = ctx.isProjectTrusted();
+	const menu = defineMenu<BrowserSettingsMenuState, BrowserSettingsScreen, BrowserSettingsAction>({
+		start: "settings",
+		screens: {
+			settings: ({ state: current }) => {
+				if (current.load.userFile.kind === "invalid") return invalidSettingsScreen(current.load);
+				const browser = current.load.effectiveBrowser;
+				return {
+					kind: "settings",
+					title: "Chrome DevTools Browser settings",
+					lines: settingsContextLines(current.load),
+					items: [
+						{
+							id: "endpoint",
+							label: "DevTools endpoint",
+							description:
+								'HTTP origin with an explicit port; enter "default" to restore 127.0.0.1:9222.',
+							currentValue: sanitizeChromeDevtoolsDisplay(browser.endpoint),
+							action: "open-endpoint",
+						},
+						{
+							id: "auto-launch",
+							label: "Auto-launch",
+							description:
+								"Launch an isolated managed browser when a local endpoint is unavailable.",
+							currentValue: browser.autoLaunchEnabled ? "On" : "Off",
+							values: ["On", "Off"],
+							action: "set-auto-launch",
+						},
+						{
+							id: "executable",
+							label: "Browser executable",
+							description:
+								'Absolute executable path; enter "automatic" to restore browser discovery.',
+							currentValue: sanitizeChromeDevtoolsDisplay(browser.executablePath ?? "Automatic"),
+							action: "open-executable",
+						},
+						{
+							id: "extensions",
+							label: "Unpacked extensions",
+							description: "Inspect trusted extension paths configured in user or project JSON.",
+							currentValue: `${browser.extensionPaths.length} configured`,
+							action: "show-extensions",
+						},
+					],
+				};
+			},
+			endpoint: ({ state: current }) => ({
+				kind: "input",
+				title: "DevTools endpoint",
+				lines: [
+					sanitizeChromeDevtoolsDisplay(
+						`Current effective endpoint: ${current.load.effectiveBrowser.endpoint}`,
+					),
+					'Enter an HTTP origin with an explicit port, or "default".',
+				],
+				placeholder: "http://127.0.0.1:9222",
+				action: "save-endpoint",
+				hint: "back",
+			}),
+			executable: ({ state: current }) => ({
+				kind: "input",
+				title: "Browser executable",
+				lines: [
+					sanitizeChromeDevtoolsDisplay(
+						`Current effective executable: ${current.load.effectiveBrowser.executablePath ?? "automatic discovery"}`,
+					),
+					'Enter an absolute path, or "automatic".',
+				],
+				placeholder: "absolute browser executable path",
+				action: "save-executable",
+				hint: "back",
+			}),
+			extensions: ({ state: current }) => ({
+				kind: "detail",
+				title: "Unpacked extensions",
+				lines: extensionDetailLines(current.load),
+				hint: "back",
+			}),
+		},
+		actions: {
+			"open-endpoint": () => ({ kind: "to", screen: "endpoint" }),
+			"save-endpoint": async ({ value, signal }) => {
+				if (value === undefined) return { kind: "rejected" };
+				let endpoint: string | null;
+				try {
+					const trimmed = value.trim();
+					endpoint =
+						trimmed.toLowerCase() === "default" ? null : parseBrowserEndpoint(trimmed).endpoint;
+				} catch (error) {
+					notifySaveFailure(ctx, error);
+					return { kind: "rejected" };
+				}
+				const saved = await saveAndApplyBrowserPatch(
+					ctx,
+					generation,
+					ownerSignal,
+					signal,
+					projectTrusted,
+					{ endpoint },
+				);
+				if (!saved) return { kind: "rejected" };
+				notifyEffectiveSave(
+					ctx,
+					"endpoint",
+					saved.effectiveBrowser.endpoint,
+					saved.effectiveBrowser.endpointSource,
+				);
+				return { kind: "back" };
+			},
+			"set-auto-launch": async ({ value, signal }) => {
+				if (value !== "On" && value !== "Off") return { kind: "rejected" };
+				const saved = await saveAndApplyBrowserPatch(
+					ctx,
+					generation,
+					ownerSignal,
+					signal,
+					projectTrusted,
+					{ autoLaunch: value === "On" },
+				);
+				if (!saved) return { kind: "rejected" };
+				notifyEffectiveSave(
+					ctx,
+					"auto-launch",
+					saved.effectiveBrowser.autoLaunchEnabled ? "On" : "Off",
+					saved.effectiveBrowser.autoLaunchSource,
+				);
+				return { kind: "stay" };
+			},
+			"open-executable": () => ({ kind: "to", screen: "executable" }),
+			"save-executable": async ({ value, signal }) => {
+				if (value === undefined) return { kind: "rejected" };
+				const trimmed = value.trim();
+				const reset = ["automatic", "default", "none"].includes(trimmed.toLowerCase());
+				if (!reset && (!trimmed || !isAbsolute(trimmed))) {
+					notifySaveFailure(ctx, new Error('Enter an absolute path or "automatic".'));
+					return { kind: "rejected" };
+				}
+				const executablePath = reset ? null : trimmed;
+				const saved = await saveAndApplyBrowserPatch(
+					ctx,
+					generation,
+					ownerSignal,
+					signal,
+					projectTrusted,
+					{ executablePath },
+				);
+				if (!saved) return { kind: "rejected" };
+				notifyEffectiveSave(
+					ctx,
+					"browser executable",
+					saved.effectiveBrowser.executablePath ?? "automatic discovery",
+					saved.effectiveBrowser.executablePathSource,
+				);
+				return { kind: "back" };
+			},
+			"show-extensions": () => ({ kind: "to", screen: "extensions" }),
+		},
+	});
+	const result = await runMenu(ctx, menu, {
+		getState: async ({ signal }) => {
+			signal.throwIfAborted();
+			const load = await loadSettings({ cwd: ctx.cwd, projectTrusted });
+			signal.throwIfAborted();
+			return { load };
+		},
+		signal: ownerSignal,
+		isCurrent,
+		onError: (currentCtx, error) =>
+			currentCtx.ui.notify(
+				sanitizeChromeDevtoolsDisplay(
+					`Chrome DevTools browser settings failed: ${formatError(error)}`,
+				),
+				"error",
+			),
+	});
+	return { closeParent: result.kind === "closed" && result.reason === "close" };
+}
+
+async function saveAndApplyBrowserPatch(
+	ctx: CommandContext,
+	generation: number,
+	ownerSignal: AbortSignal,
+	actionSignal: AbortSignal,
+	projectTrusted: boolean,
+	patch: BrowserSettingsPatch,
+) {
+	try {
+		await ctx.waitForIdle();
+		if (!isCurrent(generation, ownerSignal, actionSignal)) return false;
+		await saveBrowserSettings(patch);
+		if (!isCurrent(generation, ownerSignal, actionSignal)) return false;
+		await shutdownManagedBrowser();
+		if (!isCurrent(generation, ownerSignal, actionSignal)) return false;
+		const loaded = await loadSettings({ cwd: ctx.cwd, projectTrusted });
+		if (!isCurrent(generation, ownerSignal, actionSignal)) return false;
+		applyRuntimeBrowserSettings(loaded.effectiveBrowser, loaded.paths, projectTrusted);
+		state.settingsNotice = loaded.notice;
+		return loaded;
+	} catch (error) {
+		if (isCurrent(generation, ownerSignal, actionSignal)) notifySaveFailure(ctx, error);
+		return false;
+	}
+}
+
+function isCurrent(generation: number, ownerSignal: AbortSignal, actionSignal: AbortSignal) {
+	return generation === state.sessionGeneration && !ownerSignal.aborted && !actionSignal.aborted;
+}
+
+function invalidSettingsScreen(load: SettingsLoadResult) {
+	const reason =
+		load.userFile.kind === "invalid"
+			? load.userFile.reason
+			: "The user settings file is unavailable.";
+	return {
+		kind: "detail" as const,
+		title: "Chrome DevTools Browser settings · Read only",
+		lines: [
+			sanitizeChromeDevtoolsDisplay(
+				`Fix the active user settings before saving; the file will not be overwritten. ${reason}`,
+			),
+		],
+		hint: "back" as const,
+	};
+}
+
+function settingsContextLines(load: SettingsLoadResult) {
+	const browser = load.effectiveBrowser;
+	return [
+		`User settings · ${load.paths.user}`,
+		`Effective sources: endpoint ${browser.endpointSource} · auto-launch ${browser.autoLaunchSource} · executable ${browser.executablePathSource}`,
+		...(load.notice ? [`Warning: ${load.notice}`] : []),
+	].map((line) => sanitizeChromeDevtoolsDisplay(line));
+}
+
+function extensionDetailLines(load: SettingsLoadResult) {
+	const browser = load.effectiveBrowser;
+	return [
+		`Effective source: ${browser.extensionPathsSource}`,
+		...(browser.extensionPaths.length > 0
+			? browser.extensionPaths.map((extensionPath) => `- ${extensionPath}`)
+			: ["No unpacked extensions are configured."]),
+		"Edit browser.extensionPaths in the user JSON or a trusted project JSON, then run /reload.",
+		"Unpacked extensions execute privileged browser code; load only paths you trust.",
+	].map((line) => sanitizeChromeDevtoolsDisplay(line));
+}
+
+function notifyEffectiveSave(
+	ctx: CommandContext,
+	setting: string,
+	effectiveValue: string,
+	source: BrowserSettingsSource,
+) {
+	const overrideNotice =
+		source === "environment" ? " The deprecated environment override remains effective." : "";
+	ctx.ui.notify(
+		sanitizeChromeDevtoolsDisplay(
+			`Chrome DevTools ${setting} saved. Effective ${setting}: ${effectiveValue} (${source}).${overrideNotice}`,
+		),
+		"info",
+	);
+}
+
+function notifySaveFailure(ctx: CommandContext, error: unknown) {
+	ctx.ui.notify(
+		sanitizeChromeDevtoolsDisplay(
+			`Chrome DevTools browser settings save failed; previous settings remain active: ${formatError(error)}`,
+		),
+		"warning",
+	);
+}
+
+function formatError(error: unknown) {
+	return error instanceof Error ? error.message : String(error);
+}

package/src/chrome-devtools.ts

@@ -7,7 +7,7 @@ import {
 	initializeAvailableChromeDevtoolsTools,
 } from "./lazy-tools.js";
 import { applyRuntimeBrowserSettings, state } from "./runtime.js";
-import { loadSettings } from "./settings.js";
+import { loadSettings, waitForSettingsWrites } from "./settings.js";
 import {
 	allChromeDevtoolsTools,
 	buildCommandGuide,
@@ -25,13 +25,22 @@ import {
 	selectPageTool,
 } from "./tools.js";
 
-type CommandAction = "menu" | "help" | "quickstart" | "status" | "tools" | "enable" | "disable";
+type CommandAction =
+	| "menu"
+	| "help"
+	| "quickstart"
+	| "status"
+	| "settings"
+	| "tools"
+	| "enable"
+	| "disable";
 type CommandContext = ExtensionCommandContext;
 const STATUS_KEY = "chrome-devtools";
 const COMMAND_COMPLETIONS = [
 	{ value: "help", label: "help", description: "Show command usage" },
 	{ value: "quickstart", label: "quickstart", description: "Show endpoint and launch help" },
 	{ value: "status", label: "status", description: "Show tool and settings status" },
+	{ value: "settings", label: "settings", description: "Edit browser connection settings" },
 	{ value: "tools", label: "tools", description: "Choose lazy-loadable Chrome DevTools tools" },
 	{ value: "toggle", label: "toggle", description: "Alias for tools" },
 	{ value: "select", label: "select", description: "Compatibility alias for tools" },
@@ -90,6 +99,7 @@ export default function chromeDevtools(pi: ExtensionAPI) {
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		const browserShutdown = shutdownManagedBrowser(undefined, { cancelLaunch: true });
 		await waitForChromeDevtoolsSettings();
+		await waitForSettingsWrites();
 		await browserShutdown;
 	});
 }
@@ -120,6 +130,15 @@ async function handleChromeDevtoolsCommand(
 			ctx.ui.notify(status, "info");
 			return;
 		}
+		case "settings": {
+			if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")) {
+				throw new Error("/chrome-devtools settings requires TUI or RPC mode");
+			}
+			const { showChromeDevtoolsBrowserSettings } = await import("./browser-settings-menu.js");
+			if (generation !== state.sessionGeneration) return;
+			await showChromeDevtoolsBrowserSettings(ctx, generation);
+			return;
+		}
 		case "tools": {
 			if (!ctx.hasUI || (ctx.mode !== "tui" && ctx.mode !== "rpc")) {
 				throw new Error("/chrome-devtools tools requires TUI or RPC mode");
@@ -174,6 +193,7 @@ export function parseCommand(args: string): CommandAction | "unknown" {
 	if (command === "help") return "help";
 	if (command === "quickstart") return "quickstart";
 	if (command === "status") return "status";
+	if (command === "settings") return "settings";
 	if (command === "tools" || command === "select" || command === "toggle") return "tools";
 	if (command === "enable" || command === "on") return "enable";
 	if (command === "disable" || command === "off") return "disable";

package/src/menu.ts

@@ -8,14 +8,13 @@ import { CHROME_DEVTOOLS_TOOL_NAMES, type ChromeDevToolsToolName } from "./tool-
 import {
 	buildBrowserStatusMessage,
 	buildCommandGuide,
-	buildSettingsSetupMessage,
 	sanitizeChromeDevtoolsDisplay,
 	setSelectedChromeDevtoolsTools,
 } from "./tool-selector.js";
 
 type CommandContext = ExtensionCommandContext;
-type MainScreen = "main" | "browserStatus" | "settings" | "help";
-type MainAction = "tools" | "bulk";
+type MainScreen = "main" | "browserStatus" | "help";
+type MainAction = "tools" | "bulk" | "settings";
 type ToolScreen = "tools" | "review";
 type ToolAction = "toggle" | "selectAll" | "selectNone" | "review" | "apply" | "cancel";
 
@@ -104,9 +103,9 @@ export async function showChromeDevtoolsMenu(
 					},
 					{
 						id: "settings",
-						label: "Settings & setup",
-						description: "Files, sources, trust, and reload steps.",
-						to: "settings",
+						label: "Browser settings",
+						description: "Edit endpoint, auto-launch, and browser executable settings.",
+						action: "settings",
 					},
 					{
 						id: "help",
@@ -125,14 +124,6 @@ export async function showChromeDevtoolsMenu(
 				viewportSize: "adaptive",
 				hint: "back",
 			}),
-			settings: () => ({
-				kind: "review",
-				title: "Settings & setup",
-				content: buildSettingsSetupMessage(),
-				format: { kind: "text" },
-				viewportSize: "adaptive",
-				hint: "back",
-			}),
 			help: () => ({
 				kind: "review",
 				title: "Chrome DevTools help",
@@ -163,6 +154,13 @@ export async function showChromeDevtoolsMenu(
 				if (result?.applied && isCurrent()) updateSnapshotAfterApply(current, result.selectedTools);
 				return result?.closeParent ? { kind: "close" } : { kind: "stay" };
 			},
+			settings: async () => {
+				const { showChromeDevtoolsBrowserSettings } = await import("./browser-settings-menu.js");
+				if (!isCurrent()) return { kind: "stay" };
+				const result = await showChromeDevtoolsBrowserSettings(ctx, generation);
+				if (!isCurrent()) return { kind: "stay" };
+				return result.closeParent ? { kind: "close" } : { kind: "stay" };
+			},
 		},
 	});
 	await runMenu(ctx, menu, {

package/src/runtime.ts

@@ -1,8 +1,13 @@
 import type { ChildProcess } from "node:child_process";
-import type { EffectiveBrowserSettings } from "./settings.js";
+import {
+	DEFAULT_BROWSER_HOST,
+	DEFAULT_BROWSER_PORT,
+	type EffectiveBrowserSettings,
+	parseConfiguredPort,
+} from "./settings.js";
 
-export const DEFAULT_HOST = "127.0.0.1";
-export const DEFAULT_PORT = 9222;
+export const DEFAULT_HOST = DEFAULT_BROWSER_HOST;
+export const DEFAULT_PORT = DEFAULT_BROWSER_PORT;
 export const DEFAULT_TIMEOUT_MS = 10_000;
 export const DEFAULT_HTTP_TIMEOUT_MS = 1_000;
 export const DEFAULT_ENDPOINT_WAIT_MS = 5_000;
@@ -26,6 +31,8 @@ export interface ChromeDevToolsState {
 	hostConfigured: boolean;
 	portConfigured: boolean;
 	autoLaunchEnabled: boolean;
+	endpointSource: EffectiveBrowserSettings["endpointSource"];
+	autoLaunchSource: EffectiveBrowserSettings["autoLaunchSource"];
 	browserExecutable?: string;
 	extensionPaths: string[];
 	browserExecutableSource: EffectiveBrowserSettings["executablePathSource"];
@@ -71,29 +78,19 @@ export interface BrowserCandidate extends BrowserCandidateDefinition {
 	resolvedExecutable: string;
 }
 
-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;
-}
-
-const configuredHost = process.env.PI_CHROME_DEVTOOLS_HOST ?? DEFAULT_HOST;
-const configuredPortOverride = parseConfiguredPort(process.env.PI_CHROME_DEVTOOLS_PORT);
-const configuredPort = configuredPortOverride ?? DEFAULT_PORT;
+export { parseConfiguredPort };
 
 export const state: ChromeDevToolsState = {
-	host: configuredHost,
-	port: configuredPort,
-	configuredPort,
-	hostConfigured: process.env.PI_CHROME_DEVTOOLS_HOST !== undefined,
-	portConfigured: configuredPortOverride !== undefined,
-	autoLaunchEnabled: process.env.PI_CHROME_DEVTOOLS_AUTO_LAUNCH !== "0",
-	browserExecutable: process.env.PI_CHROME_DEVTOOLS_BROWSER,
+	host: DEFAULT_HOST,
+	port: DEFAULT_PORT,
+	configuredPort: DEFAULT_PORT,
+	hostConfigured: false,
+	portConfigured: false,
+	autoLaunchEnabled: true,
+	endpointSource: "default",
+	autoLaunchSource: "default",
 	extensionPaths: [],
-	browserExecutableSource: process.env.PI_CHROME_DEVTOOLS_BROWSER ? "environment" : "default",
+	browserExecutableSource: "default",
 	extensionPathsSource: "default",
 	projectSettingsTrusted: false,
 	shuttingDown: false,
@@ -106,6 +103,14 @@ export function applyRuntimeBrowserSettings(
 	paths: { user: string; project?: string },
 	projectTrusted: boolean,
 ) {
+	state.host = browser.host;
+	state.port = browser.port;
+	state.configuredPort = browser.port;
+	state.hostConfigured = browser.hostConfigured;
+	state.portConfigured = browser.portConfigured;
+	state.autoLaunchEnabled = browser.autoLaunchEnabled;
+	state.endpointSource = browser.endpointSource;
+	state.autoLaunchSource = browser.autoLaunchSource;
 	state.browserExecutable = browser.executablePath;
 	state.extensionPaths = [...browser.extensionPaths];
 	state.browserExecutableSource = browser.executablePathSource;

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

@@ -268,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.",
@@ -287,6 +288,7 @@ 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 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 — make all Chrome DevTools tools available to lazy-load",