@bsbofmusic/agent-browser-mcp-opencode 0.1.1 → 1.0.0

package/src/ensure.js

@@ -0,0 +1,425 @@
+import { execSync, exec } from 'child_process';
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import semver from 'semver';
+import { runFullDetection } from './detect.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+
+const ALWAYS_LATEST = process.env.ALWAYS_LATEST !== '0';
+const UPDATE_STRATEGY = process.env.UPDATE_STRATEGY || 'simple';
+const LOG_LEVEL = process.env.LOG_LEVEL || 'info';
+const LOCK_FILE = path.join(os.tmpdir(), 'agent-browser-mcp.lock');
+
+const MCP_VERSION = '1.0.0';
+const MIN_NODE_VERSION = '18.0.0';
+
+function log(level, message, data = null) {
+  const levels = { error: 0, warn: 1, info: 2, debug: 3 };
+  if (levels[level] <= levels[LOG_LEVEL]) {
+    const timestamp = new Date().toISOString();
+    console.error(`[${timestamp}] [${level.toUpperCase()}] ${message}`, data ? JSON.stringify(data) : '');
+  }
+}
+
+function execPromise(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const defaultOptions = { 
+      encoding: 'utf8', 
+      timeout: 300000,
+      ...options 
+    };
+    exec(command, defaultOptions, (error, stdout, stderr) => {
+      if (error) {
+        reject({ error, stdout, stderr });
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
+
+async function acquireLock() {
+  const maxWait = 30000;
+  const start = Date.now();
+  
+  while (true) {
+    try {
+      if (!fs.existsSync(LOCK_FILE)) {
+        fs.writeFileSync(LOCK_FILE, `${process.pid}:${Date.now()}`);
+        log('debug', 'Lock acquired', { pid: process.pid });
+        return true;
+      }
+      
+      const lockContent = fs.readFileSync(LOCK_FILE, 'utf8');
+      const [lockPid, lockTime] = lockContent.split(':');
+      
+      if (Date.now() - parseInt(lockTime) > maxWait) {
+        log('warn', 'Stale lock detected, removing', { lockPid, lockTime });
+        fs.unlinkSync(LOCK_FILE);
+        continue;
+      }
+      
+      try {
+        process.kill(lockPid, 0);
+      } catch (e) {
+        fs.unlinkSync(LOCK_FILE);
+        log('debug', 'Stale lock removed');
+        continue;
+      }
+      
+      await new Promise(r => setTimeout(r, 1000));
+    } catch (e) {
+      await new Promise(r => setTimeout(r, 1000));
+    }
+    
+    if (Date.now() - start > maxWait) {
+      throw new Error('Failed to acquire lock after 30 seconds');
+    }
+  }
+}
+
+function releaseLock() {
+  try {
+    if (fs.existsSync(LOCK_FILE)) {
+      fs.unlinkSync(LOCK_FILE);
+      log('debug', 'Lock released');
+    }
+  } catch (e) {
+    log('warn', 'Failed to release lock', { error: e.message });
+  }
+}
+
+async function checkNodeVersion() {
+  const currentVersion = process.version;
+  if (!semver.gte(currentVersion, MIN_NODE_VERSION)) {
+    return { ok: false, error: `Node.js version ${currentVersion} is below minimum required ${MIN_NODE_VERSION}` };
+  }
+  return { ok: true, version: currentVersion };
+}
+
+async function checkNpmAvailable() {
+  try {
+    execSync('npm --version', { stdio: 'ignore' });
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: 'npm is not available' };
+  }
+}
+
+async function installAgentBrowser() {
+  const logs = [];
+  
+  log('info', 'Installing agent-browser globally...');
+  logs.push('Step 1: Install agent-browser via npm');
+  
+  try {
+    execSync('npm install -g agent-browser', { 
+      encoding: 'utf8', 
+      stdio: 'inherit',
+      timeout: 300000 
+    });
+    logs.push('agent-browser installed successfully');
+  } catch (e) {
+    const errorMsg = `Failed to install agent-browser: ${e.message}`;
+    log('error', errorMsg);
+    logs.push(errorMsg);
+    return { ok: false, logs, error: errorMsg };
+  }
+  
+  return { ok: true, logs };
+}
+
+async function installChromium() {
+  const logs = [];
+  
+  log('info', 'Installing Chromium browser...');
+  logs.push('Step 2: Install Chromium browser');
+  
+  try {
+    execSync('npx agent-browser install', { 
+      encoding: 'utf8', 
+      stdio: 'inherit',
+      timeout: 300000 
+    });
+    logs.push('Chromium installed successfully');
+  } catch (e) {
+    try {
+      log('warn', 'npx install failed, trying direct agent-browser install');
+      execSync('agent-browser install', { 
+        encoding: 'utf8', 
+        stdio: 'inherit',
+        timeout: 300000 
+      });
+      logs.push('Chromium installed via agent-browser install');
+    } catch (e2) {
+      const errorMsg = `Failed to install Chromium: ${e2.message}`;
+      log('error', errorMsg);
+      logs.push(errorMsg);
+      return { ok: false, logs, error: errorMsg };
+    }
+  }
+  
+  return { ok: true, logs };
+}
+
+async function verifyInstallation() {
+  const logs = [];
+  
+  logs.push('Step 3: Verify installation');
+  
+  try {
+    const version = execSync('agent-browser --version', { encoding: 'utf8' }).trim();
+    logs.push(`agent-browser version: ${version}`);
+  } catch (e) {
+    const errorMsg = 'agent-browser not found in PATH after installation';
+    log('error', errorMsg);
+    logs.push(errorMsg);
+    return { ok: false, logs, error: errorMsg };
+  }
+  
+  try {
+    execSync('agent-browser --help', { encoding: 'utf8', stdio: 'ignore' });
+    logs.push('Chromium is ready');
+  } catch (e) {
+    const errorMsg = 'Chromium may not be fully installed';
+    log('warn', errorMsg);
+    logs.push(errorMsg);
+  }
+  
+  return { ok: true, logs };
+}
+
+async function getAgentBrowserVersion() {
+  try {
+    const version = execSync('agent-browser --version', { encoding: 'utf8' }).trim();
+    return { installed: true, version };
+  } catch (e) {
+    return { installed: false, version: null };
+  }
+}
+
+async function checkForUpdates() {
+  const current = await getAgentBrowserVersion();
+  
+  if (!current.installed) {
+    return { hasUpdate: null, currentVersion: null, latestVersion: null };
+  }
+  
+  try {
+    const npmVersion = execSync('npm view agent-browser version', { encoding: 'utf8' }).trim();
+    const hasUpdate = semver.lt(current.version, npmVersion);
+    
+    return {
+      hasUpdate,
+      currentVersion: current.version,
+      latestVersion: npmVersion,
+    };
+  } catch (e) {
+    return { hasUpdate: null, currentVersion: current.version, latestVersion: null };
+  }
+}
+
+async function upgradeAgentBrowser() {
+  const logs = [];
+  
+  log('info', 'Upgrading agent-browser to latest...');
+  logs.push('Upgrading agent-browser to latest version');
+  
+  try {
+    execSync('npm install -g agent-browser@latest', { 
+      encoding: 'utf8', 
+      stdio: 'inherit',
+      timeout: 300000 
+    });
+    logs.push('Upgrade completed');
+    
+    const version = execSync('agent-browser --version', { encoding: 'utf8' }).trim();
+    logs.push(`New version: ${version}`);
+    
+    return { ok: true, logs, version };
+  } catch (e) {
+    const errorMsg = `Upgrade failed: ${e.message}`;
+    log('error', errorMsg);
+    logs.push(errorMsg);
+    return { ok: false, logs, error: errorMsg };
+  }
+}
+
+export async function ensureLatest() {
+  if (!ALWAYS_LATEST) {
+    log('info', 'always-latest disabled, skipping update check');
+    return { ok: true, skipped: true };
+  }
+  
+  log('info', 'Running ensureLatest...');
+  
+  const updateCheck = await checkForUpdates();
+  
+  if (updateCheck.hasUpdate === null) {
+    log('warn', 'Could not check for updates');
+    return { ok: true, skipped: true, reason: 'update_check_failed' };
+  }
+  
+  if (!updateCheck.hasUpdate) {
+    log('info', 'Already at latest version', updateCheck);
+    return { 
+      ok: true, 
+      skipped: true, 
+      currentVersion: updateCheck.currentVersion,
+      latestVersion: updateCheck.latestVersion,
+      message: 'Already at latest version' 
+    };
+  }
+  
+  log('info', 'Update available', updateCheck);
+  
+  const upgradeResult = await upgradeAgentBrowser();
+  
+  return {
+    ok: upgradeResult.ok,
+    skipped: false,
+    currentVersion: updateCheck.currentVersion,
+    latestVersion: updateCheck.latestVersion,
+    logs: upgradeResult.logs,
+    error: upgradeResult.error,
+  };
+}
+
+export async function bootstrapEnsure() {
+  log('info', 'Starting bootstrapEnsure...');
+  
+  await acquireLock();
+  
+  try {
+    const logs = [];
+    const startTime = Date.now();
+    
+    logs.push(`[${new Date().toISOString()}] Starting bootstrapEnsure`);
+    
+    const nodeCheck = await checkNodeVersion();
+    if (!nodeCheck.ok) {
+      return { ok: false, logs: nodeCheck.error, nextSteps: ['Upgrade Node.js to >= 18.0.0'] };
+    }
+    logs.push(`Node.js version: ${nodeCheck.version}`);
+    
+    const npmCheck = await checkNpmAvailable();
+    if (!npmCheck.ok) {
+      return { 
+        ok: false, 
+        logs, 
+        error: npmCheck.error,
+        nextSteps: ['Install Node.js with npm', 'Add npm to PATH'] 
+      };
+    }
+    logs.push('npm is available');
+    
+    const detection = await runFullDetection();
+    logs.push(`Detection: agent-browser installed=${detection.agentBrowser.installed}`);
+    
+    if (!detection.agentBrowser.installed) {
+      const installResult = await installAgentBrowser();
+      logs.push(...installResult.logs);
+      
+      if (!installResult.ok) {
+        return { 
+          ok: false, 
+          logs, 
+          error: installResult.error,
+          nextSteps: ['Check npm permissions', 'Try: npm install -g agent-browser --unsafe-perm'] 
+        };
+      }
+    }
+    
+    if (!detection.agentBrowser.chromiumInstalled) {
+      const chromiumResult = await installChromium();
+      logs.push(...chromiumResult.logs);
+      
+      if (!chromiumResult.ok) {
+        return { 
+          ok: false, 
+          logs, 
+          error: chromiumResult.error,
+          nextSteps: ['Manually run: npx agent-browser install', 'Check system dependencies'] 
+        };
+      }
+    }
+    
+    const verifyResult = await verifyInstallation();
+    logs.push(...verifyResult.logs);
+    
+    if (!verifyResult.ok) {
+      return { 
+        ok: false, 
+        logs, 
+        error: verifyResult.error,
+        nextSteps: ['Run: agent-browser install', 'Check PATH configuration'] 
+      };
+    }
+    
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] bootstrapEnsure completed in ${elapsed}ms`);
+    
+    return { 
+      ok: true, 
+      logs,
+      duration: elapsed,
+    };
+  } finally {
+    releaseLock();
+  }
+}
+
+export async function fullEnsure() {
+  await acquireLock();
+  
+  try {
+    const logs = [];
+    const startTime = Date.now();
+    
+    logs.push(`[${new Date().toISOString()}] Starting fullEnsure (manual trigger)`);
+    
+    const reinstall = await installAgentBrowser();
+    if (!reinstall.ok) {
+      return { ok: false, logs: reinstall.logs, error: reinstall.error };
+    }
+    logs.push(...reinstall.logs);
+    
+    const chromium = await installChromium();
+    if (!chromium.ok) {
+      return { ok: false, logs: chromium.logs, error: chromium.error };
+    }
+    logs.push(...chromium.logs);
+    
+    const verify = await verifyInstallation();
+    logs.push(...verify.logs);
+    
+    const updateCheck = await checkForUpdates();
+    logs.push(`Update check: current=${updateCheck.currentVersion}, latest=${updateCheck.latestVersion}`);
+    
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] fullEnsure completed in ${elapsed}ms`);
+    
+    return {
+      ok: verify.ok && chromium.ok,
+      logs,
+      duration: elapsed,
+      version: updateCheck.currentVersion,
+      latestVersion: updateCheck.latestVersion,
+    };
+  } finally {
+    releaseLock();
+  }
+}
+
+export default {
+  bootstrapEnsure,
+  fullEnsure,
+  ensureLatest,
+  checkForUpdates,
+  getAgentBrowserVersion,
+};

package/src/tools/actions/click.js

@@ -0,0 +1,77 @@
+import { execSync } from 'child_process';
+
+export const clickTool = {
+  name: 'browser_click',
+  description: 'Click an element. Use ref from snapshot (e.g., @e1) or CSS selector (e.g., #button).',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      selector: {
+        type: 'string',
+        description: 'Element selector (e.g., @e1, #submit, button.primary)',
+      },
+      newTab: {
+        type: 'boolean',
+        description: 'Open link in new tab',
+        default: false,
+      },
+    },
+    required: ['selector'],
+  },
+};
+
+export async function clickToolHandler(args) {
+  const { selector, newTab = false } = args;
+  const logs = [];
+  const startTime = Date.now();
+  
+  logs.push(`[${new Date().toISOString()}] browser_click: ${selector}`);
+  
+  try {
+    let command = `click "${selector}"`;
+    if (newTab) command += ' --new-tab';
+    
+    const stdout = execSync(`agent-browser ${command} --json`, {
+      encoding: 'utf8',
+      timeout: 30000,
+    });
+    
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] Completed in ${elapsed}ms`);
+    
+    let parsed;
+    try {
+      parsed = JSON.parse(stdout);
+    } catch {
+      parsed = { success: true };
+    }
+    
+    return {
+      ok: true,
+      logs,
+      stdout,
+      output: parsed,
+      selector,
+      duration: elapsed,
+    };
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] Error: ${error.message}`);
+    
+    const nextSteps = [
+      'Run browser_snapshot first to get element refs',
+      'Verify selector is correct',
+      'Wait for element: browser_wait',
+    ];
+    
+    return {
+      ok: false,
+      logs,
+      stderr: error.stderr || '',
+      error: error.message,
+      selector,
+      duration: elapsed,
+      nextSteps,
+    };
+  }
+}

