codeloop-mcp-server 0.1.4 → 0.1.6

package/dist/runners/window_manager.js

@@ -0,0 +1,1010 @@
+import { platform, tmpdir } from "os";
+import { writeFileSync, unlinkSync } from "fs";
+import { join } from "path";
+import { runCommand, checkToolAvailable } from "./base.js";
+/**
+ * Cross-platform window ID lookup.
+ * macOS: CGWindowListCopyWindowInfo via Swift
+ * Linux: xdotool search
+ * Windows: not needed (uses process handle)
+ */
+export async function findWindowId(appName) {
+    const os = platform();
+    if (os === "darwin")
+        return findMacOSWindowId(appName);
+    if (os === "linux")
+        return findLinuxWindowId(appName);
+    return null;
+}
+async function findMacOSWindowId(appName) {
+    const tmpFile = join(tmpdir(), `codeloop_findwindow_${Date.now()}.swift`);
+    const swiftCode = [
+        'import Cocoa',
+        'let options: CGWindowListOption = [.optionOnScreenOnly, .excludeDesktopElements]',
+        'guard let windowList = CGWindowListCopyWindowInfo(options, kCGNullWindowID) as? [[String: Any]] else { exit(1) }',
+        `let search = "${appName}".lowercased()`,
+        'for window in windowList {',
+        '  let owner = window[kCGWindowOwnerName as String] as? String ?? ""',
+        '  let windowID = window[kCGWindowNumber as String] as? Int ?? 0',
+        '  if owner.lowercased().contains(search) && windowID > 0 {',
+        '    print(windowID)',
+        '    exit(0)',
+        '  }',
+        '}',
+    ].join('\n');
+    writeFileSync(tmpFile, swiftCode);
+    try {
+        const result = await runCommand("swift", [tmpFile], process.cwd());
+        if (result.exit_code === 0 && result.stdout.trim()) {
+            return result.stdout.trim();
+        }
+    }
+    finally {
+        try {
+            unlinkSync(tmpFile);
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+async function findLinuxWindowId(appName) {
+    if (!(await checkToolAvailable("xdotool")))
+        return null;
+    const result = await runCommand("xdotool", ["search", "--name", appName], process.cwd());
+    if (result.exit_code === 0 && result.stdout.trim()) {
+        return result.stdout.trim().split("\n")[0];
+    }
+    return null;
+}
+/**
+ * Bring an app to the front, un-minimizing if needed.
+ * Returns the name/title of the previously frontmost app for later restoration.
+ */
+export async function bringAppToFront(appName) {
+    const os = platform();
+    if (os === "darwin")
+        return bringToFrontMacOS(appName);
+    if (os === "win32")
+        return bringToFrontWindows(appName);
+    return bringToFrontLinux(appName);
+}
+async function bringToFrontMacOS(appName) {
+    const prevScript = 'tell application "System Events" to get name of first application process whose frontmost is true';
+    const prevResult = await runCommand("osascript", ["-e", prevScript], process.cwd());
+    let previousApp = prevResult.exit_code === 0 ? prevResult.stdout.trim() : "";
+    // If detection failed or returned the target app itself, find the IDE to restore later
+    if (!previousApp || previousApp.toLowerCase().includes(appName.toLowerCase())) {
+        previousApp = await detectRunningIDE();
+    }
+    const activateScript = `
+    tell application "System Events"
+      try
+        set targetProc to first process whose name contains "${appName}"
+        set visible of targetProc to true
+      end try
+    end tell
+    tell application "${appName}" to activate
+  `;
+    await runCommand("osascript", ["-e", activateScript], process.cwd());
+    await new Promise((r) => setTimeout(r, 800));
+    return previousApp;
+}
+async function detectRunningIDE() {
+    const candidates = ["Cursor", "Code", "Visual Studio Code", "Terminal", "iTerm2", "Warp"];
+    for (const ide of candidates) {
+        const checkScript = `tell application "System Events" to (exists process "${ide}")`;
+        const result = await runCommand("osascript", ["-e", checkScript], process.cwd());
+        if (result.stdout.trim() === "true")
+            return ide;
+    }
+    return "Cursor";
+}
+async function bringToFrontWindows(appName) {
+    const script = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32Focus {
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+  [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);
+  [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+  [DllImport("user32.dll", CharSet=CharSet.Auto)] public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
+}
+"@
+$prev = [Win32Focus]::GetForegroundWindow()
+$sb = New-Object System.Text.StringBuilder 256
+[Win32Focus]::GetWindowText($prev, $sb, 256)
+Write-Output $sb.ToString()
+$proc = Get-Process | Where-Object { $_.MainWindowTitle -match '${appName}' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1
+if ($proc) {
+  [Win32Focus]::ShowWindow($proc.MainWindowHandle, 9)
+  [Win32Focus]::SetForegroundWindow($proc.MainWindowHandle)
+}
+`;
+    const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+    return result.exit_code === 0 ? result.stdout.trim() : "";
+}
+async function bringToFrontLinux(appName) {
+    let previousWindow = "";
+    if (await checkToolAvailable("xdotool")) {
+        const activeResult = await runCommand("xdotool", ["getactivewindow", "getwindowname"], process.cwd());
+        previousWindow = activeResult.exit_code === 0 ? activeResult.stdout.trim() : "";
+        const searchResult = await runCommand("xdotool", ["search", "--name", appName], process.cwd());
+        if (searchResult.exit_code === 0 && searchResult.stdout.trim()) {
+            const windowId = searchResult.stdout.trim().split("\n")[0];
+            await runCommand("xdotool", ["windowactivate", windowId], process.cwd());
+            await new Promise((r) => setTimeout(r, 500));
+        }
+    }
+    return previousWindow;
+}
+/**
+ * Get the window bounds (position + size) for cropping video capture.
+ * Returns { x, y, width, height } in screen points.
+ */
+export async function getWindowBounds(appName) {
+    const os = platform();
+    if (os === "darwin")
+        return getWindowBoundsMacOS(appName);
+    if (os === "win32")
+        return getWindowBoundsWindows(appName);
+    if (os === "linux")
+        return getWindowBoundsLinux(appName);
+    return null;
+}
+async function getWindowBoundsMacOS(appName) {
+    const tmpFile = join(tmpdir(), `codeloop_winbounds_${Date.now()}.swift`);
+    const swiftCode = [
+        'import Cocoa',
+        'let options: CGWindowListOption = [.optionOnScreenOnly, .excludeDesktopElements]',
+        'guard let windowList = CGWindowListCopyWindowInfo(options, kCGNullWindowID) as? [[String: Any]] else { exit(1) }',
+        `let search = "${appName}".lowercased()`,
+        'for window in windowList {',
+        '  let owner = window[kCGWindowOwnerName as String] as? String ?? ""',
+        '  if owner.lowercased().contains(search) {',
+        '    if let bounds = window[kCGWindowBounds as String] as? [String: Any] {',
+        '      let x = bounds["X"] as? Int ?? 0',
+        '      let y = bounds["Y"] as? Int ?? 0',
+        '      let w = bounds["Width"] as? Int ?? 0',
+        '      let h = bounds["Height"] as? Int ?? 0',
+        '      if w > 50 && h > 50 {',
+        '        print("\\(x),\\(y),\\(w),\\(h)")',
+        '        exit(0)',
+        '      }',
+        '    }',
+        '  }',
+        '}',
+    ].join('\n');
+    writeFileSync(tmpFile, swiftCode);
+    try {
+        const result = await runCommand("swift", [tmpFile], process.cwd());
+        if (result.exit_code === 0 && result.stdout.trim()) {
+            const parts = result.stdout.trim().split(",").map(Number);
+            if (parts.length === 4 && parts.every(n => !isNaN(n))) {
+                return { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
+            }
+        }
+    }
+    finally {
+        try {
+            unlinkSync(tmpFile);
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+async function getWindowBoundsWindows(appName) {
+    const script = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32Bounds {
+  [StructLayout(LayoutKind.Sequential)]
+  public struct RECT { public int Left; public int Top; public int Right; public int Bottom; }
+  [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+}
+"@
+$proc = Get-Process | Where-Object { $_.MainWindowTitle -match '${appName}' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1
+if ($proc) {
+  $rect = New-Object Win32Bounds+RECT
+  [Win32Bounds]::GetWindowRect($proc.MainWindowHandle, [ref]$rect) | Out-Null
+  Write-Output "$($rect.Left),$($rect.Top),$($rect.Right - $rect.Left),$($rect.Bottom - $rect.Top)"
+}
+`;
+    const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+    if (result.exit_code === 0 && result.stdout.trim()) {
+        const parts = result.stdout.trim().split(",").map(Number);
+        if (parts.length === 4 && parts.every(n => !isNaN(n))) {
+            return { x: parts[0], y: parts[1], width: parts[2], height: parts[3] };
+        }
+    }
+    return null;
+}
+async function getWindowBoundsLinux(appName) {
+    if (!(await checkToolAvailable("xdotool")))
+        return null;
+    const searchResult = await runCommand("xdotool", ["search", "--name", appName], process.cwd());
+    if (searchResult.exit_code !== 0 || !searchResult.stdout.trim())
+        return null;
+    const windowId = searchResult.stdout.trim().split("\n")[0];
+    const geoResult = await runCommand("xdotool", ["getwindowgeometry", "--shell", windowId], process.cwd());
+    if (geoResult.exit_code !== 0)
+        return null;
+    const lines = geoResult.stdout.split("\n");
+    let x = 0, y = 0, w = 0, h = 0;
+    for (const line of lines) {
+        const [key, val] = line.split("=");
+        if (key === "X")
+            x = parseInt(val, 10);
+        else if (key === "Y")
+            y = parseInt(val, 10);
+        else if (key === "WIDTH")
+            w = parseInt(val, 10);
+        else if (key === "HEIGHT")
+            h = parseInt(val, 10);
+    }
+    if (w > 0 && h > 0)
+        return { x, y, width: w, height: h };
+    return null;
+}
+/**
+ * Click at screen coordinates using CGEvent (macOS), user32.dll (Windows),
+ * or xdotool (Linux). These are low-level HID events that Flutter and all
+ * frameworks receive.
+ */
+export async function clickAtPosition(x, y) {
+    const os = platform();
+    if (os === "darwin") {
+        const tmpFile = join(tmpdir(), `codeloop_click_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let point = CGPoint(x: ${x}, y: ${y})`,
+            'let mouseDown = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: point, mouseButton: .left)',
+            'let mouseUp = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: point, mouseButton: .left)',
+            'mouseDown?.post(tap: .cghidEventTap)',
+            'Thread.sleep(forTimeInterval: 0.05)',
+            'mouseUp?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const script = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32Click {
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
+}
+"@
+[Win32Click]::SetCursorPos(${x}, ${y})
+Start-Sleep -Milliseconds 50
+[Win32Click]::mouse_event(0x0002, 0, 0, 0, [UIntPtr]::Zero)
+Start-Sleep -Milliseconds 50
+[Win32Click]::mouse_event(0x0004, 0, 0, 0, [UIntPtr]::Zero)
+`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const result = await runCommand("xdotool", ["mousemove", String(x), String(y), "click", "1"], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+/**
+ * Send a keystroke using CGEvent (macOS), user32.dll keybd_event (Windows),
+ * or xdotool (Linux).
+ *
+ * keyCode values are platform-specific:
+ * - macOS: CGKeyCode (e.g., 36=Return, 53=Escape, 48=Tab)
+ * - Windows: Virtual Key code (e.g., 0x0D=Enter, 0x1B=Escape, 0x09=Tab)
+ * - Linux: X11 keysym name as string via keyName param, or keyCode ignored
+ */
+export async function sendKeystroke(keyCode, keyName) {
+    const os = platform();
+    if (os === "darwin") {
+        const tmpFile = join(tmpdir(), `codeloop_key_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let keyDown = CGEvent(keyboardEventSource: nil, virtualKey: CGKeyCode(${keyCode}), keyDown: true)`,
+            `let keyUp = CGEvent(keyboardEventSource: nil, virtualKey: CGKeyCode(${keyCode}), keyDown: false)`,
+            'keyDown?.post(tap: .cghidEventTap)',
+            'Thread.sleep(forTimeInterval: 0.05)',
+            'keyUp?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const vk = keyCode & 0xFF;
+        const script = `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+public class Win32Key {
+  [DllImport("user32.dll")] public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
+}
+"@
+[Win32Key]::keybd_event(${vk}, 0, 0, [UIntPtr]::Zero)
+Start-Sleep -Milliseconds 50
+[Win32Key]::keybd_event(${vk}, 0, 2, [UIntPtr]::Zero)
+`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const xKey = keyName || String(keyCode);
+            const result = await runCommand("xdotool", ["key", "--clearmodifiers", xKey], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+// ── Mobile Interaction (Android emulator via ADB) ───────────────
+export async function adbTap(x, y) {
+    const result = await runCommand("adb", ["shell", "input", "tap", String(Math.round(x)), String(Math.round(y))], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbType(text) {
+    const escaped = text.replace(/ /g, "%s").replace(/'/g, "\\'");
+    const result = await runCommand("adb", ["shell", "input", "text", escaped], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbKey(keycode) {
+    const result = await runCommand("adb", ["shell", "input", "keyevent", keycode], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbSwipe(x1, y1, x2, y2, durationMs = 300) {
+    const result = await runCommand("adb", [
+        "shell", "input", "swipe",
+        String(Math.round(x1)), String(Math.round(y1)),
+        String(Math.round(x2)), String(Math.round(y2)),
+        String(durationMs),
+    ], process.cwd());
+    return result.exit_code === 0;
+}
+// ── Mobile Interaction (iOS Simulator via simctl) ───────────────
+export async function simctlLaunch(bundleId) {
+    const result = await runCommand("xcrun", ["simctl", "launch", "booted", bundleId], process.cwd());
+    return result.exit_code === 0;
+}
+export async function simctlTerminate(bundleId) {
+    const result = await runCommand("xcrun", ["simctl", "terminate", "booted", bundleId], process.cwd());
+    return result.exit_code === 0;
+}
+// ── Friendly Key Name Mapping ────────────────────────────────────
+const KEY_MAP = {
+    enter: { mac: 36, win: 0x0D, linux: "Return" },
+    tab: { mac: 48, win: 0x09, linux: "Tab" },
+    escape: { mac: 53, win: 0x1B, linux: "Escape" },
+    backspace: { mac: 51, win: 0x08, linux: "BackSpace" },
+    delete: { mac: 117, win: 0x2E, linux: "Delete" },
+    space: { mac: 49, win: 0x20, linux: "space" },
+    up: { mac: 126, win: 0x26, linux: "Up" },
+    down: { mac: 125, win: 0x28, linux: "Down" },
+    left: { mac: 123, win: 0x25, linux: "Left" },
+    right: { mac: 124, win: 0x27, linux: "Right" },
+    home: { mac: 115, win: 0x24, linux: "Home" },
+    end: { mac: 119, win: 0x23, linux: "End" },
+    page_up: { mac: 116, win: 0x21, linux: "Prior" },
+    page_down: { mac: 121, win: 0x22, linux: "Next" },
+    f1: { mac: 122, win: 0x70, linux: "F1" },
+    f2: { mac: 120, win: 0x71, linux: "F2" },
+    f3: { mac: 99, win: 0x72, linux: "F3" },
+    f4: { mac: 118, win: 0x73, linux: "F4" },
+    f5: { mac: 96, win: 0x74, linux: "F5" },
+    f6: { mac: 97, win: 0x75, linux: "F6" },
+    f7: { mac: 98, win: 0x76, linux: "F7" },
+    f8: { mac: 100, win: 0x77, linux: "F8" },
+    f9: { mac: 101, win: 0x78, linux: "F9" },
+    f10: { mac: 109, win: 0x79, linux: "F10" },
+    f11: { mac: 103, win: 0x7A, linux: "F11" },
+    f12: { mac: 111, win: 0x7B, linux: "F12" },
+};
+export function getAvailableKeyNames() {
+    return Object.keys(KEY_MAP);
+}
+export async function sendKeyByName(keyName) {
+    const lower = keyName.toLowerCase();
+    const mapping = KEY_MAP[lower];
+    if (!mapping)
+        return false;
+    const os = platform();
+    if (os === "darwin")
+        return sendKeystroke(mapping.mac);
+    if (os === "win32")
+        return sendKeystroke(mapping.win);
+    return sendKeystroke(0, mapping.linux);
+}
+// ── Extended Desktop Interaction ────────────────────────────────
+export async function typeText(text) {
+    const os = platform();
+    if (os === "darwin") {
+        const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+        const result = await runCommand("osascript", ["-e", `tell application "System Events" to keystroke "${escaped}"`], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "win32") {
+        const escaped = text.replace(/[+^%~(){}[\]]/g, "{$&}");
+        const script = `Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait("${escaped}")`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const result = await runCommand("xdotool", ["type", "--clearmodifiers", text], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+export async function scrollAtPosition(x, y, direction, amount = 3) {
+    const os = platform();
+    if (os === "darwin") {
+        const deltaY = direction === "up" ? amount : direction === "down" ? -amount : 0;
+        const deltaX = direction === "left" ? amount : direction === "right" ? -amount : 0;
+        const tmpFile = join(tmpdir(), `codeloop_scroll_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let move = CGEvent(mouseEventSource: nil, mouseType: .mouseMoved, mouseCursorPosition: CGPoint(x: ${x}, y: ${y}), mouseButton: .left)`,
+            'move?.post(tap: .cghidEventTap)',
+            'Thread.sleep(forTimeInterval: 0.05)',
+            `let scroll = CGEvent(scrollWheelEvent2Source: nil, units: .line, wheelCount: 2, wheel1: Int32(${deltaY}), wheel2: Int32(${deltaX}))`,
+            'scroll?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const wheelDelta = direction === "up" ? 120 * amount : direction === "down" ? -120 * amount : 0;
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32Scroll {
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
+}
+"@
+[Win32Scroll]::SetCursorPos(${x}, ${y})
+Start-Sleep -Milliseconds 50
+[Win32Scroll]::mouse_event(0x0800, 0, 0, ${wheelDelta}, [UIntPtr]::Zero)`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            await runCommand("xdotool", ["mousemove", String(x), String(y)], process.cwd());
+            const button = direction === "up" ? "4" : direction === "down" ? "5" : direction === "left" ? "6" : "7";
+            for (let i = 0; i < amount; i++) {
+                await runCommand("xdotool", ["click", button], process.cwd());
+            }
+            return true;
+        }
+    }
+    return false;
+}
+export async function doubleClickAtPosition(x, y) {
+    const os = platform();
+    if (os === "darwin") {
+        const tmpFile = join(tmpdir(), `codeloop_dblclick_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let point = CGPoint(x: ${x}, y: ${y})`,
+            'let d1 = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: point, mouseButton: .left)',
+            'd1?.setIntegerValueField(.mouseEventClickState, value: 1)',
+            'd1?.post(tap: .cghidEventTap)',
+            'let u1 = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: point, mouseButton: .left)',
+            'u1?.setIntegerValueField(.mouseEventClickState, value: 1)',
+            'u1?.post(tap: .cghidEventTap)',
+            'Thread.sleep(forTimeInterval: 0.05)',
+            'let d2 = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: point, mouseButton: .left)',
+            'd2?.setIntegerValueField(.mouseEventClickState, value: 2)',
+            'd2?.post(tap: .cghidEventTap)',
+            'let u2 = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: point, mouseButton: .left)',
+            'u2?.setIntegerValueField(.mouseEventClickState, value: 2)',
+            'u2?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32DblClick {
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
+}
+"@
+[Win32DblClick]::SetCursorPos(${x}, ${y})
+[Win32DblClick]::mouse_event(0x0002, 0, 0, 0, [UIntPtr]::Zero)
+[Win32DblClick]::mouse_event(0x0004, 0, 0, 0, [UIntPtr]::Zero)
+Start-Sleep -Milliseconds 50
+[Win32DblClick]::mouse_event(0x0002, 0, 0, 0, [UIntPtr]::Zero)
+[Win32DblClick]::mouse_event(0x0004, 0, 0, 0, [UIntPtr]::Zero)`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const result = await runCommand("xdotool", ["mousemove", String(x), String(y), "click", "--repeat", "2", "1"], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+export async function rightClickAtPosition(x, y) {
+    const os = platform();
+    if (os === "darwin") {
+        const tmpFile = join(tmpdir(), `codeloop_rclick_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let point = CGPoint(x: ${x}, y: ${y})`,
+            'let down = CGEvent(mouseEventSource: nil, mouseType: .rightMouseDown, mouseCursorPosition: point, mouseButton: .right)',
+            'let up = CGEvent(mouseEventSource: nil, mouseType: .rightMouseUp, mouseCursorPosition: point, mouseButton: .right)',
+            'down?.post(tap: .cghidEventTap)',
+            'Thread.sleep(forTimeInterval: 0.05)',
+            'up?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32RClick {
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
+}
+"@
+[Win32RClick]::SetCursorPos(${x}, ${y})
+Start-Sleep -Milliseconds 50
+[Win32RClick]::mouse_event(0x0008, 0, 0, 0, [UIntPtr]::Zero)
+Start-Sleep -Milliseconds 50
+[Win32RClick]::mouse_event(0x0010, 0, 0, 0, [UIntPtr]::Zero)`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const result = await runCommand("xdotool", ["mousemove", String(x), String(y), "click", "3"], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+export async function hoverAtPosition(x, y) {
+    const os = platform();
+    if (os === "darwin") {
+        const tmpFile = join(tmpdir(), `codeloop_hover_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let event = CGEvent(mouseEventSource: nil, mouseType: .mouseMoved, mouseCursorPosition: CGPoint(x: ${x}, y: ${y}), mouseButton: .left)`,
+            'event?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32Hover { [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y); }
+"@
+[Win32Hover]::SetCursorPos(${x}, ${y})`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const result = await runCommand("xdotool", ["mousemove", String(x), String(y)], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+const MODIFIER_KEYCODES = {
+    cmd: { mac: 55, win: 0x5B, linux: "super", macFlag: "kCGEventFlagMaskCommand" },
+    meta: { mac: 55, win: 0x5B, linux: "super", macFlag: "kCGEventFlagMaskCommand" },
+    ctrl: { mac: 59, win: 0x11, linux: "ctrl", macFlag: "kCGEventFlagMaskControl" },
+    alt: { mac: 58, win: 0x12, linux: "alt", macFlag: "kCGEventFlagMaskAlternate" },
+    shift: { mac: 56, win: 0x10, linux: "shift", macFlag: "kCGEventFlagMaskShift" },
+};
+export async function sendHotkey(combo) {
+    const parts = combo.toLowerCase().split("+").map(s => s.trim());
+    const key = parts.pop();
+    const modifiers = parts;
+    const os = platform();
+    if (os === "linux" && (await checkToolAvailable("xdotool"))) {
+        const xdoCombo = [...modifiers, KEY_MAP[key]?.linux || key].join("+");
+        const result = await runCommand("xdotool", ["key", "--clearmodifiers", xdoCombo], process.cwd());
+        return result.exit_code === 0;
+    }
+    if (os === "darwin") {
+        const keyMapping = KEY_MAP[key];
+        const keyCode = keyMapping ? keyMapping.mac : key.charCodeAt(0) - (key >= 'a' ? 97 - 0 : 65 - 0);
+        const flags = modifiers.map(m => MODIFIER_KEYCODES[m]?.macFlag).filter(Boolean);
+        const flagExpr = flags.length > 0
+            ? `var flags: CGEventFlags = []; ${flags.map(f => `flags.insert(.${f})`).join("; ")}`
+            : "let flags: CGEventFlags = []";
+        const tmpFile = join(tmpdir(), `codeloop_hotkey_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            flagExpr,
+            `let keyDown = CGEvent(keyboardEventSource: nil, virtualKey: CGKeyCode(${keyCode}), keyDown: true)`,
+            `let keyUp = CGEvent(keyboardEventSource: nil, virtualKey: CGKeyCode(${keyCode}), keyDown: false)`,
+            'keyDown?.flags = flags',
+            'keyUp?.flags = flags',
+            'keyDown?.post(tap: .cghidEventTap)',
+            'Thread.sleep(forTimeInterval: 0.05)',
+            'keyUp?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    if (os === "win32") {
+        const vkKey = KEY_MAP[key]?.win || key.toUpperCase().charCodeAt(0);
+        const modVks = modifiers.map(m => MODIFIER_KEYCODES[m]?.win).filter(Boolean);
+        const downStatements = modVks.map(vk => `[Win32HK]::keybd_event(${vk}, 0, 0, [UIntPtr]::Zero)`).join("; ");
+        const upStatements = modVks.map(vk => `[Win32HK]::keybd_event(${vk}, 0, 2, [UIntPtr]::Zero)`).join("; ");
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32HK { [DllImport("user32.dll")] public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo); }
+"@
+${downStatements}
+[Win32HK]::keybd_event(${vkKey}, 0, 0, [UIntPtr]::Zero)
+Start-Sleep -Milliseconds 50
+[Win32HK]::keybd_event(${vkKey}, 0, 2, [UIntPtr]::Zero)
+${upStatements}`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    return false;
+}
+export async function dragDrop(x1, y1, x2, y2, durationMs = 500) {
+    const os = platform();
+    if (os === "darwin") {
+        const steps = 20;
+        const tmpFile = join(tmpdir(), `codeloop_drag_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let start = CGPoint(x: ${x1}, y: ${y1})`,
+            `let end = CGPoint(x: ${x2}, y: ${y2})`,
+            'let down = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: start, mouseButton: .left)',
+            'down?.post(tap: .cghidEventTap)',
+            `for i in 1...${steps} {`,
+            `  let t = Double(i) / ${steps}.0`,
+            '  let x = start.x + (end.x - start.x) * t',
+            '  let y = start.y + (end.y - start.y) * t',
+            '  let drag = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDragged, mouseCursorPosition: CGPoint(x: x, y: y), mouseButton: .left)',
+            '  drag?.post(tap: .cghidEventTap)',
+            `  Thread.sleep(forTimeInterval: ${durationMs / 1000.0 / steps})`,
+            '}',
+            'let up = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: end, mouseButton: .left)',
+            'up?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32Drag {
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
+}
+"@
+[Win32Drag]::SetCursorPos(${x1}, ${y1}); Start-Sleep -Milliseconds 50
+[Win32Drag]::mouse_event(0x0002, 0, 0, 0, [UIntPtr]::Zero)
+$steps = 20; for ($i = 1; $i -le $steps; $i++) { $t = $i / $steps; $cx = [int](${x1} + (${x2} - ${x1}) * $t); $cy = [int](${y1} + (${y2} - ${y1}) * $t); [Win32Drag]::SetCursorPos($cx, $cy); Start-Sleep -Milliseconds ${Math.round(durationMs / 20)} }
+[Win32Drag]::mouse_event(0x0004, 0, 0, 0, [UIntPtr]::Zero)`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            const delay = Math.round(durationMs / 20);
+            const result = await runCommand("xdotool", [
+                "mousemove", String(x1), String(y1), "mousedown", "1",
+                "mousemove", "--delay", String(delay), String(x2), String(y2),
+                "mouseup", "1",
+            ], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+export async function longPressAtPosition(x, y, durationMs = 1000) {
+    const os = platform();
+    if (os === "darwin") {
+        const tmpFile = join(tmpdir(), `codeloop_longpress_${Date.now()}.swift`);
+        const swiftCode = [
+            'import CoreGraphics',
+            'import Foundation',
+            `let point = CGPoint(x: ${x}, y: ${y})`,
+            'let down = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: point, mouseButton: .left)',
+            'down?.post(tap: .cghidEventTap)',
+            `Thread.sleep(forTimeInterval: ${durationMs / 1000.0})`,
+            'let up = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: point, mouseButton: .left)',
+            'up?.post(tap: .cghidEventTap)',
+        ].join('\n');
+        writeFileSync(tmpFile, swiftCode);
+        try {
+            const result = await runCommand("swift", [tmpFile], process.cwd());
+            return result.exit_code === 0;
+        }
+        finally {
+            try {
+                unlinkSync(tmpFile);
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else if (os === "win32") {
+        const script = `
+Add-Type @"
+using System;using System.Runtime.InteropServices;
+public class Win32LP {
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo);
+}
+"@
+[Win32LP]::SetCursorPos(${x}, ${y}); Start-Sleep -Milliseconds 50
+[Win32LP]::mouse_event(0x0002, 0, 0, 0, [UIntPtr]::Zero)
+Start-Sleep -Milliseconds ${durationMs}
+[Win32LP]::mouse_event(0x0004, 0, 0, 0, [UIntPtr]::Zero)`;
+        const result = await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+        return result.exit_code === 0;
+    }
+    else if (os === "linux") {
+        if (await checkToolAvailable("xdotool")) {
+            await runCommand("xdotool", ["mousemove", String(x), String(y), "mousedown", "1"], process.cwd());
+            await new Promise(r => setTimeout(r, durationMs));
+            const result = await runCommand("xdotool", ["mouseup", "1"], process.cwd());
+            return result.exit_code === 0;
+        }
+    }
+    return false;
+}
+// ── iOS Simulator Extended Interaction ──────────────────────────
+export async function simctlTap(x, y) {
+    const result = await runCommand("xcrun", ["simctl", "io", "booted", "tap", String(Math.round(x)), String(Math.round(y))], process.cwd());
+    return result.exit_code === 0;
+}
+export async function simctlType(text) {
+    for (const char of text) {
+        const result = await runCommand("xcrun", ["simctl", "io", "booted", "type", char], process.cwd());
+        if (result.exit_code !== 0)
+            return false;
+    }
+    return true;
+}
+export async function simctlOpenUrl(url) {
+    const result = await runCommand("xcrun", ["simctl", "openurl", "booted", url], process.cwd());
+    return result.exit_code === 0;
+}
+export async function simctlBiometric(accept) {
+    await runCommand("xcrun", ["simctl", "biometric", "booted", "--state", "enrolled"], process.cwd());
+    const action = accept ? "--match" : "--no-match";
+    const result = await runCommand("xcrun", ["simctl", "biometric", "booted", action], process.cwd());
+    return result.exit_code === 0;
+}
+// ── Extended Android (adb) Helpers ──────────────────────────────
+export async function adbDeepLink(url) {
+    const result = await runCommand("adb", ["shell", "am", "start", "-a", "android.intent.action.VIEW", "-d", url], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbPermission(packageId, permission, grant) {
+    const action = grant ? "grant" : "revoke";
+    const result = await runCommand("adb", ["shell", "pm", action, packageId, permission], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbHomeButton() {
+    return adbKey("KEYCODE_HOME");
+}
+export async function adbBackButton() {
+    return adbKey("KEYCODE_BACK");
+}
+export async function adbRecentApps() {
+    return adbKey("KEYCODE_APP_SWITCH");
+}
+export async function adbNotificationShade(expand) {
+    const action = expand ? "expand-notifications" : "collapse";
+    const result = await runCommand("adb", ["shell", "cmd", "statusbar", action], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbLongPress(x, y, durationMs = 1000) {
+    return adbSwipe(x, y, x, y, durationMs);
+}
+export async function adbClearData(packageId) {
+    const result = await runCommand("adb", ["shell", "pm", "clear", packageId], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbInstallApk(apkPath) {
+    const result = await runCommand("adb", ["install", "-r", apkPath], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbNetworkCondition(mode) {
+    const result = await runCommand("adb", ["emu", "network", "speed", mode], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbMockLocation(lat, lng) {
+    const result = await runCommand("adb", ["emu", "geo", "fix", String(lng), String(lat)], process.cwd());
+    return result.exit_code === 0;
+}
+export async function adbRotate(landscape) {
+    await runCommand("adb", ["shell", "settings", "put", "system", "accelerometer_rotation", "0"], process.cwd());
+    const rotation = landscape ? "1" : "0";
+    const result = await runCommand("adb", ["shell", "settings", "put", "system", "user_rotation", rotation], process.cwd());
+    return result.exit_code === 0;
+}
+const INSTALL_INSTRUCTIONS = {
+    ffmpeg: {
+        macOS: "brew install ffmpeg",
+        windows: "winget install ffmpeg  (or: choco install ffmpeg)",
+        linux: "sudo apt-get install -y ffmpeg  (or: sudo dnf install -y ffmpeg)",
+    },
+    adb: {
+        macOS: "brew install android-platform-tools",
+        windows: "winget install Google.PlatformTools  (or install via Android Studio)",
+        linux: "sudo apt-get install -y android-tools-adb",
+    },
+    xcrun: {
+        macOS: "xcode-select --install",
+        windows: "(not available on Windows — iOS development requires macOS)",
+        linux: "(not available on Linux — iOS development requires macOS)",
+    },
+    xdotool: {
+        macOS: "(not needed on macOS)",
+        windows: "(not needed on Windows)",
+        linux: "sudo apt-get install -y xdotool",
+    },
+    maestro: {
+        macOS: 'curl -Ls "https://get.maestro.mobile.dev" | bash',
+        windows: 'curl -Ls "https://get.maestro.mobile.dev" | bash',
+        linux: 'curl -Ls "https://get.maestro.mobile.dev" | bash',
+    },
+};
+/**
+ * Check if a required external tool is installed.
+ * Returns null if available, or a user-facing error message with install instructions.
+ */
+export async function checkDependency(tool, action) {
+    const os = platform();
+    const whichCmd = os === "win32" ? "where" : "which";
+    const result = await runCommand(whichCmd, [tool], process.cwd());
+    if (result.exit_code === 0 && result.stdout.trim())
+        return null;
+    const instructions = INSTALL_INSTRUCTIONS[tool];
+    if (!instructions) {
+        return `Tool "${tool}" is not installed but is required for ${action}. Please install it and retry.`;
+    }
+    const platformKey = os === "darwin" ? "macOS" : os === "win32" ? "windows" : "linux";
+    const installCmd = instructions[platformKey];
+    return `Tool "${tool}" is not installed but is required for ${action}.\n\nInstall it with:\n  ${installCmd}\n\nThen retry this operation.`;
+}
+/**
+ * Restore the previously frontmost app/window after capture is complete.
+ */
+export async function restorePreviousApp(previousApp) {
+    const os = platform();
+    // If no previous app was captured, try to detect and restore the IDE
+    if (!previousApp && os === "darwin") {
+        previousApp = await detectRunningIDE();
+    }
+    if (!previousApp)
+        return;
+    if (os === "darwin") {
+        await runCommand("osascript", ["-e", `tell application "${previousApp}" to activate`], process.cwd());
+    }
+    else if (os === "win32") {
+        const script = `
+$proc = Get-Process | Where-Object { $_.MainWindowTitle -match '${previousApp}' -and $_.MainWindowHandle -ne 0 } | Select-Object -First 1
+if ($proc) {
+  Add-Type @"
+  using System;using System.Runtime.InteropServices;
+  public class Win32R { [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd); }
+"@
+  [Win32R]::SetForegroundWindow($proc.MainWindowHandle)
+}`;
+        await runCommand("powershell", ["-NoProfile", "-Command", script], process.cwd());
+    }
+    else {
+        if (await checkToolAvailable("xdotool")) {
+            const searchResult = await runCommand("xdotool", ["search", "--name", previousApp], process.cwd());
+            if (searchResult.exit_code === 0 && searchResult.stdout.trim()) {
+                const windowId = searchResult.stdout.trim().split("\n")[0];
+                await runCommand("xdotool", ["windowactivate", windowId], process.cwd());
+            }
+        }
+    }
+}
+//# sourceMappingURL=window_manager.js.map