entrox-bypass 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+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 __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   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
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -22,6 +32,15 @@ var index_exports = {};
 __export(index_exports, {
   automateLogin: () => automateLogin,
   default: () => index_default,
+  delay: () => delay,
+  executeWithRandomDelay: () => executeWithRandomDelay,
+  isRetryable: () => isRetryable,
+  loadCookies: () => loadCookies,
+  randomBetween: () => randomBetween,
+  retry: () => retry,
+  saveCookies: () => saveCookies,
+  sendWebhook: () => sendWebhook,
+  setupProxy: () => setupProxy,
   solveCaptchaFromPage: () => solveCaptchaFromPage
 });
 module.exports = __toCommonJS(index_exports);
@@ -116,8 +135,62 @@ validateConfig(config);
 import_cloudinary.v2.config(config);
 var cloudinary_default = import_cloudinary.v2;
 
+// src/utils/retry.ts
+var RETRYABLE_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "TimeoutError",
+  "NetworkError",
+  "PlaywrightError",
+  "LlmError",
+  "CloudinaryError",
+  "FetchError",
+  "RateLimitError",
+  "RetryableError"
+]);
+function isRetryable(error) {
+  if (!error || typeof error !== "object") return false;
+  const err = error;
+  if (err.name && RETRYABLE_ERROR_NAMES.has(err.name)) {
+    return true;
+  }
+  if (typeof err.message === "string") {
+    const lowerMessage = err.message.toLowerCase();
+    if (lowerMessage.includes("timeout") || lowerMessage.includes("network") || lowerMessage.includes("refused") || lowerMessage.includes("reset") || lowerMessage.includes("rate limit") || lowerMessage.includes("too many requests") || lowerMessage.includes("unavailable")) {
+      return true;
+    }
+  }
+  return false;
+}
+async function retry(fn, options) {
+  const maxAttempts = options?.maxAttempts ?? 3;
+  const initialDelay = options?.delayMs ?? 1e3;
+  const multiplier = options?.multiplier ?? 2;
+  const onRetry = options?.onRetry;
+  let lastError;
+  let totalDelay = 0;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isRetryable(error) || attempt >= maxAttempts) {
+        break;
+      }
+      const waitTime = initialDelay * Math.pow(multiplier, attempt - 1);
+      totalDelay += waitTime;
+      if (onRetry) {
+        onRetry(attempt, error, totalDelay);
+      }
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+  }
+  throw lastError;
+}
+
 // src/captchaSolve.ts
