@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/computer-access/computer/companion-sessions.js

@@ -0,0 +1,189 @@
+import { createHash, randomUUID } from "node:crypto";
+import { failureResult, successResult, } from "../../plugin-sdk/index.js";
+import { isHostIdentifier } from "../companion/protocol.js";
+import { resolveSystemTarget } from "../targets.js";
+import { computerNumber, computerText } from "./action-input.js";
+import { createNativeComputerBackend } from "./native-backend.js";
+import { COMPUTER_FRAME_CHUNK_BYTES, COMPUTER_IMAGE_MAX_BYTES, readNativeComputerRequest, readNativeComputerResult, } from "./native-validation.js";
+import { withDesktopQueue } from "./desktop-action-queue.js";
+/** Connection-owned, bounded private sessions. No image is written to disk. */
+export class CompanionComputerSessions {
+    platform;
+    createBackend;
+    resolveTarget;
+    sessions = new Map();
+    closedSessions = new Set();
+    stopped = false;
+    constructor(platform, createBackend = createNativeComputerBackend, resolveTarget = resolveSystemTarget) {
+        this.platform = platform;
+        this.createBackend = createBackend;
+        this.resolveTarget = resolveTarget;
+    }
+    hasActiveSessions() {
+        return this.sessions.size > 0;
+    }
+    handlers() {
+        const protect = (handler) => async (params, context) => {
+            try {
+                return await handler(params, context);
+            }
+            catch (error) {
+                return failureResult({
+                    errorCode: "computer_native_operation_failed",
+                    message: error instanceof Error
+                        ? error.message
+                        : "The computer operation failed; observe before retrying.",
+                });
+            }
+        };
+        return {
+            computer_execute: protect((params, context) => this.execute(params, context?.abortSignal)),
+            computer_frame: protect(async (params) => this.frame(params)),
+            computer_close: protect(async (params) => {
+                const id = this.sessionId(params);
+                await this.release(id);
+                return successResult({ output: "Computer session released." });
+            }),
+        };
+    }
+    async close() {
+        this.stopped = true;
+        await Promise.allSettled([...this.sessions.keys()].map((id) => this.release(id)));
+    }
+    sessionId(params) {
+        if (!isHostIdentifier(params.sessionId))
+            throw new Error("computer_session_invalid");
+        if (params.target !== this.platform)
+            throw new Error("computer_platform_mismatch");
+        return params.sessionId;
+    }
+    async acquire(id) {
+        if (this.stopped)
+            throw new Error("computer_connection_closed");
+        if (this.closedSessions.has(id))
+            throw new Error("computer_session_closed");
+        const previous = this.sessions.get(id);
+        if (previous) {
+            this.renew(id, previous);
+            return previous;
+        }
+        if (this.sessions.size >= 8)
+            throw new Error("computer_session_limit");
+        const target = await this.resolveTarget(this.platform);
+        if (target.transport !== "native")
+            throw new Error("computer_companion_must_be_native");
+        if (this.stopped)
+            throw new Error("computer_connection_closed");
+        if (this.closedSessions.has(id))
+            throw new Error("computer_session_closed");
+        const session = {
+            backend: this.createBackend(target),
+            expires: setTimeout(() => void this.release(id), 300_000),
+        };
+        session.expires.unref();
+        this.sessions.set(id, session);
+        return session;
+    }
+    renew(id, session) {
+        clearTimeout(session.expires);
+        session.expires = setTimeout(() => void this.release(id), 300_000);
+        session.expires.unref();
+    }
+    async execute(params, signal) {
+        const id = this.sessionId(params);
+        const request = readNativeComputerRequest(params.request);
+        return withDesktopQueue(`companion-native:${this.platform}`, signal, async () => {
+            const session = await this.acquire(id);
+            this.eraseFrame(session);
+            const result = await session.backend.execute(request, signal);
+            const { image, ...metadata } = result;
+            try {
+                readNativeComputerResult(metadata);
+            }
+            catch (error) {
+                image?.bytes.fill(0);
+                throw error;
+            }
+            if (!image)
+                return successResult({
+                    output: "Native desktop observation.",
+                    data: { result: metadata },
+                });
+            const frameError = this.imageAdmissionError(id, session, image.bytes.byteLength, signal);
+            if (frameError) {
+                image.bytes.fill(0);
+                return successResult({
+                    output: "Native action receipt retained; image unavailable.",
+                    data: {
+                        result: {
+                            ...metadata,
+                            error: {
+                                code: frameError,
+                                message: "Image unavailable after native execution. Preserve the dispatch receipt and observe again before another action.",
+                            },
+                        },
+                    },
+                });
+            }
+            const bytes = Buffer.from(image.bytes);
+            image.bytes.fill(0);
+            const frameId = randomUUID();
+            session.frame = { id: frameId, bytes, nextOffset: 0 };
+            return successResult({
+                output: "Native desktop observation; image transfer pending.",
+                data: {
+                    result: metadata,
+                    frame: {
+                        id: frameId,
+                        size: bytes.length,
+                        sha256: createHash("sha256").update(bytes).digest("hex"),
+                    },
+                },
+            });
+        });
+    }
+    imageAdmissionError(id, session, size, signal) {
+        if (signal?.aborted)
+            return "computer_capture_cancelled";
+        if (this.stopped || this.closedSessions.has(id))
+            return "computer_session_closed";
+        if (this.sessions.get(id) !== session)
+            return "computer_session_closed";
+        if (size < 1)
+            return "computer_image_empty";
+        if (size > COMPUTER_IMAGE_MAX_BYTES)
+            return "computer_image_limit";
+        return undefined;
+    }
+    frame(params) {
+        const session = this.sessions.get(this.sessionId(params));
+        const frame = session?.frame;
+        if (!session || !frame)
+            throw new Error("computer_frame_expired");
+        if (computerText(params.frameId, 128) !== frame.id)
+            throw new Error("computer_frame_identity_mismatch");
+        const offset = computerNumber(params.offset, 0, COMPUTER_IMAGE_MAX_BYTES);
+        if (offset !== frame.nextOffset)
+            throw new Error("computer_frame_offset_mismatch");
+        const end = Math.min(offset + COMPUTER_FRAME_CHUNK_BYTES, frame.bytes.length);
+        const bytes = frame.bytes.subarray(offset, end).toString("base64");
+        frame.nextOffset = end;
+        if (end === frame.bytes.length)
+            this.eraseFrame(session);
+        return successResult({ output: "Private image chunk.", data: { bytes } });
+    }
+    eraseFrame(session) {
+        session.frame?.bytes.fill(0);
+        delete session.frame;
+    }
+    async release(id) {
+        this.closedSessions.add(id);
+        const session = this.sessions.get(id);
+        if (!session)
+            return;
+        this.sessions.delete(id);
+        clearTimeout(session.expires);
+        this.eraseFrame(session);
+        await session.backend.close();
+    }
+}

