@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/computer-access/companion/observation-connection.js

@@ -0,0 +1,120 @@
+import WebSocket from "ws";
+import { OBSERVATION_LEASE_MS, OBSERVATION_WIRE_LIMIT, isPassiveCollectorEvent, } from "./observation-protocol.js";
+/** One device, one environment owner. Lifetime is bounded by both transports and a lease. */
+export class HostObservationConnection {
+    client;
+    deviceId;
+    capable = false;
+    lease;
+    attach(client, deviceId, capable) {
+        this.client = client;
+        this.deviceId = deviceId;
+        this.capable = capable;
+    }
+    subscribe(input) {
+        if (this.client?.readyState !== WebSocket.OPEN)
+            throw new Error("host_disconnected");
+        if (!this.capable)
+            throw new Error("host_observations_unsupported");
+        if (this.lease)
+            throw new Error("host_observations_already_owned");
+        const lease = {
+            ownerId: input.ownerId,
+            leaseId: input.leaseId,
+            emit: input.onEvent,
+            deadline: setTimeout(() => this.expire(lease), OBSERVATION_LEASE_MS),
+            sequence: 0,
+        };
+        this.lease = lease;
+        this.send({
+            type: "observe_start",
+            ownerId: input.ownerId,
+            leaseId: input.leaseId,
+            excludedApplications: input.excludedApplications,
+        });
+        return {
+            renew: () => {
+                if (this.lease !== lease)
+                    throw new Error("host_observation_lease_expired");
+                clearTimeout(lease.deadline);
+                lease.deadline = setTimeout(() => this.expire(lease), OBSERVATION_LEASE_MS);
+                this.send({
+                    type: "observe_renew",
+                    ownerId: lease.ownerId,
+                    leaseId: lease.leaseId,
+                });
+            },
+            close: () => this.release(lease),
+        };
+    }
+    receive(client, message) {
+        if (client !== this.client)
+            throw new Error("host_observation_source_mismatch");
+        const lease = this.lease;
+        if (!lease)
+            return;
+        if (message.leaseId !== lease.leaseId || message.ownerId !== lease.ownerId)
+            return;
+        if (!isPassiveCollectorEvent(message.event))
+            throw new Error("invalid_host_observation");
+        if (Buffer.byteLength(JSON.stringify(message)) > OBSERVATION_WIRE_LIMIT)
+            throw new Error("host_observation_too_large");
+        if (message.event.type === "observation") {
+            if (message.event.observation.sequence <= lease.sequence)
+                return;
+            lease.sequence = message.event.observation.sequence;
+        }
+        lease.emit({
+            ...message.event,
+            deviceId: this.deviceId,
+            ownerId: lease.ownerId,
+            leaseId: lease.leaseId,
+        });
+    }
+    disconnect() {
+        const lease = this.lease;
+        if (lease) {
+            lease.emit({
+                type: "status",
+                state: "disconnected",
+                reason: "host_disconnected",
+                deviceId: this.deviceId,
+                ownerId: lease.ownerId,
+                leaseId: lease.leaseId,
+            });
+            this.release(lease);
+        }
+        this.client = undefined;
+        this.deviceId = undefined;
+        this.capable = false;
+    }
+    send(control) {
+        if (this.client?.readyState !== WebSocket.OPEN)
+            return;
+        this.client.send(JSON.stringify(control));
+    }
+    expire(lease) {
+        if (this.lease !== lease)
+            return;
+        lease.emit({
+            type: "status",
+            state: "stopped",
+            reason: "lease_expired",
+            deviceId: this.deviceId,
+            ownerId: lease.ownerId,
+            leaseId: lease.leaseId,
+        });
+        this.release(lease);
+    }
+    release(lease) {
+        if (this.lease !== lease)
+            return;
+        this.lease = undefined;
+        clearTimeout(lease.deadline);
+        this.send({
+            type: "observe_stop",
+            ownerId: lease.ownerId,
+            leaseId: lease.leaseId,
+        });
+    }
+}

package/dist/src/computer-access/companion/observation-filter.d.ts

