@checkly/playwright-core 1.42.17 → 1.47.11

package/lib/utils/crypto.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.calculateSha1 = calculateSha1;
 exports.createGuid = createGuid;
+exports.generateSelfSignedCertificate = generateSelfSignedCertificate;
 var _crypto = _interopRequireDefault(require("crypto"));
+var _debug = require("./debug");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright (c) Microsoft Corporation.
@@ -30,4 +32,143 @@ function calculateSha1(buffer) {
   const hash = _crypto.default.createHash('sha1');
   hash.update(buffer);
   return hash.digest('hex');
+}
+
+// Variable-length quantity encoding aka. base-128 encoding
+function encodeBase128(value) {
+  const bytes = [];
+  do {
+    let byte = value & 0x7f;
+    value >>>= 7;
+    if (bytes.length > 0) byte |= 0x80;
+    bytes.push(byte);
+  } while (value > 0);
+  return Buffer.from(bytes.reverse());
+}
+;
+
+// ASN1/DER Speficiation:   https://www.itu.int/rec/T-REC-X.680-X.693-202102-I/en
+class DER {
+  static encodeSequence(data) {
+    return this._encode(0x30, Buffer.concat(data));
+  }
+  static encodeInteger(data) {
+    (0, _debug.assert)(data >= -128 && data <= 127);
+    return this._encode(0x02, Buffer.from([data]));
+  }
+  static encodeObjectIdentifier(oid) {
+    const parts = oid.split('.').map(v => Number(v));
+    // Encode the second part, which could be large, using base-128 encoding if necessary
+    const output = [encodeBase128(40 * parts[0] + parts[1])];
+    for (let i = 2; i < parts.length; i++) {
+      output.push(encodeBase128(parts[i]));
+    }
+    return this._encode(0x06, Buffer.concat(output));
+  }
+  static encodeNull() {
+    return Buffer.from([0x05, 0x00]);
+  }
+  static encodeSet(data) {
+    (0, _debug.assert)(data.length === 1, 'Only one item in the set is supported. We\'d need to sort the data to support more.');
+    // We expect the data to be already sorted.
+    return this._encode(0x31, Buffer.concat(data));
+  }
+  static encodeExplicitContextDependent(tag, data) {
+    return this._encode(0xa0 + tag, data);
+  }
+  static encodePrintableString(data) {
+    return this._encode(0x13, Buffer.from(data));
+  }
+  static encodeBitString(data) {
+    // The first byte of the content is the number of unused bits at the end
+    const unusedBits = 0; // Assuming all bits are used
+    const content = Buffer.concat([Buffer.from([unusedBits]), data]);
+    return this._encode(0x03, content);
+  }
+  static encodeDate(date) {
+    const year = date.getUTCFullYear();
+    const isGeneralizedTime = year >= 2050;
+    const parts = [isGeneralizedTime ? year.toString() : year.toString().slice(-2), (date.getUTCMonth() + 1).toString().padStart(2, '0'), date.getUTCDate().toString().padStart(2, '0'), date.getUTCHours().toString().padStart(2, '0'), date.getUTCMinutes().toString().padStart(2, '0'), date.getUTCSeconds().toString().padStart(2, '0')];
+    const encodedDate = parts.join('') + 'Z';
+    const tag = isGeneralizedTime ? 0x18 : 0x17; // 0x18 for GeneralizedTime, 0x17 for UTCTime
+    return this._encode(tag, Buffer.from(encodedDate));
+  }
+  static _encode(tag, data) {
+    const lengthBytes = this._encodeLength(data.length);
+    return Buffer.concat([Buffer.from([tag]), lengthBytes, data]);
+  }
+  static _encodeLength(length) {
+    if (length < 128) {
+      return Buffer.from([length]);
+    } else {
+      const lengthBytes = [];
+      while (length > 0) {
+        lengthBytes.unshift(length & 0xFF);
+        length >>= 8;
+      }
+      return Buffer.from([0x80 | lengthBytes.length, ...lengthBytes]);
+    }
+  }
+}
+
+// X.509 Specification: https://datatracker.ietf.org/doc/html/rfc2459#section-4.1
+function generateSelfSignedCertificate() {
+  const {
+    privateKey,
+    publicKey
+  } = _crypto.default.generateKeyPairSync('rsa', {
+    modulusLength: 2048
+  });
+  const publicKeyDer = publicKey.export({
+    type: 'pkcs1',
+    format: 'der'
+  });
+  const oneYearInMilliseconds = 365 * 24 * 60 * 60 * 1_000;
+  const notBefore = new Date(new Date().getTime() - oneYearInMilliseconds);
+  const notAfter = new Date(new Date().getTime() + oneYearInMilliseconds);
+
+  // List of fields / structure: https://datatracker.ietf.org/doc/html/rfc2459#section-4.1
+  const tbsCertificate = DER.encodeSequence([DER.encodeExplicitContextDependent(0, DER.encodeInteger(1)),
+  // version
+  DER.encodeInteger(1),
+  // serialNumber
+  DER.encodeSequence([DER.encodeObjectIdentifier('1.2.840.113549.1.1.11'),
+  // sha256WithRSAEncryption PKCS #1
+  DER.encodeNull()]),
+  // signature
+  DER.encodeSequence([DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.3'),
+  // commonName X.520 DN component
+  DER.encodePrintableString('localhost')])]), DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.10'),
+  // organizationName X.520 DN component
+  DER.encodePrintableString('Playwright Client Certificate Support')])])]),
+  // issuer
+  DER.encodeSequence([DER.encodeDate(notBefore),
+  // notBefore
+  DER.encodeDate(notAfter) // notAfter
+  ]),
+  // validity
+  DER.encodeSequence([DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.3'),
+  // commonName X.520 DN component
+  DER.encodePrintableString('localhost')])]), DER.encodeSet([DER.encodeSequence([DER.encodeObjectIdentifier('2.5.4.10'),
+  // organizationName X.520 DN component
+  DER.encodePrintableString('Playwright Client Certificate Support')])])]),
+  // subject
+  DER.encodeSequence([DER.encodeSequence([DER.encodeObjectIdentifier('1.2.840.113549.1.1.1'),
+  // rsaEncryption PKCS #1
+  DER.encodeNull()]), DER.encodeBitString(publicKeyDer)]) // SubjectPublicKeyInfo
+  ]);
+  const signature = _crypto.default.sign('sha256', tbsCertificate, privateKey);
+  const certificate = DER.encodeSequence([tbsCertificate, DER.encodeSequence([DER.encodeObjectIdentifier('1.2.840.113549.1.1.11'),
+  // sha256WithRSAEncryption PKCS #1
+  DER.encodeNull()]), DER.encodeBitString(signature)]);
+  const certPem = ['-----BEGIN CERTIFICATE-----',
+  // Split the base64 string into lines of 64 characters
+  certificate.toString('base64').match(/.{1,64}/g).join('\n'), '-----END CERTIFICATE-----'].join('\n');
+  return {
+    cert: certPem,
+    key: privateKey.export({
+      type: 'pkcs1',
+      format: 'pem'
+    })
+  };
 }

