@xbrowser/cli 0.14.0

package/dist/chunk-VEDJ5XSQ.js

@@ -0,0 +1,196 @@
+// src/daemon/network-scorer.ts
+var DEFAULT_WEIGHTS = {
+  method: { post: 30, get: 10, other: 5 },
+  resourceType: { api: 20, document: 0, static: -50, other: 0 },
+  size: { goodRange: 20, tooLarge: -10 },
+  content: { isJson: 10, hasDataArray: 15, urlContainsApi: 10 }
+};
+var STATIC_TYPES = /* @__PURE__ */ new Set(["stylesheet", "image", "font", "media"]);
+var DATA_ARRAY_KEYS = /* @__PURE__ */ new Set(["data", "list", "items", "results", "records"]);
+function calcMethodScore(entry, weights) {
+  const m = entry.method.toUpperCase();
+  if (m === "POST" || m === "PUT" || m === "DELETE") return weights.method.post;
+  if (m === "GET") return weights.method.get;
+  return weights.method.other;
+}
+function calcResourceTypeScore(entry, weights) {
+  const rt = entry.resourceType.toLowerCase();
+  if (rt === "xhr" || rt === "fetch") return weights.resourceType.api;
+  if (rt === "document") return weights.resourceType.document;
+  if (STATIC_TYPES.has(rt)) return weights.resourceType.static;
+  return weights.resourceType.other;
+}
+function calcSizeScore(entry, weights) {
+  if (entry.size > 1024 * 1024) return weights.size.tooLarge;
+  const isJson = entry.contentType.toLowerCase().includes("json");
+  if (entry.body !== void 0 && isJson && entry.size > 0 && entry.size < 100 * 1024) {
+    return weights.size.goodRange;
+  }
+  return 0;
+}
+function calcContentScore(entry, weights) {
+  let score = 0;
+  if (entry.contentType.toLowerCase().includes("json")) {
+    score += weights.content.isJson;
+  }
+  if (typeof entry.body === "object" && entry.body !== null && !Array.isArray(entry.body)) {
+    for (const key of Object.keys(entry.body)) {
+      if (DATA_ARRAY_KEYS.has(key) && Array.isArray(entry.body[key])) {
+        score += weights.content.hasDataArray;
+        break;
+      }
+    }
+  }
+  const urlLower = entry.url.toLowerCase();
+  if (urlLower.includes("/api/") || urlLower.includes("/v1/") || urlLower.includes("/v2/") || urlLower.includes("/graphql")) {
+    score += weights.content.urlContainsApi;
+  }
+  return score;
+}
+function scoreEntry(entry, weights = DEFAULT_WEIGHTS) {
+  const method = calcMethodScore(entry, weights);
+  const resourceType = calcResourceTypeScore(entry, weights);
+  const size = calcSizeScore(entry, weights);
+  const content = calcContentScore(entry, weights);
+  return {
+    ...entry,
+    score: method + resourceType + size + content,
+    scoreBreakdown: { method, resourceType, size, content }
+  };
+}
+function scoreEntries(entries, weights = DEFAULT_WEIGHTS, feedbackFn) {
+  return entries.map((e) => {
+    const scored = scoreEntry(e, weights);
+    if (feedbackFn) {
+      scored.score += feedbackFn(e.path, e.method);
+    }
+    return scored;
+  }).sort((a, b) => b.score - a.score);
+}
+
+// src/daemon/network-store.ts
+var NetworkCaptureStore = class {
+  stores = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(maxEntries = 2e3) {
+    this.maxEntries = maxEntries;
+  }
+  getStore(sessionName) {
+    let store = this.stores.get(sessionName);
+    if (!store) {
+      store = { entries: [], counter: 0 };
+      this.stores.set(sessionName, store);
+    }
+    return store;
+  }
+  add(sessionName, entry) {
+    const store = this.getStore(sessionName);
+    store.counter += 1;
+    const fullEntry = { ...entry, id: store.counter };
+    store.entries.push(fullEntry);
+    if (store.entries.length > this.maxEntries) {
+      store.entries.splice(0, store.entries.length - this.maxEntries);
+    }
+  }
+  list(sessionName, options) {
+    const store = this.getStore(sessionName);
+    let entries = store.entries;
+    if (options?.filter) {
+      const f = options.filter.toLowerCase();
+      entries = entries.filter(
+        (e) => e.url.toLowerCase().includes(f) || e.path.toLowerCase().includes(f) || e.contentType.toLowerCase().includes(f)
+      );
+    }
+    if (options?.method) {
+      const m = options.method.toUpperCase();
+      entries = entries.filter((e) => e.method === m);
+    }
+    const total = entries.length;
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? 50;
+    const captures = entries.slice(offset, offset + limit);
+    return { session: sessionName, total, captures };
+  }
+  inspect(sessionName, id) {
+    const store = this.getStore(sessionName);
+    const capture = store.entries.find((e) => e.id === id) ?? null;
+    return { session: sessionName, capture };
+  }
+  clear(sessionName) {
+    this.stores.delete(sessionName);
+  }
+  top(sessionName, options) {
+    const store = this.getStore(sessionName);
+    const feedbackFn = options?.feedbackFn;
+    const scored = feedbackFn ? scoreEntries(store.entries, void 0, feedbackFn) : scoreEntries(store.entries);
+    const minScore = options?.minScore ?? 0;
+    const filtered = scored.filter((e) => e.score >= minScore);
+    const limit = options?.limit ?? 20;
+    return { session: sessionName, entries: filtered.slice(0, limit) };
+  }
+  around(sessionName, commandId, cmdLogStore, windowMs = 5e3) {
+    const cmd = cmdLogStore.findEntry(sessionName, commandId);
+    if (!cmd) return null;
+    const netStore = this.getStore(sessionName);
+    const before = netStore.entries.filter(
+      (e) => e.timestamp >= cmd.timestamp - windowMs && e.timestamp < cmd.timestamp
+    );
+    const after = netStore.entries.filter(
+      (e) => e.timestamp >= cmd.timestamp && e.timestamp < cmd.timestamp + windowMs
+    );
+    return { command: cmd, before, after, afterCount: after.length };
+  }
+  clearAll() {
+    this.stores.clear();
+  }
+};
+var CommandLogStore = class {
+  stores = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(maxEntries = 500) {
+    this.maxEntries = maxEntries;
+  }
+  getStore(sessionName) {
+    let store = this.stores.get(sessionName);
+    if (!store) {
+      store = { entries: [], counter: 0 };
+      this.stores.set(sessionName, store);
+    }
+    return store;
+  }
+  add(sessionName, entry) {
+    const store = this.getStore(sessionName);
+    store.counter += 1;
+    const fullEntry = { ...entry, id: store.counter };
+    store.entries.push(fullEntry);
+    if (store.entries.length > this.maxEntries) {
+      store.entries.splice(0, store.entries.length - this.maxEntries);
+    }
+  }
+  list(sessionName, options) {
+    const store = this.getStore(sessionName);
+    const offset = options?.offset ?? 0;
+    const limit = options?.limit ?? 50;
+    return store.entries.slice(offset, offset + limit);
+  }
+  findEntry(sessionName, id) {
+    const store = this.stores.get(sessionName);
+    return store?.entries.find((e) => e.id === id) ?? null;
+  }
+  clear(sessionName) {
+    this.stores.delete(sessionName);
+  }
+  clearAll() {
+    this.stores.clear();
+  }
+};
+var commandLogStore = new CommandLogStore();
+var networkStore = new NetworkCaptureStore();
+
+export {
+  scoreEntries,
+  NetworkCaptureStore,
+  CommandLogStore,
+  commandLogStore,
+  networkStore
+};

