yiyan-browser-agent 1.0.21 → 1.0.22

package/package.json

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

package/src/agent.js

@@ -1,16 +1,10 @@
-// src/agent.js — The core agent loop that ties everything together
+// src/agent.js — The core agent loop
 'use strict';
 
-const fs                           = require('fs');
-const path                         = require('path');
-const { execSync }                 = require('child_process');
 const config                       = require('./config');
 const logger                       = require('./logger');
 const BrowserManager               = require('./browser-manager');
-const { executeTool }              = require('./tools');
-const { parseResponse,
-        formatToolResult }         = require('./parser');
-const { ConversationManager }      = require('./prompt');
+const PageAgent                    = require('./page-agent');
 
 // ─────────────────────────────────────────────
 //  Agent class
@@ -18,161 +12,68 @@ const { ConversationManager }      = require('./prompt');
 
 class YiyanAgent {
   constructor(options = {}) {
-    this.browser      = null;  // Will be obtained from BrowserManager
-    this.conversation = new ConversationManager();
-    this.options      = options;
-    this._running     = false;
+    this.pageAgent   = null;
+    this.options     = options;
+    this._running    = false;
   }
 
   // ── Public API ──────────────────────────────────────────────────────────────
 
-  /** Boot the browser (reuse if available, restart if error) */
+  /** Get browser and create page agent */
   async init() {
-    this.browser = await BrowserManager.getInstance();
-    await BrowserManager.newChat();
+    const { browser, page } = await BrowserManager.getInstance();
+    this.pageAgent = new PageAgent(page);
   }
 
-  /** Shut down cleanly (only on explicit exit, not after each task) */
+  /** Shutdown */
   async shutdown() {
-    await BrowserManager.close();
+    await BrowserManager.forceClose();
   }
 
   /**
-   * Run a task to completion.
-   * Returns JSON object with question, answer, duration.
+   * Run a task
    */
   async run(task) {
-    this._running   = true;
-    const maxIter   = config.MAX_ITERATIONS;
+    this._running = true;
     const startTime = Date.now();
 
-    // ── Send task directly ───────────────────────────────────
     logger.info('Sending task to Yiyan...');
-    try {
-      await this.browser.sendMessage(task);
-    } catch (err) {
-      throw err;
-    }
-
-    // ── Agent loop ──────────────────────────────────────────────────────
-    let finalAnswer = '';
-    for (let iter = 1; iter <= maxIter; iter++) {
-      logger.iteration(iter, maxIter);
-
-      // Wait for response from Yiyan
-      const rawResponse = await this.browser.waitForResponse();
-
-      if (!rawResponse || rawResponse.trim().length === 0) {
-        logger.warn('Empty response received — retrying...');
-        await this.browser.sendMessage('Please continue.');
-        continue;
-      }
-
-      if (config.DEBUG) {
-        logger.dim(`--- Raw response (${rawResponse.length} chars) ---`);
-        logger.dim(rawResponse.slice(0, 400));
-      }
-
-      this.conversation.addAssistantMessage(rawResponse);
-      const parsed = parseResponse(rawResponse);
-
-      // ── Tool call ────────────────────────────────────────────────────
-      if (parsed.type === 'tool_call') {
-        logger.toolCall(parsed.name, parsed.args);
-        let result, isError = false;
-        try {
-          result = await executeTool(parsed.name, parsed.args);
-          logger.toolResult(result);
-        } catch (err) {
-          result = `Error: ${err.message}`;
-          isError = true;
-          logger.toolResult(result, true);
-        }
-        const feedbackMsg = this.conversation.addToolResult(parsed.name, result, isError);
-        await this.browser.sendMessage(feedbackMsg);
-        continue;
-      }
-
-      // ── Parse error ──────────────────────────────────────────────────
-      if (parsed.type === 'error') {
-        logger.warn(`Parse error: ${parsed.message}`);
-        const recovery = this.conversation.addToolResult('SYSTEM', `Parse error: ${parsed.message}`, true);
-        await this.browser.sendMessage(recovery);
-        continue;
-      }
+    await this.pageAgent.sendMessage(task);
 
-      // ── Final response ───────────────────────────────────────────────
-      if (parsed.type === 'final') {
-        finalAnswer = parsed.content;
-        if (this.options.saveLog) {
-          await this._saveConversationLog(task, parsed.content);
-        }
-        this._running = false;
-        break;
-      }
-    }
+    logger.info('Waiting for response...');
+    const answer = await this.pageAgent.waitForResponse();
 
     const duration = Date.now() - startTime;
-    let status = 'success';
-    if (!finalAnswer) {
-      finalAnswer = `Reached maximum iterations (${maxIter}).`;
-      status = 'incomplete';
-    }
-
     this._running = false;
 
-    // Return JSON
     return {
       question: task,
-      answer: finalAnswer,
-      duration: duration,
-      status: status
+      answer: answer || 'No response received',
+      duration,
+      status: answer ? 'success' : 'error'
     };
   }
 
-  // ── Interactive (REPL) Mode ────────────────────────────────────────────────
+  // ── Interactive Mode ────────────────────────────────────────────────────────
 
-  /**
-   * Run the agent in interactive mode — keeps the browser open
-   * and outputs JSON format.
-   */
   async runInteractive() {
     const readline = require('readline');
-
     const rl = readline.createInterface({
-      input    : process.stdin,
-      output   : process.stdout,
-      terminal : true,
+      input: process.stdin,
+      output: process.stdout,
     });
 
     const ask = () => new Promise(resolve => rl.question('', resolve));
 
     while (true) {
-      let task;
-      try {
-        task = (await ask()).trim();
-      } catch {
-        break;
-      }
-
+      const task = (await ask()).trim();
       if (!task) continue;
-
-      if (['exit', 'quit', 'q'].includes(task.toLowerCase())) {
-        break;
-      }
-
-      if (task.toLowerCase() === 'new') {
-        await this.browser.newChat();
-        this.conversation = new ConversationManager();
-        continue;
-      }
-
-      this.conversation = new ConversationManager();
+      if (['exit', 'quit', 'q'].includes(task.toLowerCase())) break;
 
       try {
-        await this.browser.newChat();
+        // Re-init for new tab
+        await this.init();
         const result = await this.run(task);
-        // Output JSON to stdout
         console.log(JSON.stringify(result, null, 2));
       } catch (err) {
         console.log(JSON.stringify({
@@ -186,77 +87,6 @@ class YiyanAgent {
 
     rl.close();
   }
-
-  // ── Helpers ────────────────────────────────────────────────────────────────
-
-  _getWorkingDirListing() {
-    try {
-      // Use Node.js fs for cross-platform compatibility (Windows compatible)
-      const fs = require('fs');
-      const pathModule = require('path');
-      const cwd = config.WORKING_DIR;
-
-      const excludeDirs = ['node_modules', '.git', 'dist', '.next', 'build', '__pycache__', '.idea', '.vscode'];
-      const excludeFiles = ['.lock', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
-
-      let results = [];
-
-      function walk(dir, depth) {
-        if (depth > 3) return;
-        try {
-          const entries = fs.readdirSync(dir, { withFileTypes: true });
-          for (const entry of entries) {
-            const fullPath = pathModule.join(dir, entry.name);
-            const relativePath = pathModule.relative(cwd, fullPath);
-
-            if (entry.isDirectory()) {
-              if (excludeDirs.includes(entry.name)) continue;
-              results.push(relativePath);
-              walk(fullPath, depth + 1);
-            } else if (entry.isFile()) {
-              if (excludeFiles.some(ext => entry.name.endsWith(ext))) continue;
-              results.push(relativePath);
-            }
-          }
-        } catch {}
-      }
-
-      walk(cwd, 1);
-      return results.slice(0, 80).join('\n') || '(empty directory)';
-    } catch {
-      return '(could not read directory)';
-    }
-  }
-
-  async _saveConversationLog(task, finalResponse) {
-    try {
-      const logsDir = path.join(os.homedir(), '.yiyan-agent', 'logs');
-      fs.mkdirSync(logsDir, { recursive: true });
-
-      const ts       = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-      const logFile  = path.join(logsDir, `session-${ts}.txt`);
-      const content  = [
-        `Yiyan Agent — Session Log`,
-        `Date: ${new Date().toISOString()}`,
-        `Task: ${task}`,
-        `Working Dir: ${config.WORKING_DIR}`,
-        '═'.repeat(60),
-        this.conversation.exportLog(),
-        '',
-        '═'.repeat(60),
-        'FINAL RESPONSE:',
-        finalResponse,
-      ].join('\n');
-
-      fs.writeFileSync(logFile, content, 'utf8');
-      logger.dim(`Conversation saved: ${logFile}`);
-    } catch (err) {
-      logger.warn(`Could not save log: ${err.message}`);
-    }
-  }
 }
 
-// Pull os into scope for the log save helper
-const os = require('os');
-
 module.exports = YiyanAgent;

package/src/browser-manager.js

@@ -1,78 +1,58 @@
-// src/browser-manager.js — Singleton browser instance manager for reuse
+// src/browser-manager.js — Cross-process browser reuse via CDP
 'use strict';
 
 const { chromium } = require('playwright');
-const YiyanBrowser = require('./browser');
-const logger       = require('./logger');
-const fs           = require('fs');
 const path         = require('path');
 const os           = require('os');
+const fs           = require('fs');
+const logger       = require('./logger');
+const config       = require('./config');
 
-// CDP port file path
 const CDP_PORT_FILE = path.join(os.homedir(), '.yiyan-agent', 'cdp-port.json');
 const CDP_PORT = 9222;
 
-// Global instance for current process
-let _instance = null;
-
 class BrowserManager {
   /**
-   * Get browser instance - connect to existing or launch new
+   * Get browser - connect existing or launch new
    */
   static async getInstance() {
-    // Try to connect to existing browser first
-    const existing = await this._tryConnectExisting();
-    if (existing) {
-      logger.success('Connected to existing browser (reused)');
-      _instance = existing;
-      return _instance;
-    }
-
-    // Launch new browser with CDP port
-    logger.info('Launching new browser...');
-    _instance = await this._launchWithCDP();
-    return _instance;
-  }
-
-  /**
-   * Try to connect to existing browser via CDP
-   */
-  static async _tryConnectExisting() {
+    // Try connect existing browser
     try {
-      // Check if CDP port file exists
-      if (!fs.existsSync(CDP_PORT_FILE)) return null;
+      if (fs.existsSync(CDP_PORT_FILE)) {
+        const portInfo = JSON.parse(fs.readFileSync(CDP_PORT_FILE, 'utf8'));
+        const browserURL = `http://localhost:${portInfo.port || CDP_PORT}`;
 
-      const portInfo = JSON.parse(fs.readFileSync(CDP_PORT_FILE, 'utf8'));
-      const browserURL = `http://localhost:${portInfo.port || CDP_PORT}`;
+        logger.info('Connecting to existing browser...');
+        const browser = await chromium.connectOverCDP(browserURL, { timeout: 5000 });
 
-      // Try to connect
-      const context = await chromium.connectOverCDP(browserURL, {
-        timeout: 3000
-      });
+        // Create NEW page (tab) for this task
+        const page = await browser.newPage();
+        await page.goto(config.YIYAN_URL, { waitUntil: 'domcontentloaded', timeout: 15000 });
+        await page.waitForTimeout(500);
 
-      // Create wrapper instance
-      const wrapper = new YiyanBrowser();
-      wrapper.context = context;
-      wrapper.page = context.pages()[0] || await context.newPage();
-      wrapper._closed = false;
-      wrapper._connected = true;  // Mark as connected, not owned
-
-      return wrapper;
+        logger.success('Connected! Using new tab.');
+        return { browser, page, isNew: false };
+      }
     } catch (err) {
-      // Connection failed, remove stale port file
+      logger.warn('Connection failed, launching new browser...');
       try { fs.unlinkSync(CDP_PORT_FILE); } catch {}
-      return null;
     }
+
+    // Launch new browser with CDP
+    return await this._launchNew();
   }
 
   /**
-   * Launch new browser with CDP port for future connections
+   * Launch new browser with CDP port
    */
-  static async _launchWithCDP() {
-    const wrapper = new YiyanBrowser();
+  static async _launchNew() {
+    logger.info('Launching new browser...');
 
-    // Launch browser with CDP port
+    // Ensure session directory
     const sessionDir = path.join(os.homedir(), '.yiyan-agent', 'session');
+    fs.mkdirSync(sessionDir, { recursive: true });
+
+    // Launch with persistent context + CDP port
     const context = await chromium.launchPersistentContext(sessionDir, {
       headless: false,
       viewport: { width: 1280, height: 900 },
@@ -82,59 +62,45 @@ class BrowserManager {
         '--no-first-run',
         '--no-sandbox',
       ],
-      userAgent: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36',
+      userAgent: 'Mozilla/5.0 AppleWebKit/537.36 Chrome/124.0.0.0 Safari/537.36',
     });
 
-    wrapper.context = context;
-    wrapper.page = context.pages()[0] || await context.newPage();
-    wrapper._closed = false;
-    wrapper._connected = false;  // Owned by this process
+    // Get the browser from context
+    const browser = context.browser();
 
-    // Save CDP port info
+    // Save CDP port
     fs.writeFileSync(CDP_PORT_FILE, JSON.stringify({
       port: CDP_PORT,
+      pid: process.pid,
       launchedAt: Date.now()
     }));
 
-    // Navigate to Yiyan
-    await wrapper._navigate('https://yiyan.baidu.com/');
+    // Use existing page or create new
+    const pages = context.pages();
+    const page = pages.length > 0 ? pages[0] : await context.newPage();
 
-    return wrapper;
-  }
+    await page.goto(config.YIYAN_URL, { waitUntil: 'domcontentloaded', timeout: 15000 });
+    await page.waitForTimeout(800);
 
-  /**
-   * New chat session
-   */
-  static async newChat() {
-    if (_instance) {
-      await _instance.newChat();
-    }
+    logger.success('Browser launched! Tab ready.');
+    return { browser, context, page, isNew: true };
   }
 
   /**
-   * Close browser (only if we own it)
+   * Close current page (tab) but keep browser running
    */
-  static async close() {
-    if (_instance && !_instance._connected) {
-      // We own the browser, close it
-      try {
-        await _instance.close();
-        fs.unlinkSync(CDP_PORT_FILE);
-      } catch {}
-    }
-    // If connected to existing browser, don't close it
-    _instance = null;
+  static async closePage(page) {
+    try {
+      await page.close();
+    } catch {}
   }
 
   /**
-   * Force close (for cleanup on error)
+   * Force close everything (for cleanup)
    */
   static async forceClose() {
-    if (_instance) {
-      try { await _instance.close(); } catch {}
-      try { fs.unlinkSync(CDP_PORT_FILE); } catch {}
-      _instance = null;
-    }
+    try { fs.unlinkSync(CDP_PORT_FILE); } catch {}
+    // Browser will close when user does Ctrl+C or manually
   }
 }
 

package/src/page-agent.js

@@ -0,0 +1,150 @@
+// src/page-agent.js — Agent for a single page/tab
+'use strict';
+
+const logger = require('./logger');
+const config = require('./config');
+
+// Selectors for Yiyan
+const SEL = {
+  chatInput: [
+    '.editable__T7WAW4uW',
+    '[role="textbox"]',
+    '[contenteditable="true"]',
+    'textarea',
+  ],
+  sendButton: [
+    'button[aria-label*="发送"]',
+    'button[type="submit"]',
+  ],
+};
+
+class PageAgent {
+  constructor(page) {
+    this.page = page;
+  }
+
+  /**
+   * Send message to Yiyan
+   */
+  async sendMessage(text) {
+    // Find input
+    let inputEl = null;
+    for (const sel of SEL.chatInput) {
+      try {
+        inputEl = await this.page.waitForSelector(sel, { timeout: 5000, state: 'visible' });
+        if (inputEl) break;
+      } catch {}
+    }
+
+    if (!inputEl) {
+      throw new Error('Cannot find input box');
+    }
+
+    // Focus and clear
+    await inputEl.click({ clickCount: 3, force: true });
+    await this.page.waitForTimeout(100);
+    await this.page.keyboard.press('Delete');
+    await this.page.waitForTimeout(50);
+
+    // Type message
+    await this.page.keyboard.type(text, { delay: 10 });
+    await this.page.keyboard.press('Enter');
+  }
+
+  /**
+   * Wait for response
+   */
+  async waitForResponse() {
+    const timeout = config.RESPONSE_TIMEOUT;
+    const stableDelay = config.STABLE_DELAY;
+    const start = Date.now();
+
+    // Wait for new content
+    await this.page.waitForTimeout(1000);
+
+    // Poll for stable response
+    let lastText = '';
+    let stableStart = null;
+
+    while (Date.now() - start < timeout) {
+      const text = await this._extractAnswer();
+
+      if (text !== lastText && text.length > 0) {
+        lastText = text;
+        stableStart = Date.now();
+      } else if (stableStart && Date.now() - stableStart >= stableDelay) {
+        if (!await this._isGenerating()) {
+          break;
+        }
+        stableStart = null;
+      }
+
+      await this.page.waitForTimeout(200);
+    }
+
+    return this._cleanText(lastText);
+  }
+
+  /**
+   * Extract answer from page
+   */
+  async _extractAnswer() {
+    return await this.page.evaluate(() => {
+      // Try specific selector first
+      const answerEl = document.querySelector('#answer_text_id');
+      if (answerEl) return answerEl.textContent || '';
+
+      // Fallback
+      const candidates = document.querySelectorAll('[class*="answer"], [class*="response"], [class*="markdown"]');
+      for (const el of candidates) {
+        const text = el.textContent || '';
+        if (text.length > 20) return text;
+      }
+
+      return '';
+    });
+  }
+
+  /**
+   * Check if still generating
+   */
+  async _isGenerating() {
+    return await this.page.evaluate(() => {
+      const stopBtn = document.querySelector('button[aria-label*="停止"]');
+      if (stopBtn && stopBtn.offsetParent !== null) return true;
+
+      const loading = document.querySelector('[class*="loading"], [class*="typing"]');
+      if (loading) return true;
+
+      return false;
+    });
+  }
+
+  /**
+   * Clean response text
+   */
+  _cleanText(text) {
+    if (!text) return '';
+
+    // Remove before "准备输出结果"
+    const marker = '准备输出结果';
+    const idx = text.indexOf(marker);
+    if (idx !== -1) {
+      text = text.slice(idx + marker.length).trim();
+    }
+
+    // Remove after markers
+    const cutMarkers = ['重新生成', '换个回答', '输出更详细的', '再多提供'];
+    for (const m of cutMarkers) {
+      const cutIdx = text.indexOf(m);
+      if (cutIdx !== -1) {
+        text = text.slice(0, cutIdx).trim();
+        break;
+      }
+    }
+
+    return text.trim();
+  }
+}
+
+module.exports = PageAgent;