Update stealth-proxy/index.js

stealth-proxy/index.js

@@ -7,41 +7,64 @@
  * 原理：
  *   1. 启动时用 stealth 浏览器访问 cursor.com，通过 JS Challenge 获取 _vcrcs cookie
  *   2. 在同一浏览器上下文内通过 page.evaluate(fetch) 代理 API 请求
- *   3. 定时刷新 challenge（_vcrcs 有效期 3600s，每 50 分钟刷新）
+ *   3. 定时完整重建浏览器上下文，避免只刷新 challengePage 导致 workerPage 状态失配
  *   4. 支持 SSE 流式响应透传
  */
 
 const express = require('express');
 const crypto = require('crypto');
+const fs = require('fs');
 
-const PORT = parseInt(process.env.PORT || '3011');
+const PORT = parseInt(process.env.PORT || '3011', 10);
 const CHALLENGE_URL = process.env.CHALLENGE_URL || 'https://cursor.com/cn/docs';
-const REFRESH_INTERVAL = parseInt(process.env.REFRESH_INTERVAL || '3000000'); // 50 分钟
-const CHALLENGE_WAIT = parseInt(process.env.CHALLENGE_WAIT || '55000'); // challenge 最长等待时间
-
-let browser, context, challengePage, workerPage;
+const REFRESH_INTERVAL = parseInt(process.env.REFRESH_INTERVAL || '3000000', 10); // 50 分钟
+const CHALLENGE_WAIT = parseInt(process.env.CHALLENGE_WAIT || '55000', 10); // challenge 最长等待时间
+const MAX_INIT_RETRIES = parseInt(process.env.MAX_INIT_RETRIES || '5', 10);
+const RESTART_POSTPONE_MS = parseInt(process.env.RESTART_POSTPONE_MS || '60000', 10); // 有活跃请求时延后 60 秒
+
+let browser = null;
+let context = null;
+let challengePage = null;
+let workerPage = null;
+let refreshTimer = null;
 let ready = false;
+let expectedBrowserClose = false;
+let isShuttingDown = false;
+let restartPromise = null;
+let scheduledRestartPending = false;
 let startTime = Date.now();
 let challengeCount = 0;
 let requestCount = 0;
 
 const pendingRequests = new Map();
 
