@abot-ai/runtime 1.6.0 → 1.7.0

package/dist/src/computer-access/companion/install-link.js

@@ -0,0 +1,54 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parsePluginInstallLink } from "../../plugin-contract/install-source.js";
+import { notificationRuntimeOrigin } from "./notification-protocol.js";
+export function pluginInstallReviewUrl(link, runtimeUrl) {
+    const source = parsePluginInstallLink(link);
+    const url = new URL("/plugins", notificationRuntimeOrigin(runtimeUrl));
+    url.searchParams.set("tab", "discover");
+    url.searchParams.set("pluginSource", source.repository);
+    if (source.ref)
+        url.searchParams.set("pluginRef", source.ref);
+    if (source.path)
+        url.searchParams.set("pluginPath", source.path);
+    return url.toString();
+}
+/** The saved pairing owns the destination. Incoming links cannot select a host. */
+export async function openPluginInstallLink(state, link, open = openReviewBrowser) {
+    parsePluginInstallLink(link);
+    const connection = await state.read();
+    if (!connection)
+        throw new Error("Connect Computer Access before opening an ABot installation link.");
+    await open(pluginInstallReviewUrl(link, connection.url));
+}
+async function openReviewBrowser(url) {
+    const execute = promisify(execFile);
+    const options = { windowsHide: true, timeout: 10_000, maxBuffer: 16_384 };
+    if (process.platform === "win32") {
+        await execute("rundll32.exe", ["url.dll,FileProtocolHandler", url], options);
+        return;
+    }
+    if (process.platform === "darwin") {
+        await execute("/usr/bin/open", [url], options);
+        return;
+    }
+    if (process.platform === "linux") {
+        await execute("xdg-open", [url], options);
+        return;
+    }
+    throw new Error("ABot installation links are not supported on this platform.");
+}
+/** Windows Script Host expands percent-delimited environment variables in Run().
+ * The launcher sends base64 so a website URL can never interpolate local values. */
+export function parsePluginInstallArguments(args) {
+    if (args.length === 1)
+        return args[0];
+    if (args.length !== 2 || args[0] !== "--encoded")
+        throw new Error("Usage: abot host open-link <abot://install link>");
+    const encoded = args[1];
+    if (encoded.length > 12_000 || !/^[A-Za-z0-9+/]+={0,2}$/u.test(encoded))
+        throw new Error("Invalid encoded installation link.");
+    const decoded = Buffer.from(encoded, "base64").toString("utf8");
+    parsePluginInstallLink(decoded);
+    return decoded;
+}

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

