@xbrowser/cli 1.9.1 → 1.9.3

package/dist/daemon-main.js

@@ -1,3 +1,11 @@
+import {
+  getPluginLoader
+} from "./chunk-PIWNMC36.js";
+import {
+  getDaemonConfig,
+  getDaemonProcessStatus,
+  version
+} from "./chunk-24SY6PE5.js";
 import {
   commandLogStore,
   networkStore,
@@ -24,17 +32,16 @@ import {
 } from "./chunk-OOJ2H7IL.js";
 import "./chunk-VJNMAWPZ.js";
 import "./chunk-TNEN6VQ2.js";
-import {
-  getPluginLoader
-} from "./chunk-PIWNMC36.js";
-import {
-  getDaemonConfig,
-  getDaemonProcessStatus,
-  version
-} from "./chunk-24SY6PE5.js";
 import {
   errMsg
 } from "./chunk-GDKLH7ZY.js";
+import {
+  detectAntiBot,
+  formatDetectionMessage
+} from "./chunk-DPJNCMLC.js";
+import {
+  ScreencastCapturer
+} from "./chunk-7ZDWM6T2.js";
 import "./chunk-KFQGP6VL.js";
 
 // src/daemon/daemon-main.ts
@@ -5815,246 +5822,12 @@ function describeSelector(strategy, value, name) {
   }
 }
 