package/lib/utils/debugLogger.js

@@ -36,6 +36,8 @@ const debugLoggerColorMap = {
   // reset
   'socks': 92,
   // purple
+  'client-certificates': 92,
+  // purple
   'error': 160,
   // red,
   'channel': 33,

package/lib/utils/env.js

@@ -29,9 +29,11 @@ function getFromENV(name) {
   value = value === undefined ? process.env[`npm_package_config_${name.toLowerCase()}`] : value;
   return value;
 }
-function getAsBooleanFromENV(name) {
+function getAsBooleanFromENV(name, defaultValue) {
   const value = getFromENV(name);
-  return !!value && value !== 'false' && value !== '0';
+  if (value === 'false' || value === '0') return false;
+  if (value) return true;
+  return !!defaultValue;
 }
 function getPackageManager() {
   const env = process.env.npm_config_user_agent || '';

package/lib/utils/expectUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.serializeExpectedTextValues = serializeExpectedTextValues;
+var _rtti = require("./rtti");
+/**
+ * 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.
+ */
+
+function serializeExpectedTextValues(items, options = {}) {
+  return items.map(i => ({
+    string: (0, _rtti.isString)(i) ? i : undefined,
+    regexSource: (0, _rtti.isRegExp)(i) ? i.source : undefined,
+    regexFlags: (0, _rtti.isRegExp)(i) ? i.flags : undefined,
+    matchSubstring: options.matchSubstring,
+    ignoreCase: options.ignoreCase,
+    normalizeWhiteSpace: options.normalizeWhiteSpace
+  }));
+}

package/lib/utils/fileUtils.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.SerializedFS = void 0;
 exports.canAccessFile = canAccessFile;
 exports.copyFileAndMakeWritable = copyFileAndMakeWritable;
 exports.fileUploadSizeLimit = exports.existsAsync = void 0;
@@ -12,6 +13,8 @@ exports.sanitizeForFilePath = sanitizeForFilePath;
 exports.toPosixPath = toPosixPath;
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
+var _manualPromise = require("./manualPromise");
+var _zipBundle = require("../zipBundle");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright (c) Microsoft Corporation.
@@ -63,4 +66,140 @@ function sanitizeForFilePath(s) {
 }
 function toPosixPath(aPath) {
   return aPath.split(_path.default.sep).join(_path.default.posix.sep);
-}
+}
+class SerializedFS {
+  constructor() {
+    this._buffers = new Map();
+    // Should never be accessed from within appendOperation.
+    this._error = void 0;
+    this._operations = [];
+    this._operationsDone = void 0;
+    this._operationsDone = new _manualPromise.ManualPromise();
+    this._operationsDone.resolve(); // No operations scheduled yet.
+  }
+  mkdir(dir) {
+    this._appendOperation({
+      op: 'mkdir',
+      dir
+    });
+  }
+  writeFile(file, content, skipIfExists) {
+    this._buffers.delete(file); // No need to flush the buffer since we'll overwrite anyway.
+    this._appendOperation({
+      op: 'writeFile',
+      file,
+      content,
+      skipIfExists
+    });
+  }
+  appendFile(file, text, flush) {
+    if (!this._buffers.has(file)) this._buffers.set(file, []);
+    this._buffers.get(file).push(text);
+    if (flush) this._flushFile(file);
+  }
+  _flushFile(file) {
+    const buffer = this._buffers.get(file);
+    if (buffer === undefined) return;
+    const content = buffer.join('');
+    this._buffers.delete(file);
+    this._appendOperation({
+      op: 'appendFile',
+      file,
+      content
+    });
+  }
+  copyFile(from, to) {
+    this._flushFile(from);
+    this._buffers.delete(to); // No need to flush the buffer since we'll overwrite anyway.
+    this._appendOperation({
+      op: 'copyFile',
+      from,
+      to
+    });
+  }
+  async syncAndGetError() {
+    for (const file of this._buffers.keys()) this._flushFile(file);
+    await this._operationsDone;
+    return this._error;
+  }
+  zip(entries, zipFileName) {
+    for (const file of this._buffers.keys()) this._flushFile(file);
+
+    // Chain the export operation against write operations,
+    // so that files do not change during the export.
+    this._appendOperation({
+      op: 'zip',
+      entries,
+      zipFileName
+    });
+  }
+
+  // This method serializes all writes to the trace.
+  _appendOperation(op) {
+    const last = this._operations[this._operations.length - 1];
+    if ((last === null || last === void 0 ? void 0 : last.op) === 'appendFile' && op.op === 'appendFile' && last.file === op.file) {
+      // Merge pending appendFile operations for performance.
+      last.content += op.content;
+      return;
+    }
+    this._operations.push(op);
+    if (this._operationsDone.isDone()) this._performOperations();
+  }
+  async _performOperations() {
+    this._operationsDone = new _manualPromise.ManualPromise();
+    while (this._operations.length) {
+      const op = this._operations.shift();
+      // Ignore all operations after the first error.
+      if (this._error) continue;
+      try {
+        await this._performOperation(op);
+      } catch (e) {
+        this._error = e;
+      }
+    }
+    this._operationsDone.resolve();
+  }
+  async _performOperation(op) {
+    switch (op.op) {
+      case 'mkdir':
+        {
+          await _fs.default.promises.mkdir(op.dir, {
+            recursive: true
+          });
+          return;
+        }
+      case 'writeFile':
+        {
+          // Note: 'wx' flag only writes when the file does not exist.
+          // See https://nodejs.org/api/fs.html#file-system-flags.
+          // This way tracing never have to write the same resource twice.
+          if (op.skipIfExists) await _fs.default.promises.writeFile(op.file, op.content, {
+            flag: 'wx'
+          }).catch(() => {});else await _fs.default.promises.writeFile(op.file, op.content);
+          return;
+        }
+      case 'copyFile':
+        {
+          await _fs.default.promises.copyFile(op.from, op.to);
+          return;
+        }
+      case 'appendFile':
+        {
+          await _fs.default.promises.appendFile(op.file, op.content);
+          return;
+        }
+      case 'zip':
+        {
+          const zipFile = new _zipBundle.yazl.ZipFile();
+          const result = new _manualPromise.ManualPromise();
+          zipFile.on('error', error => result.reject(error));
+          for (const entry of op.entries) zipFile.addFile(entry.value, entry.name);
+          zipFile.end();
+          zipFile.outputStream.pipe(_fs.default.createWriteStream(op.zipFileName)).on('close', () => result.resolve()).on('error', error => result.reject(error));
+          await result;
+          return;
+        }
+    }
+  }
+}
+exports.SerializedFS = SerializedFS;

package/lib/utils/glob.js

@@ -80,4 +80,5 @@ function globToRegex(glob) {
   }
   tokens.push('$');
   return new RegExp(tokens.join(''));
-}
+}
+//# sourceMappingURL=glob.js.map

