patchright-core 1.49.2 → 1.50.1

package/lib/server/recorder/chat.js

@@ -0,0 +1,177 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Chat = void 0;
+exports.asString = asString;
+var _transport = require("../transport");
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class Chat {
+  constructor(wsEndpoint) {
+    this._history = [];
+    this._connectionPromise = void 0;
+    this._chatSinks = new Map();
+    this._wsEndpoint = void 0;
+    this._wsEndpoint = wsEndpoint;
+  }
+  clearHistory() {
+    this._history = [];
+  }
+  async post(prompt) {
+    await this._append('user', prompt);
+    let text = await asString(await this._post());
+    if (text.startsWith('```json') && text.endsWith('```')) text = text.substring('```json'.length, text.length - '```'.length);
+    for (let i = 0; i < 3; ++i) {
+      try {
+        return JSON.parse(text);
+      } catch (e) {
+        await this._append('user', String(e));
+      }
+    }
+    throw new Error('Failed to parse response: ' + text);
+  }
+  async _append(user, content) {
+    this._history.push({
+      user,
+      content
+    });
+  }
+  async _connection() {
+    if (!this._connectionPromise) {
+      this._connectionPromise = _transport.WebSocketTransport.connect(undefined, this._wsEndpoint).then(transport => {
+        return new Connection(transport, (method, params) => this._dispatchEvent(method, params), () => {});
+      });
+    }
+    return this._connectionPromise;
+  }
+  _dispatchEvent(method, params) {
+    if (method === 'chatChunk') {
+      const {
+        chatId,
+        chunk
+      } = params;
+      const chunkSink = this._chatSinks.get(chatId);
+      chunkSink(chunk);
+      if (!chunk) this._chatSinks.delete(chatId);
+    }
+  }
+  async _post() {
+    const connection = await this._connection();
+    const result = await connection.send('chat', {
+      history: this._history
+    });
+    const {
+      chatId
+    } = result;
+    const {
+      iterable,
+      addChunk
+    } = iterablePump();
+    this._chatSinks.set(chatId, addChunk);
+    return iterable;
+  }
+}
+exports.Chat = Chat;
+async function asString(stream) {
+  let result = '';
+  for await (const chunk of stream) result += chunk;
+  return result;
+}
+function iterablePump() {
+  let controller;
+  const stream = new ReadableStream({
+    start: c => controller = c
+  });
+  const iterable = async function* () {
+    const reader = stream.getReader();
+    while (true) {
+      const {
+        done,
+        value
+      } = await reader.read();
+      if (done) break;
+      yield value;
+    }
+  }();
+  return {
+    iterable,
+    addChunk: chunk => {
+      if (chunk) controller.enqueue(chunk);else controller.close();
+    }
+  };
+}
+class Connection {
+  constructor(transport, onEvent, onClose) {
+    this._transport = void 0;
+    this._lastId = 0;
+    this._closed = false;
+    this._pending = new Map();
+    this._onEvent = void 0;
+    this._onClose = void 0;
+    this._transport = transport;
+    this._onEvent = onEvent;
+    this._onClose = onClose;
+    this._transport.onmessage = this._dispatchMessage.bind(this);
+    this._transport.onclose = this._close.bind(this);
+  }
+  send(method, params) {
+    const id = this._lastId++;
+    const message = {
+      id,
+      method,
+      params
+    };
+    this._transport.send(message);
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, {
+        resolve,
+        reject
+      });
+    });
+  }
+  _dispatchMessage(message) {
+    if (message.id === undefined) {
+      this._onEvent(message.method, message.params);
+      return;
+    }
+    const callback = this._pending.get(message.id);
+    this._pending.delete(message.id);
+    if (!callback) return;
+    if (message.error) {
+      callback.reject(new Error(message.error.message));
+      return;
+    }
+    callback.resolve(message.result);
+  }
+  _close() {
+    this._closed = true;
+    this._transport.onmessage = undefined;
+    this._transport.onclose = undefined;
+    for (const {
+      reject
+    } of this._pending.values()) reject(new Error('Connection closed'));
+    this._onClose();
+  }
+  isClosed() {
+    return this._closed;
+  }
+  close() {
+    if (!this._closed) this._transport.close();
+  }
+}

