Spaces:

zhepama
/

aistudio2api

Running

App Files Files Community

github-actions[bot] commited on Jul 6

Commit

e513b2a

1 Parent(s): 91d2485

Update from GitHub Actions

Browse files

Files changed (22) hide show

.env.example +19 -0
.gitattributes +2 -0
Dockerfile +66 -0
package-lock.json +147 -0
package.json +29 -0
public/index.html +331 -0
src/config.js +133 -0
src/login.js +86 -0
src/middlewares/auth.js +44 -0
src/middlewares/cors.js +41 -0
src/routes/chat-completions.js +53 -0
src/routes/health.js +23 -0
src/routes/models.js +75 -0
src/utils/ai-studio-injector.js +266 -0
src/utils/ai-studio-processor.js +264 -0
src/utils/browser.js +949 -0
src/utils/common-utils.js +104 -0
src/utils/logger.js +90 -0
src/utils/page-pool-monitor.js +57 -0
src/utils/response-parser.js +189 -0
src/utils/validation.js +41 -0
src/web-server.js +129 -0

.env.example ADDED Viewed

	@@ -0,0 +1,19 @@

+# 服务器配置
+PORT=3000
+NODE_ENV=development
+# 浏览器配置
+HEADLESS=false
+USER_AGENT=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36
+# AI Studio 配置
+AI_STUDIO_URL=https://aistudio.google.com/
+PAGE_TIMEOUT=30000
+DEFAULT_MODEL=gemini-pro
+# CORS 配置
+CORS_ORIGIN=*
+# API 认证配置
+# 设置一个强密码作为API访问令牌
+API_TOKEN=your_secret_api_token_here

.gitattributes CHANGED Viewed

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text

 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text

Dockerfile ADDED Viewed

	@@ -0,0 +1,66 @@

+# 使用官方 Node.js 运行时作为基础镜像
+FROM node:23-alpine
+# 设置工作目录
+WORKDIR /app
+# 安装系统依赖
+RUN apk add --no-cache \
+    # 基本构建工具
+    python3 \
+    make \
+    g++ \
+    # Playwright 依赖
+    chromium \
+    nss \
+    freetype \
+    freetype-dev \
+    harfbuzz \
+    ca-certificates \
+    ttf-freefont \
+    # 其他依赖
+    gcompat
+# 设置 Playwright 的环境变量
+ENV PLAYWRIGHT_BROWSERS_PATH=/usr/bin
+ENV PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1
+ENV PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH=/usr/bin/chromium-browser
+ENV PLAYWRIGHT_SKIP_BROWSER_VALIDATION=1
+# 复制 package.json 和 package-lock.json（如果存在）
+COPY package*.json ./
+# 复制应用代码
+COPY src/ ./src/
+COPY public/ ./public/
+# 复制 cookies.json 文件（如果存在）
+# 使用通配符语法，如果文件不存在则跳过，不会报错
+COPY cookies.json* ./
+# 安装依赖
+RUN npm ci --only=production
+# 设置非 root 用户（安全最佳实践）
+RUN addgroup -g 1001 -S nodejs && \
+    adduser -S nodejs -u 1001
+# 更改文件所有权
+# 创建 screenshots 和 logs 目录，并设置正确的权限
+RUN mkdir -p /app/screenshots && \
+    mkdir -p /app/logs && \
+    chown -R nodejs:nodejs /app && \
+    chmod -R 777 /app/screenshots && \
+    chmod -R 777 /app/logs
+USER nodejs
+# 暴露端口
+EXPOSE 7860
+# 设置环境变量
+ENV NODE_ENV=production
+ENV PORT=7860
+# 启动应用
+CMD ["npm", "start"]

package-lock.json ADDED Viewed

	@@ -0,0 +1,147 @@

