browserclaw 0.5.6 → 0.5.7

package/dist/index.js

@@ -4,6 +4,8 @@ import fs from 'fs';
 import net from 'net';
 import { spawn, execFileSync } from 'child_process';
 import { devices, chromium } from 'playwright-core';
+import http from 'http';
+import https from 'https';
 import { lookup as lookup$1 } from 'dns/promises';
 import { lookup } from 'dns';
 import { realpath, rename, rm, lstat } from 'fs/promises';
@@ -1164,6 +1166,9 @@ function isWebSocketUrl(url) {
 function isLoopbackHost(hostname) {
   return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
 }
+function hasProxyEnvConfigured() {
+  return !!(process.env.HTTP_PROXY || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.https_proxy);
+}
 function normalizeCdpWsUrl(wsUrl, cdpUrl) {
   const ws = new URL(wsUrl);
   const cdp = new URL(cdpUrl);
@@ -1425,8 +1430,81 @@ async function stopChrome(running, timeoutMs = 2500) {
   } catch {
   }
 }
-var cached = null;
-var connectingByUrl = /* @__PURE__ */ new Map();
+var LOOPBACK_ENTRIES = "localhost,127.0.0.1,[::1]";
+function noProxyAlreadyCoversLocalhost() {
+  const current = process.env.NO_PROXY || process.env.no_proxy || "";
+  return current.includes("localhost") && current.includes("127.0.0.1") && current.includes("[::1]");
+}
+function isLoopbackCdpUrl(url) {
+  try {
+    return isLoopbackHost(new URL(url).hostname);
+  } catch {
+    return false;
+  }
+}
+var NoProxyLeaseManager = class {
+  leaseCount = 0;
+  snapshot = null;
+  acquire(url) {
+    if (!isLoopbackCdpUrl(url) || !hasProxyEnvConfigured()) return null;
+    if (this.leaseCount === 0 && !noProxyAlreadyCoversLocalhost()) {
+      const noProxy = process.env.NO_PROXY;
+      const noProxyLower = process.env.no_proxy;
+      const current = noProxy || noProxyLower || "";
+      const applied = current ? `${current},${LOOPBACK_ENTRIES}` : LOOPBACK_ENTRIES;
+      process.env.NO_PROXY = applied;
+      process.env.no_proxy = applied;
+      this.snapshot = { noProxy, noProxyLower, applied };
+    }
+    this.leaseCount += 1;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.release();
+    };
+  }
+  release() {
+    if (this.leaseCount <= 0) return;
+    this.leaseCount -= 1;
+    if (this.leaseCount > 0 || !this.snapshot) return;
+    const { noProxy, noProxyLower, applied } = this.snapshot;
+    const currentNoProxy = process.env.NO_PROXY;
+    const currentNoProxyLower = process.env.no_proxy;
+    if (currentNoProxy === applied && (currentNoProxyLower === applied || currentNoProxyLower === void 0)) {
+      if (noProxy !== void 0) process.env.NO_PROXY = noProxy;
+      else delete process.env.NO_PROXY;
+      if (noProxyLower !== void 0) process.env.no_proxy = noProxyLower;
+      else delete process.env.no_proxy;
+    }
+    this.snapshot = null;
+  }
+};
+var noProxyLeaseManager = new NoProxyLeaseManager();
+async function withNoProxyForCdpUrl(url, fn) {
+  const release = noProxyLeaseManager.acquire(url);
+  try {
+    return await fn();
+  } finally {
+    release?.();
+  }
+}
+new http.Agent();
+new https.Agent();
+function getHeadersWithAuth(endpoint, baseHeaders = {}) {
+  const headers = { ...baseHeaders };
+  try {
+    const parsed = new URL(endpoint);
+    if (parsed.username && parsed.password) {
+      const credentials = Buffer.from(`${decodeURIComponent(parsed.username)}:${decodeURIComponent(parsed.password)}`).toString("base64");
+      headers["Authorization"] = `Basic ${credentials}`;
+    }
+  } catch {
+  }
+  return headers;
+}
+var cachedByCdpUrl = /* @__PURE__ */ new Map();
+var connectingByCdpUrl = /* @__PURE__ */ new Map();
 var pageStates = /* @__PURE__ */ new WeakMap();
 var contextStates = /* @__PURE__ */ new WeakMap();
 var observedContexts = /* @__PURE__ */ new WeakSet();
