ft-scout 9.0.2 → 9.0.4

package/bin/src/engine/computer/computerController.js

@@ -1,295 +1,505 @@
-import { openApp, executeInApp, takeoverControl, releaseTakeover, captureScreen, analyzeScreen, getScreenInfo, } from '../appControl.js';
-/**
- * OSComputerController: Production implementation driving host desktop OS
- * (Windows, macOS, Linux) through Scout's platform automation engine.
- */
-export class OSComputerController {
-    async screenshot() {
+import fs from 'fs';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class SystemComputerController {
+    workspaceDir;
+    screenshotsDir;
+    expectedApplication = null;
+    activeWindow = null;
+    constructor(workspaceDir = process.cwd()) {
+        this.workspaceDir = workspaceDir;
+        this.screenshotsDir = path.join(this.workspaceDir, '.ft', 'screenshots');
         try {
-            const shotPath = await captureScreen();
-            return {
-                success: true,
-                output: `Captured screen to ${shotPath}`,
-                details: { path: shotPath },
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                output: `Failed to capture screen: ${err.message}`,
-            };
+            if (!fs.existsSync(this.screenshotsDir)) {
+                fs.mkdirSync(this.screenshotsDir, { recursive: true });
+            }
         }
+        catch { }
     }
-    async click(x, y, button = 'left') {
-        const res = await executeInApp('desktop', 'click_app', { x, y, button });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async double_click(x, y) {
-        const res = await executeInApp('desktop', 'click_app', { x, y, double: true });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async type(text) {
-        const res = await executeInApp('desktop', 'type_text', { text });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async key_press(key) {
-        const res = await executeInApp('desktop', 'send_keys', { key });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async hotkey(keys) {
-        const keyCombo = Array.isArray(keys) ? keys.join('+') : keys;
-        const res = await executeInApp('desktop', 'key_combo', { keyCombo });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async scroll(direction, amount = 4) {
-        const res = await executeInApp('desktop', 'scroll', { direction, amount });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async move_mouse(x, y) {
-        const res = await executeInApp('desktop', 'move_mouse', { x, y });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async drag(start, end) {
-        const res = await executeInApp('desktop', 'drag', { startX: start.x, startY: start.y, endX: end.x, endY: end.y });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async wait(durationMs) {
-        await new Promise((r) => setTimeout(r, Math.min(10000, durationMs)));
-        return {
-            success: true,
-            output: `Waited for ${durationMs}ms`,
-            details: { durationMs },
-        };
+    setExpectedApplication(app) {
+        this.expectedApplication = app;
     }
-    async open_application(name, target) {
-        const res = await openApp(name, target);
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async close_application(name) {
-        const res = await executeInApp(name, 'close_app');
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
+    getExpectedApplication() {
+        return this.expectedApplication;
     }
-    async switch_application(name) {
-        const res = await executeInApp('desktop', 'focus_window', { app: name });
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async inspect_page() {
-        const res = await executeInApp('desktop', 'analyze_screen');
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
-    }
-    async get_active_window() {
-        const res = await getScreenInfo();
-        return {
-            success: res.success,
-            output: res.output,
-            details: res.details,
-        };
+    async runPowerShell(script) {
+        const encoded = Buffer.from(script, 'utf16le').toString('base64');
+        const { stdout } = await execAsync(`powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`);
+        return (stdout || '').trim();
     }
-}
-/**
- * MockComputerController: Fast, deterministic in-memory computer controller
- * for automated unit tests, CI pipelines, and desktop simulations.
- */
-export class MockComputerController {
-    cursor = { x: 0, y: 0 };
-    activeApp = null;
-    openApps = new Set();
-    typedHistory = [];
-    actionLog = [];
     async screenshot() {
-        this.actionLog.push({ action: 'screenshot', params: {} });
-        return {
-            success: true,
-            output: 'Mock screenshot captured: 1920x1080 virtual desktop.',
-            details: { width: 1920, height: 1080, format: 'png' },
-        };
-    }
-    async click(x, y, button) {
-        const btn = typeof button === 'object' ? (button.button || 'left') : (button || 'left');
-        this.cursor = { x, y };
-        this.actionLog.push({ action: 'click', params: { x, y, button: btn } });
-        return {
-            success: true,
-            output: `Mock clicked ${btn} button at (${x}, ${y}).`,
-            details: { x, y, button: btn },
-        };
-    }
-    async getWindowList() {
-        return Array.from(this.openApps).length > 0 ? Array.from(this.openApps) : ['Code', 'Chrome', 'Terminal'];
+        const timestamp = new Date().toISOString();
+        const filename = `screen_${Date.now()}.png`;
+        const filePath = path.join(this.screenshotsDir, filename);
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+$bmp = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+$graphics = [System.Drawing.Graphics]::FromImage($bmp)
+$graphics.CopyFromScreen($bounds.Location, [System.Drawing.Point]::Empty, $bounds.Size)
+$bmp.Save('${filePath.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)
+$graphics.Dispose()
+$bmp.Dispose()
+Write-Output "$($bounds.Width)x$($bounds.Height)"
+`.trim();
+                const { stdout } = await execAsync(`powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, '; ')}"`);
+                const dims = stdout.trim().split('x');
+                const width = parseInt(dims[0] || '1920', 10);
+                const height = parseInt(dims[1] || '1080', 10);
+                const ui = await this.inspectUI();
+                return {
+                    path: filePath,
+                    width,
+                    height,
+                    activeWindow: ui.activeWindow,
+                    timestamp,
+                };
+            }
+            catch (err) {
+                return {
+                    width: 1920,
+                    height: 1080,
+                    activeWindow: 'Desktop',
+                    timestamp,
+                };
+            }
+        }
+        else if (process.platform === 'darwin') {
+            try {
+                await execAsync(`screencapture -x "${filePath}"`);
+                return { path: filePath, width: 1920, height: 1080, activeWindow: 'Desktop', timestamp };
+            }
+            catch {
+                return { width: 1920, height: 1080, timestamp };
+            }
+        }
+        else {
+            // Linux fallback (scrot or import)
+            try {
+                await execAsync(`scrot "${filePath}"`);
+                return { path: filePath, width: 1920, height: 1080, activeWindow: 'Desktop', timestamp };
+            }
+            catch {
+                return { width: 1920, height: 1080, timestamp };
+            }
+        }
     }
-    async typeText(text) {
-        return this.type(text);
+    async click(x, y, options) {
+        const btn = options?.button || 'left';
+        const count = options?.clicks || 1;
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(x)}, ${Math.round(y)})
+$src = @"
+using System;
+using System.Runtime.InteropServices;
+public class WinMouse {
+    [DllImport("user32.dll")]
+    public static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo);
+}
+"@
+Add-Type -TypeDefinition $src -ErrorAction SilentlyContinue
+# MOUSEEVENTF_LEFTDOWN = 0x0002, MOUSEEVENTF_LEFTUP = 0x0004
+# MOUSEEVENTF_RIGHTDOWN = 0x0008, MOUSEEVENTF_RIGHTUP = 0x0010
+${btn === 'right'
+                    ? `[WinMouse]::mouse_event(0x0008, 0, 0, 0, 0); Start-Sleep -Milliseconds 50; [WinMouse]::mouse_event(0x0010, 0, 0, 0, 0)`
+                    : `for ($i=0; $i -lt ${count}; $i++) { [WinMouse]::mouse_event(0x0002, 0, 0, 0, 0); Start-Sleep -Milliseconds 40; [WinMouse]::mouse_event(0x0004, 0, 0, 0, 0); Start-Sleep -Milliseconds 50 }`}
+`.trim();
+                await execAsync(`powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, '; ')}"`);
+                return { success: true, output: `Clicked ${btn} button at (${x}, ${y})` };
+            }
+            catch (err) {
+                return { success: false, output: `Click failed at (${x}, ${y}): ${err?.message || String(err)}` };
+            }
+        }
+        return { success: true, output: `Simulated click at (${x}, ${y}) on platform ${process.platform}` };
     }
-    async takeScreenshot() {
-        return {
-            format: 'base64',
-            width: 1920,
-            height: 1080,
-            data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
-        };
-    }
-    async double_click(x, y) {
-        this.cursor = { x, y };
-        this.actionLog.push({ action: 'double_click', params: { x, y } });
-        return {
-            success: true,
-            output: `Mock double-clicked at (${x}, ${y}).`,
-            details: { x, y },
-        };
+    async doubleClick(x, y) {
+        return this.click(x, y, { button: 'left', clicks: 2 });
     }
     async type(text) {
-        this.typedHistory.push(text);
-        this.actionLog.push({ action: 'type', params: { text } });
+        if (!text)
+            return { success: true, output: 'Typed empty string', action: 'type' };
+        if (process.platform === 'win32') {
+            try {
+                const targetApp = this.expectedApplication || 'Notepad';
+                const escaped = text
+                    .replace(/\{/g, '{{}')
+                    .replace(/\}/g, '{}}')
+                    .replace(/\+/g, '{+}')
+                    .replace(/\^/g, '{^}')
+                    .replace(/%/g, '{%}')
+                    .replace(/~/g, '{~}')
+                    .replace(/\(/g, '{(}')
+                    .replace(/\)/g, '{)}')
+                    .replace(/\[/g, '{[}')
+                    .replace(/\]/g, '{]}');
+                const psScript = `
+$wshell = New-Object -ComObject Wscript.Shell
+$null = $wshell.AppActivate('${targetApp}')
+Start-Sleep -Milliseconds 250
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${escaped.replace(/"/g, '`"')}")
+`.trim();
+                await this.runPowerShell(psScript);
+                this.activeWindow = targetApp;
+                return {
+                    success: true,
+                    output: `Typed text (${text.length} chars) into active application "${targetApp}"`,
+                    action: 'type',
+                    activeWindow: targetApp,
+                    expectedWindow: targetApp,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    output: `Type error on active window "${this.expectedApplication || 'foreground'}": ${err?.message || String(err)}`,
+                    action: 'type',
+                    error: err?.message || String(err),
+                    recoverable: true,
+                    expectedWindow: this.expectedApplication || undefined,
+                };
+            }
+        }
         return {
             success: true,
-            output: `Mock typed "${text}" into active application ${this.activeApp || 'desktop'}.`,
-            details: { text, activeApp: this.activeApp },
+            output: `Simulated type (${text.length} chars)`,
+            action: 'type',
+            activeWindow: this.expectedApplication || 'Simulated Window',
         };
     }
-    async key_press(key) {
-        this.actionLog.push({ action: 'key_press', params: { key } });
-        return {
-            success: true,
-            output: `Mock pressed key "${key}".`,
-            details: { key },
+    async keyPress(key) {
+        const keyMap = {
+            enter: '{ENTER}',
+            return: '{ENTER}',
+            tab: '{TAB}',
+            escape: '{ESC}',
+            esc: '{ESC}',
+            backspace: '{BACKSPACE}',
+            delete: '{DEL}',
+            up: '{UP}',
+            down: '{DOWN}',
+            left: '{LEFT}',
+            right: '{RIGHT}',
+            space: ' ',
+            home: '{HOME}',
+            end: '{END}',
+            pageup: '{PGUP}',
+            pagedown: '{PGDN}',
         };
+        const mapped = keyMap[key.toLowerCase()] || key;
+        if (process.platform === 'win32') {
+            try {
+                const targetApp = this.expectedApplication || '';
+                const psScript = `
+$wshell = New-Object -ComObject Wscript.Shell
+${targetApp ? `$null = $wshell.AppActivate('${targetApp}')\nStart-Sleep -Milliseconds 150` : ''}
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${mapped}")
+`.trim();
+                await this.runPowerShell(psScript);
+                return {
+                    success: true,
+                    output: `Pressed key: ${key}`,
+                    action: 'key_press',
+                    activeWindow: targetApp || undefined,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    output: `KeyPress error: ${err?.message || String(err)}`,
+                    action: 'key_press',
+                    error: err?.message || String(err),
+                    recoverable: true,
+                };
+            }
+        }
+        return { success: true, output: `Simulated key press: ${key}`, action: 'key_press' };
     }
     async hotkey(keys) {
-        const combo = Array.isArray(keys) ? keys.join('+') : keys;
-        this.actionLog.push({ action: 'hotkey', params: { combo } });
-        return {
-            success: true,
-            output: `Mock pressed hotkey combo "${combo}".`,
-            details: { combo },
-        };
-    }
-    async scroll(direction, amount = 4) {
-        this.actionLog.push({ action: 'scroll', params: { direction, amount } });
-        return {
-            success: true,
-            output: `Mock scrolled ${direction} by ${amount} units.`,
-            details: { direction, amount },
-        };
-    }
-    async move_mouse(x, y) {
-        this.cursor = { x, y };
-        this.actionLog.push({ action: 'move_mouse', params: { x, y } });
-        return {
-            success: true,
-            output: `Mock moved cursor to (${x}, ${y}).`,
-            details: { x, y },
-        };
-    }
-    async drag(start, end) {
-        this.cursor = { ...end };
-        this.actionLog.push({ action: 'drag', params: { start, end } });
-        return {
-            success: true,
-            output: `Mock dragged from (${start.x}, ${start.y}) to (${end.x}, ${end.y}).`,
-            details: { start, end },
-        };
+        if (!keys || keys.length === 0)
+            return { success: false, output: 'No keys provided for hotkey', action: 'hotkey' };
+        if (process.platform === 'win32') {
+            try {
+                const targetApp = this.expectedApplication || '';
+                let prefix = '';
+                let mainKey = '';
+                for (const k of keys) {
+                    const lk = k.toLowerCase();
+                    if (lk === 'ctrl' || lk === 'control')
+                        prefix += '^';
+                    else if (lk === 'alt')
+                        prefix += '%';
+                    else if (lk === 'shift')
+                        prefix += '+';
+                    else
+                        mainKey = k;
+                }
+                const sendPattern = `${prefix}${mainKey.toLowerCase()}`;
+                const psScript = `
+$wshell = New-Object -ComObject Wscript.Shell
+${targetApp ? `$null = $wshell.AppActivate('${targetApp}')\nStart-Sleep -Milliseconds 150` : ''}
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${sendPattern}")
+`.trim();
+                await this.runPowerShell(psScript);
+                return {
+                    success: true,
+                    output: `Executed hotkey: ${keys.join('+')} on "${targetApp || 'active window'}"`,
+                    action: 'hotkey',
+                    activeWindow: targetApp || undefined,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    output: `Hotkey error: ${err?.message || String(err)}`,
+                    action: 'hotkey',
+                    error: err?.message || String(err),
+                    recoverable: true,
+                };
+            }
+        }
+        return { success: true, output: `Simulated hotkey: ${keys.join('+')}`, action: 'hotkey' };
+    }
+    async scroll(deltaX, deltaY) {
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+$src = @"
+using System;
+using System.Runtime.InteropServices;
+public class WinMouseScroll {
+    [DllImport("user32.dll")]
+    public static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo);
+}
+"@
+Add-Type -TypeDefinition $src -ErrorAction SilentlyContinue
+# MOUSEEVENTF_WHEEL = 0x0800
+[WinMouseScroll]::mouse_event(0x0800, 0, 0, [uint32]${Math.round(-deltaY * 120)}, 0)
+`.trim();
+                await execAsync(`powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, '; ')}"`);
+                return { success: true, output: `Scrolled deltaY=${deltaY}, deltaX=${deltaX}` };
+            }
+            catch (err) {
+                return { success: false, output: `Scroll error: ${err?.message || String(err)}` };
+            }
+        }
+        return { success: true, output: `Simulated scroll deltaY=${deltaY}` };
+    }
+    async mouseMove(x, y) {
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(x)}, ${Math.round(y)})
+`.trim();
+                await execAsync(`powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, '; ')}"`);
+                return { success: true, output: `Moved mouse cursor to (${x}, ${y})` };
+            }
+            catch (err) {
+                return { success: false, output: `MouseMove error: ${err?.message || String(err)}` };
+            }
+        }
+        return { success: true, output: `Simulated mouse move to (${x}, ${y})` };
+    }
+    async drag(fromX, fromY, toX, toY) {
+        await this.mouseMove(fromX, fromY);
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+Add-Type -AssemblyName System.Windows.Forms
+$src = @"
+using System;
+using System.Runtime.InteropServices;
+public class WinMouseDrag {
+    [DllImport("user32.dll")]
+    public static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo);
+}
+"@
+Add-Type -TypeDefinition $src -ErrorAction SilentlyContinue
+[WinMouseDrag]::mouse_event(0x0002, 0, 0, 0, 0)
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(toX)}, ${Math.round(toY)})
+Start-Sleep -Milliseconds 100
+[WinMouseDrag]::mouse_event(0x0004, 0, 0, 0, 0)
+`.trim();
+                await execAsync(`powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, '; ')}"`);
+                return { success: true, output: `Dragged from (${fromX}, ${fromY}) to (${toX}, ${toY})` };
+            }
+            catch (err) {
+                return { success: false, output: `Drag error: ${err?.message || String(err)}` };
+            }
+        }
+        return { success: true, output: `Simulated drag from (${fromX}, ${fromY}) to (${toX}, ${toY})` };
     }