package/dist/src/computer-access/computer/desktop-action-queue.d.ts

@@ -0,0 +1 @@
+export declare function withDesktopQueue<T>(identity: string, signal: AbortSignal | undefined, operation: () => Promise<T>): Promise<T>;

package/dist/src/computer-access/computer/desktop-action-queue.js

@@ -0,0 +1,41 @@
+/** Serializes observation and injection within the caller's desktop exclusion scope. */
+const desktopTails = new Map();
+export async function withDesktopQueue(identity, signal, operation) {
+    signal?.throwIfAborted();
+    const previous = desktopTails.get(identity) ?? Promise.resolve();
+    let release;
+    const done = new Promise((resolve) => {
+        release = resolve;
+    });
+    const tail = previous.then(() => done);
+    desktopTails.set(identity, tail);
+    try {
+        await waitForDesktopTurn(previous, signal);
+        signal?.throwIfAborted();
+        return await operation();
+    }
+    finally {
+        release();
+        void tail.then(() => {
+            if (desktopTails.get(identity) === tail)
+                desktopTails.delete(identity);
+        });
+    }
+}
+function waitForDesktopTurn(previous, signal) {
+    if (!signal)
+        return previous;
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            cleanup();
+            reject(signal.reason);
+        };
+        const cleanup = () => signal.removeEventListener("abort", abort);
+        signal.addEventListener("abort", abort, { once: true });
+        void previous.then(() => {
+            cleanup();
+            resolve();
+        });
+    });
+}

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

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

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