+{
+  "name": "aistudio2api",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "aistudio2api",
+      "version": "1.0.0",
+      "license": "MIT",
+      "dependencies": {
+        "dotenv": "^17.0.1",
+        "h3": "^2.0.0-beta.1",
+        "playwright": "^1.53.2"
+      },
+      "devDependencies": {
+        "@types/node": "^20.10.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.4",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-20.19.4.tgz",
+      "integrity": "sha512-OP+We5WV8Xnbuvw0zC2m4qfB/BJvjyCwtNjhHdJxV1639SGSKrLmJkc3fMnp2Qy8nJyHp8RO6umxELN/dS1/EA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/cookie-es": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/cookie-es/-/cookie-es-2.0.0.tgz",
+      "integrity": "sha512-RAj4E421UYRgqokKUmotqAwuplYw15qtdXfY+hGzgCJ/MBjCVZcSoHK/kH9kocfjRjcDME7IiDWR/1WX1TM2Pg==",
+      "license": "MIT"
+    },
+    "node_modules/dotenv": {
+      "version": "17.0.1",
+      "resolved": "https://registry.npmmirror.com/dotenv/-/dotenv-17.0.1.tgz",
+      "integrity": "sha512-GLjkduuAL7IMJg/ZnOPm9AnWKJ82mSE2tzXLaJ/6hD6DhwGfZaXG77oB8qbReyiczNxnbxQKyh0OE5mXq0bAHA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/fetchdts": {
+      "version": "0.1.5",
+      "resolved": "https://registry.npmmirror.com/fetchdts/-/fetchdts-0.1.5.tgz",
+      "integrity": "sha512-GCxyHdCCUm56atms+sIjOsAENvhebk3HAM1CfzgKCgMRjPUylpkkPmNknsaXe1gDRqM3cJbMhpkXMhCzXSE+Jg==",
+      "license": "MIT"
+    },
+    "node_modules/fsevents": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmmirror.com/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+      }
+    },
+    "node_modules/h3": {
+      "version": "2.0.0-beta.1",
+      "resolved": "https://registry.npmmirror.com/h3/-/h3-2.0.0-beta.1.tgz",
+      "integrity": "sha512-sAhBVWbCi2AzApSLZhk41Rmiz+gjPhoAEqjJ96VH3OwyS3Co2kHVx3FZk0/OCCrzKWzYx3Pwf5WbEKDQ2plifg==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie-es": "^2.0.0",
+        "fetchdts": "^0.1.5",
+        "rou3": "^0.7.3",
+        "srvx": "^0.8.1"
+      },
+      "engines": {
+        "node": ">=20.11.1"
+      },
+      "peerDependencies": {
+        "crossws": "^0.4.1"
+      },
+      "peerDependenciesMeta": {
+        "crossws": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/playwright": {
+      "version": "1.53.2",
+      "resolved": "https://registry.npmmirror.com/playwright/-/playwright-1.53.2.tgz",
+      "integrity": "sha512-6K/qQxVFuVQhRQhFsVZ9fGeatxirtrpPgxzBYWyZLEXJzqYwuL4fuNmfOfD5et1tJE4GScKyPNeLhZeRwuTU3A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "playwright-core": "1.53.2"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "optionalDependencies": {
+        "fsevents": "2.3.2"
+      }
+    },
+    "node_modules/playwright-core": {
+      "version": "1.53.2",
+      "resolved": "https://registry.npmmirror.com/playwright-core/-/playwright-core-1.53.2.tgz",
+      "integrity": "sha512-ox/OytMy+2w1jcYEYlOo1Hhp8hZkLCximMTUTMBXjGUA1KoFfiSZ+DU+3a739jsPY0yoKH2TFy9S2fsJas8yAw==",
+      "license": "Apache-2.0",
+      "bin": {
+        "playwright-core": "cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/rou3": {
+      "version": "0.7.3",
+      "resolved": "https://registry.npmmirror.com/rou3/-/rou3-0.7.3.tgz",
+      "integrity": "sha512-KKenF/hB2iIhS1ohj226LT+/8uKCBpSMqeS4V1UPN9vad99uLoyIhrULRRB1skaB40LQHcBlSsAi3sT8MaoDDQ==",
+      "license": "MIT"
+    },
+    "node_modules/srvx": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmmirror.com/srvx/-/srvx-0.8.2.tgz",
+      "integrity": "sha512-anC1+7B6tryHQd4lFVSDZIfZ1QwJwqm5h1iveKwC1E40PA8nOD50hEt7+AlUoGc9jW3OdmztWBqf4yHCdCPdRQ==",
+      "license": "MIT",
+      "dependencies": {
+        "cookie-es": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=20.16.0"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmmirror.com/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package.json ADDED Viewed

	@@ -0,0 +1,29 @@

+{
+  "name": "aistudio2api",
+  "version": "1.0.0",
+  "description": "Google AI Studio to OpenAI API proxy using H3 and Playwright",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "login": "node src/login.js",
+    "dev": "node --watch src/web-server.js",
+    "start": "node src/web-server.js"
+  },
+  "keywords": [
+    "h3",
+    "playwright",
+    "openai",
+    "proxy",
+    "google-ai-studio"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "^17.0.1",
+    "h3": "^2.0.0-beta.1",
+    "playwright": "^1.53.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0"
+  }
+}

public/index.html ADDED Viewed

	@@ -0,0 +1,331 @@

+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AI Studio 2 API - 管理面板</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            color: #333;
+        }
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        .header {
+            text-align: center;
+            margin-bottom: 40px;
+            color: white;
+        }
+        .header h1 {
+            font-size: 2.5rem;
+            margin-bottom: 10px;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+        }
+        .header p {
+            font-size: 1.2rem;
+            opacity: 0.9;
+        }
+        .main-content {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 30px;
+            margin-bottom: 40px;
+        }
+        .card {
+            background: white;
+            border-radius: 15px;
+            padding: 25px;
+            box-shadow: 0 10px 30px rgba(0,0,0,0.1);
+            transition: transform 0.3s ease;
+        }
+        .card:hover {
+            transform: translateY(-5px);
+        }
+        .card h2 {
+            color: #4a5568;
+            margin-bottom: 20px;
+            font-size: 1.5rem;
+            border-bottom: 2px solid #e2e8f0;
+            padding-bottom: 10px;
+        }
+        .screenshot-container {
+            text-align: center;
+        }
+        .screenshot {
+            max-width: 100%;
+            height: auto;
+            border-radius: 10px;
+            box-shadow: 0 5px 15px rgba(0,0,0,0.2);
+            margin-bottom: 15px;
+        }
+        .config-item {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 12px 0;
+            border-bottom: 1px solid #e2e8f0;
+        }
+        .config-item:last-child {
+            border-bottom: none;
+        }
+        .config-label {
+            font-weight: 600;
+            color: #4a5568;
+        }
+        .config-value {
+            color: #2d3748;
+            font-family: 'Courier New', monospace;
+            background: #f7fafc;
+            padding: 4px 8px;
+            border-radius: 4px;
+            font-size: 0.9rem;
+        }
+        .status-indicator {
+            display: inline-block;
+            width: 10px;
+            height: 10px;
+            border-radius: 50%;
+            margin-right: 8px;
+        }
+        .status-online {
+            background-color: #48bb78;
+            animation: pulse 2s infinite;
+        }
+        .status-offline {
+            background-color: #f56565;
+        }
+        @keyframes pulse {
+            0% { opacity: 1; }
+            50% { opacity: 0.5; }
+            100% { opacity: 1; }
+        }
+        .api-endpoints {
+            grid-column: 1 / -1;
+        }
+        .endpoint-list {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+            gap: 15px;
+        }
+        .endpoint {
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 8px;
+            border-left: 4px solid #667eea;
+        }
+        .endpoint-method {
+            font-weight: bold;
+            color: #667eea;
+            margin-right: 10px;
+        }
+        .endpoint-url {
+            font-family: 'Courier New', monospace;
+            color: #2d3748;
+        }
+        .endpoint-desc {
+            font-size: 0.9rem;
+            color: #718096;
+            margin-top: 5px;
+        }
+        .footer {
+            text-align: center;
+            color: white;
+            opacity: 0.8;
+            margin-top: 40px;
+        }
+        @media (max-width: 768px) {
+            .main-content {
+                grid-template-columns: 1fr;
+            }
+            .header h1 {
+                font-size: 2rem;
+            }
+            .container {
+                padding: 15px;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🤖 AI Studio 2 API</h1>
+            <p>Google AI Studio 到 OpenAI API 格式的转换服务</p>
+        </div>
+        <div class="main-content">
+            <div class="card screenshot-container">
+                <h2>📸 AI Studio 状态截图</h2>
+                <img src="/screenshots/aistudio-startup.png" alt="AI Studio 启动截图" class="screenshot" id="screenshot">
+                <p style="color: #718096; font-size: 0.9rem;">最后更新: <span id="lastUpdate">加载中...</span></p>
+            </div>
+            <div class="card">
+                <h2>⚙️ 基础配置</h2>
+                <div class="config-item">
+                    <span class="config-label">服务状态</span>
+                    <span class="config-value">
+                        <span class="status-indicator status-online"></span>
+                        运行中
+                    </span>
+                </div>
+                <div class="config-item">
+                    <span class="config-label">服务端口</span>
+                    <span class="config-value" id="serverPort">加载中...</span>
+                </div>
+                <div class="config-item">
+                    <span class="config-label">AI Studio URL</span>
+                    <span class="config-value" id="aiStudioUrl">加载中...</span>
+                </div>
+                <div class="config-item">
+                    <span class="config-label">默认模型</span>
+                    <span class="config-value" id="defaultModel">加载中...</span>
+                </div>
+                <div class="config-item">
+                    <span class="config-label">浏览器模式</span>
+                    <span class="config-value" id="browserMode">加载中...</span>
+                </div>
+                <div class="config-item">
+                    <span class="config-label">页面超时</span>
+                    <span class="config-value" id="pageTimeout">加载中...</span>
+                </div>
+            </div>
+            <div class="card api-endpoints">
+                <h2>🔗 API 端点</h2>
+                <div class="endpoint-list">
+                    <div class="endpoint">
+                        <div>
+                            <span class="endpoint-method">GET</span>
+                            <span class="endpoint-url">/health</span>
+                        </div>
+                        <div class="endpoint-desc">健康检查端点</div>
+                    </div>
+                    <div class="endpoint">
+                        <div>
+                            <span class="endpoint-method">GET</span>
+                            <span class="endpoint-url">/v1/models</span>
+                        </div>
+                        <div class="endpoint-desc">获取可用模型列表</div>
+                    </div>
+                    <div class="endpoint">
+                        <div>
+                            <span class="endpoint-method">GET</span>
+                            <span class="endpoint-url">/v1/models/{model}</span>
+                        </div>
+                        <div class="endpoint-desc">获取特定模型信息</div>
+                    </div>
+                    <div class="endpoint">
+                        <div>
+                            <span class="endpoint-method">POST</span>
+                            <span class="endpoint-url">/v1/chat/completions</span>
+                        </div>
+                        <div class="endpoint-desc">聊天完成 API (兼容 OpenAI 格式)</div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        <div class="footer">
+            <p>© 2024 AI Studio 2 API - 基于 H3 v2 构建</p>
+        </div>
+    </div>
+    <script>
+        // 获取配置信息
+        async function loadConfig() {
+            try {
+                // 从健康检查端点获取基本信息
+                const healthResponse = await fetch('/health');
+                const healthData = await healthResponse.json();
+                // 更新页面信息
+                document.getElementById('serverPort').textContent = window.location.port || '7860';
+                document.getElementById('aiStudioUrl').textContent = 'https://aistudio.google.com/prompts/new_chat';
+                document.getElementById('defaultModel').textContent = 'gemini-pro';
+                document.getElementById('browserMode').textContent = 'Headless';
+                document.getElementById('pageTimeout').textContent = '30000ms';
+                // 更新截图时间戳
+                updateScreenshotTimestamp();
+            } catch (error) {
+                console.error('加载配置失败:', error);
+                // 设置默认值
+                document.getElementById('serverPort').textContent = window.location.port || '7860';
+                document.getElementById('aiStudioUrl').textContent = 'https://aistudio.google.com/prompts/new_chat';
+                document.getElementById('defaultModel').textContent = 'gemini-pro';
+                document.getElementById('browserMode').textContent = 'Headless';
+                document.getElementById('pageTimeout').textContent = '30000ms';
+            }
+        }
+        // 更新截图时间戳
+        function updateScreenshotTimestamp() {
+            const now = new Date();
+            const timestamp = now.toLocaleString('zh-CN', {
+                year: 'numeric',
+                month: '2-digit',
+                day: '2-digit',
+                hour: '2-digit',
+                minute: '2-digit',
+                second: '2-digit'
+            });
+            document.getElementById('lastUpdate').textContent = timestamp;
+        }
+        // 处理截图加载错误
+        document.getElementById('screenshot').onerror = function() {
+            this.src = 'data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAwIiBoZWlnaHQ9IjMwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSIjZjBmMGYwIi8+PHRleHQgeD0iNTAlIiB5PSI1MCUiIGZvbnQtZmFtaWx5PSJBcmlhbCwgc2Fucy1zZXJpZiIgZm9udC1zaXplPSIxOCIgZmlsbD0iIzk5OTk5OSIgdGV4dC1hbmNob3I9Im1pZGRsZSIgZHk9Ii4zZW0iPuaIquWbvuS4jeWPr+eUqDwvdGV4dD48L3N2Zz4=';
+            this.alt = '截图不可用';
+        };
+        // 页面加载完成后执行
+        document.addEventListener('DOMContentLoaded', function() {
+            loadConfig();
+            // 每30秒刷新一次截图时间戳
+            setInterval(updateScreenshotTimestamp, 30000);
+        });
+    </script>
+</body>
+</html>

src/config.js ADDED Viewed

	@@ -0,0 +1,133 @@

+import dotenv from 'dotenv';
+// 加载 .env 文件中的环境变量
+dotenv.config();
+/**
+ * @typedef {Object} AppConfig
+ * @property {Object} server - 服务器配置
+ * @property {number} server.port - 监听端口
+ * @property {string} server.host - 监听主机
+ * @property {Object} browser - Playwright 浏览器配置
+ * @property {boolean} browser.headless - 是否以无头模式运行
+ * @property {number} browser.timeout - 浏览器操作的全局超时时间
+ * @property {string|undefined} browser.executablePath - Chromium 可执行文件路径
+ * @property {string[]} browser.args - 浏览器启动参数
+ * @property {string} browser.userAgent - 浏览器 User-Agent
+ * @property {string} cookieFile - Cookie 存储文件路径
+ * @property {string|undefined} cookiesFromEnv - 从环境变量读取的 Cookie 字符串
+ * @property {string} screenshotDir - 截图保存目录
+ * @property {Object} aiStudio - AI Studio 相关配置
+ * @property {string} aiStudio.url - AI Studio 的目标 URL
+ * @property {number} aiStudio.responseTimeout - 等待 AI 响应的超时时间
+ * @property {number} aiStudio.pageTimeout - 页面加载的超时时间
+ * @property {Object} api - API 相关配置
+ * @property {string} api.defaultModel - 默认使用的模型 ID
+ * @property {number} api.maxTokens - 支持的最大令牌数 (此为示例，实际限制在网页端)
+ * @property {number} api.temperature - 默认温度
+ * @property {string|undefined} api.token - API 访问令牌
+ * @property {Object.<string, Object>} models - 支持的模型列表
+ * @property {Object} debug - 调试配置
+ * @property {boolean} debug.logRequests - 是否记录请求体
+ * @property {boolean} debug.logResponses - 是否记录响应体
+ * @property {boolean} debug.saveScreenshots - 是否在出错时保存截图
+ */
+/** @type {AppConfig} */
+const config = {
+  // 服务器配置
+  server: {
+    port: parseInt(process.env.PORT || '3096', 10),
+    host: process.env.HOST || 'localhost'
+  },
+  // Playwright 浏览器配置
+  browser: {
+    headless: (process.env.HEADLESS || 'true').toLowerCase() !== 'false',
+    timeout: parseInt(process.env.TIMEOUT || '30000', 10),
+    executablePath: process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH,
+    args: [
+      '--disable-blink-features=AutomationControlled', // 防止被检测为自动化工具
+      '--no-sandbox',
+      '--disable-dev-shm-usage',
+      '--disable-infobars',
+      '--disable-extensions',
+    ],
+    userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+  },
+  // Cookie 配置
+  cookieFile: './cookies.json',
+  cookiesFromEnv: process.env.COOKIES,
+  // 截图目录
+  screenshotDir: './screenshots',
+  // Google AI Studio 配置
+  aiStudio: {
+    url: process.env.AI_STUDIO_URL || 'https://aistudio.google.com/prompts/new_chat',
+    responseTimeout: parseInt(process.env.RESPONSE_TIMEOUT || '600000', 10), // 10分钟
+    pageTimeout: parseInt(process.env.PAGE_TIMEOUT || '30000', 10) // 30秒
+  },
+  // API 兼容层配置
+  api: {
+    defaultModel: process.env.DEFAULT_MODEL || 'gemini-pro',
+    maxTokens: 65536, // 理论值，实际由网页决定
+    temperature: 1,
+    token: process.env.API_TOKEN
+  },
+  // 可用模型列表 (遵循 OpenAI API 格式)
+  models: {
+    'gemini-2.5-pro': {
+      displayName: 'Gemini 2.5 Pro',
+      id: 'gemini-2.5-pro',
+      object: 'model',
+      created: 1704067200, // 2024-01-01
+      owned_by: 'google',
+      permission: [],
+      root: 'gemini-2.5-pro',
+      parent: null
+    },
+    'gemini-2.5-flash': {
+      displayName: 'Gemini 2.5 Flash',
+      id: 'gemini-2.5-flash',
+      object: 'model',
+      created: 1704067200,
+      owned_by: 'google',
+      permission: [],
+      root: 'gemini-2.5-flash',
+      parent: null
+    },
+    'gemini-pro': {
+      displayName: 'Gemini Pro',
+      id: 'gemini-pro',
+      object: 'model',
+      created: 1701388800, // 2023-12-01
+      owned_by: 'google',
+      permission: [],
+      root: 'gemini-pro',
+      parent: null
+    },
+    'gemini-flash': {
+      displayName: 'Gemini Flash',
+      id: 'gemini-flash',
+      object: 'model',
+      created: 1701388800,
+      owned_by: 'google',
+      permission: [],
+      root: 'gemini-flash',
+      parent: null
+    }
+  },
+  // 调试选项
+  debug: {
+    logRequests: process.env.DEBUG_REQUESTS === 'true',
+    logResponses: process.env.DEBUG_RESPONSES === 'true',
+    saveScreenshots: process.env.SAVE_SCREENSHOTS === 'true'
+  }
+};
+export default config;

src/login.js ADDED Viewed

	@@ -0,0 +1,86 @@

+import { chromium } from 'playwright';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import config from './config.js';
+import { loadCookies, waitForUserInput } from './utils/common-utils.js';
+import { info, error } from './utils/logger.js';
+import { handleWelcomeModal } from './utils/browser.js';
+/**
+ * 启动一个非无头浏览器，引导用户手动登录 Google AI Studio 并保存 Cookie。
+ */
+async function login() {
+    info('启动浏览器以进行手动登录...');
+    const browser = await chromium.launch({
+        headless: false, // 必须为 false 以便用户交互
+        timeout: config.browser.timeout,
+        args: config.browser.args
+    });
+    const context = await browser.newContext({
+        userAgent: config.browser.userAgent
+    });
+    // 尝试加载现有 Cookie
+    const existingCookies = loadCookies(config.cookieFile, config.cookiesFromEnv);
+    if (existingCookies.length > 0) {
+        await context.addCookies(existingCookies);
+        info(`已加载 ${existingCookies.length} 个现有 Cookie。`);
+    }
+    const page = await context.newPage();
+    try {
+        info(`导航至 Google AI Studio: ${config.aiStudio.url}`);
+        await page.goto(config.aiStudio.url, { waitUntil: 'networkidle' });
+        await page.waitForTimeout(3000); // 等待页面稳定
+        // 尝试处理可能出现的欢迎弹窗
+        await handleWelcomeModal(page);
+        info('当前页面 URL:', page.url());
+        info('页面标题:', await page.title());
+        info('请在浏览器窗口中完成登录操作。');
+        info('登录成功并跳转到 AI Studio 主界面后，请返回此处按 Enter 键继续...');
+        await waitForUserInput();
+        info('用户确认登录完成，正在保存 Cookie...');
+        // 再次导航以确保在正确的页面上
+        try {
+            await page.goto(config.aiStudio.url, { waitUntil: 'load', timeout: 15000 });
+            await page.waitForTimeout(5000); // 等待页面完全加载
+        } catch (err) {
+            info('导航到主页时出现小问题，但这通常不影响 Cookie 保存。');
+        }
+        const newCookies = await context.cookies();
+        if (newCookies.length > 0) {
+            fs.writeFileSync(config.cookieFile, JSON.stringify(newCookies, null, 2));
+            info(`成功将 ${newCookies.length} 个 Cookie 保存到 ${config.cookieFile}`);
+            info('主要 Cookie 名称:');
+            newCookies.slice(0, 5).forEach(cookie => {
+                info(`  - ${cookie.name} (域: ${cookie.domain})`);
+            });
+        } else {
+            error('未能获取到任何 Cookie，请确保已成功登录。');
+        }
+    } catch (err) {
+        error('登录过程中发生严重错误:', err);
+    } finally {
+        info('关闭浏览器。');
+        await browser.close();
+    }
+}
+// 使该文件可以直接通过 `node login.js` 运行
+const __filename = fileURLToPath(import.meta.url);
+const scriptPath = path.resolve(process.argv[1]);
+if (path.resolve(__filename) === scriptPath) {
+    login().catch(err => error('执行登录脚本失败:', err));
+}
+export default login;

src/middlewares/auth.js ADDED Viewed

	@@ -0,0 +1,44 @@

+import { createError } from 'h3';
+import config from '../config.js';
+/**
+ * API Token 认证中间件。
+ * 验证请求头中的 `Authorization: Bearer <token>` 是否与配置的 API_TOKEN 匹配。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ * @throws {Error} 如果认证失败，则抛出 H3 错误。
+ */
+export function apiTokenAuth(event) {
+  // 如果未配置 API_TOKEN，则跳过认证
+  if (!config.api.token) {
+    // 在开发环境中，这可能是预期的行为，但在生产中应发出警告
+    if (process.env.NODE_ENV === 'production') {
+        console.warn('警告: API_TOKEN 未在生产环境中配置，API 对外开放！');
+    }
+    return;
+  }
+  const authHeader = event.node.req.headers.authorization;
+  if (!authHeader) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: 'Unauthorized: Missing Authorization header.'
+    });
+  }
+  const [authType, token] = authHeader.split(' ');
+  if (authType !== 'Bearer' || !token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: 'Unauthorized: Invalid Authorization header format. Expected: Bearer <token>.'
+    });
+  }
+  if (token !== config.api.token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: 'Unauthorized: Invalid API token.'
+    });
+  }
+}

