appium-novawindows2-driver 0.1.1

package/lib/xpath/functions.ts

@@ -0,0 +1,366 @@
+import { errors } from '@appium/base-driver';
+
+import {
+    FunctionName,
+    ExprNode,
+    BOOLEAN,
+    CONCAT,
+    CONTAINS,
+    COUNT,
+    FALSE,
+    ROUND,
+    CEILING,
+    FLOOR,
+    ID,
+    LAST,
+    LOCAL_NAME,
+    NAME,
+    NORMALIZE_SPACE,
+    NOT,
+    POSITION,
+    STARTS_WITH,
+    STRING_LENGTH,
+    NUMBER,
+    STRING,
+    SUBSTRING_AFTER,
+    SUBSTRING_BEFORE,
+    SUBSTRING,
+    SUM,
+    TRANSLATE,
+    TRUE
+} from 'xpath-analyzer';
+
+import { AutomationElement, PropertyCondition, Property, PSInt32Array, TreeScope, FoundAutomationElement } from '../powershell';
+import { $ } from '../util';
+import { processExprNode } from './core';
+
+const FUNCTION_ARGUMENT_ERROR = $`Function ${0}() requires ${1}.`;
+
+export async function handleFunctionCall<T>(name: FunctionName, context: AutomationElement, sendPowerShellCommand: (command: string) => Promise<string>, ...args: ExprNode[]): Promise<T[]> {
+    const processArgs = async <T>(...args: ExprNode[]): Promise<T[][]> => {
+        const results: T[][] = [];
+        for (const arg of args) {
+            results.push(await processExprNode(arg, context, sendPowerShellCommand));
+        }
+
+        return results;
+    };
+
+    switch (name) {
+        case NOT:
+        case BOOLEAN: {
+            if (args.length !== 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 1 argument'));
+            }
+
+            const [resultArray] = await processArgs(args[0]);
+            const result = Boolean(resultArray[0]);
+            return [name === NOT ? !result as T : result as T];
+        }
+        case CONCAT: {
+            if (args.length < 2) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'at least 2 arguments'));
+            }
+
+            const resultArrays = await processArgs(...args);
+            if (resultArrays.some((resultArray) => resultArray.length > 1)) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to have either one or zero elements'));
+            }
+
+            const stringArray = convertProcessedExprNodesToStrings(...resultArrays.map((resultArray) => resultArray[0]));
+            return [String.prototype.concat(...stringArray) as T];
+        }
+        case STARTS_WITH:
+        case CONTAINS: {
+            if (args.length !== 2) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 2 arguments'));
+            }
+
+            const [firstArgResult, secondArgResult] = await processArgs<string | boolean | AutomationElement>(args[0], args[1]);
+
+            if (firstArgResult.length > 1 || secondArgResult.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to have either one or zero elements'));
+            }
+
+            const [lhs] = firstArgResult;
+            const [rhs] = secondArgResult;
+
+            if (typeof lhs === 'boolean') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be string, number or element'));
+            }
+
+            if (typeof rhs === 'boolean') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the second argument to be string, number or element'));
+            }
+
+            const stringMethodMap = {
+                [STARTS_WITH]: 'startsWith',
+                [CONTAINS]: 'includes',
+            } as const satisfies Record<typeof name, keyof string>;
+
+            const [lhsString, rhsString] = convertProcessedExprNodesToStrings(firstArgResult, secondArgResult);
+            return [lhsString[stringMethodMap[name]](rhsString) as T];
+        }
+        case COUNT: {
+            if (args.length !== 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 1 argument'));
+            }
+
+            const resultArray = await processArgs(args[0]);
+            return [resultArray.length as T];
+        }
+        case TRUE:
+        case FALSE:
+            if (args.length > 0) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'to have 0 arguments'));
+            }
+
+            return [name === TRUE ? true as T : false as T];
+        case ROUND:
+        case CEILING:
+        case FLOOR: {
+            if (args.length !== 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 1 argument'));
+            }
+
+            const resultArray = await processArgs(args[0]);
+            const [num] = resultArray[0];
+            if (typeof num !== 'number') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be a number'));
+            }
+
+            const mathMethodMap = {
+                [ROUND]: 'round',
+                [FLOOR]: 'floor',
+                [CEILING]: 'ceil',
+            } as const satisfies Record<typeof name, keyof Math>;
+
+            return [Math[mathMethodMap[name]](num) as T];
+        }
+        case ID: {
+            if (args.length !== 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 1 argument'));
+            }
+
+            const resultArray = await processArgs(args[0]);
+            const stringArray = convertProcessedExprNodesToStrings(...resultArray);
+
+            const ids = Array.from(new Set(stringArray.flatMap((string) => string.split(/\s+/))));
+            const conditions = ids.map((id) => new PropertyCondition(Property.RUNTIME_ID, new PSInt32Array(id.split('.').map(Number))));
+            const results: string[] = [];
+            for (const condition of conditions) {
+                results.push(await sendPowerShellCommand(AutomationElement.rootElement.findFirst(TreeScope.SUBTREE, condition).buildCommand()));
+            }
+
+            return results.map((result) => new FoundAutomationElement(result.trim()) as T);
+        }
+        case POSITION:
+        case LAST: {
+            if (args.length > 0) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'to have 0 arguments'));
+            }
+
+            const elIds = await sendPowerShellCommand(context.buildCommand());
+            const lastElementIndex = elIds.split('\n').map((id) => id.trim()).filter(Boolean).length;
+            return name === LAST ? [lastElementIndex as T] : Array.from({ length: lastElementIndex }, () => 0 as T);
+        }
+        case LOCAL_NAME:
+        case NAME: {
+            if (args.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'no more than 1 argument'));
+            }
+
+            const [argResult] = await processArgs<AutomationElement>(args[0]);
+
+            if (argResult && argResult.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to have either one or zero elements'));
+            }
+
+            const [element] = argResult ?? [context];
+
+            if (!(element instanceof AutomationElement)) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be element'));
+            }
+
+            const result = await sendPowerShellCommand(element.buildGetTagNameCommand());
+            return result.split('\n').map((x) => x.trim() as T);
+        }
+        case NORMALIZE_SPACE: {
+            if (args.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'no more than 1 argument'));
+            }
+
+            const [argResult] = await processArgs<AutomationElement | string>(args[0]);
+
+            if (argResult && argResult.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to have either one or zero elements'));
+            }
+
+            if (!argResult[0] || argResult[0] instanceof AutomationElement) {
+                return ['' as T];
+            }
+
+            if (typeof argResult[0] === 'string') {
+                return [argResult[0].trim().replace(/\s+/g, ' ') as T];
+            }
+
+            throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be string or element'));
+        }
+        case STRING_LENGTH: {
+            if (args.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'no more than 1 argument'));
+            }
+
+            const [argResult] = await processArgs<AutomationElement | string>(args[0]);
+
+            if (argResult && argResult.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to have either one or zero elements'));
+            }
+
+            if (!argResult[0] || argResult[0] instanceof AutomationElement) {
+                return [0 as T];
+            }
+
+            if (typeof argResult[0] === 'string') {
+                return [argResult[0].length as T];
+            }
+
+            throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be string or element'));
+        }
+        case TRANSLATE:{
+            if (args.length !== 3) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 3 arguments'));
+            }
+
+            const [firstArgResult, secondArgResult, thirdArgResult] = await processArgs<string | AutomationElement>(args[0], args[1], args[2]);
+
+            if (firstArgResult.length > 1 || secondArgResult.length > 1 || thirdArgResult.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to have either one or zero elements'));
+            }
+
+            const [[str], [from], [to]] = [firstArgResult, secondArgResult, thirdArgResult];
+
+            if (![str, from, to].every((x) => typeof x === 'string' || x instanceof AutomationElement)) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to be string or element'));
+            }
+
+            if (str instanceof AutomationElement) {
+                return ['' as T];
+            }
+
+            if (from instanceof AutomationElement) {
+                return [str as T];
+            }
+
+            const result = str.split('').map((char) => {
+                const index = from.indexOf(char);
+                return index !== -1 ? (to instanceof AutomationElement ? '' : to)[index] ?? '' : char;
+            }).join('');
+
+            return [result as T];
+        }
+        case NUMBER:
+        case STRING: {
+            if (args.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'no more than 1 argument'));
+            }
+
+            const [firstArg] = await processArgs(args[0]);
+
+            if (firstArg && firstArg.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to have either one or zero elements'));
+            }
+
+            return name === STRING ? [...convertProcessedExprNodesToStrings(firstArg ?? [context]) as T[]] : [...convertProcessedExprNodesToNumbers(firstArg ?? [context]) as T[]];
+        }
+        case SUBSTRING_AFTER:
+        case SUBSTRING_BEFORE: {
+            if (args.length !== 2) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 2 arguments'));
+            }
+
+            const [firstArgResult, secondArgResult] = await processArgs<string | boolean | AutomationElement>(args[0], args[1]);
+
+            if (firstArgResult.length > 1 || secondArgResult.length > 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'each argument to have either one or zero elements'));
+            }
+
+            const [lhs] = firstArgResult;
+            const [rhs] = secondArgResult;
+
+            if (typeof lhs === 'boolean') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be string, number or element'));
+            }
+
+            if (typeof rhs === 'boolean') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the second argument to be string, number or element'));
+            }
+
+            const [firstString] = convertProcessedExprNodesToStrings(firstArgResult);
+            const [secondString] = convertProcessedExprNodesToStrings(secondArgResult);
+
+            const index = firstString.indexOf(secondString);
+
+            if (index === -1) {
+                return ['' as T];
+            }
+
+            return name === SUBSTRING_BEFORE ? [firstString.slice(0, index) as T] : [firstString.slice(index + 1) as T];
+        }
+        case SUBSTRING: {
+            if (args.length < 2) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'at least 2 arguments'));
+            }
+
+            if (args.length > 3) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'no more than 3 arguments'));
+            }
+
+            const [stringArg, fromArg, countArg] = await processArgs(...args);
+
+            if (typeof stringArg[0] === 'boolean' || typeof stringArg[0] === 'number') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the first argument to be string or element'));
+            }
+
+            const [string] = convertProcessedExprNodesToStrings(stringArg);
+            const [index] = fromArg;
+            const [count] = countArg;
+
+            if (typeof index !== 'number') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the second argument to be number'));
+            }
+
+            if (typeof count !== 'number' && typeof count !== 'undefined') {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'the second argument to be number'));
+            }
+
+            if (count && count < 0) {
+                return ['' as T];
+            }
+
+            return [string.slice(index + 1, count ? index + count : string.length) as T];
+        }
+        case SUM: {
+            if (args.length !== 1) {
+                throw new errors.InvalidArgumentError(FUNCTION_ARGUMENT_ERROR.format(name, 'exactly 1 argument'));
+            }
+
+            const [arg] = await processArgs(args[0]);
+            const argAsNumbers = convertProcessedExprNodesToNumbers(arg);
+            return [argAsNumbers.reduce((a, b) => a + b) as T];
+        }
+        default:
+            throw new errors.InvalidSelectorError(`XPath function ${name}() not found.`);
+    }
+}
+
+function convertProcessedExprNodesToStrings<T>(...arrayOfProcessedExprNodes: T[]): string[] {
+    return arrayOfProcessedExprNodes
+        .map((item) => (item instanceof AutomationElement) ? '' : item) // windows element xml representaton never contains text nodes
+        .map((item) => item === undefined || item === null ? '' : String(item)); // convert not found elements to empty string and others to string
+}
+
+function convertProcessedExprNodesToNumbers<T>(...arrayOfProcessedExprNodes: T[]): number[] {
+    const arrayOfStrings = convertProcessedExprNodesToStrings(...arrayOfProcessedExprNodes);
+    return arrayOfStrings.map((str) => /^\s*(?<![\d.+-])[+-]?(?:\d*[.])?\d+(?![\d.])\s*$/.test(str) ? NaN : Number(str));
+}

