appium-novawindows2-driver 0.1.2 → 0.1.3

package/lib/commands/extension.ts

@@ -1,9 +1,10 @@
 import { W3C_ELEMENT_KEY, errors } from '@appium/base-driver';
 import { Element, Rect } from '@appium/types';
-import { NovaWindowsDriver } from '../driver';
+import { NovaWindows2Driver } from '../driver';
 import { $, sleep } from '../util';
 import { POWER_SHELL_FEATURE } from '../constants';
-import { keyDown,
+import {
+    keyDown,
     keyUp,
     mouseDown,
     mouseMoveAbsolute,
@@ -94,7 +95,7 @@ type KeyAction = {
     down?: boolean,
 }
 
-export async function execute(this: NovaWindowsDriver, script: string, args: any[]) {
+export async function execute(this: NovaWindows2Driver, script: string, args: any[]) {
     if (script.startsWith(PLATFORM_COMMAND_PREFIX)) {
         script = script.replace(PLATFORM_COMMAND_PREFIX, '').trim();
         this.log.info(`Executing command '${PLATFORM_COMMAND_PREFIX} ${script}'...`);
@@ -108,11 +109,14 @@ export async function execute(this: NovaWindowsDriver, script: string, args: any
 
     if (script === 'powerShell') {
         this.assertFeatureEnabled(POWER_SHELL_FEATURE);
+        // this.log.info(`Executing command: \n${args[0]}`);
         return await this.executePowerShellScript(args[0]);
     }
 
     if (script === 'return window.name') {
-        return await this.sendPowerShellCommand(AutomationElement.automationRoot.buildGetPropertyCommand(Property.NAME));
+        const command = AutomationElement.automationRoot.buildGetPropertyCommand(Property.NAME);
+        // this.log.info(`Executing command: \n${command}`);
+        return await this.sendPowerShellCommand(command);
     }
 
     throw new errors.NotImplementedError();
@@ -127,7 +131,7 @@ type CacheRequest = {
 const TREE_SCOPE_REGEX = new PropertyRegexMatcher('System.Windows.Automation.TreeScope', ...Object.values(TreeScope)).toRegex('i');
 const AUTOMATION_ELEMENT_MODE_REGEX = new PropertyRegexMatcher('System.Windows.Automation.AutomationElementMode', ...Object.values(AutomationElementMode)).toRegex('i');
 
-export async function pushCacheRequest(this: NovaWindowsDriver, cacheRequest: CacheRequest): Promise<void> {
+export async function pushCacheRequest(this: NovaWindows2Driver, cacheRequest: CacheRequest): Promise<void> {
     if (Object.keys(cacheRequest).every((key) => cacheRequest[key] === undefined)) {
         throw new errors.InvalidArgumentError('At least one property of the cache request must be set.');
     }
@@ -163,28 +167,28 @@ export async function pushCacheRequest(this: NovaWindowsDriver, cacheRequest: Ca
     }
 }
 
-export async function patternInvoke(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternInvoke(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildInvokeCommand());
 }
 
-export async function patternExpand(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternExpand(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildExpandCommand());
 }
 
-export async function patternCollapse(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternCollapse(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildCollapseCommand());
 }
 
-export async function patternScrollIntoView(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternScrollIntoView(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildScrollIntoViewCommand());
 }
 
-export async function patternIsMultiple(this: NovaWindowsDriver, element: Element): Promise<boolean> {
+export async function patternIsMultiple(this: NovaWindows2Driver, element: Element): Promise<boolean> {
     const result = await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildIsMultipleSelectCommand());
     return result.toLowerCase() === 'true' ? true : false;
 }
 
-export async function patternGetSelectedItem(this: NovaWindowsDriver, element: Element): Promise<Element> {
+export async function patternGetSelectedItem(this: NovaWindows2Driver, element: Element): Promise<Element> {
     const result = await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildGetSelectionCommand());
     const elId = result.split('\n').filter(Boolean)[0];
 
@@ -195,28 +199,28 @@ export async function patternGetSelectedItem(this: NovaWindowsDriver, element: E
     return { [W3C_ELEMENT_KEY]: elId };
 }
 
-export async function patternGetAllSelectedItems(this: NovaWindowsDriver, element: Element): Promise<Element[]> {
+export async function patternGetAllSelectedItems(this: NovaWindows2Driver, element: Element): Promise<Element[]> {
     const result = await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildGetSelectionCommand());
     return result.split('\n').filter(Boolean).map((elId) => ({ [W3C_ELEMENT_KEY]: elId }));
 }
 
-export async function patternAddToSelection(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternAddToSelection(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildAddToSelectionCommand());
 }
 
-export async function patternRemoveFromSelection(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternRemoveFromSelection(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildRemoveFromSelectionCommand());
 }
 
-export async function patternSelect(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternSelect(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildSelectCommand());
 }
 
-export async function patternToggle(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternToggle(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildToggleCommand());
 }
 
-export async function patternSetValue(this: NovaWindowsDriver, element: Element, value: string): Promise<void> {
+export async function patternSetValue(this: NovaWindows2Driver, element: Element, value: string): Promise<void> {
     try {
         await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildSetValueCommand(value));
     } catch {
@@ -224,31 +228,31 @@ export async function patternSetValue(this: NovaWindowsDriver, element: Element,
     }
 }
 
-export async function patternGetValue(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternGetValue(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildGetValueCommand());
 }
 
-export async function patternMaximize(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternMaximize(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildMaximizeCommand());
 }
 
-export async function patternMinimize(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternMinimize(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildMinimizeCommand());
 }
 
-export async function patternRestore(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternRestore(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildRestoreCommand());
 }
 
-export async function patternClose(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function patternClose(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildCloseCommand());
 }
 
-export async function focusElement(this: NovaWindowsDriver, element: Element): Promise<void> {
+export async function focusElement(this: NovaWindows2Driver, element: Element): Promise<void> {
     await this.sendPowerShellCommand(new FoundAutomationElement(element[W3C_ELEMENT_KEY]).buildSetFocusCommand());
 }
 
-export async function getClipboardBase64(this: NovaWindowsDriver, contentType?: ContentType | { contentType?: ContentType }): Promise<string> {
+export async function getClipboardBase64(this: NovaWindows2Driver, contentType?: ContentType | { contentType?: ContentType }): Promise<string> {
     if (!contentType || (contentType && typeof contentType === 'object')) {
         contentType = contentType?.contentType ?? ContentType.PLAINTEXT;
     }
@@ -263,7 +267,7 @@ export async function getClipboardBase64(this: NovaWindowsDriver, contentType?:
     }
 }
 
-export async function setClipboardFromBase64(this: NovaWindowsDriver, args: { contentType?: ContentType, b64Content: string }): Promise<string> {
+export async function setClipboardFromBase64(this: NovaWindows2Driver, args: { contentType?: ContentType, b64Content: string }): Promise<string> {
     if (!args || typeof args !== 'object' || !args.b64Content) {
         throw new errors.InvalidArgumentError(`'b64Content' must be provided.`);
     }
@@ -280,7 +284,7 @@ export async function setClipboardFromBase64(this: NovaWindowsDriver, args: { co
     }
 }
 
-export async function executePowerShellScript(this: NovaWindowsDriver, script: string | { script: string, command: undefined } | { script: undefined, command: string }): Promise<string> {
+export async function executePowerShellScript(this: NovaWindows2Driver, script: string | { script: string, command: undefined } | { script: undefined, command: string }): Promise<string> {
     if (script && typeof script === 'object') {
         if (script.script) {
             script = script.script;
@@ -299,7 +303,7 @@ export async function executePowerShellScript(this: NovaWindowsDriver, script: s
     }
 }
 
-export async function executeKeys(this: NovaWindowsDriver, keyActions: { actions: KeyAction | KeyAction[], forceUnicode: boolean }) {
+export async function executeKeys(this: NovaWindows2Driver, keyActions: { actions: KeyAction | KeyAction[], forceUnicode: boolean }) {
     if (!Array.isArray(keyActions.actions)) {
         keyActions.actions = [keyActions.actions];
     }
@@ -358,7 +362,7 @@ export async function executeKeys(this: NovaWindowsDriver, keyActions: { actions
     }
 }
 
-export async function executeClick(this: NovaWindowsDriver, clickArgs: {
+export async function executeClick(this: NovaWindows2Driver, clickArgs: {
     elementId?: string,
     x?: number,
     y?: number,
@@ -404,7 +408,7 @@ export async function executeClick(this: NovaWindowsDriver, clickArgs: {
         pos = [x!, y!];
     }
 
-    const clickTypeToButtonMapping: { [key in ClickType]: number} = {
+    const clickTypeToButtonMapping: { [key in ClickType]: number } = {
         [ClickType.LEFT]: 0,
         [ClickType.MIDDLE]: 1,
         [ClickType.RIGHT]: 2,
@@ -458,7 +462,7 @@ export async function executeClick(this: NovaWindowsDriver, clickArgs: {
     }
 }
 
-export async function executeHover(this: NovaWindowsDriver, hoverArgs: {
+export async function executeHover(this: NovaWindows2Driver, hoverArgs: {
     startElementId?: string,
     startX?: number,
     startY?: number,
@@ -561,7 +565,7 @@ export async function executeHover(this: NovaWindowsDriver, hoverArgs: {
     }
 }
 
-export async function executeScroll(this: NovaWindowsDriver, scrollArgs: {
+export async function executeScroll(this: NovaWindows2Driver, scrollArgs: {
     elementId?: string,
     x?: number,
     y?: number,

package/lib/commands/index.ts

@@ -22,7 +22,7 @@ type Commands = {
 };
 
 declare module '../driver' {
-    interface NovaWindowsDriver extends Commands {}
+    interface NovaWindows2Driver extends Commands { }
 }
 
 export default commands;

package/lib/commands/powershell.ts

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { NovaWindowsDriver } from '../driver';
+import { NovaWindows2Driver } from '../driver';
 import { errors } from '@appium/base-driver';
 import { FIND_CHILDREN_RECURSIVELY, PAGE_SOURCE } from './functions';
 
@@ -11,11 +11,46 @@ const INIT_ROOT_ELEMENT = /* ps1 */ `$rootElement = [AutomationElement]::RootEle
 const NULL_ROOT_ELEMENT = /* ps1 */ `$rootElement = $null`;
 const INIT_ELEMENT_TABLE = /* ps1 */ `$elementTable = New-Object System.Collections.Generic.Dictionary[[string]\`,[AutomationElement]]`;
 
-export async function startPowerShellSession(this: NovaWindowsDriver): Promise<void> {
+async function executeRawCommand(driver: NovaWindows2Driver, command: string): Promise<string> {
+    const magicNumber = 0xF2EE;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const powerShell = driver.powerShell!;
+
+    driver.powerShellStdOut = '';
+    driver.powerShellStdErr = '';
+
+    powerShell.stdin.write(`${command}\n`);
+    powerShell.stdin.write(/* ps1 */ `Write-Output $([char]0x${magicNumber.toString(16)})\n`);
+
+    return await new Promise<string>((resolve, reject) => {
+        const onClose = (code: number) => {
+            reject(new errors.UnknownError(`PowerShell process exited unexpectedly with code ${code}`));
+            driver.powerShell = undefined; // Clear the reference as the process is dead
+        };
+        powerShell.on('close', onClose);
+
+        const onData: Parameters<typeof powerShell.stdout.on>[1] = ((chunk: any) => {
+            const magicChar = String.fromCharCode(magicNumber);
+            if (chunk.toString().includes(magicChar)) {
+                powerShell.stdout.off('data', onData);
+                powerShell.off('close', onClose);
+                if (driver.powerShellStdErr) {
+                    reject(new errors.UnknownError(driver.powerShellStdErr));
+                } else {
+                    resolve(driver.powerShellStdOut.replace(`${magicChar}`, '').trim());
+                }
+            }
+        }).bind(driver);
+
+        powerShell.stdout.on('data', onData);
+    });
+}
+
+export async function startPowerShellSession(this: NovaWindows2Driver): Promise<void> {
     this.log.debug('Starting new PowerShell session...');
     const powerShell = spawn('powershell.exe', ['-NoExit', '-Command', '-']);
     powerShell.stdout.setEncoding('utf8');
-    powerShell.stdout.setEncoding('utf8');
+    powerShell.stderr.setEncoding('utf8');
 
     powerShell.stdout.on('data', (chunk: any) => {
         this.powerShellStdOut += chunk.toString();
@@ -38,27 +73,29 @@ export async function startPowerShellSession(this: NovaWindowsDriver): Promise<v
         for (const envVar of envVars) {
             this.caps.appWorkingDir = this.caps.appWorkingDir.replaceAll(`%${envVar}%`, process.env[envVar.toUpperCase()] ?? '');
         }
-        this.sendPowerShellCommand(`Set-Location -Path '${this.caps.appWorkingDir}'`);
+        // Use raw execution to bypass queue
+        await executeRawCommand(this, `Set-Location -Path '${this.caps.appWorkingDir}'`);
     }
 
-    await this.sendPowerShellCommand(SET_UTF8_ENCODING);
-    await this.sendPowerShellCommand(ADD_NECESSARY_ASSEMBLIES);
-    await this.sendPowerShellCommand(USE_UI_AUTOMATION_CLIENT);
-    await this.sendPowerShellCommand(INIT_CACHE_REQUEST);
-    await this.sendPowerShellCommand(INIT_ELEMENT_TABLE);
+    // Use raw execution to bypass queue
+    await executeRawCommand(this, SET_UTF8_ENCODING);
+    await executeRawCommand(this, ADD_NECESSARY_ASSEMBLIES);
+    await executeRawCommand(this, USE_UI_AUTOMATION_CLIENT);
+    await executeRawCommand(this, INIT_CACHE_REQUEST);
+    await executeRawCommand(this, INIT_ELEMENT_TABLE);
 
     // initialize functions
-    await this.sendPowerShellCommand(PAGE_SOURCE);
-    await this.sendPowerShellCommand(FIND_CHILDREN_RECURSIVELY);
+    await executeRawCommand(this, PAGE_SOURCE);
+    await executeRawCommand(this, FIND_CHILDREN_RECURSIVELY);
 
     if ((!this.caps.app && !this.caps.appTopLevelWindow) || (!this.caps.app || this.caps.app.toLowerCase() === 'none')) {
         this.log.info(`No app or top-level window specified in capabilities. Setting root element to null.`);
-        await this.sendPowerShellCommand(NULL_ROOT_ELEMENT);
+        await executeRawCommand(this, NULL_ROOT_ELEMENT);
     }
 
     if (this.caps.app && this.caps.app.toLowerCase() === 'root') {
         this.log.info(`'root' specified as app in capabilities. Setting root element to desktop root.`);
-        await this.sendPowerShellCommand(INIT_ROOT_ELEMENT);
+        await executeRawCommand(this, INIT_ROOT_ELEMENT);
     }
 
     if (this.caps.app && this.caps.app.toLowerCase() !== 'none' && this.caps.app.toLowerCase() !== 'root') {
@@ -91,7 +128,7 @@ export async function startPowerShellSession(this: NovaWindowsDriver): Promise<v
     }
 }
 
-export async function sendIsolatedPowerShellCommand(this: NovaWindowsDriver, command: string): Promise<string> {
+export async function sendIsolatedPowerShellCommand(this: NovaWindows2Driver, command: string): Promise<string> {
     const magicNumber = 0xF2EE;
 
     const powerShell = spawn('powershell.exe', ['-NoExit', '-Command', '-']);
@@ -166,55 +203,28 @@ export async function sendIsolatedPowerShellCommand(this: NovaWindowsDriver, com
     }
 }
 
-export async function sendPowerShellCommand(this: NovaWindowsDriver, command: string): Promise<string> {
-    const magicNumber = 0xF2EE;
-    // this.log.debug(`Sending PowerShell command: ${command.substring(0, 50)}...`);
-
-    if (!this.powerShell) {
-        this.log.warn('PowerShell session not running. It was either closed or has crashed. Attempting to start a new session...');
-        await this.startPowerShellSession();
-    }
-
-    const result = await new Promise<string>((resolve, reject) => {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const powerShell = this.powerShell!;
-
-        this.powerShellStdOut = '';
-        this.powerShellStdErr = '';
-
-        powerShell.stdin.write(`${command}\n`);
-        powerShell.stdin.write(/* ps1 */ `Write-Output $([char]0x${magicNumber.toString(16)})\n`);
-
-        const onClose = (code: number) => {
-            reject(new errors.UnknownError(`PowerShell process exited unexpectedly with code ${code}`));
-            this.powerShell = undefined; // Clear the reference as the process is dead
-        };
-        powerShell.on('close', onClose);
-
-        const onData: Parameters<typeof powerShell.stdout.on>[1] = ((chunk: any) => {
-            const magicChar = String.fromCharCode(magicNumber);
-            if (chunk.toString().includes(magicChar)) {
-                powerShell.stdout.off('data', onData);
-                powerShell.off('close', onClose);
-                if (this.powerShellStdErr) {
-                    reject(new errors.UnknownError(this.powerShellStdErr));
-                } else {
-                    // this.log.debug(`Received magic char, resolving command.`);
-                    resolve(this.powerShellStdOut.replace(`${magicChar}`, '').trim());
-                }
-            }
-        }).bind(this);
+export async function sendPowerShellCommand(this: NovaWindows2Driver, command: string): Promise<string> {
+    const nextCommand = async () => {
+        if (!this.powerShell) {
+            this.log.warn('PowerShell session not running. It was either closed or has crashed. Attempting to start a new session...');
+            await this.startPowerShellSession();
+        }
 
-        powerShell.stdout.on('data', onData);
-    });
+        // Use the extracted raw command function
+        return await executeRawCommand(this, command);
+    };
 
-    // commented out for now to avoid cluttering the logs with long command outputs
-    // this.log.debug(`PowerShell command executed:\n${command}\n\nCommand output below:\n${result}\n   --------`);
+    // Chain the command to the queue
+    // Use .catch to ignore previous failures, then .then to queue this command.
+    // This prevents re-running this command if it fails (no infinite loop).
+    this.commandQueue = this.commandQueue
+        .catch(() => { /* ignore previous error */ })
+        .then(nextCommand);
 
-    return result;
+    return this.commandQueue;
 }
 
-export async function terminatePowerShellSession(this: NovaWindowsDriver): Promise<void> {
+export async function terminatePowerShellSession(this: NovaWindows2Driver): Promise<void> {
     if (!this.powerShell) {
         return;
     }

package/lib/commands/system.ts

@@ -1,7 +1,7 @@
 import { Orientation } from '@appium/types';
-import { NovaWindowsDriver } from '../driver';
+import { NovaWindows2Driver } from '../driver';
 import { getDisplayOrientation } from '../winapi/user32';
 
-export function getOrientation(this: NovaWindowsDriver): Orientation {
+export function getOrientation(this: NovaWindows2Driver): Orientation {
     return getDisplayOrientation();
 }

package/lib/driver.ts

@@ -54,11 +54,12 @@ const LOCATION_STRATEGIES = Object.freeze([
     '-windows uiautomation',
 ] as const);
 
-export class NovaWindowsDriver extends BaseDriver<NovaWindowsDriverConstraints, StringRecord> {
+export class NovaWindows2Driver extends BaseDriver<NovaWindowsDriverConstraints, StringRecord> {
     isPowerShellSessionStarted: boolean = false;
     powerShell?: ChildProcessWithoutNullStreams;
     powerShellStdOut: string = '';
     powerShellStdErr: string = '';
+    commandQueue: Promise<any> = Promise.resolve();
     keyboardState: KeyboardState = {
         pressed: new Set(),
         alt: false,
@@ -67,6 +68,8 @@ export class NovaWindowsDriver extends BaseDriver<NovaWindowsDriverConstraints,
         shift: false,
     };
 
+    activeCommands: number = 0;
+
     constructor(opts: InitialOpts = {} as InitialOpts, shouldValidateCaps = true) {
         super(opts, shouldValidateCaps);
 
@@ -74,8 +77,24 @@ export class NovaWindowsDriver extends BaseDriver<NovaWindowsDriverConstraints,
         this.desiredCapConstraints = UI_AUTOMATION_DRIVER_CONSTRAINTS;
 
         for (const key in commands) { // TODO: create a decorator that will do that for the class
-            NovaWindowsDriver.prototype[key] = commands[key].bind(this);
+            NovaWindows2Driver.prototype[key] = commands[key].bind(this);
+        }
+    }
+
+    override async executeCommand(cmd: string, ...args: any[]): Promise<any> {
+        this.activeCommands++;
+        try {
+            return await super.executeCommand(cmd, ...args);
+        } finally {
+            this.activeCommands--;
+        }
+    }
+
+    override async startNewCommandTimeout() {
+        if (this.activeCommands > 0) {
+            return;
         }
+        await super.startNewCommandTimeout();
     }
 
     override async findElement(strategy: string, selector: string): Promise<Element> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appium-novawindows2-driver",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Appium driver for Windows",
   "keywords": [
     "appium",
@@ -21,10 +21,10 @@
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nguyenvanhuy0612/appium-novawindows-driver.git"
+    "url": "https://github.com/nguyenvanhuy0612/appium-novawindows2-driver.git"
   },
   "bugs": {
-    "url": "https://github.com/nguyenvanhuy0612/appium-novawindows-driver/issues"
+    "url": "https://github.com/nguyenvanhuy0612/appium-novawindows2-driver/issues"
   },
   "peerDependencies": {
     "appium": "^3.1.0"
@@ -41,7 +41,7 @@
     "platformNames": [
       "Windows"
     ],
-    "mainClass": "NovaWindowsDriver"
+    "mainClass": "NovaWindows2Driver"
   },
   "devDependencies": {
     "@appium/eslint-config-appium-ts": "^2.0.3",
@@ -56,6 +56,7 @@
     "semantic-release": "^25.0.1",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.1",
-    "webdriverio": "^9.21.0"
+    "webdriverio": "^9.21.0",
+    "axios": "^1.4.0"
   }
-}
+}

package/examples/C#/CalculatorTest/CalculatorTest/CalculatorSession.cs

@@ -1,44 +0,0 @@
-// Based on the original WinAppDriver Calculator test by Microsoft, licensed under the MIT License.
-
-using OpenQA.Selenium.Appium;
-using OpenQA.Selenium.Appium.Windows;
-
-namespace CalculatorTest;
-
-public class CalculatorSession
-{
-    private const string AppiumServerUrl = "http://127.0.0.1:4723/";
-    private const string CalculatorAppId = "Microsoft.WindowsCalculator_8wekyb3d8bbwe!App";
-
-    protected static WindowsDriver Session { get; private set; }
-
-    protected static void Setup()
-    {
-        if (Session != null) return;
-
-        // Launch Calculator application if it is not yet launched
-        // Create a new session to bring up an instance of the Calculator application
-        // Note: Multiple calculator windows (instances) share the same process Id
-        var appiumOptions = new AppiumOptions
-        {
-            App = CalculatorAppId,
-            AutomationName = "NovaWindows",
-            PlatformName = "Windows",
-        };
-
-        Session = new WindowsDriver(new Uri(AppiumServerUrl), appiumOptions);
-        Assert.That(Session, Is.Not.Null);
-
-        // Set implicit timeout to 1.5 seconds to make element search to retry every 500 ms for at most three times
-        Session.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(1.5);
-    }
-
-    protected static void TearDown()
-    {
-        if (Session == null) return;
-
-        // Close the application and delete the session
-        Session.Quit();
-        Session = null;
-    }
-}

package/examples/C#/CalculatorTest/CalculatorTest/CalculatorTest.csproj

@@ -1,24 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-    <PropertyGroup>
-        <TargetFramework>net8.0</TargetFramework>
-        <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>disable</Nullable>
-
-        <IsPackable>false</IsPackable>
-        <IsTestProject>true</IsTestProject>
-    </PropertyGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Appium.WebDriver" Version="7.2.0" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
-        <PackageReference Include="NUnit" Version="3.14.0"/>
-        <PackageReference Include="NUnit.Analyzers" Version="3.9.0"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
-    </ItemGroup>
-
-    <ItemGroup>
-        <Using Include="NUnit.Framework"/>
-    </ItemGroup>
-
-</Project>