appium 2.0.0-beta.20 → 2.0.0-beta.24

package/build/test/utils-specs.js

@@ -0,0 +1,288 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _utils = require("../lib/utils");
+
+var _helpers = require("./helpers");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _colors = require("@dabh/colors");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _logger = _interopRequireDefault(require("../lib/logger"));
+
+describe('utils', function () {
+  describe('parseCapsForInnerDriver()', function () {
+    it('should return an error if only JSONWP provided', function () {
+      let {
+        error,
+        protocol
+      } = (0, _utils.parseCapsForInnerDriver)(_helpers.BASE_CAPS);
+      protocol.should.equal('W3C');
+      error.message.should.match(/W3C/);
+    });
+    it('should return W3C caps unchanged if only W3C caps were provided', function () {
+      let {
+        desiredCaps,
+        processedJsonwpCapabilities,
+        processedW3CCapabilities,
+        protocol
+      } = (0, _utils.parseCapsForInnerDriver)(undefined, _helpers.W3C_CAPS);
+      desiredCaps.should.deep.equal(_helpers.BASE_CAPS);
+      should.not.exist(processedJsonwpCapabilities);
+      processedW3CCapabilities.should.deep.equal(_helpers.W3C_CAPS);
+      protocol.should.equal('W3C');
+    });
+    it('should return JSONWP and W3C caps if both were provided', function () {
+      let {
+        desiredCaps,
+        processedJsonwpCapabilities,
+        processedW3CCapabilities,
+        protocol
+      } = (0, _utils.parseCapsForInnerDriver)(_helpers.BASE_CAPS, _helpers.W3C_CAPS);
+      desiredCaps.should.deep.equal(_helpers.BASE_CAPS);
+      processedJsonwpCapabilities.should.deep.equal(_helpers.BASE_CAPS);
+      processedW3CCapabilities.should.deep.equal(_helpers.W3C_CAPS);
+      protocol.should.equal('W3C');
+    });
+    it('should include default capabilities in results', function () {
+      const defaultW3CCaps = {
+        'appium:foo': 'bar',
+        'appium:baz': 'bla'
+      };
+      const expectedDefaultCaps = {
+        foo: 'bar',
+        baz: 'bla'
+      };
+      const {
+        desiredCaps,
+        processedJsonwpCapabilities,
+        processedW3CCapabilities
+      } = (0, _utils.parseCapsForInnerDriver)(_helpers.BASE_CAPS, _helpers.W3C_CAPS, {}, defaultW3CCaps);
+      desiredCaps.should.deep.equal({ ...expectedDefaultCaps,
+        ..._helpers.BASE_CAPS
+      });
+      processedJsonwpCapabilities.should.deep.equal({ ...expectedDefaultCaps,
+        ..._helpers.BASE_CAPS
+      });
+      processedW3CCapabilities.alwaysMatch.should.deep.equal({ ...(0, _utils.insertAppiumPrefixes)(expectedDefaultCaps),
+        ...(0, _utils.insertAppiumPrefixes)(_helpers.BASE_CAPS)
+      });
+    });
+    it('should allow valid default capabilities', function () {
+      const res = (0, _utils.parseCapsForInnerDriver)(null, _helpers.W3C_CAPS, {}, {
+        'appium:foo': 'bar2'
+      });
+      res.processedW3CCapabilities.alwaysMatch['appium:foo'].should.eql('bar2');
+    });
+    it('should not allow invalid default capabilities', function () {
+      const res = (0, _utils.parseCapsForInnerDriver)(null, _helpers.W3C_CAPS, {}, {
+        foo: 'bar',
+        'appium:foo2': 'bar2'
+      });
+      res.error.should.eql({
+        jsonwpCode: 61,
+        error: 'invalid argument',
+        w3cStatus: 400,
+        _stacktrace: null
+      });
+    });
+    it('should reject if W3C caps are not passing constraints', function () {
+      const err = (0, _utils.parseCapsForInnerDriver)(undefined, _helpers.W3C_CAPS, {
+        hello: {
+          presence: true
+        }
+      }).error;
+      err.message.should.match(/'hello' can't be blank/);
+      _lodash.default.isError(err).should.be.true;
+    });
+    it('should only accept W3C caps that have passing constraints', function () {
+      let w3cCaps = { ..._helpers.W3C_CAPS,
+        firstMatch: [{
+          foo: 'bar'
+        }, {
+          'appium:hello': 'world'
+        }]
+      };
+      (0, _utils.parseCapsForInnerDriver)(_helpers.BASE_CAPS, w3cCaps, {
+        hello: {
+          presence: true
+        }
+      }).error.should.eql({
+        jsonwpCode: 61,
+        error: 'invalid argument',
+        w3cStatus: 400,
+        _stacktrace: null
+      });
+    });
+    it('should add appium prefixes to W3C caps that are not standard in W3C', function () {
+      (0, _utils.parseCapsForInnerDriver)(undefined, {
+        alwaysMatch: {
+          platformName: 'Fake',
+          propertyName: 'PROP_NAME'
+        }
+      }).error.error.should.includes('invalid argument');
+    });
+  });
+  describe('removeAppiumPrefixes()', function () {
+    it('should remove appium prefixes from cap names', function () {
+      (0, _utils.removeAppiumPrefixes)({
+        'appium:cap1': 'value1',
+        'ms:cap2': 'value2',
+        someCap: 'someCap'
+      }).should.eql({
+        'cap1': 'value1',
+        'ms:cap2': 'value2',
+        someCap: 'someCap'
+      });
+    });
+  });
+  describe('insertAppiumPrefixes()', function () {
+    it('should apply prefixes to non-standard capabilities', function () {
+      (0, _utils.insertAppiumPrefixes)({
+        someCap: 'someCap'
+      }).should.deep.equal({
+        'appium:someCap': 'someCap'
+      });
+    });
+    it('should not apply prefixes to standard capabilities', function () {
+      (0, _utils.insertAppiumPrefixes)({
+        browserName: 'BrowserName',
+        platformName: 'PlatformName'
+      }).should.deep.equal({
+        browserName: 'BrowserName',
+        platformName: 'PlatformName'
+      });
+    });
+    it('should not apply prefixes to capabilities that already have a prefix', function () {
+      (0, _utils.insertAppiumPrefixes)({
+        'appium:someCap': 'someCap',
+        'moz:someOtherCap': 'someOtherCap'
+      }).should.deep.equal({
+        'appium:someCap': 'someCap',
+        'moz:someOtherCap': 'someOtherCap'
+      });
+    });
+    it('should apply prefixes to non-prefixed, non-standard capabilities; should not apply prefixes to any other capabilities', function () {
+      (0, _utils.insertAppiumPrefixes)({
+        'appium:someCap': 'someCap',
+        'moz:someOtherCap': 'someOtherCap',
+        browserName: 'BrowserName',
+        platformName: 'PlatformName',
+        someOtherCap: 'someOtherCap',
+        yetAnotherCap: 'yetAnotherCap'
+      }).should.deep.equal({
+        'appium:someCap': 'someCap',
+        'moz:someOtherCap': 'someOtherCap',
+        browserName: 'BrowserName',
+        platformName: 'PlatformName',
+        'appium:someOtherCap': 'someOtherCap',
+        'appium:yetAnotherCap': 'yetAnotherCap'
+      });
+    });
+  });
+  describe('pullSettings()', function () {
+    it('should pull settings from caps', function () {
+      const caps = {
+        platformName: 'foo',
+        browserName: 'bar',
+        'settings[settingName]': 'baz',
+        'settings[settingName2]': 'baz2'
+      };
+      const settings = (0, _utils.pullSettings)(caps);
+      settings.should.eql({
+        settingName: 'baz',
+        settingName2: 'baz2'
+      });
+      caps.should.eql({
+        platformName: 'foo',
+        browserName: 'bar'
+      });
+    });
+    it('should pull settings dict if object values are present in caps', function () {
+      const caps = {
+        platformName: 'foo',
+        browserName: 'bar',
+        'settings[settingName]': {
+          key: 'baz'
+        }
+      };
+      const settings = (0, _utils.pullSettings)(caps);
+      settings.should.eql({
+        settingName: {
+          key: 'baz'
+        }
+      });
+      caps.should.eql({
+        platformName: 'foo',
+        browserName: 'bar'
+      });
+    });
+    it('should pull empty dict if no settings are present in caps', function () {
+      const caps = {
+        platformName: 'foo',
+        browserName: 'bar',
+        'setting[settingName]': 'baz'
+      };
+      const settings = (0, _utils.pullSettings)(caps);
+      settings.should.eql({});
+      caps.should.eql({
+        platformName: 'foo',
+        browserName: 'bar',
+        'setting[settingName]': 'baz'
+      });
+    });
+    it('should pull empty dict if caps are empty', function () {
+      const caps = {};
+      const settings = (0, _utils.pullSettings)(caps);
+      settings.should.eql({});
+      caps.should.eql({});
+    });
+  });
+  describe('ReadonlyMap', function () {
+    it('should allow writing', function () {
+      const map = new _utils.ReadonlyMap();
+      (() => map.set('foo', 'bar')).should.not.throw();
+    });
+    it('should allow reading', function () {
+      const map = new _utils.ReadonlyMap([['foo', 'bar']]);
+      (() => map.get('foo')).should.not.throw();
+    });
+    it('should not allow deletion', function () {
+      const map = new _utils.ReadonlyMap([['foo', 'bar']]);
+      map.delete('foo').should.be.false;
+    });
+    it('should not allow clearing', function () {
+      const map = new _utils.ReadonlyMap([['foo', 'bar']]);
+      (() => map.clear()).should.throw();
+    });
+    it('should not allow updating', function () {
+      const map = new _utils.ReadonlyMap([['foo', 'bar']]);
+      (() => map.set('foo', 'baz')).should.throw();
+    });
+  });
+  describe('inspect()', function () {
+    let sandbox;
+    beforeEach(function () {
+      sandbox = _sinon.default.createSandbox();
+      sandbox.spy(_logger.default, 'info');
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    it('should log the result of inspecting a value', function () {
+      (0, _utils.inspect)({
+        foo: 'bar'
+      });
+      (0, _colors.stripColors)(_logger.default.info.firstCall.firstArg).should.equal('{ foo: \'bar\' }');
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/utils-specs.js"],"names":["describe","it","error","protocol","BASE_CAPS","should","equal","message","match","desiredCaps","processedJsonwpCapabilities","processedW3CCapabilities","undefined","W3C_CAPS","deep","not","exist","defaultW3CCaps","expectedDefaultCaps","foo","baz","alwaysMatch","res","eql","jsonwpCode","w3cStatus","_stacktrace","err","hello","presence","_","isError","be","true","w3cCaps","firstMatch","platformName","propertyName","includes","someCap","browserName","someOtherCap","yetAnotherCap","caps","settings","settingName","settingName2","key","map","ReadonlyMap","set","throw","get","delete","false","clear","sandbox","beforeEach","sinon","createSandbox","spy","logger","afterEach","restore","info","firstCall","firstArg"],"mappings":"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","sourcesContent":["import {\n  parseCapsForInnerDriver, insertAppiumPrefixes, pullSettings,\n  removeAppiumPrefixes, ReadonlyMap, inspect\n} from '../lib/utils';\nimport { BASE_CAPS, W3C_CAPS } from './helpers';\nimport _ from 'lodash';\nimport { stripColors } from '@dabh/colors';\nimport sinon from 'sinon';\nimport logger from '../lib/logger';\n\ndescribe('utils', function () {\n  describe('parseCapsForInnerDriver()', function () {\n    it('should return an error if only JSONWP provided', function () {\n      let {error, protocol} = parseCapsForInnerDriver(BASE_CAPS);\n      protocol.should.equal('W3C');\n      error.message.should.match(/W3C/);\n    });\n    it('should return W3C caps unchanged if only W3C caps were provided', function () {\n      let {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities, protocol} = parseCapsForInnerDriver(undefined, W3C_CAPS);\n      desiredCaps.should.deep.equal(BASE_CAPS);\n      should.not.exist(processedJsonwpCapabilities);\n      processedW3CCapabilities.should.deep.equal(W3C_CAPS);\n      protocol.should.equal('W3C');\n    });\n    it('should return JSONWP and W3C caps if both were provided', function () {\n      let {desiredCaps, processedJsonwpCapabilities, processedW3CCapabilities, protocol} = parseCapsForInnerDriver(BASE_CAPS, W3C_CAPS);\n      desiredCaps.should.deep.equal(BASE_CAPS);\n      processedJsonwpCapabilities.should.deep.equal(BASE_CAPS);\n      processedW3CCapabilities.should.deep.equal(W3C_CAPS);\n      protocol.should.equal('W3C');\n    });\n    it('should include default capabilities in results', function () {\n      const defaultW3CCaps = {\n        'appium:foo': 'bar',\n        'appium:baz': 'bla',\n      };\n      const expectedDefaultCaps = {\n        foo: 'bar',\n        baz: 'bla',\n      };\n      const {\n        desiredCaps,\n        processedJsonwpCapabilities,\n        processedW3CCapabilities\n      } = parseCapsForInnerDriver(BASE_CAPS, W3C_CAPS, {}, defaultW3CCaps);\n      desiredCaps.should.deep.equal({\n        ...expectedDefaultCaps,\n        ...BASE_CAPS,\n      });\n      processedJsonwpCapabilities.should.deep.equal({\n        ...expectedDefaultCaps,\n        ...BASE_CAPS\n      });\n      processedW3CCapabilities.alwaysMatch.should.deep.equal({\n        ...insertAppiumPrefixes(expectedDefaultCaps),\n        ...insertAppiumPrefixes(BASE_CAPS)\n      });\n    });\n    it('should allow valid default capabilities', function () {\n      const res = parseCapsForInnerDriver(null, W3C_CAPS, {}, {\n        'appium:foo': 'bar2',\n      });\n      res.processedW3CCapabilities.alwaysMatch['appium:foo'].should.eql('bar2');\n    });\n    it('should not allow invalid default capabilities', function () {\n      const res = parseCapsForInnerDriver(null, W3C_CAPS, {}, {\n        foo: 'bar', 'appium:foo2': 'bar2',\n      });\n      res.error.should.eql({\n        jsonwpCode: 61, error: 'invalid argument', w3cStatus: 400, _stacktrace: null\n      });\n    });\n    it('should reject if W3C caps are not passing constraints', function () {\n      const err = parseCapsForInnerDriver(undefined, W3C_CAPS, {hello: {presence: true}}).error;\n      err.message.should.match(/'hello' can't be blank/);\n      _.isError(err).should.be.true;\n\n    });\n    it('should only accept W3C caps that have passing constraints', function () {\n      let w3cCaps = {\n        ...W3C_CAPS,\n        firstMatch: [\n          {foo: 'bar'},\n          {'appium:hello': 'world'},\n        ],\n      };\n      parseCapsForInnerDriver(BASE_CAPS, w3cCaps, {hello: {presence: true}}).error.should.eql({\n        jsonwpCode: 61, error: 'invalid argument', w3cStatus: 400, _stacktrace: null\n      });\n    });\n    it('should add appium prefixes to W3C caps that are not standard in W3C', function () {\n      parseCapsForInnerDriver(undefined, {\n        alwaysMatch: {\n          platformName: 'Fake',\n          propertyName: 'PROP_NAME',\n        },\n      }).error.error.should.includes('invalid argument');\n    });\n  });\n\n  describe('removeAppiumPrefixes()', function () {\n    it('should remove appium prefixes from cap names', function () {\n      removeAppiumPrefixes({\n        'appium:cap1': 'value1',\n        'ms:cap2': 'value2',\n        someCap: 'someCap',\n      }).should.eql({\n        'cap1': 'value1',\n        'ms:cap2': 'value2',\n        someCap: 'someCap',\n      });\n    });\n  });\n\n  describe('insertAppiumPrefixes()', function () {\n    it('should apply prefixes to non-standard capabilities', function () {\n      insertAppiumPrefixes({\n        someCap: 'someCap',\n      }).should.deep.equal({\n        'appium:someCap': 'someCap',\n      });\n    });\n    it('should not apply prefixes to standard capabilities', function () {\n      insertAppiumPrefixes({\n        browserName: 'BrowserName',\n        platformName: 'PlatformName',\n      }).should.deep.equal({\n        browserName: 'BrowserName',\n        platformName: 'PlatformName',\n      });\n    });\n    it('should not apply prefixes to capabilities that already have a prefix', function () {\n      insertAppiumPrefixes({\n        'appium:someCap': 'someCap',\n        'moz:someOtherCap': 'someOtherCap',\n      }).should.deep.equal({\n        'appium:someCap': 'someCap',\n        'moz:someOtherCap': 'someOtherCap',\n      });\n    });\n    it('should apply prefixes to non-prefixed, non-standard capabilities; should not apply prefixes to any other capabilities', function () {\n      insertAppiumPrefixes({\n        'appium:someCap': 'someCap',\n        'moz:someOtherCap': 'someOtherCap',\n        browserName: 'BrowserName',\n        platformName: 'PlatformName',\n        someOtherCap: 'someOtherCap',\n        yetAnotherCap: 'yetAnotherCap',\n      }).should.deep.equal({\n        'appium:someCap': 'someCap',\n        'moz:someOtherCap': 'someOtherCap',\n        browserName: 'BrowserName',\n        platformName: 'PlatformName',\n        'appium:someOtherCap': 'someOtherCap',\n        'appium:yetAnotherCap': 'yetAnotherCap',\n      });\n    });\n  });\n\n  describe('pullSettings()', function () {\n    it('should pull settings from caps', function () {\n      const caps = {\n        platformName: 'foo',\n        browserName: 'bar',\n        'settings[settingName]': 'baz',\n        'settings[settingName2]': 'baz2',\n      };\n      const settings = pullSettings(caps);\n      settings.should.eql({\n        settingName: 'baz',\n        settingName2: 'baz2',\n      });\n      caps.should.eql({\n        platformName: 'foo',\n        browserName: 'bar',\n      });\n    });\n    it('should pull settings dict if object values are present in caps', function () {\n      const caps = {\n        platformName: 'foo',\n        browserName: 'bar',\n        'settings[settingName]': {key: 'baz'},\n      };\n      const settings = pullSettings(caps);\n      settings.should.eql({\n        settingName: {key: 'baz'},\n      });\n      caps.should.eql({\n        platformName: 'foo',\n        browserName: 'bar',\n      });\n    });\n    it('should pull empty dict if no settings are present in caps', function () {\n      const caps = {\n        platformName: 'foo',\n        browserName: 'bar',\n        'setting[settingName]': 'baz',\n      };\n      const settings = pullSettings(caps);\n      settings.should.eql({});\n      caps.should.eql({\n        platformName: 'foo',\n        browserName: 'bar',\n        'setting[settingName]': 'baz',\n      });\n    });\n    it('should pull empty dict if caps are empty', function () {\n      const caps = {};\n      const settings = pullSettings(caps);\n      settings.should.eql({});\n      caps.should.eql({});\n    });\n  });\n\n  describe('ReadonlyMap', function () {\n    it('should allow writing', function () {\n      const map = new ReadonlyMap();\n      (() => map.set('foo', 'bar')).should.not.throw();\n\n    });\n\n    it('should allow reading', function () {\n      const map = new ReadonlyMap([['foo', 'bar']]);\n      (() => map.get('foo')).should.not.throw();\n    });\n\n    it('should not allow deletion', function () {\n      const map = new ReadonlyMap([['foo', 'bar']]);\n      map.delete('foo').should.be.false;\n    });\n\n    it('should not allow clearing', function () {\n      const map = new ReadonlyMap([['foo', 'bar']]);\n      (() => map.clear()).should.throw();\n    });\n\n    it('should not allow updating', function () {\n      const map = new ReadonlyMap([['foo', 'bar']]);\n      (() => map.set('foo', 'baz')).should.throw();\n    });\n  });\n\n  describe('inspect()', function () {\n\n    /**\n     * @type {import('sinon').SinonSandbox}\n     */\n    let sandbox;\n    beforeEach(function () {\n      sandbox = sinon.createSandbox();\n      sandbox.spy(logger, 'info');\n    });\n\n    afterEach(function () {\n      sandbox.restore();\n    });\n\n    it('should log the result of inspecting a value', function () {\n      inspect({foo: 'bar'});\n      stripColors(/** @type {import('sinon').SinonStub} */(logger.info).firstCall.firstArg)\n        .should.equal('{ foo: \\'bar\\' }');\n    });\n  });\n});\n"],"file":"test/utils-specs.js","sourceRoot":"../.."}

package/index.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+const {asyncify} = require('asyncbox');
+
+const appium = require('./build/lib/main.js');
+
+if (require.main === module) {
+  asyncify(appium.main);
+}
+
+module.exports = appium;

package/lib/appium-config.schema.json

@@ -210,7 +210,8 @@
           "default": false,
           "description": "Disable additional security checks, so it is possible to use some advanced features, provided by drivers supporting this option. Only enable it if all the clients are in the trusted network and it's not the case if a client could potentially break out of the session sandbox. Specific features can be overridden by using \"deny-insecure\"",
           "title": "relaxed-security config",
-          "type": "boolean"
+          "type": "boolean",
+          "appiumCliDest": "relaxedSecurityEnabled"
         },
         "session-override": {
           "default": false,

package/lib/appium.js

@@ -3,10 +3,12 @@ import log from './logger';
 import { getBuildInfo, updateBuildInfo, APPIUM_VER } from './config';
 import { findMatchingDriver } from './drivers';
 import { BaseDriver, errors, isSessionCommand,
-         CREATE_SESSION_COMMAND } from '@appium/base-driver';
+         CREATE_SESSION_COMMAND, DELETE_SESSION_COMMAND, GET_STATUS_COMMAND
+} from '@appium/base-driver';
 import AsyncLock from 'async-lock';
 import { parseCapsForInnerDriver, pullSettings } from './utils';
 import { util } from '@appium/support';
+import { getDefaultsForExtension } from './schema';
 
 const desiredCapabilityConstraints = {
   automationName: {
@@ -51,6 +53,7 @@ class AppiumDriver extends BaseDriver {
     // It is not recommended to access this property directly from the outside
     this.pendingDrivers = {};
 
+    /** @type {PluginExtensionClass[]} */
     this.pluginClasses = []; // list of which plugins are active
     this.sessionPlugins = {}; // map of sessions to actual plugin instances per session
     this.sessionlessPlugins = []; // some commands are sessionless, so we need a set of plugins for them
@@ -59,9 +62,12 @@ class AppiumDriver extends BaseDriver {
     updateBuildInfo();
   }
 
-  /** @type {DriverConfig|undefined} */
+  /** @type {import('./driver-config').default|undefined} */
   driverConfig;
 
+  /** @type {import('express').Express|undefined} */
+  server;
+
   /**
    * Cancel commands queueing for the umbrella Appium driver
    */
@@ -118,14 +124,22 @@ class AppiumDriver extends BaseDriver {
    * Validate and assign CLI args for a driver or plugin
    *
    * If the extension has provided a schema, validation has already happened.
+   *
+   * Any arg which is equal to its default value will not be assigned to the extension.
    * @param {import('./ext-config-io').ExtensionType} extType 'driver' or 'plugin'
    * @param {string} extName the name of the extension
    * @param {Object} extInstance the driver or plugin instance
    */
   assignCliArgsToExtension (extType, extName, extInstance) {
-    const cliArgs = this.args[extType]?.[extName];
-    if (!_.isEmpty(cliArgs)) {
-      extInstance.cliArgs = cliArgs;
+    const allCliArgsForExt = this.args[extType]?.[extName];
+    if (!_.isEmpty(allCliArgsForExt)) {
+      const defaults = getDefaultsForExtension(extType, extName);
+      const cliArgs = _.isEmpty(defaults)
+        ? allCliArgsForExt
+        : _.omitBy(allCliArgsForExt, (value, key) => _.isEqual(defaults[key], value));
+      if (!_.isEmpty(cliArgs)) {
+        extInstance.cliArgs = cliArgs;
+      }
     }
   }
 
@@ -216,6 +230,12 @@ class AppiumDriver extends BaseDriver {
 
       // This assignment is required for correct web sockets functionality inside the driver
       driverInstance.server = this.server;
+
+      // Drivers/plugins might also want to know where they are hosted
+      driverInstance.serverHost = this.args.address;
+      driverInstance.serverPort = this.args.port;
+      driverInstance.serverPath = this.args.basePath;
+
       try {
         runningDriversData = await this.curSessionDataForDriver(InnerDriver);
       } catch (e) {
@@ -437,9 +457,10 @@ class AppiumDriver extends BaseDriver {
     // The tricky part is that because we support command plugins, we need to wrap any of these
     // cases with plugin handling.
 
-    const isGetStatus = cmd === 'getStatus';
+    const isGetStatus = cmd === GET_STATUS_COMMAND;
+    const isDeleteSession = cmd === DELETE_SESSION_COMMAND;
     const isUmbrellaCmd = !isGetStatus && isAppiumDriverCommand(cmd);
-    const isSessionCmd = !isGetStatus && !isUmbrellaCmd;
+    const isSessionCmd = !isUmbrellaCmd || isDeleteSession;
 
     // if a plugin override proxying for this command and that is why we are here instead of just
     // letting the protocol proxy the command entirely, determine that, get the request object for
@@ -464,7 +485,9 @@ class AppiumDriver extends BaseDriver {
       }
       // now save the response protocol given that the session driver's protocol might differ
       protocol = dstSession.protocol;
-      driver = dstSession;
+      if (!isUmbrellaCmd) {
+        driver = dstSession;
+      }
     }
 
     // get any plugins which are registered as handling this command
@@ -651,3 +674,23 @@ export class NoDriverProxyCommandError extends Error {
 }
 
 export { AppiumDriver };
+
+
+/**
+ * @typedef {Object} StaticExtMembers
+ * @property {(app: import('express').Express, httpServer: import('http').Server) => import('type-fest').Promisable<void>} [updateServer]
+ * @property {import('@appium/base-driver').MethodMap} [newMethodMap]
+ */
+
+/**
+ * @typedef {Object} StaticPluginMembers
+ * @property {string} pluginName
+ */
+
+/**
+ * @typedef {import('type-fest').Class<unknown> & StaticPluginMembers & StaticExtMembers} PluginExtensionClass
+ */
+
+/**
+ * @typedef {import('type-fest').Class<unknown> & StaticExtMembers} DriverExtensionClass
+ */

package/lib/cli/args.js

@@ -1,7 +1,6 @@
 // @ts-check
 
 // @ts-ignore
-import { DEFAULT_BASE_PATH } from '@appium/base-driver';
 import _ from 'lodash';
 import DriverConfig from '../driver-config';
 import { APPIUM_HOME, DRIVER_TYPE, INSTALL_TYPES, PLUGIN_TYPE } from '../extension-config';
@@ -175,13 +174,7 @@ function makeRunArgs (type) {
  */
 function getServerArgs () {
   return new Map([
-    ...toParserArgs({
-      overrides: {
-        basePath: {
-          default: DEFAULT_BASE_PATH
-        },
-      }
-    }),
+    ...toParserArgs(),
     ...serverArgsDisallowedInConfig,
   ]);
 }
@@ -195,21 +188,31 @@ const serverArgsDisallowedInConfig = new Map([
     ['--shell'],
     {
       required: false,
-      default: null,
       help: 'Enter REPL mode',
-      action: 'store_true',
+      action: 'store_const',
+      const: true,
       dest: 'shell',
     },
   ],
+  [
+    ['--show-build-info'],
+    {
+      dest: 'showBuildInfo',
+      action: 'store_const',
+      const: true,
+      required: false,
+      help: 'Show info about the Appium build and exit',
+    },
+  ],
   [
     ['--show-config'],
     {
-      default: false,
       dest: 'showConfig',
-      action: 'store_true',
+      action: 'store_const',
+      const: true,
       required: false,
-      help: 'Show info about the appium server configuration and exit',
-    },
+      help: 'Show the current Appium configuration and exit',
+    }
   ],
   [
     ['--config'],

package/lib/cli/npm.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import path from 'path';
 import semver from 'semver';
 import { exec } from 'teen_process';
@@ -8,10 +10,23 @@ const LINK_LOCKFILE = '.appium.link.lock';
 
 export default class NPM {
 
+  /**
+   * @param {string} appiumHome
+   */
   constructor (appiumHome) {
+    /** @type {string} */
     this.appiumHome = appiumHome;
   }
 
+  /**
+   * Execute `npm` with given args.
+   *
+   * If the process exits with a nonzero code, the contents of `STDOUT` and `STDERR` will be in the
+   * `message` of the {@link TeenProcessExecError} rejected.
+   * @param {string} cmd
+   * @param {string[]} args
+   * @param {{ json?: boolean; cwd?: string; lockFile?: string; }} opts
+   */
   async exec (cmd, args, opts, execOpts = {}) {
     let { cwd, json, lockFile } = opts;
     if (!cwd) {
@@ -33,7 +48,7 @@ export default class NPM {
 
     args.unshift(cmd);
     if (json) {
-      args.push('-json');
+      args.push('--json');
     }
     const npmCmd = system.isWindows() ? 'npm.cmd' : 'npm';
     let runner = async () => await exec(npmCmd, args, execOpts);
@@ -42,27 +57,38 @@ export default class NPM {
       const _runner = runner;
       runner = async () => await acquireLock(_runner);
     }
-    const {stdout, stderr, code} = await runner();
-    const ret = {stdout, stderr, code, json: null};
 
-    if (json) {
+    let ret;
+    try {
+      const {stdout, stderr, code} = await runner();
+      ret = /** @type {TeenProcessExecResult} */({stdout, stderr, code});
       // if possible, parse NPM's json output. During NPM install 3rd-party
       // packages can write to stdout, so sometimes the json output can't be
       // guaranteed to be parseable
       try {
         ret.json = JSON.parse(stdout);
       } catch (ign) {}
+    } catch (e) {
+      const {stdout, stderr, code} = /** @type {TeenProcessExecError} */(e);
+      const err = new Error(`npm command '${cmd} ${args.join(' ')}' failed with code ${code}.\n\nSTDOUT:\n${stdout.trim()}\n\nSTDERR:\n${stderr.trim()}`);
+      throw err;
     }
-
     return ret;
   }
 
+  /**
+   * @param {string} pkg
+   */
   async getLatestVersion (pkg) {
     return (await this.exec('view', [pkg, 'dist-tags'], {
       json: true
-    })).json.latest;
+    })).json?.latest;
   }
 
+  /**
+   * @param {string} pkg
+   * @param {string} curVersion
+   */
   async getLatestSafeUpgradeVersion (pkg, curVersion) {
     const allVersions = (await this.exec('view', [pkg, 'versions'], {
       json: true
@@ -115,6 +141,11 @@ export default class NPM {
     return safeUpgradeVer;
   }
 
+  /**
+   *
+   * @param {{pkgDir: string, pkgName: string, pkgVer?: string}} param0
+   * @returns {Promise<import('type-fest').PackageJson>}
+   */
   async installPackage ({pkgDir, pkgName, pkgVer}) {
     const res = await this.exec('install', [
       '--no-save',
@@ -148,6 +179,9 @@ export default class NPM {
     }
   }
 
+  /**
+   * @param {string} pkgPath
+   */
   async linkPackage (pkgPath) {
     // from the path alone we don't know the npm package name, so we need to
     // look in package.json
@@ -180,6 +214,10 @@ export default class NPM {
     }
   }
 
+  /**
+   * @param {string} pkgDir
+   * @param {string} pkg
+   */
   async uninstallPackage (pkgDir, pkg) {
     await this.exec('uninstall', [pkg], {
       cwd: pkgDir,
@@ -187,3 +225,27 @@ export default class NPM {
     });
   }
 }
+
+
+/**
+ * Result from a non-zero-exit execution of `appium`
+ * @typedef {Object} TeenProcessExecResult
+ * @property {string} stdout - Stdout
+ * @property {string} stderr - Stderr
+ * @property {number?} code - Exit code
+ * @property {any} json - JSON parsed from stdout
+ */
+
+/**
+ * Extra props `teen_process.exec` adds to its error objects
+ * @typedef {Object} TeenProcessExecErrorProps
+ * @property {string} stdout - STDOUT
+ * @property {string} stderr - STDERR
+ * @property {number?} code - Exit code
+ */
+
+
+/**
+ * Error thrown by `teen_process.exec`
+ * @typedef {Error & TeenProcessExecErrorProps} TeenProcessExecError
+ */