-    async wait(durationMs) {
-        this.actionLog.push({ action: 'wait', params: { durationMs } });
-        return {
-            success: true,
-            output: `Mock waited ${durationMs}ms.`,
-            details: { durationMs },
-        };
+    async wait(ms) {
+        return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
     }
-    async open_application(name, target) {
-        this.openApps.add(name);
-        this.activeApp = name;
-        this.actionLog.push({ action: 'open_application', params: { name, target } });
-        return {
-            success: true,
-            output: `Mock opened application "${name}" with target "${target || 'default'}".`,
-            details: { name, target, active: true },
-        };
-    }
-    async close_application(name) {
-        this.openApps.delete(name);
-        if (this.activeApp === name)
-            this.activeApp = null;
-        this.actionLog.push({ action: 'close_application', params: { name } });
-        return {
-            success: true,
-            output: `Mock closed application "${name}".`,
-            details: { name },
-        };
+    async openApplication(appName, args = []) {
+        const appLower = appName.toLowerCase().trim();
+        const argsStr = args.join(' ');
+        try {
+            if (process.platform === 'win32') {
+                if (appLower === 'code' || appLower === 'vscode') {
+                    await execAsync(`start code ${argsStr}`);
+                    this.expectedApplication = 'Visual Studio Code';
+                }
+                else if (appLower === 'explorer' || appLower === 'file explorer') {
+                    await execAsync(`start explorer ${argsStr || '.'}`);
+                    this.expectedApplication = 'File Explorer';
+                }
+                else if (appLower === 'notepad') {
+                    await execAsync(`start notepad ${argsStr}`);
+                    this.expectedApplication = 'Notepad';
+                }
+                else if (appLower === 'terminal' || appLower === 'cmd' || appLower === 'powershell') {
+                    await execAsync(`start powershell ${argsStr}`);
+                    this.expectedApplication = 'PowerShell';
+                }
+                else {
+                    await execAsync(`start "" "${appName}" ${argsStr}`);
+                    this.expectedApplication = appName;
+                }
+                await this.wait(350);
+                if (this.expectedApplication) {
+                    await this.switchWindow(this.expectedApplication);
+                }
+                return {
+                    success: true,
+                    output: `Launched and focused application: "${this.expectedApplication || appName}"`,
+                    action: 'open_app',
+                    activeWindow: this.expectedApplication || appName,
+                    expectedWindow: this.expectedApplication || appName,
+                };
+            }
+            else if (process.platform === 'darwin') {
+                await execAsync(`open -a "${appName}" ${argsStr}`);
+                this.expectedApplication = appName;
+            }
+            else {
+                await execAsync(`xdg-open "${appName}" ${argsStr} &`);
+                this.expectedApplication = appName;
+            }
+            return {
+                success: true,
+                output: `Launched application: "${appName}"`,
+                action: 'open_app',
+                activeWindow: appName,
+                expectedWindow: appName,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed to launch "${appName}": ${err?.message || String(err)}`,
+                action: 'open_app',
+                error: err?.message || String(err),
+                recoverable: true,
+            };
+        }
     }
-    async switch_application(name) {
-        this.openApps.add(name);
-        this.activeApp = name;
-        this.actionLog.push({ action: 'switch_application', params: { name } });
-        return {
-            success: true,
-            output: `Mock focused application "${name}".`,
-            details: { name },
-        };
+    async closeApplication(appName) {
+        try {
+            if (process.platform === 'win32') {
+                const cleanName = appName.replace(/\.exe$/i, '');
+                await execAsync(`powershell -NoProfile -Command "Stop-Process -Name '${cleanName}' -Force -ErrorAction SilentlyContinue"`);
+            }
+            else {
+                await execAsync(`pkill -f "${appName}"`);
+            }
+            if (this.expectedApplication && this.expectedApplication.toLowerCase().includes(appName.toLowerCase())) {
+                this.expectedApplication = null;
+            }
+            return { success: true, output: `Closed application: "${appName}"`, action: 'close_app' };
+        }
+        catch (err) {
+            return {
+                success: false,
+                output: `Failed to close "${appName}": ${err?.message || String(err)}`,
+                action: 'close_app',
+                error: err?.message || String(err),
+            };
+        }
     }
-    async inspect_page() {
-        this.actionLog.push({ action: 'inspect_page', params: {} });
-        return {
-            success: true,
-            output: `Mock visual inspection of active app "${this.activeApp || 'desktop'}": 3 windows, 12 controls detected.`,
-            details: { activeApp: this.activeApp, controlsCount: 12 },
-        };
+    async switchWindow(windowTitleOrApp) {
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+$wshell = New-Object -ComObject Wscript.Shell
+$result = $wshell.AppActivate("${windowTitleOrApp.replace(/"/g, '`"')}")
+if (-not $result) {
+    $p = Get-Process | Where-Object { $_.MainWindowTitle -like "*${windowTitleOrApp.replace(/"/g, '`"')}*" -or $_.ProcessName -like "*${windowTitleOrApp.replace(/"/g, '`"')}*" } | Select-Object -First 1
+    if ($p) {
+        $null = $wshell.AppActivate($p.Id)
+        $result = $true
     }
-    async get_active_window() {
-        return {
-            success: true,
-            output: `Active window: "${this.activeApp || 'Desktop'}"`,
-            details: { activeApp: this.activeApp },
-        };
+}
+Start-Sleep -Milliseconds 150
+if ($result) { Write-Output "OK" } else { Write-Output "NOT_FOUND" }
+`.trim();
+                const stdout = await this.runPowerShell(psScript);
+                this.activeWindow = windowTitleOrApp;
+                this.expectedApplication = windowTitleOrApp;
+                if (stdout.includes('OK')) {
+                    return {
+                        success: true,
+                        output: `Focused window matching: "${windowTitleOrApp}"`,
+                        action: 'switch_window',
+                        activeWindow: windowTitleOrApp,
+                        expectedWindow: windowTitleOrApp,
+                    };
+                }
+                return {
+                    success: false,
+                    output: `Could not find or focus window: "${windowTitleOrApp}". Try computer_inspect_ui to list open windows.`,
+                    action: 'switch_window',
+                    recoverable: true,
+                };
+            }
+            catch (err) {
+                return {
+                    success: false,
+                    output: `Window switch error for "${windowTitleOrApp}": ${err?.message || String(err)}`,
+                    action: 'switch_window',
+                    error: err?.message || String(err),
+                    recoverable: true,
+                };
+            }
+        }
+        this.activeWindow = windowTitleOrApp;
+        return { success: true, output: `Switched window to: "${windowTitleOrApp}"`, action: 'switch_window' };
+    }
+    async inspectUI() {
+        if (process.platform === 'win32') {
+            try {
+                const psScript = `
+Get-Process | Where-Object { $_.MainWindowTitle -and $_.MainWindowTitle.Trim().Length -gt 0 } | Select-Object -ExpandProperty MainWindowTitle
+`.trim();
+                const { stdout } = await execAsync(`powershell -NoProfile -NonInteractive -Command "${psScript.replace(/\n/g, '; ')}"`);
+                const titles = stdout
+                    .split('\n')
+                    .map((t) => t.trim())
+                    .filter((t) => t.length > 0);
+                const active = titles.length > 0 ? titles[0] : 'Desktop';
+                return {
+                    activeWindow: active,
+                    windows: titles,
+                };
+            }
+            catch {
+                return { activeWindow: 'Desktop', windows: ['Desktop'] };
+            }
+        }
+        return { activeWindow: 'Desktop', windows: ['Desktop', 'Terminal'] };
     }
 }
 //# sourceMappingURL=computerController.js.map