@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/desktop-automation/windows-native-provider.js

@@ -1,10 +1,19 @@
 /**
  * Windows Native Desktop Automation Provider
  *
- * Uses PowerShell P/Invoke (user32.dll) for native Windows desktop automation.
- * Supports WSL2 interop via powershell.exe.
+ * Uses a persistent C# background daemon (CodeBuddyDesktopBridge.exe)
+ * for native Windows desktop automation, falling back to PowerShell scripts.
+ * Supports WSL2 interop.
  */
+import { spawn, execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import readline from 'readline';
+import { fileURLToPath } from 'url';
 import { BaseNativeProvider } from './base-native-provider.js';
+import { logger } from '../utils/logger.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 // Virtual key code mapping
 const VK_CODES = {
     'return': 0x0D,
@@ -49,8 +58,6 @@ const VK_CODES = {
     'f10': 0x79,
     'f11': 0x7A,
     'f12': 0x7B,
-    // a-z (populated below)
-    // 0-9 (populated below)
 };
 // Populate a-z
 for (let i = 0; i < 26; i++) {
@@ -96,6 +103,9 @@ export class WindowsNativeProvider extends BaseNativeProvider {
     };
     psCmd;
     wsl;
+    daemonProcess = null;
+    daemonInterface = null;
+    daemonQueue = Promise.resolve();
     P_INVOKE_BLOCK = `Add-Type @"
 using System;
 using System.Runtime.InteropServices;
@@ -123,33 +133,162 @@ public class NativeInput {
         this.psCmd = this.wsl ? 'powershell.exe' : 'powershell';
     }
     // ---------------------------------------------------------------------------
-    // PowerShell execution helper
+    // Environment Check
+    // ---------------------------------------------------------------------------
+    isTestMode() {
+        return process.env.NODE_ENV === 'test' || process.env.VITEST === 'true' || !!process.env.JEST_WORKER_ID;
+    }
+    // ---------------------------------------------------------------------------
+    // Persistent Daemon / Execution
+    // ---------------------------------------------------------------------------
+    getWindowsPath(posixPath) {
+        if (!this.wsl)
+            return posixPath;
+        try {
+            return execSync(`wslpath -w "${posixPath}"`, { encoding: 'utf8' }).trim();
+        }
+        catch {
+            return posixPath;
+        }
+    }
+    compileBridge() {
+        if (this.isTestMode())
+            return;
+        const srcPath = path.join(__dirname, 'CodeBuddyDesktopBridge.cs');
+        const exePath = path.join(__dirname, 'CodeBuddyDesktopBridge.exe');
+        let needsCompile = false;
+        try {
+            if (!fs.existsSync(exePath)) {
+                needsCompile = true;
+            }
+            else {
+                const srcStat = fs.statSync(srcPath);
+                const exeStat = fs.statSync(exePath);
+                if (srcStat.mtime > exeStat.mtime) {
+                    needsCompile = true;
+                }
+            }
+        }
+        catch {
+            needsCompile = true;
+        }
+        if (needsCompile) {
+            logger.info('Compiling CodeBuddyDesktopBridge...');
+            const cscPath = this.wsl
+                ? '/mnt/c/Windows/Microsoft.NET/Framework64/v4.0.30319/csc.exe'
+                : 'C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\csc.exe';
+            const winSrcPath = this.getWindowsPath(srcPath);
+            const winExePath = this.getWindowsPath(exePath);
+            const cmd = `"${cscPath}" /r:"System.dll" /r:"System.Drawing.dll" /r:"System.Windows.Forms.dll" /r:"System.Web.Extensions.dll" /r:"C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\WPF\\UIAutomationClient.dll" /r:"C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\WPF\\UIAutomationTypes.dll" /r:"C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\WPF\\WindowsBase.dll" /out:"${winExePath}" "${winSrcPath}"`;
+            try {
+                execSync(cmd, { stdio: 'ignore' });
+                logger.info('CodeBuddyDesktopBridge compiled successfully.');
+            }
+            catch (err) {
+                logger.warn('Failed to compile CodeBuddyDesktopBridge, falling back to legacy PowerShell:', { error: err });
+            }
+        }
+    }
+    spawnDaemon() {
+        if (this.isTestMode())
+            return;
+        const exePath = path.join(__dirname, 'CodeBuddyDesktopBridge.exe');
+        if (!fs.existsSync(exePath)) {
+            logger.warn('CodeBuddyDesktopBridge.exe not found, using legacy PowerShell execution.');
+            return;
+        }
+        try {
+            const execName = this.wsl ? 'powershell.exe' : exePath;
+            const args = this.wsl
+                ? ['-NoProfile', '-NonInteractive', '-Command', `& "${this.getWindowsPath(exePath)}"`]
+                : [];
+            this.daemonProcess = spawn(execName, args, {
+                stdio: ['pipe', 'pipe', 'ignore'],
+            });
+            this.daemonInterface = readline.createInterface({
+                input: this.daemonProcess.stdout,
+                output: this.daemonProcess.stdin,
+            });
+            this.daemonProcess.on('error', (err) => {
+                logger.error('CodeBuddyDesktopBridge daemon process error:', { error: err });
+                this.daemonProcess = null;
+            });
+            this.daemonProcess.on('exit', (code) => {
+                logger.warn(`CodeBuddyDesktopBridge daemon process exited with code ${code}`);
+                this.daemonProcess = null;
+            });
+        }
+        catch (err) {
+            logger.error('Failed to spawn CodeBuddyDesktopBridge daemon:', { error: err });
+            this.daemonProcess = null;
+        }
+    }
+    writeToDaemon(action, args) {
+        return new Promise((resolve, reject) => {
+            if (!this.daemonProcess || !this.daemonInterface) {
+                return reject(new Error('Daemon not running'));
+            }
+            const timeout = setTimeout(() => {
+                this.daemonInterface?.removeAllListeners('line');
+                reject(new Error(`Daemon request timed out: ${action}`));
+            }, 10000);
+            this.daemonInterface.once('line', (line) => {
+                clearTimeout(timeout);
+                try {
+                    const res = JSON.parse(line);
+                    if (res.success) {
+                        resolve(res);
+                    }
+                    else {
+                        reject(new Error(res.error || 'Unknown daemon error'));
+                    }
+                }
+                catch (err) {
+                    reject(new Error(`Failed to parse daemon response: ${line}`));
+                }
+            });
+            this.daemonProcess.stdin.write(JSON.stringify({ action, ...args }) + '\n');
+        });
+    }
+    async executeAction(action, args = {}) {
+        if (this.isTestMode() || !this.daemonProcess) {
+            return this.fallbackPs(action, args);
+        }
+        return new Promise((resolve, reject) => {
+            this.daemonQueue = this.daemonQueue.then(async () => {
+                try {
+                    const res = await this.writeToDaemon(action, args);
+                    resolve(res);
+                }
+                catch (err) {
+                    logger.warn(`Daemon action ${action} failed, trying PowerShell fallback:`, { error: err });
+                    try {
+                        const res = await this.fallbackPs(action, args);
+                        resolve(res);
+                    }
+                    catch (fallbackErr) {
+                        reject(fallbackErr);
+                    }
+                }
+            });
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // PowerShell execution helper (for fallback/test mode)
     // ---------------------------------------------------------------------------
-    /**
-     * Execute a PowerShell script via the configured PS command.
-     * Escapes double quotes in the script for shell invocation.
-     */
     async ps(script) {
-        const escapedScript = script.replace(/"/g, '\\"');
-        return this.exec(`${this.psCmd} -NoProfile -NonInteractive -Command "${escapedScript}"`, 15000);
+        const preparedScript = `$ProgressPreference='SilentlyContinue'; $ErrorActionPreference='Stop'; ${script}`;
+        const encodedScript = Buffer.from(preparedScript, 'utf16le').toString('base64');
+        return this.exec(`${this.psCmd} -NoProfile -NonInteractive -EncodedCommand ${encodedScript}`, 15000);
     }
-    /**
-     * Validate that a value is a finite number to prevent injection.
-     */
     validateNumber(value, name) {
         if (typeof value !== 'number' || !Number.isFinite(value)) {
             throw new Error(`Invalid ${name}: must be a finite number`);
         }
     }
-    /**
-     * Escape a string for use inside PowerShell single quotes (double the single quotes).
-     */
     escapePsSingleQuote(s) {
         return s.replace(/'/g, "''");
     }
-    /**
-     * Get mouse button event flags.
-     */
     getMouseFlags(button = 'left') {
         switch (button) {
             case 'right':
@@ -161,14 +300,10 @@ public class NativeInput {
                 return { down: MOUSEEVENTF_LEFTDOWN, up: MOUSEEVENTF_LEFTUP };
         }
     }
-    /**
-     * Resolve a key name to its virtual key code.
-     */
     resolveVK(key) {
         const normalized = key.toLowerCase();
         const vk = VK_CODES[normalized];
         if (vk === undefined) {
-            // If single character, use its char code
             if (key.length === 1) {
                 return key.toUpperCase().charCodeAt(0);
             }
@@ -181,6 +316,8 @@ public class NativeInput {
     // ---------------------------------------------------------------------------
     async initialize() {
         try {
+            this.compileBridge();
+            this.spawnDaemon();
             await this.ps('Write-Output ok');
             this.initialized = true;
         }
@@ -199,49 +336,45 @@ public class NativeInput {
     }
     async shutdown() {
         this.initialized = false;
+        if (this.daemonProcess) {
+            try {
+                this.daemonProcess.stdin?.end();
+                this.daemonProcess.kill();
+            }
+            catch {
+                // ignore
+            }
+            this.daemonProcess = null;
+        }
     }
     // ---------------------------------------------------------------------------
     // Mouse
     // ---------------------------------------------------------------------------
     async getMousePosition() {
         this.ensureInitialized();
-        const result = await this.ps(`${this.P_INVOKE_BLOCK}; $p = New-Object NativeInput+POINT; [NativeInput]::GetCursorPos([ref]$p) | Out-Null; Write-Output "$($p.X),$($p.Y)"`);
-        const parts = result.trim().split(',');
-        return {
-            x: parseInt(parts[0], 10),
-            y: parseInt(parts[1], 10),
-        };
+        const result = await this.executeAction('get_mouse_position');
+        return { x: result.x, y: result.y };
     }
     async moveMouse(x, y, _options) {
         this.ensureInitialized();
         this.validateNumber(x, 'x');
         this.validateNumber(y, 'y');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::SetCursorPos(${Math.round(x)}, ${Math.round(y)})`);
+        await this.executeAction('move_mouse', { x: Math.round(x), y: Math.round(y) });
     }
     async click(options) {
         this.ensureInitialized();
         const button = options?.button ?? 'left';
         const clicks = options?.clicks ?? 1;
-        const clickDelay = options?.delay ?? 50;
-        const flags = this.getMouseFlags(button);
-        for (let i = 0; i < clicks; i++) {
-            if (i > 0) {
-                await this.delay(clickDelay);
-            }
-            await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
-        }
+        const delay = options?.delay ?? 50;
+        await this.executeAction('click', { button, clicks, delay });
     }
     async doubleClick(button) {
         this.ensureInitialized();
-        const flags = this.getMouseFlags(button ?? 'left');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
-        await this.delay(50);
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+        await this.executeAction('double_click', { button: button ?? 'left' });
     }
     async rightClick() {
         this.ensureInitialized();
-        const flags = this.getMouseFlags('right');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+        await this.executeAction('right_click');
     }
     async drag(fromX, fromY, toX, toY, options) {
         this.ensureInitialized();
@@ -250,34 +383,14 @@ public class NativeInput {
         this.validateNumber(toX, 'toX');
         this.validateNumber(toY, 'toY');
         const button = options?.button ?? 'left';
-        const flags = this.getMouseFlags(button);
         const duration = options?.duration ?? 300;
-        // Move to start position
-        await this.moveMouse(fromX, fromY);
-        await this.delay(50);
-        // Mouse down
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero)`);
-        await this.delay(duration);
-        // Move to end position
-        await this.moveMouse(toX, toY);
-        await this.delay(50);
-        // Mouse up
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+        await this.executeAction('drag', { fromX, fromY, toX, toY, button, duration });
     }
     async scroll(options) {
         this.ensureInitialized();
         const deltaY = options.deltaY ?? 0;
         const deltaX = options.deltaX ?? 0;
-        if (deltaY !== 0) {
-            this.validateNumber(deltaY, 'deltaY');
-            const amount = Math.round(deltaY * 120);
-            await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${MOUSEEVENTF_WHEEL}, 0, 0, ${amount}, [IntPtr]::Zero)`);
-        }
-        if (deltaX !== 0) {
-            this.validateNumber(deltaX, 'deltaX');
-            const amount = Math.round(deltaX * 120);
-            await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${MOUSEEVENTF_HWHEEL}, 0, 0, ${amount}, [IntPtr]::Zero)`);
-        }
+        await this.executeAction('scroll', { deltaY, deltaX });
     }
     // ---------------------------------------------------------------------------
     // Keyboard
@@ -286,125 +399,53 @@ public class NativeInput {
         this.ensureInitialized();
         const vk = this.resolveVK(key);
         const modifiers = options?.modifiers ?? [];
-        const modVKs = modifiers.map(m => {
-            const mvk = MODIFIER_VK[m];
-            if (mvk === undefined)
-                throw new Error(`Unknown modifier: ${m}`);
-            return mvk;
-        });
-        // Build PS script: modifiers down, key down/up, modifiers up
-        const lines = [this.P_INVOKE_BLOCK];
-        for (const mvk of modVKs) {
-            lines.push(`[NativeInput]::keybd_event(${mvk}, 0, 0, [IntPtr]::Zero)`);
-        }
-        lines.push(`[NativeInput]::keybd_event(${vk}, 0, 0, [IntPtr]::Zero)`);
-        if (options?.delay) {
-            lines.push(`Start-Sleep -Milliseconds ${Math.round(options.delay)}`);
-        }
-        lines.push(`[NativeInput]::keybd_event(${vk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
-        for (const mvk of modVKs.reverse()) {
-            lines.push(`[NativeInput]::keybd_event(${mvk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
-        }
-        await this.ps(lines.join('; '));
+        const delay = options?.delay ?? 0;
+        await this.executeAction('key_press', { vk, modifiers, delay });
     }
     async keyDown(key) {
         this.ensureInitialized();
         const vk = this.resolveVK(key);
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::keybd_event(${vk}, 0, 0, [IntPtr]::Zero)`);
+        await this.executeAction('key_down', { vk });
     }
     async keyUp(key) {
         this.ensureInitialized();
         const vk = this.resolveVK(key);
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::keybd_event(${vk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
+        await this.executeAction('key_up', { vk });
     }
     async type(text, _options) {
         this.ensureInitialized();
-        // Escape special SendKeys characters: +^%~(){}[]
-        const escaped = text.replace(/([+^%~(){}[\]])/g, '{$1}');
-        const psEscaped = this.escapePsSingleQuote(escaped);
-        await this.ps(`Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${psEscaped}')`);
+        await this.executeAction('type', { text });
     }
     async hotkey(sequence) {
         this.ensureInitialized();
         const modifiers = sequence.modifiers ?? [];
-        const modVKs = modifiers.map(m => {
-            const mvk = MODIFIER_VK[m];
-            if (mvk === undefined)
-                throw new Error(`Unknown modifier: ${m}`);
-            return mvk;
-        });
-        const lines = [this.P_INVOKE_BLOCK];
-        // Modifiers down
-        for (const mvk of modVKs) {
-            lines.push(`[NativeInput]::keybd_event(${mvk}, 0, 0, [IntPtr]::Zero)`);
-        }
-        // Key presses
-        for (const key of sequence.keys) {
-            const vk = this.resolveVK(key);
-            lines.push(`[NativeInput]::keybd_event(${vk}, 0, 0, [IntPtr]::Zero)`);
-            lines.push(`[NativeInput]::keybd_event(${vk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
-        }
-        // Modifiers up (reverse order)
-        for (const mvk of [...modVKs].reverse()) {
-            lines.push(`[NativeInput]::keybd_event(${mvk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
-        }
-        await this.ps(lines.join('; '));
+        const keys = sequence.keys.map(k => String(this.resolveVK(k)));
+        await this.executeAction('hotkey', { keys, modifiers });
     }
     // ---------------------------------------------------------------------------
     // Windows
     // ---------------------------------------------------------------------------
     async getActiveWindow() {
         this.ensureInitialized();
-        try {
-            const handleStr = await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::GetForegroundWindow().ToInt64()`);
-            const handle = handleStr.trim();
-            if (!handle || handle === '0')
-                return null;
-            return this.getWindow(handle);
-        }
-        catch {
-            return null;
-        }
+        const res = await this.executeAction('get_active_window');
+        return res.window;
     }
-    async getWindows(_options) {
+    async getWindows(options) {
         this.ensureInitialized();
-        const result = await this.ps('Get-Process | Where-Object {$_.MainWindowHandle -ne 0} | ForEach-Object { Write-Output "$($_.MainWindowHandle)|$($_.Id)|$($_.ProcessName)|$($_.MainWindowTitle)" }');
-        const windows = [];
-        const lines = result.split('\n').filter(l => l.trim());
-        for (const line of lines) {
-            const parts = line.split('|');
-            if (parts.length < 4)
-                continue;
-            const handle = parts[0].trim();
-            const pid = parseInt(parts[1].trim(), 10);
-            const processName = parts[2].trim();
-            const title = parts.slice(3).join('|').trim();
-            windows.push({
-                handle,
-                title,
-                pid,
-                processName,
-                bounds: { x: 0, y: 0, width: 0, height: 0 },
-                focused: false,
-                visible: true,
-                minimized: false,
-                maximized: false,
-                fullscreen: false,
-            });
-        }
-        // Apply search filters
-        if (_options) {
+        const res = await this.executeAction('get_windows');
+        const windows = res.windows || [];
+        if (options) {
             return windows.filter(w => {
-                if (_options.title) {
-                    const titleMatch = _options.title instanceof RegExp
-                        ? _options.title.test(w.title)
-                        : w.title.includes(_options.title);
+                if (options.title) {
+                    const titleMatch = options.title instanceof RegExp
+                        ? options.title.test(w.title)
+                        : w.title.includes(options.title);
                     if (!titleMatch)
                         return false;
                 }
-                if (_options.processName && w.processName !== _options.processName)
+                if (options.processName && w.processName !== options.processName)
                     return false;
-                if (_options.pid && w.pid !== _options.pid)
+                if (options.pid && w.pid !== options.pid)
                     return false;
                 return true;
             });
@@ -413,241 +454,491 @@ public class NativeInput {
     }
     async getWindow(handle) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        try {
-            const script = `${this.P_INVOKE_BLOCK};
-$h = [IntPtr]${handleNum};
-$r = New-Object NativeInput+RECT;
-[NativeInput]::GetWindowRect($h, [ref]$r) | Out-Null;
-$len = [NativeInput]::GetWindowTextLength($h);
-$sb = New-Object System.Text.StringBuilder($len + 1);
-[NativeInput]::GetWindowText($h, $sb, $sb.Capacity) | Out-Null;
-$pid = [uint32]0;
-[NativeInput]::GetWindowThreadProcessId($h, [ref]$pid) | Out-Null;
-$fg = [NativeInput]::GetForegroundWindow();
-$pname = '';
-try { $pname = (Get-Process -Id $pid -ErrorAction SilentlyContinue).ProcessName } catch {}
-Write-Output "$($r.Left)|$($r.Top)|$($r.Right)|$($r.Bottom)|$($sb.ToString())|$pid|$pname|$($fg -eq $h)"`;
-            const result = await this.ps(script);
-            const parts = result.trim().split('|');
-            if (parts.length < 8)
-                return null;
-            const left = parseInt(parts[0], 10);
-            const top = parseInt(parts[1], 10);
-            const right = parseInt(parts[2], 10);
-            const bottom = parseInt(parts[3], 10);
-            const title = parts[4];
-            const pid = parseInt(parts[5], 10);
-            const processName = parts[6];
-            const focused = parts[7].trim().toLowerCase() === 'true';
-            return {
-                handle,
-                title,
-                pid,
-                processName,
-                bounds: {
-                    x: left,
-                    y: top,
-                    width: right - left,
-                    height: bottom - top,
-                },
-                focused,
-                visible: true,
-                minimized: false,
-                maximized: false,
-                fullscreen: false,
-            };
-        }
-        catch {
-            return null;
-        }
+        const res = await this.executeAction('get_window', { handle });
+        return res.window;
     }
     async focusWindow(handle) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::SetForegroundWindow([IntPtr]${handleNum})`);
+        await this.executeAction('focus_window', { handle });
     }
     async minimizeWindow(handle) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::ShowWindow([IntPtr]${handleNum}, 6)`);
+        await this.executeAction('minimize_window', { handle });
     }
     async maximizeWindow(handle) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::ShowWindow([IntPtr]${handleNum}, 3)`);
+        await this.executeAction('maximize_window', { handle });
     }
     async restoreWindow(handle) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::ShowWindow([IntPtr]${handleNum}, 9)`);
+        await this.executeAction('restore_window', { handle });
     }
     async closeWindow(handle) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::SendMessage([IntPtr]${handleNum}, 0x10, [IntPtr]::Zero, [IntPtr]::Zero)`);
+        await this.executeAction('close_window', { handle });
     }
     async setWindow(handle, options) {
         this.ensureInitialized();
-        const handleNum = parseInt(handle, 10);
-        this.validateNumber(handleNum, 'handle');
-        const lines = [this.P_INVOKE_BLOCK];
-        if (options.position || options.size) {
-            // Need current rect to fill in missing values
-            const current = await this.getWindow(handle);
-            const x = options.position?.x ?? current?.bounds.x ?? 0;
-            const y = options.position?.y ?? current?.bounds.y ?? 0;
-            const w = options.size?.width ?? current?.bounds.width ?? 800;
-            const h = options.size?.height ?? current?.bounds.height ?? 600;
-            this.validateNumber(x, 'x');
-            this.validateNumber(y, 'y');
-            this.validateNumber(w, 'width');
-            this.validateNumber(h, 'height');
-            lines.push(`[NativeInput]::MoveWindow([IntPtr]${handleNum}, ${Math.round(x)}, ${Math.round(y)}, ${Math.round(w)}, ${Math.round(h)}, $true)`);
-        }
-        if (options.focus) {
-            lines.push(`[NativeInput]::SetForegroundWindow([IntPtr]${handleNum})`);
-        }
-        if (lines.length > 1) {
-            await this.ps(lines.join('; '));
-        }
+        await this.executeAction('set_window', { handle, ...options });
     }
     // ---------------------------------------------------------------------------
     // Applications
     // ---------------------------------------------------------------------------
     async getRunningApps() {
         this.ensureInitialized();
-        const result = await this.ps('Get-Process | Where-Object {$_.MainWindowHandle -ne 0} | Select-Object Id,ProcessName,Path | ConvertTo-Json -Compress');
-        try {
-            const parsed = JSON.parse(result);
-            const items = Array.isArray(parsed) ? parsed : [parsed];
-            return items.map((item) => ({
-                name: item.ProcessName ?? '',
-                path: item.Path ?? '',
-                pid: item.Id,
-                running: true,
-            }));
-        }
-        catch {
-            return [];
-        }
+        const res = await this.executeAction('get_running_apps');
+        return res.apps || [];
     }
     async launchApp(appPath, options) {
         this.ensureInitialized();
-        const escapedPath = this.escapePsSingleQuote(appPath);
-        let cmd = `Start-Process '${escapedPath}' -PassThru`;
-        if (options?.args && options.args.length > 0) {
-            const args = options.args.map(a => this.escapePsSingleQuote(a)).join(' ');
-            cmd += ` -ArgumentList '${args}'`;
-        }
-        if (options?.cwd) {
-            cmd += ` -WorkingDirectory '${this.escapePsSingleQuote(options.cwd)}'`;
-        }
-        if (options?.hidden) {
-            cmd += ' -WindowStyle Hidden';
-        }
-        cmd += ' | Select-Object Id,ProcessName | ConvertTo-Json -Compress';
-        const result = await this.ps(cmd);
-        try {
-            const parsed = JSON.parse(result);
-            return {
-                name: parsed.ProcessName ?? '',
-                path: appPath,
-                pid: parsed.Id,
-                running: true,
-            };
-        }
-        catch {
-            return {
-                name: appPath,
-                path: appPath,
-                running: true,
-            };
-        }
+        const res = await this.executeAction('launch_app', { path: appPath, ...options });
+        return res.app;
     }
     async closeApp(pid) {
         this.ensureInitialized();
-        this.validateNumber(pid, 'pid');
-        await this.ps(`Stop-Process -Id ${Math.round(pid)}`);
+        await this.executeAction('close_app', { pid });
     }
     // ---------------------------------------------------------------------------
     // Screens
     // ---------------------------------------------------------------------------
     async getScreens() {
         this.ensureInitialized();
-        const result = await this.ps('Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::AllScreens | ForEach-Object { Write-Output "$($_.DeviceName)|$($_.Bounds.X)|$($_.Bounds.Y)|$($_.Bounds.Width)|$($_.Bounds.Height)|$($_.WorkingArea.X)|$($_.WorkingArea.Y)|$($_.WorkingArea.Width)|$($_.WorkingArea.Height)|$($_.Primary)" }');
-        const screens = [];
-        const lines = result.split('\n').filter(l => l.trim());
-        for (let i = 0; i < lines.length; i++) {
-            const parts = lines[i].split('|');
-            if (parts.length < 10)
-                continue;
-            screens.push({
-                id: i,
-                name: parts[0].trim(),
-                bounds: {
-                    x: parseInt(parts[1], 10),
-                    y: parseInt(parts[2], 10),
-                    width: parseInt(parts[3], 10),
-                    height: parseInt(parts[4], 10),
-                },
-                workArea: {
-                    x: parseInt(parts[5], 10),
-                    y: parseInt(parts[6], 10),
-                    width: parseInt(parts[7], 10),
-                    height: parseInt(parts[8], 10),
-                },
-                scaleFactor: 1,
-                primary: parts[9].trim().toLowerCase() === 'true',
-            });
-        }
-        return screens;
+        const res = await this.executeAction('get_screens');
+        return res.screens || [];
     }
     async getPixelColor(x, y) {
         this.ensureInitialized();
         this.validateNumber(x, 'x');
         this.validateNumber(y, 'y');
-        const result = await this.ps(`Add-Type -AssemblyName System.Drawing; $bmp = New-Object System.Drawing.Bitmap(1, 1); $g = [System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen(${Math.round(x)}, ${Math.round(y)}, 0, 0, (New-Object System.Drawing.Size(1, 1))); $c = $bmp.GetPixel(0, 0); Write-Output "$($c.R)|$($c.G)|$($c.B)|$($c.A)"; $g.Dispose(); $bmp.Dispose()`);
-        const parts = result.trim().split('|');
-        const r = parseInt(parts[0], 10);
-        const g = parseInt(parts[1], 10);
-        const b = parseInt(parts[2], 10);
-        const a = parts.length > 3 ? parseInt(parts[3], 10) : 255;
-        const hex = `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
-        return { r, g, b, a, hex };
+        const res = await this.executeAction('get_pixel_color', { x, y });
+        return { r: res.r, g: res.g, b: res.b, a: res.a, hex: res.hex };
     }
     // ---------------------------------------------------------------------------
     // Clipboard
     // ---------------------------------------------------------------------------
     async getClipboard() {
         this.ensureInitialized();
-        try {
-            const text = await this.ps('Get-Clipboard');
-            return {
-                text: text || undefined,
-                formats: text ? ['text'] : [],
-            };
-        }
-        catch {
-            return { formats: [] };
-        }
+        const res = await this.executeAction('get_clipboard');
+        return {
+            text: res.text || undefined,
+            formats: res.formats || [],
+        };
     }
     async setClipboard(content) {
         this.ensureInitialized();
         if (content.text !== undefined) {
-            const escaped = this.escapePsSingleQuote(content.text);
-            await this.ps(`Set-Clipboard -Value '${escaped}'`);
+            await this.executeAction('set_clipboard', { text: content.text });
         }
     }
     async clearClipboard() {
         this.ensureInitialized();
-        await this.ps('Set-Clipboard -Value $null');
+        await this.executeAction('clear_clipboard');
+    }
+    // ---------------------------------------------------------------------------
+    // Legacy PowerShell Failback Logic
+    // ---------------------------------------------------------------------------
+    async fallbackPs(action, args) {
+        switch (action) {
+            case 'get_mouse_position': {
+                const result = await this.ps(`${this.P_INVOKE_BLOCK}; $p = New-Object NativeInput+POINT; [NativeInput]::GetCursorPos([ref]$p) | Out-Null; Write-Output "$($p.X),$($p.Y)"`);
+                const parts = result.trim().split(',');
+                return {
+                    x: parseInt(parts[0] ?? '', 10),
+                    y: parseInt(parts[1] ?? '', 10),
+                };
+            }
+            case 'move_mouse': {
+                const { x, y } = args;
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::SetCursorPos(${Math.round(x)}, ${Math.round(y)})`);
+                break;
+            }
+            case 'click': {
+                const { button, clicks, delay } = args;
+                const flags = this.getMouseFlags(button);
+                for (let i = 0; i < clicks; i++) {
+                    if (i > 0)
+                        await this.delay(delay);
+                    await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+                }
+                break;
+            }
+            case 'double_click': {
+                const { button } = args;
+                const flags = this.getMouseFlags(button);
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+                await this.delay(50);
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+                break;
+            }
+            case 'right_click': {
+                const flags = this.getMouseFlags('right');
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero); [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+                break;
+            }
+            case 'drag': {
+                const { fromX, fromY, toX, toY, button, duration } = args;
+                const flags = this.getMouseFlags(button);
+                await this.moveMouse(fromX, fromY);
+                await this.delay(50);
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.down}, 0, 0, 0, [IntPtr]::Zero)`);
+                await this.delay(duration);
+                await this.moveMouse(toX, toY);
+                await this.delay(50);
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${flags.up}, 0, 0, 0, [IntPtr]::Zero)`);
+                break;
+            }
+            case 'scroll': {
+                const { deltaY, deltaX } = args;
+                if (deltaY !== 0) {
+                    const amount = Math.round(deltaY * 120);
+                    await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${MOUSEEVENTF_WHEEL}, 0, 0, ${amount}, [IntPtr]::Zero)`);
+                }
+                if (deltaX !== 0) {
+                    const amount = Math.round(deltaX * 120);
+                    await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::mouse_event(${MOUSEEVENTF_HWHEEL}, 0, 0, ${amount}, [IntPtr]::Zero)`);
+                }
+                break;
+            }
+            case 'key_press': {
+                const { vk, modifiers, delay } = args;
+                const modVKs = modifiers.map((m) => {
+                    const mvk = MODIFIER_VK[m];
+                    if (mvk === undefined)
+                        throw new Error(`Unknown modifier: ${m}`);
+                    return mvk;
+                });
+                const lines = [this.P_INVOKE_BLOCK];
+                for (const mvk of modVKs) {
+                    lines.push(`[NativeInput]::keybd_event(${mvk}, 0, 0, [IntPtr]::Zero)`);
+                }
+                lines.push(`[NativeInput]::keybd_event(${vk}, 0, 0, [IntPtr]::Zero)`);
+                if (delay) {
+                    lines.push(`Start-Sleep -Milliseconds ${Math.round(delay)}`);
+                }
+                lines.push(`[NativeInput]::keybd_event(${vk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
+                for (const mvk of modVKs.reverse()) {
+                    lines.push(`[NativeInput]::keybd_event(${mvk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
+                }
+                await this.ps(lines.join('; '));
+                break;
+            }
+            case 'key_down': {
+                const { vk } = args;
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::keybd_event(${vk}, 0, 0, [IntPtr]::Zero)`);
+                break;
+            }
+            case 'key_up': {
+                const { vk } = args;
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::keybd_event(${vk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
+                break;
+            }
+            case 'type': {
+                const { text } = args;
+                const escaped = text.replace(/([+^%~(){}[\]])/g, '{$1}');
+                const psEscaped = this.escapePsSingleQuote(escaped);
+                await this.ps(`Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('${psEscaped}')`);
+                break;
+            }
+            case 'hotkey': {
+                const { keys, modifiers } = args;
+                const modVKs = modifiers.map((m) => {
+                    const mvk = MODIFIER_VK[m];
+                    if (mvk === undefined)
+                        throw new Error(`Unknown modifier: ${m}`);
+                    return mvk;
+                });
+                const lines = [this.P_INVOKE_BLOCK];
+                for (const mvk of modVKs) {
+                    lines.push(`[NativeInput]::keybd_event(${mvk}, 0, 0, [IntPtr]::Zero)`);
+                }
+                for (const key of keys) {
+                    const vk = parseInt(key, 10);
+                    lines.push(`[NativeInput]::keybd_event(${vk}, 0, 0, [IntPtr]::Zero)`);
+                    lines.push(`[NativeInput]::keybd_event(${vk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
+                }
+                for (const mvk of [...modVKs].reverse()) {
+                    lines.push(`[NativeInput]::keybd_event(${mvk}, 0, ${KEYEVENTF_KEYUP}, [IntPtr]::Zero)`);
+                }
+                await this.ps(lines.join('; '));
+                break;
+            }
+            case 'get_active_window': {
+                try {
+                    const handleStr = await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::GetForegroundWindow().ToInt64()`);
+                    const handle = handleStr.trim();
+                    if (!handle || handle === '0')
+                        return { window: null };
+                    const win = await this.getWindow(handle);
+                    return { window: win };
+                }
+                catch {
+                    return { window: null };
+                }
+            }
+            case 'get_windows': {
+                const result = await this.ps('Get-Process | Where-Object {$_.MainWindowHandle -ne 0} | ForEach-Object { Write-Output "$($_.MainWindowHandle)|$($_.Id)|$($_.ProcessName)|$($_.MainWindowTitle)" }');
+                const windows = [];
+                const lines = result.split('\n').filter(l => l.trim());
+                for (const line of lines) {
+                    const parts = line.split('|');
+                    if (parts.length < 4)
+                        continue;
+                    const [rawHandle = '', rawPid = '', rawProcessName = ''] = parts;
+                    const handle = rawHandle.trim();
+                    const pid = parseInt(rawPid.trim(), 10);
+                    const processName = rawProcessName.trim();
+                    const title = parts.slice(3).join('|').trim();
+                    windows.push({
+                        handle,
+                        title,
+                        pid,
+                        processName,
+                        bounds: { x: 0, y: 0, width: 0, height: 0 },
+                        focused: false,
+                        visible: true,
+                        minimized: false,
+                        maximized: false,
+                        fullscreen: false,
+                    });
+                }
+                return { windows };
+            }
+            case 'get_window': {
+                const { handle } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                try {
+                    const script = `${this.P_INVOKE_BLOCK};
+$h = [IntPtr]${handleNum};
+$r = New-Object NativeInput+RECT;
+[NativeInput]::GetWindowRect($h, [ref]$r) | Out-Null;
+$len = [NativeInput]::GetWindowTextLength($h);
+$sb = New-Object System.Text.StringBuilder($len + 1);
+[NativeInput]::GetWindowText($h, $sb, $sb.Capacity) | Out-Null;
+$procId = [uint32]0;
+[NativeInput]::GetWindowThreadProcessId($h, [ref]$procId) | Out-Null;
+$fg = [NativeInput]::GetForegroundWindow();
+$pname = '';
+try { $pname = (Get-Process -Id $procId -ErrorAction SilentlyContinue).ProcessName } catch {}
+Write-Output "$($r.Left)|$($r.Top)|$($r.Right)|$($r.Bottom)|$($sb.ToString())|$procId|$pname|$($fg -eq $h)"`;
+                    const result = await this.ps(script);
+                    const parts = result.trim().split('|');
+                    if (parts.length < 8)
+                        return { window: null };
+                    const [rawLeft = '', rawTop = '', rawRight = '', rawBottom = '', rawTitle = '', rawPid = '', rawProcessName = '', rawFocused = '',] = parts;
+                    const left = parseInt(rawLeft, 10);
+                    const top = parseInt(rawTop, 10);
+                    const right = parseInt(rawRight, 10);
+                    const bottom = parseInt(rawBottom, 10);
+                    const title = rawTitle;
+                    const pid = parseInt(rawPid, 10);
+                    const processName = rawProcessName;
+                    const focused = rawFocused.trim().toLowerCase() === 'true';
+                    return {
+                        window: {
+                            handle,
+                            title,
+                            pid,
+                            processName,
+                            bounds: {
+                                x: left,
+                                y: top,
+                                width: right - left,
+                                height: bottom - top,
+                            },
+                            focused,
+                            visible: true,
+                            minimized: false,
+                            maximized: false,
+                            fullscreen: false,
+                        }
+                    };
+                }
+                catch {
+                    return { window: null };
+                }
+            }
+            case 'focus_window': {
+                const { handle } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::SetForegroundWindow([IntPtr]${handleNum})`);
+                break;
+            }
+            case 'minimize_window': {
+                const { handle } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::ShowWindow([IntPtr]${handleNum}, 6)`);
+                break;
+            }
+            case 'maximize_window': {
+                const { handle } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::ShowWindow([IntPtr]${handleNum}, 3)`);
+                break;
+            }
+            case 'restore_window': {
+                const { handle } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::ShowWindow([IntPtr]${handleNum}, 9)`);
+                break;
+            }
+            case 'close_window': {
+                const { handle } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                await this.ps(`${this.P_INVOKE_BLOCK}; [NativeInput]::SendMessage([IntPtr]${handleNum}, 0x10, [IntPtr]::Zero, [IntPtr]::Zero)`);
+                break;
+            }
+            case 'set_window': {
+                const { handle, position, size, focus } = args;
+                const handleNum = parseInt(handle, 10);
+                this.validateNumber(handleNum, 'handle');
+                const lines = [this.P_INVOKE_BLOCK];
+                if (position || size) {
+                    const current = await this.getWindow(handle);
+                    const x = position?.x ?? current?.bounds.x ?? 0;
+                    const y = position?.y ?? current?.bounds.y ?? 0;
+                    const w = size?.width ?? current?.bounds.width ?? 800;
+                    const h = size?.height ?? current?.bounds.height ?? 600;
+                    this.validateNumber(x, 'x');
+                    this.validateNumber(y, 'y');
+                    this.validateNumber(w, 'width');
+                    this.validateNumber(h, 'height');
+                    lines.push(`[NativeInput]::MoveWindow([IntPtr]${handleNum}, ${Math.round(x)}, ${Math.round(y)}, ${Math.round(w)}, ${Math.round(h)}, $true)`);
+                }
+                if (focus) {
+                    lines.push(`[NativeInput]::SetForegroundWindow([IntPtr]${handleNum})`);
+                }
+                if (lines.length > 1) {
+                    await this.ps(lines.join('; '));
+                }
+                break;
+            }
+            case 'get_running_apps': {
+                const result = await this.ps('Get-Process | Where-Object {$_.MainWindowHandle -ne 0} | Select-Object Id,ProcessName,Path | ConvertTo-Json -Compress');
+                try {
+                    const parsed = JSON.parse(result);
+                    const items = Array.isArray(parsed) ? parsed : [parsed];
+                    const apps = items.map((item) => ({
+                        name: item.ProcessName ?? '',
+                        path: item.Path ?? '',
+                        pid: item.Id,
+                        running: true,
+                    }));
+                    return { apps };
+                }
+                catch {
+                    return { apps: [] };
+                }
+            }
+            case 'launch_app': {
+                const { path: appPath, args: appArgs, cwd, hidden } = args;
+                const escapedPath = this.escapePsSingleQuote(appPath);
+                let cmd = `Start-Process '${escapedPath}' -PassThru`;
+                if (appArgs && appArgs.length > 0) {
+                    const joinedArgs = appArgs.map((a) => this.escapePsSingleQuote(a)).join(' ');
+                    cmd += ` -ArgumentList '${joinedArgs}'`;
+                }
+                if (cwd) {
+                    cmd += ` -WorkingDirectory '${this.escapePsSingleQuote(cwd)}'`;
+                }
+                if (hidden) {
+                    cmd += ' -WindowStyle Hidden';
+                }
+                cmd += ' | Select-Object Id,ProcessName | ConvertTo-Json -Compress';
+                const result = await this.ps(cmd);
+                try {
+                    const parsed = JSON.parse(result);
+                    return {
+                        app: {
+                            name: parsed.ProcessName ?? '',
+                            path: appPath,
+                            pid: parsed.Id,
+                            running: true,
+                        }
+                    };
+                }
+                catch {
+                    return {
+                        app: {
+                            name: appPath,
+                            path: appPath,
+                            running: true,
+                        }
+                    };
+                }
+            }
+            case 'close_app': {
+                const { pid } = args;
+                this.validateNumber(pid, 'pid');
+                await this.ps(`Stop-Process -Id ${Math.round(pid)}`);
+                break;
+            }
+            case 'get_screens': {
+                const result = await this.ps('Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.Screen]::AllScreens | ForEach-Object { Write-Output "$($_.DeviceName)|$($_.Bounds.X)|$($_.Bounds.Y)|$($_.Bounds.Width)|$($_.Bounds.Height)|$($_.WorkingArea.X)|$($_.WorkingArea.Y)|$($_.WorkingArea.Width)|$($_.WorkingArea.Height)|$($_.Primary)" }');
+                const screens = [];
+                const lines = result.split('\n').filter(l => l.trim());
+                for (const [i, line] of lines.entries()) {
+                    const parts = line.split('|');
+                    if (parts.length < 10)
+                        continue;
+                    const [name = '', boundsX = '', boundsY = '', boundsW = '', boundsH = '', workX = '', workY = '', workW = '', workH = '', primary = '',] = parts;
+                    screens.push({
+                        id: i,
+                        name: name.trim(),
+                        bounds: {
+                            x: parseInt(boundsX, 10),
+                            y: parseInt(boundsY, 10),
+                            width: parseInt(boundsW, 10),
+                            height: parseInt(boundsH, 10),
+                        },
+                        workArea: {
+                            x: parseInt(workX, 10),
+                            y: parseInt(workY, 10),
+                            width: parseInt(workW, 10),
+                            height: parseInt(workH, 10),
+                        },
+                        scaleFactor: 1,
+                        primary: primary.trim().toLowerCase() === 'true',
+                    });
+                }
+                return { screens };
+            }
+            case 'get_pixel_color': {
+                const { x, y } = args;
+                const result = await this.ps(`Add-Type -AssemblyName System.Drawing; $bmp = New-Object System.Drawing.Bitmap(1, 1); $g = [System.Drawing.Graphics]::FromImage($bmp); $g.CopyFromScreen(${Math.round(x)}, ${Math.round(y)}, 0, 0, (New-Object System.Drawing.Size(1, 1))); $c = $bmp.GetPixel(0, 0); Write-Output "$($c.R)|$($c.G)|$($c.B)|$($c.A)"; $g.Dispose(); $bmp.Dispose()`);
+                const parts = result.trim().split('|');
+                const r = parseInt(parts[0] ?? '', 10);
+                const g = parseInt(parts[1] ?? '', 10);
+                const b = parseInt(parts[2] ?? '', 10);
+                const a = parts.length > 3 ? parseInt(parts[3] ?? '', 10) : 255;
+                const hex = `#${r.toString(16).padStart(2, '0')}${g.toString(16).padStart(2, '0')}${b.toString(16).padStart(2, '0')}`;
+                return { r, g, b, a, hex };
+            }
+            case 'get_clipboard': {
+                const text = await this.ps('Get-Clipboard');
+                return {
+                    text: text || undefined,
+                    formats: text ? ['text'] : [],
+                };
+            }
+            case 'set_clipboard': {
+                const { text } = args;
+                const escaped = this.escapePsSingleQuote(text);
+                await this.ps(`Set-Clipboard -Value '${escaped}'`);
+                break;
+            }
+            case 'clear_clipboard': {
+                await this.ps('Set-Clipboard -Value $null');
+                break;
+            }
+            default:
+                throw new Error(`Unknown fallback action: ${action}`);
+        }
     }
 }
 //# sourceMappingURL=windows-native-provider.js.map