@appium/base-driver 10.7.0 → 10.7.2

package/lib/jsonwp-proxy/proxy.ts

@@ -1,38 +1,31 @@
-import type {
-  AppiumLogger,
-  HTTPBody,
-  HTTPHeaders,
-  HTTPMethod,
-  ProxyOptions,
-  ProxyResponse,
-} from '@appium/types';
+import http from 'node:http';
+import https from 'node:https';
+import nodeUrl from 'node:url';
+
 import {logger, util} from '@appium/support';
+import type {AppiumLogger, HTTPBody, HTTPHeaders, HTTPMethod, ProxyOptions, ProxyResponse} from '@appium/types';
+import type {AxiosError, AxiosResponse, RawAxiosRequestConfig} from 'axios';
+import type {Request, Response} from 'express';
+import {match as pathToRegexMatch} from 'path-to-regexp';
+
+import {DEFAULT_BASE_PATH, MAX_LOG_BODY_LENGTH, PROTOCOLS} from '../constants';
 import {getSummaryByCode} from '../jsonwp-status/status';
+import {isSessionCommand, routeToCommandName} from '../protocol';
 import {
-  errors,
-  isErrorType,
   errorFromMJSONWPStatusCode,
   errorFromW3CJsonCode,
+  errors,
   getResponseForW3CError,
+  isErrorType,
 } from '../protocol/errors';
-import {isSessionCommand, routeToCommandName} from '../protocol';
-import {MAX_LOG_BODY_LENGTH, DEFAULT_BASE_PATH, PROTOCOLS} from '../constants';
-import {ProtocolConverter} from './protocol-converter';
+import {ensureW3cResponse, formatResponseValue} from '../protocol/helpers';
 import {omit, pick} from '../utils';
-import {formatResponseValue, ensureW3cResponse} from '../protocol/helpers';
-import http from 'node:http';
-import https from 'node:https';
-import {match as pathToRegexMatch} from 'path-to-regexp';
-import nodeUrl from 'node:url';
+import {ProtocolConverter} from './protocol-converter';
 import {ProxyRequest} from './proxy-request';
-import type {Request, Response} from 'express';
-import type {AxiosError, AxiosResponse, RawAxiosRequestConfig} from 'axios';
 
 const DEFAULT_LOG = logger.getLogger('WD Proxy');
 const DEFAULT_REQUEST_TIMEOUT = 240000;
-const COMMAND_WITH_SESSION_ID_MATCHER = pathToRegexMatch(
-  '{/*prefix}/session/:sessionId{/*command}',
-);
+const COMMAND_WITH_SESSION_ID_MATCHER = pathToRegexMatch('{/*prefix}/session/:sessionId{/*command}');
 
 const {MJSONWP, W3C} = PROTOCOLS;
 
