@skrillex1224/playwright-toolkit 2.1.217 → 2.1.219

package/dist/index.js

@@ -415,6 +415,9 @@ function createInternalLogger(moduleName, explicitLogger) {
     },
     info(message) {
       baseLogger.info(message);
+    },
+    error(message) {
+      baseLogger.error(message);
     }
   };
 }
@@ -2947,13 +2950,45 @@ var LiveView = {
 // src/captcha-monitor.js
 import { v4 as uuidv4 } from "uuid";
 var logger9 = createInternalLogger("Captcha");
+var DEFAULT_BYTEDANCE_CAPTCHA_TOKEN = "eKJvBfwfN0YRav0-VD_44E2VBSfm7l0YtddUQ7cFySI";
+var DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS = Object.freeze({
+  token: DEFAULT_BYTEDANCE_CAPTCHA_TOKEN,
+  apiUrl: "https://api.jfbym.com/api/YmServer/customApi",
+  apiType: "31234",
+  maxRetries: 3,
+  containerSelector: "#captcha_container",
+  iframeSelector: 'iframe[src*="verifycenter"]',
+  iframeFallbackSelector: "iframe",
+  sourceImageSelector: "div.canvas-container",
+  dropTargetContainerSelector: "#captcha_verify_image div",
+  dropTargetTexts: ["\u62D6\u62FD\u5230\u8FD9\u91CC"],
+  refreshTexts: ["\u5237\u65B0"],
+  submitTexts: ["\u63D0\u4EA4"],
+  recognitionSuccessCode: 1e4,
+  containerVisibleTimeoutMs: 2e3,
+  iframeVisibleTimeoutMs: 12e3,
+  iframeFallbackVisibleTimeoutMs: 4e3,
+  contentFrameResolveRetries: 5,
+  contentFrameResolveDelayMs: 500,
+  actionVisibleTimeoutMs: 1500,
+  sourceImageVisibleTimeoutMs: 3e3,
+  challengeReadyTimeoutMs: 15e3,
+  challengeReadyPollMs: 300,
+  loadingIndicatorVisibleTimeoutMs: 200,
+  loadingTexts: ["\u52A0\u8F7D\u4E2D", "\u52A0\u8F7D\u4E2D..."],
+  recognitionDelayMs: 2e3,
+  refreshWaitMs: 3e3,
+  submitWaitMs: 3e3,
+  retryDelayBaseMs: 2e3,
+  retryDelayStepMs: 1e3
+});
 function useCaptchaMonitor(page, options) {
   const { domSelector, urlPattern, onDetected } = options;
   if (!domSelector && !urlPattern) {
-    throw new Error("[CaptchaMonitor] \u5FC5\u987B\u63D0\u4F9B domSelector \u6216 urlPattern \u81F3\u5C11\u4E00\u4E2A");
+    throw new Error("[CaptchaMonitor] \u5FC5\u987B\u63D0\u4F9B domSelector \u6216 urlPattern\u3002");
   }
   if (!onDetected || typeof onDetected !== "function") {
-    throw new Error("[CaptchaMonitor] onDetected \u5FC5\u987B\u662F\u4E00\u4E2A\u51FD\u6570");
+    throw new Error("[CaptchaMonitor] onDetected \u5FC5\u987B\u662F\u51FD\u6570\u3002");
   }
   let isStopped = false;
   let isHandling = false;
@@ -2974,28 +3009,22 @@ function useCaptchaMonitor(page, options) {
     const cleanerName = `__c_cleaner_${uuidv4().replace(/-/g, "_")}`;
     page.exposeFunction(exposedFunctionName, triggerDetected).catch(() => {
     });
-    page.addInitScript(({ selector, callbackName, cleanerName: cleanerName2 }) => {
+    page.addInitScript(({ selector, callbackName, cleanerName: cleanupName }) => {
       (() => {
         let observer = null;
         const checkAndReport = () => {
           const element = document.querySelector(selector);
-          if (element) {
-            if (window[callbackName]) {
-              window[callbackName]();
-            }
-            return true;
+          if (!element) {
+            return false;
           }
-          return false;
+          if (window[callbackName]) {
+            window[callbackName]();
+          }
+          return true;
         };
         checkAndReport();
         observer = new MutationObserver((mutations) => {
-          let shouldCheck = false;
-          for (const mutation of mutations) {
-            if (mutation.addedNodes.length > 0) {
-              shouldCheck = true;
-              break;
-            }
-          }
+          const shouldCheck = mutations.some((mutation) => mutation.addedNodes.length > 0);
           if (shouldCheck && observer) {
             checkAndReport();
           }
@@ -3011,7 +3040,7 @@ function useCaptchaMonitor(page, options) {
         } else {
           mountObserver();
         }
-        window[cleanerName2] = () => {
+        window[cleanupName] = () => {
           if (observer) {
             observer.disconnect();
             observer = null;
@@ -3019,7 +3048,7 @@ function useCaptchaMonitor(page, options) {
         };
       })();
     }, { selector: domSelector, callbackName: exposedFunctionName, cleanerName });
-    logger9.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528: ${domSelector}`);
+    logger9.success("useCaptchaMonitor", `DOM \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${domSelector}`);
     cleanupFns.push(async () => {
       try {
         await page.evaluate((name) => {
@@ -3028,28 +3057,29 @@ function useCaptchaMonitor(page, options) {
             delete window[name];
           }
         }, cleanerName);
-      } catch (e) {
+      } catch {
       }
     });
   }
   if (urlPattern) {
     frameHandler = async (frame) => {
-      if (frame === page.mainFrame()) {
-        const currentUrl = page.url();
-        if (currentUrl.includes(urlPattern)) {
-          await triggerDetected();
-        }
+      if (frame !== page.mainFrame()) {
+        return;
+      }
+      const currentUrl = page.url();
+      if (currentUrl.includes(urlPattern)) {
+        await triggerDetected();
       }
     };
     page.on("framenavigated", frameHandler);
-    logger9.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528: ${urlPattern}`);
+    logger9.success("useCaptchaMonitor", `URL \u76D1\u63A7\u5DF2\u542F\u7528\uFF1A${urlPattern}`);
     cleanupFns.push(async () => {
       page.off("framenavigated", frameHandler);
     });
   }
   return {
     stop: async () => {
-      logger9.info("useCaptchaMonitor", "\u6B63\u5728\u505C\u6B62\u76D1\u63A7...");
+      logger9.info("\u6B63\u5728\u505C\u6B62\u9A8C\u8BC1\u7801\u76D1\u63A7...");
       for (const fn of cleanupFns) {
         await fn();
       }
@@ -3057,8 +3087,281 @@ function useCaptchaMonitor(page, options) {
     }
   };
 }
+var callCaptchaRecognitionApi = async (imageBase64, { apiUrl, apiType, token }) => {
+  const response = await fetch(apiUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      type: apiType,
+      image: imageBase64,
+      token
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Captcha API request failed with status ${response.status}`);
+  }
+  return await response.json();
+};
+var extractCaptchaSerialNumbers = (apiResponse) => {
+  const serialNumbers = apiResponse?.data?.data?.serial_number;
+  if (!Array.isArray(serialNumbers)) {
+    return [];
+  }
+  return serialNumbers.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value >= 0);
+};
+var waitForVisible = async (locator, timeout) => {
+  try {
+    await locator.waitFor({
+      state: "visible",
+      timeout
+    });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var isAnyCaptchaTextVisible = async (frame, texts, timeout) => {
+  for (const text of texts || []) {
+    if (!text) {
+      continue;
+    }
+    const candidates = [
+      frame.getByText(text, { exact: false }).first(),
+      frame.locator(`text=${text}`).first()
+    ];
+    for (const candidate of candidates) {
+      const isVisible = await candidate.isVisible({ timeout }).catch(() => false);
+      if (isVisible) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var waitForCaptchaChallengeReady = async (page, frame, options) => {
+  const deadline = Date.now() + options.challengeReadyTimeoutMs;
+  let hasSeenLoading = false;
+  while (Date.now() < deadline) {
+    const isLoadingVisible = await isAnyCaptchaTextVisible(
+      frame,
+      options.loadingTexts,
+      options.loadingIndicatorVisibleTimeoutMs
+    );
+    hasSeenLoading = hasSeenLoading || isLoadingVisible;
+    const sourceImages = frame.locator(options.sourceImageSelector);
+    const imageCount = await sourceImages.count().catch(() => 0);
+    const hasVisibleSourceImage = imageCount > 0 ? await sourceImages.first().isVisible({ timeout: options.loadingIndicatorVisibleTimeoutMs }).catch(() => false) : false;
+    if (!isLoadingVisible && hasVisibleSourceImage) {
+      logger9.info(hasSeenLoading ? "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u52A0\u8F7D\u5B8C\u6210\u3002" : "\u9A8C\u8BC1\u7801\u56FE\u7247\u5DF2\u5C31\u7EEA\u3002");
+      return;
+    }
+    await page.waitForTimeout(options.challengeReadyPollMs);
+  }
+  throw new Error("Captcha challenge is still loading and did not become ready in time.");
+};
+var resolveContentFrame = async (page, iframeLocator, options) => {
+  for (let attempt = 1; attempt <= options.contentFrameResolveRetries; attempt++) {
+    const iframeHandle = await iframeLocator.elementHandle();
+    const frame = await iframeHandle?.contentFrame();
+    if (frame) {
+      return frame;
+    }
+    if (attempt < options.contentFrameResolveRetries) {
+      await page.waitForTimeout(options.contentFrameResolveDelayMs);
+    }
+  }
+  return null;
+};
+var getVerifycenterCaptchaContext = async (page, options) => {
+  const captchaContainer = page.locator(options.containerSelector).first();
+  const isContainerVisible = await waitForVisible(
+    captchaContainer,
+    options.containerVisibleTimeoutMs
+  );
+  if (!isContainerVisible) {
+    return null;
+  }
+  logger9.info("\u68C0\u6D4B\u5230\u9A8C\u8BC1\u7801\u5BB9\u5668\uFF0C\u5F00\u59CB\u7B49\u5F85 iframe \u52A0\u8F7D\u3002");
+  let iframeLocator = page.locator(options.iframeSelector).first();
+  let isIframeVisible = await waitForVisible(
+    iframeLocator,
+    options.iframeVisibleTimeoutMs
+  );
+  if (!isIframeVisible) {
+    logger9.warn("\u672A\u5728\u9884\u671F\u9009\u62E9\u5668\u4E2D\u627E\u5230 verifycenter iframe\uFF0C\u5C1D\u8BD5\u5BB9\u5668\u5185\u4EFB\u610F iframe\u3002");
+    iframeLocator = captchaContainer.locator(options.iframeFallbackSelector).first();
+    isIframeVisible = await waitForVisible(
+      iframeLocator,
+      options.iframeFallbackVisibleTimeoutMs
+    );
+  }
+  if (!isIframeVisible) {
+    throw new Error("verifycenter iframe not found inside captcha container.");
+  }
+  logger9.info("\u9A8C\u8BC1\u7801 iframe \u5DF2\u53EF\u89C1\uFF0C\u5F00\u59CB\u89E3\u6790\u5185\u5BB9 frame\u3002");
+  const frame = await resolveContentFrame(page, iframeLocator, options);
+  if (!frame) {
+    throw new Error("Failed to resolve verifycenter iframe content frame.");
+  }
+  return { iframeLocator, frame };
+};
+var clickCaptchaAction = async (frame, texts, options) => {
+  for (const text of texts) {
+    const candidates = [
+      frame.getByText(text, { exact: false }).first(),
+      frame.locator(`text=${text}`).first()
+    ];
+    for (const candidate of candidates) {
+      const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
+      if (!isVisible) {
+        continue;
+      }
+      await candidate.click();
+      return true;
+    }
+  }
+  return false;
+};
+var findCaptchaDropTarget = async (frame, options) => {
+  for (const text of options.dropTargetTexts) {
+    const candidates = [
+      frame.locator(options.dropTargetContainerSelector).filter({ hasText: text }).first(),
+      frame.getByText(text, { exact: false }).first()
+    ];
+    for (const candidate of candidates) {
+      const isVisible = await waitForVisible(candidate, options.actionVisibleTimeoutMs);
+      if (isVisible) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+};
+var dragCaptchaWithMouse = async (page, sourceLocator, targetLocator) => {
+  const sourceBox = await sourceLocator.boundingBox();
+  const targetBox = await targetLocator.boundingBox();
+  if (!sourceBox || !targetBox) {
+    throw new Error("Unable to resolve captcha drag coordinates.");
+  }
+  const startX = sourceBox.x + sourceBox.width / 2;
+  const startY = sourceBox.y + sourceBox.height / 2;
+  const endX = targetBox.x + targetBox.width / 2;
+  const endY = targetBox.y + targetBox.height / 2;
+  const steps = 10;
+  const liftOffsetX = Math.min(18, Math.max(8, sourceBox.width * 0.12));
+  const liftOffsetY = Math.min(12, Math.max(4, sourceBox.height * 0.08));
+  await page.mouse.move(startX, startY, { steps: 8 });
+  await page.waitForTimeout(250);
+  await page.mouse.down();
+  await page.waitForTimeout(350);
+  await page.mouse.move(startX + liftOffsetX, startY + liftOffsetY, { steps: 6 });
+  await page.waitForTimeout(250);
+  for (let step = 1; step <= steps; step++) {
+    const progress = step / steps;
+    const easedProgress = 1 - (1 - progress) * (1 - progress);
+    const currentX = startX + liftOffsetX + (endX - startX - liftOffsetX) * easedProgress;
+    const currentY = startY + liftOffsetY + (endY - startY - liftOffsetY) * easedProgress;
+    await page.mouse.move(currentX, currentY, { steps: 2 });
+    await page.waitForTimeout(90);
+  }
+  await page.waitForTimeout(100);
+  await page.mouse.up();
+  await page.waitForTimeout(100);
+};
+var refreshCaptcha = async (page, frame, options) => {
+  const clicked = await clickCaptchaAction(frame, options.refreshTexts, options).catch(() => false);
+  if (!clicked) {
+    logger9.warn("Refresh button not found.");
+    return false;
+  }
+  await page.waitForTimeout(options.refreshWaitMs);
+  return true;
+};
+async function solveBytedanceCaptcha(page, options = {}) {
+  const config = {
+    ...DEFAULT_BYTEDANCE_CAPTCHA_OPTIONS,
+    ...options
+  };
+  if (!config.token) {
+    logger9.warn("\u7F3A\u5C11\u9A8C\u8BC1\u7801 token\uFF0C\u8DF3\u8FC7\u81EA\u52A8\u8BC6\u522B\u3002");
+    return false;
+  }
+  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
+    logger9.info(`\u5F00\u59CB\u7B2C ${attempt}/${config.maxRetries} \u6B21 verifycenter \u9A8C\u8BC1\u7801\u8BC6\u522B\u3002`);
+    try {
+      const captchaContext = await getVerifycenterCaptchaContext(page, config);
+      if (!captchaContext) {
+        logger9.info("Captcha container is not visible anymore.");
+        return true;
+      }
+      const { iframeLocator, frame } = captchaContext;
+      await waitForCaptchaChallengeReady(page, frame, config);
+      await page.waitForTimeout(config.recognitionDelayMs);
+      const screenshotBuffer = await iframeLocator.screenshot();
+      const apiResponse = await callCaptchaRecognitionApi(
+        screenshotBuffer.toString("base64"),
+        config
+      );
+      const serialNumbers = extractCaptchaSerialNumbers(apiResponse);
+      if (apiResponse?.code !== config.recognitionSuccessCode || serialNumbers.length === 0) {
+        logger9.warn(
+          `\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\u3002code=${apiResponse?.code}, msg=${apiResponse?.msg || "unknown"}`
+        );
+        await refreshCaptcha(page, frame, config);
+        continue;
+      }
+      logger9.info(`\u9A8C\u8BC1\u7801\u8BC6\u522B\u6210\u529F\uFF0C\u5E8F\u53F7\uFF1A${serialNumbers.join(", ")}`);
+      const dropTarget = await findCaptchaDropTarget(frame, config);
+      if (!dropTarget) {
+        logger9.warn("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u62D6\u62FD\u76EE\u6807\u533A\u57DF\u3002");
+        await refreshCaptcha(page, frame, config);
+        continue;
+      }
+      const sourceImages = frame.locator(config.sourceImageSelector);
+      const imageCount = await sourceImages.count();
+      for (const rawIndex of serialNumbers) {
+        let imageIndex = rawIndex;
+        if (imageIndex >= imageCount && imageIndex > 0 && imageIndex - 1 < imageCount) {
+          imageIndex -= 1;
+        }
+        if (imageIndex < 0 || imageIndex >= imageCount) {
+          throw new Error(`Captcha image index ${rawIndex} is out of range. count=${imageCount}`);
+        }
+        const sourceImage = sourceImages.nth(imageIndex);
+        await sourceImage.waitFor({
+          state: "visible",
+          timeout: config.sourceImageVisibleTimeoutMs
+        });
+        await dragCaptchaWithMouse(page, sourceImage, dropTarget);
+      }
+      const submitted = await clickCaptchaAction(frame, config.submitTexts, config).catch(() => false);
+      if (!submitted) {
+        logger9.warn("\u672A\u627E\u5230\u63D0\u4EA4\u6309\u94AE\uFF0C\u53EF\u80FD\u4F1A\u81EA\u52A8\u63D0\u4EA4\u3002");
+      }
+      await page.waitForTimeout(config.submitWaitMs);
+      const stillVisible = await iframeLocator.isVisible({ timeout: config.containerVisibleTimeoutMs }).catch(() => false);
+      if (!stillVisible) {
+        logger9.info("\u9A8C\u8BC1\u7801\u8BC6\u522B\u5E76\u63D0\u4EA4\u6210\u529F\u3002");
+        return true;
+      }
+      logger9.warn("\u63D0\u4EA4\u540E\u9A8C\u8BC1\u7801 iframe \u4ECD\u7136\u53EF\u89C1\uFF0C\u51C6\u5907\u5237\u65B0\u540E\u91CD\u8BD5\u3002");
+      await page.waitForTimeout(2e3);
+      await refreshCaptcha(page, frame, config);
+    } catch (error) {
+      logger9.error(`\u7B2C ${attempt}/${config.maxRetries} \u6B21\u9A8C\u8BC1\u7801\u8BC6\u522B\u5931\u8D25\uFF1A${error?.message || error}`);
+    }
+    if (attempt < config.maxRetries) {
+      await page.waitForTimeout(config.retryDelayBaseMs + attempt * config.retryDelayStepMs);
+    }
+  }
+  logger9.error(`\u91CD\u8BD5 ${config.maxRetries} \u6B21\u540E\uFF0C\u9A8C\u8BC1\u7801\u4ECD\u672A\u8BC6\u522B\u6210\u529F\u3002`);
+  return false;
+}
 var Captcha = {
-  useCaptchaMonitor
+  useCaptchaMonitor,
+  solveBytedanceCaptcha
 };
 
 // src/mutation.js