gemini-proxy-client 1.0.0

package/README.md

@@ -0,0 +1,172 @@
+# Gemini Proxy Client
+
+基于 Camoufox 的 Gemini Proxy 客户端工具，用于自动化连接和保活 Build App。
+
+## 特性
+
+- **反指纹检测**: 使用 Camoufox (基于 Firefox) 防止 Google 检测多账号
+- **自动登录管理**: 首次需要手动登录，之后自动保持登录状态
+- **自动保活**: 每 2 小时检查登录状态，断线自动重连
+- **无头运行**: 登录后可在后台无头运行，节省资源
+
+## 安装
+
+### 方式 1: 从 npm 安装（推荐）
+
+```bash
+npm install -g gemini-proxy-client
+```
+
+安装时会自动下载 Camoufox 浏览器（约 200MB）。如果下载失败，手动执行：
+
+```bash
+npx camoufox-js fetch
+```
+
+### 方式 2: 从源码安装
+
+```bash
+git clone https://github.com/user/gemini-proxy-panel.git
+cd gemini-proxy-panel/client
+npm install
+npm run build
+npm link  # 可选，全局安装
+```
+
+## 使用方法
+
+### 1. 启动客户端
+
+```bash
+# 连接到代理服务器
+gemini-client start --server wss://your-server.com/v1/ws
+
+# 或使用简写
+gemini-client start -s wss://your-server.com/v1/ws
+```
+
+**首次运行**会打开浏览器窗口，请登录您的 Google 账号。登录成功后，cookies 会自动保存，之后运行将使用无头模式。
+
+### 2. 指定 Token
+
+```bash
+# 不指定 token 会自动生成 gp_client_YYYY_MM_DD_HH_mm_ss 格式
+gemini-client start -s wss://your-server.com/v1/ws
+
+# 指定自定义 token
+gemini-client start -s wss://your-server.com/v1/ws -t my-custom-token
+```
+
+### 3. 其他命令
+
+```bash
+# 单独登录 Google 账号
+gemini-client login
+
+# 查看状态
+gemini-client status
+
+# 清除登录状态
+gemini-client logout
+
+# 查看帮助
+gemini-client --help
+```
+
+## 命令参考
+
+### start - 启动客户端
+
+```bash
+gemini-client start [options]
+```
+
+| 选项 | 说明 | 默认值 |
+|------|------|--------|
+| `-s, --server <url>` | 代理服务器 WebSocket 地址 | `ws://localhost:5345/v1/ws` |
+| `-t, --token <token>` | 客户端认证令牌 | 自动生成 |
+| `-d, --daemon` | 后台运行模式 | false |
+| `--headless` | 强制无头模式 | 自动判断 |
+| `--data-dir <path>` | 数据目录路径 | `~/.gemini-client` |
+
+### login - 登录 Google
+
+```bash
+gemini-client login [options]
+```
+
+打开浏览器让用户登录 Google 账号，保存 cookies 供后续使用。
+
+### status - 查看状态
+
+```bash
+gemini-client status [options]
+```
+
+显示当前登录状态和配置信息。
+
+### logout - 清除登录
+
+```bash
+gemini-client logout [options]
+```
+
+清除保存的 Google 登录 cookies。
+
+## 数据存储
+
+默认数据目录: `~/.gemini-client/`
+
+| 文件 | 说明 |
+|------|------|
+| `cookies.json` | Google 登录 cookies |
+| `config.json` | 配置信息 |
+
+## 保活机制
+
+- **登录状态检查**: 每 2 小时检查一次 Google 登录状态
+- **连接状态检查**: 每 30 秒检查一次 WebSocket 连接
+- **自动重连**: 连接断开时自动尝试重新连接
+- **登录过期处理**: 登录过期时会弹出浏览器让用户重新登录
+
+## 系统要求
+
+- Node.js >= 18.0.0
+- 能够访问 GitHub（下载 Camoufox 浏览器）
+- 能够访问 Google AI Studio（非中国大陆 IP）
+
+## 常见问题
+
+### Q: Camoufox 下载失败怎么办？
+
+A: 可能是网络问题，尝试使用代理或手动下载：
+
+```bash
+# 设置代理
+export https_proxy=http://127.0.0.1:7890
+
+# 重新下载
+npx camoufox-js fetch
+```
+
+### Q: Google 登录状态能保持多久？
+
+A: 通常 1-2 周，但可能因以下原因提前失效：
+- IP 地址变化
+- 长时间无活动
+- Google 安全检测
+
+客户端会每 2 小时检查一次，失效时会提示重新登录。
+
+### Q: 可以同时运行多个客户端吗？
+
+A: 可以，使用不同的 `--data-dir` 参数：
+
+```bash
+gemini-client start -s wss://server.com/v1/ws --data-dir ~/.gemini-client-1
+gemini-client start -s wss://server.com/v1/ws --data-dir ~/.gemini-client-2
+```
+
+## License
+
+MIT

