yiyan-browser-agent 1.5.1 → 1.5.3

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.1",
+  "version": "1.5.3",
   "description": "AI coding agent powered by Yiyan (文心一言) via browser automation — no API key needed",
   "main": "src/index.js",
   "bin": {

package/src/server.js

@@ -6,6 +6,7 @@ const http = require('http');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const TaskQueue = require('./task-queue');
 
 const DEFAULT_PORT = 9527;
 const LOCK_FILE = path.join(os.homedir(), '.yiyan-agent', 'server.lock');
@@ -15,6 +16,11 @@ class AgentServer {
     this.agent = agent;
     this.port = port;
     this.server = null;
+
+    // 创建任务队列，设置任务准备好时的回调
+    this.taskQueue = new TaskQueue((task) => {
+      this._executeTask(task);
+    });
   }
 
   async start() {
@@ -39,6 +45,9 @@ class AgentServer {
   }
 
   async stop() {
+    // 清空队列
+    this.taskQueue.clearQueue();
+
     if (this.server) {
       await new Promise((resolve) => {
         this.server.close(resolve);
@@ -98,60 +107,146 @@ class AgentServer {
 
   async _handleRequest(req, res) {
     const logger = require('./logger');
+    const url = new URL(req.url, `http://localhost:${this.port}`);
+
+    // ── API 路由 ─────────────────────────────────────────────
+
+    // GET /status - 获取队列状态
+    if (req.method === 'GET' && url.pathname === '/status') {
+      this._handleStatus(req, res);
+      return;
+    }
+
+    // GET /queue - 获取队列详情
+    if (req.method === 'GET' && url.pathname === '/queue') {
+      this._handleQueue(req, res);
+      return;
+    }
+
+    // GET /task/:id - 获取单个任务状态
+    if (req.method === 'GET' && url.pathname.startsWith('/task/')) {
+      const requestId = url.pathname.slice(6);
+      this._handleTaskStatus(req, res, requestId);
+      return;
+    }
+
+    // POST /task - 提交任务
+    if (req.method === 'POST' && url.pathname === '/task') {
+      this._handleTaskSubmit(req, res);
+      return;
+    }
 
-    // 只接受 POST /task
-    if (req.method !== 'POST') {
-      res.writeHead(405, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ status: 'error', answer: 'Method not allowed, use POST' }));
+    // GET / - 简单介绍
+    if (req.method === 'GET' && url.pathname === '/') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        name: 'yiyan-agent',
+        version: '1.5.2',
+        endpoints: {
+          'POST /task': '提交任务',
+          'GET /status': '获取队列状态',
+          'GET /queue': '获取队列详情',
+          'GET /task/:id': '获取任务状态',
+        }
+      }));
       return;
     }
 
-    // 读取请求体
+    // 其他请求 - 404
+    res.writeHead(404, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ status: 'error', answer: 'Not found' }));
+  }
+
+  // ── POST /task - 提交任务 ─────────────────────────────────────
+  _handleTaskSubmit(req, res) {
+    const logger = require('./logger');
     let body = '';
+
     req.on('data', chunk => { body += chunk.toString(); });
-    req.on('end', async () => {
+
+    req.on('end', () => {
       try {
         const request = JSON.parse(body);
-        const result = await this._executeTask(request);
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify(result));
+        const { task, newChat = true } = request;
+
+        if (!task) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'error', answer: 'No task provided' }));
+          return;
+        }
+
+        // 添加任务到队列，等待任务完成后自动调用 resolve 返回结果
+        this.taskQueue.addTask(request, (result) => {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        });
+
       } catch (err) {
         logger.error(`[HTTP Error] ${err.message}`);
         res.writeHead(400, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ status: 'error', answer: `Bad request: ${err.message}` }));
       }
     });
-  }
-
-  async _executeTask(request) {
-    const { task, newChat = true } = request;
 
-    if (!task) {
-      return { status: 'error', answer: 'No task provided' };
-    }
+    req.on('error', (err) => {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'error', answer: `Request error: ${err.message}` }));
+    });
+  }
 
+  // ── 执行任务（由队列回调触发）─────────────────────────────────────
+  async _executeTask(task) {
+    const { data } = task;
+    const { task: taskText, newChat = true } = data;
     const logger = require('./logger');
-    logger.info(`[Remote Task] ${task}`);
+
+    logger.info(`[Remote Task] ${taskText}`);
 
     try {
-      // 可选：开启新对话
+      // 开启新对话
       if (newChat) {
         await this.agent.browser.newChat();
       }
 
-      const result = await this.agent.run(task);
-      logger.info(`[Remote Task Done] ${result.status} (${result.duration}ms)`);
-      return result;
+      // 执行任务
+      const result = await this.agent.run(taskText);
+
+      // 完成任务（通知队列，触发 resolve）
+      this.taskQueue.completeCurrentTask(result);
+
     } catch (err) {
       logger.error(`[Remote Task Error] ${err.message}`);
-      return {
-        question: task,
-        answer: `Error: ${err.message}`,
-        duration: 0,
-        status: 'error'
-      };
+      this.taskQueue.errorCurrentTask(err);
     }
   }
