appium-desktop-driver 1.7.2-preview.1 → 1.7.2

package/build/lib/commands/app.js

@@ -12,141 +12,123 @@ exports.changeRootElement = changeRootElement;
 exports.back = back;
 exports.forward = forward;
 exports.title = title;
-exports.maximizeWindow = maximizeWindow;
-exports.minimizeWindow = minimizeWindow;
 exports.setWindowRect = setWindowRect;
-exports.waitForNewWindow = waitForNewWindow;
-exports.attachToWindowHandles = attachToWindowHandles;
 exports.attachToApplicationWindow = attachToApplicationWindow;
-exports.waitForMainWindow = waitForMainWindow;
 const node_path_1 = require("node:path");
-const conditions_1 = require("../server/conditions");
+const powershell_1 = require("../powershell");
 const util_1 = require("../util");
 const base_driver_1 = require("@appium/base-driver");
 const user32_1 = require("../winapi/user32");
 const enums_1 = require("../enums");
-/**
- * Polling interval used when waiting for windows/elements to appear during
- * app launch and window switching.
- *
- * This is deliberately kept low (200ms) because the app launch flow has
- * multiple sequential retry phases that each sleep on failure:
- *
- *   changeRootElement (outer loop)
- *     → attachToApplicationWindow
- *       → waitForNewWindow  (polls for Win32 window handle)
- *       → findElement loop  (polls UIAutomation tree for the element)
- *
- * At 500ms per poll, 10 failed attempts in any one phase cost 5 seconds,
- * and the phases compound. At 200ms the same 10 attempts cost 2 seconds,
- * cutting overall launch latency from 10-15s down to ~3-5s for typical
- * UWP apps like Calculator.
- */
-const POLL_INTERVAL_MS = 200;
-/**
- * Maximum number of polling attempts per retry phase.
- * Combined with POLL_INTERVAL_MS this gives a ~6s window per phase,
- * which is enough for most apps to register in the UIAutomation tree.
- */
-const MAX_POLL_ATTEMPTS = 30;
-// setWindow is called often during a session. If a handle doesn't exist,
-// we fail fast (~400ms) instead of waiting 6s. Session-attach loops below
-// still use MAX_POLL_ATTEMPTS.
-const SET_WINDOW_MAX_POLL_ATTEMPTS = 2;
-/**
- * Normalizes the `ms:waitForAppLaunch` capability to milliseconds.
- *
- * WinAppDriver's spec says the value is in seconds (max 50), but many users
- * pass milliseconds (e.g. 120000 meaning "120 seconds"). We auto-detect:
- * values > 120 are assumed to already be in milliseconds; values ≤ 120 are
- * treated as seconds and converted to ms.
- */
-function normalizeWaitForAppLaunchMs(raw) {
-    if (raw == null || raw <= 0) {
-        return 0;
+const GET_PAGE_SOURCE_COMMAND = (0, powershell_1.pwsh$ /* ps1 */) `
+    $el = ${0}
+
+    if ($el -eq $null) {
+        $dummy = [xml]'<DummyRoot></DummyRoot>'
+        return $dummy.OuterXml
     }
-    // Values > 120 are almost certainly milliseconds (120 seconds is already very generous;
-    // WinAppDriver caps at 50s). Values ≤ 120 are seconds per the original spec.
-    return raw > 120 ? raw : raw * 1000;
-}
+
+    Get-PageSource $el |
+    ForEach-Object { $_.OuterXml }
+`;
+const GET_SCREENSHOT_COMMAND = (0, powershell_1.pwsh /* ps1 */) `
+    if ($rootElement -eq $null) {
+        $bitmap = New-Object Drawing.Bitmap 1,1
+        $stream = New-Object IO.MemoryStream
+        $bitmap.Save($stream, [Drawing.Imaging.ImageFormat]::Png)
+        $bitmap.Dispose()
+        return [Convert]::ToBase64String($stream.ToArray())
+    }
+
+    $rect = $rootElement.Current.BoundingRectangle
+    $bitmap = New-Object Drawing.Bitmap([int32]$rect.Width, [int32]$rect.Height)
+
+    $graphics = [Drawing.Graphics]::FromImage($bitmap)
+    $graphics.CopyFromScreen([int32]$rect.Left, [int32]$rect.Top, 0, 0, $bitmap.Size)
+    $graphics.Dispose()
+
+    $stream = New-Object IO.MemoryStream
+    $bitmap.Save($stream, [Drawing.Imaging.ImageFormat]::Png)
+    $bitmap.Dispose()
+
+    [Convert]::ToBase64String($stream.ToArray())
+`;
+const SLEEP_INTERVAL_MS = 500;
 async function getPageSource() {
-    return await this.sendCommand('getPageSource', {});
+    return await this.sendPowerShellCommand(GET_PAGE_SOURCE_COMMAND.format(powershell_1.AutomationElement.automationRoot));
 }
 async function getScreenshot() {
-    const automationRootId = await this.sendCommand('saveRootElementToTable', {});
+    const automationRootId = await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildCommand());
     if (this.caps.app && this.caps.app.toLowerCase() !== 'root') {
         try {
             await this.focusElement({
-                [base_driver_1.W3C_ELEMENT_KEY]: automationRootId?.trim(),
+                [base_driver_1.W3C_ELEMENT_KEY]: automationRootId.trim(),
             });
         }
         catch {
             // noop
         }
     }
-    return await this.sendCommand('getScreenshot', {});
+    return await this.sendPowerShellCommand(GET_SCREENSHOT_COMMAND);
 }
 async function getWindowRect() {
-    return await this.sendCommand('getRootRect', {});
+    const result = await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildGetElementRectCommand());
+    return JSON.parse(result.replaceAll(/(?:infinity)/gi, 0x7FFFFFFF.toString()));
 }
 async function getWindowHandle() {
-    const rootId = await this.sendCommand('saveRootElementToTable', {});
-    const nativeWindowHandle = await this.sendCommand('getProperty', { elementId: rootId, property: 'NativeWindowHandle' });
+    const nativeWindowHandle = await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildGetPropertyCommand(powershell_1.Property.NATIVE_WINDOW_HANDLE));
     return `0x${Number(nativeWindowHandle).toString(16).padStart(8, '0')}`;
 }
 async function getWindowHandles() {
-    // Search from desktop root (RootElement), not the session root
-    const elIds = await this.sendCommand('findElements', {
-        scope: 'children',
-        condition: (0, conditions_1.trueCondition)(),
-        contextElementId: null,
-    });
+    if (this.appProcessIds.length > 0 && !this.caps.returnAllWindowHandles) {
+        const handles = (0, user32_1.getWindowAllHandlesForProcessIds)(this.appProcessIds);
+        return handles.map((h) => `0x${h.toString(16).padStart(8, '0')}`);
+    }
+    const result = await this.sendPowerShellCommand(powershell_1.AutomationElement.rootElement.findAll(powershell_1.TreeScope.CHILDREN, new powershell_1.TrueCondition()).buildCommand());
+    const elIds = result.split('\n').map((x) => x.trim()).filter(Boolean);
     const nativeWindowHandles = [];
-    for (const elId of elIds ?? []) {
-        const nativeWindowHandle = await this.sendCommand('getProperty', { elementId: elId, property: 'NativeWindowHandle' });
+    for (const elId of elIds) {
+        const nativeWindowHandle = await this.sendPowerShellCommand(new powershell_1.FoundAutomationElement(elId).buildGetPropertyCommand(powershell_1.Property.NATIVE_WINDOW_HANDLE));
         nativeWindowHandles.push(`0x${Number(nativeWindowHandle).toString(16).padStart(8, '0')}`);
     }
     return nativeWindowHandles;
 }
 async function setWindow(nameOrHandle) {
     const handle = Number(nameOrHandle);
-    for (let i = 1; i <= SET_WINDOW_MAX_POLL_ATTEMPTS; i++) {
+    const maxRetries = this.caps['ms:windowSwitchRetries'] ?? 20;
+    const sleepInterval = this.caps['ms:windowSwitchInterval'] ?? SLEEP_INTERVAL_MS;
+    for (let i = 1; i <= maxRetries; i++) {
         if (!isNaN(handle)) {
-            const elementId = await this.sendCommand('findElement', {
-                scope: 'child-or-self',
-                condition: (0, conditions_1.propertyCondition)('NativeWindowHandle', handle),
-                contextElementId: null,
-            });
-            if (elementId && elementId.trim() !== '') {
-                await this.sendCommand('setRootElementFromElementId', { elementId });
+            const condition = new powershell_1.PropertyCondition(powershell_1.Property.NATIVE_WINDOW_HANDLE, new powershell_1.PSInt32(handle));
+            const elementId = await this.sendPowerShellCommand(powershell_1.AutomationElement.rootElement.findFirst(powershell_1.TreeScope.CHILDREN_OR_SELF, condition).buildCommand());
+            if (elementId.trim() !== '') {
+                await this.sendPowerShellCommand(/* ps1 */ `$rootElement = ${new powershell_1.FoundAutomationElement(elementId).buildCommand()}`);
                 (0, user32_1.trySetForegroundWindow)(handle);
                 return;
             }
         }
         const name = nameOrHandle;
-        const elementId = await this.sendCommand('findElement', {
-            scope: 'children',
-            condition: (0, conditions_1.propertyCondition)('Name', name),
-            contextElementId: null,
-        });
-        if (elementId && elementId.trim() !== '') {
+        const condition = new powershell_1.PropertyCondition(powershell_1.Property.NAME, new powershell_1.PSString(name));
+        const elementId = await this.sendPowerShellCommand(powershell_1.AutomationElement.rootElement.findFirst(powershell_1.TreeScope.CHILDREN, condition).buildCommand());
+        if (elementId.trim() !== '') {
             this.log.info(`Found window with name '${name}'. Setting it as the root element.`);
-            await this.sendCommand('setRootElementFromElementId', { elementId });
+            await this.sendPowerShellCommand(/* ps1 */ `$rootElement = ${new powershell_1.FoundAutomationElement(elementId).buildCommand()}`);
             (0, user32_1.trySetForegroundWindow)(handle);
             return;
         }
-        this.log.info(`Failed to locate window with name '${name}'. Sleeping for ${POLL_INTERVAL_MS}ms and retrying... (${i}/${SET_WINDOW_MAX_POLL_ATTEMPTS})`);
-        await (0, util_1.sleep)(POLL_INTERVAL_MS);
+        this.log.info(`Failed to locate window with name '${name}'. Sleeping for ${sleepInterval} milliseconds and retrying... (${i}/${maxRetries})`);
+        await (0, util_1.sleep)(sleepInterval);
     }
     throw new base_driver_1.errors.NoSuchWindowError(`No window was found with name or handle '${nameOrHandle}'.`);
 }
 async function closeApp() {
-    const rootId = await this.sendCommand('saveRootElementToTable', {});
-    if (!rootId) {
+    const result = await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildCommand());
+    const elementId = result.split('\n').map((id) => id.trim()).filter(Boolean)[0];
+    if (!elementId) {
         throw new base_driver_1.errors.NoSuchWindowError('No active app window is found for this session.');
     }
-    await this.sendCommand('closeWindow', { elementId: rootId });
-    await this.sendCommand('setRootElementNull', {});
+    await this.sendPowerShellCommand(new powershell_1.FoundAutomationElement(elementId).buildCloseCommand());
+    await this.sendPowerShellCommand(/* ps1 */ `$rootElement = $null`);
 }
 async function launchApp() {
     if (!this.caps.app || ['root', 'none'].includes(this.caps.app.toLowerCase())) {
@@ -157,103 +139,55 @@ async function launchApp() {
 async function changeRootElement(pathOrNativeWindowHandle) {
     if (typeof pathOrNativeWindowHandle === 'number') {
         const nativeWindowHandle = pathOrNativeWindowHandle;
-        const elementId = await this.sendCommand('setRootElementFromHandle', { handle: nativeWindowHandle });
-        if (elementId) {
+        const condition = new powershell_1.PropertyCondition(powershell_1.Property.NATIVE_WINDOW_HANDLE, new powershell_1.PSInt32(nativeWindowHandle));
+        const elementId = await this.sendPowerShellCommand(powershell_1.AutomationElement.rootElement.findFirst(powershell_1.TreeScope.CHILDREN_OR_SELF, condition).buildCommand());
+        if (elementId.trim() !== '') {
+            await this.sendPowerShellCommand(/* ps1 */ `$rootElement = ${new powershell_1.FoundAutomationElement(elementId).buildCommand()}`);
             (0, user32_1.trySetForegroundWindow)(nativeWindowHandle);
+            const pidResult = await this.sendPowerShellCommand(`$rootElement.Current.ProcessId`);
+            const pid = Number(pidResult.trim());
+            if (!isNaN(pid) && pid > 0) {
+                this.appProcessIds = [pid];
+            }
             return;
         }
         throw new base_driver_1.errors.UnknownError('Failed to locate top level window with that window handle.');
     }
     const path = pathOrNativeWindowHandle;
-    const isUwp = path.includes('!') && path.includes('_') && !(path.includes('/') || path.includes('\\'));
-    const waitForAppLaunchMs = normalizeWaitForAppLaunchMs(this.caps['ms:waitForAppLaunch']);
-    // When ms:waitForAppLaunch is set, use it as an overall deadline for
-    // all retry loops. When not set, fall back to fixed iteration counts.
-    const deadline = waitForAppLaunchMs ? Date.now() + waitForAppLaunchMs : null;
-    if (isUwp) {
+    if ((0, util_1.isUwpAppId)(path)) {
         this.log.debug('Detected app path to be in the UWP format.');
-        // Snapshot all visible windows before launch so we can detect new ones.
-        // WinUI 3 packaged apps (e.g. Windows 11 Calculator) run in their own
-        // process rather than being hosted inside ApplicationFrameHost like
-        // legacy UWP apps. The snapshot lets us tell apart the new app window
-        // from pre-existing windows that belong to other apps or to
-        // ApplicationFrameHost itself.
-        const handlesBeforeLaunch = new Set((0, user32_1.getAllWindowHandles)());
-        await this.sendCommand('startProcess', {
-            path: 'explorer.exe',
-            arguments: `shell:AppsFolder\\${path}`,
-        });
-        // Outer retry loop: polls until the app window is found or the
-        // deadline / attempt limit is reached. Each iteration is one
-        // POLL_INTERVAL_MS tick — no blind sleep up front.
-        for (let i = 1; deadline ? Date.now() < deadline : i <= 10; i++) {
-            // Strategy 1: new window detection.
-            // Works for WinUI 3 / standalone packaged apps that spawn a new
-            // top-level window in their own process.
-            const newHandles = (0, user32_1.getAllWindowHandles)().filter((h) => !handlesBeforeLaunch.has(h));
-            if (newHandles.length > 0) {
-                this.log.debug(`Found ${newHandles.length} new window(s) since launch: ${newHandles.map((h) => `0x${h.toString(16).padStart(8, '0')}`).join(', ')}`);
-                try {
-                    if (await this.attachToWindowHandles(newHandles)) {
-                        return;
-                    }
-                }
-                catch (err) {
-                    if (err instanceof Error) {
-                        this.log.debug(`New-window strategy failed: ${err.message}`);
-                    }
-                }
-            }
-            // Strategy 2: ApplicationFrameHost.
-            // Works for legacy hosted UWP apps. Prefer newly appeared
-            // ApplicationFrameHost windows (i.e. the frame that opened for
-            // this specific launch) to avoid accidentally attaching to a
-            // pre-existing frame that belongs to another UWP app.
-            const processIds = await this.sendCommand('getProcessIds', { processName: 'ApplicationFrameHost' });
-            if (processIds.length > 0) {
-                const afhHandles = (0, user32_1.getWindowAllHandlesForProcessIds)(processIds);
-                const newAfhHandles = afhHandles.filter((h) => !handlesBeforeLaunch.has(h));
-                const handlesToTry = newAfhHandles.length > 0 ? newAfhHandles : afhHandles;
-                this.log.debug(`ApplicationFrameHost strategy: trying ${handlesToTry.length} handle(s).`);
-                try {
-                    if (await this.attachToWindowHandles(handlesToTry)) {
-                        return;
-                    }
-                }
-                catch (err) {
-                    if (err instanceof Error) {
-                        this.log.debug(`ApplicationFrameHost strategy failed: ${err.message}`);
-                    }
-                }
-            }
-            this.log.info(`Failed to locate window of the app. Sleeping for ${POLL_INTERVAL_MS}ms and retrying... (attempt ${i})`);
-            await (0, util_1.sleep)(POLL_INTERVAL_MS);
+        await this.sendPowerShellCommand(/* ps1 */ `Start-Process 'explorer.exe' 'shell:AppsFolder\\${path}'${this.caps.appArguments ? ` -ArgumentList '${this.caps.appArguments}'` : ''}`);
+        const result = await this.sendPowerShellCommand(/* ps1 */ `(Get-Process -Name 'ApplicationFrameHost').Id`);
+        const processIds = result.split('\n').map((pid) => pid.trim()).filter(Boolean).map(Number);
+        this.log.debug(`Process IDs of ApplicationFrameHost processes (${processIds.length}): ` + processIds.join(', '));
+        this.appProcessIds = processIds;
+        await this.attachToApplicationWindow(processIds);
+        const attachedPid = Number((await this.sendPowerShellCommand(`$rootElement.Current.ProcessId`)).trim());
+        if (!isNaN(attachedPid) && attachedPid > 0) {
+            this.appProcessIds = [attachedPid];
         }
     }
     else {
         this.log.debug('Detected app path to be in the classic format.');
         const normalizedPath = (0, node_path_1.normalize)(path);
-        const launcherPid = await this.sendCommand('startProcess', {
-            path: normalizedPath,
-            arguments: this.caps.appArguments ?? null,
-            workingDir: this.caps.appWorkingDir ?? null,
-            waitForAppLaunchMs: waitForAppLaunchMs || null,
-        });
-        if (!launcherPid) {
-            throw new base_driver_1.errors.UnknownError('Process did not start (no PID returned).');
+        await this.sendPowerShellCommand(/* ps1 */ `Start-Process '${normalizedPath}'${this.caps.appArguments ? ` -ArgumentList '${this.caps.appArguments}'` : ''}`);
+        const breadcrumbs = normalizedPath.toLowerCase().split('\\').flatMap((x) => x.split('/'));
+        const executable = breadcrumbs[breadcrumbs.length - 1];
+        const processName = executable.endsWith('.exe') ? executable.slice(0, executable.length - 4) : executable;
+        const result = await this.sendPowerShellCommand(/* ps1 */ `(Get-Process -Name '${processName}' | Sort-Object StartTime -Descending).Id`);
+        const processIds = result.split('\n').map((pid) => pid.trim()).filter(Boolean).map(Number);
+        this.log.debug(`Process IDs of '${processName}' processes: ` + processIds.join(', '));
+        this.appProcessIds = processIds;
+        await this.attachToApplicationWindow(processIds);
+        const attachedPid = Number((await this.sendPowerShellCommand(`$rootElement.Current.ProcessId`)).trim());
+        if (!isNaN(attachedPid) && attachedPid > 0) {
+            this.appProcessIds = [attachedPid];
         }
-        const result = await this.attachToApplicationWindow(launcherPid, { deadline });
-        if (!result.focused && deadline && Date.now() < deadline) {
-            this.log.info('Attached to a window that cannot receive focus (likely a splash screen). Waiting for the main window...');
-            await this.waitForMainWindow(result.knownPids, deadline);
-        }
-        return;
     }
-    throw new base_driver_1.errors.UnknownError('Failed to locate window of the app.');
 }
 async function back() {
-    const rootId = (await this.sendCommand('saveRootElementToTable', {}))?.trim();
-    if (!rootId) {
+    const elementId = (await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildCommand())).trim();
+    if (!elementId) {
         throw new base_driver_1.errors.NoSuchWindowError('No active window found for this session.');
     }
     (0, user32_1.keyDown)(enums_1.Key.ALT);
@@ -262,8 +196,8 @@ async function back() {
     (0, user32_1.keyUp)(enums_1.Key.ALT);
 }
 async function forward() {
-    const rootId = (await this.sendCommand('saveRootElementToTable', {}))?.trim();
-    if (!rootId) {
+    const elementId = (await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildCommand())).trim();
+    if (!elementId) {
         throw new base_driver_1.errors.NoSuchWindowError('No active window found for this session.');
     }
     (0, user32_1.keyDown)(enums_1.Key.ALT);
@@ -272,27 +206,11 @@ async function forward() {
     (0, user32_1.keyUp)(enums_1.Key.ALT);
 }
 async function title() {
-    const rootId = (await this.sendCommand('saveRootElementToTable', {}))?.trim();
-    if (!rootId) {
-        throw new base_driver_1.errors.NoSuchWindowError('No active window found for this session.');
-    }
-    return await this.sendCommand('getProperty', { elementId: rootId, property: 'Name' });
-}
-async function maximizeWindow() {
-    const elementId = (await this.sendCommand('saveRootElementToTable', {}))?.trim();
-    if (!elementId) {
-        throw new base_driver_1.errors.NoSuchWindowError('No active window found for this session.');
-    }
-    await this.sendCommand('maximizeWindow', { elementId });
-    return await this.getWindowRect();
-}
-async function minimizeWindow() {
-    const elementId = (await this.sendCommand('saveRootElementToTable', {}))?.trim();
+    const elementId = (await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildCommand())).trim();
     if (!elementId) {
         throw new base_driver_1.errors.NoSuchWindowError('No active window found for this session.');
     }
-    await this.sendCommand('minimizeWindow', { elementId });
-    return await this.getWindowRect();
+    return await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildGetPropertyCommand(powershell_1.Property.NAME));
 }
 async function setWindowRect(x, y, width, height) {
     if (width !== null && width < 0) {
@@ -301,253 +219,67 @@ async function setWindowRect(x, y, width, height) {
     if (height !== null && height < 0) {
         throw new base_driver_1.errors.InvalidArgumentError('height must be a non-negative integer.');
     }
-    const elementId = (await this.sendCommand('saveRootElementToTable', {}))?.trim();
+    const elementId = (await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildCommand())).trim();
     if (!elementId) {
         throw new base_driver_1.errors.NoSuchWindowError('No active window found for this session.');
     }
-    // TransformPattern.Move/Resize fail when window is maximized or minimized;
-    // restore to normal state first so CanMove/CanResize are true.
-    await this.sendCommand('restoreWindow', { elementId });
+    const el = new powershell_1.FoundAutomationElement(elementId);
     if (x !== null && y !== null) {
-        await this.sendCommand('moveWindow', { elementId, x, y });
+        await this.sendPowerShellCommand(el.buildMoveCommand(x, y));
     }
     if (width !== null && height !== null) {
-        await this.sendCommand('resizeWindow', { elementId, width, height });
+        await this.sendPowerShellCommand(el.buildResizeCommand(width, height));
     }
     return await this.getWindowRect();
 }
-/**
- * Polls for a visible Win32 window in the process tree rooted at launcherPid.
- *
- * On each iteration, discovers children of every known PID via
- * getChildProcessIds and accumulates them so they survive if the launcher
- * exits before the next poll. This lets stub-launcher apps (e.g. the
- * notepad.exe that immediately re-execs the real one in a child process) be
- * detected without waiting out the full timeout on a windowless PID.
- *
- * Returns the HWND of the found window together with all discovered PIDs so
- * the caller can use them for subsequent ProcessId-based searches without a
- * separate getProcessIds round-trip.
- */
-async function waitForNewWindow(launcherPid, timeout) {
+async function attachToApplicationWindow(processIds) {
+    const trackedPids = new Set(processIds);
+    this.log.debug(`Attaching to application window. Process IDs: [${[...trackedPids].join(', ')}]`);
+    const timeout = (this.caps['ms:waitForAppLaunch'] ?? 0) * 1000 || SLEEP_INTERVAL_MS * 20;
     const start = Date.now();
     let attempts = 0;
-    const knownPids = new Set([launcherPid]);
     while (Date.now() - start < timeout) {
-        for (const pid of [...knownPids]) {
-            const childPids = await this.sendCommand('getChildProcessIds', { parentPid: pid });
-            for (const child of childPids) {
-                knownPids.add(child);
+        // Discover child processes of all currently-tracked PIDs
+        const pidList = [...trackedPids].join(', ');
+        const childPidResult = await this.sendPowerShellCommand(
+        /* ps1 */ `@(Get-CimInstance Win32_Process | Where-Object { $_.ParentProcessId -in @(${pidList}) }).ProcessId`);
+        for (const token of childPidResult.split('\n').map((s) => s.trim()).filter(Boolean)) {
+            const childPid = Number(token);
+            if (!isNaN(childPid) && childPid > 0 && !trackedPids.has(childPid)) {
+                this.log.debug(`Discovered child process PID ${childPid} spawned by tracked PIDs`);
+                trackedPids.add(childPid);
             }
         }
-        const handles = (0, user32_1.getWindowAllHandlesForProcessIds)([...knownPids]);
+        const currentPids = [...trackedPids];
+        const handles = (0, user32_1.getWindowAllHandlesForProcessIds)(currentPids);
         if (handles.length > 0) {
-            return { handle: handles[handles.length - 1], knownPids: [...knownPids] };
-        }
-        this.log.debug(`Waiting for the process window to appear... (${++attempts}/${Math.floor(timeout / POLL_INTERVAL_MS)})`);
-        await (0, util_1.sleep)(POLL_INTERVAL_MS);
-    }
-    throw new Error('Timed out waiting for window.');
-}
-/**
- * Iterates a list of Win32 window handles, finds the first one whose UIA
- * subtree has at least two keyboard-focusable descendants (indicating it is a
- * real, loaded app window rather than a splash or empty frame), sets it as the
- * session root, and brings it to the foreground.
- *
- * Returns true if a window was successfully attached, false if none qualified.
- */
-async function attachToWindowHandles(handles) {
-    let fallbackElementId = '';
-    for (const hwnd of handles) {
-        let candidateId = '';
-        try {
-            candidateId = await this.sendCommand('elementFromHandle', { handle: hwnd }) ?? '';
-        }
-        catch {
-            continue;
-        }
-        if (!candidateId) {
-            continue;
-        }
-        if (!fallbackElementId) {
-            fallbackElementId = candidateId;
-        }
-        const focusables = await this.sendCommand('findElements', {
-            scope: 'descendants',
-            condition: (0, conditions_1.propertyCondition)('IsKeyboardFocusable', true),
-            contextElementId: candidateId,
-        });
-        if (focusables && focusables.length >= 2) {
-            this.log.info(`Attaching to window 0x${hwnd.toString(16).padStart(8, '0')} (${focusables.length} focusable descendants).`);
-            await this.sendCommand('setRootElementFromElementId', { elementId: candidateId });
-            const isNotNull = await this.sendCommand('checkRootElementNotNull', {});
-            if (isNotNull) {
-                const rootId = await this.sendCommand('saveRootElementToTable', {});
-                const nwh = Number(await this.sendCommand('getProperty', { elementId: rootId, property: 'NativeWindowHandle' }));
-                (0, user32_1.trySetForegroundWindow)(nwh);
-            }
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Attaches the driver session to the window spawned by launcherPid.
- *
- * Delegates process-tree discovery to waitForNewWindow, then resolves the
- * Win32 HWND to a UIA element via elementFromHandle (with a short ProcessId
- * fallback for the rare case where UIA registration lags the Win32 window).
- * Returns focused=false when the attached window looks like a splash screen
- * (fewer than 2 keyboard-focusable descendants), signalling the caller to
- * run waitForMainWindow.
- */
-async function attachToApplicationWindow(launcherPid, options = {}) {
-    const { deadline = null } = options;
-    const waitForAppLaunchMs = normalizeWaitForAppLaunchMs(this.caps['ms:waitForAppLaunch']) || POLL_INTERVAL_MS * MAX_POLL_ATTEMPTS;
-    const windowTimeout = deadline
-        ? Math.min(waitForAppLaunchMs, Math.max(0, deadline - Date.now()))
-        : waitForAppLaunchMs;
-    const { handle: nativeWindowHandle, knownPids } = await waitForNewWindow.call(this, launcherPid, windowTimeout);
-    let elementId = '';
-    // Short retry for UIA registration lag: the Win32 window exists (waitForNewWindow
-    // confirmed it), but the UIA COM provider may take a moment to initialise.
-    // 5 attempts × 200 ms = 1 s — enough for any real app; avoids the old 6 s burn.
-    for (let i = 1; i <= 5; i++) {
-        try {
-            elementId = await this.sendCommand('elementFromHandle', { handle: nativeWindowHandle }) ?? '';
-        }
-        catch {
-            elementId = '';
-        }
-        if (!elementId) {
-            for (const pid of knownPids) {
-                const foundId = await this.sendCommand('findElement', {
-                    scope: 'children',
-                    condition: (0, conditions_1.propertyCondition)('ProcessId', pid),
-                    contextElementId: null,
-                }) ?? '';
-                if (foundId) {
-                    this.log.info(`Found window by ProcessId ${pid} (handle mismatch: Win32=0x${nativeWindowHandle.toString(16).padStart(8, '0')})`);
-                    elementId = foundId;
-                    break;
-                }
-            }
-        }
-        if (elementId) {
-            break;
-        }
-        this.log.debug(`Window 0x${nativeWindowHandle.toString(16).padStart(8, '0')} not yet in UIA tree, retry ${i}/5...`);
-        await (0, util_1.sleep)(POLL_INTERVAL_MS);
-    }
-    if (!elementId) {
-        throw new base_driver_1.errors.UnknownError(`Window 0x${nativeWindowHandle.toString(16).padStart(8, '0')} did not appear in the UI Automation tree.`);
-    }
-    await this.sendCommand('setRootElementFromElementId', { elementId });
-    const isNotNull = await this.sendCommand('checkRootElementNotNull', {});
-    if (isNotNull) {
-        const rootId = await this.sendCommand('saveRootElementToTable', {});
-        const nwh = Number(await this.sendCommand('getProperty', { elementId: rootId, property: 'NativeWindowHandle' }));
-        let focused = (0, user32_1.trySetForegroundWindow)(nwh);
-        if (!focused) {
-            try {
-                await this.focusElement({ [base_driver_1.W3C_ELEMENT_KEY]: elementId });
-                focused = true;
-            }
-            catch {
-                // Window cannot receive focus (e.g. splash screen)
-            }
-        }
-        // Splash-screen guard: probe for focusable descendants.
-        // Splash screens have 0–1; real app windows have several.
-        if (focused) {
-            try {
-                const focusables = await this.sendCommand('findElements', {
-                    scope: 'descendants',
-                    condition: (0, conditions_1.propertyCondition)('IsKeyboardFocusable', true),
-                    contextElementId: elementId,
-                });
-                if (!focusables || focusables.length < 2) {
-                    this.log.info(`Attached window has only ${focusables?.length ?? 0} focusable descendant(s); treating as a splash screen.`);
-                    focused = false;
+            this.log.debug(`Found ${handles.length} window handle(s) for PIDs [${currentPids.join(', ')}]: ${handles.map((h) => `0x${h.toString(16).padStart(8, '0')}`).join(', ')}`);
+            for (const handle of handles) {
+                const elementId = await this.sendPowerShellCommand(powershell_1.AutomationElement.rootElement.findFirst(powershell_1.TreeScope.CHILDREN, new powershell_1.PropertyCondition(powershell_1.Property.NATIVE_WINDOW_HANDLE, new powershell_1.PSInt32(handle))).buildCommand());
+                if (elementId.trim()) {
+                    await this.sendPowerShellCommand(/* ps1 */ `$rootElement = ${new powershell_1.FoundAutomationElement(elementId).buildCommand()}`);
+                    if ((await this.sendPowerShellCommand(/* ps1 */ `$null -ne $rootElement`)).toLowerCase() === 'true') {
+                        const confirmedHandle = Number(await this.sendPowerShellCommand(powershell_1.AutomationElement.automationRoot.buildGetPropertyCommand(powershell_1.Property.NATIVE_WINDOW_HANDLE)));
+                        this.log.info(`Successfully attached to window. Native window handle: 0x${confirmedHandle.toString(16).padStart(8, '0')}`);
+                        this.appProcessIds = currentPids;
+                        if (!(0, user32_1.trySetForegroundWindow)(confirmedHandle)) {
+                            try {
+                                await this.focusElement({
+                                    [base_driver_1.W3C_ELEMENT_KEY]: elementId,
+                                });
+                            }
+                            catch (e) {
+                                this.log.warn(`Could not focus app window: ${e.message}`);
+                            }
+                        }
+                        return;
+                    }
                 }
             }
-            catch {
-                // leave focused as-is
-            }
-        }
-        return { focused, knownPids };
-    }
-    return { focused: false, knownPids };
-}
-/**
- * Waits for a splash screen to disappear and re-attaches to the app's main window.
- *
- * After `attachToApplicationWindow` attaches to a window that can't receive focus
- * (a splash screen), this function polls until the current root element becomes
- * stale (splash screen closed) or a new, different window handle appears for the
- * same process. It then re-attaches to the new main window.
- */
-async function waitForMainWindow(knownPids, deadline) {
-    // Capture the splash screen's window handle so we can detect when a new window appears
-    let splashHandle = null;
-    try {
-        const rootId = await this.sendCommand('saveRootElementToTable', {});
-        splashHandle = Number(await this.sendCommand('getProperty', { elementId: rootId, property: 'NativeWindowHandle' }));
-    }
-    catch {
-        // If we can't get the handle, we'll just watch for staleness
-    }
-    this.log.debug(`Splash screen handle: ${splashHandle != null ? `0x${splashHandle.toString(16).padStart(8, '0')}` : 'unknown'}. Polling for main window...`);
-    let attempt = 0;
-    while (Date.now() < deadline) {
-        attempt++;
-        await (0, util_1.sleep)(POLL_INTERVAL_MS);
-        // Check if the current root element is still alive
-        let rootStale = false;
-        try {
-            const isNotNull = await this.sendCommand('checkRootElementNotNull', {});
-            if (!isNotNull) {
-                rootStale = true;
-            }
-            else {
-                // Try to read a property — if the element is stale, this throws
-                const rootId = await this.sendCommand('saveRootElementToTable', {});
-                await this.sendCommand('getProperty', { elementId: rootId, property: 'Name' });
-            }
-        }
-        catch {
-            rootStale = true;
-        }
-        if (rootStale) {
-            this.log.info(`Splash screen closed (root element stale after ${attempt} polls). Re-attaching to main window via attachToApplicationWindow...`);
-            // Clear the stale root so attachToApplicationWindow starts fresh
-            await this.sendCommand('setRootElementNull', {});
-            // attachToApplicationWindow has its own polling loop for the UIA tree,
-            // so it will wait until the new main window registers.
-            const result = await this.attachToApplicationWindow(knownPids[0], { deadline });
-            if (result.focused) {
-                this.log.info('Successfully attached to the main application window after splash screen.');
-            }
-            else {
-                this.log.info('Attached to main window (could not focus, but window found).');
-            }
-            return;
-        }
-        // Root is still alive — check if the process now has a different (new) window
-        if (splashHandle != null) {
-            const handles = (0, user32_1.getWindowAllHandlesForProcessIds)(knownPids);
-            const newHandle = handles.find((h) => h !== splashHandle);
-            if (newHandle) {
-                this.log.info(`New window detected (0x${newHandle.toString(16).padStart(8, '0')}) alongside splash screen (attempt ${attempt}). Waiting for splash to close...`);
-                // Don't re-attach yet — let the splash finish naturally.
-                // Once it closes, the root-stale path above will handle re-attach.
-            }
-        }
-        if (attempt % 10 === 0) {
-            this.log.debug(`Still waiting for splash screen to close... (attempt ${attempt})`);
         }
+        this.log.debug(`No attachable window found yet. Sleeping for ${SLEEP_INTERVAL_MS} milliseconds and retrying... (${++attempts}/${Math.floor(timeout / SLEEP_INTERVAL_MS)})`);
+        await (0, util_1.sleep)(SLEEP_INTERVAL_MS);
     }
-    this.log.warn('Deadline reached while waiting for splash screen to close. Session is attached to the splash screen window.');
+    throw new Error('Timed out waiting to attach to application window.');
 }
 //# sourceMappingURL=app.js.map