package/lib/server/recorder/contextRecorder.js

@@ -35,7 +35,7 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 
 class ContextRecorder extends _events.EventEmitter {
-  constructor(codegenMode, context, params, delegate) {
+  constructor(context, params, delegate) {
     super();
     this._collection = void 0;
     this._pageAliases = new Map();
@@ -49,8 +49,6 @@ 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;
@@ -112,7 +110,7 @@ class ContextRecorder extends _events.EventEmitter {
       var _this$_throttledOutpu3;
       (_this$_throttledOutpu3 = this._throttledOutputFile) === null || _this$_throttledOutpu3 === void 0 || _this$_throttledOutpu3.flush();
     }));
-    this.setEnabled(true);
+    this.setEnabled(params.mode === 'recording');
   }
   setOutput(codegenId, outputFile) {
     var _this$_collection;
@@ -145,14 +143,6 @@ 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() {
     _utils.eventsHelper.removeEventListeners(this._listeners);
@@ -198,6 +188,9 @@ class ContextRecorder extends _events.EventEmitter {
       for (const page of this._context.pages()) this._onFrameNavigated(page.mainFrame(), page);
     }
   }
+  runTask(task) {
+    // TODO: implement
+  }
   _describeMainFrame(page) {
     return {
       pageAlias: this._pageAliases.get(page),
@@ -289,9 +282,7 @@ async function generateFrameSelectorInParent(parent, frame) {
         return injected.generateSelectorSimple(element);
       }, frameElement);
       return selector;
-    } catch (e) {
-      return e.toString();
-    }
+    } catch (e) {}
   }, (0, _utils.monotonicTime)() + 2000);
   if (!result.timedOut && result.result) return result.result;
   if (frame.name()) return `iframe[name=${(0, _utils.quoteCSSAttributeValue)(frame.name())}]`;

package/lib/server/recorder/recorderApp.js

@@ -87,7 +87,7 @@ class RecorderApp extends _events.EventEmitter {
       }).catch(() => {});
     });
     const mainFrame = this._page.mainFrame();
