appium 3.1.2 → 3.2.1

package/lib/appium.js

@@ -560,16 +560,14 @@ class AppiumDriver extends DriverCore {
   /**
    * Get the appropriate plugins for a session (or sessionless plugins)
    *
-   * @param {?string} sessionId - the sessionId (or null) to use to find plugins
+   * @param {string|null} [sessionId=null] - the sessionId (or null) to use to find plugins
    * @returns {Array<import('@appium/types').Plugin>} - array of plugin instances
    */
   pluginsForSession(sessionId = null) {
     if (sessionId) {
-      if (!this.sessionPlugins[sessionId]) {
-        const driverId = generateDriverLogPrefix(this.sessions[sessionId]);
-        this.sessionPlugins[sessionId] = this.createPluginInstances(driverId || null);
-      }
-      return this.sessionPlugins[sessionId];
+      const driver = this.sessions[sessionId];
+      return this.sessionPlugins[sessionId]
+        ?? (driver ? this.createPluginInstances(generateDriverLogPrefix(driver)) : []);
     }
 
     if (_.isEmpty(this.sessionlessPlugins)) {
@@ -598,7 +596,7 @@ class AppiumDriver extends DriverCore {
 
   /**
    * Creates instances of all of the enabled Plugin classes
-   * @param {string|null} driverId - ID to use for linking a driver to a plugin in logs
+   * @param {string|null} [driverId=null] - ID to use for linking a driver to a plugin in logs
    * @returns {Plugin[]}
    */
   createPluginInstances(driverId = null) {

package/lib/bidi-commands.ts

@@ -1,9 +1,7 @@
 import _ from 'lodash';
 import B from 'bluebird';
-import {
-  errors,
-  ExtensionCore,
-} from '@appium/base-driver';
+import type {ExtensionCore} from '@appium/base-driver';
+import {errors} from '@appium/base-driver';
 import {BIDI_BASE_PATH, BIDI_EVENT_NAME} from './constants';
 import WebSocket from 'ws';
 import os from 'node:os';
@@ -23,7 +21,7 @@ import type {
   BiDiResultData
 } from '@appium/types';
 
-type ExtensionPlugin = Plugin & ExtensionCore
+type ExtensionPlugin = Plugin & ExtensionCore;
 type AnyDriver = ExternalDriver | AppiumDriver;
 type SendData = (data: string | Buffer) => Promise<void>;
 type LogSocketError = (err: Error) => void;
@@ -448,7 +446,7 @@ function initBidiEventListeners(
   // sure the client is subscribed and then pass it on
   const eventLogCounts: Record<string, number> = BIDI_EVENTS_MAP.get(bidiHandlerDriver) ?? {};
   BIDI_EVENTS_MAP.set(bidiHandlerDriver, eventLogCounts);
-  const eventListenerFactory = (extType: 'driver'|'plugin', ext: ExtensionCore) => {
+  const eventListenerFactory = (extType: 'driver' | 'plugin', ext: ExtensionCore) => {
     const eventListener = async ({context, method, params = {}}) => {
       // if the driver didn't specify a context, use the empty context
       if (!context) {

package/lib/cli/extension-command.js

@@ -1,6 +1,6 @@
 import B from 'bluebird';
 import _ from 'lodash';
-import path from 'path';
+import path from 'node:path';
 import {npm, util, env, console, fs, system} from '@appium/support';
 import {spinWith, RingBuffer} from './utils';
 import {
@@ -12,14 +12,15 @@ import {
 } from '../extension/extension-config';
 import {SubProcess} from 'teen_process';
 import {packageDidChange} from '../extension/package-changed';
-import {spawn} from 'child_process';
+import {spawn} from 'node:child_process';
 import {inspect} from 'node:util';
-import {pathToFileURL} from 'url';
+import {pathToFileURL} from 'node:url';
 import {Doctor, EXIT_CODE as DOCTOR_EXIT_CODE} from '../doctor/doctor';
 import {getAppiumModuleRoot, npmPackage} from '../utils';
 import * as semver from 'semver';
 
 const UPDATE_ALL = 'installed';
+const MAX_CONCURRENT_REPO_FETCHES = 5;
 
 class NotUpdatableError extends Error {}
 class NoUpdatesAvailableError extends Error {}
@@ -96,6 +97,7 @@ class ExtensionCliCommand {
    * For TS to understand that a function throws an exception, it must actually throw an exception--
    * in other words, _calling_ a function which is guaranteed to throw an exception is not enough--
    * nor is something like `@returns {never}` which does not imply a thrown exception.
+   *
    * @param {string} message
    * @protected
    * @throws {Error}
@@ -121,18 +123,45 @@ class ExtensionCliCommand {
 
   /**
    * List extensions
+   *
    * @template {ExtensionType} ExtType
    * @param {ListOptions} opts
    * @return {Promise<ExtensionList<ExtType>>} map of extension names to extension data
    */
   async list({showInstalled, showUpdates, verbose = false}) {
-    let lsMsg = `Listing ${showInstalled ? 'installed' : 'available'} ${this.type}s`;
+    const listData = this._buildListData(showInstalled);
+
+    const lsMsg =
+      `Listing ${showInstalled ? 'installed' : 'available'} ${this.type}s` +
+      (verbose ? ' (verbose mode)' : ' (rerun with --verbose for more info)');
+    await this._checkForUpdates(listData, showUpdates, lsMsg);
+
+    if (this.isJsonOutput) {
+      await this._addRepositoryUrlsToListData(listData);
+      return listData;
+    }
+
     if (verbose) {
-      lsMsg += ' (verbose mode)';
+      await this._addRepositoryUrlsToListData(listData);
+      this.log.log(inspect(listData, {colors: true, depth: null}));
+      return listData;
     }
+
+    return await this._displayNormalListOutput(listData, showUpdates);
+  }
+
+  /**
+   * Build the initial list data structure from installed and known extensions
+   *
+   * @template {ExtensionType} ExtType
+   * @param {boolean} showInstalled
+   * @returns {ExtensionList<ExtType>}
+   * @private
+   */
+  _buildListData(showInstalled) {
     const installedNames = Object.keys(this.config.installedExtensions);
     const knownNames = Object.keys(this.knownExtensions);
-    const listData = [...installedNames, ...knownNames].reduce((acc, name) => {
+    return [...installedNames, ...knownNames].reduce((acc, name) => {
       if (!acc[name]) {
         if (installedNames.includes(name)) {
           acc[name] = {
@@ -148,99 +177,233 @@ class ExtensionCliCommand {
       }
       return acc;
     }, /** @type {ExtensionList<ExtType>} */ ({}));
+  }
 
-    // if we want to show whether updates are available, put that behind a spinner
+  /**
+   * Check for available updates for installed extensions
+   *
+   * @template {ExtensionType} ExtType
+   * @param {ExtensionList<ExtType>} listData
+   * @param {boolean} showUpdates
+   * @param {string} lsMsg
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _checkForUpdates(listData, showUpdates, lsMsg) {
     await spinWith(this.isJsonOutput, lsMsg, async () => {
+      // We'd like to still show lsMsg even if showUpdates is false
       if (!showUpdates) {
         return;
       }
-      for (const [ext, data] of _.toPairs(listData)) {
-        if (!data.installed || data.installType !== INSTALL_TYPE_NPM) {
-          // don't need to check for updates on exts that aren't installed
-          // also don't need to check for updates on non-npm exts
-          continue;
-        }
-        try {
-          const updates = await this.checkForExtensionUpdate(ext);
-          data.updateVersion = updates.safeUpdate;
-          data.unsafeUpdateVersion = updates.unsafeUpdate;
-          data.upToDate = updates.safeUpdate === null && updates.unsafeUpdate === null;
-        } catch (e) {
-          data.updateError = e.message;
-        }
-      }
+
+      // Filter to only extensions that need update checks (installed npm packages)
+      const extensionsToCheck = _.toPairs(listData).filter(
+        ([, data]) => data.installed && data.installType === INSTALL_TYPE_NPM
+      );
+
+      await B.map(
+        extensionsToCheck,
+        async ([ext, data]) => {
+          try {
+            const updates = await this.checkForExtensionUpdate(ext);
+            data.updateVersion = updates.safeUpdate;
+            data.unsafeUpdateVersion = updates.unsafeUpdate;
+            data.upToDate = updates.safeUpdate === null && updates.unsafeUpdate === null;
+          } catch (e) {
+            data.updateError = e.message;
+          }
+        },
+        {concurrency: MAX_CONCURRENT_REPO_FETCHES}
+      );
     });
+  }
 
-    /**
-     * Type guard to narrow "installed" extensions, which have more data
-     * @param {any} data
-     * @returns {data is InstalledExtensionListData<ExtType>}
-     */
-    const extIsInstalled = (data) => Boolean(data.installed);
+  /**
+   * Add repository URLs to list data for all extensions
+   *
+   * @template {ExtensionType} ExtType
+   * @param {ExtensionList<ExtType>} listData
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _addRepositoryUrlsToListData(listData) {
+    await spinWith(this.isJsonOutput, 'Fetching repository information', async () => {
+      await B.map(
+        _.values(listData),
+        async (data) => {
+          const repoUrl = await this._getRepositoryUrl(data);
+          if (repoUrl) {
+            data.repositoryUrl = repoUrl;
+          }
+        },
+        {concurrency: MAX_CONCURRENT_REPO_FETCHES}
+      );
+    });
+  }
 
-    // if we're just getting the data, short circuit return here since we don't need to do any
-    // formatting logic
-    if (this.isJsonOutput) {
-      return listData;
+  /**
+   * Display normal formatted output
+   *
+   * @template {ExtensionType} ExtType
+   * @param {ExtensionList<ExtType>} listData
+   * @param {boolean} showUpdates
+   * @returns {Promise<ExtensionList<ExtType>>}
+   * @private
+   */
+  async _displayNormalListOutput(listData, showUpdates) {
+    for (const [name, data] of _.toPairs(listData)) {
+      const line = await this._formatExtensionLine(name, data, showUpdates);
+      this.log.log(line);
     }
 
-    if (verbose) {
-      this.log.log(inspect(listData, {colors: true, depth: null}));
-      return listData;
+    return listData;
+  }
+
+  /**
+   * Format a single extension line for display
+   *
+   * @template {ExtensionType} ExtType
+   * @param {string} name
+   * @param {ExtensionListData<ExtType>} data
+   * @param {boolean} showUpdates
+   * @returns {Promise<string>}
+   * @private
+   */
+  async _formatExtensionLine(name, data, showUpdates) {
+    if (data.installed) {
+      const installTxt = this._formatInstallText(/** @type {InstalledExtensionListData<ExtType>} */ (data));
+      const updateTxt = showUpdates ? this._formatUpdateText(/** @type {InstalledExtensionListData<ExtType>} */ (data)) : '';
+      return `- ${name.yellow}${installTxt}${updateTxt}`;
     }
-    for (const [name, data] of _.toPairs(listData)) {
-      let installTxt = ' [not installed]'.grey;
-      let updateTxt = '';
-      let upToDateTxt = '';
-      let unsafeUpdateTxt = '';
-      if (extIsInstalled(data)) {
-        const {
-          installType,
-          installSpec,
-          updateVersion,
-          unsafeUpdateVersion,
-          version,
-          upToDate,
-          updateError,
-        } = data;
-        let typeTxt;
-        switch (installType) {
-          case INSTALL_TYPE_GIT:
-          case INSTALL_TYPE_GITHUB:
-            typeTxt = `(cloned from ${installSpec})`.yellow;
-            break;
-          case INSTALL_TYPE_LOCAL:
-            typeTxt = `(linked from ${installSpec})`.magenta;
-            break;
-          case INSTALL_TYPE_DEV:
-            typeTxt = '(dev mode)';
-            break;
-          default:
-            typeTxt = '(npm)';
-        }
-        installTxt = `@${version.yellow} ${('[installed ' + typeTxt + ']').green}`;
-
-        if (showUpdates) {
-          if (updateError) {
-            updateTxt = ` [Cannot check for updates: ${updateError}]`.red;
-          } else {
-            if (updateVersion) {
-              updateTxt = ` [${updateVersion} available]`.magenta;
-            }
-            if (upToDate) {
-              upToDateTxt = ` [Up to date]`.green;
-            }
-            if (unsafeUpdateVersion) {
-              unsafeUpdateTxt = ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
-            }
+    const installTxt = ' [not installed]'.grey;
+    return `- ${name.yellow}${installTxt}`;
+  }
+
+  /**
+   * Format installation status text
+   *
+   * @template {ExtensionType} ExtType
+   * @param {InstalledExtensionListData<ExtType>} data
+   * @returns {string}
+   * @private
+   */
+  _formatInstallText(data) {
+    const {installType, installSpec, version} = data;
+    let typeTxt;
+    switch (installType) {
+      case INSTALL_TYPE_GIT:
+      case INSTALL_TYPE_GITHUB:
+        typeTxt = `(cloned from ${installSpec})`.yellow;
+        break;
+      case INSTALL_TYPE_LOCAL:
+        typeTxt = `(linked from ${installSpec})`.magenta;
+        break;
+      case INSTALL_TYPE_DEV:
+        typeTxt = '(dev mode)';
+        break;
+      default:
+        typeTxt = '(npm)';
+    }
+    return `@${version.yellow} ${('[installed ' + typeTxt + ']').green}`;
+  }
+
+  /**
+   * Format update information text
+   *
+   * @template {ExtensionType} ExtType
+   * @param {InstalledExtensionListData<ExtType>} data
+   * @returns {string}
+   * @private
+   */
+  _formatUpdateText(data) {
+    const {updateVersion, unsafeUpdateVersion, upToDate, updateError} = data;
+    if (updateError) {
+      return ` [Cannot check for updates: ${updateError}]`.red;
+    }
+    let txt = '';
+    if (updateVersion) {
+      txt += ` [${updateVersion} available]`.magenta;
+    }
+    if (upToDate) {
+      txt += ` [Up to date]`.green;
+    }
+    if (unsafeUpdateVersion) {
+      txt += ` [${unsafeUpdateVersion} available (potentially unsafe)]`.cyan;
+    }
+    return txt;
+  }
+
+  /**
+   * Get repository URL from package data
+   *
+   * @template {ExtensionType} ExtType
+   * @param {ExtensionListData<ExtType>} data
+   * @returns {Promise<string|null>}
+   * @private
+   */
+  async _getRepositoryUrl(data) {
+    if (data.installed && data.installPath) {
+      return await this._getRepositoryUrlFromInstalled(
+        /** @type {InstalledExtensionListData<ExtType>} */ (data)
+      );
+    }
+    if (data.pkgName && !data.installed) {
+      return await this._getRepositoryUrlFromNpm(data.pkgName);
+    }
+    return null;
+  }
+
+  /**
+   * Get repository URL from installed extension's package.json
+   *
+   * @template {ExtensionType} ExtType
+   * @param {InstalledExtensionListData<ExtType>} data
+   * @returns {Promise<string|null>}
+   * @private
+   */
+  async _getRepositoryUrlFromInstalled(data) {
+    try {
+      const pkgJsonPath = path.join(data.installPath, 'package.json');
+      if (await fs.exists(pkgJsonPath)) {
+        const pkg = JSON.parse(await fs.readFile(pkgJsonPath, 'utf8'));
+        if (pkg.repository) {
+          if (typeof pkg.repository === 'string') {
+            return pkg.repository;
+          }
+          if (pkg.repository.url) {
+            return pkg.repository.url.replace(/^git\+/, '').replace(/\.git$/, '');
           }
         }
       }
-
-      this.log.log(`- ${name.yellow}${installTxt}${updateTxt}${upToDateTxt}${unsafeUpdateTxt}`);
+    } catch {
+      // Ignore errors reading package.json
     }
+    return null;
+  }
 
-    return listData;
+  /**
+   * Get repository URL from npm for a package name
+   *
+   * @param {string} pkgName
+   * @returns {Promise<string|null>}
+   * @private
+   */
+  async _getRepositoryUrlFromNpm(pkgName) {
+    try {
+      const repoInfo = await npm.getPackageInfo(pkgName, ['repository']);
+      // When requesting only 'repository', npm.getPackageInfo returns the repository object directly
+      if (repoInfo) {
+        if (typeof repoInfo === 'string') {
+          return repoInfo;
+        }
+        if (repoInfo.url) {
+          return repoInfo.url.replace(/^git\+/, '').replace(/\.git$/, '');
+        }
+      }
+    } catch {
+      // Ignore errors fetching from npm
+    }
+    return null;
   }
 
   /**
@@ -438,34 +601,24 @@ class ExtensionCliCommand {
    * @returns {Promise<ExtInstallReceipt<ExtType>>}
    */
   async installViaNpm({installSpec, pkgName, pkgVer, installType}) {
-    const msg = `Installing '${installSpec}'`;
+    const installMsg = `Installing '${installSpec}'`;
+    const validateMsg = `Validating '${installSpec}'`;
 
     // the string used for installation is either <name>@<ver> in the case of a standard NPM
     // package, or whatever the user sent in otherwise.
     const installStr = installType === INSTALL_TYPE_NPM ? `${pkgName}${pkgVer ? `@${pkgVer}` : ''}` : installSpec;
     const appiumHome = this.config.appiumHome;
     try {
-      const {pkg, installPath} = await spinWith(this.isJsonOutput, msg, async () => {
-        const {pkg, installPath} = await npm.installPackage(appiumHome, installStr, {
-          pkgName,
-          installType,
-        });
+      const {pkg, installPath} = await spinWith(
+        this.isJsonOutput,
+        installMsg,
+        async () => await npm.installPackage(appiumHome, installStr, {pkgName, installType})
+      );
+
+      await spinWith(this.isJsonOutput, validateMsg, async () => {
         this.validatePackageJson(pkg, installSpec);
-        return {pkg, installPath};
       });
 
-      /** @type {Promise<void>[]} */
-      const symlinkInjectionPromises = _.uniq([
-        ...Object.values(this.config.installedExtensions).map((ext) => ext.installPath),
-        installPath,
-      ]).map((instPath) => injectAppiumSymlink.bind(this)(path.join(instPath, 'node_modules')));
-      // After the extension is installed, we try to inject the appium module symlink
-      // into the extension's node_modules folder if it is not there yet.
-      // We also inject the symlink into other installed extensions' node_modules folders
-      // as these might be cleaned up unexpectedly by npm
-      // (see https://github.com/appium/python-client/pull/1177#issuecomment-3419826643).
-      await Promise.all(symlinkInjectionPromises);
-
       return this.getInstallationReceipt({
         pkg,
         installPath,
@@ -971,11 +1124,35 @@ class ExtensionCliCommand {
  * This is needed to ensure proper module resolution for installed extensions,
  * especially ESM ones.
  *
- * @this {ExtensionCliCommand}
+ * @param {ExtensionConfig<ExtensionType>} driverConfig
+ * @param {ExtensionConfig<ExtensionType>} pluginConfig
+ * @param {import('@appium/types').AppiumLogger} logger
+ */
+export async function injectAppiumSymlinks(driverConfig, pluginConfig, logger) {
+  const installPaths = _.compact([
+    ...Object.values(driverConfig.installedExtensions || {}),
+    ...Object.values(pluginConfig.installedExtensions || {})
+  ].filter((details) => details.installType === INSTALL_TYPE_NPM)
+   .map((details) => details.installPath));
+  // After the extension is installed, we try to inject the appium module symlink
+  // into the extension's node_modules folder if it is not there yet.
+  // We also inject the symlink into other installed extensions' node_modules folders
+  // as these might be cleaned up unexpectedly by npm
+  // (see https://github.com/appium/python-client/pull/1177#issuecomment-3419826643).
+  await Promise.all(
+    installPaths.map((installPath) => injectAppiumSymlink(path.join(installPath, 'node_modules'), logger))
+  );
+}
+
+/**
+ * This is needed to ensure proper module resolution for installed extensions,
+ * especially ESM ones.
+ *
  * @param {string} dstFolder The destination folder where the symlink should be created
+ * @param {import('@appium/types').AppiumLogger} logger
  * @returns {Promise<void>}
  */
-async function injectAppiumSymlink(dstFolder) {
+async function injectAppiumSymlink(dstFolder, logger) {
   let appiumModuleRoot;
   try {
     appiumModuleRoot = getAppiumModuleRoot();
@@ -985,7 +1162,7 @@ async function injectAppiumSymlink(dstFolder) {
     }
   } catch (error) {
     // This error is not fatal, we may still doing just fine if the module being loaded is a CJS one
-    this.log.info(
+    logger.info(
       `Cannot create a symlink to the appium module '${appiumModuleRoot}' in '${dstFolder}'. ` +
       `Original error: ${error.message}`
     );
@@ -1013,6 +1190,7 @@ export {ExtensionCliCommand as ExtensionCommand};
  * @property {string|null} unsafeUpdateVersion - Same as above, but a major version bump
  * @property {string} [updateError] - Update check error message (if present)
  * @property {boolean} [devMode] - If Appium is run from an extension's working copy
+ * @property {string} [repositoryUrl] - Repository URL for the extension (if available)
  */
 
 /**

package/lib/cli/parser.js

@@ -1,7 +1,7 @@
 import {fs} from '@appium/support';
 import {ArgumentParser} from 'argparse';
 import _ from 'lodash';
-import path from 'path';
+import path from 'node:path';
 import {
   DRIVER_TYPE,
   EXT_SUBCOMMAND_DOCTOR,
@@ -14,7 +14,7 @@ import {
   SERVER_SUBCOMMAND,
   SETUP_SUBCOMMAND
 } from '../constants';
-import {finalizeSchema, getArgSpec, hasArgSpec} from '../schema';
+import {finalizeSchema, getAllArgSpecs, getArgSpec, hasArgSpec} from '../schema';
 import {rootDir} from '../config';
 import {getExtensionArgs, getServerArgs} from './args';
 import {
@@ -158,6 +158,25 @@ class ArgParser {
     }
   }
 
+  /**
+   * Normalize hyphenated server arg keys (e.g. "log-level") to dest form (e.g. "loglevel").
+   * Use when server args come from programmatic init rather than the CLI, so they match
+   * the shape produced by parseArgs() / _transformParsedArgs().
+   * Mutates the given object.
+   *
+   * @param {object} obj - Object that may contain server args with schema property names
+   * @returns {object} The same object with keys normalized
+   */
+  static normalizeServerArgs(obj) {
+    for (const spec of getAllArgSpecs().values()) {
+      if (!spec.extType && obj[spec.name] !== undefined && spec.rawDest !== spec.name) {
+        obj[spec.rawDest] = obj[spec.name] ?? obj[spec.rawDest];
+        delete obj[spec.name];
+      }
+    }
+    return obj;
+  }
+
   /**
    * Given an object full of arguments as returned by `argparser.parse_args`,
    * expand the ones for extensions into a nested object structure and rename

package/lib/constants.js

@@ -1,4 +1,4 @@
-import path from 'path';
+import path from 'node:path';
 
 /**
  * The name of the extension type for drivers

package/lib/extension/extension-config.js

@@ -1,7 +1,7 @@
 import {util, fs, system} from '@appium/support';
 import B from 'bluebird';
 import _ from 'lodash';
-import path from 'path';
+import path from 'node:path';
 import resolveFrom from 'resolve-from';
 import {satisfies} from 'semver';
 import {commandClasses} from '../cli/extension';
@@ -12,7 +12,7 @@ import {
   isAllowedSchemaFileExtension,
   registerSchema,
 } from '../schema/schema';
-import { pathToFileURL } from 'url';
+import { pathToFileURL } from 'node:url';
 
 const DEFAULT_ENTRY_POINT = 'index.js';
 /**

package/lib/extension/manifest.js

@@ -5,7 +5,7 @@
 import B from 'bluebird';
 import {env, fs} from '@appium/support';
 import _ from 'lodash';
-import path from 'path';
+import path from 'node:path';
 import * as YAML from 'yaml';
 import {CURRENT_SCHEMA_REV, DRIVER_TYPE, PLUGIN_TYPE} from '../constants';
 import {INSTALL_TYPE_NPM, INSTALL_TYPE_DEV} from './extension-config';

package/lib/extension/package-changed.js

@@ -1,6 +1,6 @@
 import {fs} from '@appium/support';
 import {isPackageChanged} from 'package-changed';
-import path from 'path';
+import path from 'node:path';
 import {PKG_HASHFILE_RELATIVE_PATH} from '../constants';
 import log from '../logger';
 

package/lib/inspector-commands.ts

@@ -19,7 +19,7 @@ import type {
   BiDiCommandNamesToInfosMap,
   ExecuteMethodMap,
 } from '@appium/types';
-import type { AppiumDriver } from './appium';
+import type {AppiumDriver} from './appium';
 
 
 export async function listCommands(this: AppiumDriver, sessionId?: string): Promise<ListCommandsResponse> {