abu-browser-bridge 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -5,10 +5,12 @@
  * This process acts as a bridge between Abu (via MCP stdio transport)
  * and the Chrome Extension (via WebSocket).
  *
+ * Startup strategy:
+ * 1. Check if an old bridge is running via the discovery endpoint (port 9875)
+ * 2. If found, kill it by PID so we can take over the ports
+ * 3. Start discovery (9875) + WS (9876) on fixed ports — no fallback
+ *
  * Usage:
  *   npx abu-browser-bridge [--port 9876]
- *
- * Abu connects to this as an MCP server (stdio).
- * Chrome Extension connects via WebSocket (ws://127.0.0.1:9876).
  */
 export {};

package/dist/index.js

@@ -5,36 +5,63 @@
  * This process acts as a bridge between Abu (via MCP stdio transport)
  * and the Chrome Extension (via WebSocket).
  *
+ * Startup strategy:
+ * 1. Check if an old bridge is running via the discovery endpoint (port 9875)
+ * 2. If found, kill it by PID so we can take over the ports
+ * 3. Start discovery (9875) + WS (9876) on fixed ports — no fallback
+ *
  * Usage:
  *   npx abu-browser-bridge [--port 9876]
- *
- * Abu connects to this as an MCP server (stdio).
- * Chrome Extension connects via WebSocket (ws://127.0.0.1:9876).
  */
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { execSync } from 'child_process';
 import { startWSServer, stopWSServer } from './wsServer.js';
 import { registerTools } from './tools.js';
 const DEFAULT_WS_PORT = 9876;
-const PORT_RANGE = 5; // ports 9876-9880
+const DISCOVERY_PORT = 9875;
 /**
- * Kill any stale abu-browser-bridge processes listening on our port range.
- * This ensures the Extension always connects to the newest bridge.
- * Cross-platform: uses lsof on macOS/Linux, netstat+taskkill on Windows.
+ * Kill any stale abu-browser-bridge by querying the discovery endpoint.
+ * If an old bridge is running, its /status returns { pid }, and we kill it.
+ * Also kills any process on the WS port range as a fallback.
  */
-function killStaleBridges(basePort) {
+async function killStaleBridges(wsPort) {
     const myPid = process.pid;
+    // Method 1: Query discovery endpoint for PID (most reliable)
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 2000);
+        const res = await fetch(`http://127.0.0.1:${DISCOVERY_PORT}/status`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (res.ok) {
+            const data = await res.json();
+            if (data.pid && data.pid !== myPid) {
+                try {
+                    process.kill(data.pid, 'SIGTERM');
+                    console.error(`[abu-bridge] Killed old bridge (pid: ${data.pid}) via discovery`);
+                    // Wait a bit for ports to be released
+                    await new Promise(r => setTimeout(r, 500));
+                }
+                catch {
+                    // Already dead
+                }
+            }
+        }
+    }
+    catch {
+        // Discovery not available — old bridge might not have it
+    }
+    // Method 2: Kill any process on our ports (fallback for old versions without discovery)
+    const portsToCheck = [DISCOVERY_PORT, wsPort];
     const isWindows = process.platform === 'win32';
     try {
-        let pids;
         if (isWindows) {
-            // Windows: use netstat to find PIDs on each port
-            pids = new Set();
+            const { execSync } = await import('child_process');
             const output = execSync('netstat -ano -p TCP', { encoding: 'utf-8', timeout: 5000 });
-            for (let p = basePort; p < basePort + PORT_RANGE; p++) {
-                // Match lines like "  TCP    127.0.0.1:9876    0.0.0.0:0    LISTENING    12345"
-                const regex = new RegExp(`127\\.0\\.0\\.1:${p}\\s+.*LISTENING\\s+(\\d+)`, 'g');
+            const pids = new Set();
+            for (const port of portsToCheck) {
+                const regex = new RegExp(`127\\.0\\.0\\.1:${port}\\s+.*LISTENING\\s+(\\d+)`, 'g');
                 let match;
                 while ((match = regex.exec(output)) !== null) {
                     const pid = parseInt(match[1], 10);
@@ -45,37 +72,34 @@ function killStaleBridges(basePort) {
             for (const pid of pids) {
                 try {
                     execSync(`taskkill /PID ${pid} /F`, { timeout: 3000 });
-                    console.error(`[abu-bridge] Killed stale process ${pid}`);
-                }
-                catch {
-                    // Process may have already exited
+                    console.error(`[abu-bridge] Killed stale process ${pid} (port scan)`);
                 }
+                catch { /* already dead */ }
             }
         }
         else {
-            // macOS/Linux: single lsof call with multiple -i flags
-            const portFlags = Array.from({ length: PORT_RANGE }, (_, i) => `-ti:${basePort + i}`);
+            const { execSync } = await import('child_process');
+            const portFlags = portsToCheck.map(p => `-ti:${p}`);
             const output = execSync(`lsof ${portFlags.join(' ')}`, { encoding: 'utf-8', timeout: 5000 }).trim();
-            if (!output)
-                return;
-            pids = new Set(output.split('\n').map(l => parseInt(l.trim(), 10)).filter(pid => pid && pid !== myPid));
-            for (const pid of pids) {
-                try {
-                    process.kill(pid, 'SIGTERM');
-                    console.error(`[abu-bridge] Killed stale process ${pid}`);
-                }
-                catch {
-                    // Process may have already exited
+            if (output) {
+                const pids = new Set(output.split('\n').map(l => parseInt(l.trim(), 10)).filter(pid => pid && pid !== myPid));
+                for (const pid of pids) {
+                    try {
+                        process.kill(pid, 'SIGTERM');
+                        console.error(`[abu-bridge] Killed stale process ${pid} (port scan)`);
+                    }
+                    catch { /* already dead */ }
                 }
             }
         }
     }
     catch {
-        // Command not available or no processes found — that's fine
+        // No processes found or command failed — that's fine
     }
+    // Wait for ports to be released
+    await new Promise(r => setTimeout(r, 300));
 }
 async function main() {
-    // Parse CLI args
     const args = process.argv.slice(2);
     let wsPort = DEFAULT_WS_PORT;
     const portIndex = args.indexOf('--port');
@@ -86,24 +110,20 @@ async function main() {
             process.exit(1);
         }
     }
-    // 0. Kill any stale bridge processes so the Extension connects to us
-    killStaleBridges(wsPort);
-    // 1. Start WebSocket server (for Chrome Extension)
-    // startWSServer already tries ports 9876-9880 with fallback if a port is still in TIME_WAIT
+    // 0. Kill any stale bridge so we can take over the fixed ports
+    await killStaleBridges(wsPort);
+    // 1. Start WebSocket + Discovery server on fixed ports (no fallback)
     try {
-        const actualPort = await startWSServer(wsPort);
-        if (actualPort !== wsPort) {
-            console.error(`[abu-bridge] Note: using port ${actualPort} instead of ${wsPort}`);
-        }
+        await startWSServer(wsPort);
     }
     catch (err) {
         console.error(`Failed to start WS server:`, err);
         process.exit(1);
     }
-    // 2. Create MCP server (for Abu)
+    // 2. Create MCP server
     const mcpServer = new McpServer({
         name: 'abu-browser-bridge',
-        version: '0.1.0',
+        version: '0.3.0',
     });
     // 3. Register browser tools
     registerTools(mcpServer);

package/dist/wsServer.d.ts

@@ -7,9 +7,9 @@
  */
 import type { BridgeResponse } from './types.js';
 /**
- * Start the WebSocket server. If the default port is occupied,
- * try a few alternative ports. The Extension discovers the port
- * via the HTTP discovery endpoint.
+ * Start the WebSocket server on a fixed port.
+ * The caller (index.ts) is responsible for killing stale bridges first.
+ * No port fallback — if the port is taken, it's a fatal error.
  */
 export declare function startWSServer(port?: number): Promise<number>;
 /**

package/dist/wsServer.js

@@ -95,36 +95,15 @@ function startDiscoveryServer() {
 }
 // --- WebSocket Server ---
 /**
- * Start the WebSocket server. If the default port is occupied,
- * try a few alternative ports. The Extension discovers the port
- * via the HTTP discovery endpoint.
+ * Start the WebSocket server on a fixed port.
+ * The caller (index.ts) is responsible for killing stale bridges first.
+ * No port fallback — if the port is taken, it's a fatal error.
  */
 export async function startWSServer(port = DEFAULT_WS_PORT) {
-    // Start discovery endpoint first (non-blocking if port taken)
     await startDiscoveryServer();
-    const MAX_RETRIES = 5;
-    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-        const tryPort = port + attempt;
-        const inUse = await isPortInUse(tryPort, '127.0.0.1');
-        if (inUse) {
-            console.error(`[abu-bridge] Port ${tryPort} is in use, trying ${tryPort + 1}...`);
-            continue;
-        }
-        try {
-            await listenOnPort(tryPort);
-            activePort = tryPort;
-            return tryPort;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (msg.includes('EADDRINUSE') && attempt < MAX_RETRIES - 1) {
-                console.error(`[abu-bridge] Port ${tryPort} race condition, trying next...`);
-                continue;
-            }
-            throw err;
-        }
-    }
-    throw new Error(`All ports ${port}-${port + MAX_RETRIES - 1} are in use`);
+    await listenOnPort(port);
+    activePort = port;
+    return port;
 }
 function listenOnPort(port) {
     return new Promise((resolve, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "abu-browser-bridge",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "MCP Server that bridges Abu AI assistant with Chrome Extension for browser automation",
   "type": "module",
   "license": "MIT",