src/middlewares/cors.js ADDED Viewed

	@@ -0,0 +1,41 @@

+/**
+ * CORS (跨域资源共享) 中间件。
+ * 为所有请求设置通用的 CORS 响应头。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ * @returns {Response|void} 如果是 OPTIONS 请求，则返回一个 204 响应。
+ */
+export function corsMiddleware(event) {
+  const headers = event.node.res.getHeaders();
+  if (!headers['access-control-allow-origin']) {
+    event.node.res.setHeader('Access-Control-Allow-Origin', process.env.CORS_ORIGIN || '*');
+  }
+  if (!headers['access-control-allow-methods']) {
+    event.node.res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+  }
+  if (!headers['access-control-allow-headers']) {
+    event.node.res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+  }
+  if (!headers['access-control-max-age']) {
+    event.node.res.setHeader('Access-Control-Max-Age', '86400'); // 24 hours
+  }
+  // 处理预检请求 (OPTIONS)
+  if (event.node.req.method === 'OPTIONS') {
+    event.node.res.statusCode = 204;
+    return event.node.res.end();
+  }
+}
+/**
+ * 为流式响应 (Server-Sent Events) 设置特定的响应头。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ */
+export function setStreamHeaders(event) {
+  event.node.res.setHeader('Content-Type', 'text/event-stream');
+  event.node.res.setHeader('Cache-Control', 'no-cache');
+  event.node.res.setHeader('Connection', 'keep-alive');
+  // CORS 头也需要为流式响应设置
+  event.node.res.setHeader('Access-Control-Allow-Origin', process.env.CORS_ORIGIN || '*');
+  event.node.res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+}

src/routes/chat-completions.js ADDED Viewed

	@@ -0,0 +1,53 @@

+import { readBody, createError } from 'h3';
+import { validateChatCompletionRequest } from '../utils/validation.js';
+import { setStreamHeaders } from '../middlewares/cors.js';
+import { apiTokenAuth } from '../middlewares/auth.js';
+import { processAIStudioRequest, processAIStudioRequestSync } from '../utils/ai-studio-processor.js';
+/**
+ * 处理 `/v1/chat/completions` 的 POST 请求。
+ * 支持流式和非流式响应。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ * @returns {Promise<object|ReadableStream>} OpenAI 格式的响应对象或 SSE 流。
+ */
+export async function chatCompletionsHandler(event) {
+  try {
+    // 1. 认证
+    apiTokenAuth(event);
+    // 2. 读取和验证请求体
+    const body = await readBody(event);
+    const { prompt, stream, model, temperature } = validateChatCompletionRequest(body);
+    // 3. 根据 stream 参数决定处理方式
+    if (stream) {
+      // 流式响应
+      setStreamHeaders(event);
+      const stream = new ReadableStream({
+        start(controller) {
+          // 将请求处理委托给 AI Studio 处理器
+          processAIStudioRequest(prompt, controller, { model, temperature });
+        }
+      });
+      return stream;
+    } else {
+      // 非流式响应
+      const result = await processAIStudioRequestSync(prompt, { model, temperature });
+      return result;
+    }
+  } catch (error) {
+    console.error('处理聊天请求时出错:', error);
+    // 重新抛出 H3 错误或将标准错误包装成 H3 错误
+    if (error.statusCode) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: error.message || 'An internal server error occurred.'
+    });
+  }
+}

src/routes/health.js ADDED Viewed

	@@ -0,0 +1,23 @@

+import { getPagePoolStatus } from '../utils/browser.js';
+/**
+ * 处理 `/health` 的 GET 请求，提供服务健康状态。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ * @returns {object} 包含服务状态和页面池信息的健康报告。
+ */
+export function healthHandler(event) {
+  const pagePoolStatus = getPagePoolStatus();
+  const utilization = pagePoolStatus.total > 0
+    ? Math.round((pagePoolStatus.busy / pagePoolStatus.total) * 100)
+    : 0;
+  return {
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    version: process.env.npm_package_version || '1.0.0',
+    pagePool: {
+      ...pagePoolStatus,
+      utilization: `${utilization}%`
+    }
+  };
+}

src/routes/models.js ADDED Viewed

	@@ -0,0 +1,75 @@

+import { createError } from 'h3';
+import config from '../config.js';
+/**
+ * 处理 `/v1/models` 的 GET 请求，返回所有可用模型的列表。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ * @returns {Promise<object>} OpenAI 格式的模型列表响应。
+ */
+export async function modelsHandler(event) {
+  try {
+    const models = Object.values(config.models).map(model => ({
+      id: model.id,
+      object: model.object,
+      created: model.created,
+      owned_by: model.owned_by,
+      permission: model.permission,
+      root: model.root,
+      parent: model.parent
+    }));
+    // 按创建时间降序排序
+    models.sort((a, b) => b.created - a.created);
+    return {
+      object: 'list',
+      data: models
+    };
+  } catch (error) {
+    console.error('获取模型列表时出错:', error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Failed to retrieve models list.'
+    });
+  }
+}
+/**
+ * 处理 `/v1/models/:model` 的 GET 请求，返回单个模型的详细信息。
+ * @param {import('h3').H3Event} event - H3 事件对象。
+ * @returns {Promise<object>} OpenAI 格式的单个模型信息。
+ */
+export async function modelHandler(event) {
+  try {
+    const modelId = event.context.params?.model;
+    if (!modelId) {
+      throw createError({ statusCode: 400, statusMessage: 'Model ID is required.' });
+    }
+    const model = config.models[modelId];
+    if (!model) {
+      throw createError({ statusCode: 404, statusMessage: `Model '${modelId}' not found.` });
+    }
+    return {
+      id: model.id,
+      object: model.object,
+      created: model.created,
+      owned_by: model.owned_by,
+      permission: model.permission,
+      root: model.root,
+      parent: model.parent
+    };
+  } catch (error) {
+    console.error(`获取模型 '${event.context.params?.model}' 信息时出错:`, error);
+    if (error.statusCode) {
+      throw error;
+    }
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Failed to retrieve model information.'
+    });
+  }
+}

src/utils/ai-studio-injector.js ADDED Viewed

	@@ -0,0 +1,266 @@

+import { handleWelcomeModal, simulateHumanRandomClicks, simulateHumanBehavior } from './browser.js';
+import config from '../config.js';
+/**
+ * 封装了与 Google AI Studio 页面交互的所有操作，
+ * 如输入文本、点击按钮、设置模型和温度等。
+ */
+export class AIStudioInjector {
+  /**
+   * @param {import('playwright').Page} page Playwright 页面对象
+   * @param {object} [options={}] 配置选项
+   * @param {boolean} [options.enableHumanSimulation=true] 是否启用人类行为模拟
+   */
+  constructor(page, options = {}) {
+    this.page = page;
+    this.options = {
+      enableHumanSimulation: true,
+      ...options
+    };
+    this.modelMapping = Object.fromEntries(
+      Object.entries(config.models).map(([key, model]) => [key, model.displayName])
+    );
+  }
+  /**
+   * 等待页面主要内容加载完成并处理欢迎弹窗。
+   * @returns {Promise<boolean>} 是否加载成功。
+   */
+  async waitForPageLoad() {
+    try {
+      await this.page.waitForSelector('body', { timeout: 15000 });
+      await handleWelcomeModal(this.page);
+      return true;
+    } catch (error) {
+      console.error('页面加载超时或失败:', error);
+      return false;
+    }
+  }
+  /**
+   * 查找页面上的主输入框。
+   * 增强了选择器和等待逻辑，以提高在动态加载页面上的成功率。
+   * @returns {Promise<import('playwright').Locator|null>} 输入框的定位器。
+   */
+  async findInputElement() {
+    // 首先，等待一个稳定的父容器出现，这表明输入区域已开始渲染。
+    // 这可以大大减少因时序问题导致的查找失败。
+    try {
+      await this.page.waitForSelector('footer ms-prompt-input-wrapper', { timeout: 10000 });
+      console.log('输入框的父容器已加载。');
+    } catch (error) {
+      console.warn('等待输入框父容器超时，将继续尝试查找...');
+    }
+    // 定义一组从最具体到最通用的选择器
+    const selectors = [
+      // --- 新增的、更具体的选择器 (基于您提供的HTML) ---
+      'ms-prompt-input-wrapper textarea[aria-label*="prompt"]', // 结合自定义组件和aria-label
+      'textarea[placeholder="Start typing a prompt"]', // 精确匹配placeholder
+      'textarea[aria-label="Start typing a prompt"]',   // 精确匹配aria-label
+      'footer textarea', // 任何在footer里的textarea
+      // --- 原有的选择器作为后备 ---
+      'textarea[placeholder*="prompt"]',
+      'textarea[aria-label*="prompt"]',
+      'div[contenteditable="true"]', // 某些情况下可能是div
+      'textarea', // 最通用的后备
+    ];
+    for (const selector of selectors) {
+      try {
+        const locator = this.page.locator(selector);
+        const count = await locator.count();
+        if (count > 0) {
+          console.log(`选择器 "${selector}" 找到了 ${count} 个元素。正在检查可见性和可用性...`);
+          // 遍历找到的元素，返回第一个可见且可用的
+          for (let i = 0; i < count; i++) {
+            const element = locator.nth(i);
+            if (await element.isVisible() && await element.isEnabled()) {
+              console.log(`成功找到可用输入框: ${selector} (索引 ${i})`);
+              return element;
+            }
+          }
+          console.log(`选择器 "${selector}" 找到的元素均不可见或不可用。`);
+        }
+      } catch (error) {
+        // 忽略单个选择器的错误，继续尝试下一个
+        console.warn(`使用选择器 "${selector}" 查找时出错: ${error.message}`);
+      }
+    }
+    console.error('关键错误: 尝试了所有选择器后，仍未找到任何可用的输入元素。');
+    // 在失败时保存截图以供调试
+    if (config.debug.saveScreenshots) {
+        const { saveScreenshot } = await import('./common-utils.js');
+        await saveScreenshot(this.page, config.screenshotDir, 'find-input-failed');
+    }
+    return null;
+  }
+  /**
+   * 查找页面上的发送/运行按钮。
+   * @returns {Promise<import('playwright').Locator|null>} 按钮的定位器。
+   */
+  async findSendButton() {
+    const selectors = [
+      'button[aria-label="Run"]',
+      'button.run-button',
+      'button[aria-label*="Send"]',
+      'button[data-testid*="send"]',
+    ];
+    for (const selector of selectors) {
+      const locator = this.page.locator(selector);
+      if (await locator.count() > 0) {
+        const button = locator.first();
+        const isDisabled = await button.isDisabled();
+        if (!isDisabled) return button;
+      }
+    }
+    console.error('未找到任何可用的发送按钮。');
+    return null;
+  }
+  /**
+   * 在输入框中填入消息。
+   * @param {string} message 要发送的消息。
+   * @returns {Promise<boolean>} 是否填充成功。
+   */
+  async fillMessage(message) {
+    const inputElement = await this.findInputElement();
+    if (!inputElement) throw new Error('无法找到输入框。');
+    try {
+      if (this.options.enableHumanSimulation) {
+        await simulateHumanRandomClicks(this.page, { referenceElement: inputElement });
+      }
+      await inputElement.fill(message);
+      await this.page.waitForTimeout(200); // 等待UI响应
+      console.log('消息填充完成。');
+      return true;
+    } catch (error) {
+      console.error('填充消息失败:', error);
+      return false;
+    }
+  }
+  /**
+   * 等待发送按钮变为可用状态。
+   * @param {number} [timeout=10000] 超时时间。
+   * @returns {Promise<boolean>} 按钮是否变为可用。
+   */
+  async waitForSendButtonEnabled(timeout = 10000) {
+    try {
+      const sendButtonLocator = this.page.locator('button[aria-label="Run"]:not([disabled]), button.run-button:not([disabled])');
+      await sendButtonLocator.waitFor({ state: 'visible', timeout });
+      console.log('发送按钮已可用。');
+      return true;
+    } catch (error) {
+      console.warn('等待发送按钮可用超时，将继续尝试。');
+      return false;
+    }
+  }
+  /**
+   * 点击发送按钮发送消息。
+   * @returns {Promise<boolean>} 是否发送成功。
+   */
+  async sendMessage() {
+    if (this.options.enableHumanSimulation) {
+      await simulateHumanBehavior(this.page, { includeScrolling: false, duration: 1500 });
+    }
+    const sendButton = await this.findSendButton();
+    if (!sendButton) throw new Error('无法找到可用的发送按钮。');
+    try {
+      await sendButton.click();
+      console.log('消息已发送。');
+      return true;
+    } catch (error) {
+      console.error('点击发送按钮失败:', error);
+      try {
+        console.log('尝试使用键盘快捷键 (Ctrl+Enter) 发送...');
+        await this.page.keyboard.press('Control+Enter');
+        console.log('已使用键盘快捷键发送。');
+        return true;
+      } catch (keyboardError) {
+        console.error('键盘快捷键发送也失败:', keyboardError);
+        return false;
+      }
+    }
+  }
+  /**
+   * 设置 AI 模型。
+   * @param {string} modelName 模型 ID (例如 'gemini-pro')。
+   * @returns {Promise<boolean>} 是否设置成功。
+   */
+  async setModel(modelName) {
+    try {
+      const targetDisplayName = this.modelMapping[modelName] || modelName;
+      const modelSelectorContainerLocator = this.page.locator('ms-model-selector-two-column');
+      if (await modelSelectorContainerLocator.count() === 0) {
+        console.log('未找到模型选择器，跳过模型设置。');
+        return false;
+      }
+      const currentModelText = await modelSelectorContainerLocator.locator('.model-option-content .gmat-body-medium').textContent();
+      if (currentModelText?.trim() === targetDisplayName) {
+        console.log('当前已是目标模型，无需切换。');
+        return true;
+      }
+      await modelSelectorContainerLocator.click({ timeout: 5000 });
+      const dropdownPanelLocator = this.page.locator('.mat-mdc-select-panel');
+      await dropdownPanelLocator.waitFor({ state: 'visible', timeout: 5000 });
+      const targetOption = dropdownPanelLocator.locator('mat-option.model-option', { hasText: targetDisplayName });
+      if (await targetOption.count() > 0) {
+        await targetOption.first().click({ timeout: 5000 });
+        await this.page.waitForTimeout(1000); // 等待选择生效
+        console.log(`模型已成功设置为: ${targetDisplayName}`);
+        return true;
+      } else {
+        console.log(`未在下拉菜单中找到目标模型: ${targetDisplayName}`);
+        await this.page.keyboard.press('Escape'); // 关闭下拉菜单
+        return false;
+      }
+    } catch (error) {
+      console.error('设置模型时发生错误:', error);
+      try { await this.page.keyboard.press('Escape'); } catch (e) {}
+      return false;
+    }
+  }
+  /**
+   * 设置温度参数。
+   * @param {number} temperature 温度值。
+   * @returns {Promise<boolean>} 是否设置成功。
+   */
+  async setTemperature(temperature) {
+    try {
+      const temperatureContainerLocator = this.page.locator('[data-test-id="temperatureSliderContainer"]');
+      if (await temperatureContainerLocator.count() === 0) {
+        console.log('未找到温度设置容器，跳过。');
+        return false;
+      }
+      const numberInput = temperatureContainerLocator.locator('input[type="number"]');
+      if (await numberInput.count() > 0) {
+        await numberInput.fill(temperature.toString());
+        await numberInput.dispatchEvent('change');
+        console.log(`温度已设置为: ${temperature}`);
+        return true;
+      }
+      console.log('未找到温度数字输入框，跳过设置。');
+      return false;
+    } catch (error) {
+      console.error('设置温度时出错:', error);
+      return false;
+    }
+  }
+  /**
+   * 完整处理流程：加载页面、设置参数、填写并发送消息。
+   * @param {string} message 要发送的消息。
+   * @param {object} [options={}] 请求选项。
+   * @param {string} [options.model] 模型 ID。
+   * @param {number} [options.temperature] 温度值。
+   * @returns {Promise<boolean>} 整个流程是否成功。
+   */
+  async processMessage(message, options = {}) {
+    console.log('开始处理消息...');
+    if (!await this.waitForPageLoad()) throw new Error('页面加载失败。');
+    if (options.model) await this.setModel(options.model);
+    if (options.temperature !== undefined) await this.setTemperature(options.temperature);
+    if (!await this.fillMessage(message)) throw new Error('消息填写失败。');
+    await this.waitForSendButtonEnabled();
+    if (!await this.sendMessage()) throw new Error('消息发送失败。');
+    console.log('消息发送成功，等待网络拦截获取响应。');
+    return true;
+  }
+}

