yandex-smartcaptcha-solver 1.0.0

package/README.md

@@ -0,0 +1,434 @@
+# yandex-smartcaptcha-solver
+
+[![npm version](https://badge.fury.io/js/yandex-smartcaptcha-solver.svg)](https://www.npmjs.com/package/yandex-smartcaptcha-solver)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Автоматическое решение Yandex SmartCaptcha с использованием сервиса распознавания XEvil.
+
+## 🚀 Установка
+
+```bash
+npm install yandex-smartcaptcha-solver
+```
+
+## 📖 Быстрый старт
+
+```javascript
+const YandexSmartCaptchaSolver = require('yandex-smartcaptcha-solver');
+
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: 'http://127.0.0.1:80',
+    xevilApiKey: 'your_xevil_api_key',
+    siteUrl: 'https://example.com/page-with-captcha',
+    siteKey: 'ysc1_YourSiteKeyHere'
+});
+
+// Решить капчу
+const result = await solver.solve();
+console.log(result);
+// { status: 'ok', token: 'dD0xNzcx...' }
+
+// Использовать токен в вашем запросе
+const response = await fetch('https://example.com/api/submit', {
+    method: 'POST',
+    body: JSON.stringify({
+        captcha_token: result.token,
+        // другие данные...
+    })
+});
+```
+
+## 🔧 API
+
+### Constructor
+
+```javascript
+new YandexSmartCaptchaSolver(config, options)
+```
+
+#### Обязательные параметры (config):
+
+- **xevilUrl** (string) - URL вашего XEvil сервера (например: `'http://127.0.0.1:80'`)
+- **xevilApiKey** (string) - API ключ для XEvil
+- **siteUrl** (string) - Полный URL страницы с капчей (например: `'https://example.com/page'`)
+- **siteKey** (string) - Site key Yandex SmartCaptcha (находится в коде страницы)
+- **coreName** (string, optional) - Имя конкретного ядра XEvil для использования (например: `'XEvil1'`, `'XEvil2'`)
+
+#### Опциональные параметры (options):
+
+- **userAgent** (string) - User-Agent браузера (по умолчанию: Chrome 120)
+- **debug** (boolean) - Режим отладки с детальными логами (по умолчанию: `false`)
+- **saveImages** (boolean) - Сохранять изображения капчи для анализа (по умолчанию: `false`)
+- **imagesDir** (string) - Папка для сохранения изображений (по умолчанию: `'./captcha_images'`)
+- **humanDelayMin** (number) - Минимальная задержка перед отправкой ответа в мс (по умолчанию: `2000`)
+- **humanDelayMax** (number) - Максимальная задержка перед отправкой ответа в мс (по умолчанию: `4000`)
+- **timeout** (number) - Timeout для HTTP запросов в мс (по умолчанию: `60000`)
+
+### Методы
+
+#### solve()
+
+Решает капчу один раз.
+
+```javascript
+const result = await solver.solve();
+// { status: 'ok', token: 'dD0x...' }
+```
+
+**Возвращает:** `Promise<{status: string, token: string}>`
+
+**Выбрасывает:** `Error` при неудаче
+
+#### solveWithRetry(maxAttempts, retryDelay)
+
+Решает капчу с автоматическими повторными попытками.
+
+```javascript
+const result = await solver.solveWithRetry(5, 4000);
+// До 5 попыток с задержкой 4 секунды между ними
+```
+
+**Параметры:**
+- `maxAttempts` (number, по умолчанию: 3) - Максимальное количество попыток
+- `retryDelay` (number, по умолчанию: 3000) - Задержка между попытками в мс
+
+**Возвращает:** `Promise<{status: string, token: string}>`
+
+## 📝 Примеры
+
+### Базовое использование
+
+```javascript
+const YandexSmartCaptchaSolver = require('yandex-smartcaptcha-solver');
+
+async function main() {
+    const solver = new YandexSmartCaptchaSolver({
+        xevilUrl: 'http://127.0.0.1:80',
+        xevilApiKey: 'your_api_key',
+        siteUrl: 'https://example.com/page',
+        siteKey: 'ysc1_SiteKey123'
+    });
+
+    try {
+        const result = await solver.solve();
+        console.log('Token:', result.token);
+    } catch (error) {
+        console.error('Error:', error.message);
+    }
+}
+
+main();
+```
+
+### С retry и debug режимом
+
+```javascript
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: 'http://127.0.0.1:80',
+    xevilApiKey: 'your_api_key',
+    siteUrl: 'https://example.com/page',
+    siteKey: 'ysc1_SiteKey123',
+    coreName: 'XEvil2'        // Использовать конкретное ядро XEvil
+}, {
+    debug: true,           // Включить детальные логи
+    saveImages: true,      // Сохранять изображения
+    humanDelayMin: 3000,   // Увеличить задержку до 3-6 секунд
+    humanDelayMax: 6000
+});
+
+// До 5 попыток с задержкой 4 секунды
+const result = await solver.solveWithRetry(5, 4000);
+```
+
+### С использованием конкретного ядра XEvil
+
+```javascript
+// Если у вас несколько ядер XEvil, можно указать конкретное
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: 'http://127.0.0.1:80',
+    xevilApiKey: 'your_api_key',
+    siteUrl: 'https://example.com/page',
+    siteKey: 'ysc1_SiteKey123',
+    coreName: 'XEvil1'  // Название ядра из XEvil
+});
+
+const result = await solver.solve();
+```
+
+### Использование с переменными окружения
+
+```javascript
+require('dotenv').config();
+
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: process.env.XEVIL_URL,
+    xevilApiKey: process.env.XEVIL_API_KEY,
+    siteUrl: process.env.SITE_URL,
+    siteKey: process.env.SITE_KEY
+});
+
+const result = await solver.solveWithRetry();
+```
+
+### Express API endpoint
+
+```javascript
+const express = require('express');
+const YandexSmartCaptchaSolver = require('yandex-smartcaptcha-solver');
+
+const app = express();
+
+app.post('/api/solve-captcha', async (req, res) => {
+    try {
+        const solver = new YandexSmartCaptchaSolver({
+            xevilUrl: process.env.XEVIL_URL,
+            xevilApiKey: process.env.XEVIL_API_KEY,
+            siteUrl: req.body.siteUrl,
+            siteKey: req.body.siteKey
+        });
+
+        const result = await solver.solveWithRetry(3);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+app.listen(3000, () => {
+    console.log('Server running on port 3000');
+});
+```
+
+### Пример для HurmaCredit
+
+```javascript
+const YandexSmartCaptchaSolver = require('yandex-smartcaptcha-solver');
+
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: 'http://127.0.0.1:80',
+    xevilApiKey: 'your_xevil_key',
+    siteUrl: 'https://borrow.hurmacredit.ru/?term=12&amount=10000',
+    siteKey: 'ysc1_LuYGybUg4evR0gMXB5JMtarE9ExcyxmHrELxL1oWb310434a'
+}, {
+    debug: true,
+    saveImages: true
+});
+
+const result = await solver.solveWithRetry(5);
+console.log('Spravka token:', result.token);
+
+// Использовать result.token для отправки заявки
+```
+
+## 🔍 Отладка
+
+### Включение debug режима
+
+```javascript
+const solver = new YandexSmartCaptchaSolver({
+    // ... config
+}, {
+    debug: true
+});
+```
+
+Вывод в консоль:
+```
+[2024-01-15T12:34:56.789Z] [INFO] Starting captcha solving process...
+[2024-01-15T12:34:57.123Z] [DEBUG] Generated GUID: abc-123-def
+[2024-01-15T12:34:58.456Z] [INFO] Sending captcha to XEvil...
+[2024-01-15T12:35:03.789Z] [INFO] Captcha recognized: "текст"
+[2024-01-15T12:35:07.012Z] [INFO] Submitting answer to Yandex...
+[2024-01-15T12:35:08.345Z] [INFO] Captcha solved successfully!
+```
+
+### Сохранение изображений
+
+```javascript
+const solver = new YandexSmartCaptchaSolver({
+    // ... config
+}, {
+    saveImages: true,
+    imagesDir: './my-captcha-images'
+});
+```
+
+Изображения сохраняются с префиксами:
+- `captcha_timestamp_SUCCESS_text.png` - успешно решено
+- `captcha_timestamp_FAILED_text.png` - Яндекс отклонил
+- `captcha_timestamp_UNKNOWN_text.png` - ошибка при решении
+
+## ⚙️ Как найти siteKey
+
+1. Откройте страницу с капчей в браузере
+2. Откройте DevTools (F12)
+3. Перейдите во вкладку Elements/Инспектор
+4. Найдите элемент с `smartcaptcha.yandexcloud.net`
+5. Найдите параметр `data-sitekey` или `sitekey` в коде
+6. Скопируйте значение (обычно начинается с `ysc1_`)
+
+Или через консоль браузера:
+```javascript
+// В консоли DevTools
+document.querySelector('[data-sitekey]').getAttribute('data-sitekey')
+```
+
+## 🎯 Использование конкретного ядра XEvil (coreName)
+
+Если у вас установлено несколько ядер XEvil, вы можете указать конкретное ядро для решения капчи:
+
+### Как узнать имя ядра:
+1. Откройте интерфейс XEvil (обычно http://127.0.0.1:80)
+2. В разделе "Cores" / "Ядра" вы увидите список доступных ядер
+3. Имена обычно выглядят как: `XEvil1`, `XEvil2`, `XEvil3`, и т.д.
+
+### Примеры использования:
+
+```javascript
+// Использовать конкретное ядро
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: 'http://127.0.0.1:80',
+    xevilApiKey: 'your_key',
+    siteUrl: 'https://example.com',
+    siteKey: 'ysc1_SiteKey',
+    coreName: 'XEvil2'  // Указываем имя ядра
+});
+```
+
+```javascript
+// Через переменную окружения
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: process.env.XEVIL_URL,
+    xevilApiKey: process.env.XEVIL_API_KEY,
+    siteUrl: process.env.SITE_URL,
+    siteKey: process.env.SITE_KEY,
+    coreName: process.env.XEVIL_CORE  // XEvil1, XEvil2, etc.
+});
+```
+
+```javascript
+// Если не указывать coreName, будет использовано ядро по умолчанию
+const solver = new YandexSmartCaptchaSolver({
+    xevilUrl: 'http://127.0.0.1:80',
+    xevilApiKey: 'your_key',
+    siteUrl: 'https://example.com',
+    siteKey: 'ysc1_SiteKey'
+    // coreName не указан - используется default core
+});
+```
+
+### Зачем использовать конкретное ядро?
+
+- **Балансировка нагрузки** - распределить задачи между ядрами
+- **Приоритизация** - выделить отдельное ядро для важных задач
+- **Производительность** - разные ядра могут иметь разную скорость/точность
+- **Изоляция** - разделить проекты по ядрам
+
+## 🛠️ Требования
+
+- Node.js >= 14.0.0
+- Работающий XEvil сервер (купить на xevil.net)
+- npm пакеты: axios, uuid, form-data
+
+## 📊 Производительность
+
+- **Среднее время решения:** 8-15 секунд
+  - XEvil распознавание: 5-10 секунд
+  - Задержка перед submit: 2-4 секунды
+- **Успешность:** ~70-90% (с использованием retry)
+
+## ⚠️ Обработка ошибок
+
+```javascript
+try {
+    const result = await solver.solve();
+} catch (error) {
+    if (error.message.includes('XEvil')) {
+        console.error('Проблема с XEvil:', error.message);
+        // Проверьте что XEvil запущен и доступен
+    } else if (error.message.includes('Yandex rejected')) {
+        console.error('Яндекс отклонил ответ:', error.message);
+        // Попробуйте увеличить humanDelay или используйте retry
+    } else if (error.message.includes('timeout')) {
+        console.error('Timeout:', error.message);
+        // Увеличьте timeout в настройках
+    } else {
+        console.error('Неизвестная ошибка:', error.message);
+    }
+}
+```
+
+## 💡 Советы
+
+1. **Всегда используйте retry** для повышения успешности:
+   ```javascript
+   await solver.solveWithRetry(5, 4000);
+   ```
+
+2. **Увеличьте задержку** если Яндекс часто отклоняет правильные ответы:
+   ```javascript
+   { humanDelayMin: 5000, humanDelayMax: 8000 }
+   ```
+
+3. **Используйте переменные окружения** для конфиденциальных данных:
+   ```javascript
+   xevilApiKey: process.env.XEVIL_API_KEY
+   ```
+
+4. **Включите debug и saveImages** при проблемах с решением
+
+5. **Мониторьте баланс XEvil:**
+   ```bash
+   curl "http://127.0.0.1:80/res.php?key=YOUR_KEY&action=getbalance"
+   ```
+
+## 🐛 Известные проблемы
+
+### "Yandex rejected the answer"
+
+**Причина:** Яндекс отклоняет правильно распознанный текст
+
+**Решение:**
+- Увеличьте `humanDelayMin` и `humanDelayMax` до 5-8 секунд
+- Используйте `solveWithRetry()` для автоматических повторов
+- Проверьте что siteKey актуален
+
+### "XEvil timeout"
+
+**Причина:** XEvil слишком долго решает капчу
+
+**Решение:**
+- Проверьте что XEvil запущен: `curl http://127.0.0.1:80`
+- Проверьте баланс XEvil
+- Убедитесь что сервер не перегружен
+
+## 📄 Лицензия
+
+MIT
+
+## ⚖️ Disclaimer
+
+Этот инструмент предназначен только для законного использования, тестирования и образовательных целей. Убедитесь, что вы не нарушаете Terms of Service целевого сайта. Авторы не несут ответственности за неправомерное использование.
+
+## 🤝 Вклад
+
+Contributions приветствуются! Пожалуйста, создавайте pull requests или issues на GitHub.
+
+## 📞 Поддержка
+
+Если у вас возникли проблемы:
+
+1. Проверьте что все требования выполнены
+2. Включите `debug: true` и проверьте логи
+3. Проверьте сохраненные изображения (если `saveImages: true`)
+4. Создайте issue на GitHub с логами и описанием проблемы
+
+## 🔗 Полезные ссылки
+
+- [XEvil официальный сайт](https://xevil.net)
+- [Yandex SmartCaptcha документация](https://cloud.yandex.ru/docs/smartcaptcha/)
+- [GitHub репозиторий](https://github.com/yourusername/yandex-smartcaptcha-solver)
+
+---
+
+Made with ❤️ for automation

package/index.js

@@ -0,0 +1,429 @@
+const axios = require('axios');
+const { v4: uuidv4 } = require('uuid');
+const FormData = require('form-data');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Yandex SmartCaptcha Solver
+ * Автоматическое решение Yandex SmartCaptcha через XEvil
+ * @module yandex-smartcaptcha-solver
+ */
+
+class YandexSmartCaptchaSolver {
+    /**
+     * Создать новый экземпляр солвера
+     * @param {Object} config - Конфигурация
+     * @param {string} config.xevilUrl - URL XEvil сервера (например: 'http://127.0.0.1:80')
+     * @param {string} config.xevilApiKey - API ключ для XEvil
+     * @param {string} config.siteUrl - Полный URL страницы с капчей
+     * @param {string} config.siteKey - Site key Yandex SmartCaptcha
+     * @param {string} [config.coreName] - Имя ядра XEvil для использования (опционально)
+     * @param {Object} [options] - Дополнительные опции
+     * @param {string} [options.userAgent] - User-Agent браузера
+     * @param {boolean} [options.debug=false] - Режим отладки
+     * @param {boolean} [options.saveImages=false] - Сохранять изображения капчи
+     * @param {string} [options.imagesDir='./captcha_images'] - Папка для изображений
+     * @param {number} [options.humanDelayMin=2000] - Минимальная задержка перед submit (мс)
+     * @param {number} [options.humanDelayMax=4000] - Максимальная задержка перед submit (мс)
+     * @param {number} [options.timeout=60000] - Timeout для HTTP запросов (мс)
+     */
+    constructor(config, options = {}) {
+        if (!config.xevilUrl) {
+            throw new Error('xevilUrl is required');
+        }
+        if (!config.xevilApiKey) {
+            throw new Error('xevilApiKey is required');
+        }
+        if (!config.siteUrl) {
+            throw new Error('siteUrl is required');
+        }
+        if (!config.siteKey) {
+            throw new Error('siteKey is required');
+        }
+
+        // Парсим URL
+        const url = new URL(config.siteUrl);
+        
+        this.config = {
+            xevilUrl: config.xevilUrl,
+            xevilApiKey: config.xevilApiKey,
+            siteUrl: config.siteUrl,
+            siteKey: config.siteKey,
+            host: url.hostname,
+            coreName: config.coreName || null,  // Опциональное имя ядра
+            
+            // Опции
+            userAgent: options.userAgent || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            debug: options.debug || false,
+            saveImages: options.saveImages || false,
+            imagesDir: options.imagesDir || './captcha_images',
+            humanDelayMin: options.humanDelayMin || 2000,
+            humanDelayMax: options.humanDelayMax || 4000,
+            timeout: options.timeout || 60000
+        };
+
+        this.state = {
+            captchaId: null,
+            recognizedText: null
+        };
+        
+        this.axios = axios.create({
+            headers: {
+                'User-Agent': this.config.userAgent,
+                'Accept': '*/*',
+                'Accept-Language': 'ru-RU,ru;q=0.9,en;q=0.8',
+                'Accept-Encoding': 'gzip, deflate, br'
+            },
+            timeout: this.config.timeout
+        });
+        
+        if (this.config.saveImages && !fs.existsSync(this.config.imagesDir)) {
+            fs.mkdirSync(this.config.imagesDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Логирование
+     * @private
+     */
+    _log(message, level = 'info') {
+        if (!this.config.debug && level === 'debug') return;
+        
+        const timestamp = new Date().toISOString();
+        const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+        
+        console.log(`${prefix} ${message}`);
+    }
+
+    /**
+     * Сохранить изображение капчи
+     * @private
+     */
+    _saveImage(imageBuffer, text, success) {
+        if (!this.config.saveImages) return;
+        
+        try {
+            const timestamp = Date.now();
+            const status = success === true ? 'SUCCESS' : success === false ? 'FAILED' : 'UNKNOWN';
+            const cleanText = text.replace(/[^a-zA-Zа-яА-Я0-9]/g, '_');
+            const filename = `captcha_${timestamp}_${status}_${cleanText}.png`;
+            const filepath = path.join(this.config.imagesDir, filename);
+            
+            fs.writeFileSync(filepath, imageBuffer);
+            this._log(`Image saved: ${filename}`, 'debug');
+        } catch (error) {
+            this._log(`Failed to save image: ${error.message}`, 'warn');
+        }
+    }
+
+    /**
+     * Сообщить XEvil о неправильном ответе
+     * @private
+     */
+    async _reportBadCaptcha() {
+        if (!this.state.captchaId) return;
+        
+        try {
+            this._log(`Reporting incorrect answer to XEvil (ID: ${this.state.captchaId})`, 'debug');
+            
+            await axios.get(`${this.config.xevilUrl}/res.php`, {
+                params: {
+                    key: this.config.xevilApiKey,
+                    action: 'reportbad',
+                    id: this.state.captchaId
+                },
+                timeout: 10000
+            });
+            
+            this._log('Bad answer reported successfully', 'debug');
+        } catch (error) {
+            this._log(`Failed to report bad answer: ${error.message}`, 'warn');
+        }
+    }
+
+    /**
+     * Первый запрос к Yandex SmartCaptcha
+     * @private
+     */
+    async _firstCheck() {
+        this._log('Performing first check request...', 'debug');
+
+        const url = `https://smartcaptcha.yandexcloud.net/check?host=${this.config.host}&sitekey=${this.config.siteKey}&href=${encodeURIComponent(this.config.siteUrl)}`;
+        const data = `sitekey=${this.config.siteKey}`;
+
+        const headers = {
+            'Referer': `https://smartcaptcha.yandexcloud.net/backend.636bb879d1085041bc19.html?sitekey=${this.config.siteKey}&theme=light&hl=ru&host=${this.config.host}&href=${encodeURIComponent(this.config.siteUrl)}&test=false&webview=false&hideChallengeContainer=false`,
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'Origin': 'https://smartcaptcha.yandexcloud.net',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin'
+        };
+
+        const response = await this.axios.post(url, data, { headers });
+        return response.data;
+    }
+
+    /**
+     * Второй запрос к Yandex SmartCaptcha
+     * @private
+     */
+    async _secondCheck(captchaKey) {
+        this._log('Performing second check request...', 'debug');
+
+        const url = `https://smartcaptcha.yandexcloud.net/check?host=${this.config.host}&sitekey=${this.config.siteKey}&href=${encodeURIComponent(this.config.siteUrl)}`;
+        const data = `key=${captchaKey}&sitekey=${this.config.siteKey}&lang=ru&test=false&webview=false`;
+
+        const headers = {
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'Origin': 'https://smartcaptcha.yandexcloud.net',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin'
+        };
+
+        const response = await this.axios.post(url, data, { headers });
+        return response.data;
+    }
+
+    /**
+     * Получить изображение капчи
+     * @private
+     */
+    async _getImage(imageUrl) {
+        this._log('Downloading captcha image...', 'debug');
+
+        const response = await this.axios.get(imageUrl, {
+            responseType: 'arraybuffer',
+            headers: {
+                'Referer': 'https://smartcaptcha.yandexcloud.net/'
+            }
+        });
+
+        this._log(`Image downloaded: ${response.data.length} bytes`, 'debug');
+        return Buffer.from(response.data);
+    }
+
+    /**
+     * Распознать капчу через XEvil
+     * @private
+     */
+    async _recognize(imageBuffer) {
+        this._log('Sending captcha to XEvil...', 'info');
+
+        const base64Image = imageBuffer.toString('base64');
+        
+        const formData = new FormData();
+        formData.append('key', this.config.xevilApiKey);
+        formData.append('method', 'base64');
+        formData.append('body', base64Image);
+        formData.append('json', '1');
+        
+        // Добавляем coreName если указан
+        if (this.config.coreName) {
+            formData.append('core', this.config.coreName);
+            this._log(`Using XEvil core: ${this.config.coreName}`, 'debug');
+        }
+
+        const inResponse = await axios.post(
+            `${this.config.xevilUrl}/in.php`,
+            formData,
+            {
+                headers: formData.getHeaders(),
+                timeout: 30000
+            }
+        );
+
+        if (inResponse.data.status !== 1) {
+            throw new Error(`XEvil error: ${inResponse.data.request || JSON.stringify(inResponse.data)}`);
+        }
+
+        this.state.captchaId = inResponse.data.request;
+        this._log(`Captcha sent to XEvil (ID: ${this.state.captchaId})`, 'debug');
+
+        // Ожидание результата
+        this._log('Waiting for XEvil to solve captcha...', 'info');
+        
+        const maxAttempts = 30;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await new Promise(resolve => setTimeout(resolve, 3000));
+
+            const resResponse = await axios.get(
+                `${this.config.xevilUrl}/res.php`,
+                {
+                    params: {
+                        key: this.config.xevilApiKey,
+                        action: 'get',
+                        id: this.state.captchaId,
+                        json: 1
+                    },
+                    timeout: 30000
+                }
+            );
+
+            if (resResponse.data.status === 1) {
+                const result = resResponse.data.request.trim();
+                this._log(`Captcha recognized: "${result}"`, 'info');
+                this.state.recognizedText = result;
+                return result;
+            }
+
+            if (resResponse.data.request !== 'CAPCHA_NOT_READY') {
+                throw new Error(`XEvil error: ${resResponse.data.request}`);
+            }
+
+            this._log(`Attempt ${attempt}/${maxAttempts}: still processing...`, 'debug');
+        }
+
+        throw new Error('XEvil timeout: captcha not solved in time');
+    }
+
+    /**
+     * Закодировать результат
+     * @private
+     */
+    _encode(text) {
+        const bytes = Buffer.from(text, 'utf8');
+        let encoded = '';
+        
+        for (let i = 0; i < bytes.length; i++) {
+            encoded += '%' + bytes[i].toString(16).toUpperCase().padStart(2, '0');
+        }
+        
+        return encoded;
+    }
+
+    /**
+     * Отправить результат в Yandex
+     * @private
+     */
+    async _submit(captchaKey, encodedResult) {
+        this._log('Submitting answer to Yandex...', 'info');
+
+        // Задержка для имитации человека
+        const delay = this.config.humanDelayMin + 
+                      Math.random() * (this.config.humanDelayMax - this.config.humanDelayMin);
+        this._log(`Waiting ${Math.round(delay/1000)}s before submit (human simulation)...`, 'debug');
+        await new Promise(resolve => setTimeout(resolve, delay));
+
+        const url = `https://smartcaptcha.yandexcloud.net/check?host=${this.config.host}&sitekey=${this.config.siteKey}&href=${encodeURIComponent(this.config.siteUrl)}`;
+        const data = `key=${captchaKey}&sitekey=${this.config.siteKey}&lang=ru&test=false&webview=false&rep=${encodedResult}`;
+
+        const headers = {
+            'Content-Type': 'text/plain;charset=UTF-8',
+            'Origin': 'https://smartcaptcha.yandexcloud.net',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin'
+        };
+
+        const response = await this.axios.post(url, data, { headers });
+        return response.data;
+    }
+
+    /**
+     * Решить капчу
+     * @returns {Promise<Object>} Результат с полями status и token (spravka)
+     * @throws {Error} При неудаче
+     * @example
+     * const result = await solver.solve();
+     * console.log(result); // { status: 'ok', token: 'dD0x...' }
+     */
+    async solve() {
+        let imageBuffer = null;
+
+        try {
+            this._log('Starting captcha solving process...', 'info');
+            
+            // Генерируем GUID
+            const guid = uuidv4();
+            this._log(`Generated GUID: ${guid}`, 'debug');
+
+            // Первый запрос
+            const firstResponse = await this._firstCheck();
+            if (!firstResponse.captcha?.key) {
+                throw new Error('No captcha key received from first request');
+            }
+            this._log('First captcha key received', 'debug');
+
+            // Второй запрос
+            const secondResponse = await this._secondCheck(firstResponse.captcha.key);
+            if (!secondResponse.captcha?.image) {
+                throw new Error('No captcha image URL received');
+            }
+            
+            const captchaKey = secondResponse.captcha.key;
+            this._log('Second captcha key received', 'debug');
+
+            // Получаем и распознаем изображение
+            imageBuffer = await this._getImage(secondResponse.captcha.image);
+            const recognizedText = await this._recognize(imageBuffer);
+            
+            // Кодируем и отправляем
+            const encodedResult = this._encode(recognizedText);
+            this._log(`Encoded result: ${encodedResult}`, 'debug');
+            
+            const finalResponse = await this._submit(captchaKey, encodedResult);
+
+            // Проверяем результат
+            if (finalResponse.status === 'ok') {
+                this._log('Captcha solved successfully!', 'info');
+                this._saveImage(imageBuffer, recognizedText, true);
+                
+                return {
+                    status: 'ok',
+                    token: finalResponse.token || finalResponse.key
+                };
+            } else {
+                // Неудача - сообщаем XEvil
+                await this._reportBadCaptcha();
+                this._saveImage(imageBuffer, recognizedText, false);
+                
+                throw new Error(`Yandex rejected the answer. Recognized text: "${recognizedText}"`);
+            }
+
+        } catch (error) {
+            this._log(`Error: ${error.message}`, 'error');
+            
+            if (imageBuffer && this.state.recognizedText) {
+                this._saveImage(imageBuffer, this.state.recognizedText, null);
+            }
+            
+            throw error;
+        }
+    }
+
+    /**
+     * Решить капчу с автоматическими повторными попытками
+     * @param {number} [maxAttempts=3] - Максимальное количество попыток
+     * @param {number} [retryDelay=3000] - Задержка между попытками (мс)
+     * @returns {Promise<Object>} Результат с полями status и token
+     * @throws {Error} Если все попытки неудачны
+     * @example
+     * const result = await solver.solveWithRetry(5, 4000);
+     */
+    async solveWithRetry(maxAttempts = 3, retryDelay = 3000) {
+        this._log(`Will attempt to solve up to ${maxAttempts} times`, 'info');
+
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                this._log(`Attempt ${attempt}/${maxAttempts}`, 'info');
+                const result = await this.solve();
+                this._log(`Successfully solved on attempt ${attempt}!`, 'info');
+                return result;
+            } catch (error) {
+                this._log(`Attempt ${attempt} failed: ${error.message}`, 'warn');
+                
+                if (attempt < maxAttempts) {
+                    this._log(`Waiting ${retryDelay/1000}s before retry...`, 'info');
+                    await new Promise(resolve => setTimeout(resolve, retryDelay));
+                }
+            }
+        }
+
+        throw new Error(`Failed to solve captcha after ${maxAttempts} attempts`);
+    }
+}
+
+module.exports = YandexSmartCaptchaSolver;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "yandex-smartcaptcha-solver",
+  "version": "1.0.0",
+  "description": "Automatic Yandex SmartCaptcha solver using XEvil OCR service",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test/test.js",
+    "example": "node examples/basic.js"
+  },
+  "keywords": [
+    "captcha",
+    "yandex",
+    "smartcaptcha",
+    "captcha-solver",
+    "xevil",
+    "ocr",
+    "automation",
+    "bot"
+  ],
+  "author": "SH3EL1T",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sh3el1t/yandex-smartcaptcha-solver.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sh3el1t/yandex-smartcaptcha-solver/issues"
+  },
+  "homepage": "https://github.com/sh3el1t/yandex-smartcaptcha-solver#readme",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "uuid": "^9.0.0",
+    "form-data": "^4.0.0"
+  },
+  "devDependencies": {
+    "dotenv": "^16.0.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "index.js",
+    "README.md",
+    "LICENSE"
+  ]
+}