@browsermation/test 0.0.51 → 0.0.53

package/dist/bin/cli.js

@@ -42258,7 +42258,7 @@ var {
 // package.json
 var package_default = {
   name: "@browsermation/test",
-  version: "0.0.51",
+  version: "0.0.53",
   description: "The testing platform for Playwright by Browsermation.",
   main: "./dist/index.js",
   types: "./dist/index.d.ts",
@@ -42285,10 +42285,11 @@ var package_default = {
   ],
   scripts: {
     "build:cli": "esbuild src/bin/cli.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/bin/cli.js",
+    "build:hook": "esbuild src/bin/hook.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/bin/hook.js",
     "build:reporter": "esbuild src/reporter/reporter.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/reporter.js",
     "build:index": "esbuild src/index.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/index.js",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
-    build: "rm -rf dist && npm run build:cli && npm run build:index && npm run build:reporter && npm run build:types",
+    build: "rm -rf dist && npm run build:cli && npm run build:hook && npm run build:index && npm run build:reporter && npm run build:types",
     start: "node dist/bin/cli.js",
     "build:start": "npm run build && npm start",
     publishPackage: "npm run build && npm publish --access public"
@@ -42315,6 +42316,7 @@ var package_default = {
     chalk: "^5.4.1",
     commander: "^14.0.0",
     "form-data": "^4.0.3",
+    "import-in-the-middle": "^1.14.2",
     ora: "^8.2.0",
     "tiny-invariant": "^1.3.3",
     "ts-morph": "^26.0.0",
@@ -46661,6 +46663,14 @@ function startTunnel(tunnelProcess, options) {
     );
     process.exit(1);
   }
+  if (!options?.port) {
+    console.error(
+      source_default.red.bold(
+        "\u274C Error: Please provide a port to expose via the tunnel using the --tunnel or --port option."
+      )
+    );
+    process.exit(1);
+  }
   const tunnelDomain = `${options.subdomain || crypto.randomUUID()}.browsermationtunnel.com`;
   tunnelProcess = (0, import_node_child_process.spawn)("ssh", [
     "-o",
@@ -46668,7 +46678,7 @@ function startTunnel(tunnelProcess, options) {
     "-o",
     "UserKnownHostsFile=/dev/null",
     "-R",
-    `:80:localhost:${options.tunnel}`,
+    `:80:localhost:${options.port}`,
     "v0@browsermationtunnel.com",
     "-p",
     "2200",
@@ -46759,7 +46769,9 @@ program2.command("test").option("-t, --tunnel <port>").option("-p, --proxy").opt
       proxy: false
     };
     if (options.tunnel) {
-      const startTunnelResult = await startTunnel(tunnelProcess, options);
+      const startTunnelResult = await startTunnel(tunnelProcess, {
+        port: options.tunnel
+      });
       tunnelProcess = startTunnelResult.tunnelProcess;
     }
     if (options.proxy) {

package/dist/bin/hook.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin/hook.js

@@ -0,0 +1,325 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/module-details-from-path/index.js
+var require_module_details_from_path = __commonJS({
+  "node_modules/module-details-from-path/index.js"(exports2, module2) {
+    "use strict";
+    var sep = require("path").sep;
+    module2.exports = function(file) {
+      var segments = file.split(sep);
+      var index = segments.lastIndexOf("node_modules");
+      if (index === -1) return;
+      if (!segments[index + 1]) return;
+      var scoped = segments[index + 1][0] === "@";
+      var name = scoped ? segments[index + 1] + "/" + segments[index + 2] : segments[index + 1];
+      var offset = scoped ? 3 : 2;
+      var basedir = "";
+      var lastBaseDirSegmentIndex = index + offset - 1;
+      for (var i = 0; i <= lastBaseDirSegmentIndex; i++) {
+        if (i === lastBaseDirSegmentIndex) {
+          basedir += segments[i];
+        } else {
+          basedir += segments[i] + sep;
+        }
+      }
+      var path = "";
+      var lastSegmentIndex = segments.length - 1;
+      for (var i2 = index + offset; i2 <= lastSegmentIndex; i2++) {
+        if (i2 === lastSegmentIndex) {
+          path += segments[i2];
+        } else {
+          path += segments[i2] + sep;
+        }
+      }
+      return {
+        name,
+        basedir,
+        path
+      };
+    };
+  }
+});
+
+// node_modules/import-in-the-middle/lib/register.js
+var require_register = __commonJS({
+  "node_modules/import-in-the-middle/lib/register.js"(exports2) {
+    var importHooks = [];
+    var setters = /* @__PURE__ */ new WeakMap();
+    var getters = /* @__PURE__ */ new WeakMap();
+    var specifiers = /* @__PURE__ */ new Map();
+    var toHook = [];
+    var proxyHandler = {
+      set(target, name, value) {
+        return setters.get(target)[name](value);
+      },
+      get(target, name) {
+        if (name === Symbol.toStringTag) {
+          return "Module";
+        }
+        const getter = getters.get(target)[name];
+        if (typeof getter === "function") {
+          return getter();
+        }
+      },
+      defineProperty(target, property, descriptor) {
+        if (!("value" in descriptor)) {
+          throw new Error("Getters/setters are not supported for exports property descriptors.");
+        }
+        return setters.get(target)[property](descriptor.value);
+      }
+    };
+    function register2(name, namespace, set, get, specifier) {
+      specifiers.set(name, specifier);
+      setters.set(namespace, set);
+      getters.set(namespace, get);
+      const proxy = new Proxy(namespace, proxyHandler);
+      importHooks.forEach((hook) => hook(name, proxy));
+      toHook.push([name, proxy]);
+    }
+    var experimentalPatchInternals = false;
+    function getExperimentalPatchInternals() {
+      return experimentalPatchInternals;
+    }
+    function setExperimentalPatchInternals(value) {
+      experimentalPatchInternals = value;
+    }
+    exports2.register = register2;
+    exports2.importHooks = importHooks;
+    exports2.specifiers = specifiers;
+    exports2.toHook = toHook;
+    exports2.getExperimentalPatchInternals = getExperimentalPatchInternals;
+    exports2.setExperimentalPatchInternals = setExperimentalPatchInternals;
+  }
+});
+
+// node_modules/import-in-the-middle/index.js
+var require_import_in_the_middle = __commonJS({
+  "node_modules/import-in-the-middle/index.js"(exports2, module2) {
+    var path = require("path");
+    var parse = require_module_details_from_path();
+    var { fileURLToPath } = require("url");
+    var { MessageChannel } = require("worker_threads");
+    var {
+      importHooks,
+      specifiers,
+      toHook,
+      getExperimentalPatchInternals
+    } = require_register();
+    function addHook(hook) {
+      importHooks.push(hook);
+      toHook.forEach(([name, namespace]) => hook(name, namespace));
+    }
+    function removeHook(hook) {
+      const index = importHooks.indexOf(hook);
+      if (index > -1) {
+        importHooks.splice(index, 1);
+      }
+    }
+    function callHookFn(hookFn, namespace, name, baseDir) {
+      const newDefault = hookFn(namespace, name, baseDir);
+      if (newDefault && newDefault !== namespace) {
+        namespace.default = newDefault;
+      }
+    }
+    var sendModulesToLoader;
+    function createAddHookMessageChannel2() {
+      const { port1, port2 } = new MessageChannel();
+      let pendingAckCount = 0;
+      let resolveFn;
+      sendModulesToLoader = (modules) => {
+        pendingAckCount++;
+        port1.postMessage(modules);
+      };
+      port1.on("message", () => {
+        pendingAckCount--;
+        if (resolveFn && pendingAckCount <= 0) {
+          resolveFn();
+        }
+      }).unref();
+      function waitForAllMessagesAcknowledged() {
+        const timer = setInterval(() => {
+        }, 1e3);
+        const promise = new Promise((resolve) => {
+          resolveFn = resolve;
+        }).then(() => {
+          clearInterval(timer);
+        });
+        if (pendingAckCount === 0) {
+          resolveFn();
+        }
+        return promise;
+      }
+      const addHookMessagePort = port2;
+      const registerOptions2 = { data: { addHookMessagePort, include: [] }, transferList: [addHookMessagePort] };
+      return { registerOptions: registerOptions2, addHookMessagePort, waitForAllMessagesAcknowledged };
+    }
+    function Hook2(modules, options, hookFn) {
+      if (this instanceof Hook2 === false) return new Hook2(modules, options, hookFn);
+      if (typeof modules === "function") {
+        hookFn = modules;
+        modules = null;
+        options = null;
+      } else if (typeof options === "function") {
+        hookFn = options;
+        options = null;
+      }
+      const internals = options ? options.internals === true : false;
+      if (sendModulesToLoader && Array.isArray(modules)) {
+        sendModulesToLoader(modules);
+      }
+      this._iitmHook = (name, namespace) => {
+        const filename = name;
+        const isBuiltin = name.startsWith("node:");
+        let baseDir;
+        if (isBuiltin) {
+          name = name.replace(/^node:/, "");
+        } else {
+          if (name.startsWith("file://")) {
+            try {
+              name = fileURLToPath(name);
+            } catch (e) {
+            }
+          }
+          const details = parse(name);
+          if (details) {
+            name = details.name;
+            baseDir = details.basedir;
+          }
+        }
+        if (modules) {
+          for (const moduleName of modules) {
+            if (moduleName === name) {
+              if (baseDir) {
+                if (internals) {
+                  name = name + path.sep + path.relative(baseDir, fileURLToPath(filename));
+                } else {
+                  if (!getExperimentalPatchInternals() && !baseDir.endsWith(specifiers.get(filename))) continue;
+                }
+              }
+              callHookFn(hookFn, namespace, name, baseDir);
+            }
+          }
+        } else {
+          callHookFn(hookFn, namespace, name, baseDir);
+        }
+      };
+      addHook(this._iitmHook);
+    }
+    Hook2.prototype.unhook = function() {
+      removeHook(this._iitmHook);
+    };
+    module2.exports = Hook2;
+    module2.exports.Hook = Hook2;
+    module2.exports.addHook = addHook;
+    module2.exports.removeHook = removeHook;
+    module2.exports.createAddHookMessageChannel = createAddHookMessageChannel2;
+  }
+});
+
+// src/bin/hook.ts
+var import_module = require("module");
+var import_import_in_the_middle = __toESM(require_import_in_the_middle());
+var import_meta = {};
+var { registerOptions } = (0, import_import_in_the_middle.createAddHookMessageChannel)();
+(0, import_module.register)("import-in-the-middle/hook.mjs", import_meta.url, registerOptions);
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "proxy-connection",
+  "keep-alive",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "proxy-authorization",
+  "proxy-authenticate",
+  "host"
+]);
+function sanitizeReqHeaders(h, hasBody) {
+  const out = {};
+  for (const [k, v] of Object.entries(h ?? {})) {
+    const key = k.toLowerCase();
+    if (HOP_BY_HOP.has(key)) continue;
+    if (key === "content-length" && !hasBody) continue;
+    if (typeof v === "string") out[key] = v;
+  }
+  delete out["accept-encoding"];
+  return out;
+}
+async function loopbackProxy(route) {
+  const req = route.request();
+  const url = new URL(req.url());
+  const isHttps = url.protocol === "https:";
+  const port = url.port ? Number(url.port) : isHttps ? 443 : 80;
+  const target = `${isHttps ? "https" : "http"}://127.0.0.1:${port}${url.pathname}${url.search}`;
+  const method = req.method();
+  const isHead = method === "HEAD";
+  const isGet = method === "GET";
+  const postBuf = req.postDataBuffer();
+  const body = !isGet && !isHead && postBuf && postBuf.length ? new Blob([postBuf]) : void 0;
+  const headers = sanitizeReqHeaders(await req.headers(), !!body);
+  const init = {
+    method,
+    headers,
+    ...body ? { body } : {},
+    // only include body when valid
+    // If you ever switch to a Readable stream body, also add: duplex: 'half'
+    signal: AbortSignal.timeout(3e4)
+  };
+  const upstream = await fetch(target, init);
+  const status = upstream.status;
+  const respHeadersRaw = Object.fromEntries(upstream.headers);
+  const buf = isHead ? Buffer.alloc(0) : Buffer.from(await upstream.arrayBuffer());
+  const respHeaders = {};
+  for (const [k, v] of Object.entries(respHeadersRaw)) {
+    const key = k.toLowerCase();
+    if (HOP_BY_HOP.has(key)) continue;
+    if (key === "content-length") continue;
+    respHeaders[key] = v;
+  }
+  if (!isHead) respHeaders["content-length"] = String(buf.length);
+  await route.fulfill({
+    status,
+    headers: respHeaders,
+    ...isHead ? {} : { body: buf }
+  });
+}
+new import_import_in_the_middle.Hook(["@playwright/test"], (exported, name, baseDir) => {
+  const base = exported;
+  const routedTest = base.test.extend({
+    routeSetup: [
+      async ({ context }, use) => {
+        const regex = /^https?:\/\/(?:127\.0\.0\.1|\[::1\]|(?:[\w-]+\.)*localhost)(?::\d+)?/i;
+        await context.route(regex, loopbackProxy);
+        await use();
+        await context.unroute(regex, loopbackProxy);
+      },
+      { auto: true }
+    ]
+  });
+  exported.test = routedTest;
+  return exported;
+});

package/dist/index.js

@@ -545,6 +545,14 @@ function startTunnel(tunnelProcess2, options) {
     );
     process.exit(1);
   }
+  if (!options?.port) {
+    console.error(
+      source_default.red.bold(
+        "\u274C Error: Please provide a port to expose via the tunnel using the --tunnel or --port option."
+      )
+    );
+    process.exit(1);
+  }
   const tunnelDomain = `${options.subdomain || crypto.randomUUID()}.browsermationtunnel.com`;
   tunnelProcess2 = (0, import_node_child_process.spawn)("ssh", [
     "-o",
@@ -552,7 +560,7 @@ function startTunnel(tunnelProcess2, options) {
     "-o",
     "UserKnownHostsFile=/dev/null",
     "-R",
-    `:80:localhost:${options.tunnel}`,
+    `:80:localhost:${options.port}`,
     "v0@browsermationtunnel.com",
     "-p",
     "2200",
@@ -659,7 +667,7 @@ async function defineConfig(config) {
     use: {
       ...config.use,
       connectOptions: {
-        wsEndpoint: endpointUrl
+        wsEndpoint: "endpointUrl"
       }
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@browsermation/test",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "description": "The testing platform for Playwright by Browsermation.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -27,10 +27,11 @@
   ],
   "scripts": {
     "build:cli": "esbuild src/bin/cli.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/bin/cli.js",
+    "build:hook": "esbuild src/bin/hook.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/bin/hook.js",
     "build:reporter": "esbuild src/reporter/reporter.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/reporter.js",
     "build:index": "esbuild src/index.ts --bundle --platform=node --external:playwright --target=node22 --outfile=dist/index.js",
     "build:types": "tsc --emitDeclarationOnly --outDir dist",
-    "build": "rm -rf dist && npm run build:cli && npm run build:index && npm run build:reporter && npm run build:types",
+    "build": "rm -rf dist && npm run build:cli && npm run build:hook && npm run build:index && npm run build:reporter && npm run build:types",
     "start": "node dist/bin/cli.js",
     "build:start": "npm run build && npm start",
     "publishPackage": "npm run build && npm publish --access public"
@@ -57,6 +58,7 @@
     "chalk": "^5.4.1",
     "commander": "^14.0.0",
     "form-data": "^4.0.3",
+    "import-in-the-middle": "^1.14.2",
     "ora": "^8.2.0",
     "tiny-invariant": "^1.3.3",
     "ts-morph": "^26.0.0",