yiyan-browser-agent 1.0.19 → 1.0.20

package/package.json

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

package/src/browser-manager.js

@@ -1,83 +1,139 @@
 // src/browser-manager.js — Singleton browser instance manager for reuse
 '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');
 
-// Global singleton instance
+// 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;
-let _initialized = false;
-let _hasError = false;
 
 class BrowserManager {
   /**
-   * Get or create browser instance (singleton)
-   * If previous run had error, will restart the browser
+   * Get browser instance - connect to existing or launch new
    */
   static async getInstance() {
-    // If there was an error, restart the browser
-    if (_hasError && _instance) {
-      logger.info('Previous error detected, restarting browser...');
-      try {
-        await _instance.close();
-      } catch {}
-      _instance = null;
-      _initialized = false;
-      _hasError = false;
-    }
-
-    // Create new instance if needed
-    if (!_instance) {
-      _instance = new YiyanBrowser();
-      await _instance.launch();
-      _initialized = true;
-      logger.success('Browser initialized (will be reused)');
+    // 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;
   }
 
   /**
-   * Mark that an error occurred (browser should be restarted next time)
+   * Try to connect to existing browser via CDP
    */
-  static markError() {
-    _hasError = true;
+  static async _tryConnectExisting() {
+    try {
+      // Check if CDP port file exists
+      if (!fs.existsSync(CDP_PORT_FILE)) return null;
+
+      const portInfo = JSON.parse(fs.readFileSync(CDP_PORT_FILE, 'utf8'));
+      const browserURL = `http://localhost:${portInfo.port || CDP_PORT}`;
+
+      // Try to connect
+      const context = await chromium.connectOverCDP(browserURL, {
+        timeout: 3000
+      });
+
+      // 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;
+    } catch (err) {
+      // Connection failed, remove stale port file
+      try { fs.unlinkSync(CDP_PORT_FILE); } catch {}
+      return null;
+    }
   }
 
   /**
-   * Mark that everything is working fine (keep browser open)
+   * Launch new browser with CDP port for future connections
    */
-  static markSuccess() {
-    _hasError = false;
+  static async _launchWithCDP() {
+    const wrapper = new YiyanBrowser();
+
+    // Launch browser with CDP port
+    const sessionDir = path.join(os.homedir(), '.yiyan-agent', 'session');
+    const context = await chromium.launchPersistentContext(sessionDir, {
+      headless: false,
+      viewport: { width: 1280, height: 900 },
+      args: [
+        `--remote-debugging-port=${CDP_PORT}`,
+        '--disable-blink-features=AutomationControlled',
+        '--no-first-run',
+        '--no-sandbox',
+      ],
+      userAgent: 'Mozilla/5.0 (X11; Linux x86_64) 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
+
+    // Save CDP port info
+    fs.writeFileSync(CDP_PORT_FILE, JSON.stringify({
+      port: CDP_PORT,
+      launchedAt: Date.now()
+    }));
+
+    // Navigate to Yiyan
+    await wrapper._navigate('https://yiyan.baidu.com/');
+
+    return wrapper;
   }
 
   /**
-   * Check if browser is currently initialized
+   * New chat session
    */
-  static isInitialized() {
-    return _initialized && _instance && !_instance._closed;
+  static async newChat() {
+    if (_instance) {
+      await _instance.newChat();
+    }
   }
 
   /**
-   * Force close the browser (for shutdown)
+   * Close browser (only if we own it)
    */
   static async close() {
-    if (_instance) {
+    if (_instance && !_instance._connected) {
+      // We own the browser, close it
       try {
         await _instance.close();
+        fs.unlinkSync(CDP_PORT_FILE);
       } catch {}
-      _instance = null;
-      _initialized = false;
-      _hasError = false;
     }
+    // If connected to existing browser, don't close it
+    _instance = null;
   }
 
   /**
-   * Reset for new chat session
+   * Force close (for cleanup on error)
    */
-  static async newChat() {
+  static async forceClose() {
     if (_instance) {
-      await _instance.newChat();
+      try { await _instance.close(); } catch {}
+      try { fs.unlinkSync(CDP_PORT_FILE); } catch {}
+      _instance = null;
     }
   }
 }

package/src/index.js

@@ -151,25 +151,24 @@ async function main() {
   const agent = new YiyanAgent({ saveLog: opts.saveLog });
 
   // ── Graceful shutdown handler ──────────────────────────────────────────────
-  const shutdown = async (code = 0, closeBrowser = true) => {
-    if (closeBrowser) {
-      logger.info('\nShutting down...');
-      try { await agent.shutdown(); } catch {}
-    }
+  // Only close browser on explicit exit (Ctrl+C, error)
+  const shutdown = async (code = 0) => {
+    logger.info('\nShutting down...');
+    try { await BrowserManager.forceClose(); } catch {}
     process.exit(code);
   };
 
-  process.on('SIGINT',  () => shutdown(0, true));
-  process.on('SIGTERM', () => shutdown(0, true));
+  process.on('SIGINT',  () => shutdown(0));
+  process.on('SIGTERM', () => shutdown(0));
   process.on('uncaughtException', async err => {
     logger.error(`Uncaught error: ${err.message}`);
     if (config.DEBUG) console.error(err.stack);
-    await shutdown(1, true);  // Error: close browser
+    await shutdown(1);
   });
   process.on('unhandledRejection', async reason => {
     logger.error(`Unhandled rejection: ${reason}`);
     if (config.DEBUG) console.error(reason);
-    await shutdown(1, true);  // Error: close browser
+    await shutdown(1);
   });
 
   // ── Calibrate mode ─────────────────────────────────────────────────────────
@@ -205,36 +204,9 @@ async function main() {
     } else {
       const result = await agent.run(opts.task);
       console.log(JSON.stringify(result, null, 2));
-
-      // Success: keep process alive for next task (read from stdin)
-      if (result.status === 'success') {
-        logger.info('Browser kept open. Enter next task or Ctrl+C to exit...');
-        const readline = require('readline');
-        const rl = readline.createInterface({
-          input  : process.stdin,
-          output : process.stdout,
-        });
-
-        // Wait for next task
-        while (true) {
-          const nextTask = await new Promise(resolve => rl.question('', resolve));
-          const trimmed = nextTask.trim();
-
-          if (!trimmed) continue;
-          if (['exit', 'quit', 'q'].includes(trimmed.toLowerCase())) break;
-
-          // Run next task with same browser
-          agent.conversation = new ConversationManager();
-          await BrowserManager.newChat();
-          const nextResult = await agent.run(trimmed);
-          console.log(JSON.stringify(nextResult, null, 2));
-        }
-
-        rl.close();
-        await shutdown(0, true);
-      } else {
-        await shutdown(0, true);  // Error: close browser
-      }
+      // Success: don't close browser, next process can connect to it
+      // Error: close browser
+      process.exit(result.status === 'error' ? 1 : 0);
     }
   } catch (err) {
     console.log(JSON.stringify({