package/dist/browser/manager.js

@@ -0,0 +1,346 @@
+import { Camoufox } from 'camoufox-js';
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import { sleep, formatUptime } from '../utils/helpers.js';
+// Build App URL
+const BUILD_APP_URL = 'https://aistudio.google.com/apps/drive/1JqM2cAKs9japdW99aJwkg2k6GZSeCSHR?showPreview=true&pli=1&showAssistant=true';
+const GOOGLE_LOGIN_URL = 'https://accounts.google.com/';
+const GOOGLE_LOGGED_IN_INDICATOR = 'aistudio.google.com';
+// 登录检查间隔: 2 小时
+const LOGIN_CHECK_INTERVAL = 2 * 60 * 60 * 1000;
+// 连接状态检查间隔: 30 秒
+const CONNECTION_CHECK_INTERVAL = 30 * 1000;
+export class BrowserManager {
+    browser = null;
+    context = null;
+    page = null;
+    options;
+    startTime = 0;
+    requestCount = 0;
+    isRunning = false;
+    loginCheckTimer = null;
+    connectionCheckTimer = null;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * 启动浏览器
+     */
+    async launch() {
+        this.browser = await Camoufox({
+            headless: this.options.headless,
+        });
+        this.context = await this.browser.newContext({
+            viewport: { width: 1280, height: 800 },
+            locale: 'en-US',
+        });
+        // 加载已保存的 cookies
+        await this.loadCookies();
+        this.page = await this.context.newPage();
+        this.startTime = Date.now();
+        this.isRunning = true;
+    }
+    /**
+     * 打开 Build App 页面
+     */
+    async openBuildApp() {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        // 构建带 token 的 URL (如果 Build App 支持)
+        // 注意: 实际的 ws connect 按钮会在页面内处理连接
+        await this.page.goto(BUILD_APP_URL, {
+            waitUntil: 'networkidle',
+            timeout: 60000,
+        });
+    }
+    /**
+     * 打开 Google 登录页面
+     */
+    async openGoogleLogin() {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        await this.page.goto(GOOGLE_LOGIN_URL, {
+            waitUntil: 'networkidle',
+            timeout: 60000,
+        });
+    }
+    /**
+     * 检查是否已登录 Google
+     */
+    async checkGoogleLogin() {
+        if (!this.page)
+            return false;
+        try {
+            // 检查页面 URL 是否在 AI Studio 域名下且没有登录重定向
+            const url = this.page.url();
+            // 如果在 accounts.google.com，说明需要登录
+            if (url.includes('accounts.google.com')) {
+                return false;
+            }
+            // 如果在 AI Studio，检查是否有登录相关的元素
+            if (url.includes(GOOGLE_LOGGED_IN_INDICATOR)) {
+                // 检查是否有用户头像或登录状态指示器
+                const isLoggedIn = await this.page.evaluate(() => {
+                    // 检查是否有登录提示或错误
+                    const loginPrompt = document.querySelector('[data-login-required]');
+                    if (loginPrompt)
+                        return false;
+                    // 检查是否有用户相关元素
+                    const userAvatar = document.querySelector('img[alt*="Account"], img[alt*="Profile"]');
+                    return !!userAvatar || !document.body.textContent?.includes('Sign in');
+                });
+                return isLoggedIn;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('检查登录状态失败:', error);
+            return false;
+        }
+    }
+    /**
+     * 等待用户完成 Google 登录
+     */
+    async waitForGoogleLogin(timeout = 300000) {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            // 检查是否已经在 AI Studio 页面
+            const url = this.page.url();
+            if (url.includes(GOOGLE_LOGGED_IN_INDICATOR) && !url.includes('accounts.google.com')) {
+                // 额外等待页面加载完成
+                await sleep(2000);
+                // 再次确认登录状态
+                const isLoggedIn = await this.checkGoogleLogin();
+                if (isLoggedIn) {
+                    return;
+                }
+            }
+            await sleep(1000);
+        }
+        throw new Error('登录超时');
+    }
+    /**
+     * 点击 ws connect 按钮
+     */
+    async clickConnectButton() {
+        if (!this.page)
+            throw new Error('Browser not launched');
+        // 等待页面完全加载
+        await sleep(2000);
+        // 查找并修改 WebSocket 连接地址 (如果需要)
+        // 这取决于 Build App 的实现方式
+        // 尝试多种方式找到连接按钮
+        const buttonSelectors = [
+            'button:has-text("ws connect")',
+            'button:has-text("connect")',
+            '[data-action="connect"]',
+            '.connect-button',
+        ];
+        let clicked = false;
+        for (const selector of buttonSelectors) {
+            try {
+                const button = await this.page.$(selector);
+                if (button) {
+                    // 先尝试设置服务器地址 (如果有输入框)
+                    await this.setServerAddress();
+                    await button.click();
+                    clicked = true;
+                    break;
+                }
+            }
+            catch (e) {
+                // 继续尝试下一个选择器
+            }
+        }
+        if (!clicked) {
+            // 如果找不到按钮，可能需要通过其他方式触发连接
+            // 尝试在页面中执行 JavaScript
+            await this.page.evaluate(({ serverUrl, token }) => {
+                // 尝试找到全局的连接函数或 WebSocket 实例
+                const wsUrl = `${serverUrl}?auth_token=${token}`;
+                console.log('Attempting to connect to:', wsUrl);
+                // 这里的实现取决于 Build App 的具体代码结构
+                // 可能需要根据实际情况调整
+            }, { serverUrl: this.options.serverUrl, token: this.options.token });
+            console.log(chalk.yellow('⚠️ 未找到连接按钮，请手动点击连接'));
+        }
+        // 等待连接建立
+        await sleep(3000);
+    }
+    /**
+     * 设置服务器地址
+     */
+    async setServerAddress() {
+        if (!this.page)
+            return;
+        try {
+            // 查找服务器地址输入框
+            const inputSelectors = [
+                'input[placeholder*="server"]',
+                'input[placeholder*="ws://"]',
+                'input[name="server"]',
+                '#server-url',
+            ];
+            for (const selector of inputSelectors) {
+                const input = await this.page.$(selector);
+                if (input) {
+                    await input.fill(`${this.options.serverUrl}?auth_token=${this.options.token}`);
+                    break;
+                }
+            }
+        }
+        catch (e) {
+            // 忽略错误
+        }
+    }
+    /**
+     * 保存 Cookies
+     */
+    async saveCookies() {
+        if (!this.context)
+            return;
+        const cookies = await this.context.cookies();
+        const cookiesPath = path.join(this.options.dataDir, 'cookies.json');
+        fs.writeFileSync(cookiesPath, JSON.stringify(cookies, null, 2));
+    }
+    /**
+     * 加载 Cookies
+     */
+    async loadCookies() {
+        if (!this.context)
+            return;
+        const cookiesPath = path.join(this.options.dataDir, 'cookies.json');
+        if (fs.existsSync(cookiesPath)) {
+            try {
+                const cookies = JSON.parse(fs.readFileSync(cookiesPath, 'utf-8'));
+                await this.context.addCookies(cookies);
+            }
+            catch (e) {
+                console.error('加载 Cookies 失败:', e);
+            }
+        }
+    }
+    /**
+     * 启动保活机制
+     */
+    async startKeepAlive() {
+        // 登录状态检查 (每 2 小时)
+        this.loginCheckTimer = setInterval(async () => {
+            await this.checkAndRefreshLogin();
+        }, LOGIN_CHECK_INTERVAL);
+        // 连接状态检查 (每 30 秒)
+        this.connectionCheckTimer = setInterval(async () => {
+            await this.checkConnection();
+        }, CONNECTION_CHECK_INTERVAL);
+        // 定期更新状态显示
+        this.startStatusDisplay();
+    }
+    /**
+     * 检查并刷新登录状态
+     */
+    async checkAndRefreshLogin() {
+        if (!this.page || !this.isRunning)
+            return;
+        console.log(chalk.gray(`\n[${new Date().toLocaleTimeString()}] 检查 Google 登录状态...`));
+        const isLoggedIn = await this.checkGoogleLogin();
+        if (!isLoggedIn) {
+            console.log(chalk.red('⚠️ Google 登录已失效！'));
+            console.log(chalk.yellow('   需要重新登录，正在打开浏览器...'));
+            // 切换到有界面模式重新登录
+            // 这里需要重启浏览器
+            await this.handleLoginExpired();
+        }
+        else {
+            console.log(chalk.green('✅ Google 登录状态正常'));
+            // 刷新 cookies
+            await this.saveCookies();
+        }
+    }
+    /**
+     * 处理登录过期
+     */
+    async handleLoginExpired() {
+        // 关闭当前浏览器
+        await this.close();
+        // 以有界面模式重新启动
+        this.options.headless = false;
+        await this.launch();
+        await this.openBuildApp();
+        console.log(chalk.yellow('\n🔐 请在浏览器中重新登录 Google 账号...'));
+        await this.waitForGoogleLogin();
+        await this.saveCookies();
+        console.log(chalk.green('✅ 重新登录成功！'));
+        // 重新连接
+        await this.clickConnectButton();
+        // 切回无头模式 (下次启动时)
+        this.options.headless = true;
+    }
+    /**
+     * 检查 WebSocket 连接状态
+     */
+    async checkConnection() {
+        if (!this.page || !this.isRunning)
+            return;
+        try {
+            // 检查页面是否还在运行
+            const url = this.page.url();
+            if (!url.includes(GOOGLE_LOGGED_IN_INDICATOR)) {
+                console.log(chalk.yellow('⚠️ 页面异常，尝试重新打开...'));
+                await this.openBuildApp();
+                await this.clickConnectButton();
+            }
+            // 检查连接状态 (通过页面元素或 JavaScript)
+            const connectionStatus = await this.page.evaluate(() => {
+                // 这里需要根据 Build App 的实际实现来检查连接状态
+                // 例如检查某个状态指示器元素
+                const statusEl = document.querySelector('[data-connection-status]');
+                if (statusEl) {
+                    return statusEl.textContent?.includes('connected');
+                }
+                return true; // 默认假设连接正常
+            });
+            if (!connectionStatus) {
+                console.log(chalk.yellow('⚠️ 连接断开，尝试重新连接...'));
+                await this.clickConnectButton();
+            }
+        }
+        catch (error) {
+            console.error('检查连接状态失败:', error);
+        }
+    }
+    /**
+     * 启动状态显示
+     */
+    startStatusDisplay() {
+        // 每分钟更新一次状态
+        setInterval(() => {
+            if (this.isRunning) {
+                const uptime = formatUptime(this.startTime);
+                process.stdout.write(`\r${chalk.gray(`运行时间: ${uptime} | 状态: 在线`)}`);
+            }
+        }, 60000);
+    }
+    /**
+     * 关闭浏览器
+     */
+    async close() {
+        this.isRunning = false;
+        if (this.loginCheckTimer) {
+            clearInterval(this.loginCheckTimer);
+            this.loginCheckTimer = null;
+        }
+        if (this.connectionCheckTimer) {
+            clearInterval(this.connectionCheckTimer);
+            this.connectionCheckTimer = null;
+        }
+        if (this.browser) {
+            await this.browser.close();
+            this.browser = null;
+            this.context = null;
+            this.page = null;
+        }
+    }
+}

