@appium/base-driver 10.2.0 → 10.2.2

package/lib/protocol/protocol.ts

@@ -14,13 +14,13 @@ import B from 'bluebird';
 import {formatResponseValue, ensureW3cResponse} from './helpers';
 import {MAX_LOG_BODY_LENGTH, PROTOCOLS, DEFAULT_BASE_PATH} from '../constants';
 import {isW3cCaps} from '../helpers/capabilities';
-import log from '../basedriver/logger';
-import { generateDriverLogPrefix } from '../basedriver/helpers';
-import type { Core, AppiumLogger, PayloadParams, MethodMap, Driver, DriverMethodDef } from '@appium/types';
-import type { BaseDriver } from '../basedriver/driver';
-import type { Request, Response, Application } from 'express';
-import type { MultidimensionalReadonlyArray } from 'type-fest';
-import type { RouteConfiguringFunction } from '../express/server';
+import {log} from '../basedriver/logger';
+import {generateDriverLogPrefix} from '../basedriver/helpers';
+import type {Core, AppiumLogger, PayloadParams, MethodMap, Driver, DriverMethodDef} from '@appium/types';
+import type {BaseDriver} from '../basedriver/driver';
+import type {Request, Response, Application} from 'express';
+import type {MultidimensionalReadonlyArray} from 'type-fest';
+import type {RouteConfiguringFunction} from '../express/server';
 
 export const CREATE_SESSION_COMMAND = 'createSession';
 export const DELETE_SESSION_COMMAND = 'deleteSession';
@@ -34,6 +34,34 @@ export function determineProtocol(createSessionArgs: any[]): keyof typeof PROTOC
   return _.some(createSessionArgs, isW3cCaps) ? PROTOCOLS.W3C : PROTOCOLS.MJSONWP;
 }
 