src/utils/ai-studio-processor.js ADDED Viewed

	@@ -0,0 +1,264 @@

+import { AIStudioInjector } from './ai-studio-injector.js';
+import { getPageFromPool, releasePageToPool, injectStreamInterceptor, activateStreamInterceptor, deactivateStreamInterceptor, smartNavigate } from './browser.js';
+import { parseGeminiResponse, createStreamResponse, createErrorResponse, createNonStreamResponse } from './response-parser.js';
+import config from '../config.js';
+const MAX_RETRIES = 3;
+const RETRY_DELAY_MS = 1000; // 增加了重试延迟，给页面更多反应时间
+/**
+ * 检查错误是否与页面状态相关，这类错误通常可以通过刷新或重新导航解决。
+ * @param {Error} error - 错误对象。
+ * @returns {boolean} 是否是页面状态错误。
+ */
+function isPageStateError(error) {
+  const message = error.message.toLowerCase();
+  const pageErrors = [
+    'timeout',
+    'navigation failed',
+    'page crashed',
+    'target closed',
+    'element not found',
+    'is not visible',
+    '无法找到', // 增强中文错误识别
+    'not find', // 增强英文错误识别
+    'cannot find' // 增强英文错误识别
+  ];
+  return pageErrors.some(pattern => message.includes(pattern));
+}
+/**
+ * 检查错误是否与权限相关，这类错误通常可以通过刷新页面来解决（如果Cookie有效）。
+ * @param {Error} error - 错误对象。
+ * @returns {boolean} 是否是权限错误。
+ */
+function isPermissionError(error) {
+  const message = error.message.toLowerCase();
+  const permissionKeywords = [
+    'permission', // 英文关键词
+    'unauthorized', // 英文关键词
+    '无权访问',     // 中文关键词 (来自你的日志)
+    'cookie',       // 关联关键词
+    '登录'          // 关联关键词
+  ];
+  return permissionKeywords.some(keyword => message.includes(keyword));
+}
+/**
+ * 重置页面状态，优先刷新，失败则重新导航。
+ * @param {import('playwright').Page} page - Playwright 页面对象。
+ */
+async function resetPageState(page) {
+  console.log('页面状态异常或遇到权限问题，开始重置...');
+  try {
+    await page.reload({ waitUntil: 'networkidle', timeout: 20000 });
+    console.log('页面刷新成功。');
+  } catch (reloadError) {
+    console.warn('页面刷新失败，尝试重新导航:', reloadError.message);
+    try {
+      await smartNavigate(page, config.aiStudio.url, { timeout: config.aiStudio.pageTimeout });
+      console.log('重新导航成功。');
+    } catch (gotoError) {
+      console.error('页面重置失败：刷新和重新导航均告失败。', gotoError);
+      throw new Error('Failed to reset page state.');
+    }
+  }
+}
+/**
+ * 核心处理逻辑，封装了重试和页面交互。
+ * @param {string} prompt - 用户提示。
+ * @param {object} options - 请求选项。
+ * @param {function} responseHandler - 处理响应的回调函数。
+ * @returns {Promise<any>} 响应处理函数返回的结果。
+ */
+async function coreAIStudioProcessor(prompt, options, responseHandler) {
+  let page = null;
+  let lastError = null;
+  try {
+    page = await getPageFromPool();
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        console.log(`[尝试 ${attempt}/${MAX_RETRIES}] 开始处理请求...`);
+        // 在第一次尝试或页面URL不正确时，强制导航
+        if (attempt === 1 || !page.url().includes('aistudio.google.com')) {
+            await smartNavigate(page, config.aiStudio.url, { timeout: config.aiStudio.pageTimeout });
+        }
+        const result = await responseHandler(page, prompt, options);
+        await releasePageToPool(page);
+        return result;
+      } catch (error) {
+        lastError = error;
+        console.warn(`[尝试 ${attempt}/${MAX_RETRIES}] 失败: ${error.message}`);
+        // 使用新的、更健壮的错误检查函数
+        if ((isPermissionError(error) || isPageStateError(error)) && attempt < MAX_RETRIES) {
+          console.log(`检测到可重试的错误（权限或页面状态），将在 ${RETRY_DELAY_MS}ms 后重试...`);
+          await resetPageState(page); // 刷新或重新导航页面
+          await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+        } else {
+          console.error(`错误不可重试或已达到最大重试次数，将抛出异常。`);
+          throw error; // 抛出错误，终止循环
+        }
+      }
+    }
+  } catch (error) {
+    console.error('处理 AI Studio 请求最终失败:', error);
+    if (page) {
+      // 如果是页面状态错误，标记页面以便从池中移除
+      if (isPageStateError(error)) {
+        page._needsRemoval = true;
+      }
+      await releasePageToPool(page);
+    }
+    throw lastError || error;
+  }
+}
+/**
+ * 流式处理 AI Studio 请求。
+ * @param {string} prompt - 用户提示。
+ * @param {ReadableStreamDefaultController} controller - 流控制器。
+ * @param {object} options - 请求选项。
+ */
+export async function processAIStudioRequest(prompt, controller, options = {}) {
+  const model = options.model || config.api.defaultModel;
+  try {
+    await coreAIStudioProcessor(prompt, options, async (page, p, opts) => {
+      return new Promise(async (resolve, reject) => {
+        let streamEnded = false;
+        let accumulatedResponse = "";
+        const sentContentKeys = new Set();
+        const finalize = (err) => {
+          if (streamEnded) return;
+          streamEnded = true;
+          deactivateStreamInterceptor(page).catch(console.error);
+          if (err) {
+            reject(err);
+          } else {
+            resolve();
+          }
+        };
+        const onStreamChunk = (chunk) => {
+          if (streamEnded) return;
+          accumulatedResponse += chunk;
+          const parsedData = parseGeminiResponse(accumulatedResponse);
+          // 如果解析器检测到权限错误，就用这个错误来拒绝Promise
+          if (parsedData?.permissionError) {
+            return finalize(new Error(parsedData.content));
+          }
+          if (Array.isArray(parsedData) && parsedData.length > 0) {
+            for (const item of parsedData) {
+              const contentKey = `${item.type}::${item.content}`;
+              if (item.content?.trim() && !sentContentKeys.has(contentKey)) {
+                controller.enqueue(`data: ${JSON.stringify(createStreamResponse(item.content, item.type, model))}\n\n`);
+                sentContentKeys.add(contentKey);
+              }
+            }
+          }
+        };
+        const onStreamEnd = () => {
+          if (streamEnded) return;
+          console.log('流已结束，发送 [DONE] 信号。');
+          controller.enqueue('data: [DONE]\n\n');
+          controller.close();
+          finalize();
+        };
+        try {
+          await injectStreamInterceptor(page, onStreamChunk, onStreamEnd);
+          await activateStreamInterceptor(page);
+          const injector = new AIStudioInjector(page);
+          await injector.processMessage(p, opts);
+          // 设置一个总超时，以防万一
+          setTimeout(() => {
+            if (!streamEnded) {
+              finalize(new Error('AI Studio 响应超时。'));
+            }
+          }, config.aiStudio.responseTimeout);
+        } catch (err) {
+          finalize(err);
+        }
+      });
+    });
+  } catch (error) {
+    // 确保在任何情况下都能正确关闭流
+    if (controller.desiredSize !== null) {
+      try {
+        controller.enqueue(`data: ${JSON.stringify(createErrorResponse(error.message, model))}\n\n`);
+        controller.enqueue('data: [DONE]\n\n');
+        controller.close();
+      } catch (e) {
+        console.error('关闭流控制器时出错:', e);
+      }
+    }
+  }
+}
+/**
+ * 非流式（同步）处理 AI Studio 请求。
+ * @param {string} prompt - 用户提示。
+ * @param {object} options - 请求选项。
+ * @returns {Promise<object>} OpenAI 格式的响应对象。
+ */
+export async function processAIStudioRequestSync(prompt, options = {}) {
+  const model = options.model || config.api.defaultModel;
+  try {
+    return await coreAIStudioProcessor(prompt, options, async (page, p, opts) => {
+      return new Promise(async (resolve, reject) => {
+        let collectedContent = '';
+        const responseListener = async (response) => {
+          if (response.url().includes('GenerateContent')) {
+            try {
+              const text = await response.text();
+              const parsedData = parseGeminiResponse(text);
+              if (parsedData?.permissionError) {
+                return reject(new Error(parsedData.content));
+              }
+              if (Array.isArray(parsedData)) {
+                collectedContent += parsedData
+                  .filter(item => item.type === 'text')
+                  .map(item => item.content)
+                  .join('');
+              }
+              page.removeListener('response', responseListener);
+              resolve(createNonStreamResponse(collectedContent, model));
+            } catch (err) {
+              reject(err);
+            }
+          }
+        };
+        page.on('response', responseListener);
+        try {
+          const injector = new AIStudioInjector(page);
+          await injector.processMessage(p, opts);
+          setTimeout(() => {
+            page.removeListener('response', responseListener);
+            reject(new Error('AI Studio 响应超时。'));
+          }, config.aiStudio.responseTimeout);
+        } catch (err) {
+          page.removeListener('response', responseListener);
+          reject(err);
+        }
+      });
+    });
+  } catch (error) {
+    return createErrorResponse(error.message, model);
+  }
+}

