@narumitw/pi-chrome-devtools 0.53.4 → 0.54.1

package/src/browser-startup.ts

@@ -0,0 +1,122 @@
+import type { ChildProcess } from "node:child_process";
+import type { EventEmitter } from "node:events";
+
+const MAX_STARTUP_STDERR_BYTES = 64 * 1024;
+
+function handleErrorsUntilClose(emitter: EventEmitter) {
+  // Cancellation or readiness can settle before an already queued process/pipe error.
+  // Keep the resource safe until close, then remove this lifetime-only handler.
+  const ignoreError = () => undefined;
+  emitter.on("error", ignoreError);
+  emitter.once("close", () => emitter.off("error", ignoreError));
+}
+
+export function browserWebSocketIdentity(value: unknown, port: number): string | undefined {
+  if (typeof value !== "string") return undefined;
+  try {
+    const url = new URL(value);
+    if (
+      url.protocol !== "ws:" ||
+      !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) ||
+      Number(url.port || "80") !== port ||
+      url.username ||
+      url.password ||
+      url.search ||
+      url.hash ||
+      !/^\/devtools\/browser\/[^/]+$/.test(url.pathname)
+    ) {
+      return undefined;
+    }
+    return url.pathname;
+  } catch {
+    return undefined;
+  }
+}
+
+// A free-port probe cannot reserve the port through Chrome's startup. Use the owned child's
+// announcement, not an arbitrary responding HTTP server, as the browser identity authority.
+export function waitForBrowserStartup(
+  child: ChildProcess,
+  port: number,
+  waitMs: number,
+  signal: AbortSignal,
+): Promise<string> {
+  handleErrorsUntilClose(child);
+  const stderr = child.stderr;
+  if (stderr && !stderr.closed) handleErrorsUntilClose(stderr);
+  signal.throwIfAborted();
+  if (!stderr) return Promise.reject(new Error("Auto-launched browser has no startup stderr stream."));
+
+  return new Promise<string>((resolve, reject) => {
+    let spawned = false;
+    let identity: string | undefined;
+    let receivedBytes = 0;
+    let pendingLine = "";
+    let settled = false;
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+
+    const settle = (error?: Error) => {
+      if (settled) return;
+      if (!error && (!spawned || !identity)) return;
+      settled = true;
+      clearTimeout(timeout);
+      child.off("spawn", onSpawn);
+      child.off("error", onError);
+      child.off("exit", onExit);
+      child.off("close", onExit);
+      stderr.off("data", onData);
+      stderr.off("end", onEnd);
+      stderr.off("error", onError);
+      signal.removeEventListener("abort", onAbort);
+      // Keep the pipe drained after startup without retaining or displaying browser logs.
+      stderr.resume();
+      if (error) reject(error);
+      else resolve(identity as string);
+    };
+    const onError = (error: Error) => settle(error);
+    const onAbort = () => settle(new Error("Chrome DevTools browser startup cancelled.", { cause: signal.reason }));
+    const onExit = () => settle(new Error("Auto-launched browser exited before DevTools became available."));
+    const onSpawn = () => {
+      spawned = true;
+      timeout = setTimeout(
+        () => settle(new Error("Timed out waiting for auto-launched browser DevTools startup announcement.")),
+        waitMs,
+      );
+      settle();
+    };
+    const inspectLine = (line: string) => {
+      const match = /^DevTools listening on (\S+)$/.exec(line.trim());
+      if (!match) return;
+      identity = browserWebSocketIdentity(match[1], port);
+      if (!identity) settle(new Error("Auto-launched browser announced an unexpected DevTools endpoint."));
+      else settle();
+    };
+    const onData = (data: Buffer | string) => {
+      receivedBytes += Buffer.byteLength(data);
+      if (receivedBytes > MAX_STARTUP_STDERR_BYTES) {
+        settle(new Error("Auto-launched browser startup stderr exceeded 64 KB before readiness."));
+        return;
+      }
+      pendingLine += data.toString();
+      const lines = pendingLine.split("\n");
+      pendingLine = lines.pop() ?? "";
+      for (const line of lines) {
+        inspectLine(line);
+        if (settled) break;
+      }
+    };
+    const onEnd = () => {
+      inspectLine(pendingLine);
+      if (!identity) settle(new Error("Auto-launched browser closed stderr before its DevTools startup announcement."));
+    };
+
+    child.once("spawn", onSpawn);
+    child.once("error", onError);
+    child.once("exit", onExit);
+    child.once("close", onExit);
+    stderr.on("data", onData);
+    stderr.once("end", onEnd);
+    stderr.once("error", onError);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}

package/src/chrome-devtools.ts

@@ -3,9 +3,11 @@ import { shutdownManagedBrowser, startManagedBrowserSession, syncManagedBrowserS
 import { setActivePageId } from "./cdp-client.js";
 import {
   availableChromeDevtoolsTools,
+  chromeDevtoolsToolMode,
   configureChromeDevtoolsToolExposure,
-  createChromeDevtoolsLoadTool,
   initializeAvailableChromeDevtoolsTools,
+  previousChromeDevtoolsTools,
+  registerChromeDevtoolsCapabilities,
   requireEagerChromeDevtoolsToolExposure,
   setChromeDevtoolsSessionOwner,
   supportsNativeDeferredToolLoading,
@@ -55,14 +57,15 @@ const COMMAND_COMPLETIONS = [
   { value: "off", label: "off", description: "Compatibility alias for disable" },
 ];
 export default function chromeDevtools(pi: ExtensionAPI) {
-  pi.registerTool(listPagesTool);
-  pi.registerTool(selectPageTool);
-  pi.registerTool(navigateTool);
-  pi.registerTool(evaluateTool);
-  pi.registerTool(screenshotTool);
-  pi.registerTool(webMcpListToolsTool);
-  pi.registerTool(webMcpCallTool);
-  pi.registerTool(createChromeDevtoolsLoadTool(pi));
+  registerChromeDevtoolsCapabilities(pi, [
+    listPagesTool,
+    selectPageTool,
+    navigateTool,
+    evaluateTool,
+    screenshotTool,
+    webMcpListToolsTool,
+    webMcpCallTool,
+  ]);
 
   pi.registerCommand("chrome-devtools", {
     description: "Open Chrome DevTools help and tool controls",
@@ -77,7 +80,11 @@ export default function chromeDevtools(pi: ExtensionAPI) {
 
   pi.on("session_start", async (_event, ctx) => {
     const generation = ++state.sessionGeneration;
-    setChromeDevtoolsSessionOwner(pi, ctx.sessionManager);
+    setChromeDevtoolsSessionOwner(pi, ctx.sessionManager, ctx.sessionManager.getBranch());
+    // Capture before default initialization: unknown invalid files must not
+    // broaden availability, while a restored/current policy survives reload.
+    const previousAvailableTools = previousChromeDevtoolsTools(pi);
+    const previousMode = chromeDevtoolsToolMode(pi);
     initializeAvailableChromeDevtoolsTools(pi);
     setWebMcpSessionOwner(ctx.sessionManager);
     replaceSessionController("Chrome DevTools session replaced");
@@ -95,6 +102,8 @@ export default function chromeDevtools(pi: ExtensionAPI) {
     state.activePageId = undefined;
     state.lastLaunchAttempt = undefined;
     const projectTrusted = ctx.isProjectTrusted();
+    await waitForChromeDevtoolsSettings();
+    if (generation !== state.sessionGeneration) return;
     const settings = await loadSettings({ cwd: ctx.cwd, projectTrusted });
     if (generation !== state.sessionGeneration) return;
     applyRuntimeBrowserSettings(settings.effectiveBrowser, settings.paths, projectTrusted);
@@ -110,17 +119,41 @@ export default function chromeDevtools(pi: ExtensionAPI) {
         "warning",
       );
     }
-    const availableTools =
-      settings.kind === "loaded" && settings.settings.tools
+    // Tool mode/catalog are user-owned; a valid project browser section can
+    // make the aggregate result loaded even when its user source is invalid.
+    const preserveToolPolicy = settings.userFile.kind === "invalid";
+    const availableTools = preserveToolPolicy
+      ? previousAvailableTools
+      : settings.kind === "loaded" && settings.settings.tools
         ? settings.settings.tools
-        : availableChromeDevtoolsTools(pi);
-    configureChromeDevtoolsToolExposure(pi, availableTools, ctx.model);
+        : allChromeDevtoolsTools(ctx.sessionManager);
+    const provenanceWarning = configureChromeDevtoolsToolExposure(
+      pi,
+      availableTools,
+      ctx.model,
+      preserveToolPolicy ? previousMode : settings.kind === "loaded" ? settings.settings.toolMode : "codemode",
+    );
+    if (generation !== state.sessionGeneration) return;
+    if (provenanceWarning) ctx.ui.notify(provenanceWarning, "warning");
+    const active = new Set(pi.getActiveTools());
+    if (
+      chromeDevtoolsToolMode(pi) === "codemode" &&
+      !active.has("codemode") &&
+      availableChromeDevtoolsTools(pi).some((name) => !active.has(name))
+    ) {
+      ctx.ui.notify(
+        "Chrome DevTools capabilities require Pi's codemode tool, but it is not active. Add '+codemode' to defaultTools and reload, or choose direct/lazy mode in Chrome DevTools settings. Chrome DevTools does not activate host tools automatically.",
+        "warning",
+      );
+    }
   });
 
   pi.on("model_select", (event, ctx) => {
+    const generation = state.sessionGeneration;
     invalidateWebMcpOperations(ctx.sessionManager, "Chrome DevTools model and tool exposure changed");
     if (!supportsNativeDeferredToolLoading(event.model)) {
-      requireEagerChromeDevtoolsToolExposure(pi);
+      const provenanceWarning = requireEagerChromeDevtoolsToolExposure(pi);
+      if (generation === state.sessionGeneration && provenanceWarning) ctx.ui.notify(provenanceWarning, "warning");
     }
   });