package/lib/xpath/index.ts

@@ -0,0 +1,2 @@
+export * from './core';
+export * from './functions';

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "appium-novawindows2-driver",
+  "version": "0.1.1",
+  "description": "Appium driver for Windows",
+  "keywords": [
+    "appium",
+    "novawindows2",
+    "uiautomation",
+    "powershell",
+    "automated testing",
+    "windows"
+  ],
+  "main": "build/lib/driver.js",
+  "scripts": {
+    "build": "tsc -b",
+    "watch": "tsc -b --watch",
+    "lint": "eslint .",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "nguyenvanhuy0612",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nguyenvanhuy0612/appium-novawindows-driver.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nguyenvanhuy0612/appium-novawindows-driver/issues"
+  },
+  "peerDependencies": {
+    "appium": "^3.1.0"
+  },
+  "dependencies": {
+    "@appium/base-driver": "^10.1.0",
+    "bezier-easing": "^2.1.0",
+    "koffi": "^2.14.1",
+    "xpath-analyzer": "^3.0.1"
+  },
+  "appium": {
+    "driverName": "novawindows2",
+    "automationName": "NovaWindows",
+    "platformNames": [
+      "Windows"
+    ],
+    "mainClass": "NovaWindowsDriver"
+  },
+  "devDependencies": {
+    "@appium/eslint-config-appium-ts": "^2.0.3",
+    "@appium/tsconfig": "^1.1.0",
+    "@appium/types": "^1.1.0",
+    "@eslint/js": "^9.38.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/node": "^24.8.1",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "eslint": "^9.38.0",
+    "semantic-release": "^25.0.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.1",
+    "webdriverio": "^9.21.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@appium/tsconfig/tsconfig.json",
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "outDir": "build",
+    "strict": false,
+    "checkJs": true,
+    "types": ["node"],
+    "noImplicitOverride": true,
+  },
+  "include": ["lib", "eslint.config.mjs"]
+}

