@appium/base-driver 10.6.0 → 10.7.1

package/lib/basedriver/ipc.ts

@@ -1,5 +1,13 @@
 import {log} from './logger';
-import type {StringRecord, IIpcSubscription, IAppiumIpc, IpcMessage, IpcEvent, AppiumLogger, IpcData} from '@appium/types';
+import type {
+  StringRecord,
+  IIpcSubscription,
+  IAppiumIpc,
+  IpcMessage,
+  IpcEvent,
+  AppiumLogger,
+  IpcData,
+} from '@appium/types';
 import EventEmitter from 'node:events';
 import {sleep} from 'asyncbox';
 import {node} from '@appium/support';
@@ -18,12 +26,14 @@ export type AppiumIpcOpts = {
 
 const ASYNC_ITERATOR_STOP = Symbol('asyncIteratorStop');
 
-export class IpcSubscription<T extends IpcData> extends EventEmitter<IpcEvent<T>> implements IIpcSubscription<T> {
-
+export class IpcSubscription<T extends IpcData>
+  extends EventEmitter<IpcEvent<T>>
+  implements IIpcSubscription<T>
+{
   constructor(
     public readonly subscriber: string,
     public readonly topic: string,
-    private readonly ipc: AppiumIpc
+    private readonly ipc: AppiumIpc,
   ) {
     super();
   }
@@ -87,18 +97,22 @@ export class AppiumIpc implements IAppiumIpc {
   protected readonly maxTopics: number;
   protected readonly log: AppiumLogger;
 
-  constructor (opts: AppiumIpcOpts = {}) {
+  constructor(opts: AppiumIpcOpts = {}) {
     this.maxObjSize = opts.maxObjSize ?? DEF_MAX_OBJ_SIZE_BYTES;
     this.maxTopics = opts.maxTopics ?? DEF_MAX_TOPICS;
     this.log = opts.log ?? log;
-    this.log.debug(`Initialized new IPC object with max object size of ${this.maxObjSize} bytes ` +
-      `and max topics of ${this.maxTopics}`);
+    this.log.debug(
+      `Initialized new IPC object with max object size of ${this.maxObjSize} bytes ` +
+        `and max topics of ${this.maxTopics}`,
+    );
   }
 
   subscribe<T extends IpcData>(topic: string, subscriber: string): IpcSubscription<T> {
     this.log.info(`Subscribing ${subscriber} to topic '${topic}'`);
     if (this.subscriptionExists(topic, subscriber)) {
-      throw new Error(`Subscription already exists for topic "${topic}" and subscriber "${subscriber}"`);
+      throw new Error(
+        `Subscription already exists for topic "${topic}" and subscriber "${subscriber}"`,
+      );
     }
 
     this.ensureTopic(topic);
@@ -124,24 +138,28 @@ export class AppiumIpc implements IAppiumIpc {
 
     const messageSize = node.getObjectSize(data);
     if (messageSize > this.maxObjSize) {
-      throw new Error(`Error when ${publisher} is publishing to topic '${topic}': ` +
-                      `Message with size ${messageSize} bytes is bigger than max size of ${this.maxObjSize} bytes`);
+      throw new Error(
+        `Error when ${publisher} is publishing to topic '${topic}': ` +
+          `Message with size ${messageSize} bytes is bigger than max size of ${this.maxObjSize} bytes`,
+      );
     }
 
     let clonedData: T;
     try {
       clonedData = structuredClone(data);
     } catch (e) {
-      throw new Error(`Could not clone data for IPC publish from ${publisher} on topic ${topic}`, {cause: e});
+      throw new Error(`Could not clone data for IPC publish from ${publisher} on topic ${topic}`, {
+        cause: e,
+      });
     }
 
     const message: IpcMessage<T> = {publisher, data: clonedData, topic, timestampMs: Date.now()};
 
     this.messageByTopic[topic] = message;
 
-    const subs = this.subs[topic] ?
-      this.subs[topic].filter((sub) => sub.subscriber !== publisher) :
-      [];
+    const subs = this.subs[topic]
+      ? this.subs[topic].filter((sub) => sub.subscriber !== publisher)
+      : [];
 
     for (const sub of subs) {
       sub.emit(EVT_MESSAGE, structuredClone(message));
@@ -150,7 +168,6 @@ export class AppiumIpc implements IAppiumIpc {
     // we don't want to return from publish until the async iterators on subscriptions have had
     // a chance to observe the emitted value, otherwise some might get lost
     await sleep(0);
-
   }
 
   getMessage<T extends IpcData>(topic: string): IpcMessage<T> | undefined {
@@ -170,9 +187,11 @@ export class AppiumIpc implements IAppiumIpc {
       return;
     }
     if (this.topics.size >= this.maxTopics) {
-      throw new Error(`Cannot create new IPC topic '${topic}': ` +
-        `maximum of ${this.maxTopics} topics per session reached. ` +
-        `Adjust with the --max-ipc-topics server arg.`);
+      throw new Error(
+        `Cannot create new IPC topic '${topic}': ` +
+          `maximum of ${this.maxTopics} topics per session reached. ` +
+          `Adjust with the --max-ipc-topics server arg.`,
+      );
     }
     this.topics.add(topic);
   }

package/lib/basedriver/validation.ts

@@ -77,7 +77,7 @@ export class Validator {
       if (value !== undefined && options) {
         log.warn(
           `The '${key}' capability has been deprecated and must not be used anymore. ` +
-          `Please check the driver documentation for possible alternatives.`
+            `Please check the driver documentation for possible alternatives.`,
         );
       }
       return null;
@@ -108,15 +108,19 @@ export class Validator {
       }
       if (
         !options?.allowEmpty &&
-        ((value !== undefined && util.isEmpty(value)) || (typeof value === 'string' && !value.trim()))
+        ((value !== undefined && util.isEmpty(value)) ||
+          (typeof value === 'string' && !value.trim()))
       ) {
         return 'must not be empty or blank';
       }
       return null;
-    }
+    },
   };
 
-  validate(values: Record<string, any>, constraints: Record<string, Constraint>): Record<string, string[]> | null {
+  validate(
+    values: Record<string, any>,
+    constraints: Record<string, Constraint>,
+  ): Record<string, string[]> | null {
     const result: Record<string, string[]> = {};
     for (const [key, constraint] of Object.entries(constraints)) {
       const value = values[key];
@@ -125,7 +129,11 @@ export class Validator {
           continue;
         }
 
-        const validationError = this._validators[validatorName as keyof Constraint](value, options, key);
+        const validationError = this._validators[validatorName as keyof Constraint](
+          value,
+          options,
+          key,
+        );
         if (validationError == null) {
           continue;
         }
@@ -139,7 +147,6 @@ export class Validator {
     }
     return util.isEmpty(result) ? null : result;
   }
-
 }
 
 export const validator = new Validator();

package/lib/express/express-logging.ts

@@ -1,5 +1,4 @@
-import {util, logger} from '@appium/support';
-import '@colors/colors';
+import {console, logger, util} from '@appium/support';
 import morgan from 'morgan';
 import type {Request, RequestHandler, Response} from 'express';
 import {log} from './logger';
@@ -23,17 +22,18 @@ export const startLogFormatter: RequestHandler = morgan(startLogFormatterHandler
 type MorganTokens = unknown;
 type FormatFn = (tokens: MorganTokens, req: Request, res: Response) => string;
 
-function endLogFormatterHandler(tokens: MorganTokens, req: Request, res: Response): void {
+function endLogFormatterHandler(tokens: MorganTokens, req: Request, res: Response): undefined {
   log.info(requestEndLoggingFormat(tokens, req, res));
+  return undefined;
 }
 
-function startLogFormatterHandler(tokens: unknown, req: Request, res: Response): void {
+function startLogFormatterHandler(tokens: unknown, req: Request, res: Response): undefined {
   let reqBody = '';
   if (req.body) {
     try {
       reqBody = util.truncateString(
         typeof req.body === 'string' ? req.body : JSON.stringify(req.body),
-        {length: MAX_LOG_BODY_LENGTH}
+        {length: MAX_LOG_BODY_LENGTH},
       );
     } catch {
       // ignore
@@ -41,8 +41,9 @@ function startLogFormatterHandler(tokens: unknown, req: Request, res: Response):
   }
   log.info(
     requestStartLoggingFormat(tokens, req, res),
-    logger.markSensitive(reqBody.grey)
+    logger.markSensitive(console.styleText('grey', reqBody)),
   );
+  return undefined;
 }
 
 // Copied the morgan compile function over so that cooler formats may be configured
@@ -55,29 +56,25 @@ function compile(fmt: string): FormatFn {
   return new Function('tokens', 'req', 'res', js) as FormatFn;
 }
 
-function requestEndLoggingFormat(
-  tokens: MorganTokens,
-  req: Request,
-  res: Response
-): string {
+function requestEndLoggingFormat(tokens: MorganTokens, req: Request, res: Response): string {
   const status = res.statusCode;
   let statusStr = ':status';
   if (status >= 500) {
-    statusStr = statusStr.red;
+    statusStr = console.styleText('red', statusStr);
   } else if (status >= 400) {
-    statusStr = statusStr.yellow;
+    statusStr = console.styleText('yellow', statusStr);
   } else if (status >= 300) {
-    statusStr = statusStr.cyan;
+    statusStr = console.styleText('cyan', statusStr);
   } else {
-    statusStr = statusStr.green;
+    statusStr = console.styleText('green', statusStr);
   }
   const fn = compile(
-    `${'<-- :method :url '.white}${statusStr} ${':response-time ms - :res[content-length]'.grey}`
+    `${console.styleText('white', '<-- :method :url ')}${statusStr} ${console.styleText('grey', ':response-time ms - :res[content-length]')}`,
   );
   return fn(tokens, req, res);
 }
 
 const requestStartLoggingFormat = compile(
-  `${'-->'.white} ${':method'.white} ${':url'.white}`
+  `${console.styleText('white', '-->')} ${console.styleText('white', ':method')} ${console.styleText('white', ':url')}`,
 );
 // #endregion

package/lib/express/idempotency.ts

@@ -31,7 +31,7 @@ const MAX_CACHED_PAYLOAD_SIZE_BYTES = 1 * 1024 * 1024; // 1 MiB
 export async function handleIdempotency(
   req: Request,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): Promise<void> {
   const keyOrArr = req.headers[IDEMPOTENCY_KEY_HEADER];
   if (util.isEmpty(keyOrArr) || !keyOrArr) {
@@ -114,7 +114,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
   const patchedWriter = (
     chunk: unknown,
     encoding: BufferEncoding | (() => void),
-    next?: (() => void) | ((err?: Error) => void)
+    next?: (() => void) | ((err?: Error) => void),
   ): boolean => {
     if (errorMessage || !responseRef.deref()) {
       responseChunks = [];
@@ -122,7 +122,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
       return originalSocketWriter(
         chunk as string | Buffer | Uint8Array,
         encoding as BufferEncoding,
-        next as (err?: Error) => void
+        next as (err?: Error | null) => void,
       );
     }
 
@@ -139,7 +139,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     return originalSocketWriter(
       chunk as string | Buffer | Uint8Array,
       encoding as BufferEncoding,
-      next as (err?: Error) => void
+      next as (err?: Error | null) => void,
     );
   };
   socket.write = patchedWriter as typeof socket.write;
@@ -153,7 +153,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     if (!IDEMPOTENT_RESPONSES.has(key)) {
       log.info(
         `Could not cache the response identified by '${key}'. ` +
-          `Cache consistency has been damaged`
+          `Cache consistency has been damaged`,
       );
     } else {
       log.info(`Could not cache the response identified by '${key}': ${errorMessage}`);
@@ -175,7 +175,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     if (!IDEMPOTENT_RESPONSES.has(key)) {
       log.info(
         `Could not cache the response identified by '${key}'. ` +
-          `Cache consistency has been damaged`
+          `Cache consistency has been damaged`,
       );
     } else if (errorMessage) {
       log.info(`Could not cache the response identified by '${key}': ${errorMessage}`);

package/lib/express/middleware.ts

@@ -21,7 +21,7 @@ export function allowCrossDomain(req: Request, res: Response, next: NextFunction
   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'
+    'Cache-Control, Pragma, Origin, X-Requested-With, Content-Type, Accept, User-Agent',
   );
 
   if (req.method === 'OPTIONS') {
@@ -42,10 +42,10 @@ export function allowCrossDomainAsyncExecute(basePath: string): RequestHandler {
   function allowCrossDomainAsyncExecuteHandler(
     req: Request,
     res: Response,
-    next: NextFunction
+    next: NextFunction,
   ): void {
     const receiveAsyncResponseRegExp = new RegExp(
-      `${util.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`
+      `${util.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`,
     );
     if (!receiveAsyncResponseRegExp.test(req.url)) {
       next();
@@ -72,9 +72,11 @@ export function handleLogContext(req: Request, _res: Response, next: NextFunctio
     {
       requestId,
       ...sessionInfo,
-      isSensitive: ['true', '1', 'yes'].includes(String(isSensitiveHeaderValue ?? '').toLowerCase()),
+      isSensitive: ['true', '1', 'yes'].includes(
+        String(isSensitiveHeaderValue ?? '').toLowerCase(),
+      ),
     },
-    true
+    true,
   );
 
   next();
@@ -83,11 +85,7 @@ export function handleLogContext(req: Request, _res: Response, next: NextFunctio
 /**
  * Ensures requests default to JSON content-type when none is provided.
  */
-export function defaultToJSONContentType(
-  req: Request,
-  _res: Response,
-  next: NextFunction
-): void {
+export function defaultToJSONContentType(req: Request, _res: Response, next: NextFunction): void {
   if (!req.headers['content-type']) {
     req.headers['content-type'] = 'application/json; charset=utf-8';
   }
@@ -107,7 +105,7 @@ export function tryHandleWebSocketUpgrade(
   req: IncomingMessage,
   socket: Duplex,
   head: Buffer,
-  webSocketsMapping: StringRecord<WSServer>
+  webSocketsMapping: StringRecord<WSServer>,
 ): boolean {
   if (String(req.headers?.upgrade ?? '').toLowerCase() !== 'websocket') {
     return false;
@@ -157,7 +155,7 @@ export function catchAllHandler(
   err: Error,
   _req: Request,
   res: Response,
-  next: NextFunction
+  next: NextFunction,
 ): void {
   if (res.headersSent) {
     next(err);

package/lib/express/server.ts

@@ -1,9 +1,8 @@
-import path from 'node:path';
 import express from 'express';
 import type {Express, RequestHandler} from 'express';
 import http from 'node:http';
 import type {Server as HttpServer} from 'node:http';
-import favicon from 'serve-favicon';
+import {createRequire} from 'node:module';
 import bodyParser from 'body-parser';
 import methodOverride from 'method-override';
 import {log} from './logger';
@@ -19,14 +18,9 @@ import {
   catch404Handler,
   handleLogContext,
 } from './middleware';
-import {
-  guineaPig,
-  guineaPigScrollable,
-  guineaPigAppBanner,
-  welcome,
-  STATIC_DIR,
-} from './static';
-import {produceError, produceCrash} from './crash';
+// Import env helper directly — not from the test-pages barrel — so Express handlers and
+// fixture code stay unloaded unless APPIUM_ENABLE_LEGACY_TEST_PAGES is set.
+import {isLegacyTestPagesEnabled} from '../test-pages/env';
 import {
   addWebSocketHandler,
   removeWebSocketHandler,
@@ -53,10 +47,7 @@ export interface RouteConfiguringFunctionOpts {
 }
 
 /** A function which configures routes */
-export type RouteConfiguringFunction = (
-  app: Express,
-  opts?: RouteConfiguringFunctionOpts
-) => void;
+export type RouteConfiguringFunction = (app: Express, opts?: RouteConfiguringFunctionOpts) => void;
 
 /** Options for {@linkcode server} */
 export interface ServerOpts {
@@ -83,6 +74,12 @@ export interface ConfigureServerOpts {
   useLegacyUpgradeHandler?: boolean;
 }
 
+/** @internal */
+export interface ConfigureServerInternalOpts extends ConfigureServerOpts {
+  /** @deprecated Appium 4 */
+  registerTestPages?: (app: Express, opts: {basePath: string}) => void;
+}
+
 /** Options for {@linkcode configureHttp} */
 export interface ConfigureHttpOpts {
   httpServer: HttpServer;
@@ -134,6 +131,11 @@ export async function server(opts: ServerOpts): Promise<AppiumServer> {
           gracefulShutdownTimeout: cliArgs.shutdownTimeout,
         });
         const useLegacyUpgradeHandler = !hasShouldUpgradeCallback(httpServer);
+        let registerTestPages: ConfigureServerInternalOpts['registerTestPages'];
+        if (isLegacyTestPagesEnabled()) {
+          const require = createRequire(__filename);
+          registerTestPages = require('../test-pages').registerTestPages;
+        }
         configureServer({
           app,
           addRoutes: routeConfiguringFunction,
@@ -142,7 +144,8 @@ export async function server(opts: ServerOpts): Promise<AppiumServer> {
           extraMethodMap,
           webSocketsMapping: appiumServer.webSocketsMapping,
           useLegacyUpgradeHandler,
-        });
+          registerTestPages,
+        } as ConfigureServerInternalOpts);
         // allow extensions to update the app and http server objects
         for (const updater of serverUpdaters) {
           await updater(app, appiumServer, cliArgs);
@@ -174,27 +177,25 @@ export async function server(opts: ServerOpts): Promise<AppiumServer> {
  *
  * @param opts - Configuration options
  */
-export function configureServer({
-  app,
-  addRoutes,
-  allowCors = true,
-  basePath = DEFAULT_BASE_PATH,
-  extraMethodMap = {},
-  webSocketsMapping = {},
-  useLegacyUpgradeHandler = true,
-}: ConfigureServerOpts): void {
-  basePath = normalizeBasePath(basePath);
+export function configureServer(opts: ConfigureServerOpts): void {
+  const {
+    app,
+    addRoutes,
+    allowCors = true,
+    basePath: rawBasePath = DEFAULT_BASE_PATH,
+    extraMethodMap = {},
+    webSocketsMapping = {},
+    useLegacyUpgradeHandler = true,
+  } = opts;
+  const {registerTestPages} = opts as ConfigureServerInternalOpts;
+  const basePath = normalizeBasePath(rawBasePath);
 
   app.use(endLogFormatter);
   app.use(handleLogContext);
 
-  // set up static assets
-  app.use(favicon(path.resolve(STATIC_DIR, 'favicon.ico')));
-  app.use(express.static(STATIC_DIR));
-
-  // crash routes, for testing
-  app.use(`${basePath}/produce_error`, produceError);
-  app.use(`${basePath}/crash`, produceCrash);
+  if (registerTestPages) {
+    registerTestPages(app, {basePath});
+  }
 
   // Only use legacy Express middleware for WebSocket upgrades if shouldUpgradeCallback is not available.
   // When shouldUpgradeCallback is available, upgrades are handled directly on the HTTP server
@@ -220,12 +221,6 @@ export function configureServer({
   app.use(startLogFormatter);
 
   addRoutes(app, {basePath, extraMethodMap});
-
-  // dynamic routes for testing, etc.
-  app.all('/welcome', welcome);
-  app.all('/test/guinea-pig', guineaPig);
-  app.all('/test/guinea-pig-scrollable', guineaPigScrollable);
-  app.all('/test/guinea-pig-app-banner', guineaPigAppBanner);
 }
 
 /**
@@ -251,18 +246,13 @@ export function normalizeBasePath(basePath: string): string {
   return basePath;
 }
 
-async function createServer(
-  app: Express,
-  cliArgs?: Partial<ServerArgs>
-): Promise<HttpServer> {
+async function createServer(app: Express, cliArgs?: Partial<ServerArgs>): Promise<HttpServer> {
   const {sslCertificatePath, sslKeyPath} = cliArgs ?? {};
   if (!sslCertificatePath && !sslKeyPath) {
     return http.createServer(app);
   }
   if (!sslCertificatePath || !sslKeyPath) {
-    throw new Error(
-      `Both certificate path and key path must be provided to enable TLS`
-    );
+    throw new Error(`Both certificate path and key path must be provided to enable TLS`);
   }
 
   const certKey = [sslCertificatePath, sslKeyPath];
@@ -272,20 +262,19 @@ async function createServer(
     [keyExists, 'key', sslKeyPath],
   ]) {
     if (!exists) {
-      throw new Error(
-        `The provided SSL ${desc} at '${p}' does not exist or is not accessible`
-      );
+      throw new Error(`The provided SSL ${desc} at '${p}' does not exist or is not accessible`);
     }
   }
-  const [cert, key] = await Promise.all(
-    certKey.map((p) => fs.readFile(p, 'utf8'))
-  ) as [string, string];
+  const [cert, key] = (await Promise.all(certKey.map((p) => fs.readFile(p, 'utf8')))) as [
+    string,
+    string,
+  ];
   log.debug('Enabling TLS/SPDY on the server using the provided certificate');
 
   const spdy = require('spdy') as {
     createServer: (
       options: {cert: string; key: string; spdy: {plain: boolean; ssl: boolean}},
-      requestListener: RequestHandler
+      requestListener: RequestHandler,
     ) => HttpServer;
   };
   return spdy.createServer(
@@ -297,7 +286,7 @@ async function createServer(
         ssl: true,
       },
     },
-    app
+    app,
   );
 }
 
@@ -329,7 +318,9 @@ function configureHttp({
   // See: https://github.com/nodejs/node/pull/59824
   if (hasShouldUpgradeCallback(httpServer)) {
     // shouldUpgradeCallback only returns a boolean to indicate if the upgrade should proceed
-    (appiumServer as unknown as {shouldUpgradeCallback?: (req: http.IncomingMessage) => boolean}).shouldUpgradeCallback = (req) =>
+    (
+      appiumServer as unknown as {shouldUpgradeCallback?: (req: http.IncomingMessage) => boolean}
+    ).shouldUpgradeCallback = (req) =>
       String(req.headers?.upgrade ?? '').toLowerCase() === 'websocket';
     appiumServer.on('upgrade', (req, socket, head) => {
       if (!tryHandleWebSocketUpgrade(req, socket, head, appiumServer.webSocketsMapping)) {
@@ -340,7 +331,9 @@ function configureHttp({
 
   // http.Server.close() only stops new connections, but we need to wait until
   // all connections are closed and the `close` event is emitted
-  const originalClose = appiumServer.close.bind(appiumServer);
+  const originalClose = appiumServer.close.bind(appiumServer) as (
+    callback?: (err?: Error | null) => void,
+  ) => void;
   appiumServer.close = async () =>
     await new Promise<void>((_resolve, _reject) => {
       log.info('Closing Appium HTTP server');
@@ -350,7 +343,7 @@ function configureHttp({
           log.info(
             `Not all active connections have been closed within ${gracefulShutdownTimeout}ms. ` +
               `This timeout might be customized by the --shutdown-timeout command line ` +
-              `argument. Closing the server anyway.`
+              `argument. Closing the server anyway.`,
           );
         }
         process.exit(process.exitCode ?? 0);
@@ -358,13 +351,13 @@ function configureHttp({
       const onClose = () => {
         log.info(
           `Appium HTTP server has been successfully closed after ` +
-            `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`
+            `${timer.getDuration().asMilliSeconds.toFixed(0)}ms`,
         );
         clearTimeout(onTimeout);
         _resolve();
       };
       httpServer.once('close', onClose);
-      originalClose((err?: Error) => {
+      originalClose((err?: Error | null) => {
         if (err) {
           clearTimeout(onTimeout);
           httpServer.removeListener('close', onClose);
@@ -376,14 +369,13 @@ function configureHttp({
   appiumServer.once('error', (err: NodeJS.ErrnoException) => {
     if (err.code === 'EADDRNOTAVAIL') {
       log.error(
-        'Could not start REST http interface listener. ' +
-          'Requested address is not available.'
+        'Could not start REST http interface listener. ' + 'Requested address is not available.',
       );
     } else {
       log.error(
         'Could not start REST http interface listener. The requested ' +
           'port may already be in use. Please make sure there is no ' +
-          'other instance of this server running already.'
+          'other instance of this server running already.',
       );
     }
     reject(err);

package/lib/express/websocket.ts

@@ -10,7 +10,7 @@ export const DEFAULT_WS_PATHNAME_PREFIX = '/ws';
 export async function addWebSocketHandler(
   this: AppiumServer,
   handlerPathname: string,
-  handlerServer: WSServer
+  handlerServer: WSServer,
 ): Promise<void> {
   this.webSocketsMapping[handlerPathname] = handlerServer;
 }
@@ -21,7 +21,7 @@ export async function addWebSocketHandler(
  */
 export async function getWebSocketHandlers(
   this: AppiumServer,
-  keysFilter: string | null = null
+  keysFilter: string | null = null,
 ): Promise<Record<string, WSServer>> {
   return Object.entries(this.webSocketsMapping).reduce<Record<string, WSServer>>(
     (acc, [pathname, wsServer]) => {
@@ -30,7 +30,7 @@ export async function getWebSocketHandlers(
       }
       return acc;
     },
-    {}
+    {},
   );
 }
 
@@ -40,7 +40,7 @@ export async function getWebSocketHandlers(
  */
 export async function removeWebSocketHandler(
   this: AppiumServer,
-  handlerPathname: string
+  handlerPathname: string,
 ): Promise<boolean> {
   const wsServer = this.webSocketsMapping?.[handlerPathname];
   if (!wsServer) {
@@ -71,9 +71,7 @@ export async function removeAllWebSocketHandlers(this: AppiumServer): Promise<bo
   }
 
   const results = await Promise.all(
-    Object.keys(this.webSocketsMapping).map((pathname) =>
-      this.removeWebSocketHandler(pathname)
-    )
+    Object.keys(this.webSocketsMapping).map((pathname) => this.removeWebSocketHandler(pathname)),
   );
   return results.some(Boolean);
 }