agent-browser 0.0.0 → 0.1.1

package/src/client.ts

@@ -0,0 +1,150 @@
+import * as net from 'net';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import * as path from 'path';
+import * as fs from 'fs';
+import { getSocketPath, isDaemonRunning, setSession, getSession } from './daemon.js';
+import type { Response } from './types.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let DEBUG = false;
+
+export function setDebug(enabled: boolean): void {
+  DEBUG = enabled;
+}
+
+export { setSession, getSession };
+
+function debug(...args: unknown[]): void {
+  if (DEBUG) {
+    console.error('[debug]', ...args);
+  }
+}
+
+/**
+ * Wait for socket to exist
+ */
+async function waitForSocket(maxAttempts = 30): Promise<boolean> {
+  const socketPath = getSocketPath();
+  debug('Waiting for socket at', socketPath);
+  for (let i = 0; i < maxAttempts; i++) {
+    if (fs.existsSync(socketPath)) {
+      debug('Socket found after', i * 100, 'ms');
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  debug('Socket not found after', maxAttempts * 100, 'ms');
+  return false;
+}
+
+/**
+ * Ensure daemon is running, start if not
+ */
+export async function ensureDaemon(): Promise<void> {
+  const session = getSession();
+  debug(`Checking if daemon is running for session "${session}"...`);
+  if (isDaemonRunning()) {
+    debug('Daemon already running');
+    return;
+  }
+
+  debug('Starting daemon...');
+  const daemonPath = path.join(__dirname, 'daemon.js');
+  const child = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, AGENT_BROWSER_DAEMON: '1', AGENT_BROWSER_SESSION: session },
+  });
+  child.unref();
+
+  // Wait for socket to be created
+  const ready = await waitForSocket();
+  if (!ready) {
+    throw new Error('Failed to start daemon');
+  }
+
+  debug(`Daemon started for session "${session}"`);
+}
+
+/**
+ * Send a command to the daemon
+ */
+export async function sendCommand(command: Record<string, unknown>): Promise<Response> {
+  const socketPath = getSocketPath();
+  debug('Sending command:', JSON.stringify(command));
+
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    let buffer = '';
+    const startTime = Date.now();
+
+    const socket = net.createConnection(socketPath);
+
+    socket.on('connect', () => {
+      debug('Connected to daemon, sending command...');
+      socket.write(JSON.stringify(command) + '\n');
+    });
+
+    socket.on('data', (data) => {
+      buffer += data.toString();
+      debug('Received data:', buffer.length, 'bytes');
+
+      // Try to parse complete JSON from buffer
+      const newlineIdx = buffer.indexOf('\n');
+      if (newlineIdx !== -1) {
+        const jsonStr = buffer.substring(0, newlineIdx);
+        try {
+          const response = JSON.parse(jsonStr) as Response;
+          debug('Response received in', Date.now() - startTime, 'ms');
+          resolved = true;
+          socket.end();
+          resolve(response);
+        } catch (e) {
+          debug('JSON parse error:', e);
+        }
+      }
+    });
+
+    socket.on('error', (err) => {
+      debug('Socket error:', err.message);
+      if (!resolved) {
+        reject(new Error(`Connection error: ${err.message}`));
+      }
+    });
+
+    socket.on('close', () => {
+      debug('Socket closed, resolved:', resolved, 'buffer:', buffer.length);
+      if (!resolved && buffer.trim()) {
+        try {
+          const response = JSON.parse(buffer.trim()) as Response;
+          resolve(response);
+        } catch {
+          reject(new Error('Invalid response from daemon'));
+        }
+      } else if (!resolved) {
+        reject(new Error('Connection closed without response'));
+      }
+    });
+
+    // Timeout after 15 seconds (allows for 10s Playwright timeout + overhead)
+    setTimeout(() => {
+      if (!resolved) {
+        debug('Command timeout after 15s');
+        socket.destroy();
+        reject(new Error('Command timeout'));
+      }
+    }, 15000);
+  });
+}
+
+/**
+ * Send a command, ensuring daemon is running first
+ */
+export async function send(command: Record<string, unknown>): Promise<Response> {
+  const startTime = Date.now();
+  await ensureDaemon();
+  debug('ensureDaemon took', Date.now() - startTime, 'ms');
+  return sendCommand(command);
+}

package/src/daemon.ts