-// src/anti-bot-detection.ts
-var CAPTCHA_PATTERNS = [
-  { name: "reCAPTCHA", pattern: /recaptcha/i },
-  { name: "hCaptcha", pattern: /hcaptcha/i },
-  { name: "Turnstile", pattern: /turnstile/i },
-  { name: "Cloudflare", pattern: /cloudflare/i },
-  { name: "FunCaptcha", pattern: /funcaptcha/i },
-  { name: "AWS WAF", pattern: /aws.*challenge/i }
-];
-var WARNING_TEXTS = [
-  { text: "detected as bot", severity: "high" },
-  { text: "suspicious activity", severity: "high" },
-  { text: "unusual traffic", severity: "high" },
-  { text: "please verify you are human", severity: "medium" },
-  { text: "access denied", severity: "high" },
-  { text: "blocked", severity: "high" },
-  { text: "rate limit", severity: "medium" },
-  { text: "too many requests", severity: "medium" },
-  { text: "\u9A8C\u8BC1", severity: "low" },
-  { text: "\u9A8C\u8BC1\u7801", severity: "low" }
-];
-var BLOCKED_URL_PATTERNS = [
-  { name: "Cloudflare Challenge", pattern: /challenge-platform/i },
-  { name: "Cloudflare Captcha", pattern: /cf-challenge/i },
-  { name: "AWS WAF", pattern: /aws-waf/i },
-  { name: "Generic Captcha", pattern: /captcha/i }
-];
-async function detectAntiBot(page, config = {}) {
-  const {
-    checkCaptcha = true,
-    checkWarning = true,
-    checkBlocked = true,
-    checkLogin = false,
-    checkWebdriver = true
-  } = config;
-  const result = {
-    detected: false
+// src/context.ts
+function attachDetectAntiBot(ctx) {
+  ctx.detectAntiBot = async (page, config) => {
+    const { detectAntiBot: detectAntiBot2 } = await import("./anti-bot-MCVM6IFB.js");
+    return detectAntiBot2(page, config);
   };
-  if (checkCaptcha) {
-    const captchaResult = await detectCaptcha2(page);
-    if (captchaResult.detected) {
-      return captchaResult;
-    }
-  }
-  if (checkWarning) {
-    const warningResult = await detectWarningText(page);
-    if (warningResult.detected) {
-      return warningResult;
-    }
-  }
-  if (checkBlocked) {
-    const blockedResult = await detectBlockedPage(page);
-    if (blockedResult.detected) {
-      return blockedResult;
-    }
-  }
-  if (checkWebdriver) {
-    const webdriverResult = await detectWebdriverExposure(page);
-    if (webdriverResult.detected) {
-      return webdriverResult;
-    }
-  }
-  if (checkLogin) {
-    const loginResult = await detectLoginRequired(page);
-    if (loginResult.detected) {
-      return loginResult;
-    }
-  }
-  return result;
-}
-async function detectCaptcha2(page) {
-  try {
-    const iframes = await page.frames();
-    for (const iframe of iframes) {
-      const src = iframe.url();
-      for (const pattern of CAPTCHA_PATTERNS) {
-        if (pattern.pattern.test(src)) {
-          return {
-            detected: true,
-            type: "captcha",
-            severity: "high",
-            message: `Detected ${pattern.name} CAPTCHA (iframe: ${src})`,
-            selector: `iframe[src*="${pattern.name.toLowerCase()}"]`,
-            actionRequired: "manual"
-          };
-        }
-      }
-    }
-    const captchaSelectors = [
-      ".g-recaptcha",
-      "#captcha",
-      '[class*="captcha"]',
-      '[id*="captcha"]',
-      'iframe[src*="recaptcha"]',
-      'iframe[src*="hcaptcha"]',
-      'iframe[src*="turnstile"]'
-    ];
-    for (const selector of captchaSelectors) {
-      const element = await page.$(selector).catch(() => null);
-      if (element) {
-        return {
-          detected: true,
-          type: "captcha",
-          severity: "high",
-          message: `CAPTCHA element found: ${selector}`,
-          selector,
-          actionRequired: "manual"
-        };
-      }
-    }
-    return { detected: false };
-  } catch {
-    return { detected: false };
-  }
-}
-async function detectWarningText(page) {
-  try {
-    const pageText = await page.textContent("body").catch(() => "") || "";
-    const lowerText = pageText.toLowerCase();
-    for (const { text, severity } of WARNING_TEXTS) {
-      if (lowerText.includes(text.toLowerCase())) {
-        return {
-          detected: true,
-          type: "warning",
-          severity,
-          message: `Anti-bot warning text found: "${text}"`,
-          actionRequired: severity === "high" ? "manual" : "retry"
-        };
-      }
-    }
-    return { detected: false };
-  } catch {
-    return { detected: false };
-  }
-}
-async function detectBlockedPage(page) {
-  try {
-    const url = page.url();
-    for (const { name, pattern } of BLOCKED_URL_PATTERNS) {
-      if (pattern.test(url)) {
-        return {
-          detected: true,
-          type: "blocked",
-          severity: "high",
-          message: `Blocked page detected: ${name} (${url})`,
-          actionRequired: "manual"
-        };
-      }
-    }
-    return { detected: false };
-  } catch {
-    return { detected: false };
-  }
-}
-async function detectWebdriverExposure(page) {
-  try {
-    const webdriver = await page.evaluate(() => {
-      return {
-        webdriver: navigator.webdriver,
-        webdriverScriptFn: !!window.__webdriver_script_fn,
-        webdriverEvaluate: !!window.__webdriver_evaluate,
-        chrome: !!window.chrome,
-        permissions: navigator.permissions
-      };
-    }).catch(() => null);
-    if (!webdriver) {
-      return { detected: false };
-    }
-    const issues = [];
-    if (webdriver.webdriver === true) {
-      issues.push("navigator.webdriver === true");
-    }
-    if (webdriver.webdriverScriptFn) {
-      issues.push("__webdriver_script_fn present");
-    }
-    if (webdriver.webdriverEvaluate) {
-      issues.push("__webdriver_evaluate present");
-    }
-    if (!webdriver.chrome) {
-      issues.push("window.chrome missing");
-    }
-    if (!webdriver.permissions) {
-      issues.push("navigator.permissions missing");
-    }
-    if (issues.length > 0) {
-      return {
-        detected: true,
-        type: "warning",
-        severity: "high",
-        message: `Automation markers exposed: ${issues.join(", ")}`,
-        actionRequired: "manual"
-      };
-    }
-    return { detected: false };
-  } catch {
-    return { detected: false };
-  }
-}
-async function detectLoginRequired(page) {
-  try {
-    const loginSelectors = [
-      'a[href*="login"]',
-      'a[href*="signin"]',
-      'a[href*="sign-in"]',
-      'button:has-text("Log in")',
-      'button:has-text("Sign in")',
-      'button:has-text("Login")',
-      'button:has-text("\u767B\u5F55")'
-    ];
-    for (const selector of loginSelectors) {
-      const element = await page.$(selector).catch(() => null);
-      if (element) {
-        const rect = await element.boundingBox().catch(() => null);
-        if (rect && rect.y < 200) {
-          return {
-            detected: true,
-            type: "login",
-            severity: "medium",
-            message: "Login button detected in page header",
-            selector,
-            actionRequired: "manual"
-          };
-        }
-      }
-    }
-    return { detected: false };
-  } catch {
-    return { detected: false };
-  }
-}
-function formatDetectionMessage(result) {
-  if (!result.detected) {
-    return "\u2705 No anti-bot detection detected.";
-  }
-  const emoji = result.severity === "high" ? "\u{1F6A8}" : result.severity === "medium" ? "\u26A0\uFE0F" : "\u2139\uFE0F";
-  const action = result.actionRequired === "manual" ? "Please handle manually" : result.actionRequired === "retry" ? "Consider retrying with delay" : "Consider switching to a different session";
-  return `${emoji} Detection: ${result.message}
-  Type: ${result.type}
-  Severity: ${result.severity}
-  Action: ${action}`;
 }
 
 // src/utils/viewer-url.ts
@@ -6858,6 +6631,7 @@ async function executeCommand(commandName, params, sessionName = "default", extr
     cliName: "xbrowser",
     tips: new TipCollector2()
   };
+  attachDetectAntiBot(ctx);
   if (_tabIndex !== void 0 && session?.context) {
     const pages = session.context.pages();
     if (_tabIndex >= 0 && _tabIndex < pages.length) {
@@ -8780,148 +8554,6 @@ var StreamCoordinator = class {
 // src/ws/session-manager.ts
 import { EventEmitter } from "events";
 
-// src/screencast.ts
-var ScreencastCapturer = class {
-  interval;
-  quality;
-  type;
-  maxWidth;
-  maxHeight;
-  isCapturing = false;
-  frameCallback = null;
-  // CDP Cast state
-  cdpSession = null;
-  sessionId = "";
-  // Fallback polling state
-  fallbackTimer = null;
-  constructor(options = {}) {
-    this.interval = options.interval || 100;
-    this.quality = options.quality || 60;
-    this.type = options.type || "jpeg";
-    this.maxWidth = options.width || 1920;
-    this.maxHeight = options.height || 1080;
-  }
-  /**
-   * Start screencast capture using CDP Page.startScreencast.
-   *
-   * If CDP session creation fails (non-Chromium, restricted access),
-   * automatically falls back to `page.screenshot()` polling.
-   */
-  async startCapture(page, sessionId, onFrame) {
-    if (this.isCapturing) {
-      throw new Error("Screencast is already capturing");
-    }
-    this.isCapturing = true;
-    this.frameCallback = onFrame;
-    this.sessionId = sessionId;
-    try {
-      const cdp = await page.context().newCDPSession(page);
-      this.cdpSession = cdp;
-      cdp.on("Page.screencastFrame", async (params) => {
-        if (!this.frameCallback) return;
-        try {
-          await cdp.send("Page.screencastFrameAck", { sessionId: params.sessionId });
-        } catch {
-        }
-        const viewport = {
-          width: params.metadata?.deviceWidth || this.maxWidth,
-          height: params.metadata?.deviceHeight || this.maxHeight
-        };
-        this.frameCallback({
-          id: crypto.randomUUID(),
-          sessionId: this.sessionId,
-          timestamp: Date.now(),
-          data: Buffer.from(params.data, "base64"),
-          url: page.url(),
-          viewport
-        });
-      });
-      await cdp.send("Page.startScreencast", {
-        format: this.type === "png" ? "png" : "jpeg",
-        quality: this.type === "jpeg" ? this.quality : void 0,
-        maxWidth: this.maxWidth,
-        maxHeight: this.maxHeight
-      });
-    } catch {
-      this.cdpSession = null;
-      this.startFallbackPolling(page, sessionId);
-    }
-  }
-  /**
-   * Fallback: periodic page.screenshot() polling when CDP Cast is unavailable.
-   */
-  startFallbackPolling(page, sessionId) {
-    const captureLoop = async () => {
-      if (!this.frameCallback) return;
-      try {
-        const frame = await this.captureFrame(page, sessionId);
-        this.frameCallback(frame);
-      } catch {
-      }
-    };
-    captureLoop();
-    this.fallbackTimer = setInterval(captureLoop, this.interval);
-  }
-  /**
-   * Capture a single screenshot frame from the page (fallback mode).
-   */
-  async captureFrame(page, sessionId) {
-    let viewport = page.viewportSize();
-    if (!viewport) {
-      try {
-        viewport = await page.evaluate(() => ({ width: window.innerWidth, height: window.innerHeight }));
-      } catch {
-        viewport = { width: 1920, height: 1080 };
-      }
-    }
-    const screenshot = await page.screenshot({
-      type: this.type,
-      quality: this.type === "jpeg" ? this.quality : void 0
-    });
-    return {
-      id: crypto.randomUUID(),
-      sessionId,
-      timestamp: Date.now(),
-      data: screenshot,
-      url: page.url(),
-      viewport: viewport || { width: 0, height: 0 }
-    };
-  }
-  /**
-   * Stop the current screencast capture.
-   */
-  async stopCapture() {
-    if (this.cdpSession) {
-      try {
-        this.cdpSession.off("Page.screencastFrame", () => {
-        });
-        await this.cdpSession.send("Page.stopScreencast");
-      } catch {
-      }
-      try {
-        await this.cdpSession.detach();
-      } catch {
-      }
-      this.cdpSession = null;
-    }
-    if (this.fallbackTimer) {
-      clearInterval(this.fallbackTimer);
-      this.fallbackTimer = null;
-    }
-    this.isCapturing = false;
-    this.frameCallback = null;
-  }
-  isActive() {
-    return this.isCapturing;
-  }
-  setInterval(interval) {
-    this.interval = interval;
-  }
-  setQuality(quality) {
-    this.quality = quality;
-  }
-};
-
 // src/ws/element-monitor.ts
 var ElementMonitor = class {
   constructor(page, onFocusChange, onViewsUpdate, getClientCount) {