amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/browser/agent-browser.js

@@ -0,0 +1,505 @@
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const DEFAULT_TIMEOUT_MS = 120_000;
+const DEFAULT_SESSION = 'default';
+const activeRecordings = new Map();
+const knownSessions = new Map();
+
+function amalgmDir() {
+  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+function safeId(value, fallback = DEFAULT_SESSION) {
+  const raw = String(value || fallback).replace(/^agent-browser:/, '');
+  return raw.replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 96) || fallback;
+}
+
+function browserRoot() {
+  return ensureDir(path.join(amalgmDir(), 'browser'));
+}
+
+function profileDir(session) {
+  return ensureDir(path.join(browserRoot(), 'profiles', session));
+}
+
+function screenshotDir() {
+  return ensureDir(path.join(browserRoot(), 'screenshots'));
+}
+
+function recordingDir(session) {
+  return ensureDir(path.join(amalgmDir(), 'browser-sessions', session));
+}
+
+function browserSession(args = {}, context = {}) {
+  return safeId(
+    args.browserSessionId
+      || args.sessionId
+      || args.tabId
+      || context?.callerSessionId
+      || DEFAULT_SESSION,
+  );
+}
+
+function tabInfo(session, extra = {}) {
+  const info = {
+    tabId: `agent-browser:${session}`,
+    browserSessionId: session,
+    backend: 'agent-browser',
+    ...extra,
+  };
+  knownSessions.set(session, { ...knownSessions.get(session), ...info, lastActiveAt: Date.now() });
+  return info;
+}
+
+function agentBrowserCommand() {
+  if (process.env.AMALGM_AGENT_BROWSER_BIN) {
+    return { command: process.env.AMALGM_AGENT_BROWSER_BIN, prefix: [] };
+  }
+
+  try {
+    return {
+      command: process.execPath,
+      prefix: [require.resolve('agent-browser/bin/agent-browser.js')],
+    };
+  } catch {
+    return { command: 'agent-browser', prefix: [] };
+  }
+}
+
+function wantsHeaded() {
+  const explicit = process.env.AMALGM_BROWSER_HEADED || process.env.AGENT_BROWSER_HEADED;
+  if (explicit) return !/^(0|false|no)$/i.test(explicit);
+  if (/^(1|true|yes)$/i.test(process.env.AMALGM_BROWSER_HEADLESS || '')) return false;
+  if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return false;
+  return true;
+}
+
+function baseArgs(session, json = true) {
+  const args = [
+    '--session', session,
+    '--profile', profileDir(session),
+    '--screenshot-dir', screenshotDir(),
+  ];
+
+  if (json) args.push('--json');
+  if (wantsHeaded()) args.push('--headed');
+  if (process.env.AMALGM_BROWSER_EXECUTABLE_PATH) {
+    args.push('--executable-path', process.env.AMALGM_BROWSER_EXECUTABLE_PATH);
+  }
+  if (process.env.AMALGM_BROWSER_PROVIDER) {
+    args.push('--provider', process.env.AMALGM_BROWSER_PROVIDER);
+  }
+
+  return args;
+}
+
+function parseJson(stdout) {
+  const text = String(stdout || '').trim();
+  if (!text) return {};
+
+  try {
+    return JSON.parse(text);
+  } catch {
+    const lines = text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      if (!/^[{[]/.test(lines[i])) continue;
+      try {
+        return JSON.parse(lines.slice(i).join('\n'));
+      } catch {
+        // Keep looking for a JSON suffix.
+      }
+    }
+  }
+
+  return { text };
+}
+
+function asText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  if (value.success === true && value.data !== undefined) return asText(value.data);
+  if (typeof value.snapshot === 'string') return value.snapshot;
+  if (typeof value.text === 'string') return value.text;
+  if (typeof value.value === 'string') return value.value;
+  if (typeof value.result === 'string') return value.result;
+  if (typeof value.output === 'string') return value.output;
+  if (typeof value.url === 'string') return value.url;
+  if (typeof value.title === 'string') return value.title;
+  return JSON.stringify(value, null, 2);
+}
+
+function runAgentBrowser(commandArgs, options = {}) {
+  const session = safeId(options.session);
+  const json = options.json !== false;
+  const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+  const bin = agentBrowserCommand();
+  const args = [...bin.prefix, ...baseArgs(session, json), ...commandArgs.map(String)];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin.command, args, {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        AGENT_BROWSER_SESSION: session,
+        AGENT_BROWSER_PROFILE: profileDir(session),
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM');
+      reject(new Error(`agent-browser timed out running: ${commandArgs.join(' ')}`));
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err.code === 'ENOENT'
+        ? new Error('agent-browser is not installed. Reinstall Amalgm or run `npm install agent-browser`.')
+        : err);
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error((stderr || stdout || `agent-browser exited with code ${code}`).trim()));
+        return;
+      }
+      const result = json ? parseJson(stdout) : { text: stdout.trim() };
+      if (result && result.success === false) {
+        reject(new Error(result.error || result.message || 'agent-browser command failed'));
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+
+function directTarget(args = {}) {
+  if (args.ref) return String(args.ref);
+  if (args.selector) return String(args.selector);
+  return null;
+}
+
+function findCommand(args = {}, action, value) {
+  const command = ['find'];
+  if (args.text || args.name) command.push('text', args.text || args.name);
+  else if (args.label) command.push('label', args.label);
+  else if (args.placeholder) command.push('placeholder', args.placeholder);
+  else if (args.testId) command.push('testid', args.testId);
+  else if (args.role) command.push('role', args.role);
+  else throw new Error('A selector, ref, text, role, label, placeholder, or testId target is required');
+
+  command.push(action);
+  if (value !== undefined) command.push(value);
+  if (args.role && args.name) command.push('--name', args.name);
+  return command;
+}
+
+async function readTextCommand(command, session) {
+  return asText(await runAgentBrowser(command, { session, timeoutMs: 30_000 }));
+}
+
+async function stateBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  let url = '';
+  let title = '';
+
+  try { url = await readTextCommand(['get', 'url'], session); } catch {}
+  try { title = await readTextCommand(['get', 'title'], session); } catch {}
+
+  return tabInfo(session, { title, url, loading: false, visible: wantsHeaded() });
+}
+
+async function navigateBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  await runAgentBrowser(['open', args.url], { session });
+  const state = await stateBrowser(args, context);
+  return { ...state, status: 'ok' };
+}
+
+async function screenshotBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const file = path.join(screenshotDir(), `${session}-${Date.now()}-${crypto.randomUUID()}.png`);
+  await runAgentBrowser(['screenshot', ...(args.fullPage ? ['--full'] : []), file], { session });
+  const buffer = fs.readFileSync(file);
+  return {
+    ...tabInfo(session),
+    base64: buffer.toString('base64'),
+    bytes: buffer.length,
+    mode: args.fullPage ? 'full page' : 'viewport',
+    path: file,
+  };
+}
+
+async function snapshotBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const snapshot = await runAgentBrowser(['snapshot', '-i'], { session, timeoutMs: 30_000 });
+  const state = await stateBrowser(args, context);
+  return { ...state, snapshotText: asText(snapshot) };
+}
+
+async function clickBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const target = directTarget(args);
+  await runAgentBrowser(target ? ['click', target] : findCommand(args, 'click'), { session });
+  return tabInfo(session, { description: `Clicked ${target || args.text || args.name || args.label || args.placeholder || args.testId || args.role}` });
+}
+
+async function typeBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const target = directTarget(args);
+  const action = args.clear === false ? 'type' : 'fill';
+  await runAgentBrowser(target ? [action, target, args.text || ''] : findCommand(args, action, args.text || ''), { session });
+  return tabInfo(session, { description: `Typed into ${target || args.label || args.placeholder || args.role || 'target'}` });
+}
+
+async function pressBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const target = directTarget(args);
+  if (target) await runAgentBrowser(['focus', target], { session });
+  await runAgentBrowser(['press', args.key], { session });
+  return tabInfo(session, { pressed: args.key });
+}
+
+async function getTextBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const target = directTarget(args) || 'body';
+  return { ...tabInfo(session), text: await readTextCommand(['get', 'text', target], session) };
+}
+
+async function evaluateBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  return { ...tabInfo(session), result: await runAgentBrowser(['eval', args.script || ''], { session }) };
+}
+
+async function locatorCountBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const target = directTarget(args);
+  if (!target) throw new Error('Count currently requires selector or ref. Use browser_snapshot for refs.');
+  const count = Number(await readTextCommand(['get', 'count', target], session));
+  return { ...tabInfo(session), count: Number.isFinite(count) ? count : 0 };
+}
+
+async function locatorTextBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const target = directTarget(args);
+  if (!target) throw new Error('Text lookup currently requires selector or ref. Use browser_snapshot for refs.');
+  return { ...tabInfo(session), text: await readTextCommand(['get', 'text', target], session) };
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function globToRegExp(pattern) {
+  const escaped = String(pattern)
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+    .replace(/\*\*/g, '.*')
+    .replace(/\*/g, '[^/]*');
+  return new RegExp(`^${escaped}$`);
+}
+
+function urlMatches(actual, expected) {
+  if (!expected) return true;
+  const target = String(expected);
+  if (actual === target) return true;
+  if (target.includes('*')) return globToRegExp(target).test(actual);
+  return actual.includes(target);
+}
+
+async function pollUntil(description, timeoutMs, check) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+
+  while (Date.now() < deadline) {
+    try {
+      if (await check()) return;
+    } catch (err) {
+      lastError = err;
+    }
+    await sleep(250);
+  }
+
+  throw new Error(`${description} timed out${lastError?.message ? `: ${lastError.message}` : ''}`);
+}
+
+async function waitForLoadStateBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const state = args.state || 'load';
+  const timeoutMs = args.timeoutMs || 30_000;
+
+  if (state === 'networkidle') {
+    await runAgentBrowser(['wait', Math.min(timeoutMs, 1000)], { session, timeoutMs });
+    return stateBrowser(args, context);
+  }
+
+  await pollUntil(`wait for ${state}`, timeoutMs, async () => {
+    const readyState = await readTextCommand(['eval', 'document.readyState'], session);
+    return state === 'domcontentloaded'
+      ? readyState !== 'loading'
+      : readyState === 'complete';
+  });
+  return stateBrowser(args, context);
+}
+
+async function waitForURLBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const expectedUrl = args.url;
+  await pollUntil(`wait for URL ${expectedUrl}`, args.timeoutMs || 30_000, async () => {
+    const currentUrl = await readTextCommand(['get', 'url'], session);
+    return urlMatches(currentUrl, expectedUrl);
+  });
+  return stateBrowser(args, context);
+}
+
+async function waitForSelectorBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  await runAgentBrowser(['wait', args.selector], { session, timeoutMs: args.timeoutMs || 30_000 });
+  return { ...tabInfo(session), selector: args.selector, matched: true };
+}
+
+async function tabNavigationBrowser(action, args = {}, context) {
+  const session = browserSession(args, context);
+  await runAgentBrowser([action], { session });
+  return stateBrowser(args, context);
+}
+
+async function tabsListBrowser() {
+  return {
+    tabs: Array.from(knownSessions.values()).sort((a, b) => (b.lastActiveAt || 0) - (a.lastActiveAt || 0)),
+    backend: 'agent-browser',
+  };
+}
+
+async function tabsSelectedBrowser(context) {
+  return stateBrowser({}, context);
+}
+
+async function tabsNewBrowser(args = {}, context) {
+  const session = safeId(args.browserSessionId || args.sessionId || `browser-${Date.now().toString(36)}`);
+  if (args.url) await navigateBrowser({ ...args, browserSessionId: session }, context);
+  return stateBrowser({ ...args, browserSessionId: session }, context);
+}
+
+async function tabsGetBrowser(args = {}, context) {
+  return stateBrowser(args, context);
+}
+
+async function tabsSelectBrowser(args = {}, context) {
+  return stateBrowser(args, context);
+}
+
+async function cuaBrowser(action, args = {}, context) {
+  const session = browserSession(args, context);
+  const x = Math.round(Number(args.x || 0));
+  const y = Math.round(Number(args.y || 0));
+  if (action === 'cua_move') await runAgentBrowser(['mouse', 'move', x, y], { session });
+  if (action === 'cua_click') {
+    await runAgentBrowser(['mouse', 'move', x, y], { session });
+    await runAgentBrowser(['mouse', 'down', args.button || 1], { session });
+    await runAgentBrowser(['mouse', 'up', args.button || 1], { session });
+  }
+  if (action === 'cua_double_click') {
+    await runAgentBrowser(['mouse', 'move', x, y], { session });
+    await runAgentBrowser(['mouse', 'down', 1], { session });
+    await runAgentBrowser(['mouse', 'up', 1], { session });
+    await runAgentBrowser(['mouse', 'down', 1], { session });
+    await runAgentBrowser(['mouse', 'up', 1], { session });
+  }
+  if (action === 'cua_scroll') await runAgentBrowser(['mouse', 'wheel', args.scrollY || 0, args.scrollX || 0], { session });
+  if (action === 'cua_type') await runAgentBrowser(['keyboard', 'type', args.text || ''], { session });
+  if (action === 'cua_keypress') await runAgentBrowser(['press', (args.keys || []).join('+')], { session });
+  if (action === 'cua_drag') await dragBrowser(args, session);
+  return tabInfo(session, { ok: true });
+}
+
+async function dragBrowser(args, session) {
+  const pathPoints = Array.isArray(args.path) ? args.path : [];
+  if (pathPoints.length < 2) throw new Error('drag path must contain at least two points');
+  await runAgentBrowser(['mouse', 'move', pathPoints[0].x, pathPoints[0].y], { session });
+  await runAgentBrowser(['mouse', 'down', 1], { session });
+  for (const point of pathPoints.slice(1)) {
+    await runAgentBrowser(['mouse', 'move', point.x, point.y], { session });
+  }
+  await runAgentBrowser(['mouse', 'up', 1], { session });
+}
+
+async function clipboardBrowser(action, args = {}, context) {
+  const session = browserSession(args, context);
+  if (action === 'clipboard_read_text') {
+    return { ...tabInfo(session), text: await readTextCommand(['clipboard', 'read'], session) };
+  }
+  await runAgentBrowser(['clipboard', 'write', args.text || ''], { session });
+  return tabInfo(session, { written: true });
+}
+
+async function startVideoBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  const id = safeId(args.sessionId || args.recording_id || session, session);
+  const file = path.join(recordingDir(id), `${new Date().toISOString().replace(/[:.]/g, '-')}.webm`);
+  await runAgentBrowser(['record', 'start', file], { session });
+  activeRecordings.set(session, file);
+  return tabInfo(session, { path: file, mimeType: 'video/webm' });
+}
+
+async function stopVideoBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  await runAgentBrowser(['record', 'stop'], { session });
+  const file = activeRecordings.get(session);
+  activeRecordings.delete(session);
+  if (!file) return tabInfo(session, { stopped: true });
+  const bytes = fs.existsSync(file) ? fs.statSync(file).size : 0;
+  return tabInfo(session, {
+    path: file,
+    relativePath: path.relative(amalgmDir(), file),
+    url: `/api/browser-sessions/video?file=${encodeURIComponent(path.relative(amalgmDir(), file))}`,
+    bytes,
+    mimeType: 'video/webm',
+  });
+}
+
+async function closeBrowser(args = {}, context) {
+  const session = browserSession(args, context);
+  await runAgentBrowser(['close'], { session });
+  knownSessions.delete(session);
+}
+
+module.exports = {
+  clipboardBrowser,
+  closeBrowser,
+  clickBrowser,
+  cuaBrowser,
+  evaluateBrowser,
+  getTextBrowser,
+  locatorCountBrowser,
+  locatorTextBrowser,
+  navigateBrowser,
+  pressBrowser,
+  screenshotBrowser,
+  snapshotBrowser,
+  startVideoBrowser,
+  stateBrowser,
+  stopVideoBrowser,
+  tabNavigationBrowser,
+  tabsGetBrowser,
+  tabsListBrowser,
+  tabsNewBrowser,
+  tabsSelectBrowser,
+  tabsSelectedBrowser,
+  typeBrowser,
+  waitForLoadStateBrowser,
+  waitForSelectorBrowser,
+  waitForURLBrowser,
+};