screenhand 0.2.0 → 0.3.1

package/native/windows-bridge/Program.cs

@@ -0,0 +1,270 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+
+namespace WindowsBridge;
+
+/// <summary>
+/// JSON-RPC over stdio bridge for Windows native APIs.
+/// Reads JSON requests from stdin (one per line), dispatches to the appropriate bridge,
+/// and writes JSON responses to stdout (one per line).
+/// Mirrors the protocol of the macOS Swift bridge exactly.
+/// </summary>
+class Program
+{
+    private static readonly AppManagement _appManagement = new();
+    private static readonly UIAutomationBridge _uiAutomation = new();
+    private static readonly InputBridge _input = new();
+    private static readonly ScreenCapture _screenCapture = new();
+
+    private static readonly object _outputLock = new();
+    private static readonly JsonSerializerOptions _jsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        WriteIndented = false,
+    };
+
+    static void Main(string[] args)
+    {
+        Console.InputEncoding = System.Text.Encoding.UTF8;
+        Console.OutputEncoding = System.Text.Encoding.UTF8;
+
+        string? line;
+        while ((line = Console.ReadLine()) != null)
+        {
+            if (string.IsNullOrWhiteSpace(line)) continue;
+
+            try
+            {
+                var request = JsonSerializer.Deserialize<JsonRpcRequest>(line, _jsonOptions);
+                if (request == null)
+                {
+                    WriteError(0, -32700, "Parse error: null request");
+                    continue;
+                }
+
+                try
+                {
+                    var result = Dispatch(request.Method, request.Params);
+                    WriteResult(request.Id, result);
+                }
+                catch (BridgeException ex)
+                {
+                    WriteError(request.Id, -1, ex.Message);
+                }
+                catch (Exception ex)
+                {
+                    WriteError(request.Id, -1, ex.Message);
+                }
+            }
+            catch (Exception ex)
+            {
+                WriteError(0, -32700, $"Parse error: {ex.Message}");
+            }
+        }
+    }
+
+    private static object Dispatch(string method, JsonObject? p)
+    {
+        return method switch
+        {
+            // Lifecycle
+            "ping" => new Dictionary<string, object>
+            {
+                ["pong"] = true,
+                ["pid"] = Environment.ProcessId,
+                ["accessible"] = true, // UI Automation doesn't need special permissions on Windows
+            },
+            "check_permissions" => new Dictionary<string, object>
+            {
+                ["trusted"] = true, // No special permissions needed on Windows for UIA
+            },
+
+            // App Management
+            "app.launch" => _appManagement.LaunchApp(RequiredParam<string>(p, "bundleId")),
+            "app.focus" => _appManagement.FocusApp(RequiredParam<string>(p, "bundleId")),
+            "app.list" => _appManagement.ListRunningApps(),
+            "app.windows" => _appManagement.ListWindows(),
+            "app.frontmost" => _appManagement.FrontmostApp(),
+
+            // UI Automation (Accessibility equivalent)
+            "ax.findElement" => _uiAutomation.FindElement(
+                RequiredParam<int>(p, "pid"),
+                Param<string>(p, "role"),
+                Param<string>(p, "title"),
+                Param<string>(p, "value"),
+                Param<string>(p, "identifier"),
+                Param<bool>(p, "exact") ?? true),
+            "ax.getElementTree" => _uiAutomation.GetElementTree(
+                RequiredParam<int>(p, "pid"),
+                Param<int>(p, "maxDepth") ?? 5),
+            "ax.performAction" => _uiAutomation.PerformAction(
+                RequiredParam<int>(p, "pid"),
+                RequiredParam<int[]>(p, "elementPath"),
+                Param<string>(p, "action") ?? "AXPress"),
+            "ax.setElementValue" => _uiAutomation.SetElementValue(
+                RequiredParam<int>(p, "pid"),
+                RequiredParam<int[]>(p, "elementPath"),
+                RequiredParam<string>(p, "value")),
+            "ax.getElementValue" => _uiAutomation.GetElementValue(
+                RequiredParam<int>(p, "pid"),
+                RequiredParam<int[]>(p, "elementPath")),
+            "ax.menuClick" => _uiAutomation.MenuClick(
+                RequiredParam<int>(p, "pid"),
+                RequiredParam<string[]>(p, "menuPath")),
+
+            // Observer (stub — Windows UIA events could be added later)
+            "observer.start" => new Dictionary<string, object>
+            {
+                ["ok"] = true,
+                ["stub"] = true,
+                ["message"] = "UI Automation event observation not yet implemented on Windows",
+            },
+            "observer.stop" => new Dictionary<string, object>
+            {
+                ["ok"] = true,
+                ["stub"] = true,
+                ["message"] = "UI Automation event observation not yet implemented on Windows",
+            },
+
+            // Input (CoreGraphics equivalent)
+            "cg.mouseClick" => _input.MouseClick(
+                RequiredParam<double>(p, "x"),
+                RequiredParam<double>(p, "y"),
+                Param<string>(p, "button") ?? "left",
+                Param<int>(p, "clickCount") ?? 1),
+            "cg.mouseMove" => _input.MouseMove(
+                RequiredParam<double>(p, "x"),
+                RequiredParam<double>(p, "y")),
+            "cg.mouseDrag" => _input.MouseDrag(
+                RequiredParam<double>(p, "fromX"),
+                RequiredParam<double>(p, "fromY"),
+                RequiredParam<double>(p, "toX"),
+                RequiredParam<double>(p, "toY")),
+            "cg.mouseFlick" => _input.MouseDrag( // Map flick to fast drag on Windows
+                RequiredParam<double>(p, "fromX"),
+                RequiredParam<double>(p, "fromY"),
+                RequiredParam<double>(p, "toX"),
+                RequiredParam<double>(p, "toY")),
+            "cg.keyCombo" => _input.KeyCombo(RequiredParam<string[]>(p, "keys")),
+            "cg.typeText" => _input.TypeText(RequiredParam<string>(p, "text")),
+            "cg.scroll" => _input.Scroll(
+                RequiredParam<double>(p, "x"),
+                RequiredParam<double>(p, "y"),
+                Param<int>(p, "deltaX") ?? 0,
+                Param<int>(p, "deltaY") ?? 0),
+            "cg.captureScreen" => _screenCapture.CaptureScreen(
+                Param<Dictionary<string, double>>(p, "region")),
+            "cg.captureWindow" => _screenCapture.CaptureWindow(
+                RequiredParam<int>(p, "windowId")),
+            "cg.captureWindowBuffer" => _screenCapture.CaptureWindowBuffer(
+                RequiredParam<int>(p, "windowId")),
+
+            // Vision (OCR)
+            "vision.findText" => _screenCapture.FindText(
+                RequiredParam<string>(p, "imagePath"),
+                Param<string>(p, "searchText")),
+            "vision.ocr" => _screenCapture.Ocr(
+                RequiredParam<string>(p, "imagePath")),
+            "vision.ocrRegion" => _screenCapture.OcrRegion(
+                RequiredParam<int>(p, "windowId"),
+                RequiredParam<Dictionary<string, double>>(p, "region")),
+
+            _ => throw new BridgeException($"Unknown method: {method}"),
+        };
+    }
+
+    // Parameter helpers (mirror Swift's param/requiredParam)
+    private static T? Param<T>(JsonObject? p, string key)
+    {
+        if (p == null || !p.ContainsKey(key) || p[key] == null) return default;
+
+        var node = p[key]!;
+
+        // Handle numeric coercion
+        if (typeof(T) == typeof(double) && node is JsonValue jv)
+        {
+            if (jv.TryGetValue<double>(out var d)) return (T)(object)d;
+            if (jv.TryGetValue<int>(out var i)) return (T)(object)(double)i;
+            if (jv.TryGetValue<long>(out var l)) return (T)(object)(double)l;
+        }
+        if (typeof(T) == typeof(int) && node is JsonValue jv2)
+        {
+            if (jv2.TryGetValue<int>(out var i)) return (T)(object)i;
+            if (jv2.TryGetValue<double>(out var d)) return (T)(object)(int)d;
+            if (jv2.TryGetValue<long>(out var l)) return (T)(object)(int)l;
+        }
+
+        try
+        {
+            return node.Deserialize<T>(_jsonOptions);
+        }
+        catch
+        {
+            return default;
+        }
+    }
+
+    private static T RequiredParam<T>(JsonObject? p, string key)
+    {
+        var value = Param<T>(p, key);
+        if (value == null)
+            throw new BridgeException($"Missing required parameter: {key}");
+        return value;
+    }
+
+    // Output helpers
+    private static void WriteResult(int id, object result)
+    {
+        var response = new Dictionary<string, object?>
+        {
+            ["id"] = id,
+            ["result"] = result,
+            ["error"] = null,
+        };
+        WriteLine(response);
+    }
+
+    private static void WriteError(int id, int code, string message)
+    {
+        var response = new Dictionary<string, object?>
+        {
+            ["id"] = id,
+            ["result"] = null,
+            ["error"] = new Dictionary<string, object> { ["code"] = code, ["message"] = message },
+        };
+        WriteLine(response);
+    }
+
+    public static void WriteEvent(Dictionary<string, object> eventData)
+    {
+        var wrapped = new Dictionary<string, object>
+        {
+            ["id"] = 0,
+            ["event"] = eventData,
+        };
+        WriteLine(wrapped);
+    }
+
+    private static void WriteLine(object obj)
+    {
+        var json = JsonSerializer.Serialize(obj, _jsonOptions);
+        lock (_outputLock)
+        {
+            Console.WriteLine(json);
+            Console.Out.Flush();
+        }
+    }
+}
+
+// JSON-RPC types
+class JsonRpcRequest
+{
+    public int Id { get; set; }
+    public string Method { get; set; } = "";
+    public JsonObject? Params { get; set; }
+}
+
+class BridgeException : Exception
+{
+    public BridgeException(string message) : base(message) { }
+}