+
+  // ── GET /status - 获取队列状态 ─────────────────────────────────────
+  _handleStatus(req, res) {
+    const status = this.taskQueue.getQueueStatus();
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(status, null, 2));
+  }
+
+  // ── GET /queue - 获取队列详情 ─────────────────────────────────────
+  _handleQueue(req, res) {
+    const status = this.taskQueue.getQueueStatus();
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(status, null, 2));
+  }
+
+  // ── GET /task/:id - 获取任务状态 ─────────────────────────────────────
+  _handleTaskStatus(req, res, requestId) {
+    const status = this.taskQueue.getTaskStatus(requestId);
+
+    if (!status) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ status: 'error', answer: 'Task not found' }));
+      return;
+    }
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(status, null, 2));
+  }
 }
 
 module.exports = { AgentServer, DEFAULT_PORT, LOCK_FILE };

package/src/task-queue.js

@@ -0,0 +1,296 @@
+// src/task-queue.js — Task queue for handling concurrent requests
+'use strict';
+
+const logger = require('./logger');
+
+/**
+ * TaskQueue - 任务队列管理器
+ *
+ * 解决问题：
+ * 1. 多个客户端并发请求时，输入框竞争导致任务混淆
+ * 2. 响应返回给错误的客户端
+ *
+ * 解决方案：
+ * 1. 所有任务进入队列，串行处理
+ * 2. 每个任务绑定唯一ID，追踪响应归属
+ * 3. 提供状态查询API
+ */
+class TaskQueue {
+  constructor(onTaskReady = null) {
+    this.queue = [];           // 待处理任务队列
+    this.currentTask = null;   // 当前正在处理的任务
+    this.isProcessing = false; // 是否正在处理
+    this.completedTasks = [];  // 已完成任务（最近10个）
+    this.onTaskReady = onTaskReady; // 任务准备好执行时的回调
+    this.stats = {
+      totalProcessed: 0,
+      averageProcessTime: 0,
+      totalProcessTime: 0,
+    };
+  }
+
+  /**
+   * 添加任务到队列
+   * @param {object} taskData - 任务数据 { task, newChat, provider }
+   * @param {function} resolve - Promise的resolve函数
+   * @returns {object} - { requestId, queuePosition, estimatedWait }
+   */
+  addTask(taskData, resolve) {
+    const requestId = this._generateRequestId();
+
+    const task = {
+      id: requestId,
+      data: taskData,
+      resolve,
+      status: 'pending',
+      addedAt: Date.now(),
+      startedAt: null,
+      completedAt: null,
+    };
+
+    this.queue.push(task);
+
+    const queuePosition = this.queue.length;
+    const estimatedWait = this._estimateWaitTime(queuePosition);
+
+    logger.info(`[Queue] 新任务 ${this._shortId(requestId)}: "${taskData.task.slice(0, 30)}..." (队列位置: ${queuePosition})`);
+
+    // 如果没有正在处理的任务，立即开始处理
+    if (!this.isProcessing) {
+      this._processNext();
+    }
+
+    return {
+      requestId,
+      queuePosition,
+      estimatedWait,
+      status: 'pending',
+    };
+  }
+
+  /**
+   * 处理下一个任务
+   */
+  _processNext() {
+    if (this.queue.length === 0) {
+      this.isProcessing = false;
+      this.currentTask = null;
+      logger.dim('[Queue] 队列已空，等待新任务...');
+      return;
+    }
+
+    this.isProcessing = true;
+    this.currentTask = this.queue.shift();
+    this.currentTask.status = 'processing';
+    this.currentTask.startedAt = Date.now();
+
+    const waitTime = this.currentTask.startedAt - this.currentTask.addedAt;
+    logger.info(`[Queue] 开始处理 ${this._shortId(this.currentTask.id)}: "${this.currentTask.data.task.slice(0, 30)}..." (等待了 ${waitTime}ms)`);
+
+    // 调用外部执行回调
+    if (this.onTaskReady) {
+      this.onTaskReady(this.currentTask);
+    }
+  }
+
+  /**
+   * 完成当前任务（由外部调用，传入执行结果）
+   * @param {object} result - 执行结果
+   */
+  completeCurrentTask(result) {
+    if (!this.currentTask) return;
+
+    this.currentTask.completedAt = Date.now();
+    this.currentTask.status = 'completed';
+
+    const processTime = this.currentTask.completedAt - this.currentTask.startedAt;
+    result.requestId = this.currentTask.id;
+    result.processTime = processTime;
+    result.waitTime = this.currentTask.startedAt - this.currentTask.addedAt;
+
+    // 更新统计
+    this._updateStats(processTime);
+
+    // 保存到已完成列表（保留最近10个）
+    this.completedTasks.unshift({
+      id: this.currentTask.id,
+      task: this.currentTask.data.task,
+      processTime,
+      status: result.status,
+      completedAt: this.currentTask.completedAt,
+    });
+    if (this.completedTasks.length > 10) {
+      this.completedTasks.pop();
+    }
+
+    // 返回结果给客户端
+    this.currentTask.resolve(result);
+
+    logger.info(`[Queue] ✓ 完成 ${this._shortId(this.currentTask.id)} (${processTime}ms)`);
+
+    // 处理下一个
+    this.currentTask = null;
+    this._processNext();
+  }
+
+  /**
+   * 当前任务出错
+   * @param {Error} err - 错误对象
+   */
+  errorCurrentTask(err) {
+    if (!this.currentTask) return;
+
+    this.currentTask.completedAt = Date.now();
+    this.currentTask.status = 'error';
+
+    const result = {
+      question: this.currentTask.data.task,
+      answer: `Error: ${err.message}`,
+      status: 'error',
+      requestId: this.currentTask.id,
+      processTime: this.currentTask.completedAt - this.currentTask.startedAt,
+    };
+
+    this.currentTask.resolve(result);
+
+    logger.error(`[Queue] ✗ 错误 ${this._shortId(this.currentTask.id)}: ${err.message}`);
+
+    this.currentTask = null;
+    this._processNext();
+  }
+
+  /**
+   * 获取任务状态
+   * @param {string} requestId - 任务ID
+   * @returns {object|null} - 任务状态
+   */
+  getTaskStatus(requestId) {
+    // 检查当前任务
+    if (this.currentTask && this.currentTask.id === requestId) {
+      return {
+        id: requestId,
+        task: this.currentTask.data.task,
+        status: 'processing',
+        addedAt: this.currentTask.addedAt,
+        startedAt: this.currentTask.startedAt,
+        elapsed: Date.now() - this.currentTask.startedAt,
+      };
+    }
+
+    // 检查队列中的任务
+    const pending = this.queue.find(t => t.id === requestId);
+    if (pending) {
+      return {
+        id: requestId,
+        task: pending.data.task,
+        status: 'pending',
+        addedAt: pending.addedAt,
+        queuePosition: this.queue.indexOf(pending) + 1,
+        waitTime: Date.now() - pending.addedAt,
+      };
+    }
+
+    // 检查已完成任务
+    const completed = this.completedTasks.find(t => t.id === requestId);
+    if (completed) {
+      return {
+        id: requestId,
+        task: completed.task,
+        status: 'completed',
+        processTime: completed.processTime,
+        completedAt: completed.completedAt,
+      };
+    }
+
+    return null;
+  }
+
+  /**
+   * 获取队列整体状态
+   * @returns {object} - 队列状态
+   */
+  getQueueStatus() {
+    return {
+      queueLength: this.queue.length,
+      isProcessing: this.isProcessing,
+      currentTask: this.currentTask ? {
+        id: this.shortId(this.currentTask.id),
+        task: this.currentTask.data.task.slice(0, 50),
+        status: this.currentTask.status,
+        elapsed: Date.now() - this.currentTask.startedAt,
+      } : null,
+      pendingTasks: this.queue.map(t => ({
+        id: this.shortId(t.id),
+        task: t.data.task.slice(0, 50),
+        waitTime: Date.now() - t.addedAt,
+      })),
+      recentCompleted: this.completedTasks.slice(0, 5).map(t => ({
+        id: this.shortId(t.id),
+        task: t.task.slice(0, 50),
+        processTime: t.processTime,
+        status: t.status,
+      })),
+      stats: {
+        totalProcessed: this.stats.totalProcessed,
+        averageProcessTime: Math.round(this.stats.averageProcessTime),
+      },
+    };
+  }
+
+  /**
+   * 生成唯一请求ID
+   */
+  _generateRequestId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  }
+
+  /**
+   * 简短ID（用于显示）
+   */
+  _shortId(id) {
+    if (!id) return 'unknown';
+    const parts = id.split('-');
+    return parts[1] || id.slice(-6);
+  }
+
+  shortId(id) {
+    return this._shortId(id);
+  }
+
+  /**
+   * 估算等待时间
+   */
+  _estimateWaitTime(position) {
+    if (position === 0) return 0;
+    // 使用历史平均处理时间估算
+    const avgTime = this.stats.averageProcessTime || 5000;
+    return Math.round(avgTime * position);
+  }
+
+  /**
+   * 更新统计信息
+   */
+  _updateStats(processTime) {
+    this.stats.totalProcessed++;
+    this.stats.totalProcessTime += processTime;
+    this.stats.averageProcessTime = this.stats.totalProcessTime / this.stats.totalProcessed;
+  }
+
+  /**
+   * 清空队列（紧急情况）
+   */
+  clearQueue() {
+    // 通知所有等待的任务
+    for (const task of this.queue) {
+      task.resolve({
+        status: 'error',
+        answer: 'Queue cleared',
+        requestId: task.id,
+      });
+    }
+    this.queue = [];
+    logger.warn('[Queue] 队列已清空');
+  }
+}
+
+module.exports = TaskQueue;