ft-scout 9.0.3 → 9.0.5

package/bin/src/engine/computer/scoutDriver.cs

@@ -0,0 +1,873 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Threading;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+using System.Runtime.InteropServices;
+using System.Diagnostics;
+using System.Collections.Generic;
+
+namespace Scout.ComputerControl
+{
+    public class ScoutDriver
+    {
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern IntPtr OpenWindowStation(string lpszWinSta, bool fInherit, uint dwDesiredAccess);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool SetProcessWindowStation(IntPtr hWinSta);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern IntPtr OpenDesktop(string lpszDesktop, uint dwFlags, bool fInherit, uint dwDesiredAccess);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern IntPtr OpenInputDesktop(uint dwFlags, bool fInherit, uint dwDesiredAccess);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool SetThreadDesktop(IntPtr hDesktop);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool CloseDesktop(IntPtr hDesktop);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool GetCursorPos(out POINT lpPoint);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern bool SetCursorPos(int X, int Y);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        public static extern void mouse_event(uint dwFlags, uint dx, uint dy, uint cButtons, uint dwExtraInfo);
+
+        [DllImport("user32.dll")]
+        public static extern int GetSystemMetrics(int nIndex);
+
+        [DllImport("user32.dll")]
+        public static extern bool SetProcessDPIAware();
+
+        [DllImport("user32.dll")]
+        public static extern IntPtr GetForegroundWindow();
+
+        [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        public static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);
+
+        [DllImport("user32.dll")]
+        public static extern bool SetForegroundWindow(IntPtr hWnd);
+
+        [DllImport("user32.dll")]
+        public static extern bool BringWindowToTop(IntPtr hWnd);
+
+        [DllImport("user32.dll")]
+        public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+
+        [DllImport("user32.dll")]
+        public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+        public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool IsWindowVisible(IntPtr hWnd);
+
+        [DllImport("user32.dll")]
+        public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+
+        [DllImport("user32.dll")]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+
+        [DllImport("user32.dll")]
+        public static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
+
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        public static extern bool CreateProcess(
+            string lpApplicationName,
+            string lpCommandLine,
+            IntPtr lpProcessAttributes,
+            IntPtr lpThreadAttributes,
+            bool bInheritHandles,
+            uint dwCreationFlags,
+            IntPtr lpEnvironment,
+            string lpCurrentDirectory,
+            ref STARTUPINFO lpStartupInfo,
+            out PROCESS_INFORMATION lpProcessInformation
+        );
+
+        public const uint MOUSEEVENTF_MOVE = 0x0001;
+        public const uint MOUSEEVENTF_LEFTDOWN = 0x0002;
+        public const uint MOUSEEVENTF_LEFTUP = 0x0004;
+        public const uint MOUSEEVENTF_RIGHTDOWN = 0x0008;
+        public const uint MOUSEEVENTF_RIGHTUP = 0x0010;
+        public const uint MOUSEEVENTF_MIDDLEDOWN = 0x0020;
+        public const uint MOUSEEVENTF_MIDDLEUP = 0x0040;
+        public const uint MOUSEEVENTF_WHEEL = 0x0800;
+
+        public const int SM_CXSCREEN = 0;
+        public const int SM_CYSCREEN = 1;
+        public const int SM_CXVIRTUALSCREEN = 78;
+        public const int SM_CYVIRTUALSCREEN = 79;
+        public const int SW_RESTORE = 9;
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct RECT
+        {
+            public int Left;
+            public int Top;
+            public int Right;
+            public int Bottom;
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        public struct STARTUPINFO
+        {
+            public int cb;
+            public string lpReserved;
+            public string lpDesktop;
+            public string lpTitle;
+            public int dwX;
+            public int dwY;
+            public int dwXSize;
+            public int dwYSize;
+            public int dwXCountChars;
+            public int dwYCountChars;
+            public int dwFillAttribute;
+            public int dwFlags;
+            public short wShowWindow;
+            public short cbReserved2;
+            public IntPtr lpReserved2;
+            public IntPtr hStdInput;
+            public IntPtr hStdOutput;
+            public IntPtr hStdError;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct PROCESS_INFORMATION
+        {
+            public IntPtr hProcess;
+            public IntPtr hThread;
+            public int dwProcessId;
+            public int dwThreadId;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct POINT
+        {
+            public int X;
+            public int Y;
+        }
+
+        public static void AttachInputDesktop()
+        {
+            try
+            {
+                SetProcessDPIAware();
+                IntPtr hwinsta = OpenWindowStation("WinSta0", false, 0x10000000);
+                if (hwinsta != IntPtr.Zero)
+                {
+                    SetProcessWindowStation(hwinsta);
+                }
+                IntPtr hdesk = OpenInputDesktop(0, false, 0x10000000);
+                if (hdesk == IntPtr.Zero)
+                {
+                    hdesk = OpenDesktop("Default", 0, false, 0x10000000);
+                }
+                if (hdesk != IntPtr.Zero)
+                {
+                    SetThreadDesktop(hdesk);
+                }
+            }
+            catch { }
+        }
+
+        public static POINT GetPosition()
+        {
+            POINT pt = new POINT();
+            GetCursorPos(out pt);
+            return pt;
+        }
+
+        public static bool Move(int x, int y)
+        {
+            SetCursorPos(x, y);
+            Thread.Sleep(20);
+            POINT actual = GetPosition();
+            return (Math.Abs(actual.X - x) <= 5 && Math.Abs(actual.Y - y) <= 5);
+        }
+
+        public static bool Click(string button, int x, int y, int count)
+        {
+            Move(x, y);
+            Thread.Sleep(30);
+
+            uint downFlag = MOUSEEVENTF_LEFTDOWN;
+            uint upFlag = MOUSEEVENTF_LEFTUP;
+
+            if (button == "right")
+            {
+                downFlag = MOUSEEVENTF_RIGHTDOWN;
+                upFlag = MOUSEEVENTF_RIGHTUP;
+            }
+            else if (button == "middle")
+            {
+                downFlag = MOUSEEVENTF_MIDDLEDOWN;
+                upFlag = MOUSEEVENTF_MIDDLEUP;
+            }
+
+            for (int i = 0; i < count; i++)
+            {
+                mouse_event(downFlag, 0, 0, 0, 0);
+                Thread.Sleep(40);
+                mouse_event(upFlag, 0, 0, 0, 0);
+                if (count > 1 && i < count - 1)
+                {
+                    Thread.Sleep(70);
+                }
+            }
+            return true;
+        }
+
+        public static bool MouseDown(string button, int x, int y)
+        {
+            if (x >= 0 && y >= 0)
+            {
+                Move(x, y);
+                Thread.Sleep(30);
+            }
+            uint downFlag = MOUSEEVENTF_LEFTDOWN;
+            if (button == "right") downFlag = MOUSEEVENTF_RIGHTDOWN;
+            else if (button == "middle") downFlag = MOUSEEVENTF_MIDDLEDOWN;
+
+            mouse_event(downFlag, 0, 0, 0, 0);
+            return true;
+        }
+
+        public static bool MouseUp(string button, int x, int y)
+        {
+            if (x >= 0 && y >= 0)
+            {
+                Move(x, y);
+                Thread.Sleep(30);
+            }
+            uint upFlag = MOUSEEVENTF_LEFTUP;
+            if (button == "right") upFlag = MOUSEEVENTF_RIGHTUP;
+            else if (button == "middle") upFlag = MOUSEEVENTF_MIDDLEUP;
+
+            mouse_event(upFlag, 0, 0, 0, 0);
+            return true;
+        }
+
+        public static bool Drag(int startX, int startY, int endX, int endY)
+        {
+            Move(startX, startY);
+            Thread.Sleep(50);
+            mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
+            Thread.Sleep(50);
+
+            int steps = 15;
+            for (int i = 1; i <= steps; i++)
+            {
+                int curX = startX + (int)((endX - startX) * ((double)i / steps));
+                int curY = startY + (int)((endY - startY) * ((double)i / steps));
+                SetCursorPos(curX, curY);
+                Thread.Sleep(15);
+            }
+
+            Move(endX, endY);
+            Thread.Sleep(50);
+            mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
+            Thread.Sleep(30);
+            return true;
+        }
+
+        public static bool Scroll(int deltaX, int deltaY)
+        {
+            if (deltaY != 0)
+            {
+                int amount = -deltaY * 120;
+                mouse_event(MOUSEEVENTF_WHEEL, 0, 0, (uint)amount, 0);
+            }
+            return true;
+        }
+
+        public static string GetActiveWindowTitle()
+        {
+            try
+            {
+                IntPtr hwnd = GetForegroundWindow();
+                if (hwnd == IntPtr.Zero) return "Desktop";
+                StringBuilder sb = new StringBuilder(512);
+                GetWindowText(hwnd, sb, sb.Capacity);
+                string title = sb.ToString().Trim();
+                return string.IsNullOrEmpty(title) ? "Desktop" : title;
+            }
+            catch
+            {
+                return "Desktop";
+            }
+        }
+
+        public static List<string> GetVisibleWindows()
+        {
+            List<string> list = new List<string>();
+            try
+            {
+                EnumWindows((hWnd, lParam) =>
+                {
+                    if (IsWindowVisible(hWnd))
+                    {
+                        StringBuilder sb = new StringBuilder(512);
+                        GetWindowText(hWnd, sb, sb.Capacity);
+                        string t = sb.ToString().Trim();
+                        if (!string.IsNullOrEmpty(t) && t != "Default IME" && t != "MSCTFIME UI")
+                        {
+                            list.Add(t);
+                        }
+                    }
+                    return true;
+                }, IntPtr.Zero);
+            }
+            catch { }
+            return list;
+        }
+
+        public static bool FocusWindow(string titleOrApp)
+        {
+            try
+            {
+                string target = titleOrApp.ToLower().Trim();
+                IntPtr foundHwnd = IntPtr.Zero;
+
+                EnumWindows((hWnd, lParam) =>
+                {
+                    if (IsWindowVisible(hWnd))
+                    {
+                        StringBuilder sb = new StringBuilder(512);
+                        GetWindowText(hWnd, sb, sb.Capacity);
+                        string t = sb.ToString().Trim().ToLower();
+
+                        uint pid;
+                        GetWindowThreadProcessId(hWnd, out pid);
+                        string pName = "";
+                        try { pName = Process.GetProcessById((int)pid).ProcessName.ToLower(); } catch { }
+
+                        if (t.Contains(target) || pName.Contains(target))
+                        {
+                            foundHwnd = hWnd;
+                            return false;
+                        }
+                    }
+                    return true;
+                }, IntPtr.Zero);
+
+                if (foundHwnd != IntPtr.Zero)
+                {
+                    ShowWindow(foundHwnd, SW_RESTORE);
+                    keybd_event(0x12, 0, 0, UIntPtr.Zero);
+                    keybd_event(0x12, 0, 0x0002, UIntPtr.Zero);
+                    SetForegroundWindow(foundHwnd);
+                    BringWindowToTop(foundHwnd);
+                    Thread.Sleep(150);
+                    return true;
+                }
+            }
+            catch { }
+            return false;
+        }
+
+        public static RECT? GetWindowBounds(string titleOrApp)
+        {
+            try
+            {
+                string target = titleOrApp.ToLower().Trim();
+                IntPtr foundHwnd = IntPtr.Zero;
+
+                EnumWindows((hWnd, lParam) =>
+                {
+                    if (IsWindowVisible(hWnd))
+                    {
+                        StringBuilder sb = new StringBuilder(512);
+                        GetWindowText(hWnd, sb, sb.Capacity);
+                        string t = sb.ToString().Trim().ToLower();
+
+                        uint pid;
+                        GetWindowThreadProcessId(hWnd, out pid);
+                        string pName = "";
+                        try { pName = Process.GetProcessById((int)pid).ProcessName.ToLower(); } catch { }
+
+                        if (t.Contains(target) || pName.Contains(target))
+                        {
+                            foundHwnd = hWnd;
+                            return false;
+                        }
+                    }
+                    return true;
+                }, IntPtr.Zero);
+
+                if (foundHwnd != IntPtr.Zero)
+                {
+                    RECT rect;
+                    if (GetWindowRect(foundHwnd, out rect))
+                    {
+                        return rect;
+                    }
+                }
+            }
+            catch { }
+            return null;
+        }
+
+        public static bool LaunchApp(string appName, out int pid)
+        {
+            pid = 0;
+            try
+            {
+                STARTUPINFO si = new STARTUPINFO();
+                si.cb = Marshal.SizeOf(si);
+                si.lpDesktop = @"WinSta0\Default";
+                PROCESS_INFORMATION pi = new PROCESS_INFORMATION();
+
+                string cmd = appName;
+                if (!cmd.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
+                {
+                    cmd += ".exe";
+                }
+
+                bool ok = CreateProcess(null, cmd, IntPtr.Zero, IntPtr.Zero, false, 0, IntPtr.Zero, null, ref si, out pi);
+                if (ok)
+                {
+                    pid = pi.dwProcessId;
+                    return true;
+                }
+            }
+            catch { }
+            return false;
+        }
+
+        public static string Screenshot(string savePath)
+        {
+            int width = GetSystemMetrics(SM_CXSCREEN);
+            int height = GetSystemMetrics(SM_CYSCREEN);
+            if (width <= 0) width = 1920;
+            if (height <= 0) height = 1080;
+
+            string dir = Path.GetDirectoryName(savePath);
+            if (!string.IsNullOrEmpty(dir) && !Directory.Exists(dir))
+            {
+                Directory.CreateDirectory(dir);
+            }
+
+            using (Bitmap bmp = new Bitmap(width, height))
+            {
+                using (Graphics g = Graphics.FromImage(bmp))
+                {
+                    g.CopyFromScreen(0, 0, 0, 0, new Size(width, height), CopyPixelOperation.SourceCopy);
+                }
+                bmp.Save(savePath, ImageFormat.Png);
+            }
+
+            return string.Format("{{\"success\":true,\"action\":\"screenshot\",\"width\":{0},\"height\":{1},\"path\":{2},\"activeWindow\":{3}}}",
+                width, height, JsonEscape(savePath), JsonEscape(GetActiveWindowTitle()));
+        }
+
+        public static bool TypeText(string text)
+        {
+            if (string.IsNullOrEmpty(text)) return true;
+            try
+            {
+                SendKeys.SendWait(EscapeForSendKeys(text));
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static bool KeyPress(string key)
+        {
+            string k = key.ToLower().Trim();
+            string sendStr = key;
+            if (k == "enter" || k == "return") sendStr = "{ENTER}";
+            else if (k == "tab") sendStr = "{TAB}";
+            else if (k == "esc" || k == "escape") sendStr = "{ESC}";
+            else if (k == "backspace") sendStr = "{BACKSPACE}";
+            else if (k == "del" || k == "delete") sendStr = "{DEL}";
+            else if (k == "up") sendStr = "{UP}";
+            else if (k == "down") sendStr = "{DOWN}";
+            else if (k == "left") sendStr = "{LEFT}";
+            else if (k == "right") sendStr = "{RIGHT}";
+            else if (k == "space") sendStr = " ";
+            else if (k == "home") sendStr = "{HOME}";
+            else if (k == "end") sendStr = "{END}";
+            else if (k == "pageup") sendStr = "{PGUP}";
+            else if (k == "pagedown") sendStr = "{PGDN}";
+
+            SendKeys.SendWait(sendStr);
+            return true;
+        }
+
+        public static bool Hotkey(string[] keys)
+        {
+            string prefix = "";
+            string mainKey = "";
+            foreach (string k in keys)
+            {
+                string lk = k.ToLower().Trim();
+                if (lk == "ctrl" || lk == "control") prefix += "^";
+                else if (lk == "alt") prefix += "%";
+                else if (lk == "shift") prefix += "+";
+                else mainKey = k;
+            }
+            string sendStr = prefix + mainKey.ToLower();
+            SendKeys.SendWait(sendStr);
+            return true;
+        }
+
+        public static string EscapeForSendKeys(string text)
+        {
+            StringBuilder sb = new StringBuilder();
+            foreach (char c in text)
+            {
+                if (c == '+' || c == '^' || c == '%' || c == '~' || c == '(' || c == ')' || c == '{' || c == '}' || c == '[' || c == ']')
+                {
+                    sb.Append("{" + c + "}");
+                }
+                else
+                {
+                    sb.Append(c);
+                }
+            }
+            return sb.ToString();
+        }
+
+        public static string JsonEscape(string text)
+        {
+            if (text == null) return "null";
+            StringBuilder sb = new StringBuilder();
+            sb.Append("\"");
+            foreach (char c in text)
+            {
+                if (c == '\\') sb.Append("\\\\");
+                else if (c == '\"') sb.Append("\\\"");
+                else if (c == '\n') sb.Append("\\n");
+                else if (c == '\r') sb.Append("\\r");
+                else if (c == '\t') sb.Append("\\t");
+                else if (c < ' ') sb.Append(string.Format("\\u{0:x4}", (int)c));
+                else sb.Append(c);
+            }
+            sb.Append("\"");
+            return sb.ToString();
+        }
+
+        public static string ExecuteAction(string action, string[] args)
+        {
+            try
+            {
+                string act = action.ToLower().Trim();
+
+                if (act == "move")
+                {
+                    int x = int.Parse(args[0]);
+                    int y = int.Parse(args[1]);
+                    bool ok = Move(x, y);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"move\",\"coordinates\":{{\"x\":{1},\"y\":{2}}},\"activeWindow\":{3}}}",
+                        ok ? "true" : "false", pos.X, pos.Y, JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "click" || act == "left_click")
+                {
+                    int x = int.Parse(args[0]);
+                    int y = int.Parse(args[1]);
+                    string btn = (args.Length > 2 && !string.IsNullOrEmpty(args[2])) ? args[2] : "left";
+                    bool ok = Click(btn, x, y, 1);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"click\",\"button\":\"{1}\",\"coordinates\":{{\"x\":{2},\"y\":{3}}},\"activeWindow\":{4}}}",
+                        ok ? "true" : "false", btn, pos.X, pos.Y, JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "right_click")
+                {
+                    int x = int.Parse(args[0]);
+                    int y = int.Parse(args[1]);
+                    bool ok = Click("right", x, y, 1);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"right_click\",\"button\":\"right\",\"coordinates\":{{\"x\":{1},\"y\":{2}}},\"activeWindow\":{3}}}",
+                        ok ? "true" : "false", pos.X, pos.Y, JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "double_click")
+                {
+                    int x = int.Parse(args[0]);
+                    int y = int.Parse(args[1]);
+                    bool ok = Click("left", x, y, 2);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"double_click\",\"coordinates\":{{\"x\":{1},\"y\":{2}}},\"activeWindow\":{3}}}",
+                        ok ? "true" : "false", pos.X, pos.Y, JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "mouse_down")
+                {
+                    int x = args.Length > 0 ? int.Parse(args[0]) : -1;
+                    int y = args.Length > 1 ? int.Parse(args[1]) : -1;
+                    string btn = (args.Length > 2 && !string.IsNullOrEmpty(args[2])) ? args[2] : "left";
+                    bool ok = MouseDown(btn, x, y);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"mouse_down\",\"button\":\"{1}\",\"coordinates\":{{\"x\":{2},\"y\":{3}}}}}",
+                        ok ? "true" : "false", btn, pos.X, pos.Y);
+                }
+
+                if (act == "mouse_up")
+                {
+                    int x = args.Length > 0 ? int.Parse(args[0]) : -1;
+                    int y = args.Length > 1 ? int.Parse(args[1]) : -1;
+                    string btn = (args.Length > 2 && !string.IsNullOrEmpty(args[2])) ? args[2] : "left";
+                    bool ok = MouseUp(btn, x, y);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"mouse_up\",\"button\":\"{1}\",\"coordinates\":{{\"x\":{2},\"y\":{3}}}}}",
+                        ok ? "true" : "false", btn, pos.X, pos.Y);
+                }
+
+                if (act == "drag")
+                {
+                    int sx = int.Parse(args[0]);
+                    int sy = int.Parse(args[1]);
+                    int ex = int.Parse(args[2]);
+                    int ey = int.Parse(args[3]);
+                    bool ok = Drag(sx, sy, ex, ey);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":{0},\"action\":\"drag\",\"from\":{{\"x\":{1},\"y\":{2}}},\"to\":{{\"x\":{3},\"y\":{4}}},\"coordinates\":{{\"x\":{5},\"y\":{6}}}}}",
+                        ok ? "true" : "false", sx, sy, ex, ey, pos.X, pos.Y);
+                }
+
+                if (act == "scroll")
+                {
+                    int dx = args.Length > 0 ? int.Parse(args[0]) : 0;
+                    int dy = args.Length > 1 ? int.Parse(args[1]) : 0;
+                    bool ok = Scroll(dx, dy);
+                    return string.Format("{{\"success\":{0},\"action\":\"scroll\",\"deltaX\":{1},\"deltaY\":{2}}}",
+                        ok ? "true" : "false", dx, dy);
+                }
+
+                if (act == "position")
+                {
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":true,\"action\":\"position\",\"coordinates\":{{\"x\":{0},\"y\":{1}}}}}",
+                        pos.X, pos.Y);
+                }
+
+                if (act == "screen_info")
+                {
+                    int width = GetSystemMetrics(SM_CXSCREEN);
+                    int height = GetSystemMetrics(SM_CYSCREEN);
+                    POINT pos = GetPosition();
+                    return string.Format("{{\"success\":true,\"width\":{0},\"height\":{1},\"cursor\":{{\"x\":{2},\"y\":{3}}},\"activeWindow\":{4}}}",
+                        width, height, pos.X, pos.Y, JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "screenshot")
+                {
+                    string path = args.Length > 0 ? args[0] : Path.Combine(Directory.GetCurrentDirectory(), "screen.png");
+                    return Screenshot(path);
+                }
+
+                if (act == "type")
+                {
+                    string text = args.Length > 0 ? args[0] : "";
+                    bool ok = TypeText(text);
+                    return string.Format("{{\"success\":{0},\"action\":\"type\",\"chars\":{1},\"activeWindow\":{2}}}",
+                        ok ? "true" : "false", text.Length, JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "key" || act == "key_press")
+                {
+                    string key = args.Length > 0 ? args[0] : "";
+                    bool ok = KeyPress(key);
+                    return string.Format("{{\"success\":{0},\"action\":\"key_press\",\"key\":{1},\"activeWindow\":{2}}}",
+                        ok ? "true" : "false", JsonEscape(key), JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "hotkey")
+                {
+                    string[] keys = args.Length > 0 ? args[0].Split(new char[] { '+', ',' }, StringSplitOptions.RemoveEmptyEntries) : new string[0];
+                    bool ok = Hotkey(keys);
+                    return string.Format("{{\"success\":{0},\"action\":\"hotkey\",\"keys\":{1},\"activeWindow\":{2}}}",
+                        ok ? "true" : "false", JsonEscape(string.Join("+", keys)), JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "active_window")
+                {
+                    string title = GetActiveWindowTitle();
+                    return string.Format("{{\"success\":true,\"action\":\"active_window\",\"activeWindow\":{0}}}",
+                        JsonEscape(title));
+                }
+
+                if (act == "list_windows")
+                {
+                    List<string> wins = GetVisibleWindows();
+                    StringBuilder sb = new StringBuilder();
+                    sb.Append("[");
+                    for (int i = 0; i < wins.Count; i++)
+                    {
+                        sb.Append(JsonEscape(wins[i]));
+                        if (i < wins.Count - 1) sb.Append(",");
+                    }
+                    sb.Append("]");
+                    return string.Format("{{\"success\":true,\"action\":\"list_windows\",\"activeWindow\":{0},\"windows\":{1}}}",
+                        JsonEscape(GetActiveWindowTitle()), sb.ToString());
+                }
+
+                if (act == "focus_window")
+                {
+                    string win = args.Length > 0 ? args[0] : "";
+                    bool ok = FocusWindow(win);
+                    return string.Format("{{\"success\":{0},\"action\":\"focus_window\",\"target\":{1},\"activeWindow\":{2}}}",
+                        ok ? "true" : "false", JsonEscape(win), JsonEscape(GetActiveWindowTitle()));
+                }
+
+                if (act == "launch" || act == "open_app")
+                {
+                    string app = args.Length > 0 ? args[0] : "";
+                    int pid;
+                    bool ok = LaunchApp(app, out pid);
+                    return string.Format("{{\"success\":{0},\"action\":\"launch\",\"app\":{1},\"pid\":{2}}}",
+                        ok ? "true" : "false", JsonEscape(app), pid);
+                }
+
+                if (act == "window_bounds")
+                {
+                    string win = args.Length > 0 ? args[0] : "";
+                    RECT? r = GetWindowBounds(win);
+                    if (r.HasValue)
+                    {
+                        int w = r.Value.Right - r.Value.Left;
+                        int h = r.Value.Bottom - r.Value.Top;
+                        return string.Format("{{\"success\":true,\"action\":\"window_bounds\",\"x\":{0},\"y\":{1},\"width\":{2},\"height\":{3}}}",
+                            r.Value.Left, r.Value.Top, w, h);
+                    }
+                    return string.Format("{{\"success\":false,\"action\":\"window_bounds\",\"error\":{0}}}", JsonEscape("Window not found: " + win));
+                }
+
+                if (act == "diagnostic")
+                {
+                    int width = GetSystemMetrics(SM_CXSCREEN);
+                    int height = GetSystemMetrics(SM_CYSCREEN);
+                    POINT pos = GetPosition();
+                    string title = GetActiveWindowTitle();
+                    List<string> wins = GetVisibleWindows();
+
+                    return string.Format("{{\"success\":true,\"action\":\"diagnostic\",\"width\":{0},\"height\":{1},\"mouse\":{{\"x\":{2},\"y\":{3}}},\"activeWindow\":{4},\"windowCount\":{5}}}",
+                        width, height, pos.X, pos.Y, JsonEscape(title), wins.Count);
+                }
+
+                return string.Format("{{\"success\":false,\"error\":{0},\"recoverable\":true}}",
+                    JsonEscape("Unknown action: " + action));
+            }
+            catch (Exception ex)
+            {
+                return string.Format("{{\"success\":false,\"action\":{0},\"error\":{1},\"recoverable\":true}}",
+                    JsonEscape(action), JsonEscape(ex.Message));
+            }
+        }
+
+        public static void RunServer()
+        {
+            AttachInputDesktop();
+            string line;
+            while ((line = Console.ReadLine()) != null)
+            {
+                line = line.Trim();
+                if (string.IsNullOrEmpty(line)) continue;
+                if (line == "exit" || line == "quit") break;
+
+                // Simple format: action arg1 arg2 ... or base64
+                string result = "";
+                try
+                {
+                    string[] parts = ParseCommandLine(line);
+                    if (parts.Length > 0)
+                    {
+                        string action = parts[0];
+                        string[] args = new string[parts.Length - 1];
+                        Array.Copy(parts, 1, args, 0, args.Length);
+                        result = ExecuteAction(action, args);
+                    }
+                    else
+                    {
+                        result = "{\"success\":false,\"error\":\"Empty command\"}";
+                    }
+                }
+                catch (Exception ex)
+                {
+                    result = string.Format("{{\"success\":false,\"error\":{0}}}", JsonEscape(ex.Message));
+                }
+                Console.WriteLine(result);
+                Console.Out.Flush();
+            }
+        }
+
+        private static string[] ParseCommandLine(string cmdLine)
+        {
+            List<string> args = new List<string>();
+            bool inQuotes = false;
+            StringBuilder current = new StringBuilder();
+
+            for (int i = 0; i < cmdLine.Length; i++)
+            {
+                char c = cmdLine[i];
+                if (c == '\"')
+                {
+                    inQuotes = !inQuotes;
+                }
+                else if (c == ' ' && !inQuotes)
+                {
+                    if (current.Length > 0)
+                    {
+                        args.Add(current.ToString());
+                        current.Clear();
+                    }
+                }
+                else
+                {
+                    current.Append(c);
+                }
+            }
+            if (current.Length > 0)
+            {
+                args.Add(current.ToString());
+            }
+            return args.ToArray();
+        }
+
+        [STAThread]
+        public static void Main(string[] args)
+        {
+            // Thread execution with desktop attachment
+            Thread t = new Thread(() =>
+            {
+                AttachInputDesktop();
+
+                if (args.Length > 0 && args[0] == "--server")
+                {
+                    RunServer();
+                    return;
+                }
+
+                if (args.Length == 0)
+                {
+                    Console.WriteLine(ExecuteAction("diagnostic", new string[0]));
+                    return;
+                }
+
+                string action = args[0];
+                string[] actionArgs = new string[args.Length - 1];
+                Array.Copy(args, 1, actionArgs, 0, actionArgs.Length);
+                Console.WriteLine(ExecuteAction(action, actionArgs));
+            });
+
+            t.SetApartmentState(ApartmentState.STA);
+            t.Start();
+            t.Join();
+        }
+    }
+}