solver.js

const { BrowserWindow, session } = require("electron");
const logger = require("./logger");

class RecaptchaSolver {
  constructor() {
    this.solverWindow = null;
  }

  findChrome() {
    return "Electron";
  }

  async createSolverWindow(targetUrl, proxy = null) {
    if (this.solverWindow && !this.solverWindow.isDestroyed()) {
      this.solverWindow.destroy();
    }

    const partition = `temp:solver-${Date.now()}-${Math.random().toString(36).substring(7)}`;
    const ses = session.fromPartition(partition);

    if (proxy) {
      try {
        const proxyUrl = new URL(proxy);
        const proxyRules = proxyUrl.host; // ip:port

        logger.debug(`[RecaptchaSolver] Setting proxy: ${proxyRules}`);

        // Store credentials in session for app-level login handler (app.on('login'))
        ses.proxyCredentials = {
          username: proxyUrl.username,
          password: proxyUrl.password
        };

        await ses.setProxy({ proxyRules });
      } catch (e) {
        logger.error(`[RecaptchaSolver] Proxy format error: ${proxy}. Skipping.`);
      }
    }

    this.solverWindow = new BrowserWindow({
      width: 360,
      height: 640,
      show: true,
      x: -32000,
      y: -32000,
      frame: false,
      skipTaskbar: true,
      focusable: false,
      webPreferences: {
        nodeIntegration: false,
        contextIsolation: false,
        session: ses,
        webSecurity: false,
        backgroundThrottling: false,
      },
    });

    this.solverWindow.webContents.session.webRequest.onHeadersReceived(
      (details, callback) => {
        const responseHeaders = Object.assign({}, details.responseHeaders);

        if (responseHeaders["content-security-policy"])
          delete responseHeaders["content-security-policy"];
        if (responseHeaders["x-frame-options"])
          delete responseHeaders["x-frame-options"];
        callback({ responseHeaders, cancel: false });
      }
    );

    this.solverWindow.webContents.setUserAgent(
      "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
    );

    this.solverWindow.webContents.setAudioMuted(true);

    this.solverWindow.webContents.on("did-fail-load", (event, errorCode, errorDescription, validatedURL) => {
      logger.warn(`[RecaptchaSolver] Failed to load URL: ${validatedURL} | Error: ${errorDescription} (${errorCode})`);
    });

    await this.solverWindow.loadURL(targetUrl);
  }

  async simulateHumanInteraction() {
    if (!this.solverWindow || this.solverWindow.isDestroyed()) return;

    const contents = this.solverWindow.webContents;
    try {
      contents.sendInputEvent({ type: "mouseEnter", x: 10, y: 10 });
      contents.sendInputEvent({ type: "mouseMove", x: 100, y: 100 });
      await new Promise((r) => setTimeout(r, 100));
      contents.sendInputEvent({ type: "mouseMove", x: 200, y: 150 });
      contents.sendInputEvent({
        type: "mouseDown",
        x: 200,
        y: 150,
        button: "left",
        clickCount: 1,
      });
      await new Promise((r) => setTimeout(r, 50));
      contents.sendInputEvent({
        type: "mouseUp",
        x: 200,
        y: 150,
        button: "left",
        clickCount: 1,
      });
    } catch (e) { }
  }

  async getRecaptchaToken(websiteURL, websiteKey, pageAction, proxy = null) {
    const FIXED_URL = "https://labs.google";
    const FIXED_KEY = "6LdsFiUsAAAAAIjVDZcuLhaHiDn5nnHVXVRQGeMV";
    try {
      await this.createSolverWindow(FIXED_URL, proxy);

      await this.simulateHumanInteraction();

      const token = await this.solverWindow.webContents.executeJavaScript(
        `
        (async function() {
          const siteKey = '${FIXED_KEY}';
          const action = '${pageAction}';

         
          const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));

         
          async function ensureLibrary() {
            if (window.grecaptcha && window.grecaptcha.execute) return;
            
            
            const old = document.getElementById('recaptcha-solver-script');
            if (old) old.remove();

            return new Promise((resolve, reject) => {
              const script = document.createElement('script');
              script.id = 'recaptcha-solver-script';
              script.src = 'https://www.google.com/recaptcha/api.js?render=' + siteKey;
              script.onload = () => {
                  // Đợi thêm 1s để library init xong
                  setTimeout(resolve, 1000);
              };
              script.onerror = () => reject("Load script failed");
              document.head.appendChild(script);
            });
          }

          try {
            await ensureLibrary();
            
            
            let attempts = 0;
            while (!window.grecaptcha || !window.grecaptcha.execute) {
                if (attempts++ > 20) throw new Error("Timeout waiting for grecaptcha");
                await wait(200);
            }

            return new Promise((resolve, reject) => {
               window.grecaptcha.ready(() => {
                  window.grecaptcha.execute(siteKey, { action: action })
                    .then(token => resolve(token))
                    .catch(err => reject("Execute Error: " + err.message));
               });
            });

          } catch (e) {
            return "ERROR: " + e.message;
          }
        })();
      `,
        true
      );

      if (!token || typeof token !== "string" || token.startsWith("ERROR:")) {
        throw new Error("Token lỗi: " + token);
      }

      logger.debug(`[Solver] Token generated: ${token.substring(0, 20)}...`);

      this.close();
      return token;
    } catch (error) {
      logger.error(`[Solver] Error: ${error.message}`);
      this.close();
      return "ERROR: " + error.message;
    }
  }

  async close() {
    if (this.solverWindow && !this.solverWindow.isDestroyed()) {
      this.solverWindow.destroy();
      this.solverWindow = null;
    }
  }
}

module.exports = RecaptchaSolver;