-// ==================== 浏览器管理 ====================
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
-const fs = require('fs');
+function getActiveRequestCount() {
+    return pendingRequests.size;
+}
+
+function getCookiePreview(value) {
+    if (!value) return null;
+    return `${value.substring(0, 40)}...`;
+}
+
+async function getVcrcsCookie() {
+    if (!context) return null;
+    const cookies = await context.cookies().catch(() => []);
+    return cookies.find((c) => c.name === '_vcrcs') || null;
+}
 
 // 自动检测系统 Chrome 路径（优先使用，指纹更真实）
 function findSystemChrome() {
     const paths = [
-        // macOS
         '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
-        // Linux
         '/usr/bin/google-chrome',
         '/usr/bin/google-chrome-stable',
         '/usr/bin/chromium',
         '/usr/bin/chromium-browser',
-        // Windows
         'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
         'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
     ];
@@ -58,7 +81,112 @@ async function loadStealth() {
     return chromium;
 }
 
+function attachBrowserHandlers(currentBrowser) {
+    currentBrowser.on('disconnected', () => {
+        if (expectedBrowserClose || isShuttingDown) {
+            return;
+        }
+        console.error('[Stealth] Browser disconnected unexpectedly! Restarting...');
+        ready = false;
+        setTimeout(() => {
+            restartBrowser('browser disconnected').catch((err) => {
+                console.error('[Stealth] Restart after disconnect failed:', err.message);
+            });
+        }, 3000);
+    });
+}
+
+async function waitForCookie(maxWait) {
+    const timeout = maxWait || CHALLENGE_WAIT;
+    const start = Date.now();
+
+    while (Date.now() - start < timeout) {
+        const vcrcs = await getVcrcsCookie();
+        if (vcrcs) {
+            console.log('[Stealth] _vcrcs obtained:', getCookiePreview(vcrcs.value));
+            return vcrcs;
+        }
+        await sleep(2000);
+    }
+
+    console.error('[Stealth] Failed to obtain _vcrcs within timeout');
+    return null;
+}
+
+// 模拟人类行为：鼠标移动、点击、滚动，帮助通过 Vercel bot 检测
+async function simulateHumanBehavior(page) {
+    try {
+        await sleep(500 + Math.random() * 1000);
+
+        const points = Array.from({ length: 5 }, () => ({
+            x: 100 + Math.random() * 600,
+            y: 100 + Math.random() * 400,
+        }));
+        for (const p of points) {
+            await page.mouse.move(p.x, p.y, { steps: 5 + Math.floor(Math.random() * 10) });
+            await sleep(100 + Math.random() * 300);
+        }
+
+        await page.mouse.wheel(0, 100 + Math.random() * 200);
+        await sleep(300 + Math.random() * 500);
+        await page.mouse.wheel(0, -(50 + Math.random() * 100));
+
+        await page.mouse.click(300 + Math.random() * 400, 300 + Math.random() * 200);
+        await sleep(200 + Math.random() * 500);
+
+        console.log('[Stealth] Human behavior simulation done');
+    } catch (e) {
+        console.log('[Stealth] Human simulation skipped:', e.message);
+    }
+}
+
+async function createWorkerPage() {
+    workerPage = await context.newPage();
+    await workerPage.goto(CHALLENGE_URL, {
+        waitUntil: 'domcontentloaded',
+        timeout: 60000,
+    });
+
+    await workerPage.exposeFunction('__proxyCallback', (requestId, type, data) => {
+        const pending = pendingRequests.get(requestId);
+        if (!pending) return;
+
+        switch (type) {
+            case 'headers': {
+                const { status, contentType } = JSON.parse(data);
+                const headers = {
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                };
+                if (contentType) headers['Content-Type'] = contentType;
+                pending.res.writeHead(status, headers);
+                break;
+            }
+            case 'chunk':
+                pending.res.write(data);
+                break;
+            case 'end':
+                pending.res.end();
+                pending.resolve();
+                break;
+            case 'error':
+                if (!pending.res.headersSent) {
+                    pending.res.writeHead(502, {
+                        'Content-Type': 'application/json',
+                    });
+                }
+                pending.res.end(JSON.stringify({ error: { message: data } }));
+                pending.resolve();
+                break;
+            default:
+                break;
+        }
+    });
+}
+
 async function initBrowser() {
+    ready = false;
+
     const chromium = await loadStealth();
     const chromePath = findSystemChrome();
 
@@ -81,6 +209,7 @@ async function initBrowser() {
 
     console.log('[Stealth] Launching browser...');
     browser = await chromium.launch(launchOptions);
+    attachBrowserHandlers(browser);
 
     context = await browser.newContext({
         userAgent:
@@ -89,7 +218,6 @@ async function initBrowser() {
         viewport: { width: 1920, height: 1080 },
     });
 
-    // ---- Challenge 页面：获取 _vcrcs ----
     challengePage = await context.newPage();
     console.log(`[Stealth] Passing Vercel challenge: ${CHALLENGE_URL}`);
     await challengePage.goto(CHALLENGE_URL, {
@@ -97,205 +225,134 @@ async function initBrowser() {
         timeout: 60000,
     });
 
-    // 模拟人类行为，帮助通过 bot 检测
     await simulateHumanBehavior(challengePage);
 
-    // 等待 cookie（challenge JS 会异步设置 _vcrcs）
-    const ok = await waitForCookie();
-    if (!ok) {
-        // 重试：刷新页面 + 再次模拟行为
+    let vcrcs = await waitForCookie();
+    if (!vcrcs) {
         console.log('[Stealth] First attempt failed, retrying challenge...');
         await challengePage.reload({ waitUntil: 'domcontentloaded', timeout: 60000 });
         await simulateHumanBehavior(challengePage);
-        const retryOk = await waitForCookie();
-        if (!retryOk) {
+        vcrcs = await waitForCookie();
+        if (!vcrcs) {
             throw new Error('Failed to obtain _vcrcs cookie after retry');
         }
     }
-    challengeCount++;
-
-    // ---- Worker 页面：代理 API 请求 ----
-    // cookie 已在 challenge 页面获取，worker 页面只需加载到 domcontentloaded 即可
-    workerPage = await context.newPage();
-    await workerPage.goto(CHALLENGE_URL, {
-        waitUntil: 'domcontentloaded',
-        timeout: 60000,
-    });
+    challengeCount += 1;
 
-    // 注册流式回调（Node.js 侧接收浏览器内 fetch 的数据块）
-    await workerPage.exposeFunction(
-        '__proxyCallback',
-        (requestId, type, data) => {
-            const pending = pendingRequests.get(requestId);
-            if (!pending) return;
-
-            switch (type) {
-                case 'headers': {
-                    const { status, contentType } = JSON.parse(data);
-                    const headers = {
-                        'Cache-Control': 'no-cache',
-                        Connection: 'keep-alive',
-                    };
-                    if (contentType) headers['Content-Type'] = contentType;
-                    pending.res.writeHead(status, headers);
-                    break;
-                }
-                case 'chunk':
-                    pending.res.write(data);
-                    break;
-                case 'end':
-                    pending.res.end();
-                    pending.resolve();
-                    break;
-                case 'error':
-                    if (!pending.res.headersSent) {
-                        pending.res.writeHead(502, {
-                            'Content-Type': 'application/json',
-                        });
-                    }
-                    pending.res.end(
-                        JSON.stringify({ error: { message: data } }),
-                    );
-                    pending.resolve();
-                    break;
-            }
-        },
-    );
+    await createWorkerPage();
 
     ready = true;
     console.log('[Stealth] Ready! Accepting proxy requests.');
 }
 
-async function waitForCookie(maxWait) {
-    maxWait = maxWait || CHALLENGE_WAIT;
-    const start = Date.now();
-    while (Date.now() - start < maxWait) {
-        const cookies = await context.cookies();
-        const vcrcs = cookies.find((c) => c.name === '_vcrcs');
-        if (vcrcs) {
-            console.log(
-                '[Stealth] _vcrcs obtained:',
-                vcrcs.value.substring(0, 40) + '...',
-            );
-            return true;
-        }
-        await new Promise((r) => setTimeout(r, 2000));
+async function closeBrowserSilently() {
+    if (!browser) return;
+    try {
+        expectedBrowserClose = true;
+        await browser.close().catch(() => {});
+    } finally {
+        expectedBrowserClose = false;
     }
-    console.error('[Stealth] Failed to obtain _vcrcs within timeout');
-    return false;
 }
 
-// 模拟人类行为：鼠标移动、点击、滚动，帮助通过 Vercel bot 检测
-async function simulateHumanBehavior(page) {
-    try {
-        // 随机延迟
-        await new Promise(r => setTimeout(r, 500 + Math.random() * 1000));
+async function restartBrowser(reason = 'manual') {
+    if (restartPromise) {
+        console.log(`[Stealth] Restart already in progress, joining existing restart (${reason})...`);
+        return restartPromise;
+    }
 
-        // 模拟鼠标移动轨迹（多个随机点）
-        const points = Array.from({ length: 5 }, () => ({
-            x: 100 + Math.random() * 600,
-            y: 100 + Math.random() * 400,
-        }));
-        for (const p of points) {
-            await page.mouse.move(p.x, p.y, { steps: 5 + Math.floor(Math.random() * 10) });
-            await new Promise(r => setTimeout(r, 100 + Math.random() * 300));
-        }
+    restartPromise = (async () => {
+        console.log(`[Stealth] Restarting browser (${reason})...`);
+        ready = false;
+        await closeBrowserSilently();
+        browser = null;
+        context = null;
+        challengePage = null;
+        workerPage = null;
+        await initBrowser();
+    })();
 
-        // 模拟滚动
-        await page.mouse.wheel(0, 100 + Math.random() * 200);
-        await new Promise(r => setTimeout(r, 300 + Math.random() * 500));
-        await page.mouse.wheel(0, -(50 + Math.random() * 100));
+    try {
+        await restartPromise;
+    } finally {
+        restartPromise = null;
+    }
+}
 
-        // 模拟点击页面空白区域
-        await page.mouse.click(300 + Math.random() * 400, 300 + Math.random() * 200);
-        await new Promise(r => setTimeout(r, 200 + Math.random() * 500));
+async function scheduleFullRestart(reason) {
+    if (isShuttingDown) {
+        return;
+    }
 
-        console.log('[Stealth] Human behavior simulation done');
-    } catch (e) {
-        // 模拟行为失败不影响主流程
-        console.log('[Stealth] Human simulation skipped:', e.message);
+    if (restartPromise) {
+        console.log(`[Stealth] Skip scheduled restart (${reason}): restart already in progress.`);
+        return restartPromise;
     }
-}
 
-async function refreshChallenge() {
-    console.log('[Stealth] Refreshing challenge...');
-    try {
-        await challengePage.goto(CHALLENGE_URL, {
-            waitUntil: 'networkidle',
-            timeout: 30000,
-        });
-        const ok = await waitForCookie();
-        if (ok) {
-            challengeCount++;
+    const active = getActiveRequestCount();
+    if (active > 0) {
+        if (!scheduledRestartPending) {
+            scheduledRestartPending = true;
             console.log(
-                `[Stealth] Challenge refreshed (total: ${challengeCount})`,
+                `[Stealth] Postponing scheduled restart (${reason}) because ${active} request(s) are active. Will retry in ${Math.floor(RESTART_POSTPONE_MS / 1000)}s.`,
             );
+            setTimeout(() => {
+                scheduleFullRestart('postponed scheduled restart').catch((err) => {
+                    console.error('[Stealth] Postponed scheduled restart failed:', err.message);
+                });
+            }, RESTART_POSTPONE_MS);
         } else {
-            console.error('[Stealth] Challenge refresh failed - cookie not obtained');
+            console.log(`[Stealth] Scheduled restart (${reason}) already postponed.`);
         }
-    } catch (e) {
-        console.error('[Stealth] Challenge refresh error:', e.message);
+        return;
     }
-}
 
-async function restartBrowser() {
-    console.log('[Stealth] Restarting browser...');
-    ready = false;
-    try {
-        if (browser) await browser.close().catch(() => {});
-    } catch (_) {}
-    browser = null;
-    context = null;
-    challengePage = null;
-    workerPage = null;
-    await initBrowser();
+    scheduledRestartPending = false;
+    await restartBrowser(reason);
+    console.log('[Stealth] Scheduled full browser restart completed.');
 }
 
-// ==================== HTTP 服务 ====================
-
 const app = express();
 app.use(express.json({ limit: '10mb' }));
 
-// 健康检查
 app.get('/health', async (_req, res) => {
-    let cookie = null;
-    if (context) {
-        const cookies = await context.cookies().catch(() => []);
-        const vcrcs = cookies.find((c) => c.name === '_vcrcs');
-        if (vcrcs) cookie = vcrcs.value.substring(0, 40) + '...';
-    }
+    const vcrcs = await getVcrcsCookie();
     res.json({
-        status: ready ? 'ok' : 'initializing',
+        status: ready ? 'ok' : restartPromise ? 'restarting' : 'initializing',
         uptime: Math.floor((Date.now() - startTime) / 1000),
         challengeCount,
         requestCount,
-        cookie,
+        activeRequests: getActiveRequestCount(),
+        cookie: getCookiePreview(vcrcs && vcrcs.value),
     });
 });
 
-// 代理请求
 app.post('/proxy/chat', async (req, res) => {
-    if (!ready) {
+    if (!ready || restartPromise || !workerPage) {
         res.status(503).json({
-            error: { message: 'Stealth proxy not ready, please wait' },
+            error: { message: 'Stealth proxy is restarting, please retry shortly' },
         });
         return;
     }
 
     const requestId = crypto.randomUUID();
-    requestCount++;
+    requestCount += 1;
 
-    // 客户端断开时清理
-    let aborted = false;
     req.on('close', () => {
-        aborted = true;
+        const pending = pendingRequests.get(requestId);
+        if (pending && !pending.res.writableEnded) {
+            try {
+                pending.res.end();
+            } catch (_) {}
+            pending.resolve();
+        }
+        pendingRequests.delete(requestId);
     });
 
     const promise = new Promise((resolve) => {
         pendingRequests.set(requestId, { res, resolve });
     });
 
-    // 在浏览器上下文内发起 fetch 并流式回传
     workerPage
         .evaluate(
             async ({ body, requestId }) => {
@@ -317,12 +374,9 @@ app.post('/proxy/chat', async (req, res) => {
 
                     if (!r.body) {
                         const text = await r.text();
-                        if (text)
-                            await window.__proxyCallback(
-                                requestId,
-                                'chunk',
-                                text,
-                            );
+                        if (text) {
+                            await window.__proxyCallback(requestId, 'chunk', text);
+                        }
                         await window.__proxyCallback(requestId, 'end', '');
                         return;
                     }
@@ -333,12 +387,9 @@ app.post('/proxy/chat', async (req, res) => {
                         const { done, value } = await reader.read();
                         if (done) break;
                         const chunk = decoder.decode(value, { stream: true });
-                        if (chunk)
-                            await window.__proxyCallback(
-                                requestId,
-                                'chunk',
-                                chunk,
-                            );
+                        if (chunk) {
+                            await window.__proxyCallback(requestId, 'chunk', chunk);
+                        }
                     }
                     await window.__proxyCallback(requestId, 'end', '');
                 } catch (e) {
@@ -372,22 +423,19 @@ app.post('/proxy/chat', async (req, res) => {
     pendingRequests.delete(requestId);
 });
 
-// ==================== 启动 ====================
-
-const MAX_INIT_RETRIES = parseInt(process.env.MAX_INIT_RETRIES || '5');
-
 (async () => {
-    // 自动重试启动：网络不稳定时多试几次
-    for (let attempt = 1; attempt <= MAX_INIT_RETRIES; attempt++) {
+    for (let attempt = 1; attempt <= MAX_INIT_RETRIES; attempt += 1) {
         try {
             console.log(`[Stealth] Initialization attempt ${attempt}/${MAX_INIT_RETRIES}...`);
             await initBrowser();
-            break; // 成功，跳出重试循环
+            break;
         } catch (e) {
             console.error(`[Stealth] Attempt ${attempt} failed:`, e.message);
-            // 清理失败的浏览器实例
-            if (browser) await browser.close().catch(() => {});
-            browser = null; context = null; challengePage = null; workerPage = null;
+            await closeBrowserSilently();
+            browser = null;
+            context = null;
+            challengePage = null;
+            workerPage = null;
 
             if (attempt >= MAX_INIT_RETRIES) {
                 console.error(`[Stealth] All ${MAX_INIT_RETRIES} attempts failed, exiting.`);
@@ -395,7 +443,7 @@ const MAX_INIT_RETRIES = parseInt(process.env.MAX_INIT_RETRIES || '5');
             }
             const delay = attempt * 5;
             console.log(`[Stealth] Retrying in ${delay}s...`);
-            await new Promise(r => setTimeout(r, delay * 1000));
+            await sleep(delay * 1000);
         }
     }
 
@@ -403,24 +451,24 @@ const MAX_INIT_RETRIES = parseInt(process.env.MAX_INIT_RETRIES || '5');
         console.log(`[Stealth] Proxy listening on port ${PORT}`);
     });
 
-    // 定时刷新 challenge
-    setInterval(refreshChallenge, REFRESH_INTERVAL);
-
-    // 浏览器崩溃恢复
-    browser.on('disconnected', () => {
-        console.error('[Stealth] Browser disconnected! Restarting...');
-        ready = false;
-        setTimeout(restartBrowser, 3000);
-    });
+    refreshTimer = setInterval(() => {
+        scheduleFullRestart('scheduled refresh').catch((err) => {
+            console.error('[Stealth] Scheduled full restart failed:', err.message);
+        });
+    }, REFRESH_INTERVAL);
 })();
 
-// 优雅退出
 const shutdown = async () => {
     console.log('[Stealth] Shutting down...');
+    isShuttingDown = true;
     ready = false;
-    if (browser) await browser.close().catch(() => {});
+    if (refreshTimer) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+    }
+    await closeBrowserSilently();
     process.exit(0);
 };
 
 process.on('SIGTERM', shutdown);
-process.on('SIGINT', shutdown);
+process.on('SIGINT', shutdown);