@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/computer-access/computer/linux-portal.js

@@ -0,0 +1,268 @@
+/** Persistent Wayland remote-desktop portal session. No compositor-specific input shortcuts. */
+export const LINUX_PORTAL_SOURCE = String.raw `
+class PortalDesktop:
+    BUS = 'org.freedesktop.portal.Desktop'
+    PATH = '/org/freedesktop/portal/desktop'
+    REMOTE = 'org.freedesktop.portal.RemoteDesktop'
+    SCREEN = 'org.freedesktop.portal.ScreenCast'
+
+    def __init__(self):
+        import gi
+        from gi.repository import Gio, GLib
+        self.Gio, self.GLib = (Gio, GLib)
+        self.bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
+        self.session = None
+        self.fd = None
+        self.pipeline = None
+        self.sink = None
+        self.stream = None
+        self.geometry = {'x': 0, 'y': 0, 'width': 1, 'height': 1}
+        self.binding = 'wayland:' + str(uuid.uuid4())
+        self.devices = 0
+        self.closed = False
+        self.Gst = None
+        self.remote_available = False
+        self.capture_available = False
+        self.capture_dimensions = None
+        self.capture_layout = None
+        self.invalidated_reason = None
+        self.subscriptions = []
+        try:
+            devices = self.call('org.freedesktop.DBus.Properties', 'Get', GLib.Variant('(ss)', (self.REMOTE, 'AvailableDeviceTypes'))).unpack()[0]
+            self.remote_available = bool(devices & 3)
+        except Exception:
+            pass
+        try:
+            gi.require_version('Gst', '1.0')
+            gi.require_version('GstVideo', '1.0')
+            from gi.repository import Gst, GstVideo
+            self.GstVideo = GstVideo
+            Gst.init(None)
+            if all((Gst.ElementFactory.find(name) for name in ['pipewiresrc', 'videoconvert', 'appsink'])):
+                self.Gst = Gst
+            sources = self.call('org.freedesktop.DBus.Properties', 'Get', GLib.Variant('(ss)', (self.SCREEN, 'AvailableSourceTypes'))).unpack()[0]
+            self.capture_available = bool(self.Gst and sources & 1)
+        except Exception:
+            pass
+
+    def call(self, interface, method, parameters, path=None):
+        return self.bus.call_sync(self.BUS, path or self.PATH, interface, method, parameters, None, self.Gio.DBusCallFlags.NONE, 5000, None)
+
+    def request(self, interface, method, signature, args, options, cancel):
+        token = 'abot_' + uuid.uuid4().hex
+        options = dict(options)
+        options['handle_token'] = self.GLib.Variant('s', token)
+        sender = self.bus.get_unique_name().lstrip(':').replace('.', '_')
+        path = '/org/freedesktop/portal/desktop/request/' + sender + '/' + token
+        ready = threading.Event()
+        result = {}
+
+        def received(connection, sender, path, interface, signal, parameters, data):
+            response, values = parameters.unpack()
+            result.update({'response': response, 'values': values})
+            ready.set()
+        subscription = self.bus.signal_subscribe(self.BUS, 'org.freedesktop.portal.Request', 'Response', path, None, self.Gio.DBusSignalFlags.NONE, received, None)
+        try:
+            self.call(interface, method, self.GLib.Variant(signature, tuple(args) + (options,)))
+            deadline = time.monotonic() + 30
+            while not ready.wait(0.05):
+                if cancel.is_set() or time.monotonic() > deadline:
+                    try:
+                        self.call('org.freedesktop.portal.Request', 'Close', None, path)
+                    except Exception:
+                        pass
+                    raise NativeFailure('linux_portal_request_cancelled')
+            if result['response'] != 0:
+                raise NativeFailure('linux_portal_permission_denied')
+            return result['values']
+        finally:
+            self.bus.signal_unsubscribe(subscription)
+
+    def ensure_session(self, cancel):
+        if self.closed:
+            raise NativeFailure('linux_portal_session_closed')
+        if self.session:
+            return
+        if not self.capture_available:
+            raise NativeFailure('linux_pipewire_capture_dependencies_unavailable')
+        session_interface = self.REMOTE if self.remote_available else self.SCREEN
+        session_token = 'abot_' + uuid.uuid4().hex
+        created = self.request(session_interface, 'CreateSession', '(a{sv})', [], {'session_handle_token': self.GLib.Variant('s', session_token)}, cancel)
+        self.session = created['session_handle']
+
+        def session_closed(*args):
+            self.closed = True
+        self.subscriptions.append(self.bus.signal_subscribe(self.BUS, 'org.freedesktop.portal.Session', 'Closed', self.session, None, self.Gio.DBusSignalFlags.NONE, session_closed, None))
+        try:
+            if self.remote_available:
+                self.request(self.REMOTE, 'SelectDevices', '(oa{sv})', [self.session], {'types': self.GLib.Variant('u', 3)}, cancel)
+            self.request(self.SCREEN, 'SelectSources', '(oa{sv})', [self.session], {'types': self.GLib.Variant('u', 1), 'multiple': self.GLib.Variant('b', False)}, cancel)
+            started = self.request(session_interface, 'Start', '(osa{sv})', [self.session, ''], {}, cancel)
+            self.devices = started.get('devices', 0)
+            streams = started.get('streams', [])
+            if len(streams) != 1:
+                raise NativeFailure('linux_portal_single_monitor_required')
+            self.stream, properties = streams[0]
+            size = properties.get('size')
+            if not size or size[0] <= 0 or size[1] <= 0:
+                raise NativeFailure('linux_portal_geometry_unavailable')
+            self.geometry = {'x': 0, 'y': 0, 'width': size[0], 'height': size[1]}
+            returned, fds = self.bus.call_with_unix_fd_list_sync(self.BUS, self.PATH, self.SCREEN, 'OpenPipeWireRemote', self.GLib.Variant('(oa{sv})', (self.session, {})), None, self.Gio.DBusCallFlags.NONE, 5000, None, None)
+            self.fd = fds.get(returned.unpack()[0])
+            self.pipeline = self.Gst.Pipeline.new('abot-capture')
+            source = self.Gst.ElementFactory.make('pipewiresrc', 'source')
+            source.set_property('fd', self.fd)
+            self.binding = bind_portal_capture_source(self, source, properties)
+            convert = self.Gst.ElementFactory.make('videoconvert', 'convert')
+            self.sink = self.Gst.ElementFactory.make('appsink', 'sink')
+            self.sink.set_property('caps', self.Gst.Caps.from_string('video/x-raw,format=RGB'))
+            self.sink.set_property('max-buffers', 1)
+            self.sink.set_property('drop', True)
+            self.sink.set_property('sync', False)
+            for element in [source, convert, self.sink]:
+                self.pipeline.add(element)
+            if not source.link(convert) or not convert.link(self.sink):
+                raise NativeFailure('linux_pipewire_pipeline_failed')
+            self.pipeline.set_state(self.Gst.State.PLAYING)
+        except Exception:
+            self.close()
+            raise
+
+    def inspect(self):
+        self.validate_stream_dimensions()
+        active = not self.closed and (self.remote_available or self.capture_available)
+        capture_reason = 'linux_portal_permission_required' if self.capture_available else 'linux_pipewire_capture_dependencies_unavailable'
+        input_reason = 'linux_portal_permission_required' if self.remote_available else 'linux_remote_desktop_portal_unavailable'
+        has_granted_session = bool(self.session and not self.closed)
+        result = desktop_result('linux', self.binding, self.geometry, active, cap(self.capture_available and has_granted_session, capture_reason), cap(self.remote_available and has_granted_session, input_reason), cap(False, 'wayland_window_inventory_unavailable', False), 'observed_surface')
+        result['desktop']['coordinateSpace'] = 'logical_points'
+        if self.closed:
+            result['desktop']['reason'] = self.invalidated_reason or 'linux_portal_session_closed'
+        if self.session:
+            denied_input = 'linux_portal_input_permission_partial' if self.remote_available else 'linux_remote_desktop_portal_unavailable'
+            result['desktop']['capabilities']['input'] = cap(has_granted_session and self.devices & 3 == 3, self.invalidated_reason or denied_input)
+        return result
+
+    def source_binding(self):
+        self.validate_stream_dimensions()
+        if self.closed:
+            raise NativeFailure(self.invalidated_reason or 'linux_portal_session_closed')
+        return self.binding
+
+    def validate_stream_dimensions(self):
+        require_portal_stream_alive(self)
+        if not getattr(self, 'sink', None):
+            return
+        pad = self.sink.get_static_pad('sink')
+        caps = pad.get_current_caps() if pad else None
+        if not caps:
+            return
+        require_portal_frame_layout(self, caps)
+        structure = caps.get_structure(0)
+        dimensions = (structure.get_value('width'), structure.get_value('height'))
+        if self.capture_dimensions is not None and self.capture_dimensions != dimensions:
+            self.closed = True
+            self.invalidated_reason = 'linux_portal_geometry_changed'
+
+    def capture(self, region):
+        self.validate_stream_dimensions()
+        if self.closed or not self.sink:
+            raise NativeFailure('linux_portal_session_unavailable')
+        sample = fresh_portal_sample(self)
+        require_portal_stream_alive(self)
+        require_portal_frame_layout(self, sample.get_caps())
+        if self.closed:
+            raise NativeFailure(self.invalidated_reason or 'linux_portal_session_closed')
+        structure = sample.get_caps().get_structure(0)
+        width, height = (structure.get_value('width'), structure.get_value('height'))
+        dimensions = (width, height)
+        if self.capture_dimensions is not None and dimensions != self.capture_dimensions:
+            self.closed = True
+            self.invalidated_reason = 'linux_portal_geometry_changed'
+            raise NativeFailure(self.invalidated_reason)
+        self.capture_dimensions = dimensions
+        self.capture_layout = portal_frame_layout(sample.get_caps())
+        buffer = sample.get_buffer()
+        success, mapped = buffer.map(self.Gst.MapFlags.READ)
+        if not success:
+            raise NativeFailure('linux_pipewire_frame_unavailable')
+        try:
+            info = self.GstVideo.VideoInfo.new_from_caps(sample.get_caps())
+            if info is None:
+                raise NativeFailure('linux_pipewire_pixel_format_unsupported')
+            sx = width / self.geometry['width']
+            sy = height / self.geometry['height']
+            x, y = (round(region['x'] * sx), round(region['y'] * sy))
+            w, h = (round(region['width'] * sx), round(region['height'] * sy))
+            scale = min(1.0, 2048 / max(w, h))
+            output_width, output_height = max(1, round(w * scale)), max(1, round(h * scale))
+            rows = []
+            for output_row in range(output_height):
+                row = y + min(h - 1, int(output_row / scale))
+                offset = info.offset[0] + row * info.stride[0] + x * 3
+                line = bytearray([0])
+                for output_column in range(output_width):
+                    column = min(w - 1, int(output_column / scale))
+                    line.extend(mapped.data[offset + column * 3:offset + column * 3 + 3])
+                rows.append(bytes(line))
+            return (encode_png(output_width, output_height, b''.join(rows)), output_width, output_height)
+        finally:
+            buffer.unmap(mapped)
+
+    def notify(self, method, signature, values):
+        self.validate_stream_dimensions()
+        if self.closed or not self.session:
+            raise NativeFailure('linux_portal_session_closed')
+        self.call(self.REMOTE, method, self.GLib.Variant(signature, (self.session, {}) + tuple(values)))
+
+    def pointer(self, point):
+        self.notify('NotifyPointerMotionAbsolute', '(oa{sv}udd)', [self.stream, float(point['x']), float(point['y'])])
+
+    def button(self, button, down):
+        self.notify('NotifyPointerButton', '(oa{sv}iu)', [{1: 272, 2: 274, 3: 273}[button], int(down)])
+
+    def scroll(self, x, y):
+        if x % 120 or y % 120:
+            raise NativeFailure('linux_wayland_scroll_fraction_unsupported')
+        if x:
+            self.notify('NotifyPointerAxisDiscrete', '(oa{sv}ui)', [1, int(x / 120)])
+        if y:
+            self.notify('NotifyPointerAxisDiscrete', '(oa{sv}ui)', [0, int(y / 120)])
+
+    def key_event(self, key, down):
+        self.notify('NotifyKeyboardKeysym', '(oa{sv}iu)', [key, int(down)])
+
+    def key(self, name):
+        aliases = {'Ctrl': 65507, 'Control': 65507, 'Alt': 65513, 'Shift': 65505, 'Meta': 65515, 'Super': 65515, 'Command': 65515, 'Enter': 65293, 'Escape': 65307, 'Esc': 65307, 'Tab': 65289, 'Backspace': 65288, 'Delete': 65535, 'Space': 32, 'ArrowLeft': 65361, 'ArrowUp': 65362, 'ArrowRight': 65363, 'ArrowDown': 65364, 'Home': 65360, 'End': 65367, 'PageUp': 65365, 'PageDown': 65366}
+        if name in aliases:
+            return (aliases[name], False)
+        if len(name) == 1:
+            return (ord(name) if ord(name) <= 255 else 16777216 | ord(name), False)
+        if name.startswith('F') and name[1:].isdigit() and (1 <= int(name[1:]) <= 24):
+            return (65469 + int(name[1:]), False)
+        raise NativeFailure('linux_key_unmapped')
+
+    def text_keys(self, text):
+        return [self.key({'\n': 'Enter', '\t': 'Tab'}.get(char, char)) for char in text]
+
+    def focus(self, binding):
+        raise NativeFailure('wayland_window_focus_unavailable')
+
+    def close(self):
+        self.closed = True
+        if self.pipeline:
+            self.pipeline.set_state(self.Gst.State.NULL)
+            self.pipeline = None
+        if self.fd is not None:
+            os.close(self.fd)
+            self.fd = None
+        if self.session:
+            try:
+                self.call('org.freedesktop.portal.Session', 'Close', None, self.session)
+            except Exception:
+                pass
+        for subscription in self.subscriptions:
+            self.bus.signal_unsubscribe(subscription)
+        self.subscriptions = []
+        self.session = None
+`;