@@ -0,0 +1,12 @@
+import type { PassiveCollectorEvent } from "../../shared/passive-observation.js";
+/** Bounded source-aware deduplication; returning to a source remains an activity observation. */
+export declare class ObservationFilter {
+    private readonly excludedApplications;
+    private readonly sourceIdentityKey;
+    private sequence;
+    private lastStatus?;
+    private lastSource?;
+    private readonly fingerprints;
+    constructor(excludedApplications?: readonly string[]);
+    accept(value: unknown): PassiveCollectorEvent | undefined;
+}

package/dist/src/computer-access/companion/observation-filter.js

@@ -0,0 +1,180 @@
+import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
+import { isHostRecord } from "./protocol.js";
+import { redactObservationSource, redactObservationText, } from "./observation-redaction.js";
+import { isPassiveCollectorEvent, isObservationOwner, OBSERVATION_CONTENT_LIMIT, OBSERVATION_WIRE_LIMIT, } from "./observation-protocol.js";
+// Include the previous title so tabs opened before an update are also excluded.
+const OWN_WEB_UI_TITLES = ["ABot Runtime — Workspace", "ABot Runtime"];
+const BROWSER_WINDOW_NAMES = [
+    "Mozilla Firefox",
+    "Mozilla Firefox (Private Browsing)",
+    "Google Chrome",
+    "Chromium",
+    "Microsoft Edge",
+    "Brave",
+    "Safari",
+];
+const BROWSER_WINDOW_SUFFIXES = BROWSER_WINDOW_NAMES.flatMap((browser) => [
+    ` — ${browser}`,
+    ` - ${browser}`,
+]);
+function isOwnWebUiWindowTitle(title) {
+    if (typeof title !== "string")
+        return false;
+    if (OWN_WEB_UI_TITLES.includes(title))
+        return true;
+    const suffix = BROWSER_WINDOW_SUFFIXES.find((candidate) => title.endsWith(candidate));
+    if (!suffix)
+        return false;
+    return OWN_WEB_UI_TITLES.includes(title.slice(0, -suffix.length));
+}
+function hasBoundedSourceMetadata(source) {
+    if (!isObservationOwner(source.app))
+        return false;
+    if (typeof source.windowId !== "string")
+        return false;
+    if (source.windowId.length === 0)
+        return false;
+    if (source.windowId.length > 256)
+        return false;
+    for (const field of ["documentId", "title", "url"]) {
+        if (source[field] === undefined)
+            continue;
+        if (typeof source[field] !== "string")
+            return false;
+        if (source[field].length > 4096)
+            return false;
+    }
+    return true;
+}
+function boundedObservation(observation) {
+    let bounded = observation;
+    while (Buffer.byteLength(JSON.stringify(bounded)) >
+        OBSERVATION_WIRE_LIMIT - 1024 &&
+        bounded.content.length > 0) {
+        bounded = {
+            ...bounded,
+            content: bounded.content.slice(0, Math.floor(bounded.content.length * 0.75)),
+            coverage: "partial",
+            coverageReason: "transport_content_limit",
+        };
+    }
+    return bounded;
+}
+/** Bounded source-aware deduplication; returning to a source remains an activity observation. */
+export class ObservationFilter {
+    excludedApplications;
+    // Private to one collector lease: source identity must not retain or expose raw secrets.
+    sourceIdentityKey = randomBytes(32);
+    sequence = 0;
+    lastStatus;
+    lastSource;
+    fingerprints = new Map();
+    constructor(excludedApplications = []) {
+        this.excludedApplications = excludedApplications;
+    }
+    accept(value) {
+        if (isPassiveCollectorEvent(value) && value.type === "status") {
+            if (value.state === "paused")
+                this.lastSource = undefined;
+            const reason = value.reason === undefined
+                ? undefined
+                : redactObservationText(value.reason).slice(0, 512);
+            const identity = JSON.stringify([value.state, reason]);
+            if (identity === this.lastStatus)
+                return undefined;
+            this.lastStatus = identity;
+            return {
+                type: "status",
+                state: value.state,
+                ...(reason === undefined ? {} : { reason }),
+            };
+        }
+        if (!isHostRecord(value) ||
+            value.type !== "snapshot" ||
+            !isHostRecord(value.source))
+            return undefined;
+        if (typeof value.beforeKey !== "string" ||
+            value.beforeKey !== value.afterKey)
+            return undefined;
+        if (value.secure === true || value.locked === true)
+            return undefined;
+        if (typeof value.content !== "string" ||
+            typeof value.source.app !== "string")
+            return undefined;
+        const rawSource = {
+            app: value.source.app,
+            processId: value.source.processId,
+            windowId: value.source.windowId,
+            documentId: value.source.documentId,
+            title: value.source.title,
+            url: value.source.url,
+        };
+        if (!hasBoundedSourceMetadata(rawSource))
+            return undefined;
+        if (isOwnWebUiWindowTitle(rawSource.title)) {
+            this.lastSource = undefined;
+            return undefined;
+        }
+        const isExcludedApplication = this.excludedApplications.some((app) => app.toLocaleLowerCase() === rawSource.app.toLocaleLowerCase());
+        if (isExcludedApplication) {
+            this.lastSource = undefined;
+            return undefined;
+        }
+        const sourceKey = createHmac("sha256", this.sourceIdentityKey)
+            .update(JSON.stringify([
+            rawSource.app,
+            rawSource.processId,
+            rawSource.windowId,
+            rawSource.documentId,
+            rawSource.title,
+            rawSource.url,
+        ]))
+            .digest("hex");
+        const source = redactObservationSource(rawSource, sourceKey);
+        const content = redactObservationText(value.content)
+            .replace(/\r\n?/gu, "\n")
+            .replace(/[ \t]+\n/gu, "\n")
+            .trim();
+        const fingerprint = createHash("sha256").update(content).digest("hex");
+        const previous = this.fingerprints.get(sourceKey);
+        const duplicate = previous?.fingerprint === fingerprint;
+        if (duplicate && this.lastSource === sourceKey)
+            return undefined;
+        const truncated = content.length > OBSERVATION_CONTENT_LIMIT;
+        let coverageReason = typeof value.coverageReason === "string"
+            ? redactObservationText(value.coverageReason).slice(0, 512)
+            : undefined;
+        if (truncated)
+            coverageReason = "content_limit";
+        const observation = {
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            sequence: this.sequence + 1,
+            source,
+            content: duplicate ? "" : content.slice(0, OBSERVATION_CONTENT_LIMIT),
+            ...(duplicate ? { revisitsObservationId: previous.observationId } : {}),
+            kind: duplicate ? "activity" : value.kind === "edit" ? "edit" : "view",
+            extraction: value.extraction,
+            coverage: truncated
+                ? "partial"
+                : value.coverage,
+            coverageReason,
+        };
+        const event = {
+            type: "observation",
+            observation: boundedObservation(observation),
+        };
+        if (!isPassiveCollectorEvent(event))
+            return undefined;
+        this.sequence += 1;
+        this.lastSource = sourceKey;
+        this.fingerprints.delete(sourceKey);
+        this.fingerprints.set(sourceKey, {
+            fingerprint,
+            observationId: duplicate ? previous.observationId : observation.id,
+        });
+        if (this.fingerprints.size > 128)
+            this.fingerprints.delete(this.fingerprints.keys().next().value);
+        return event;
+    }
+}

