@appium/base-driver 10.7.0 → 10.7.2

package/lib/express/express-logging.ts

@@ -1,8 +1,9 @@
 import {console, logger, util} from '@appium/support';
-import morgan from 'morgan';
 import type {Request, RequestHandler, Response} from 'express';
-import {log} from './logger';
+import morgan from 'morgan';
+
 import {MAX_LOG_BODY_LENGTH} from '../constants';
+import {log} from './logger';
 
 /**
  * Morgan middleware that logs when the HTTP response finishes.
@@ -31,18 +32,14 @@ function startLogFormatterHandler(tokens: unknown, req: Request, res: Response):
   let reqBody = '';
   if (req.body) {
     try {
-      reqBody = util.truncateString(
-        typeof req.body === 'string' ? req.body : JSON.stringify(req.body),
-        {length: MAX_LOG_BODY_LENGTH},
-      );
+      reqBody = util.truncateString(typeof req.body === 'string' ? req.body : JSON.stringify(req.body), {
+        length: MAX_LOG_BODY_LENGTH,
+      });
     } catch {
       // ignore
     }
   }
-  log.info(
-    requestStartLoggingFormat(tokens, req, res),
-    logger.markSensitive(console.styleText('grey', reqBody)),
-  );
+  log.info(requestStartLoggingFormat(tokens, req, res), logger.markSensitive(console.styleText('grey', reqBody)));
   return undefined;
 }
 
@@ -69,7 +66,10 @@ function requestEndLoggingFormat(tokens: MorganTokens, req: Request, res: Respon
     statusStr = console.styleText('green', statusStr);
   }
   const fn = compile(
-    `${console.styleText('white', '<-- :method :url ')}${statusStr} ${console.styleText('grey', ':response-time ms - :res[content-length]')}`,
+    `${console.styleText('white', '<-- :method :url ')}${statusStr} ${console.styleText(
+      'grey',
+      ':response-time ms - :res[content-length]',
+    )}`,
   );
   return fn(tokens, req, res);
 }

package/lib/express/idempotency.ts

@@ -1,8 +1,10 @@
-import {log} from './logger';
-import {LRUCache} from 'lru-cache';
-import {util} from '@appium/support';
 import {EventEmitter} from 'node:events';
-import type {Request, Response, NextFunction} from 'express';
+
+import {util} from '@appium/support';
+import type {NextFunction, Request, Response} from 'express';
+import {LRUCache} from 'lru-cache';
+
+import {log} from './logger';
 
 interface CachedResponse {
   method: string;
@@ -28,11 +30,7 @@ const MAX_CACHED_PAYLOAD_SIZE_BYTES = 1 * 1024 * 1024; // 1 MiB
  * Middleware that caches and replays responses for idempotent requests using the
  * `x-idempotency-key` header. Only POST and PATCH are cached.
  */
