patchright-core 1.56.1 → 1.58.2

package/lib/server/agent/performTools.js

@@ -0,0 +1,262 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var performTools_exports = {};
+__export(performTools_exports, {
+  default: () => performTools_default
+});
+module.exports = __toCommonJS(performTools_exports);
+var import_mcpBundle = require("../../mcpBundle");
+var import_tool = require("./tool");
+const navigateSchema = import_mcpBundle.z.object({
+  url: import_mcpBundle.z.string().describe("URL to navigate to")
+});
+const navigate = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_navigate",
+    title: "Navigate to URL",
+    description: "Navigate to a URL",
+    inputSchema: navigateSchema
+  },
+  handle: async (progress, context, params) => {
+    return await context.runActionNoWait(progress, {
+      method: "navigate",
+      url: params.url
+    });
+  }
+});
+const snapshot = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_snapshot",
+    title: "Page snapshot",
+    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    inputSchema: import_mcpBundle.z.object({})
+  },
+  handle: async (progress, context, params) => {
+    return await context.snapshotResult(progress);
+  }
+});
+const elementSchema = import_mcpBundle.z.object({
+  element: import_mcpBundle.z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
+});
+const clickSchema = elementSchema.extend({
+  doubleClick: import_mcpBundle.z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
+  button: import_mcpBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
+  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const click = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_click",
+    title: "Click",
+    description: "Perform click on a web page",
+    inputSchema: clickSchema
+  },
+  handle: async (progress, context, params) => {
+    const [selector] = await context.refSelectors(progress, [params]);
+    return await context.runActionAndWait(progress, {
+      method: "click",
+      selector,
+      button: params.button,
+      modifiers: params.modifiers,
+      clickCount: params.doubleClick ? 2 : void 0
+    });
+  }
+});
+const drag = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_drag",
+    title: "Drag mouse",
+    description: "Perform drag and drop between two elements",
+    inputSchema: import_mcpBundle.z.object({
+      startElement: import_mcpBundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
+      startRef: import_mcpBundle.z.string().describe("Exact source element reference from the page snapshot"),
+      endElement: import_mcpBundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
+      endRef: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
+    })
+  },
+  handle: async (progress, context, params) => {
+    const [sourceSelector, targetSelector] = await context.refSelectors(progress, [
+      { ref: params.startRef, element: params.startElement },
+      { ref: params.endRef, element: params.endElement }
+    ]);
+    return await context.runActionAndWait(progress, {
+      method: "drag",
+      sourceSelector,
+      targetSelector
+    });
+  }
+});
+const hoverSchema = elementSchema.extend({
+  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const hover = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_hover",
+    title: "Hover mouse",
+    description: "Hover over element on page",
+    inputSchema: hoverSchema
+  },
+  handle: async (progress, context, params) => {
+    const [selector] = await context.refSelectors(progress, [params]);
+    return await context.runActionAndWait(progress, {
+      method: "hover",
+      selector,
+      modifiers: params.modifiers
+    });
+  }
+});
+const selectOptionSchema = elementSchema.extend({
+  values: import_mcpBundle.z.array(import_mcpBundle.z.string()).describe("Array of values to select in the dropdown. This can be a single value or multiple values.")
+});
+const selectOption = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_select_option",
+    title: "Select option",
+    description: "Select an option in a dropdown",
+    inputSchema: selectOptionSchema
+  },
+  handle: async (progress, context, params) => {
+    const [selector] = await context.refSelectors(progress, [params]);
+    return await context.runActionAndWait(progress, {
+      method: "selectOption",
+      selector,
+      labels: params.values
+    });
+  }
+});
+const pressKey = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_press_key",
+    title: "Press a key",
+    description: "Press a key on the keyboard",
+    inputSchema: import_mcpBundle.z.object({
+      key: import_mcpBundle.z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`"),
+      modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+    })
+  },
+  handle: async (progress, context, params) => {
+    return await context.runActionAndWait(progress, {
+      method: "pressKey",
+      key: params.modifiers ? [...params.modifiers, params.key].join("+") : params.key
+    });
+  }
+});
+const typeSchema = elementSchema.extend({
+  text: import_mcpBundle.z.string().describe("Text to type into the element"),
+  submit: import_mcpBundle.z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
+  slowly: import_mcpBundle.z.boolean().optional().describe("Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.")
+});
+const type = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_type",
+    title: "Type text",
+    description: "Type text into editable element",
+    inputSchema: typeSchema
+  },
+  handle: async (progress, context, params) => {
+    const [selector] = await context.refSelectors(progress, [params]);
+    if (params.slowly) {
+      return await context.runActionAndWait(progress, {
+        method: "pressSequentially",
+        selector,
+        text: params.text,
+        submit: params.submit
+      });
+    } else {
+      return await context.runActionAndWait(progress, {
+        method: "fill",
+        selector,
+        text: params.text,
+        submit: params.submit
+      });
+    }
+  }
+});
+const fillForm = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_fill_form",
+    title: "Fill form",
+    description: "Fill multiple form fields. Always use this tool when you can fill more than one field at a time.",
+    inputSchema: import_mcpBundle.z.object({
+      fields: import_mcpBundle.z.array(import_mcpBundle.z.object({
+        name: import_mcpBundle.z.string().describe("Human-readable field name"),
+        type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
+        ref: import_mcpBundle.z.string().describe("Exact target field reference from the page snapshot"),
+        value: import_mcpBundle.z.string().describe("Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.")
+      })).describe("Fields to fill in")
+    })
+  },
+  handle: async (progress, context, params) => {
+    const actions = [];
+    for (const field of params.fields) {
+      const [selector] = await context.refSelectors(progress, [{ ref: field.ref, element: field.name }]);
+      if (field.type === "textbox" || field.type === "slider") {
+        actions.push({
+          method: "fill",
+          selector,
+          text: field.value
+        });
+      } else if (field.type === "checkbox" || field.type === "radio") {
+        actions.push({
+          method: "setChecked",
+          selector,
+          checked: field.value === "true"
+        });
+      } else if (field.type === "combobox") {
+        actions.push({
+          method: "selectOption",
+          selector,
+          labels: [field.value]
+        });
+      }
+    }
+    return await context.runActionsAndWait(progress, actions);
+  }
+});
+const setCheckedSchema = elementSchema.extend({
+  checked: import_mcpBundle.z.boolean().describe("Whether to check the checkbox")
+});
+const setChecked = (0, import_tool.defineTool)({
+  schema: {
+    name: "browser_set_checked",
+    title: "Set checked",
+    description: "Set the checked state of a checkbox",
+    inputSchema: setCheckedSchema
+  },
+  handle: async (progress, context, params) => {
+    const [selector] = await context.refSelectors(progress, [params]);
+    return await context.runActionAndWait(progress, {
+      method: "setChecked",
+      selector,
+      checked: params.checked
+    });
+  }
+});
+var performTools_default = [
+  navigate,
+  snapshot,
+  click,
+  drag,
+  hover,
+  selectOption,
+  pressKey,
+  type,
+  fillForm,
+  setChecked
+];

package/lib/server/agent/tool.js

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_exports = {};
+__export(tool_exports, {
+  defineTool: () => defineTool,
+  toolsForLoop: () => toolsForLoop
+});
+module.exports = __toCommonJS(tool_exports);
+var import_mcpBundle = require("../../mcpBundle");
+var import_stringUtils = require("../../utils/isomorphic/stringUtils");
+function defineTool(tool) {
+  return tool;
+}
+function toolsForLoop(progress, context, toolDefinitions, options = {}) {
+  const tools = toolDefinitions.map((tool) => {
+    const result = {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      inputSchema: import_mcpBundle.z.toJSONSchema(tool.schema.inputSchema)
+    };
+    return result;
+  });
+  if (options.resultSchema) {
+    tools.push({
+      name: "report_result",
+      description: "Report the result of the task.",
+      inputSchema: options.resultSchema
+    });
+  }
+  if (options.refuseToPerform === "allow") {
+    tools.push({
+      name: "refuse_to_perform",
+      description: "Refuse to perform action.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          reason: {
+            type: "string",
+            description: `Call this when you believe that you can't perform the action because something is wrong with the page. The reason will be reported to the user.`
+          }
+        },
+        required: ["reason"]
+      }
+    });
+  }
+  let reportedResult;
+  let refusedToPerformReason;
+  const callTool = async (params) => {
+    if (params.name === "report_result") {
+      reportedResult = params.arguments;
+      return {
+        content: [{ type: "text", text: "Done" }],
+        isError: false
+      };
+    }
+    if (params.name === "refuse_to_perform") {
+      refusedToPerformReason = params.arguments.reason;
+      return {
+        content: [{ type: "text", text: "Done" }],
+        isError: false
+      };
+    }
+    const tool = toolDefinitions.find((t) => t.schema.name === params.name);
+    if (!tool) {
+      return {
+        content: [{
+          type: "text",
+          text: `Tool ${params.name} not found. Available tools: ${toolDefinitions.map((t) => t.schema.name)}`
+        }],
+        isError: true
+      };
+    }
+    try {
+      return await tool.handle(progress, context, params.arguments);
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: (0, import_stringUtils.stripAnsiEscapes)(error.message) }],
+        isError: true
+      };
+    }
+  };
+  return {
+    tools,
+    callTool,
+    reportedResult: options.resultSchema ? () => reportedResult : void 0,
+    refusedToPerformReason: () => refusedToPerformReason
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineTool,
+  toolsForLoop
+});

