brave-real-playwright-core
Version:
Brave-optimized Playwright Core (v1.55.0) with comprehensive stealth patches and error stack sanitization
324 lines (323 loc) • 12.2 kB
JavaScript
"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 crConnection_exports = {};
__export(crConnection_exports, {
CDPSession: () => CDPSession,
CRConnection: () => CRConnection,
CRSession: () => CRSession,
ConnectionEvents: () => ConnectionEvents,
kBrowserCloseMessageId: () => kBrowserCloseMessageId
});
module.exports = __toCommonJS(crConnection_exports);
var import_utils = require("../../utils");
var import_debugLogger = require("../utils/debugLogger");
var import_helper = require("../helper");
var import_protocolError = require("../protocolError");
var import_instrumentation = require("../instrumentation");
const ConnectionEvents = {
Disconnected: Symbol("ConnectionEvents.Disconnected")
};
const kBrowserCloseMessageId = -9999;
class CRConnection extends import_instrumentation.SdkObject {
constructor(parent, transport, protocolLogger, browserLogsCollector) {
super(parent, "cr-connection");
this._lastId = 0;
this._sessions = /* @__PURE__ */ new Map();
this._closed = false;
this.setMaxListeners(0);
this._transport = transport;
this._protocolLogger = protocolLogger;
this._browserLogsCollector = browserLogsCollector;
this.rootSession = new CRSession(this, null, "");
this._sessions.set("", this.rootSession);
this._transport.onmessage = this._onMessage.bind(this);
this._transport.onclose = this._onClose.bind(this);
}
_rawSend(sessionId, method, params) {
const id = ++this._lastId;
const message = { id, method, params };
if (sessionId)
message.sessionId = sessionId;
this._protocolLogger("send", message);
this._transport.send(message);
return id;
}
async _onMessage(message) {
this._protocolLogger("receive", message);
if (message.id === kBrowserCloseMessageId)
return;
const session = this._sessions.get(message.sessionId || "");
if (session)
session._onMessage(message);
}
_onClose(reason) {
this._closed = true;
this._transport.onmessage = void 0;
this._transport.onclose = void 0;
this._browserDisconnectedLogs = import_helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);
this.rootSession.dispose();
Promise.resolve().then(() => this.emit(ConnectionEvents.Disconnected));
}
close() {
if (!this._closed)
this._transport.close();
}
async createBrowserSession() {
const { sessionId } = await this.rootSession.send("Target.attachToBrowserTarget");
return new CDPSession(this.rootSession, sessionId);
}
}
class CRSession extends import_instrumentation.SdkObject {
constructor(connection, parentSession, sessionId, eventListener) {
super(connection, "cr-session");
this._callbacks = /* @__PURE__ */ new Map();
this._crashed = false;
this._closed = false;
this.setMaxListeners(0);
this._connection = connection;
this._parentSession = parentSession;
this._sessionId = sessionId;
this._eventListener = eventListener;
this.on = super.on;
this.addListener = super.addListener;
this.off = super.removeListener;
this.removeListener = super.removeListener;
this.once = super.once;
}
_markAsCrashed() {
this._crashed = true;
}
createChildSession(sessionId, eventListener) {
const session = new CRSession(this._connection, this, sessionId, eventListener);
this._connection._sessions.set(sessionId, session);
return session;
}
async send(method, params) {
if (this._crashed || this._closed || this._connection._closed || this._connection._browserDisconnectedLogs)
throw new import_protocolError.ProtocolError(this._crashed ? "crashed" : "closed", void 0, this._connection._browserDisconnectedLogs);
const id = this._connection._rawSend(this._sessionId, method, params);
return new Promise((resolve, reject) => {
this._callbacks.set(id, { resolve, reject, error: new import_protocolError.ProtocolError("error", method) });
});
}
_sendMayFail(method, params) {
return this.send(method, params).catch((error) => import_debugLogger.debugLogger.log("error", error));
}
_onMessage(object) {
if (object.id && this._callbacks.has(object.id)) {
const callback = this._callbacks.get(object.id);
this._callbacks.delete(object.id);
if (object.error) {
callback.error.setMessage(object.error.message);
callback.reject(callback.error);
} else {
callback.resolve(object.result);
}
} else if (object.id && object.error?.code === -32001) {
} else {
(0, import_utils.assert)(!object.id, object?.error?.message || void 0);
Promise.resolve().then(() => {
if (this._eventListener)
this._eventListener(object.method, object.params);
this.emit(object.method, object.params);
});
}
}
async detach() {
if (this._closed)
throw new Error(`Session already detached. Most likely the page has been closed.`);
if (!this._parentSession)
throw new Error("Root session cannot be closed");
await this._sendMayFail("Runtime.runIfWaitingForDebugger");
await this._parentSession.send("Target.detachFromTarget", { sessionId: this._sessionId });
this.dispose();
}
dispose() {
this._closed = true;
this._connection._sessions.delete(this._sessionId);
for (const callback of this._callbacks.values()) {
callback.error.setMessage(`Internal server error, session closed.`);
callback.error.type = this._crashed ? "crashed" : "closed";
callback.error.logs = this._connection._browserDisconnectedLogs;
callback.reject(callback.error);
}
this._callbacks.clear();
}
async __re__emitExecutionContext({
world,
targetId,
frame = null
}) {
const fixMode = process.env["REBROWSER_PATCHES_RUNTIME_FIX_MODE"] || "addBinding";
const utilityWorldName = process.env["REBROWSER_PATCHES_UTILITY_WORLD_NAME"] !== "0" ? process.env["REBROWSER_PATCHES_UTILITY_WORLD_NAME"] || "util" : "__playwright_utility_world__";
process.env["REBROWSER_PATCHES_DEBUG"] && console.log(`[rebrowser-patches][crSession] targetId = ${targetId}, world = ${world}, frame = ${frame ? "Y" : "N"}, fixMode = ${fixMode}`);
let getWorldPromise;
if (fixMode === "addBinding") {
if (world === "utility") {
getWorldPromise = this.__re__getIsolatedWorld({
client: this,
frameId: targetId,
worldName: utilityWorldName
}).then((contextId) => {
return {
id: contextId,
// use UTILITY_WORLD_NAME value from crPage.ts otherwise _onExecutionContextCreated will ignore it
name: "__playwright_utility_world__",
auxData: {
frameId: targetId,
isDefault: false
}
};
});
} else if (world === "main") {
getWorldPromise = this.__re__getMainWorld({
client: this,
frameId: targetId,
isWorker: frame === null
}).then((contextId) => {
return {
id: contextId,
name: "",
auxData: {
frameId: targetId,
isDefault: true
}
};
});
}
} else if (fixMode === "alwaysIsolated") {
getWorldPromise = this.__re__getIsolatedWorld({
client: this,
frameId: targetId,
worldName: utilityWorldName
}).then((contextId) => {
return {
id: contextId,
name: "",
auxData: {
frameId: targetId,
isDefault: true
}
};
});
}
const contextPayload = await getWorldPromise;
this.emit("Runtime.executionContextCreated", {
context: contextPayload
});
}
async __re__getMainWorld({ client, frameId, isWorker = false }) {
let contextId;
const randomName = [...Array(Math.floor(Math.random() * (10 + 1)) + 10)].map(() => Math.random().toString(36)[2]).join("");
process.env["REBROWSER_PATCHES_DEBUG"] && console.log(`[rebrowser-patches][getMainWorld] binding name = ${randomName}`);
await client.send("Runtime.addBinding", {
name: randomName
});
const bindingCalledHandler = ({ name, payload, executionContextId }) => {
process.env["REBROWSER_PATCHES_DEBUG"] && console.log("[rebrowser-patches][bindingCalledHandler]", {
name,
payload,
executionContextId
});
if (contextId > 0) {
return;
}
if (name !== randomName) {
return;
}
if (payload !== frameId) {
return;
}
contextId = executionContextId;
client.off("Runtime.bindingCalled", bindingCalledHandler);
};
client.on("Runtime.bindingCalled", bindingCalledHandler);
if (isWorker) {
await client.send("Runtime.evaluate", {
expression: `this['${randomName}']('${frameId}')`
});
} else {
await client.send("Page.addScriptToEvaluateOnNewDocument", {
source: `document.addEventListener('${randomName}', (e) => self['${randomName}'](e.detail.frameId))`,
runImmediately: true
});
const createIsolatedWorldResult = await client.send("Page.createIsolatedWorld", {
frameId,
// use randomName for worldName to distinguish from normal utility world
worldName: randomName,
grantUniveralAccess: true
});
await client.send("Runtime.evaluate", {
expression: `document.dispatchEvent(new CustomEvent('${randomName}', { detail: { frameId: '${frameId}' } }))`,
contextId: createIsolatedWorldResult.executionContextId
});
}
process.env["REBROWSER_PATCHES_DEBUG"] && console.log(`[rebrowser-patches][getMainWorld] result:`, { contextId });
return contextId;
}
async __re__getIsolatedWorld({ client, frameId, worldName }) {
const createIsolatedWorldResult = await client.send("Page.createIsolatedWorld", {
frameId,
worldName,
grantUniveralAccess: true
});
process.env["REBROWSER_PATCHES_DEBUG"] && console.log(`[rebrowser-patches][getIsolatedWorld] result:`, createIsolatedWorldResult);
return createIsolatedWorldResult.executionContextId;
}
}
class CDPSession extends import_instrumentation.SdkObject {
constructor(parentSession, sessionId) {
super(parentSession, "cdp-session");
this._listeners = [];
this._session = parentSession.createChildSession(sessionId, (method, params) => this.emit(CDPSession.Events.Event, { method, params }));
this._listeners = [import_utils.eventsHelper.addEventListener(parentSession, "Target.detachedFromTarget", (event) => {
if (event.sessionId === sessionId)
this._onClose();
})];
}
static {
this.Events = {
Event: "event",
Closed: "close"
};
}
async send(method, params) {
return await this._session.send(method, params);
}
async detach() {
return await this._session.detach();
}
async attachToTarget(targetId) {
const { sessionId } = await this.send("Target.attachToTarget", { targetId, flatten: true });
return new CDPSession(this._session, sessionId);
}
_onClose() {
import_utils.eventsHelper.removeEventListeners(this._listeners);
this._session.dispose();
this.emit(CDPSession.Events.Closed);
}
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
CDPSession,
CRConnection,
CRSession,
ConnectionEvents,
kBrowserCloseMessageId
});