-export async function handleIdempotency(
-  req: Request,
-  res: Response,
-  next: NextFunction,
-): Promise<void> {
+export async function handleIdempotency(req: Request, res: Response, next: NextFunction): Promise<void> {
   const keyOrArr = req.headers[IDEMPOTENCY_KEY_HEADER];
   if (util.isEmpty(keyOrArr) || !keyOrArr) {
     next();
@@ -133,8 +131,7 @@ function cacheResponse(key: string, req: Request, res: Response): void {
     responseSize += buf.length;
     if (responseSize > MAX_CACHED_PAYLOAD_SIZE_BYTES) {
       errorMessage =
-        `The actual response size exceeds ` +
-        `the maximum allowed limit of ${MAX_CACHED_PAYLOAD_SIZE_BYTES} bytes`;
+        `The actual response size exceeds ` + `the maximum allowed limit of ${MAX_CACHED_PAYLOAD_SIZE_BYTES} bytes`;
     }
     return originalSocketWriter(
       chunk as string | Buffer | Uint8Array,
@@ -151,10 +148,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`,
-      );
+      log.info(`Could not cache the response identified by '${key}'. ` + `Cache consistency has been damaged`);
     } else {
       log.info(`Could not cache the response identified by '${key}': ${errorMessage}`);
       IDEMPOTENT_RESPONSES.delete(key);
@@ -173,10 +167,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`,
-      );
+      log.info(`Could not cache the response identified by '${key}'. ` + `Cache consistency has been damaged`);
     } else if (errorMessage) {
       log.info(`Could not cache the response identified by '${key}': ${errorMessage}`);
       IDEMPOTENT_RESPONSES.delete(key);

package/lib/express/middleware.ts

@@ -1,14 +1,17 @@
-import {util} from '@appium/support';
-import type {NextFunction, Request, RequestHandler, Response} from 'express';
 import type {IncomingMessage} from 'node:http';
 import type {Duplex} from 'node:stream';
-import {log} from './logger';
+
+import {util} from '@appium/support';
+import type {NextFunction, Request, RequestHandler, Response} from 'express';
+
 import {errors} from '../protocol';
+import {log} from './logger';
 export {handleIdempotency} from './idempotency';
+import type {StringRecord, WSServer} from '@appium/types';
 import {match} from 'path-to-regexp';
+
 import {calcSignature} from '../helpers/session';
 import {getResponseForW3CError} from '../protocol/errors';
-import type {StringRecord, WSServer} from '@appium/types';
 
 const SESSION_ID_PATTERN = /\/session\/([^/]+)/;
 
@@ -39,11 +42,7 @@ export function allowCrossDomain(req: Request, res: Response, next: NextFunction
  * @returns Express request handler
  */
 export function allowCrossDomainAsyncExecute(basePath: string): RequestHandler {
-  function allowCrossDomainAsyncExecuteHandler(
-    req: Request,
-    res: Response,
-    next: NextFunction,
-  ): void {
+  function allowCrossDomainAsyncExecuteHandler(req: Request, res: Response, next: NextFunction): void {
     const receiveAsyncResponseRegExp = new RegExp(
       `${util.escapeRegExp(basePath)}/session/[a-f0-9-]+/(appium/)?receive_async_response`,
     );
@@ -72,9 +71,7 @@ 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,
   );
@@ -151,12 +148,7 @@ export function handleUpgrade(webSocketsMapping: StringRecord<WSServer>): Reques
  * Final error-handling middleware.
  * Logs uncaught errors and returns a W3C-formatted error response unless headers were already sent.
  */
-export function catchAllHandler(
-  err: Error,
-  _req: Request,
-  res: Response,
-  next: NextFunction,
-): void {
+export function catchAllHandler(err: Error, _req: Request, res: Response, next: NextFunction): void {
   if (res.headersSent) {
     next(err);
     return;

package/lib/express/server.ts

@@ -1,42 +1,44 @@
-import express from 'express';
-import type {Express, RequestHandler} from 'express';
 import http from 'node:http';
 import type {Server as HttpServer} from 'node:http';
 import {createRequire} from 'node:module';
+
+// 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 {fs, timing} from '@appium/support';
+import type {
+  AppiumServer,
+  ExternalDriver,
+  MethodMap,
+  ServerArgs,
+  StringRecord,
+  UpdateServerCallback,
+} from '@appium/types';
 import bodyParser from 'body-parser';
+import express from 'express';
+import type {Express, RequestHandler} from 'express';
 import methodOverride from 'method-override';
+
+import {DEFAULT_BASE_PATH} from '../constants';
+import {isLegacyTestPagesEnabled} from '../test-pages/env';
+import {endLogFormatter, startLogFormatter} from './express-logging';
 import {log} from './logger';
-import {startLogFormatter, endLogFormatter} from './express-logging';
 import {
   allowCrossDomain,
-  defaultToJSONContentType,
-  catchAllHandler,
   allowCrossDomainAsyncExecute,
+  catch404Handler,
+  catchAllHandler,
+  defaultToJSONContentType,
   handleIdempotency,
+  handleLogContext,
   handleUpgrade,
   tryHandleWebSocketUpgrade,
-  catch404Handler,
-  handleLogContext,
 } from './middleware';
-// 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,
-  removeAllWebSocketHandlers,
   getWebSocketHandlers,
+  removeAllWebSocketHandlers,
+  removeWebSocketHandler,
 } from './websocket';
-import {DEFAULT_BASE_PATH} from '../constants';
-import {fs, timing} from '@appium/support';
-import type {
-  AppiumServer,
-  ServerArgs,
-  UpdateServerCallback,
-  MethodMap,
-  ExternalDriver,
-  StringRecord,
-} from '@appium/types';
 
 const KEEP_ALIVE_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 
@@ -265,10 +267,7 @@ async function createServer(app: Express, cliArgs?: Partial<ServerArgs>): Promis
       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 {
@@ -320,8 +319,7 @@ function configureHttp({
     // shouldUpgradeCallback only returns a boolean to indicate if the upgrade should proceed
     (
       appiumServer as unknown as {shouldUpgradeCallback?: (req: http.IncomingMessage) => boolean}
-    ).shouldUpgradeCallback = (req) =>
-      String(req.headers?.upgrade ?? '').toLowerCase() === 'websocket';
+    ).shouldUpgradeCallback = (req) => String(req.headers?.upgrade ?? '').toLowerCase() === 'websocket';
     appiumServer.on('upgrade', (req, socket, head) => {
       if (!tryHandleWebSocketUpgrade(req, socket, head, appiumServer.webSocketsMapping)) {
         socket.destroy();
@@ -331,9 +329,7 @@ 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) as (
-    callback?: (err?: Error | null) => void,
-  ) => void;
+  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');
@@ -368,9 +364,7 @@ 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.',
-      );
+      log.error('Could not start REST http interface listener. ' + 'Requested address is not available.');
     } else {
       log.error(
         'Could not start REST http interface listener. The requested ' +
@@ -426,10 +420,7 @@ function hasShouldUpgradeCallback(server: HttpServer): boolean {
   // Check if shouldUpgradeCallback is available on http.Server
   // This is a runtime check that works regardless of TypeScript types
   try {
-    return (
-      typeof (server as unknown as {shouldUpgradeCallback?: unknown}).shouldUpgradeCallback !==
-      'undefined'
-    );
+    return typeof (server as unknown as {shouldUpgradeCallback?: unknown}).shouldUpgradeCallback !== 'undefined';
   } catch {
     return false;
   }

package/lib/express/websocket.ts

@@ -23,25 +23,19 @@ export async function getWebSocketHandlers(
   this: AppiumServer,
   keysFilter: string | null = null,
 ): Promise<Record<string, WSServer>> {
-  return Object.entries(this.webSocketsMapping).reduce<Record<string, WSServer>>(
-    (acc, [pathname, wsServer]) => {
-      if (typeof keysFilter !== 'string' || pathname.includes(keysFilter)) {
-        acc[pathname] = wsServer;
-      }
-      return acc;
-    },
-    {},
-  );
+  return Object.entries(this.webSocketsMapping).reduce<Record<string, WSServer>>((acc, [pathname, wsServer]) => {
+    if (typeof keysFilter !== 'string' || pathname.includes(keysFilter)) {
+      acc[pathname] = wsServer;
+    }
+    return acc;
+  }, {});
 }
 
 /**
  * Removes a WebSocket handler by pathname.
  * @see AppiumServerExtension.removeWebSocketHandler
  */
-export async function removeWebSocketHandler(
-  this: AppiumServer,
-  handlerPathname: string,
-): Promise<boolean> {
+export async function removeWebSocketHandler(this: AppiumServer, handlerPathname: string): Promise<boolean> {
   const wsServer = this.webSocketsMapping?.[handlerPathname];
   if (!wsServer) {
     return false;

package/lib/helpers/capabilities.ts

@@ -1,5 +1,5 @@
-import type {Constraints, W3CCapabilities, Capabilities, AppiumLogger} from '@appium/types';
 import {util} from '@appium/support';
+import type {AppiumLogger, Capabilities, Constraints, W3CCapabilities} from '@appium/types';
 
 /**
  * Determine whether the given argument is valid
@@ -38,8 +38,7 @@ export function fixCaps<C extends Constraints>(
 ): Capabilities<C> {
   const caps = {...oldCaps} as Record<string, unknown>;
 
-  const logCastWarning = (prefix: string) =>
-    log.warn(`${prefix}. This may cause unexpected behavior`);
+  const logCastWarning = (prefix: string) => log.warn(`${prefix}. This may cause unexpected behavior`);
 
   // boolean capabilities can be passed in as strings 'false' and 'true'
   // which we want to translate into boolean values

package/lib/helpers/extension-command-name.ts

@@ -1,5 +1,6 @@
 import {util} from '@appium/support';
 import type {Constraints, Driver, DriverClass} from '@appium/types';
+
 import type {BaseDriver} from '../basedriver/driver';
 
 /**
@@ -9,10 +10,7 @@ import type {BaseDriver} from '../basedriver/driver';
  * @param commandName - The command name to resolve.
  * @returns The resolved extension command name if a mapping exists. Otherwise, the original command name.
  */
-export function resolveExecuteExtensionName<C extends Constraints>(
-  this: BaseDriver<C>,
-  commandName: string,
-): string {
+export function resolveExecuteExtensionName<C extends Constraints>(this: BaseDriver<C>, commandName: string): string {
   const Driver = this.constructor as DriverClass<Driver<C>>;
   const methodMap = Driver.executeMethodMap;
 

package/lib/helpers/levenshtein-match.ts

@@ -41,19 +41,14 @@ export function rankLevenshteinCandidates(
       },
       {} as StringRecord<string[]>,
     );
-  const sortedDistanceKeys = Object.keys(matchesMap).sort(
-    (a, b) => parseInt(a, 10) - parseInt(b, 10),
-  );
+  const sortedDistanceKeys = Object.keys(matchesMap).sort((a, b) => parseInt(a, 10) - parseInt(b, 10));
   const sorted = sortedDistanceKeys.flatMap((k) => (matchesMap[k] ?? []).sort());
 
   const best = sorted[0];
   const firstDistanceKey = sortedDistanceKeys[0];
   const minDist = firstDistanceKey !== undefined ? parseInt(firstDistanceKey, 10) : NaN;
   const suggestion =
-    maxEditDistance >= 0 &&
-    best !== undefined &&
-    !Number.isNaN(minDist) &&
-    minDist <= maxEditDistance
+    maxEditDistance >= 0 && best !== undefined && !Number.isNaN(minDist) && minDist <= maxEditDistance
       ? best
       : undefined;
   return {sorted, suggestion};

package/lib/{index.js → index.ts}

@@ -7,7 +7,7 @@ export {AppiumIpc} from './basedriver/ipc';
 
 export {BaseDriver};
 export default BaseDriver;
-export {MAX_LOG_BODY_LENGTH, DEFAULT_BASE_PATH, PROTOCOLS, W3C_ELEMENT_KEY} from './constants';
+export {DEFAULT_BASE_PATH, MAX_LOG_BODY_LENGTH, PROTOCOLS, W3C_ELEMENT_KEY} from './constants';
 
 // MJSONWP exports
 export * from './protocol';
@@ -15,8 +15,8 @@ export {errorFromMJSONWPStatusCode as errorFromCode} from './protocol';
 
 // Express exports
 /** @deprecated Removed in Appium 4. Use hard-copied test fixtures in driver CI instead. */
+export {normalizeBasePath, server} from './express/server';
 export {TEST_FIXTURES_DIR as STATIC_DIR} from './test-pages';
-export {server, normalizeBasePath} from './express/server';
 
 // jsonwp-proxy exports
 /** @deprecated The JWProxy export is deprecated. Please use WebDriverProxy instead */
@@ -24,17 +24,17 @@ export {JWProxy} from './jsonwp-proxy/proxy';
 export {JWProxy as WebDriverProxy} from './jsonwp-proxy/proxy';
 
 // jsonwp-status exports
-export {getSummaryByCode, codes as statusCodes} from './jsonwp-status/status';
+export {codes as statusCodes, getSummaryByCode} from './jsonwp-status/status';
 
 // W3C capabilities parser
 export {
+  isStandardCap,
   PREFIXED_APPIUM_OPTS_CAP,
-  STANDARD_CAPS,
   processCapabilities,
-  isStandardCap,
-  validateCaps,
   promoteAppiumOptions,
   promoteAppiumOptionsForObject,
+  STANDARD_CAPS,
+  validateCaps,
 } from './basedriver/capabilities';
 
 // Web socket helpers
@@ -47,6 +47,4 @@ export {generateDriverLogPrefix} from './basedriver/helpers';
 
 export {isW3cCaps} from './helpers/capabilities';
 
-/**
- * @typedef {import('./express/server').ServerOpts} ServerOpts
- */
+export type {ServerOpts} from './express/server';

package/lib/jsonwp-proxy/protocol-converter.ts

@@ -1,26 +1,21 @@
-import type {AppiumLogger, HTTPBody, ProxyResponse} from '@appium/types';
 import {logger, util} from '@appium/support';
+import type {AppiumLogger, HTTPBody, ProxyResponse} from '@appium/types';
+
 import {duplicateKeys} from '../basedriver/helpers';
-import {MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY, PROTOCOLS} from '../constants';
+import {MJSONWP_ELEMENT_KEY, PROTOCOLS, W3C_ELEMENT_KEY} from '../constants';
 
-export type ProxyFunction = (
-  url: string,
-  method: string,
-  body?: HTTPBody,
-) => Promise<[ProxyResponse, HTTPBody]>;
+export type ProxyFunction = (url: string, method: string, body?: HTTPBody) => Promise<[ProxyResponse, HTTPBody]>;
 
 export const COMMAND_URLS_CONFLICTS = [
   {
     commandNames: ['execute', 'executeAsync'],
-    jsonwpConverter: (url: string) =>
-      url.replace(/\/execute.*/, url.includes('async') ? '/execute_async' : '/execute'),
+    jsonwpConverter: (url: string) => url.replace(/\/execute.*/, url.includes('async') ? '/execute_async' : '/execute'),
     w3cConverter: (url: string) =>
       url.replace(/\/execute.*/, url.includes('async') ? '/execute/async' : '/execute/sync'),
   },
   {
     commandNames: ['getElementScreenshot'],
-    jsonwpConverter: (url: string) =>
-      url.replace(/\/element\/([^/]+)\/screenshot$/, '/screenshot/$1'),
+    jsonwpConverter: (url: string) => url.replace(/\/element\/([^/]+)\/screenshot$/, '/screenshot/$1'),
     w3cConverter: (url: string) => url.replace(/\/screenshot\/([^/]+)/, '/element/$1/screenshot'),
   },
   {
@@ -114,17 +109,12 @@ export class ProtocolConverter {
       if (!(commandNames as readonly string[]).includes(commandName)) {
         continue;
       }
-      const rewrittenUrl =
-        this.downstreamProtocol === MJSONWP ? jsonwpConverter(url) : w3cConverter(url);
+      const rewrittenUrl = this.downstreamProtocol === MJSONWP ? jsonwpConverter(url) : w3cConverter(url);
       if (rewrittenUrl === url) {
-        this.log.debug(
-          `Did not know how to rewrite the original URL '${url}' for ${this.downstreamProtocol} protocol`,
-        );
+        this.log.debug(`Did not know how to rewrite the original URL '${url}' for ${this.downstreamProtocol} protocol`);
         break;
       }
-      this.log.info(
-        `Rewrote the original URL '${url}' to '${rewrittenUrl}' for ${this.downstreamProtocol} protocol`,
-      );
+      this.log.info(`Rewrote the original URL '${url}' to '${rewrittenUrl}' for ${this.downstreamProtocol} protocol`);
       return await this.proxyFunc(rewrittenUrl, method, body);
     }
 
@@ -143,11 +133,7 @@ export class ProtocolConverter {
     }
 
     const bodyObj = (util.safeJsonParse(body) as Record<string, unknown>) ?? {};
-    if (
-      this.downstreamProtocol === W3C &&
-      Object.hasOwn(bodyObj, 'ms') &&
-      Object.hasOwn(bodyObj, 'type')
-    ) {
+    if (this.downstreamProtocol === W3C && Object.hasOwn(bodyObj, 'ms') && Object.hasOwn(bodyObj, 'type')) {
       const typeToW3C = (x: string) => (x === 'page load' ? 'pageLoad' : x);
       return [
         {
@@ -156,10 +142,7 @@ export class ProtocolConverter {
       ];
     }
 
-    if (
-      this.downstreamProtocol === MJSONWP &&
-      (!Object.hasOwn(bodyObj, 'ms') || !Object.hasOwn(bodyObj, 'type'))
-    ) {
+    if (this.downstreamProtocol === MJSONWP && (!Object.hasOwn(bodyObj, 'ms') || !Object.hasOwn(bodyObj, 'type'))) {
       const typeToJSONWP = (x: string) => (x === 'pageLoad' ? 'page load' : x);
       return (
         Object.entries(bodyObj)
@@ -178,18 +161,12 @@ export class ProtocolConverter {
   /**
    * Proxy an array of timeout objects and merge the result.
    */
-  private async proxySetTimeouts(
-    url: string,
-    method: string,
-    body?: HTTPBody,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  private async proxySetTimeouts(url: string, method: string, body?: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
     const timeoutRequestObjects = this.getTimeoutRequestObjects(body);
     if (timeoutRequestObjects.length === 0) {
       return await this.proxyFunc(url, method, body);
     }
-    this.log.debug(
-      `Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`,
-    );
+    this.log.debug(`Will send the following request bodies to /timeouts: ${JSON.stringify(timeoutRequestObjects)}`);
 
     let response!: ProxyResponse;
     let resBody!: HTTPBody;
@@ -209,27 +186,15 @@ export class ProtocolConverter {
     return [response, resBody];
   }
 
-  private async proxySetWindow(
-    url: string,
-    method: string,
-    body: HTTPBody,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  private async proxySetWindow(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
     if (util.isPlainObject(bodyObj)) {
       const obj = bodyObj as Record<string, unknown>;
-      if (
-        this.downstreamProtocol === W3C &&
-        Object.hasOwn(bodyObj, 'name') &&
-        !Object.hasOwn(bodyObj, 'handle')
-      ) {
+      if (this.downstreamProtocol === W3C && Object.hasOwn(bodyObj, 'name') && !Object.hasOwn(bodyObj, 'handle')) {
         this.log.debug(`Copied 'name' value '${obj.name}' to 'handle' as per W3C spec`);
         return await this.proxyFunc(url, method, {...obj, handle: obj.name});
       }
-      if (
-        this.downstreamProtocol === MJSONWP &&
-        Object.hasOwn(bodyObj, 'handle') &&
-        !Object.hasOwn(bodyObj, 'name')
-      ) {
+      if (this.downstreamProtocol === MJSONWP && Object.hasOwn(bodyObj, 'handle') && !Object.hasOwn(bodyObj, 'name')) {
         this.log.debug(`Copied 'handle' value '${obj.handle}' to 'name' as per JSONWP spec`);
         return await this.proxyFunc(url, method, {...obj, name: obj.handle});
       }
@@ -237,16 +202,9 @@ export class ProtocolConverter {
     return await this.proxyFunc(url, method, body);
   }
 
-  private async proxySetValue(
-    url: string,
-    method: string,
-    body: HTTPBody,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  private async proxySetValue(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body) as Record<string, unknown> | undefined;
-    if (
-      util.isPlainObject(bodyObj) &&
-      (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))
-    ) {
+    if (util.isPlainObject(bodyObj) && (util.hasValue(bodyObj?.text) || util.hasValue(bodyObj?.value))) {
       let {text, value} = bodyObj;
       if (util.hasValue(text) && !util.hasValue(value)) {
         value = typeof text === 'string' ? [...text] : Array.isArray(text) ? text : [];
@@ -260,48 +218,26 @@ export class ProtocolConverter {
     return await this.proxyFunc(url, method, body);
   }
 
-  private async proxySetFrame(
-    url: string,
-    method: string,
-    body: HTTPBody,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  private async proxySetFrame(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
-    if (
-      Object.hasOwn(bodyObj ?? {}, 'id') &&
-      util.isPlainObject((bodyObj as Record<string, unknown>).id)
-    ) {
+    if (Object.hasOwn(bodyObj ?? {}, 'id') && util.isPlainObject((bodyObj as Record<string, unknown>).id)) {
       return await this.proxyFunc(url, method, {
         ...(bodyObj as object),
-        id: duplicateKeys(
-          (bodyObj as Record<string, unknown>).id as object,
-          MJSONWP_ELEMENT_KEY,
-          W3C_ELEMENT_KEY,
-        ),
+        id: duplicateKeys((bodyObj as Record<string, unknown>).id as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
       });
     }
     return await this.proxyFunc(url, method, body);
   }
 
-  private async proxyPerformActions(
-    url: string,
-    method: string,
-    body: HTTPBody,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  private async proxyPerformActions(url: string, method: string, body: HTTPBody): Promise<[ProxyResponse, HTTPBody]> {
     const bodyObj = util.safeJsonParse(body);
     if (util.isPlainObject(bodyObj)) {
-      return await this.proxyFunc(
-        url,
-        method,
-        duplicateKeys(bodyObj as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY),
-      );
+      return await this.proxyFunc(url, method, duplicateKeys(bodyObj as object, MJSONWP_ELEMENT_KEY, W3C_ELEMENT_KEY));
     }
     return await this.proxyFunc(url, method, body);
   }
 
-  private async proxyReleaseActions(
-    url: string,
-    method: string,
-  ): Promise<[ProxyResponse, HTTPBody]> {
+  private async proxyReleaseActions(url: string, method: string): Promise<[ProxyResponse, HTTPBody]> {
     return await this.proxyFunc(url, method);
   }
 }