amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/browser/electron-bridge.js

@@ -0,0 +1,222 @@
+const http = require('http');
+const https = require('https');
+
+const DEFAULT_SESSION = `mcp-${process.pid}-default`;
+
+function config() {
+  const baseUrl = process.env.AMALGM_ELECTRON_BROWSER_URL;
+  const token = process.env.AMALGM_ELECTRON_BROWSER_TOKEN;
+  return baseUrl && token ? { baseUrl, token } : null;
+}
+
+function isConfigured() {
+  return Boolean(config());
+}
+
+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.trim()) {
+          try {
+            parsed = JSON.parse(raw);
+          } catch (err) {
+            reject(new Error(`Browser bridge returned invalid JSON: ${err.message}`));
+            return;
+          }
+        }
+
+        if (res.statusCode && res.statusCode >= 400) {
+          const error = new Error(parsed?.error || `Browser bridge request failed with status ${res.statusCode}`);
+          error.statusCode = res.statusCode;
+          reject(error);
+          return;
+        }
+
+        resolve(parsed);
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(120_000, () => {
+      req.destroy(new Error('Browser bridge request timed out'));
+    });
+    if (payload) req.write(payload);
+    req.end();
+  });
+}
+
+function withContext(body = {}, context = {}) {
+  const next = {
+    ...body,
+    ...(context?.callerSessionId ? { callerSessionId: context.callerSessionId } : {}),
+  };
+  if (!next.tabId && !next.sessionId && !next.browserSessionId) {
+    next.browserSessionId = context?.callerSessionId || DEFAULT_SESSION;
+  }
+  return next;
+}
+
+async function call(action, body = {}, context) {
+  const bridge = config();
+  if (!bridge) throw new Error('Electron browser bridge is not configured');
+  return requestJson(`${bridge.baseUrl}/browser/${action}`, {
+    method: 'POST',
+    headers: { 'x-amalgm-browser-token': bridge.token },
+    body: withContext(body, context),
+  });
+}
+
+async function navigateBrowser(args = {}, context) {
+  return call('navigate', args, context);
+}
+
+async function screenshotBrowser(args = {}, context) {
+  return call('screenshot', args, context);
+}
+
+async function snapshotBrowser(args = {}, context) {
+  return call('snapshot', args, context);
+}
+
+async function clickBrowser(args = {}, context) {
+  return call('click', args, context);
+}
+
+async function typeBrowser(args = {}, context) {
+  return call('type', args, context);
+}
+
+async function pressBrowser(args = {}, context) {
+  return call('press', args, context);
+}
+
+async function getTextBrowser(args = {}, context) {
+  return call('get_text', args, context);
+}
+
+async function evaluateBrowser(args = {}, context) {
+  return call('evaluate', args, context);
+}
+
+async function stateBrowser(args = {}, context) {
+  return call('state', args, context);
+}
+
+async function locatorCountBrowser(args = {}, context) {
+  return call('locator_count', args, context);
+}
+
+async function locatorTextBrowser(args = {}, context) {
+  return call('locator_text', args, context);
+}
+
+async function waitForLoadStateBrowser(args = {}, context) {
+  return call('wait_for_load_state', args, context);
+}
+
+async function waitForURLBrowser(args = {}, context) {
+  return call('wait_for_url', args, context);
+}
+
+async function waitForSelectorBrowser(args = {}, context) {
+  return call('wait_for_selector', args, context);
+}
+
+async function tabNavigationBrowser(action, args = {}, context) {
+  return call(action, args, context);
+}
+
+async function tabsListBrowser(context) {
+  return call('tabs_list', {}, context);
+}
+
+async function tabsSelectedBrowser(context) {
+  return call('tabs_selected', {}, context);
+}
+
+async function tabsNewBrowser(args = {}, context) {
+  const sessionId = args.browserSessionId || args.sessionId || `browser-${Date.now().toString(36)}`;
+  return call('tabs_new', {
+    ...args,
+    browserSessionId: sessionId,
+    sessionId,
+    newTab: true,
+  }, context);
+}
+
+async function tabsGetBrowser(args = {}, context) {
+  return call('tabs_get', args, context);
+}
+
+async function tabsSelectBrowser(args = {}, context) {
+  return call('tabs_select', args, context);
+}
+
+async function cuaBrowser(action, args = {}, context) {
+  return call(action, args, context);
+}
+
+async function clipboardBrowser(action, args = {}, context) {
+  return call(action, args, context);
+}
+
+async function startVideoBrowser(args = {}, context) {
+  return call('start_video', {
+    ...args,
+    recordingSessionId: args.sessionId || args.recording_id || args.session_id,
+  }, context);
+}
+
+async function stopVideoBrowser(args = {}, context) {
+  return call('stop_video', args, context);
+}
+
+async function closeBrowser(args = {}, context) {
+  return call('close', args, context);
+}
+
+module.exports = {
+  clipboardBrowser,
+  closeBrowser,
+  clickBrowser,
+  cuaBrowser,
+  evaluateBrowser,
+  getTextBrowser,
+  isConfigured,
+  locatorCountBrowser,
+  locatorTextBrowser,
+  navigateBrowser,
+  pressBrowser,
+  screenshotBrowser,
+  snapshotBrowser,
+  startVideoBrowser,
+  stateBrowser,
+  stopVideoBrowser,
+  tabNavigationBrowser,
+  tabsGetBrowser,
+  tabsListBrowser,
+  tabsNewBrowser,
+  tabsSelectBrowser,
+  tabsSelectedBrowser,
+  typeBrowser,
+  waitForLoadStateBrowser,
+  waitForSelectorBrowser,
+  waitForURLBrowser,
+};