package/dist/src/computer-access/companion/observation-linux.d.ts

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

package/dist/src/computer-access/companion/observation-linux.js

@@ -0,0 +1,228 @@
+/** Requires the session's AT-SPI, GLib and D-Bus Python bindings; never installs dependencies. */
+import { OBSERVATION_CAPTURE_POLICY as policy } from "./observation-capture-policy.js";
+export const LINUX_OBSERVATION_SCRIPT = String.raw `
+import os, json, time, sys
+def emit(value):
+    print(json.dumps(value, ensure_ascii=False), flush=True)
+try:
+    import pyatspi
+    import dbus
+    from gi.repository import GLib
+    from dbus.mainloop.glib import DBusGMainLoop
+except ImportError:
+    emit({'type':'status','state':'unavailable','reason':'linux_atspi_python_dependencies_missing'})
+    sys.exit(0)
+if not (os.environ.get('DISPLAY') or os.environ.get('WAYLAND_DISPLAY')):
+    emit({'type':'status','state':'unavailable','reason':'graphical_session_unavailable'})
+    sys.exit(0)
+DBusGMainLoop(set_as_default=True)
+bus = dbus.SessionBus()
+excluded = {str(x).casefold() for x in json.loads(os.environ.get('ABOT_OBSERVATION_EXCLUSIONS','[]'))}
+lock_source = None
+for name, path, interface in [('org.freedesktop.ScreenSaver','/org/freedesktop/ScreenSaver','org.freedesktop.ScreenSaver'),('org.gnome.ScreenSaver','/org/gnome/ScreenSaver','org.gnome.ScreenSaver')]:
+    try:
+        candidate = dbus.Interface(bus.get_object(name,path), interface)
+        candidate.GetActive(timeout=1)
+        lock_source = candidate
+        break
+    except Exception:
+        pass
+if lock_source is None:
+    emit({'type':'status','state':'unavailable','reason':'session_lock_state_unavailable'})
+    sys.exit(0)
+pending = 0
+maximum = 0
+last_capture = -${policy.minimumIntervalMs / 1000}
+burst_started = 0
+burst_captures = 0
+noise_paused = False
+editing = False
+editing_key = None
+editing_document = None
+def active():
+    desktop = pyatspi.Registry.getDesktop(0)
+    for app in desktop:
+        if app is None: continue
+        for window in app:
+            if window is not None and window.getState().contains(pyatspi.STATE_ACTIVE):
+                return app, window
+    return None, None
+def process_id(app):
+    return int(app.get_process_id())
+def object_id(item):
+    return str(item.path)
+def document_scope(window):
+    queue, count = [window], 0
+    started = time.monotonic()
+    while queue and count < 400 and time.monotonic()-started < 0.25:
+        item = queue.pop(0)
+        count += 1
+        if not item.getState().contains(pyatspi.STATE_SHOWING): continue
+        if item.getState().contains(pyatspi.STATE_FOCUSED):
+            ancestor, found = item, None
+            for depth in range(32):
+                if ancestor is None: break
+                if ancestor == window: return found
+                if found is None and ancestor.getRole() in [pyatspi.ROLE_DOCUMENT_FRAME,pyatspi.ROLE_DOCUMENT_WEB,pyatspi.ROLE_DOCUMENT_TEXT]: found = ancestor
+                ancestor = ancestor.parent
+        for child in item:
+            if len(queue) >= 400: break
+            if child is not None: queue.append(child)
+    return None
+def documents(window):
+    document = document_scope(window)
+    return object_id(document) if document is not None else ''
+def visible_leaf(item, window):
+    try:
+        rect = item.queryComponent().getExtents(pyatspi.DESKTOP_COORDS)
+        frame = window.queryComponent().getExtents(pyatspi.DESKTOP_COORDS)
+        return rect.width > 0 and rect.height > 0 and frame.width > 0 and frame.height > 0 and rect.x < frame.x + frame.width and rect.x + rect.width > frame.x and rect.y < frame.y + frame.height and rect.y + rect.height > frame.y
+    except (NotImplementedError, AttributeError):
+        return False
+def window_key(app, window):
+    return str(process_id(app)) + ':' + object_id(window) + ':' + str(window.name)
+def identity(app, window):
+    return window_key(app,window) + ':' + documents(window)
+def capture():
+    global pending, maximum, editing, last_capture, burst_started, burst_captures, noise_paused
+    if pending: GLib.source_remove(pending)
+    if maximum: GLib.source_remove(maximum)
+    pending = maximum = 0
+    now = time.monotonic()
+    if noise_paused:
+        noise_paused, burst_captures = False, 0
+    if now-last_capture < ${policy.minimumIntervalMs / 1000}:
+        pending = GLib.timeout_add(max(1,int((${policy.minimumIntervalMs / 1000}-(now-last_capture))*1000)),capture)
+        return False
+    if now-burst_started > ${policy.burstWindowMs / 1000}:
+        burst_started, burst_captures = now, 0
+    if not editing: burst_captures += 1
+    if burst_captures > ${policy.burstLimit}:
+        noise_paused = True
+        emit({'type':'status','state':'paused','reason':'continuous_activity'})
+        pending = GLib.timeout_add(${policy.resumeQuietMs},capture)
+        return False
+    last_capture = now
+    kind = 'edit' if editing else 'view'
+    editing = False
+    try:
+        if bool(lock_source.GetActive(timeout=1)):
+            emit({'type':'status','state':'paused','reason':'screen_locked'})
+            return False
+        app, window = active()
+        if window is None: return False
+        app_name = str(app.name)
+        if app_name.casefold() in excluded:
+            emit({'type':'status','state':'paused','reason':'application_excluded'})
+            return False
+        key = identity(app, window)
+        document_ids = documents(window)
+        edit_matches = editing_key == window_key(app,window)
+        if editing_document and editing_document not in document_ids.split('|'): edit_matches = False
+        kind = 'edit' if kind == 'edit' and edit_matches else 'view'
+        content_root = document_scope(window)
+        queue, parts, seen = [content_root if content_root is not None else window], [], set()
+        started = time.monotonic()
+        count = 0
+        while queue and count < 600 and time.monotonic()-started < 0.4 and sum(map(len,parts)) < 24000:
+            item = queue.pop(0)
+            count += 1
+            state = item.getState()
+            if item.getRole() == pyatspi.ROLE_PASSWORD_TEXT: continue
+            if not state.contains(pyatspi.STATE_SHOWING): continue
+            if content_root is None and item.getRole() in [pyatspi.ROLE_DOCUMENT_FRAME,pyatspi.ROLE_DOCUMENT_WEB,pyatspi.ROLE_DOCUMENT_TEXT]: continue
+            text = ''
+            # Read leaf text/editable values, not a parent document that could include protected descendants.
+            if item.childCount == 0 and visible_leaf(item,window):
+                try:
+                    text_api = item.queryText()
+                    text = text_api.getText(0,min(text_api.characterCount,24000))
+                except (NotImplementedError, AttributeError):
+                    if item.getRole() in [pyatspi.ROLE_LABEL,pyatspi.ROLE_TEXT,pyatspi.ROLE_HEADING]: text = item.name or ''
+            if text and text not in seen:
+                seen.add(text)
+                parts.append(text)
+            for child in item:
+                if len(queue) >= 600: break
+                if child is not None: queue.append(child)
+        after_app, after_window = active()
+        if after_window is None or identity(after_app,after_window) != key or bool(lock_source.GetActive(timeout=1)): return False
+        emit({'type':'snapshot','source':{'app':app_name,'processId':process_id(app),'windowId':object_id(window),'documentId':documents(window),'title':str(window.name)},'content':'\n'.join(parts),'kind':kind,'extraction':'atspi','coverage':'partial' if parts else 'metadata_only','coverageReason':'visible_accessibility_subset','beforeKey':key,'afterKey':key})
+        emit({'type':'status','state':'partial','reason':'atspi_application_coverage'})
+    except Exception:
+        emit({'type':'status','state':'partial','reason':'accessibility_read_unavailable'})
+    return False
+def schedule_capture():
+    global pending, maximum
+    if pending: GLib.source_remove(pending)
+    pending = GLib.timeout_add(${policy.resumeQuietMs} if noise_paused else 1200, capture)
+    if not noise_paused and not maximum: maximum = GLib.timeout_add(5000, capture)
+def changed(event=None, *args, switched=False):
+    global pending, maximum, editing, editing_key, editing_document, noise_paused, burst_captures, burst_started
+    if switched:
+        noise_paused, burst_captures, burst_started = False, 0, time.monotonic()
+    if event is not None and hasattr(event,'type'):
+        try:
+            event_type = str(event.type)
+            editable_event = event_type.startswith('object:text-changed') and event.source.getState().contains(pyatspi.STATE_EDITABLE)
+            if noise_paused and not editable_event and not event_type.startswith('window:activate'):
+                schedule_capture()
+                return
+            app, current = active()
+            if current is None: return
+            source = event.source
+            ancestor = source
+            document = None
+            for depth in range(32):
+                if ancestor is None or ancestor == current: break
+                if ancestor.getRole() in [pyatspi.ROLE_DOCUMENT_FRAME,pyatspi.ROLE_DOCUMENT_WEB,pyatspi.ROLE_DOCUMENT_TEXT]: document = object_id(ancestor)
+                ancestor = ancestor.parent
+            if ancestor != current: return
+            if editable_event:
+                editing = True
+                editing_key = window_key(app,current)
+                editing_document = document
+            if editing or event_type.startswith('window:activate'):
+                noise_paused, burst_captures, burst_started = False, 0, time.monotonic()
+        except Exception: return
+    schedule_capture()
+pyatspi.Registry.registerEventListener(changed,'window:activate','object:state-changed:focused','object:property-change:accessible-name','object:text-changed','object:children-changed','object:visible-data-changed')
+bus.add_signal_receiver(changed, signal_name='ActiveChanged')
+if os.environ.get('DISPLAY') and not os.environ.get('WAYLAND_DISPLAY'):
+    # X11 root-property notifications supplement accessibility focus events, without polling.
+    try:
+        import ctypes
+        x11 = ctypes.CDLL('libX11.so.6')
+        x11.XOpenDisplay.restype = ctypes.c_void_p
+        x11.XDefaultRootWindow.argtypes = [ctypes.c_void_p]
+        x11.XDefaultRootWindow.restype = ctypes.c_ulong
+        x11.XConnectionNumber.argtypes = [ctypes.c_void_p]
+        x11.XSelectInput.argtypes = [ctypes.c_void_p,ctypes.c_ulong,ctypes.c_long]
+        x11.XPending.argtypes = [ctypes.c_void_p]
+        x11.XNextEvent.argtypes = [ctypes.c_void_p,ctypes.c_void_p]
+        x11.XInternAtom.argtypes = [ctypes.c_void_p,ctypes.c_char_p,ctypes.c_int]
+        x11.XInternAtom.restype = ctypes.c_ulong
+        class XPropertyEvent(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),('atom',ctypes.c_ulong),('time',ctypes.c_ulong),('state',ctypes.c_int)]
+        display = x11.XOpenDisplay(None)
+        if display:
+            active_window_atom = x11.XInternAtom(display,b'_NET_ACTIVE_WINDOW',False)
+            x11.XSelectInput(display,x11.XDefaultRootWindow(display),1 << 22)
+            def xchanged(fd, condition):
+                event = (ctypes.c_long * 24)()
+                switched = False
+                for count in range(64):
+                    if not x11.XPending(display): break
+                    x11.XNextEvent(display,ctypes.byref(event))
+                    property_event = ctypes.cast(ctypes.byref(event),ctypes.POINTER(XPropertyEvent)).contents
+                    if property_event.type == 28 and property_event.atom == active_window_atom:
+                        switched = True
+                if switched: changed(switched=True)
+                return True
+            GLib.io_add_watch(x11.XConnectionNumber(display),GLib.IO_IN,xchanged)
+    except Exception:
+        emit({'type':'status','state':'partial','reason':'x11_events_unavailable_atspi_only'})
+emit({'type':'status','state':'partial','reason':'wayland_atspi_coverage' if os.environ.get('WAYLAND_DISPLAY') else 'x11_atspi_coverage'})
+changed()
+pyatspi.Registry.start()
+`;