package/dist/chunk-VEKPHQBR.js

@@ -0,0 +1,47 @@
+// src/utils/proxy-fetch.ts
+var patched = false;
+async function ensureProxyFetch() {
+  if (patched) return;
+  patched = true;
+  if (process.env.https_proxy && !process.env.HTTPS_PROXY) {
+    process.env.HTTPS_PROXY = process.env.https_proxy;
+  }
+  if (process.env.http_proxy && !process.env.HTTP_PROXY) {
+    process.env.HTTP_PROXY = process.env.http_proxy;
+  }
+  if (process.env.all_proxy && !process.env.ALL_PROXY) {
+    process.env.ALL_PROXY = process.env.all_proxy;
+  }
+  const proxyUrl = process.env.https_proxy || process.env.HTTPS_PROXY || process.env.http_proxy || process.env.HTTP_PROXY || process.env.all_proxy || process.env.ALL_PROXY;
+  if (!proxyUrl) return;
+  try {
+    const undici = await import("undici");
+    const EnvHttpProxyAgent = undici.EnvHttpProxyAgent;
+    const uFetch = undici.fetch;
+    const UFormData = undici.FormData;
+    if (EnvHttpProxyAgent && uFetch && UFormData) {
+      const agent = new EnvHttpProxyAgent();
+      globalThis.fetch = ((input, init) => {
+        const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+        const body = init?.body;
+        if (body instanceof globalThis.FormData && !(body instanceof UFormData)) {
+          const ufd = new UFormData();
+          body.forEach((value, key) => {
+            if (value instanceof Blob) {
+              ufd.append(key, value, value.name || "file");
+            } else {
+              ufd.append(key, value);
+            }
+          });
+          return uFetch(url, { ...init, body: ufd, dispatcher: agent });
+        }
+        return uFetch(url, { ...init, dispatcher: agent });
+      });
+    }
+  } catch {
+  }
+}
+
+export {
+  ensureProxyFetch
+};