src/utils/browser.js ADDED Viewed

	@@ -0,0 +1,949 @@

+import { chromium } from 'playwright'
+// import { chromium } from 'playwright-extra'
+// import StealthPlugin from 'puppeteer-extra-plugin-stealth'
+import config from '../config.js'
+import { loadCookies } from './common-utils.js'
+import { info } from './logger.js'
+// 存储浏览器实例
+let browser = null
+let context = null
+// 页面池管理
+class PagePool {
+  constructor(maxSize = 5) {
+    this.maxSize = maxSize
+    this.availablePages = []
+    this.busyPages = new Set()
+    this.totalPages = 0
+  }
+  /**
+   * 获取一个可用的页面
+   * @returns {Promise<Page>}
+   */
+  async getPage() {
+    // 如果有可用页面，直接返回
+    if (this.availablePages.length > 0) {
+      const page = this.availablePages.pop()
+      this.busyPages.add(page)
+      info(`从页面池获取页面，当前忙碌页面数: ${this.busyPages.size}`)
+      return page
+    }
+    // 如果没有可用页面且未达到最大数量，创建新页面
+    if (this.totalPages < this.maxSize) {
+      const { context } = await initBrowser()
+      const page = await context.newPage()
+      this.busyPages.add(page)
+      this.totalPages++
+      info(`创建新页面，总页面数: ${this.totalPages}，忙碌页面数: ${this.busyPages.size}`)
+      return page
+    }
+    // 如果达到最大数量，等待有页面释放
+    info('页面池已满，等待页面释放...')
+    return new Promise((resolve) => {
+      const checkAvailable = () => {
+        if (this.availablePages.length > 0) {
+          const page = this.availablePages.pop()
+          this.busyPages.add(page)
+          info(`等待后获取到页面，当前忙碌页面数: ${this.busyPages.size}`)
+          resolve(page)
+        } else {
+          setTimeout(checkAvailable, 100)
+        }
+      }
+      checkAvailable()
+    })
+  }
+  /**
+   * 释放页面回到池中
+   * @param {Page} page
+   */
+  async releasePage(page) {
+    if (!this.busyPages.has(page)) {
+      info('尝试释放不在忙碌列表中的页面')
+      return
+    }
+    // 检查页面是否被标记为需要移除
+    if (page._needsRemoval) {
+      info('页面被标记为需要移除，将从池中移除')
+      await this.removePage(page)
+      return
+    }
+    try {
+      // 清理页面状态
+      await this.cleanupPage(page)
+      this.busyPages.delete(page)
+      this.availablePages.push(page)
+      info(`页面已释放回池中，可用页面数: ${this.availablePages.length}，忙碌页面数: ${this.busyPages.size}`)
+    } catch (error) {
+      info(`清理页面时出错，将关闭该页面: ${error.message}`)
+      await this.removePage(page)
+    }
+  }
+  /**
+   * 清理页面状态
+   * @param {Page} page
+   */
+  async cleanupPage(page) {
+    try {
+      // 移除所有事件监听器
+      page.removeAllListeners()
+      // 清理流式拦截器相关的函数和状态
+      try {
+        await page.evaluate(() => {
+          // 清理所有流式拦截器相关的函数
+          const keys = Object.keys(window)
+          keys.forEach(key => {
+            if (key.startsWith('__handleStreamChunk') ||
+              key.startsWith('__onStreamChunk') ||
+              key.startsWith('__onStreamEnd')) {
+              delete window[key]
+            }
+          })
+          // 清理拦截器状态
+          if (window.__streamInterceptor) {
+            if (typeof window.__streamInterceptor.deactivate === 'function') {
+              window.__streamInterceptor.deactivate()
+            }
+            delete window.__streamInterceptor
+          }
+          // 清理其他相关状态
+          delete window.__handleStreamChunk
+          delete window.__onStreamChunk
+          delete window.__onStreamEnd
+          delete window.__streamCallbacks
+        })
+      } catch (evalError) {
+        // 忽略页面evaluate错误，可能页面已经关闭
+        info(`清理页面状态时出现evaluate错误: ${evalError.message}`)
+      }
+      info('页面状态已清理')
+    } catch (error) {
+      throw new Error(`清理页面失败: ${error.message}`)
+    }
+  }
+  /**
+   * 从池中移除页面
+   * @param {Page} page
+   */
+  async removePage(page) {
+    try {
+      this.busyPages.delete(page)
+      const index = this.availablePages.indexOf(page)
+      if (index > -1) {
+        this.availablePages.splice(index, 1)
+      }
+      await page.close()
+      this.totalPages--
+      info(`页面已从池中移除，总页面数: ${this.totalPages}`)
+    } catch (error) {
+      info(`关闭页面时出错: ${error.message}`)
+    }
+  }
+  /**
+   * 清理所有页面
+   */
+  async cleanup() {
+    info('开始清理页面池...')
+    // 关闭所有忙碌页面
+    for (const page of this.busyPages) {
+      try {
+        await page.close()
+      } catch (error) {
+        info(`关闭忙碌页面时出错: ${error.message}`)
+      }
+    }
+    // 关闭所有可用页面
+    for (const page of this.availablePages) {
+      try {
+        await page.close()
+      } catch (error) {
+        info(`关闭可用页面时出错: ${error.message}`)
+      }
+    }
+    this.busyPages.clear()
+    this.availablePages = []
+    this.totalPages = 0
+    info('页面池清理完成')
+  }
+  /**
+   * 获取池状态信息
+   */
+  getStatus() {
+    return {
+      total: this.totalPages,
+      available: this.availablePages.length,
+      busy: this.busyPages.size,
+      maxSize: this.maxSize
+    }
+  }
+}
+// 全局页面池实例
+let pagePool = null
+/**
+ * 初始化浏览器
+ * @returns {Promise<{browser: any, context: any}>}
+ */
+export async function initBrowser() {
+  if (!browser) {
+    // chromium.use(StealthPlugin())
+    browser = await chromium.launch({
+      headless: config.browser.headless, // 从环境变量读取
+      timeout: config.browser.timeout,
+      args: config.browser.args,
+      executablePath: config.browser.executablePath
+    })
+    context = await browser.newContext({
+      userAgent: config.browser.userAgent
+    });
+    // 读取并设置cookies（优先使用环境变量）
+    const cookies = loadCookies(config.cookieFile, config.cookiesFromEnv);
+    await context.addCookies(cookies);
+  }
+  return { browser, context }
+}
+/**
+ * 初始化页面池
+ * @param {number} maxSize - 页面池最大大小
+ * @returns {PagePool}
+ */
+export function initPagePool(maxSize = 5) {
+  if (!pagePool) {
+    pagePool = new PagePool(maxSize)
+    info(`页面池已初始化，最大页面数: ${maxSize}`)
+  }
+  return pagePool
+}
+/**
+ * 获取页面池实例
+ * @returns {PagePool}
+ */
+export function getPagePool() {
+  if (!pagePool) {
+    pagePool = new PagePool()
+    info('页面池已自动初始化，使用默认配置')
+  }
+  return pagePool
+}
+/**
+ * 从页面池获取页面
+ * @returns {Promise<any>}
+ */
+export async function getPageFromPool() {
+  const pool = getPagePool()
+  const page = await pool.getPage()
+  // 将页面切换到前台
+  await page.bringToFront()
+  return page
+}
+/**
+ * 智能导航到指定URL，如果页面已在目标URL则进行刷新
+ * @param {Page} page - Playwright页面对象
+ * @param {string} targetUrl - 目标URL
+ * @param {Object} options - 导航选项
+ * @returns {Promise<boolean>} 是否进行了实际导航
+ */
+export async function smartNavigate(page, targetUrl, options = {}) {
+  const currentUrl = page.url()
+  console.log('当前页面URL:', currentUrl)
+  console.log('目标URL:', targetUrl)
+  try {
+    if (currentUrl !== targetUrl) {
+      console.log('页面URL不匹配，需要导航...')
+      await page.goto(targetUrl, {
+        waitUntil: 'load',
+        timeout: 30000,
+        ...options
+      })
+      console.log('页面导航完成')
+      return true
+    } else {
+      console.log('页面已在目标URL，进行刷新以确保最新状态...')
+      // 确保页面处于活跃状态
+      await page.bringToFront()
+      // 刷新页面
+      await page.reload({
+        waitUntil: 'load',
+        timeout: 30000,
+        ...options
+      })
+      console.log('页面刷新完成')
+      return true
+    }
+  }
+  catch {
+  }
+  return false
+}
+/**
+ * 释放页面回到池中
+ * @param {any} page
+ */
+export async function releasePageToPool(page) {
+  const pool = getPagePool()
+  await pool.releasePage(page)
+}
+/**
+ * 获取页面池状态
+ * @returns {Object}
+ */
+export function getPagePoolStatus() {
+  if (!pagePool) {
+    return { total: 0, available: 0, busy: 0, maxSize: 0 }
+  }
+  return pagePool.getStatus()
+}
+/**
+ * 清理浏览器资源
+ */
+export async function cleanup() {
+  // 先清理页面池
+  if (pagePool) {
+    await pagePool.cleanup()
+    pagePool = null
+  }
+  if (context) {
+    await context.close()
+    context = null
+  }
+  if (browser) {
+    await browser.close()
+    browser = null
+  }
+}
+/**
+ * 模拟人类随机点击行为 - 仅在输入框上方300像素内的安全区域
+ * @param {Page} page - Playwright页面对象
+ * @param {Object} options - 配置选项
+ * @param {number} options.minClicks - 最少点击次数，默认2
+ * @param {number} options.maxClicks - 最多点击次数，默认5
+ * @param {number} options.minDelay - 点击间最小延迟（毫秒），默认500
+ * @param {number} options.maxDelay - 点击间最大延迟（毫秒），默认2000
+ * @param {Element} options.referenceElement - 参考元素（如输入框），在其上方300像素内进行点击
+ * @returns {Promise<void>}
+ */
+export async function simulateHumanRandomClicks(page, options = {}) {
+  const {
+    minClicks = 1,
+    maxClicks = 3,
+    minDelay = 300,
+    maxDelay = 500,
+    referenceElement = null
+  } = options
+  try {
+    info('开始模拟人类随机点击行为...')
+    // 随机确定点击次数
+    const clickCount = Math.floor(Math.random() * (maxClicks - minClicks + 1)) + minClicks
+    info(`将进行 ${clickCount} 次随机点击`)
+    let safeArea = null
+    // 如果提供���参考元素，获取其位置信息
+    if (referenceElement) {
+      try {
+        const boundingBox = await referenceElement.boundingBox()
+        if (boundingBox) {
+          // 定义输入框上方300像素内的安全区域
+          safeArea = {
+            x: boundingBox.x - 50, // 左边扩展50px
+            y: Math.max(0, boundingBox.y - 200), // 上方300px区域
+            width: boundingBox.width + 50, // 宽度扩展100px
+            height: 300 // 高度300px的安全区域（输入框上方300像素内）
+          }
+          info(`使用输入框附近的安全区域: x=${safeArea.x}, y=${safeArea.y}, w=${safeArea.width}, h=${safeArea.height}`)
+        }
+      } catch (error) {
+        info(`获取参考元素位置失败，使用默认安全区域: ${error.message}`)
+      }
+    }
+    // 如果没有安全区域，使用页面中央的安全区域
+    if (!safeArea) {
+      const viewport = page.viewportSize()
+      const width = viewport?.width || 1280
+      const height = viewport?.height || 720
+      safeArea = {
+        x: width * 0.3,
+        y: height * 0.3,
+        width: width * 0.4,
+        height: height * 0.2
+      }
+      info(`使用默认安全区域: x=${safeArea.x}, y=${safeArea.y}, w=${safeArea.width}, h=${safeArea.height}`)
+    }
+    for (let i = 0; i < clickCount; i++) {
+      try {
+        // 在安全区域内生成随机坐标
+        const x = Math.floor(Math.random() * safeArea.width) + safeArea.x
+        const y = Math.floor(Math.random() * safeArea.height) + safeArea.y
+        info(`第 ${i + 1} 次安全点击: (${x}, ${y})`)
+        // 检查点击位置是否有可交互元素
+        const elementAtPoint = await page.locator(`*`).first().evaluate((_, coords) => {
+          const element = document.elementFromPoint(coords.x, coords.y)
+          if (!element) return { safe: true }
+          const tagName = element.tagName.toLowerCase()
+          const hasHref = element.hasAttribute('href')
+          const hasOnClick = element.hasAttribute('onclick') || element.onclick
+          const isButton = tagName === 'button' || element.type === 'button'
+          const isLink = tagName === 'a' || hasHref
+          const isInput = ['input', 'textarea', 'select'].includes(tagName)
+          return {
+            safe: !isButton && !isLink && !hasOnClick && !isInput,
+            tagName,
+            hasHref,
+            hasOnClick,
+            isButton,
+            isLink,
+            isInput
+          }
+        }, { x, y })
+        if (elementAtPoint.safe) {
+          // 模拟鼠标移动到目标位置
+          await page.mouse.move(x, y, {
+            steps: Math.floor(Math.random() * 10) + 5 // 5-15步移动，更自然
+          })
+          // 随机等待一小段时间
+          await page.waitForTimeout(Math.floor(Math.random() * 200) + 100)
+          // 执行点击
+          await page.mouse.click(x, y)
+          info(`安全点击完成: (${x}, ${y})`)
+        } else {
+          info(`跳过不安全的点击位置 (${x}, ${y}): ${elementAtPoint.tagName}`)
+        }
+        // 点击间随机延迟
+        if (i < clickCount - 1) {
+          const delay = Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay
+          info(`等待 ${delay}ms 后进行下一次点击`)
+          await page.waitForTimeout(delay)
+        }
+      } catch (clickError) {
+        info(`第 ${i + 1} 次点击出现错误，继续下一次: ${clickError.message}`)
+      }
+    }
+    info('安全随机点击模拟完成')
+  } catch (error) {
+    info(`模拟安全随机点击时出现错误: ${error.message}`)
+  }
+}
+/**
+ * 模拟更复杂的人类行为
+ * @param {Page} page - Playwright页面对象
+ * @param {Object} options - 配置选项
+ * @returns {Promise<void>}
+ */
+export async function simulateHumanBehavior(page, options = {}) {
+  const {
+    includeScrolling = true,
+    includeMouseMovement = true,
+    includeRandomClicks = true,
+    duration = 3000 // 总持续时间
+  } = options
+  try {
+    info('开始模拟复杂的人类行为...')
+    const startTime = Date.now()
+    const viewport = page.viewportSize()
+    const width = viewport?.width || 1280
+    const height = viewport?.height || 720
+    while (Date.now() - startTime < duration) {
+      const action = Math.random()
+      if (action < 0.3 && includeScrolling) {
+        // 30% 概率进行滚动
+        const scrollDirection = Math.random() > 0.5 ? 'down' : 'up'
+        const scrollAmount = Math.floor(Math.random() * 300) + 100
+        info(`模拟滚动: ${scrollDirection}, 距离: ${scrollAmount}px`)
+        await page.mouse.wheel(0, scrollDirection === 'down' ? scrollAmount : -scrollAmount)
+      } else if (action < 0.6 && includeMouseMovement) {
+        // 30% 概率进行鼠标移动
+        const x = Math.floor(Math.random() * width)
+        const y = Math.floor(Math.random() * height)
+        info(`模拟鼠标移动到: (${x}, ${y})`)
+        await page.mouse.move(x, y, {
+          steps: Math.floor(Math.random() * 15) + 5
+        })
+      } else if (action < 0.8 && includeRandomClicks) {
+        // 20% 概率进行点击
+        const x = Math.floor(Math.random() * (width * 0.8)) + width * 0.1
+        const y = Math.floor(Math.random() * (height * 0.8)) + height * 0.1
+        info(`模拟随机点击: (${x}, ${y})`)
+        await page.mouse.click(x, y)
+      }
+      // 随机等待
+      const waitTime = Math.floor(Math.random() * 800) + 200
+      await page.waitForTimeout(waitTime)
+    }
+    info('复杂人类行为模拟完成')
+  } catch (error) {
+    info(`模拟复杂人类行为时出现错误: ${error.message}`)
+  }
+}
+/**
+ * 处理Google AI Studio可能出现的欢迎模态对话框
+ * @param {Page} page - Playwright页面对象
+ * @param {number} timeout - 等待对话框出现的超时时间（毫秒），默认5000ms
+ * @returns {Promise<boolean>} - 返回是否成功处理了对话框
+ */
+export async function handleWelcomeModal(page, timeout = 5000) {
+  try {
+    info('检查是否有欢迎对话框需要关闭...')
+    // 对话框和关闭按钮的选择器
+    const dialogSelector = 'mat-dialog-container'
+    const closeButtonSelector = 'button[mat-dialog-close][aria-label="close"]'
+    // 检查是否存在对话框
+    const dialog = page.locator(dialogSelector).first()
+    if (await dialog.isVisible({ timeout })) {
+      info('发现欢迎对话框，尝试关闭...')
+      // 查找并点击关闭按钮
+      const closeButton = page.locator(closeButtonSelector).first()
+      if (await closeButton.isVisible({ timeout: 2000 })) {
+        await closeButton.click()
+        info('已通过关闭按钮关闭欢迎对话框')
+        // 等待对话框消失
+        await page.waitForTimeout(1000)
+        return true
+      } else {
+        info('未找到关闭按钮，尝试按ESC键关闭对话框')
+        await page.keyboard.press('Escape')
+        await page.waitForTimeout(1000)
+        return true
+      }
+    } else {
+      info('未发现欢迎对话框')
+      return false
+    }
+  } catch (err) {
+    info('处理欢迎对话框时出现错误，继续执行:', err.message)
+    return false
+  }
+}
+/**
+ * 注入流式拦截脚本到页面中（基于Tampermonkey脚本的思路）
+ * 这种方法避免了Playwright的page.route()阻塞问题
+ * @param {Page} page - Playwright页面对象
+ * @param {Function} onStreamChunk - 流数据块回调函数
+ * @param {Function} onStreamEnd - 流结束回调函数
+ * @returns {Promise<void>}
+ */
+export async function injectStreamInterceptor(page, onStreamChunk, onStreamEnd) {
+  try {
+    info('注入流式拦截脚本到页面中...')
+    // 清理可能存在的旧函数（清理所有以__onStream开头的函数）
+    try {
+      await page.evaluate(() => {
+        // 清理所有以__onStream开头的函数
+        Object.keys(window).forEach(key => {
+          if (key.startsWith('__onStreamChunk_') || key.startsWith('__onStreamEnd_')) {
+            delete window[key]
+          }
+        })
+        // 也清理旧的固定名称函数
+        delete window.__onStreamChunk
+        delete window.__onStreamEnd
+      })
+    } catch (e) {
+      // 忽略清理错误
+    }
+    // 设置回调函数（使用唯一名称避免冲突）
+    const uniqueId = Date.now() + '_' + Math.random().toString(36).substr(2, 9)
+    const chunkFunctionName = `__onStreamChunk_${uniqueId}`
+    const endFunctionName = `__onStreamEnd_${uniqueId}`
+    await page.exposeFunction(chunkFunctionName, onStreamChunk)
+    await page.exposeFunction(endFunctionName, onStreamEnd)
+    // 直接在页面中注入拦截脚本（不使用addInitScript，确保每次都能重新注入）
+    await page.evaluate(() => {
+      // 如果已经存在拦截器，先清理
+      if (window.__streamInterceptor) {
+        if (typeof window.__streamInterceptor.deactivate === 'function') {
+          window.__streamInterceptor.deactivate()
+        }
+        delete window.__streamInterceptor
+      }
+      // 保存原始的XMLHttpRequest方法
+      const originalXhrOpen = window.XMLHttpRequest.prototype.open
+      const originalXhrSend = window.XMLHttpRequest.prototype.send
+      // 支持多种可能的URL模式
+      const TARGET_URL_PATTERNS = [
+        "MakerSuiteService/GenerateContent",
+        "GenerateContent",
+        "streamGenerateContent",
+        "generateContent"
+      ]
+      // 流结束检测的正则表达式（基于Tampermonkey脚本）
+      const FINAL_BLOCK_SIGNATURE = /\[\s*null\s*,\s*null\s*,\s*null\s*,\s*\[\s*"/
+      const END_OF_STREAM_SIGNAL = "__END_OF_STREAM__"
+      let interceptorActive = false
+      // 向页面暴露拦截器控制函数
+      window.__streamInterceptor = {
+        activate: () => {
+          if (interceptorActive) return
+          console.log('🎯 激活流式拦截器...')
+          interceptorActive = true
+          // 重写XMLHttpRequest.open方法
+          window.XMLHttpRequest.prototype.open = function (method, url, ...rest) {
+            this._url = url
+            this._method = method
+            console.log(`[XHR] 请求: ${method} ${url}`)
+            return originalXhrOpen.apply(this, [method, url, ...rest])
+          }
+          // 重写XMLHttpRequest.send方法
+          window.XMLHttpRequest.prototype.send = function (...args) {
+            // 检查URL是否匹配任何目标模式
+            const urlString = this._url ? this._url.toString() : ''
+            const isTargetRequest = TARGET_URL_PATTERNS.some(pattern => urlString.includes(pattern))
+            if (this._url && isTargetRequest) {
+              console.log('🎯 [XHR Stream] 拦截到目标请求:', urlString)
+              console.log('🎯 [XHR Stream] 准备接收流式数据...')
+              let lastSentLength = 0
+              let fullResponseText = ""
+              let streamEnded = false
+              let finalizationTimer = null
+              const finalizeStream = () => {
+                if (streamEnded) return
+                streamEnded = true
+                console.log('[Stream] 判定流已结束')
+                clearTimeout(finalizationTimer)
+                const finalChunk = fullResponseText.slice(lastSentLength)
+                if (finalChunk) {
+                  window.__streamInterceptor.sendChunk(finalChunk)
+                }
+                window.__streamInterceptor.sendChunk(END_OF_STREAM_SIGNAL)
+              }
+              // 监听progress事件来获取流式数据
+              this.addEventListener('progress', () => {
+                if (streamEnded) return
+                try {
+                  fullResponseText = this.responseText || ''
+                  const newChunk = fullResponseText.slice(lastSentLength)
+                  if (newChunk) {
+                    console.log(`[Stream] 收到数据块，长度: ${newChunk.length}，HTTP状态: ${this.status}`)
+                    console.log(`[Stream] 数据块内容预览: ${newChunk.substring(0, 100)}...`)
+                    window.__streamInterceptor.sendChunk(newChunk)
+                    lastSentLength = fullResponseText.length
+                    // 检查是否是错误状态码的响应
+                    if (this.status >= 400 && this.readyState === 4) {
+                      console.log(`[Stream] progress事件中检测到HTTP错误状态码 ${this.status}，立即结束流`)
+                      finalizeStream()
+                      return
+                    }
+                    // 使用精确的签名来检查流是否结束
+                    if (FINAL_BLOCK_SIGNATURE.test(newChunk)) {
+                      console.log('[Stream] ✅ 检测到最终 ID 签名块，确认流结束')
+                      finalizeStream()
+                    }
+                  }
+                } catch (error) {
+                  console.error('[Stream] 处理progress事件时出错:', error)
+                }
+              })
+              // 监听readystatechange事件作为备用方法
+              this.addEventListener('readystatechange', () => {
+                if (streamEnded) return
+                console.log(`[Stream] readyState: ${this.readyState}, status: ${this.status}`)
+                // readyState 3 = LOADING (部分数据可用)
+                // readyState 4 = DONE (请求完成)
+                if (this.readyState === 3 || this.readyState === 4) {
+                  try {
+                    const currentText = this.responseText || ''
+                    const newChunk = currentText.slice(lastSentLength)
+                    if (newChunk) {
+                      console.log(`[Stream] readyState ${this.readyState} 收到数据块，长度: ${newChunk.length}`)
+                      console.log(`[Stream] 数据块内容预览: ${newChunk.substring(0, 200)}...`)
+                      window.__streamInterceptor.sendChunk(newChunk)
+                      lastSentLength = currentText.length
+                      fullResponseText = currentText
+                      // 检查流结束签名
+                      if (FINAL_BLOCK_SIGNATURE.test(newChunk)) {
+                        console.log('[Stream] ✅ readyState事件中检测到最终签名')
+                        finalizeStream()
+                      }
+                    }
+                    // 如果请求完成，检查HTTP状态码
+                    if (this.readyState === 4 && !streamEnded) {
+                      console.log(`[Stream] 请求完成，HTTP状态码: ${this.status}`)
+                      // 检查是否是错误状态码
+                      if (this.status >= 400) {
+                        console.log(`[Stream] 检测到HTTP错误状态码 ${this.status}，立即处理错误响应`)
+                        // 对于错误状态码，立即发送所有响应数据并结束流
+                        if (fullResponseText && fullResponseText !== currentText) {
+                          const remainingChunk = fullResponseText.slice(lastSentLength)
+                          if (remainingChunk) {
+                            console.log(`[Stream] 发送剩余错误响应数据: ${remainingChunk}`)
+                            window.__streamInterceptor.sendChunk(remainingChunk)
+                          }
+                        }
+                        finalizeStream()
+                      } else if (!streamEnded) {
+                        // 正常状态码，设置保险计时器
+                        console.log('[Stream] 正常请求完成，设置保险计时器')
+                        finalizationTimer = setTimeout(finalizeStream, 1000)
+                      }
+                    }
+                  } catch (error) {
+                    console.error('[Stream] 处理readystatechange事件时出错:', error)
+                  }
+                }
+              })
+              this.addEventListener('load', () => {
+                if (streamEnded) return
+                console.log('[Stream] "load" 事件触发，启动最终确认计时器')
+                finalizationTimer = setTimeout(finalizeStream, 1500)
+              })
+              this.addEventListener('error', (e) => {
+                console.error('[Stream] XHR 请求出错:', e)
+                if (!streamEnded) finalizeStream()
+              })
+              this.addEventListener('abort', () => {
+                console.log('[Stream] XHR 请求被中止')
+                if (!streamEnded) finalizeStream()
+              })
+            }
+            return originalXhrSend.apply(this, args)
+          }
+        },
+        deactivate: () => {
+          if (!interceptorActive) return
+          console.log('🔄 停用流式拦截器...')
+          window.XMLHttpRequest.prototype.open = originalXhrOpen
+          window.XMLHttpRequest.prototype.send = originalXhrSend
+          interceptorActive = false
+        },
+        sendChunk: (chunk) => {
+          try {
+            console.log(`[Stream] 发送数据块到Playwright，长度: ${chunk.length}`)
+            // 直接调用暴露的函数
+            if (window.__handleStreamChunk) {
+              window.__handleStreamChunk(chunk)
+            } else {
+              console.error('[Stream] __handleStreamChunk 函数不存在')
+            }
+          } catch (error) {
+            console.error('[Stream] 发送数据块时出错:', error)
+          }
+        }
+      }
+      // 创建全局回调存储
+      window.__streamCallbacks = {
+        onChunk: null,
+        onEnd: null
+      }
+      // 创建处理函数
+      window.__handleStreamChunk = function (chunk) {
+        try {
+          console.log('[Stream] 处理数据块:', chunk.length, '字符')
+          if (chunk === "__END_OF_STREAM__") {
+            if (window.__streamCallbacks.onEnd) {
+              window.__streamCallbacks.onEnd()
+            }
+          } else {
+            if (window.__streamCallbacks.onChunk) {
+              window.__streamCallbacks.onChunk(chunk)
+            }
+          }
+        } catch (error) {
+          console.error('[Stream] 处理数据块时出错:', error)
+        }
+      }
+      console.log('[Stream] 拦截器和处理函数已创建完成')
+    })
+    // 连接回调函数（分别设置以避免参数问题）
+    await page.evaluate((chunkFuncName) => {
+      window.__streamCallbacks.onChunk = window[chunkFuncName]
+      console.log('[Stream] onChunk回调函数已连接:', chunkFuncName)
+    }, chunkFunctionName)
+    await page.evaluate((endFuncName) => {
+      window.__streamCallbacks.onEnd = window[endFuncName]
+      console.log('[Stream] onEnd回调函数已连接:', endFuncName)
+    }, endFunctionName)
+    info('流式拦截脚本注入完成')
+  } catch (error) {
+    info(`注入流式拦截脚本时出错: ${error.message}`)
+    throw error
+  }
+}
+/**
+ * 激活页面中的流式拦截器
+ * @param {Page} page - Playwright页面对象
+ * @returns {Promise<void>}
+ */
+export async function activateStreamInterceptor(page) {
+  try {
+    await page.evaluate(() => {
+      if (window.__streamInterceptor) {
+        window.__streamInterceptor.activate()
+      }
+      // 重新检查并设置处理函数（页面导航后可能被清除）
+      if (!window.__handleStreamChunk) {
+        console.log('[Stream] 重新创建 __handleStreamChunk 函数')
+        // 重新创建处理函数
+        window.__handleStreamChunk = function (chunk) {
+          try {
+            console.log('[Stream] 处理数据块:', chunk.length, '字符')
+            if (chunk === "__END_OF_STREAM__") {
+              if (window.__onStreamEnd) {
+                window.__onStreamEnd()
+              }
+            } else {
+              if (window.__onStreamChunk) {
+                window.__onStreamChunk(chunk)
+              }
+            }
+          } catch (error) {
+            console.error('[Stream] 处理数据块时出错:', error)
+          }
+        }
+        console.log('[Stream] __handleStreamChunk 函数已重新创建')
+      }
+    })
+    info('流式拦截器已激活')
+  } catch (error) {
+    info(`激活流式拦截器时出错: ${error.message}`)
+    throw error
+  }
+}
+/**
+ * 停用页面中的流式拦截器
+ * @param {Page} page - Playwright页面对象
+ * @returns {Promise<void>}
+ */
+export async function deactivateStreamInterceptor(page) {
+  try {
+    await page.evaluate(() => {
+      if (window.__streamInterceptor) {
+        window.__streamInterceptor.deactivate()
+      }
+    })
+    info('流式拦截器已停用')
+  } catch (error) {
+    info(`停用流式拦截器时出错: ${error.message}`)
+  }
+}
+/**
+ * 设置进程退出处理
+ */
+export function setupProcessHandlers() {
+  process.on('SIGINT', async () => {
+    console.log('正在清理资源...')
+    await cleanup()
+    process.exit(0)
+  })
+  process.on('SIGTERM', async () => {
+    console.log('正在清理资源...')
+    await cleanup()
+    process.exit(0)
+  })
+}

src/utils/common-utils.js ADDED Viewed

	@@ -0,0 +1,104 @@

+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { info, error } from './logger.js';
+/**
+ * 创建一个人类可读的时间戳字符串。
+ * @returns {string} 格式为 'YYYY-MM-DD_HH-MM-SS' 的时间戳。
+ */
+export function getHumanReadableTimestamp() {
+  return new Date().toISOString().replace(/T/, '_').replace(/:/g, '-').replace(/\..+/, '');
+}
+/**
+ * 确保指定的目录存在，如果不存在则创建它。
+ * @param {string} dir - 目录路径。
+ */
+export function ensureDirectoryExists(dir) {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    info(`已创建目录: ${dir}`);
+  }
+}
+/**
+ * 检查 Cookie 是否可用（通过环境变量或文件）。
+ * @param {string} cookieFile - Cookie 文件路径。
+ * @param {string|undefined} cookiesFromEnv - 环境变量中的 Cookie 字符串。
+ * @returns {boolean} Cookie 是否可用。
+ */
+export function checkCookieAvailability(cookieFile, cookiesFromEnv) {
+  if (cookiesFromEnv) {
+    try {
+      JSON.parse(cookiesFromEnv);
+      info('发现并验证了环境变量中的 COOKIES。');
+      return true;
+    } catch (err) {
+      error('环境变量 COOKIES 格式无效 (必须是 JSON 数组字符串):', err.message);
+    }
+  }
+  if (fs.existsSync(cookieFile)) {
+    info(`发现 Cookie 文件: ${cookieFile}`);
+    return true;
+  }
+  error(`Cookie 文件不存在: ${cookieFile}，且未设置 COOKIES 环境变量。`);
+  info('请先运行 `npm run login` 或设置 COOKIES 环境变量。');
+  return false;
+}
+/**
+ * 加载 Cookie，优先从环境变量读取，其次从文件读取。
+ * @param {string} cookieFile - Cookie 文件路径。
+ * @param {string|undefined} cookiesFromEnv - 环境变量中的 Cookie 字符串。
+ * @returns {object[]} Cookie 对象数组。
+ */
+export function loadCookies(cookieFile, cookiesFromEnv) {
+  try {
+    if (cookiesFromEnv) {
+      info('从环境变量 COOKIES 加载 Cookie...');
+      return JSON.parse(cookiesFromEnv);
+    }
+    if (fs.existsSync(cookieFile)) {
+      info(`从文件加载 Cookie: ${cookieFile}`);
+      return JSON.parse(fs.readFileSync(cookieFile, 'utf8'));
+    }
+  } catch (err) {
+    error('加载 Cookie 失败:', err);
+    throw new Error('无法加载或解析 Cookie。');
+  }
+  return [];
+}
+/**
+ * 保存页面截图。
+ * @param {import('playwright').Page} page - Playwright 页面对象。
+ * @param {string} screenshotDir - 截图保存目录。
+ * @param {string} [prefix='screenshot'] - 截图文件名前缀。
+ * @returns {Promise<string>} 截图文件的完整路径。
+ */
+export async function saveScreenshot(page, screenshotDir, prefix = 'screenshot') {
+  ensureDirectoryExists(screenshotDir);
+  const timestamp = getHumanReadableTimestamp();
+  const screenshotPath = path.join(screenshotDir, `${prefix}_${timestamp}.png`);
+  await page.screenshot({ path: screenshotPath, fullPage: true });
+  info(`截图已保存: ${screenshotPath}`);
+  return screenshotPath;
+}
+/**
+ * 等待用户在控制台按下 Enter 键。
+ * @returns {Promise<void>}
+ */
+export function waitForUserInput() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    rl.question('', () => {
+      rl.close();
+      resolve();
+    });
+  });
+}

