@hexonet/semantic-release-whmcs 5.0.69 → 5.1.1

package/lib/delete-marketplace-version.js

@@ -1,6 +1,7 @@
 import puppet from "./puppet.js";
 import debugConfig from "debug";
 import { fileURLToPath } from "node:url";
+import { wait, waitForSubmitResult, safeClose, loginAndNavigate, clickAndWaitForResult } from "./puppet-utils.js";
 const debug = debugConfig("semantic-release:whmcs");
 const __filename = fileURLToPath(import.meta.url);
 
@@ -19,59 +20,109 @@ export default async (pluginConfig, context) => {
 
   debug(`${out}Delete Version: ${version}`);
 
-  const püppi = await puppet(context);
-  const result = await püppi.login();
-  if (!result) {
-    return result;
-  }
-
-  const { page, navOpts, gotoOpts, selectorOpts, productid, urlbase } = püppi.config;
-
+  let page, püppi;
+  const { productid, urlbase, gotoOpts, navOpts, selectorOpts } = (context && context.config) || {};
   try {
-    // Navigate to product administration
+    // Login and navigate to product administration
+    ({ page, püppi } = await loginAndNavigate(
+      puppet,
+      context,
+      (p) => `${p.config.urlbase}/product/${p.config.productid}/edit#versions`,
+      undefined
+    ));
+    const { urlbase, productid, gotoOpts, navOpts, selectorOpts } = püppi.config;
     const url = `${urlbase}/product/${productid}/edit#versions`;
-    await page.goto(url, gotoOpts);
     debug("Product page loaded at %s", url);
 
+    // Wait for the table to appear
+    debug("Waiting for table to appear...");
+    await page.waitForSelector("table", selectorOpts);
+    debug("Table found, fetching rows...");
+
     // Fetch all version rows
     const rows = await page.$$("tr"); // Get all rows in the table
+    debug(`Found ${rows.length} rows in the table.`);
 
+    // Find the correct row and delete button for the specified version
     let deleteButton = null;
-
-    // Loop through rows to find the one containing the specified version
     for (const row of rows) {
       const textContent = await row.evaluate((el) => el.textContent);
-      if (textContent.includes(`Version ${version}`)) {
-        // Found the correct row, now look for the delete button
-        deleteButton = await row.$("a.btn-styled-red");
-        break; // Exit the loop once found
+      if (!textContent.includes(`Version ${version}`)) continue;
+      const rightCell = await row.$("td.text-right");
+      if (!rightCell) continue;
+      const candidates = await rightCell.$$("a.btn-styled-red");
+      for (const btn of candidates) {
+        const btnText = (await btn.evaluate((el) => el.textContent)).trim().toLowerCase();
+        if (btnText === "delete") {
+          deleteButton = btn;
+          break;
+        }
       }
+      if (deleteButton) break;
     }
-
     if (!deleteButton) {
       debug(`Delete button for version ${version} not found.`);
+      await safeClose(page);
       return false;
     }
 
-    // Click the delete button and wait for navigation
-    debug("Clicking the delete button.");
-    await Promise.all([deleteButton.click(), page.waitForNavigation(navOpts)]);
-
-    // Confirm deletion by clicking the confirmation button
-    const confirmSelector = "button.btn-styled-red";
-    await page.waitForSelector(confirmSelector, selectorOpts);
-    debug("Deletion confirmation button available.");
-
-    await Promise.all([page.click(confirmSelector), page.waitForNavigation(navOpts)]);
+    // Click the delete button and wait for navigation/alert
+    const box = await deleteButton.boundingBox();
+    if (!box) {
+      debug("Delete button is not visible in the viewport.");
+      await safeClose(page);
+      return false;
+    }
+    await deleteButton.evaluate((el) => el.scrollIntoView({ block: "center" }));
+    await wait(200);
+    let navigated = false;
+    try {
+      await Promise.all([
+        page.waitForNavigation({ waitUntil: "networkidle0", timeout: navOpts.timeout }),
+        deleteButton.click(),
+      ]);
+      navigated = true;
+      debug("Navigation after delete button click complete.");
+    } catch (err) {
+      debug("Navigation after delete button click timed out, will check for alert anyway.");
+    }
 
-    debug("Clicked confirmation button. WHMCS Marketplace product version deleted successfully.");
+    // Click the confirmation button and wait for navigation/alert
+    await clickAndWaitForResult(page, 'button[type="submit"].btn-styled-red', { navOpts });
+    await wait(200);
+    debug("Checking for alert-success after confirmation...");
+    const result = await waitForSubmitResult(page, { timeout: navOpts.timeout });
+    if (result === "error") {
+      debug("Delete failed: error alert shown.");
+      await safeClose(page);
+      return false;
+    }
+    if (result === "success") {
+      debug("Delete succeeded.");
+      // Success, return as normal
+    } else {
+      // Fallback: check if the version row is gone
+      debug("No success or error alert appeared after delete. Checking if version row is gone...");
+      await page.waitForSelector("table", { timeout: 5000 });
+      const rowsAfter = await page.$$("tr");
+      for (const row of rowsAfter) {
+        const textContent = await row.evaluate((el) => el.textContent);
+        if (textContent.includes(`Version ${version}`)) {
+          debug("Delete failed: version row still present.");
+          await safeClose(page);
+          return false;
+        }
+      }
+      debug("Delete succeeded (row is gone).");
+    }
   } catch (error) {
-    debug("Deleting product version failed.", error.message);
-    await page.browser().close();
+    debug("Deleting product version failed.", error && error.message);
+    // await page.screenshot({ path: `delete-version-error.png` });
+    await safeClose(page);
     return false;
   }
 
-  await page.browser().close();
+  await safeClose(page);
   return {
     name: "WHMCS Marketplace Product Version",
     url: `${urlbase}/product/${productid}`,

package/lib/publish.js

@@ -2,6 +2,7 @@ import puppet from "./puppet.js";
 import setCompatibleVersions from "./set-compatible-versions.js";
 import debugConfig from "debug";
 import { fileURLToPath } from "node:url";
+import { robustType, safeClose, waitForSubmitResult, loginAndNavigate, clickAndWaitForResult } from "./puppet-utils.js";
 const debug = debugConfig("semantic-release:whmcs");
 const __filename = fileURLToPath(import.meta.url);
 
@@ -21,69 +22,77 @@ export default async (pluginConfig, context) => {
   // strip markdown links from notes as not allowed to keep (taken from remove-markdown and cleaned up)
   const cleanedNotes = notes.replace(/\[([^[\]]*)\]\([^()]*\)/gm, "$1");
 
-  const püppi = await puppet(context);
-  const result = await püppi.login();
-  if (!result) {
-    return result;
-  }
-  const { page, gotoOpts, selectorOpts, productid, urlbase } = püppi.config;
+  let page, püppi, urlbase, productid, gotoOpts, selectorOpts;
 
   debug(`Release Version: ${version}`);
   debug(`Notes: ${notes}`);
 
   try {
-    // add new version
+    // Login and navigate using a urlBuilder function
+    ({ page, püppi } = await loginAndNavigate(
+      puppet,
+      context,
+      (p) => `${p.config.urlbase}/product/${p.config.productid}/versions/new`,
+      undefined
+    ));
+    ({ urlbase, productid, gotoOpts, selectorOpts } = püppi.config);
     const url = `${urlbase}/product/${productid}/versions/new`;
-    await page.goto(url, gotoOpts);
     debug("product page loaded at %s", url);
-    const selector = 'div.listing-edit-container form button[type="submit"]';
-    await page.waitForSelector(selector, selectorOpts);
+    const submitSelector = 'div.listing-edit-container form button[type="submit"]';
+    await page.waitForSelector(submitSelector, selectorOpts);
     debug("product page submit button selector found");
-    /* istanbul ignore next */
-    await page.$eval(
-      "#version",
-      (el, value) => {
-        el.value = value;
-      },
-      version
-    );
+    // Fill version
+    await robustType(page, "#version", version);
     debug("form input for version finished.");
 
-    // fill input type date with localized string
-    // https://www.mattzeunert.com/2020/04/01/filling-out-a-date-input-with-puppeteer.html
-    const date = releaseDate ? new Date(releaseDate) : new Date();
-    /* istanbul ignore next */
-    const dateString = await page.evaluate(
-      (d) =>
-        new Date(d).toLocaleDateString(navigator.language, {
-          day: "2-digit",
-          month: "2-digit",
-          year: "numeric",
-        }),
-      date.toISOString()
-    );
-    await page.enterAndType("#released_at", dateString);
-
-    debug("form input for released_at finished.");
-    /* istanbul ignore next */
-    await page.$eval(
-      "#description",
-      (el, value) => {
-        el.value = value;
+    // Fill release date (input type="date" expects yyyy-mm-dd)
+    // Simplified date logic: support dd/mm/yyyy and ISO, always output yyyy-mm-dd
+    // Always use the current date for the release date input
+    const now = new Date();
+    const dateString = now.toISOString().slice(0, 10);
+    // Set the value directly for input[type=date] (robust for Puppeteer)
+    await page.evaluate(
+      (selector, value) => {
+        const el = document.querySelector(selector);
+        if (el) {
+          el.value = value;
+          el.dispatchEvent(new Event("input", { bubbles: true }));
+          el.dispatchEvent(new Event("change", { bubbles: true }));
+        }
       },
-      cleanedNotes
+      "#released_at",
+      dateString
     );
+    debug("form input for released_at finished.");
+
+    // Fill description
+    await robustType(page, "#description", cleanedNotes);
     debug("form input for description finished.");
 
-    await page.clickAndNavigate('div.listing-edit-container form button[type="submit"]');
+    // Wait for submit button to be enabled
+    await page.waitForFunction((sel) => !document.querySelector(sel).disabled, {}, submitSelector);
+
+    // Click submit and wait for navigation/alert using shared util
+    await clickAndWaitForResult(page, submitSelector, { navOpts: selectorOpts });
+    const result = await waitForSubmitResult(page, { timeout: selectorOpts.timeout || 15000 });
+    if (result === "error") {
+      debug("Publish failed: error alert shown.");
+      await safeClose(page);
+      return false;
+    } else if (result === "success") {
+      debug("Publish succeeded.");
+    } else {
+      debug("No success or error alert appeared after submit.");
+    }
+
     await setCompatibleVersions(pluginConfig, context);
   } catch (error) {
     debug("Publishing new product version failed.", error.message);
-    await page.browser().close();
+    await safeClose(page);
     return false;
   }
   debug("Publishing new product version succeeded.");
-  await page.browser().close();
+  await safeClose(page);
 
   return {
     name: "WHMCS Marketplace Product Version",

package/lib/puppet-utils.js

@@ -0,0 +1,145 @@
+/**
+ * Safely close a Puppeteer page and its browser if defined.
+ */
+export async function safeClose(page) {
+  if (page) {
+    try {
+      if (typeof page.close === "function") await page.close();
+      if (typeof page.browser === "function") {
+        const browser = page.browser();
+        if (browser && typeof browser.close === "function") await browser.close();
+      }
+    } catch (e) {
+      // ignore errors on close
+    }
+  }
+}
+/**
+ * Login, navigate to a URL, and return the page object if successful.
+ * Throws on login failure or navigation failure.
+ */
+/**
+ * Log in, then build the URL using the logged-in config, then navigate.
+ * urlBuilder: function that receives püppi and returns the URL string.
+ */
+export async function loginAndNavigate(puppet, context, urlBuilder, gotoOpts) {
+  const debug = context && context.debug ? context.debug : console.debug;
+  const püppi = await puppet(context);
+  const loginResult = await püppi.login();
+  if (!loginResult) {
+    debug && debug("Login failed or returned falsy result.");
+    throw new Error("Login failed");
+  }
+  const { page } = püppi.config;
+  const url = typeof urlBuilder === "function" ? urlBuilder(püppi) : urlBuilder;
+  const navOpts = gotoOpts || { waitUntil: ["load", "domcontentloaded"], timeout: 10000 };
+  debug && debug(`Navigating to: ${url} with options: ${JSON.stringify(navOpts)}`);
+  await page.goto(url, navOpts);
+  debug && debug(`Navigation to ${url} complete.`);
+  return { page, püppi };
+}
+
+/**
+ * Click a selector, wait for navigation or alert, and return the result.
+ * Handles both navigation and in-place alert scenarios.
+ */
+export async function clickAndWaitForResult(page, selector, { navOpts, resultTimeout = 10000, waitAfter = 200 } = {}) {
+  await page.waitForSelector(selector, { visible: true, timeout: navOpts?.timeout || 10000 });
+  const btn = await page.$(selector);
+  if (!btn) throw new Error(`Button not found: ${selector}`);
+  const isDisabled = await btn.evaluate((el) => el.disabled);
+  if (isDisabled) throw new Error(`Button is disabled: ${selector}`);
+  await btn.evaluate((el) => el.scrollIntoView({ block: "center" }));
+  await new Promise((res) => setTimeout(res, waitAfter));
+  let navigated = false;
+  try {
+    await Promise.all([
+      page.waitForNavigation({ waitUntil: "networkidle0", timeout: navOpts?.timeout || 10000 }),
+      btn.evaluate((el) => el.click()),
+    ]);
+    navigated = true;
+  } catch (err) {
+    // Navigation may not always happen
+  }
+  await new Promise((res) => setTimeout(res, waitAfter));
+  return navigated;
+}
+/**
+ * Wait for a success or error alert after a form submit, and return 'success', 'error', or 'none'.
+ */
+export async function waitForSubmitResult(page, { timeout = 10000 } = {}) {
+  const successSelector = ".alert-success, .alert.alert-success";
+  const errorSelector = ".alert-danger, .alert.alert-danger";
+  try {
+    await page.waitForSelector(`${successSelector},${errorSelector}`, { timeout });
+    if (await page.$(successSelector)) return "success";
+    if (await page.$(errorSelector)) return "error";
+  } catch (e) {
+    // No alert appeared
+  }
+  return "none";
+}
+// Shared Puppeteer utility functions for robust automation
+
+/**
+ * Wait for either a navigation (URL change) or a selector to appear, polling for up to timeout ms.
+ * Returns { redirected: boolean, selectorFound: boolean, url: string }
+ */
+export async function waitForNavigationOrSelector(
+  page,
+  { urlPart = "", selector = "", timeout = 15000, pollInterval = 300 } = {}
+) {
+  const oldUrl = page.url();
+  let redirected = false;
+  let selectorFound = false;
+  let urlAfter = "";
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    urlAfter = page.url();
+    if (urlPart && urlAfter.includes(urlPart)) {
+      redirected = true;
+      break;
+    }
+    if (selector) {
+      try {
+        await page.waitForSelector(selector, { timeout: pollInterval });
+        selectorFound = true;
+        urlAfter = page.url();
+        break;
+      } catch (e) {
+        // ignore, keep polling
+      }
+    }
+    await new Promise((res) => setTimeout(res, pollInterval));
+  }
+  return { redirected, selectorFound, url: urlAfter };
+}
+
+/**
+ * Robustly fill an input field: focus, clear, type, and fallback to evaluate if needed.
+ */
+export async function robustType(page, selector, value, delay = 30) {
+  await page.focus(selector);
+  await page.click(selector, { clickCount: 3 });
+  await page.keyboard.press("Backspace");
+  await page.type(selector, value, { delay });
+  let actual = await page.$eval(selector, (el) => el.value);
+  if (actual !== value) {
+    await page.evaluate(
+      (sel, val) => {
+        document.querySelector(sel).value = val;
+      },
+      selector,
+      value
+    );
+    actual = await page.$eval(selector, (el) => el.value);
+  }
+  return actual;
+}
+
+/**
+ * Wait for a short time (ms)
+ */
+export function wait(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}

package/lib/puppet.js

@@ -1,7 +1,13 @@
 import puppeteer from "puppeteer";
 import resolveConfig from "./resolve-config.js";
 import debugConfig from "debug";
+import path from "path";
+import { fileURLToPath } from "url";
+import { waitForNavigationOrSelector, robustType, wait } from "./puppet-utils.js";
 const debug = debugConfig("semantic-release:whmcs");
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export default async (context) => {
   let config;
   const cfg = {
@@ -10,32 +16,44 @@ export default async (context) => {
     // logger: logger,
     gotoOpts: {
       waitUntil: ["load", "domcontentloaded"],
-      timeout: 60 * 1000 * 10,
+      timeout: 20 * 1000,
     },
     navOpts: {
       waitUntil: ["networkidle0"],
-      timeout: 60 * 1000 * 5,
+      timeout: 20 * 1000,
     },
     selectorOpts: {
-      timeout: 60 * 1000 * 5,
+      timeout: 20 * 1000,
     },
     logger: context.logger,
   };
 
+  // Configure browser launch arguments
+  const baseArgs = [
+    "--disable-gpu",
+    "--start-maximized",
+    "--no-sandbox",
+    "--disable-setuid-sandbox",
+    "--disable-infobars",
+    "--ignore-certifcate-errors",
+    "--ignore-certifcate-errors-spki-list",
+    "--ignoreHTTPSErrors=true",
+  ];
+
+  const launchArgs = [...baseArgs];
+  // Add extension if not using incognito mode and if extension is available
+  if (cfg.useCookieExtension && !cfg.incognito) {
+    const extensionPath = path.join(__dirname, "../extensions/I-Still-Dont-Care-About-Cookies");
+    launchArgs.push(`--disable-extensions-except=${extensionPath}`, `--load-extension=${extensionPath}`);
+    debug("Loading I Still Don't Care About Cookies extension");
+  } else if (cfg.incognito) {
+    launchArgs.push("--incognito");
+  }
+
   const browser = await puppeteer.launch({
-    headless: cfg.headless === "1" ? "new" : false,
+    headless: cfg.headless === "1" ? "true" : false,
     defaultViewport: null, // automatically full-sized
-    args: [
-      "--disable-gpu",
-      "--incognito",
-      "--start-maximized",
-      "--no-sandbox",
-      "--disable-setuid-sandbox",
-      "--disable-infobars",
-      "--ignore-certifcate-errors",
-      "--ignore-certifcate-errors-spki-list",
-      "--ignoreHTTPSErrors=true",
-    ],
+    args: launchArgs,
   });
   const { logger } = cfg;
   const [page] = await browser.pages();
@@ -55,40 +73,51 @@ export default async (context) => {
     });
   }
 
-  page.clickAndNavigate = async (selector) => {
-    const { page, navOpts } = config;
-    const nav = page.waitForNavigation(navOpts);
-    await page.hover(selector);
-    await page.click(selector);
-    await nav;
-  };
-
-  page.enterAndType = async (selector, value) => {
-    const { page, selectorOpts } = config;
-    await page.waitForSelector(selector, selectorOpts);
-    await page.type(selector, value);
-  };
-
   async function login() {
-    const { page, login, password, productid, gotoOpts, urlbase } = config;
-    const selector = 'div.login-leftcol form button[type="submit"]';
-    // do login
+    const { page, login, password, productid, gotoOpts, urlbase, selectorOpts } = config;
+    const submitSelector = 'div.login-leftcol form button[type="submit"]';
     try {
       await page.goto(`${urlbase}/user/login`, gotoOpts);
       debug("login form loaded at %s", `${urlbase}/user/login`);
-      await page.enterAndType("#email", login);
-      await page.enterAndType("#password", password);
+      // Wait for login form
+      await page.waitForSelector("#email", selectorOpts);
+      await page.waitForSelector("#password", selectorOpts);
+      await page.waitForSelector(submitSelector, selectorOpts);
+      // Enter credentials
+      await robustType(page, "#email", login);
+      await robustType(page, "#password", password);
       debug("WHMCS Marketplace credentials entered");
-      await page.clickAndNavigate(selector);
-      debug("WHMCS Marketplace login form submitted.");
+      await page.click(submitSelector);
+      // Wait for either navigation or post-login selector
+      const { redirected, selectorFound, url } = await waitForNavigationOrSelector(page, {
+        urlPart: "/account",
+        selector: ".account-navbar",
+        timeout: 5000,
+      });
+      if (!redirected && !selectorFound) {
+        // Check for alert-danger (login error) on the same page
+        const errorAlert = await page.$(".alert-danger, .alert.alert-danger");
+        if (errorAlert) {
+          debug("Login failed: error alert shown on login page.");
+        } else {
+          debug("Login failed: no navigation, no selector, and no error alert after submit");
+        }
+        // await page.screenshot({ path: `login-failed-no-redirect-or-selector.png` });
+        await page.browser().close();
+        return false;
+      }
+      debug("WHMCS Marketplace login succeeded (redirected: %s, selectorFound: %s)", redirected, selectorFound);
     } catch (error) {
-      debug("WHMCS Marketplace login failed or Product ID missing", error.message);
+      debug("WHMCS Marketplace login failed", error.message);
+      try {
+        // await page.screenshot({ path: `login-error.png` });
+      } catch (e) {
+        debug("Screenshot failed", e.message);
+      }
       await page.browser().close();
       return false;
     }
 
-    debug("WHMCS Marketplace login succeeded.");
-
     // access MP Product ID
     let tmp = productid;
     if (!tmp || !/^[0-9]+$/.test(productid) || !parseInt(productid, 10)) {
@@ -96,10 +125,8 @@ export default async (context) => {
       await page.browser().close();
       return false;
     }
-
     tmp = tmp.replace(/(.)/g, "$&\u200E");
     debug(`WHMCS Marketplace Product ID: ${tmp}`);
-
     return true;
   }
 

package/lib/resolve-config.js

@@ -7,4 +7,5 @@ export default ({ env }) => ({
   ghrepo: env.GH_REPO || env.GITHUB_REPO || false,
   headless: env.PUPPETEER_HEADLESS || "1",
   debug: (env.DEBUG && /^semantic-release:(\*|whmcs)$/.test(env.DEBUG)) || false,
+  useCookieExtension: env.USE_COOKIE_EXTENSION || true,
 });

package/lib/set-compatible-versions.js

@@ -1,6 +1,7 @@
 import puppet from "./puppet.js";
 import debugConfig from "debug";
 import { fileURLToPath } from "node:url";
+import { robustType, wait, waitForSubmitResult, loginAndNavigate, clickAndWaitForResult } from "./puppet-utils.js";
 const debug = debugConfig("semantic-release:whmcs");
 const __filename = fileURLToPath(import.meta.url);
 
@@ -11,18 +12,20 @@ export default async (pluginConfig, context) => {
   const sep = "+++++++++++++++++++++++++++++++++++++++++++++++++++";
   const out = `\n${sep}\n${__filename}\n${sep}\n`;
 
-  const püppi = await puppet(context);
-  const result = await püppi.login();
-  if (!result) {
-    return result;
-  }
-  const { page, gotoOpts, selectorOpts, productid, urlbase, minversion } = püppi.config;
+  let page, püppi;
+  const { productid, urlbase, gotoOpts, selectorOpts, minversion } = (context && context.config) || {};
 
   debug(out);
   try {
-    // scrap versions from WHMCS marketplace
+    // Login and navigate to compatibility page
+    ({ page, püppi } = await loginAndNavigate(
+      puppet,
+      context,
+      (p) => `${p.config.urlbase}/product/${p.config.productid}/edit#compatibility`,
+      undefined
+    ));
+    const { urlbase, productid, gotoOpts, selectorOpts, minversion } = püppi.config;
     const url = `${urlbase}/product/${productid}/edit#compatibility`;
-    await page.goto(url, gotoOpts);
     debug("product page loaded at %s", url);
 
     const selector = 'input[name="versionIds[]"]';
@@ -36,7 +39,7 @@ export default async (pluginConfig, context) => {
       tmp = tmp.replace(/(.)/g, "$&\u200E");
     }
     debug(`Minimum required WHMCS version: ${tmp}`);
-    /* istanbul ignore next */
+    // No robustType needed for checkboxes, but keep logic DRY
     await page.$$eval(
       selector,
       (checkboxes, minversion) =>
@@ -59,7 +62,20 @@ export default async (pluginConfig, context) => {
         }),
       minversion
     );
-    await page.clickAndNavigate(submitSelector);
+    // Wait for submit button to be enabled
+    await page.waitForFunction((sel) => !document.querySelector(sel).disabled, {}, submitSelector);
+    // Click submit and wait for navigation/alert using shared util
+    await clickAndWaitForResult(page, submitSelector, { navOpts: gotoOpts });
+    const result = await waitForSubmitResult(page, { timeout: gotoOpts.timeout || 10000 });
+    if (result === "error") {
+      debug("Compatibility update failed: error alert shown.");
+      await page.browser().close();
+      return false;
+    } else if (result === "success") {
+      debug("Compatibility update succeeded.");
+    } else {
+      debug("No success or error alert appeared after submit.");
+    }
   } catch (error) {
     debug("Updating whmcs compatibility list failed.", error.message);
     await page.browser().close();