@narumitw/pi-chrome-devtools 0.51.0 → 0.52.1

package/dist/chunks/chunk-RM7OGXVL.ts

@@ -0,0 +1,1607 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+
+// src/tool-names.ts
+var CHROME_DEVTOOLS_TOOL_NAMES = [
+  "chrome_devtools_list_pages",
+  "chrome_devtools_select_page",
+  "chrome_devtools_navigate",
+  "chrome_devtools_evaluate",
+  "chrome_devtools_screenshot"
+];
+
+// src/settings.ts
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import {
+  access,
+  lstat,
+  mkdir,
+  readFile,
+  realpath,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+var NEW_SETTINGS_FILE_NAME = "pi-chrome-devtools.json";
+var LEGACY_SETTINGS_FILE_NAME = "pi-chrome-devtools-settings.json";
+var DEFAULT_BROWSER_HOST = "127.0.0.1";
+var DEFAULT_BROWSER_PORT = 9222;
+var DEFAULT_BROWSER_ENDPOINT = `http://${DEFAULT_BROWSER_HOST}:${DEFAULT_BROWSER_PORT}`;
+var DEFAULT_FILE_OPERATIONS = {
+  write: (path, data) => writeFile(path, data, "utf8").then(() => void 0),
+  rename
+};
+var settingsSaveQueue = Promise.resolve();
+async function waitForSettingsWrites() {
+  await settingsSaveQueue;
+}
+async function loadSettings(options = {}) {
+  await settingsSaveQueue;
+  const userPath = settingsFilePath();
+  const projectPath = options.cwd ? projectSettingsFilePath(options.cwd) : void 0;
+  const paths = { user: userPath, ...projectPath ? { project: projectPath } : {} };
+  const warnings = [];
+  let user = await readSettingsDocument(userPath, "user");
+  const legacyExists = await fileExists(legacySettingsFilePath());
+  if (user.kind !== "missing" && legacyExists) {
+    warnings.push(
+      `Chrome DevTools legacy settings ignored: ${legacySettingsFilePath()} exists, but ${userPath} takes precedence. Delete ${LEGACY_SETTINGS_FILE_NAME} after confirming your settings.`
+    );
+  }
+  if (user.kind === "missing") {
+    const legacy = await readSettingsDocument(legacySettingsFilePath(), "user");
+    const concurrentlyCreated = await readSettingsDocument(userPath, "user");
+    if (concurrentlyCreated.kind !== "missing") {
+      user = concurrentlyCreated;
+      if (legacy.kind !== "missing") {
+        warnings.push(
+          `Chrome DevTools legacy settings ignored: ${legacySettingsFilePath()} exists, but ${userPath} takes precedence. Delete ${LEGACY_SETTINGS_FILE_NAME} after confirming your settings.`
+        );
+      }
+    } else if (legacy.kind !== "missing") {
+      user = legacy;
+      if (legacy.kind === "valid") {
+        warnings.push(
+          `Using legacy ${LEGACY_SETTINGS_FILE_NAME}; rename it to ${NEW_SETTINGS_FILE_NAME}. Future saves write ${NEW_SETTINGS_FILE_NAME} without modifying the legacy file.`
+        );
+      }
+    }
+  }
+  warnings.push(...user.warnings);
+  let project = { kind: "missing", warnings: [] };
+  if (projectPath && options.projectTrusted) {
+    project = await readSettingsDocument(projectPath, "project", options.cwd);
+    warnings.push(...project.warnings);
+  }
+  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 !== void 0 || user.normalized?.browser !== void 0 || project.normalized?.browser !== void 0;
+  const invalidReasons = [user, project].filter((result) => result.kind === "invalid").map((result) => result.reason).filter((reason) => Boolean(reason));
+  const userFile = 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") } : {}
+  };
+  if (recognized) return { ...base, kind: "loaded", settings };
+  if (invalidReasons.length > 0) {
+    return { ...base, kind: "invalid", reason: invalidReasons.join("; ") };
+  }
+  return { ...base, kind: "missing" };
+}
+function resolveSettings(user, _project, browser) {
+  return {
+    ...user?.tools ? { tools: user.tools, updatedAt: user.updatedAt } : {},
+    browser
+  };
+}
+function resolveEffectiveBrowser(user, project) {
+  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 !== void 0 || environmentPort !== void 0;
+  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 endpointSource = environmentEndpointConfigured ? "environment" : user.endpoint ? "user" : "default";
+  return {
+    endpoint: formatBrowserEndpoint(host, port),
+    host,
+    port,
+    hostConfigured: environmentHost !== void 0 || user.endpoint !== void 0,
+    portConfigured: environmentPort !== void 0 || user.endpoint !== void 0,
+    autoLaunchEnabled: environmentAutoLaunch === void 0 ? user.autoLaunch ?? true : environmentAutoLaunch !== "0",
+    ...executablePath ? { executablePath } : {},
+    extensionPaths: [...extensionPaths],
+    endpointSource,
+    autoLaunchSource: environmentAutoLaunch !== void 0 ? "environment" : user.autoLaunch !== void 0 ? "user" : "default",
+    executablePathSource: environmentExecutable ? "environment" : user.executablePath ? "user" : "default",
+    extensionPathsSource: project?.extensionPaths ? "project" : 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] !== void 0);
+  if (configuredNames.length === 0) return void 0;
+  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, scope, cwd) {
+  let text;
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return { kind: "missing", warnings: [] };
+    const reason = `${filePath}: ${formatError(error)}`;
+    return { kind: "invalid", reason, warnings: [`Chrome DevTools settings ignored: ${reason}`] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    const reason = `${filePath}: invalid JSON`;
+    return { kind: "invalid", reason, warnings: [`Chrome DevTools settings ignored: ${reason}`] };
+  }
+  if (!isRecord(parsed)) {
+    const reason = `${filePath}: expected a JSON object`;
+    return { kind: "invalid", reason, warnings: [`Chrome DevTools settings ignored: ${reason}`] };
+  }
+  const scopeWarnings = projectMachineSettingsWarnings(parsed, scope, filePath);
+  try {
+    const normalized = await normalizeSettingsDocument(parsed, scope, filePath, cwd);
+    return { kind: "valid", document: { ...parsed }, normalized, warnings: scopeWarnings };
+  } catch (error) {
+    const reason = `${filePath}: ${formatError(error)}`;
+    return {
+      kind: "invalid",
+      reason,
+      warnings: [...scopeWarnings, `Chrome DevTools settings ignored: ${reason}`]
+    };
+  }
+}
+function projectMachineSettingsWarnings(document, scope, filePath) {
+  if (scope !== "project" || !isRecord(document.browser)) return [];
+  const browser = document.browser;
+  return ["endpoint", "autoLaunch", "executablePath"].filter((field) => browser[field] !== void 0).map(
+    (field) => `Chrome DevTools project browser.${field} ignored in ${filePath}; configure this machine-owned setting in ${settingsFilePath()}.`
+  );
+}
+async function normalizeSettingsDocument(document, scope, filePath, cwd) {
+  const normalized = {};
+  if (scope === "user" && (document.tools !== void 0 || document.updatedAt !== void 0)) {
+    const toolSettings = normalizeChromeDevtoolsSettings(document);
+    if (!toolSettings) {
+      throw new Error(
+        "expected tools to be an array of Chrome DevTools tool names with numeric updatedAt"
+      );
+    }
+    normalized.tools = toolSettings.tools;
+    normalized.updatedAt = toolSettings.updatedAt;
+  }
+  if (document.browser !== void 0) {
+    if (!isRecord(document.browser)) throw new Error("expected browser to be an object");
+    normalized.browser = await normalizeBrowserSection(document.browser, scope, filePath, cwd);
+  }
+  return normalized;
+}
+async function normalizeBrowserSection(browser, scope, _filePath, cwd) {
+  const normalized = {};
+  if (scope === "user" && browser.endpoint !== void 0) {
+    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 !== void 0) {
+    if (typeof browser.autoLaunch !== "boolean") {
+      throw new Error("expected browser.autoLaunch to be a boolean");
+    }
+    normalized.autoLaunch = browser.autoLaunch;
+  }
+  if (scope === "user" && browser.executablePath !== void 0) {
+    if (typeof browser.executablePath !== "string" || browser.executablePath.length === 0) {
+      throw new Error("expected browser.executablePath to be a non-empty absolute path");
+    }
+    if (!isAbsolute(browser.executablePath)) {
+      throw new Error("browser.executablePath in user settings must be absolute");
+    }
+    normalized.executablePath = resolve(browser.executablePath);
+  }
+  if (browser.extensionPaths !== void 0) {
+    if (!Array.isArray(browser.extensionPaths) || !browser.extensionPaths.every((entry) => typeof entry === "string" && entry.length > 0)) {
+      throw new Error(`expected ${scope} browser.extensionPaths to be an array of non-empty paths`);
+    }
+    const resolvedPaths = [];
+    for (const configuredPath of browser.extensionPaths) {
+      if (scope === "user" && !isAbsolute(configuredPath)) {
+        throw new Error("browser.extensionPaths in user settings must contain only absolute paths");
+      }
+      const absolutePath = isAbsolute(configuredPath) ? resolve(configuredPath) : resolve(cwd ?? process.cwd(), configuredPath);
+      resolvedPaths.push(await validateUnpackedExtensionPath(absolutePath));
+    }
+    normalized.extensionPaths = orderedUnique(resolvedPaths);
+  }
+  return normalized;
+}
+async function validateUnpackedExtensionPath(extensionPath) {
+  let canonicalPath;
+  try {
+    canonicalPath = await realpath(extensionPath);
+    const extensionStat = await stat(canonicalPath);
+    if (!extensionStat.isDirectory()) throw new Error("not a directory");
+  } catch (error) {
+    throw new Error(`unpacked extension path ${extensionPath} is invalid: ${formatError(error)}`);
+  }
+  const manifestPath = join(canonicalPath, "manifest.json");
+  let manifest;
+  try {
+    const manifestStat = await lstat(manifestPath);
+    if (!manifestStat.isFile()) throw new Error("not a regular file");
+    manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `unpacked extension ${canonicalPath} has invalid manifest.json: ${formatError(error)}`
+    );
+  }
+  if (canonicalPath.includes(",")) {
+    throw new Error(
+      `unpacked extension path ${canonicalPath} cannot contain a comma because Chrome separates multiple --load-extension paths with commas`
+    );
+  }
+  if (!isRecord(manifest) || ![2, 3].includes(manifest.manifest_version) || typeof manifest.name !== "string" || typeof manifest.version !== "string") {
+    throw new Error(
+      `unpacked extension ${canonicalPath} has invalid manifest.json: expected manifest_version, name, and version`
+    );
+  }
+  return canonicalPath;
+}
+function parseBrowserEndpoint(value) {
+  const trimmedValue = value.trim();
+  const explicitPort = trimmedValue.match(/^http:\/\/(?:\[[^\]]+\]|[^/:?#]+):(\d+)\/?$/i)?.[1];
+  let endpoint;
+  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 === void 0) {
+    throw new Error("browser.endpoint must use a port from 1 through 65535");
+  }
+  const host = endpoint.hostname;
+  return { endpoint: formatBrowserEndpoint(host, port), host, port };
+}
+function parseConfiguredPort(value) {
+  if (value === void 0) return void 0;
+  const trimmedValue = value.trim();
+  if (!/^\d+$/.test(trimmedValue)) return void 0;
+  const port = Number(trimmedValue);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return void 0;
+  return port;
+}
+function formatBrowserEndpoint(host, port) {
+  const formattedHost = host.startsWith("[") && host.endsWith("]") ? host : host.includes(":") ? `[${host}]` : host;
+  return `http://${formattedHost}:${port}`;
+}
+function normalizeChromeDevtoolsSettings(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.updatedAt !== "number" || !Number.isFinite(value.updatedAt)) return void 0;
+  if (value.tools === "enabled") {
+    return { tools: [...CHROME_DEVTOOLS_TOOL_NAMES], updatedAt: value.updatedAt };
+  }
+  if (value.tools === "disabled") return { tools: [], updatedAt: value.updatedAt };
+  if (!Array.isArray(value.tools) || !value.tools.every(isChromeDevtoolsToolName)) return void 0;
+  return { tools: orderedUniqueChromeDevtoolsTools(value.tools), updatedAt: value.updatedAt };
+}
+function isChromeDevtoolsToolName(value) {
+  return typeof value === "string" && CHROME_DEVTOOLS_TOOL_NAMES.includes(value);
+}
+function orderedUniqueChromeDevtoolsTools(tools) {
+  const selectedTools = new Set(tools);
+  return CHROME_DEVTOOLS_TOOL_NAMES.filter((toolName) => selectedTools.has(toolName));
+}
+function orderedUnique(values) {
+  return [...new Set(values)];
+}
+function saveSettings(settings, operations = {}) {
+  return queueSettingsMutation(
+    (current) => ({
+      ...current,
+      tools: [...settings.tools],
+      updatedAt: settings.updatedAt
+    }),
+    operations
+  );
+}
+function saveBrowserSettings(patch, operations = {}) {
+  return queueSettingsMutation(async (current) => {
+    const browser = isRecord(current.browser) ? { ...current.browser } : {};
+    for (const field of ["endpoint", "autoLaunch", "executablePath"]) {
+      const value = patch[field];
+      if (value === void 0) continue;
+      if (value === null) delete browser[field];
+      else browser[field] = value;
+    }
+    await normalizeBrowserSection(browser, "user", settingsFilePath());
+    return { ...current, browser };
+  }, operations);
+}
+function queueSettingsMutation(mutate, operations) {
+  const operation = settingsSaveQueue.then(() => saveSettingsMutationNow(mutate, operations));
+  settingsSaveQueue = operation.catch(() => void 0);
+  return operation;
+}
+async function saveSettingsMutationNow(mutate, operations) {
+  const filePath = settingsFilePath();
+  let current = await readSettingsDocument(filePath, "user");
+  const replaceCanonical = current.kind !== "missing";
+  if (!replaceCanonical) current = await readSettingsDocument(legacySettingsFilePath(), "user");
+  if (current.kind === "invalid") {
+    throw new Error(`Cannot save Chrome DevTools settings until you repair ${current.reason}`);
+  }
+  const nextDocument = await mutate(current.document ?? {});
+  await mkdir(dirname(filePath), { recursive: true });
+  const tempFile = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await (operations.write ?? DEFAULT_FILE_OPERATIONS.write)(
+      tempFile,
+      `${JSON.stringify(nextDocument, null, 2)}
+`
+    );
+    if (!replaceCanonical && await pathEntryExists(filePath)) {
+      throw new Error(
+        `${NEW_SETTINGS_FILE_NAME} was created concurrently; reopen settings and retry.`
+      );
+    }
+    await (operations.rename ?? DEFAULT_FILE_OPERATIONS.rename)(tempFile, filePath);
+  } catch (error) {
+    await rm(tempFile, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+function settingsFilePath() {
+  return join(getAgentDir(), NEW_SETTINGS_FILE_NAME);
+}
+function projectSettingsFilePath(cwd) {
+  return join(cwd, CONFIG_DIR_NAME, NEW_SETTINGS_FILE_NAME);
+}
+function legacySettingsFilePath() {
+  return join(getAgentDir(), LEGACY_SETTINGS_FILE_NAME);
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function pathEntryExists(filePath) {
+  try {
+    await lstat(filePath);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/runtime.ts
+var DEFAULT_HOST = DEFAULT_BROWSER_HOST;
+var DEFAULT_PORT = DEFAULT_BROWSER_PORT;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_HTTP_TIMEOUT_MS = 1e3;
+var DEFAULT_ENDPOINT_WAIT_MS = 5e3;
+var DEFAULT_ENDPOINT_RETRY_MS = 250;
+var MANAGED_BROWSER_PROFILE_PREFIX = "pi-chrome-devtools-profile-";
+var DEVTOOLS_ACTIVE_PORT_FILE = "DevToolsActivePort";
+var BROWSER_SHUTDOWN_WAIT_MS = 1500;
+var state = {
+  host: DEFAULT_HOST,
+  port: DEFAULT_PORT,
+  configuredPort: DEFAULT_PORT,
+  hostConfigured: false,
+  portConfigured: false,
+  autoLaunchEnabled: true,
+  endpointSource: "default",
+  autoLaunchSource: "default",
+  extensionPaths: [],
+  browserExecutableSource: "default",
+  extensionPathsSource: "default",
+  projectSettingsTrusted: false,
+  shuttingDown: false,
+  sessionGeneration: 0,
+  sessionController: new AbortController()
+};
+function applyRuntimeBrowserSettings(browser, paths, projectTrusted) {
+  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;
+  state.extensionPathsSource = browser.extensionPathsSource;
+  state.settingsFilePath = paths.user;
+  state.projectSettingsFilePath = paths.project;
+  state.projectSettingsTrusted = projectTrusted;
+}
+
+// src/browser-manager.ts
+import { execFile, spawn } from "node:child_process";
+import { constants as constants2 } from "node:fs";
+import { access as access2, mkdtemp, readFile as readFile2, rm as rm2 } from "node:fs/promises";
+import { createServer } from "node:net";
+import { tmpdir } from "node:os";
+import { delimiter, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "node:path";
+var DEFAULT_BROWSER_MANAGER_OPERATIONS = {
+  access: access2,
+  mkdtemp,
+  readFile: readFile2,
+  rm: (path, options) => rm2(path, options),
+  fetch: (input, init) => fetch(input, init),
+  spawn,
+  inspectBrowserVersion,
+  isPortAvailable,
+  sleep: abortableSleep
+};
+var browserManagerOperations = DEFAULT_BROWSER_MANAGER_OPERATIONS;
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+function normalizePathForComparison(value) {
+  return process.platform === "win32" ? value.toLowerCase() : value;
+}
+async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS) {
+  if (extensionsConfigured()) {
+    validateExtensionLaunchMode();
+    await ensureManagedBrowserLaunched(waitMs);
+    return;
+  }
+  if (canAutoLaunchBrowser()) {
+    try {
+      await withEndpointRetry(() => fetchDevToolsJson("/json/version"), waitMs);
+      return;
+    } catch (error) {
+      if (shouldAutoLaunchAfterEndpointError(error)) {
+        await ensureManagedBrowserLaunched(waitMs);
+        return;
+      }
+      throw error;
+    }
+  }
+  try {
+    await fetchDevToolsJson("/json/version");
+  } catch (error) {
+    if (isRetryableEndpointError(error)) return;
+    throw error;
+  }
+}
+function validateExtensionLaunchMode() {
+  if (!isLocalDevToolsHost(state.host)) {
+    throw new DevToolsEndpointError(
+      "Unpacked extensions require a local extension-owned managed browser; remote CDP endpoints cannot be modified."
+    );
+  }
+  if (!state.autoLaunchEnabled) {
+    throw new DevToolsEndpointError(
+      "Auto-launch is required for unpacked extensions so Pi can create an isolated managed browser."
+    );
+  }
+  if (!state.browserExecutable) {
+    throw new DevToolsEndpointError(
+      "Unpacked extensions require browser.executablePath for Chrome for Testing or Chromium in pi-chrome-devtools.json."
+    );
+  }
+}
+async function ensureManagedBrowserLaunched(waitMs) {
+  if (state.launchPromise) return state.launchPromise;
+  if (state.managedBrowser && !state.managedBrowser.exited && state.managedBrowser.ready) return;
+  const generation = state.sessionGeneration;
+  const signal = state.sessionController.signal;
+  throwIfBrowserLaunchCancelled(generation, signal);
+  const launchPromise = prepareManagedBrowserLaunch(waitMs, generation, signal);
+  const wrappedPromise = launchPromise.finally(() => {
+    if (state.launchPromise === wrappedPromise) state.launchPromise = void 0;
+  });
+  state.launchPromise = wrappedPromise;
+  return wrappedPromise;
+}
+async function prepareManagedBrowserLaunch(waitMs, generation, signal) {
+  if (state.managedBrowser) {
+    await shutdownManagedBrowser(state.managedBrowser, { awaitLaunch: false });
+    throwIfBrowserLaunchCancelled(generation, signal);
+  }
+  if (state.portConfigured) {
+    const available = await browserManagerOperations.isPortAvailable(state.host, state.port);
+    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 browser.endpoint port or reset the endpoint to use a dynamic managed port.`
+      );
+    }
+  }
+  return launchManagedBrowser(waitMs, generation, signal);
+}
+async function launchManagedBrowser(waitMs, generation, signal) {
+  throwIfBrowserLaunchCancelled(generation, signal);
+  const candidateDefinitions = browserCandidateDefinitions();
+  const candidates = await resolveBrowserCandidates(candidateDefinitions, generation, signal);
+  throwIfBrowserLaunchCancelled(generation, signal);
+  state.lastLaunchAttempt = {
+    candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
+    mode: state.portConfigured ? "explicit-port" : "dynamic-port"
+  };
+  if (candidates.length === 0) {
+    throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions));
+  }
+  let lastError;
+  for (const candidate of candidates) {
+    throwIfBrowserLaunchCancelled(generation, signal);
+    try {
+      if (extensionsConfigured())
+        await requireSupportedExtensionBrowser(candidate, generation, signal);
+      await launchBrowserCandidate(candidate, waitMs, generation, signal);
+      throwIfBrowserLaunchCancelled(generation, signal);
+      state.lastLaunchAttempt = {
+        ...state.lastLaunchAttempt,
+        selectedCandidate: formatBrowserCandidate(candidate),
+        userDataDir: state.managedBrowser?.userDataDir
+      };
+      return;
+    } catch (error) {
+      try {
+        throwIfBrowserLaunchCancelled(generation, signal);
+      } catch (cancellation) {
+        state.lastLaunchAttempt = {
+          ...state.lastLaunchAttempt,
+          lastError: formatError2(cancellation)
+        };
+        throw cancellation;
+      }
+      lastError = error;
+      state.lastLaunchAttempt = {
+        ...state.lastLaunchAttempt,
+        lastError: formatError2(error)
+      };
+    }
+  }
+  if (lastError instanceof DevToolsEndpointError && extensionsConfigured()) throw lastError;
+  throw new DevToolsEndpointError(
+    [
+      "Unable to auto-launch a Chromium-family browser for Chrome DevTools.",
+      `Tried: ${candidates.map(formatBrowserCandidate).join(", ")}`,
+      lastError ? `Last error: ${formatError2(lastError)}` : void 0,
+      launchHint(),
+      endpointConfigHint()
+    ].filter(Boolean).join("\n")
+  );
+}
+async function requireSupportedExtensionBrowser(candidate, generation, signal) {
+  let version;
+  try {
+    version = (await browserManagerOperations.inspectBrowserVersion(candidate.resolvedExecutable, signal)).trim();
+  } catch (error) {
+    throwIfBrowserLaunchCancelled(generation, signal);
+    throw new DevToolsEndpointError(
+      `Unable to identify the configured extension browser ${candidate.resolvedExecutable}: ${formatError2(error)}. Configure Chrome for Testing or Chromium.`
+    );
+  }
+  throwIfBrowserLaunchCancelled(generation, signal);
+  const classification = classifyExtensionBrowserVersion(version);
+  if (!classification.supported) {
+    throw new DevToolsEndpointError(
+      `Unsupported browser for unpacked extensions: ${version || "unknown product"}. Configure Chrome for Testing or Chromium; branded Chrome may silently ignore extension startup flags.`
+    );
+  }
+}
+function classifyExtensionBrowserVersion(version) {
+  if (/^(?:Google )?Chrome for Testing\b/i.test(version)) {
+    return { supported: true, product: "Chrome for Testing" };
+  }
+  if (/^Chromium\b/i.test(version)) return { supported: true, product: "Chromium" };
+  const product = version.trim().replace(/\s+\d+(?:\.\d+)*.*$/, "") || "Unknown";
+  return { supported: false, product };
+}
+async function launchBrowserCandidate(candidate, waitMs, generation, signal) {
+  throwIfBrowserLaunchCancelled(generation, signal);
+  const userDataDir = await browserManagerOperations.mkdtemp(
+    join2(tmpdir(), MANAGED_BROWSER_PROFILE_PREFIX)
+  );
+  let managedBrowser;
+  try {
+    throwIfBrowserLaunchCancelled(generation, signal);
+    const portArgument = state.portConfigured ? String(state.port) : "0";
+    const args = buildManagedBrowserLaunchArguments(
+      userDataDir,
+      portArgument,
+      state.extensionPaths
+    );
+    const child = browserManagerOperations.spawn(candidate.resolvedExecutable, args, {
+      shell: false,
+      stdio: "ignore"
+    });
+    const launchedBrowser = {
+      process: child,
+      userDataDir,
+      exited: false,
+      ready: false,
+      ownerGeneration: generation
+    };
+    managedBrowser = launchedBrowser;
+    state.managedBrowser = launchedBrowser;
+    child.once("exit", () => {
+      launchedBrowser.exited = true;
+      launchedBrowser.ready = false;
+      if (!state.portConfigured && launchedBrowser.port === state.port) {
+        state.port = state.configuredPort;
+      }
+    });
+    await waitForBrowserSpawn(child);
+    throwIfBrowserLaunchCancelled(generation, signal);
+    if (state.portConfigured) {
+      launchedBrowser.port = state.port;
+    } else {
+      launchedBrowser.port = await readManagedBrowserPort(
+        userDataDir,
+        launchedBrowser,
+        waitMs,
+        generation,
+        signal
+      );
+      throwIfBrowserLaunchCancelled(generation, signal);
+      state.port = launchedBrowser.port;
+    }
+    await waitForDevToolsEndpoint(waitMs, launchedBrowser, generation, signal);
+    throwIfBrowserLaunchCancelled(generation, signal);
+    launchedBrowser.ready = true;
+  } catch (error) {
+    if (managedBrowser) await shutdownManagedBrowser(managedBrowser, { awaitLaunch: false });
+    else {
+      await browserManagerOperations.rm(userDataDir, { recursive: true, force: true }).catch(() => void 0);
+    }
+    throw error;
+  }
+}
+function buildManagedBrowserLaunchArguments(userDataDir, portArgument, extensionPaths) {
+  const extensionList = extensionPaths.join(",");
+  return [
+    `--remote-debugging-port=${portArgument}`,
+    `--user-data-dir=${userDataDir}`,
+    ...extensionPaths.length > 0 ? [`--disable-extensions-except=${extensionList}`, `--load-extension=${extensionList}`] : [],
+    // Chrome 138+ de-elevates when launched from an elevated process on Windows: the
+    // spawned process relaunches a de-elevated child and exits immediately, which the
+    // exit watchdog misreads as a failed launch.
+    ...process.platform === "win32" ? ["--do-not-de-elevate"] : [],
+    "--no-first-run",
+    "--no-default-browser-check",
+    "about:blank"
+  ];
+}
+function waitForBrowserSpawn(child) {
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    const settle = (callback) => {
+      if (settled) return;
+      settled = true;
+      child.off("error", onError);
+      child.off("spawn", onSpawn);
+      callback();
+    };
+    const onError = (error) => settle(() => reject(error));
+    const onSpawn = () => settle(resolve3);
+    child.once("error", onError);
+    child.once("spawn", onSpawn);
+  });
+}
+async function readManagedBrowserPort(userDataDir, managedBrowser, waitMs, generation, signal) {
+  const activePortFile = join2(userDataDir, DEVTOOLS_ACTIVE_PORT_FILE);
+  const deadline = Date.now() + waitMs;
+  while (true) {
+    throwIfManagedBrowserExited(managedBrowser);
+    const text = await browserManagerOperations.readFile(activePortFile, "utf8").catch((error) => {
+      if (isNodeError2(error) && error.code === "ENOENT") return void 0;
+      throw error;
+    });
+    throwIfBrowserLaunchCancelled(generation, signal);
+    const portText = text?.split(/\r?\n/, 1)[0]?.trim();
+    const port = Number(portText);
+    if (Number.isInteger(port) && port > 0) return port;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new DevToolsEndpointError(
+        [
+          "Timed out waiting for auto-launched browser DevToolsActivePort.",
+          `Expected file: ${activePortFile}`,
+          launchHint()
+        ].join("\n")
+      );
+    }
+    await browserManagerOperations.sleep(Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs), signal);
+  }
+}
+async function waitForDevToolsEndpoint(waitMs, managedBrowser, generation, signal) {
+  const deadline = Date.now() + waitMs;
+  while (true) {
+    throwIfManagedBrowserExited(managedBrowser);
+    try {
+      await fetchDevToolsJson("/json/version", { signal });
+      throwIfBrowserLaunchCancelled(generation, signal);
+      return;
+    } catch (error) {
+      if (!isRetryableEndpointError(error)) throw error;
+    }
+    throwIfBrowserLaunchCancelled(generation, signal);
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new DevToolsEndpointError(
+        [
+          `Timed out waiting for auto-launched browser at ${devToolsEndpoint()}.`,
+          launchHint()
+        ].join("\n")
+      );
+    }
+    await browserManagerOperations.sleep(Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs), signal);
+  }
+}
+function throwIfManagedBrowserExited(managedBrowser) {
+  if (!managedBrowser.exited) return;
+  throw new DevToolsEndpointError("Auto-launched browser exited before DevTools became available.");
+}
+function throwIfBrowserLaunchCancelled(generation, signal) {
+  if (!state.shuttingDown && generation === state.sessionGeneration && !signal.aborted) {
+    return;
+  }
+  throw new DevToolsEndpointError(
+    generation === state.sessionGeneration ? "Chrome DevTools browser launch cancelled during shutdown." : "Chrome DevTools browser launch cancelled because the session was replaced."
+  );
+}
+async function shutdownManagedBrowser(managedBrowser = state.managedBrowser, options = {}) {
+  if (options.cancelLaunch) state.shuttingDown = true;
+  if (options.awaitLaunch !== false) {
+    await state.launchPromise?.catch(() => void 0);
+    managedBrowser = managedBrowser ?? state.managedBrowser;
+  }
+  if (!managedBrowser) return;
+  if (managedBrowser.cleanupPromise) return managedBrowser.cleanupPromise;
+  const cleanup = cleanupManagedBrowser(managedBrowser);
+  managedBrowser.cleanupPromise = cleanup;
+  return cleanup;
+}
+async function cleanupManagedBrowser(managedBrowser) {
+  if (state.managedBrowser === managedBrowser) state.managedBrowser = void 0;
+  if (!managedBrowser.exited) {
+    killManagedBrowserProcess(managedBrowser);
+    await waitForManagedBrowserExit(managedBrowser, BROWSER_SHUTDOWN_WAIT_MS).catch(async () => {
+      killManagedBrowserProcess(managedBrowser, "SIGKILL");
+      await waitForManagedBrowserExit(managedBrowser, BROWSER_SHUTDOWN_WAIT_MS).catch(
+        () => void 0
+      );
+    });
+  }
+  await browserManagerOperations.rm(managedBrowser.userDataDir, { recursive: true, force: true }).catch(() => void 0);
+  if (!state.portConfigured && managedBrowser.port === state.port) {
+    state.port = state.configuredPort;
+  }
+}
+function killManagedBrowserProcess(managedBrowser, signal) {
+  try {
+    managedBrowser.process.kill(signal);
+  } catch {
+  }
+}
+function waitForManagedBrowserExit(managedBrowser, waitMs) {
+  if (managedBrowser.exited) return Promise.resolve();
+  return new Promise((resolve3, reject) => {
+    const settle = (callback) => {
+      clearTimeout(timeout);
+      managedBrowser.process.off("exit", onExitOrClose);
+      managedBrowser.process.off("close", onExitOrClose);
+      callback();
+    };
+    const onExitOrClose = () => {
+      managedBrowser.exited = true;
+      settle(resolve3);
+    };
+    const timeout = setTimeout(
+      () => settle(() => reject(new Error("Timed out waiting for browser shutdown."))),
+      waitMs
+    );
+    managedBrowser.process.once("exit", onExitOrClose);
+    managedBrowser.process.once("close", onExitOrClose);
+  });
+}
+async function fetchDevToolsJson(path, init) {
+  const url = `${devToolsEndpoint()}${path}`;
+  let response;
+  try {
+    const timeoutSignal = AbortSignal.timeout(DEFAULT_HTTP_TIMEOUT_MS);
+    response = await browserManagerOperations.fetch(url, {
+      ...init,
+      signal: init?.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal
+    });
+  } catch (error) {
+    throw new DevToolsEndpointError(endpointConnectionErrorMessage(error), {
+      launchable: true,
+      retryable: true
+    });
+  }
+  if (!response.ok) {
+    const body = (await response.text().catch(() => "")).trim();
+    const suffix = body ? `: ${body.slice(0, 200)}` : "";
+    throw new DevToolsEndpointError(
+      [
+        `Chrome DevTools endpoint ${url} returned ${response.status} ${response.statusText}${suffix}.`,
+        endpointConfigHint()
+      ].join("\n"),
+      { retryable: response.status === 429 || response.status >= 500 }
+    );
+  }
+  try {
+    return await response.json();
+  } catch (error) {
+    throw new DevToolsEndpointError(
+      [
+        `Chrome DevTools endpoint ${url} returned invalid JSON: ${formatError2(error)}.`,
+        endpointConfigHint()
+      ].join("\n")
+    );
+  }
+}
+async function withEndpointRetry(operation, waitMs) {
+  const deadline = Date.now() + waitMs;
+  while (true) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!isRetryableEndpointError(error)) throw error;
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) throw error;
+      await browserManagerOperations.sleep(Math.min(DEFAULT_ENDPOINT_RETRY_MS, remainingMs));
+    }
+  }
+}
+function isRetryableEndpointError(error) {
+  return error instanceof DevToolsEndpointError && error.retryable;
+}
+function isLaunchableEndpointError(error) {
+  return error instanceof DevToolsEndpointError && error.launchable;
+}
+function shouldAutoLaunchAfterEndpointError(error) {
+  if (!canAutoLaunchBrowser()) return false;
+  if (isLaunchableEndpointError(error)) return true;
+  return !state.portConfigured && error instanceof DevToolsEndpointError;
+}
+function canAutoLaunchBrowser() {
+  return state.autoLaunchEnabled && isLocalDevToolsHost(state.host);
+}
+function extensionsConfigured() {
+  return state.extensionPaths.length > 0;
+}
+function endpointConnectionErrorMessage(error) {
+  const reason = isTimeoutError(error) ? "request timed out" : "connection failed";
+  return [
+    `Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint()} (${reason}).`,
+    launchHint(),
+    endpointConfigHint()
+  ].join("\n");
+}
+function isTimeoutError(error) {
+  return error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name);
+}
+function devToolsEndpoint() {
+  return `http://${formatHostForUrl(state.host)}:${state.port}`;
+}
+function formatHostForUrl(host) {
+  if (host.startsWith("[") && host.endsWith("]")) return host;
+  return host.includes(":") ? `[${host}]` : host;
+}
+function endpointSourceLabel() {
+  return state.endpointSource;
+}
+function browserLifecycleState() {
+  if (state.launchPromise) return "starting";
+  if (state.managedBrowser?.exited) return "exited";
+  if (state.managedBrowser?.ready) return "running";
+  if (state.lastLaunchAttempt?.lastError) return "failed";
+  return "unobserved";
+}
+function launchModeLabel() {
+  if (extensionsConfigured()) {
+    if (!isLocalDevToolsHost(state.host)) return "invalid; extensions require a local endpoint";
+    if (!state.autoLaunchEnabled) return "invalid; extensions require auto-launch";
+    if (state.managedBrowser && !state.managedBrowser.exited) {
+      return state.portConfigured ? "extension-owned browser on explicit port" : "extension-owned browser on dynamic port";
+    }
+    return state.portConfigured ? "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 (state.managedBrowser && !state.managedBrowser.exited) {
+    return state.portConfigured ? "auto-launched on explicit port" : "auto-launched on dynamic port";
+  }
+  return state.portConfigured ? "attach first; auto-launch explicit port" : "attach first; auto-launch dynamic port";
+}
+function launchAttemptLines() {
+  if (!state.lastLaunchAttempt) return [];
+  const lines = [`Last launch attempt: ${state.lastLaunchAttempt.mode}`];
+  if (state.lastLaunchAttempt.selectedCandidate) {
+    lines.push(`Launched browser: ${state.lastLaunchAttempt.selectedCandidate}`);
+  } else {
+    lines.push(`Tried browser candidates: ${state.lastLaunchAttempt.candidateLabels.join(", ")}`);
+  }
+  if (state.lastLaunchAttempt.userDataDir) {
+    lines.push(`Managed browser profile: ${state.lastLaunchAttempt.userDataDir}`);
+  }
+  if (state.lastLaunchAttempt.lastError) {
+    lines.push(`Last launch error: ${state.lastLaunchAttempt.lastError}`);
+  }
+  return lines;
+}
+function launchHint() {
+  if (extensionsConfigured()) {
+    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 (!state.autoLaunchEnabled) {
+    return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand()}`;
+  }
+  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()}`;
+}
+function browserCandidateHint() {
+  if (extensionsConfigured()) {
+    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().map((candidate) => candidate.label).join(", ")}`;
+}
+function chromeLaunchCommand() {
+  const executable = state.browserExecutable ?? 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}`;
+}
+function defaultManualBrowserExecutable() {
+  return process.platform === "darwin" ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" : process.platform === "win32" ? "chrome.exe" : "google-chrome";
+}
+function quoteCommandPart(value) {
+  return /\s/.test(value) ? `"${value.replaceAll('"', '\\"')}"` : value;
+}
+function endpointConfigHint() {
+  return "Configure browser.endpoint, browser.executablePath, and browser.autoLaunch in pi-chrome-devtools.json or the /chrome-devtools Settings flow.";
+}
+function isLocalDevToolsHost(host) {
+  const normalizedHost = host.toLowerCase().replace(/^\[(.*)]$/, "$1");
+  return ["localhost", "127.0.0.1", "::1", "0:0:0:0:0:0:0:1"].includes(normalizedHost);
+}
+function browserCandidateDefinitions() {
+  const explicitCandidate = explicitBrowserCandidateDefinition();
+  if (explicitCandidate.length > 0) return explicitCandidate;
+  return uniqueBrowserCandidates(platformBrowserCandidateDefinitions());
+}
+function explicitBrowserCandidateDefinition() {
+  if (!state.browserExecutable) return [];
+  return [
+    {
+      label: state.browserExecutableSource === "environment" ? "PI_CHROME_DEVTOOLS_BROWSER" : "browser.executablePath",
+      executable: state.browserExecutable,
+      source: "env"
+    }
+  ];
+}
+function platformBrowserCandidateDefinitions() {
+  if (process.platform === "darwin") {
+    return [
+      {
+        label: "Google Chrome",
+        executable: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        source: "wellKnownPath"
+      },
+      {
+        label: "Chromium",
+        executable: "/Applications/Chromium.app/Contents/MacOS/Chromium",
+        source: "wellKnownPath"
+      },
+      {
+        label: "Brave Browser",
+        executable: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+        source: "wellKnownPath"
+      },
+      {
+        label: "Microsoft Edge",
+        executable: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        source: "wellKnownPath"
+      }
+    ];
+  }
+  if (process.platform === "win32") {
+    return windowsBrowserCandidateDefinitions();
+  }
+  return [
+    { label: "Google Chrome", executable: "google-chrome", source: "path" },
+    { label: "Google Chrome Stable", executable: "google-chrome-stable", source: "path" },
+    { label: "Chromium", executable: "chromium", source: "path" },
+    { label: "Chromium Browser", executable: "chromium-browser", source: "path" },
+    { label: "Brave Browser", executable: "brave-browser", source: "path" },
+    { label: "Brave", executable: "brave", source: "path" },
+    { label: "Microsoft Edge", executable: "microsoft-edge", source: "path" },
+    { label: "Microsoft Edge Stable", executable: "microsoft-edge-stable", source: "path" }
+  ];
+}
+function windowsBrowserCandidateDefinitions() {
+  const programFiles = [
+    process.env.PROGRAMFILES,
+    process.env["PROGRAMFILES(X86)"],
+    process.env.LOCALAPPDATA
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  const wellKnownPaths = programFiles.flatMap((root) => [
+    join2(root, "Google", "Chrome", "Application", "chrome.exe"),
+    join2(root, "Chromium", "Application", "chrome.exe"),
+    join2(root, "BraveSoftware", "Brave-Browser", "Application", "brave.exe"),
+    join2(root, "Microsoft", "Edge", "Application", "msedge.exe")
+  ]);
+  return [
+    ...wellKnownPaths.map((executable) => ({
+      label: browserLabelFromExecutable(executable),
+      executable,
+      source: "wellKnownPath"
+    })),
+    { label: "Google Chrome", executable: "chrome.exe", source: "path" },
+    { label: "Chromium", executable: "chromium.exe", source: "path" },
+    { label: "Brave Browser", executable: "brave.exe", source: "path" },
+    { label: "Microsoft Edge", executable: "msedge.exe", source: "path" }
+  ];
+}
+function browserLabelFromExecutable(executable) {
+  const normalizedExecutable = normalizePathForComparison(executable);
+  if (normalizedExecutable.includes("brave")) return "Brave Browser";
+  if (normalizedExecutable.includes("edge") || normalizedExecutable.includes("msedge")) {
+    return "Microsoft Edge";
+  }
+  if (normalizedExecutable.includes("chromium")) return "Chromium";
+  return "Google Chrome";
+}
+function uniqueBrowserCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const key = normalizePathForComparison(candidate.executable);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function resolveBrowserCandidates(definitions, generation, signal) {
+  const candidates = [];
+  for (const definition of definitions) {
+    const resolvedExecutable = await resolveBrowserExecutable(definition.executable);
+    throwIfBrowserLaunchCancelled(generation, signal);
+    if (!resolvedExecutable) continue;
+    candidates.push({ ...definition, resolvedExecutable });
+  }
+  return uniqueBrowserCandidatesByResolvedPath(candidates);
+}
+function uniqueBrowserCandidatesByResolvedPath(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const key = normalizePathForComparison(resolve2(candidate.resolvedExecutable));
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+async function resolveBrowserExecutable(executable) {
+  if (hasPathSeparator(executable) || isAbsolute2(executable)) {
+    const resolvedExecutable = isAbsolute2(executable) ? executable : resolve2(executable);
+    return await canAccessExecutable(resolvedExecutable) ? resolvedExecutable : void 0;
+  }
+  for (const directory of executableSearchPath()) {
+    for (const executableName of executableSearchNames(executable)) {
+      const candidate = join2(directory, executableName);
+      if (await canAccessExecutable(candidate)) return candidate;
+    }
+  }
+  return void 0;
+}
+function hasPathSeparator(path) {
+  return path.includes("/") || path.includes("\\");
+}
+function executableSearchPath() {
+  return (process.env.PATH ?? "").split(delimiter).filter((part) => part.length > 0);
+}
+function executableSearchNames(executable) {
+  if (process.platform !== "win32" || /\.[a-z0-9]+$/i.test(executable)) return [executable];
+  return [executable, `${executable}.exe`, `${executable}.cmd`, `${executable}.bat`];
+}
+async function canAccessExecutable(path) {
+  try {
+    await browserManagerOperations.access(
+      path,
+      process.platform === "win32" ? constants2.F_OK : constants2.X_OK
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatBrowserCandidate(candidate) {
+  return `${candidate.label} (${candidate.resolvedExecutable})`;
+}
+function formatBrowserCandidateDefinition(candidate) {
+  return `${candidate.label} (${candidate.executable})`;
+}
+function noBrowserCandidateMessage(candidateDefinitions) {
+  if (extensionsConfigured()) {
+    return [
+      "Cannot launch unpacked extensions because the configured browser executable was not found or is not executable.",
+      `Tried: ${candidateDefinitions.map(formatBrowserCandidateDefinition).join(", ")}`,
+      "Set browser.executablePath to an executable Chrome for Testing or Chromium binary."
+    ].join("\n");
+  }
+  return [
+    "Cannot auto-launch Chrome DevTools because no Chromium-family browser executable was found.",
+    `Tried: ${candidateDefinitions.map(formatBrowserCandidateDefinition).join(", ")}`,
+    endpointConfigHint()
+  ].join("\n");
+}
+function formatPageListItem(page) {
+  return `- ${page.id}: ${page.title || "(untitled)"} ${page.url}`;
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolveSleep, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const timeout = setTimeout(settleResolve, ms);
+    const onAbort = () => settleReject(signal?.reason);
+    function cleanup() {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", onAbort);
+    }
+    function settleResolve() {
+      cleanup();
+      resolveSleep();
+    }
+    function settleReject(reason) {
+      cleanup();
+      reject(reason);
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function inspectBrowserVersion(executable, signal) {
+  return new Promise((resolveVersion, reject) => {
+    execFile(executable, ["--version"], { signal, timeout: 5e3 }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolveVersion(`${stdout}${stderr}`.trim());
+    });
+  });
+}
+function isPortAvailable(host, port) {
+  return new Promise((resolveAvailability, reject) => {
+    const server = createServer();
+    const normalizedHost = host.replace(/^\[(.*)]$/, "$1");
+    server.unref();
+    server.once("error", (error) => {
+      if (error.code === "EADDRINUSE") resolveAvailability(false);
+      else reject(error);
+    });
+    server.listen(port, normalizedHost, () => {
+      server.close((error) => {
+        if (error) reject(error);
+        else resolveAvailability(true);
+      });
+    });
+  });
+}
+var DevToolsEndpointError = class extends Error {
+  retryable;
+  launchable;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "DevToolsEndpointError";
+    this.retryable = options.retryable ?? false;
+    this.launchable = options.launchable ?? false;
+  }
+};
+
+// src/lazy-tools.ts
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+var CHROME_DEVTOOLS_LOAD_TOOL_NAME = "chrome_devtools_load";
+var AVAILABLE_TOOLS_STORE = /* @__PURE__ */ Symbol.for("@narumitw/pi-chrome-devtools.available-tools-store");
+var sharedGlobal = globalThis;
+var existingAvailableToolsStore = sharedGlobal[AVAILABLE_TOOLS_STORE];
+var availableToolsByApi = existingAvailableToolsStore ?? /* @__PURE__ */ new WeakMap();
+if (!existingAvailableToolsStore) sharedGlobal[AVAILABLE_TOOLS_STORE] = availableToolsByApi;
+var SEARCH_TEXT = {
+  chrome_devtools_list_pages: "list open inspectable chrome browser pages tabs targets",
+  chrome_devtools_select_page: "select choose active chrome browser page tab target",
+  chrome_devtools_navigate: "navigate open create chrome browser page url website",
+  chrome_devtools_evaluate: "evaluate run javascript expression dom inspect chrome browser page",
+  chrome_devtools_screenshot: "capture screenshot png image visual chrome browser page"
+};
+function initializeAvailableChromeDevtoolsTools(pi) {
+  if (availableToolsByApi.has(pi)) return;
+  const activeTools = new Set(pi.getActiveTools());
+  setAvailableTools(
+    pi,
+    CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => activeTools.has(name))
+  );
+}
+function configureLazyChromeDevtoolsTools(pi, availableTools) {
+  setAvailableTools(pi, availableTools);
+  const nonCapabilityTools = pi.getActiveTools().filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
+  pi.setActiveTools(unique([...nonCapabilityTools, CHROME_DEVTOOLS_LOAD_TOOL_NAME]));
+}
+function applyAvailableChromeDevtoolsTools(pi, availableTools) {
+  const available = setAvailableTools(pi, availableTools);
+  const active = pi.getActiveTools().filter(
+    (name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name) || available.has(name)
+  );
+  pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME]));
+}
+function availableChromeDevtoolsTools(pi) {
+  const available = availableToolsByApi.get(pi) ?? /* @__PURE__ */ new Set();
+  return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
+}
+function createChromeDevtoolsLoadTool(pi) {
+  return defineTool({
+    name: CHROME_DEVTOOLS_LOAD_TOOL_NAME,
+    label: "Chrome DevTools: Load Tools",
+    description: "Find and enable Chrome DevTools browser tools relevant to a task. Loaded tools remain available for the session.",
+    promptSnippet: "Load Chrome DevTools browser capabilities on demand",
+    promptGuidelines: [
+      "Use chrome_devtools_load when a task requires inspecting or controlling a Chrome browser and the needed chrome_devtools_* capability is not active."
+    ],
+    parameters: Type.Object({
+      query: Type.String({
+        description: "Browser capability or task to find tools for.",
+        maxLength: 500
+      }),
+      limit: Type.Optional(
+        Type.Integer({
+          description: "Maximum tools to load. Defaults to 3.",
+          minimum: 1,
+          maximum: 5
+        })
+      )
+    }),
+    async execute(_toolCallId, params, signal) {
+      signal?.throwIfAborted();
+      const available = new Set(availableChromeDevtoolsTools(pi));
+      const matches = matchChromeDevtoolsTools(params.query, params.limit ?? 3, available);
+      const active = pi.getActiveTools();
+      const activeSet = new Set(active);
+      const added = matches.filter((name) => !activeSet.has(name));
+      if (added.length > 0) {
+        pi.setActiveTools(unique([...active, ...added]));
+      }
+      const text = matches.length === 0 ? "No available Chrome DevTools tools matched the query." : added.length > 0 ? `Loaded Chrome DevTools tools: ${added.join(", ")}` : `Matching Chrome DevTools tools are already loaded: ${matches.join(", ")}`;
+      return {
+        content: [{ type: "text", text }],
+        details: { matches, added }
+      };
+    }
+  });
+}
+function matchChromeDevtoolsTools(query, limit, available) {
+  const terms = query.toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length >= 2);
+  if (terms.length === 0) return [];
+  return CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name)).map((name, index) => ({
+    name,
+    index,
+    score: terms.reduce((score, term) => score + (SEARCH_TEXT[name].includes(term) ? 1 : 0), 0)
+  })).filter((match) => match.score > 0).sort((left, right) => right.score - left.score || left.index - right.index).slice(0, limit).map((match) => match.name);
+}
+function setAvailableTools(pi, availableTools) {
+  const available = new Set(availableTools);
+  availableToolsByApi.set(pi, available);
+  return available;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+
+// src/tool-selector.ts
+import { stripVTControlCharacters } from "node:util";
+function unique2(values) {
+  return Array.from(new Set(values));
+}
+function formatError3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function updateChromeDevtoolsTools(pi, ctx, selectedTools, action) {
+  const generation = state.sessionGeneration;
+  const result = await transactSelectedTools(pi, ctx, selectedTools, generation);
+  if (result !== "saved" || generation !== state.sessionGeneration) return;
+  const status = await buildToolStatusMessage(pi);
+  if (generation !== state.sessionGeneration) return;
+  ctx.ui.notify(`Chrome DevTools lazy catalog ${action}.
+
+${status}`, "info");
+}
+async function setSelectedChromeDevtoolsTools(pi, ctx, selectedTools, expectedActiveTools) {
+  return transactSelectedTools(
+    pi,
+    ctx,
+    selectedTools,
+    state.sessionGeneration,
+    expectedActiveTools
+  );
+}
+var toolTransactionQueue = Promise.resolve();
+async function waitForChromeDevtoolsSettings() {
+  await toolTransactionQueue;
+}
+function transactSelectedTools(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools) {
+  const operation = toolTransactionQueue.then(
+    () => transactSelectedToolsNow(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools)
+  );
+  toolTransactionQueue = operation.then(
+    () => void 0,
+    () => void 0
+  );
+  return operation;
+}
+async function transactSelectedToolsNow(pi, ctx, selectedTools, expectedGeneration, expectedActiveTools) {
+  if (expectedGeneration !== state.sessionGeneration) return "failed";
+  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"
+    );
+    return "active-tools-changed";
+  }
+  const previousActiveTools = pi.getActiveTools();
+  const previousAvailableTools = availableChromeDevtoolsTools(pi);
+  try {
+    applyChromeDevtoolsTools(pi, selectedTools);
+    await persistSettings(selectedTools);
+    return expectedGeneration === state.sessionGeneration ? "saved" : "failed";
+  } catch (error) {
+    let rollbackError;
+    try {
+      applyAvailableChromeDevtoolsTools(pi, previousAvailableTools);
+      const currentNonChromeTools = pi.getActiveTools().filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name));
+      const previousLoadedChromeTools = previousActiveTools.filter(
+        (name) => CHROME_DEVTOOLS_TOOL_NAMES.includes(name)
+      );
+      pi.setActiveTools(unique2([...currentNonChromeTools, ...previousLoadedChromeTools]));
+    } catch (caught) {
+      rollbackError = caught;
+    }
+    if (expectedGeneration !== state.sessionGeneration) return "failed";
+    ctx.ui.notify(
+      sanitizeChromeDevtoolsDisplay(
+        rollbackError ? `Chrome DevTools settings save failed: ${formatError3(error)}; active-tool rollback failed: ${formatError3(rollbackError)}` : `Chrome DevTools settings save failed; active tools restored: ${formatError3(error)}`
+      ),
+      "warning"
+    );
+    return "failed";
+  }
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function applyChromeDevtoolsTools(pi, selectedTools) {
+  applyAvailableChromeDevtoolsTools(pi, selectedTools);
+}
+function getToolStatusSummary(pi) {
+  const chromeToolNames = new Set(CHROME_DEVTOOLS_TOOL_NAMES);
+  const activeToolNames = new Set(pi.getActiveTools());
+  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 !== CHROME_DEVTOOLS_LOAD_TOOL_NAME
+  ).length;
+  const availabilityStatus = availableChromeToolCount === CHROME_DEVTOOLS_TOOL_NAMES.length ? "enabled" : availableChromeToolCount === 0 ? "disabled" : "partial";
+  return {
+    availabilityStatus,
+    availableChromeToolCount,
+    loadedChromeToolCount,
+    activeNonChromeToolCount
+  };
+}
+async function buildToolStatusMessage(pi) {
+  const summary = getToolStatusSummary(pi);
+  const persistedSetting = await persistedSettingLabel();
+  return sanitizeChromeDevtoolsDisplay(
+    [
+      `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}`,
+      `Endpoint: ${devToolsEndpoint()}`,
+      `Endpoint source: ${endpointSourceLabel()}`,
+      `Launch mode: ${launchModeLabel()}`,
+      ...launchAttemptLines()
+    ].join("\n")
+  );
+}
+function buildQuickstartMessage() {
+  return buildSettingsSetupMessage();
+}
+function buildBrowserStatusMessage() {
+  const lifecycle = browserLifecycleState();
+  const browserState = lifecycle === "starting" ? "starting managed browser" : lifecycle === "running" ? "managed browser running" : lifecycle === "exited" ? "managed browser exited" : lifecycle === "failed" ? "last launch failed" : "not started; connection has not been checked";
+  const needsRecovery = lifecycle === "exited" || lifecycle === "failed";
+  return sanitizeChromeDevtoolsDisplay(
+    [
+      `Browser: ${browserState}`,
+      "Viewing this status does not probe the endpoint or launch Chrome.",
+      `Endpoint: ${devToolsEndpoint()}`,
+      `Endpoint source: ${endpointSourceLabel()}`,
+      `Launch mode: ${launchModeLabel()}`,
+      `Unpacked extensions: ${state.extensionPaths.length} (${state.extensionPathsSource})`,
+      ...state.extensionPaths.length > 0 ? ["Unpacked extensions execute trusted browser code in an isolated managed browser."] : [],
+      ...launchAttemptLines(),
+      ...needsRecovery ? [launchHint(), endpointConfigHint()] : []
+    ].join("\n")
+  );
+}
+function buildSettingsSetupMessage() {
+  return sanitizeChromeDevtoolsDisplay(
+    [
+      `Chrome DevTools endpoint: ${devToolsEndpoint()}`,
+      `Endpoint source: ${endpointSourceLabel()}`,
+      `Launch mode: ${launchModeLabel()}`,
+      ...browserSettingsStatusLines(),
+      launchHint(),
+      browserCandidateHint(),
+      ...launchAttemptLines(),
+      endpointConfigHint()
+    ].join("\n")
+  );
+}
+function sanitizeChromeDevtoolsDisplay(value, maxCharacters = 5e4) {
+  const sanitized = Array.from(stripVTControlCharacters(value), (character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    const unsafeControl = codePoint >= 0 && codePoint <= 8 || codePoint >= 11 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159;
+    return unsafeControl ? "\uFFFD" : character;
+  }).join("");
+  if (sanitized.length <= maxCharacters) return sanitized;
+  return `${sanitized.slice(0, Math.max(0, maxCharacters - 1))}\u2026`;
+}
+function browserSettingsStatusLines() {
+  const extensionLines = state.extensionPaths.length > 0 ? state.extensionPaths.map((extensionPath) => `  - ${extensionPath}`) : ["  - none"];
+  return [
+    `Settings file: ${state.settingsFilePath ?? settingsFilePath()} (user)`,
+    ...state.projectSettingsFilePath ? [
+      `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,
+    "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."
+    ] : []
+  ];
+}
+function buildCommandGuide() {
+  return [
+    "Chrome DevTools commands:",
+    "/chrome-devtools \u2014 open this menu",
+    "/chrome-devtools help \u2014 show command usage",
+    "/chrome-devtools quickstart \u2014 show endpoint and launch help",
+    "/chrome-devtools status \u2014 show tool and settings status",
+    "/chrome-devtools settings \u2014 edit browser connection settings",
+    "/chrome-devtools tools \u2014 choose tools available to lazy-load",
+    "/chrome-devtools toggle|select \u2014 compatibility aliases for tools",
+    "/chrome-devtools enable|on \u2014 make all Chrome DevTools tools available to lazy-load",
+    "/chrome-devtools disable|off \u2014 make all Chrome DevTools capability tools unavailable"
+  ].join("\n");
+}
+function allChromeDevtoolsTools() {
+  return [...CHROME_DEVTOOLS_TOOL_NAMES];
+}
+function formatRuntimeStatus(summary) {
+  return `${summary.availabilityStatus} (${summary.availableChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length} available)`;
+}
+async function persistedSettingLabel() {
+  const settings = await loadSettings();
+  if (settings.kind === "loaded" && settings.settings.tools) {
+    return formatPersistedSelection(settings.settings.tools);
+  }
+  if (settings.kind === "invalid") {
+    return `none; current active-tool policy preserved (invalid settings ignored: ${settings.reason})`;
+  }
+  return "none; current active-tool policy preserved";
+}
+function formatPersistedSelection(tools) {
+  if (tools.length === CHROME_DEVTOOLS_TOOL_NAMES.length) {
+    return `all available (${tools.length}/${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(", ")}`;
+}
+async function persistSettings(selectedTools) {
+  await saveSettings({ tools: [...selectedTools], updatedAt: Date.now() });
+}
+
+export {
+  CHROME_DEVTOOLS_TOOL_NAMES,
+  waitForSettingsWrites,
+  loadSettings,
+  parseBrowserEndpoint,
+  saveBrowserSettings,
+  DEFAULT_TIMEOUT_MS,
+  DEFAULT_ENDPOINT_WAIT_MS,
+  state,
+  applyRuntimeBrowserSettings,
+  ensureDevToolsEndpoint,
+  shutdownManagedBrowser,
+  fetchDevToolsJson,
+  withEndpointRetry,
+  devToolsEndpoint,
+  browserLifecycleState,
+  launchModeLabel,
+  launchHint,
+  formatPageListItem,
+  initializeAvailableChromeDevtoolsTools,
+  configureLazyChromeDevtoolsTools,
+  availableChromeDevtoolsTools,
+  createChromeDevtoolsLoadTool,
+  updateChromeDevtoolsTools,
+  setSelectedChromeDevtoolsTools,
+  waitForChromeDevtoolsSettings,
+  buildToolStatusMessage,
+  buildQuickstartMessage,
+  buildBrowserStatusMessage,
+  sanitizeChromeDevtoolsDisplay,
+  buildCommandGuide,
+  allChromeDevtoolsTools
+};
+//# sourceMappingURL=chunk-RM7OGXVL.ts.map