screenhand 0.1.0 → 0.1.1

package/native/macos-bridge/Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version: 5.9
+import PackageDescription
+
+let package = Package(
+    name: "macos-bridge",
+    platforms: [
+        .macOS(.v13)
+    ],
+    targets: [
+        .executableTarget(
+            name: "macos-bridge",
+            path: "Sources",
+            linkerSettings: [
+                .linkedFramework("ApplicationServices"),
+                .linkedFramework("CoreGraphics"),
+                .linkedFramework("AppKit"),
+                .linkedFramework("Vision"),
+            ]
+        )
+    ]
+)

package/native/macos-bridge/Sources/AccessibilityBridge.swift

@@ -0,0 +1,261 @@
+import ApplicationServices
+import AppKit
+import Foundation
+
+class AccessibilityBridge {
+
+    func isAccessibilityTrusted() -> Bool {
+        return AXIsProcessTrusted()
+    }
+
+    // MARK: - Element Tree
+
+    func getElementTree(pid: pid_t, maxDepth: Int) throws -> [String: Any] {
+        let appElement = AXUIElementCreateApplication(pid)
+        return try buildTree(element: appElement, depth: 0, maxDepth: maxDepth)
+    }
+
+    private func buildTree(element: AXUIElement, depth: Int, maxDepth: Int) throws -> [String: Any] {
+        var node: [String: Any] = [:]
+
+        node["role"] = getAttribute(element, kAXRoleAttribute) as? String ?? "Unknown"
+        if let title = getAttribute(element, kAXTitleAttribute) as? String, !title.isEmpty {
+            node["title"] = title
+        }
+        if let value = getAttribute(element, kAXValueAttribute) {
+            node["value"] = "\(value)"
+        }
+        if let desc = getAttribute(element, kAXDescriptionAttribute) as? String, !desc.isEmpty {
+            node["description"] = desc
+        }
+        if let identifier = getAttribute(element, kAXIdentifierAttribute) as? String, !identifier.isEmpty {
+            node["identifier"] = identifier
+        }
+        if let enabled = getAttribute(element, kAXEnabledAttribute) as? Bool {
+            node["enabled"] = enabled
+        }
+        if let focused = getAttribute(element, kAXFocusedAttribute) as? Bool {
+            node["focused"] = focused
+        }
+
+        // Position and size
+        if let posValue = getAttribute(element, kAXPositionAttribute) {
+            var point = CGPoint.zero
+            if AXValueGetValue(posValue as! AXValue, .cgPoint, &point) {
+                node["position"] = ["x": Double(point.x), "y": Double(point.y)]
+            }
+        }
+        if let sizeValue = getAttribute(element, kAXSizeAttribute) {
+            var size = CGSize.zero
+            if AXValueGetValue(sizeValue as! AXValue, .cgSize, &size) {
+                node["size"] = ["width": Double(size.width), "height": Double(size.height)]
+            }
+        }
+
+        // Children (if not at max depth)
+        if depth < maxDepth {
+            if let children = getAttribute(element, kAXChildrenAttribute) as? [AXUIElement] {
+                var childNodes: [[String: Any]] = []
+                for (index, child) in children.enumerated() {
+                    if index > 100 { break } // Safety limit
+                    if let childNode = try? buildTree(element: child, depth: depth + 1, maxDepth: maxDepth) {
+                        childNodes.append(childNode)
+                    }
+                }
+                if !childNodes.isEmpty {
+                    node["children"] = childNodes
+                }
+            }
+        }
+
+        return node
+    }
+
+    // MARK: - Find Element
+
+    func findElement(pid: pid_t, role: String?, title: String?, value: String?,
+                     identifier: String?, exact: Bool) throws -> [String: Any] {
+        let appElement = AXUIElementCreateApplication(pid)
+        guard let result = searchElement(
+            element: appElement, path: [], role: role, title: title,
+            value: value, identifier: identifier, exact: exact
+        ) else {
+            throw BridgeError.notFound("Element not found matching criteria")
+        }
+        return result
+    }
+
+    private func searchElement(element: AXUIElement, path: [Int], role: String?,
+                               title: String?, value: String?, identifier: String?,
+                               exact: Bool) -> [String: Any]? {
+        // Check if this element matches
+        let elementRole = getAttribute(element, kAXRoleAttribute) as? String ?? ""
+        let elementTitle = getAttribute(element, kAXTitleAttribute) as? String ?? ""
+        let elementValue = getAttribute(element, kAXValueAttribute).flatMap { "\($0)" } ?? ""
+        let elementId = getAttribute(element, kAXIdentifierAttribute) as? String ?? ""
+
+        var matches = true
+        if let role = role {
+            matches = matches && matchString(elementRole, role, exact: exact)
+        }
+        if let title = title {
+            matches = matches && matchString(elementTitle, title, exact: exact)
+        }
+        if let value = value {
+            matches = matches && matchString(elementValue, value, exact: exact)
+        }
+        if let identifier = identifier {
+            matches = matches && matchString(elementId, identifier, exact: exact)
+        }
+
+        if matches && (role != nil || title != nil || value != nil || identifier != nil) {
+            var result: [String: Any] = [
+                "role": elementRole,
+                "title": elementTitle,
+                "elementPath": path,
+                "handleId": "ax_\(path.map { String($0) }.joined(separator: "_"))",
+            ]
+            if !elementValue.isEmpty { result["value"] = elementValue }
+            if !elementId.isEmpty { result["identifier"] = elementId }
+
+            // Get position for coordinates
+            if let posValue = getAttribute(element, kAXPositionAttribute) {
+                var point = CGPoint.zero
+                if AXValueGetValue(posValue as! AXValue, .cgPoint, &point) {
+                    if let sizeValue = getAttribute(element, kAXSizeAttribute) {
+                        var size = CGSize.zero
+                        if AXValueGetValue(sizeValue as! AXValue, .cgSize, &size) {
+                            result["bounds"] = [
+                                "x": Double(point.x), "y": Double(point.y),
+                                "width": Double(size.width), "height": Double(size.height)
+                            ]
+                        }
+                    }
+                }
+            }
+
+            return result
+        }
+
+        // Search children
+        if let children = getAttribute(element, kAXChildrenAttribute) as? [AXUIElement] {
+            for (index, child) in children.enumerated() {
+                var childPath = path
+                childPath.append(index)
+                if let found = searchElement(
+                    element: child, path: childPath, role: role, title: title,
+                    value: value, identifier: identifier, exact: exact
+                ) {
+                    return found
+                }
+            }
+        }
+
+        return nil
+    }
+
+    // MARK: - Actions
+
+    func performAction(pid: pid_t, elementPath: [Int], action: String) throws {
+        let element = try resolveElement(pid: pid, path: elementPath)
+        let result = AXUIElementPerformAction(element, action as CFString)
+        if result != .success {
+            throw BridgeError.general("AX action '\(action)' failed with code \(result.rawValue)")
+        }
+    }
+
+    func setElementValue(pid: pid_t, elementPath: [Int], value: String) throws {
+        let element = try resolveElement(pid: pid, path: elementPath)
+        let result = AXUIElementSetAttributeValue(element, kAXValueAttribute as CFString, value as CFTypeRef)
+        if result != .success {
+            // Try focused approach: set focus then type
+            let focusResult = AXUIElementSetAttributeValue(element, kAXFocusedAttribute as CFString, true as CFTypeRef)
+            if focusResult != .success {
+                throw BridgeError.general("Cannot focus element for value set, code \(focusResult.rawValue)")
+            }
+            // Use CG to type the value
+            CoreGraphicsBridge().typeText(text: value)
+        }
+    }
+
+    func getElementValue(pid: pid_t, elementPath: [Int]) throws -> [String: Any] {
+        let element = try resolveElement(pid: pid, path: elementPath)
+        let value = getAttribute(element, kAXValueAttribute)
+        return ["value": value.flatMap { "\($0)" } ?? ""]
+    }
+
+    // MARK: - Menu Click
+
+    func menuClick(pid: pid_t, menuPath: [String]) throws {
+        guard !menuPath.isEmpty else {
+            throw BridgeError.missingParam("menuPath must not be empty")
+        }
+
+        let appElement = AXUIElementCreateApplication(pid)
+        guard let menuBar = getAttribute(appElement, kAXMenuBarAttribute) as AnyObject? else {
+            throw BridgeError.notFound("Menu bar not found")
+        }
+        let menuBarElement = menuBar as! AXUIElement
+
+        var currentElement: AXUIElement = menuBarElement
+
+        for menuItem in menuPath {
+            guard let children = getAttribute(currentElement, kAXChildrenAttribute) as? [AXUIElement] else {
+                throw BridgeError.notFound("No children found in menu for '\(menuItem)'")
+            }
+
+            var found = false
+            for child in children {
+                let title = getAttribute(child, kAXTitleAttribute) as? String ?? ""
+                if title == menuItem {
+                    // Press this menu item to open it (for submenus) or activate it
+                    AXUIElementPerformAction(child, kAXPressAction as CFString)
+                    // Small delay for menu to open
+                    Thread.sleep(forTimeInterval: 0.1)
+
+                    // If there are more items in the path, navigate into the submenu
+                    if let submenu = getAttribute(child, kAXChildrenAttribute) as? [AXUIElement],
+                       let firstChild = submenu.first {
+                        currentElement = firstChild
+                    }
+
+                    found = true
+                    break
+                }
+            }
+
+            if !found {
+                throw BridgeError.notFound("Menu item '\(menuItem)' not found")
+            }
+        }
+    }
+
+    // MARK: - Helpers
+
+    private func resolveElement(pid: pid_t, path: [Int]) throws -> AXUIElement {
+        var current = AXUIElementCreateApplication(pid) as AXUIElement
+        for index in path {
+            guard let children = getAttribute(current, kAXChildrenAttribute) as? [AXUIElement] else {
+                throw BridgeError.notFound("No children at path index \(index)")
+            }
+            guard index < children.count else {
+                throw BridgeError.notFound("Index \(index) out of bounds (count: \(children.count))")
+            }
+            current = children[index]
+        }
+        return current
+    }
+
+    private func getAttribute(_ element: AXUIElement, _ attribute: String) -> AnyObject? {
+        var value: AnyObject?
+        let result = AXUIElementCopyAttributeValue(element, attribute as CFString, &value)
+        return result == .success ? value : nil
+    }
+
+    private func matchString(_ haystack: String, _ needle: String, exact: Bool) -> Bool {
+        if exact {
+            return haystack == needle
+        }
+        return haystack.localizedCaseInsensitiveContains(needle)
+    }
+}