package/dist/src/computer-access/computer/linux-topology.d.ts

@@ -0,0 +1,2 @@
+/** Native capture-source identity; display union bounds alone cannot identify a layout. */
+export declare const LINUX_TOPOLOGY_SOURCE: string;

package/dist/src/computer-access/computer/linux-topology.js

@@ -0,0 +1,92 @@
+/** Native capture-source identity; display union bounds alone cannot identify a layout. */
+export const LINUX_TOPOLOGY_SOURCE = String.raw `
+import hashlib
+
+def source_fingerprint(records):
+    canonical = sorted(json.dumps(record, sort_keys=True, separators=(',', ':')) for record in records)
+    return hashlib.sha256(json.dumps(canonical, separators=(',', ':')).encode()).hexdigest()
+
+class RandrResources(ctypes.Structure):
+    _fields_ = [('timestamp', ctypes.c_ulong), ('configTimestamp', ctypes.c_ulong), ('ncrtc', ctypes.c_int), ('crtcs', ctypes.POINTER(ctypes.c_ulong)), ('noutput', ctypes.c_int), ('outputs', ctypes.POINTER(ctypes.c_ulong)), ('nmode', ctypes.c_int), ('modes', ctypes.c_void_p)]
+
+class RandrCrtc(ctypes.Structure):
+    _fields_ = [('timestamp', ctypes.c_ulong), ('x', ctypes.c_int), ('y', ctypes.c_int), ('width', ctypes.c_uint), ('height', ctypes.c_uint), ('mode', ctypes.c_ulong), ('rotation', ctypes.c_ushort), ('noutput', ctypes.c_int), ('outputs', ctypes.POINTER(ctypes.c_ulong)), ('rotations', ctypes.c_ushort), ('npossible', ctypes.c_int), ('possible', ctypes.POINTER(ctypes.c_ulong))]
+
+class RandrTransform(ctypes.Structure):
+    _fields_ = [('pending', ctypes.c_int32 * 9), ('pendingFilter', ctypes.c_void_p), ('pendingCount', ctypes.c_int), ('pendingParams', ctypes.c_void_p), ('current', ctypes.c_int32 * 9), ('currentFilter', ctypes.c_void_p), ('currentCount', ctypes.c_int), ('currentParams', ctypes.c_void_p)]
+
+class X11Topology:
+    def __init__(self, desktop):
+        self.desktop = desktop
+        try:
+            self.r = ctypes.CDLL('libXrandr.so.2')
+            signatures = {
+                'XRRQueryVersion': ([ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)], ctypes.c_int),
+                'XRRGetScreenResourcesCurrent': ([ctypes.c_void_p, ctypes.c_ulong], ctypes.POINTER(RandrResources)),
+                'XRRFreeScreenResources': ([ctypes.POINTER(RandrResources)], None),
+                'XRRGetCrtcInfo': ([ctypes.c_void_p, ctypes.POINTER(RandrResources), ctypes.c_ulong], ctypes.POINTER(RandrCrtc)),
+                'XRRFreeCrtcInfo': ([ctypes.POINTER(RandrCrtc)], None),
+                'XRRGetCrtcTransform': ([ctypes.c_void_p, ctypes.c_ulong, ctypes.POINTER(ctypes.POINTER(RandrTransform))], ctypes.c_int),
+            }
+            for name, (args, result) in signatures.items():
+                function = getattr(self.r, name)
+                function.argtypes, function.restype = args, result
+            major, minor = ctypes.c_int(), ctypes.c_int()
+            if not self.r.XRRQueryVersion(desktop.display, ctypes.byref(major), ctypes.byref(minor)):
+                raise NativeFailure('linux_randr_topology_unavailable')
+            if (major.value, minor.value) < (1, 3):
+                raise NativeFailure('linux_randr13_required')
+        except (OSError, AttributeError):
+            raise NativeFailure('linux_randr_topology_unavailable')
+
+    def resources(self):
+        resources = self.r.XRRGetScreenResourcesCurrent(self.desktop.display, self.desktop.root)
+        if not resources:
+            raise NativeFailure('linux_randr_topology_unavailable')
+        return resources
+
+    def crtc_record(self, resources, identifier):
+        pointer = self.r.XRRGetCrtcInfo(self.desktop.display, resources, identifier)
+        if not pointer:
+            raise NativeFailure('linux_randr_topology_unavailable')
+        try:
+            info = pointer.contents
+            if info.mode == 0:
+                return None
+            if not 1 <= info.noutput <= 256:
+                raise NativeFailure('linux_randr_topology_unavailable')
+            transform = ctypes.POINTER(RandrTransform)()
+            if not self.r.XRRGetCrtcTransform(self.desktop.display, identifier, ctypes.byref(transform)) or not transform:
+                raise NativeFailure('linux_randr_transform_unavailable')
+            try:
+                matrix = list(transform.contents.current)
+            finally:
+                self.desktop.x.XFree(transform)
+            return {'crtc': identifier, 'outputs': sorted(info.outputs[:info.noutput]), 'rect': [info.x, info.y, info.width, info.height], 'mode': info.mode, 'rotation': info.rotation, 'transform': matrix}
+        finally:
+            self.r.XRRFreeCrtcInfo(pointer)
+
+    def fingerprint(self):
+        resources = self.resources()
+        try:
+            info = resources.contents
+            epoch = (info.timestamp, info.configTimestamp)
+            if not 1 <= info.ncrtc <= 256:
+                raise NativeFailure('linux_randr_topology_unavailable')
+            records = []
+            for identifier in info.crtcs[:info.ncrtc]:
+                record = self.crtc_record(resources, identifier)
+                if record is not None:
+                    records.append(record)
+            if not records:
+                raise NativeFailure('linux_randr_topology_unavailable')
+            current = self.resources()
+            try:
+                if epoch != (current.contents.timestamp, current.contents.configTimestamp):
+                    raise NativeFailure('computer_topology_changed')
+            finally:
+                self.r.XRRFreeScreenResources(current)
+            return source_fingerprint([{'epoch': epoch}] + records)
+        finally:
+            self.r.XRRFreeScreenResources(resources)
+`;