@@ -0,0 +1,16 @@
+import { createUnixNativeProcess } from "./unix-native-process.js";
+import { unavailableUnixDesktop } from "./unix-native-results.js";
+import { LINUX_COMPUTER_HELPER } from "./linux-helper.js";
+export function createLinuxComputerBackend(target) {
+    if (target.id !== "linux" || target.transport !== "native") {
+        return {
+            execute: async () => unavailableUnixDesktop("linux", "computer_native_target_required"),
+            close: async () => { },
+        };
+    }
+    return createUnixNativeProcess({
+        platform: "linux",
+        file: "python3",
+        args: ["-u", "-c", LINUX_COMPUTER_HELPER],
+    });
+}

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

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

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

@@ -0,0 +1,165 @@
+export const LINUX_DESKTOP_SOURCE = String.raw `
+import sys, os, json, time, uuid, threading, queue, ctypes, struct, zlib, base64, datetime, math
+MAX_PNG = 10 * 1024 * 1024
+output_lock = threading.Lock()
+
+class NativeFailure(Exception):
+
+    def __init__(self, code):
+        self.code = code
+        super().__init__(code)
+
+def emit(value):
+    with output_lock:
+        print(json.dumps(value, ensure_ascii=False, separators=(',', ':')), flush=True)
+
+def cap(available, reason=None, supported=True):
+    result = {'supported': supported, 'available': available}
+    if not available and reason:
+        result['reason'] = reason
+    return result
+
+def bounded_text(value, limit=256):
+    return str(value).encode('utf-8')[:limit].decode('utf-8', 'ignore')
+
+def desktop_result(platform, binding, bounds, available, capture, input_, windows, targeting):
+    return {'desktop': {'platform': platform, 'binding': binding, 'name': 'User desktop', 'available': available, 'bounds': bounds, 'capabilities': {'capture': capture, 'input': input_, 'windows': windows, 'accessibility': cap(False, 'linux_accessibility_not_available')}, 'targetingGuarantee': targeting}, 'windows': []}
+
+def failed_desktop(code):
+    return desktop_result('linux', 'unavailable:linux', {'x': 0, 'y': 0, 'width': 1, 'height': 1}, False, cap(False, code), cap(False, code), cap(False, code), 'observed_surface')
+
+def targeting_guarantee_for_focus(focused):
+    if not focused:
+        return 'observed_surface'
+    return 'verified_window'
+
+def require_observation_source(request, state):
+    if request.get('region') is None and request.get('operation') != 'act':
+        return
+    if request.get('desktopBinding') != state['desktop']['binding']:
+        raise NativeFailure('computer_desktop_stale')
+    if request.get('expectedGeometry') != state['desktop']['bounds']:
+        raise NativeFailure('computer_geometry_changed')
+
+def encode_png(width, height, scanlines):
+
+    def chunk(kind, data):
+        return struct.pack('!I', len(data)) + kind + data + struct.pack('!I', zlib.crc32(kind + data) & 4294967295)
+    image = b'\x89PNG\r\n\x1a\n' + chunk(b'IHDR', struct.pack('!2I5B', width, height, 8, 2, 0, 0, 0)) + chunk(b'IDAT', zlib.compress(scanlines, 3)) + chunk(b'IEND', b'')
+    if len(image) > MAX_PNG:
+        raise NativeFailure('computer_capture_size_limit')
+    return image
+
+def point_inside(point, bounds):
+    if not all((isinstance(point.get(axis), (int, float)) and math.isfinite(point[axis]) for axis in ['x', 'y'])):
+        return False
+    return bounds['x'] <= point['x'] < bounds['x'] + bounds['width'] and bounds['y'] <= point['y'] < bounds['y'] + bounds['height']
+
+def capture_region(region, bounds):
+    if region is None:
+        return bounds.copy()
+    if not all((isinstance(region.get(key), (int, float)) and math.isfinite(region[key]) for key in ['x', 'y', 'width', 'height'])):
+        raise NativeFailure('computer_region_invalid')
+    if region['width'] < 1 or region['height'] < 1:
+        raise NativeFailure('computer_region_invalid')
+    if not point_inside({'x': region['x'], 'y': region['y']}, bounds):
+        raise NativeFailure('computer_region_outside_desktop')
+    if region['x'] + region['width'] > bounds['x'] + bounds['width'] or region['y'] + region['height'] > bounds['y'] + bounds['height']:
+        raise NativeFailure('computer_region_outside_desktop')
+    return {key: round(region[key]) for key in ['x', 'y', 'width', 'height']}
+
+def session_locked():
+    try:
+        from gi.repository import Gio, GLib
+        bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
+        for service, path in [('org.freedesktop.ScreenSaver', '/org/freedesktop/ScreenSaver'), ('org.gnome.ScreenSaver', '/org/gnome/ScreenSaver')]:
+            try:
+                result = bus.call_sync(service, path, service, 'GetActive', None, None, Gio.DBusCallFlags.NONE, 1000, None)
+                return bool(result.unpack()[0])
+            except Exception:
+                pass
+        return None
+    except Exception:
+        return None
+
+def read_accessibility(expected_window):
+    try:
+        import pyatspi
+    except ImportError:
+        return ([], False, False)
+    nodes = []
+    pending = []
+    started = time.monotonic()
+    total = 0
+    try:
+        expected_pid = int(expected_window['binding'].split(':')[-1])
+        if expected_pid <= 0:
+            return ([], False, False)
+        for app in pyatspi.Registry.getDesktop(0):
+            if int(app.get_process_id()) != expected_pid:
+                continue
+            for window in app:
+                if not window.getState().contains(pyatspi.STATE_ACTIVE):
+                    continue
+                if bounded_text(window.name or '', 128) != expected_window['title']:
+                    continue
+                pending.append(window)
+        if len(pending) != 1:
+            return ([], False, False)
+        visited = 0
+        while pending and visited < 400 and (len(nodes) < 64) and (total < 24000) and (time.monotonic() - started < 0.4):
+            item = pending.pop(0)
+            visited += 1
+            if item.getRole() == pyatspi.ROLE_PASSWORD_TEXT or not item.getState().contains(pyatspi.STATE_SHOWING):
+                continue
+            node = {'role': bounded_text(item.getRoleName(), 64), 'name': bounded_text(item.name or '', 128), 'focused': item.getState().contains(pyatspi.STATE_FOCUSED)}
+            if item.childCount == 0:
+                try:
+                    text = item.queryText()
+                    node['value'] = bounded_text(text.getText(0, min(text.characterCount, 256)))
+                except Exception:
+                    pass
+            total += len(node.get('name', '')) + len(node.get('value', ''))
+            nodes.append(node)
+            for child in item:
+                if len(pending) < 400 and child is not None:
+                    pending.append(child)
+        return (nodes, bool(pending), True)
+    except Exception:
+        return (nodes, True, True)
+
+def add_observation(backend, state, region=None):
+    bounds = state['desktop']['bounds']
+    region = capture_region(region, bounds)
+    require_capture_source(state, backend.inspect())
+    data, width, height = backend.capture(region)
+    nodes, truncated, available = ([], False, False)
+    reason = 'selected_surface_accessibility_unbound'
+    focused = next((window for window in state['windows'] if window['binding'] == state.get('focusedWindow')), None)
+    if focused:
+        nodes, truncated, available = read_accessibility(focused)
+        reason = 'linux_accessibility_source_unavailable'
+    after = backend.inspect()
+    require_capture_source_available(state, after)
+    if state['desktop']['binding'] != after['desktop']['binding'] or bounds != after['desktop']['bounds']:
+        raise NativeFailure('computer_geometry_changed_during_capture')
+    if state.get('focusedWindow') != after.get('focusedWindow'):
+        raise NativeFailure('computer_focus_changed_during_capture')
+    state['desktop']['capabilities']['accessibility'] = cap(available, reason)
+    state['observation'] = {'capturedAt': datetime.datetime.now(datetime.timezone.utc).isoformat(), 'region': region, 'imageWidth': width, 'imageHeight': height, 'accessibility': nodes, 'accessibilityTruncated': truncated}
+    state['imageBase64'] = base64.b64encode(data).decode('ascii')
+    return state
+
+def require_capture_source(expected, current):
+    require_capture_source_available(expected, current)
+    if expected['desktop']['binding'] != current['desktop']['binding']:
+        raise NativeFailure('computer_desktop_stale')
+    if expected['desktop']['bounds'] != current['desktop']['bounds']:
+        raise NativeFailure('computer_geometry_changed')
+
+def require_capture_source_available(expected, current):
+    if current['desktop']['available']:
+        return
+    expected['desktop'] = current['desktop']
+    raise NativeFailure(current['desktop'].get('reason') or 'computer_capture_source_unavailable')
+`;

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