package/native/macos-bridge/Sources/AppManagement.swift

@@ -0,0 +1,129 @@
+import AppKit
+import Foundation
+
+class AppManagement {
+
+    func launchApp(bundleId: String) throws -> [String: Any] {
+        let workspace = NSWorkspace.shared
+
+        guard let url = workspace.urlForApplication(withBundleIdentifier: bundleId) else {
+            throw BridgeError.notFound("Application with bundle ID '\(bundleId)' not found")
+        }
+
+        let config = NSWorkspace.OpenConfiguration()
+        config.activates = true
+
+        let semaphore = DispatchSemaphore(value: 0)
+        var launchedApp: NSRunningApplication?
+        var launchError: Error?
+
+        workspace.openApplication(at: url, configuration: config) { app, error in
+            launchedApp = app
+            launchError = error
+            semaphore.signal()
+        }
+
+        semaphore.wait()
+
+        if let error = launchError {
+            throw BridgeError.general("Failed to launch '\(bundleId)': \(error.localizedDescription)")
+        }
+
+        guard let app = launchedApp else {
+            throw BridgeError.general("Launch returned nil for '\(bundleId)'")
+        }
+
+        // Wait for the app to finish launching (up to 10 seconds)
+        let deadline = Date().addingTimeInterval(10)
+        while !app.isFinishedLaunching && Date() < deadline {
+            Thread.sleep(forTimeInterval: 0.1)
+        }
+
+        return [
+            "bundleId": bundleId,
+            "appName": app.localizedName ?? bundleId,
+            "pid": Int(app.processIdentifier),
+            "windowTitle": "",
+        ]
+    }
+
+    func focusApp(bundleId: String) throws {
+        guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: bundleId).first else {
+            throw BridgeError.notFound("No running application with bundle ID '\(bundleId)'")
+        }
+        app.activate()
+    }
+
+    func listRunningApps() -> [[String: Any]] {
+        let workspace = NSWorkspace.shared
+        return workspace.runningApplications
+            .filter { $0.activationPolicy == .regular }
+            .map { app in
+                [
+                    "bundleId": app.bundleIdentifier ?? "unknown",
+                    "name": app.localizedName ?? "Unknown",
+                    "pid": Int(app.processIdentifier),
+                    "isActive": app.isActive,
+                ] as [String: Any]
+            }
+    }
+
+    func listWindows() -> [[String: Any]] {
+        guard let windowList = CGWindowListCopyWindowInfo([.optionOnScreenOnly, .excludeDesktopElements], kCGNullWindowID) as? [[String: Any]] else {
+            return []
+        }
+
+        return windowList.compactMap { window -> [String: Any]? in
+            guard let windowId = window[kCGWindowNumber as String] as? Int,
+                  let ownerPid = window[kCGWindowOwnerPID as String] as? Int,
+                  let boundsRaw = window[kCGWindowBounds as String],
+                  let layer = window[kCGWindowLayer as String] as? Int,
+                  layer == 0 else { // Only normal windows (layer 0)
+                return nil
+            }
+
+            // Parse bounds — CGWindowListCopyWindowInfo returns a dict with CGFloat values
+            var rect = CGRect.zero
+            if let boundsDict = boundsRaw as? [String: Any] {
+                let bx = (boundsDict["X"] as? NSNumber)?.doubleValue ?? 0
+                let by = (boundsDict["Y"] as? NSNumber)?.doubleValue ?? 0
+                let bw = (boundsDict["Width"] as? NSNumber)?.doubleValue ?? 0
+                let bh = (boundsDict["Height"] as? NSNumber)?.doubleValue ?? 0
+                rect = CGRect(x: bx, y: by, width: bw, height: bh)
+            }
+
+            let title = window[kCGWindowName as String] as? String ?? ""
+            let ownerName = window[kCGWindowOwnerName as String] as? String ?? ""
+            let isOnScreen = window[kCGWindowIsOnscreen as String] as? Bool ?? true
+
+            // Look up bundle ID from PID
+            let bundleId = NSRunningApplication(processIdentifier: pid_t(ownerPid))?.bundleIdentifier ?? ""
+
+            return [
+                "windowId": windowId,
+                "title": title,
+                "bundleId": bundleId,
+                "pid": ownerPid,
+                "appName": ownerName,
+                "bounds": [
+                    "x": Double(rect.origin.x),
+                    "y": Double(rect.origin.y),
+                    "width": Double(rect.size.width),
+                    "height": Double(rect.size.height),
+                ] as [String: Double],
+                "isOnScreen": isOnScreen,
+            ]
+        }
+    }
+
+    func frontmostApp() -> [String: Any] {
+        guard let app = NSWorkspace.shared.frontmostApplication else {
+            return ["error": "No frontmost application"]
+        }
+        return [
+            "bundleId": app.bundleIdentifier ?? "unknown",
+            "name": app.localizedName ?? "Unknown",
+            "pid": Int(app.processIdentifier),
+        ]
+    }
+}