package/lib/utils/happy-eyeballs.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.createConnectionAsync = createConnectionAsync;
 exports.createSocket = createSocket;
+exports.createTLSSocket = createTLSSocket;
 exports.httpsHappyEyeballsAgent = exports.httpHappyEyeballsTimings = exports.httpHappyEyeballsAgent = void 0;
 var dns = _interopRequireWildcard(require("dns"));
 var http = _interopRequireWildcard(require("http"));
@@ -11,6 +13,7 @@ var https = _interopRequireWildcard(require("https"));
 var net = _interopRequireWildcard(require("net"));
 var tls = _interopRequireWildcard(require("tls"));
 var _manualPromise = require("./manualPromise");
+var _debug = require("./debug");
 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; }
 /**
@@ -59,8 +62,14 @@ class HttpsHappyEyeballsAgent extends https.Agent {
     createConnectionAsync(options, oncreate, /* useTLS */true).catch(err => oncreate === null || oncreate === void 0 ? void 0 : oncreate(err));
   }
 }
-const httpsHappyEyeballsAgent = exports.httpsHappyEyeballsAgent = new HttpsHappyEyeballsAgent();
-const httpHappyEyeballsAgent = exports.httpHappyEyeballsAgent = new HttpHappyEyeballsAgent();
+
+// These options are aligned with the default Node.js globalAgent options.
+const httpsHappyEyeballsAgent = exports.httpsHappyEyeballsAgent = new HttpsHappyEyeballsAgent({
+  keepAlive: true
+});
+const httpHappyEyeballsAgent = exports.httpHappyEyeballsAgent = new HttpHappyEyeballsAgent({
+  keepAlive: true
+});
 const httpHappyEyeballsTimings = exports.httpHappyEyeballsTimings = timings;
 async function createSocket(host, port) {
   return new Promise((resolve, reject) => {
@@ -82,6 +91,24 @@ async function createSocket(host, port) {
     }
   });
 }
