appium 2.0.0-beta.26 → 2.0.0-beta.29

package/lib/cli/extension-command.js

@@ -1,12 +1,13 @@
-// @ts-check
 /* eslint-disable no-console */
 
 import _ from 'lodash';
-import { npm, fs, util } from '@appium/support';
+import path from 'path';
+import { npm, fs, util, env } from '@appium/support';
 import { log, spinWith, RingBuffer } from './utils';
 import { SubProcess } from 'teen_process';
 import { INSTALL_TYPE_NPM, INSTALL_TYPE_GIT, INSTALL_TYPE_GITHUB,
          INSTALL_TYPE_LOCAL } from '../extension/extension-config';
+import { packageDidChange } from '../extension/package-changed';
 
 const UPDATE_ALL = 'installed';
 
@@ -16,7 +17,7 @@ class NoUpdatesAvailableError extends Error {}
 /**
  * @template {ExtensionType} ExtType
  */
-export default class ExtensionCommand {
+class ExtensionCommand {
   /**
    * This is the `DriverConfig` or `PluginConfig`, depending on `ExtType`.
    * @type {ExtensionConfig<ExtType>}
@@ -25,7 +26,7 @@ export default class ExtensionCommand {
 
   /**
    * {@linkcode Record} of official plugins or drivers.
-   * @type {ExtType extends import('../extension/manifest').DriverType ? typeof import('../constants').KNOWN_DRIVERS : typeof import('../constants').KNOWN_PLUGINS}
+   * @type {KnownExtensions<ExtType>}
    */
   knownExtensions;
 
@@ -59,7 +60,7 @@ export default class ExtensionCommand {
    */
   async execute (args) {
     const cmd = args[`${this.type}Command`];
-    if (!_.isFunction(ExtensionCommand.prototype[cmd])) {
+    if (!_.isFunction(this[cmd])) {
       throw new Error(`Cannot handle ${this.type} command ${cmd}`);
     }
     const executeCmd = this[cmd].bind(this);
@@ -91,7 +92,12 @@ export default class ExtensionCommand {
         }
       }
       return acc;
-    }, /** @type {ExtensionListData} */({}));
+    },
+    /**
+     * This accumulator contains either {@linkcode UninstalledExtensionLIstData} _or_
+     * {@linkcode InstalledExtensionListData} without upgrade information (which is added by the below code block)
+     * @type {Record<string,Partial<InstalledExtensionListData>|UninstalledExtensionListData>}
+     */({}));
 
     // if we want to show whether updates are available, put that behind a spinner
     await spinWith(this.isJsonOutput, lsMsg, async () => {
@@ -111,16 +117,18 @@ export default class ExtensionCommand {
       }
     });
 
+    const listData = /** @type {ExtensionListData} */(exts);
+
     // 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 exts;
+      return listData;
     }
 
     for (const [
       name,
       data
-    ] of _.toPairs(exts)) {
+    ] of _.toPairs(listData)) {
       let installTxt = ' [not installed]'.grey;
       let updateTxt = '';
       let upToDateTxt = '';
@@ -157,7 +165,7 @@ export default class ExtensionCommand {
       console.log(`- ${name.yellow}${installTxt}${updateTxt}${upToDateTxt}${unsafeUpdateTxt}`);
     }
 
-    return exts;
+    return listData;
   }
 
   /**
@@ -166,8 +174,7 @@ export default class ExtensionCommand {
    * @param {InstallArgs} args
    * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data
    */
