amalgm 0.1.51 → 0.1.53

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

@@ -1,637 +1,19 @@
-/**
- * Browser tool backend selector.
- *
- * In desktop local mode, browser_* tools talk to Electron's visible browser
- * bridge so users can watch the session in a real tab. Outside Electron, we
- * fall back to a private Playwright Chromium instance.
- */
+const electron = require('./electron-bridge');
+const agentBrowser = require('./agent-browser');
 
-const http = require('http');
-const https = require('https');
-const { loadPlaywright } = require('../deps');
+function backend() {
+  const requested = (process.env.AMALGM_BROWSER_BACKEND || '').toLowerCase();
+  if (requested === 'agent-browser' || requested === 'external') return agentBrowser;
+  if (requested === 'electron') return electron;
 
-let _browserBackend = null;
-let _lastElectronBridgeProbeAt = 0;
-let _browser = null;
-let _browserContext = null;
-let _browserPage = null;
-let _selectedPlaywrightTabId = 'playwright-default';
-const _playwrightTabs = new Map();
-const _defaultElectronSessionId = `mcp-${process.pid}-default`;
-
-function newBrowserSessionId(prefix = 'browser') {
-  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-function formatAccessibilityTree(node, depth = 0) {
-  if (!node) return '';
-  const indent = '  '.repeat(depth);
-  let line = `${indent}${node.role || 'unknown'}`;
-  if (node.name) line += `: "${node.name}"`;
-  if (node.value) line += ` = "${node.value}"`;
-  let result = line + '\n';
-  if (node.children) {
-    for (const child of node.children) result += formatAccessibilityTree(child, depth + 1);
-  }
-  return result;
-}
-
-function getElectronBridgeConfig() {
-  const baseUrl = process.env.AMALGM_ELECTRON_BROWSER_URL;
-  const token = process.env.AMALGM_ELECTRON_BROWSER_TOKEN;
-  if (!baseUrl || !token) return null;
-  return { baseUrl, token };
-}
-
-function isBridgeTransportError(err) {
-  return Boolean(
-    err && (
-      err.code === 'ECONNREFUSED'
-      || err.code === 'ECONNRESET'
-      || err.code === 'ENOTFOUND'
-      || err.code === 'ETIMEDOUT'
-      || err.bridgeTransport === true
-    ),
-  );
-}
-
-function requestJson(url, { method = 'GET', headers = {}, body } = {}) {
-  return new Promise((resolve, reject) => {
-    const target = new URL(url);
-    const transport = target.protocol === 'https:' ? https : http;
-    const payload = body ? JSON.stringify(body) : null;
-    const req = transport.request(target, {
-      method,
-      headers: {
-        Accept: 'application/json',
-        ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(payload)) } : {}),
-        ...headers,
-      },
-    }, (res) => {
-      let raw = '';
-      res.on('data', (chunk) => {
-        raw += chunk.toString();
-      });
-      res.on('end', () => {
-        let parsed = {};
-        if (raw) {
-          try {
-            parsed = JSON.parse(raw);
-          } catch (parseErr) {
-            const err = new Error(`Browser bridge returned invalid JSON: ${parseErr.message}`);
-            err.bridgeTransport = true;
-            reject(err);
-            return;
-          }
-        }
-
-        if (res.statusCode && res.statusCode >= 400) {
-          const message = parsed && typeof parsed.error === 'string'
-            ? parsed.error
-            : `Browser bridge request failed with status ${res.statusCode}`;
-          const err = new Error(message);
-          err.statusCode = res.statusCode;
-          reject(err);
-          return;
-        }
-
-        resolve(parsed);
-      });
-    });
-
-    req.on('error', (err) => {
-      err.bridgeTransport = true;
-      reject(err);
-    });
-
-    req.setTimeout(120_000, () => {
-      const err = new Error('Browser bridge request timed out');
-      err.code = 'ETIMEDOUT';
-      err.bridgeTransport = true;
-      req.destroy(err);
-    });
-
-    if (payload) req.write(payload);
-    req.end();
-  });
-}
-
-async function callElectronBridge(action, body = {}) {
-  const bridge = getElectronBridgeConfig();
-  if (!bridge) throw new Error('Electron browser bridge is not configured');
-
-  try {
-    return await requestJson(`${bridge.baseUrl}/browser/${action}`, {
-      method: 'POST',
-      headers: { 'x-amalgm-browser-token': bridge.token },
-      body,
-    });
-  } catch (err) {
-    if (isBridgeTransportError(err)) {
-      _browserBackend = null;
-    }
-    throw err;
-  }
-}
-
-function withRequestContext(body = {}, context = {}) {
-  const next = {
-    ...body,
-    ...(context?.callerSessionId ? { callerSessionId: context.callerSessionId } : {}),
-  };
-  if (!next.tabId && !next.sessionId && !next.browserSessionId) {
-    next.browserSessionId = context?.callerSessionId || _defaultElectronSessionId;
-  }
-  return next;
-}
-
-async function probeElectronBridge() {
-  const bridge = getElectronBridgeConfig();
-  if (!bridge) return false;
-
-  _lastElectronBridgeProbeAt = Date.now();
-  try {
-    await requestJson(`${bridge.baseUrl}/healthz`, {
-      headers: { 'x-amalgm-browser-token': bridge.token },
-    });
-    console.log('[AmalgmMCP] Using Electron browser bridge');
-    return true;
-  } catch (err) {
-    if (isBridgeTransportError(err)) {
-      console.warn(`[AmalgmMCP] Electron browser bridge unavailable, falling back to Playwright: ${err.message}`);
-      return false;
-    }
-    throw err;
-  }
-}
-
-async function resolveBrowserBackend() {
-  if (_browserBackend === 'electron') return _browserBackend;
-  if (_browserBackend === 'playwright') {
-    const hasElectronBridgeConfig = Boolean(getElectronBridgeConfig());
-    const shouldRetryElectron = hasElectronBridgeConfig && Date.now() - _lastElectronBridgeProbeAt > 1_000;
-    if (!shouldRetryElectron) return _browserBackend;
-  }
-
-  if (await probeElectronBridge()) {
-    _browserBackend = 'electron';
-    return _browserBackend;
-  }
-
-  _browserBackend = 'playwright';
-  return _browserBackend;
-}
-
-async function getPlaywrightPage() {
-  if (_browserPage && !_browserPage.isClosed()) {
-    _playwrightTabs.set(_selectedPlaywrightTabId, _browserPage);
-    return _browserPage;
-  }
-
-  const pw = loadPlaywright();
-  if (!_browser || !_browser.isConnected()) {
-    console.log('[AmalgmMCP] Launching headless Chromium...');
-    _browser = await pw.chromium.launch({
-      headless: true,
-      args: ['--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu'],
-    });
-  }
-
-  _browserContext = await _browser.newContext({ viewport: { width: 1280, height: 720 } });
-  _browserPage = await _browserContext.newPage();
-  _playwrightTabs.set(_selectedPlaywrightTabId, _browserPage);
-  return _browserPage;
-}
-
-async function navigateBrowser(urlOrArgs, context) {
-  const args = typeof urlOrArgs === 'object' && urlOrArgs
-    ? urlOrArgs
-    : { url: urlOrArgs };
-  const url = args.url;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('navigate', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  const response = await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
-  const status = response ? response.status() : 'unknown';
-  const title = await page.title();
-  return { title, url: page.url(), status };
-}
-
-async function screenshotBrowser(fullPageOrArgs = false, context) {
-  const args = typeof fullPageOrArgs === 'object' && fullPageOrArgs
-    ? fullPageOrArgs
-    : { fullPage: Boolean(fullPageOrArgs) };
-  const fullPage = Boolean(args.fullPage);
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('screenshot', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  const buffer = await page.screenshot({ fullPage, type: 'png' });
-  return {
-    base64: buffer.toString('base64'),
-    bytes: buffer.length,
-    mode: fullPage ? 'full page' : 'viewport',
-  };
-}
-
-async function snapshotBrowser(argsOrContext, maybeContext) {
-  const hasArgs = maybeContext !== undefined;
-  const args = hasArgs ? (argsOrContext || {}) : {};
-  const context = hasArgs ? maybeContext : argsOrContext;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('snapshot', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  const snapshot = await page.accessibility.snapshot();
-  const title = await page.title();
-  const url = page.url();
-
-  return {
-    title,
-    url,
-    snapshotText: snapshot
-      ? formatAccessibilityTree(snapshot, 0)
-      : await page.evaluate(() => document.body.innerText),
-  };
-}
-
-async function clickBrowser(args = {}, context) {
-  const { selector, text } = args;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('click', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  if (text) {
-    await page.getByText(text, { exact: false }).first().click({ timeout: 5_000 });
-    return { description: `Clicked element with text: "${text}"` };
-  }
-
-  await page.click(selector, { timeout: 5_000 });
-  return { description: `Clicked element: ${selector}` };
-}
-
-async function typeBrowser(args = {}, context) {
-  const { selector, text, clear = true } = args;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('type', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  if (selector) {
-    if (clear) await page.fill(selector, text);
-    else await page.type(selector, text);
-    return { description: `Typed into ${selector}: "${text}"` };
-  }
-
-  await page.keyboard.type(text);
-  return { description: `Typed: "${text}"` };
-}
-
-async function getTextBrowser(selectorOrArgs, context) {
-  const args = typeof selectorOrArgs === 'object' && selectorOrArgs
-    ? selectorOrArgs
-    : { selector: selectorOrArgs };
-  const { selector } = args;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('get_text', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  let text;
-  if (selector) text = await page.textContent(selector);
-  else text = await page.evaluate(() => document.body.innerText);
-  return { text: text || '' };
-}
-
-async function evaluateBrowser(scriptOrArgs, context) {
-  const args = typeof scriptOrArgs === 'object' && scriptOrArgs
-    ? scriptOrArgs
-    : { script: scriptOrArgs };
-  const { script } = args;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('evaluate', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  const result = await page.evaluate(script);
-  return { result };
-}
-
-async function stateBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('state', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  return {
-    tabId: _selectedPlaywrightTabId,
-    browserSessionId: _selectedPlaywrightTabId,
-    title: await page.title(),
-    url: page.url(),
-    loading: false,
-    backend: 'playwright',
-  };
-}
-
-async function tabsListBrowser(context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('tabs_list', withRequestContext({}, context));
-  }
-
-  await getPlaywrightPage();
-  const tabs = [];
-  for (const [tabId, page] of _playwrightTabs.entries()) {
-    if (!page || page.isClosed()) continue;
-    tabs.push({
-      tabId,
-      browserSessionId: tabId,
-      title: await page.title(),
-      url: page.url(),
-      selected: tabId === _selectedPlaywrightTabId,
-      backend: 'playwright',
-    });
-  }
-  return { tabs, selectedTabId: _selectedPlaywrightTabId };
-}
-
-async function tabsSelectedBrowser(context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('tabs_selected', withRequestContext({}, context));
-  }
-  return stateBrowser({}, context);
-}
-
-async function tabsNewBrowser({ url, browserSessionId, sessionId } = {}, context) {
-  const nextSessionId = browserSessionId || sessionId || newBrowserSessionId('browser-tab');
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('tabs_new', withRequestContext({
-      browserSessionId: nextSessionId,
-      sessionId: nextSessionId,
-      url,
-      newTab: true,
-    }, context));
-  }
-
-  const pw = loadPlaywright();
-  if (!_browser || !_browser.isConnected()) {
-    _browser = await pw.chromium.launch({
-      headless: true,
-      args: ['--no-sandbox', '--disable-dev-shm-usage', '--disable-gpu'],
-    });
-  }
-  const contextInstance = await _browser.newContext({ viewport: { width: 1280, height: 720 } });
-  const page = await contextInstance.newPage();
-  _browserContext = contextInstance;
-  _browserPage = page;
-  _selectedPlaywrightTabId = nextSessionId;
-  _playwrightTabs.set(nextSessionId, page);
-  if (url) await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30_000 });
-  return stateBrowser({}, context);
-}
-
-async function tabsGetBrowser({ tabId, browserSessionId, sessionId } = {}, context) {
-  const backend = await resolveBrowserBackend();
-  const targetSessionId = browserSessionId || sessionId;
-  if (backend === 'electron') {
-    return callElectronBridge('tabs_get', withRequestContext({
-      ...(tabId ? { tabId } : {}),
-      ...(targetSessionId ? { browserSessionId: targetSessionId } : {}),
-    }, context));
-  }
-  const targetTabId = tabId || targetSessionId;
-  if (targetTabId && _playwrightTabs.has(targetTabId)) {
-    _selectedPlaywrightTabId = targetTabId;
-    _browserPage = _playwrightTabs.get(targetTabId);
-  }
-  return stateBrowser({}, context);
+  // In the desktop app this bridge drives the visible in-tab Electron webview.
+  // Outside Electron, keep the agent-browser CLI fallback for headless/remote use.
+  return electron.isConfigured() ? electron : agentBrowser;
 }
 
-async function tabsSelectBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('tabs_select', withRequestContext(args, context));
-  }
-  return tabsGetBrowser(args, context);
-}
-
-async function tabNavigationBrowser(action, args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge(action, withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  if (action === 'back') await page.goBack({ waitUntil: 'domcontentloaded', timeout: 30_000 }).catch(() => null);
-  if (action === 'forward') await page.goForward({ waitUntil: 'domcontentloaded', timeout: 30_000 }).catch(() => null);
-  if (action === 'reload') await page.reload({ waitUntil: 'domcontentloaded', timeout: 30_000 });
-  return stateBrowser({}, context);
-}
-
-async function waitForLoadStateBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('wait_for_load_state', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  await page.waitForLoadState(args.state || 'load', { timeout: args.timeoutMs || 10_000 });
-  return stateBrowser({}, context);
-}
-
-async function waitForURLBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('wait_for_url', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  await page.waitForURL(args.url, { timeout: args.timeoutMs || 10_000, waitUntil: args.waitUntil || 'load' });
-  return stateBrowser({}, context);
-}
-
-async function waitForSelectorBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('wait_for_selector', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  await page.locator(args.selector).waitFor({ state: args.state || 'visible', timeout: args.timeoutMs || 10_000 });
-  return { selector: args.selector, state: args.state || 'visible', matched: true };
-}
-
-async function locatorCountBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('locator_count', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  const locator = args.selector
-    ? page.locator(args.selector)
-    : args.text
-      ? page.getByText(args.text, { exact: args.exact === true })
-      : args.role
-        ? page.getByRole(args.role, { name: args.name, exact: args.exact === true })
-        : args.label
-          ? page.getByLabel(args.label, { exact: args.exact === true })
-          : args.placeholder
-            ? page.getByPlaceholder(args.placeholder, { exact: args.exact === true })
-            : args.testId
-              ? page.getByTestId(args.testId)
-              : null;
-  if (!locator) throw new Error('A selector, text, role, label, placeholder, or testId target is required');
-  return { count: await locator.count() };
-}
-
-async function locatorTextBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('locator_text', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  const locator = args.selector ? page.locator(args.selector) : page.getByText(args.text || args.name || '', { exact: args.exact === true });
-  return { text: await locator.first().innerText({ timeout: args.timeoutMs || 5_000 }), count: await locator.count() };
-}
-
-async function pressBrowser(args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('press', withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  if (args.selector) await page.locator(args.selector).press(args.key, { timeout: args.timeoutMs || 5_000 });
-  else await page.keyboard.press(args.key);
-  return { pressed: args.key };
-}
-
-async function cuaBrowser(action, args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge(action, withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  if (action === 'cua_click') await page.mouse.click(args.x, args.y, { button: args.button === 3 ? 'right' : args.button === 2 ? 'middle' : 'left' });
-  else if (action === 'cua_double_click') await page.mouse.dblclick(args.x, args.y);
-  else if (action === 'cua_move') await page.mouse.move(args.x, args.y);
-  else if (action === 'cua_scroll') await page.mouse.wheel(args.scrollX || 0, args.scrollY || 0);
-  else if (action === 'cua_type') await page.keyboard.type(args.text || '');
-  else if (action === 'cua_keypress') await page.keyboard.press((args.keys || []).join('+'));
-  else if (action === 'cua_drag') {
-    const path = Array.isArray(args.path) ? args.path : [];
-    if (path.length < 2) throw new Error('drag path must contain at least two points');
-    await page.mouse.move(path[0].x, path[0].y);
-    await page.mouse.down();
-    for (const point of path.slice(1)) await page.mouse.move(point.x, point.y);
-    await page.mouse.up();
-  }
-  return { ok: true };
-}
-
-async function clipboardBrowser(action, args = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge(action, withRequestContext(args, context));
-  }
-
-  const page = await getPlaywrightPage();
-  if (action === 'clipboard_read_text') {
-    return { text: await page.evaluate(() => navigator.clipboard.readText()) };
-  }
-  await page.evaluate((text) => navigator.clipboard.writeText(text), args.text || '');
-  return { written: true };
-}
-
-async function closePlaywrightBrowser() {
-  if (_browserContext) {
-    await _browserContext.close().catch(() => {});
-    _browserContext = null;
-    _browserPage = null;
-  }
-
-  if (_browser && _browser.isConnected()) {
-    await _browser.close().catch(() => {});
-    _browser = null;
-  }
-}
-
-async function startVideoBrowser({ fps, sessionId, browserSessionId, tabId } = {}, context) {
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('start_video', withRequestContext({ fps, recordingSessionId: sessionId, browserSessionId, tabId }, context));
-  }
-
-  throw new Error('Video recording is available in the Amalgm desktop app only. Open the desktop app to use the visible browser tab and local recording.');
-}
-
-async function stopVideoBrowser(argsOrContext, maybeContext) {
-  const hasArgs = maybeContext !== undefined;
-  const args = hasArgs ? (argsOrContext || {}) : {};
-  const context = hasArgs ? maybeContext : argsOrContext;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    return callElectronBridge('stop_video', withRequestContext(args, context));
-  }
-
-  throw new Error('Video recording is available in the Amalgm desktop app only. Open the desktop app to use the visible browser tab and local recording.');
-}
-
-async function closeBrowser(argsOrContext, maybeContext) {
-  const hasArgs = maybeContext !== undefined;
-  const args = hasArgs ? (argsOrContext || {}) : {};
-  const context = hasArgs ? maybeContext : argsOrContext;
-  const backend = await resolveBrowserBackend();
-  if (backend === 'electron') {
-    await callElectronBridge('close', withRequestContext(args, context));
-    return;
-  }
-
-  await closePlaywrightBrowser();
+const exported = {};
+for (const key of Object.keys(agentBrowser)) {
+  exported[key] = (...args) => backend()[key](...args);
 }
 
-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,
-};
+module.exports = exported;