Forgets

Dockerfile

@@ -0,0 +1,43 @@
+FROM node:18-bullseye
+
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    chromium \
+    chromium-driver \
+    fonts-liberation \
+    libasound2 \
+    libatk-bridge2.0-0 \
+    libatk1.0-0 \
+    libatspi2.0-0 \
+    libcups2 \
+    libdbus-1-3 \
+    libdrm2 \
+    libgbm1 \
+    libgtk-3-0 \
+    libnspr4 \
+    libnss3 \
+    libwayland-client0 \
+    libxcomposite1 \
+    libxdamage1 \
+    libxfixes3 \
+    libxkbcommon0 \
+    libxrandr2 \
+    xdg-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY package*.json ./
+COPY postinstall.js ./
+
+
+RUN npm install
+
+COPY . .
+
+EXPOSE 7860
+
+ENV PLAYWRIGHT_BROWSERS_PATH=/usr/bin/chromium
+ENV NODE_ENV=production
+
+CMD ["node", "server.js"]

README.md

@@ -1,11 +1,10 @@
 ---
 title: V2
-emoji: 🦀
-colorFrom: indigo
-colorTo: green
+emoji: 📉
+colorFrom: red
+colorTo: blue
 sdk: docker
 pinned: false
-short_description: 🙏
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

package.json