package/verify_driver.js

@@ -0,0 +1,96 @@
+const { remote } = require('webdriverio');
+const fs = require('fs');
+const path = require('path');
+
+async function main() {
+    const opts = {
+        hostname: '127.0.0.1',
+        port: 4723,
+        path: '/',
+        capabilities: {
+            "appium:automationName": "NovaWindows",
+            "platformName": "Windows",
+            "appium:app": "Root", // Using Root to attach to desktop, verify this is supported
+            "appium:newCommandTimeout": 60
+        },
+        logLevel: 'error'
+    };
+
+    console.log('Initializing session...');
+    let client;
+    try {
+        client = await remote(opts);
+        console.log('Session created successfully.');
+    } catch (err) {
+        console.error('Failed to create session:', err);
+        return;
+    }
+
+    try {
+        // 1. Get Page Source
+        console.log('Test 1: Get Page Source (SKIPPED - too slow for Root)');
+        //const source = await client.getPageSource();
+        //console.log(`Page Source retrieval successful (Length: ${source.length} chars)`);
+
+        // 2. Maximize Window
+        // Note: For Root, maximize might not be applicable to the "desktop" window itself in the same way, 
+        // but we can try getting window size or finding a window to maximize. 
+        // For simplicity, we just log window size.
+        console.log('Test 2: Get Window Rect');
+        const rect = await client.getWindowRect();
+        console.log(`Window Rect: ${JSON.stringify(rect)}`);
+
+        // 3. Take Screenshot
+        console.log('Test 3: Take Screenshot');
+        const screenshotPath = path.resolve(__dirname, 'screenshot.png');
+        await client.saveScreenshot(screenshotPath);
+        if (fs.existsSync(screenshotPath)) {
+            console.log(`Screenshot saved to: ${screenshotPath}`);
+        } else {
+            console.error('Screenshot failed to save.');
+        }
+
+        // 4. Find Element
+        console.log('Test 4: Find Element (XPath)');
+        // Try to find the Taskbar or Start button. 
+        // Common on Windows 10/11: "Starry" or name="Start"
+        // Let's try a generic find first
+        const element = await client.$('//*');
+        if (element.error) {
+            console.error('Failed to find root element');
+        } else {
+            console.log(`Found root element with ID: ${element.elementId}`);
+        }
+
+        // 5. Get Window Handle
+        console.log('Test 5: Get Window Handle');
+        const handle = await client.getWindowHandle();
+        console.log(`Window Handle: ${handle}`);
+
+        // 6. Execute powershell command
+        console.log('Test 6: Execute powershell command');
+        const result = await client.executeScript('powerShell', [{ 'command': 'Get-Process' }]);
+        // console.log(`Result: ${JSON.stringify(result)}`); // Output can be huge, maybe truncate
+        console.log(`Result length: ${JSON.stringify(result).length} chars`);
+
+        // 7. Execute powershell command with exit
+        console.log('Test 7: Execute powershell command with exit');
+        try {
+            const resultExit = await client.executeScript('powerShell', [{ 'command': 'Get-Process; exit 0' }]);
+            console.log(`Result exit length: ${JSON.stringify(resultExit).length}`);
+        } catch (e) {
+            console.log(`Test 7 encountered error as expected (or unexpected): ${e.message}`);
+        }
+
+    } catch (err) {
+        console.error('Test execution failed:', err);
+    } finally {
+        if (client) {
+            console.log('Deleting session...');
+            await client.deleteSession();
+            console.log('Session deleted.');
+        }
+    }
+}
+
+main();