@@ -1464,6 +1542,13 @@ function normalizeCdpUrl(raw) {
 function roleRefsKey(cdpUrl, targetId) {
   return `${normalizeCdpUrl(cdpUrl)}::${targetId}`;
 }
+function findNetworkRequestById(state, id) {
+  for (let i = state.requests.length - 1; i >= 0; i--) {
+    const candidate = state.requests[i];
+    if (candidate && candidate.id === id) return candidate;
+  }
+  return void 0;
+}
 function ensurePageState(page) {
   const existing = pageStates.get(page);
   if (existing) return existing;
@@ -1515,25 +1600,19 @@ function ensurePageState(page) {
       const req = resp.request();
       const id = state.requestIds.get(req);
       if (!id) return;
-      for (let i = state.requests.length - 1; i >= 0; i--) {
-        const rec = state.requests[i];
-        if (rec && rec.id === id) {
-          rec.status = resp.status();
-          rec.ok = resp.ok();
-          break;
-        }
+      const rec = findNetworkRequestById(state, id);
+      if (rec) {
+        rec.status = resp.status();
+        rec.ok = resp.ok();
       }
     });
     page.on("requestfailed", (req) => {
       const id = state.requestIds.get(req);
       if (!id) return;
-      for (let i = state.requests.length - 1; i >= 0; i--) {
-        const rec = state.requests[i];
-        if (rec && rec.id === id) {
-          rec.failureText = req.failure()?.errorText;
-          rec.ok = false;
-          break;
-        }
+      const rec = findNetworkRequestById(state, id);
+      if (rec) {
+        rec.failureText = req.failure()?.errorText;
+        rec.ok = false;
       }
     });
     page.on("close", () => {
@@ -1568,12 +1647,8 @@ function observeContext(context) {
 function observeBrowser(browser) {
   for (const context of browser.contexts()) observeContext(context);
 }
-function storeRoleRefsForTarget(opts) {
-  const state = ensurePageState(opts.page);
-  state.roleRefs = opts.refs;
-  state.roleRefsFrameSelector = opts.frameSelector;
-  state.roleRefsMode = opts.mode;
-  const targetId = opts.targetId?.trim();
+function rememberRoleRefsForTarget(opts) {
+  const targetId = opts.targetId.trim();
   if (!targetId) return;
   roleRefsByTarget.set(roleRefsKey(opts.cdpUrl, targetId), {
     refs: opts.refs,
@@ -1586,6 +1661,20 @@ function storeRoleRefsForTarget(opts) {
     roleRefsByTarget.delete(first.value);
   }
 }
+function storeRoleRefsForTarget(opts) {
+  const state = ensurePageState(opts.page);
+  state.roleRefs = opts.refs;
+  state.roleRefsFrameSelector = opts.frameSelector;
+  state.roleRefsMode = opts.mode;
+  if (!opts.targetId?.trim()) return;
+  rememberRoleRefsForTarget({
+    cdpUrl: opts.cdpUrl,
+    targetId: opts.targetId,
+    refs: opts.refs,
+    frameSelector: opts.frameSelector,
+    mode: opts.mode
+  });
+}
 function restoreRoleRefsForTarget(opts) {
   const targetId = opts.targetId?.trim() || "";
   if (!targetId) return;
@@ -1599,8 +1688,9 @@ function restoreRoleRefsForTarget(opts) {
 }
 async function connectBrowser(cdpUrl, authToken) {
   const normalized = normalizeCdpUrl(cdpUrl);
-  if (cached?.cdpUrl === normalized) return cached;
-  const existing = connectingByUrl.get(normalized);
+  const existing_cached = cachedByCdpUrl.get(normalized);
+  if (existing_cached) return existing_cached;
+  const existing = connectingByCdpUrl.get(normalized);
   if (existing) return await existing;
   const connectWithRetry = async () => {
     let lastErr;
@@ -1608,17 +1698,17 @@ async function connectBrowser(cdpUrl, authToken) {
       try {
         const timeout = 5e3 + attempt * 2e3;
         const endpoint = await getChromeWebSocketUrl(normalized, timeout, authToken).catch(() => null) ?? normalized;
-        const headers = {};
-        if (authToken) headers["Authorization"] = `Bearer ${authToken}`;
-        const browser = await chromium.connectOverCDP(endpoint, { timeout, headers });
+        const headers = getHeadersWithAuth(endpoint);
+        if (authToken && !headers["Authorization"]) headers["Authorization"] = `Bearer ${authToken}`;
+        const browser = await withNoProxyForCdpUrl(endpoint, () => chromium.connectOverCDP(endpoint, { timeout, headers }));
         const onDisconnected = () => {
-          if (cached?.browser === browser) cached = null;
+          if (cachedByCdpUrl.get(normalized)?.browser === browser) cachedByCdpUrl.delete(normalized);
           for (const key of roleRefsByTarget.keys()) {
             if (key.startsWith(normalized + "::")) roleRefsByTarget.delete(key);
           }
         };
-        const connected = { browser, cdpUrl: normalized, authToken, onDisconnected };
-        cached = connected;
+        const connected = { browser, cdpUrl: normalized, onDisconnected };
+        cachedByCdpUrl.set(normalized, connected);
         observeBrowser(browser);
         browser.on("disconnected", onDisconnected);
         return connected;
@@ -1631,24 +1721,25 @@ async function connectBrowser(cdpUrl, authToken) {
     throw lastErr instanceof Error ? lastErr : new Error("CDP connect failed");
   };
   const promise = connectWithRetry().finally(() => {
-    connectingByUrl.delete(normalized);
+    connectingByCdpUrl.delete(normalized);
   });
-  connectingByUrl.set(normalized, promise);
+  connectingByCdpUrl.set(normalized, promise);
   return await promise;
 }
 async function disconnectBrowser() {
-  if (connectingByUrl.size) {
-    for (const p of connectingByUrl.values()) {
+  if (connectingByCdpUrl.size) {
+    for (const p of connectingByCdpUrl.values()) {
       try {
         await p;
       } catch {
       }
     }
   }
-  const cur = cached;
-  cached = null;
-  if (cur) await cur.browser.close().catch(() => {
-  });
+  for (const cur of cachedByCdpUrl.values()) {
+    await cur.browser.close().catch(() => {
+    });
+  }
+  cachedByCdpUrl.clear();
 }
 function cdpSocketNeedsAttach(wsUrl) {
   try {
@@ -1728,10 +1819,10 @@ async function tryTerminateExecutionViaCdp(cdpUrl, targetId) {
 }
 async function forceDisconnectPlaywrightForTarget(opts) {
   const normalized = normalizeCdpUrl(opts.cdpUrl);
-  const cur = cached;
-  if (!cur || cur.cdpUrl !== normalized) return;
-  cached = null;
-  connectingByUrl.delete(normalized);
+  const cur = cachedByCdpUrl.get(normalized);
+  if (!cur) return;
+  cachedByCdpUrl.delete(normalized);
+  connectingByCdpUrl.delete(normalized);
   if (cur.onDisconnected && typeof cur.browser.off === "function") {
     cur.browser.off("disconnected", cur.onDisconnected);
   }
@@ -1774,7 +1865,6 @@ async function findPageByTargetId(browser, targetId, cdpUrl) {
     try {
       const listUrl = `${normalizeCdpHttpBaseForJsonEndpoints(cdpUrl)}/json/list`;
       const headers = {};
-      if (cached?.authToken) headers["Authorization"] = `Bearer ${cached.authToken}`;
       const ctrl = new AbortController();
       const t = setTimeout(() => ctrl.abort(), 2e3);
       try {
@@ -2311,7 +2401,7 @@ function isAllowedNonNetworkNavigationUrl(parsed) {
 function isPrivateNetworkAllowedByPolicy(policy) {
   return policy?.dangerouslyAllowPrivateNetwork === true || policy?.allowPrivateNetwork === true;
 }
-function hasProxyEnvConfigured(env = process.env) {
+function hasProxyEnvConfigured2(env = process.env) {
   for (const key of PROXY_ENV_KEYS) {
     const value = env[key];
     if (typeof value === "string" && value.trim().length > 0) return true;
@@ -2625,7 +2715,7 @@ async function assertBrowserNavigationAllowed(opts) {
     if (isAllowedNonNetworkNavigationUrl(parsed)) return;
     throw new InvalidBrowserNavigationUrlError(`Navigation blocked: unsupported protocol "${parsed.protocol}"`);
   }
-  if (hasProxyEnvConfigured() && !isPrivateNetworkAllowedByPolicy(opts.ssrfPolicy)) {
+  if (hasProxyEnvConfigured2() && !isPrivateNetworkAllowedByPolicy(opts.ssrfPolicy)) {
     throw new InvalidBrowserNavigationUrlError(
       "Navigation blocked: strict browser SSRF policy cannot be enforced while env proxy variables are set"
     );