appium-mac2-driver 4.3.6 → 4.5.0

package/lib/commands/windows.ts

@@ -0,0 +1,44 @@
+import type {Mac2Driver} from '../driver.js';
+import type {AdjustedWindowInfo, WindowInfo, WindowState} from '../types.js';
+
+/**
+ * Lists the windows of the current application
+ *
+ * @returns Information about each window, including its element identifier
+ */
+export async function macosListWindows(this: Mac2Driver): Promise<WindowInfo[]> {
+  return (await this.wda.proxy.command('/wda/windows', 'GET')) as WindowInfo[];
+}
+
+/**
+ * Changes the state and/or geometry of an application window, optionally moving it to another display
+ *
+ * @param windowId - Identifier of the window element. The main window is used by default
+ * @param state - The state to put the window into
+ * @param x - Horizontal origin. Global, or relative to the display if `displayId` is set
+ * @param y - Vertical origin. Global, or relative to the display if `displayId` is set
+ * @param width - Window width
+ * @param height - Window height
+ * @param displayId - Identifier of the display to move the window to
+ * @returns The updated window information. `windowId` is null if a minimized window was adjusted
+ */
+export async function macosAdjustWindow(
+  this: Mac2Driver,
+  windowId?: string,
+  state?: WindowState,
+  x?: number,
+  y?: number,
+  width?: number,
+  height?: number,
+  displayId?: number,
+): Promise<AdjustedWindowInfo> {
+  return (await this.wda.proxy.command('/wda/window/adjust', 'POST', {
+    windowId,
+    state,
+    x,
+    y,
+    width,
+    height,
+    displayId,
+  })) as AdjustedWindowInfo;
+}

package/lib/driver.ts

@@ -11,7 +11,7 @@ import type {
   DriverOpts,
   W3CDriverCaps,
 } from '@appium/types';
-import {BaseDriver, DeviceSettings} from 'appium/driver.js';
+import {BaseDriver, DeviceSettings, errors} from 'appium/driver.js';
 
 import * as appManagemenetCommands from './commands/app-management.js';
 import * as appleScriptCommands from './commands/applescript.js';
@@ -25,10 +25,12 @@ import * as navigationCommands from './commands/navigation.js';
 import * as recordScreenCommands from './commands/record-screen.js';
 import * as screenshotCommands from './commands/screenshots.js';
 import * as sourceCommands from './commands/source.js';
+import * as windowCommands from './commands/windows.js';
 import MAC2_CONSTRAINTS, {type Mac2Constraints} from './constraints.js';
 import {executeMethodMap} from './execute-method-map.js';
 import log from './logger.js';
 import {newMethodMap} from './method-map.js';
