chocolatito-code 1.0.0

package/dist/tools/win/hostScript.js

@@ -0,0 +1,925 @@
+// Fuente del host persistente de Windows (PowerShell + C#).
+// Se lanza UNA sola vez por sesion: compila los tipos nativos al arrancar y luego
+// atiende comandos JSON por stdin. Evita el coste de ~1s por accion que tenia la
+// version anterior (un powershell.exe + Add-Type nuevo en cada clic).
+export const WIN_HOST_SCRIPT = String.raw `
+$ErrorActionPreference = 'Stop'
+$OutputEncoding = [System.Text.Encoding]::UTF8
+[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
+[Console]::InputEncoding = [System.Text.Encoding]::UTF8
+
+$csharp = @'
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Windows.Automation;
+
+public static class Choco
+{
+    // ================= P/Invoke =================
+    [StructLayout(LayoutKind.Sequential)] public struct POINT { public int X; public int Y; }
+    [StructLayout(LayoutKind.Sequential)] public struct RECT { public int Left; public int Top; public int Right; public int Bottom; }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct MOUSEINPUT { public int dx; public int dy; public uint mouseData; public uint dwFlags; public uint time; public IntPtr dwExtraInfo; }
+    [StructLayout(LayoutKind.Sequential)]
+    struct KEYBDINPUT { public ushort wVk; public ushort wScan; public uint dwFlags; public uint time; public IntPtr dwExtraInfo; }
+    [StructLayout(LayoutKind.Explicit)]
+    struct INPUTUNION { [FieldOffset(0)] public MOUSEINPUT mi; [FieldOffset(0)] public KEYBDINPUT ki; }
+    [StructLayout(LayoutKind.Sequential)]
+    struct INPUT { public uint type; public INPUTUNION u; }
+
+    delegate bool EnumProc(IntPtr hWnd, IntPtr lParam);
+
+    [DllImport("user32.dll")] static extern IntPtr SetProcessDpiAwarenessContext(IntPtr value);
+    [DllImport("user32.dll")] static extern bool SetProcessDPIAware();
+    [DllImport("user32.dll")] static extern int GetSystemMetrics(int index);
+    [DllImport("user32.dll")] static extern bool SetCursorPos(int x, int y);
+    [DllImport("user32.dll")] static extern bool GetCursorPos(out POINT p);
+    [DllImport("user32.dll", SetLastError = true)] static extern uint SendInput(uint n, INPUT[] inputs, int cb);
+    [DllImport("user32.dll")] static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll")] static extern int GetWindowText(IntPtr h, StringBuilder s, int c);
+    [DllImport("user32.dll")] static extern int GetClassName(IntPtr h, StringBuilder s, int c);
+    [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr h);
+    [DllImport("user32.dll")] static extern bool IsIconic(IntPtr h);
+    [DllImport("user32.dll")] static extern bool GetWindowRect(IntPtr h, out RECT r);
+    [DllImport("user32.dll")] static extern bool GetClientRect(IntPtr h, out RECT r);
+    [DllImport("user32.dll")] static extern bool ClientToScreen(IntPtr h, ref POINT p);
+    [DllImport("user32.dll")] static extern bool ScreenToClient(IntPtr h, ref POINT p);
+    [DllImport("user32.dll")] static extern bool EnumWindows(EnumProc cb, IntPtr l);
+    [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr h, out uint pid);
+    [DllImport("user32.dll")] static extern bool PrintWindow(IntPtr h, IntPtr hdc, uint flags);
+    [DllImport("user32.dll")] static extern bool PostMessage(IntPtr h, uint msg, IntPtr w, IntPtr l);
+    [DllImport("user32.dll")] static extern bool SetForegroundWindow(IntPtr h);
+    [DllImport("user32.dll")] static extern bool ShowWindow(IntPtr h, int n);
+    [DllImport("user32.dll")] static extern bool BringWindowToTop(IntPtr h);
+    [DllImport("user32.dll")] static extern bool AttachThreadInput(uint a, uint b, bool attach);
+    [DllImport("user32.dll")] static extern short VkKeyScan(char c);
+    [DllImport("kernel32.dll")] static extern uint GetCurrentThreadId();
+
+    const uint MOUSEEVENTF_MOVE = 0x0001, MOUSEEVENTF_LEFTDOWN = 0x0002, MOUSEEVENTF_LEFTUP = 0x0004;
+    const uint MOUSEEVENTF_RIGHTDOWN = 0x0008, MOUSEEVENTF_RIGHTUP = 0x0010;
+    const uint MOUSEEVENTF_MIDDLEDOWN = 0x0020, MOUSEEVENTF_MIDDLEUP = 0x0040;
+    const uint MOUSEEVENTF_WHEEL = 0x0800, MOUSEEVENTF_HWHEEL = 0x01000, MOUSEEVENTF_ABSOLUTE = 0x8000;
+    const uint KEYEVENTF_KEYUP = 0x0002, KEYEVENTF_UNICODE = 0x0004, KEYEVENTF_EXTENDEDKEY = 0x0001;
+    const uint WM_LBUTTONDOWN = 0x0201, WM_LBUTTONUP = 0x0202, WM_RBUTTONDOWN = 0x0204, WM_RBUTTONUP = 0x0205;
+    const uint WM_MOUSEMOVE = 0x0200, WM_CHAR = 0x0102, WM_KEYDOWN = 0x0100, WM_KEYUP = 0x0101;
+    const uint WM_LBUTTONDBLCLK = 0x0203;
+
+    // ================= Estado =================
+    static Dictionary<int, AutomationElement> _snap = new Dictionary<int, AutomationElement>();
+    static Dictionary<int, string> _snapLabel = new Dictionary<int, string>();
+    static IntPtr _snapWindow = IntPtr.Zero;
+
+    // ================= Utilidades JSON =================
+    public static string Esc(string s)
+    {
+        if (s == null) return "";
+        StringBuilder b = new StringBuilder();
+        char bs = (char)92;
+        foreach (char c in s)
+        {
+            if (c == (char)34) { b.Append(bs); b.Append((char)34); }
+            else if (c == bs) { b.Append(bs); b.Append(bs); }
+            else if (c == (char)10) { b.Append(bs); b.Append('n'); }
+            else if (c == (char)13) { b.Append(bs); b.Append('r'); }
+            else if (c == (char)9) { b.Append(bs); b.Append('t'); }
+            else if (c < 32 || c == 127) { b.Append(bs); b.Append('u'); b.Append(((int)c).ToString("x4")); }
+            else b.Append(c);
+        }
+        return b.ToString();
+    }
+    static string Q(string s) { return "\"" + Esc(s) + "\""; }
+
+    // Comparacion sin tildes ni mayusculas: en una interfaz en espanol, buscar
+    // "Imagenes" tiene que encontrar "Imágenes". Si no, el agente cree que el
+    // control no existe y se cae innecesariamente a la vision.
+    public static string Norm(string s)
+    {
+        if (s == null) return "";
+        string d = s.Normalize(NormalizationForm.FormD);
+        StringBuilder b = new StringBuilder(d.Length);
+        for (int i = 0; i < d.Length; i++)
+        {
+            if (CharUnicodeInfo.GetUnicodeCategory(d[i]) != UnicodeCategory.NonSpacingMark) b.Append(d[i]);
+        }
+        return b.ToString().Normalize(NormalizationForm.FormC).ToLowerInvariant();
+    }
+    static string N(int v) { return v.ToString(CultureInfo.InvariantCulture); }
+
+    // ================= DPI =================
+    public static string SetDpiAware()
+    {
+        string mode = "none";
+        try { if (SetProcessDpiAwarenessContext(new IntPtr(-4)) != IntPtr.Zero) mode = "per-monitor-v2"; }
+        catch { }
+        if (mode == "none") { try { if (SetProcessDPIAware()) mode = "system"; } catch { } }
+        return mode;
+    }
+
+    public static string ScreenInfo()
+    {
+        int w = GetSystemMetrics(0), h = GetSystemMetrics(1);
+        int vx = GetSystemMetrics(76), vy = GetSystemMetrics(77);
+        int vw = GetSystemMetrics(78), vh = GetSystemMetrics(79);
+        POINT c; GetCursorPos(out c);
+        IntPtr fg = GetForegroundWindow();
+        return "{\"width\":" + N(w) + ",\"height\":" + N(h) +
+               ",\"virtualX\":" + N(vx) + ",\"virtualY\":" + N(vy) +
+               ",\"virtualWidth\":" + N(vw) + ",\"virtualHeight\":" + N(vh) +
+               ",\"cursorX\":" + N(c.X) + ",\"cursorY\":" + N(c.Y) +
+               ",\"foreground\":" + Q(Title(fg)) + "}";
+    }
+
+    static string Title(IntPtr h)
+    {
+        StringBuilder sb = new StringBuilder(512);
+        GetWindowText(h, sb, 512);
+        return sb.ToString();
+    }
+    static string ClassOf(IntPtr h)
+    {
+        StringBuilder sb = new StringBuilder(256);
+        GetClassName(h, sb, 256);
+        return sb.ToString();
+    }
+    static string ProcOf(IntPtr h)
+    {
+        uint pid; GetWindowThreadProcessId(h, out pid);
+        try { return System.Diagnostics.Process.GetProcessById((int)pid).ProcessName; }
+        catch { return ""; }
+    }
+
+    // ================= Ventanas =================
+    public static string ListWindows(string filter)
+    {
+        List<string> rows = new List<string>();
+        string f = Norm(filter);
+        EnumWindows(delegate(IntPtr h, IntPtr l)
+        {
+            if (!IsWindowVisible(h)) return true;
+            string t = Title(h);
+            if (t.Length == 0) return true;
+            string cls = ClassOf(h);
+            if (cls == "Progman" || cls == "Shell_TrayWnd" || cls == "WorkerW") return true;
+            RECT r; GetWindowRect(h, out r);
+            int w = r.Right - r.Left, hh = r.Bottom - r.Top;
+            if (w <= 0 || hh <= 0) return true;
+            string proc = ProcOf(h);
+            if (f.Length > 0 && Norm(t).IndexOf(f) < 0 && Norm(proc).IndexOf(f) < 0) return true;
+            rows.Add("{\"hwnd\":" + N((int)h) + ",\"title\":" + Q(t) + ",\"process\":" + Q(proc) +
+                     ",\"class\":" + Q(cls) + ",\"x\":" + N(r.Left) + ",\"y\":" + N(r.Top) +
+                     ",\"width\":" + N(w) + ",\"height\":" + N(hh) +
+                     ",\"minimized\":" + (IsIconic(h) ? "true" : "false") + "}");
+            return true;
+        }, IntPtr.Zero);
+        return "[" + string.Join(",", rows.ToArray()) + "]";
+    }
+
+    // Busca la mejor ventana: prioriza coincidencia de titulo, luego proceso, y
+    // entre varias elige la de mayor area visible (evita ventanas fantasma de 1x1).
+    public static IntPtr FindWindow(string query)
+    {
+        if (query == null || query.Trim().Length == 0) return GetForegroundWindow();
+        string q = Norm(query);
+        IntPtr best = IntPtr.Zero;
+        int bestScore = -1;
+        _bestTier = -1; _tieCount = 0; _tieTitles = "";
+        EnumWindows(delegate(IntPtr h, IntPtr l)
+        {
+            if (!IsWindowVisible(h)) return true;
+            string t = Title(h);
+            if (t.Length == 0) return true;
+            string cls = ClassOf(h);
+            if (cls == "Progman" || cls == "Shell_TrayWnd" || cls == "WorkerW") return true;
+            string tl = Norm(t);
+            string pl = Norm(ProcOf(h));
+            RECT r; GetWindowRect(h, out r);
+            int area = (r.Right - r.Left) * (r.Bottom - r.Top);
+            if (area <= 0) return true;
+            int score = -1;
+            if (tl == q) score = 400;
+            else if (tl.IndexOf(q) >= 0) score = 300;
+            else if (pl == q) score = 200;
+            else if (pl.IndexOf(q) >= 0) score = 100;
+            if (score < 0) return true;
+            if (IsIconic(h)) score -= 50;
+            // Se guarda el nivel de coincidencia aparte del desempate por area,
+            // para poder detectar despues si la consulta era ambigua.
+            if (score > _bestTier) { _bestTier = score; _tieCount = 1; _tieTitles = Title(h); }
+            else if (score == _bestTier) { _tieCount++; if (_tieTitles.Length < 300) _tieTitles += " | " + Title(h); }
+            score = score * 1000000 + Math.Min(area / 1000, 900000);
+            if (score > bestScore) { bestScore = score; best = h; }
+            return true;
+        }, IntPtr.Zero);
+        return best;
+    }
+
+    static int _bestTier = -1;
+    static int _tieCount = 0;
+    static string _tieTitles = "";
+
+    /**
+     * Cuantas ventanas empataban en la ultima busqueda. Si son varias, quien
+     * llama debe negarse a actuar en vez de elegir una a ciegas: elegir mal aqui
+     * significa mandar un Alt+F4 a la ventana equivocada.
+     */
+    public static string Ambiguity()
+    {
+        return "{\"matches\":" + N(_tieCount) + ",\"candidates\":" + Q(_tieTitles) + "}";
+    }
+
+    public static string WindowInfo(IntPtr h)
+    {
+        if (h == IntPtr.Zero) return "{\"found\":false}";
+        RECT r; GetWindowRect(h, out r);
+        return "{\"found\":true,\"hwnd\":" + N((int)h) + ",\"title\":" + Q(Title(h)) +
+               ",\"process\":" + Q(ProcOf(h)) + ",\"class\":" + Q(ClassOf(h)) +
+               ",\"x\":" + N(r.Left) + ",\"y\":" + N(r.Top) +
+               ",\"width\":" + N(r.Right - r.Left) + ",\"height\":" + N(r.Bottom - r.Top) +
+               ",\"minimized\":" + (IsIconic(h) ? "true" : "false") +
+               ",\"foreground\":" + (GetForegroundWindow() == h ? "true" : "false") + "}";
+    }
+
+    public static string FocusWindow(IntPtr h)
+    {
+        if (h == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        if (IsIconic(h)) ShowWindow(h, 9);
+        // AttachThreadInput evita que Windows bloquee el cambio de foco entre procesos.
+        uint target = GetWindowThreadProcessId(h, out _dummyPid);
+        uint self = GetCurrentThreadId();
+        bool attached = false;
+        if (target != self) attached = AttachThreadInput(self, target, true);
+        // Windows bloquea que un proceso de fondo robe el primer plano salvo que
+        // haya habido entrada de teclado reciente. Un toque de ALT levanta ese
+        // bloqueo; sin esto SetForegroundWindow devuelve false y las teclas
+        // acaban en la ventana equivocada.
+        SendVk(0x12, false);
+        SendVk(0x12, true);
+        BringWindowToTop(h);
+        SetForegroundWindow(h);
+        if (attached) AttachThreadInput(self, target, false);
+        Thread.Sleep(150);
+        // Lo que importa no es lo que devuelva la API, sino si la ventana quedo
+        // realmente delante: se comprueba.
+        bool ok = (GetForegroundWindow() == h);
+        return "{\"ok\":" + (ok ? "true" : "false") + ",\"title\":" + Q(Title(h)) +
+               ",\"foreground\":" + Q(Title(GetForegroundWindow())) + "}";
+    }
+    static uint _dummyPid = 0;
+
+    // ================= Captura =================
+    // Escala la imagen respetando el limite de lado largo de la spec de Anthropic
+    // (1568 px para modelos clasicos) y devuelve el factor para poder traducir
+    // coordenadas del modelo -> pantalla fisica.
+    static double SaveScaled(Bitmap bmp, string path, int maxLongEdge)
+    {
+        int w = bmp.Width, h = bmp.Height;
+        double scale = 1.0;
+        int longEdge = Math.Max(w, h);
+        if (maxLongEdge > 0 && longEdge > maxLongEdge) scale = (double)maxLongEdge / (double)longEdge;
+        if (scale >= 0.999)
+        {
+            bmp.Save(path, ImageFormat.Png);
+            return 1.0;
+        }
+        int nw = (int)Math.Round(w * scale), nh = (int)Math.Round(h * scale);
+        using (Bitmap dst = new Bitmap(nw, nh))
+        using (Graphics g = Graphics.FromImage(dst))
+        {
+            g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
+            g.DrawImage(bmp, 0, 0, nw, nh);
+            dst.Save(path, ImageFormat.Png);
+        }
+        return scale;
+    }
+
+    public static string CaptureScreen(string path, int maxLongEdge, bool drawCursor)
+    {
+        int vx = GetSystemMetrics(76), vy = GetSystemMetrics(77);
+        int vw = GetSystemMetrics(78), vh = GetSystemMetrics(79);
+        using (Bitmap bmp = new Bitmap(vw, vh, PixelFormat.Format32bppArgb))
+        {
+            using (Graphics g = Graphics.FromImage(bmp))
+            {
+                g.CopyFromScreen(vx, vy, 0, 0, new Size(vw, vh), CopyPixelOperation.SourceCopy);
+                if (drawCursor)
+                {
+                    POINT c; GetCursorPos(out c);
+                    g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;
+                    using (Pen p = new Pen(Color.FromArgb(255, 235, 75, 75), 3))
+                    {
+                        g.DrawEllipse(p, c.X - vx - 16, c.Y - vy - 16, 32, 32);
+                        g.DrawLine(p, c.X - vx - 24, c.Y - vy, c.X - vx + 24, c.Y - vy);
+                        g.DrawLine(p, c.X - vx, c.Y - vy - 24, c.X - vx, c.Y - vy + 24);
+                    }
+                }
+            }
+            double s = SaveScaled(bmp, path, maxLongEdge);
+            return "{\"ok\":true,\"path\":" + Q(path) + ",\"screenWidth\":" + N(vw) + ",\"screenHeight\":" + N(vh) +
+                   ",\"originX\":" + N(vx) + ",\"originY\":" + N(vy) +
+                   ",\"imageWidth\":" + N((int)Math.Round(vw * s)) + ",\"imageHeight\":" + N((int)Math.Round(vh * s)) +
+                   ",\"scale\":" + s.ToString("0.#####", CultureInfo.InvariantCulture) + "}";
+    }
+    }
+
+    // Captura UNA ventana concreta sin traerla al frente.
+    // PrintWindow(PW_RENDERFULLCONTENT=2) pide a la ventana que se redibuje en
+    // nuestro DC, asi funciona aunque este tapada o en segundo plano.
+    public static string CaptureWindow(IntPtr h, string path, int maxLongEdge, bool clientOnly)
+    {
+        if (h == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        RECT r;
+        if (clientOnly) { GetClientRect(h, out r); } else { GetWindowRect(h, out r); }
+        int w = r.Right - r.Left, hh = r.Bottom - r.Top;
+        if (w <= 0 || hh <= 0) return "{\"ok\":false,\"error\":\"ventana sin area visible (minimizada?)\"}";
+        using (Bitmap bmp = new Bitmap(w, hh, PixelFormat.Format32bppArgb))
+        {
+            bool printed = false;
+            using (Graphics g = Graphics.FromImage(bmp))
+            {
+                IntPtr hdc = g.GetHdc();
+                try { printed = PrintWindow(h, hdc, 2); }
+                finally { g.ReleaseHdc(hdc); }
+            }
+            // Chrome/Electron a veces devuelven negro con PrintWindow: si sale casi
+            // todo negro y la ventana esta visible, caemos a copia de pantalla.
+            if (!printed || IsMostlyBlank(bmp))
+            {
+                RECT wr; GetWindowRect(h, out wr);
+                using (Graphics g2 = Graphics.FromImage(bmp))
+                    g2.CopyFromScreen(wr.Left, wr.Top, 0, 0, new Size(w, hh), CopyPixelOperation.SourceCopy);
+            }
+            double s = SaveScaled(bmp, path, maxLongEdge);
+            RECT wr2; GetWindowRect(h, out wr2);
+            return "{\"ok\":true,\"path\":" + Q(path) + ",\"title\":" + Q(Title(h)) +
+                   ",\"windowX\":" + N(wr2.Left) + ",\"windowY\":" + N(wr2.Top) +
+                   ",\"windowWidth\":" + N(w) + ",\"windowHeight\":" + N(hh) +
+                   ",\"imageWidth\":" + N((int)Math.Round(w * s)) + ",\"imageHeight\":" + N((int)Math.Round(hh * s)) +
+                   ",\"scale\":" + s.ToString("0.#####", CultureInfo.InvariantCulture) + "}";
+        }
+    }
+
+    static bool IsMostlyBlank(Bitmap b)
+    {
+        int step = Math.Max(1, Math.Min(b.Width, b.Height) / 24);
+        int total = 0, blank = 0;
+        for (int y = 0; y < b.Height; y += step)
+            for (int x = 0; x < b.Width; x += step)
+            {
+                Color c = b.GetPixel(x, y);
+                total++;
+                if (c.A == 0 || (c.R < 8 && c.G < 8 && c.B < 8)) blank++;
+            }
+        return total > 0 && ((double)blank / (double)total) > 0.97;
+    }
+
+    // ================= UI Automation (arbol de accesibilidad) =================
+    // Pieza clave: en vez de adivinar pixeles, enumeramos los controles reales de
+    // la ventana con su nombre y su rectangulo. El modelo elige por "ref", no por
+    // coordenada inventada, y ademas se puede activar sin tocar el raton.
+    static string RoleOf(AutomationElement e)
+    {
+        try { return e.Current.ControlType.ProgrammaticName.Replace("ControlType.", ""); }
+        catch { return "Unknown"; }
+    }
+
+    static bool IsInteractive(string role)
+    {
+        switch (role)
+        {
+            case "Button": case "Edit": case "Document": case "ComboBox": case "CheckBox":
+            case "RadioButton": case "MenuItem": case "ListItem": case "TabItem": case "Hyperlink":
+            case "TreeItem": case "Slider": case "SplitButton": case "Spinner": case "Custom":
+            case "DataItem": case "Menu": case "Tab": case "List":
+                return true;
+            default: return false;
+        }
+    }
+
+    static string PatternsOf(AutomationElement e)
+    {
+        List<string> p = new List<string>();
+        try { if ((bool)e.GetCurrentPropertyValue(AutomationElement.IsInvokePatternAvailableProperty)) p.Add("invoke"); } catch { }
+        try { if ((bool)e.GetCurrentPropertyValue(AutomationElement.IsValuePatternAvailableProperty)) p.Add("setvalue"); } catch { }
+        try { if ((bool)e.GetCurrentPropertyValue(AutomationElement.IsTogglePatternAvailableProperty)) p.Add("toggle"); } catch { }
+        try { if ((bool)e.GetCurrentPropertyValue(AutomationElement.IsExpandCollapsePatternAvailableProperty)) p.Add("expand"); } catch { }
+        try { if ((bool)e.GetCurrentPropertyValue(AutomationElement.IsSelectionItemPatternAvailableProperty)) p.Add("select"); } catch { }
+        return string.Join("|", p.ToArray());
+    }
+
+    public static string Snapshot(IntPtr hwnd, int maxNodes, string filter, bool interactiveOnly)
+    {
+        if (hwnd == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        AutomationElement root;
+        try { root = AutomationElement.FromHandle(hwnd); }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q("UIA no pudo abrir la ventana: " + ex.Message) + "}"; }
+        if (root == null) return "{\"ok\":false,\"error\":\"UIA devolvio null\"}";
+
+        _snap.Clear(); _snapLabel.Clear(); _snapWindow = hwnd;
+        List<string> rows = new List<string>();
+        string f = Norm(filter);
+        int counter = 0;
+        int budget = (maxNodes <= 0) ? 250 : maxNodes;
+        TreeWalker walker = TreeWalker.ControlViewWalker;
+
+        // Recorrido en anchura: los controles utiles suelen estar arriba en el
+        // arbol y asi no desbordamos la pila en apps enormes como Chrome.
+        Queue<KeyValuePair<AutomationElement, int>> queue = new Queue<KeyValuePair<AutomationElement, int>>();
+        queue.Enqueue(new KeyValuePair<AutomationElement, int>(root, 0));
+        int visited = 0;
+
+        while (queue.Count > 0 && rows.Count < budget && visited < 6000)
+        {
+            KeyValuePair<AutomationElement, int> cur = queue.Dequeue();
+            AutomationElement el = cur.Key;
+            int depth = cur.Value;
+            visited++;
+            try
+            {
+                string role = RoleOf(el);
+                string name = "";
+                string val = "";
+                bool enabled = true, offscreen = false;
+                System.Windows.Rect rect = System.Windows.Rect.Empty;
+                try { name = el.Current.Name; } catch { }
+                try { enabled = el.Current.IsEnabled; } catch { }
+                try { offscreen = el.Current.IsOffscreen; } catch { }
+                try { rect = el.Current.BoundingRectangle; } catch { }
+                try
+                {
+                    object vpo;
+                    if (el.TryGetCurrentPattern(ValuePattern.Pattern, out vpo))
+                        val = ((ValuePattern)vpo).Current.Value;
+                }
+                catch { }
+                if (name == null) name = "";
+                if (val == null) val = "";
+
+                bool hasArea = !rect.IsEmpty && rect.Width >= 2 && rect.Height >= 2;
+                bool keep = hasArea && !offscreen && depth > 0;
+                if (keep && interactiveOnly && !IsInteractive(role)) keep = false;
+                if (keep && name.Length == 0 && val.Length == 0 && role != "Edit" && role != "Document") keep = false;
+                if (keep && f.Length > 0)
+                {
+                    string hay = Norm(name + " " + val + " " + role);
+                    if (hay.IndexOf(f) < 0) keep = false;
+                }
+
+                if (keep)
+                {
+                    counter++;
+                    _snap[counter] = el;
+                    _snapLabel[counter] = role + " " + name;
+                    int cx = (int)Math.Round(rect.X + rect.Width / 2.0);
+                    int cy = (int)Math.Round(rect.Y + rect.Height / 2.0);
+                    string shortName = name.Length > 120 ? name.Substring(0, 117) + "..." : name;
+                    string shortVal = val.Length > 80 ? val.Substring(0, 77) + "..." : val;
+                    rows.Add("{\"ref\":" + N(counter) + ",\"role\":" + Q(role) + ",\"name\":" + Q(shortName) +
+                             ",\"value\":" + Q(shortVal) + ",\"x\":" + N(cx) + ",\"y\":" + N(cy) +
+                             ",\"left\":" + N((int)rect.X) + ",\"top\":" + N((int)rect.Y) +
+                             ",\"width\":" + N((int)rect.Width) + ",\"height\":" + N((int)rect.Height) +
+                             ",\"enabled\":" + (enabled ? "true" : "false") +
+                             ",\"actions\":" + Q(PatternsOf(el)) + "}");
+                }
+
+                if (depth < 40)
+                {
+                    AutomationElement child = walker.GetFirstChild(el);
+                    int siblings = 0;
+                    while (child != null && siblings < 300)
+                    {
+                        queue.Enqueue(new KeyValuePair<AutomationElement, int>(child, depth + 1));
+                        siblings++;
+                        child = walker.GetNextSibling(child);
+                    }
+                }
+            }
+            catch { }
+        }
+
+        RECT wr; GetWindowRect(hwnd, out wr);
+        return "{\"ok\":true,\"title\":" + Q(Title(hwnd)) + ",\"hwnd\":" + N((int)hwnd) +
+               ",\"windowX\":" + N(wr.Left) + ",\"windowY\":" + N(wr.Top) +
+               ",\"windowWidth\":" + N(wr.Right - wr.Left) + ",\"windowHeight\":" + N(wr.Bottom - wr.Top) +
+               ",\"truncated\":" + (rows.Count >= budget ? "true" : "false") +
+               ",\"elements\":[" + string.Join(",", rows.ToArray()) + "]}";
+    }
+
+    static AutomationElement Ref(int id)
+    {
+        AutomationElement e;
+        if (_snap.TryGetValue(id, out e)) return e;
+        return null;
+    }
+
+    public static string RefRect(int id)
+    {
+        AutomationElement e = Ref(id);
+        if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        try
+        {
+            System.Windows.Rect r = e.Current.BoundingRectangle;
+            return "{\"ok\":true,\"x\":" + N((int)Math.Round(r.X + r.Width / 2.0)) +
+                   ",\"y\":" + N((int)Math.Round(r.Y + r.Height / 2.0)) +
+                   ",\"label\":" + Q(_snapLabel.ContainsKey(id) ? _snapLabel[id] : "") + "}";
+        }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
+    }
+
+    // Activa el elemento SIN mover el raton y SIN robar el foco de pantalla.
+    public static string RefInvoke(int id)
+    {
+        AutomationElement e = Ref(id);
+        if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        string label = _snapLabel.ContainsKey(id) ? _snapLabel[id] : ("ref " + N(id));
+        try
+        {
+            try { object sp; if (e.TryGetCurrentPattern(ScrollItemPattern.Pattern, out sp)) ((ScrollItemPattern)sp).ScrollIntoView(); } catch { }
+            object p;
+            if (e.TryGetCurrentPattern(InvokePattern.Pattern, out p)) { ((InvokePattern)p).Invoke(); return "{\"ok\":true,\"via\":\"invoke\",\"label\":" + Q(label) + "}"; }
+            if (e.TryGetCurrentPattern(SelectionItemPattern.Pattern, out p)) { ((SelectionItemPattern)p).Select(); return "{\"ok\":true,\"via\":\"select\",\"label\":" + Q(label) + "}"; }
+            if (e.TryGetCurrentPattern(TogglePattern.Pattern, out p)) { ((TogglePattern)p).Toggle(); return "{\"ok\":true,\"via\":\"toggle\",\"label\":" + Q(label) + "}"; }
+            if (e.TryGetCurrentPattern(ExpandCollapsePattern.Pattern, out p)) { ((ExpandCollapsePattern)p).Expand(); return "{\"ok\":true,\"via\":\"expand\",\"label\":" + Q(label) + "}"; }
+            return "{\"ok\":false,\"error\":" + Q("El elemento " + label + " no expone patron activable; usa click sobre sus coordenadas.") + "}";
+        }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
+    }
+
+    public static string RefSetValue(int id, string text, bool replace)
+    {
+        AutomationElement e = Ref(id);
+        if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        try
+        {
+            // ValuePattern.SetValue SUSTITUYE todo el contenido del control. En un
+            // campo de una linea es lo que se quiere; en un editor de texto
+            // completo eso borra el documento entero del usuario. Por eso un
+            // Document nunca se escribe por aqui salvo peticion explicita.
+            string role = RoleOf(e);
+            if (role == "Document" && !replace)
+            {
+                return "{\"ok\":false,\"needsTyping\":true,\"error\":\"es un editor de texto completo: escribir por ValuePattern borraria todo su contenido. Se escribe con enfoque y teclado.\"}";
+            }
+            object p;
+            if (e.TryGetCurrentPattern(ValuePattern.Pattern, out p))
+            {
+                ValuePattern vp = (ValuePattern)p;
+                if (vp.Current.IsReadOnly) return "{\"ok\":false,\"error\":\"campo de solo lectura\"}";
+                try { e.SetFocus(); } catch { }
+                vp.SetValue(text);
+                return "{\"ok\":true,\"via\":\"valuepattern\"}";
+            }
+            return "{\"ok\":false,\"error\":\"el elemento no acepta ValuePattern; usa ui_focus y luego type\"}";
+        }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
+    }
+
+    public static string RefFocus(int id)
+    {
+        AutomationElement e = Ref(id);
+        if (e == null) return "{\"ok\":false,\"error\":\"ref inexistente; repite ui_snapshot\"}";
+        try { e.SetFocus(); Thread.Sleep(60); return "{\"ok\":true}"; }
+        catch (Exception ex) { return "{\"ok\":false,\"error\":" + Q(ex.Message) + "}"; }
+    }
+
+    // ================= Teclado =================
+    static ushort VkOf(string k)
+    {
+        string s = k.Trim().ToLowerInvariant();
+        switch (s)
+        {
+            case "ctrl": case "control": return 0x11;
+            case "alt": case "menu": return 0x12;
+            case "shift": return 0x10;
+            case "win": case "super": case "cmd": case "meta": return 0x5B;
+            case "enter": case "return": return 0x0D;
+            case "esc": case "escape": return 0x1B;
+            case "tab": return 0x09;
+            case "space": case "spacebar": return 0x20;
+            case "backspace": case "bksp": return 0x08;
+            case "delete": case "del": return 0x2E;
+            case "insert": return 0x2D;
+            case "home": return 0x24;
+            case "end": return 0x23;
+            case "pageup": case "prior": return 0x21;
+            case "pagedown": case "next": return 0x22;
+            case "up": return 0x26;
+            case "down": return 0x28;
+            case "left": return 0x25;
+            case "right": return 0x27;
+            case "printscreen": return 0x2C;
+            case "capslock": return 0x14;
+            case "f1": return 0x70; case "f2": return 0x71; case "f3": return 0x72; case "f4": return 0x73;
+            case "f5": return 0x74; case "f6": return 0x75; case "f7": return 0x76; case "f8": return 0x77;
+            case "f9": return 0x78; case "f10": return 0x79; case "f11": return 0x7A; case "f12": return 0x7B;
+        }
+        if (s.Length == 1)
+        {
+            short v = VkKeyScan(s[0]);
+            if (v != -1) return (ushort)(v & 0xFF);
+        }
+        return 0;
+    }
+
+    static bool IsExtended(ushort vk)
+    {
+        return vk == 0x25 || vk == 0x26 || vk == 0x27 || vk == 0x28 || vk == 0x2D ||
+               vk == 0x2E || vk == 0x24 || vk == 0x23 || vk == 0x21 || vk == 0x22 || vk == 0x5B;
+    }
+
+    static void SendVk(ushort vk, bool up)
+    {
+        INPUT[] inp = new INPUT[1];
+        inp[0].type = 1;
+        inp[0].u.ki.wVk = vk;
+        inp[0].u.ki.wScan = 0;
+        inp[0].u.ki.dwFlags = (up ? KEYEVENTF_KEYUP : 0) | (IsExtended(vk) ? KEYEVENTF_EXTENDEDKEY : 0);
+        inp[0].u.ki.time = 0;
+        inp[0].u.ki.dwExtraInfo = IntPtr.Zero;
+        SendInput(1, inp, Marshal.SizeOf(typeof(INPUT)));
+    }
+
+    static void SendUnicode(char c, bool up)
+    {
+        INPUT[] inp = new INPUT[1];
+        inp[0].type = 1;
+        inp[0].u.ki.wVk = 0;
+        inp[0].u.ki.wScan = (ushort)c;
+        inp[0].u.ki.dwFlags = KEYEVENTF_UNICODE | (up ? KEYEVENTF_KEYUP : 0);
+        inp[0].u.ki.time = 0;
+        inp[0].u.ki.dwExtraInfo = IntPtr.Zero;
+        SendInput(1, inp, Marshal.SizeOf(typeof(INPUT)));
+    }
+
+    // Escribe por SendInput con KEYEVENTF_UNICODE: acepta tildes, enes y emoji sin
+    // el infierno de escapes de SendKeys, y no pierde caracteres en textos largos.
+    public static string TypeText(string text, int delayMs)
+    {
+        if (text == null) text = "";
+        int d = delayMs <= 0 ? 6 : delayMs;
+        foreach (char c in text)
+        {
+            if (c == '\n' || c == '\r')
+            {
+                if (c == '\r') continue;
+                SendVk(0x0D, false); SendVk(0x0D, true);
+            }
+            else if (c == '\t') { SendVk(0x09, false); SendVk(0x09, true); }
+            else { SendUnicode(c, false); SendUnicode(c, true); }
+            Thread.Sleep(d);
+        }
+        return "{\"ok\":true,\"chars\":" + N(text.Length) + "}";
+    }
+
+    // Acepta "ctrl+s", "alt+Tab", "Return", "ctrl+shift+t".
+    public static string KeyCombo(string combo, int repeat)
+    {
+        if (combo == null || combo.Trim().Length == 0) return "{\"ok\":false,\"error\":\"combo vacio\"}";
+        string[] parts = combo.Replace(" ", "").Split('+');
+        List<ushort> mods = new List<ushort>();
+        ushort main = 0;
+        for (int i = 0; i < parts.Length; i++)
+        {
+            if (parts[i].Length == 0) { main = VkOf("+"); continue; }
+            ushort vk = VkOf(parts[i]);
+            if (vk == 0) return "{\"ok\":false,\"error\":" + Q("tecla desconocida: " + parts[i]) + "}";
+            bool isMod = (vk == 0x11 || vk == 0x12 || vk == 0x10 || vk == 0x5B);
+            if (isMod && i < parts.Length - 1) mods.Add(vk); else main = vk;
+        }
+        if (main == 0) return "{\"ok\":false,\"error\":\"falta la tecla principal\"}";
+        int r = repeat <= 0 ? 1 : Math.Min(repeat, 100);
+        for (int k = 0; k < r; k++)
+        {
+            for (int i = 0; i < mods.Count; i++) SendVk(mods[i], false);
+            SendVk(main, false);
+            Thread.Sleep(20);
+            SendVk(main, true);
+            for (int i = mods.Count - 1; i >= 0; i--) SendVk(mods[i], true);
+            if (r > 1) Thread.Sleep(30);
+        }
+        return "{\"ok\":true,\"combo\":" + Q(combo) + ",\"repeat\":" + N(r) + "}";
+    }
+
+    // ================= Raton =================
+    const uint MOUSEEVENTF_VIRTUALDESK = 0x4000;
+
+    static void MouseAbs(int x, int y, uint extraFlags, uint data)
+    {
+        int vx = GetSystemMetrics(76), vy = GetSystemMetrics(77);
+        int vw = GetSystemMetrics(78), vh = GetSystemMetrics(79);
+        if (vw <= 0) vw = 1; if (vh <= 0) vh = 1;
+        int nx = (int)Math.Round((double)(x - vx) * 65535.0 / (double)(vw - 1));
+        int ny = (int)Math.Round((double)(y - vy) * 65535.0 / (double)(vh - 1));
+        INPUT[] inp = new INPUT[1];
+        inp[0].type = 0;
+        inp[0].u.mi.dx = nx;
+        inp[0].u.mi.dy = ny;
+        inp[0].u.mi.mouseData = data;
+        inp[0].u.mi.dwFlags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_VIRTUALDESK | MOUSEEVENTF_MOVE | extraFlags;
+        inp[0].u.mi.time = 0;
+        inp[0].u.mi.dwExtraInfo = IntPtr.Zero;
+        SendInput(1, inp, Marshal.SizeOf(typeof(INPUT)));
+    }
+
+    public static string MoveMouse(int x, int y)
+    {
+        MouseAbs(x, y, 0, 0);
+        Thread.Sleep(30);
+        return "{\"ok\":true,\"x\":" + N(x) + ",\"y\":" + N(y) + "}";
+    }
+
+    public static string Click(int x, int y, string button, int count)
+    {
+        uint down = MOUSEEVENTF_LEFTDOWN, up = MOUSEEVENTF_LEFTUP;
+        string b = (button == null) ? "left" : button.ToLowerInvariant();
+        if (b == "right") { down = MOUSEEVENTF_RIGHTDOWN; up = MOUSEEVENTF_RIGHTUP; }
+        else if (b == "middle") { down = MOUSEEVENTF_MIDDLEDOWN; up = MOUSEEVENTF_MIDDLEUP; }
+        MouseAbs(x, y, 0, 0);
+        Thread.Sleep(40);
+        int c = count <= 0 ? 1 : Math.Min(count, 3);
+        for (int i = 0; i < c; i++)
+        {
+            MouseAbs(x, y, down, 0);
+            Thread.Sleep(18);
+            MouseAbs(x, y, up, 0);
+            if (i < c - 1) Thread.Sleep(70);
+        }
+        IntPtr fg = GetForegroundWindow();
+        return "{\"ok\":true,\"x\":" + N(x) + ",\"y\":" + N(y) + ",\"button\":" + Q(b) +
+               ",\"count\":" + N(c) + ",\"window\":" + Q(Title(fg)) + "}";
+    }
+
+    public static string Drag(int x1, int y1, int x2, int y2)
+    {
+        MouseAbs(x1, y1, 0, 0);
+        Thread.Sleep(60);
+        MouseAbs(x1, y1, MOUSEEVENTF_LEFTDOWN, 0);
+        Thread.Sleep(80);
+        int steps = 24;
+        for (int i = 1; i <= steps; i++)
+        {
+            int cx = x1 + (int)Math.Round((x2 - x1) * ((double)i / steps));
+            int cy = y1 + (int)Math.Round((y2 - y1) * ((double)i / steps));
+            MouseAbs(cx, cy, 0, 0);
+            Thread.Sleep(12);
+        }
+        Thread.Sleep(60);
+        MouseAbs(x2, y2, MOUSEEVENTF_LEFTUP, 0);
+        return "{\"ok\":true}";
+    }
+
+    public static string Scroll(int x, int y, string direction, int amount)
+    {
+        string d = (direction == null) ? "down" : direction.ToLowerInvariant();
+        int a = amount <= 0 ? 3 : amount;
+        if (x >= 0 && y >= 0) { MouseAbs(x, y, 0, 0); Thread.Sleep(30); }
+        for (int i = 0; i < a; i++)
+        {
+            if (d == "up") MouseAbs(x, y, MOUSEEVENTF_WHEEL, 120);
+            else if (d == "down") MouseAbs(x, y, MOUSEEVENTF_WHEEL, unchecked((uint)-120));
+            else if (d == "right") MouseAbs(x, y, MOUSEEVENTF_HWHEEL, 120);
+            else MouseAbs(x, y, MOUSEEVENTF_HWHEEL, unchecked((uint)-120));
+            Thread.Sleep(40);
+        }
+        return "{\"ok\":true,\"direction\":" + Q(d) + ",\"amount\":" + N(a) + "}";
+    }
+
+    // Clic en SEGUNDO PLANO: manda el mensaje directo a la ventana destino.
+    // No mueve el cursor real ni roba el foco, asi el usuario puede seguir
+    // trabajando en otra ventana mientras el agente opera.
+    public static string BgClick(IntPtr hwnd, int screenX, int screenY, string button, int count)
+    {
+        if (hwnd == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        POINT p; p.X = screenX; p.Y = screenY;
+        if (!ScreenToClient(hwnd, ref p)) return "{\"ok\":false,\"error\":\"no se pudo convertir a coordenadas de cliente\"}";
+        IntPtr lp = (IntPtr)((p.Y << 16) | (p.X & 0xFFFF));
+        uint dn = WM_LBUTTONDOWN, up = WM_LBUTTONUP; IntPtr wp = (IntPtr)1;
+        string b = (button == null) ? "left" : button.ToLowerInvariant();
+        if (b == "right") { dn = WM_RBUTTONDOWN; up = WM_RBUTTONUP; wp = (IntPtr)2; }
+        int c = count <= 0 ? 1 : Math.Min(count, 3);
+        PostMessage(hwnd, WM_MOUSEMOVE, IntPtr.Zero, lp);
+        for (int i = 0; i < c; i++)
+        {
+            PostMessage(hwnd, dn, wp, lp);
+            Thread.Sleep(20);
+            PostMessage(hwnd, up, IntPtr.Zero, lp);
+            if (i < c - 1) Thread.Sleep(60);
+        }
+        return "{\"ok\":true,\"mode\":\"background\",\"clientX\":" + N(p.X) + ",\"clientY\":" + N(p.Y) +
+               ",\"window\":" + Q(Title(hwnd)) + "}";
+    }
+
+    public static string BgType(IntPtr hwnd, string text)
+    {
+        if (hwnd == IntPtr.Zero) return "{\"ok\":false,\"error\":\"ventana no encontrada\"}";
+        if (text == null) text = "";
+        foreach (char c in text)
+        {
+            PostMessage(hwnd, WM_CHAR, (IntPtr)c, IntPtr.Zero);
+            Thread.Sleep(4);
+        }
+        return "{\"ok\":true,\"mode\":\"background\",\"chars\":" + N(text.Length) + "}";
+    }
+
+    public static IntPtr Foreground() { return GetForegroundWindow(); }
+    public static string ForegroundInfo() { return WindowInfo(GetForegroundWindow()); }
+    public static string CursorPos()
+    {
+        POINT c; GetCursorPos(out c);
+        return "{\"ok\":true,\"x\":" + N(c.X) + ",\"y\":" + N(c.Y) + "}";
+    }
+}
+'@
+
+Add-Type -TypeDefinition $csharp -ReferencedAssemblies @(
+  'System.Drawing','System.Windows.Forms','UIAutomationClient','UIAutomationTypes','WindowsBase'
+) -ErrorAction Stop
+
+# DPI-aware ANTES de cualquier medicion: sin esto Windows reporta la pantalla
+# escalada (p.ej. 2048x1152 en un monitor 2560x1440 al 125%) y TODOS los clics
+# salen desviados ~25% hacia arriba-izquierda. Era la causa raiz de los fallos.
+$dpiMode = [Choco]::SetDpiAware()
+
+function Get-Prop($o, $n, $d) {
+  if ($null -eq $o) { return $d }
+  $p = $o.PSObject.Properties[$n]
+  if ($null -eq $p) { return $d }
+  if ($null -eq $p.Value) { return $d }
+  return $p.Value
+}
+
+function Resolve-Hwnd($cmd) {
+  $h = [int](Get-Prop $cmd 'hwnd' 0)
+  if ($h -ne 0) { return [IntPtr]$h }
+  $w = [string](Get-Prop $cmd 'window' '')
+  if ($w.Trim() -ne '') { return [Choco]::FindWindow($w) }
+  return [Choco]::Foreground()
+}
+
+Write-Output ("CHOCO#0#{""ok"":true,""ready"":true,""dpi"":""" + $dpiMode + """}")
+
+while ($true) {
+  $line = [Console]::In.ReadLine()
+  if ($null -eq $line) { break }
+  if ($line.Trim() -eq '') { continue }
+  $id = 0
+  try {
+    $cmd = $line | ConvertFrom-Json
+    $id = [int](Get-Prop $cmd 'id' 0)
+    $action = [string](Get-Prop $cmd 'action' '')
+    $res = ''
+    switch ($action) {
+      'ping'          { $res = '{"ok":true,"pong":true,"dpi":"' + $dpiMode + '"}' }
+      'screen_info'   { $res = [Choco]::ScreenInfo() }
+      'cursor_position' { $res = [Choco]::CursorPos() }
+      'list_windows'  { $res = '{"ok":true,"windows":' + [Choco]::ListWindows([string](Get-Prop $cmd 'filter' '')) + '}' }
+      'find_window'   {
+        $h = [Choco]::FindWindow([string](Get-Prop $cmd 'window' ''))
+        $info = [Choco]::WindowInfo($h)
+        $amb = [Choco]::Ambiguity()
+        $res = ($info.TrimEnd('}')) + ',"ambiguity":' + $amb + '}'
+      }
+      'active_window' { $res = [Choco]::ForegroundInfo() }
+      'focus_window'  {
+        $h = Resolve-Hwnd $cmd
+        $r = [Choco]::FocusWindow($h)
+        $amb = [Choco]::Ambiguity()
+        $res = ($r.TrimEnd('}')) + ',"ambiguity":' + $amb + '}'
+      }
+      'wait'          { Start-Sleep -Milliseconds ([int](Get-Prop $cmd 'ms' 1000)); $res = '{"ok":true}' }
+      'capture_screen' {
+        $res = [Choco]::CaptureScreen([string](Get-Prop $cmd 'path' ''), [int](Get-Prop $cmd 'maxLongEdge' 1568), [bool](Get-Prop $cmd 'cursor' $true))
+      }
+      'capture_window' {
+        $res = [Choco]::CaptureWindow((Resolve-Hwnd $cmd), [string](Get-Prop $cmd 'path' ''), [int](Get-Prop $cmd 'maxLongEdge' 1568), [bool](Get-Prop $cmd 'clientOnly' $false))
+      }
+      'ui_snapshot' {
+        $res = [Choco]::Snapshot((Resolve-Hwnd $cmd), [int](Get-Prop $cmd 'max' 250), [string](Get-Prop $cmd 'filter' ''), [bool](Get-Prop $cmd 'interactiveOnly' $true))
+      }
+      'ui_click'      { $res = [Choco]::RefInvoke([int](Get-Prop $cmd 'ref' 0)) }
+      'ui_set_value'  { $res = [Choco]::RefSetValue([int](Get-Prop $cmd 'ref' 0), [string](Get-Prop $cmd 'text' ''), [bool](Get-Prop $cmd 'replace' $false)) }
+      'ui_focus'      { $res = [Choco]::RefFocus([int](Get-Prop $cmd 'ref' 0)) }
+      'ui_rect'       { $res = [Choco]::RefRect([int](Get-Prop $cmd 'ref' 0)) }
+      'click'         { $res = [Choco]::Click([int](Get-Prop $cmd 'x' 0), [int](Get-Prop $cmd 'y' 0), [string](Get-Prop $cmd 'button' 'left'), [int](Get-Prop $cmd 'count' 1)) }
+      'move'          { $res = [Choco]::MoveMouse([int](Get-Prop $cmd 'x' 0), [int](Get-Prop $cmd 'y' 0)) }
+      'drag'          { $res = [Choco]::Drag([int](Get-Prop $cmd 'x1' 0), [int](Get-Prop $cmd 'y1' 0), [int](Get-Prop $cmd 'x2' 0), [int](Get-Prop $cmd 'y2' 0)) }
+      'scroll'        { $res = [Choco]::Scroll([int](Get-Prop $cmd 'x' (-1)), [int](Get-Prop $cmd 'y' (-1)), [string](Get-Prop $cmd 'direction' 'down'), [int](Get-Prop $cmd 'amount' 3)) }
+      'type'          { $res = [Choco]::TypeText([string](Get-Prop $cmd 'text' ''), [int](Get-Prop $cmd 'delay' 6)) }
+      'key'           { $res = [Choco]::KeyCombo([string](Get-Prop $cmd 'keys' ''), [int](Get-Prop $cmd 'repeat' 1)) }
+      'bg_click'      { $res = [Choco]::BgClick((Resolve-Hwnd $cmd), [int](Get-Prop $cmd 'x' 0), [int](Get-Prop $cmd 'y' 0), [string](Get-Prop $cmd 'button' 'left'), [int](Get-Prop $cmd 'count' 1)) }
+      'bg_type'       { $res = [Choco]::BgType((Resolve-Hwnd $cmd), [string](Get-Prop $cmd 'text' '')) }
+      default         { $res = '{"ok":false,"error":"accion desconocida: ' + [Choco]::Esc($action) + '"}' }
+    }
+    Write-Output ("CHOCO#" + $id + "#" + $res)
+  } catch {
+    $msg = [Choco]::Esc($_.Exception.Message)
+    Write-Output ("CHOCO#" + $id + "#" + '{"ok":false,"error":"' + $msg + '"}')
+  }
+}
+`;