package/src/tools/actions/close.js

@@ -0,0 +1,45 @@
+import { execSync } from 'child_process';
+
+export const closeTool = {
+  name: 'browser_close',
+  description: 'Close the browser. Ends the current browser session.',
+  inputSchema: {
+    type: 'object',
+    properties: {},
+  },
+};
+
+export async function closeToolHandler(args = {}) {
+  const logs = [];
+  const startTime = Date.now();
+  
+  logs.push(`[${new Date().toISOString()}] browser_close called`);
+  
+  try {
+    const stdout = execSync('agent-browser close --json', {
+      encoding: 'utf8',
+      timeout: 10000,
+    });
+    
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] Completed in ${elapsed}ms`);
+    
+    return {
+      ok: true,
+      logs,
+      stdout,
+      duration: elapsed,
+    };
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] Error: ${error.message}`);
+    
+    return {
+      ok: false,
+      logs,
+      stderr: error.stderr || '',
+      error: error.message,
+      duration: elapsed,
+    };
+  }
+}

package/src/tools/actions/fill.js

@@ -0,0 +1,77 @@
+import { execSync } from 'child_process';
+
+export const fillTool = {
+  name: 'browser_fill',
+  description: 'Clear and fill an input field. Use ref from snapshot (e.g., @e1) or CSS selector.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      selector: {
+        type: 'string',
+        description: 'Element selector (e.g., @e1, #email, input[name="email"])',
+      },
+      value: {
+        type: 'string',
+        description: 'Value to fill in the input field',
+      },
+    },
+    required: ['selector', 'value'],
+  },
+};
+
+export async function fillToolHandler(args) {
+  const { selector, value } = args;
+  const logs = [];
+  const startTime = Date.now();
+  
+  logs.push(`[${new Date().toISOString()}] browser_fill: ${selector} = "${value}"`);
+  
+  try {
+    const command = `fill "${selector}" "${value}"`;
+    
+    const stdout = execSync(`agent-browser ${command} --json`, {
+      encoding: 'utf8',
+      timeout: 30000,
+    });
+    
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] Completed in ${elapsed}ms`);
+    
+    let parsed;
+    try {
+      parsed = JSON.parse(stdout);
+    } catch {
+      parsed = { success: true };
+    }
+    
+    return {
+      ok: true,
+      logs,
+      stdout,
+      output: parsed,
+      selector,
+      value,
+      duration: elapsed,
+    };
+  } catch (error) {
+    const elapsed = Date.now() - startTime;
+    logs.push(`[${new Date().toISOString()}] Error: ${error.message}`);
+    
+    const nextSteps = [
+      'Run browser_snapshot first to get element refs',
+      'Verify selector targets an input element',
+      'Wait for element: browser_wait',
+    ];
+    
+    return {
+      ok: false,
+      logs,
+      stderr: error.stderr || '',
+      error: error.message,
+      selector,
+      value,
+      duration: elapsed,
+      nextSteps,
+    };
+  }
+}