amalgm 0.1.89 → 0.1.90

package/runtime/scripts/amalgm-mcp/server/core-tools.js

@@ -8,6 +8,10 @@
  * circular dependency on the MCP server.
  */
 
+function withCapability(tools, capability) {
+  return tools.map((tool) => ({ ...tool, capability }));
+}
+
 function group(id, name, description, tools, extra = {}) {
   return {
     id,
@@ -58,37 +62,21 @@ const CORE_TOOL_GROUPS = [
     'Register, run, and route local-first Amalgm apps.',
     require('../apps/tools'),
   ),
-  // The Browser family: one product primitive ("browser") plus optional
-  // capabilities that stay separately grantable but present as Browser modes,
-  // not peer products. `family`/`capability` flow into the toolbox catalog so
-  // UIs can nest them under Browser.
+  // Browser is ONE toolbox entry. Users enable/disable it per agent as a
+  // single tool; fine-grained control stays available because loadouts can
+  // hold individual action ids (`browser.cua_click`). Each action carries a
+  // `capability` tag so UIs can section the card (core / computer-use /
+  // recording / auth) without splitting the entry.
   group(
     'browser',
     'Browser',
-    "Drive Amalgm's browser: open pages, snapshot interactive elements, click, fill, and run any agent-browser CLI command.",
-    require('../browser/tools'),
-    { family: 'browser', capability: 'core' },
-  ),
-  group(
-    'browser_cua',
-    'Browser Computer Use',
-    'Browser capability: coordinate/pixel control for vision-model loops — screenshot, click and type at x/y.',
-    require('../browser/cua-tools'),
-    { family: 'browser', capability: 'computer-use' },
-  ),
-  group(
-    'browser_recording',
-    'Browser Recording',
-    'Browser capability: record sessions to WebM videos stored with the Amalgm project they belong to.',
-    require('../browser/recorder-tools'),
-    { family: 'browser', capability: 'recording' },
-  ),
-  group(
-    'browser_auth',
-    'Browser Auth',
-    'Browser infrastructure: durable profiles, encrypted auth bundles, and temporary login links.',
-    require('../browser/auth-tools'),
-    { family: 'browser', capability: 'auth' },
+    "Drive Amalgm's browser: open pages, snapshot interactive elements as @refs, click, fill, record sessions to project videos, manage durable login profiles, and run any agent-browser CLI command. Visible in the desktop split view; headless on servers.",
+    [
+      ...withCapability(require('../browser/tools'), 'core'),
+      ...withCapability(require('../browser/cua-tools'), 'computer-use'),
+      ...withCapability(require('../browser/recorder-tools'), 'recording'),
+      ...withCapability(require('../browser/auth-tools'), 'auth'),
+    ],
   ),
 ];
 

package/runtime/scripts/amalgm-mcp/state/snapshot.js

@@ -75,6 +75,10 @@ function readResource(resource, cache) {
       return require('../browser/store').listBrowserAuthBundles();
     case 'browser_login_sessions':
       return require('../browser/store').listBrowserLoginSessions();
+    case 'browser_surfaces':
+      // Surface-open requests are commands, not state: delivered via the
+      // event stream only, so snapshots always start empty.
+      return [];
     default:
       if (String(resource).startsWith('files:')) {
         return require('../fs/rest')._private.buildFilesResource(resource);

package/runtime/scripts/amalgm-mcp/tests/browser-routing.test.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const engine = require('../browser/engine');
+
+const ROUTING_ENV = [
+  'AMALGM_BROWSER_BACKEND',
+  'AMALGM_BROWSER_CDP_URL',
+  'AMALGM_RUNTIME_STATE_DIR',
+  'AMALGM_RUNTIME_LABEL',
+  'AMALGM_BRANCH',
+  'AMALGM_DIR',
+];
+
+function withEnv(overrides, fn) {
+  const saved = {};
+  for (const key of ROUTING_ENV) {
+    saved[key] = process.env[key];
+    delete process.env[key];
+  }
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value !== undefined) process.env[key] = value;
+  }
+  try {
+    return fn();
+  } finally {
+    for (const key of ROUTING_ENV) {
+      if (saved[key] === undefined) delete process.env[key];
+      else process.env[key] = saved[key];
+    }
+  }
+}
+
+function tempDir(name) {
+  return fs.mkdtempSync(path.join(os.tmpdir(), `amalgm-${name}-`));
+}
+
+function writeAdvertisement(dir, data) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    path.join(dir, 'electron-browser-bridge.json'),
+    `${JSON.stringify(data, null, 2)}\n`,
+  );
+}
+
+test('entrypoint routing: no advertisement means headless cli', () => {
+  withEnv({ AMALGM_DIR: tempDir('empty') }, () => {
+    assert.equal(engine.mode(), 'cli');
+    assert.equal(engine.cdpEndpoint(), null);
+  });
+});
+
+test('entrypoint routing: AMALGM_BROWSER_BACKEND forces a backend', () => {
+  withEnv({ AMALGM_BROWSER_BACKEND: 'cli', AMALGM_BROWSER_CDP_URL: 'ws://127.0.0.1:9242/x' }, () => {
+    assert.equal(engine.mode(), 'cli');
+  });
+  withEnv({ AMALGM_BROWSER_BACKEND: 'attached' }, () => {
+    assert.equal(engine.mode(), 'attached');
+  });
+  // Old override value keeps meaning "the visible desktop browser".
+  withEnv({ AMALGM_BROWSER_BACKEND: 'electron' }, () => {
+    assert.equal(engine.mode(), 'attached');
+  });
+});
+
+test('entrypoint routing: explicit AMALGM_BROWSER_CDP_URL attaches', () => {
+  withEnv({ AMALGM_BROWSER_CDP_URL: 'ws://127.0.0.1:9999/devtools/browser/abc' }, () => {
+    assert.equal(engine.mode(), 'attached');
+    // --cdp takes a port; URLs are reduced to their port.
+    assert.equal(engine.cdpEndpoint(), '9999');
+  });
+});
+
+test('entrypoint routing: fresh advertisement in the runtime state dir attaches', () => {
+  const stateDir = tempDir('state');
+  writeAdvertisement(stateDir, {
+    cdpUrl: 'ws://127.0.0.1:9242/devtools/browser/live',
+    cdpPort: 9242,
+    pid: process.pid,
+  });
+  withEnv({ AMALGM_RUNTIME_STATE_DIR: stateDir }, () => {
+    assert.equal(engine.mode(), 'attached');
+    assert.equal(engine.cdpEndpoint(), '9242');
+  });
+});
+
+test('entrypoint routing: stale advertisement (dead pid) means headless', () => {
+  const stateDir = tempDir('stale');
+  writeAdvertisement(stateDir, {
+    cdpUrl: 'ws://127.0.0.1:9242/devtools/browser/dead',
+    pid: 2 ** 30, // not a real pid
+  });
+  withEnv({ AMALGM_RUNTIME_STATE_DIR: stateDir, AMALGM_DIR: tempDir('empty2') }, () => {
+    assert.equal(engine.mode(), 'cli');
+  });
+});
+
+test('entrypoint routing: AMALGM_DIR + label derives the state dir path', () => {
+  const amalgmDir = tempDir('scoped');
+  writeAdvertisement(path.join(amalgmDir, 'runtimes', 'main'), {
+    cdpUrl: 'ws://127.0.0.1:9242/devtools/browser/scoped',
+    pid: process.pid,
+  });
+  withEnv({ AMALGM_DIR: amalgmDir, AMALGM_RUNTIME_LABEL: 'main' }, () => {
+    assert.equal(engine.mode(), 'attached');
+    assert.equal(engine.cdpEndpoint(), '9242');
+  });
+  // A different label does not see it (branch isolation).
+  withEnv({ AMALGM_DIR: amalgmDir, AMALGM_RUNTIME_LABEL: 'preview' }, () => {
+    assert.equal(engine.mode(), 'cli');
+  });
+});
+
+test('entrypoint routing: candidate order is state dir, derived label dir, AMALGM_DIR, home', () => {
+  withEnv({
+    AMALGM_RUNTIME_STATE_DIR: '/tmp/a-state',
+    AMALGM_DIR: '/tmp/a-dir',
+    AMALGM_RUNTIME_LABEL: 'main',
+  }, () => {
+    const candidates = engine.bridgeFileCandidates();
+    assert.deepEqual(candidates.slice(0, 3), [
+      '/tmp/a-state/electron-browser-bridge.json',
+      '/tmp/a-dir/runtimes/main/electron-browser-bridge.json',
+      '/tmp/a-dir/electron-browser-bridge.json',
+    ]);
+    assert.equal(candidates[3], path.join(os.homedir(), '.amalgm', 'electron-browser-bridge.json'));
+  });
+});