package/dist/src/computer-access/companion/observation-macos-permission.d.ts

@@ -0,0 +1,2 @@
+/** Pure Swift permission gate; injected effects keep native tests free of TCC requests. */
+export declare const MACOS_OBSERVATION_PERMISSION_SCRIPT: string;

package/dist/src/computer-access/companion/observation-macos-permission.js

@@ -0,0 +1,26 @@
+/** Pure Swift permission gate; injected effects keep native tests free of TCC requests. */
+export const MACOS_OBSERVATION_PERMISSION_SCRIPT = String.raw `
+func waitForMacObservationPermission(
+  isTrusted: () -> Bool,
+  requestPermission: () -> Void,
+  now: () -> Double,
+  wait: (Double) -> Void,
+  reportRequired: () -> Void,
+  reportTimeout: () -> Void
+) -> Bool {
+  if isTrusted() { return true }
+  let deadline = now() + 120
+  requestPermission()
+  reportRequired()
+  while true {
+    let remaining = deadline - now()
+    let permissionWaitExpired = remaining <= 0
+    if permissionWaitExpired {
+      reportTimeout()
+      return false
+    }
+    wait(min(2, remaining))
+    if isTrusted() { return true }
+  }
+}
+`;

package/dist/src/computer-access/companion/observation-macos.d.ts

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