-async function solveCaptchaFromPage(page, captchaSelector = "img.captcha-image", outputScreenshotPath) {
+async function solveCaptchaFromPage(page, captchaSelector = "img.captcha-image", outputScreenshotPath, options) {
+  const maxRetries = options?.maxRetries ?? 3;
+  const retryDelay = options?.retryDelayMs ?? 1e3;
+  const retryMultiplier = options?.retryMultiplier ?? 2;
   const captchaImage = page.locator(captchaSelector);
   try {
     await captchaImage.waitFor({ state: "visible" });
@@ -129,37 +202,54 @@ async function solveCaptchaFromPage(page, captchaSelector = "img.captcha-image",
   }
   let imageData;
   try {
-    imageData = await captchaImage.evaluate(async (img) => {
-      const response = await fetch(img.src);
-      if (!response.ok) {
-        throw new Error(`Image fetch failed: ${response.status}`);
-      }
-      const blob = await response.blob();
-      return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-          const result = reader.result;
-          const base64 = result.split(",")[1];
-          resolve({
-            mimeType: blob.type || "image/png",
-            base64
+    imageData = await retry(
+      async () => {
+        return await captchaImage.evaluate(async (img) => {
+          const response = await fetch(img.src);
+          if (!response.ok) {
+            throw new Error(`Image fetch failed: ${response.status}`);
+          }
+          const blob = await response.blob();
+          return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+              const result = reader.result;
+              resolve({
+                mimeType: blob.type || "image/png",
+                base64: result.split(",")[1]
+              });
+            };
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
           });
-        };
-        reader.onerror = reject;
-        reader.readAsDataURL(blob);
-      });
-    });
+        });
+      },
+      {
+        maxAttempts: maxRetries,
+        delayMs: retryDelay,
+        multiplier: retryMultiplier
+      }
+    );
   } catch (error) {
     throw new Error(`Failed to extract CAPTCHA image: ${error}`);
   }
   let uploadResult;
   try {
-    uploadResult = await cloudinary_default.uploader.upload(
-      `data:${imageData.mimeType};base64,${imageData.base64}`,
+    uploadResult = await retry(
+      async () => {
+        return await cloudinary_default.uploader.upload(
+          `data:${imageData.mimeType};base64,${imageData.base64}`,
+          {
+            folder: "playwright-captcha-images",
+            resource_type: "image",
+            type: "auth"
+          }
+        );
+      },
       {
-        folder: "playwright-captcha-images",
-        resource_type: "image",
-        type: "auth"
+        maxAttempts: maxRetries,
+        delayMs: retryDelay,
+        multiplier: retryMultiplier
       }
     );
   } catch (error) {
@@ -167,7 +257,16 @@ async function solveCaptchaFromPage(page, captchaSelector = "img.captcha-image",
   }
   const imageUrl = uploadResult.secure_url;
   try {
-    const result = await llm_default(imageUrl);
+    const result = await retry(
+      async () => {
+        return await llm_default(imageUrl);
+      },
+      {
+        maxAttempts: maxRetries,
+        delayMs: retryDelay,
+        multiplier: retryMultiplier
+      }
+    );
     return result;
   } catch (error) {
     throw new Error(`Failed to solve CAPTCHA using AI: ${error}`);
@@ -176,62 +275,266 @@ async function solveCaptchaFromPage(page, captchaSelector = "img.captcha-image",
 
 // src/login.ts
 var import_playwright = require("playwright");
-async function validateEnv() {
-  const missing = [];
-  if (!process.env.EMAIL || process.env.EMAIL === "dev@example.com") {
-    missing.push("EMAIL - Set to actual email address");
+
+// src/utils/humanDelay.ts
+function randomBetween(min, max) {
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function delay(ms) {
+  const jittered = ms + Math.floor((Math.random() * 0.4 - 0.2) * ms);
+  const actualDelay = Math.max(0, jittered);
+  return new Promise((resolve) => setTimeout(resolve, actualDelay));
+}
+async function executeWithRandomDelay(action, minDelay = 500, maxDelay = 1500) {
+  const result = await action();
+  const delayMs = randomBetween(minDelay, maxDelay);
+  await delay(delayMs);
+  return result;
+}
+
+// src/login.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+async function validateEnv(options) {
+  const email = options.email || process.env.EMAIL || "";
+  const password = options.password || process.env.PASSWORD || "";
+  if (email === "" || email === "dev@example.com") {
+    console.warn(
+      `Warning: EMAIL is set to default or missing. ${options.email ? "Override via LoginOptions.email." : "Set EMAIL env var."}`
+    );
   }
-  if (!process.env.PASSWORD || process.env.PASSWORD === "22222222") {
-    missing.push("PASSWORD - Set to actual password");
+  if (password === "" || password === "22222222") {
+    console.warn(
+      `Warning: PASSWORD is set to default or missing. ${options.password ? "Override via LoginOptions.password." : "Set PASSWORD env var."}`
+    );
   }
-  if (missing.length > 0) {
-    console.warn("Warning: The following environment variables are set to defaults or missing:");
-    missing.forEach((m) => console.warn(`  - ${m}`));
-    console.warn("Please update your .env file with real credentials.");
+}
+async function sendWebhook(url, payload) {
+  try {
+    await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(1e4)
+    });
+    return true;
+  } catch {
+    try {
+      await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(1e4)
+      });
+      return true;
+    } catch {
+      return false;
+    }
   }
 }
+async function saveCookies(context, filePath) {
+  const cookies = await context.cookies();
+  const dir = path.dirname(filePath);
+  if (dir && !fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(cookies, null, 2), "utf-8");
+}
+async function loadCookies(context, filePath) {
+  if (!fs.existsSync(filePath)) return;
+  const data = fs.readFileSync(filePath, "utf-8");
+  const cookies = JSON.parse(data);
+  await context.addCookies(cookies);
+}
+function setupProxy(proxyConfig) {
+  if (!proxyConfig) return void 0;
+  return {
+    server: proxyConfig.server,
+    username: proxyConfig.username,
+    password: proxyConfig.password
+  };
+}
 async function automateLogin(options) {
   let browser = null;
   let context = null;
   let page = null;
   try {
-    await validateEnv();
-    browser = await import_playwright.chromium.launch({
+    await validateEnv(options);
+    const retryCount = options.retryCount ?? 2;
+    const baseRetryDelay = options.baseRetryDelay ?? 1e3;
+    const delayRange = options.delayRange ?? { min: 500, max: 1500 };
+    const proxySettings = setupProxy(options.proxy);
+    const launchOpts = {
       headless: options.headless ?? false
-    });
-    context = await browser.newContext();
+    };
+    if (proxySettings) {
+      launchOpts.proxy = proxySettings;
+    }
+    browser = await import_playwright.chromium.launch(launchOpts);
+    const contextOptions = {};
+    if (proxySettings && !launchOpts.proxy) {
+      contextOptions.proxy = proxySettings;
+    }
+    if (options.cookieFile) {
+      contextOptions.storageState = options.cookieFile;
+    }
+    if (options.videoPath) {
+      const videoDir = path.isAbsolute(options.videoPath) ? path.dirname(options.videoPath) : path.join(process.cwd(), path.dirname(options.videoPath));
+      contextOptions.recordVideo = {
+        dir: videoDir,
+        size: { width: 1280, height: 720 }
+      };
+    }
+    context = await browser.newContext(contextOptions);
     page = await context.newPage();
-    await page.goto(options.url, { waitUntil: "domcontentloaded" });
     const loginSelector = options.loginSelector || "#login";
     const passwordSelector = options.passwordSelector || "#password";
     const captchaSelector = "img.captcha-image";
     const captchaInputSelector = options.captchaInputSelector || "#captcha";
     const submitButtonSelector = options.submitButtonSelector || "button[type='submit']";
-    await page.locator(loginSelector).fill(process.env.EMAIL || "");
-    await page.locator(passwordSelector).fill(process.env.PASSWORD || "");
-    const captchaResult = await solveCaptchaFromPage(
-      page,
-      captchaSelector,
-      options.outputScreenshotPath ? void 0 : void 0
-    );
-    await page.locator(captchaInputSelector).fill(captchaResult.text);
-    await page.locator(submitButtonSelector).click();
+    const attemptLogin = async () => {
+      await executeWithRandomDelay(
+        async () => page.goto(options.url, { waitUntil: "domcontentloaded" }),
+        ...Object.values(delayRange)
+      );
+      const emailVal = options.email || process.env.EMAIL || "";
+      const passwordVal = options.password || process.env.PASSWORD || "";
+      await executeWithRandomDelay(
+        async () => page.locator(loginSelector).fill(emailVal),
+        ...Object.values(delayRange)
+      );
+      await executeWithRandomDelay(
+        async () => page.locator(passwordSelector).fill(passwordVal),
+        ...Object.values(delayRange)
+      );
+      const captchaResult = await solveCaptchaFromPage(
+        page,
+        captchaSelector,
+        options.outputScreenshotPath ? void 0 : void 0
+      );
+      await executeWithRandomDelay(
+        async () => page.locator(captchaInputSelector).fill(captchaResult.text),
+        ...Object.values(delayRange)
+      );
+      await executeWithRandomDelay(
+        async () => page.locator(submitButtonSelector).click(),
+        ...Object.values(delayRange)
+      );
+      try {
+        await page.waitForLoadState("domcontentloaded", { timeout: 15e3 });
+        if (options.screenshotDelay) {
+          await page.waitForTimeout(options.screenshotDelay);
+        }
+        if (options.outputScreenshotPath) {
+          await page.screenshot({ path: options.outputScreenshotPath, fullPage: true });
+        }
+      } catch {
+        console.warn("Warning: Could not wait for post-login state");
+      }
+      return {
+        success: true,
+        url: page.url(),
+        title: await page.title(),
+        page
+      };
+    };
+    let result;
     try {
-      await page.waitForLoadState("domcontentloaded", { timeout: 15e3 });
-      if (options.screenshotDelay) {
-        await page.waitForTimeout(options.screenshotDelay);
+      result = await retry(attemptLogin, {
+        maxAttempts: retryCount + 1,
+        // +1 for the initial attempt
+        delayMs: baseRetryDelay,
+        multiplier: 2,
+        onRetry: (attempt, error, totalDelay) => {
+          console.warn(
+            `[retry] Attempt ${attempt} failed: ${error instanceof Error ? error.message : error}. Total backoff: ${totalDelay}ms`
+          );
+        }
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      let pageTitle = "";
+      if (page) {
+        try {
+          pageTitle = await page.title();
+        } catch {
+          pageTitle = "failed to get title";
+        }
       }
-      if (options.outputScreenshotPath) {
-        await page.screenshot({ path: options.outputScreenshotPath, fullPage: true });
+      if (options.cookieFile && context) {
+        try {
+          await saveCookies(context, options.cookieFile);
+        } catch {
+        }
+      }
+      if (options.webhookUrl) {
+        await sendWebhook(options.webhookUrl, {
+          content: "\u{1F534} **Login Failed**",
+          embeds: [
+            {
+              title: "Login Automation Failed",
+              fields: [
+                { name: "URL", value: options.url, inline: true },
+                {
+                  name: "Error",
+                  value: error instanceof Error ? error.message : String(error),
+                  inline: false
+                }
+              ],
+              color: 16734223
+            }
+          ]
+        });
+      }
+      return {
+        success: false,
+        url: page?.url() || "",
+        title: pageTitle,
+        page,
+        error: errorMessage
+      };
+    }
+    if (options.cookieFile && context) {
+      try {
+        await saveCookies(context, options.cookieFile);
+      } catch (err) {
+        console.warn("Warning: Could not save cookies:", err);
       }
-    } catch (error) {
-      console.warn("Warning: Could not wait for post-login state:", error);
+    }
+    if (options.videoPath && page) {
+      try {
+        const videoObj = page.video();
+        if (videoObj) {
+          const outputPath = path.isAbsolute(options.videoPath) ? options.videoPath : path.join(process.cwd(), options.videoPath);
+          await delay(500);
+          await videoObj.saveAs(outputPath);
+          console.log(`Video saved to ${outputPath}`);
+        }
+      } catch (err) {
+        console.warn("Warning: Could not save video recording:", err);
+      }
+    }
+    if (options.webhookUrl) {
+      await sendWebhook(options.webhookUrl, {
+        content: "\u2705 **Login Successful**",
+        embeds: [
+          {
+            title: "Login Automation Succeeded",
+            fields: [
+              { name: "URL", value: options.url, inline: true },
+              { name: "Final URL", value: result.url, inline: true },
+              { name: "Title", value: result.title, inline: false }
+            ],
+            color: 5763719
+          }
+        ]
+      });
     }
     return {
       success: true,
-      url: page.url(),
-      title: await page.title(),
-      page
+      url: result.url,
+      title: result.title,
+      page: result.page
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -243,6 +546,31 @@ async function automateLogin(options) {
         pageTitle = "failed to get title";
       }
     }
+    if (options.cookieFile && context) {
+      try {
+        await saveCookies(context, options.cookieFile);
+      } catch {
+      }
+    }
+    if (options.webhookUrl) {
+      await sendWebhook(options.webhookUrl, {
+        content: "\u{1F534} **Login Error**",
+        embeds: [
+          {
+            title: "Unexpected Login Error",
+            fields: [
+              { name: "URL", value: options.url, inline: true },
+              {
+                name: "Error",
+                value: error instanceof Error ? error.message : String(error),
+                inline: false
+              }
+            ],
+            color: 16734223
+          }
+        ]
+      });
+    }
     return {
       success: false,
       url: page?.url() || "",
@@ -261,11 +589,29 @@ async function automateLogin(options) {
 // src/index.ts
 var index_default = {
   solveCaptchaFromPage,
-  automateLogin
+  automateLogin,
+  sendWebhook,
+  saveCookies,
+  loadCookies,
+  setupProxy,
+  randomBetween,
+  delay,
+  executeWithRandomDelay,
+  retry,
+  isRetryable
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   automateLogin,
+  delay,
+  executeWithRandomDelay,
+  isRetryable,
+  loadCookies,
+  randomBetween,
+  retry,
+  saveCookies,
+  sendWebhook,
+  setupProxy,
   solveCaptchaFromPage
 });
 //# sourceMappingURL=index.cjs.map