-    await mainFrame.goto((0, _instrumentation.serverSideCallMetadata)(), 'https://playwright/index.html');
+    await mainFrame.goto((0, _instrumentation.serverSideCallMetadata)(), process.env.PW_HMR ? 'http://localhost:44225' : 'https://playwright/index.html');
   }
   static factory(context) {
     return async recorder => {

package/lib/server/recorder/recorderCollection.js

@@ -7,7 +7,6 @@ exports.RecorderCollection = void 0;
 var _events = require("events");
 var _time = require("../../utils/time");
 var _recorderUtils = require("./recorderUtils");
-var _errors = require("../errors");
 var _recorderRunner = require("./recorderRunner");
 var _debug = require("../../utils/debug");
 /**
@@ -42,8 +41,8 @@ class RecorderCollection extends _events.EventEmitter {
     this._enabled = enabled;
   }
   async performAction(actionInContext) {
-    await this._addAction(actionInContext, async callMetadata => {
-      await (0, _recorderRunner.performAction)(callMetadata, this._pageAliases, actionInContext);
+    await this._addAction(actionInContext, async () => {
+      await (0, _recorderRunner.performAction)(this._pageAliases, actionInContext);
     });
   }
   addRecordedAction(actionInContext) {
@@ -61,21 +60,10 @@ class RecorderCollection extends _events.EventEmitter {
       this._fireChange();
       return;
     }
-    const {
-      callMetadata,
-      mainFrame
-    } = (0, _recorderUtils.callMetadataForAction)(this._pageAliases, actionInContext);
-    await mainFrame.instrumentation.onBeforeCall(mainFrame, callMetadata);
     this._actions.push(actionInContext);
     this._fireChange();
-    const error = await (callback === null || callback === void 0 ? void 0 : callback(callMetadata).catch(e => e));
-    callMetadata.endTime = (0, _time.monotonicTime)();
-    actionInContext.endTime = callMetadata.endTime;
-    callMetadata.error = error ? (0, _errors.serializeError)(error) : undefined;
-    // Do not wait for onAfterCall so that performAction returned immediately after the action.
-    mainFrame.instrumentation.onAfterCall(mainFrame, callMetadata).then(() => {
-      this._fireChange();
-    }).catch(() => {});
+    await (callback === null || callback === void 0 ? void 0 : callback().catch());
+    actionInContext.endTime = (0, _time.monotonicTime)();
   }
   signal(pageAlias, frame, signal) {
     if (!this._enabled) return;
@@ -84,7 +72,7 @@ class RecorderCollection extends _events.EventEmitter {
       const lastAction = this._actions[this._actions.length - 1];
       const signalThreshold = (0, _debug.isUnderTest)() ? 500 : 5000;
       let generateGoto = false;
-      if (!lastAction) generateGoto = true;else if (lastAction.action.name !== 'click' && lastAction.action.name !== 'press') generateGoto = true;else if (timestamp - lastAction.startTime > signalThreshold) generateGoto = true;
+      if (!lastAction) generateGoto = true;else if (lastAction.action.name !== 'click' && lastAction.action.name !== 'press' && lastAction.action.name !== 'fill') generateGoto = true;else if (timestamp - lastAction.startTime > signalThreshold) generateGoto = true;
       if (generateGoto) {
         this.addRecordedAction({
           frame: {

package/lib/server/recorder/recorderRunner.js

@@ -7,8 +7,8 @@ exports.performAction = performAction;
 exports.toClickOptions = toClickOptions;
 var _utils = require("../../utils");
 var _language = require("../codegen/language");
+var _instrumentation = require("../instrumentation");
 var _recorderUtils = require("./recorderUtils");
-var _recorderUtils2 = require("../../utils/isomorphic/recorderUtils");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -25,7 +25,8 @@ var _recorderUtils2 = require("../../utils/isomorphic/recorderUtils");
  * limitations under the License.
  */
 
-async function performAction(callMetadata, pageAliases, actionInContext) {
+async function performAction(pageAliases, actionInContext) {
+  const callMetadata = (0, _instrumentation.serverSideCallMetadata)();
   const mainFrame = (0, _recorderUtils.mainFrameForAction)(pageAliases, actionInContext);
   const {
     action
@@ -42,7 +43,7 @@ async function performAction(callMetadata, pageAliases, actionInContext) {
     await mainFrame._page.close(callMetadata);
     return;
   }
-  const selector = (0, _recorderUtils2.buildFullSelector)(actionInContext.frame.framePath, action.selector);
+  const selector = (0, _recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);
   if (action.name === 'click') {
     const options = toClickOptions(action);
     await mainFrame.click(callMetadata, selector, {
@@ -105,6 +106,9 @@ async function performAction(callMetadata, pageAliases, actionInContext) {
     await mainFrame.expect(callMetadata, selector, {
       selector,
       expression: 'to.be.checked',
+      expectedValue: {
+        checked: action.checked
+      },
       isNot: !action.checked,
       timeout: kActionTimeout
     });

package/lib/server/recorder/recorderUtils.js

@@ -3,13 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.callMetadataForAction = callMetadataForAction;
+exports.buildFullSelector = buildFullSelector;
 exports.collapseActions = collapseActions;
 exports.frameForAction = frameForAction;
 exports.mainFrameForAction = mainFrameForAction;
 exports.metadataToCallLog = metadataToCallLog;
-var _utils = require("../../utils");
-var _recorderUtils = require("../../utils/isomorphic/recorderUtils");
 /**
  * Copyright (c) Microsoft Corporation.
  *
@@ -26,6 +24,9 @@ var _recorderUtils = require("../../utils/isomorphic/recorderUtils");
  * limitations under the License.
  */
 
+function buildFullSelector(framePath, selector) {
+  return [...framePath, selector].join(' >> internal:control=enter-frame >> ');
+}
 function metadataToCallLog(metadata, status) {
   var _metadata$params, _metadata$params2, _metadata$error;
   let title = metadata.apiName || metadata.method;
@@ -64,36 +65,11 @@ async function frameForAction(pageAliases, actionInContext, action) {
   const pageAlias = actionInContext.frame.pageAlias;
   const page = (_find2 = [...pageAliases.entries()].find(([, alias]) => pageAlias === alias)) === null || _find2 === void 0 ? void 0 : _find2[0];
   if (!page) throw new Error('Internal error: page not found');
-  const fullSelector = (0, _recorderUtils.buildFullSelector)(actionInContext.frame.framePath, action.selector);
+  const fullSelector = buildFullSelector(actionInContext.frame.framePath, action.selector);
   const result = await page.mainFrame().selectors.resolveFrameForSelector(fullSelector);
   if (!result) throw new Error('Internal error: frame not found');
   return result.frame;
 }
-function callMetadataForAction(pageAliases, actionInContext) {
-  const mainFrame = mainFrameForAction(pageAliases, actionInContext);
-  const {
-    method,
-    apiName,
-    params
-  } = (0, _recorderUtils.traceParamsForAction)(actionInContext);
-  const callMetadata = {
-    id: `call@${(0, _utils.createGuid)()}`,
-    apiName,
-    objectId: mainFrame.guid,
-    pageId: mainFrame._page.guid,
-    frameId: mainFrame.guid,
-    startTime: actionInContext.startTime,
-    endTime: 0,
-    type: 'Frame',
-    method,
-    params,
-    log: []
-  };
-  return {
-    callMetadata,
-    mainFrame
-  };
-}
 function collapseActions(actions) {
   const result = [];
   for (const action of actions) {

package/lib/server/recorder.js

@@ -12,7 +12,6 @@ var _browserContext = require("./browserContext");
 var _debugger = require("./debugger");
 var _contextRecorder = require("./recorder/contextRecorder");
 var _recorderUtils = require("./recorder/recorderUtils");
-var _recorderUtils2 = require("../utils/isomorphic/recorderUtils");
 var _selectorParser = require("../utils/isomorphic/selectorParser");
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
@@ -36,26 +35,26 @@ const recorderSymbol = Symbol('recorderSymbol');
 class Recorder {
   static async showInspector(context, params, recorderAppFactory) {
     if ((0, _utils.isUnderTest)()) params.language = process.env.TEST_INSPECTOR_LANGUAGE;
-    return await Recorder.show('actions', context, recorderAppFactory, params);
+    return await Recorder.show(context, recorderAppFactory, params);
   }
   static showInspectorNoReply(context, recorderAppFactory) {
     Recorder.showInspector(context, {}, recorderAppFactory).catch(() => {});
   }
-  static show(codegenMode, context, recorderAppFactory, params) {
+  static show(context, recorderAppFactory, params) {
     let recorderPromise = context[recorderSymbol];
     if (!recorderPromise) {
-      recorderPromise = Recorder._create(codegenMode, context, recorderAppFactory, params);
+      recorderPromise = Recorder._create(context, recorderAppFactory, params);
       context[recorderSymbol] = recorderPromise;
     }
     return recorderPromise;
   }
-  static async _create(codegenMode, context, recorderAppFactory, params = {}) {
-    const recorder = new Recorder(codegenMode, context, params);
+  static async _create(context, recorderAppFactory, params = {}) {
+    const recorder = new Recorder(context, params);
     const recorderApp = await recorderAppFactory(recorder);
     await recorder._install(recorderApp);
     return recorder;
   }
-  constructor(codegenMode, context, params) {
+  constructor(context, params) {
     this.handleSIGINT = void 0;
     this._context = void 0;
     this._mode = void 0;
@@ -73,7 +72,7 @@ class Recorder {
     this._currentLanguage = void 0;
     this._mode = params.mode || 'none';
     this.handleSIGINT = params.handleSIGINT;
-    this._contextRecorder = new _contextRecorder.ContextRecorder(codegenMode, context, params, {});
+    this._contextRecorder = new _contextRecorder.ContextRecorder(context, params, {});
     this._context = context;
     this._omitCallTracking = !!params.omitCallTracking;
     this._debugger = context.debugger();
@@ -121,6 +120,10 @@ class Recorder {
         this._contextRecorder.clearScript();
         return;
       }
+      if (data.event === 'runTask') {
+        this._contextRecorder.runTask(data.params.task);
+        return;
+      }
     });
     await Promise.all([recorderApp.setMode(this._mode), recorderApp.setPaused(this._debugger.isPaused()), this._pushAllSources()]);
     this._context.once(_browserContext.BrowserContext.Events.Close, () => {
@@ -165,7 +168,7 @@ class Recorder {
       var _this$_recorderApp2;
       const selectorChain = await (0, _contextRecorder.generateFrameSelector)(frame);
       await ((_this$_recorderApp2 = this._recorderApp) === null || _this$_recorderApp2 === void 0 ? void 0 : _this$_recorderApp2.elementPicked({
-        selector: (0, _recorderUtils2.buildFullSelector)(selectorChain, elementInfo.selector),
+        selector: (0, _recorderUtils.buildFullSelector)(selectorChain, elementInfo.selector),
         ariaSnapshot: elementInfo.ariaSnapshot
       }, true));
     });

package/lib/server/registry/browserFetcher.js

@@ -41,7 +41,7 @@ async function downloadBrowserWithProgressBar(title, browserDirectory, executabl
   }
   const zipPath = _path.default.join(_os.default.tmpdir(), downloadFileName);
   try {
-    const retryCount = 3;
+    const retryCount = 5;
     for (let attempt = 1; attempt <= retryCount; ++attempt) {
       _debugLogger.debugLogger.log('install', `downloading ${title} - attempt #${attempt}`);
       const url = downloadURLs[(attempt - 1) % downloadURLs.length];

package/lib/server/registry/dependencies.js

@@ -104,7 +104,7 @@ async function installDependenciesLinux(targets, dryRun) {
   for (const target of targets) {
     const info = _nativeDeps.deps[platform];
     if (!info) {
-      console.warn(`Cannot install dependencies for ${platform}!`); // eslint-disable-line no-console
+      console.warn(`Cannot install dependencies for ${platform} with Playwright ${(0, _userAgent.getPlaywrightVersion)()}!`); // eslint-disable-line no-console
       return;
     }
     libraries.push(...info[target]);
@@ -132,11 +132,11 @@ async function installDependenciesLinux(targets, dryRun) {
     child.on('error', reject);
   });
 }
-async function validateDependenciesWindows(windowsExeAndDllDirectories) {
+async function validateDependenciesWindows(sdkLanguage, windowsExeAndDllDirectories) {
   const directoryPaths = windowsExeAndDllDirectories;
   const lddPaths = [];
   for (const directoryPath of directoryPaths) lddPaths.push(...(await executablesOrSharedLibraries(directoryPath)));
-  const allMissingDeps = await Promise.all(lddPaths.map(lddPath => missingFileDependenciesWindows(lddPath)));
+  const allMissingDeps = await Promise.all(lddPaths.map(lddPath => missingFileDependenciesWindows(sdkLanguage, lddPath)));
   const missingDeps = new Set();
   for (const deps of allMissingDeps) {
     for (const dep of deps) missingDeps.add(dep);
@@ -238,8 +238,8 @@ async function executablesOrSharedLibraries(directoryPath) {
   }))).filter(Boolean);
   return executablersOrLibraries;
 }
-async function missingFileDependenciesWindows(filePath) {
-  const executable = _path.default.join(__dirname, '..', '..', '..', 'bin', 'PrintDeps.exe');
+async function missingFileDependenciesWindows(sdkLanguage, filePath) {
+  const executable = _.registry.findExecutable('winldd').executablePathOrDie(sdkLanguage);
   const dirname = _path.default.dirname(filePath);
   const {
     stdout,