package/dist/chunk-VUJDJCIN.js

@@ -0,0 +1,437 @@
+import {
+  getCaptchaConfig
+} from "./chunk-M7CMBPCA.js";
+
+// src/human-interaction.ts
+import { execSync } from "child_process";
+
+// 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/captcha-detector.ts
+var CAPTCHA_SELECTORS = [
+  { selector: 'iframe[src*="recaptcha"]', type: "recaptcha", confidence: "high" },
+  { selector: ".g-recaptcha", type: "recaptcha", confidence: "high" },
+  { selector: "#recaptcha", type: "recaptcha", confidence: "high" },
+  { selector: "[data-sitekey]", type: "recaptcha", confidence: "medium" },
+  { selector: 'iframe[src*="hcaptcha"]', type: "hcaptcha", confidence: "high" },
+  { selector: ".h-captcha", type: "hcaptcha", confidence: "high" },
+  { selector: 'iframe[src*="challenges.cloudflare.com"]', type: "turnstile", confidence: "high" },
+  { selector: ".cf-turnstile", type: "turnstile", confidence: "high" },
+  { selector: 'iframe[src*="captcha"]', type: "generic", confidence: "medium" },
+  { selector: "[data-captcha]", type: "generic", confidence: "medium" },
+  { selector: ".captcha-container", type: "generic", confidence: "medium" },
+  { selector: "#captcha", type: "generic", confidence: "medium" },
+  { selector: ".captcha-image", type: "generic", confidence: "medium" },
+  { selector: "#captcha_image", type: "generic", confidence: "medium" },
+  // 小红书滑块验证
+  { selector: ".captcha-verify-image", type: "xhs-slider", confidence: "high" },
+  { selector: ".verify-wrap", type: "xhs-slider", confidence: "medium" },
+  { selector: '[class*="slider-verify"]', type: "xhs-slider", confidence: "medium" },
+  { selector: '[class*="captcha-verify"]', type: "xhs-slider", confidence: "medium" },
+  { selector: '[class*="verify-image"]', type: "xhs-slider", confidence: "low" }
+];
+var CAPTCHA_TEXT_PATTERNS = [
+  "verify you are human",
+  "prove you are not a robot",
+  "complete the challenge",
+  "are you a robot",
+  "human verification",
+  "security check",
+  "prove you're human",
+  "not a robot",
+  // 小红书验证提示
+  /xiaohongshu.*verif/i,
+  /拖动滑块/,
+  /请完成验证/,
+  /slide.*verify/i
+];
+var CaptchaDetector = class {
+  /**
+   * Scan the page for visible CAPTCHA elements or challenge text.
+   *
+   * @param page - The Playwright page to scan.
+   * @returns Detection result with type, selector, and confidence level.
+   */
+  static async detect(page) {
+    for (const rule of CAPTCHA_SELECTORS) {
+      try {
+        const el = await page.$(rule.selector);
+        if (el) {
+          const visible = await el.isVisible().catch(() => false);
+          if (visible) {
+            return {
+              detected: true,
+              type: rule.type,
+              selector: rule.selector,
+              confidence: rule.confidence
+            };
+          }
+        }
+      } catch {
+      }
+    }
+    try {
+      const bodyText = await page.textContent("body").catch(() => "");
+      if (bodyText) {
+        for (const pattern of CAPTCHA_TEXT_PATTERNS) {
+          const matches = pattern instanceof RegExp ? pattern.test(bodyText) : bodyText.toLowerCase().includes(pattern);
+          if (matches) {
+            return {
+              detected: true,
+              type: "text-challenge",
+              confidence: "low"
+            };
+          }
+        }
+      }
+    } catch {
+    }
+    return { detected: false, confidence: "low" };
+  }
+  /**
+   * Check whether a previously detected CAPTCHA has been solved.
+   *
+   * @param page - The Playwright page to check.
+   * @param previousSelector - The selector from a previous detection result.
+   * @returns `true` if the CAPTCHA is no longer visible.
+   */
+  static async isSolved(page, previousSelector) {
+    if (previousSelector) {
+      try {
+        const el = await page.$(previousSelector);
+        if (!el) return true;
+        const visible = await el.isVisible().catch(() => false);
+        if (!visible) return true;
+      } catch {
+        return true;
+      }
+    }
+    const result = await this.detect(page);
+    return !result.detected;
+  }
+};
+
+// src/webhook.ts
+var WebhookNotifier = class {
+  url;
+  constructor(url) {
+    this.url = url || process.env.XBROWSER_NOTIFY_URL || null;
+  }
+  /**
+   * Send a webhook notification payload.
+   *
+   * @param payload - The event payload to send.
+   * @returns `true` if the request succeeded (HTTP 2xx), `false` otherwise.
+   */
+  async notify(payload) {
+    if (!this.url) return false;
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: AbortSignal.timeout(5e3)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/utils/shell-escape.ts
+function shellEscape(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+// src/human-interaction.ts
+var HumanInteractionManager = class {
+  wsServer;
+  page;
+  capturer;
+  webhook;
+  autoOpen;
+  constructor(wsServer, page) {
+    this.wsServer = wsServer;
+    this.page = page;
+    this.capturer = new ScreencastCapturer();
+    const cfg = getCaptchaConfig();
+    this.webhook = new WebhookNotifier(cfg.notifyUrl);
+    this.autoOpen = cfg.autoOpen;
+    this.wsServer.registerSession("default", page);
+  }
+  async sendWebhook(event, overrides = {}) {
+    await this.webhook.notify({
+      event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      url: this.page.url(),
+      previewUrl: `http://localhost:${this.wsServer.getPort()}`,
+      ...overrides
+    });
+  }
+  tryAutoOpen(previewUrl) {
+    if (!this.autoOpen) return;
+    try {
+      const cmd = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : "start";
+      execSync(`${cmd} ${shellEscape(previewUrl)}`, { stdio: "ignore" });
+    } catch {
+    }
+  }
+  /**
+   * Wait for a human to solve a CAPTCHA or complete an interaction.
+   *
+   * Starts screencast streaming, sends webhook and broadcast notifications,
+   * then polls for CAPTCHA resolution or waits for a manual solve signal.
+   *
+   * @param options - Configuration for timeout, auto-detection, and reason text.
+   * @returns Result indicating whether the CAPTCHA was solved and by what method.
+   */
+  async waitForHuman(options = {}) {
+    const {
+      reason = "Human interaction required",
+      timeout = 120,
+      autoDetect = true,
+      detectInterval = 2e3
+    } = options;
+    const captcha = await CaptchaDetector.detect(this.page);
+    const captchaInfo = captcha.detected ? captcha : void 0;
+    await this.capturer.startCapture(this.page, "default", (frame) => {
+      this.wsServer.broadcast({
+        type: "screenshot",
+        data: {
+          sessionId: frame.sessionId,
+          id: frame.id,
+          timestamp: frame.timestamp,
+          data: frame.data,
+          url: frame.url,
+          viewport: frame.viewport
+        }
+      });
+    });
+    const previewUrl = `http://localhost:${this.wsServer.getPort()}`;
+    await this.sendWebhook("captcha-detected", {
+      reason: captchaInfo ? `${captchaInfo.type ?? "unknown"} CAPTCHA detected` : reason,
+      timeout,
+      targetUrl: this.page.url()
+    });
+    this.wsServer.broadcast({
+      type: "captcha-detected",
+      sessionId: "default",
+      url: this.page.url(),
+      reason: captchaInfo ? `${captchaInfo.type ?? "unknown"} CAPTCHA detected` : reason,
+      timeout
+    });
+    this.tryAutoOpen(previewUrl);
+    console.log("");
+    console.log("\u26A0\uFE0F  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log(`\u26A0\uFE0F  ${captchaInfo ? (captchaInfo.type ?? "UNKNOWN").toUpperCase() + " CAPTCHA" : "INTERACTION"} REQUIRED`);
+    console.log(`\u26A0\uFE0F  URL: ${this.page.url()}`);
+    console.log(`\u26A0\uFE0F  `);
+    console.log(`\u26A0\uFE0F  Solve via:`);
+    console.log(`\u26A0\uFE0F    \u{1F4FA} Preview: ${previewUrl}`);
+    console.log(`\u26A0\uFE0F    \u{1F310} Direct:  ${this.page.url()}`);
+    console.log(`\u26A0\uFE0F    \u23ED\uFE0F  Skip`);
+    console.log(`\u26A0\uFE0F    \u274C Abort`);
+    console.log(`\u26A0\uFE0F  `);
+    console.log(`\u26A0\uFE0F  \u23F3 Waiting... (${timeout}s timeout)`);
+    console.log("\u26A0\uFE0F  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    console.log("");
+    return new Promise((resolve) => {
+      let resolved = false;
+      let pollTimer = null;
+      let timeoutTimer = null;
+      const cleanup = () => {
+        if (pollTimer) clearInterval(pollTimer);
+        if (timeoutTimer) clearTimeout(timeoutTimer);
+        this.wsServer.removeListener("human-solved", onHumanSolved);
+        this.capturer.stopCapture();
+      };
+      if (autoDetect && captchaInfo) {
+        pollTimer = setInterval(async () => {
+          if (resolved) return;
+          try {
+            const solved = await CaptchaDetector.isSolved(this.page, captchaInfo.selector);
+            if (solved) {
+              resolved = true;
+              cleanup();
+              this.wsServer.broadcast({ type: "resolved", sessionId: "default" });
+              console.log("\u2705 CAPTCHA auto-detected as solved!");
+              this.sendWebhook("captcha-resolved", { reason: "auto-detected" });
+              resolve({ solved: true, method: "auto-detected" });
+            }
+          } catch {
+          }
+        }, detectInterval);
+      }
+      const onHumanSolved = () => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          this.wsServer.broadcast({ type: "resolved", sessionId: "default" });
+          console.log("\u2705 CAPTCHA solved via preview!");
+          this.sendWebhook("captcha-resolved", { reason: "preview" });
+          resolve({ solved: true, method: "preview" });
+        }
+      };
+      this.wsServer.on("human-solved", onHumanSolved);
+      if (timeout > 0) {
+        timeoutTimer = setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            cleanup();
+            console.log("\u23F0 Timeout - skipping");
+            this.sendWebhook("captcha-resolved", { reason: "timeout" });
+            resolve({ solved: false, method: "timeout" });
+          }
+        }, timeout * 1e3);
+      }
+    });
+  }
+};
+
+export {
+  ScreencastCapturer,
+  CaptchaDetector,
+  WebhookNotifier,
+  HumanInteractionManager
+};

package/dist/chunk-YEN2ODUI.js

@@ -0,0 +1,14 @@
+// src/utils/json-file.ts
+import { readFileSync, writeFileSync } from "fs";
+function readJsonFile(filePath, defaultValue) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+
+export {
+  readJsonFile
+};