yiyan-browser-agent 1.5.2 → 1.6.0

package/README.md

@@ -166,6 +166,26 @@ ya --debug "build a calculator"
 
 When interactive mode (`-i`) is running, an HTTP server starts on port **9527**, allowing external services to send tasks.
 
+### Task Queue (v1.5.2+)
+
+**多客户端并发支持：** 所有请求进入队列串行处理，确保每个客户端收到正确的响应。
+
+```
+客户端A → 请求"北京天气" → 队列位置1 → 处理 → 返回"北京天气答案"
+客户端B → 请求"上海天气" → 队列位置2 → 等待 → 处理 → 返回"上海天气答案"
+客户端C → 请求"广州天气" → 队列位置3 → 等待 → 处理 → 返回"广州天气答案"
+```
+
+### API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/task` | POST | 提交任务 |
+| `/status` | GET | 获取队列状态 |
+| `/queue` | GET | 获取队列详情 |
+| `/task/:id` | GET | 获取单个任务状态 |
+| `/` | GET | 服务信息 |
+
 ### Process Communication
 
 ```bash
@@ -239,6 +259,67 @@ curl -X POST http://localhost:9527/task -H "Content-Type: application/json" -d '
 - 第二次请求 (`newChat=false`)：AI 回答"小明"
 - 第三次请求 (`newChat=true`)：AI 回答"不知道"或"你没有告诉我"
 
+### GET /status - 队列状态查询
+
+```bash
+curl http://localhost:9527/status
+```
+
+**Response:**
+```json
+{
+  "queueLength": 2,
+  "isProcessing": true,
+  "currentTask": {
+    "id": "abc123",
+    "task": "北京天气",
+    "elapsed": 3000
+  },
+  "pendingTasks": [
+    { "id": "def456", "task": "上海天气", "waitTime": 2000 },
+    { "id": "ghi789", "task": "广州天气", "waitTime": 1000 }
+  ],
+  "stats": {
+    "totalProcessed": 10,
+    "averageProcessTime": 5000
+  }
+}
+```
+
+### GET /queue - 队列详情
+
+```bash
+curl http://localhost:9527/queue
+```
+
+### GET /task/:id - 单个任务状态
+
+```bash
+curl http://localhost:9527/task/abc123
+```
+
+**Response (processing):**
+```json
+{
+  "id": "abc123",
+  "task": "北京天气",
+  "status": "processing",
+  "startedAt": 1735001234,
+  "elapsed": 3000
+}
+```
+
+**Response (pending):**
+```json
+{
+  "id": "def456",
+  "task": "上海天气",
+  "status": "pending",
+  "queuePosition": 2,
+  "waitTime": 5000
+}
+```
+
 ### Windows CMD (curl)
 
 ```cmd

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yiyan-browser-agent",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "description": "AI coding agent powered by Yiyan (文心一言) via browser automation — no API key needed",
   "main": "src/index.js",
   "bin": {

package/src/agent.js

@@ -27,6 +27,31 @@ class YiyanAgent {
   async run(task) {
     const startTime = Date.now();
 
+    // 使用崩溃处理器包装整个执行流程
+    if (this.browser.crashHandler) {
+      return this.browser.crashHandler.wrap(
+        async () => {
+          logger.info('Sending task to Yiyan...');
+          await this.browser.sendMessage(task);
+
+          logger.info('Waiting for response...');
+          const answer = await this.browser.waitForResponse();
+
+          const duration = Date.now() - startTime;
+
+          return {
+            question: task,
+            answer: answer || 'No response',
+            duration,
+            status: answer ? 'success' : 'error'
+          };
+        },
+        'run_task',
+        config.RESPONSE_TIMEOUT
+      );
+    }
+
+    // 降级：无崩溃处理器时使用原有逻辑
     logger.info('Sending task to Yiyan...');
     await this.browser.sendMessage(task);
 

package/src/browser.js

@@ -6,6 +6,7 @@ const { chromium } = require('playwright');
 const path         = require('path');
 const config       = require('./config');
 const logger       = require('./logger');
+const CrashHandler = require('./stability/crash-handler');
 
 // ─────────────────────────────────────────────────────────────────────────────
 //  Selector banks — ordered by likelihood, with fallbacks
@@ -85,6 +86,7 @@ class YiyanBrowser {
     this.context  = null;
     this.page     = null;
     this._closed  = false;
+    this.crashHandler = null;  // 崩溃处理器
   }
 
   // ── Lifecycle ──────────────────────────────────────────────────────────────
@@ -122,12 +124,17 @@ class YiyanBrowser {
     await this._navigate(config.YIYAN_URL);
     await this._ensureLoggedIn();
 
+    // 注册崩溃监听
+    this.crashHandler = new CrashHandler(this);
+    this.crashHandler.attach();
+
     logger.success('Browser ready!');
   }
 
   async close() {
     if (this._closed) return;
     this._closed = true;
+    // 崩溃处理器不再需要监听
     try { await this.context?.close(); } catch {}
   }
 

package/src/config.js

@@ -24,6 +24,10 @@ const defaults = {
   // Output
   MAX_OUTPUT_LENGTH : 8_000,
   DEBUG             : false,
+
+  // CrashHandler - 崩溃恢复配置
+  MAX_RETRIES       : 3,      // 连续崩溃最大重试次数
+  COOLDOWN_MS       : 10000,  // 冷却期 (毫秒)，防止无限重启
 };
 
 // ─────────────────────────────────────────────

package/src/stability/crash-handler.js

@@ -0,0 +1,261 @@
+// src/stability/crash-handler.js — Simplified crash detection and recovery
+'use strict';
+
+const config = require('../config');
+const logger = require('../logger');
+
+/**
+ * CrashHandler - 简化版崩溃处理器
+ *
+ * 功能：
+ * 1. 监听浏览器崩溃事件
+ * 2. 自动恢复（新建页面或重启浏览器）
+ * 3. 操作重试机制
+ * 4. 冷却期防止无限重启
+ */
+class CrashHandler {
+  constructor(browser) {
+    this.browser = browser;
+    this.crashCount = 0;                      // 连续崩溃计数
+    this.lastCrashTime = 0;                   // 上次崩溃时间
+    this.maxRetries = config.MAX_RETRIES || 3;
+    this.cooldownMs = config.COOLDOWN_MS || 10000;
+    this._recoveryPromise = null;             // 正在进行的恢复
+  }
+
+  // ── 注册崩溃监听 ──
+  attach() {
+    if (!this.browser.context || !this.browser.page) {
+      logger.warn('[CrashHandler] Browser not ready, cannot attach listeners');
+      return;
+    }
+
+    // 浏览器 context 关闭
+    this.browser.context.on('close', () => {
+      this._onCrash('context_closed');
+    });
+
+    // 页面崩溃
+    this.browser.page.on('crash', () => {
+      this._onCrash('page_crash');
+    });
+
+    // 页面断开
+    this.browser.page.on('disconnected', () => {
+      this._onCrash('disconnected');
+    });
+
+    logger.dim('[CrashHandler] Listeners attached');
+  }
+
+  // ── 崩溃事件处理 ──
+  _onCrash(type) {
+    const now = Date.now();
+
+    // 冷却期检查：短时间内重复崩溃不处理
+    if (now - this.lastCrashTime < this.cooldownMs) {
+      logger.warn(`[CrashHandler] ${type} ignored (cooldown active, ${Math.round((this.cooldownMs - (now - this.lastCrashTime)) / 1000)}s remaining)`);
+      return;
+    }
+
+    this.crashCount++;
+    this.lastCrashTime = now;
+
+    logger.error(`[CrashHandler] Crash detected: ${type} (count: ${this.crashCount}/${this.maxRetries})`);
+
+    // 超过最大重试次数
+    if (this.crashCount > this.maxRetries) {
+      logger.error(`[CrashHandler] Max retries (${this.maxRetries}) exceeded, stopping auto-recovery`);
+      return;
+    }
+
+    // 触发恢复（异步，不阻塞）
+    this._recover(type).catch(err => {
+      logger.error(`[CrashHandler] Recovery error: ${err.message}`);
+    });
+  }
+
+  // ── 恢复逻辑 ──
+  async _recover(type) {
+    // 防止并发恢复
+    if (this._recoveryPromise) {
+      logger.dim('[CrashHandler] Recovery already in progress, waiting...');
+      return this._recoveryPromise;
+    }
+
+    this._recoveryPromise = this._doRecovery(type);
+    try {
+      await this._recoveryPromise;
+    } finally {
+      this._recoveryPromise = null;
+    }
+  }
+
+  async _doRecovery(type) {
+    logger.info(`[CrashHandler] Starting recovery for: ${type}`);
+    const startTime = Date.now();
+
+    try {
+      if (type === 'page_crash') {
+        // 页面崩溃 → 新建页面
+        logger.dim('[CrashHandler] Strategy: create new page');
+
+        try {
+          await this.browser.page.close();
+        } catch {
+          // 页面可能已经关闭
+        }
+
+        this.browser.page = await this.browser.context.newPage();
+        await this.browser.page.goto(config.YIYAN_URL, { waitUntil: 'domcontentloaded', timeout: 15000 });
+        await this.browser.page.waitForTimeout(500);
+
+      } else {
+        // 其他崩溃 → 完全重启浏览器
+        logger.dim('[CrashHandler] Strategy: full browser restart');
+
+        // 先关闭
+        try {
+          await this.browser.close();
+        } catch {
+          // 可能已经关闭
+        }
+
+        // 重置状态
+        this.browser._closed = false;
+        this.browser.context = null;
+        this.browser.page = null;
+
+        // 等待一下再重启
+        await new Promise(r => setTimeout(r, 1000));
+
+        // 重新启动
+        await this.browser.launch();
+
+        // 重新注册监听
+        this.attach();
+      }
+
+      // 恢复成功，重置崩溃计数
+      this.crashCount = 0;
+      const duration = Date.now() - startTime;
+      logger.success(`[CrashHandler] Recovery successful (${duration}ms)`);
+
+      return { success: true, duration };
+
+    } catch (err) {
+      logger.error(`[CrashHandler] Recovery failed: ${err.message}`);
+      return { success: false, error: err.message };
+    }
+  }
+
+  // ── 操作包装器（带重试）──
+  async wrap(operation, operationName = 'operation', timeoutMs = null) {
+    const maxTimeout = timeoutMs || config.RESPONSE_TIMEOUT || 180000;
+    const startTime = Date.now();
+    let attempt = 0;
+
+    while (Date.now() - startTime < maxTimeout) {
+      attempt++;
+
+      try {
+        // 检查浏览器状态
+        if (!this.browser.page || this.browser.page.isClosed()) {
+          logger.warn(`[CrashHandler] Browser disconnected before ${operationName}`);
+          await this._recover('disconnected');
+
+          if (!this.browser.page || this.browser.page.isClosed()) {
+            throw new Error('Browser recovery failed');
+          }
+        }
+
+        // 执行操作
+        const result = await operation();
+
+        // 成功，重置崩溃计数
+        if (attempt > 1) {
+          this.crashCount = 0;
+        }
+
+        return result;
+
+      } catch (err) {
+        const elapsed = Date.now() - startTime;
+        const msg = err.message?.toLowerCase() || '';
+
+        logger.warn(`[CrashHandler] ${operationName} failed (attempt ${attempt}): ${err.message}`);
+
+        // 判断是否值得重试
+        const shouldRetry =
+          elapsed < maxTimeout - 5000 &&  // 还有足够时间
+          this.crashCount <= this.maxRetries &&  // 未超过最大崩溃次数
+          (
+            msg.includes('disconnected') ||
+            msg.includes('crash') ||
+            msg.includes('closed') ||
+            msg.includes('timeout') ||
+            msg.includes('network') ||
+            msg.includes('socket') ||
+            msg.includes('navigation') ||
+            err.name === 'TimeoutError'
+          );
+
+        if (!shouldRetry) {
+          throw err;
+        }
+
+        // 等待后重试
+        const retryDelay = Math.min(2000 * attempt, 10000);  // 递增延迟，最多10秒
+        logger.dim(`[CrashHandler] Retrying ${operationName} in ${retryDelay}ms...`);
+        await new Promise(r => setTimeout(r, retryDelay));
+
+        // 尝试恢复浏览器
+        if (msg.includes('disconnected') || msg.includes('crash') || msg.includes('closed')) {
+          await this._recover('disconnected');
+        }
+      }
+    }
+
+    throw new Error(`${operationName} timed out after ${Math.round((Date.now() - startTime) / 1000)}s`);
+  }
+
+  // ── 健康检查 ──
+  async healthCheck() {
+    if (!this.browser.page) {
+      return { healthy: false, reason: 'no_page' };
+    }
+
+    if (this.browser.page.isClosed()) {
+      return { healthy: false, reason: 'page_closed' };
+    }
+
+    try {
+      // 尝试执行简单 JS 检测页面是否响应
+      await this.browser.page.evaluate(() => Date.now());
+      return { healthy: true };
+    } catch (err) {
+      return { healthy: false, reason: err.message };
+    }
+  }
+
+  // ── 状态报告 ──
+  getStatus() {
+    return {
+      crashCount: this.crashCount,
+      lastCrashTime: this.lastCrashTime,
+      maxRetries: this.maxRetries,
+      cooldownMs: this.cooldownMs,
+      cooldownRemaining: Math.max(0, this.cooldownMs - (Date.now() - this.lastCrashTime)),
+      recovering: this._recoveryPromise !== null,
+    };
+  }
+
+  // ── 重置崩溃计数（手动干预后调用）──
+  reset() {
+    this.crashCount = 0;
+    this.lastCrashTime = 0;
+    logger.info('[CrashHandler] Crash count reset');
+  }
+}
+
+module.exports = CrashHandler;