-  async install ({ext, installType, packageName}) {
-    /** @type {ExtData<ExtType>} */
+  async _install ({ext, installType, packageName}) {
     let extData;
     let installSpec = ext;
 
@@ -179,14 +186,7 @@ export default class ExtensionCommand {
       throw new Error(`When using --source=${installType}, must also use --package`);
     }
 
-    if (installType === INSTALL_TYPE_LOCAL) {
-      const msg = `Linking ${this.type} from local path into ${this.config.appiumHome}`;
-      const pkgJsonData = await spinWith(this.isJsonOutput, msg, async () => (
-        await npm.linkPackage(this.config.appiumHome, installSpec))
-      );
-      extData = this.getExtensionFields(pkgJsonData);
-      log(this.isJsonOutput, `Successfully linked ${extData.pkgName} into ${this.config.appiumHome}`);
-    } else if (installType === INSTALL_TYPE_GITHUB) {
+    if (installType === INSTALL_TYPE_GITHUB) {
       if (installSpec.split('/').length !== 2) {
         throw new Error(`Github ${this.type} spec ${installSpec} appeared to be invalid; ` +
                         'it should be of the form <org>/<repo>');
@@ -198,40 +198,44 @@ export default class ExtensionCommand {
       installSpec = installSpec.replace(/\.git$/, '');
       extData = await this.installViaNpm({ext: installSpec, pkgName: /** @type {string} */(packageName)});
     } else {
-      // at this point we have either an npm package or an appium verified extension
-      // name. both of which will be installed via npm.
-      // extensions installed via npm can include versions or tags after the '@'
-      // sign, so check for that. We also need to be careful that package names themselves can
-      // contain the '@' symbol, as in `npm install @appium/fake-driver@1.2.0`
-      let name, pkgVer;
-      const splits = installSpec.split('@');
-      if (installSpec[0] === '@') {
-        // this is the case where we have an npm org included in the package name
-        [name, pkgVer] = [`@${splits[1]}`, splits[2]];
+      let pkgName, pkgVer;
+      if (installType === INSTALL_TYPE_LOCAL) {
+        pkgName = path.isAbsolute(installSpec) ? installSpec : path.resolve(installSpec);
       } else {
-        // this is the case without an npm org
-        [name, pkgVer] = splits;
-      }
-      let pkgName;
+        // at this point we have either an npm package or an appium verified extension
+        // name or a local path. both of which will be installed via npm.
+        // extensions installed via npm can include versions or tags after the '@'
+        // sign, so check for that. We also need to be careful that package names themselves can
+        // contain the '@' symbol, as in `npm install @appium/fake-driver@1.2.0`
+        let name;
+        const splits = installSpec.split('@');
+        if (installSpec[0] === '@') {
+          // this is the case where we have an npm org included in the package name
+          [name, pkgVer] = [`@${splits[1]}`, splits[2]];
+        } else {
+          // this is the case without an npm org
+          [name, pkgVer] = splits;
+        }
 
-      if (installType === INSTALL_TYPE_NPM) {
-        // if we're installing a named package from npm, we don't need to check
-        // against the appium extension list; just use the installSpec as is
-        pkgName = name;
-      } else {
-        // if we're installing a named appium driver (like 'xcuitest') we need to
-        // dereference the actual npm package ('appiupm-xcuitest-driver'), so
-        // check it exists and get the correct package
-        const knownNames = Object.keys(this.knownExtensions);
-        if (!_.includes(knownNames, name)) {
-          const msg = `Could not resolve ${this.type}; are you sure it's in the list ` +
-                      `of supported ${this.type}s? ${JSON.stringify(knownNames)}`;
-          throw new Error(msg);
+        if (installType === INSTALL_TYPE_NPM) {
+          // if we're installing a named package from npm, we don't need to check
+          // against the appium extension list; just use the installSpec as is
+          pkgName = name;
+        } else {
+          // if we're installing a named appium driver (like 'xcuitest') we need to
+          // dereference the actual npm package ('appiupm-xcuitest-driver'), so
+          // check it exists and get the correct package
+          const knownNames = Object.keys(this.knownExtensions);
+          if (!_.includes(knownNames, name)) {
+            const msg = `Could not resolve ${this.type}; are you sure it's in the list ` +
+                        `of supported ${this.type}s? ${JSON.stringify(knownNames)}`;
+            throw new Error(msg);
+          }
+          pkgName = this.knownExtensions[name];
+          // given that we'll use the install type in the driver json, store it as
+          // 'npm' now
+          installType = INSTALL_TYPE_NPM;
         }
-        pkgName = this.knownExtensions[name];
-        // given that we'll use the install type in the driver json, store it as
-        // 'npm' now
-        installType = INSTALL_TYPE_NPM;
       }
 
       extData = await this.installViaNpm({ext, pkgName, pkgVer});
@@ -246,9 +250,13 @@ export default class ExtensionCommand {
                       `installed ${this.type}s with 'appium ${this.type} list --installed'.`);
     }
 
-    extData.installType = installType;
-    extData.installSpec = installSpec;
-    await this.config.addExtension(extName, extData);
+    const extManifest = {...extData, installType, installSpec};
+    await this.config.addExtension(extName, extManifest);
+
+    // update the if we've changed the local `package.json`
+    if (await env.hasAppiumDependency(this.config.appiumHome)) {
+      await packageDidChange(this.config.appiumHome);
+    }
 
     // log info for the user
     log(this.isJsonOutput, this.getPostInstallText({extName, extData}));
@@ -260,7 +268,6 @@ export default class ExtensionCommand {
    * Install an extension via NPM
    *
    * @param {InstallViaNpmArgs} args
-   * @returns {Promise<ExtData<ExtType>>}
    */
   async installViaNpm ({ext, pkgName, pkgVer}) {
     const npmSpec = `${pkgName}${pkgVer ? '@' + pkgVer : ''}`;
@@ -296,8 +303,9 @@ export default class ExtensionCommand {
    * load as the main driver class, or to be able to detect incompatibilities between driver and
    * appium versions.
    *
-   * @param {object} pkgJsonData - the package.json data for a driver module, as if it had been
+   * @param {ExtPackageJson<ExtType>} pkgJsonData - the package.json data for a driver module, as if it had been
    * straightforwardly 'require'd
+   * @returns {ExtensionFields<ExtType>}
    */
   getExtensionFields (pkgJsonData) {
     if (!pkgJsonData.appium) {
@@ -306,8 +314,9 @@ export default class ExtensionCommand {
     }
     const {appium, name, version} = pkgJsonData;
     this.validateExtensionFields(appium);
-
-    return {...appium, pkgName: name, version};
+    /** @type {unknown} */
+    const result = {...appium, pkgName: name, version};
+    return /** @type {ExtensionFields<ExtType>} */(result);
   }
 
   /**
@@ -315,19 +324,20 @@ export default class ExtensionCommand {
    * presence and form of those fields on the package.json data, throwing an error if anything is
    * amiss.
    *
-   * @param {import('../extension/manifest').ExternalData<ExtType>} appiumPkgData - the data in the "appium" field of package.json for an extension
+   * @param {ExtMetadata<ExtType>} appiumPkgData - the data in the "appium" field of package.json for an extension
    */
   // eslint-disable-next-line no-unused-vars
   validateExtensionFields (appiumPkgData) {
     throw new Error('Must be implemented in final class');
   }
+
   /**
    * Uninstall an extension
    *
    * @param {UninstallOpts} opts
    * @return {Promise<ExtRecord<ExtType>>} map of all installed extension names to extension data
    */
-  async uninstall ({ext}) {
+  async _uninstall ({ext}) {
     if (!this.config.isInstalled(ext)) {
       throw new Error(`Can't uninstall ${this.type} '${ext}'; it is not installed`);
     }
@@ -347,7 +357,7 @@ export default class ExtensionCommand {
    * @param {ExtensionUpdateOpts} updateSpec
    * @return {Promise<ExtensionUpdateResult>}
    */
-  async update ({ext, unsafe}) {
+  async _update ({ext, unsafe}) {
     const shouldUpdateAll = ext === UPDATE_ALL;
     // if we're specifically requesting an update for an extension, make sure it's installed
     if (!shouldUpdateAll && !this.config.isInstalled(ext)) {
@@ -450,6 +460,7 @@ export default class ExtensionCommand {
    *
    * @param {string} ext - name of extension to update
    * @param {string} version - version string identifier to update extension to
+   * @returns {Promise<void>}
    */
   async updateExtension (ext, version) {
     const {pkgName} = this.config.installedExtensions[ext];
@@ -470,7 +481,7 @@ export default class ExtensionCommand {
    * @param {RunOptions} opts
    * @return {Promise<RunOutput>}
    */
-  async run ({ext, scriptName}) {
+  async _run ({ext, scriptName}) {
     if (!_.has(this.config.installedExtensions, ext)) {
       throw new Error(`please install the ${this.type} first`);
     }
@@ -519,10 +530,8 @@ export default class ExtensionCommand {
   }
 }
 
-/**
- * @template {ExtensionType} ExtType
- * @typedef {import('../extension/extension-config').ExtensionConfig<ExtType>} ExtensionConfig
- */
+export default ExtensionCommand;
+export {ExtensionCommand};
 
 /**
  * Options for the {@linkcode ExtensionCommand} constructor
@@ -537,39 +546,68 @@ export default class ExtensionCommand {
  *
  * @typedef ExtensionMetadata
  * @property {boolean} installed - If `true`, the extension is installed
- * @property {string|null} [updateVersion] - If the extension is installed, the version it can be updated to
- * @property {string|null} [unsafeUpdateVersion] - Same as above, but a major version bump
- * @property {boolean} [upToDate] - If the extension is installed and the latest
+ * @property {string?} updateVersion - If the extension is installed, the version it can be updated to
+ * @property {string?} unsafeUpdateVersion - Same as above, but a major version bump
+ * @property {boolean} upToDate - If the extension is installed and the latest
+ */
+
+/**
+ * @typedef {import('../../types').ExtensionType} ExtensionType
+ * @typedef {import('../../types').DriverType} DriverType
+ * @typedef {import('../../types').PluginType} PluginType
  */
 
 /**
- * @typedef {import('../extension/manifest').ExtensionType} ExtensionType
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../../types/appium-manifest').ExtRecord<ExtType>} ExtRecord
  */
 
 /**
  * @template {ExtensionType} ExtType
- * @typedef {import('../extension/manifest').ExtRecord<ExtType>} ExtRecord
+ * @typedef {import('../extension/extension-config').ExtensionConfig<ExtType>} ExtensionConfig
  */
 
 /**
  * @template {ExtensionType} ExtType
- * @typedef {import('../extension/manifest').ExtData<ExtType>} ExtData
+ * @typedef {import('../../types/external-manifest').ExtMetadata<ExtType>} ExtMetadata
+ */
+
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../../types/appium-manifest').ExtManifest<ExtType>} ExtManifest
+ */
+
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {import('../../types/external-manifest').ExtPackageJson<ExtType>} ExtPackageJson
+ */
+
+/**
+ * Possible return value for {@linkcode ExtensionCommand.list}
+ * @typedef UninstalledExtensionListData
+ * @property {string} pkgName
+ * @property {false} installed
+ */
+
+/**
+ * Possible return value for {@linkcode ExtensionCommand.list}
+ * @typedef {import('../../types/appium-manifest').InternalMetadata & ExtensionMetadata} InstalledExtensionListData
  */
 
 /**
  * Return value of {@linkcode ExtensionCommand.list}.
- * @typedef {Record<string, (import('../extension/manifest').InternalData & ExtensionMetadata) | { pkgName: string, installed: false }>} ExtensionListData
+ * @typedef {Record<string,InstalledExtensionListData|UninstalledExtensionListData>} ExtensionListData
  */
 
 /**
- * Options for {@linkcode ExtensionCommand.run}.
+ * Options for {@linkcode ExtensionCommand._run}.
  * @typedef RunOptions
  * @property {string} ext - name of the extension to run a script from
  * @property {string} scriptName - name of the script to run
  */
 
 /**
- * Return value of {@linkcode ExtensionCommand.run}
+ * Return value of {@linkcode ExtensionCommand._run}
  *
  * @typedef RunOutput
  * @property {string} [error] - error message if script ran unsuccessfully, otherwise undefined
@@ -577,28 +615,28 @@ export default class ExtensionCommand {
  */
 
 /**
- * Options for {@linkcode ExtensionCommand.update}.
+ * Options for {@linkcode ExtensionCommand._update}.
  * @typedef ExtensionUpdateOpts
  * @property {string} ext - the name of the extension to update
  * @property {boolean} unsafe - if true, will perform unsafe updates past major revision boundaries
  */
 
 /**
- * Return value of {@linkcode ExtensionCommand.update}.
+ * Return value of {@linkcode ExtensionCommand._update}.
  * @typedef ExtensionUpdateResult
  * @property {Record<string,Error>} errors - map of ext names to error objects
  * @property {Record<string,UpdateReport>} updates - map of ext names to {@linkcode UpdateReport}s
  */
 
 /**
- * Part of result of {@linkcode ExtensionCommand.update}.
+ * Part of result of {@linkcode ExtensionCommand._update}.
  * @typedef UpdateReport
  * @property {string} from - version the extension was updated from
  * @property {string} to - version the extension was updated to
  */
 
 /**
- * Options for {@linkcode ExtensionCommand.uninstall}.
+ * Options for {@linkcode ExtensionCommand._uninstall}.
  * @typedef UninstallOpts
  * @property {string} ext - the name or spec of an extension to uninstall
  */
@@ -627,9 +665,20 @@ export default class ExtensionCommand {
  */
 
 /**
- * Options for {@linkcode ExtensionCommand.install}
+ * Options for {@linkcode ExtensionCommand._install}
  * @typedef InstallArgs
  * @property {string} ext - the name or spec of an extension to install
- * @property {import('../extension/extension-config').InstallType} installType - how to install this extension. One of the INSTALL_TYPES
+ * @property {import('../../types/appium-manifest').InstallType} installType - how to install this extension. One of the INSTALL_TYPES
  * @property {string} [packageName] - for git/github installs, the extension node package name
  */
+
+/**
+ * Returned by {@linkcode ExtensionCommand.getExtensionFields}
+ * @template {ExtensionType} ExtType
+ * @typedef {ExtMetadata<ExtType> & { pkgName: string, version: string } & import('../../types/external-manifest').CommonMetadata} ExtensionFields
+ */
+
+/**
+ * @template {ExtensionType} ExtType
+ * @typedef {ExtType extends DriverType ? typeof import('../constants').KNOWN_DRIVERS : ExtType extends PluginType ? typeof import('../constants').KNOWN_PLUGINS : never} KnownExtensions
+ */

package/lib/cli/extension.js

@@ -2,16 +2,21 @@
 
 import DriverCommand from './driver-command';
 import PluginCommand from './plugin-command';
-import { DRIVER_TYPE } from '../constants';
+import { DRIVER_TYPE, PLUGIN_TYPE } from '../constants';
 import { errAndQuit, log, JSON_SPACES } from './utils';
 
+const commandClasses = Object.freeze(/** @type {const} */({
+  [DRIVER_TYPE]: DriverCommand,
+  [PLUGIN_TYPE]: PluginCommand
+}));
+
 /**
  * Run a subcommand of the 'appium driver' type. Each subcommand has its own set of arguments which
  * can be represented as a JS object.
  *
  * @param {Object} args - JS object where the key is the parameter name (as defined in
  * driver-parser.js)
- * @template {ExtensionType} ExtType
+ * @template {import('../extension/manifest').ExtensionType} ExtType
  * @param {import('../extension/extension-config').ExtensionConfig<ExtType>} configObject - Extension config object
  */
 async function runExtensionCommand (args, configObject) {
@@ -30,7 +35,7 @@ async function runExtensionCommand (args, configObject) {
   const logFn = (msg) => log(json, msg);
   let config = configObject;
   config.log = logFn;
-  const CommandClass = type === DRIVER_TYPE ? DriverCommand : PluginCommand;
+  const CommandClass = /** @type {ExtCommand<ExtType>} */(commandClasses[type]);
   const cmd = new CommandClass({config, json});
   try {
     jsonResult = await cmd.execute(args);
@@ -53,3 +58,8 @@ async function runExtensionCommand (args, configObject) {
 export {
   runExtensionCommand,
 };
+
+/**
+ * @template {import('../../types').ExtensionType} ExtType
+ * @typedef {ExtType extends import('../../types').DriverType ? import('@appium/types').Class<DriverCommand> : ExtType extends import('../../types').PluginType ? import('@appium/types').Class<PluginCommand> : never} ExtCommand
+ */

package/lib/cli/parser.js

@@ -1,4 +1,3 @@
-// @ts-check
 
 import { fs } from '@appium/support';
 import { ArgumentParser } from 'argparse';
@@ -101,7 +100,7 @@ class ArgParser {
    *
    * `ArgParser.prototype.parse_args` is an alias of this method.
    * @param {string[]} [args] - Array of arguments, ostensibly from `process.argv`. Gathers args from `process.argv` if not provided.
-   * @returns {import('../../types/types').ParsedArgs} - The parsed arguments
+   * @returns {import('../../types/cli').ParsedArgs} - The parsed arguments
    */
   parseArgs (args = process.argv.slice(2)) {
     if (!NON_SERVER_ARGS.has(args[0])) {

package/lib/cli/plugin-command.js

@@ -1,30 +1,34 @@
 import _ from 'lodash';
 import ExtensionCommand from './extension-command';
-import { PLUGIN_TYPE, KNOWN_PLUGINS } from '../constants';
+import { KNOWN_PLUGINS } from '../constants';
 
 const REQ_PLUGIN_FIELDS = ['pluginName', 'mainClass'];
 
 export default class PluginCommand extends ExtensionCommand {
 
+  /**
+   *
+   * @param {PluginCommandOptions} opts
+   */
   constructor ({config, json}) {
-    super({config, json, type: PLUGIN_TYPE});
+    super({config, json});
     this.knownExtensions = KNOWN_PLUGINS;
   }
 
   async install ({plugin, installType, packageName}) {
-    return await super.install({ext: plugin, installType, packageName});
+    return await super._install({ext: plugin, installType, packageName});
   }
 
   async uninstall ({plugin}) {
-    return await super.uninstall({ext: plugin});
+    return await super._uninstall({ext: plugin});
   }
 
   async update ({plugin, unsafe}) {
-    return await super.update({ext: plugin, unsafe});
+    return await super._update({ext: plugin, unsafe});
   }
 
   async run ({plugin, scriptName}) {
-    return await super.run({ext: plugin, scriptName});
+    return await super._run({ext: plugin, scriptName});
   }
 
   getPostInstallText ({extName, extData}) {
@@ -44,3 +48,9 @@ export default class PluginCommand extends ExtensionCommand {
   }
 
 }
+
+/**
+ * @typedef PluginCommandOptions
+ * @property {import('../extension/extension-config').ExtensionConfig<import('../extension/manifest').PluginType>} config
+ * @property {boolean} json
+ */

package/lib/cli/utils.js

@@ -7,7 +7,7 @@ const JSON_SPACES = 4;
 /***
  * Log an error to the console and exit the process.
  * @param {boolean} json - whether we should log json or text
- * @param {string} msg - error message
+ * @param {any} msg - error message, object, Error instance, etc.
  */
 function errAndQuit (json, msg) {
   if (json) {

package/lib/config-file.js

@@ -1,4 +1,3 @@
-// @ts-check
 
 import betterAjvErrors from '@sidvind/better-ajv-errors';
 import { lilconfig } from 'lilconfig';
@@ -186,7 +185,7 @@ export function normalizeConfig (config) {
  * @property {string} [filepath] - The path to the config file, if found
  * @property {boolean} [isEmpty] - If `true`, the config file exists but is empty
  * @property {NormalizedAppiumConfig} [config] - The parsed configuration
- * @property {string|betterAjvErrors.IOutputError[]} [reason] - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.
+ * @property {string|import('@sidvind/better-ajv-errors').IOutputError[]} [reason] - Human-readable error messages and suggestions. If the `pretty` option is `true`, this will be a nice string to print.
  */
 
 /**
@@ -202,12 +201,12 @@ export function normalizeConfig (config) {
 
 /**
  * The contents of an Appium config file. Generated from schema
- * @typedef {import('../types/types').AppiumConfig} AppiumConfig
+ * @typedef {import('@appium/types').AppiumConfig} AppiumConfig
  */
 
 /**
  * The contents of an Appium config file with camelcased property names (and using `appiumCliDest` value if present). Generated from {@link AppiumConfig}
- * @typedef {import('../types/types').NormalizedAppiumConfig} NormalizedAppiumConfig
+ * @typedef {import('@appium/types').NormalizedAppiumConfig} NormalizedAppiumConfig
  */
 
 /**

package/lib/config.js

@@ -1,5 +1,3 @@
-// @ts-check
-
 /* eslint-disable no-console */
 import _ from 'lodash';
 import { system, fs } from '@appium/support';
@@ -19,6 +17,9 @@ const GIT_META_ROOT = '.git';
 const GIT_BINARY = `git${system.isWindows() ? '.exe' : ''}`;
 const GITHUB_API = 'https://api.github.com/repos/appium/appium';
 
+/**
+ * @type {import('../types/cli').BuildInfo}
+ */
 const BUILD_INFO = {
   version: APPIUM_VER,
 };
@@ -34,7 +35,7 @@ async function updateBuildInfo (useGithubApiFallback = false) {
   }
   BUILD_INFO['git-sha'] = sha;
   const built = await getGitTimestamp(sha, useGithubApiFallback);
-  if (!_.isEmpty(built)) {
+  if (built) {
     BUILD_INFO.built = built;
   }
 }
@@ -85,7 +86,7 @@ async function getGitRev (useGithubApiFallback = false) {
 /**
  * @param {string} commitSha
  * @param {boolean} [useGithubApiFallback]
- * @returns {Promise<number?>}
+ * @returns {Promise<string?>}
  */
 async function getGitTimestamp (commitSha, useGithubApiFallback = false) {
   const gitRoot = await findGitRoot();
@@ -121,10 +122,11 @@ async function getGitTimestamp (commitSha, useGithubApiFallback = false) {
 }
 
 /**
- * @return Mutable object containing Appium build information. By default it
+ * Mutable object containing Appium build information. By default it
  * only contains the Appium version, but is updated with the build timestamp
  * and git commit hash asynchronously as soon as `updateBuildInfo` is called
  * and succeeds.
+ * @returns {import('../types/cli').BuildInfo}
  */
 function getBuildInfo () {
   return BUILD_INFO;
@@ -166,7 +168,7 @@ function getNonDefaultServerArgs (parsedArgs) {
    * Flattens parsed args into a single level object for comparison with
    * flattened defaults across server args and extension args.
    * @param {ParsedArgs} args
-   * @returns {Record<string, { value: any, argSpec: import('./schema/arg-spec').ArgSpec }>}
+   * @returns {Record<string, { value: any, argSpec: ArgSpec }>}
    */
   const flatten = (args) => {
     const argSpecs = getAllArgSpecs();
@@ -175,7 +177,7 @@ function getNonDefaultServerArgs (parsedArgs) {
         acc[argSpec.dest] = {value: _.get(args, argSpec.dest), argSpec};
       }
       return acc;
-    }, /** @type {Record<string, { value: any, argSpec: import('./schema/arg-spec').ArgSpec }>} */({}));
+    }, /** @type {Record<string, { value: any, argSpec: ArgSpec }>} */({}));
 
     return flattened;
   };
@@ -304,5 +306,7 @@ export {
 };
 
 /**
- * @typedef {import('../types/types').ParsedArgs} ParsedArgs
+ * @typedef {import('../types/cli').ParsedArgs} ParsedArgs
+ * @typedef {import('./schema/arg-spec').ArgSpec} ArgSpec
  */
+

package/lib/constants.js

@@ -1,4 +1,3 @@
-// @ts-check
 
 import path from 'path';