@@ -0,0 +1,2 @@
+/** Reject cached portal frames; capture evidence must follow this observation boundary. */
+export declare const LINUX_FRAME_SOURCE: string;

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

@@ -0,0 +1,29 @@
+/** Reject cached portal frames; capture evidence must follow this observation boundary. */
+export const LINUX_FRAME_SOURCE = String.raw `
+def fresh_portal_sample(backend):
+    clock = backend.pipeline.get_clock()
+    if clock is None:
+        raise NativeFailure('linux_pipewire_clock_unavailable')
+    cutoff = max(0, clock.get_time() - backend.pipeline.get_base_time())
+    for _ in range(4):
+        cached = backend.sink.emit('try-pull-sample', 0)
+        if cached is None:
+            break
+    deadline = time.monotonic() + 3
+    while time.monotonic() < deadline:
+        sample = backend.sink.emit('try-pull-sample', int(0.2 * backend.Gst.SECOND))
+        if sample is None:
+            continue
+        buffer = sample.get_buffer()
+        if buffer.pts == backend.Gst.CLOCK_TIME_NONE:
+            continue
+        segment = sample.get_segment()
+        if segment is None:
+            continue
+        timestamp = segment.to_running_time(backend.Gst.Format.TIME, buffer.pts)
+        if timestamp == backend.Gst.CLOCK_TIME_NONE:
+            continue
+        if timestamp >= cutoff:
+            return sample
+    raise NativeFailure('linux_pipewire_fresh_frame_unavailable')
+`;

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

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

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

