@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/computer-access/companion/native-notifications.js

@@ -0,0 +1,84 @@
+import { failureResult, successResult, } from "../../plugin-sdk/index.js";
+import { readDesktopNotification, } from "./notification-protocol.js";
+import { defaultNotificationLocations, } from "./notification-locations.js";
+import { sendWindowsNotification } from "./notification-windows.js";
+import { sendMacNotification } from "./notification-macos.js";
+import { LinuxNotificationRenderer } from "./notification-linux.js";
+import { stopMacNotificationApp } from "./notification-installation.js";
+import { runNotificationProcess } from "./notification-process.js";
+import { hasDesktopNotificationSupport } from "./notification-readiness.js";
+import { NotificationReadinessState } from "./notification-readiness-state.js";
+function hasUnknownNotificationOutcome(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (error.name === "AbortError")
+        return true;
+    if (error.message === "notification_native_timeout")
+        return true;
+    return error.message === "notification_cancelled";
+}
+export function createNotificationSession(platform, runtimeUrl, ready, renderer, probe) {
+    const readiness = new NotificationReadinessState(ready, probe);
+    return {
+        get ready() {
+            return readiness.ready;
+        },
+        refreshReadiness: (signal) => readiness.refresh(signal),
+        handlers: () => ({
+            desktop_notification: async (params, context) => {
+                if (!readiness.ready)
+                    return failureResult({
+                        errorCode: "notification_setup_required",
+                        message: "Desktop notifications are unavailable. Update Computer access setup and check the operating system notification settings.",
+                    });
+                try {
+                    const notification = readDesktopNotification(params, platform, runtimeUrl);
+                    context?.abortSignal?.throwIfAborted();
+                    await renderer.send(notification, context?.abortSignal);
+                    return successResult({
+                        output: "Notification submitted to the desktop notification service.",
+                        data: {
+                            notificationId: notification.notificationId,
+                            delivery: "submitted",
+                        },
+                    });
+                }
+                catch (error) {
+                    return failureResult({
+                        errorCode: hasUnknownNotificationOutcome(error)
+                            ? "notification_outcome_unknown"
+                            : "notification_native_failed",
+                        message: error instanceof Error
+                            ? error.message.slice(0, 1000)
+                            : "Desktop notification submission failed.",
+                    });
+                }
+            },
+        }),
+        close: () => renderer.close(),
+    };
+}
+export async function createNativeNotificationSession(platform, runtimeUrl, locations = defaultNotificationLocations(), signal) {
+    signal?.throwIfAborted();
+    const linux = new LinuxNotificationRenderer();
+    const ready = await hasDesktopNotificationSupport(platform, locations, runNotificationProcess, signal);
+    signal?.throwIfAborted();
+    const session = createNotificationSession(platform, runtimeUrl, ready, {
+        async send(notification, signal) {
+            if (platform === "windows")
+                return sendWindowsNotification(notification, signal);
+            if (platform === "macos")
+                return sendMacNotification(notification, locations, signal);
+            return linux.send(notification, signal);
+        },
+        async close() {
+            linux.close();
+            if (platform === "macos" && session.ready)
+                await stopMacNotificationApp(locations, runNotificationProcess).catch((error) => {
+                    console.warn("Desktop notification helper could not stop: " +
+                        (error instanceof Error ? error.message : String(error)));
+                });
+        },
+    }, (refreshSignal) => hasDesktopNotificationSupport(platform, locations, runNotificationProcess, refreshSignal));
+    return session;
+}

package/dist/src/computer-access/companion/native-observations.d.ts

@@ -0,0 +1,15 @@
+import type { PassiveCollectorEvent } from "../../shared/passive-observation.js";
+import { type DesktopCollector } from "./observation-process.js";
+import { type ObservationControl } from "./observation-protocol.js";
+export type ObservationCollectorFactory = (options: {
+    excludedApplications: readonly string[];
+    onEvent(event: PassiveCollectorEvent): void;
+}) => DesktopCollector;
+export declare class NativeObservationSession {
+    private readonly send;
+    private readonly start;
+    private lease?;
+    constructor(send: (message: unknown) => void, start?: ObservationCollectorFactory);
+    receive(control: ObservationControl): void;
+    close(): void;
+}

package/dist/src/computer-access/companion/native-observations.js