+import {sessionClaimHandler} from './session-claim-handler.js';
 import {WDA_MAC_SERVER, type WDAMacServer} from './wda-mac.js';
 
 const NO_PROXY: RouteMatcher[] = [
@@ -110,12 +112,17 @@ export class Mac2Driver
 
   macosSource = sourceCommands.macosSource;
 
+  macosListWindows = windowCommands.macosListWindows;
+  macosAdjustWindow = windowCommands.macosAdjustWindow;
+
   _videoChunksBroadcaster!: nativeScreenRecordingCommands.NativeVideoChunksBroadcaster;
   _screenRecorder: recordScreenCommands.ScreenRecorder | null = null;
   public proxyReqRes!: (...args: any) => any;
 
   private isProxyActive: boolean = false;
   private _wda: WDAMacServer | null = null;
+  private _wdaSessionId: string | null = null;
+  private _hasClaimedHost: boolean = false;
 
   constructor(opts: InitialOpts = {} as InitialOpts) {
     super(opts);
@@ -143,6 +150,13 @@ export class Mac2Driver
     if (!this._wda) {
       throw new Error('WDA server is not initialized');
     }
+    // The WDA server is shared and only supports a single session, so a newer
+    // session replaces this one. Never send commands on its behalf after that.
+    if (this._wdaSessionId && !this._wda.isSessionActive(this._wdaSessionId)) {
+      throw new errors.NoSuchDriverError(
+        'This session has been replaced by a newer one, because this driver only supports a single session',
+      );
+    }
     return this._wda;
   }
 
@@ -150,7 +164,7 @@ export class Mac2Driver
     if (!this._wda) {
       return;
     }
-    return await this._wda.proxy.command('/appium/settings', 'POST', {
+    return await this.wda.proxy.command('/appium/settings', 'POST', {
       settings: {[key]: value},
     });
   }
@@ -170,10 +184,7 @@ export class Mac2Driver
   }
 
   async proxyCommand(url: string, method: HTTPMethod, body: HTTPBody = null): Promise<any> {
-    if (!this._wda) {
-      throw new Error('WDA server is not initialized');
-    }
-    return await this._wda.proxy.command(url, method, body);
+    return await this.wda.proxy.command(url, method, body);
   }
 
   override async getStatus(): Promise<any> {
@@ -185,10 +196,7 @@ export class Mac2Driver
 
   // needed to make image plugin work
   async getWindowRect(): Promise<any> {
-    if (!this._wda) {
-      throw new Error('WDA server is not initialized');
-    }
-    return await this._wda.proxy.command('/window/rect', 'GET');
+    return await this.wda.proxy.command('/window/rect', 'GET');
   }
 
   override async createSession(
@@ -202,34 +210,51 @@ export class Mac2Driver
     this.caps = caps as Mac2DriverCaps;
     // oxlint-disable-next-line no-self-assign -- narrows this.opts' type for the rest of the method
     this.opts = this.opts as Mac2DriverOpts;
-    try {
-      const prerun = caps.prerun as PrerunCapability | undefined;
-      if (prerun) {
-        if (typeof prerun.command !== 'string' && typeof prerun.script !== 'string') {
-          throw new Error(`'prerun' capability value must either contain 'script' or 'command' entry of string type`);
-        }
-        log.info('Executing prerun AppleScript');
-        const output = await this.macosExecAppleScript(prerun.script, undefined, prerun.command);
-        if (output.trim()) {
-          log.info(`Prerun script output: ${output}`);
+    // The host supports a single session: the previous one has to quit first
+    await sessionClaimHandler.runExclusive(async () => {
+      // The session might have been deleted while it was waiting for its turn
+      if (!this._wda || !this.sessionId) {
+        throw new errors.NoSuchDriverError('The session has been deleted before it could start');
+      }
+      try {
+        await sessionClaimHandler.registerActiveSession(this);
+        await sessionClaimHandler.claimHost(this);
+        this._hasClaimedHost = true;
+        const prerun = caps.prerun as PrerunCapability | undefined;
+        if (prerun) {
+          if (typeof prerun.command !== 'string' && typeof prerun.script !== 'string') {
+            throw new Error(`'prerun' capability value must either contain 'script' or 'command' entry of string type`);
+          }
+          log.info('Executing prerun AppleScript');
+          const output = await this.macosExecAppleScript(prerun.script, undefined, prerun.command);
+          if (output.trim()) {
+            log.info(`Prerun script output: ${output}`);
+          }
         }
+        this._wdaSessionId = await this.wda.startSession(caps, {
+          reqBasePath: this.basePath,
+        });
+      } catch (e: any) {
+        await this.deleteSession();
+        throw e;
       }
-      await this._wda.startSession(caps, {
-        reqBasePath: this.basePath,
-      });
-    } catch (e: any) {
-      await this.deleteSession();
-      throw e;
-    }
-    this.proxyReqRes = this.wda.proxy.proxyReqRes.bind(this._wda.proxy);
+    });
+    this.proxyReqRes = (...args: any[]) =>
+      (this.wda.proxy.proxyReqRes as (...a: any[]) => any).apply(this.wda.proxy, args);
     this.isProxyActive = true;
     return [sessionId, caps];
   }
 
   override async deleteSession(): Promise<void> {
+    sessionClaimHandler.unregisterActiveSession(this);
+    // A new session waits for the teardown to complete before it starts
+    await sessionClaimHandler.trackTeardown(async () => await this.teardownSession());
+  }
+
+  private async teardownSession(): Promise<void> {
     await this._screenRecorder?.stop(true);
     if (this._videoChunksBroadcaster.hasPublishers) {
-      if (this._wda) {
+      if (this._wda?.isSessionActive(this._wdaSessionId)) {
         try {
           await this.wda.proxy.command('/wda/video/stop', 'POST', {});
         } catch {}
@@ -237,10 +262,11 @@ export class Mac2Driver
       await this._videoChunksBroadcaster.shutdown(5000);
     }
     if (this._wda) {
-      await this.wda.stopSession();
+      await this._wda.stopSession(this._wdaSessionId);
     }
 
-    const postrun = this.opts.postrun as PostrunCapability | undefined;
+    // Skip postrun if the host was never acquired, as the previous session might still be using it
+    const postrun = this._hasClaimedHost ? (this.opts.postrun as PostrunCapability | undefined) : undefined;
     if (postrun) {
       if (typeof postrun.command !== 'string' && typeof postrun.script !== 'string') {
         log.error(`'postrun' capability value must either contain 'script' or 'command' entry of string type`);
@@ -264,6 +290,8 @@ export class Mac2Driver
 
   private resetState(): void {
     this._wda = null;
+    this._wdaSessionId = null;
+    this._hasClaimedHost = false;
     this.isProxyActive = false;
     this._videoChunksBroadcaster = new nativeScreenRecordingCommands.NativeVideoChunksBroadcaster(
       this.eventEmitter,

package/lib/execute-method-map.ts

@@ -130,6 +130,15 @@ export const executeMethodMap = {
       optional: ['displayId'],
     },
   },
+  'macos: listWindows': {
+    command: 'macosListWindows',
+  },
+  'macos: adjustWindow': {
+    command: 'macosAdjustWindow',
+    params: {
+      optional: ['windowId', 'state', 'x', 'y', 'width', 'height', 'displayId'],
+    },
+  },
   'macos: appleScript': {
     command: 'macosExecAppleScript',
     params: {

package/lib/session-claim-handler.ts

@@ -0,0 +1,306 @@
+import {setTimeout as delay} from 'node:timers/promises';
+
+import type {AppiumLogger, IAppiumIpc, IIpcSubscription, IpcMessage} from '@appium/types';
+import {errors} from 'appium/driver.js';
+import {node, util} from 'appium/support.js';
+import AsyncLock from 'async-lock';
+import {waitForCondition} from 'asyncbox';
+
+import type {Mac2Driver} from './driver.js';
+
+export type SessionIpcMessage = {
+  sessionId: string;
+};
+
+type AppiumIpcConstructor = new () => IAppiumIpc;
+type IpcProvider = () => Promise<IAppiumIpc | undefined>;
+
+/** Lets a new session make the previous one quit, over a driver-wide IPC (per-session IPCs are isolated). */
+export class SessionClaimHandler {
+  static readonly CLAIMED_TOPIC = 'mac2:sessionClaimed';
+  static readonly CONTENDED_TOPIC = 'mac2:sessionContended';
+  static readonly RELEASED_TOPIC = 'mac2:sessionReleased';
+
+  private static readonly STARTUP_LOCK_KEY = 'mac2:sessionStartup';
+
+  private static readonly CONTENTION_PROBE_MS = 10;
+  private static readonly DEFAULT_RELEASE_WAIT_MS = 15000;
+
+  private readonly startupLock = new AsyncLock();
+  private readonly pendingTeardowns = new Set<Promise<void>>();
+  private readonly subscriptionsBySessionId = new Map<string, IIpcSubscription<SessionIpcMessage>>();
+
+  constructor(
+    private readonly getIpc: IpcProvider,
+    private readonly releaseWaitMs: number = SessionClaimHandler.DEFAULT_RELEASE_WAIT_MS,
+  ) {}
+
+  /** Serializes session startups so the newest wins. Enter before registering the session. */
+  async runExclusive<T>(fn: () => Promise<T>): Promise<T> {
+    return await this.startupLock.acquire(SessionClaimHandler.STARTUP_LOCK_KEY, fn);
+  }
+
+  /** Subscribe the session to claim messages from newer sessions. */
+  async registerActiveSession(driver: Mac2Driver): Promise<void> {
+    const ipc = await this.getIpc();
+    const sessionId = driver.sessionId;
+    if (!ipc || !sessionId) {
+      return;
+    }
+
+    this.unregisterActiveSession(driver);
+
+    const subscription = ipc.subscribe<SessionIpcMessage>(
+      SessionClaimHandler.CLAIMED_TOPIC,
+      this.getPublisherId(driver),
+    );
+    subscription.on('message', (message) => {
+      void this.dispatchClaimMessage(driver, sessionId, message);
+    });
+    this.subscriptionsBySessionId.set(sessionId, subscription);
+  }
+
+  /** Unsubscribe the session from claim messages. */
+  unregisterActiveSession(driver: Mac2Driver): void {
+    const sessionId = driver.sessionId;
+    if (!sessionId) {
+      return;
+    }
+
+    this.subscriptionsBySessionId.get(sessionId)?.unsubscribe();
+    this.subscriptionsBySessionId.delete(sessionId);
+  }
+
+  /** Tracks a session teardown, so that a new session does not start before it is complete. */
+  async trackTeardown(teardown: () => Promise<void>): Promise<void> {
+    const promise = teardown();
+    const tracked = (async () => {
+      try {
+        await promise;
+      } catch {
+        // the failure is reported to the caller of trackTeardown()
+      }
+    })();
+    this.pendingTeardowns.add(tracked);
+    try {
+      await promise;
+    } finally {
+      this.pendingTeardowns.delete(tracked);
+    }
+  }
+
+  /** Make any other active session quit and wait until it has released the host. */
+  async claimHost(driver: Mac2Driver): Promise<void> {
+    await this.requestRelease(driver);
+    await this.waitForPendingTeardowns(driver);
+  }
+
+  private async waitForPendingTeardowns(driver: Mac2Driver): Promise<void> {
+    if (this.pendingTeardowns.size === 0) {
+      return;
+    }
+
+    driver.log.debug(`Waiting for ${util.pluralize('session', this.pendingTeardowns.size, true)} to finish quitting`);
+    const timer = new AbortController();
+    const timedOut = Symbol('timedOut');
+    const timeout = (async () => {
+      try {
+        return await delay(this.releaseWaitMs, timedOut, {signal: timer.signal});
+      } catch {
+        return undefined; // aborted
+      }
+    })();
+    try {
+      if ((await Promise.race([Promise.all(this.pendingTeardowns), timeout])) === timedOut) {
+        // Starting now could let the old teardown (e.g. postrun) interfere with this session
+        throw new errors.SessionNotCreatedError(
+          `The previous session did not finish quitting within ${this.releaseWaitMs}ms`,
+        );
+      }
+    } finally {
+      timer.abort();
+    }
+  }
+
+  private async requestRelease(driver: Mac2Driver): Promise<void> {
+    const ipc = await this.getIpc();
+    if (!ipc) {
+      driver.log.debug('Driver-instance IPC is unavailable. Skipping the session claim.');
+      return;
+    }
+
+    const sessionId = driver.sessionId;
+    if (!sessionId) {
+      return;
+    }
+
+    const contendingSessionIds = new Set<string>();
+    const releasedSessionIds = new Set<string>();
+    const subscriptions: IIpcSubscription<SessionIpcMessage>[] = [];
+
+    try {
+      const contendedSubscription = ipc.subscribe<SessionIpcMessage>(
+        SessionClaimHandler.CONTENDED_TOPIC,
+        this.getPublisherId(driver),
+      );
+      subscriptions.push(contendedSubscription);
+      const releasedSubscription = ipc.subscribe<SessionIpcMessage>(
+        SessionClaimHandler.RELEASED_TOPIC,
+        this.getPublisherId(driver),
+      );
+      subscriptions.push(releasedSubscription);
+      contendedSubscription.on('message', (message) => {
+        if (message.data.sessionId !== sessionId) {
+          contendingSessionIds.add(message.data.sessionId);
+        }
+      });
+      releasedSubscription.on('message', (message) => {
+        if (message.data.sessionId !== sessionId) {
+          releasedSessionIds.add(message.data.sessionId);
+        }
+      });
+
+      await ipc.publish<SessionIpcMessage>(SessionClaimHandler.CLAIMED_TOPIC, this.getPublisherId(driver), {
+        sessionId,
+      });
+      // Older sessions reply synchronously to the claim, so a short wait is enough to learn about them
+      await delay(SessionClaimHandler.CONTENTION_PROBE_MS);
+
+      if (contendingSessionIds.size === 0) {
+        return;
+      }
+
+      try {
+        await waitForCondition(() => [...contendingSessionIds].every((id) => releasedSessionIds.has(id)), {
+          waitMs: this.releaseWaitMs,
+          intervalMs: 50,
+        });
+        driver.log.debug(
+          `Received release confirmation from ${util.pluralize('session', contendingSessionIds.size, true)}`,
+        );
+      } catch {
+        const pendingSessionIds = [...contendingSessionIds].filter((id) => !releasedSessionIds.has(id));
+        // Starting now could let the old session interfere with this one
+        throw new errors.SessionNotCreatedError(
+          `${util.pluralize('session', pendingSessionIds.length, true)} [${pendingSessionIds.join(', ')}] ` +
+            `did not quit within ${this.releaseWaitMs}ms`,
+        );
+      }
+    } finally {
+      subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+  }
+
+  /** @internal Exposed for unit tests. */
+  resetForTesting(): void {
+    this.pendingTeardowns.clear();
+    for (const subscription of this.subscriptionsBySessionId.values()) {
+      subscription.unsubscribe();
+    }
+    this.subscriptionsBySessionId.clear();
+  }
+
+  private async dispatchClaimMessage(
+    driver: Mac2Driver,
+    sessionId: string,
+    message: IpcMessage<SessionIpcMessage>,
+  ): Promise<void> {
+    try {
+      await this.handleClaimMessage(driver, sessionId, message);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      driver.log.warn(`Could not handle the session claim IPC message for session '${sessionId}': ${msg}`);
+    }
+  }
+
+  private async handleClaimMessage(
+    driver: Mac2Driver,
+    sessionId: string,
+    message: IpcMessage<SessionIpcMessage>,
+  ): Promise<void> {
+    if (message.data.sessionId === sessionId || driver.sessionId !== sessionId) {
+      return;
+    }
+
+    // Tell the claimer that it has to wait for us
+    await this.publish(driver, SessionClaimHandler.CONTENDED_TOPIC, sessionId);
+
+    driver.log.warn(
+      `Session '${message.data.sessionId}' is starting, while this session ('${sessionId}') is still active. ` +
+        `Only one session at a time is supported, since XCTest is single-threaded. ` +
+        `Consider enabling the Appium server's '--session-override' flag and make sure to properly ` +
+        `quit the previous session before starting a new one. Terminating the obsolete session.`,
+    );
+    await this.terminateSession(driver, sessionId);
+  }
+
+  private async terminateSession(driver: Mac2Driver, sessionId: string): Promise<void> {
+    const publisherId = this.getPublisherId(driver);
+    const {log} = driver;
+
+    try {
+      // Unlike deleteSession(), this also makes the server drop the session from its list
+      await driver.startUnexpectedShutdown(
+        new errors.NoSuchDriverError(
+          'This session has been replaced by a newer one, because only a single session is supported',
+        ),
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn(`Could not terminate session '${sessionId}' on IPC request: ${msg}`);
+    }
+
+    await this.publish(driver, SessionClaimHandler.RELEASED_TOPIC, sessionId, publisherId, log);
+  }
+
+  private async publish(
+    driver: Mac2Driver,
+    topic: string,
+    sessionId: string,
+    publisherId: string = this.getPublisherId(driver),
+    log: AppiumLogger = driver.log,
+  ): Promise<void> {
+    try {
+      const ipc = await this.getIpc();
+      await ipc?.publish<SessionIpcMessage>(topic, publisherId, {sessionId});
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      log.warn(`Could not publish '${topic}' message for session '${sessionId}': ${msg}`);
+    }
+  }
+
+  private getPublisherId(driver: Mac2Driver): string {
+    return node.getObjectId(driver);
+  }
+}
+
+let sharedIpc: Promise<IAppiumIpc | undefined> | undefined;
+
+async function loadSharedIpc(): Promise<IAppiumIpc | undefined> {
+  sharedIpc ??= (async () => {
+    try {
+      const {AppiumIpc} = (await import('appium/driver.js')) as {AppiumIpc?: AppiumIpcConstructor};
+      return AppiumIpc ? new AppiumIpc() : undefined;
+    } catch {
+      return undefined;
+    }
+  })();
+  return await sharedIpc;
+}
+
+export const sessionClaimHandler = new SessionClaimHandler(loadSharedIpc);
+
+/**
+ * @internal Exposed for unit tests.
+ */
+export function setSharedIpcForTesting(ipc: IAppiumIpc | undefined): void {
+  sharedIpc = Promise.resolve(ipc);
+}
+
+/**
+ * @internal Exposed for unit tests.
+ */
+export function resetSharedIpcForTesting(): void {
+  sessionClaimHandler.resetForTesting();
+  sharedIpc = undefined;
+}

package/lib/types.ts

@@ -26,3 +26,31 @@ export interface ScreenshotInfo {
 
 /** A dictionary where each key contains a unique display identifier */
 export type ScreenshotsInfo = StringRecord<ScreenshotInfo>;
+
+export interface Rect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+export type WindowState = 'normal' | 'minimized' | 'maximized' | 'fullscreen';
+
+export interface WindowInfo {
+  /** Identifier of the window element */
+  windowId: string;
+  title: string;
+  rect: Rect;
+  /** The display that contains most of the window, if any */
+  displayId: number | null;
+  /** Traits below are null if the Accessibility permission is not granted */
+  isMain: boolean | null;
+  isFocused: boolean | null;
+  isMinimized: boolean | null;
+  isFullscreen: boolean | null;
+  isMovable: boolean | null;
+  isResizable: boolean | null;
+}
+
+/** `windowId` is null if a minimized window has been adjusted */
+export type AdjustedWindowInfo = Omit<WindowInfo, 'windowId'> & {windowId: string | null};

package/lib/wda-mac.ts

@@ -301,7 +301,8 @@ export class WDAMacServer {
     return this._proxy;
   }
 
-  async startSession(caps: StartSessionCapabilities, opts: SessionOptions = {}): Promise<void> {
+  /** Starts a WDA session, replacing the previous one. Returns the new WDA session id. */
+  async startSession(caps: StartSessionCapabilities, opts: SessionOptions = {}): Promise<string> {
     this._serverStartupTimeoutMs = caps.serverStartupTimeout ?? this._serverStartupTimeoutMs;
 
     this._isProxyingToRemoteServer = !!caps.webDriverAgentMacUrl;
@@ -381,23 +382,53 @@ export class WDAMacServer {
       log.info('The host process has already been listening. Proceeding with session creation');
     }
 
-    await this._proxy.command('/session', 'POST', {
-      capabilities: {
-        firstMatch: [{}],
-        alwaysMatch: caps,
-      },
-    });
+    // WDA drops the previous session as soon as it gets this request,
+    // so a failure must not leave the proxy pointing at the replaced one
+    try {
+      await this._proxy.command('/session', 'POST', {
+        capabilities: {
+          firstMatch: [{}],
+          alwaysMatch: caps,
+        },
+      });
+    } catch (e) {
+      this._proxy.sessionId = null;
+      throw e;
+    }
+    const sessionId = this._proxy.sessionId;
+    if (!sessionId) {
+      throw new errors.SessionNotCreatedError('WebDriverAgentMac did not return a session id');
+    }
+    return sessionId;
+  }
+
+  /** Whether the WDA session has not been replaced by a newer one. */
+  isSessionActive(sessionId: string | null | undefined): boolean {
+    return !!sessionId && this._proxy?.sessionId === sessionId;
   }
 
-  async stopSession(): Promise<void> {
+  /** Stops the WDA session. A replaced one is skipped, so the newer one is never affected. */
+  async stopSession(sessionId: string | null | undefined): Promise<void> {
     if (!this._isProxyingToRemoteServer && !this._process?.isRunning) {
       log.info(`Mac2Driver session cannot be stopped, because the server is not running`);
       return;
     }
 
-    if (this._proxy?.sessionId) {
+    if (!this.isSessionActive(sessionId)) {
+      if (sessionId) {
+        log.info(`Mac2Driver session '${sessionId}' is not active anymore. Nothing to stop`);
+      }
+      return;
+    }
+
+    const proxy = this._proxy;
+    if (proxy) {
       try {
-        await this._proxy.command(`/session/${this._proxy.sessionId}`, 'DELETE');
+        await proxy.command(`/session/${sessionId}`, 'DELETE');
+        // A newer session might have been created while the DELETE was pending
+        if (proxy.sessionId === sessionId) {
+          proxy.sessionId = null;
+        }
       } catch (e: any) {
         log.info(`Mac2Driver session cannot be deleted. Original error: ${e.message}`);
       }

package/node_modules/appium-xcode/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [7.2.3](https://github.com/appium/appium-ios/compare/appium-xcode@7.2.2...appium-xcode@7.2.3) (2026-10-02)
+
+### Miscellaneous Chores
+
+* ensure Dependabot preserves version ranges ([#24](https://github.com/appium/appium-ios/issues/24)) ([95e4e1a](https://github.com/appium/appium-ios/commit/95e4e1a4703f8ca833f01ecf2af75f4696d98043))
+
+
 ## [7.2.2](https://github.com/appium/appium-ios/compare/appium-xcode@7.2.1...appium-xcode@7.2.2) (2026-10-01)
 
 **Note:** Version bump only for package appium-xcode