package/dist/src/computer-access/computer/linux-x11.d.ts

@@ -0,0 +1,2 @@
+/** X11 server APIs; screenshots never leave memory. All input is XTEST, never a shell command. */
+export declare const LINUX_X11_SOURCE: string;

package/dist/src/computer-access/computer/linux-x11.js

@@ -0,0 +1,217 @@
+/** X11 server APIs; screenshots never leave memory. All input is XTEST, never a shell command. */
+export const LINUX_X11_SOURCE = String.raw `
+class XImage(ctypes.Structure):
+    _fields_ = [('width', ctypes.c_int), ('height', ctypes.c_int), ('xoffset', ctypes.c_int), ('format', ctypes.c_int), ('data', ctypes.c_void_p), ('byte_order', ctypes.c_int), ('bitmap_unit', ctypes.c_int), ('bitmap_bit_order', ctypes.c_int), ('bitmap_pad', ctypes.c_int), ('depth', ctypes.c_int), ('bytes_per_line', ctypes.c_int), ('bits_per_pixel', ctypes.c_int), ('red_mask', ctypes.c_ulong), ('green_mask', ctypes.c_ulong), ('blue_mask', ctypes.c_ulong)]
+
+class X11Desktop:
+
+    def __init__(self):
+        self.x = ctypes.CDLL('libX11.so.6')
+        self.t = None
+        signatures = {'XOpenDisplay': ([ctypes.c_char_p], ctypes.c_void_p), 'XDefaultRootWindow': ([ctypes.c_void_p], ctypes.c_ulong), 'XInternAtom': ([ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int], ctypes.c_ulong), 'XGetWindowProperty': ([ctypes.c_void_p, ctypes.c_ulong, ctypes.c_ulong, ctypes.c_long, ctypes.c_long, ctypes.c_int, ctypes.c_ulong, ctypes.POINTER(ctypes.c_ulong), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_ulong), ctypes.POINTER(ctypes.c_ulong), ctypes.POINTER(ctypes.c_void_p)], ctypes.c_int), 'XGetGeometry': ([ctypes.c_void_p, ctypes.c_ulong, ctypes.POINTER(ctypes.c_ulong), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint), ctypes.POINTER(ctypes.c_uint)], ctypes.c_int), 'XTranslateCoordinates': ([ctypes.c_void_p, ctypes.c_ulong, ctypes.c_ulong, ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_ulong)], ctypes.c_int), 'XGetImage': ([ctypes.c_void_p, ctypes.c_ulong, ctypes.c_int, ctypes.c_int, ctypes.c_uint, ctypes.c_uint, ctypes.c_ulong, ctypes.c_int], ctypes.POINTER(XImage)), 'XDestroyImage': ([ctypes.POINTER(XImage)], ctypes.c_int), 'XFree': ([ctypes.c_void_p], ctypes.c_int), 'XFlush': ([ctypes.c_void_p], ctypes.c_int), 'XCloseDisplay': ([ctypes.c_void_p], ctypes.c_int), 'XKeysymToKeycode': ([ctypes.c_void_p, ctypes.c_ulong], ctypes.c_ubyte), 'XStringToKeysym': ([ctypes.c_char_p], ctypes.c_ulong), 'XGetKeyboardMapping': ([ctypes.c_void_p, ctypes.c_ubyte, ctypes.c_int, ctypes.POINTER(ctypes.c_int)], ctypes.POINTER(ctypes.c_ulong)), 'XSetErrorHandler': ([ctypes.c_void_p], ctypes.c_void_p)}
+        for name, (args, result) in signatures.items():
+            function = getattr(self.x, name)
+            function.argtypes = args
+            function.restype = result
+        self.error_callback = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)(lambda display, event: 0)
+        self.x.XSetErrorHandler(self.error_callback)
+        self.display = self.x.XOpenDisplay(None)
+        if not self.display:
+            raise NativeFailure('linux_x11_display_unavailable')
+        self.root = self.x.XDefaultRootWindow(self.display)
+        try:
+            self.t = ctypes.CDLL('libXtst.so.6')
+            self.t.XTestFakeMotionEvent.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_ulong]
+            self.t.XTestFakeButtonEvent.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_int, ctypes.c_ulong]
+            self.t.XTestFakeKeyEvent.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_int, ctypes.c_ulong]
+            self.t.XTestQueryExtension.argtypes = [ctypes.c_void_p] + [ctypes.POINTER(ctypes.c_int)] * 4
+            values = [ctypes.c_int() for _ in range(4)]
+            if not self.t.XTestQueryExtension(self.display, *[ctypes.byref(value) for value in values]):
+                self.t = None
+        except OSError:
+            self.t = None
+        self.binding = 'x11:' + os.environ.get('XDG_SESSION_ID', 'session') + ':' + str(uuid.uuid4())
+        try:
+            self.topology = X11Topology(self)
+        except Exception:
+            self.x.XCloseDisplay(self.display)
+            self.display = None
+            raise
+
+    def source_binding(self):
+        return self.binding + ':' + self.topology.fingerprint()
+
+    def focused_window_binding(self):
+        active = self.property(self.root, '_NET_ACTIVE_WINDOW') or []
+        if not active or not active[0]:
+            return None
+        pid = (self.property(active[0], '_NET_WM_PID') or [0])[0]
+        return str(active[0]) + ':' + str(pid)
+
+    def property(self, window, name):
+        atom = self.x.XInternAtom(self.display, name.encode(), True)
+        if not atom:
+            return None
+        actual, format_, count, remaining = (ctypes.c_ulong(), ctypes.c_int(), ctypes.c_ulong(), ctypes.c_ulong())
+        data = ctypes.c_void_p()
+        status = self.x.XGetWindowProperty(self.display, window, atom, 0, 16384, False, 0, ctypes.byref(actual), ctypes.byref(format_), ctypes.byref(count), ctypes.byref(remaining), ctypes.byref(data))
+        if status or not data:
+            return None
+        try:
+            if format_.value == 8:
+                return ctypes.string_at(data, count.value).decode('utf-8', 'replace')
+            if format_.value == 32:
+                return list(ctypes.cast(data, ctypes.POINTER(ctypes.c_ulong))[:count.value])
+            return None
+        finally:
+            self.x.XFree(data)
+
+    def geometry(self, window):
+        root, child = (ctypes.c_ulong(), ctypes.c_ulong())
+        x, y = (ctypes.c_int(), ctypes.c_int())
+        w, h, border, depth = (ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint(), ctypes.c_uint())
+        if not self.x.XGetGeometry(self.display, window, ctypes.byref(root), ctypes.byref(x), ctypes.byref(y), ctypes.byref(w), ctypes.byref(h), ctypes.byref(border), ctypes.byref(depth)):
+            return None
+        if window != self.root:
+            if not self.x.XTranslateCoordinates(self.display, window, self.root, 0, 0, ctypes.byref(x), ctypes.byref(y), ctypes.byref(child)):
+                return None
+        return {'x': x.value, 'y': y.value, 'width': w.value, 'height': h.value}
+
+    def inspect(self):
+        bounds = self.geometry(self.root)
+        if not bounds:
+            raise NativeFailure('linux_x11_geometry_unavailable')
+        active = self.property(self.root, '_NET_ACTIVE_WINDOW') or []
+        ids = self.property(self.root, '_NET_CLIENT_LIST_STACKING') or self.property(self.root, '_NET_CLIENT_LIST')
+        windows = []
+        for xid in (ids or [])[:64]:
+            geometry = self.geometry(xid)
+            if not geometry:
+                continue
+            pid = (self.property(xid, '_NET_WM_PID') or [0])[0]
+            windows.append({'binding': str(xid) + ':' + str(pid), 'title': bounded_text(self.property(xid, '_NET_WM_NAME') or self.property(xid, 'WM_NAME') or '', 128), 'bounds': geometry, 'focused': bool(active and active[0] == xid)})
+        result = desktop_result('linux', self.source_binding(), bounds, True, cap(True), cap(self.t is not None, 'linux_xtest_unavailable'), cap(ids is not None, 'linux_window_inventory_unavailable'), 'observed_surface')
+        result['windows'] = windows
+        result['desktop']['coordinateSpace'] = 'physical_pixels'
+        for window in windows:
+            if window['focused']:
+                result['focusedWindow'] = window['binding']
+        result['desktop']['targetingGuarantee'] = targeting_guarantee_for_focus(result.get('focusedWindow'))
+        return result
+
+    def capture(self, region):
+        image = self.x.XGetImage(self.display, self.root, int(region['x']), int(region['y']), int(region['width']), int(region['height']), ctypes.c_ulong(-1).value, 2)
+        if not image:
+            raise NativeFailure('linux_x11_capture_failed')
+        try:
+            info = image.contents
+            if info.bits_per_pixel not in (16, 24, 32):
+                raise NativeFailure('linux_x11_pixel_format_unsupported')
+            pixel_size = info.bits_per_pixel // 8
+            source = ctypes.string_at(info.data, info.bytes_per_line * info.height)
+            rows = []
+            masks = [info.red_mask, info.green_mask, info.blue_mask]
+            shifts = [(mask & -mask).bit_length() - 1 for mask in masks]
+            maxima = [mask >> shift for mask, shift in zip(masks, shifts)]
+            scale = min(1.0, 2048 / max(info.width, info.height))
+            output_width = max(1, round(info.width * scale))
+            output_height = max(1, round(info.height * scale))
+            for output_row in range(output_height):
+                row = min(info.height - 1, int(output_row / scale))
+                line = bytearray([0])
+                for output_column in range(output_width):
+                    column = min(info.width - 1, int(output_column / scale))
+                    offset = row * info.bytes_per_line + column * pixel_size
+                    value = int.from_bytes(source[offset:offset + pixel_size], 'little' if info.byte_order == 0 else 'big')
+                    line.extend((((value & mask) >> shift) * 255 // maximum for mask, shift, maximum in zip(masks, shifts, maxima)))
+                rows.append(bytes(line))
+            return (encode_png(output_width, output_height, b''.join(rows)), output_width, output_height)
+        finally:
+            self.x.XDestroyImage(image)
+
+    def key(self, name):
+        aliases = {'Ctrl': 'Control_L', 'Control': 'Control_L', 'Alt': 'Alt_L', 'Shift': 'Shift_L', 'Meta': 'Super_L', 'Super': 'Super_L', 'Command': 'Super_L', 'Enter': 'Return', 'Esc': 'Escape', 'Backspace': 'BackSpace', 'Space': 'space', 'ArrowLeft': 'Left', 'ArrowRight': 'Right', 'ArrowUp': 'Up', 'ArrowDown': 'Down', 'PageUp': 'Prior', 'PageDown': 'Next'}
+        symbol = self.x.XStringToKeysym(aliases.get(name, name).encode('ascii', 'strict'))
+        code = self.x.XKeysymToKeycode(self.display, symbol)
+        if not symbol or not code:
+            raise NativeFailure('linux_key_unmapped')
+        return (int(code), False)
+
+    def text_keys(self, text):
+        self.x.XkbGetState.argtypes = [ctypes.c_void_p, ctypes.c_uint, ctypes.c_void_p]
+        self.x.XkbKeycodeToKeysym.argtypes = [ctypes.c_void_p, ctypes.c_ubyte, ctypes.c_int, ctypes.c_int]
+        self.x.XkbKeycodeToKeysym.restype = ctypes.c_ulong
+        state = (ctypes.c_ubyte * 256)()
+        if self.x.XkbGetState(self.display, 0x100, ctypes.byref(state)) != 0:
+            raise NativeFailure('linux_keyboard_state_unavailable')
+        group, modifiers = state[0], state[6]
+        if modifiers & (1 | 2 | 4 | 8 | 64):
+            raise NativeFailure('linux_text_active_modifiers_unsupported')
+        keys = []
+        for character in text:
+            symbol = {'\n': 65293, '\t': 65289}.get(character, ord(character) if ord(character) <= 255 else 16777216 | ord(character))
+            code = self.x.XKeysymToKeycode(self.display, symbol)
+            if not code:
+                raise NativeFailure('linux_text_character_unmapped')
+            plain = self.x.XkbKeycodeToKeysym(self.display, code, group, 0)
+            shifted = self.x.XkbKeycodeToKeysym(self.display, code, group, 1)
+            if plain == symbol:
+                keys.append((int(code), False))
+                continue
+            if shifted == symbol:
+                keys.append((int(code), True))
+                continue
+            raise NativeFailure('linux_text_character_unmapped')
+        return keys
+
+    def pointer(self, point):
+        if not self.t.XTestFakeMotionEvent(self.display, -1, round(point['x']), round(point['y']), 0):
+            raise NativeFailure('linux_xtest_pointer_rejected')
+        self.x.XFlush(self.display)
+
+    def button(self, button, down):
+        if not self.t.XTestFakeButtonEvent(self.display, button, int(down), 0):
+            raise NativeFailure('linux_xtest_button_rejected')
+        self.x.XFlush(self.display)
+
+    def key_event(self, key, down):
+        if not self.t.XTestFakeKeyEvent(self.display, key, int(down), 0):
+            raise NativeFailure('linux_xtest_key_rejected')
+        self.x.XFlush(self.display)
+
+    def scroll(self, x, y):
+        for amount, positive, negative in [(y / 120, 5, 4), (x / 120, 7, 6)]:
+            if abs(amount) > 100:
+                raise NativeFailure('linux_scroll_limit')
+            for _ in range(abs(round(amount))):
+                self.button(positive if amount > 0 else negative, True)
+                self.button(positive if amount > 0 else negative, False)
+
+    def focus(self, binding):
+
+        class XClientMessageData(ctypes.Union):
+            _fields_ = [('b', ctypes.c_char * 20), ('s', ctypes.c_short * 10), ('l', ctypes.c_long * 5)]
+
+        class XClientMessage(ctypes.Structure):
+            _fields_ = [('type', ctypes.c_int), ('serial', ctypes.c_ulong), ('send_event', ctypes.c_int), ('display', ctypes.c_void_p), ('window', ctypes.c_ulong), ('message_type', ctypes.c_ulong), ('format', ctypes.c_int), ('data', XClientMessageData)]
+
+        class XEvent(ctypes.Union):
+            _fields_ = [('client', XClientMessage), ('pad', ctypes.c_long * 24)]
+        event = XEvent()
+        event.client.type = 33
+        event.client.display = self.display
+        event.client.window = int(binding.split(':')[0])
+        event.client.message_type = self.x.XInternAtom(self.display, b'_NET_ACTIVE_WINDOW', False)
+        event.client.format = 32
+        event.client.data.l[0] = 2
+        event.client.data.l[1] = 0
+        self.x.XSendEvent.argtypes = [ctypes.c_void_p, ctypes.c_ulong, ctypes.c_int, ctypes.c_long, ctypes.POINTER(XEvent)]
+        if not self.x.XSendEvent(self.display, self.root, False, 1 << 20 | 1 << 19, ctypes.byref(event)):
+            raise NativeFailure('linux_window_focus_failed')
+        self.x.XFlush(self.display)
+
+    def close(self):
+        if self.display:
+            self.x.XCloseDisplay(self.display)
+            self.display = None
+`;