@@ -69,10 +62,10 @@ export class JWProxy {
   private readonly _log: AppiumLogger | undefined;
 
   constructor(opts: ProxyOptions = {}) {
-    const filteredOptsWithoutLog = omit(
-      pick(opts as Record<string, unknown>, ALLOWED_OPTS),
-      'log',
-    ) as Omit<ProxyOptions, 'log'>;
+    const filteredOptsWithoutLog = omit(pick(opts as Record<string, unknown>, ALLOWED_OPTS), 'log') as Omit<
+      ProxyOptions,
+      'log'
+    >;
     const options = {
       scheme: 'http',
       server: 'localhost',
@@ -177,11 +170,7 @@ export class JWProxy {
   /**
    * Proxies a raw WebDriver command to the downstream server.
    */
-  async proxy(
-    url: string,
-    method: string,
-    body: HTTPBody = null,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  async proxy(url: string, method: string, body: HTTPBody = null): Promise<[ProxyResponse, HTTPBody]> {
     method = method.toUpperCase();
     const newUrl = this.getUrlForProxy(url, method as HTTPMethod);
     const truncateBody = (content: unknown): string =>
@@ -214,10 +203,9 @@ export class JWProxy {
             (error as Error).message,
             logger.markSensitive(truncateBody(body)),
           );
-          throw new Error(
-            'Cannot interpret the request body as valid JSON. Check the server log for more details.',
-            {cause: error},
-          );
+          throw new Error('Cannot interpret the request body as valid JSON. Check the server log for more details.', {
+            cause: error,
+          });
         }
       } else {
         reqOpts.data = body;
@@ -253,7 +241,7 @@ export class JWProxy {
         // If it cannot be coerced to an object then the response is wrong
         throwProxyError(data);
       }
-      this.log.debug(`Got response with status ${status}: ${truncateBody(data)}`);
+      this.log.debug(`Got response with status ${status}: %s`, logger.markSensitive(truncateBody(data)));
       isResponseLogged = true;
       const isSessionCreationRequest = url.endsWith('/session') && method === 'POST';
       if (isSessionCreationRequest) {
@@ -281,11 +269,12 @@ export class JWProxy {
       let proxyErrorMsg = err.message;
       if (util.hasValue(err.response)) {
         if (!isResponseLogged) {
-          const error = truncateBody(err.response.data);
+          const error = logger.markSensitive(truncateBody(err.response.data));
           this.log.info(
             util.hasValue(err.response.status)
-              ? `Got response with status ${err.response.status}: ${error}`
-              : `Got response with unknown status: ${error}`,
+              ? `Got response with status ${err.response.status}: %s`
+              : `Got response with unknown status: %s`,
+            error,
           );
         }
       } else {
@@ -311,11 +300,7 @@ export class JWProxy {
   /**
    * Proxies a command identified by its HTTP method and URL to the downstream server.
    */
-  async proxyCommand(
-    url: string,
-    method: HTTPMethod,
-    body: HTTPBody = null,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  async proxyCommand(url: string, method: HTTPMethod, body: HTTPBody = null): Promise<[ProxyResponse, HTTPBody]> {
     const parsedUrl = this._parseUrl(url);
     const normalizedPathname = this._toNormalizedPathname(parsedUrl);
     const commandName = normalizedPathname ? routeToCommandName(normalizedPathname, method) : '';
@@ -355,9 +340,7 @@ export class JWProxy {
         }
         throw errorFromMJSONWPStatusCode(
           status,
-          util.isEmpty(message)
-            ? getSummaryByCode(status)
-            : (message as string | {message: string}),
+          util.isEmpty(message) ? getSummaryByCode(status) : (message as string | {message: string}),
         );
       }
     } else if (protocol === W3C) {
@@ -401,11 +384,7 @@ export class JWProxy {
     let statusCode: number;
     let resBodyObj: HTTPBody;
     try {
-      const [response, body] = await this.proxyCommand(
-        req.originalUrl,
-        req.method as HTTPMethod,
-        req.body,
-      );
+      const [response, body] = await this.proxyCommand(req.originalUrl, req.method as HTTPMethod, req.body);
       statusCode = response.statusCode;
       resBodyObj = body;
     } catch (err: unknown) {
@@ -483,15 +462,8 @@ export class JWProxy {
     // This is needed for the backward compatibility
     // if drivers don't set reqBasePath properly
     if (!this.reqBasePath) {
-      if (
-        match &&
-        match.params &&
-        Array.isArray((match.params as Record<string, unknown>).prefix)
-      ) {
-        pathname = pathname.replace(
-          `/${((match.params as Record<string, unknown>).prefix as string[]).join('/')}`,
-          '',
-        );
+      if (match && match.params && Array.isArray((match.params as Record<string, unknown>).prefix)) {
+        pathname = pathname.replace(`/${((match.params as Record<string, unknown>).prefix as string[]).join('/')}`, '');
       } else if (pathname.startsWith('/wd/hub')) {
         pathname = pathname.replace('/wd/hub', '');
       }

package/lib/jsonwp-status/status.ts

@@ -13,8 +13,7 @@ export const codes = {
   },
   NoSuchFrame: {
     code: 8,
-    summary:
-      'A request to switch to a frame could not be satisfied because the frame could not be found.',
+    summary: 'A request to switch to a frame could not be satisfied because the frame could not be found.',
   },
   UnknownCommand: {
     code: 9,
@@ -23,13 +22,11 @@ export const codes = {
   },
   StaleElementReference: {
     code: 10,
-    summary:
-      'An element command failed because the referenced element is no longer attached to the DOM.',
+    summary: 'An element command failed because the referenced element is no longer attached to the DOM.',
   },
   ElementNotVisible: {
     code: 11,
-    summary:
-      'An element command could not be completed because the element is not visible on the page.',
+    summary: 'An element command could not be completed because the element is not visible on the page.',
   },
   InvalidElementState: {
     code: 12,
@@ -58,13 +55,11 @@ export const codes = {
   },
   NoSuchWindow: {
     code: 23,
-    summary:
-      'A request to switch to a different window could not be satisfied because the window could not be found.',
+    summary: 'A request to switch to a different window could not be satisfied because the window could not be found.',
   },
   InvalidCookieDomain: {
     code: 24,
-    summary:
-      'An illegal attempt was made to set a cookie under a different domain than the current page.',
+    summary: 'An illegal attempt was made to set a cookie under a different domain than the current page.',
   },
   UnableToSetCookie: {
     code: 25,

package/lib/protocol/errors.ts

@@ -1,6 +1,6 @@
-import {util, logger} from '@appium/support';
+import {logger, util} from '@appium/support';
+import type {Class, ErrorBiDiCommandResponse} from '@appium/types';
 import {StatusCodes as HTTPStatusCodes} from 'http-status-codes';
-import type {ErrorBiDiCommandResponse, Class} from '@appium/types';
 
 const mjsonwpLog = logger.getLogger('MJSONWP');
 const w3cLog = logger.getLogger('W3C');
@@ -45,13 +45,7 @@ export class ProtocolError extends BaseError {
   public w3cStatus: number;
   protected _stacktrace: string | undefined;
 
-  constructor(
-    msg: string,
-    jsonwpCode: number,
-    w3cStatus: number,
-    w3cErrorSignature: string,
-    cause?: Error,
-  ) {
+  constructor(msg: string, jsonwpCode: number, w3cStatus: number, w3cErrorSignature: string, cause?: Error) {
     super(msg, cause);
     this.jsonwpCode = jsonwpCode ?? UnknownError.code();
     this.error = w3cErrorSignature ?? UnknownError.error();
@@ -117,8 +111,7 @@ export class NoSuchDriverError extends ProtocolError {
 export class NoSuchElementError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'An element could not be located on the page using the given ' + 'search parameters.',
+      message || 'An element could not be located on the page using the given ' + 'search parameters.',
       NoSuchElementError.code(),
       NoSuchElementError.w3cStatus(),
       NoSuchElementError.error(),
@@ -171,9 +164,7 @@ export class NoSuchShadowRootError extends ProtocolError {
 export class NoSuchFrameError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'A request to switch to a frame could not be satisfied because ' +
-          'the frame could not be found.',
+      message || 'A request to switch to a frame could not be satisfied because ' + 'the frame could not be found.',
       NoSuchFrameError.code(),
       NoSuchFrameError.w3cStatus(),
       NoSuchFrameError.error(),
@@ -220,9 +211,7 @@ export class UnknownCommandError extends ProtocolError {
 export class StaleElementReferenceError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'An element command failed because the referenced element is no ' +
-          'longer attached to the DOM.',
+      message || 'An element command failed because the referenced element is no ' + 'longer attached to the DOM.',
       StaleElementReferenceError.code(),
       StaleElementReferenceError.w3cStatus(),
       StaleElementReferenceError.error(),
@@ -244,9 +233,7 @@ export class StaleElementReferenceError extends ProtocolError {
 export class ElementNotVisibleError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'An element command could not be completed because the element is ' +
-          'not visible on the page.',
+      message || 'An element command could not be completed because the element is ' + 'not visible on the page.',
       ElementNotVisibleError.code(),
       ElementNotVisibleError.w3cStatus(),
       ElementNotVisibleError.error(),
@@ -314,8 +301,7 @@ export class UnknownError extends ProtocolError {
 export class UnknownMethodError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'The requested command matched a known URL but did not match an method for that URL',
+      message || 'The requested command matched a known URL but did not match an method for that URL',
       UnknownMethodError.code(),
       UnknownMethodError.w3cStatus(),
       UnknownMethodError.error(),
@@ -405,8 +391,7 @@ export class ElementClickInterceptedError extends ProtocolError {
 export class ElementNotInteractableError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'A command could not be completed because the element is not pointer- or keyboard interactable',
+      message || 'A command could not be completed because the element is not pointer- or keyboard interactable',
       ElementNotInteractableError.code(),
       ElementNotInteractableError.w3cStatus(),
       ElementNotInteractableError.error(),
@@ -515,8 +500,7 @@ export class NoSuchWindowError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
       message ||
-        'A request to switch to a different window could not be satisfied ' +
-          'because the window could not be found.',
+        'A request to switch to a different window could not be satisfied ' + 'because the window could not be found.',
       NoSuchWindowError.code(),
       NoSuchWindowError.w3cStatus(),
       NoSuchWindowError.error(),
@@ -560,9 +544,7 @@ export class InvalidArgumentError extends ProtocolError {
 export class InvalidCookieDomainError extends ProtocolError {
   constructor(message: string = '', cause?: Error) {
     super(
-      message ||
-        'An illegal attempt was made to set a cookie under a different ' +
-          'domain than the current page.',
+      message || 'An illegal attempt was made to set a cookie under a different ' + 'domain than the current page.',
       InvalidCookieDomainError.code(),
       InvalidCookieDomainError.w3cStatus(),
       InvalidCookieDomainError.error(),
@@ -913,20 +895,14 @@ export class ProxyRequestError extends BaseError {
   private readonly _jwpError?: MJSONWPError;
 
   constructor(message: string, httpResponseData: any, httpStatus?: number, cause?: Error) {
-    const [responseErrorObj, originalMessage] =
-      ProxyRequestError._parseHttpResponse(httpResponseData);
+    const [responseErrorObj, originalMessage] = ProxyRequestError._parseHttpResponse(httpResponseData);
     super(
-      util.isEmpty(message)
-        ? `Proxy request unsuccessful.${originalMessage ? ' ' + originalMessage : ''}`
-        : message,
+      util.isEmpty(message) ? `Proxy request unsuccessful.${originalMessage ? ' ' + originalMessage : ''}` : message,
       cause,
     );
 
     // If the response error is an object and value is an object, it's a W3C error (for JSONWP value is a string)
-    if (
-      util.isPlainObject(responseErrorObj.value) &&
-      Object.hasOwn(responseErrorObj.value, 'error')
-    ) {
+    if (util.isPlainObject(responseErrorObj.value) && Object.hasOwn(responseErrorObj.value, 'error')) {
       this._w3cError = responseErrorObj.value as unknown as typeof this._w3cError;
       this._w3cErrorStatus = httpStatus;
     } else if (Object.hasOwn(responseErrorObj, 'status')) {
@@ -953,11 +929,7 @@ export class ProxyRequestError extends BaseError {
       // If it's MJSONWP error, returns actual error cause for request failure based on `jsonwp.status`
       return errorFromMJSONWPStatusCode(this._jwpError.status, this._jwpError.value);
     }
-    if (
-      util.hasValue(this._w3cError) &&
-      typeof this._w3cErrorStatus === 'number' &&
-      this._w3cErrorStatus >= 300
-    ) {
+    if (util.hasValue(this._w3cError) && typeof this._w3cErrorStatus === 'number' && this._w3cErrorStatus >= 300) {
       return errorFromW3CJsonCode(
         this._w3cError.error,
         this._w3cError.message || this.message,
@@ -968,10 +940,7 @@ export class ProxyRequestError extends BaseError {
   }
 }
 
-function generateBadParametersMessage(
-  paramRequirements: ParameterRequirements,
-  paramNames: string[],
-): string {
+function generateBadParametersMessage(paramRequirements: ParameterRequirements, paramNames: string[]): string {
   const toArray = function <T>(x: T | T[]): T[] {
     if (x === undefined) {
       return [];
@@ -984,17 +953,15 @@ function generateBadParametersMessage(
 
   const requiredParamNames = toArray(paramRequirements.required);
   const actualParamNames = toArray(paramNames);
-  const missingRequiredParamNames = requiredParamNames.filter(
-    (name) => !actualParamNames.includes(name),
-  );
+  const missingRequiredParamNames = requiredParamNames.filter((name) => !actualParamNames.includes(name));
   const resultLines: string[] = [];
   resultLines.push(
     util.isEmpty(missingRequiredParamNames)
       ? // This should not happen
         'Some of the provided parameters are not known'
-      : `The following required parameter${
-          missingRequiredParamNames.length === 1 ? ' is' : 's are'
-        } missing: ${JSON.stringify(missingRequiredParamNames)}`,
+      : `The following required parameter${missingRequiredParamNames.length === 1 ? ' is' : 's are'} missing: ${JSON.stringify(
+          missingRequiredParamNames,
+        )}`,
   );
   if (!util.isEmpty(requiredParamNames)) {
     resultLines.push(`Known required parameters are: ${JSON.stringify(requiredParamNames)}`);
@@ -1005,11 +972,7 @@ function generateBadParametersMessage(
   if (!util.isEmpty(optionalParamNames)) {
     resultLines.push(`Known optional parameters are: ${JSON.stringify(optionalParamNames)}`);
   }
-  resultLines.push(
-    `You have provided${
-      util.isEmpty(actualParamNames) ? ' none' : ': ' + JSON.stringify(paramNames)
-    }`,
-  );
+  resultLines.push(`You have provided${util.isEmpty(actualParamNames) ? ' none' : ': ' + JSON.stringify(paramNames)}`);
   return resultLines.join('\n');
 }
 
@@ -1107,10 +1070,7 @@ export function isErrorType<T>(err: any, type: Class<T>): err is T {
  * @param value The error message, or an object with a `message` property
  * @return The error that is associated with provided JSONWP status code
  */
-export function errorFromMJSONWPStatusCode(
-  code: number,
-  value: string | {message: string} = '',
-): ProtocolError {
+export function errorFromMJSONWPStatusCode(code: number, value: string | {message: string} = ''): ProtocolError {
   const ErrorClass = jsonwpErrorCodeMap[code] ?? UnknownError;
   mjsonwpLog.debug(`Matched JSONWP error code ${code} to ${ErrorClass.name}`);
   // if `value` is an object, pull message from it, otherwise use the plain
@@ -1126,11 +1086,7 @@ export function errorFromMJSONWPStatusCode(
  * @param stacktrace an optional error stacktrace
  * @return The error that is associated with the W3C error string
  */
-export function errorFromW3CJsonCode(
-  signature: string,
-  message: string,
-  stacktrace?: string,
-): ProtocolError {
+export function errorFromW3CJsonCode(signature: string, message: string, stacktrace?: string): ProtocolError {
   const ErrorClass = w3cErrorCodeMap[signature.toLowerCase()] ?? UnknownError;
   w3cLog.debug(`Matched W3C error code '${signature}' to ${ErrorClass.name}`);
   const resultError = new ErrorClass(message);
@@ -1144,9 +1100,7 @@ export function errorFromW3CJsonCode(
  * @param err The error that needs to be translated
  */
 export function getResponseForW3CError(err: any): [number, {value: W3CError}] {
-  const protocolErrorToResponse: (e: ProtocolError) => [number, {value: W3CError}] = (
-    e: ProtocolError,
-  ) => [
+  const protocolErrorToResponse: (e: ProtocolError) => [number, {value: W3CError}] = (e: ProtocolError) => [
     e.w3cStatus,
     {
       value: {

package/lib/protocol/helpers.ts

@@ -1,4 +1,5 @@
 import {util} from '@appium/support';
+
 import {duplicateKeys} from '../basedriver/helpers';
 import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY} from '../constants';
 

package/lib/protocol/index.ts

@@ -1,44 +1,38 @@
+import {errorFromMJSONWPStatusCode, errorFromW3CJsonCode, errors, getResponseForW3CError, isErrorType} from './errors';
 import {
-  isSessionCommand,
-  routeConfiguringFunction,
-  determineProtocol,
+  checkParams,
   CREATE_SESSION_COMMAND,
   DELETE_SESSION_COMMAND,
+  determineProtocol,
   GET_STATUS_COMMAND,
+  isSessionCommand,
   LIST_DRIVER_COMMANDS_COMMAND,
   LIST_DRIVER_EXTENSIONS_COMMAND,
   makeArgs,
-  checkParams,
+  routeConfiguringFunction,
   validateExecuteMethodParams,
 } from './protocol';
-import {NO_SESSION_ID_COMMANDS, ALL_COMMANDS, METHOD_MAP, routeToCommandName} from './routes';
-import {
-  errors,
-  isErrorType,
-  errorFromMJSONWPStatusCode,
-  errorFromW3CJsonCode,
-  getResponseForW3CError,
-} from './errors';
+import {ALL_COMMANDS, METHOD_MAP, NO_SESSION_ID_COMMANDS, routeToCommandName} from './routes';
 
 export {
-  routeConfiguringFunction,
-  errors,
-  isErrorType,
-  makeArgs,
-  checkParams,
-  validateExecuteMethodParams,
-  errorFromMJSONWPStatusCode,
-  errorFromW3CJsonCode,
   ALL_COMMANDS,
-  METHOD_MAP,
-  routeToCommandName,
-  NO_SESSION_ID_COMMANDS,
-  isSessionCommand,
-  determineProtocol,
+  checkParams,
   CREATE_SESSION_COMMAND,
   DELETE_SESSION_COMMAND,
+  determineProtocol,
+  errorFromMJSONWPStatusCode,
+  errorFromW3CJsonCode,
+  errors,
   GET_STATUS_COMMAND,
+  getResponseForW3CError,
+  isErrorType,
+  isSessionCommand,
   LIST_DRIVER_COMMANDS_COMMAND,
   LIST_DRIVER_EXTENSIONS_COMMAND,
-  getResponseForW3CError,
+  makeArgs,
+  METHOD_MAP,
+  NO_SESSION_ID_COMMANDS,
+  routeConfiguringFunction,
+  routeToCommandName,
+  validateExecuteMethodParams,
 };