@@ -0,0 +1,187 @@
+import * as net from 'net';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { BrowserManager } from './browser.js';
+import { parseCommand, serializeResponse, errorResponse } from './protocol.js';
+import { executeCommand } from './actions.js';
+
+// Session support - each session gets its own socket/pid
+let currentSession = process.env.AGENT_BROWSER_SESSION || 'default';
+
+/**
+ * Set the current session
+ */
+export function setSession(session: string): void {
+  currentSession = session;
+}
+
+/**
+ * Get the current session
+ */
+export function getSession(): string {
+  return currentSession;
+}
+
+/**
+ * Get the socket path for the current session
+ */
+export function getSocketPath(session?: string): string {
+  const sess = session ?? currentSession;
+  return path.join(os.tmpdir(), `agent-browser-${sess}.sock`);
+}
+
+/**
+ * Get the PID file path for the current session
+ */
+export function getPidFile(session?: string): string {
+  const sess = session ?? currentSession;
+  return path.join(os.tmpdir(), `agent-browser-${sess}.pid`);
+}
+
+/**
+ * Check if daemon is running for the current session
+ */
+export function isDaemonRunning(session?: string): boolean {
+  const pidFile = getPidFile(session);
+  if (!fs.existsSync(pidFile)) return false;
+
+  try {
+    const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+    // Check if process exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    // Process doesn't exist, clean up stale files
+    cleanupSocket(session);
+    return false;
+  }
+}
+
+/**
+ * Clean up socket and PID file for the current session
+ */
+export function cleanupSocket(session?: string): void {
+  const socketPath = getSocketPath(session);
+  const pidFile = getPidFile(session);
+  try {
+    if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath);
+    if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile);
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+/**
+ * Start the daemon server
+ */
+export async function startDaemon(): Promise<void> {
+  // Clean up any stale socket
+  cleanupSocket();
+
+  const browser = new BrowserManager();
+  let shuttingDown = false;
+
+  const server = net.createServer((socket) => {
+    let buffer = '';
+
+    socket.on('data', async (data) => {
+      buffer += data.toString();
+
+      // Process complete lines
+      while (buffer.includes('\n')) {
+        const newlineIdx = buffer.indexOf('\n');
+        const line = buffer.substring(0, newlineIdx);
+        buffer = buffer.substring(newlineIdx + 1);
+
+        if (!line.trim()) continue;
+
+        try {
+          const parseResult = parseCommand(line);
+
+          if (!parseResult.success) {
+            const resp = errorResponse(parseResult.id ?? 'unknown', parseResult.error);
+            socket.write(serializeResponse(resp) + '\n');
+            continue;
+          }
+
+          // Auto-launch browser if not already launched and this isn't a launch command
+          if (
+            !browser.isLaunched() &&
+            parseResult.command.action !== 'launch' &&
+            parseResult.command.action !== 'close'
+          ) {
+            await browser.launch({ id: 'auto', action: 'launch', headless: true });
+          }
+
+          // Handle close command specially
+          if (parseResult.command.action === 'close') {
+            const response = await executeCommand(parseResult.command, browser);
+            socket.write(serializeResponse(response) + '\n');
+
+            if (!shuttingDown) {
+              shuttingDown = true;
+              setTimeout(() => {
+                server.close();
+                cleanupSocket();
+                process.exit(0);
+              }, 100);
+            }
+            return;
+          }
+
+          const response = await executeCommand(parseResult.command, browser);
+          socket.write(serializeResponse(response) + '\n');
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          socket.write(serializeResponse(errorResponse('error', message)) + '\n');
+        }
+      }
+    });
+
+    socket.on('error', () => {
+      // Client disconnected, ignore
+    });
+  });
+
+  const socketPath = getSocketPath();
+  const pidFile = getPidFile();
+
+  // Write PID file before listening
+  fs.writeFileSync(pidFile, process.pid.toString());
+
+  server.listen(socketPath, () => {
+    // Daemon is ready
+  });
+
+  server.on('error', (err) => {
+    console.error('Server error:', err);
+    cleanupSocket();
+    process.exit(1);
+  });
+
+  // Handle shutdown signals
+  const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    await browser.close();
+    server.close();
+    cleanupSocket();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Keep process alive
+  process.stdin.resume();
+}
+
+// Run daemon if this is the entry point
+if (process.argv[1]?.endsWith('daemon.js') || process.env.AGENT_BROWSER_DAEMON === '1') {
+  startDaemon().catch((err) => {
+    console.error('Daemon error:', err);
+    cleanupSocket();
+    process.exit(1);
+  });
+}