qwen-api-proxy 1.0.10

package/src/api/tokenManager.js

@@ -0,0 +1,382 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { logError, logWarn, logInfo } from '../logger/index.js';
+import { SESSION_DIR, ACCOUNTS_DIR, TOKEN_EXPIRY_WARNING_MS } from '../config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const SESSION_PATH = path.resolve(__dirname, '..', '..', SESSION_DIR);
+const ACCOUNTS_PATH = path.join(SESSION_PATH, ACCOUNTS_DIR);
+const TOKENS_FILE = path.join(SESSION_PATH, 'tokens.json');
+
+let pointer = 0;
+
+function ensureSessionDir() {
+    if (!fs.existsSync(SESSION_PATH)) fs.mkdirSync(SESSION_PATH, { recursive: true });
+    if (!fs.existsSync(ACCOUNTS_PATH)) fs.mkdirSync(ACCOUNTS_PATH, { recursive: true });
+}
+
+/**
+ * Проверяет наличие cookies.json для аккаунта
+ * @param {string} accountId - ID аккаунта
+ * @returns {boolean} - true если cookies.json существует
+ */
+export function hasCookies(accountId) {
+    const cookiesPath = path.join(ACCOUNTS_PATH, accountId, 'cookies.json');
+    return fs.existsSync(cookiesPath);
+}
+
+/**
+ * Декодирует JWT токен и извлекает время истечения
+ * @param {string} token - JWT токен
+ * @returns {number|null} - Время истечения в миллисекундах или null
+ */
+function decodeJwtExpiry(token) {
+    try {
+        if (!token || typeof token !== 'string') return null;
+        
+        const parts = token.split('.');
+        if (parts.length !== 3) return null;
+        
+        // Декодируем payload (вторая часть JWT)
+        // JWT использует URL-safe base64, нужно заменить - на + и _ на /
+        let base64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
+        
+        // Добавляем padding если нужно
+        while (base64.length % 4) {
+            base64 += '=';
+        }
+        
+        const payload = Buffer.from(base64, 'base64').toString('utf8');
+        const decoded = JSON.parse(payload);
+        
+        // JWT использует поле 'exp' для времени истечения (в секундах)
+        if (decoded.exp) {
+            return decoded.exp * 1000; // Конвертируем в миллисекунды
+        }
+        
+        return null;
+    } catch (error) {
+        // Если не удалось декодировать, возвращаем null
+        return null;
+    }
+}
+
+export function loadTokens() {
+    ensureSessionDir();
+    if (!fs.existsSync(TOKENS_FILE)) return [];
+    try {
+        const tokens = JSON.parse(fs.readFileSync(TOKENS_FILE, 'utf8'));
+        
+        // Добавляем expiryTime для каждого токена, если его нет
+        return tokens.map(token => {
+            if (!token.expiryTime && token.token) {
+                token.expiryTime = decodeJwtExpiry(token.token);
+            }
+            return token;
+        });
+    } catch (e) {
+        logError('TokenManager: ошибка чтения tokens.json', e);
+        return [];
+    }
+}
+
+export function saveTokens(tokens) {
+    ensureSessionDir();
+    try {
+        fs.writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2), 'utf8');
+    } catch (e) {
+        // Не логируем EACCES как ошибку - это предупреждение
+        if (e.code === 'EACCES') {
+            logWarn('⚠️ Нет прав на записи tokens.json. Запустите: sudo chown -R $USER:$USER session/');
+        } else {
+            logError('TokenManager: ошибка сохранения tokens.json', e);
+        }
+    }
+}
+
+export async function getAvailableToken() {
+    const tokens = loadTokens();
+    const now = Date.now();
+    
+    // Фильтруем токены: не rate-limited, не invalid, JWT не истёк, и есть cookies
+    const valid = tokens.filter(t => {
+        // Пропускаем недействительные токены
+        if (t.invalid) return false;
+        
+        // Пропускаем токены с rate limit в будущем
+        if (t.resetAt && new Date(t.resetAt).getTime() > now) return false;
+        
+        // Пропускаем токены с истёкшим JWT
+        if (t.expiryTime && t.expiryTime <= now) return false;
+        
+        // Пропускаем токены без cookies.json
+        if (!hasCookies(t.id)) return false;
+        
+        return true;
+    });
+    
+    if (!valid.length) return null;
+    const token = valid[pointer % valid.length];
+    pointer = (pointer + 1) % valid.length;
+    return token;
+}
+
+export function hasValidTokens() {
+    const tokens = loadTokens();
+    const now = Date.now();
+    
+    // Проверяем, есть ли хотя бы один валидный токен с cookies
+    return tokens.some(t => {
+        // Пропускаем недействительные токены
+        if (t.invalid) return false;
+        
+        // Пропускаем токены с rate limit в будущем
+        if (t.resetAt && new Date(t.resetAt).getTime() > now) return false;
+        
+        // Пропускаем токены с истёкшим JWT
+        if (t.expiryTime && t.expiryTime <= now) return false;
+        
+        // Пропускаем токены без cookies.json
+        if (!hasCookies(t.id)) return false;
+        
+        return true;
+    });
+}
+
+export function markRateLimited(id, hours = 24) {
+    const tokens = loadTokens();
+    const idx = tokens.findIndex(t => t.id === id);
+    if (idx !== -1) {
+        tokens[idx].resetAt = new Date(Date.now() + hours * 3600 * 1000).toISOString();
+        saveTokens(tokens);
+    }
+}
+
+export function removeToken(id) {
+    saveTokens(loadTokens().filter(t => t.id !== id));
+}
+
+export { removeToken as removeInvalidToken };
+
+export function markInvalid(id) {
+    const tokens = loadTokens();
+    const idx = tokens.findIndex(t => t.id === id);
+    if (idx !== -1) { tokens[idx].invalid = true; saveTokens(tokens); }
+}
+
+export function markValid(id, newToken) {
+    const tokens = loadTokens();
+    const idx = tokens.findIndex(t => t.id === id);
+    if (idx !== -1) {
+        tokens[idx].invalid = false;
+        tokens[idx].resetAt = null;
+        if (newToken) tokens[idx].token = newToken;
+        saveTokens(tokens);
+    }
+}
+
+export function listTokens() {
+    return loadTokens();
+}
+
+/**
+ * Получает только действительные токены (не истекшие, не invalid, не rate-limited, с cookies)
+ * @returns {Array} - Массив действительных токенов
+ */
+export function getValidTokens() {
+    const tokens = loadTokens();
+    const now = Date.now();
+    
+    return tokens.filter(t => {
+        // Пропускаем недействительные токены
+        if (t.invalid) return false;
+        
+        // Пропускаем токены с rate limit в будущем
+        if (t.resetAt && new Date(t.resetAt).getTime() > now) return false;
+        
+        // Пропускаем токены с истёкшим JWT
+        if (t.expiryTime && t.expiryTime <= now) return false;
+        
+        // Пропускаем токены без cookies.json
+        if (!hasCookies(t.id)) return false;
+        
+        return true;
+    });
+}
+
+/**
+ * Проверяет, истекает ли токен в ближайшее время
+ * Проверяет оба параметра: resetAt (rate limit) и expiryTime (JWT expiry)
+ * @param {string} tokenId - ID токена
+ * @param {number} warningMs - Время предупреждения в мс (по умолчанию 1 час)
+ * @returns {object} - {willExpireSoon: boolean, expiresAt: Date|null, timeLeft: number|null}
+ */
+export function checkTokenExpiry(tokenId, warningMs = TOKEN_EXPIRY_WARNING_MS) {
+    const tokens = loadTokens();
+    const token = tokens.find(t => t.id === tokenId);
+    
+    if (!token) {
+        return { willExpireSoon: false, expiresAt: null, timeLeft: null, tokenFound: false };
+    }
+
+    const now = Date.now();
+    
+    // Если токен помечен как недействительный
+    if (token.invalid) {
+        return { willExpireSoon: true, expiresAt: null, timeLeft: null, tokenFound: true, isInvalid: true };
+    }
+
+    // Проверяем JWT expiry time (если есть)
+    if (token.expiryTime) {
+        const jwtTimeLeft = token.expiryTime - now;
+        
+        // Если JWT уже истёк
+        if (jwtTimeLeft <= 0) {
+            return { 
+                willExpireSoon: true, 
+                expiresAt: new Date(token.expiryTime), 
+                timeLeft: 0, 
+                tokenFound: true, 
+                isExpired: true,
+                expiredType: 'jwt'
+            };
+        }
+        
+        // Если JWT истекает в ближайшее время
+        if (jwtTimeLeft <= warningMs) {
+            return { 
+                willExpireSoon: true, 
+                expiresAt: new Date(token.expiryTime), 
+                timeLeft: jwtTimeLeft, 
+                tokenFound: true,
+                isExpiringSoon: true,
+                expiredType: 'jwt'
+            };
+        }
+    }
+
+    // Если есть время сброса лимита
+    if (token.resetAt) {
+        const resetTime = new Date(token.resetAt).getTime();
+        const timeLeft = resetTime - now;
+        
+        // Если уже истёк или истекает в ближайшее время
+        if (timeLeft <= 0) {
+            return { 
+                willExpireSoon: true, 
+                expiresAt: new Date(token.resetAt), 
+                timeLeft: 0, 
+                tokenFound: true, 
+                isExpired: true,
+                expiredType: 'rate_limit'
+            };
+        }
+        
+        if (timeLeft <= warningMs) {
+            return { 
+                willExpireSoon: true, 
+                expiresAt: new Date(token.resetAt), 
+                timeLeft, 
+                tokenFound: true,
+                isExpiringSoon: true,
+                expiredType: 'rate_limit'
+            };
+        }
+        
+        return { 
+            willExpireSoon: false, 
+            expiresAt: new Date(token.resetAt), 
+            timeLeft, 
+            tokenFound: true 
+        };
+    }
+
+    // Если нет времени сброса, токен активен
+    return { willExpireSoon: false, expiresAt: null, timeLeft: null, tokenFound: true };
+}
+
+/**
+ * Проверяет все токены и возвращает информацию об истекающих
+ * @param {number} warningMs - Время предупреждения в мс
+ * @returns {object} - {expiringTokens: Array, allTokensExpired: boolean, totalTokens: number}
+ */
+export function checkAllTokensExpiry(warningMs = TOKEN_EXPIRY_WARNING_MS) {
+    const tokens = loadTokens();
+    const now = Date.now();
+    
+    const expiringTokens = [];
+    let activeTokens = 0;
+
+    tokens.forEach(token => {
+        const expiryInfo = checkTokenExpiry(token.id, warningMs);
+        
+        if (expiryInfo.willExpireSoon) {
+            expiringTokens.push({
+                ...token,
+                expiryInfo
+            });
+        } else {
+            activeTokens++;
+        }
+    });
+
+    return {
+        expiringTokens,
+        allTokensExpired: activeTokens === 0,
+        totalTokens: tokens.length,
+        activeTokens
+    };
+}
+
+/**
+ * Получает токен, который не истекает в ближайшее время
+ * Проверяет оба параметра: resetAt (rate limit) и expiryTime (JWT expiry)
+ * Требует наличия cookies.json
+ * @param {number} warningMs - Время предупреждения в мс
+ * @returns {object|null} - Токен или null
+ */
+export async function getSafeToken(warningMs = TOKEN_EXPIRY_WARNING_MS) {
+    const tokens = loadTokens();
+    const now = Date.now();
+    
+    // Фильтруем токены, которые не истекают в ближайшее время и имеют cookies
+    const safeTokens = tokens.filter(t => {
+        // Пропускаем недействительные токены
+        if (t.invalid) return false;
+        
+        // Пропускаем токены без cookies.json
+        if (!hasCookies(t.id)) return false;
+        
+        // Проверяем rate limit reset time
+        if (t.resetAt) {
+            const resetTime = new Date(t.resetAt).getTime();
+            // Если reset time в будущем и меньше warningMs - токен небезопасен
+            if (resetTime > now && (resetTime - now) <= warningMs) {
+                return false;
+            }
+        }
+        
+        // Проверяем JWT expiry time (если есть)
+        if (t.expiryTime) {
+            const jwtTimeLeft = t.expiryTime - now;
+            // Если JWT истекает в ближайшее время - токен небезопасен
+            if (jwtTimeLeft <= warningMs) {
+                return false;
+            }
+        }
+        
+        return true;
+    });
+
+    if (safeTokens.length === 0) {
+        return null;
+    }
+
+    const token = safeTokens[pointer % safeTokens.length];
+    pointer = (pointer + 1) % safeTokens.length;
+    
+    logInfo(`Использован безопасный токен: ${token.id}`);
+    return token;
+}