@@ -0,0 +1,67 @@
+import { startDesktopCollector, } from "./observation-process.js";
+import { OBSERVATION_LEASE_MS, } from "./observation-protocol.js";
+export class NativeObservationSession {
+    send;
+    start;
+    lease;
+    constructor(send, start = startDesktopCollector) {
+        this.send = send;
+        this.start = start;
+    }
+    receive(control) {
+        if (control.type === "observe_start") {
+            if (this.lease)
+                throw new Error("observation_lease_already_active");
+            const lease = {
+                ownerId: control.ownerId,
+                leaseId: control.leaseId,
+                collector: { close() { } },
+                deadline: setTimeout(() => this.close(), OBSERVATION_LEASE_MS),
+            };
+            this.lease = lease;
+            const onEvent = (event) => {
+                if (this.lease !== lease)
+                    return;
+                this.send({
+                    type: "observation_event",
+                    ownerId: lease.ownerId,
+                    leaseId: lease.leaseId,
+                    event,
+                });
+            };
+            try {
+                lease.collector = this.start({
+                    excludedApplications: control.excludedApplications ?? [],
+                    onEvent,
+                });
+            }
+            catch {
+                onEvent({
+                    type: "status",
+                    state: "failed",
+                    reason: "collector_start_failed",
+                });
+            }
+            return;
+        }
+        const lease = this.lease;
+        if (!lease ||
+            lease.ownerId !== control.ownerId ||
+            lease.leaseId !== control.leaseId)
+            return;
+        if (control.type === "observe_stop") {
+            this.close();
+            return;
+        }
+        clearTimeout(lease.deadline);
+        lease.deadline = setTimeout(() => this.close(), OBSERVATION_LEASE_MS);
+    }
+    close() {
+        const lease = this.lease;
+        if (!lease)
+            return;
+        this.lease = undefined;
+        clearTimeout(lease.deadline);
+        lease.collector.close();
+    }
+}

package/dist/src/computer-access/companion/native-permissions.d.ts

@@ -0,0 +1,14 @@
+import { type ExecFileOptionsWithStringEncoding } from "node:child_process";
+import { type ToolImplementation } from "../../plugin-sdk/index.js";
+import { missingMacosComputerPrerequisite } from "../computer/macos-prerequisites.js";
+import { type MacPermissionAction, type MacPermissionResult } from "./permission-protocol.js";
+/** Launched by the calling Runtime/companion, just like its real Swift computer helper. */
+export declare function prepareMacPermissions(action: MacPermissionAction, signal?: AbortSignal, dependencies?: {
+    platform?: string;
+    execute?: (file: string, args: string[], options: ExecFileOptionsWithStringEncoding) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    prerequisite?: typeof missingMacosComputerPrerequisite;
+}): Promise<MacPermissionResult>;
+export declare function createNativePermissionHandlers(platform: string, prepare?: typeof prepareMacPermissions): Record<string, ToolImplementation>;

package/dist/src/computer-access/companion/native-permissions.js

@@ -0,0 +1,49 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { failureResult, successResult } from "../../plugin-sdk/index.js";
+import { MACOS_PERMISSION_HELPER } from "../computer/macos-permission-helper.js";
+import { missingMacosComputerPrerequisite } from "../computer/macos-prerequisites.js";
+import { isMacPermissionAction, isMacPermissionStatus, MACOS_PERMISSION_OPERATION, } from "./permission-protocol.js";
+const executeFile = promisify(execFile);
+/** Launched by the calling Runtime/companion, just like its real Swift computer helper. */
+export async function prepareMacPermissions(action, signal, dependencies = {}) {
+    if ((dependencies.platform ?? process.platform) !== "darwin")
+        throw new Error("macos_permissions_platform_required");
+    if (!isMacPermissionAction(action))
+        throw new Error("macos_permissions_input_invalid");
+    signal?.throwIfAborted();
+    const prerequisite = await (dependencies.prerequisite ?? missingMacosComputerPrerequisite)();
+    if (prerequisite)
+        throw new Error(prerequisite);
+    const requested = action.action === "request" ? action.permission : "check";
+    const output = await (dependencies.execute ?? executeFile)("/usr/bin/swift", ["-swift-version", "5", "-e", MACOS_PERMISSION_HELPER, requested], { timeout: 45_000, maxBuffer: 16_384, encoding: "utf8", signal });
+    const permissions = JSON.parse(String(output.stdout));
+    if (!isMacPermissionStatus(permissions))
+        throw new Error("macos_permissions_result_invalid");
+    return {
+        permissions,
+        executablePath: process.execPath,
+        restartMayBeRequired: requested === "screen_recording",
+    };
+}
+export function createNativePermissionHandlers(platform, prepare = prepareMacPermissions) {
+    if (platform !== "macos")
+        return {};
+    return {
+        [MACOS_PERMISSION_OPERATION]: async (params, context) => {
+            const { target, ...action } = params;
+            if (target !== "macos" || !isMacPermissionAction(action))
+                return failureResult({ errorCode: "macos_permissions_input_invalid", message: "Choose a permission check or one explicit permission request." });
+            try {
+                const result = await prepare(action, context?.abortSignal);
+                return successResult({ output: "Mac permission preparation completed.", data: result });
+            }
+            catch {
+                return failureResult({
+                    errorCode: "macos_permissions_check_failed",
+                    message: "Permission preparation could not complete. Check that macOS 14 or later and Swift developer tools are available, then check again. No desktop content was collected.",
+                });
+            }
+        },
+    };
+}