src/utils/logger.js ADDED Viewed

	@@ -0,0 +1,90 @@

+import fs from 'fs';
+import path from 'path';
+const LogLevel = {
+  DEBUG: 'DEBUG',
+  INFO: 'INFO',
+  WARN: 'WARN',
+  ERROR: 'ERROR'
+};
+const LOG_CONFIG = {
+  logFile: './logs/app.log',
+  logDir: './logs',
+  enableConsole: true,
+  enableFile: true,
+  logLevel: process.env.LOG_LEVEL || LogLevel.INFO
+};
+/**
+ * 确保日志目录存在。
+ */
+function ensureLogDirectory() {
+  if (!fs.existsSync(LOG_CONFIG.logDir)) {
+    fs.mkdirSync(LOG_CONFIG.logDir, { recursive: true });
+  }
+}
+/**
+ * 格式化日志消息。
+ * @param {any[]} args - 要记录的参数。
+ * @returns {string} 格式化后的消息字符串。
+ */
+function formatMessage(...args) {
+  return args.map(arg =>
+    (typeof arg === 'object' && arg !== null) ? JSON.stringify(arg, null, 2) : String(arg)
+  ).join(' ');
+}
+/**
+ * 将日志异步写入文件。
+ * @param {string} level - 日志级别。
+ * @param {string} message - 日志消息。
+ */
+async function writeToFile(level, message) {
+  if (!LOG_CONFIG.enableFile) return;
+  ensureLogDirectory();
+  const timestamp = new Date().toISOString();
+  const logEntry = `[${timestamp}] [${level}] ${message}\n`;
+  try {
+    await fs.promises.appendFile(LOG_CONFIG.logFile, logEntry);
+  } catch (error) {
+    console.error('写入日志文件失败:', error);
+  }
+}
+/**
+ * 将日志输出到控制台。
+ * @param {string} level - 日志级别。
+ * @param {any[]} args - 要记录的参数。
+ */
+function writeToConsole(level, ...args) {
+  if (!LOG_CONFIG.enableConsole) return;
+  const consoleMethod = {
+    [LogLevel.DEBUG]: console.debug,
+    [LogLevel.INFO]: console.log,
+    [LogLevel.WARN]: console.warn,
+    [LogLevel.ERROR]: console.error,
+  }[level] || console.log;
+  const timestamp = new Date().toLocaleTimeString();
+  consoleMethod(`[${timestamp}] [${level}]`, ...args);
+}
+/**
+ * 通用日志记录函数。
+ * @param {string} level - 日志级别。
+ * @param {any[]} args - 要记录的参数。
+ */
+function log(level, ...args) {
+  const message = formatMessage(...args);
+  writeToConsole(level, ...args);
+  writeToFile(level, message);
+}
+export const debug = (...args) => log(LogLevel.DEBUG, ...args);
+export const info = (...args) => log(LogLevel.INFO, ...args);
+export const warn = (...args) => log(LogLevel.WARN, ...args);
+export const error = (...args) => log(LogLevel.ERROR, ...args);
+export default { debug, info, warn, error };

