rebrowser-playwright-core 1.47.2 → 1.48.2

package/lib/server/frames.js

@@ -61,7 +61,7 @@ class FrameManager {
     this._webSockets = new Map();
     this._openedDialogs = new Set();
     this._closeAllOpeningDialogs = false;
-    this._isolatedContext = undefined;
+    this.__re__contexts = undefined;
     this._page = page;
     this._mainFrame = undefined;
   }
@@ -429,7 +429,7 @@ class Frame extends _instrumentation.SdkObject {
     if (this._inflightRequests.size === 0) this._startNetworkIdleTimer();
     this._page.mainFrame()._recalculateNetworkIdle(this);
     this._onLifecycleEvent('commit');
-    this._isolatedContext = undefined;
+    this.__re__contexts = undefined;
   }
   setPendingDocument(documentInfo) {
     this._pendingDocument = documentInfo;
@@ -584,33 +584,169 @@ class Frame extends _instrumentation.SdkObject {
   async frameElement() {
     return this._page._delegate.getFrameElement(this);
   }
+  async __re__getMainWorld({
+    client,
+    frameId
+  }) {
+    let contextId;
+
+    // random name to make it harder to detect for any 3rd party script by watching window object and events
+    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}`);
+
+    // add the binding
+    await client.send('Runtime.addBinding', {
+      name: randomName
+    });
+
+    // listen for 'Runtime.bindingCalled' event
+    const bindingCalledHandler = ({
+      name,
+      payload,
+      executionContextId
+    }) => {
+      process.env['REBROWSER_PATCHES_DEBUG'] && console.log('[rebrowser-patches][bindingCalledHandler]', {
+        name,
+        payload,
+        executionContextId
+      });
+      if (contextId > 0) {
+        // already acquired the id
+        return;
+      }
+      if (name !== randomName) {
+        // ignore irrelevant bindings
+        return;
+      }
+      if (payload !== frameId) {
+        // ignore irrelevant frames
+        return;
+      }
+      contextId = executionContextId;
+      // remove this listener
+      client.off('Runtime.bindingCalled', bindingCalledHandler);
+    };
+    client.on('Runtime.bindingCalled', bindingCalledHandler);
+
+    // we could call the binding right from addScriptToEvaluateOnNewDocument, but this way it will be called in all existing frames and it's hard to distinguish children from the parent
+    await client.send('Page.addScriptToEvaluateOnNewDocument', {
+      source: `document.addEventListener('${randomName}', (e) => self['${randomName}'](e.detail.frameId))`,
+      runImmediately: true
+    });
+
+    // create new isolated world for this frame
+    const createIsolatedWorldResult = await client.send('Page.createIsolatedWorld', {
+      frameId,
+      // use randomName for worldName to distinguish from normal utility world
+      worldName: randomName,
+      grantUniveralAccess: true
+    });
+
+    // emit event in the specific frame from the isolated world
+    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;
+  }
   _context(world) {
-    if (process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] !== '0') {
-      // rebrowser-patches: use only utility context, create it on demand and cache
-      if (this._isolatedContext !== undefined) {
-        return this._isolatedContext;
+    const fixMode = process.env['REBROWSER_PATCHES_RUNTIME_FIX_MODE'] || 'addBinding';
+    process.env['REBROWSER_PATCHES_DEBUG'] && console.log(`[rebrowser-patches][frames._context] frameId = ${this._id}, world = ${world}, fixMode = ${fixMode}`);
+    if (fixMode !== '0') {
+      if (typeof this.__re__contexts === 'undefined') {
+        this.__re__contexts = {};
       }
+      const frameSession = this._page._delegate._sessions.get(this._id) || this._page._delegate._mainFrameSession;
+      const client = frameSession._client;
       const utilityWorldName = process.env['REBROWSER_PATCHES_UTILITY_WORLD_NAME'] !== '0' ? process.env['REBROWSER_PATCHES_UTILITY_WORLD_NAME'] || 'util' : '__playwright_utility_world__';
-      return this._page._delegate._mainFrameSession._client.send('Page.createIsolatedWorld', {
-        frameId: this._id,
-        grantUniveralAccess: true,
-        worldName: utilityWorldName
-      }).then(createIsolatedWorldResult => {
-        const contextPayload = {
-          id: createIsolatedWorldResult.executionContextId,
-          name: utilityWorldName,
-          auxData: {
+      let getWorldPromise;
+      if (fixMode === 'addBinding') {
+        if (this.__re__contexts[world] !== undefined) {
+          return Promise.resolve(this.__re__contexts[world]);
+        }
+        if (world === 'utility') {
+          getWorldPromise = this.__re__getIsolatedWorld({
+            client,
             frameId: this._id,
-            isDefault: false
-          }
-        };
-        const delegate = new _crExecutionContext.CRExecutionContext(this._page._delegate._mainFrameSession._client, contextPayload);
-        this._isolatedContext = new dom.FrameExecutionContext(delegate, this, 'utility');
-        return this._isolatedContext;
-      }).catch(error => {
-        // probably target is closed
+            worldName: utilityWorldName
+          }).then(contextId => {
+            return {
+              id: contextId,
+              name: utilityWorldName,
+              auxData: {
+                frameId: this._id,
+                isDefault: false
+              }
+            };
+          });
+        } else if (world === 'main') {
+          getWorldPromise = this.__re__getMainWorld({
+            client,
+            frameId: this._id
+          }).then(contextId => {
+            return {
+              id: contextId,
+              name: '',
+              auxData: {
+                frameId: this._id,
+                isDefault: true
+              }
+            };
+          });
+        }
+        getWorldPromise = getWorldPromise.then(contextPayload => {
+          const delegate = new _crExecutionContext.CRExecutionContext(client, contextPayload);
+          this.__re__contexts[world] = new dom.FrameExecutionContext(delegate, this, world);
+          return this.__re__contexts[world];
+        });
+      } else if (fixMode === 'alwaysIsolated') {
+        // use only utility context
+        if (this.__re__contexts.utility !== undefined) {
+          return Promise.resolve(this.__re__contexts.utility);
+        }
+        getWorldPromise = this.__re__getIsolatedWorld({
+          client,
+          frameId: this._id,
+          worldName: utilityWorldName
+        }).then(contextId => {
+          const contextPayload = {
+            id: contextId,
+            name: utilityWorldName,
+            auxData: {
+              frameId: this._id,
+              isDefault: false
+            }
+          };
+          const delegate = new _crExecutionContext.CRExecutionContext(client, contextPayload);
+          this.__re__contexts.utility = new dom.FrameExecutionContext(delegate, this, 'utility');
+          return this.__re__contexts.utility;
+        });
+      }
+      return getWorldPromise.catch(error => {
+        if (error.message.includes('No frame for given id found')) {
+          // ignore, frame is already gone
+          return {
+            destroyedReason: 'Frame was detached'
+          };
+        }
         _debugLogger.debugLogger.log('error', error);
-        console.error('[rebrowser-patches][frames._context] cannot create utility world');
+        console.error('[rebrowser-patches][frames._context] cannot get world, error:', error);
       });
     }
     return this._contextData.get(world).contextPromise.then(contextOrDestroyedReason => {
@@ -654,14 +790,15 @@ class Frame extends _instrumentation.SdkObject {
     if (!['attached', 'detached', 'visible', 'hidden'].includes(state)) throw new Error(`state: expected one of (attached|detached|visible|hidden)`);
     return controller.run(async progress => {
       progress.log(`waiting for ${this._asLocator(selector)}${state === 'attached' ? '' : ' to be ' + state}`);
-      return await this.waitForSelectorInternal(progress, selector, options, scope);
+      return await this.waitForSelectorInternal(progress, selector, true, options, scope);
     }, this._page._timeoutSettings.timeout(options));
   }
-  async waitForSelectorInternal(progress, selector, options, scope) {
+  async waitForSelectorInternal(progress, selector, performLocatorHandlersCheckpoint, options, scope) {
     const {
       state = 'visible'
     } = options;
     const promise = this.retryWithProgressAndTimeouts(progress, [0, 20, 50, 100, 100, 500], async continuePolling => {
+      if (performLocatorHandlersCheckpoint) await this._page.performLocatorHandlersCheckpoint(progress);
       const resolved = await this.selectors.resolveInjectedForSelector(selector, options, scope);
       progress.throwIfAborted();
       if (!resolved) {
@@ -795,11 +932,10 @@ class Frame extends _instrumentation.SdkObject {
     const controller = new _progress.ProgressController(metadata, this);
     return controller.run(async progress => {
       await this.raceNavigationAction(progress, options, async () => {
-        var _this$_page$_delegate, _this$_page$_delegate2;
         const waitUntil = options.waitUntil === undefined ? 'load' : options.waitUntil;
         progress.log(`setting frame content, waiting until "${waitUntil}"`);
         const tag = `--playwright--set--content--${this._id}--${++this._setContentCounter}--`;
-        const context = (_this$_page$_delegate = (_this$_page$_delegate2 = this._page._delegate).useMainWorldForSetContent) !== null && _this$_page$_delegate !== void 0 && _this$_page$_delegate.call(_this$_page$_delegate2) ? await this._mainContext() : await this._utilityContext();
+        const context = await this._utilityContext();
         const lifecyclePromise = new Promise((resolve, reject) => {
           this._page._frameManager._consoleMessageTags.set(tag, () => {
             // Clear lifecycle right after document.open() - see 'tag' below.

package/lib/server/har/harTracer.js

@@ -156,12 +156,22 @@ class HarTracer {
     if (this._started) this._delegate.onEntryStarted(harEntry);
   }
   _onAPIRequestFinished(event) {
+    var _event$body$length, _event$body;
     const harEntry = this._entryForRequest(event.requestEvent);
     if (!harEntry) return;
     harEntry.response.status = event.statusCode;
     harEntry.response.statusText = event.statusMessage;
     harEntry.response.httpVersion = event.httpVersion;
     harEntry.response.redirectURL = event.headers.location || '';
+    if (!this._options.omitServerIP) {
+      harEntry.serverIPAddress = event.serverIPAddress;
+      harEntry._serverPort = event.serverPort;
+    }
+    if (!this._options.omitTiming) {
+      harEntry.timings = event.timings;
+      this._computeHarEntryTotalTime(harEntry);
+    }
+    if (!this._options.omitSecurityDetails) harEntry._securityDetails = event.securityDetails;
     for (let i = 0; i < event.rawHeaders.length; i += 2) {
       harEntry.response.headers.push({
         name: event.rawHeaders[i],
@@ -178,6 +188,7 @@ class HarTracer {
     const contentType = event.headers['content-type'];
     if (contentType) content.mimeType = contentType;
     this._storeResponseContent(event.body, content, 'other');
+    if (!this._options.omitSizes) harEntry.response.bodySize = (_event$body$length = (_event$body = event.body) === null || _event$body === void 0 ? void 0 : _event$body.length) !== null && _event$body$length !== void 0 ? _event$body$length : 0;
     if (this._started) this._delegate.onEntryFinished(harEntry);
   }
   _onRequest(request) {

package/lib/server/input.js

@@ -189,7 +189,6 @@ class Mouse {
       x,
       y
     };
-    if (this._raw.click) return await this._raw.click(x, y, options);
     const {
       delay = null,
       clickCount = 1

package/lib/server/javascript.js

@@ -85,9 +85,6 @@ class ExecutionContext extends _instrumentation.SdkObject {
     }
     return this._utilityScriptPromise;
   }
-  async objectCount(objectId) {
-    return this._delegate.objectCount(objectId);
-  }
   async doSlowMo() {
     // overridden in FrameExecutionContext
   }
@@ -189,10 +186,6 @@ class JSHandle extends _instrumentation.SdkObject {
     this._preview = preview;
     if (this._previewCallback) this._previewCallback(preview);
   }
-  async objectCount() {
-    if (!this._objectId) throw new Error('Can only count objects for a handle that points to the constructor prototype');
-    return this._context.objectCount(this._objectId);
-  }
 }
 exports.JSHandle = JSHandle;
 async function evaluate(context, returnByValue, pageFunction, ...args) {

package/lib/server/page.js

@@ -285,6 +285,9 @@ class Page extends _instrumentation.SdkObject {
       return response;
     }), this._timeoutSettings.navigationTimeout(options));
   }
+  requestGC() {
+    return this._delegate.requestGC();
+  }
   registerLocatorHandler(selector, noWaitAfter) {
     const uid = ++this._lastLocatorHandlerUid;
     this._locatorHandlers.set(uid, {
@@ -324,7 +327,7 @@ class Page extends _instrumentation.SdkObject {
           progress.throwIfAborted();
           if (!handler.noWaitAfter) {
             progress.log(`  locator handler has finished, waiting for ${(0, _utils.asLocator)(this.attribution.playwright.options.sdkLanguage, handler.selector)} to be hidden`);
-            await this.mainFrame().waitForSelectorInternal(progress, handler.selector, {
+            await this.mainFrame().waitForSelectorInternal(progress, handler.selector, false, {
               state: 'hidden'
             });
           } else {
@@ -668,6 +671,7 @@ class PageBinding {
           context: page._browserContext
         }, handle);
       } else {
+        if (!Array.isArray(serializedArgs)) throw new Error(`serializedArgs is not an array. This can happen when Array.prototype.toJSON is defined incorrectly`);
         const args = serializedArgs.map(a => (0, _utilityScriptSerializers.parseEvaluationResultValue)(a));
         result = await binding.playwrightFunction({
           frame: context.frame,

package/lib/server/playwright.js

@@ -15,6 +15,7 @@ var _webkit = require("./webkit/webkit");
 var _instrumentation = require("./instrumentation");
 var _utils = require("../utils");
 var _debugController = require("./debugController");
+var _bidiChromium = require("./bidi/bidiChromium");
 var _bidiFirefox = require("./bidi/bidiFirefox");
 /**
  * Copyright (c) Microsoft Corporation.
@@ -42,9 +43,10 @@ class Playwright extends _instrumentation.SdkObject {
     this.chromium = void 0;
     this.android = void 0;
     this.electron = void 0;
-    this.bidi = void 0;
     this.firefox = void 0;
     this.webkit = void 0;
+    this.bidiChromium = void 0;
+    this.bidiFirefox = void 0;
     this.options = void 0;
     this.debugController = void 0;
     this._allPages = new Set();
@@ -61,7 +63,8 @@ class Playwright extends _instrumentation.SdkObject {
       }
     }, null);
     this.chromium = new _chromium.Chromium(this);
-    this.bidi = new _bidiFirefox.BidiFirefox(this);
+    this.bidiChromium = new _bidiChromium.BidiChromium(this);
+    this.bidiFirefox = new _bidiFirefox.BidiFirefox(this);
     this.firefox = new _firefox.Firefox(this);
     this.webkit = new _webkit.WebKit(this);
     this.electron = new _electron.Electron(this);

package/lib/server/recorder/contextRecorder.js

@@ -6,14 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.ContextRecorder = void 0;
 exports.generateFrameSelector = generateFrameSelector;
 var _events = require("events");
-var recorderSource = _interopRequireWildcard(require("../../generated/recorderSource"));
+var recorderSource = _interopRequireWildcard(require("../../generated/pollingRecorderSource"));
 var _utils = require("../../utils");
 var _timeoutRunner = require("../../utils/timeoutRunner");
 var _browserContext = require("../browserContext");
 var _languages = require("../codegen/languages");
 var _frames = require("../frames");
 var _page = require("../page");
-var _recorderRunner = require("./recorderRunner");
 var _throttledFile = require("./throttledFile");
 var _recorderCollection = require("./recorderCollection");
 var _language = require("../codegen/language");
@@ -36,14 +35,13 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 
 class ContextRecorder extends _events.EventEmitter {
-  constructor(context, params, delegate) {
+  constructor(codegenMode, context, params, delegate) {
     super();
     this._collection = void 0;
     this._pageAliases = new Map();
     this._lastPopupOrdinal = 0;
     this._lastDialogOrdinal = -1;
     this._lastDownloadOrdinal = -1;
-    this._timers = new Set();
     this._context = void 0;
     this._params = void 0;
     this._delegate = void 0;
@@ -51,6 +49,8 @@ class ContextRecorder extends _events.EventEmitter {
     this._throttledOutputFile = null;
     this._orderedLanguages = [];
     this._listeners = [];
+    this._codegenMode = void 0;
+    this._codegenMode = codegenMode;
     this._context = context;
     this._params = params;
     this._delegate = delegate;
@@ -63,7 +63,8 @@ class ContextRecorder extends _events.EventEmitter {
       browserName: context._browser.options.name,
       launchOptions: {
         headless: false,
-        ...params.launchOptions
+        ...params.launchOptions,
+        tracesDir: undefined
       },
       contextOptions: {
         ...params.contextOptions
@@ -71,8 +72,8 @@ class ContextRecorder extends _events.EventEmitter {
       deviceName: params.device,
       saveStorage: params.saveStorage
     };
-    const collection = new _recorderCollection.RecorderCollection(params.mode === 'recording');
-    collection.on('change', () => {
+    this._collection = new _recorderCollection.RecorderCollection(this._pageAliases);
+    this._collection.on('change', actions => {
       this._recorderSources = [];
       for (const languageGenerator of this._orderedLanguages) {
         var _this$_throttledOutpu;
@@ -81,7 +82,7 @@ class ContextRecorder extends _events.EventEmitter {
           footer,
           actionTexts,
           text
-        } = (0, _language.generateCode)(collection.actions(), languageGenerator, languageGeneratorOptions);
+        } = (0, _language.generateCode)(actions, languageGenerator, languageGeneratorOptions);
         const source = {
           isRecorded: true,
           label: languageGenerator.name,
@@ -100,7 +101,7 @@ class ContextRecorder extends _events.EventEmitter {
       }
       this.emit(ContextRecorder.Events.Change, {
         sources: this._recorderSources,
-        primaryFileName: this._orderedLanguages[0].id
+        actions
       });
     });
     context.on(_browserContext.BrowserContext.Events.BeforeClose, () => {
@@ -111,7 +112,7 @@ class ContextRecorder extends _events.EventEmitter {
       var _this$_throttledOutpu3;
       (_this$_throttledOutpu3 = this._throttledOutputFile) === null || _this$_throttledOutpu3 === void 0 || _this$_throttledOutpu3.flush();
     }));
-    this._collection = collection;
+    this.setEnabled(true);
   }
   setOutput(codegenId, outputFile) {
     var _this$_collection;
@@ -144,23 +145,29 @@ class ContextRecorder extends _events.EventEmitter {
   }
   setEnabled(enabled) {
     this._collection.setEnabled(enabled);
+    if (this._codegenMode === 'trace-events') {
+      if (enabled) this._context.tracing.startChunk({
+        name: 'trace',
+        title: 'trace'
+      }).catch(() => {});else this._context.tracing.stopChunk({
+        mode: 'discard'
+      }).catch(() => {});
+    }
   }
   dispose() {
-    for (const timer of this._timers) clearTimeout(timer);
-    this._timers.clear();
     _utils.eventsHelper.removeEventListeners(this._listeners);
   }
   async _onPage(page) {
     // First page is called page, others are called popup1, popup2, etc.
     const frame = page.mainFrame();
     page.on('close', () => {
-      this._collection.addAction({
+      this._collection.addRecordedAction({
         frame: this._describeMainFrame(page),
-        committed: true,
         action: {
           name: 'closePage',
           signals: []
-        }
+        },
+        startTime: (0, _utils.monotonicTime)()
       });
       this._pageAliases.delete(page);
     });
@@ -174,14 +181,14 @@ class ContextRecorder extends _events.EventEmitter {
     if (page.opener()) {
       this._onPopup(page.opener(), page);
     } else {
-      this._collection.addAction({
+      this._collection.addRecordedAction({
         frame: this._describeMainFrame(page),
-        committed: true,
         action: {
           name: 'openPage',
           url: page.mainFrame().url(),
           signals: []
-        }
+        },
+        startTime: (0, _utils.monotonicTime)()
       });
     }
   }
@@ -206,47 +213,23 @@ class ContextRecorder extends _events.EventEmitter {
   testIdAttributeName() {
     return this._params.testIdAttributeName || this._context.selectors().testIdAttributeName() || 'data-testid';
   }
-  async _performAction(frame, action) {
+  async _createActionInContext(frame, action) {
     var _this$_delegate$rewri, _this$_delegate;
-    // Commit last action so that no further signals are added to it.
-    this._collection.commitLastAction();
     const frameDescription = await this._describeFrame(frame);
     const actionInContext = {
       frame: frameDescription,
       action,
-      description: undefined
+      description: undefined,
+      startTime: (0, _utils.monotonicTime)()
     };
     await ((_this$_delegate$rewri = (_this$_delegate = this._delegate).rewriteActionInContext) === null || _this$_delegate$rewri === void 0 ? void 0 : _this$_delegate$rewri.call(_this$_delegate, this._pageAliases, actionInContext));
-    this._collection.willPerformAction(actionInContext);
-    const success = await (0, _recorderRunner.performAction)(this._pageAliases, actionInContext);
-    if (success) {
-      this._collection.didPerformAction(actionInContext);
-      this._setCommittedAfterTimeout(actionInContext);
-    } else {
-      this._collection.performedActionFailed(actionInContext);
-    }
+    return actionInContext;
   }
-  async _recordAction(frame, action) {
-    var _this$_delegate$rewri2, _this$_delegate2;
-    // Commit last action so that no further signals are added to it.
-    this._collection.commitLastAction();
-    const frameDescription = await this._describeFrame(frame);
-    const actionInContext = {
-      frame: frameDescription,
-      action,
-      description: undefined
-    };
-    await ((_this$_delegate$rewri2 = (_this$_delegate2 = this._delegate).rewriteActionInContext) === null || _this$_delegate$rewri2 === void 0 ? void 0 : _this$_delegate$rewri2.call(_this$_delegate2, this._pageAliases, actionInContext));
-    this._setCommittedAfterTimeout(actionInContext);
-    this._collection.addAction(actionInContext);
+  async _performAction(frame, action) {
+    await this._collection.performAction(await this._createActionInContext(frame, action));
   }
-  _setCommittedAfterTimeout(actionInContext) {
-    const timer = setTimeout(() => {
-      // Commit the action after 5 seconds so that no further signals are added to it.
-      actionInContext.committed = true;
-      this._timers.delete(timer);
-    }, (0, _utils.isUnderTest)() ? 500 : 5000);
-    this._timers.add(timer);
+  async _recordAction(frame, action) {
+    this._collection.addRecordedAction(await this._createActionInContext(frame, action));
   }
   _onFrameNavigated(frame, page) {
     const pageAlias = this._pageAliases.get(page);

package/lib/server/recorder/recorderApp.js

@@ -30,25 +30,30 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  */
 
 class EmptyRecorderApp extends _events.EventEmitter {
+  constructor(...args) {
+    super(...args);
+    this.wsEndpointForTest = void 0;
+  }
   async close() {}
   async setPaused(paused) {}
   async setMode(mode) {}
-  async setFileIfNeeded(file) {}
+  async setRunningFile(file) {}
   async setSelector(selector, userGesture) {}
   async updateCallLogs(callLogs) {}
   async setSources(sources) {}
+  async setActions(actions, sources) {}
 }
 exports.EmptyRecorderApp = EmptyRecorderApp;
 class RecorderApp extends _events.EventEmitter {
   constructor(recorder, page, wsEndpoint) {
     super();
     this._page = void 0;
-    this.wsEndpoint = void 0;
+    this.wsEndpointForTest = void 0;
     this._recorder = void 0;
     this.setMaxListeners(0);
     this._recorder = recorder;
     this._page = page;
-    this.wsEndpoint = wsEndpoint;
+    this.wsEndpointForTest = wsEndpoint;
   }
   async close() {
     await this._page.context().close({
@@ -63,7 +68,6 @@ class RecorderApp extends _events.EventEmitter {
       const file = require.resolve('../../vite/recorder/' + uri);
       _fs.default.promises.readFile(file).then(buffer => {
         route.fulfill({
-          requestUrl: route.request().url(),
           status: 200,
           headers: [{
             name: 'Content-Type',
@@ -114,9 +118,8 @@ class RecorderApp extends _events.EventEmitter {
       persistentContextOptions: {
         noDefaultViewport: true,
         headless: !!process.env.PWTEST_CLI_HEADLESS || (0, _utils.isUnderTest)() && !headed,
-        useWebSocket: !!process.env.PWTEST_RECORDER_PORT,
-        handleSIGINT: false,
-        args: process.env.PWTEST_RECORDER_PORT ? [`--remote-debugging-port=${process.env.PWTEST_RECORDER_PORT}`] : [],
+        useWebSocket: (0, _utils.isUnderTest)(),
+        handleSIGINT: recorder.handleSIGINT,
         executablePath: inspectedContext._browser.options.isChromium ? inspectedContext._browser.options.customExecutablePath : undefined
       }
     });
@@ -135,9 +138,9 @@ class RecorderApp extends _events.EventEmitter {
       isFunction: true
     }, mode).catch(() => {});
   }
-  async setFileIfNeeded(file) {
+  async setRunningFile(file) {
     await this._page.mainFrame().evaluateExpression((file => {
-      window.playwrightSetFileIfNeeded(file);
+      window.playwrightSetRunningFile(file);
     }).toString(), {
       isFunction: true
     }, file).catch(() => {});
@@ -157,8 +160,11 @@ class RecorderApp extends _events.EventEmitter {
     }, sources).catch(() => {});
 
     // Testing harness for runCLI mode.
-    if (process.env.PWTEST_CLI_IS_UNDER_TEST && sources.length) process._didSetSourcesForTest(sources[0].text);
+    if (process.env.PWTEST_CLI_IS_UNDER_TEST && sources.length) {
+      if (process._didSetSourcesForTest(sources[0].text)) this.close();
+    }
   }
+  async setActions(actions, sources) {}
   async setSelector(selector, userGesture) {
     if (userGesture) {
       var _this$_recorder;