package/dist/src/computer-access/companion/native-replacement.d.ts

@@ -0,0 +1,19 @@
+import { readLockSnapshot } from "../../runtime/adapters/long-term-memory/file-lock/snapshot.js";
+import { isProcessOwnerAlive, readProcessOwnerIdentity } from "./process-owner-identity.js";
+export type NativeReplacementDependencies = Readonly<{
+    platform: NodeJS.Platform;
+    currentPid: number;
+    readLock: typeof readLockSnapshot;
+    readIdentity: typeof readProcessOwnerIdentity;
+    isAlive: typeof isProcessOwnerAlive;
+    signal(pid: number, signal: "SIGTERM"): void;
+    execute(file: string, args: readonly string[], options: {
+        windowsHide: true;
+        timeout: number;
+        maxBuffer: number;
+    }): Promise<void>;
+    now(): number;
+    delay(milliseconds: number): Promise<void>;
+}>;
+/** Retire only the lock's verified process incarnation; the new owner reclaims its own lock. */
+export declare function stopOwnedNativeCompanion(stateDir: string, overrides?: Partial<NativeReplacementDependencies>): Promise<void>;

package/dist/src/computer-access/companion/native-replacement.js

@@ -0,0 +1,120 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { promisify } from "node:util";
+import { readLockSnapshot } from "../../runtime/adapters/long-term-memory/file-lock/snapshot.js";
+import { hasSameProcessOwnerIdentity, isProcessOwnerAlive, readProcessOwnerIdentity, } from "./process-owner-identity.js";
+const executeFile = promisify(execFile);
+const STOP_WAIT_MS = 10_000;
+function replacementFailure(reason) {
+    return new Error(`The running Host Companion could not be safely replaced (${reason}). Close the existing Host Companion, then run the updated setup again. The saved pairing was not changed.`);
+}
+async function readReplacementLock(path, dependencies) {
+    try {
+        return await dependencies.readLock(path);
+    }
+    catch {
+        throw replacementFailure("ownership lock unreadable");
+    }
+}
+function requireRecordedOwner(snapshot) {
+    if (snapshot.kind !== "directory")
+        throw replacementFailure("legacy ownership lock");
+    if (!snapshot.record)
+        throw replacementFailure("ownership record unavailable");
+    return snapshot.record;
+}
+function isReclaimableLockWithoutRecord(snapshot) {
+    if (snapshot.kind !== "directory")
+        return false;
+    if (!snapshot.reclaimable)
+        return false;
+    return snapshot.record === undefined;
+}
+function isSameCompanionOwner(snapshot, owner) {
+    if (snapshot.kind !== "directory")
+        return false;
+    if (!snapshot.record)
+        return false;
+    if (snapshot.record.pid !== owner.pid)
+        return false;
+    if (snapshot.record.token !== owner.token)
+        return false;
+    return snapshot.record.ownerIdentity === owner.ownerIdentity;
+}
+async function verifyLiveCompanionOwner(owner, dependencies) {
+    if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0)
+        throw replacementFailure("invalid owner PID");
+    if (owner.pid === dependencies.currentPid)
+        throw replacementFailure("setup owns the companion lock");
+    if (!(await dependencies.isAlive(owner.pid)))
+        return false;
+    if (!owner.ownerIdentity)
+        throw replacementFailure("process identity unavailable");
+    const observed = await dependencies.readIdentity(owner.pid);
+    if (!observed)
+        throw replacementFailure("process identity unreadable");
+    if (!hasSameProcessOwnerIdentity(owner.ownerIdentity, observed))
+        throw replacementFailure("process identity changed");
+    return true;
+}
+async function stopCompanionProcess(owner, dependencies) {
+    try {
+        if (dependencies.platform === "win32") {
+            await dependencies.execute("taskkill.exe", ["/PID", String(owner.pid), "/T", "/F"], {
+                windowsHide: true,
+                timeout: STOP_WAIT_MS,
+                maxBuffer: 4096,
+            });
+            return;
+        }
+        dependencies.signal(owner.pid, "SIGTERM");
+    }
+    catch {
+        if (!(await dependencies.isAlive(owner.pid, owner.ownerIdentity)))
+            return;
+        throw replacementFailure("process could not be stopped");
+    }
+}
+/** Retire only the lock's verified process incarnation; the new owner reclaims its own lock. */
+export async function stopOwnedNativeCompanion(stateDir, overrides = {}) {
+    const dependencies = {
+        platform: process.platform,
+        currentPid: process.pid,
+        readLock: readLockSnapshot,
+        readIdentity: readProcessOwnerIdentity,
+        isAlive: isProcessOwnerAlive,
+        signal: (pid, signal) => {
+            process.kill(pid, signal);
+        },
+        execute: async (file, args, options) => {
+            await executeFile(file, [...args], options);
+        },
+        now: Date.now,
+        delay,
+        ...overrides,
+    };
+    const lockPath = join(stateDir, "agent");
+    const initial = await readReplacementLock(lockPath, dependencies);
+    if (!initial)
+        return;
+    if (isReclaimableLockWithoutRecord(initial))
+        return;
+    const owner = requireRecordedOwner(initial);
+    if (!(await verifyLiveCompanionOwner(owner, dependencies)))
+        return;
+    const current = await readReplacementLock(lockPath, dependencies);
+    if (!current)
+        return;
+    if (!isSameCompanionOwner(current, owner))
+        throw replacementFailure("ownership changed during setup");
+    if (!(await verifyLiveCompanionOwner(owner, dependencies)))
+        return;
+    await stopCompanionProcess(owner, dependencies);
+    const deadline = dependencies.now() + STOP_WAIT_MS;
+    while (await dependencies.isAlive(owner.pid, owner.ownerIdentity)) {
+        if (dependencies.now() >= deadline)
+            throw replacementFailure("process did not stop in time");
+        await dependencies.delay(100);
+    }
+}