package/lib/server/android/android.js

@@ -248,7 +248,7 @@ class AndroidDevice extends import_instrumentation.SdkObject {
       "--disable-fre",
       "--no-default-browser-check",
       `--remote-debugging-socket-name=${socketName}`,
-      ...(0, import_chromiumSwitches.chromiumSwitches)(),
+      ...(0, import_chromiumSwitches.chromiumSwitches)(void 0, void 0, true),
       ...this._innerDefaultArgs(options)
     ];
     return chromeArguments;

package/lib/server/artifact.js

@@ -103,7 +103,7 @@ class Artifact extends import_instrumentation.SdkObject {
     if (!this._unaccessibleErrorMessage)
       await import_fs.default.promises.unlink(this._localPath).catch((e) => {
       });
-    await this.reportFinished(new import_errors.TargetClosedError());
+    await this.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
   }
   async reportFinished(error) {
     if (this._finished)

package/lib/server/bidi/bidiBrowser.js

@@ -62,12 +62,16 @@ class BidiBrowser extends import_browser.Browser {
     browser._bidiSessionInfo = await browser._browserSession.send("session.new", {
       capabilities: {
         alwaysMatch: {
-          acceptInsecureCerts: options.persistent?.internalIgnoreHTTPSErrors || options.persistent?.ignoreHTTPSErrors,
-          proxy: getProxyConfiguration(options.originalLaunchOptions.proxyOverride ?? options.proxy),
-          unhandledPromptBehavior: {
+          "acceptInsecureCerts": options.persistent?.internalIgnoreHTTPSErrors || options.persistent?.ignoreHTTPSErrors,
+          "proxy": getProxyConfiguration(options.originalLaunchOptions.proxyOverride ?? options.proxy),
+          "unhandledPromptBehavior": {
             default: bidi.Session.UserPromptHandlerType.Ignore
           },
-          webSocketUrl: true
+          "webSocketUrl": true,
+          // Chrome with WebDriver BiDi does not support prerendering
+          // yet because WebDriver BiDi behavior is not specified. See
+          // https://github.com/w3c/webdriver-bidi/issues/321.
+          "goog:prerenderingDisabled": true
         }
       }
     });
@@ -76,7 +80,8 @@ class BidiBrowser extends import_browser.Browser {
         "browsingContext",
         "network",
         "log",
-        "script"
+        "script",
+        "input"
       ]
     });
     await browser._browserSession.send("network.addDataCollector", {
@@ -122,15 +127,15 @@ class BidiBrowser extends import_browser.Browser {
   _onBrowsingContextCreated(event) {
     if (event.parent) {
       const parentFrameId = event.parent;
-      for (const page2 of this._bidiPages.values()) {
-        const parentFrame = page2._page.frameManager.frame(parentFrameId);
-        if (!parentFrame)
-          continue;
+      const page2 = this._findPageForFrame(parentFrameId);
+      if (page2) {
         page2._session.addFrameBrowsingContext(event.context);
-        page2._page.frameManager.frameAttached(event.context, parentFrameId);
-        const frame = page2._page.frameManager.frame(event.context);
-        if (frame)
-          frame._url = event.url;
+        const frame = page2._page.frameManager.frameAttached(event.context, parentFrameId);
+        frame._url = event.url;
+        page2._getFrameNode(frame).then((node) => {
+          const attributes = node?.value?.attributes;
+          frame._name = attributes?.name ?? attributes?.id ?? "";
+        });
         return;
       }
       return;
@@ -140,8 +145,9 @@ class BidiBrowser extends import_browser.Browser {
       context = this._defaultContext;
     if (!context)
       return;
+    context.doGrantGlobalPermissionsForURL(event.url);
     const session = this._connection.createMainFrameBrowsingContextSession(event.context);
-    const opener = event.originalOpener && this._bidiPages.get(event.originalOpener);
+    const opener = event.originalOpener && this._findPageForFrame(event.originalOpener);
     const page = new import_bidiPage.BidiPage(context, session, opener || null);
     page._page.mainFrame()._url = event.url;
     this._bidiPages.set(event.context, page);
@@ -171,6 +177,12 @@ class BidiBrowser extends import_browser.Browser {
         return;
     }
   }
+  _findPageForFrame(frameId) {
+    for (const page of this._bidiPages.values()) {
+      if (page._page.frameManager.frame(frameId))
+        return page;
+    }
+  }
 }
 class BidiBrowserContext extends import_browserContext.BrowserContext {
   constructor(browser, browserContextId, options) {
@@ -207,6 +219,10 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
         userContexts: [this._userContextId()]
       }));
     }
+    if (this._options.extraHTTPHeaders)
+      promises.push(this.doUpdateExtraHTTPHeaders());
+    if (this._options.permissions)
+      promises.push(this.doGrantPermissions("*", this._options.permissions));
     await Promise.all(promises);
   }
   possiblyUninitializedPages() {
@@ -265,17 +281,34 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     );
   }
   async doGrantPermissions(origin, permissions) {
+    if (origin === "null")
+      return;
     const currentPermissions = this._originToPermissions.get(origin) || [];
     const toGrant = permissions.filter((permission) => !currentPermissions.includes(permission));
     this._originToPermissions.set(origin, [...currentPermissions, ...toGrant]);
-    await Promise.all(toGrant.map((permission) => this._setPermission(origin, permission, bidi.Permissions.PermissionState.Granted)));
+    if (origin === "*") {
+      await Promise.all(this._bidiPages().flatMap(
+        (page) => page._page.frames().map(
+          (frame) => this.doGrantPermissions(new URL(frame._url).origin, permissions)
+        )
+      ));
+    } else {
+      await Promise.all(toGrant.map((permission) => this._setPermission(origin, permission, bidi.Permissions.PermissionState.Granted)));
+    }
+  }
+  async doGrantGlobalPermissionsForURL(url) {
+    const permissions = this._originToPermissions.get("*");
+    if (!permissions)
+      return;
+    await this.doGrantPermissions(new URL(url).origin, permissions);
   }
   async doClearPermissions() {
     const currentPermissions = [...this._originToPermissions.entries()];
     this._originToPermissions = /* @__PURE__ */ new Map();
-    await Promise.all(currentPermissions.map(([origin, permissions]) => permissions.map(
-      (p) => this._setPermission(origin, p, bidi.Permissions.PermissionState.Prompt)
-    )));
+    await Promise.all(currentPermissions.flatMap(([origin, permissions]) => {
+      if (origin !== "*")
+        return permissions.map((p) => this._setPermission(origin, p, bidi.Permissions.PermissionState.Prompt));
+    }));
   }
   async _setPermission(origin, permission, state) {
     await this._browser._browserSession.send("permissions.setPermission", {
@@ -300,6 +333,11 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     });
   }
   async doUpdateExtraHTTPHeaders() {
+    const allHeaders = this._options.extraHTTPHeaders || [];
+    await this._browser._browserSession.send("network.setExtraHeaders", {
+      headers: allHeaders.map(({ name, value }) => ({ name, value: { type: "string", value } })),
+      userContexts: [this._userContextId()]
+    });
   }
   async setUserAgent(userAgent) {
     this._options.userAgent = userAgent;
@@ -334,21 +372,42 @@ class BidiBrowserContext extends import_browserContext.BrowserContext {
     await Promise.all(ids.map((script) => this._browser._browserSession.send("script.removePreloadScript", { script })));
   }
   async doUpdateRequestInterception() {
+    if (this.requestInterceptors.length > 0 && !this._interceptId) {
+      const { intercept } = await this._browser._browserSession.send("network.addIntercept", {
+        phases: [bidi.Network.InterceptPhase.BeforeRequestSent],
+        urlPatterns: [{ type: "pattern" }]
+      });
+      this._interceptId = intercept;
+    }
+    if (this.requestInterceptors.length === 0 && this._interceptId) {
+      const intercept = this._interceptId;
+      this._interceptId = void 0;
+      await this._browser._browserSession.send("network.removeIntercept", { intercept });
+    }
   }
   async doUpdateDefaultViewport() {
-    if (!this._options.viewport)
+    if (!this._options.viewport && !this._options.screen)
       return;
+    const screenSize = this._options.screen || this._options.viewport;
+    const viewportSize = this._options.viewport || this._options.screen;
     await Promise.all([
       this._browser._browserSession.send("browsingContext.setViewport", {
         viewport: {
-          width: this._options.viewport.width,
-          height: this._options.viewport.height
+          width: viewportSize.width,
+          height: viewportSize.height
         },
         devicePixelRatio: this._options.deviceScaleFactor || 1,
         userContexts: [this._userContextId()]
       }),
       this._browser._browserSession.send("emulation.setScreenOrientationOverride", {
-        screenOrientation: getScreenOrientation(!!this._options.isMobile, this._options.viewport),
+        screenOrientation: getScreenOrientation(!!this._options.isMobile, screenSize),
+        userContexts: [this._userContextId()]
+      }),
+      this._browser._browserSession.send("emulation.setScreenSettingsOverride", {
+        screenArea: {
+          width: screenSize.width,
+          height: screenSize.height
+        },
         userContexts: [this._userContextId()]
       })
     ]);

package/lib/server/bidi/bidiChromium.js

@@ -38,9 +38,10 @@ var import_bidiBrowser = require("./bidiBrowser");
 var import_bidiConnection = require("./bidiConnection");
 var import_chromiumSwitches = require("../chromium/chromiumSwitches");
 var import_chromium = require("../chromium/chromium");
+var import_hostPlatform = require("../utils/hostPlatform");
 class BidiChromium extends import_browserType.BrowserType {
   constructor(parent) {
-    super(parent, "_bidiChromium");
+    super(parent, "chromium");
   }
   async connectToTransport(transport, options, browserLogsCollector) {
     const bidiTransport = await require("./bidiOverCdp").connectBidiOverCdp(transport);
@@ -56,14 +57,12 @@ class BidiChromium extends import_browserType.BrowserType {
       throw e;
     }
   }
-  doRewriteStartupLog(error) {
-    if (!error.logs)
-      return error;
-    if (error.logs.includes("Missing X server"))
-      error.logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
-    if (!error.logs.includes("crbug.com/357670") && !error.logs.includes("No usable sandbox!") && !error.logs.includes("crbug.com/638180"))
-      return error;
-    error.logs = [
+  doRewriteStartupLog(logs) {
+    if (logs.includes("Missing X server"))
+      logs = "\n" + (0, import_ascii.wrapInASCIIBox)(import_browserType.kNoXServerRunningError, 1);
+    if (!logs.includes("crbug.com/357670") && !logs.includes("No usable sandbox!") && !logs.includes("crbug.com/638180"))
+      return logs;
+    return [
       `Chromium sandboxing failed!`,
       `================================`,
       `To avoid the sandboxing issue, do either of the following:`,
@@ -72,7 +71,6 @@ class BidiChromium extends import_browserType.BrowserType {
       `================================`,
       ``
     ].join("\n");
-    return error;
   }
   amendEnvironment(env) {
     return env;
@@ -109,11 +107,9 @@ class BidiChromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode)];
-    if (import_os.default.platform() === "darwin") {
+    if (import_os.default.platform() !== "darwin" || !(0, import_hostPlatform.hasGpuMac)()) {
       chromeArguments.push("--enable-unsafe-swiftshader");
     }
-    if (options.devtools)
-      chromeArguments.push("--auto-open-devtools-for-tabs");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(

package/lib/server/bidi/bidiConnection.js

@@ -173,6 +173,7 @@ class BidiSession extends import_events.EventEmitter {
     this._browsingContexts.clear();
     for (const callback of this._callbacks.values()) {
       callback.error.type = this._crashed ? "crashed" : "closed";
+      callback.error.setMessage(`Internal server error, session ${callback.error.type}.`);
       callback.error.logs = this.connection._browserDisconnectedLogs;
       callback.reject(callback.error);
     }