yiyan-browser-agent 1.4.7 → 1.4.9

package/README.md

@@ -108,6 +108,22 @@ yiyan-agent --interactive
 # Run on a specific project
 ya --dir ~/projects/my-app "refactor all callbacks to async/await"
 
+### Process Communication (v1.4.8+)
+
+When interactive mode (`-i`) is running, other `yiyan-agent` processes automatically detect and forward tasks to it, avoiding repeated browser startup:
+
+```bash
+# Terminal 1: Start interactive mode (acts as server)
+yiyan-agent -i
+# → Server listening on port 9527
+
+# Terminal 2: Send task (forwarded to server, no new browser)
+yiyan-agent "北京天气，15个字"
+# → Found running server, forwarding task...
+```
+
+Lock file: `~/.yiyan-agent/server.lock`
+
 # Debug mode (shows what Yiyan is actually outputting)
 ya --debug "build a calculator"
 

package/package.json

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

package/src/agent.js

@@ -4,11 +4,13 @@
 const config     = require('./config');
 const logger     = require('./logger');
 const YiyanBrowser = require('./browser');
+const { AgentServer } = require('./server');
 
 class YiyanAgent {
   constructor(options = {}) {
     this.browser = new YiyanBrowser();
     this.options = options;
+    this.server = null; // TCP server for accepting remote tasks
   }
 
   async init() {
@@ -16,6 +18,9 @@ class YiyanAgent {
   }
 
   async shutdown() {
+    if (this.server) {
+      await this.server.stop();
+    }
     await this.browser.close();
   }
 
@@ -39,10 +44,22 @@ class YiyanAgent {
   }
 
   async runInteractive() {
+    // 启动 TCP 服务，接收其他进程的任务
+    this.server = new AgentServer(this);
+    try {
+      await this.server.start();
+      logger.info(`Server listening on port ${this.server.port} — other processes can send tasks here`);
+    } catch (err) {
+      logger.warn(`Failed to start server: ${err.message}`);
+      // 继续运行，只是不能接收远程任务
+    }
+
     const readline = require('readline');
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = () => new Promise(resolve => rl.question('', resolve));
 
+    logger.info('Interactive mode — type task and press Enter (exit/quit/q to quit)');
+
     while (true) {
       const task = (await ask()).trim();
       if (!task) continue;

package/src/client.js

@@ -0,0 +1,80 @@
+#!/usr/bin/env node
+// src/client.js — TCP client for sending tasks to running server
+'use strict';
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { DEFAULT_PORT, LOCK_FILE } = require('./server');
+
+class AgentClient {
+  constructor() {
+    this.port = DEFAULT_PORT;
+  }
+
+  // 检查是否有服务器运行
+  isServerAvailable() {
+    if (fs.existsSync(LOCK_FILE)) {
+      try {
+        const lock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8'));
+        // 检查进程是否活着
+        try {
+          process.kill(lock.pid, 0);
+          this.port = lock.port || DEFAULT_PORT;
+          return true;
+        } catch {
+          return false;
+        }
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  // 发送任务到服务器
+  async sendTask(task, options = {}) {
+    return new Promise((resolve, reject) => {
+      const socket = net.connect(this.port, 'localhost');
+      const timeout = options.timeout || 180000; // 3分钟
+
+      let data = '';
+      let timer = setTimeout(() => {
+        socket.destroy();
+        reject(new Error('Connection timeout'));
+      }, timeout);
+
+      socket.on('connect', () => {
+        clearTimeout(timer);
+        // 发送任务
+        const request = JSON.stringify({
+          task,
+          newChat: options.newChat !== false
+        });
+        socket.end(request);
+      });
+
+      socket.on('data', (chunk) => {
+        data += chunk.toString();
+      });
+
+      socket.on('end', () => {
+        try {
+          const result = JSON.parse(data);
+          resolve(result);
+        } catch (err) {
+          reject(new Error(`Invalid response: ${data}`));
+        }
+      });
+
+      socket.on('error', (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+}
+
+module.exports = AgentClient;

package/src/index.js

@@ -7,6 +7,7 @@ const fs     = require('fs');
 const config = require('./config');
 const logger = require('./logger');
 const YiyanAgent = require('./agent');
+const AgentClient = require('./client');
 
 function parseArgs(argv) {
   const args = argv.slice(2);
@@ -32,13 +33,19 @@ yiyan-agent — AI Agent via Yiyan Browser
 
 USAGE
   yiyan-agent "任务"              # 执行任务，只输出JSON
-  yiyan-agent -i                  # 交互模式（用于登录）
+  yiyan-agent -i                  # 交互模式（启动服务器，接收远程任务）
 
 OPTIONS
-  -i, --interactive    交互模式
+  -i, --interactive    交互模式（启动 TCP 服务，端口 9527）
   --show-browser       显示浏览器
   --debug              调试模式
   -h, --help           帮助
+
+进程间通信
+  当交互模式运行时，其他 yiyan-agent 进程会自动检测并转发任务，
+  避免每次重新启动浏览器。
+
+  锁文件: ~/.yiyan-agent/server.lock
 `);
 }
 
@@ -101,8 +108,25 @@ async function main() {
     if (opts.interactive) {
       await agent.runInteractive();
     } else {
+      // 单任务模式：先检查是否有服务器运行
+      const client = new AgentClient();
+
+      if (client.isServerAvailable()) {
+        // 有服务器运行，转发任务
+        logger.info(`Found running server, forwarding task...`);
+        try {
+          const result = await client.sendTask(opts.task);
+          console.log(JSON.stringify(result, null, 2));
+          // 直接退出，不关闭浏览器（服务器管理）
+          process.exit(0);
+        } catch (err) {
+          // 转发失败，fallback 到本地执行
+          logger.warn(`Server connection failed: ${err.message}, running locally...`);
+        }
+      }
+
+      // 无服务器或转发失败，本地执行
       const result = await agent.run(opts.task);
-      // 单任务：只输出JSON
       console.log(JSON.stringify(result, null, 2));
     }
   } catch (err) {

package/src/server.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// src/server.js — TCP server for accepting tasks from other processes
+'use strict';
+
+const net = require('net');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_PORT = 9527;
+const LOCK_FILE = path.join(os.homedir(), '.yiyan-agent', 'server.lock');
+
+class AgentServer {
+  constructor(agent, port = DEFAULT_PORT) {
+    this.agent = agent;
+    this.port = port;
+    this.server = null;
+  }
+
+  async start() {
+    // 检查是否已有服务器运行
+    if (this._isServerRunning()) {
+      throw new Error(`Server already running on port ${this.port}`);
+    }
+
+    this.server = net.createServer((socket) => {
+      this._handleConnection(socket);
+    });
+
+    await new Promise((resolve, reject) => {
+      this.server.listen(this.port, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+
+    // 写锁文件
+    this._writeLockFile();
+
+    return this.port;
+  }
+
+  async stop() {
+    if (this.server) {
+      await new Promise((resolve) => {
+        this.server.close(resolve);
+      });
+      this.server = null;
+    }
+    this._removeLockFile();
+  }
+
+  _isServerRunning() {
+    if (fs.existsSync(LOCK_FILE)) {
+      try {
+        const lock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf8'));
+        // 检查进程是否还活着
+        try {
+          process.kill(lock.pid, 0);
+          return true;
+        } catch {
+          // 进程已死，清理锁文件
+          this._removeLockFile();
+          return false;
+        }
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+
+  _writeLockFile() {
+    const dir = path.dirname(LOCK_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(LOCK_FILE, JSON.stringify({
+      pid: process.pid,
+      port: this.port,
+      started: Date.now()
+    }));
+  }
+
+  _removeLockFile() {
+    try {
+      if (fs.existsSync(LOCK_FILE)) {
+        fs.unlinkSync(LOCK_FILE);
+      }
+    } catch {}
+  }
+
+  async _handleConnection(socket) {
+    let data = '';
+
+    socket.on('data', (chunk) => {
+      data += chunk.toString();
+    });
+
+    socket.on('end', async () => {
+      try {
+        const request = JSON.parse(data);
+        const result = await this._executeTask(request);
+        socket.end(JSON.stringify(result));
+      } catch (err) {
+        socket.end(JSON.stringify({
+          status: 'error',
+          answer: `Server error: ${err.message}`
+        }));
+      }
+    });
+
+    socket.on('error', (err) => {
+      // 连接错误，忽略
+    });
+  }
+
+  async _executeTask(request) {
+    const { task, newChat = true } = request;
+
+    if (!task) {
+      return { status: 'error', answer: 'No task provided' };
+    }
+
+    try {
+      // 可选：开启新对话
+      if (newChat) {
+        await this.agent.browser.newChat();
+      }
+
+      const result = await this.agent.run(task);
+      return result;
+    } catch (err) {
+      return {
+        question: task,
+        answer: `Error: ${err.message}`,
+        duration: 0,
+        status: 'error'
+      };
+    }
+  }
+}
+
+module.exports = { AgentServer, DEFAULT_PORT, LOCK_FILE };