+async function createTLSSocket(options) {
+  return new Promise((resolve, reject) => {
+    (0, _debug.assert)(options.host, 'host is required');
+    if (net.isIP(options.host)) {
+      const socket = tls.connect(options);
+      socket.on('secureConnect', () => resolve(socket));
+      socket.on('error', error => reject(error));
+    } else {
+      createConnectionAsync(options, (err, socket) => {
+        if (err) reject(err);
+        if (socket) {
+          socket.on('secureConnect', () => resolve(socket));
+          socket.on('error', error => reject(error));
+        }
+      }, true).catch(err => reject(err));
+    }
+  });
+}
 async function createConnectionAsync(options, oncreate, useTLS) {
   const lookup = options.__testHookLookup || lookupAddresses;
   const hostname = clientRequestArgsToHostName(options);

package/lib/utils/hostPlatform.js

@@ -37,7 +37,7 @@ function calculatePlatform() {
       macVersion = 'mac10.15';
     } else {
       // ver[0] >= 20
-      const LAST_STABLE_MAC_MAJOR_VERSION = 13;
+      const LAST_STABLE_MAC_MAJOR_VERSION = 14;
       // Best-effort support for MacOS beta versions.
       macVersion = 'mac' + Math.min(ver[0] - 9, LAST_STABLE_MAC_MAJOR_VERSION);
       // BigSur is the first version that might run on Apple Silicon.
@@ -69,21 +69,30 @@ function calculatePlatform() {
         hostPlatform: 'ubuntu20.04' + archSuffix,
         isOfficiallySupportedPlatform
       };
-      return {
+      if (parseInt(distroInfo.version, 10) <= 22) return {
         hostPlatform: 'ubuntu22.04' + archSuffix,
         isOfficiallySupportedPlatform
       };
+      return {
+        hostPlatform: 'ubuntu24.04' + archSuffix,
+        isOfficiallySupportedPlatform
+      };
     }
     // Linux Mint is ubuntu-based but does not have the same versions
     if ((distroInfo === null || distroInfo === void 0 ? void 0 : distroInfo.id) === 'linuxmint') {
-      if (parseInt(distroInfo.version, 10) <= 20) return {
+      const mintMajor = parseInt(distroInfo.version, 10);
+      if (mintMajor <= 20) return {
         hostPlatform: 'ubuntu20.04' + archSuffix,
         isOfficiallySupportedPlatform: false
       };
-      return {
+      if (mintMajor === 21) return {
         hostPlatform: 'ubuntu22.04' + archSuffix,
         isOfficiallySupportedPlatform: false
       };
+      return {
+        hostPlatform: 'ubuntu24.04' + archSuffix,
+        isOfficiallySupportedPlatform: false
+      };
     }
     if ((distroInfo === null || distroInfo === void 0 ? void 0 : distroInfo.id) === 'debian' || (distroInfo === null || distroInfo === void 0 ? void 0 : distroInfo.id) === 'raspbian') {
       const isOfficiallySupportedPlatform = (distroInfo === null || distroInfo === void 0 ? void 0 : distroInfo.id) === 'debian';

package/lib/utils/httpServer.js

@@ -10,6 +10,7 @@ var _utilsBundle = require("../utilsBundle");
 var _debug = require("./debug");
 var _network = require("./network");
 var _manualPromise = require("./manualPromise");
+var _crypto = require("./crypto");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /**
  * Copyright (c) Microsoft Corporation.
@@ -28,13 +29,14 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  */
 
 class HttpServer {
-  constructor(address = '') {
+  constructor() {
     this._server = void 0;
-    this._urlPrefix = void 0;
+    this._urlPrefixPrecise = '';
+    this._urlPrefixHumanReadable = '';
     this._port = 0;
     this._started = false;
     this._routes = [];
-    this._urlPrefix = address;
+    this._wsGuid = void 0;
     this._server = (0, _network.createHttpServer)(this._onRequest.bind(this));
   }
   server() {
@@ -66,6 +68,45 @@ class HttpServer {
       this._server.removeListener('error', errorListener);
     }
   }
+  createWebSocket(transport, guid) {
+    (0, _debug.assert)(!this._wsGuid, 'can only create one main websocket transport per server');
+    this._wsGuid = guid || (0, _crypto.createGuid)();
+    const wss = new _utilsBundle.wsServer({
+      server: this._server,
+      path: '/' + this._wsGuid
+    });
+    wss.on('connection', ws => {
+      transport.sendEvent = (method, params) => ws.send(JSON.stringify({
+        method,
+        params
+      }));
+      transport.close = () => ws.close();
+      ws.on('message', async message => {
+        const {
+          id,
+          method,
+          params
+        } = JSON.parse(String(message));
+        try {
+          const result = await transport.dispatch(method, params);
+          ws.send(JSON.stringify({
+            id,
+            result
+          }));
+        } catch (e) {
+          ws.send(JSON.stringify({
+            id,
+            error: String(e)
+          }));
+        }
+      });
+      ws.on('close', () => transport.onclose());
+      ws.on('error', () => transport.onclose());
+    });
+  }
+  wsGuid() {
+    return this._wsGuid;
+  }
   async start(options = {}) {
     (0, _debug.assert)(!this._started, 'server already started');
     this._started = true;
@@ -82,21 +123,21 @@ class HttpServer {
     }
     const address = this._server.address();
     (0, _debug.assert)(address, 'Could not bind server socket');
-    if (!this._urlPrefix) {
-      if (typeof address === 'string') {
-        this._urlPrefix = address;
-      } else {
-        this._port = address.port;
-        this._urlPrefix = `http://${host}:${address.port}`;
-      }
+    if (typeof address === 'string') {
+      this._urlPrefixPrecise = address;
+      this._urlPrefixHumanReadable = address;
+    } else {
+      this._port = address.port;
+      const resolvedHost = address.family === 'IPv4' ? address.address : `[${address.address}]`;
+      this._urlPrefixPrecise = `http://${resolvedHost}:${address.port}`;
+      this._urlPrefixHumanReadable = `http://${host}:${address.port}`;
     }
-    return this._urlPrefix;
   }
   async stop() {
     await new Promise(cb => this._server.close(cb));
   }
-  urlPrefix() {
-    return this._urlPrefix;
+  urlPrefix(purpose) {
+    return purpose === 'human-readable' ? this._urlPrefixHumanReadable : this._urlPrefixPrecise;
   }
   serveFile(request, response, absoluteFilePath, headers) {
     try {