@browserbasehq/orca 3.6.0-gemini-cua → 3.7.1-preview.0

package/dist/esm/lib/v3/understudy/context.js

@@ -6,9 +6,14 @@ import { v3ScriptContent } from "../dom/build/scriptV3Content.js";
 import { executionContexts } from "./executionContextRegistry.js";
 import { normalizeInitScriptSource } from "./initScripts.js";
 import { ContextClipboard } from "./clipboard.js";
-import { TimeoutError, CookieSetError, PageNotFoundError, StagehandSetExtraHTTPHeadersError, } from "../types/public/sdkErrors.js";
+import { TimeoutError, CookieSetError, PageNotFoundError, StagehandSetExtraHTTPHeadersError, StagehandSetDomainPolicyError, } from "../types/public/sdkErrors.js";
 import { getEnvTimeoutMs, withTimeout } from "../timeoutConfig.js";
 import { filterCookies, normalizeCookieParams, cookieMatchesFilter, toCdpCookieParam, } from "./cookies.js";
+import { getDomainPolicyDecision, normalizeDomainPolicy, } from "./domainPolicy.js";
+function isMissingTargetError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /No target with given id found/i.test(message);
+}
 /**
  * Returns true when the target's URL points to a document with a real,
  * pierceable HTML DOM.  We allowlist the small set of schemes that carry
@@ -79,6 +84,7 @@ export class V3Context {
     // Timestamp for most recent popup/open signal
     _lastPopupSignalAt = 0;
     _targetSessionListeners = new Set();
+    _domainPolicySessionListeners = new Map();
     _sessionInit = new Set();
     pagesByTarget = new Map();
     mainFrameToTarget = new Map();
@@ -89,8 +95,17 @@ export class V3Context {
     typeByTarget = new Map();
     _pageOrder = [];
     pendingCreatedTargetUrl = new Map();
+    pageCreationFailures = new Map();
+    // Popup close attempts can race targetCreated, targetInfoChanged, and attached.
+    // In-flight promises let attach wait for a close result before deciding whether
+    // to skip normal setup. Successful closes stay deduped for the context lifetime
+    // because Chrome can emit late targetInfoChanged events after targetDestroyed.
+    // Failed closes are not retained so attach can continue and future events may retry.
+    domainPolicyClosingTargets = new Set();
+    domainPolicyClosePromises = new Map();
     initScripts = [];
     extraHttpHeaders = null;
+    domainPolicy = null;
     _clipboard;
     installTargetSessionListeners(session) {
         const sessionId = session.id;
@@ -329,6 +344,120 @@ export class V3Context {
             throw new StagehandSetExtraHTTPHeadersError(failures);
         }
     }
+    getDomainPolicy() {
+        if (!this.domainPolicy)
+            return null;
+        return {
+            ...(this.domainPolicy.allowedDomains.length
+                ? { allowedDomains: [...this.domainPolicy.allowedDomains] }
+                : {}),
+            ...(this.domainPolicy.blockedDomains.length
+                ? { blockedDomains: [...this.domainPolicy.blockedDomains] }
+                : {}),
+        };
+    }
+    async setDomainPolicy(policy) {
+        const nextPolicy = normalizeDomainPolicy(policy);
+        this.domainPolicy = nextPolicy;
+        const sessions = [];
+        for (const sessionId of this._sessionInit) {
+            const session = this.conn.getSession(sessionId);
+            if (session)
+                sessions.push(session);
+        }
+        if (!sessions.length)
+            return;
+        const results = await Promise.allSettled(sessions.map(async (session) => {
+            if (!nextPolicy) {
+                try {
+                    await session.send("Fetch.disable");
+                    this.uninstallDomainPolicyHandler(session);
+                }
+                catch (error) {
+                    throw { action: "disable", error };
+                }
+                return;
+            }
+            this.installDomainPolicyHandler(session);
+            try {
+                await session.send("Fetch.enable", {
+                    patterns: nextPolicy.fetchPatterns,
+                });
+            }
+            catch (error) {
+                throw { action: "enable", error };
+            }
+        }));
+        const failures = results
+            .map((result, index) => ({ result, session: sessions[index] }))
+            .filter((entry) => entry.result.status === "rejected")
+            .map((entry) => {
+            const failure = entry.result.reason;
+            if (failure?.action === "enable") {
+                this.uninstallDomainPolicyHandler(entry.session);
+            }
+            const reason = failure?.error ?? entry.result.reason;
+            const sid = entry.session.id ?? "unknown";
+            const message = reason instanceof Error ? reason.message : String(reason);
+            return `session=${sid} error=${message}`;
+        });
+        if (failures.length) {
+            throw new StagehandSetDomainPolicyError(failures);
+        }
+    }
+    installDomainPolicyHandler(session) {
+        const sessionId = session.id;
+        if (!sessionId)
+            return;
+        if (this._domainPolicySessionListeners.has(sessionId))
+            return;
+        const handler = (evt) => {
+            void this.handleDomainPolicyRequestPaused(session, evt);
+        };
+        this._domainPolicySessionListeners.set(sessionId, handler);
+        session.on("Fetch.requestPaused", handler);
+    }
+    uninstallDomainPolicyHandler(session) {
+        const sessionId = session.id;
+        if (!sessionId)
+            return;
+        const handler = this._domainPolicySessionListeners.get(sessionId);
+        if (!handler)
+            return;
+        session.off("Fetch.requestPaused", handler);
+        this._domainPolicySessionListeners.delete(sessionId);
+    }
+    async handleDomainPolicyRequestPaused(session, evt) {
+        const decision = getDomainPolicyDecision(evt.request.url, this.domainPolicy);
+        if (decision.action === "continue") {
+            await session
+                .send("Fetch.continueRequest", { requestId: evt.requestId })
+                .catch(() => { });
+            return;
+        }
+        let hostname = "";
+        try {
+            hostname = new URL(evt.request.url).hostname.toLowerCase();
+        }
+        catch {
+            // ignore malformed URLs for logging
+        }
+        v3Logger({
+            category: "network",
+            message: "Blocked request by domain policy",
+            level: 2,
+            auxiliary: {
+                hostname: { value: hostname, type: "string" },
+                ruleType: { value: decision.reason, type: "string" },
+            },
+        });
+        await session
+            .send("Fetch.failRequest", {
+            requestId: evt.requestId,
+            errorReason: "BlockedByClient",
+        })
+            .catch(() => { });
+    }
     get clipboard() {
         return (this._clipboard ??= new ContextClipboard({
             context: this,
@@ -397,6 +526,12 @@ export class V3Context {
         await this.conn.send("Target.activateTarget", { targetId }).catch(() => { });
         const deadline = Date.now() + 5000;
         while (Date.now() < deadline) {
+            const failure = this.pageCreationFailures.get(targetId);
+            if (failure) {
+                this.pageCreationFailures.delete(targetId);
+                this.pendingCreatedTargetUrl.delete(targetId);
+                throw failure;
+            }
             const page = this.pagesByTarget.get(targetId);
             if (page) {
                 // we created at about:blank; navigate only after attach so init scripts run
@@ -412,6 +547,7 @@ export class V3Context {
             }
             await new Promise((r) => setTimeout(r, 25));
         }
+        this.pendingCreatedTargetUrl.delete(targetId);
         throw new TimeoutError(`newPage: target not attached (${targetId})`, 5000);
     }
     /**
@@ -427,6 +563,9 @@ export class V3Context {
         this.createdAtByTarget.clear();
         this.typeByTarget.clear();
         this.pendingCreatedTargetUrl.clear();
+        this.pageCreationFailures.clear();
+        this.domainPolicyClosingTargets.clear();
+        this.domainPolicyClosePromises.clear();
     }
     /**
      * Bootstrap target lifecycle:
@@ -453,8 +592,12 @@ export class V3Context {
             const ti = info;
             if (info.type === "page" && (ti?.openerId || ti?.openerFrameId)) {
                 this._notePopupSignal();
+                void this.closePopupIfBlockedByDomainPolicy(info, "targetCreated");
             }
         });
+        this.conn.on("Target.targetInfoChanged", (evt) => {
+            void this.closePopupIfBlockedByDomainPolicy(evt.targetInfo, "targetInfoChanged");
+        });
         // Only enable auto-attach after listeners are ready so replayed targets are captured.
         await this.conn.enableAutoAttach();
         const targets = await this.conn.getTargets();
@@ -482,6 +625,9 @@ export class V3Context {
      * - Resume the target only after listeners are wired.
      */
     async onAttachedToTarget(info, sessionId) {
+        if (await this.closePopupIfBlockedByDomainPolicy(info, "attached")) {
+            return;
+        }
         // Skip non-web targets (workers, chrome extensions, background pages, etc.).
         // They still need to be resumed so we don't leave them paused by
         // waitForDebuggerOnStart, but injecting the piercer into these targets
@@ -533,6 +679,24 @@ export class V3Context {
                 .catch(() => false);
             return { dispatched, response };
         };
+        const queueFetchEnablePreResume = (params) => {
+            let error;
+            const dispatched = this.conn
+                .waitForSessionDispatch(sessionId, "Fetch.enable")
+                .then(() => true)
+                .catch((err) => {
+                error = err;
+                return false;
+            });
+            const response = session
+                .send("Fetch.enable", params)
+                .then(() => true)
+                .catch((err) => {
+                error = err;
+                return false;
+            });
+            return { dispatched, response, getError: () => error };
+        };
         const initScriptOps = [];
         // Pre-resume ordering matters:
         // - enable domains;
@@ -554,6 +718,13 @@ export class V3Context {
             headerPreResumeOps.push(queuePreResume("Network.enable"));
             headerPreResumeOps.push(queuePreResume("Network.setExtraHTTPHeaders", { headers }));
         }
+        const fetchPreResumeOps = [];
+        if (this.domainPolicy) {
+            this.installDomainPolicyHandler(session);
+            fetchPreResumeOps.push(queueFetchEnablePreResume({
+                patterns: this.domainPolicy.fetchPatterns,
+            }));
+        }
         // Send init scripts only after auto-attach has been queued.
         if (this.initScripts.length) {
             for (const source of this.initScripts) {
@@ -572,6 +743,7 @@ export class V3Context {
         const preResumeDispatched = (await Promise.all([
             ...corePreResumeOps.map((op) => op.dispatched),
             ...headerPreResumeOps.map((op) => op.dispatched),
+            ...fetchPreResumeOps.map((op) => op.dispatched),
             ...initScriptOps.map((op) => op.dispatched),
             piercerPreloadOp.dispatched,
         ])).every(Boolean);
@@ -581,9 +753,10 @@ export class V3Context {
             resumeOp.dispatched,
             resumeOp.response,
         ]);
-        const [coreResults, headerResults, initScriptResults, piercerPreRegistered,] = await Promise.all([
+        const [coreResults, headerResults, fetchResults, initScriptResults, piercerPreRegistered,] = await Promise.all([
             Promise.all(corePreResumeOps.map((op) => op.response)),
             Promise.all(headerPreResumeOps.map((op) => op.response)),
+            Promise.all(fetchPreResumeOps.map((op) => op.response)),
             Promise.all(initScriptOps.map((op) => op.response)),
             piercerPreloadOp.response,
         ]);
@@ -616,6 +789,40 @@ export class V3Context {
             return;
         }
         resumed = true;
+        if (fetchPreResumeOps.length > 0 && !fetchResults.every(Boolean)) {
+            this.uninstallDomainPolicyHandler(session);
+            const fetchError = fetchPreResumeOps
+                .map((op) => op.getError())
+                .find((error) => error !== undefined);
+            const fetchErrorMessage = fetchError
+                ? fetchError instanceof Error
+                    ? fetchError.message
+                    : String(fetchError)
+                : "Fetch.enable failed during target attach";
+            const policyFailureMessage = "Fetch.enable failed during target attach; closing target because " +
+                "Stagehand cannot guarantee domain policy enforcement";
+            if (this.pendingCreatedTargetUrl.has(info.targetId)) {
+                this.pageCreationFailures.set(info.targetId, new StagehandSetDomainPolicyError([
+                    `session=${sessionId} target=${info.targetId} error=${policyFailureMessage} cdpError=${fetchErrorMessage}`,
+                ]));
+            }
+            v3Logger({
+                category: "ctx",
+                message: "Closing target because domain policy could not be guaranteed",
+                level: 0,
+                auxiliary: {
+                    targetId: { value: String(info.targetId), type: "string" },
+                    targetType: { value: String(info.type), type: "string" },
+                    targetUrl: { value: String(info.url ?? ""), type: "string" },
+                    sessionId: { value: sessionId, type: "string" },
+                    cdpError: { value: fetchErrorMessage, type: "string" },
+                },
+            });
+            await this.conn
+                .send("Target.closeTarget", { targetId: info.targetId })
+                .catch(() => { });
+            return;
+        }
         const scriptsInstalled = coreResults.every(Boolean) && initScriptResults.every(Boolean);
         try {
             // Best-effort lifecycle events; do not block top-level page registration
@@ -731,6 +938,74 @@ export class V3Context {
             await resume();
         }
     }
+    async closePopupIfBlockedByDomainPolicy(info, source) {
+        if (!this.domainPolicy || !isTopLevelPage(info))
+            return false;
+        if (!info.openerId && !info.openerFrameId)
+            return false;
+        if (this.domainPolicyClosingTargets.has(info.targetId))
+            return true;
+        const existingClose = this.domainPolicyClosePromises.get(info.targetId);
+        if (existingClose) {
+            return source === "attached" ? await existingClose : true;
+        }
+        const decision = getDomainPolicyDecision(info.url ?? "", this.domainPolicy);
+        if (decision.action === "continue")
+            return false;
+        v3Logger({
+            category: "network",
+            message: "Popup reached a disallowed domain before it could be intercepted; closing it",
+            level: 2,
+            auxiliary: {
+                targetId: { value: String(info.targetId), type: "string" },
+                targetUrl: { value: String(info.url ?? ""), type: "string" },
+                openerId: { value: String(info.openerId ?? ""), type: "string" },
+                openerFrameId: {
+                    value: String(info.openerFrameId ?? ""),
+                    type: "string",
+                },
+                ruleType: { value: decision.reason, type: "string" },
+                source: { value: source, type: "string" },
+            },
+        });
+        const closePromise = this.closeTargetAfterDomainPolicyViolation(info, {
+            failureMessage: "Failed to close popup after it reached a disallowed domain",
+        }).then((closed) => {
+            this.domainPolicyClosePromises.delete(info.targetId);
+            if (closed) {
+                this.domainPolicyClosingTargets.add(info.targetId);
+            }
+            return closed;
+        });
+        this.domainPolicyClosePromises.set(info.targetId, closePromise);
+        return await closePromise;
+    }
+    async closeTargetAfterDomainPolicyViolation(info, opts) {
+        try {
+            await this.conn.send("Target.closeTarget", { targetId: info.targetId });
+            return true;
+        }
+        catch (error) {
+            if (isMissingTargetError(error)) {
+                return true;
+            }
+            v3Logger({
+                category: "network",
+                message: opts.failureMessage,
+                level: 0,
+                auxiliary: {
+                    targetId: { value: String(info.targetId), type: "string" },
+                    targetType: { value: String(info.type), type: "string" },
+                    targetUrl: { value: String(info.url ?? ""), type: "string" },
+                    error: {
+                        value: error instanceof Error ? error.message : String(error),
+                        type: "string",
+                    },
+                },
+            });
+            return false;
+        }
+    }
     /**
      * Detach handler:
      * - Remove child session ownership and prune its subtree.
@@ -751,6 +1026,13 @@ export class V3Context {
                 this.pendingOopifByMainFrame.delete(fid);
         }
         this._targetSessionListeners.delete(sessionId);
+        const session = this.conn.getSession(sessionId);
+        if (session) {
+            this.uninstallDomainPolicyHandler(session);
+        }
+        else {
+            this._domainPolicySessionListeners.delete(sessionId);
+        }
         this._sessionInit.delete(sessionId);
         this._piercerInstalled.delete(sessionId);
     }
@@ -761,6 +1043,7 @@ export class V3Context {
         const page = this.pagesByTarget.get(targetId);
         if (!page)
             return;
+        this.pageCreationFailures.delete(targetId);
         const mainId = page.mainFrameId();
         this.mainFrameToTarget.delete(mainId);
         this.frameOwnerPage.delete(mainId);