package/dist/src/computer-access/computer/macos-backend.d.ts

@@ -0,0 +1,3 @@
+import type { SystemTarget } from "../contracts.js";
+import type { NativeComputerBackend } from "./native-protocol.js";
+export declare function createMacosComputerBackend(target: SystemTarget): NativeComputerBackend;

package/dist/src/computer-access/computer/macos-backend.js

@@ -0,0 +1,28 @@
+import { createUnixNativeProcess } from "./unix-native-process.js";
+import { unavailableUnixDesktop } from "./unix-native-results.js";
+import { MACOS_COMPUTER_HELPER } from "./macos-helper.js";
+import { missingMacosComputerPrerequisite } from "./macos-prerequisites.js";
+export function createMacosComputerBackend(target) {
+    if (target.id !== "macos" || target.transport !== "native") {
+        return {
+            execute: async () => unavailableUnixDesktop("macos", "computer_native_target_required"),
+            close: async () => { },
+        };
+    }
+    const native = createUnixNativeProcess({
+        platform: "macos",
+        file: "/usr/bin/swift",
+        args: ["-swift-version", "5", "-e", MACOS_COMPUTER_HELPER],
+    });
+    let prerequisites;
+    return {
+        async execute(request, signal) {
+            prerequisites ??= missingMacosComputerPrerequisite();
+            const reason = await prerequisites;
+            if (reason)
+                return unavailableUnixDesktop("macos", reason);
+            return native.execute(request, signal);
+        },
+        close: () => native.close(),
+    };
+}

package/dist/src/computer-access/computer/macos-capture.d.ts

@@ -0,0 +1 @@
+export declare const MACOS_CAPTURE_SOURCE: string;