@@ -0,0 +1,23 @@
+{
+  "name": "recaptcha-solver-api",
+  "version": "1.0.0",
+  "description": "reCAPTCHA Solver API for Hugging Face",
+  "main": "server.js",
+  "type": "module",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node server.js",
+    "postinstall": "node postinstall.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "playwright-core": "^1.40.0",
+    "cors": "^2.8.5",
+    "vosk-koffi": "^1.0.8",
+    "wav": "^1.0.2",
+    "yauzl": "^2.10.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

postinstall.js

@@ -0,0 +1,122 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import https from 'https';
+import yauzl from 'yauzl';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const URL = "https://alphacephei.com/vosk/models/vosk-model-small-en-us-0.15.zip";
+const MODEL_DIR = path.resolve(__dirname, "model");
+
+async function main() {
+    if (!fs.existsSync(MODEL_DIR)) {
+        fs.mkdirSync(MODEL_DIR, { recursive: true });
+    }
+
+    if (fs.existsSync(path.resolve(MODEL_DIR, "DONE"))) {
+        console.log("Model already downloaded");
+        return;
+    }
+
+    const zip = path.resolve(os.tmpdir(), path.basename(URL));
+    await download(URL, zip);
+    console.log("Downloaded model to", zip);
+
+    await unzip(zip, MODEL_DIR);
+    fs.unlinkSync(zip);
+}
+
+function download(url, to, redirect = 0) {
+    if (redirect === 0) {
+        console.log(`Downloading ${url} to ${to}`);
+    } else {
+        console.log(`Redirecting to ${url}`);
+    }
+
+    return new Promise((resolve, reject) => {
+        if (!fs.existsSync(path.dirname(to))) {
+            fs.mkdirSync(path.dirname(to), { recursive: true });
+        }
+
+        let done = true;
+        const file = fs.createWriteStream(to);
+        const request = https.get(url, (res) => {
+            if (res.statusCode === 302 && res.headers.location !== undefined) {
+                done = false;
+                file.close();
+                resolve(download(res.headers.location, to, redirect + 1));
+                return;
+            }
+            res.pipe(file);
+        });
+
+        file.on("finish", () => {
+            if (done) {
+                resolve(to);
+            }
+        });
+
+        request.on("error", (err) => {
+            fs.unlink(to, () => reject(err));
+        });
+
+        file.on("error", (err) => {
+            fs.unlink(to, () => reject(err));
+        });
+
+        request.end();
+    });
+}
+
+function unzip(zip, dest) {
+    const dir = path.basename(zip, ".zip");
+    return new Promise((resolve, reject) => {
+        yauzl.open(zip, { lazyEntries: true }, (err, zipfile) => {
+            if (err) {
+                reject(err);
+            }
+            zipfile.readEntry();
+            zipfile
+                .on("entry", (entry) => {
+                    if (/\/$/.test(entry.fileName)) {
+                        zipfile.readEntry();
+                    } else {
+                        zipfile.openReadStream(entry, (err, stream) => {
+                            if (err) {
+                                reject(err);
+                            }
+                            const f = path.resolve(dest, entry.fileName.replace(`${dir}/`, ""));
+                            if (!fs.existsSync(path.dirname(f))) {
+                                fs.mkdirSync(path.dirname(f), { recursive: true });
+                                console.log("Created directory", path.dirname(f));
+                            }
+                            stream.pipe(fs.createWriteStream(f));
+                            stream
+                                .on("end", () => {
+                                    console.log("Extracted", f);
+                                    zipfile.readEntry();
+                                })
+                                .on("error", (err) => {
+                                    reject(err);
+                                });
+                        });
+                    }
+                })
+                .on("error", (err) => {
+                    reject(err);
+                })
+                .on("end", () => {
+                    console.log("Extracted all files");
+                    fs.writeFileSync(path.resolve(dest, "DONE"), "");
+                })
+                .on("close", () => {
+                    resolve();
+                });
+        });
+    });
+}
+
+main().catch(console.error);

server.js

@@ -0,0 +1,201 @@
+import express from 'express';
+import { chromium } from 'playwright-core';
+import cors from 'cors';
+import { solve } from './solver.js';
+
+const app = express();
+const PORT = process.env.PORT || 7860;
+
+app.use(cors());
+app.use(express.json());
+
+app.get('/', (req, res) => {
+  res.json({
+    status: 'ok',
+    message: 'reCAPTCHA Solver API is running',
+    endpoints: {
+      solve: '/api/solve?url=YOUR_URL',
+      health: '/health'
+    }
+  });
+});
+
+app.get('/health', (req, res) => {
+  res.json({ status: 'healthy' });
+});
+
+app.get('/api/solve', async (req, res) => {
+  const { url } = req.query;
+
+  if (!url) {
+    return res.status(400).json({
+      error: 'Missing required parameter',
+      message: 'Please provide a URL parameter'
+    });
+  }
+
+  let browser;
+  const startTime = Date.now();
+
+  try {
+    console.log(`[API] Starting to solve reCAPTCHA for: ${url}`);
+
+    browser = await chromium.launch({
+      headless: true,
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-gpu',
+        '--disable-software-rasterizer',
+        '--disable-extensions',
+        '--disable-blink-features=AutomationControlled'
+      ],
+      executablePath: process.env.PLAYWRIGHT_BROWSERS_PATH || '/usr/bin/chromium'
+    });
+
+    const context = await browser.newContext({
+      userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      viewport: { width: 1280, height: 720 }
+    });
+    
+    const page = await context.newPage();
+    
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+
+    console.log('[API] Attempting to solve reCAPTCHA...');
+    
+    await solve(page);
+
+    const solveTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(`[API] reCAPTCHA solved in ${solveTime}s`);
+
+    const pageUrl = page.url();
+    const pageTitle = await page.title();
+
+    const token = await page.evaluate(() => {
+      const textarea = document.querySelector('[name="g-recaptcha-response"]');
+      return textarea ? textarea.value : null;
+    });
+
+    await browser.close();
+
+    res.json({
+      success: true,
+      message: 'reCAPTCHA solved successfully',
+      solveTime: `${solveTime}s`,
+      url: pageUrl,
+      title: pageTitle,
+      hasToken: !!token,
+      tokenLength: token ? token.length : 0,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('[API] Error solving reCAPTCHA:', error);
+
+    if (browser) {
+      await browser.close().catch(err => console.error('Error closing browser:', err));
+    }
+
+    res.status(500).json({
+      success: false,
+      error: 'Failed to solve reCAPTCHA',
+      message: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+});
+
+app.post('/api/solve', async (req, res) => {
+  const { url, submitSelector } = req.body;
+
+  if (!url) {
+    return res.status(400).json({
+      error: 'Missing required field',
+      message: 'Please provide a URL in the request body'
+    });
+  }
+
+  let browser;
+  const startTime = Date.now();
+
+  try {
+    console.log(`[API] Starting to solve reCAPTCHA for: ${url}`);
+
+    browser = await chromium.launch({
+      headless: true,
+      args: [
+        '--no-sandbox',
+        '--disable-setuid-sandbox',
+        '--disable-dev-shm-usage',
+        '--disable-gpu',
+        '--disable-blink-features=AutomationControlled'
+      ],
+      executablePath: process.env.PLAYWRIGHT_BROWSERS_PATH || '/usr/bin/chromium'
+    });
+
+    const context = await browser.newContext({
+      userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+      viewport: { width: 1280, height: 720 }
+    });
+    
+    const page = await context.newPage();
+    await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 60000 });
+
+    console.log('[API] Attempting to solve reCAPTCHA...');
+    await solve(page);
+
+    await page.waitForTimeout(2000);
+
+    if (submitSelector) {
+      await page.click(submitSelector);
+      await page.waitForTimeout(3000);
+    }
+
+    const solveTime = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(`[API] reCAPTCHA solved in ${solveTime}s`);
+
+    const pageUrl = page.url();
+
+    await browser.close();
+
+    res.json({
+      success: true,
+      message: 'reCAPTCHA solved successfully',
+      solveTime: `${solveTime}s`,
+      url: pageUrl,
+      timestamp: new Date().toISOString()
+    });
+
+  } catch (error) {
+    console.error('[API] Error solving reCAPTCHA:', error);
+
+    if (browser) {
+      await browser.close().catch(err => console.error('Error closing browser:', err));
+    }
+
+    res.status(500).json({
+      success: false,
+      error: 'Failed to solve reCAPTCHA',
+      message: error.message,
+      timestamp: new Date().toISOString()
+    });
+  }
+});
+
+app.listen(PORT, '0.0.0.0', () => {
+  console.log(`🚀 reCAPTCHA Solver API running on port ${PORT}`);
+  console.log(`📍 Health check: http://localhost:${PORT}/health`);
+  console.log(`🔧 Solve endpoint: http://localhost:${PORT}/api/solve?url=YOUR_URL`);
+});
+
+process.on('SIGTERM', () => {
+  console.log('SIGTERM received, shutting down gracefully...');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('SIGINT received, shutting down gracefully...');
+  process.exit(0);
+});

solver.js

@@ -0,0 +1,377 @@
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { Readable } from 'stream';
+import vosk from 'vosk-koffi';
+import wav from 'wav';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+vosk.setLogLevel(-1);
+const MODEL_DIR = path.resolve(__dirname, "model");
+const model = new vosk.Model(MODEL_DIR);
+
+const SOURCE_FILE = "sound.mp3";
+const OUT_FILE = "out.wav";
+const MAIN_FRAME = "iframe[title='reCAPTCHA']";
+const BFRAME = "iframe[src*='google.com/recaptcha'][src*='bframe']";
+const CHALLENGE = "body > div > div";
+
+class Mutex {
+    constructor(name = "Mutex") {
+        this.name = name;
+        this._locked = false;
+        this._queue = [];
+    }
+
+    async lock(tag) {
+        if (this._locked) {
+            if (tag) {
+                console.log(`[${this.name}] ${tag} waiting`);
+            }
+
+            return new Promise((resolve) => {
+                this._queue.push(() => {
+                    this._lock(tag);
+                    resolve();
+                });
+            });
+        }
+
+        this._lock(tag);
+    }
+
+    unlock(tag) {
+        if (this._locked) {
+            if (tag) {
+                console.log(`[${this.name}] ${tag} unlocked`);
+            }
+
+            this._locked = false;
+            this._queue.shift()?.();
+        }
+    }
+
+    _lock(tag) {
+        this._locked = true;
+
+        if (tag) {
+            console.log(`[${this.name}] ${tag} locked`);
+        }
+    }
+}
+
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function createDir() {
+    const dir = path.resolve(os.tmpdir(), "reSOLVER-" + Math.random().toString().slice(2));
+    if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true });
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+function convert(dir, ffmpeg = "ffmpeg") {
+    const args = [
+        "-loglevel",
+        "error",
+        "-i",
+        SOURCE_FILE,
+        "-acodec",
+        "pcm_s16le",
+        "-ac",
+        "1",
+        "-ar",
+        "16000",
+        OUT_FILE,
+    ];
+
+    spawnSync(ffmpeg, args, { cwd: dir });
+}
+
+function recognize(dir) {
+    return new Promise((resolve) => {
+        const stream = fs.createReadStream(path.resolve(dir, OUT_FILE), { highWaterMark: 4096 });
+
+        const reader = new wav.Reader();
+        const readable = new Readable().wrap(reader);
+        reader.on("format", async ({ audioFormat, sampleRate, channels }) => {
+            if (audioFormat != 1 || channels != 1) {
+                throw new Error("Audio file must be WAV with mono PCM.");
+            }
+
+            const rec = new vosk.Recognizer({ model, sampleRate });
+            rec.setMaxAlternatives(10);
+            rec.setWords(true);
+            rec.setPartialWords(true);
+
+            for await (const data of readable) {
+                const end_of_speech = rec.acceptWaveform(data);
+                if (end_of_speech) {
+                    const result = rec
+                        .result()
+                        .alternatives.sort((a, b) => b.confidence - a.confidence)[0].text;
+                    stream.close(() => resolve(result));
+                }
+            }
+
+            rec.free();
+        });
+
+        stream.pipe(reader);
+    });
+}
+
+async function getText(res, ffmpeg = "ffmpeg") {
+    const tempDir = createDir();
+
+    fs.writeFileSync(path.resolve(tempDir, SOURCE_FILE), await res.body());
+    convert(tempDir, ffmpeg);
+    const result = await recognize(tempDir);
+
+    fs.rmSync(tempDir, { recursive: true });
+    return result;
+}
+
+export async function solve(page, { delay = 64, wait = 5000, retry = 3, ffmpeg = "ffmpeg" } = {}) {
+    console.log("Starting reCAPTCHA solver...");
+    
+    try {
+        await page.waitForSelector('iframe', { state: "attached", timeout: wait });
+        console.log("Found iframes on page");
+        
+        const allIframes = await page.$$('iframe');
+        console.log(`Total iframes found: ${allIframes.length}`);
+        
+        for (let i = 0; i < allIframes.length; i++) {
+            const src = await allIframes[i].getAttribute('src');
+            const title = await allIframes[i].getAttribute('title');
+            console.log(`Iframe ${i}: src=${src}, title=${title}`);
+        }
+    } catch (error) {
+        console.error("Error finding iframes:", error.message);
+        throw new Error("No reCAPTCHA detected");
+    }
+
+    let invisible = false;
+
+    let b_iframe = null;
+    const bframeSelectors = [
+        "iframe[src*='/recaptcha/api2/bframe']",
+        "iframe[src*='/recaptcha/enterprise/bframe']",
+        "iframe[src*='bframe']"
+    ];
+    
+    for (const selector of bframeSelectors) {
+        try {
+            await page.waitForSelector(selector, { state: "attached", timeout: 2000 });
+            b_iframe = await page.$(selector);
+            if (b_iframe) {
+                console.log(`Found bframe with selector: ${selector}`);
+                break;
+            }
+        } catch {
+            continue;
+        }
+    }
+
+    if (b_iframe === null) {
+        console.log("Bframe not found yet, checking main frame...");
+        
+        try {
+            await page.waitForSelector(MAIN_FRAME, { state: "attached", timeout: wait });
+            const iframe = await page.$(MAIN_FRAME);
+            
+            if (iframe === null) {
+                throw new Error("Could not find reCAPTCHA iframe");
+            }
+
+            const box_page = await iframe.contentFrame();
+            if (box_page === null) {
+                throw new Error("Could not find reCAPTCHA iframe content");
+            }
+
+            invisible = (await box_page.$("div.rc-anchor-invisible")) ? true : false;
+            console.log("invisible:", invisible);
+
+            if (invisible === true) {
+                return false;
+            } else {
+                const label = await box_page.$("#recaptcha-anchor-label");
+                if (label === null) {
+                    throw new Error("Could not find reCAPTCHA label");
+                }
+
+                console.log("Clicking reCAPTCHA checkbox...");
+                await label.click();
+                
+                await sleep(2000);
+                
+                for (const selector of bframeSelectors) {
+                    b_iframe = await page.$(selector);
+                    if (b_iframe) {
+                        console.log(`Found bframe after click: ${selector}`);
+                        break;
+                    }
+                }
+            }
+        } catch (error) {
+            console.error("Error handling main frame:", error.message);
+            throw new Error("Could not find reCAPTCHA popup iframe");
+        }
+    }
+
+    if (b_iframe === null) {
+        throw new Error("Could not find reCAPTCHA popup iframe after all attempts");
+    }
+
+    const bframe = await b_iframe.contentFrame();
+    if (bframe === null) {
+        throw new Error("Could not find reCAPTCHA popup iframe content");
+    }
+
+    await sleep(1000);
+    
+    const challenge = await bframe.$(CHALLENGE);
+    if (challenge === null) {
+        console.log("No challenge found yet, this might be OK");
+        return false;
+    }
+
+    const required = await challenge.evaluate(
+        (elm) => !elm.classList.contains("rc-footer"),
+    );
+    console.log("action required:", required);
+
+    if (required === false) {
+        return false;
+    }
+
+    await bframe.waitForSelector("#recaptcha-audio-button", { timeout: wait });
+    const audio_button = await bframe.$("#recaptcha-audio-button");
+    if (audio_button === null) {
+        throw new Error("Could not find reCAPTCHA audio button");
+    }
+
+    const mutex = new Mutex();
+    await mutex.lock("init");
+    let passed = false;
+    let answer = Promise.resolve("");
+    const listener = async (res) => {
+        if (res.headers()["content-type"] === "audio/mp3") {
+            console.log(`got audio from ${res.url()}`);
+            answer = new Promise((resolve) => {
+                getText(res, ffmpeg)
+                    .then(resolve)
+                    .catch(() => undefined);
+            });
+            mutex.unlock("get sound");
+        } else if (
+            res.url().startsWith("https://www.google.com/recaptcha/api2/userverify") ||
+            res.url().startsWith("https://www.google.com/recaptcha/enterprise/userverify")
+        ) {
+            const raw = (await res.body()).toString().replace(")]}'\n", "");
+            const json = JSON.parse(raw);
+            passed = json[2] === 1;
+            mutex.unlock("verified");
+        }
+    };
+    page.on("response", listener);
+
+    await audio_button.click();
+
+    let tried = 0;
+    while (passed === false) {
+        if (tried++ >= retry) {
+            throw new Error("Could not solve reCAPTCHA");
+        }
+
+        await Promise.race([
+            mutex.lock("ready"),
+            sleep(wait).then(() => {
+                throw new Error("No Audio Found");
+            }),
+        ]);
+        await bframe.waitForSelector("#audio-source", { state: "attached", timeout: wait });
+        await bframe.waitForSelector("#audio-response", { timeout: wait });
+
+        console.log("recognized:", await answer);
+
+        const input = await bframe.$("#audio-response");
+        if (input === null) {
+            throw new Error("Could not find reCAPTCHA audio input");
+        }
+
+        await input.type(await answer, { delay });
+
+        const button = await bframe.$("#recaptcha-verify-button");
+        if (button === null) {
+            throw new Error("Could not find reCAPTCHA verify button");
+        }
+
+        await button.click();
+        await mutex.lock("done");
+        console.log("passed:", passed);
+    }
+
+    page.off("response", listener);
+
+    await sleep(1000);
+
+    let token = null;
+    
+    try {
+        const iframe = await page.$(MAIN_FRAME);
+        if (iframe) {
+            const box_page = await iframe.contentFrame();
+            if (box_page) {
+                const textarea = await box_page.$('#g-recaptcha-response');
+                if (textarea) {
+                    token = await textarea.evaluate(el => el.value);
+                    console.log("Token found in textarea:", token?.substring(0, 50) + "...");
+                }
+            }
+        }
+    } catch (error) {
+        console.log("Error extracting token from iframe:", error.message);
+    }
+
+    if (!token) {
+        try {
+            const textarea = await page.$('#g-recaptcha-response');
+            if (textarea) {
+                token = await textarea.evaluate(el => el.value);
+                console.log("Token found in main page:", token?.substring(0, 50) + "...");
+            }
+        } catch (error) {
+            console.log("Error extracting token from main page:", error.message);
+        }
+    }
+
+    if (!token) {
+        try {
+            const allTextareas = await page.$('textarea');
+            for (const textarea of allTextareas) {
+                const name = await textarea.getAttribute('name');
+                const id = await textarea.getAttribute('id');
+                if (name === 'g-recaptcha-response' || id === 'g-recaptcha-response') {
+                    token = await textarea.evaluate(el => el.value);
+                    console.log("Token found in textarea by attribute:", token?.substring(0, 50) + "...");
+                    break;
+                }
+            }
+        } catch (error) {
+            console.log("Error searching all textareas:", error.message);
+        }
+    }
+
+    console.log("Final token:", token ? `${token.substring(0, 50)}... (length: ${token.length})` : "not found");
+
+    return { success: true, token };
+}