src/utils/page-pool-monitor.js ADDED Viewed

	@@ -0,0 +1,57 @@

+import { getPagePoolStatus } from './browser.js';
+import { info } from './logger.js';
+let monitorIntervalId = null;
+/**
+ * 开始监控页面池状态，并定期打印到控制台。
+ * @param {number} [intervalMs=10000] - 监控间隔（毫秒）。
+ */
+export function startPagePoolMonitoring(intervalMs = 10000) {
+  if (monitorIntervalId) {
+    info('页面池监控已在运行中。');
+    return;
+  }
+  info(`开始监控页面池状态，间隔: ${intervalMs}ms`);
+  monitorIntervalId = setInterval(() => {
+    const status = getPagePoolStatus();
+    const timestamp = new Date().toLocaleTimeString();
+    const utilization = status.total > 0 ? ((status.busy / status.total) * 100).toFixed(1) : 0;
+    info(`[${timestamp}] 页面池状态: 总计=${status.total}, 可用=${status.available}, 忙碌=${status.busy}, 使用率=${utilization}%`);
+  }, intervalMs);
+}
+/**
+ * 停止页面池监控。
+ */
+export function stopPagePoolMonitoring() {
+  if (!monitorIntervalId) {
+    info('页面池监控未在运行。');
+    return;
+  }
+  info('停止页面池监控。');
+  clearInterval(monitorIntervalId);
+  monitorIntervalId = null;
+}
+/**
+ * 打印一次详细的当前页面池状态。
+ */
+export function printPagePoolStatus() {
+  const status = getPagePoolStatus();
+  const timestamp = new Date().toLocaleString();
+  const utilization = status.total > 0 ? ((status.busy / status.total) * 100).toFixed(1) : 0;
+  console.log(`
+--- 页面池状态 @ ${timestamp} ---
+  总页面数:   ${status.total}
+  可用页面数: ${status.available}
+  忙碌页面数: ${status.busy}
+  最大页面数: ${status.maxSize}
+  使用率:     ${utilization}%
+------------------------------------
+  `);
+}