package/dist/src/computer-access/companion/native-runtime-installation.d.ts

@@ -0,0 +1,15 @@
+import type { NativeAutostartOptions } from "./autostart.js";
+export declare const NATIVE_RUNTIME_INSTALLATION_FAILURE = "The Mac companion runtime could not be prepared safely. The saved pairing was not changed. Check the local Node.js installation and run setup again.";
+type RuntimeVersionOptions = Readonly<{
+    encoding: "utf8";
+    timeout: number;
+    maxBuffer: number;
+    killSignal: "SIGKILL";
+    windowsHide: true;
+}>;
+export type NativeRuntimeInstallationDependencies = Readonly<{
+    execute(file: string, args: readonly string[], options: RuntimeVersionOptions): Promise<string>;
+}>;
+/** The stopped Mac companion uses one private executable path across Node upgrades. */
+export declare function prepareNativeCompanionRuntime(startup: NativeAutostartOptions, overrides?: Partial<NativeRuntimeInstallationDependencies>): Promise<NativeAutostartOptions>;
+export {};

package/dist/src/computer-access/companion/native-runtime-installation.js

@@ -0,0 +1,218 @@
+import { execFile } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { assertPrivateRuntimeAccess } from "../../runtime/local-host/private-access.js";
+import { ensurePrivateRuntimeDirectory } from "../../runtime/local-host/private-directory.js";
+const executeFile = promisify(execFile);
+export const NATIVE_RUNTIME_INSTALLATION_FAILURE = "The Mac companion runtime could not be prepared safely. The saved pairing was not changed. Check the local Node.js installation and run setup again.";
+function runtimeInstallationFailure() {
+    return new Error(NATIVE_RUNTIME_INSTALLATION_FAILURE);
+}
+function isAbsentRuntimePath(error) {
+    if (!error || typeof error !== "object" || !("code" in error))
+        return false;
+    return error.code === "ENOENT";
+}
+function hasSameRuntimeIdentity(left, right) {
+    if (left.dev !== right.dev)
+        return false;
+    if (left.ino !== right.ino)
+        return false;
+    if (left.size !== right.size)
+        return false;
+    if (left.mtimeMs !== right.mtimeMs)
+        return false;
+    return left.ctimeMs === right.ctimeMs;
+}
+function hasTrustedRuntimeSource(stat) {
+    if (!stat.isFile())
+        return false;
+    if (stat.isSymbolicLink())
+        return false;
+    if ((stat.mode & 0o111) === 0)
+        return false;
+    if ((stat.mode & 0o022) !== 0)
+        return false;
+    if (stat.uid === 0)
+        return true;
+    return stat.uid === process.getuid?.();
+}
+async function requireManagedRuntimeFile(path, stat) {
+    if (!stat.isFile())
+        throw runtimeInstallationFailure();
+    if (stat.isSymbolicLink())
+        throw runtimeInstallationFailure();
+    if (stat.nlink !== 1)
+        throw runtimeInstallationFailure();
+    if ((stat.mode & 0o777) !== 0o500)
+        throw runtimeInstallationFailure();
+    await assertPrivateRuntimeAccess(path, stat, NATIVE_RUNTIME_INSTALLATION_FAILURE);
+}
+async function streamRuntimeDigest(handle) {
+    const hash = createHash("sha256");
+    for await (const chunk of handle.createReadStream({
+        start: 0,
+        autoClose: false,
+    }))
+        hash.update(chunk);
+    return hash.digest("hex");
+}
+async function readRuntimeFile(path, managed) {
+    const stat = await lstat(path).catch((error) => {
+        if (isAbsentRuntimePath(error))
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return undefined;
+    if (managed)
+        await requireManagedRuntimeFile(path, stat);
+    if (!managed && !hasTrustedRuntimeSource(stat))
+        throw runtimeInstallationFailure();
+    const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        if (!hasSameRuntimeIdentity(stat, await handle.stat()))
+            throw runtimeInstallationFailure();
+        const digest = await streamRuntimeDigest(handle);
+        if (!hasSameRuntimeIdentity(stat, await handle.stat()))
+            throw runtimeInstallationFailure();
+        if (!hasSameRuntimeIdentity(stat, await lstat(path)))
+            throw runtimeInstallationFailure();
+        return { stat, digest };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function runtimeVersion(path, dependencies) {
+    const version = (await dependencies.execute(path, ["--version"], {
+        encoding: "utf8",
+        timeout: 5_000,
+        maxBuffer: 1_024,
+        killSignal: "SIGKILL",
+        windowsHide: true,
+    })).trim();
+    if (!/^v\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/u.test(version))
+        throw runtimeInstallationFailure();
+    return version;
+}
+async function requireRuntimeVersion(path, expected, dependencies) {
+    if ((await runtimeVersion(path, dependencies)) !== expected)
+        throw runtimeInstallationFailure();
+}
+async function copyRuntimeSource(source, staged, expected) {
+    const input = await open(source, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        if (!hasSameRuntimeIdentity(expected.stat, await input.stat()))
+            throw runtimeInstallationFailure();
+        const output = await open(staged, constants.O_WRONLY |
+            constants.O_CREAT |
+            constants.O_EXCL |
+            constants.O_NOFOLLOW, 0o600);
+        try {
+            const hash = createHash("sha256");
+            for await (const chunk of input.createReadStream({
+                start: 0,
+                autoClose: false,
+            })) {
+                hash.update(chunk);
+                await output.writeFile(chunk);
+            }
+            if (hash.digest("hex") !== expected.digest)
+                throw runtimeInstallationFailure();
+            if (!hasSameRuntimeIdentity(expected.stat, await input.stat()))
+                throw runtimeInstallationFailure();
+            await output.chmod(0o500);
+            await output.sync();
+        }
+        finally {
+            await output.close();
+        }
+    }
+    finally {
+        await input.close();
+    }
+}
+async function requireUnchangedRuntimeTarget(path, expected) {
+    const current = await readRuntimeFile(path, true);
+    if (!expected) {
+        if (current)
+            throw runtimeInstallationFailure();
+        return;
+    }
+    if (!current)
+        throw runtimeInstallationFailure();
+    if (!hasSameRuntimeIdentity(expected.stat, current.stat))
+        throw runtimeInstallationFailure();
+    if (current.digest !== expected.digest)
+        throw runtimeInstallationFailure();
+}
+async function requireUnchangedRuntimeDirectory(path, expected) {
+    await ensurePrivateRuntimeDirectory(path);
+    const current = await lstat(path);
+    if (expected.dev !== current.dev)
+        throw runtimeInstallationFailure();
+    if (expected.ino !== current.ino)
+        throw runtimeInstallationFailure();
+}
+async function installManagedRuntime(startup, dependencies) {
+    await ensurePrivateRuntimeDirectory(startup.stateDir);
+    const stateIdentity = await lstat(startup.stateDir);
+    const directory = join(startup.stateDir, "runtime");
+    await ensurePrivateRuntimeDirectory(directory);
+    const directoryIdentity = await lstat(directory);
+    const target = join(directory, "node");
+    const source = await readRuntimeFile(startup.nodePath, false);
+    if (!source)
+        throw runtimeInstallationFailure();
+    const existing = await readRuntimeFile(target, true);
+    const expectedVersion = await runtimeVersion(startup.nodePath, dependencies);
+    if (existing?.digest === source.digest) {
+        await requireRuntimeVersion(target, expectedVersion, dependencies);
+        await requireUnchangedRuntimeDirectory(startup.stateDir, stateIdentity);
+        await requireUnchangedRuntimeDirectory(directory, directoryIdentity);
+        await requireUnchangedRuntimeTarget(target, existing);
+        return target;
+    }
+    const staged = join(directory, ".node-" + randomUUID() + ".tmp");
+    try {
+        await copyRuntimeSource(startup.nodePath, staged, source);
+        const stagedFile = await readRuntimeFile(staged, true);
+        if (stagedFile?.digest !== source.digest)
+            throw runtimeInstallationFailure();
+        await requireRuntimeVersion(staged, expectedVersion, dependencies);
+        await requireUnchangedRuntimeTarget(staged, stagedFile);
+        await requireUnchangedRuntimeDirectory(startup.stateDir, stateIdentity);
+        await requireUnchangedRuntimeDirectory(directory, directoryIdentity);
+        await requireUnchangedRuntimeTarget(target, existing);
+        await rename(staged, target);
+        return target;
+    }
+    finally {
+        await unlink(staged).catch((error) => {
+            if (!isAbsentRuntimePath(error))
+                throw error;
+        });
+    }
+}
+/** The stopped Mac companion uses one private executable path across Node upgrades. */
+export async function prepareNativeCompanionRuntime(startup, overrides = {}) {
+    if (startup.platform !== "darwin")
+        return startup;
+    const dependencies = {
+        execute: async (file, args, options) => (await executeFile(file, [...args], options)).stdout,
+        ...overrides,
+    };
+    try {
+        return {
+            ...startup,
+            nodePath: await installManagedRuntime(startup, dependencies),
+        };
+    }
+    catch {
+        throw runtimeInstallationFailure();
+    }
+}

package/dist/{plugins/system/source → src/computer-access}/companion/native-session.d.ts

@@ -1,4 +1,6 @@
-import type { ToolImplementation } from "../../../../src/plugin-sdk/index.js";
+import { type NativeNotificationSession } from "./native-notifications.js";
+import { type ObservationCollectorFactory } from "./native-observations.js";
+import type { ToolImplementation } from "../../plugin-sdk/index.js";
 import { type NativeHostResolver } from "./native-address.js";
 import { type HostIdentity } from "./protocol.js";
 export type NativeSessionOutcome = "disconnected" | "authorization_rejected" | "protocol_rejected" | "stopped";
@@ -14,6 +16,8 @@ export type NativeSessionOptions = Readonly<{
     handlers?: Record<string, ToolImplementation>;
     heartbeatMs?: number;
     operationLimit?: number;
+    observationCollector?: ObservationCollectorFactory;
+    notifications?: NativeNotificationSession;
 }>;
 /** One connection lifetime. Its pending actions are never retried or replayed. */
 export declare function connectNativeHost(options: NativeSessionOptions): Promise<NativeSessionOutcome>;