@xbrowser/cli 1.9.1 → 1.9.3

package/dist/anti-bot-MCVM6IFB.js

@@ -0,0 +1,9 @@
+import {
+  detectAntiBot,
+  formatDetectionMessage
+} from "./chunk-DPJNCMLC.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  detectAntiBot,
+  formatDetectionMessage
+};

package/dist/chunk-7ZDWM6T2.js

@@ -0,0 +1,145 @@
+// 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;
+  }
+};
+
+export {
+  ScreencastCapturer
+};

package/dist/chunk-DPJNCMLC.js

@@ -0,0 +1,246 @@
+// src/lib/anti-bot.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
+  };
+  if (checkCaptcha) {
+    const captchaResult = await detectCaptcha(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 detectCaptcha(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}`;
+}
+
+export {
+  detectAntiBot,
+  formatDetectionMessage
+};

package/dist/chunk-IIM5GOD7.js

@@ -0,0 +1,93 @@
+// src/config.ts
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+import { loadConfig as coreLoadConfig, saveConfig as coreSaveConfig } from "@dyyz1993/xcli-core";
+function getConfigSource() {
+  return { configDir: join(homedir() || tmpdir(), ".xbrowser") };
+}
+function loadConfig() {
+  return coreLoadConfig(getConfigSource());
+}
+function saveConfig(config) {
+  coreSaveConfig(getConfigSource(), config);
+}
+function getConfigValue(key) {
+  const parts = key.split(".");
+  let obj = loadConfig();
+  for (const part of parts) {
+    if (obj && typeof obj === "object") {
+      obj = obj[part];
+    } else {
+      return void 0;
+    }
+  }
+  return obj;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  const parts = key.split(".");
+  let obj = config;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (!obj[parts[i]] || typeof obj[parts[i]] !== "object") {
+      obj[parts[i]] = {};
+    }
+    obj = obj[parts[i]];
+  }
+  obj[parts[parts.length - 1]] = value;
+  saveConfig(config);
+}
+var DEFAULT_MARKETPLACE_URL = "https://marketplace.xbrowser.dev";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org";
+var NPM_SCOPE = "@xbrowser/";
+function getMarketplaceUrl() {
+  return process.env.XBROWSER_MARKETPLACE_URL || getConfigValue("marketplaceUrl") || DEFAULT_MARKETPLACE_URL;
+}
+function resolveNpmPackageName(name) {
+  if (name.startsWith("@")) return name;
+  return `${NPM_SCOPE}${name}`;
+}
+var NPM_NAME_ALIASES = {
+  "1688": "alibaba-1688"
+};
+function generateNpmCandidates(name) {
+  if (name.startsWith("@")) return [name];
+  const resolved = NPM_NAME_ALIASES[name] ?? name;
+  return [
+    `${NPM_SCOPE}xbrowser-plugin-${resolved}`,
+    `${NPM_SCOPE}${resolved}`,
+    `xbrowser-plugin-${resolved}`
+  ];
+}
+async function resolveNpmPackageWithFallback(name) {
+  const candidates = generateNpmCandidates(name);
+  for (const candidate of candidates) {
+    try {
+      const encoded = encodeURIComponent(candidate);
+      const res = await fetch(`${NPM_REGISTRY_URL}/${encoded}`);
+      if (res.ok) return candidate;
+    } catch {
+      continue;
+    }
+  }
+  return resolveNpmPackageName(name);
+}
+function getCaptchaConfig() {
+  const config = loadConfig();
+  return {
+    notifyUrl: process.env.XBROWSER_NOTIFY_URL || config.captcha?.notifyUrl,
+    autoOpen: process.env.XBROWSER_AUTO_OPEN === "true" || config.captcha?.autoOpen === true,
+    timeout: parseInt(process.env.XBROWSER_CAPTCHA_TIMEOUT || "") || config.captcha?.timeout || 120,
+    previewPort: parseInt(process.env.XBROWSER_PREVIEW_PORT || "") || config.preview?.port || 9223
+  };
+}
+
+export {
+  loadConfig,
+  getConfigValue,
+  setConfigValue,
+  NPM_REGISTRY_URL,
+  NPM_SCOPE,
+  getMarketplaceUrl,
+  resolveNpmPackageWithFallback,
+  getCaptchaConfig
+};