appium-webdriveragent 12.1.1 → 12.2.0

package/lib/check-dependencies.ts

@@ -5,21 +5,9 @@ import {WDA_SCHEME, SDK_SIMULATOR, WDA_RUNNER_APP} from './constants';
 import {BOOTSTRAP_PATH} from './utils';
 import type {XcodeBuild} from './xcodebuild';
 
-async function buildWDASim(): Promise<void> {
-  const args = [
-    '-project',
-    path.join(BOOTSTRAP_PATH, 'WebDriverAgent.xcodeproj'),
-    '-scheme',
-    WDA_SCHEME,
-    '-sdk',
-    SDK_SIMULATOR,
-    'CODE_SIGN_IDENTITY=""',
-    'CODE_SIGNING_REQUIRED="NO"',
-    'GCC_TREAT_WARNINGS_AS_ERRORS=0',
-  ];
-  await exec('xcodebuild', args);
-}
-
+/**
+ * Ensure simulator WDA is built and return the resulting app bundle path.
+ */
 export async function bundleWDASim(xcodebuild: XcodeBuild): Promise<string> {
   const derivedDataPath = await xcodebuild.retrieveDerivedDataPath();
   if (!derivedDataPath) {
@@ -38,3 +26,18 @@ export async function bundleWDASim(xcodebuild: XcodeBuild): Promise<string> {
   await buildWDASim();
   return wdaBundlePath;
 }
+
+async function buildWDASim(): Promise<void> {
+  const args = [
+    '-project',
+    path.join(BOOTSTRAP_PATH, 'WebDriverAgent.xcodeproj'),
+    '-scheme',
+    WDA_SCHEME,
+    '-sdk',
+    SDK_SIMULATOR,
+    'CODE_SIGN_IDENTITY=""',
+    'CODE_SIGNING_REQUIRED="NO"',
+    'GCC_TREAT_WARNINGS_AS_ERRORS=0',
+  ];
+  await exec('xcodebuild', args);
+}

package/lib/utils.ts

@@ -3,9 +3,7 @@ import {exec, SubProcess} from 'teen_process';
 import path, {dirname} from 'node:path';
 import {fileURLToPath} from 'node:url';
 import {log} from './logger';
-import _ from 'lodash';
 import {PLATFORM_NAME_TVOS} from './constants';
-import B from 'bluebird';
 import _fs from 'node:fs';
 import {waitForCondition} from 'asyncbox';
 import {arch} from 'node:os';
@@ -19,13 +17,18 @@ const currentFilename =
 
 const currentDirname = dirname(currentFilename);
 
+let moduleRootCache: string | undefined;
+
 /**
  * Calculates the path to the current module's root folder
  *
  * @returns {string} The full path to module root
  * @throws {Error} If the current module root folder cannot be determined
  */
-const getModuleRoot = _.memoize(function getModuleRoot(): string {
+const getModuleRoot = function getModuleRoot(): string {
+  if (moduleRootCache) {
+    return moduleRootCache;
+  }
   let currentDir = currentDirname;
   let isAtFsRoot = false;
   while (!isAtFsRoot) {
@@ -35,6 +38,7 @@ const getModuleRoot = _.memoize(function getModuleRoot(): string {
         _fs.existsSync(manifestPath) &&
         JSON.parse(_fs.readFileSync(manifestPath, 'utf8')).name === 'appium-webdriveragent'
       ) {
+        moduleRootCache = currentDir;
         return currentDir;
       }
     } catch {}
@@ -42,15 +46,29 @@ const getModuleRoot = _.memoize(function getModuleRoot(): string {
     isAtFsRoot = currentDir.length <= path.dirname(currentDir).length;
   }
   throw new Error('Cannot find the root folder of the appium-webdriveragent Node.js module');
-});
+};
 
 export const BOOTSTRAP_PATH = getModuleRoot();
 
+/**
+ * Arguments for setting xctestrun file
+ */
+export interface XctestrunFileArgs {
+  deviceInfo: DeviceInfo;
+  sdkVersion: string;
+  bootstrapPath: string;
+  wdaRemotePort: number | string;
+  wdaBindingIP?: string;
+}
+
+/**
+ * Find and terminate all processes matching the given pgrep pattern.
+ */
 export async function killAppUsingPattern(pgrepPattern: string): Promise<void> {
   const signals = [2, 15, 9];
   for (const signal of signals) {
     const matchedPids = await getPIDsUsingPattern(pgrepPattern);
-    if (_.isEmpty(matchedPids)) {
+    if (matchedPids.length === 0) {
       return;
     }
     const args = [`-${signal}`, ...matchedPids];
@@ -59,21 +77,24 @@ export async function killAppUsingPattern(pgrepPattern: string): Promise<void> {
     } catch (err: any) {
       log.debug(`kill ${args.join(' ')} -> ${err.message}`);
     }
-    if (signal === _.last(signals)) {
+    if (signal === signals[signals.length - 1]) {
       // there is no need to wait after SIGKILL
       return;
     }
     try {
       await waitForCondition(
         async () => {
-          const pidCheckPromises = matchedPids.map((pid) =>
-            exec('kill', ['-0', pid])
+          const pidCheckPromises = matchedPids.map(async (pid) => {
+            try {
+              await exec('kill', ['-0', pid]);
               // the process is still alive
-              .then(() => false)
+              return false;
+            } catch {
               // the process is dead
-              .catch(() => true),
-          );
-          return (await B.all(pidCheckPromises)).every((x) => x === true);
+              return true;
+            }
+          });
+          return (await Promise.all(pidCheckPromises)).every((x) => x === true);
         },
         {
           waitMs: 1000,
@@ -93,9 +114,12 @@ export async function killAppUsingPattern(pgrepPattern: string): Promise<void> {
  * @returns Return true if the platformName is tvOS
  */
 export function isTvOS(platformName: string): boolean {
-  return _.toLower(platformName) === _.toLower(PLATFORM_NAME_TVOS);
+  return platformName?.toLowerCase() === PLATFORM_NAME_TVOS.toLowerCase();
 }
 
+/**
+ * Configure keychain access required for real-device code signing.
+ */
 export async function setRealDeviceSecurity(
   keychainPath: string,
   keychainPassword: string,
@@ -106,17 +130,6 @@ export async function setRealDeviceSecurity(
   await exec('security', ['set-keychain-settings', '-t', '3600', '-l', keychainPath]);
 }
 
-/**
- * Arguments for setting xctestrun file
- */
-export interface XctestrunFileArgs {
-  deviceInfo: DeviceInfo;
-  sdkVersion: string;
-  bootstrapPath: string;
-  wdaRemotePort: number | string;
-  wdaBindingIP?: string;
-}
-
 /**
  * Creates xctestrun file per device & platform version.
  * We expects to have WebDriverAgentRunner_iphoneos${sdkVersion|platformVersion}-arm64.xctestrun for real device
@@ -140,7 +153,7 @@ export async function setXctestrunFile(args: XctestrunFileArgs): Promise<string>
     wdaRemotePort,
     wdaBindingIP,
   );
-  const newXctestRunContent = _.merge(xctestRunContent, updateWDAPort);
+  const newXctestRunContent = mergeObjects(xctestRunContent, updateWDAPort);
   await plist.updatePlistFile(xctestrunFilePath, newXctestRunContent, true);
 
   return xctestrunFilePath;
@@ -285,6 +298,23 @@ export async function getWDAUpgradeTimestamp(): Promise<number | null> {
   return mtime.getTime();
 }
 
+/**
+ * Escape regular expression metacharacters in a string.
+ */
+export function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+/**
+ * Truncate a string to the given length and append ellipsis if needed.
+ */
+export function truncateString(value: string, length: number): string {
+  if (value.length <= length) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, length - 1))}…`;
+}
+
 /**
  * Kills running XCTest processes for the particular device.
  */
@@ -296,7 +326,7 @@ export async function resetTestProcesses(udid: string, isSimulator: boolean): Pr
     processPatterns.push(`xctest.*${udid}`);
   }
   log.debug(`Killing running processes '${processPatterns.join(', ')}' for the device ${udid}...`);
-  await B.all(processPatterns.map(killAppUsingPattern));
+  await Promise.all(processPatterns.map(killAppUsingPattern));
 }
 
 /**
@@ -329,22 +359,25 @@ export async function getPIDsListeningOnPort(
     return result;
   }
 
-  if (!_.isFunction(filteringFunc)) {
+  if (typeof filteringFunc !== 'function') {
     return result;
   }
-  return await B.filter(result, async (pid) => {
-    let stdout: string;
-    try {
-      ({stdout} = await exec('ps', ['-p', pid, '-o', 'command']));
-    } catch (e: any) {
-      if (e.code === 1) {
-        // The process does not exist anymore, there's nothing to filter
-        return false;
+  const filtered = await Promise.all(
+    result.map(async (pid) => {
+      let stdout: string;
+      try {
+        ({stdout} = await exec('ps', ['-p', pid, '-o', 'command']));
+      } catch (e: any) {
+        if (e.code === 1) {
+          // The process does not exist anymore, there's nothing to filter
+          return null;
+        }
+        throw e;
       }
-      throw e;
-    }
-    return await filteringFunc(stdout);
-  });
+      return (await filteringFunc(stdout)) ? pid : null;
+    }),
+  );
+  return filtered.filter((pid): pid is string => Boolean(pid));
 }
 
 // Private functions
@@ -359,7 +392,7 @@ async function getPIDsUsingPattern(pattern: string): Promise<string[]> {
     return stdout
       .split(/\s+/)
       .map((x) => parseInt(x, 10))
-      .filter(_.isInteger)
+      .filter(Number.isInteger)
       .map((x) => `${x}`);
   } catch (err: any) {
     log.debug(
@@ -368,3 +401,27 @@ async function getPIDsUsingPattern(pattern: string): Promise<string[]> {
     return [];
   }
 }
+
+function mergeObjects<T extends Record<string, any>, U extends Record<string, any>>(
+  target: T,
+  source: U,
+): T & U {
+  const output: Record<string, any> = {...target};
+  for (const [key, sourceValue] of Object.entries(source)) {
+    const targetValue = output[key];
+    if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+      output[key] = mergeObjects(targetValue, sourceValue);
+      continue;
+    }
+    output[key] = sourceValue;
+  }
+  return output as T & U;
+}
+
+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;
+}

package/lib/webdriveragent.ts

@@ -1,8 +1,5 @@
 import {waitForCondition} from 'asyncbox';
-import _ from 'lodash';
 import path from 'node:path';
-import url from 'node:url';
-import B from 'bluebird';
 import {JWProxy} from '@appium/base-driver';
 import {fs, util, plist} from '@appium/support';
 import type {AppiumLogger, StringRecord} from '@appium/types';
@@ -34,41 +31,42 @@ const WDA_AGENT_PORT = 8100;
 const WDA_CF_BUNDLE_NAME = 'WebDriverAgentRunner-Runner';
 const SHARED_RESOURCES_GUARD = new AsyncLock();
 const RECENT_MODULE_VERSION_ITEM_NAME = 'recentWdaModuleVersion';
+const URL_PROTOCOL_SEPARATOR = '://';
 
 export class WebDriverAgent {
   bootstrapPath: string;
   agentPath: string;
   readonly args: WebDriverAgentArgs;
-  private readonly log: AppiumLogger;
   readonly device: AppleDevice;
   readonly platformVersion?: string;
   readonly platformName?: string;
   readonly iosSdkVersion?: string;
   readonly host?: string;
   readonly isRealDevice: boolean;
-  private readonly wdaBundlePath?: string;
-  private readonly wdaLocalPort?: number;
   readonly wdaRemotePort: number;
   readonly wdaBaseUrl: string;
   readonly wdaBindingIP?: string;
-  private readonly prebuildWDA?: boolean;
   webDriverAgentUrl?: string;
   started: boolean;
+  updatedWDABundleId?: string;
+  noSessionProxy?: NoSessionProxy;
+  jwproxy?: JWProxy;
+  proxyReqRes?: any;
+  private readonly log: AppiumLogger;
+  private readonly wdaBundlePath?: string;
+  private readonly wdaLocalPort?: number;
+  private readonly prebuildWDA?: boolean;
   private readonly wdaConnectionTimeout?: number;
   private readonly useXctestrunFile?: boolean;
   private readonly usePrebuiltWDA?: boolean;
   private readonly derivedDataPath?: string;
   private readonly mjpegServerPort?: number;
-  updatedWDABundleId?: string;
   private readonly wdaLaunchTimeout: number;
   private readonly usePreinstalledWDA?: boolean;
-  private xctestApiClient?: Xctest | null;
   private readonly updatedWDABundleIdSuffix: string;
+  private xctestApiClient?: Xctest | null;
   private _xcodebuild?: XcodeBuild | null;
-  noSessionProxy?: NoSessionProxy;
-  jwproxy?: JWProxy;
-  proxyReqRes?: any;
-  private _url?: url.UrlWithStringQuery;
+  private _url?: URL;
 
   /**
    * Creates a new WebDriverAgent instance.
@@ -76,7 +74,7 @@ export class WebDriverAgent {
    * @param log - Optional logger instance
    */
   constructor(args: WebDriverAgentArgs, log: AppiumLogger | null = null) {
-    this.args = _.clone(args);
+    this.args = {...args};
     this.log = log ?? defaultLogger;
 
     this.device = args.device;
@@ -185,6 +183,62 @@ export class WebDriverAgent {
     return `${this.updatedWDABundleId ? this.updatedWDABundleId : WDA_RUNNER_BUNDLE_ID}${this.updatedWDABundleIdSuffix}`;
   }
 
+  /**
+   * Gets the base path for the WebDriverAgent URL.
+   * @returns The base path (empty string if root path)
+   */
+  get basePath(): string {
+    if (this.url.pathname === '/') {
+      return '';
+    }
+    return this.url.pathname || '';
+  }
+
+  /**
+   * Gets the WebDriverAgent URL.
+   * Constructs the URL from webDriverAgentUrl if provided, otherwise
+   * builds it from wdaBaseUrl, wdaBindingIP, and wdaLocalPort.
+   * @returns The parsed URL object
+   */
+  get url(): URL {
+    if (!this._url) {
+      if (this.webDriverAgentUrl) {
+        this._url = this.toUrl(this.webDriverAgentUrl);
+      } else {
+        const port = this.wdaLocalPort || WDA_AGENT_PORT;
+        const parsedBaseUrl = this.toUrl(this.wdaBaseUrl || WDA_BASE_URL);
+        this._url = new URL(
+          `${parsedBaseUrl.protocol}//${this.wdaBindingIP || parsedBaseUrl.hostname}:${port}`,
+        );
+      }
+    }
+    return this._url;
+  }
+
+  /**
+   * Gets whether WebDriverAgent has fully started.
+   * @returns `true` if WDA has started, `false` otherwise
+   */
+  get fullyStarted(): boolean {
+    return this.started;
+  }
+
+  /**
+   * Sets whether WebDriverAgent has fully started.
+   * @param started - `true` if WDA has started, `false` otherwise
+   */
+  set fullyStarted(started: boolean) {
+    this.started = started ?? false;
+  }
+
+  /**
+   * Sets the WebDriverAgent URL.
+   * @param _url - The URL string to parse and set
+   */
+  set url(_url: string) {
+    this._url = this.toUrl(_url);
+  }
+
   /**
    * Cleans up obsolete cached processes from previous WDA sessions
    * that are listening on the same port but belong to different devices.
@@ -197,7 +251,7 @@ export class WebDriverAgent {
         !cmdLine.toLowerCase().includes(this.device.udid.toLowerCase()),
     );
 
-    if (_.isEmpty(obsoletePids)) {
+    if (obsoletePids.length === 0) {
       this.log.debug(
         `No obsolete cached processes from previous WDA sessions ` +
           `listening on port ${this.url.port} have been found`,
@@ -220,14 +274,6 @@ export class WebDriverAgent {
   }
 
   /**
-   * Gets the base path for the WebDriverAgent URL.
-   * @returns The base path (empty string if root path)
-   */
-  get basePath(): string {
-    if (this.url.path === '/') {
-      return '';
-    }
-    return this.url.path || '';
   }
 
   /**
@@ -307,56 +353,10 @@ export class WebDriverAgent {
    * @returns `true` if source is fresh (all required files exist), `false` otherwise
    */
   async isSourceFresh(): Promise<boolean> {
-    const existsPromises = ['Resources', `Resources${path.sep}WebDriverAgent.bundle`].map(
+    const existsPromises = ['Resources', path.join('Resources', 'WebDriverAgent.bundle')].map(
       (subPath) => fs.exists(path.resolve(this.bootstrapPath, subPath)),
     );
-    return (await B.all(existsPromises)).some((v) => v === false);
-  }
-
-  private async parseBundleId(wdaBundlePath: string): Promise<string> {
-    const infoPlistPath = path.join(wdaBundlePath, 'Info.plist');
-    const infoPlist = (await plist.parsePlist(await fs.readFile(infoPlistPath))) as {
-      CFBundleIdentifier?: string;
-    };
-    if (!infoPlist.CFBundleIdentifier) {
-      throw new Error(`Could not find bundle id in '${infoPlistPath}'`);
-    }
-    return infoPlist.CFBundleIdentifier;
-  }
-
-  private async fetchWDABundle(): Promise<string> {
-    if (!this.derivedDataPath) {
-      return await bundleWDASim(this.xcodebuild);
-    }
-    const wdaBundlePaths = await fs.glob(`${this.derivedDataPath}/**/*${WDA_RUNNER_APP}/`, {
-      absolute: true,
-    });
-    if (_.isEmpty(wdaBundlePaths)) {
-      throw new Error(`Could not find the WDA bundle in '${this.derivedDataPath}'`);
-    }
-    return wdaBundlePaths[0];
-  }
-
-  private setupProxies(sessionId: string): void {
-    const proxyOpts: any = {
-      log: this.log,
-      server: this.url.hostname ?? undefined,
-      port: parseInt(this.url.port ?? '', 10) || undefined,
-      base: this.basePath,
-      timeout: this.wdaConnectionTimeout,
-      keepAlive: true,
-      scheme: this.url.protocol ? this.url.protocol.replace(':', '') : 'http',
-      headers: this.args.extraRequestHeaders,
-    };
-    if (this.args.reqBasePath) {
-      proxyOpts.reqBasePath = this.args.reqBasePath;
-    }
-
-    this.jwproxy = new JWProxy(proxyOpts);
-    this.jwproxy.sessionId = sessionId;
-    this.proxyReqRes = this.jwproxy.proxyReqRes.bind(this.jwproxy);
-
-    this.noSessionProxy = new NoSessionProxy(proxyOpts);
+    return (await Promise.all(existsPromises)).every((v) => v === true);
   }
 
   /**
@@ -401,49 +401,6 @@ export class WebDriverAgent {
     }
   }
 
-  /**
-   * Gets the WebDriverAgent URL.
-   * Constructs the URL from webDriverAgentUrl if provided, otherwise
-   * builds it from wdaBaseUrl, wdaBindingIP, and wdaLocalPort.
-   * @returns The parsed URL object
-   */
-  get url(): url.UrlWithStringQuery {
-    if (!this._url) {
-      if (this.webDriverAgentUrl) {
-        this._url = url.parse(this.webDriverAgentUrl);
-      } else {
-        const port = this.wdaLocalPort || WDA_AGENT_PORT;
-        const {protocol, hostname} = url.parse(this.wdaBaseUrl || WDA_BASE_URL);
-        this._url = url.parse(`${protocol}//${this.wdaBindingIP || hostname}:${port}`);
-      }
-    }
-    return this._url;
-  }
-
-  /**
-   * Sets the WebDriverAgent URL.
-   * @param _url - The URL string to parse and set
-   */
-  set url(_url: string) {
-    this._url = url.parse(_url);
-  }
-
-  /**
-   * Gets whether WebDriverAgent has fully started.
-   * @returns `true` if WDA has started, `false` otherwise
-   */
-  get fullyStarted(): boolean {
-    return this.started;
-  }
-
-  /**
-   * Sets whether WebDriverAgent has fully started.
-   * @param started - `true` if WDA has started, `false` otherwise
-   */
-  set fullyStarted(started: boolean) {
-    this.started = started ?? false;
-  }
-
   /**
    * Retrieves the Xcode derived data path for WebDriverAgent.
    * @returns The derived data path, or `undefined` if xcodebuild is skipped
@@ -497,7 +454,7 @@ export class WebDriverAgent {
     if (
       actualUpgradeTimestamp &&
       upgradedAt &&
-      _.toLower(`${actualUpgradeTimestamp}`) !== _.toLower(`${upgradedAt}`)
+      `${actualUpgradeTimestamp}`.toLowerCase() !== `${upgradedAt}`.toLowerCase()
     ) {
       this.log.info(
         'Will uninstall running WDA since it has different version in comparison to the one ' +
@@ -523,6 +480,64 @@ export class WebDriverAgent {
     await this.uninstall();
   }
 
+  private async parseBundleId(wdaBundlePath: string): Promise<string> {
+    const infoPlistPath = path.join(wdaBundlePath, 'Info.plist');
+    const infoPlist = (await plist.parsePlist(await fs.readFile(infoPlistPath))) as {
+      CFBundleIdentifier?: string;
+    };
+    if (!infoPlist.CFBundleIdentifier) {
+      throw new Error(`Could not find bundle id in '${infoPlistPath}'`);
+    }
+    return infoPlist.CFBundleIdentifier;
+  }
+
+  private async fetchWDABundle(): Promise<string> {
+    if (!this.derivedDataPath) {
+      return await bundleWDASim(this.xcodebuild);
+    }
+    const wdaBundlePaths = await fs.glob(`${this.derivedDataPath}/**/*${WDA_RUNNER_APP}/`, {
+      absolute: true,
+    });
+    if (wdaBundlePaths.length === 0) {
+      throw new Error(`Could not find the WDA bundle in '${this.derivedDataPath}'`);
+    }
+    return wdaBundlePaths[0];
+  }
+
+  private setupProxies(sessionId: string): void {
+    const proxyOpts: any = {
+      log: this.log,
+      server: this.url.hostname ?? undefined,
+      port: parseInt(this.url.port ?? '', 10) || undefined,
+      base: this.basePath,
+      timeout: this.wdaConnectionTimeout,
+      keepAlive: true,
+      scheme: this.url.protocol ? this.url.protocol.replace(':', '') : 'http',
+      headers: this.args.extraRequestHeaders,
+    };
+    if (this.args.reqBasePath) {
+      proxyOpts.reqBasePath = this.args.reqBasePath;
+    }
+
+    this.jwproxy = new JWProxy(proxyOpts);
+    this.jwproxy.sessionId = sessionId;
+    this.proxyReqRes = this.jwproxy.proxyReqRes.bind(this.jwproxy);
+
+    this.noSessionProxy = new NoSessionProxy(proxyOpts);
+  }
+
+  private toUrl(value: string): URL {
+    // Treat values without `://` as host/path inputs and normalize to http.
+    if (!value.includes(URL_PROTOCOL_SEPARATOR)) {
+      return new URL(`http://${value}`);
+    }
+    try {
+      return new URL(value);
+    } catch {
+      throw new Error(`Invalid URL: ${value}`);
+    }
+  }
+
   private setWDAPaths(bootstrapPath?: string, agentPath?: string): void {
     // allow the user to specify a place for WDA. This is undocumented and
     // only here for the purposes of testing development of WDA
@@ -572,7 +587,7 @@ export class WebDriverAgent {
     const sendGetStatus = async () =>
       (await noSessionProxy.command('/status', 'GET')) as StringRecord;
 
-    if (_.isNil(timeoutMs) || timeoutMs <= 0) {
+    if (timeoutMs == null || timeoutMs <= 0) {
       try {
         return await sendGetStatus();
       } catch (err: any) {
@@ -619,7 +634,7 @@ export class WebDriverAgent {
   private async uninstall(): Promise<void> {
     try {
       const bundleIds = await this.device.getUserInstalledBundleIdsByBundleName(WDA_CF_BUNDLE_NAME);
-      if (_.isEmpty(bundleIds)) {
+      if (bundleIds.length === 0) {
         this.log.debug('No WDAs on the device.');
         return;
       }