gemini-proxy-client 1.0.17 → 1.0.19

package/dist/browser/manager.js

@@ -1,4 +1,5 @@
 import { Camoufox } from 'camoufox-js';
+import { firefox } from 'playwright-core';
 import fs from 'fs';
 import path from 'path';
 import chalk from 'chalk';
@@ -11,6 +12,9 @@ const GOOGLE_LOGGED_IN_INDICATOR = 'aistudio.google.com';
 const LOGIN_CHECK_INTERVAL = 2 * 60 * 60 * 1000;
 // 连接状态检查间隔: 30 秒
 const CONNECTION_CHECK_INTERVAL = 30 * 1000;
+// 用户活动模拟间隔: 2-5 秒随机
+const ACTIVITY_INTERVAL_MIN = 2000;
+const ACTIVITY_INTERVAL_MAX = 5000;
 export class BrowserManager {
     browser = null;
     context = null;
@@ -21,6 +25,8 @@ export class BrowserManager {
     isRunning = false;
     loginCheckTimer = null;
     connectionCheckTimer = null;
+    activityTimer = null;
+    wsConnected = false; // 通过控制台日志跟踪 WebSocket 连接状态
     constructor(options) {
         this.options = options;
     }
@@ -30,14 +36,41 @@ export class BrowserManager {
     async launch() {
         // 获取随机指纹配置（同一 dataDir 会保持一致）
         const fingerprint = getRandomFingerprint(this.options.dataDir);
-        console.log(chalk.gray(`指纹配置: ${fingerprint.viewport.width}x${fingerprint.viewport.height}, ${fingerprint.locale}, ${fingerprint.timezoneId}`));
-        this.browser = await Camoufox({
-            headless: this.options.headless,
-            // 禁用 Cross-Origin-Opener-Policy，允许操作跨域 iframe 中的元素
-            disable_coop: true,
-            // 允许在主世界执行脚本，用于 iframe 内的 evaluate
-            main_world_eval: true,
-        });
+        const modeText = this.options.headless === 'virtual' ? '虚拟显示' : (this.options.headless ? '无头' : '有界面');
+        const browserType = this.options.usePlaywright ? 'Playwright Firefox' : 'Camoufox';
+        console.log(chalk.cyan(`[${new Date().toLocaleTimeString()}] 启动 ${browserType} (${modeText}模式)`));
+        console.log(chalk.gray(`[${new Date().toLocaleTimeString()}] 指纹配置: ${fingerprint.viewport.width}x${fingerprint.viewport.height}, ${fingerprint.locale}, ${fingerprint.timezoneId}`));
+        console.log(chalk.gray(`[${new Date().toLocaleTimeString()}] 数据目录: ${this.options.dataDir}`));
+        if (this.options.usePlaywright) {
+            // 使用原生 Playwright Firefox
+            // 对于 Playwright，virtual 模式也使用 headless（Playwright 的 headless 模式比较稳定）
+            const useHeadless = this.options.headless === true || this.options.headless === 'virtual';
+            this.browser = await firefox.launch({
+                headless: useHeadless,
+            });
+        }
+        else {
+            // 使用 Camoufox
+            // 注意: headless 模式下可能有 TLS/JA3 指纹问题导致 WebSocket 连接失败
+            // 如果遇到问题，可以尝试 --playwright 选项使用原生 Firefox
+            this.browser = await Camoufox({
+                headless: this.options.headless,
+                // 禁用 Cross-Origin-Opener-Policy，允许操作跨域 iframe 中的元素
+                disable_coop: true,
+                // 允许在主世界执行脚本，用于 iframe 内的 evaluate
+                main_world_eval: true,
+                // 忽略 disable_coop 警告
+                i_know_what_im_doing: true,
+                // Firefox 偏好设置
+                firefox_user_prefs: {
+                    // WebSocket 相关设置
+                    'network.websocket.allowInsecureFromHTTPS': true,
+                    'network.websocket.max-connections': 200,
+                    'network.websocket.timeout.open': 60,
+                },
+            });
+        }
+        console.log(chalk.green(`[${new Date().toLocaleTimeString()}] 浏览器启动成功`));
         this.context = await this.browser.newContext({
             viewport: fingerprint.viewport,
             locale: fingerprint.locale,
@@ -46,6 +79,89 @@ export class BrowserManager {
         // 加载已保存的 cookies
         await this.loadCookies();
         this.page = await this.context.newPage();
+        // 在 headless 模式下，强制页面和所有 iframe 保持 "visible" 状态
+        if (this.options.headless) {
+            const visibilityScript = `
+        // 覆盖 Page Visibility API
+        Object.defineProperty(document, 'visibilityState', {
+          get: () => 'visible',
+          configurable: true,
+        });
+        Object.defineProperty(document, 'hidden', {
+          get: () => false,
+          configurable: true,
+        });
+        // 阻止 visibilitychange 事件
+        document.addEventListener('visibilitychange', (e) => {
+          e.stopImmediatePropagation();
+        }, true);
+        // 模拟 focus 状态
+        Object.defineProperty(document, 'hasFocus', {
+          value: () => true,
+          configurable: true,
+        });
+      `;
+            // 主页面注入
+            await this.page.addInitScript(visibilityScript);
+            // 监听所有 frame 并注入
+            this.page.on('frameattached', async (frame) => {
+                try {
+                    await frame.evaluate(visibilityScript);
+                }
+                catch (e) {
+                    // 忽略跨域 frame 错误
+                }
+            });
+        }
+        // 监听网络请求，用于调试
+        this.page.on('request', (request) => {
+            const url = request.url();
+            // 只显示 API 相关请求
+            if (url.includes('ProxyStreamedCall') || url.includes('generativelanguage')) {
+                console.log(chalk.cyan(`[${new Date().toLocaleTimeString()}] 📤 请求: ${request.method()} ${url.substring(0, 80)}...`));
+            }
+        });
+        this.page.on('response', (response) => {
+            const url = response.url();
+            // 只显示 API 相关响应
+            if (url.includes('ProxyStreamedCall') || url.includes('generativelanguage')) {
+                const status = response.status();
+                const statusColor = status >= 400 ? chalk.red : chalk.green;
+                console.log(statusColor(`[${new Date().toLocaleTimeString()}] 📥 响应: ${status} ${url.substring(0, 80)}...`));
+            }
+        });
+        this.page.on('requestfailed', (request) => {
+            const url = request.url();
+            if (url.includes('ProxyStreamedCall') || url.includes('generativelanguage')) {
+                console.log(chalk.red(`[${new Date().toLocaleTimeString()}] ❌ 请求失败: ${url.substring(0, 80)}... - ${request.failure()?.errorText}`));
+            }
+        });
+        // 监听控制台消息
+        this.page.on('console', (msg) => {
+            const text = msg.text();
+            const type = msg.type();
+            // 过滤掉不重要的警告
+            if (type === 'warning') {
+                if (text.includes('Content-Security-Policy') ||
+                    text.includes('cookie') ||
+                    text.includes('expires') ||
+                    text.includes('No ID or name')) {
+                    return; // 忽略这些警告
+                }
+            }
+            // 跟踪 WebSocket 连接状态
+            if (text.includes('WebSocket Proxy: CONNECTED') || text.includes('WebSocket Proxy Status: CONNECTED')) {
+                this.wsConnected = true;
+            }
+            else if (text.includes('DISCONNECTED')) {
+                this.wsConnected = false;
+            }
+            // 只显示重要的日志
+            if (type === 'error' || text.includes('WebSocket') || text.includes('Proxy') || text.includes('request') || text.includes('Request')) {
+                const color = type === 'error' ? chalk.red : (type === 'warning' ? chalk.yellow : chalk.gray);
+                console.log(color(`[${new Date().toLocaleTimeString()}] 🖥️  控制台[${type}]: ${text.substring(0, 150)}`));
+            }
+        });
         this.startTime = Date.now();
         this.isRunning = true;
     }
@@ -136,7 +252,8 @@ export class BrowserManager {
     async clickConnectButton() {
         if (!this.page)
             throw new Error('Browser not launched');
-        console.log(chalk.gray('开始查找连接按钮...'));
+        const timestamp = () => `[${new Date().toLocaleTimeString()}]`;
+        console.log(chalk.cyan(`${timestamp()} 开始查找连接按钮...`));
         // 等待页面完全加载
         await sleep(3000);
         // 第一步：点击 "Continue to the app" 按钮（如果存在）
@@ -144,12 +261,12 @@ export class BrowserManager {
             const continueButton = await this.page.waitForSelector('button:has-text("Continue to the app")', { timeout: 5000 });
             if (continueButton) {
                 await continueButton.click();
-                console.log(chalk.green('✅ 点击了 "Continue to the app" 按钮'));
+                console.log(chalk.green(`${timestamp()} ✅ 点击了 "Continue to the app" 按钮`));
                 await sleep(5000); // 等待页面切换，给更多时间
             }
         }
         catch (e) {
-            console.log(chalk.gray('未找到 "Continue to the app" 按钮，继续...'));
+            console.log(chalk.gray(`${timestamp()} 未找到 "Continue to the app" 按钮，继续...`));
         }
         let clicked = false;
         let buildAppFrame = null;
@@ -164,7 +281,7 @@ export class BrowserManager {
                 try {
                     const modal = await this.page.$(selector);
                     if (modal) {
-                        console.log(chalk.gray(`发现模态框: ${selector}，尝试关闭...`));
+                        console.log(chalk.gray(`${timestamp()} 发现模态框: ${selector}，尝试关闭...`));
                         await this.page.keyboard.press('Escape');
                         await sleep(500);
                     }
@@ -179,23 +296,24 @@ export class BrowserManager {
         }
         // 第三步：使用 frames() API 访问 Build App iframe
         try {
-            console.log(chalk.gray('查找 Build App iframe...'));
+            console.log(chalk.cyan(`${timestamp()} 查找 Build App iframe...`));
             const frames = this.page.frames();
-            console.log(chalk.gray(`检查 ${frames.length} 个 frame...`));
+            console.log(chalk.gray(`${timestamp()} 检查 ${frames.length} 个 frame...`));
             for (const frame of frames) {
                 if (clicked)
                     break;
                 const frameUrl = frame.url();
                 // 查找 Build App iframe (可能是 blob: URL 或 scf.usercontent.goog)
                 if (frameUrl.includes('scf.usercontent.goog') || frameUrl.startsWith('blob:')) {
-                    console.log(chalk.gray(`找到 Build App iframe: ${frameUrl.substring(0, 60)}...`));
+                    console.log(chalk.green(`${timestamp()} 找到 Build App iframe: ${frameUrl.substring(0, 60)}...`));
                     buildAppFrame = frame;
                     // 等待 iframe 内容加载
                     try {
                         await frame.waitForLoadState('domcontentloaded');
+                        console.log(chalk.gray(`${timestamp()} iframe 内容加载完成`));
                     }
                     catch (e) {
-                        // 忽略
+                        console.log(chalk.yellow(`${timestamp()} iframe 加载等待超时，继续...`));
                     }
                     // 直接使用 evaluate 在 iframe 中执行点击
                     // 这样可以绑过任何遮挡问题
@@ -215,11 +333,11 @@ export class BrowserManager {
                             return false;
                         });
                         if (clicked) {
-                            console.log(chalk.green('✅ 点击了连接按钮'));
+                            console.log(chalk.green(`${timestamp()} ✅ 点击了连接按钮 (dispatchEvent)`));
                         }
                     }
                     catch (e) {
-                        console.log(chalk.gray(`evaluate 点击失败: ${e}`));
+                        console.log(chalk.yellow(`${timestamp()} evaluate 点击失败: ${e}`));
                     }
                     // 如果 dispatchEvent 失败，尝试直接调用 onclick
                     if (!clicked) {
@@ -233,49 +351,82 @@ export class BrowserManager {
                                 return false;
                             });
                             if (clicked) {
-                                console.log(chalk.green('✅ 点击了连接按钮 (click())'));
+                                console.log(chalk.green(`${timestamp()} ✅ 点击了连接按钮 (click())`));
                             }
                         }
                         catch (e) {
-                            console.log(chalk.gray(`click() 失败: ${e}`));
+                            console.log(chalk.yellow(`${timestamp()} click() 失败: ${e}`));
                         }
                     }
                 }
             }
         }
         catch (e) {
-            console.log(chalk.gray(`iframe 访问失败: ${e}`));
+            console.log(chalk.red(`${timestamp()} iframe 访问失败: ${e}`));
         }
         if (!clicked) {
-            console.log(chalk.yellow('⚠️ 未找到连接按钮，请手动点击连接'));
+            console.log(chalk.yellow(`${timestamp()} ⚠️ 未找到连接按钮，请手动点击连接`));
             return;
         }
-        // 第四步：等待并验证连接成功（按钮文字变成 "Disconnect WS"）
-        console.log(chalk.gray('等待 WebSocket 连接...'));
+        // 第四步：等待并验证连接成功（通过控制台日志检测）
+        console.log(chalk.cyan(`${timestamp()} 等待 WebSocket 连接...`));
         let connected = false;
-        for (let i = 0; i < 15; i++) { // 最多等待 15 秒
+        for (let i = 0; i < 30; i++) { // 最多等待 30 秒
             await sleep(1000);
+            // 通过控制台日志跟踪的状态判断
+            if (this.wsConnected) {
+                connected = true;
+                console.log(chalk.green(`${timestamp()} ✅ WebSocket 连接成功！`));
+                break;
+            }
+            console.log(chalk.gray(`${timestamp()}   等待连接... (${i + 1}/30)`));
+        }
+        if (!connected) {
+            console.log(chalk.yellow(`${timestamp()} ⚠️ WebSocket 连接超时或失败`));
+        }
+        // 第五步：点击 "Launch!" 按钮（如果存在蒙层）
+        try {
+            console.log(chalk.cyan(`${timestamp()} 检查是否有 Launch 蒙层...`));
+            // 先在主页面查找
+            const launchButton = await this.page.waitForSelector('button:has-text("Launch")', { timeout: 3000 });
+            if (launchButton) {
+                await launchButton.click();
+                console.log(chalk.green(`${timestamp()} ✅ 点击了 "Launch!" 按钮`));
+                await sleep(1000);
+            }
+        }
+        catch (e) {
+            // 在 iframe 中查找
             if (buildAppFrame) {
                 try {
-                    const buttonText = await buildAppFrame.evaluate(() => {
-                        const btn = document.querySelector('button[title="Connect WebSocket Proxy"], button[title="Disconnect WebSocket Proxy"]');
-                        return btn?.textContent?.trim() || '';
+                    const clicked = await buildAppFrame.evaluate(() => {
+                        const btn = document.querySelector('button');
+                        if (btn && btn.textContent?.includes('Launch')) {
+                            btn.click();
+                            return true;
+                        }
+                        // 查找所有按钮
+                        const buttons = document.querySelectorAll('button');
+                        for (const b of buttons) {
+                            if (b.textContent?.includes('Launch')) {
+                                b.click();
+                                return true;
+                            }
+                        }
+                        return false;
                     });
-                    console.log(chalk.gray(`  检测按钮文字: "${buttonText}"`));
-                    if (buttonText.includes('Disconnect')) {
-                        connected = true;
-                        console.log(chalk.green('✅ WebSocket 连接成功！'));
-                        break;
+                    if (clicked) {
+                        console.log(chalk.green(`${timestamp()} ✅ 点击了 iframe 中的 "Launch!" 按钮`));
+                    }
+                    else {
+                        console.log(chalk.gray(`${timestamp()} 未找到 Launch 蒙层`));
                     }
                 }
-                catch (e) {
-                    // 忽略
+                catch (e2) {
+                    console.log(chalk.gray(`${timestamp()} 未找到 Launch 蒙层`));
                 }
             }
         }
-        if (!connected) {
-            console.log(chalk.yellow('⚠️ WebSocket 连接可能未成功，请检查'));
-        }
     }
     /**
      * 设置服务器地址
@@ -342,9 +493,91 @@ export class BrowserManager {
         this.connectionCheckTimer = setInterval(async () => {
             await this.checkConnection();
         }, CONNECTION_CHECK_INTERVAL);
+        // 启动用户活动模拟（仅在 headless 或 virtual 模式下）
+        if (this.options.headless) {
+            this.startHumanActivity();
+        }
         // 定期更新状态显示
         this.startStatusDisplay();
     }
+    /**
+     * 启动人类活动模拟
+     * 定期模拟鼠标移动和其他用户交互，防止页面因检测不到用户而暂停
+     */
+    startHumanActivity() {
+        const scheduleNext = () => {
+            // 随机间隔 5-15 秒
+            const interval = ACTIVITY_INTERVAL_MIN + Math.random() * (ACTIVITY_INTERVAL_MAX - ACTIVITY_INTERVAL_MIN);
+            this.activityTimer = setTimeout(async () => {
+                await this.simulateHumanActivity();
+                if (this.isRunning) {
+                    scheduleNext();
+                }
+            }, interval);
+        };
+        console.log(chalk.cyan(`[${new Date().toLocaleTimeString()}] 🖱️  启动用户活动模拟...`));
+        scheduleNext();
+    }
+    /**
+     * 模拟人类活动
+     */
+    async simulateHumanActivity() {
+        if (!this.page || !this.isRunning)
+            return;
+        try {
+            // 获取视口大小
+            const viewport = this.page.viewportSize();
+            if (!viewport)
+                return;
+            // 生成随机坐标（避开边缘区域）
+            const margin = 50;
+            const x = margin + Math.random() * (viewport.width - 2 * margin);
+            const y = margin + Math.random() * (viewport.height - 2 * margin);
+            // 随机选择活动类型
+            const activityType = Math.random();
+            if (activityType < 0.7) {
+                // 70% 概率：鼠标移动
+                await this.page.mouse.move(x, y, {
+                    steps: 5 + Math.floor(Math.random() * 10), // 随机步数使移动更自然
+                });
+            }
+            else if (activityType < 0.9) {
+                // 20% 概率：鼠标移动 + 小幅度滚动
+                await this.page.mouse.move(x, y, { steps: 5 });
+                const scrollAmount = (Math.random() - 0.5) * 100; // -50 到 50
+                await this.page.mouse.wheel(0, scrollAmount);
+            }
+            else {
+                // 10% 概率：在 Build App iframe 内模拟鼠标移动
+                const frames = this.page.frames();
+                for (const frame of frames) {
+                    const frameUrl = frame.url();
+                    if (frameUrl.includes('scf.usercontent.goog') || frameUrl.startsWith('blob:')) {
+                        try {
+                            // 在 iframe 内触发 mousemove 事件
+                            await frame.evaluate(() => {
+                                const event = new MouseEvent('mousemove', {
+                                    bubbles: true,
+                                    cancelable: true,
+                                    clientX: Math.random() * window.innerWidth,
+                                    clientY: Math.random() * window.innerHeight,
+                                    view: window
+                                });
+                                document.dispatchEvent(event);
+                            });
+                        }
+                        catch (e) {
+                            // iframe 可能已经不可访问，忽略
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // 忽略模拟活动时的错误，不影响主流程
+        }
+    }
     /**
      * 检查并刷新登录状态
      */
@@ -443,6 +676,10 @@ export class BrowserManager {
             clearInterval(this.connectionCheckTimer);
             this.connectionCheckTimer = null;
         }
+        if (this.activityTimer) {
+            clearTimeout(this.activityTimer);
+            this.activityTimer = null;
+        }
         if (this.browser) {
             await this.browser.close();
             this.browser = null;

package/dist/cli.js

@@ -25,7 +25,9 @@ program
     .option('-s, --server <url>', '代理服务器 WebSocket 地址', 'ws://localhost:5345/v1/ws')
     .option('-t, --token <token>', '客户端认证令牌 (不指定则自动生成)')
     .option('-d, --daemon', '后台运行模式')
-    .option('--headless', '强制无头模式 (需要已有登录状态)')
+    .option('--headless', '强制无头模式 (可能有兼容性问题)')
+    .option('--virtual', '虚拟显示模式 (需要安装 xvfb，推荐)')
+    .option('--playwright', '使用原生 Playwright Firefox (解决 Camoufox WebSocket 问题)')
     .option('--data-dir <path>', '数据目录路径', DEFAULT_DATA_DIR)
     .action(async (options) => {
     try {

package/dist/commands/start.js

@@ -5,6 +5,12 @@ import path from 'path';
 import { execSync } from 'child_process';
 import { BrowserManager } from '../browser/manager.js';
 import { generateToken, ensureDataDir } from '../utils/helpers.js';
+/**
+ * 检查是否是 macOS
+ */
+function isMacOS() {
+    return process.platform === 'darwin';
+}
 /**
  * 检查 Camoufox 是否已安装
  */
@@ -65,25 +71,47 @@ export async function startClient(options) {
     console.log(chalk.gray('─'.repeat(50)));
     const cookiesPath = path.join(dataDir, 'cookies.json');
     const hasCookies = fs.existsSync(cookiesPath);
-    // 决定是否使用无头模式
+    // 决定使用哪种模式: false (有界面) / true (无头) / 'virtual' (虚拟显示)
     let headless = options.headless ?? false;
+    let usePlaywright = options.playwright ?? false;
+    // 如果指定了 --virtual，使用虚拟显示模式
+    if (options.virtual) {
+        headless = 'virtual';
+    }
+    // macOS 上自动使用 Playwright（Camoufox headless 在 macOS 上有问题）
+    if (isMacOS() && !options.playwright && (options.headless || options.virtual)) {
+        console.log(chalk.yellow('⚠️  macOS 检测到，自动切换到 Playwright Firefox'));
+        usePlaywright = true;
+        headless = true; // macOS 上使用纯 headless
+    }
     if (!hasCookies) {
         console.log(chalk.yellow('⚠️  未检测到 Google 登录状态'));
         console.log(chalk.white('   将打开浏览器，请登录您的 Google 账号...'));
         headless = false;
+        usePlaywright = false; // 登录时使用 Camoufox 有界面模式
     }
-    else if (!options.headless) {
-        // 有 cookies，默认使用无头模式
-        headless = true;
-        console.log(chalk.green('📂 检测到已保存的登录状态'));
+    else if (!options.headless && !options.virtual) {
+        // 有 cookies，默认使用虚拟显示模式（如果可用）或无头模式
+        if (isMacOS()) {
+            headless = true;
+            usePlaywright = true;
+            console.log(chalk.green('📂 检测到已保存的登录状态'));
+            console.log(chalk.gray('   macOS: 使用 Playwright Firefox 无头模式'));
+        }
+        else {
+            headless = 'virtual';
+            console.log(chalk.green('📂 检测到已保存的登录状态'));
+            console.log(chalk.gray('   尝试使用虚拟显示模式 (需要 xvfb)'));
+        }
     }
-    const spinner = ora('启动 Camoufox 浏览器...').start();
+    const spinner = ora('启动浏览器...').start();
     try {
         let browserManager = new BrowserManager({
             headless,
             dataDir,
             serverUrl: server,
             token,
+            usePlaywright,
         });
         // 设置信号处理
         setupSignalHandlers(browserManager);
@@ -103,19 +131,19 @@ export async function startClient(options) {
             // 保存 cookies
             await browserManager.saveCookies();
             console.log(chalk.green('✅ Google 登录成功！已保存登录状态'));
-            // 关闭有界面的浏览器，以无头模式重新启动
-            console.log(chalk.gray('🔄 切换到无头模式...'));
+            // 关闭有界面的浏览器，以虚拟显示模式重新启动
+            console.log(chalk.gray('🔄 切换到虚拟显示模式...'));
             await browserManager.close();
-            // 创建新的无头浏览器实例
+            // 创建新的虚拟显示模式浏览器实例
             browserManager = new BrowserManager({
-                headless: true,
+                headless: 'virtual',
                 dataDir,
                 serverUrl: server,
                 token,
             });
             // 重新设置信号处理
             setupSignalHandlers(browserManager);
-            spinner.start('以无头模式重新启动...');
+            spinner.start('以虚拟显示模式重新启动...');
             await browserManager.launch();
             spinner.text = '打开 Build App 页面...';
             await browserManager.openBuildApp();
@@ -124,8 +152,9 @@ export async function startClient(options) {
         spinner.text = '点击 ws connect 按钮...';
         await browserManager.clickConnectButton();
         spinner.succeed(chalk.green('已连接到代理服务器！'));
+        const modeText = headless === 'virtual' ? '虚拟显示模式' : (headless ? '无头模式' : '有界面模式');
         console.log(chalk.gray('─'.repeat(50)));
-        console.log(chalk.green(`✅ 客户端已启动 (无头模式)`));
+        console.log(chalk.green(`✅ 客户端已启动 (${modeText})`));
         console.log(chalk.white(`   Token: ${token}`));
         console.log(chalk.gray('   按 Ctrl+C 退出'));
         console.log(chalk.gray('─'.repeat(50)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemini-proxy-client",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "Gemini Proxy Build App 客户端 - 使用 Camoufox 自动保持连接",
   "main": "dist/index.js",
   "bin": {
@@ -26,6 +26,7 @@
   ],
   "dependencies": {
     "camoufox-js": "^0.8.5",
+    "playwright-core": "^1.40.0",
     "commander": "^12.0.0",
     "chalk": "^5.3.0",
     "ora": "^8.0.1",