@narumitw/pi-chrome-devtools 0.53.0 → 0.53.1

package/dist/chunks/{chunk-GVBXT3FB.js → chunk-SRT3UUIP.js}

@@ -587,13 +587,34 @@ var DEFAULT_BROWSER_MANAGER_OPERATIONS = {
 };
 var browserManagerOperations = DEFAULT_BROWSER_MANAGER_OPERATIONS;
 var managedBrowserScopes = /* @__PURE__ */ new WeakMap();
+function cloneBrowserSettings(browser) {
+  return { ...browser, extensionPaths: [...browser.extensionPaths] };
+}
+function runtimeBrowserSettings() {
+  return {
+    endpoint: `http://${formatHostForUrl(state.host)}:${state.configuredPort}`,
+    host: state.host,
+    port: state.configuredPort,
+    hostConfigured: state.hostConfigured,
+    portConfigured: state.portConfigured,
+    autoLaunchEnabled: state.autoLaunchEnabled,
+    ...state.browserExecutable ? { executablePath: state.browserExecutable } : {},
+    extensionPaths: [...state.extensionPaths],
+    endpointSource: state.endpointSource,
+    autoLaunchSource: state.autoLaunchSource,
+    executablePathSource: state.browserExecutableSource,
+    extensionPathsSource: state.extensionPathsSource
+  };
+}
 function managedBrowserScope(owner) {
   const existing = managedBrowserScopes.get(owner);
   if (existing) return existing;
+  const browser = runtimeBrowserSettings();
   const created = {
+    browser,
     controller: new AbortController(),
     generation: 0,
-    port: state.configuredPort
+    port: browser.port
   };
   managedBrowserScopes.set(owner, created);
   return created;
@@ -603,9 +624,19 @@ function startManagedBrowserSession(owner) {
   scope.controller.abort(new DOMException("Chrome DevTools session replaced", "AbortError"));
   scope.controller = new AbortController();
   scope.generation += 1;
-  scope.port = state.configuredPort;
   scope.lastLaunchAttempt = void 0;
 }
+function syncManagedBrowserSettings(owner, browser) {
+  const scope = managedBrowserScope(owner);
+  scope.browser = cloneBrowserSettings(browser);
+  scope.port = browser.port;
+}
+function browserSettingsForOwner(owner) {
+  return owner ? managedBrowserScope(owner).browser : runtimeBrowserSettings();
+}
+function managedBrowserExtensionPaths(owner) {
+  return browserSettingsForOwner(owner).extensionPaths;
+}
 function managedBrowserForOwner(owner) {
   if (!owner) return state.managedBrowser;
   const scopedBrowser = managedBrowserScope(owner).managedBrowser;
@@ -626,6 +657,12 @@ function setLaunchPromise(owner, launchPromise) {
 function managedBrowserPort(owner) {
   return owner ? managedBrowserScope(owner).port : state.port;
 }
+function managedBrowserConfiguredPort(owner) {
+  return browserSettingsForOwner(owner).port;
+}
+function managedBrowserPortConfigured(owner) {
+  return browserSettingsForOwner(owner).portConfigured;
+}
 function setManagedBrowserPort(owner, port) {
   if (owner) managedBrowserScope(owner).port = port;
   else state.port = port;
@@ -648,12 +685,12 @@ function normalizePathForComparison(value) {
 }
 async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS, callerSignal, owner) {
   callerSignal?.throwIfAborted();
-  if (extensionsConfigured()) {
-    validateExtensionLaunchMode();
+  if (extensionsConfigured(owner)) {
+    validateExtensionLaunchMode(owner);
     await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
     return;
   }
-  if (canAutoLaunchBrowser()) {
+  if (canAutoLaunchBrowser(owner)) {
     try {
       await withEndpointRetry(
         () => fetchDevToolsJson("/json/version", { signal: callerSignal }, owner),
@@ -662,7 +699,7 @@ async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS, callerS
       );
       return;
     } catch (error) {
-      if (shouldAutoLaunchAfterEndpointError(error)) {
+      if (shouldAutoLaunchAfterEndpointError(error, owner)) {
         await ensureManagedBrowserLaunched(waitMs, callerSignal, owner);
         return;
       }
@@ -676,18 +713,19 @@ async function ensureDevToolsEndpoint(waitMs = DEFAULT_ENDPOINT_WAIT_MS, callerS
     throw error;
   }
 }
-function validateExtensionLaunchMode() {
-  if (!isLocalDevToolsHost(state.host)) {
+function validateExtensionLaunchMode(owner) {
+  const browser = browserSettingsForOwner(owner);
+  if (!isLocalDevToolsHost(browser.host)) {
     throw new DevToolsEndpointError(
       "Unpacked extensions require a local extension-owned managed browser; remote CDP endpoints cannot be modified."
     );
   }
-  if (!state.autoLaunchEnabled) {
+  if (!browser.autoLaunchEnabled) {
     throw new DevToolsEndpointError(
       "Auto-launch is required for unpacked extensions so Pi can create an isolated managed browser."
     );
   }
-  if (!state.browserExecutable) {
+  if (!browser.executablePath) {
     throw new DevToolsEndpointError(
       "Unpacked extensions require browser.executablePath for Chrome for Testing or Chromium in pi-chrome-devtools.json."
     );
@@ -736,9 +774,9 @@ async function prepareManagedBrowserLaunch(waitMs, generation, signal, owner) {
     await shutdownManagedBrowser(existingBrowser, { awaitLaunch: false, owner });
     throwIfBrowserLaunchCancelled(generation, signal, owner);
   }
-  if (state.portConfigured) {
+  if (managedBrowserPortConfigured(owner)) {
     const available = await browserManagerOperations.isPortAvailable(
-      state.host,
+      browserSettingsForOwner(owner).host,
       managedBrowserPort(owner)
     );
     throwIfBrowserLaunchCancelled(generation, signal, owner);
@@ -752,7 +790,7 @@ async function prepareManagedBrowserLaunch(waitMs, generation, signal, owner) {
 }
 async function launchManagedBrowser(waitMs, generation, signal, owner) {
   throwIfBrowserLaunchCancelled(generation, signal, owner);
-  const candidateDefinitions = browserCandidateDefinitions();
+  const candidateDefinitions = browserCandidateDefinitions(owner);
   const candidates = await resolveBrowserCandidates(
     candidateDefinitions,
     generation,
@@ -762,23 +800,23 @@ async function launchManagedBrowser(waitMs, generation, signal, owner) {
   throwIfBrowserLaunchCancelled(generation, signal, owner);
   setLastLaunchAttempt(owner, {
     candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-    mode: state.portConfigured ? "explicit-port" : "dynamic-port"
+    mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port"
   });
   if (candidates.length === 0) {
-    throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions));
+    throw new DevToolsEndpointError(noBrowserCandidateMessage(candidateDefinitions, owner));
   }
   let lastError;
   for (const candidate of candidates) {
     throwIfBrowserLaunchCancelled(generation, signal, owner);
     try {
-      if (extensionsConfigured())
+      if (extensionsConfigured(owner))
         await requireSupportedExtensionBrowser(candidate, generation, signal, owner);
       await launchBrowserCandidate(candidate, waitMs, generation, signal, owner);
       throwIfBrowserLaunchCancelled(generation, signal, owner);
       setLastLaunchAttempt(owner, {
         ...lastLaunchAttempt(owner),
         candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-        mode: state.portConfigured ? "explicit-port" : "dynamic-port",
+        mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port",
         selectedCandidate: formatBrowserCandidate(candidate),
         userDataDir: managedBrowserForOwner(owner)?.userDataDir
       });
@@ -790,7 +828,7 @@ async function launchManagedBrowser(waitMs, generation, signal, owner) {
         setLastLaunchAttempt(owner, {
           ...lastLaunchAttempt(owner) ?? {
             candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-            mode: state.portConfigured ? "explicit-port" : "dynamic-port"
+            mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port"
           },
           lastError: formatError2(cancellation)
         });
@@ -800,19 +838,19 @@ async function launchManagedBrowser(waitMs, generation, signal, owner) {
       setLastLaunchAttempt(owner, {
         ...lastLaunchAttempt(owner) ?? {
           candidateLabels: candidateDefinitions.map(formatBrowserCandidateDefinition),
-          mode: state.portConfigured ? "explicit-port" : "dynamic-port"
+          mode: managedBrowserPortConfigured(owner) ? "explicit-port" : "dynamic-port"
         },
         lastError: formatError2(error)
       });
     }
   }
-  if (lastError instanceof DevToolsEndpointError && extensionsConfigured()) throw lastError;
+  if (lastError instanceof DevToolsEndpointError && extensionsConfigured(owner)) throw lastError;
   throw new DevToolsEndpointError(
     [
       "Unable to auto-launch a Chromium-family browser for Chrome DevTools.",
       `Tried: ${candidates.map(formatBrowserCandidate).join(", ")}`,
       lastError ? `Last error: ${formatError2(lastError)}` : void 0,
-      launchHint(),
+      launchHint(owner),
       endpointConfigHint()
     ].filter(Boolean).join("\n")
   );
@@ -851,11 +889,11 @@ async function launchBrowserCandidate(candidate, waitMs, generation, signal, own
   let managedBrowser;
   try {
     throwIfBrowserLaunchCancelled(generation, signal, owner);
-    const portArgument = state.portConfigured ? String(managedBrowserPort(owner)) : "0";
+    const portArgument = managedBrowserPortConfigured(owner) ? String(managedBrowserPort(owner)) : "0";
     const args = buildManagedBrowserLaunchArguments(
       userDataDir,
       portArgument,
-      state.extensionPaths
+      managedBrowserExtensionPaths(owner)
     );
     const child = browserManagerOperations.spawn(candidate.resolvedExecutable, args, {
       shell: false,
@@ -877,13 +915,13 @@ async function launchBrowserCandidate(candidate, waitMs, generation, signal, own
       }
       launchedBrowser.exited = true;
       launchedBrowser.ready = false;
-      if (!state.portConfigured && launchedBrowser.port === managedBrowserPort(owner)) {
-        setManagedBrowserPort(owner, state.configuredPort);
+      if (!managedBrowserPortConfigured(owner) && launchedBrowser.port === managedBrowserPort(owner)) {
+        setManagedBrowserPort(owner, managedBrowserConfiguredPort(owner));
       }
     });
     await waitForBrowserSpawn(child);
     throwIfBrowserLaunchCancelled(generation, signal, owner);
-    if (state.portConfigured) {
+    if (managedBrowserPortConfigured(owner)) {
       launchedBrowser.port = managedBrowserPort(owner);
     } else {
       launchedBrowser.port = await readManagedBrowserPort(
@@ -958,7 +996,7 @@ async function readManagedBrowserPort(userDataDir, managedBrowser, waitMs, gener
         [
           "Timed out waiting for auto-launched browser DevToolsActivePort.",
           `Expected file: ${activePortFile}`,
-          launchHint()
+          launchHint(owner)
         ].join("\n")
       );
     }
@@ -982,7 +1020,7 @@ async function waitForDevToolsEndpoint(waitMs, managedBrowser, generation, signa
       throw new DevToolsEndpointError(
         [
           `Timed out waiting for auto-launched browser at ${devToolsEndpoint(owner)}.`,
-          launchHint()
+          launchHint(owner)
         ].join("\n")
       );
     }
@@ -1041,8 +1079,8 @@ async function cleanupManagedBrowser(managedBrowser, owner) {
     });
   }
   await browserManagerOperations.rm(managedBrowser.userDataDir, { recursive: true, force: true }).catch(() => void 0);
-  if (!state.portConfigured && managedBrowser.port === managedBrowserPort(owner)) {
-    setManagedBrowserPort(owner, state.configuredPort);
+  if (!managedBrowserPortConfigured(owner) && managedBrowser.port === managedBrowserPort(owner)) {
+    setManagedBrowserPort(owner, managedBrowserConfiguredPort(owner));
   }
 }
 function killManagedBrowserProcess(managedBrowser, signal) {
@@ -1132,22 +1170,23 @@ function isRetryableEndpointError(error) {
 function isLaunchableEndpointError(error) {
   return error instanceof DevToolsEndpointError && error.launchable;
 }
-function shouldAutoLaunchAfterEndpointError(error) {
-  if (!canAutoLaunchBrowser()) return false;
+function shouldAutoLaunchAfterEndpointError(error, owner) {
+  if (!canAutoLaunchBrowser(owner)) return false;
   if (isLaunchableEndpointError(error)) return true;
-  return !state.portConfigured && error instanceof DevToolsEndpointError;
+  return !managedBrowserPortConfigured(owner) && error instanceof DevToolsEndpointError;
 }
-function canAutoLaunchBrowser() {
-  return state.autoLaunchEnabled && isLocalDevToolsHost(state.host);
+function canAutoLaunchBrowser(owner) {
+  const browser = browserSettingsForOwner(owner);
+  return browser.autoLaunchEnabled && isLocalDevToolsHost(browser.host);
 }
-function extensionsConfigured() {
-  return state.extensionPaths.length > 0;
+function extensionsConfigured(owner) {
+  return managedBrowserExtensionPaths(owner).length > 0;
 }
 function endpointConnectionErrorMessage(error, owner) {
   const reason = isTimeoutError(error) ? "request timed out" : "connection failed";
   return [
     `Cannot connect to Chrome DevTools endpoint at ${devToolsEndpoint(owner)} (${reason}).`,
-    launchHint(),
+    launchHint(owner),
     endpointConfigHint()
   ].join("\n");
 }
@@ -1155,14 +1194,14 @@ function isTimeoutError(error) {
   return error instanceof Error && ["AbortError", "TimeoutError"].includes(error.name);
 }
 function devToolsEndpoint(owner) {
-  return `http://${formatHostForUrl(state.host)}:${managedBrowserPort(owner)}`;
+  return `http://${formatHostForUrl(browserSettingsForOwner(owner).host)}:${managedBrowserPort(owner)}`;
 }
 function formatHostForUrl(host) {
   if (host.startsWith("[") && host.endsWith("]")) return host;
   return host.includes(":") ? `[${host}]` : host;
 }
-function endpointSourceLabel() {
-  return state.endpointSource;
+function endpointSourceLabel(owner) {
+  return browserSettingsForOwner(owner).endpointSource;
 }
 function browserLifecycleState(owner) {
   if (launchPromiseForOwner(owner)) return "starting";
@@ -1172,21 +1211,22 @@ function browserLifecycleState(owner) {
   return "unobserved";
 }
 function launchModeLabel(owner) {
+  const browser = browserSettingsForOwner(owner);
   const managedBrowser = managedBrowserForOwner(owner);
-  if (extensionsConfigured()) {
-    if (!isLocalDevToolsHost(state.host)) return "invalid; extensions require a local endpoint";
-    if (!state.autoLaunchEnabled) return "invalid; extensions require auto-launch";
+  if (extensionsConfigured(owner)) {
+    if (!isLocalDevToolsHost(browser.host)) return "invalid; extensions require a local endpoint";
+    if (!browser.autoLaunchEnabled) return "invalid; extensions require auto-launch";
     if (managedBrowser && !managedBrowser.exited) {
-      return state.portConfigured ? "extension-owned browser on explicit port" : "extension-owned browser on dynamic port";
+      return managedBrowserPortConfigured(owner) ? "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";
+    return managedBrowserPortConfigured(owner) ? "force extension-owned launch on explicit port" : "force extension-owned launch on dynamic port";
   }
-  if (!isLocalDevToolsHost(state.host)) return "manual remote endpoint";
-  if (!state.autoLaunchEnabled) return "manual; auto-launch disabled";
+  if (!isLocalDevToolsHost(browser.host)) return "manual remote endpoint";
+  if (!browser.autoLaunchEnabled) return "manual; auto-launch disabled";
   if (managedBrowser && !managedBrowser.exited) {
-    return state.portConfigured ? "auto-launched on explicit port" : "auto-launched on dynamic port";
+    return managedBrowserPortConfigured(owner) ? "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";
+  return managedBrowserPortConfigured(owner) ? "attach first; auto-launch explicit port" : "attach first; auto-launch dynamic port";
 }
 function launchAttemptLines(owner) {
   const attempt = lastLaunchAttempt(owner);
@@ -1201,29 +1241,30 @@ function launchAttemptLines(owner) {
   if (attempt.lastError) lines.push(`Last launch error: ${attempt.lastError}`);
   return lines;
 }
-function launchHint() {
-  if (extensionsConfigured()) {
+function launchHint(owner) {
+  const browser = browserSettingsForOwner(owner);
+  if (extensionsConfigured(owner)) {
     return "Configured unpacked extensions force an isolated extension-owned launch; existing CDP browsers are never reused, modified, or closed.";
   }
-  if (!isLocalDevToolsHost(state.host)) {
-    return `Remote/non-local endpoints are not auto-launched. Start a browser with CDP enabled at ${devToolsEndpoint()}.`;
+  if (!isLocalDevToolsHost(browser.host)) {
+    return `Remote/non-local endpoints are not auto-launched. Start a browser with CDP enabled at ${devToolsEndpoint(owner)}.`;
   }
-  if (!state.autoLaunchEnabled) {
-    return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand()}`;
+  if (!browser.autoLaunchEnabled) {
+    return `Auto-launch is disabled. Start a browser manually: ${chromeLaunchCommand(owner)}`;
   }
-  const managedMode = state.portConfigured ? `port ${state.port}` : "a dynamic DevTools port";
-  return `If no endpoint is available, Pi will auto-launch a Chromium-family browser with ${managedMode} and an isolated temp profile. Manual command: ${chromeLaunchCommand()}`;
+  const managedMode = managedBrowserPortConfigured(owner) ? `port ${managedBrowserPort(owner)}` : "a dynamic DevTools port";
+  return `If no endpoint is available, Pi will auto-launch a Chromium-family browser with ${managedMode} and an isolated temp profile. Manual command: ${chromeLaunchCommand(owner)}`;
 }
-function browserCandidateHint() {
-  if (extensionsConfigured()) {
+function browserCandidateHint(owner) {
+  if (extensionsConfigured(owner)) {
     return "Extension browser requirement: configure Chrome for Testing or Chromium with browser.executablePath; branded Chrome is rejected because it may ignore unpacked-extension flags.";
   }
-  return `Browser candidates: ${browserCandidateDefinitions().map((candidate) => candidate.label).join(", ")}`;
+  return `Browser candidates: ${browserCandidateDefinitions(owner).map((candidate) => candidate.label).join(", ")}`;
 }
-function chromeLaunchCommand() {
-  const executable = state.browserExecutable ?? defaultManualBrowserExecutable();
+function chromeLaunchCommand(owner) {
+  const executable = browserSettingsForOwner(owner).executablePath ?? defaultManualBrowserExecutable();
   const dataDir = process.platform === "win32" ? "%TEMP%\\pi-chrome-devtools" : "/tmp/pi-chrome-devtools";
-  return `${quoteCommandPart(executable)} --remote-debugging-port=${state.port} --user-data-dir=${dataDir}`;
+  return `${quoteCommandPart(executable)} --remote-debugging-port=${managedBrowserPort(owner)} --user-data-dir=${dataDir}`;
 }
 function defaultManualBrowserExecutable() {
   return process.platform === "darwin" ? "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" : process.platform === "win32" ? "chrome.exe" : "google-chrome";
@@ -1238,17 +1279,18 @@ 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();
+function browserCandidateDefinitions(owner) {
+  const explicitCandidate = explicitBrowserCandidateDefinition(owner);
   if (explicitCandidate.length > 0) return explicitCandidate;
   return uniqueBrowserCandidates(platformBrowserCandidateDefinitions());
 }
-function explicitBrowserCandidateDefinition() {
-  if (!state.browserExecutable) return [];
+function explicitBrowserCandidateDefinition(owner) {
+  const browser = browserSettingsForOwner(owner);
+  if (!browser.executablePath) return [];
   return [
     {
-      label: state.browserExecutableSource === "environment" ? "PI_CHROME_DEVTOOLS_BROWSER" : "browser.executablePath",
-      executable: state.browserExecutable,
+      label: browser.executablePathSource === "environment" ? "PI_CHROME_DEVTOOLS_BROWSER" : "browser.executablePath",
+      executable: browser.executablePath,
       source: "env"
     }
   ];
@@ -1393,8 +1435,8 @@ function formatBrowserCandidate(candidate) {
 function formatBrowserCandidateDefinition(candidate) {
   return `${candidate.label} (${candidate.executable})`;
 }
-function noBrowserCandidateMessage(candidateDefinitions) {
-  if (extensionsConfigured()) {
+function noBrowserCandidateMessage(candidateDefinitions, owner) {
+  if (extensionsConfigured(owner)) {
     return [
       "Cannot launch unpacked extensions because the configured browser executable was not found or is not executable.",
       `Tried: ${candidateDefinitions.map(formatBrowserCandidateDefinition).join(", ")}`,
@@ -1497,6 +1539,8 @@ export {
   webMcpOperationIsCurrent,
   applyRuntimeBrowserSettings,
   startManagedBrowserSession,
+  syncManagedBrowserSettings,
+  browserSettingsForOwner,
   managedBrowserForOwner,
   ensureDevToolsEndpoint,
   shutdownManagedBrowser,
@@ -1512,4 +1556,4 @@ export {
   endpointConfigHint,
   formatPageListItem
 };
-//# sourceMappingURL=chunk-GVBXT3FB.js.map
+//# sourceMappingURL=chunk-SRT3UUIP.js.map