appium-remote-debugger 12.1.5 → 12.1.7

package/index.ts

@@ -6,9 +6,9 @@ export function createRemoteDebugger<T extends boolean> (
   opts: T extends true ? RemoteDebuggerRealDeviceOptions : RemoteDebuggerOptions,
   realDevice: T
 ): T extends true ? RemoteDebuggerRealDevice : RemoteDebugger {
-  // @ts-ignore TS does not understand that
   return realDevice
     ? new RemoteDebuggerRealDevice(opts as RemoteDebuggerRealDeviceOptions)
+    // @ts-ignore TS does not understand that
     : new RemoteDebugger(opts);
 }
 

package/lib/mixins/connect.js

@@ -316,9 +316,13 @@ function logApplicationDictionary () {
  * @returns {string[]}
  */
 export function getPossibleDebuggerAppKeys(bundleIds) {
+  const appDict = getAppDict(this);
+
   if (bundleIds.includes(WILDCARD_BUNDLE_ID)) {
-    this.log.debug('Skip checking bundle identifiers because the bundleIds includes a wildcard');
-    return _.uniq(Object.keys(getAppDict(this)));
+    this.log.info(
+      'Returning all apps because the list of matching bundle identifiers includes a wildcard'
+    );
+    return _.keys(appDict);
   }
 
   // go through the possible bundle identifiers
@@ -327,30 +331,40 @@ export function getPossibleDebuggerAppKeys(bundleIds) {
     WEB_CONTENT_PROCESS_BUNDLE_ID,
     SAFARI_VIEW_PROCESS_BUNDLE_ID,
     SAFARI_VIEW_BUNDLE_ID,
-    WILDCARD_BUNDLE_ID,
     ...bundleIds,
   ]);
-  this.log.debug(`Checking for bundle identifiers: ${possibleBundleIds.join(', ')}`);
-  /** @type {Set<string>} */
-  const proxiedAppIds = new Set();
+  this.log.debug(
+    `Checking for apps with matching bundle identifiers: ${possibleBundleIds.join(', ')}`
+  );
+  /** @type {string[]} */
+  const proxiedAppIds = [];
   for (const bundleId of possibleBundleIds) {
     // now we need to determine if we should pick a proxy for this instead
-    for (const appId of appIdsForBundle(bundleId, getAppDict(this))) {
-      proxiedAppIds.add(appId);
+    for (const appId of appIdsForBundle(bundleId, appDict)) {
+      if (proxiedAppIds.includes(appId)) {
+        continue;
+      }
+
+      proxiedAppIds.push(appId);
       this.log.debug(`Found app id key '${appId}' for bundle '${bundleId}'`);
-      for (const [key, data] of _.toPairs(getAppDict(this))) {
-        if (data.isProxy && data.hostId === appId) {
+      for (const [key, data] of _.toPairs(appDict)) {
+        if (data.isProxy && data.hostId === appId && !proxiedAppIds.includes(key)) {
           this.log.debug(
             `Found separate bundleId '${data.bundleId}' ` +
             `acting as proxy for '${bundleId}', with app id '${key}'`
           );
-          proxiedAppIds.add(key);
+          proxiedAppIds.push(key);
         }
       }
     }
   }
 
-  return Array.from(proxiedAppIds);
+  this.log.debug(
+    `You may also consider providing more values to 'additionalWebviewBundleIds' ` +
+    `capability to match other applications. Add a wildcard ('*') to match all apps.`
+  );
+
+  return _.uniq(proxiedAppIds);
 }
 
 /**

package/lib/utils.js

@@ -82,20 +82,17 @@ export function pageArrayFromDict (pageDict) {
  * @returns {string[]}
  */
 export function appIdsForBundle (bundleId, appDict) {
-  /** @type {Set<string>} */
-  const appIds = new Set();
-  for (const [key, data] of _.toPairs(appDict)) {
-    if (data.bundleId.endsWith(bundleId)) {
-      appIds.add(key);
-    }
-  }
+  /** @type {string[]} */
+  const appIds = _.toPairs(appDict)
+    .filter(([, data]) => data.bundleId === bundleId)
+    .map(([key]) => key);
 
   // if nothing is found, try to get the generic app
-  if (appIds.size === 0 && bundleId !== WEB_CONTENT_BUNDLE_ID) {
+  if (appIds.length === 0 && bundleId !== WEB_CONTENT_BUNDLE_ID) {
     return appIdsForBundle(WEB_CONTENT_BUNDLE_ID, appDict);
   }
 
-  return Array.from(appIds);
+  return _.uniq(appIds);
 }
 
 /**

package/package.json

@@ -4,7 +4,7 @@
   "keywords": [
     "appium"
   ],
-  "version": "12.1.5",
+  "version": "12.1.7",
   "author": "Appium Contributors",
   "license": "Apache-2.0",
   "repository": {
@@ -55,8 +55,8 @@
     "e2e-test": "mocha --exit --timeout 1m \"./test/functional/**/*-specs.js\"",
     "inspect-safari": "node build/bin/web_inspector_proxy.js",
     "build:atoms": "npm run build:selenium && npm run build:atoms:import",
-    "build:atoms:import": "node scripts/build-atoms.js",
-    "build:selenium": "node scripts/build-selenium.js"
+    "build:atoms:import": "node scripts/build-atoms.mjs",
+    "build:selenium": "node scripts/build-selenium.mjs"
   },
   "prettier": {
     "bracketSpacing": false,

package/scripts/{build-atoms.js → build-atoms.mjs}

@@ -1,4 +1,4 @@
-const { importAtoms } = require('./common.js');
+import { importAtoms } from './common.mjs';
 
 (async () => {
   await importAtoms(process.argv.includes('--clean'));

package/scripts/build-selenium.mjs

@@ -0,0 +1,4 @@
+import { seleniumClone } from './common.mjs';
+
+
+(async () => await seleniumClone())();

package/scripts/common.mjs

@@ -0,0 +1,189 @@
+import { fs, logger } from '@appium/support';
+import { glob } from 'glob';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { exec } from 'teen_process';
+
+const log = logger.getLogger('Atoms');
+
+const SELENIUM_BRANCH = process.env.SELENIUM_BRANCH || 'selenium-4.19.0';
+const SELENIUM_GITHUB = process.env.SELENIUM_GITHUB || 'https://github.com/SeleniumHQ/selenium.git';
+
+const BAZEL_WD_ATOMS_TARGET = '//javascript/webdriver/atoms/...';
+const BAZEL_WD_ATOMS_INJECT_TARGET = '//javascript/webdriver/atoms/inject/...';
+const BAZEL_ATOMS_TARGET = '//javascript/atoms/...';
+
+const WORKING_ROOT_DIR = path.resolve(fileURLToPath(import.meta.url), '..', '..');
+const TMP_DIRECTORY = path.resolve(WORKING_ROOT_DIR, 'tmp');
+const SELENIUM_DIRECTORY = path.resolve(TMP_DIRECTORY, 'selenium');
+const BAZEL_OUT_BASEDIR = path.resolve(SELENIUM_DIRECTORY, 'bazel-out');
+const BAZEL_VERSION = path.resolve(SELENIUM_DIRECTORY, '.bazelversion');
+const JS_RELATIVE_DIR = path.join('bin', 'javascript');
+const BAZEL_FRAGMENTS_DIR = path.join(JS_RELATIVE_DIR, 'atoms', 'fragments');
+const BAZEL_WD_ATOMS_DIR = path.join(JS_RELATIVE_DIR, 'webdriver', 'atoms');
+const BAZEL_WD_ATOMS_INJECT_DIR = path.join(BAZEL_WD_ATOMS_DIR, 'inject');
+const ATOMS_DIRECTORY = path.resolve(WORKING_ROOT_DIR, 'atoms');
+const LAST_UPDATE_FILE = path.resolve(ATOMS_DIRECTORY, 'lastupdate');
+
+/**
+ * Create a temporary directory to clone selenium repository to build atoms in.
+ */
+async function seleniumMkdir () {
+  log.info(`Creating '${TMP_DIRECTORY}'`);
+  await fs.mkdir(TMP_DIRECTORY, { recursive: true });
+}
+
+/**
+ * Remove entire the temporary selenium directory on the machine local.
+ */
+async function seleniumClean () {
+  log.info(`Cleaning '${SELENIUM_DIRECTORY}'`);
+  await fs.rimraf(SELENIUM_DIRECTORY);
+}
+
+/**
+ * Clone the target selenium repository and branch into the temporary directory.
+ */
+export async function seleniumClone () {
+  await seleniumMkdir();
+  await seleniumClean();
+  log.info(`Cloning branch '${SELENIUM_BRANCH}' from '${SELENIUM_GITHUB}'`);
+  await exec('git', [
+    'clone',
+    `--branch=${SELENIUM_BRANCH}`,
+    `--depth=1`,
+    SELENIUM_GITHUB,
+    SELENIUM_DIRECTORY,
+  ]);
+};
+
+/**
+ * Check bazel version if current available bazel version on the host machine
+ * is good for the target selenium repository's required version.
+ */
+async function checkBazel() {
+  log.info('Checking required Bazel version');
+  const bazelVersion = (await fs.readFile(BAZEL_VERSION, 'utf8')).trim();
+  let result;
+  let err;
+  try {
+    result = await exec('bazel', ['--version']);
+  } catch (e) {
+    err = e.stderr || e.message;
+  }
+  if (err || result.stderr) {
+    throw new Error(`Please setup Bazel ${bazelVersion} runtime environment by following https://bazel.build/install. ` +
+      `Original error: ${err || result.stderr}`);
+  }
+  // e.g. "bazel 7.4.1"
+  const currentBazelVersion = result.stdout.trim().split(' ')[1];
+  if (currentBazelVersion !== bazelVersion) {
+    throw new Error(`Please setup Bazel ${bazelVersion} runtime environment. ` +
+      `Current available version is ${currentBazelVersion}`);
+  }
+  log.info(`Bazel ${bazelVersion} will be used to build atoms.`);
+}
+
+/**
+ * Remove contents in 'atoms'.
+ */
+async function atomsCleanDir () {
+  log.info(`Cleaning '${ATOMS_DIRECTORY}'`);
+  await fs.rimraf(ATOMS_DIRECTORY);
+}
+
+/**
+ * Run bazel clean command.
+ */
+async function atomsClean () {
+  log.info('Building atoms');
+  await exec('bazel', ['clean'], {cwd: SELENIUM_DIRECTORY});
+}
+
+/**
+ * Create a directory for atoms.
+ */
+async function atomsMkdir () {
+  log.info(`Creating '${ATOMS_DIRECTORY}'`);
+  await fs.mkdir(ATOMS_DIRECTORY, { recursive: true });
+}
+
+/**
+ * Return the path to bazel built result.
+ * @returns {Promise<string>}
+ */
+async function getBazelOutDir () {
+  log.info(`Finding bazel output dir`);
+  const outDirMatch = '*-fastbuild';
+  const relativeDir = (await glob(outDirMatch, {cwd: BAZEL_OUT_BASEDIR}))[0];
+  if (!relativeDir) {
+    throw new Error(`Expected architecture-specific Bazel output directory was not found in ` +
+      `'${BAZEL_OUT_BASEDIR}'. We looked for something matching '${outDirMatch}`);
+  }
+  return path.resolve(BAZEL_OUT_BASEDIR, relativeDir);
+}
+
+/**
+ * Build atoms with bazel command.
+ */
+async function atomsBuild () {
+  for (const target of [
+    BAZEL_ATOMS_TARGET,
+    BAZEL_WD_ATOMS_TARGET,
+    BAZEL_WD_ATOMS_INJECT_TARGET,
+  ]) {
+    log.info(`Running bazel build for ${target}`);
+    await exec('bazel', ['build', target], {cwd: SELENIUM_DIRECTORY});
+  }
+  log.info(`Bazel builds complete`);
+}
+
+/**
+ * Copy atoms in bazel built result to 'atoms' in this repository's main 'atoms' place.
+ * @param {string} atomsDir
+ * @param {Function} fileFilter
+ */
+async function atomsCopyAtoms (atomsDir, fileFilter = () => true) {
+  log.info(`Copying any atoms found in ${atomsDir} to atoms dir`);
+  const filesToCopy = (await glob('**/*-ios.js', {
+    absolute: true,
+    strict: false,
+    cwd: atomsDir,
+  })).filter(fileFilter);
+  for (const file of filesToCopy) {
+    // convert - to _ for backwards compatibility with old atoms
+    const newFileName = path.basename(file).replace('-ios', '').replace(/-/g, '_');
+    const to = path.join(ATOMS_DIRECTORY, newFileName);
+    log.info(`Copying ${file} to ${to}`);
+    await fs.rimraf(to);
+    await fs.copyFile(file, to);
+  }
+}
+
+/**
+ * leave timestamp to log when atom build occurred.
+ */
+async function atomsTimestamp () {
+  log.info(`Adding timestamp to atoms build dir`);
+  const {stdout} = await exec('git', ['log', '-n', '1', '--decorate=full'], {cwd: SELENIUM_DIRECTORY});
+  await fs.writeFile(LAST_UPDATE_FILE, Buffer.from(`${new Date()}\n\n${stdout}`));
+}
+
+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/build-selenium.js

@@ -1,3 +0,0 @@
-const { seleniumClone } = require('./common.js');
-
-(async () => await seleniumClone())();

package/scripts/common.js

@@ -1,157 +0,0 @@
-const path = require('path');
-const {logger} = require('@appium/support');
-const fs = require('fs');
-const { exec } = require('teen_process');
-const { glob } = require('glob');
-
-const log = logger.getLogger('Atoms');
-
-const SELENIUM_BRANCH = 'selenium-4.19.0';
-const SELENIUM_GITHUB = 'https://github.com/SeleniumHQ/selenium.git';
-
-const BAZEL_WD_ATOMS_TARGET = '//javascript/webdriver/atoms/...';
-const BAZEL_WD_ATOMS_INJECT_TARGET = '//javascript/webdriver/atoms/inject/...';
-const BAZEL_ATOMS_TARGET = '//javascript/atoms/...';
-
-const WORKING_ROOT_DIR = path.resolve(__dirname, '..');
-const TMP_DIRECTORY = path.resolve(WORKING_ROOT_DIR, 'tmp');
-const SELENIUM_DIRECTORY = path.resolve(TMP_DIRECTORY, 'selenium');
-const BAZEL_OUT_BASEDIR = path.resolve(SELENIUM_DIRECTORY, 'bazel-out');
-const JS_RELATIVE_DIR = path.join('bin', 'javascript');
-const BAZEL_FRAGMENTS_DIR = path.join(JS_RELATIVE_DIR, 'atoms', 'fragments');
-const BAZEL_WD_ATOMS_DIR = path.join(JS_RELATIVE_DIR, 'webdriver', 'atoms');
-const BAZEL_WD_ATOMS_INJECT_DIR = path.join(BAZEL_WD_ATOMS_DIR, 'inject');
-const ATOMS_DIRECTORY = path.resolve(WORKING_ROOT_DIR, 'atoms');
-const LAST_UPDATE_FILE = path.resolve(ATOMS_DIRECTORY, 'lastupdate');
-
-async function rmDir (dir) {
-  try {
-    await fs.promises.access(dir, fs.constants.R_OK);
-  } catch {
-    return;
-  }
-
-  const files = await fs.promises.readdir(dir);
-  for (const file of files) {
-    const fullPath = path.join(dir, file);
-    const isDirectory = (await fs.promises.stat(fullPath)).isDirectory();
-    if (['.', '..'].includes(file)) {
-      // pass these files
-    } else if (isDirectory) {
-      await rmDir(fullPath);
-    } else {
-      await fs.promises.unlink(fullPath);
-    }
-  }
-  await fs.promises.rmdir(dir);
-}
-
-async function seleniumMkdir () {
-  log(`Creating '${TMP_DIRECTORY}'`);
-  await fs.promises.mkdir(TMP_DIRECTORY, { recursive: true });
-}
-
-async function seleniumClean () {
-  log(`Cleaning '${SELENIUM_DIRECTORY}'`);
-  await rmDir(SELENIUM_DIRECTORY);
-}
-
-module.exports.seleniumClone = async function seleniumClone () {
-  await seleniumMkdir();
-  await seleniumClean();
-  log(`Cloning branch '${SELENIUM_BRANCH}' from '${SELENIUM_GITHUB}'`);
-  await exec('git', [
-    'clone',
-    `--branch=${SELENIUM_BRANCH}`,
-    `--depth=1`,
-    SELENIUM_GITHUB,
-    SELENIUM_DIRECTORY,
-  ]);
-};
-
-async function atomsCleanDir () {
-  log(`Cleaning '${ATOMS_DIRECTORY}'`);
-  await rmDir(ATOMS_DIRECTORY);
-}
-
-async function atomsClean () {
-  log('Building atoms');
-  await exec('bazel', ['clean'], {cwd: SELENIUM_DIRECTORY});
-}
-
-async function atomsMkdir () {
-  log(`Creating '${ATOMS_DIRECTORY}'`);
-  await fs.promises.mkdir(ATOMS_DIRECTORY, { recursive: true });
-}
-
-async function getBazelOutDir () {
-  log(`Finding bazel output dir`);
-  const outDirMatch = '*-fastbuild';
-  const relativeDir = (await glob(outDirMatch, {cwd: BAZEL_OUT_BASEDIR}))[0];
-  if (!relativeDir) {
-    throw new Error(`Expected architecture-specific Bazel output directory was not found in ` +
-      `'${BAZEL_OUT_BASEDIR}'. We looked for something matching '${outDirMatch}`);
-  }
-  return path.resolve(BAZEL_OUT_BASEDIR, relativeDir);
-}
-
-async function atomsBuild () {
-  for (const target of [
-    BAZEL_ATOMS_TARGET,
-    BAZEL_WD_ATOMS_TARGET,
-    BAZEL_WD_ATOMS_INJECT_TARGET,
-  ]) {
-    log(`Running bazel build for ${target}`);
-    await exec('bazel', ['build', target], {cwd: SELENIUM_DIRECTORY});
-  }
-  log(`Bazel builds complete`);
-}
-
-async function atomsCopyAtoms (atomsDir, fileFilter = () => true) {
-  log(`Copying any atoms found in ${atomsDir} to atoms dir`);
-  const filesToCopy = (await glob('**/*-ios.js', {
-    absolute: true,
-    strict: false,
-    cwd: atomsDir,
-  })).filter(fileFilter);
-  for (const file of filesToCopy) {
-    // convert - to _ for backwards compatibility with old atoms
-    const newFileName = path.basename(file).replace('-ios', '').replace(/-/g, '_');
-    const to = path.join(ATOMS_DIRECTORY, newFileName);
-    log(`Copying ${file} to ${to}`);
-    // delete an existing file if it was put here by an earlier run of the function, to enable
-    // overwriting
-    try {
-      await fs.promises.unlink(to);
-    } catch (err) {
-      if (!err.message.includes('ENOENT')) {
-        throw err;
-      }
-    }
-    await fs.promises.copyFile(file, to);
-  }
-}
-
-async function atomsTimestamp () {
-  log(`Adding timestamp to atoms build dir`);
-  const {stdout} = await exec('git', ['log', '-n', '1', '--decorate=full'], {cwd: SELENIUM_DIRECTORY});
-  await fs.promises.writeFile(LAST_UPDATE_FILE, Buffer.from(`${new Date()}\n\n${stdout}`));
-}
-
-module.exports.importAtoms = async function importAtoms(shouldClean) {
-  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();
-};