package/src/browser/auth.js

@@ -0,0 +1,171 @@
+import { saveSession } from './session.js';
+import { setAuthenticationStatus, getAuthenticationStatus, restartBrowserInHeadlessMode } from './browser.js';
+import { extractAuthToken } from '../api/chat.js';
+import { logInfo, logError, logWarn } from '../logger/index.js';
+import { CHAT_PAGE_URL, AUTH_SIGNIN_URL, PAGE_TIMEOUT, RETRY_DELAY } from '../config.js';
+
+const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+function isPlaywright(context) {
+    return context && typeof context.newPage === 'function';
+}
+
+async function getPage(context) {
+    if (context && typeof context.goto === 'function') return context;
+    if (context && typeof context.newPage === 'function') return await context.newPage();
+    throw new Error('Неверный контекст: не страница Puppeteer, не контекст Playwright');
+}
+
+async function promptUser(question) {
+    return new Promise(resolve => {
+        process.stdout.write(question);
+        const onData = (data) => {
+            process.stdin.removeListener('data', onData);
+            process.stdin.pause();
+            resolve(data.toString().trim());
+        };
+        process.stdin.resume();
+        process.stdin.once('data', onData);
+    });
+}
+
+async function countLoginContainers(page, isPW) {
+    if (isPW) return page.locator('.login-container').count();
+    return (await page.$$('.login-container')).length;
+}
+
+export async function checkAuthentication(context) {
+    try {
+        if (getAuthenticationStatus()) return true;
+
+        const page = await getPage(context);
+        const isPW = isPlaywright(context);
+
+        logInfo('Проверка авторизации...');
+
+        try {
+            await page.goto(CHAT_PAGE_URL, { waitUntil: 'domcontentloaded', timeout: PAGE_TIMEOUT });
+            if (isPW) await page.waitForLoadState('domcontentloaded');
+            await delay(RETRY_DELAY);
+
+            const pageTitle = await page.title();
+            if (pageTitle.includes('Verification')) {
+                logWarn('Обнаружена страница верификации. Пожалуйста, пройдите верификацию вручную.');
+                await promptUser('После прохождения верификации нажмите ENTER для продолжения...');
+                logInfo('Верификация подтверждена пользователем.');
+            }
+
+            const loginCount = await countLoginContainers(page, isPW);
+
+            if (loginCount === 0) {
+                logInfo('Авторизация обнаружена');
+                setAuthenticationStatus(true);
+                try {
+                    await extractAuthToken(context, true);
+                    await saveSession(context);
+                    logInfo('Сессия обновлена');
+                } catch (e) { logError('Не удалось обновить сессию', e); }
+                if (isPW) await page.close();
+                return true;
+            }
+
+            console.log('------------------------------------------------------');
+            console.log('               НЕОБХОДИМА АВТОРИЗАЦИЯ');
+            console.log('------------------------------------------------------');
+            console.log('1. Войдите в систему через GitHub или другой способ в открытом браузере');
+            console.log('2. Дождитесь завершения процесса авторизации');
+            console.log('3. Нажмите ENTER в этой консоли');
+            console.log('------------------------------------------------------');
+
+            await promptUser('После успешной авторизации нажмите ENTER для продолжения...');
+            logInfo('Пользователь подтвердил завершение авторизации.');
+
+            await page.reload({ waitUntil: 'domcontentloaded', timeout: PAGE_TIMEOUT });
+            await delay(3000);
+
+            const loginCountAfter = await countLoginContainers(page, isPW);
+
+            if (loginCountAfter === 0) {
+                logInfo('Авторизация подтверждена.');
+                setAuthenticationStatus(true);
+                await saveSession(context);
+                await extractAuthToken(context, true);
+                if (isPW) await page.close();
+                return true;
+            }
+
+            logWarn('Авторизация не обнаружена.');
+            setAuthenticationStatus(false);
+            return false;
+        } catch (error) {
+            if (isPW) await page.close().catch(() => {});
+            throw error;
+        }
+    } catch (error) {
+        logError('Ошибка при проверке авторизации', error);
+        setAuthenticationStatus(false);
+        return false;
+    }
+}
+
+export async function startManualAuthentication(context, skipRestart = false) {
+    try {
+        const page = await getPage(context);
+        const isPW = isPlaywright(context);
+
+        logInfo('Открытие страницы для ручной авторизации...');
+
+        try {
+            await page.goto(AUTH_SIGNIN_URL, { waitUntil: 'load', timeout: PAGE_TIMEOUT });
+
+            console.log('------------------------------------------------------');
+            console.log('               НЕОБХОДИМА АВТОРИЗАЦИЯ');
+            console.log('------------------------------------------------------');
+            console.log('1. Войдите в систему в открытом браузере');
+            console.log('2. Дождитесь завершения процесса авторизации');
+            console.log('3. Нажмите ENTER в этой консоли');
+            console.log('------------------------------------------------------');
+
+            await promptUser('После успешной авторизации нажмите ENTER для продолжения...');
+
+            await page.goto(CHAT_PAGE_URL, { waitUntil: 'domcontentloaded', timeout: PAGE_TIMEOUT });
+            await delay(RETRY_DELAY);
+
+            const loginCount = await countLoginContainers(page, isPW);
+
+            if (loginCount === 0) {
+                logInfo('Авторизация подтверждена.');
+                setAuthenticationStatus(true);
+                await saveSession(context);
+                await extractAuthToken(context, true);
+                logInfo('Сессия сохранена успешно!');
+                if (isPW) await page.close();
+                if (!skipRestart) await restartBrowserInHeadlessMode();
+                return true;
+            }
+
+            logWarn('Авторизация не удалась.');
+            setAuthenticationStatus(false);
+            return false;
+        } catch (error) {
+            if (isPW) await page.close().catch(() => {});
+            throw error;
+        }
+    } catch (error) {
+        logError('Ошибка при ручной авторизации', error);
+        setAuthenticationStatus(false);
+        return false;
+    }
+}
+
+export async function checkVerification(page) {
+    try {
+        const pageTitle = await page.title();
+        if (pageTitle.includes('Verification')) {
+            logWarn('Обнаружена страница верификации');
+            await promptUser('Пройдите верификацию и нажмите ENTER...');
+            return true;
+        }
+        return false;
+    } catch { return false; }
+}