appium-remote-debugger 15.7.3 → 15.8.1

package/lib/rpc/rpc-message-handler.ts

@@ -1,6 +1,6 @@
 import {EventEmitter} from 'node:events';
 import {log} from '../logger';
-import _ from 'lodash';
+import {isPlainObject, truncateString} from '../utils';
 import {util} from '@appium/support';
 import type {StringRecord} from '@appium/types';
 
@@ -106,7 +106,7 @@ export default class RpcMessageHandler extends EventEmitter {
     try {
       return JSON.parse(plist.__argument.WIRMessageDataKey.toString('utf8'));
     } catch (err: any) {
-      log.error(`Unparseable message data: ${_.truncate(JSON.stringify(plist), {length: 100})}`);
+      log.error(`Unparseable message data: ${truncateString(JSON.stringify(plist), 100)}`);
       throw new Error(`Unable to parse message data: ${err.message}`);
     }
   }
@@ -132,7 +132,7 @@ export default class RpcMessageHandler extends EventEmitter {
   ): Promise<void> {
     if (msgId) {
       if (this.listenerCount(msgId)) {
-        if (_.has(result?.result, 'value')) {
+        if (Object.hasOwn(result?.result ?? {}, 'value')) {
           result = result.result.value;
         }
         this.emit(msgId, error, result);
@@ -173,12 +173,12 @@ export default class RpcMessageHandler extends EventEmitter {
         break;
     }
 
-    if (method && _.startsWith(method, 'Network.')) {
+    if (method?.startsWith('Network.')) {
       // aggregate Network events, and add original method name to the arguments
       eventNames.push('NetworkEvent');
       args.push(method);
     }
-    if (method && _.startsWith(method, 'Console.')) {
+    if (method?.startsWith('Console.')) {
       // aggregate Console events, and add original method name to the arguments
       eventNames.push('ConsoleEvent');
       args.push(method);
@@ -213,7 +213,7 @@ export default class RpcMessageHandler extends EventEmitter {
         return new Error(message);
       }
       if (dataKey.error) {
-        if (_.isPlainObject(dataKey.error)) {
+        if (isPlainObject(dataKey.error)) {
           const dataKeyError = dataKey.error as DataErrorMessage;
           const error = new Error(defaultMessage);
           for (const key of Object.keys(dataKeyError)) {
@@ -242,7 +242,7 @@ export default class RpcMessageHandler extends EventEmitter {
         if (!dataKey.error) {
           try {
             const message = JSON.parse(dataKey.params.message);
-            msgId = _.isUndefined(message.id) ? '' : String(message.id);
+            msgId = message.id === undefined ? '' : String(message.id);
             method = message.method;
             result = message.result || message;
             params = result.params;

package/lib/types.ts

@@ -75,10 +75,6 @@ export interface RemoteDebuggerOptions {
   log?: AppiumLogger;
 }
 
-interface RemoteDebuggerRealDeviceSpecificOptions {
-  udid: string;
-}
-
 export type RemoteDebuggerRealDeviceOptions = RemoteDebuggerRealDeviceSpecificOptions &
   RemoteDebuggerOptions;
 
@@ -110,9 +106,9 @@ export interface RpcClientSimulatorOptions {
 }
 
 export type AppIdKey = string | number;
+
 export type PageIdKey = string | number;
 export type TargetId = string;
-
 export interface RemoteCommandId {
   id: string;
 }
@@ -135,26 +131,8 @@ export interface ProtocolCommandOpts {
   params: StringRecord;
 }
 
-type SocketDataKey = Buffer | StringRecord;
-
-interface RemoteCommandArgument<T extends SocketDataKey> {
-  WIRSocketDataKey?: T;
-  WIRConnectionIdentifierKey?: string;
-  WIRSenderKey?: string;
-  WIRApplicationIdentifierKey?: AppIdKey;
-  WIRPageIdentifierKey?: PageIdKey;
-  WIRMessageDataTypeKey?: string;
-  WIRDestinationKey?: string;
-  WIRMessageDataKey?: string;
-  [key: string]: any;
-}
-
-interface RemoteCommandTemplated<T extends SocketDataKey> {
-  __argument: RemoteCommandArgument<T>;
-  __selector: string;
-}
-
 export type RawRemoteCommand = RemoteCommandTemplated<StringRecord>;
+
 export type RemoteCommand = RemoteCommandTemplated<Buffer>;
 
 /**
@@ -175,3 +153,25 @@ export interface ProvisionalTargetInfo {
   oldTargetId: string;
   newTargetId: string;
 }
+interface RemoteDebuggerRealDeviceSpecificOptions {
+  udid: string;
+}
+
+type SocketDataKey = Buffer | StringRecord;
+
+interface RemoteCommandArgument<T extends SocketDataKey> {
+  WIRSocketDataKey?: T;
+  WIRConnectionIdentifierKey?: string;
+  WIRSenderKey?: string;
+  WIRApplicationIdentifierKey?: AppIdKey;
+  WIRPageIdentifierKey?: PageIdKey;
+  WIRMessageDataTypeKey?: string;
+  WIRDestinationKey?: string;
+  WIRMessageDataKey?: string;
+  [key: string]: any;
+}
+
+interface RemoteCommandTemplated<T extends SocketDataKey> {
+  __argument: RemoteCommandArgument<T>;
+  __selector: string;
+}

package/lib/utils.ts

@@ -1,6 +1,6 @@
-import _ from 'lodash';
 import {errorFromMJSONWPStatusCode} from '@appium/base-driver';
 import {util, node} from '@appium/support';
+import {isDeepStrictEqual} from 'node:util';
 import nodeFs from 'node:fs';
 import path from 'node:path';
 import type {StringRecord} from '@appium/types';
@@ -17,6 +17,149 @@ const ACCEPTED_PAGE_TYPES = [
 ];
 export const RESPONSE_LOG_LENGTH = 100;
 
+/**
+ * Error thrown when an async operation exceeds the configured timeout.
+ */
+export class TimeoutError extends Error {
+  constructor(message: string = 'Operation timed out') {
+    super(message);
+    this.name = 'TimeoutError';
+  }
+}
+
+/**
+ * Truncates a string to the requested length and appends ellipsis when needed.
+ *
+ * @param value - The input string.
+ * @param length - Maximum output length.
+ * @returns The original string when short enough, otherwise a truncated variant.
+ */
+export function truncateString(value: string, length: number): string {
+  if (value.length <= length) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, length - 1))}…`;
+}
+
+/**
+ * Creates a shallow object where undefined keys from `target` are filled
+ * from `defaultsObj`.
+ *
+ * @param target - The object with priority values.
+ * @param defaultsObj - The object providing fallback values.
+ * @returns A new object containing merged defaulted values.
+ */
+export function defaults<T extends Record<string, any>, U extends Record<string, any>>(
+  target: T,
+  defaultsObj: U,
+): T & U {
+  const result = {...target} as T & U;
+  for (const [key, value] of Object.entries(defaultsObj)) {
+    if (result[key as keyof (T & U)] === undefined) {
+      (result as any)[key] = value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Determines whether a value is a plain object.
+ *
+ * @param value - The value to check.
+ * @returns True when the value is a non-null non-array object.
+ */
+export function isPlainObject(value: unknown): value is Record<string, any> {
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+/**
+ * Checks whether a value should be treated as empty.
+ *
+ * @param value - The value to evaluate.
+ * @returns True for nullish values, empty arrays/strings/maps/sets, or empty objects.
+ */
+export function isEmpty(value: unknown): boolean {
+  if (value == null) {
+    return true;
+  }
+  if (Array.isArray(value) || typeof value === 'string') {
+    return value.length === 0;
+  }
+  if (value instanceof Map || value instanceof Set) {
+    return value.size === 0;
+  }
+  if (isPlainObject(value)) {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+}
+
+/**
+ * Deduplicates array entries while preserving order.
+ *
+ * @param items - Items to deduplicate.
+ * @returns The input items without duplicates.
+ */
+export function uniq<T>(items: T[]): T[] {
+  return [...new Set(items)];
+}
+
+/**
+ * Performs deep strict equality comparison.
+ *
+ * @param a - First value.
+ * @param b - Second value.
+ * @returns True when both values are deeply equal.
+ */
+export function deepEqual(a: unknown, b: unknown): boolean {
+  return isDeepStrictEqual(a, b);
+}
+
+/**
+ * Returns a promise that resolves after the specified delay.
+ *
+ * @param ms - Delay in milliseconds.
+ * @returns A promise that resolves when the delay expires.
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Wraps a promise with a timeout.
+ *
+ * @param promise - The promise to resolve.
+ * @param timeoutMs - Maximum time to wait in milliseconds.
+ * @param message - Optional timeout message.
+ * @returns A promise that resolves/rejects with the original promise result, or rejects on timeout.
+ */
+export async function withTimeout<T>(
+  promise: Promise<T>,
+  timeoutMs: number,
+  message?: string,
+): Promise<T> {
+  let timeoutId: NodeJS.Timeout | undefined;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<T>((_resolve, reject) => {
+        timeoutId = setTimeout(
+          () => reject(new TimeoutError(message ?? `Operation timed out after ${timeoutMs}ms`)),
+          timeoutMs,
+        );
+      }),
+    ]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+
 /**
  * Takes a dictionary from the remote debugger and converts it into a more
  * manageable AppInfo object with understandable keys.
@@ -26,15 +169,16 @@ export const RESPONSE_LOG_LENGTH = 100;
  */
 export function appInfoFromDict(dict: Record<string, any>): [string, AppInfo] {
   const id = dict.WIRApplicationIdentifierKey;
-  const isProxy = _.isString(dict.WIRIsApplicationProxyKey)
-    ? dict.WIRIsApplicationProxyKey.toLowerCase() === 'true'
-    : dict.WIRIsApplicationProxyKey;
+  const isProxy =
+    typeof dict.WIRIsApplicationProxyKey === 'string'
+      ? dict.WIRIsApplicationProxyKey.toLowerCase() === 'true'
+      : dict.WIRIsApplicationProxyKey;
   // automation enabled can be either from the keys
   //   - WIRRemoteAutomationEnabledKey (boolean)
   //   - WIRAutomationAvailabilityKey (string or boolean)
   let isAutomationEnabled: boolean | string = !!dict.WIRRemoteAutomationEnabledKey;
-  if (_.has(dict, 'WIRAutomationAvailabilityKey')) {
-    if (_.isString(dict.WIRAutomationAvailabilityKey)) {
+  if (Object.hasOwn(dict, 'WIRAutomationAvailabilityKey')) {
+    if (typeof dict.WIRAutomationAvailabilityKey === 'string') {
       isAutomationEnabled =
         dict.WIRAutomationAvailabilityKey === 'WIRAutomationAvailabilityUnknown'
           ? 'Unknown'
@@ -65,16 +209,16 @@ export function appInfoFromDict(dict: Record<string, any>): [string, AppInfo] {
  */
 export function pageArrayFromDict(pageDict: StringRecord): Page[] {
   return (
-    _.values(pageDict)
+    Object.values(pageDict)
       // count only WIRTypeWeb pages and ignore all others (WIRTypeJavaScript etc)
       .filter(
-        (dict) => _.isUndefined(dict.WIRTypeKey) || ACCEPTED_PAGE_TYPES.includes(dict.WIRTypeKey),
+        (dict) => dict.WIRTypeKey === undefined || ACCEPTED_PAGE_TYPES.includes(dict.WIRTypeKey),
       )
       .map((dict) => ({
         id: dict.WIRPageIdentifierKey,
         title: dict.WIRTitleKey,
         url: dict.WIRURLKey,
-        isKey: !_.isUndefined(dict.WIRConnectionIdentifierKey),
+        isKey: dict.WIRConnectionIdentifierKey !== undefined,
       }))
   );
 }
@@ -89,7 +233,7 @@ export function pageArrayFromDict(pageDict: StringRecord): Page[] {
  * @returns An array of unique application identifier keys matching the bundle ID.
  */
 export function appIdsForBundle(bundleId: string, appDict: AppDict): string[] {
-  const appIds: string[] = _.toPairs(appDict)
+  const appIds: string[] = Object.entries(appDict)
     .filter(([, data]) => data.bundleId === bundleId)
     .map(([key]) => key);
 
@@ -98,7 +242,7 @@ export function appIdsForBundle(bundleId: string, appDict: AppDict): string[] {
     return appIdsForBundle(WEB_CONTENT_BUNDLE_ID, appDict);
   }
 
-  return _.uniq(appIds);
+  return uniq(appIds);
 }
 
 /**
@@ -112,8 +256,8 @@ export function appIdsForBundle(bundleId: string, appDict: AppDict): string[] {
  */
 export function checkParams<T extends StringRecord>(params: T): T {
   // check if all parameters have a value
-  const errors = _.toPairs(params)
-    .filter(([, value]) => _.isNil(value))
+  const errors = Object.entries(params)
+    .filter(([, value]) => value == null)
     .map(([param]) => param);
   if (errors.length) {
     throw new Error(`Missing ${util.pluralize('parameter', errors.length)}: ${errors.join(', ')}`);
@@ -122,20 +266,41 @@ export function checkParams<T extends StringRecord>(params: T): T {
 }
 
 /**
- * Converts a value to a JSON string, removing noisy function properties
- * that can muddy the logs.
+ * Converts a value to a best-effort JSON string for logging, removing noisy
+ * function properties from cloneable objects when possible.
+ *
+ * Falls back to `String(value)` when JSON serialization returns `undefined`
+ * or throws (for example, for functions, symbols, or circular structures).
  *
  * @param value - The value to stringify.
- * @param multiline - If true, formats the JSON with indentation. Defaults to false.
- * @returns A JSON string representation of the value with noisy properties removed.
+ * @param multiline - If true, formats JSON output with indentation. Defaults to false.
+ * @returns A string representation suitable for logging.
  */
 export function simpleStringify(value: any, multiline: boolean = false): string {
+  const stringify = (val: any): string => {
+    try {
+      return multiline
+        ? (JSON.stringify(val, null, 2) ?? String(val))
+        : (JSON.stringify(val) ?? String(val));
+    } catch {
+      return String(val);
+    }
+  };
+
   if (!value) {
-    return JSON.stringify(value);
+    return stringify(value);
   }
 
-  const cleanValue = removeNoisyProperties(_.clone(value));
-  return multiline ? JSON.stringify(cleanValue, null, 2) : JSON.stringify(cleanValue);
+  let cleanValue = value;
+  if (typeof value === 'object' && value !== null) {
+    try {
+      cleanValue = removeNoisyProperties(structuredClone(value));
+    } catch {
+      // Fall back to the original value when cloning fails (e.g., non-cloneable graph entries).
+      cleanValue = value;
+    }
+  }
+  return stringify(cleanValue);
 }
 
 /**
@@ -149,29 +314,29 @@ export function simpleStringify(value: any, multiline: boolean = false): string
  *               an error status code.
  */
 export function convertJavascriptEvaluationResult(res: any): any {
-  if (_.isUndefined(res)) {
+  if (res === undefined) {
     throw new Error(
-      `Did not get OK result from remote debugger. Result was: ${_.truncate(simpleStringify(res), {length: RESPONSE_LOG_LENGTH})}`,
+      `Did not get OK result from remote debugger. Result was: ${truncateString(simpleStringify(res), RESPONSE_LOG_LENGTH)}`,
     );
-  } else if (_.isString(res)) {
+  } else if (typeof res === 'string') {
     try {
       res = JSON.parse(res);
     } catch {
       // we might get a serialized object, but we might not
       // if we get here, it is just a value
     }
-  } else if (!_.isObject(res)) {
+  } else if ((typeof res !== 'object' && typeof res !== 'function') || res === null) {
     throw new Error(`Result has unexpected type: (${typeof res}).`);
   }
 
-  if (res.status && res.status !== 0) {
+  if (Object.hasOwn(res, 'status') && res.status !== 0) {
     // we got some form of error.
     throw errorFromMJSONWPStatusCode(res.status, res.value.message || res.value);
   }
 
   // with either have an object with a `value` property (even if `null`),
   // or a plain object
-  const value = _.has(res, 'value') ? res.value : res;
+  const value = Object.hasOwn(res, 'value') ? res.value : res;
   return removeNoisyProperties(value);
 }
 
@@ -182,13 +347,24 @@ export function convertJavascriptEvaluationResult(res: any): any {
  * @returns The full path to the module root directory.
  * @throws Error if the module root folder cannot be determined.
  */
-export const getModuleRoot = _.memoize(function getModuleRoot(): string {
+let cachedModuleRoot: string | undefined;
+/**
+ * Calculates and memoizes the path to the current module root.
+ *
+ * @returns The full path to the module root directory.
+ * @throws Error if the module root folder cannot be determined.
+ */
+export function getModuleRoot(): string {
+  if (cachedModuleRoot) {
+    return cachedModuleRoot;
+  }
   const root = node.getModuleRootSync(MODULE_NAME, __filename);
   if (!root) {
     throw new Error(`Cannot find the root folder of the ${MODULE_NAME} Node.js module`);
   }
+  cachedModuleRoot = root;
   return root;
-});
+}
 
 /**
  * Reads and parses the package.json file from the module root.
@@ -217,7 +393,7 @@ export function canUseWebInspectorShim(platformVersion: string): boolean {
  * @returns The cleaned object.
  */
 function removeNoisyProperties<T>(obj: T): T {
-  if (_.isObject(obj)) {
+  if (obj && typeof obj === 'object') {
     for (const property of ['ceil', 'clone', 'floor', 'round', 'scale', 'toString']) {
       delete obj[property];
     }

package/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "appium"
   ],
-  "version": "15.7.3",
+  "version": "15.8.1",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {
@@ -35,11 +35,9 @@
     "@appium/base-driver": "^10.0.0-rc.1",
     "@appium/support": "^7.0.0-rc.1",
     "appium-ios-device": "^3.0.0",
-    "asyncbox": "^6.1.0",
     "async-lock": "^1.4.1",
-    "bluebird": "^3.4.7",
+    "asyncbox": "^6.1.0",
     "glob": "^13.0.0",
-    "lodash": "^4.17.11",
     "teen_process": "^4.0.4"
   },
   "optionalDependencies": {
@@ -74,8 +72,6 @@
     "@appium/types": "^1.0.0-rc.1",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/git": "^10.0.1",
-    "@types/bluebird": "^3.5.38",
-    "@types/lodash": "^4.14.196",
     "@types/mocha": "^10.0.1",
     "@types/node": "^25.0.0",
     "appium-ios-simulator": "^8.0.0",
@@ -87,8 +83,8 @@
     "mocha-multi-reporters": "^1.5.1",
     "node-simctl": "^8.0.0",
     "prettier": "^3.0.0",
-    "serve-static": "^2.2.0",
     "semantic-release": "^25.0.2",
+    "serve-static": "^2.2.0",
     "sinon": "^21.0.0",
     "ts-node": "^10.9.1",
     "typescript": "^6.0.3"

package/scripts/common.mjs

@@ -40,6 +40,48 @@ const ATOMS_DIRECTORY = path.resolve(WORKING_ROOT_DIR, 'atoms');
 const LAST_UPDATE_FILE = path.resolve(ATOMS_DIRECTORY, 'lastupdate');
 let bazelCommand;
 
+/**
+ * Clone the target selenium repository and branch into the temporary directory.
+ */
+export async function seleniumClone () {
+  await seleniumMkdir();
+  await seleniumClean();
+  const cloneArgs = (branch) => ([
+    'clone',
+    `--branch=${branch}`,
+    '--depth=1',
+    SELENIUM_GITHUB,
+    SELENIUM_DIRECTORY,
+  ]);
+
+  log.info(`Cloning branch '${SELENIUM_BRANCH}' from '${SELENIUM_GITHUB}'`);
+  await exec('git', cloneArgs(SELENIUM_BRANCH));
+}
+
+/**
+ * Builds Selenium atoms and imports them into this repository.
+ *
+ * @param {boolean} shouldClean - Whether to run `bazel clean` before building.
+ */
+export async function importAtoms(shouldClean) {
+  await checkBazel();
+  await atomsCleanDir();
+  if (shouldClean) {
+    await atomsClean();
+  }
+  await atomsMkdir();
+  await atomsBuild();
+  const bazelOutDir = await getBazelOutDir();
+  const atomsDir = path.resolve(bazelOutDir, BAZEL_WD_ATOMS_DIR);
+  const atomsInjectDir = path.resolve(bazelOutDir, BAZEL_WD_ATOMS_INJECT_DIR);
+  const fragmentsDir = path.resolve(bazelOutDir, BAZEL_FRAGMENTS_DIR);
+  await atomsCopyAtoms(fragmentsDir);
+  // copy fragments first and atoms later so atoms overwrite fragments
+  await atomsCopyAtoms(atomsDir);
+  await atomsCopyAtoms(atomsInjectDir);
+  await atomsTimestamp();
+}
+
 function getBazelEnv() {
   // Selenium atoms build does not require Android SDK. If these env vars are set locally,
   // Bazel may try to auto-configure Android toolchains and fail on host-specific SDK issues.
@@ -66,24 +108,6 @@ async function seleniumClean () {
   await fs.rimraf(SELENIUM_DIRECTORY);
 }
 
-/**
- * Clone the target selenium repository and branch into the temporary directory.
- */
-export async function seleniumClone () {
-  await seleniumMkdir();
-  await seleniumClean();
-  const cloneArgs = (branch) => ([
-    'clone',
-    `--branch=${branch}`,
-    '--depth=1',
-    SELENIUM_GITHUB,
-    SELENIUM_DIRECTORY,
-  ]);
-
-  log.info(`Cloning branch '${SELENIUM_BRANCH}' from '${SELENIUM_GITHUB}'`);
-  await exec('git', cloneArgs(SELENIUM_BRANCH));
-};
-
 /**
  * Check bazel version if current available bazel version on the host machine
  * meets Selenium's minimum from `.bazelversion` (newer Bazel is allowed).
@@ -228,23 +252,4 @@ async function atomsTimestamp () {
   log.info(`Recording Selenium revision in atoms dir`);
   const {stdout} = await exec('git', ['log', '-n', '1', '--decorate=full'], {cwd: SELENIUM_DIRECTORY});
   await fs.writeFile(LAST_UPDATE_FILE, Buffer.from(stdout.trimEnd() + '\n'));
-}
-
-export async function importAtoms(shouldClean) {
-  await checkBazel();
-  await atomsCleanDir();
-  if (shouldClean) {
-    await atomsClean();
-  }
-  await atomsMkdir();
-  await atomsBuild();
-  const bazelOutDir = await getBazelOutDir();
-  const atomsDir = path.resolve(bazelOutDir, BAZEL_WD_ATOMS_DIR);
-  const atomsInjectDir = path.resolve(bazelOutDir, BAZEL_WD_ATOMS_INJECT_DIR);
-  const fragmentsDir = path.resolve(bazelOutDir, BAZEL_FRAGMENTS_DIR);
-  await atomsCopyAtoms(fragmentsDir);
-  // copy fragments first and atoms later so atoms overwrite fragments
-  await atomsCopyAtoms(atomsDir);
-  await atomsCopyAtoms(atomsInjectDir);
-  await atomsTimestamp();
 };

package/scripts/web_inspector_proxy.mjs

@@ -1,9 +1,7 @@
 /* eslint-disable no-console */
 import { SubProcess } from 'teen_process';
 import { plist, util } from '@appium/support';
-import B from 'bluebird';
 import { getSimulator } from 'appium-ios-simulator';
-import _ from 'lodash';
 
 
 async function getSocket (udid) {
@@ -83,8 +81,8 @@ async function startSoCat (socket) {
     }
   });
 
-  const prom = new B(function (resolve) {
-    proc.on('exit', function () {
+  const prom = new Promise((resolve) => {
+    proc.on('exit', () => {
       resolve('done');
     });
   });
@@ -95,7 +93,7 @@ async function startSoCat (socket) {
 }
 
 async function main () {
-  const udid = _.last(process.argv);
+  const udid = process.argv.at(-1);
   const s = await getSocket(udid);
   console.log('Simulator web inspector socket:', s);
   await startSoCat(s);