package/runtime/scripts/amalgm-mcp/tests/core-tools.test.js

@@ -13,9 +13,6 @@ test('core tools are grouped into first-party toolbox-style defaults', () => {
     'agents',
     'apps',
     'browser',
-    'browser_cua',
-    'browser_recording',
-    'browser_auth',
   ]);
   assert.equal(CORE_TOOL_GROUPS.every((group) => group.origin === 'system'), true);
   assert.equal(CORE_TOOL_GROUPS.every((group) => group.owner === 'amalgm'), true);
@@ -34,16 +31,22 @@ test('core tool grouping preserves handler definitions for MCP surface wrapping'
 test('core tool actions carry stable toolbox ids', () => {
   const browserOpen = CORE_TOOLS.find((tool) => tool.name === 'browser_open');
   const notifyUser = CORE_TOOLS.find((tool) => tool.name === 'notify_user');
+  const cuaClick = CORE_TOOLS.find((tool) => tool.name === 'cua_click');
+  const recordStart = CORE_TOOLS.find((tool) => tool.name === 'record_start');
 
   assert.equal(browserOpen.toolboxToolId, 'browser');
   assert.equal(browserOpen.toolboxActionId, 'browser.browser_open');
+  assert.equal(cuaClick.toolboxToolId, 'browser');
+  assert.equal(cuaClick.toolboxActionId, 'browser.cua_click');
+  assert.equal(recordStart.toolboxActionId, 'browser.record_start');
   assert.equal(notifyUser.toolboxToolId, 'notifications');
   assert.equal(notifyUser.toolboxActionId, 'notifications.notify_user');
 });
 
-test('browser surface stays thin and cua/recorder are separate groups', () => {
+test('browser is a single toolbox entry holding every browser action', () => {
   const browser = CORE_TOOL_GROUPS.find((group) => group.id === 'browser');
   assert.deepEqual(browser.tools.map((tool) => tool.name), [
+    // core verbs
     'browser_open',
     'browser_snapshot',
     'browser_screenshot',
@@ -54,17 +57,69 @@ test('browser surface stays thin and cua/recorder are separate groups', () => {
     'browser_wait',
     'browser_cli',
     'browser_close',
+    // computer use
+    'cua_screenshot',
+    'cua_click',
+    'cua_double_click',
+    'cua_move',
+    'cua_scroll',
+    'cua_type',
+    'cua_keypress',
+    'cua_drag',
+    // recording
+    'record_start',
+    'record_stop',
+    'record_list',
+    // auth / profiles
+    'browser_profiles_list',
+    'browser_auth_bundles_list',
+    'browser_login_sessions_list',
+    'browser_auth_link_create',
+    'browser_auth_save',
+    'browser_auth_load',
   ]);
 
-  const cua = CORE_TOOL_GROUPS.find((group) => group.id === 'browser_cua');
-  assert.equal(cua.tools.every((tool) => tool.name.startsWith('cua_')), true);
+  // No other browser-ish groups exist.
+  assert.deepEqual(
+    CORE_TOOL_GROUPS.filter((group) => group.id.startsWith('browser')).map((group) => group.id),
+    ['browser'],
+  );
+});
+
+test('browser actions carry capability tags so UIs can section one card', () => {
+  const browser = CORE_TOOL_GROUPS.find((group) => group.id === 'browser');
+  const byCapability = (capability) => browser.tools
+    .filter((tool) => tool.capability === capability)
+    .map((tool) => tool.name);
 
-  const recorder = CORE_TOOL_GROUPS.find((group) => group.id === 'browser_recording');
-  assert.deepEqual(recorder.tools.map((tool) => tool.name), ['record_start', 'record_stop', 'record_list']);
+  assert.equal(byCapability('core').length, 10);
+  assert.equal(byCapability('computer-use').every((name) => name.startsWith('cua_')), true);
+  assert.deepEqual(byCapability('recording'), ['record_start', 'record_stop', 'record_list']);
+  assert.equal(byCapability('auth').length, 6);
+  assert.equal(browser.tools.every((tool) => Boolean(tool.capability)), true);
 });
 
-test('browser capability groups carry family metadata for nested presentation', () => {
-  const family = CORE_TOOL_GROUPS.filter((group) => group.family === 'browser');
-  assert.deepEqual(family.map((group) => group.id), ['browser', 'browser_cua', 'browser_recording', 'browser_auth']);
-  assert.deepEqual(family.map((group) => group.capability), ['core', 'computer-use', 'recording', 'auth']);
+test('legacy capability-group loadouts still grant the collapsed actions', () => {
+  const { loadoutContainsToolOrAction } = require('../toolbox/loadout-context');
+
+  // Old group id grants exactly that group's actions.
+  const cuaLoadout = new Set(['browser_cua']);
+  assert.equal(loadoutContainsToolOrAction(cuaLoadout, 'browser', 'browser.cua_click'), true);
+  assert.equal(loadoutContainsToolOrAction(cuaLoadout, 'browser', 'browser.record_start'), false);
+  assert.equal(loadoutContainsToolOrAction(cuaLoadout, 'browser', 'browser.browser_open'), false);
+
+  // Old fine-grained action ids map 1:1.
+  const actionLoadout = new Set(['browser_recording.record_start']);
+  assert.equal(loadoutContainsToolOrAction(actionLoadout, 'browser', 'browser.record_start'), true);
+  assert.equal(loadoutContainsToolOrAction(actionLoadout, 'browser', 'browser.record_stop'), false);
+
+  // New single entry grants everything.
+  const browserLoadout = new Set(['browser']);
+  assert.equal(loadoutContainsToolOrAction(browserLoadout, 'browser', 'browser.browser_open'), true);
+  assert.equal(loadoutContainsToolOrAction(browserLoadout, 'browser', 'browser.cua_click'), true);
+  assert.equal(loadoutContainsToolOrAction(browserLoadout, 'browser', 'browser.browser_auth_save'), true);
+
+  // Legacy amalgm.browser aggregate keeps granting browser actions.
+  const legacyAggregate = new Set(['amalgm.browser']);
+  assert.equal(loadoutContainsToolOrAction(legacyAggregate, 'browser', 'browser.browser_open'), true);
 });

package/runtime/scripts/amalgm-mcp/toolbox/loadout-context.js

@@ -11,6 +11,35 @@ const FIRST_PARTY_TOOL_IDS = new Set([
   'browser',
 ]);
 
+// Browser used to ship as four toolbox entries; it is one (`browser`) now.
+// Loadouts saved against the old capability groups keep working: the old
+// group id grants exactly the actions that group contained, and old action
+// ids map 1:1 onto `browser.<action>`. Frozen sets — these never grow.
+const LEGACY_BROWSER_GROUP_ACTIONS = {
+  browser_cua: new Set([
+    'cua_screenshot', 'cua_click', 'cua_double_click', 'cua_move',
+    'cua_scroll', 'cua_type', 'cua_keypress', 'cua_drag',
+  ]),
+  browser_recording: new Set(['record_start', 'record_stop', 'record_list']),
+  browser_auth: new Set([
+    'browser_profiles_list', 'browser_auth_bundles_list',
+    'browser_login_sessions_list', 'browser_auth_link_create',
+    'browser_auth_save', 'browser_auth_load',
+  ]),
+};
+
+function legacyBrowserLoadoutHas(loadoutToolIds, actionId) {
+  if (!actionId.startsWith('browser.')) return false;
+  const action = actionId.slice('browser.'.length);
+  for (const [legacyId, actions] of Object.entries(LEGACY_BROWSER_GROUP_ACTIONS)) {
+    if (!actions.has(action)) continue;
+    if (loadoutToolIds.has(legacyId)) return true;
+    if (loadoutToolIds.has(`${legacyId}.${action}`)) return true;
+    if (loadoutToolIds.has(`amalgm.${legacyId}`)) return true;
+  }
+  return false;
+}
+
 function agentConfigIdFromContext(context) {
   const metadata = context?.sessionMetadata || {};
   return (
@@ -43,6 +72,7 @@ function loadoutHas(loadoutToolIds, id) {
   if (FIRST_PARTY_TOOL_IDS.has(value) && loadoutToolIds.has(`amalgm.${value}`)) return true;
   if (value === 'notifications.notify_user' && loadoutToolIds.has('amalgm.notify_user')) return true;
   if (value === 'agents.talk_to_agent' && loadoutToolIds.has('amalgm.talk_to_agent')) return true;
+  if (legacyBrowserLoadoutHas(loadoutToolIds, value)) return true;
   return false;
 }
 

package/runtime/scripts/amalgm-mcp/toolbox/system-catalog.js

@@ -18,6 +18,11 @@ const LEGACY_FIRST_PARTY_TOOL_IDS = new Set([
   'amalgm.agents',
   'amalgm.apps',
   'amalgm.browser',
+  // Former Browser capability groups, collapsed into the single `browser`
+  // entry. Loadout compat lives in toolbox/loadout-context.js.
+  'browser_cua',
+  'browser_recording',
+  'browser_auth',
 ]);
 
 function coreToolGroups() {
@@ -40,8 +45,6 @@ function systemToolForGroup(group) {
     display: {
       icon: '/assets/images/amalgm_logo.svg',
       description: group.description,
-      ...(group.family ? { family: group.family } : {}),
-      ...(group.capability ? { capability: group.capability } : {}),
     },
     policy: {
       system: true,
@@ -60,6 +63,7 @@ function systemActionForTool(tool, group) {
     displayName: tool.toolboxActionName,
     description: tool.description || '',
     inputSchema: tool.inputSchema || { type: 'object', properties: {} },
+    ...(tool.capability ? { capability: tool.capability } : {}),
     status: 'enabled',
     sourceAction: {
       handlerName: tool.name,

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

@@ -1,281 +0,0 @@
-const http = require('http');
-const https = require('https');
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const DEFAULT_SESSION = `mcp-${process.pid}-default`;
-
-function amalgmDir() {
-  return process.env.AMALGM_DIR || path.join(os.homedir(), '.amalgm');
-}
-
-function bridgeConfigFile() {
-  return path.join(amalgmDir(), 'electron-browser-bridge.json');
-}
-
-function isLoopbackUrl(value) {
-  try {
-    const url = new URL(value);
-    return url.protocol === 'http:' && (url.hostname === '127.0.0.1' || url.hostname === 'localhost');
-  } catch {
-    return false;
-  }
-}
-
-function pidIsRunning(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err && err.code === 'EPERM';
-  }
-}
-
-function normalizeConfig(data) {
-  const baseUrl = typeof data?.baseUrl === 'string' ? data.baseUrl : '';
-  const token = typeof data?.token === 'string' ? data.token : '';
-  if (!baseUrl || !token || !isLoopbackUrl(baseUrl)) return null;
-  if (typeof data?.pid === 'number' && !pidIsRunning(data.pid)) return null;
-  return { baseUrl, token };
-}
-
-function fileConfig() {
-  try {
-    return normalizeConfig(JSON.parse(fs.readFileSync(bridgeConfigFile(), 'utf8')));
-  } catch {
-    return null;
-  }
-}
-
-function config() {
-  const baseUrl = process.env.AMALGM_ELECTRON_BROWSER_URL;
-  const token = process.env.AMALGM_ELECTRON_BROWSER_TOKEN;
-  return normalizeConfig({ baseUrl, token }) || fileConfig();
-}
-
-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.browserSessionId && next.browserProfileId) {
-    next.browserSessionId = next.browserProfileId;
-  }
-  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 saveStateBrowser(args = {}, context) {
-  return call('state_save', args, context);
-}
-
-async function loadStateBrowser(args = {}, context) {
-  return call('state_load', 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,
-  loadStateBrowser,
-  navigateBrowser,
-  pressBrowser,
-  screenshotBrowser,
-  saveStateBrowser,
-  snapshotBrowser,
-  startVideoBrowser,
-  stateBrowser,
-  stopVideoBrowser,
-  tabNavigationBrowser,
-  tabsGetBrowser,
-  tabsListBrowser,
-  tabsNewBrowser,
-  tabsSelectBrowser,
-  tabsSelectedBrowser,
-  typeBrowser,
-  waitForLoadStateBrowser,
-  waitForSelectorBrowser,
-  waitForURLBrowser,
-};