src/utils/response-parser.js ADDED Viewed

	@@ -0,0 +1,189 @@

+/**
+ * Gemini 的响应流是一种非标准的、混合了 JSON 数组和特殊分隔符的格式。
+ * 本解析器的目标是从这种复杂的流中稳健地提取出有意义的文本内容和其类型（思考过程或最终文本）。
+ *
+ * 策略：
+ * 1. **权限错误优先**：首先检查表示权限问题的特定错误消息。
+ * 2. **JSON 优先解析**：尝试将响应文本修复为可解析的 JSON 数组。这是最可靠的方法，因为它能访问完整的结构。
+ *    a. **结构化类型判断**：递归地在解析后的数据结构中寻找内容块 `[null, "string", ...]`。
+ *       - 如果该数组长度 > 2，则初步判断为 `thinking`。
+ *       - 如果该数组长度 === 2，则初步判断为 `text`。
+ *    b. **状态化流处理**：在解析完整个数据块后，进行一次后处理。一旦第一个 `text` 类型的块出现，其后所有的块都将被强制转换为 `text` 类型，确保输出的纯净性。
+ * 3. **正则回退**：如果 JSON 解析失败，则回退到正则表达式，尽力提取内容。
+ */
+/**
+ * 检查并返回权限错误。
+ * @param {string} responseText - 响应文本。
+ * @returns {{permissionError: true, content: string}|null}
+ */
+function getPermissionError(responseText) {
+  if (responseText.includes('The caller does not have permission')) {
+    console.warn('检测到权限错误，将触发重试机制。');
+    return {
+      permissionError: true,
+      content: '无权访问 AI Studio。请检查 Cookie 或登录状态。'
+    };
+  }
+  return null;
+}
+/**
+ * 递归地在解析后的数据中寻找内容块，并根据结构初步判断类型。
+ * @param {any} data - 要搜索的数据。
+ * @returns {Array<{type: 'thinking' | 'text', content: string}>}
+ */
+function findContentRecursively(data) {
+  const results = [];
+  if (!data) {
+    return results;
+  }
+  if (Array.isArray(data)) {
+    if (data.length >= 2 && data[0] === null && typeof data[1] === 'string' && data[1]) {
+      if (data[1] !== 'model') {
+        const type = data.length > 2 ? 'thinking' : 'text';
+        results.push({
+          type: type,
+          content: data[1].replace(/\\n/g, '\n').replace(/\\"/g, '"'),
+        });
+      }
+    }
+    for (const item of data) {
+      results.push(...findContentRecursively(item));
+    }
+  }
+  return results;
+}
+/**
+ * 解析 Gemini 响应并返回内容数组。
+ * @param {string} responseText - Gemini API 响应文本。
+ * @returns {Array<{type: 'thinking' | 'text', content: string}>|{permissionError: true, content: string}|null}
+ */
+export function parseGeminiResponse(responseText) {
+  const permissionError = getPermissionError(responseText);
+  if (permissionError) return permissionError;
+  try {
+    let parsableText = responseText
+      .trim()
+      .replace(/\n/g, ',') // 用逗号替换换行符
+      .replace(/,+/g, ','); // 处理多个逗号
+    if (parsableText.endsWith(',')) {
+      parsableText = parsableText.slice(0, -1);
+    }
+    if (!parsableText.startsWith('[')) {
+      parsableText = '[' + parsableText;
+    }
+    if (!parsableText.endsWith(']')) {
+      parsableText = parsableText + ']';
+    }
+    parsableText = parsableText.replace(/,]/g, ']').replace(/\[,/g, '[');
+    const data = JSON.parse(parsableText);
+    const contentItems = findContentRecursively(data);
+    if (contentItems.length > 0) {
+        // 后处理阶段：应用 "一旦出现 text，后续皆为 text" 规则。
+        // 这能确保在最终答案开始输出后，流的类型统一，避免混入 "thinking" 片段。
+        let hasSeenText = false;
+        return contentItems.map(item => {
+            if (hasSeenText) {
+                // 如果之前已出现过 'text' 类型的内容，则将当前内容也标记为 'text'。
+                item.type = 'text';
+            } else if (item.type === 'text') {
+                // 这是流中首次出现 'text' 类型的内容，设置标志位。
+                hasSeenText = true;
+            }
+            return item;
+        });
+    }
+  } catch (e) {
+    // JSON 解析失败，将进入下面的正则回退逻辑
+  }
+  // 正则回退逻辑
+  const contentRegex = /\[null,\s*"((?:\\"|[^"])*)"/g;
+  const results = [];
+  let match;
+  while ((match = contentRegex.exec(responseText)) !== null) {
+    try {
+      const content = match[1].replace(/\\n/g, '\n').replace(/\\"/g, '"');
+      if (content && content !== 'model') {
+        const type = content.trim().startsWith('**') ? 'thinking' : 'text';
+        results.push({ type, content });
+      }
+    } catch (err) { /* 忽略单个匹配的解析错误 */ }
+  }
+  // 对正则提取的结果也应用相同的 "once text, always text" 逻辑
+  if (results.length > 0) {
+      let hasSeenText = false;
+      return results.map(item => {
+          if (hasSeenText) {
+              item.type = 'text';
+          } else if (item.type === 'text') {
+              hasSeenText = true;
+          }
+          return item;
+      });
+  }
+  return null;
+}
+/**
+ * 创建 OpenAI 格式的流式响应块 (chunk)。
+ * @param {string} content - 文本内容。
+ * @param {'thinking' | 'text'} type - 内容的类型。
+ * @param {string} [model='gemini-pro'] - 模型名称。
+ * @returns {object}
+ */
+export function createStreamResponse(content, type, model = 'gemini-pro') {
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: 'chat.completion.chunk',
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{
+      index: 0,
+      delta: {
+        content: content || '',
+        type: type || 'text',
+      },
+      logprobs: null,
+      finish_reason: null
+    }]
+  };
+}
+/**
+ * 创建 OpenAI 格式的错误响应。
+ * @param {string} message - 错误消息。
+ * @param {string} [model='gemini-pro'] - 模型名称。
+ * @returns {object}
+ */
+export function createErrorResponse(message, model = 'gemini-pro') {
+  return {
+    object: 'error',
+    message,
+    type: 'invalid_request_error',
+    model,
+  };
+}
+/**
+ * 创建 OpenAI 格式的非流式（完整）响应。
+ * @param {string} content - 完整的响应内容。
+ * @param {string} [model='gemini-pro'] - 模型名称。
+ * @returns {object}
+ */
+export function createNonStreamResponse(content, model = 'gemini-pro') {
+  return {
+    id: `chatcmpl-${Date.now()}`,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model,
+    choices: [{
+      index: 0,
+      message: {
+        role: 'assistant',
+        content
+      },
+      finish_reason: 'stop'
+    }],
+    usage: {
+      prompt_tokens: 0, // 未实现
+      completion_tokens: 0, // 未实现
+      total_tokens: 0 // 未实现
+    }
+  };
+}

src/utils/validation.js ADDED Viewed

	@@ -0,0 +1,41 @@

+import { createError } from 'h3';
+import config from "../config.js";
+/**
+ * 验证聊天完成请求体，并将其转换为内部处理格式。
+ * @param {object} body - H3 请求体。
+ * @returns {{prompt: string, stream: boolean, model: string, temperature: number, messages: object[]}} 验证和格式化后的数据。
+ * @throws {Error} 如果验证失败，则抛出 H3 错误。
+ */
+export function validateChatCompletionRequest(body) {
+  const {
+    messages,
+    stream = false,
+    model = config.api.defaultModel,
+    temperature = config.api.temperature
+  } = body;
+  if (!messages || !Array.isArray(messages) || messages.length === 0) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: 'Invalid request: `messages` must be a non-empty array.'
+    });
+  }
+  // 将消息数组转换为单个字符串 prompt，以适应 AI Studio 的单输入框模式
+  const prompt = messages.map(message => {
+    if (!message.role || !message.content) {
+      return '';
+    }
+    // 添加角色标签以提供上下文
+    return `${message.role}: ${message.content}`;
+  }).join('\n\n');
+  return {
+    prompt,
+    stream,
+    model,
+    temperature,
+    messages
+  };
+}

src/web-server.js ADDED Viewed

	@@ -0,0 +1,129 @@

+import { H3, serve, serveStatic } from 'h3';
+import { stat, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import {
+  setupProcessHandlers,
+  initPagePool,
+  getPageFromPool,
+  releasePageToPool,
+  handleWelcomeModal,
+  smartNavigate
+} from './utils/browser.js';
+import { startPagePoolMonitoring, printPagePoolStatus } from './utils/page-pool-monitor.js';
+import { corsMiddleware } from './middlewares/cors.js';
+import { healthHandler } from './routes/health.js';
+import { chatCompletionsHandler } from './routes/chat-completions.js';
+import { modelsHandler, modelHandler } from './routes/models.js';
+import { saveScreenshot } from './utils/common-utils.js';
+import config from './config.js';
+import { info, error } from './utils/logger.js';
+const app = new H3();
+const CWD = process.cwd();
+// 设置进程退出处理
+setupProcessHandlers();
+// 全局 CORS 中间件
+app.use('*', corsMiddleware);
+// --- API 端点 ---
+// 健康检查端点
+app.get('/health', healthHandler);
+// 模型相关端点
+app.get('/v1/models', modelsHandler);
+app.get('/v1/models/:model', modelHandler);
+// 主要的聊天完成端点
+app.post('/v1/chat/completions', chatCompletionsHandler);
+// --- 静态文件服务 (必须在 API 端点之后) ---
+// 处理 screenshots 目录
+app.get('/screenshots/**', (event) => {
+  // event.path is like /screenshots/foo.png
+  const assetPath = event.path.substring('/screenshots'.length);
+  const filePath = join(CWD, 'screenshots', assetPath);
+  return serveStatic(event, {
+    getContents: () => readFile(filePath),
+    getMeta: async () => {
+      const stats = await stat(filePath).catch(() => {});
+      if (stats?.isFile()) return { size: stats.size, mtime: stats.mtimeMs };
+    }
+  });
+});
+// 处理 public 目录 (作为其他所有 GET 请求的兜底)
+app.get('/**', (event) => {
+  const assetPath = event.path === '/' ? 'index.html' : event.path;
+  const filePath = join(CWD, 'public', assetPath);
+  return serveStatic(event, {
+    getContents: () => readFile(filePath),
+    getMeta: async () => {
+      const stats = await stat(filePath).catch(() => {});
+      if (stats?.isFile()) return { size: stats.size, mtime: stats.mtimeMs };
+    }
+  });
+});
+// 初始化页面池
+info('🔧 初始化页面池...');
+initPagePool(5); // 最大5个页面
+// 启动页面池监控（开发环境）
+if (process.env.NODE_ENV !== 'production') {
+  info('📊 启动页面池监控...');
+  startPagePoolMonitoring(10000); // 每10秒监控一次
+}
+// 启动服务器
+const port = config.server.port;
+const host = config.server.host;
+serve(app, { port, host });
+info(`🚀 服务器运行在 http://${host}:${port}`);
+info(`🏠 管理面板: http://${host}:${port}/`);
+info(`📋 健康检查: http://${host}:${port}/health`);
+info(`💬 聊天端点: http://${host}:${port}/v1/chat/completions`);
+info(`🎯 AI Studio URL: ${config.aiStudio.url}`);
+info(`🌍 环境: ${process.env.NODE_ENV || 'development'}`);
+// 截图AI Studio页面的函数
+async function captureAIStudioScreenshot() {
+  let page;
+  try {
+    info('📸 开始获取AI Studio页面截图...');
+    page = await getPageFromPool();
+    info(`🌐 智能导航到: ${config.aiStudio.url}`);
+    await smartNavigate(page, config.aiStudio.url, {
+      timeout: config.aiStudio.pageTimeout
+    });
+    await handleWelcomeModal(page);
+    await page.waitForTimeout(2000);
+    const screenshotPath = await saveScreenshot(page, './screenshots', 'aistudio-startup');
+    info(`✅ AI Studio截图已保存: ${screenshotPath}`);
+  } catch (err) {
+    error('❌ 截图AI Studio页面时出错:', err.message);
+  } finally {
+    if (page) {
+      await releasePageToPool(page);
+      info('🔄 页面已释放回池中');
+    }
+  }
+}
+// 打印初始页面池状态
+setTimeout(() => {
+  info('\n📊 初始页面池状态:');
+  printPagePoolStatus();
+}, 1000);
+// 启动后截图AI Studio页面
+setTimeout(() => {
+  captureAIStudioScreenshot();
+}, 2000);