@@ -62,6 +62,9 @@ const NATIVE_OPERATION_FIELDS = {
     desktop_notification: ["target", "notificationId", "title", "body", "url"],
     system_targets: [],
     system_command: ["target", "command", "cwd", "elevated", "timeout_ms"],
+    system_command_capture: ["target", "command", "cwd", "elevated", "timeout_ms", "outputRetentionMs"],
+    system_command_output: ["target", "captureId", "stream", "offset"],
+    system_command_output_close: ["target", "captureId"],
     system_applications: ["target", "query", "limit"],
     system_launch: ["target", "application_id", "arguments"],
     computer_execute: ["target", "sessionId", "request"],

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

@@ -14,6 +14,7 @@ export type NativeSessionOptions = Readonly<{
     onReady(hostId: string): void | Promise<void>;
     resolveHost?: NativeHostResolver;
     handlers?: Record<string, ToolImplementation>;
+    commandOutputStateDir?: string;
     heartbeatMs?: number;
     operationLimit?: number;
     observationCollector?: ObservationCollectorFactory;

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

@@ -1,4 +1,6 @@
 import WebSocket from "ws";
+import { CompanionCommandOutput } from "./command-output.js";
+import { SYSTEM_OUTPUT_CAPABILITY } from "./command-output-protocol.js";
 import { createNativePermissionHandlers } from "./native-permissions.js";
 import { MACOS_PERMISSION_CAPABILITY } from "./permission-protocol.js";
 import { nativeLoopbackSocketOptions } from "./native-loopback-lookup.js";
@@ -41,7 +43,10 @@ export async function connectNativeHost(options) {
         await ownedNotifications?.close();
         options.signal.throwIfAborted();
     }
+    const commandOutput = options.commandOutputStateDir && !options.handlers
+        ? new CompanionCommandOutput(options.commandOutputStateDir) : undefined;
     const handlers = options.handlers ?? {
+        ...commandOutput?.handlers(),
         ...createSystemHandlers(),
         ...computers.handlers(),
         ...notifications.handlers(),
@@ -101,6 +106,7 @@ export async function connectNativeHost(options) {
                 clearTimeout(retirement);
             observations.close();
             void computers.close();
+            commandOutput?.close();
             if (!options.notifications)
                 void notifications.close();
             for (const controller of active.values())
@@ -148,6 +154,8 @@ export async function connectNativeHost(options) {
                 return false;
             if (computers.hasActiveSessions())
                 return false;
+            if (commandOutput?.hasTransfers())
+                return false;
             if (advertisedNotificationReady)
                 return false;
             return notifications.ready;
@@ -165,11 +173,14 @@ export async function connectNativeHost(options) {
                 throw new Error("Unbound native operation.");
             if (seen.has(message.id))
                 throw new Error("Repeated native operation identity.");
-            if (seen.size >= (options.operationLimit ?? 4_096)) {
+            const readsCommandOutput = message.operation === "system_command_output" || message.operation === "system_command_output_close";
+            if (!readsCommandOutput && seen.size >= (options.operationLimit ?? 4_096)) {
                 retireConnection(message.id);
                 return;
             }
-            seen.add(message.id);
+            // Reading stored bytes is idempotent and must not retire a large transfer.
+            if (!readsCommandOutput)
+                seen.add(message.id);
             if (active.size >= 4) {
                 sendResult(message.id, operationFailure("The host companion is busy.", "system_host_busy"));
                 return;
@@ -246,6 +257,7 @@ export async function connectNativeHost(options) {
                 capabilities: [
                     OBSERVATION_CAPABILITY,
                     COMPUTER_CAPABILITY,
+                    ...(commandOutput ? [SYSTEM_OUTPUT_CAPABILITY] : []),
                     ...(options.identity.os === "macos" ? [MACOS_PERMISSION_CAPABILITY] : []),
                     ...(advertisedNotificationReady
                         ? [DESKTOP_NOTIFICATION_CAPABILITY]

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

@@ -102,6 +102,7 @@ export async function runNativeHostSupervisor(options) {
                 url: initial.url,
                 authorization: initial.credential,
                 hostId: initial.hostId,
+                commandOutputStateDir: options.state.directory,
                 identity: options.identity,
                 signal: controller.signal,
                 notifications: notificationSession,

package/dist/src/computer-access/companion/notification-windows.d.ts

@@ -2,4 +2,4 @@ import type { DesktopNotification } from "./notification-protocol.js";
 import { type NotificationProcessRunner } from "./notification-process.js";
 export declare const WINDOWS_NOTIFICATION_IDENTITY_SCRIPT: string;
 export declare function powershellNotificationArguments(script: string): string[];
-export declare function sendWindowsNotification(notification: DesktopNotification, signal?: AbortSignal, run?: NotificationProcessRunner): Promise<void>;
+export declare function sendWindowsNotification(notification: DesktopNotification, signal?: AbortSignal, run?: NotificationProcessRunner, appUserModelId?: string): Promise<void>;

package/dist/src/computer-access/companion/notification-windows.js

@@ -11,7 +11,9 @@ $Payload = [Console]::In.ReadToEnd() | ConvertFrom-Json
 [void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime]
 [void][Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType = WindowsRuntime]
 [void][Windows.Data.Xml.Dom.XmlDocument, Windows.Data.Xml.Dom.XmlDocument, ContentType = WindowsRuntime]
-$Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('${NOTIFICATION_APP_ID}')
+$ApplicationId = '${NOTIFICATION_APP_ID}'
+if ($Payload.appUserModelId) { $ApplicationId = [string]$Payload.appUserModelId }
+$Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier($ApplicationId)
 # Win32 Setting is unavailable until the first toast; Show honors Windows notification settings.
 $Xml = New-Object Windows.Data.Xml.Dom.XmlDocument
 $Xml.LoadXml('<toast activationType="protocol"><visual><binding template="ToastGeneric"><text/><text/></binding></visual><audio silent="true"/></toast>')
@@ -127,11 +129,14 @@ export function powershellNotificationArguments(script) {
         Buffer.from(script, "utf16le").toString("base64"),
     ];
 }
-export async function sendWindowsNotification(notification, signal, run = runNotificationProcess) {
+export async function sendWindowsNotification(notification, signal, run = runNotificationProcess, appUserModelId) {
     await run({
         file: "powershell.exe",
         args: powershellNotificationArguments(WINDOWS_NOTIFICATION_SCRIPT),
-        input: JSON.stringify(notification),
+        input: JSON.stringify({
+            ...notification,
+            ...(appUserModelId ? { appUserModelId } : {}),
+        }),
         signal,
     });
 }

package/dist/src/computer-access/companion/protocol.d.ts

@@ -9,7 +9,7 @@ export declare const HOST_SOCKET_PATH = "/system-host/connect";
 export declare const HOST_WIRE_MAX_BYTES: number;
 export declare const HOST_OPERATIONS: readonly ["system_targets", "system_command", "system_applications", "system_launch"];
 export declare const COMPUTER_HOST_OPERATIONS: readonly ["computer_execute", "computer_frame", "computer_close"];
-export type HostOperation = (typeof HOST_OPERATIONS)[number] | (typeof COMPUTER_HOST_OPERATIONS)[number] | typeof MACOS_PERMISSION_OPERATION | typeof DESKTOP_NOTIFICATION_OPERATION;
+export type HostOperation = (typeof HOST_OPERATIONS)[number] | (typeof COMPUTER_HOST_OPERATIONS)[number] | "system_command_capture" | "system_command_output" | "system_command_output_close" | typeof MACOS_PERMISSION_OPERATION | typeof DESKTOP_NOTIFICATION_OPERATION;
 export type HostIdentity = Readonly<{
     name: string;
     os: "windows" | "macos" | "linux";

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

@@ -20,6 +20,12 @@ export function isHostOperation(value) {
 export function isHostWireOperation(value) {
     if (isHostOperation(value))
         return true;
+    if (value === "system_command_capture")
+        return true;
+    if (value === "system_command_output")
+        return true;
+    if (value === "system_command_output_close")
+        return true;
     if (value === DESKTOP_NOTIFICATION_OPERATION)
         return true;
     if (value === MACOS_PERMISSION_OPERATION)

package/dist/src/computer-access/companion/release-version.d.ts

@@ -1,5 +1,5 @@
 /** Increment when installed companions should be offered an update. Independent of the wire protocol. */
-export declare const COMPANION_RELEASE_VERSION = 10;
+export declare const COMPANION_RELEASE_VERSION = 12;
 export declare function companionReleaseStatus(version: unknown): {
     installedVersion: number | null;
     availableVersion: number;

package/dist/src/computer-access/companion/release-version.js

@@ -1,5 +1,5 @@
 /** Increment when installed companions should be offered an update. Independent of the wire protocol. */
-export const COMPANION_RELEASE_VERSION = 10;
+export const COMPANION_RELEASE_VERSION = 12;
 export function companionReleaseStatus(version) {
     const installedVersion = typeof version === "number" && Number.isSafeInteger(version) && version > 0
         ? version

package/dist/src/computer-access/companion/windows-store/connection-error.d.ts

@@ -0,0 +1,7 @@
+import type { NativeHostConnection } from "../native-state.js";
+export declare function hasMissingStoreUpgradeConnection(upgradeHostId: string | undefined, saved: NativeHostConnection | undefined): boolean;
+/** Fixed Store helper failure codes. Never serialize underlying errors or invitations. */
+export declare class MissingStoreConnectionError extends Error {
+    constructor();
+}
+export declare function serializeStoreConnectionError(error: unknown): string;

package/dist/src/computer-access/companion/windows-store/connection-error.js

@@ -0,0 +1,19 @@
+export function hasMissingStoreUpgradeConnection(upgradeHostId, saved) {
+    if (upgradeHostId === undefined)
+        return false;
+    return saved === undefined;
+}
+/** Fixed Store helper failure codes. Never serialize underlying errors or invitations. */
+export class MissingStoreConnectionError extends Error {
+    constructor() {
+        super("companion_local_pairing_missing");
+        this.name = "MissingStoreConnectionError";
+    }
+}
+export function serializeStoreConnectionError(error) {
+    return JSON.stringify({
+        error: error instanceof MissingStoreConnectionError
+            ? "companion_local_pairing_missing"
+            : "companion_request_failed",
+    });
+}

package/dist/src/computer-access/companion/windows-store/connection-link.d.ts

@@ -0,0 +1,13 @@
+export declare const STORE_CONNECTION_LINK_MAX_BYTES = 8192;
+export type StoreConnectionInvitation = Readonly<{
+    version: 1;
+    url: string;
+    code: string;
+    expiresAt: string;
+    companionRelease: number;
+    upgradeHostId?: string;
+}>;
+export declare function readStoreConnectionInvitation(value: unknown, now?: number): StoreConnectionInvitation;
+export declare function normalizeStoreConnectionOrigin(value: unknown): string;
+export declare function createStoreConnectionLink(invitation: StoreConnectionInvitation): string;
+export declare function parseStoreConnectionLink(link: string, now?: number): StoreConnectionInvitation;

package/dist/src/computer-access/companion/windows-store/connection-link.js

@@ -0,0 +1,109 @@
+import { isNativeLoopbackAddress, normalizeNativeRuntimeUrl } from "../native-address.js";
+import { isHostIdentifier, isHostRecord } from "../protocol.js";
+import { COMPANION_RELEASE_VERSION } from "../release-version.js";
+import { WINDOWS_COMPANION_STORE } from "./identity.js";
+export const STORE_CONNECTION_LINK_MAX_BYTES = 8_192;
+function invalidInvitation() {
+    // Incoming links contain a secret. Never include their text in an error.
+    return new Error("Invalid Companion connection invitation. Open Computer access in ABot and request a new connection.");
+}
+function isLoopbackInvitationOrigin(url) {
+    if (url.protocol !== "http:")
+        return false;
+    if (url.hostname === "localhost")
+        return true;
+    if (url.hostname.endsWith(".localhost"))
+        return true;
+    return isNativeLoopbackAddress(url.hostname);
+}
+export function readStoreConnectionInvitation(value, now = Date.now()) {
+    if (!isHostRecord(value))
+        throw invalidInvitation();
+    const fields = ["version", "url", "code", "expiresAt", "companionRelease", "upgradeHostId"];
+    if (Object.keys(value).some((key) => !fields.includes(key)))
+        throw invalidInvitation();
+    if (value.version !== 1)
+        throw invalidInvitation();
+    const origin = normalizeStoreConnectionOrigin(value.url);
+    if (typeof value.code !== "string" || !/^[A-Za-z0-9_-]{43}$/u.test(value.code))
+        throw invalidInvitation();
+    if (typeof value.expiresAt !== "string")
+        throw invalidInvitation();
+    const expiresAt = Date.parse(value.expiresAt);
+    if (!Number.isFinite(expiresAt))
+        throw invalidInvitation();
+    if (expiresAt <= now)
+        throw new Error("This connection invitation has expired. Click Connect in ABot again.");
+    if (!Number.isSafeInteger(value.companionRelease))
+        throw invalidInvitation();
+    if (Number(value.companionRelease) < 1)
+        throw invalidInvitation();
+    if (Number(value.companionRelease) > COMPANION_RELEASE_VERSION)
+        throw new Error("Update ABot AI Companion in Microsoft Store, then connect again.");
+    if (value.upgradeHostId !== undefined && !isHostIdentifier(value.upgradeHostId))
+        throw invalidInvitation();
+    return {
+        version: 1,
+        url: origin,
+        code: value.code,
+        expiresAt: new Date(expiresAt).toISOString(),
+        companionRelease: Number(value.companionRelease),
+        ...(value.upgradeHostId === undefined ? {} : { upgradeHostId: value.upgradeHostId }),
+    };
+}
+export function normalizeStoreConnectionOrigin(value) {
+    if (typeof value !== "string" || value.length > 4_096)
+        throw invalidInvitation();
+    let url;
+    try {
+        url = new URL(value);
+        normalizeNativeRuntimeUrl(value);
+    }
+    catch {
+        throw invalidInvitation();
+    }
+    if (!isLoopbackInvitationOrigin(url))
+        throw invalidInvitation();
+    if (/[\x00-\x20\x7f]/u.test(value))
+        throw invalidInvitation();
+    return url.origin;
+}
+export function createStoreConnectionLink(invitation) {
+    const data = readStoreConnectionInvitation(invitation);
+    const link = new URL(`${WINDOWS_COMPANION_STORE.protocol}//connect`);
+    link.searchParams.set("invitation", Buffer.from(JSON.stringify(data)).toString("base64url"));
+    if (Buffer.byteLength(link.href) > STORE_CONNECTION_LINK_MAX_BYTES)
+        throw invalidInvitation();
+    return link.href;
+}
+export function parseStoreConnectionLink(link, now = Date.now()) {
+    if (Buffer.byteLength(link) > STORE_CONNECTION_LINK_MAX_BYTES)
+        throw invalidInvitation();
+    let url;
+    try {
+        url = new URL(link);
+    }
+    catch {
+        throw invalidInvitation();
+    }
+    if (url.protocol !== WINDOWS_COMPANION_STORE.protocol)
+        throw invalidInvitation();
+    if (url.hostname !== "connect" || url.port || url.username || url.password || url.hash)
+        throw invalidInvitation();
+    if (url.pathname !== "" && url.pathname !== "/")
+        throw invalidInvitation();
+    const entries = [...url.searchParams];
+    if (entries.length !== 1 || entries[0][0] !== "invitation")
+        throw invalidInvitation();
+    const encoded = entries[0][1];
+    if (!/^[A-Za-z0-9_-]+$/u.test(encoded))
+        throw invalidInvitation();
+    let data;
+    try {
+        data = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    }
+    catch {
+        throw invalidInvitation();
+    }
+    return readStoreConnectionInvitation(data, now);
+}

package/dist/src/computer-access/companion/windows-store/identity.d.ts

@@ -0,0 +1,13 @@
+/** Store-assigned identity. Build tooling and the packaged Companion share it. */
+export declare const WINDOWS_COMPANION_STORE: Readonly<{
+    name: "ABot-AI.ABotAICompanion";
+    publisher: "CN=5497306F-2434-4801-8B3F-4B721B2A2606";
+    publisherDisplayName: "ABot-AI";
+    displayName: "ABot AI Companion";
+    familyName: "ABot-AI.ABotAICompanion_9b4v4r6by2e32";
+    applicationId: "Companion";
+    productId: "9PK2FDQQLQS9";
+    protocol: "abot-companion:";
+}>;
+export declare const WINDOWS_COMPANION_AUMID: string;
+export declare const WINDOWS_COMPANION_STORE_URL: string;

package/dist/src/computer-access/companion/windows-store/identity.js

@@ -0,0 +1,13 @@
+/** Store-assigned identity. Build tooling and the packaged Companion share it. */
+export const WINDOWS_COMPANION_STORE = Object.freeze({
+    name: "ABot-AI.ABotAICompanion",
+    publisher: "CN=5497306F-2434-4801-8B3F-4B721B2A2606",
+    publisherDisplayName: "ABot-AI",
+    displayName: "ABot AI Companion",
+    familyName: "ABot-AI.ABotAICompanion_9b4v4r6by2e32",
+    applicationId: "Companion",
+    productId: "9PK2FDQQLQS9",
+    protocol: "abot-companion:",
+});
+export const WINDOWS_COMPANION_AUMID = `${WINDOWS_COMPANION_STORE.familyName}!${WINDOWS_COMPANION_STORE.applicationId}`;
+export const WINDOWS_COMPANION_STORE_URL = `https://apps.microsoft.com/detail/${WINDOWS_COMPANION_STORE.productId}`;

package/dist/src/computer-access/companion/windows-store/lifecycle.d.ts

@@ -0,0 +1,5 @@
+import type { HostCompanionLifecycle } from "../../../cli/host-companion-lifecycle.js";
+/** MSIX owns startup/protocol registration and updates; the shared CLI owns pairing. */
+export declare function createWindowsStoreLifecycle(options: Readonly<{
+    appUserModelId: string;
+}>): HostCompanionLifecycle;

package/dist/src/computer-access/companion/windows-store/lifecycle.js

@@ -0,0 +1,90 @@
+import { startDetachedCompanion, waitForNativeConnection, } from "../../../cli/host-companion-startup.js";
+import { existingOwnedRegistration, nativeAutostartFile, uninstallNativeAutostart, } from "../autostart.js";
+import { uninstallCompanionInstallLinks } from "../install-link-registration.js";
+import { readNativeCompanionBuildId } from "../native-build-identity.js";
+import { createNotificationSession } from "../native-notifications.js";
+import { stopOwnedNativeCompanion } from "../native-replacement.js";
+import { uninstallDesktopNotificationIdentity } from "../notification-installation.js";
+import { runNotificationProcess } from "../notification-process.js";
+import { powershellNotificationArguments, sendWindowsNotification, } from "../notification-windows.js";
+const STORE_NOTIFICATION_READINESS_SCRIPT = String.raw `
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+[Console]::InputEncoding = New-Object System.Text.UTF8Encoding($false)
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+try {
+  $Payload = [Console]::In.ReadToEnd() | ConvertFrom-Json
+  [void][Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime]
+  $Notifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier([string]$Payload.appUserModelId)
+  [Console]::Out.Write([string]$Notifier.Setting)
+} catch {
+  [Console]::Error.WriteLine($_.Exception.GetBaseException().Message)
+  exit 1
+}
+`;
+function assertWindowsStoreStartup(startup) {
+    if (startup.platform !== "win32")
+        throw new Error("The Store companion requires Windows.");
+}
+function requireStoreApplicationIdentity(appUserModelId) {
+    if (!/^[A-Za-z0-9.-]+_[A-Za-z0-9]+![A-Za-z0-9.-]+$/u.test(appUserModelId))
+        throw new Error("Invalid Store companion application identity.");
+}
+async function hasWindowsStoreNotificationSupport(appUserModelId, signal) {
+    signal?.throwIfAborted();
+    try {
+        const setting = await runNotificationProcess({
+            file: "powershell.exe",
+            args: powershellNotificationArguments(STORE_NOTIFICATION_READINESS_SCRIPT),
+            input: JSON.stringify({ appUserModelId }),
+            signal,
+        });
+        signal?.throwIfAborted();
+        return setting.trim() === "Enabled";
+    }
+    catch {
+        signal?.throwIfAborted();
+        return false;
+    }
+}
+/** Called only after the Store connection dialog has obtained the user's consent. */
+async function retireOwnedLegacyRegistration(startup) {
+    await existingOwnedRegistration(nativeAutostartFile(startup));
+    await stopOwnedNativeCompanion(startup.stateDir);
+    await uninstallNativeAutostart(startup);
+    await uninstallCompanionInstallLinks(startup);
+    await uninstallDesktopNotificationIdentity(startup);
+}
+/** MSIX owns startup/protocol registration and updates; the shared CLI owns pairing. */
+export function createWindowsStoreLifecycle(options) {
+    requireStoreApplicationIdentity(options.appUserModelId);
+    return {
+        assertStartupSupported: assertWindowsStoreStartup,
+        async completeStartup(state, startup, hostId) {
+            assertWindowsStoreStartup(startup);
+            const buildId = await readNativeCompanionBuildId(startup.cliPath);
+            await retireOwnedLegacyRegistration(startup);
+            const connectedAfter = Date.now();
+            await startDetachedCompanion(startup);
+            if (!(await waitForNativeConnection(state, hostId, buildId, connectedAfter)))
+                throw new Error("The Store companion did not connect. The saved pairing is preserved; use Connect computer again to retry.");
+            console.log("ABot AI Companion connected.");
+        },
+        async uninstall(state, startup) {
+            assertWindowsStoreStartup(startup);
+            await state.remove();
+            await stopOwnedNativeCompanion(state.directory);
+            console.log("Host companion disconnected and its saved credential was removed. Remove ABot AI Companion in Windows Settings to uninstall the app.");
+        },
+        async createNotifications(runtimeUrl, signal) {
+            signal?.throwIfAborted();
+            const { appUserModelId } = options;
+            // The supervisor already refreshes readiness and renegotiates capabilities.
+            // A slow Windows notification probe must not consume the pairing startup deadline.
+            return createNotificationSession("windows", runtimeUrl, false, {
+                send: (notification, sendSignal) => sendWindowsNotification(notification, sendSignal, runNotificationProcess, appUserModelId),
+                close() { },
+            }, (refreshSignal) => hasWindowsStoreNotificationSupport(appUserModelId, refreshSignal));
+        },
+    };
+}

package/dist/src/computer-access/contracts.d.ts

@@ -22,7 +22,7 @@ export type SystemProcessResult = Readonly<{
     exitCode: number | null;
     stdout: string;
     stderr: string;
-    status: "completed" | "timeout" | "aborted" | "spawn_failed";
+    status: "completed" | "timeout" | "aborted" | "spawn_failed" | "output_failed";
     outputTruncated: boolean;
     spawnedProcess?: SystemSpawnObservation;
 }>;

package/dist/src/computer-access/handlers.d.ts

@@ -1,3 +1,4 @@
 import { type ToolImplementation } from "../plugin-sdk/index.js";
 import { type SystemProcessRunner, type SystemTarget, type SystemTargetId } from "./contracts.js";
-export declare function createSystemHandlers(run?: SystemProcessRunner, resolveTarget?: (id: SystemTargetId) => Promise<SystemTarget>): Record<string, ToolImplementation>;
+import type { SystemCommandOutputFactory } from "./command-output.js";
+export declare function createSystemHandlers(run?: SystemProcessRunner, resolveTarget?: (id: SystemTargetId) => Promise<SystemTarget>, commandOutput?: SystemCommandOutputFactory): Record<string, ToolImplementation>;

package/dist/src/computer-access/handlers.js

@@ -30,7 +30,7 @@ function withSystemOperationErrors(operation) {
         }
     };
 }
-export function createSystemHandlers(run = runSystemProcess, resolveTarget = (id) => resolveSystemTarget(id, run)) {
+export function createSystemHandlers(run = runSystemProcess, resolveTarget = (id) => resolveSystemTarget(id, run), commandOutput) {
     const targets = async () => {
         const observation = await observeSystemTargets(run);
         return successResult({
@@ -43,12 +43,16 @@ export function createSystemHandlers(run = runSystemProcess, resolveTarget = (id
     };
     const command = async (params, context) => {
         const target = await resolveTarget(readSystemTargetId(params.target));
+        const output = commandOutput?.(context);
         const result = await executeSystemCommand({
             target,
             params,
             run,
+            ...(output ? { runCommand: output.run } : {}),
             ...(context?.abortSignal ? { abortSignal: context.abortSignal } : {}),
         });
+        if (output)
+            return output.present(target, result);
         return systemProcessResult(target, result, "command_process_completion");
     };
     const applications = async (params) => {

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

@@ -0,0 +1,6 @@
+import type { Readable } from "node:stream";
+/** Optional local output sink. Its owner handles storage, retention and delivery. */
+export type SystemProcessCapture = Readonly<{
+    attach(stdout: Readable, stderr: Readable, onFailure: () => void): void;
+    end(): void;
+}>;

package/dist/src/computer-access/process-capture.js

@@ -0,0 +1 @@
+export {};

package/dist/src/computer-access/process-result.d.ts

@@ -2,3 +2,5 @@ import { type ToolImplementationOutput } from "../plugin-sdk/index.js";
 import type { SystemApplication, SystemProcessResult, SystemTarget } from "./contracts.js";
 export type SystemEvidenceScope = "command_process_completion" | "launch_request_dispatch";
 export declare function systemProcessResult(target: SystemTarget, result: SystemProcessResult, evidenceScope: SystemEvidenceScope, application?: SystemApplication): ToolImplementationOutput;
+/** Unmeasured receipt for invocation-aware local delivery through the SDK. */
+export declare function buildSystemProcessResult(target: SystemTarget, result: SystemProcessResult, evidenceScope: SystemEvidenceScope, application?: SystemApplication): ToolImplementationOutput;

package/dist/src/computer-access/process-result.js

@@ -1,4 +1,4 @@
-import { failureResult, successResult, } from "../plugin-sdk/index.js";
+import { enforcePluginResultByteBudget, } from "../plugin-sdk/index.js";
 const STREAM_EXCERPT_CHARS = 2_000;
 const IDENTITY_EXCERPT_CHARS = 512;
 const LEGACY_EVIDENCE_LABELS = {
@@ -6,6 +6,10 @@ const LEGACY_EVIDENCE_LABELS = {
     launch_request_dispatch: "application launch request dispatch",
 };
 export function systemProcessResult(target, result, evidenceScope, application) {
+    return enforcePluginResultByteBudget(buildSystemProcessResult(target, result, evidenceScope, application));
+}
+/** Unmeasured receipt for invocation-aware local delivery through the SDK. */
+export function buildSystemProcessResult(target, result, evidenceScope, application) {
     const stdoutOmittedChars = Math.max(0, result.stdout.length - STREAM_EXCERPT_CHARS);
     const stderrOmittedChars = Math.max(0, result.stderr.length - STREAM_EXCERPT_CHARS);
     const data = {
@@ -46,20 +50,24 @@ export function systemProcessResult(target, result, evidenceScope, application)
         `Summary omitted characters: stdout=${stdoutOmittedChars}, stderr=${stderrOmittedChars}. Raw stream capture truncated: ${result.outputTruncated}.`,
     ].join("\n");
     if (hasSuccessfulSystemObservation(result)) {
-        return successResult({
+        return {
+            ok: true,
+            producedNewInformation: true,
             output,
             stdout: result.stdout,
             stderr: result.stderr,
             exitCode: 0,
             data,
-        });
+        };
     }
     const errorCode = result.status === "completed"
         ? "system_command_failed"
         : `system_${result.status}`;
-    return failureResult({
+    return {
+        ok: false,
+        producedNewInformation: false,
         errorCode,
-        message: hasUncertainDescendantState(result)
+        error: hasUncertainDescendantState(result)
             ? "System command observation stopped. External or detached descendants may remain; inspect the target before retrying."
             : "The target did not report successful command completion.",
         output,
@@ -67,7 +75,7 @@ export function systemProcessResult(target, result, evidenceScope, application)
         stderr: result.stderr,
         ...(result.exitCode !== null ? { exitCode: result.exitCode } : {}),
         data,
-    });
+    };
 }
 function hasSuccessfulSystemObservation(result) {
     if (result.status !== "completed")

package/dist/src/computer-access/process-runner.d.ts

@@ -1,3 +1,4 @@
+import type { SystemProcessCapture } from "./process-capture.js";
 import type { SystemProcessInput, SystemProcessResult } from "./contracts.js";
 /** Bounded process observation; exit zero proves command completion, not effects. */
-export declare function runSystemProcess(input: SystemProcessInput): Promise<SystemProcessResult>;
+export declare function runSystemProcess(input: SystemProcessInput, capture?: SystemProcessCapture): Promise<SystemProcessResult>;