@@ -0,0 +1,161 @@
+import { LINUX_DESKTOP_SOURCE } from "./linux-desktop.js";
+import { LINUX_X11_SOURCE } from "./linux-x11.js";
+import { LINUX_PORTAL_SOURCE } from "./linux-portal.js";
+import { LINUX_INPUT_SOURCE } from "./linux-input.js";
+import { LINUX_FRAME_SOURCE } from "./linux-frame.js";
+import { LINUX_TOPOLOGY_SOURCE } from "./linux-topology.js";
+import { LINUX_PORTAL_SOURCE_IDENTITY } from "./linux-portal-source.js";
+const LINUX_COMMAND_LOOP = String.raw `
+backend = None
+backend_error = None
+jobs = queue.Queue()
+cancellations = {}
+stopping = threading.Event()
+
+def get_backend():
+    global backend, backend_error
+    if backend is not None:
+        return backend
+    if backend_error:
+        raise NativeFailure(backend_error)
+    try:
+        if os.environ.get('WAYLAND_DISPLAY'):
+            backend = PortalDesktop()
+        elif os.environ.get('DISPLAY'):
+            backend = X11Desktop()
+        else:
+            raise NativeFailure('linux_graphical_session_unavailable')
+        return backend
+    except NativeFailure as error:
+        backend_error = error.code
+        raise
+    except (ImportError, OSError):
+        backend_error = 'linux_native_dependencies_unavailable'
+        raise NativeFailure(backend_error)
+
+def operation(id, request, cancel):
+    state = None
+    dispatch = None
+    try:
+        if cancel.is_set():
+            raise NativeFailure('computer_action_cancelled')
+        native = get_backend()
+        if isinstance(native, PortalDesktop) and request['operation'] != 'inspect':
+            native.ensure_session(cancel)
+        state = native.inspect()
+        locked = session_locked()
+        if locked is True:
+            raise NativeFailure('computer_session_locked')
+        if isinstance(native, X11Desktop) and locked is None:
+            raise NativeFailure('linux_session_lock_state_unavailable')
+        if request['operation'] == 'inspect':
+            return state
+        if request['operation'] == 'observe':
+            require_observation_source(request, state)
+            return add_observation(native, state, request.get('region'))
+        if request['operation'] != 'act':
+            raise NativeFailure('computer_operation_unsupported')
+        require_observation_source(request, state)
+        if request.get('expectedWindow') and request['expectedWindow'] != state.get('focusedWindow'):
+            raise NativeFailure('computer_focus_changed')
+        if not state['desktop']['capabilities']['input']['available']:
+            raise NativeFailure('computer_input_unavailable')
+        keys = validate_action(request['action'], state, native)
+        dispatch = execute_input(native, request['action'], keys, cancel, request['deadlineEpochMs'], id, request['desktopBinding'], request.get('expectedWindow'))
+        emit({'type': 'dispatch', 'id': id, 'dispatch': dispatch})
+        state = native.inspect()
+        state['dispatch'] = dispatch
+        require_observation_source(request, state)
+        dispatch_error = incomplete_dispatch_error(dispatch)
+        if dispatch_error:
+            state['error'] = dispatch_error
+        if request['action']['kind'] == 'focus_window' and state.get('focusedWindow') != request['action']['windowBinding']:
+            state['error'] = {'code': 'computer_focus_not_confirmed', 'message': 'The window manager accepted the request but the target focus is not confirmed.'}
+        try:
+            return add_observation(native, state)
+        except Exception:
+            state['error'] = {'code': 'computer_post_action_capture_failed', 'message': 'Input dispatch settled but the subsequent capture failed; do not repeat the input without inspection.'}
+            return state
+    except Exception as error:
+        code = error.code if isinstance(error, NativeFailure) else 'computer_native_operation_failed'
+        state = state or failed_desktop(code)
+        state['error'] = {'code': code, 'message': 'The native desktop operation could not complete.'}
+        if request.get('operation') == 'act':
+            state['dispatch'] = dispatch or {'status': 'not_dispatched', 'requestedInputCount': action_input_count(request.get('action', {})), 'acceptedInputCount': 0, 'reason': code}
+        if code in ['computer_session_locked', 'linux_session_lock_state_unavailable']:
+            state['desktop']['available'] = False
+            state['desktop']['reason'] = code
+            for capability in state['desktop']['capabilities'].values():
+                capability.update({'available': False, 'reason': code})
+        return state
+
+def worker():
+    while not stopping.is_set():
+        value = jobs.get()
+        if value is None:
+            return
+        id = value['id']
+        cancel = cancellations[id]
+        result = operation(id, value['request'], cancel)
+        emit({'type': 'result', 'id': id, 'result': result})
+        cancellations.pop(id, None)
+
+worker_thread = None
+
+def shutdown():
+    if stopping.is_set():
+        return
+    stopping.set()
+    for cancel in list(cancellations.values()):
+        cancel.set()
+    jobs.put(None)
+    if worker_thread is not None:
+        worker_thread.join(timeout=2)
+    if backend is not None:
+        try:
+            backend.close()
+        except Exception:
+            pass
+    os._exit(0)
+
+def input_loop():
+    for line in sys.stdin:
+        try:
+            if len(line) > 65536:
+                break
+            value = json.loads(line)
+            if value['type'] == 'close':
+                break
+            if value['type'] == 'cancel':
+                if value.get('id') in cancellations:
+                    cancellations[value['id']].set()
+                continue
+            if value['type'] != 'request' or not isinstance(value.get('id'), str):
+                break
+            cancellations[value['id']] = threading.Event()
+            jobs.put(value)
+        except Exception:
+            break
+    shutdown()
+if __name__ == '__main__':
+    import signal
+    signal.signal(signal.SIGTERM, lambda number, frame: threading.Thread(target=shutdown, daemon=True).start())
+    worker_thread = threading.Thread(target=worker, daemon=True)
+    worker_thread.start()
+    threading.Thread(target=input_loop, daemon=True).start()
+    try:
+        from gi.repository import GLib
+        GLib.MainLoop().run()
+    except ImportError:
+        stopping.wait()
+`;
+export const LINUX_COMPUTER_HELPER = [
+    LINUX_DESKTOP_SOURCE,
+    LINUX_TOPOLOGY_SOURCE,
+    LINUX_PORTAL_SOURCE_IDENTITY,
+    LINUX_X11_SOURCE,
+    LINUX_PORTAL_SOURCE,
+    LINUX_INPUT_SOURCE,
+    LINUX_FRAME_SOURCE,
+    LINUX_COMMAND_LOOP,
+].join("\n");

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

@@ -0,0 +1,2 @@
+/** Mechanical action execution. Unicode mapping and all geometry are checked before any input. */
+export declare const LINUX_INPUT_SOURCE: string;