appium-remote-debugger 11.4.1 → 11.5.0

package/lib/mixins/connect.js

@@ -1,7 +1,7 @@
-import log from '../logger';
 import {
-  appInfoFromDict, pageArrayFromDict, getDebuggerAppKey,
-  getPossibleDebuggerAppKeys, simpleStringify, deferredPromise
+  pageArrayFromDict,
+  getPossibleDebuggerAppKeys,
+  simpleStringify,
 } from '../utils';
 import events from './events';
 import { timing } from '@appium/support';
@@ -32,62 +32,60 @@ const BLANK_PAGE_URL = 'about:blank';
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
+ * @returns {Promise<void>}
  */
-async function setConnectionKey () {
-  log.debug('Sending connection key request');
-  if (!this.rpcClient) {
-    throw new Error('rpcClient is undefined. Is the debugger connected?');
-  }
+export async function setConnectionKey () {
+  this.log.debug('Sending connection key request');
 
   // send but only wait to make sure the socket worked
   // as response from Web Inspector can take a long time
-  await this.rpcClient.send('setConnectionKey', {}, false);
+  await this.requireRpcClient().send('setConnectionKey', {}, false);
 }
 
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
+ * @param {number} [timeout=APP_CONNECT_TIMEOUT_MS]
+ * @returns {Promise<import('@appium/types').StringRecord>}
  */
-async function connect (timeout = APP_CONNECT_TIMEOUT_MS) {
+export async function connect (timeout = APP_CONNECT_TIMEOUT_MS) {
   this.setup();
 
   // initialize the rpc client
   this.initRpcClient();
 
-  if (!this.rpcClient) {
-    throw new Error('rpcClient is undefined. Is the debugger connected?');
-  }
+  const rpcClient = this.requireRpcClient();
 
   // listen for basic debugger-level events
-  this.rpcClient.on('_rpc_reportSetup:', _.noop);
-  this.rpcClient.on('_rpc_forwardGetListing:', this.onPageChange.bind(this));
-  this.rpcClient.on('_rpc_reportConnectedApplicationList:', this.onConnectedApplicationList.bind(this));
-  this.rpcClient.on('_rpc_applicationConnected:', this.onAppConnect.bind(this));
-  this.rpcClient.on('_rpc_applicationDisconnected:', this.onAppDisconnect.bind(this));
-  this.rpcClient.on('_rpc_applicationUpdated:', this.onAppUpdate.bind(this));
-  this.rpcClient.on('_rpc_reportConnectedDriverList:', this.onConnectedDriverList.bind(this));
-  this.rpcClient.on('_rpc_reportCurrentState:', this.onCurrentState.bind(this));
-  this.rpcClient.on('Page.frameDetached', this.frameDetached.bind(this));
-
-  await this.rpcClient.connect();
+  rpcClient.on('_rpc_reportSetup:', _.noop);
+  rpcClient.on('_rpc_forwardGetListing:', this.onPageChange.bind(this));
+  rpcClient.on('_rpc_reportConnectedApplicationList:', this.onConnectedApplicationList.bind(this));
+  rpcClient.on('_rpc_applicationConnected:', this.onAppConnect.bind(this));
+  rpcClient.on('_rpc_applicationDisconnected:', this.onAppDisconnect.bind(this));
+  rpcClient.on('_rpc_applicationUpdated:', this.onAppUpdate.bind(this));
+  rpcClient.on('_rpc_reportConnectedDriverList:', this.onConnectedDriverList.bind(this));
+  rpcClient.on('_rpc_reportCurrentState:', this.onCurrentState.bind(this));
+  rpcClient.on('Page.frameDetached', this.frameDetached.bind(this));
+
+  await rpcClient.connect();
 
   // get the connection information about the app
   try {
     this.setConnectionKey();
     if (timeout) {
-      log.debug(`Waiting up to ${timeout}ms for applications to be reported`);
+      this.log.debug(`Waiting up to ${timeout}ms for applications to be reported`);
       try {
         await waitForCondition(() => !_.isEmpty(this.appDict), {
           waitMs: timeout,
           intervalMs: APP_CONNECT_INTERVAL_MS,
         });
       } catch (err) {
-        log.debug(`Timed out waiting for applications to be reported`);
+        this.log.debug(`Timed out waiting for applications to be reported`);
       }
     }
     return this.appDict || {};
   } catch (err) {
-    log.error(`Error setting connection key: ${err.message}`);
+    this.log.error(`Error setting connection key: ${err.message}`);
     await this.disconnect();
     throw err;
   }
@@ -98,7 +96,7 @@ async function connect (timeout = APP_CONNECT_TIMEOUT_MS) {
  * @this {import('../remote-debugger').RemoteDebugger}
  * @returns {Promise<void>}
  */
-async function disconnect () {
+export async function disconnect () {
   if (this.rpcClient) {
     await this.rpcClient.disconnect();
   }
@@ -106,50 +104,58 @@ async function disconnect () {
   this.teardown();
 }
 
+/**
+ * @typedef {Object} Page
+ * @property {string} url
+ * @property {string} title
+ * @property {number} id
+ * @property {boolean} isKey
+ * @property {string} [bundleId]
+ */
+
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
  * @param {string?} currentUrl
  * @param {number} [maxTries]
  * @param {boolean} [ignoreAboutBlankUrl]
- * @returns {Promise<AppPages[]>}
+ * @returns {Promise<Page[]>}
  */
-async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIES, ignoreAboutBlankUrl = false) {
-  log.debug('Selecting application');
-  if (!this.rpcClient) {
-    throw new Error('rpcClient is undefined. Is the debugger connected?');
-  }
+export async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIES, ignoreAboutBlankUrl = false) {
+  this.log.debug('Selecting application');
+  const rpcClient = this.requireRpcClient();
 
-  const shouldCheckForTarget = this.rpcClient.shouldCheckForTarget;
-  this.rpcClient.shouldCheckForTarget = false;
+  const shouldCheckForTarget = rpcClient.shouldCheckForTarget;
+  rpcClient.shouldCheckForTarget = false;
   try {
     const timer = new timing.Timer().start();
     if (!this.appDict || _.isEmpty(this.appDict)) {
-      log.debug('No applications currently connected.');
+      this.log.debug('No applications currently connected.');
       return [];
     }
 
-    const {appIdKey, pageDict} = await this.searchForApp(currentUrl, maxTries, ignoreAboutBlankUrl);
+    const {appIdKey, pageDict} = await this.searchForApp(currentUrl, maxTries, ignoreAboutBlankUrl) ?? {};
 
     // if, after all this, we have no dictionary, we have failed
     if (!appIdKey || !pageDict) {
-      log.errorAndThrow(`Could not connect to a valid app after ${maxTries} tries.`);
+      throw this.log.errorWithException(`Could not connect to a valid app after ${maxTries} tries.`);
     }
 
     if (this.appIdKey !== appIdKey) {
-      log.debug(`Received altered app id, updating from '${this.appIdKey}' to '${appIdKey}'`);
+      this.log.debug(`Received altered app id, updating from '${this.appIdKey}' to '${appIdKey}'`);
       this.appIdKey = appIdKey;
     }
 
-    logApplicationDictionary(this.appDict);
+    logApplicationDictionary.bind(this)(this.appDict);
 
     // translate the dictionary into a useful form, and return to sender
     const pageArray = _.isEmpty(this.appDict[appIdKey].pageArray)
       ? pageArrayFromDict(pageDict)
       : this.appDict[appIdKey].pageArray;
-    log.debug(`Finally selecting app ${this.appIdKey}: ${simpleStringify(pageArray)}`);
+    this.log.debug(`Finally selecting app ${this.appIdKey}: ${simpleStringify(pageArray)}`);
 
-    let fullPageArray = [];
+    /** @type {Page[]} */
+    const fullPageArray = [];
     for (const [app, info] of _.toPairs(this.appDict)) {
       if (!_.isArray(info.pageArray) || !info.isActive) {
         continue;
@@ -157,7 +163,7 @@ async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIES, igno
       const id = app.replace('PID:', '');
       for (const page of info.pageArray) {
         if (!(ignoreAboutBlankUrl && page.url === BLANK_PAGE_URL)) {
-          let pageDict = _.clone(page);
+          const pageDict = _.clone(page);
           pageDict.id = `${id}.${pageDict.id}`;
           pageDict.bundleId = info.bundleId;
           fullPageArray.push(pageDict);
@@ -165,10 +171,10 @@ async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIES, igno
       }
     }
 
-    log.debug(`Selected app after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+    this.log.debug(`Selected app after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
     return fullPageArray;
   } finally {
-    this.rpcClient.shouldCheckForTarget = shouldCheckForTarget;
+    rpcClient.shouldCheckForTarget = shouldCheckForTarget;
   }
 }
 
@@ -180,32 +186,28 @@ async function selectApp (currentUrl = null, maxTries = SELECT_APP_RETRIES, igno
  * @param {boolean} ignoreAboutBlankUrl
  * @returns {Promise<AppPages?>}
  */
-async function searchForApp (currentUrl, maxTries, ignoreAboutBlankUrl) {
+export async function searchForApp (currentUrl, maxTries, ignoreAboutBlankUrl) {
   const bundleIds = this.includeSafari && !this.isSafari
     ? [this.bundleId, ...this.additionalBundleIds, SAFARI_BUNDLE_ID]
     : [this.bundleId, ...this.additionalBundleIds];
   let retryCount = 0;
   try {
     return await retryInterval(maxTries, SELECT_APP_RETRY_SLEEP_MS, async () => {
-      if (!this.rpcClient) {
-        throw new Error('rpcClient is undefined. Is the debugger connected?');
-      }
-
-      logApplicationDictionary(this.appDict);
+      logApplicationDictionary.bind(this)(this.appDict);
       const possibleAppIds = getPossibleDebuggerAppKeys(/** @type {string[]} */ (bundleIds), this.appDict);
-      log.debug(`Trying out the possible app ids: ${possibleAppIds.join(', ')} (try #${retryCount + 1} of ${maxTries})`);
+      this.log.debug(`Trying out the possible app ids: ${possibleAppIds.join(', ')} (try #${retryCount + 1} of ${maxTries})`);
       for (const attemptedAppIdKey of possibleAppIds) {
         try {
           if (!this.appDict[attemptedAppIdKey].isActive) {
-            log.debug(`Skipping app '${attemptedAppIdKey}' because it is not active`);
+            this.log.debug(`Skipping app '${attemptedAppIdKey}' because it is not active`);
             continue;
           }
-          log.debug(`Attempting app '${attemptedAppIdKey}'`);
-          const [appIdKey, pageDict] = await this.rpcClient.selectApp(attemptedAppIdKey);
+          this.log.debug(`Attempting app '${attemptedAppIdKey}'`);
+          const [appIdKey, pageDict] = await this.requireRpcClient().selectApp(attemptedAppIdKey);
           // in iOS 8.2 the connect logic happens, but with an empty dictionary
           // which leads to the remote debugger getting disconnected, and into a loop
           if (_.isEmpty(pageDict)) {
-            log.debug('Empty page dictionary received. Trying again.');
+            this.log.debug('Empty page dictionary received. Trying again.');
             continue;
           }
 
@@ -221,19 +223,19 @@ async function searchForApp (currentUrl, maxTries, ignoreAboutBlankUrl) {
           }
 
           if (currentUrl) {
-            log.debug(`Received app, but expected url ('${currentUrl}') was not found. Trying again.`);
+            this.log.debug(`Received app, but expected url ('${currentUrl}') was not found. Trying again.`);
           } else {
-            log.debug('Received app, but no match was found. Trying again.');
+            this.log.debug('Received app, but no match was found. Trying again.');
           }
         } catch (err) {
-          log.debug(`Error checking application: '${err.message}'. Retrying connection`);
+          this.log.debug(`Error checking application: '${err.message}'. Retrying connection`);
         }
       }
       retryCount++;
       throw new Error('Failed to find an app to select');
     });
   } catch (ign) {
-    log.errorAndThrow(`Could not connect to a valid app after ${maxTries} tries.`);
+    this.log.errorAndThrow(`Could not connect to a valid app after ${maxTries} tries.`);
   }
   return null;
 }
@@ -246,7 +248,7 @@ async function searchForApp (currentUrl, maxTries, ignoreAboutBlankUrl) {
  * @param {boolean} [ignoreAboutBlankUrl]
  * @returns {AppPages?}
  */
-function searchForPage (appsDict, currentUrl = null, ignoreAboutBlankUrl = false) {
+export function searchForPage (appsDict, currentUrl = null, ignoreAboutBlankUrl = false) {
   for (const appDict of _.values(appsDict)) {
     if (!appDict || !appDict.isActive || !appDict.pageArray || appDict.pageArray.promise) {
       continue;
@@ -265,34 +267,31 @@ function searchForPage (appsDict, currentUrl = null, ignoreAboutBlankUrl = false
 /**
  *
  * @this {import('../remote-debugger').RemoteDebugger}
- * @param {string} appIdKey
- * @param {string} pageIdKey
+ * @param {string|number} appIdKey
+ * @param {string|number} pageIdKey
  * @param {boolean} [skipReadyCheck]
  * @returns {Promise<void>}
  */
-async function selectPage (appIdKey, pageIdKey, skipReadyCheck = false) {
-  this.appIdKey = `PID:${appIdKey}`;
+export async function selectPage (appIdKey, pageIdKey, skipReadyCheck = false) {
+  this.appIdKey = _.startsWith(`${appIdKey}`, 'PID:') ? `${appIdKey}` : `PID:${appIdKey}`;
   this.pageIdKey = pageIdKey;
 
-  log.debug(`Selecting page '${pageIdKey}' on app '${this.appIdKey}' and forwarding socket setup`);
-  if (!this.rpcClient) {
-    throw new Error('rpcClient is undefined. Is the debugger connected?');
-  }
+  this.log.debug(`Selecting page '${pageIdKey}' on app '${this.appIdKey}' and forwarding socket setup`);
 
   const timer = new timing.Timer().start();
 
-  await this.rpcClient.selectPage(this.appIdKey, pageIdKey);
+  await this.requireRpcClient().selectPage(this.appIdKey, pageIdKey);
 
   // make sure everything is ready to go
   if (!skipReadyCheck && !await this.checkPageIsReady()) {
     await this.waitForDom();
   }
 
-  log.debug(`Selected page after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
+  this.log.debug(`Selected page after ${timer.getDuration().asMilliSeconds.toFixed(0)}ms`);
 }
 
 /**
- *
+ * @this {import('../remote-debugger').RemoteDebugger}
  * @param {Record<string, any>} apps
  * @returns {void}
  */
@@ -308,56 +307,23 @@ function logApplicationDictionary (apps) {
     return JSON.stringify(value);
   }
 
-  log.debug('Current applications available:');
+  this.log.debug('Current applications available:');
   for (const [app, info] of _.toPairs(apps)) {
-    log.debug(`    Application: "${app}"`);
+    this.log.debug(`    Application: "${app}"`);
     for (const [key, value] of _.toPairs(info)) {
       if (key === 'pageArray' && Array.isArray(value) && value.length) {
-        log.debug(`        ${key}:`);
+        this.log.debug(`        ${key}:`);
         for (const page of value) {
           let prefix = '- ';
           for (const [k, v] of _.toPairs(page)) {
-            log.debug(`          ${prefix}${k}: ${JSON.stringify(v)}`);
+            this.log.debug(`          ${prefix}${k}: ${JSON.stringify(v)}`);
             prefix = '  ';
           }
         }
       } else {
         const valueString = getValueString(key, value);
-        log.debug(`        ${key}: ${valueString}`);
+        this.log.debug(`        ${key}: ${valueString}`);
       }
     }
   }
 }
-
-/**
- *
- * @this {import('../remote-debugger').RemoteDebugger}
- * @param {Record<string, any>} dict
- * @returns {void}
- */
-function updateAppsWithDict (dict) {
-  // get the dictionary entry into a nice form, and add it to the
-  // application dictionary
-  this.appDict = this.appDict || {};
-  let [id, entry] = appInfoFromDict(dict);
-  if (this.appDict[id]) {
-    // preserve the page dictionary for this entry
-    entry.pageArray = this.appDict[id].pageArray;
-  }
-  this.appDict[id] = entry;
-
-  // add a promise to get the page dictionary
-  if (_.isUndefined(entry.pageArray)) {
-    entry.pageArray = deferredPromise();
-  }
-
-  // try to get the app id from our connected apps
-  if (!this.appIdKey) {
-    this.appIdKey = getDebuggerAppKey(/** @type {string} */ (this.bundleId), this.appDict);
-  }
-}
-
-export default {
-  setConnectionKey, connect, disconnect, selectApp,
-  searchForApp, searchForPage, selectPage, updateAppsWithDict
-};

package/lib/mixins/cookies.js

@@ -0,0 +1,45 @@
+
+/**
+ *
+ * @this {import('../remote-debugger').RemoteDebugger}
+ * @returns {Promise<void>}
+ */
+export async function getCookies () {
+  this.log.debug('Getting cookies');
+  return await this.requireRpcClient().send('Page.getCookies', {
+    appIdKey: this.appIdKey,
+    pageIdKey: this.pageIdKey
+  });
+}
+
+/**
+ *
+ * @this {import('../remote-debugger').RemoteDebugger}
+ * @param {any} cookie
+ * @returns {Promise<any>}
+ */
+export async function setCookie (cookie) {
+  this.log.debug('Setting cookie');
+  return await this.requireRpcClient().send('Page.setCookie', {
+    appIdKey: this.appIdKey,
+    pageIdKey: this.pageIdKey,
+    cookie
+  });
+}
+
+/**
+ *
+ * @this {import('../remote-debugger').RemoteDebugger}
+ * @param {string} cookieName
+ * @param {string} url
+ * @returns {Promise<any>}
+ */
+export async function deleteCookie (cookieName, url) {
+  this.log.debug(`Deleting cookie '${cookieName}' on '${url}'`);
+  return await this.requireRpcClient().send('Page.deleteCookie', {
+    appIdKey: this.appIdKey,
+    pageIdKey: this.pageIdKey,
+    cookieName,
+    url,
+  });
+}

package/lib/mixins/events.js

@@ -1,9 +1,33 @@
 // event emitted publically
-const events = {
+export const events = {
   EVENT_PAGE_CHANGE: 'remote_debugger_page_change',
   EVENT_FRAMES_DETACHED: 'remote_debugger_frames_detached',
   EVENT_DISCONNECT: 'remote_debugger_disconnect',
 };
 
+/**
+ * Keep track of the client event listeners so they can be removed
+ *
+ * @this {import('../remote-debugger').RemoteDebugger}
+ * @param {string} eventName
+ * @param {(event: import('@appium/types').StringRecord) => any} listener
+ * @returns {void}
+ */
+export function addClientEventListener (eventName, listener) {
+  this._clientEventListeners[eventName] ??= [];
+  this._clientEventListeners[eventName].push(listener);
+  this.requireRpcClient().on(eventName, listener);
+}
+
+/**
+ * @this {import('../remote-debugger').RemoteDebugger}
+ * @param {string} eventName
+ * @returns {void}
+ */
+export function removeClientEventListener (eventName) {
+  for (const listener of (this._clientEventListeners[eventName] || [])) {
+    this.requireRpcClient().off(eventName, listener);
+  }
+}
 
 export default events;

package/lib/mixins/execute.js

@@ -1,4 +1,3 @@
-import log from '../logger';
 import { errors } from '@appium/base-driver';
 import { checkParams, simpleStringify, convertResult, RESPONSE_LOG_LENGTH } from '../utils';
 import { getScriptForAtom } from '../atoms';
@@ -15,17 +14,13 @@ const RPC_RESPONSE_TIMEOUT_MS = 5000;
  * @param {string} atom Name of Selenium atom (see atoms/ directory)
  * @param {any[]} args Arguments passed to the atom
  * @param {string[]} frames
- * @returns {Promise<string>} The result received from the atom
+ * @returns {Promise<any>} The result received from the atom
  */
-async function executeAtom (atom, args = [], frames = []) {
-  if (!this.rpcClient?.isConnected) {
-    throw new Error('Remote debugger is not connected');
-  }
-
-  log.debug(`Executing atom '${atom}' with 'args=${JSON.stringify(args)}; frames=${frames}'`);
+export async function executeAtom (atom, args = [], frames = []) {
+  this.log.debug(`Executing atom '${atom}' with 'args=${JSON.stringify(args)}; frames=${frames}'`);
   const script = await getScriptForAtom(atom, args, frames);
   const value = await this.execute(script, true);
-  log.debug(`Received result for atom '${atom}' execution: ${_.truncate(simpleStringify(value), {length: RESPONSE_LOG_LENGTH})}`);
+  this.log.debug(`Received result for atom '${atom}' execution: ${_.truncate(simpleStringify(value), {length: RESPONSE_LOG_LENGTH})}`);
   return value;
 }
 
@@ -36,18 +31,13 @@ async function executeAtom (atom, args = [], frames = []) {
  * @param {string[]} [frames]
  * @returns {Promise<any>}
  */
-async function executeAtomAsync (atom, args = [], frames = []) {
+export async function executeAtomAsync (atom, args = [], frames = []) {
   // helper to send directly to the web inspector
-  const evaluate = async (method, opts) => {
-    if (!this.rpcClient?.isConnected) {
-      throw new Error('Remote debugger is not connected');
-    }
-    return await this.rpcClient.send(method, Object.assign({
-      appIdKey: this.appIdKey,
-      pageIdKey: this.pageIdKey,
-      returnByValue: false,
-    }, opts));
-  };
+  const evaluate = async (method, opts) => await this.requireRpcClient(true).send(method, Object.assign({
+    appIdKey: this.appIdKey,
+    pageIdKey: this.pageIdKey,
+    returnByValue: false,
+  }, opts));
 
   // first create a Promise on the page, saving the resolve/reject functions
   // as properties
@@ -94,7 +84,7 @@ async function executeAtomAsync (atom, args = [], frames = []) {
     // if the timeout math turns up 0 retries, make sure it happens once
     const retries = parseInt(`${timeout / retryWait}`, 10) || 1;
     const timer = new timing.Timer().start();
-    log.debug(`Waiting up to ${timeout}ms for async execute to finish`);
+    this.log.debug(`Waiting up to ${timeout}ms for async execute to finish`);
     res = await retryInterval(retries, retryWait, async () => {
       // the atom _will_ return, either because it finished or an error
       // including a timeout error
@@ -131,10 +121,10 @@ async function executeAtomAsync (atom, args = [], frames = []) {
  * @param {boolean} [override]
  * @returns {Promise<any>}
  */
-async function execute (command, override) {
+export async function execute (command, override) {
   // if the page is not loaded yet, wait for it
   if (this.pageLoading && !override) {
-    log.debug('Trying to execute but page is not loaded.');
+    this.log.debug('Trying to execute but page is not loaded.');
     await this.waitForDom();
   }
 
@@ -149,17 +139,13 @@ async function execute (command, override) {
     await this.garbageCollect();
   }
 
-  log.debug(`Sending javascript command: '${_.truncate(command, {length: 50})}'`);
-  if (!this.rpcClient?.isConnected) {
-    throw new Error('Remote debugger is not connected');
-  }
-  const res = await this.rpcClient.send('Runtime.evaluate', {
+  this.log.debug(`Sending javascript command: '${_.truncate(command, {length: 50})}'`);
+  const res = await this.requireRpcClient(true).send('Runtime.evaluate', {
     expression: command,
     returnByValue: true,
     appIdKey: this.appIdKey,
     pageIdKey: this.pageIdKey,
   });
-
   return convertResult(res);
 }
 
@@ -169,19 +155,15 @@ async function execute (command, override) {
  * @param {any} fn
  * @param {any[]} [args]
  */
-async function callFunction (objectId, fn, args) {
-  if (!this.rpcClient?.isConnected) {
-    throw new Error('Remote debugger is not connected');
-  }
-
+export async function callFunction (objectId, fn, args) {
   checkParams({appIdKey: this.appIdKey, pageIdKey: this.pageIdKey});
 
   if (this.garbageCollectOnExecute) {
     await this.garbageCollect();
   }
 
-  log.debug('Calling javascript function');
-  const res = await this.rpcClient.send('Runtime.callFunctionOn', {
+  this.log.debug('Calling javascript function');
+  const res = await this.requireRpcClient(true).send('Runtime.callFunctionOn', {
     objectId,
     functionDeclaration: fn,
     arguments: args,
@@ -192,6 +174,3 @@ async function callFunction (objectId, fn, args) {
 
   return convertResult(res);
 }
-
-
-export default { executeAtom, executeAtomAsync, execute, callFunction };