package/dist/cli.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import chalk from 'chalk';
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+import { startClient } from './commands/start.js';
+import { loginCommand } from './commands/login.js';
+import { statusCommand } from './commands/status.js';
+const DEFAULT_DATA_DIR = path.join(os.homedir(), '.gemini-client');
+const program = new Command();
+program
+    .name('gemini-client')
+    .description('Gemini Proxy Build App 客户端 - 使用 Camoufox 自动保持连接')
+    .version('1.0.0');
+program
+    .command('start')
+    .description('启动客户端，连接到代理服务器')
+    .option('-s, --server <url>', '代理服务器 WebSocket 地址', 'ws://localhost:5345/v1/ws')
+    .option('-t, --token <token>', '客户端认证令牌 (不指定则自动生成)')
+    .option('-d, --daemon', '后台运行模式')
+    .option('--headless', '强制无头模式 (需要已有登录状态)')
+    .option('--data-dir <path>', '数据目录路径', DEFAULT_DATA_DIR)
+    .action(async (options) => {
+    try {
+        await startClient(options);
+    }
+    catch (error) {
+        console.error(chalk.red('启动失败:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('login')
+    .description('登录 Google 账号 (会打开浏览器)')
+    .option('--data-dir <path>', '数据目录路径', DEFAULT_DATA_DIR)
+    .action(async (options) => {
+    try {
+        await loginCommand(options);
+    }
+    catch (error) {
+        console.error(chalk.red('登录失败:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('status')
+    .description('查看当前状态')
+    .option('--data-dir <path>', '数据目录路径', DEFAULT_DATA_DIR)
+    .action(async (options) => {
+    try {
+        await statusCommand(options);
+    }
+    catch (error) {
+        console.error(chalk.red('查询失败:'), error);
+        process.exit(1);
+    }
+});
+program
+    .command('logout')
+    .description('清除保存的登录状态')
+    .option('--data-dir <path>', '数据目录路径', DEFAULT_DATA_DIR)
+    .action(async (options) => {
+    const cookiesPath = path.join(options.dataDir, 'cookies.json');
+    if (fs.existsSync(cookiesPath)) {
+        fs.unlinkSync(cookiesPath);
+        console.log(chalk.green('✅ 已清除登录状态'));
+    }
+    else {
+        console.log(chalk.yellow('⚠️ 没有保存的登录状态'));
+    }
+});
+program.parse();

package/dist/commands/login.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import path from 'path';
+import { BrowserManager } from '../browser/manager.js';
+import { ensureDataDir } from '../utils/helpers.js';
+export async function loginCommand(options) {
+    const { dataDir } = options;
+    ensureDataDir(dataDir);
+    console.log(chalk.cyan('🔐 Google 账号登录'));
+    console.log(chalk.gray('─'.repeat(50)));
+    const spinner = ora('启动浏览器...').start();
+    const browserManager = new BrowserManager({
+        headless: false, // 登录必须有界面
+        dataDir,
+        serverUrl: '',
+        token: '',
+    });
+    try {
+        await browserManager.launch();
+        spinner.text = '打开 Google 登录页面...';
+        await browserManager.openGoogleLogin();
+        spinner.stop();
+        console.log(chalk.yellow('\n🔐 请在浏览器中登录 Google 账号...'));
+        console.log(chalk.gray('   登录成功后将自动保存'));
+        // 等待用户登录
+        await browserManager.waitForGoogleLogin();
+        // 保存 cookies
+        await browserManager.saveCookies();
+        console.log(chalk.green('\n✅ 登录成功！已保存登录状态'));
+        console.log(chalk.gray(`   Cookies 保存在: ${path.join(dataDir, 'cookies.json')}`));
+        console.log(chalk.cyan('\n现在可以运行 gemini-client start 启动客户端'));
+    }
+    catch (error) {
+        spinner.fail('登录失败');
+        throw error;
+    }
+    finally {
+        await browserManager.close();
+    }
+}

package/dist/commands/start.js

@@ -0,0 +1,96 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import { BrowserManager } from '../browser/manager.js';
+import { generateToken, ensureDataDir } from '../utils/helpers.js';
+export async function startClient(options) {
+    const { server, daemon, dataDir } = options;
+    // 确保数据目录存在
+    ensureDataDir(dataDir);
+    // 生成或使用指定的 token
+    const token = options.token || generateToken();
+    console.log(chalk.cyan('🦊 Gemini Proxy Client'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(chalk.white(`服务器: ${server}`));
+    console.log(chalk.white(`Token: ${token}`));
+    console.log(chalk.gray('─'.repeat(50)));
+    const cookiesPath = path.join(dataDir, 'cookies.json');
+    const hasCookies = fs.existsSync(cookiesPath);
+    // 决定是否使用无头模式
+    let headless = options.headless ?? false;
+    if (!hasCookies) {
+        console.log(chalk.yellow('⚠️  未检测到 Google 登录状态'));
+        console.log(chalk.white('   将打开浏览器，请登录您的 Google 账号...'));
+        headless = false;
+    }
+    else if (!options.headless) {
+        // 有 cookies，默认使用无头模式
+        headless = true;
+        console.log(chalk.green('📂 检测到已保存的登录状态'));
+    }
+    const spinner = ora('启动 Camoufox 浏览器...').start();
+    try {
+        const browserManager = new BrowserManager({
+            headless,
+            dataDir,
+            serverUrl: server,
+            token,
+        });
+        // 设置信号处理
+        setupSignalHandlers(browserManager);
+        spinner.text = '初始化浏览器...';
+        await browserManager.launch();
+        spinner.text = '打开 Build App 页面...';
+        await browserManager.openBuildApp();
+        // 检查登录状态
+        spinner.text = '检查 Google 登录状态...';
+        const isLoggedIn = await browserManager.checkGoogleLogin();
+        if (!isLoggedIn) {
+            spinner.stop();
+            console.log(chalk.yellow('\n🔐 请在浏览器中登录 Google 账号...'));
+            console.log(chalk.gray('   登录成功后将自动继续'));
+            // 等待用户登录
+            await browserManager.waitForGoogleLogin();
+            // 保存 cookies
+            await browserManager.saveCookies();
+            console.log(chalk.green('✅ Google 登录成功！已保存登录状态'));
+            spinner.start('继续连接...');
+        }
+        // 点击连接按钮
+        spinner.text = '点击 ws connect 按钮...';
+        await browserManager.clickConnectButton();
+        spinner.succeed(chalk.green('已连接到代理服务器！'));
+        console.log(chalk.gray('─'.repeat(50)));
+        console.log(chalk.green(`✅ 客户端已启动`));
+        console.log(chalk.white(`   Token: ${token}`));
+        console.log(chalk.gray('   按 Ctrl+C 退出'));
+        console.log(chalk.gray('─'.repeat(50)));
+        // 启动保活和状态监控
+        await browserManager.startKeepAlive();
+        // 如果是 daemon 模式，保持运行
+        if (daemon) {
+            console.log(chalk.cyan('🔄 后台运行模式'));
+        }
+        // 保持进程运行
+        await new Promise(() => { });
+    }
+    catch (error) {
+        spinner.fail(chalk.red('启动失败'));
+        throw error;
+    }
+}
+function setupSignalHandlers(browserManager) {
+    const cleanup = async () => {
+        console.log(chalk.yellow('\n\n🛑 正在关闭...'));
+        try {
+            await browserManager.close();
+        }
+        catch (e) {
+            // ignore
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}

package/dist/commands/status.js

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { ensureDataDir } from '../utils/helpers.js';
+export async function statusCommand(options) {
+    const { dataDir } = options;
+    ensureDataDir(dataDir);
+    console.log(chalk.cyan('📊 Gemini Client 状态'));
+    console.log(chalk.gray('─'.repeat(50)));
+    // 检查 cookies
+    const cookiesPath = path.join(dataDir, 'cookies.json');
+    if (fs.existsSync(cookiesPath)) {
+        const stats = fs.statSync(cookiesPath);
+        const lastModified = stats.mtime;
+        const ageHours = (Date.now() - lastModified.getTime()) / (1000 * 60 * 60);
+        console.log(chalk.green('✅ Google 登录状态: 已保存'));
+        console.log(chalk.gray(`   保存时间: ${lastModified.toLocaleString()}`));
+        console.log(chalk.gray(`   已过去: ${ageHours.toFixed(1)} 小时`));
+        if (ageHours > 24 * 7) {
+            console.log(chalk.yellow('   ⚠️ 登录状态可能已过期，建议重新登录'));
+        }
+    }
+    else {
+        console.log(chalk.yellow('⚠️ Google 登录状态: 未登录'));
+        console.log(chalk.gray('   运行 gemini-client login 进行登录'));
+    }
+    // 检查配置
+    const configPath = path.join(dataDir, 'config.json');
+    if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        console.log(chalk.gray('\n配置:'));
+        console.log(chalk.gray(`   服务器: ${config.server || '未设置'}`));
+        console.log(chalk.gray(`   Token: ${config.token || '未设置'}`));
+    }
+    console.log(chalk.gray('─'.repeat(50)));
+}

package/dist/utils/helpers.js

@@ -0,0 +1,57 @@
+import fs from 'fs';
+import path from 'path';
+/**
+ * 生成客户端 Token
+ * 格式: gp_client_YYYY_MM_DD_HH_mm_ss
+ */
+export function generateToken() {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hour = String(now.getHours()).padStart(2, '0');
+    const minute = String(now.getMinutes()).padStart(2, '0');
+    const second = String(now.getSeconds()).padStart(2, '0');
+    return `gp_client_${year}_${month}_${day}_${hour}_${minute}_${second}`;
+}
+/**
+ * 确保数据目录存在
+ */
+export function ensureDataDir(dataDir) {
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+}
+/**
+ * 保存配置
+ */
+export function saveConfig(dataDir, config) {
+    const configPath = path.join(dataDir, 'config.json');
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+/**
+ * 加载配置
+ */
+export function loadConfig(dataDir) {
+    const configPath = path.join(dataDir, 'config.json');
+    if (fs.existsSync(configPath)) {
+        return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    }
+    return null;
+}
+/**
+ * 格式化运行时间
+ */
+export function formatUptime(startTime) {
+    const elapsed = Date.now() - startTime;
+    const seconds = Math.floor(elapsed / 1000) % 60;
+    const minutes = Math.floor(elapsed / (1000 * 60)) % 60;
+    const hours = Math.floor(elapsed / (1000 * 60 * 60));
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`;
+}
+/**
+ * 延迟函数
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "gemini-proxy-client",
+  "version": "1.0.0",
+  "description": "Gemini Proxy Build App 客户端 - 使用 Camoufox 自动保持连接",
+  "main": "dist/index.js",
+  "bin": {
+    "gemini-client": "./dist/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/cli.js",
+    "dev": "tsx src/cli.ts",
+    "postinstall": "camoufox-js fetch || echo 'Camoufox download failed. Run: npx camoufox-js fetch'",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["gemini", "proxy", "build-app", "camoufox", "automation", "google-ai-studio"],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "dependencies": {
+    "camoufox-js": "^0.8.5",
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "dotenv": "^16.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}