package/native/macos-bridge/Sources/CoreGraphicsBridge.swift

@@ -0,0 +1,242 @@
+import CoreGraphics
+import Foundation
+import AppKit
+
+class CoreGraphicsBridge {
+
+    // MARK: - Mouse Events
+
+    func mouseClick(x: Double, y: Double, button: String, clickCount: Int) {
+        let point = CGPoint(x: x, y: y)
+
+        let (downType, upType) = mouseButtonTypes(button: button)
+
+        for _ in 0..<clickCount {
+            if let downEvent = CGEvent(mouseEventSource: nil, mouseType: downType, mouseCursorPosition: point, mouseButton: mouseButton(button)) {
+                downEvent.setIntegerValueField(.mouseEventClickState, value: Int64(clickCount))
+                downEvent.post(tap: .cghidEventTap)
+            }
+            usleep(50_000) // 50ms between down and up
+            if let upEvent = CGEvent(mouseEventSource: nil, mouseType: upType, mouseCursorPosition: point, mouseButton: mouseButton(button)) {
+                upEvent.setIntegerValueField(.mouseEventClickState, value: Int64(clickCount))
+                upEvent.post(tap: .cghidEventTap)
+            }
+        }
+    }
+
+    func mouseMove(x: Double, y: Double) {
+        let point = CGPoint(x: x, y: y)
+        if let event = CGEvent(mouseEventSource: nil, mouseType: .mouseMoved, mouseCursorPosition: point, mouseButton: .left) {
+            event.post(tap: .cghidEventTap)
+        }
+    }
+
+    func mouseDrag(fromX: Double, fromY: Double, toX: Double, toY: Double) {
+        let from = CGPoint(x: fromX, y: fromY)
+        let to = CGPoint(x: toX, y: toY)
+
+        // Mouse down at source
+        if let downEvent = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: from, mouseButton: .left) {
+            downEvent.post(tap: .cghidEventTap)
+        }
+        usleep(100_000) // 100ms
+
+        // Interpolate drag points
+        let steps = 10
+        for i in 1...steps {
+            let t = Double(i) / Double(steps)
+            let x = fromX + (toX - fromX) * t
+            let y = fromY + (toY - fromY) * t
+            let point = CGPoint(x: x, y: y)
+            if let dragEvent = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDragged, mouseCursorPosition: point, mouseButton: .left) {
+                dragEvent.post(tap: .cghidEventTap)
+            }
+            usleep(20_000) // 20ms between steps
+        }
+
+        // Mouse up at destination
+        if let upEvent = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: to, mouseButton: .left) {
+            upEvent.post(tap: .cghidEventTap)
+        }
+    }
+
+    /// Fast flick gesture — 3 steps, 5ms gaps. Triggers iOS swipe gestures.
+    func mouseFlick(fromX: Double, fromY: Double, toX: Double, toY: Double) {
+        let from = CGPoint(x: fromX, y: fromY)
+        let to = CGPoint(x: toX, y: toY)
+
+        if let downEvent = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDown, mouseCursorPosition: from, mouseButton: .left) {
+            downEvent.post(tap: .cghidEventTap)
+        }
+        usleep(10_000) // 10ms
+
+        // Just 3 fast steps
+        for i in 1...3 {
+            let t = Double(i) / 3.0
+            let point = CGPoint(x: fromX + (toX - fromX) * t, y: fromY + (toY - fromY) * t)
+            if let dragEvent = CGEvent(mouseEventSource: nil, mouseType: .leftMouseDragged, mouseCursorPosition: point, mouseButton: .left) {
+                dragEvent.post(tap: .cghidEventTap)
+            }
+            usleep(5_000) // 5ms
+        }
+
+        if let upEvent = CGEvent(mouseEventSource: nil, mouseType: .leftMouseUp, mouseCursorPosition: to, mouseButton: .left) {
+            upEvent.post(tap: .cghidEventTap)
+        }
+    }
+
+    func scroll(x: Double, y: Double, deltaX: Int, deltaY: Int) {
+        // Move mouse to position first
+        mouseMove(x: x, y: y)
+        usleep(50_000)
+
+        if let scrollEvent = CGEvent(scrollWheelEvent2Source: nil, units: .line, wheelCount: 2, wheel1: Int32(deltaY), wheel2: Int32(deltaX), wheel3: 0) {
+            scrollEvent.post(tap: .cghidEventTap)
+        }
+    }
+
+    // MARK: - Keyboard Events
+
+    func keyCombo(keys: [String]) {
+        var modifiers: CGEventFlags = []
+        var keyCode: CGKeyCode?
+
+        for key in keys {
+            let lower = key.lowercased()
+            switch lower {
+            case "cmd", "command", "meta":
+                modifiers.insert(.maskCommand)
+            case "shift":
+                modifiers.insert(.maskShift)
+            case "alt", "option":
+                modifiers.insert(.maskAlternate)
+            case "ctrl", "control":
+                modifiers.insert(.maskControl)
+            case "fn":
+                modifiers.insert(.maskSecondaryFn)
+            default:
+                keyCode = keyCodeForString(lower)
+            }
+        }
+
+        guard let code = keyCode else { return }
+
+        if let downEvent = CGEvent(keyboardEventSource: nil, virtualKey: code, keyDown: true) {
+            downEvent.flags = modifiers
+            downEvent.post(tap: .cghidEventTap)
+        }
+        usleep(50_000)
+        if let upEvent = CGEvent(keyboardEventSource: nil, virtualKey: code, keyDown: false) {
+            upEvent.flags = modifiers
+            upEvent.post(tap: .cghidEventTap)
+        }
+    }
+
+    func typeText(text: String) {
+        for char in text {
+            let str = String(char)
+            if let event = CGEvent(keyboardEventSource: nil, virtualKey: 0, keyDown: true) {
+                let chars = Array(str.utf16)
+                event.keyboardSetUnicodeString(stringLength: chars.count, unicodeString: chars)
+                event.post(tap: .cghidEventTap)
+            }
+            usleep(20_000) // 20ms between characters
+            if let event = CGEvent(keyboardEventSource: nil, virtualKey: 0, keyDown: false) {
+                event.post(tap: .cghidEventTap)
+            }
+            usleep(10_000)
+        }
+    }
+
+    // MARK: - Screenshots
+
+    func captureScreen(region: [String: Double]?) throws -> [String: Any] {
+        let rect: CGRect
+        if let region = region {
+            rect = CGRect(
+                x: region["x"] ?? 0,
+                y: region["y"] ?? 0,
+                width: region["width"] ?? 0,
+                height: region["height"] ?? 0
+            )
+        } else {
+            rect = CGRect.infinite
+        }
+
+        guard let image = CGWindowListCreateImage(rect, .optionOnScreenOnly, kCGNullWindowID, .bestResolution) else {
+            throw BridgeError.general("Failed to capture screen")
+        }
+
+        let path = try saveImage(image)
+        return ["path": path, "width": image.width, "height": image.height]
+    }
+
+    func captureWindow(windowId: Int) throws -> [String: Any] {
+        guard let image = CGWindowListCreateImage(
+            .null, .optionIncludingWindow, CGWindowID(windowId), .bestResolution
+        ) else {
+            throw BridgeError.general("Failed to capture window \(windowId)")
+        }
+
+        let path = try saveImage(image)
+        return ["path": path, "width": image.width, "height": image.height]
+    }
+
+    private func saveImage(_ image: CGImage) throws -> String {
+        let tempDir = FileManager.default.temporaryDirectory
+        let fileName = "bridge_screenshot_\(UUID().uuidString).png"
+        let fileURL = tempDir.appendingPathComponent(fileName)
+
+        guard let dest = CGImageDestinationCreateWithURL(fileURL as CFURL, "public.png" as CFString, 1, nil) else {
+            throw BridgeError.general("Failed to create image destination")
+        }
+        CGImageDestinationAddImage(dest, image, nil)
+        guard CGImageDestinationFinalize(dest) else {
+            throw BridgeError.general("Failed to write screenshot")
+        }
+
+        return fileURL.path
+    }
+
+    // MARK: - Key Code Mapping
+
+    private func mouseButtonTypes(button: String) -> (CGEventType, CGEventType) {
+        switch button.lowercased() {
+        case "right":
+            return (.rightMouseDown, .rightMouseUp)
+        case "other", "middle":
+            return (.otherMouseDown, .otherMouseUp)
+        default:
+            return (.leftMouseDown, .leftMouseUp)
+        }
+    }
+
+    private func mouseButton(_ button: String) -> CGMouseButton {
+        switch button.lowercased() {
+        case "right": return .right
+        case "other", "middle": return .center
+        default: return .left
+        }
+    }
+
+    private func keyCodeForString(_ key: String) -> CGKeyCode? {
+        let keyMap: [String: CGKeyCode] = [
+            "a": 0, "b": 11, "c": 8, "d": 2, "e": 14, "f": 3, "g": 5,
+            "h": 4, "i": 34, "j": 38, "k": 40, "l": 37, "m": 46, "n": 45,
+            "o": 31, "p": 35, "q": 12, "r": 15, "s": 1, "t": 17, "u": 32,
+            "v": 9, "w": 13, "x": 7, "y": 16, "z": 6,
+            "0": 29, "1": 18, "2": 19, "3": 20, "4": 21, "5": 23,
+            "6": 22, "7": 26, "8": 28, "9": 25,
+            "return": 36, "enter": 36, "tab": 48, "space": 49,
+            "delete": 51, "backspace": 51, "escape": 53, "esc": 53,
+            "up": 126, "down": 125, "left": 123, "right": 124,
+            "f1": 122, "f2": 120, "f3": 99, "f4": 118, "f5": 96,
+            "f6": 97, "f7": 98, "f8": 100, "f9": 101, "f10": 109,
+            "f11": 103, "f12": 111,
+            "home": 115, "end": 119, "pageup": 116, "pagedown": 121,
+            "-": 27, "=": 24, "[": 33, "]": 30, "\\": 42,
+            ";": 41, "'": 39, ",": 43, ".": 47, "/": 44, "`": 50,
+        ]
+        return keyMap[key]
+    }
+}