+/**
+ * Extract and validate the sessionId from the Express route parameter.
+ * Express may return route params as string | string[] | undefined.
+ * Appium uses standard routes (e.g., /session/:sessionId) which should always be strings.
+ * Only `*` such as `/session/*sessionId` can return `string[]`.
+ * Then, this method will return the first element as the session id.
+ * It may break existing appium routing handling also, thus this method will log
+ * received parameters as well to help debugging.
+ * @param driver Running driver
+ * @param req The request in Express
+ * @returns The normalized sessionId (string or undefined)
+ */
+export function getSessionId(driver: Core<any>, req: Request): string | undefined {
+  if (Array.isArray(req.params.sessionId)) {
+    const sessionId = req.params.sessionId[0];
+    getLogger(driver, sessionId).warn(
+      `Received malformed sessionId as array from the route: ${req.originalUrl}. ` +
+      `This indicates the route definition issue. The route should start with '/session/:sessionId' (named parameter) ` +
+      `instead of '/session/*sessionId' (wildcard). ` +
+      `Using the first element as session id: ${sessionId}. ` +
+      `Please fix the route definition to prevent this error.`
+    );
+    // This is to not log the message multiple times.
+    req.params.sessionId = sessionId;
+    return sessionId;
+  }
+  return req.params.sessionId;
+}
 
 function extractProtocol(driver: Core<any>, sessionId: string | null = null): keyof typeof PROTOCOLS {
   const dstDriver = _.isFunction(driver.driverForSession) && sessionId
@@ -310,13 +338,14 @@ function buildHandler(
     let httpResBody = {} as any;
     let httpStatus = 200;
     let newSessionId: string | undefined;
-    let currentProtocol = extractProtocol(driver, req.params.sessionId);
+    const sessionId = getSessionId(driver, req);
+    let currentProtocol = extractProtocol(driver, sessionId);
 
     try {
       // if the route accessed is deprecated, log a warning
       if (spec.deprecated && spec.command && !deprecatedCommandsLogged.has(spec.command)) {
         deprecatedCommandsLogged.add(spec.command);
-        getLogger(driver, req.params.sessionId).warn(
+        getLogger(driver, sessionId).warn(
           `The ${method} ${path} endpoint has been deprecated and will be removed in a future ` +
             `version of Appium or your driver/plugin. Please use a different endpoint or contact the ` +
             `driver/plugin author to add explicit support for the endpoint before it is removed`
@@ -325,7 +354,7 @@ function buildHandler(
 
       // if this is a session command but we don't have a session,
       // error out early (especially before proxying)
-      if (isSessCmd && !driver.sessionExists(req.params.sessionId)) {
+      if (isSessCmd && !driver.sessionExists(sessionId)) {
         throw new errors.NoSuchDriverError();
       }
 
@@ -341,12 +370,12 @@ function buildHandler(
       if (isSessCmd && !spec.neverProxy && spec.command && driverShouldDoJwpProxy(driver, req, spec.command)) {
         if (
           !('pluginsToHandleCmd' in driver) || !_.isFunction(driver.pluginsToHandleCmd) ||
-          driver.pluginsToHandleCmd(spec.command, req.params.sessionId).length === 0
+          driver.pluginsToHandleCmd(spec.command, sessionId).length === 0
         ) {
           await doJwpProxy(driver as BaseDriver<any>, req, res);
           return;
         }
-        getLogger(driver, req.params.sessionId).debug(
+        getLogger(driver, sessionId).debug(
           `Would have proxied ` +
             `command directly, but a plugin exists which might require its value, so will let ` +
             `its value be collected internally and made part of plugin chain`
@@ -393,7 +422,7 @@ function buildHandler(
       }
 
       // run the driver command wrapped inside the argument validators
-      getLogger(driver, req.params.sessionId).debug(
+      getLogger(driver, sessionId).debug(
         `Calling %s.%s() with args: %s`,
         driver.constructor.name, spec.command,
         logger.markSensitive(_.truncate(JSON.stringify(args), {length: MAX_LOG_BODY_LENGTH}))
@@ -409,7 +438,7 @@ function buildHandler(
       driverRes = await (driver as BaseDriver<any>).executeCommand(spec.command, ...args);
 
       // Get the protocol after executeCommand
-      currentProtocol = extractProtocol(driver, req.params.sessionId) || currentProtocol;
+      currentProtocol = extractProtocol(driver, sessionId) || currentProtocol;
 
       // If `executeCommand` was overridden and the method returns an object
       // with a protocol and value/error property, re-assign the protocol
@@ -440,12 +469,12 @@ function buildHandler(
 
       // delete should not return anything even if successful
       if (spec.command === DELETE_SESSION_COMMAND) {
-        getLogger(driver, req.params.sessionId).debug(
+        getLogger(driver, sessionId).debug(
           `Received response: ${_.truncate(JSON.stringify(driverRes), {
             length: MAX_LOG_BODY_LENGTH,
           })}`
         );
-        getLogger(driver, req.params.sessionId).debug('But deleting session, so not returning');
+        getLogger(driver, sessionId).debug('But deleting session, so not returning');
         driverRes = null;
       }
 
@@ -467,7 +496,7 @@ function buildHandler(
       }
 
       httpResBody.value = driverRes;
-      getLogger(driver, req.params.sessionId || newSessionId).debug(
+      getLogger(driver, sessionId || newSessionId).debug(
         `Responding ` +
           `to client with driver.${spec.command}() result: ${_.truncate(JSON.stringify(driverRes), {
             length: MAX_LOG_BODY_LENGTH,
@@ -480,7 +509,7 @@ function buildHandler(
       if (err instanceof Error || (_.has(err, 'stack') && _.has(err, 'message'))) {
         actualErr = err;
       } else {
-        getLogger(driver, req.params.sessionId || newSessionId).warn(
+        getLogger(driver, sessionId || newSessionId).warn(
           'The thrown error object does not seem to be a valid instance of the Error class. This ' +
             'might be a genuine bug of a driver or a plugin.'
         );
@@ -488,7 +517,7 @@ function buildHandler(
       }
 
       currentProtocol =
-        currentProtocol || extractProtocol(driver, req.params.sessionId || newSessionId);
+        currentProtocol || extractProtocol(driver, sessionId || newSessionId);
 
       let errMsg = err.stacktrace || err.stack;
       if (!_.includes(errMsg, err.message)) {
@@ -499,7 +528,7 @@ function buildHandler(
       if (isErrorType(err, errors.ProxyRequestError)) {
         actualErr = err.getActualError();
       } else {
-        getLogger(driver, req.params.sessionId || newSessionId).debug(
+        getLogger(driver, sessionId || newSessionId).debug(
           `Encountered internal error running command: ${errMsg}`
         );
       }
@@ -525,9 +554,10 @@ function buildHandler(
   });
 }
 
-export function driverShouldDoJwpProxy(driver: Core<any>, req: import('express').Request, command: string): boolean {
+export function driverShouldDoJwpProxy(driver: Core<any>, req: Request, command: string): boolean {
+  const sessionId = getSessionId(driver, req);
   // drivers need to explicitly say when the proxy is active
-  if (!driver.proxyActive(req.params.sessionId)) {
+  if (!driver.proxyActive(sessionId)) {
     return false;
   }
 
@@ -539,7 +569,7 @@ export function driverShouldDoJwpProxy(driver: Core<any>, req: import('express')
 
   // validate avoidance schema, and say we shouldn't proxy if anything in the
   // avoid list matches our req
-  if (driver.proxyRouteIsAvoided(req.params.sessionId, req.method, req.originalUrl, req.body)) {
+  if (driver.proxyRouteIsAvoided(sessionId as string, req.method, req.originalUrl, req.body)) {
     return false;
   }
 
@@ -547,16 +577,17 @@ export function driverShouldDoJwpProxy(driver: Core<any>, req: import('express')
 }
 
 async function doJwpProxy(driver: BaseDriver<any>, req: Request, res: Response): Promise<void> {
-  getLogger(driver, req.params.sessionId).info(
+  const sessionId = getSessionId(driver, req) as string;
+  getLogger(driver, sessionId).info(
     'Driver proxy active, passing request on via HTTP proxy'
   );
 
   // check that the inner driver has a proxy function
-  if (!driver.canProxy(req.params.sessionId)) {
+  if (!driver.canProxy(sessionId)) {
     throw new Error('Trying to proxy to a server but the driver is unable to proxy');
   }
   try {
-    await driver.executeCommand('proxyReqRes', req, res, req.params.sessionId);
+    await driver.executeCommand('proxyReqRes', req, res, sessionId);
   } catch (err) {
     if (isErrorType(err, errors.ProxyRequestError)) {
       throw err;

package/lib/protocol/{routes.js → routes.ts}

@@ -1,20 +1,19 @@
+import type {Driver, DriverMethodDef, HTTPMethod, MethodMap} from '@appium/types';
 import _ from 'lodash';
 import {DEFAULT_BASE_PATH} from '../constants';
 import {match} from 'path-to-regexp';
 import {LRUCache} from 'lru-cache';
 
-/** @type {LRUCache<string, string>} */
-const COMMAND_NAMES_CACHE = new LRUCache({
+const COMMAND_NAMES_CACHE = new LRUCache<string, string>({
   max: 1024,
 });
 
 /**
- * define the routes, mapping of HTTP methods to particular driver commands, and
- * any parameters that are expected in a request parameters can be `required` or
- * `optional`
- * @satisfies {import('@appium/types').MethodMap<import('../basedriver/driver').BaseDriver>}
+ * Define the routes: mapping of HTTP methods to particular driver commands, and
+ * any parameters that are expected in a request. Parameters can be `required` or
+ * `optional`.
  */
-export const METHOD_MAP = /** @type {const} */ ({
+export const METHOD_MAP = {
 
   // #region W3C WebDriver
   // https://www.w3.org/TR/webdriver2/
@@ -566,42 +565,40 @@ export const METHOD_MAP = /** @type {const} */ ({
     DELETE: {command: 'deleteVirtualPressureSource'},
   },
   // #endregion
-});
+} as const satisfies MethodMap<Driver>;
 
 // driver command names
 export const ALL_COMMANDS = _.flatMap(_.values(METHOD_MAP).map(_.values))
   .filter((m) => Boolean(m.command))
   .map((m) => m.command);
 
-/**
- *
- * @param {string} endpoint
- * @param {import('@appium/types').HTTPMethod} [method]
- * @param {string} [basePath=DEFAULT_BASE_PATH]
- * @returns {string|undefined}
- */
-export function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PATH) {
-  let normalizedEndpoint = basePath
-    ? endpoint.replace(new RegExp(`^${_.escapeRegExp(basePath)}`), '')
+export function routeToCommandName(
+  endpoint: string,
+  method?: HTTPMethod,
+  basePath?: string
+): string | undefined {
+  const resolvedBasePath = basePath ?? DEFAULT_BASE_PATH;
+  let normalizedEndpoint = resolvedBasePath
+    ? endpoint.replace(new RegExp(`^${_.escapeRegExp(resolvedBasePath)}`), '')
     : endpoint;
   normalizedEndpoint = `${_.startsWith(normalizedEndpoint, '/') ? '' : '/'}${normalizedEndpoint}`;
-  /** @type {string} */
-  let normalizedPathname;
+  let normalizedPathname: string;
   try {
     // we could use any prefix there as we anyway need to only extract the pathname
     normalizedPathname = new URL(`https://appium.io${normalizedEndpoint}`).pathname;
-  } catch (err) {
-    throw new Error(`'${endpoint}' cannot be translated to a command name: ${err.message}`);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`'${endpoint}' cannot be translated to a command name: ${msg}`);
   }
 
-  const normalizedMethod = _.toUpper(method);
+  const normalizedMethod = _.toUpper(method ?? '');
   const cacheKey = toCommandNameCacheKey(normalizedPathname, normalizedMethod);
-  if (COMMAND_NAMES_CACHE.has(cacheKey)) {
-    return COMMAND_NAMES_CACHE.get(cacheKey) || undefined;
+  const cached = COMMAND_NAMES_CACHE.get(cacheKey);
+  if (cached !== undefined) {
+    return cached || undefined;
   }
 
-  /** @type {string[]} */
-  const possiblePathnames = [];
+  const possiblePathnames: string[] = [];
   if (!normalizedPathname.startsWith('/session/')) {
     possiblePathnames.push(`/session/any-session-id${normalizedPathname}`);
   }
@@ -609,12 +606,10 @@ export function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PAT
   for (const [routePath, routeSpec] of _.toPairs(METHOD_MAP)) {
     const routeMatcher = match(routePath);
     if (possiblePathnames.some((pp) => routeMatcher(pp))) {
-      const commandForAnyMethod = () => _.first(
-        (_.keys(routeSpec) ?? []).map((key) => routeSpec[key]?.command)
-      );
-      const commandName = normalizedMethod
-        ? routeSpec?.[normalizedMethod]?.command
-        : commandForAnyMethod();
+      const spec = routeSpec as Record<string, DriverMethodDef<Driver>>;
+      const commandForAnyMethod = () =>
+        _.first(_.keys(spec).map((key) => spec[key]?.command));
+      const commandName = normalizedMethod ? spec[normalizedMethod]?.command : commandForAnyMethod();
       if (commandName) {
         COMMAND_NAMES_CACHE.set(cacheKey, commandName);
         return commandName;
@@ -626,13 +621,7 @@ export function routeToCommandName(endpoint, method, basePath = DEFAULT_BASE_PAT
   COMMAND_NAMES_CACHE.set(cacheKey, '');
 }
 
-/**
- *
- * @param {string} endpoint
- * @param {string} [method]
- * @returns {string}
- */
-function toCommandNameCacheKey(endpoint, method) {
+function toCommandNameCacheKey(endpoint: string, method?: string): string {
   return `${endpoint}:${method ?? ''}`;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appium/base-driver",
-  "version": "10.2.0",
+  "version": "10.2.2",
   "description": "Base driver class for Appium drivers",
   "keywords": [
     "automation",
@@ -39,30 +39,30 @@
   ],
   "scripts": {
     "test": "run-p test:unit test:types",
-    "test:e2e": "mocha --exit --timeout 20s --slow 10s \"./test/e2e/**/*.spec.js\"",
+    "test:e2e": "mocha --exit --timeout 20s --slow 10s \"./test/e2e/**/*.spec.ts\"",
     "test:smoke": "node ./index.js",
-    "test:unit": "mocha \"./test/unit/**/*.spec.js\"",
-    "test:types": "tsd"
+    "test:unit": "mocha \"./test/unit/**/*.spec.ts\"",
+    "test:types": "tsd && tsc -p tsconfig.test.json"
   },
   "dependencies": {
-    "@appium/support": "^7.0.5",
-    "@appium/types": "^1.2.0",
+    "@appium/support": "^7.0.6",
+    "@appium/types": "^1.2.1",
     "@colors/colors": "1.6.0",
     "async-lock": "1.4.1",
-    "asyncbox": "6.0.1",
-    "axios": "1.13.3",
+    "asyncbox": "6.1.0",
+    "axios": "1.13.6",
     "bluebird": "3.7.2",
     "body-parser": "2.2.2",
     "express": "5.2.1",
     "fastest-levenshtein": "1.0.16",
     "http-status-codes": "2.3.0",
     "lodash": "4.17.23",
-    "lru-cache": "11.2.5",
+    "lru-cache": "11.2.6",
     "method-override": "3.0.0",
     "morgan": "1.10.1",
     "path-to-regexp": "8.3.0",
     "serve-favicon": "2.5.1",
-    "type-fest": "5.4.1"
+    "type-fest": "5.4.4"
   },
   "optionalDependencies": {
     "spdy": "4.0.2"
@@ -74,7 +74,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f7b20335eab4022e5cbbb627ec86866a994444f8",
+  "gitHead": "c745352c6500937a4590d1ef6ef19785143a8870",
   "tsd": {
     "directory": "test/types"
   }

package/tsconfig.json

@@ -7,8 +7,10 @@
       "@appium/types": ["../types"],
       "@appium/driver-test-support": ["../driver-test-support"]
     },
-    "checkJs": true
+    "checkJs": true,
+    "types": ["node", "mocha"]
   },
   "include": ["lib"],
+  "exclude": ["build"],
   "references": [{"path": "../support"}, {"path": "../types"}]
 }

package/lib/basedriver/logger.js

@@ -1,4 +0,0 @@
-import {logger} from '@appium/support';
-
-const log = logger.getLogger('BaseDriver');
-export default log;

package/lib/express/crash.js

@@ -1,11 +0,0 @@
-import {errors} from '../protocol';
-
-function produceError() {
-  throw new errors.UnknownCommandError('Produced generic error for testing');
-}
-
-function produceCrash() {
-  throw new Error('We just tried to crash Appium!');
-}
-
-export {produceError, produceCrash};

package/lib/express/express-logging.js

@@ -1,60 +0,0 @@
-import _ from 'lodash';
-import '@colors/colors';
-import morgan from 'morgan';
-import log from './logger';
-import {MAX_LOG_BODY_LENGTH} from '../constants';
-import {logger} from '@appium/support';
-
-// Copied the morgan compile function over so that cooler formats
-// may be configured
-function compile(fmt) {
-  // escape quotes
-  fmt = fmt.replace(/"/g, '\\"');
-  fmt = fmt.replace(/:([-\w]{2,})(?:\[([^\]]+)\])?/g, function replace(_, name, arg) {
-    return `"\n    + (tokens["${name}"](req, res, "${arg}") || "-") + "`;
-  });
-  let js = `  return "${fmt}";`;
-  return new Function('tokens, req, res', js);
-}
-
-function requestEndLoggingFormat(tokens, req, res) {
-  let status = res.statusCode;
-  let statusStr = ':status';
-  if (status >= 500) {
-    statusStr = statusStr.red;
-  } else if (status >= 400) {
-    statusStr = statusStr.yellow;
-  } else if (status >= 300) {
-    statusStr = statusStr.cyan;
-  } else {
-    statusStr = statusStr.green;
-  }
-  let fn = compile(
-    `${'<-- :method :url '.white}${statusStr} ${':response-time ms - :res[content-length]'.grey}`
-  );
-  return fn(tokens, req, res);
-}
-
-const endLogFormatter = morgan((tokens, req, res) => {
-  log.info(requestEndLoggingFormat(tokens, req, res), (res.jsonResp || '').grey);
-});
-
-const requestStartLoggingFormat = compile(`${'-->'.white} ${':method'.white} ${':url'.white}`);
-
-const startLogFormatter = morgan(
-  (tokens, req, res) => {
-    // morgan output is redirected straight to winston
-    let reqBody = '';
-    if (req.body) {
-      try {
-        reqBody = _.truncate(_.isString(req.body) ? req.body : JSON.stringify(req.body), {
-          length: MAX_LOG_BODY_LENGTH,
-        });
-      } catch {}
-    }
-    log.info(requestStartLoggingFormat(tokens, req, res), logger.markSensitive(reqBody.grey));
-  },
-  {immediate: true}
-);
-
-export {endLogFormatter, startLogFormatter};

package/lib/express/logger.js

@@ -1,4 +0,0 @@
-import {logger} from '@appium/support';
-
-const log = logger.getLogger('HTTP');
-export default log;

package/lib/express/middleware.js

@@ -1,171 +0,0 @@
-import _ from 'lodash';
-import log from './logger';
-import {errors} from '../protocol';
-export {handleIdempotency} from './idempotency';
-import {match} from 'path-to-regexp';
-import {util} from '@appium/support';
-import {calcSignature} from '../helpers/session';
-import {getResponseForW3CError} from '../protocol/errors';
-
-const SESSION_ID_PATTERN = /\/session\/([^/]+)/;
-
-/**
- *
- * @param {import('express').Request} req
- * @param {import('express').Response} res
- * @param {import('express').NextFunction} next
- * @returns {any}
- */
-export function allowCrossDomain(req, res, next) {
-  res.header('Access-Control-Allow-Origin', '*');
-  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, OPTIONS, DELETE');
-  res.header(
-    'Access-Control-Allow-Headers',
-    'Cache-Control, Pragma, Origin, X-Requested-With, Content-Type, Accept, User-Agent'
-  );
-
-  // need to respond 200 to OPTIONS
-  if ('OPTIONS' === req.method) {
-    return res.sendStatus(200);
-  }
-  next();
-}
-
-/**
- * @param {string} basePath
- * @returns {import('express').RequestHandler}
- */
-export function allowCrossDomainAsyncExecute(basePath) {
-  return (req, res, next) => {
-    // there are two paths for async responses, so cover both
-    // https://regex101.com/r/txYiEz/1
-    const receiveAsyncResponseRegExp = new RegExp(
-      `${_.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`
-    );
-    if (!receiveAsyncResponseRegExp.test(req.url)) {
-      return next();
-    }
-    allowCrossDomain(req, res, next);
-  };
-}
-
-/**
- *
- * @param {import('express').Request} req
- * @param {import('express').Response} res
- * @param {import('express').NextFunction} next
- * @returns {any}
- */
-export function handleLogContext(req, res, next) {
-  const requestId = fetchHeaderValue(req, 'x-request-id') || util.uuidV4();
-
-  const sessionId = SESSION_ID_PATTERN.exec(req.url)?.[1];
-  const sessionInfo = sessionId ? {sessionId, sessionSignature: calcSignature(sessionId)} : {};
-  const isSensitiveHeaderValue = fetchHeaderValue(req, 'x-appium-is-sensitive');
-
-  log.updateAsyncContext({
-    requestId,
-    ...sessionInfo,
-    isSensitive: ['true', '1', 'yes'].includes(_.toLower(isSensitiveHeaderValue)),
-  }, true);
-
-  return next();
-}
-
-/**
- *
- * @param {import('express').Request} req
- * @param {import('express').Response} res
- * @param {import('express').NextFunction} next
- * @returns {any}
- */
-export function defaultToJSONContentType(req, res, next) {
-  if (!req.headers['content-type']) {
-    req.headers['content-type'] = 'application/json; charset=utf-8';
-  }
-  next();
-}
-
-/**
- * Core function to handle WebSocket upgrade requests by matching the request path
- * against registered WebSocket handlers in the webSocketsMapping.
- *
- * @param {import('http').IncomingMessage} req - The HTTP request
- * @param {import('stream').Duplex} socket - The network socket
- * @param {Buffer} head - The first packet of the upgraded stream
- * @param {import('@appium/types').StringRecord<import('@appium/types').WSServer>} webSocketsMapping - Mapping of paths to WebSocket servers
- * @returns {boolean} - Returns true if the upgrade was handled, false otherwise
- */
-export function tryHandleWebSocketUpgrade(req, socket, head, webSocketsMapping) {
-  if (_.toLower(req.headers?.upgrade) !== 'websocket') {
-    return false;
-  }
-
-  let currentPathname;
-  try {
-    currentPathname = new URL(req.url ?? '', 'http://localhost').pathname;
-  } catch {
-    currentPathname = req.url ?? '';
-  }
-  for (const [pathname, wsServer] of _.toPairs(webSocketsMapping)) {
-    if (match(pathname)(currentPathname)) {
-      wsServer.handleUpgrade(req, socket, head, (ws) => {
-        wsServer.emit('connection', ws, req);
-      });
-      return true;
-    }
-  }
-  log.info(`Did not match the websocket upgrade request at ${currentPathname} to any known route`);
-  return false;
-}
-
-/**
- *
- * @param {import('@appium/types').StringRecord<import('@appium/types').WSServer>} webSocketsMapping
- * @returns {import('express').RequestHandler}
- */
-export function handleUpgrade(webSocketsMapping) {
-  return (req, res, next) => {
-    if (tryHandleWebSocketUpgrade(req, req.socket, Buffer.from(''), webSocketsMapping)) {
-      return;
-    }
-    next();
-  };
-}
-
-/**
- * @param {Error} err
- * @param {import('express').Request} req
- * @param {import('express').Response} res
- * @param {import('express').NextFunction} next
- */
-export function catchAllHandler(err, req, res, next) {
-  if (res.headersSent) {
-    return next(err);
-  }
-
-  log.error(`Uncaught error: ${err.message}`);
-  const [status, body] = getResponseForW3CError(err);
-  res.status(status).json(body);
-}
-
-/**
- * @param {import('express').Request} req
- * @param {import('express').Response} res
- */
-export function catch404Handler(req, res) {
-  log.debug(`No route found for ${req.url}`);
-  const [status, body] = getResponseForW3CError(new errors.UnknownCommandError());
-  res.status(status).json(body);
-}
-
-/**
- * @param {import('express').Request} req
- * @param {string} name
- * @returns {string | undefined}
- */
-function fetchHeaderValue(req, name) {
-  return _.isArray(req.headers[name])
-    ? req.headers[name][0]
-    : req.headers[name];
-}