@abot-ai/runtime 1.6.0 → 1.8.0

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

@@ -1,9 +1,4 @@
 import type { PassiveObservationSource } from "../../shared/passive-observation.js";
-/**
- * Mask the entire field when a known secret indicator is present, including
- * surrounding useful text. No value boundaries or source-language grammar are
- * inferred. Unlabelled arbitrary secrets and unknown encodings remain outside
- * detection; this is not a guarantee that unchanged text contains no secrets.
- */
-export declare function redactObservationText(input: string): string;
+import { redactSecretText as redactObservationText } from "../security/secret-text.js";
+export { redactObservationText };
 export declare function redactObservationSource(source: PassiveObservationSource, sourceKey: string): PassiveObservationSource;

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

@@ -1,114 +1,5 @@
-const REDACTED = "[REDACTED]";
-const CREDENTIAL_KEY_SOURCE = String.raw `(?:[A-Za-z][A-Za-z0-9_-]*\.)*(?:[A-Za-z][A-Za-z0-9]*[-_])*(?:password|passwd|pwd|api[_ -]?key|access[_ -]?token|refresh[_ -]?token|client[_ -]?secret|secret[_ -]?access[_ -]?key|recovery[_ -]?code)`;
-const credentialIndicator = new RegExp(String.raw `(?<![\p{L}\p{N}_.-])(?:-{1,2})?(?:${CREDENTIAL_KEY_SOURCE}|(?:proxy-)?authorization)[\s"'\\]*[:=]`, "iu");
-/** Detection only: normalize ASCII encodings once, without interpreting a language. */
-function detectionText(input) {
-    const percentDecoded = input.replace(/%([0-7][0-9a-f])/giu, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
-    return percentDecoded.replace(/\\(?:u00|x|U000000)([0-7][0-9a-fA-F])/gu, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
-}
-function hasPrivateKeyIndicator(text) {
-    return /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY(?: BLOCK)?-----/u.test(text);
-}
-function hasUrlCredentials(text) {
-    return /\b[a-z][a-z0-9+.-]*(?::|%3a)(?:\/|%2f){2}[^\s/?#<>]*(?:@|%40)/iu.test(text);
-}
-function hasAuthorizationCredentials(text) {
-    for (const match of text.matchAll(/\b(Bearer|Basic)[ \t]+([A-Za-z0-9._~+/-]+={0,2})/giu)) {
-        if (match[1].toLowerCase() === "bearer")
-            return true;
-        const value = match[2];
-        if (!/^[A-Za-z0-9+/]+={0,2}$/u.test(value))
-            continue;
-        if (value.length < 8)
-            continue;
-        if (Buffer.from(value, "base64").toString("utf8").includes(":"))
-            return true;
-    }
-    return false;
-}
-function isAwsAccessKeyValue(value, atEnd) {
-    if (/^[A-Z0-9]{16}$/u.test(value))
-        return true;
-    if (!atEnd)
-        return false;
-    return /^[A-Z0-9]{4,15}$/u.test(value);
-}
-function isRecognizedProviderToken(prefix, value, atEnd) {
-    if (prefix === "AKIA" || prefix === "ASIA")
-        return isAwsAccessKeyValue(value, atEnd);
-    if (value.length >= 20)
-        return true;
-    const partialMinimum = prefix === "sk-" ? 8 : 1;
-    return atEnd && value.length >= partialMinimum;
-}
-function hasProviderToken(text) {
-    const provider = /\b(sk-(?:proj-|svcacct-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA|ASIA)([A-Za-z0-9_-]+)/gu;
-    for (const match of text.matchAll(provider)) {
-        const atEnd = match.index + match[0].length === text.length;
-        if (isRecognizedProviderToken(match[1], match[2], atEnd))
-            return true;
-    }
-    return false;
-}
-function compactJoseSegmentCount(header) {
-    try {
-        const value = JSON.parse(Buffer.from(header, "base64url").toString("utf8"));
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            return undefined;
-        const fields = value;
-        if (typeof fields.alg !== "string")
-            return undefined;
-        return typeof fields.enc === "string" ? 5 : 3;
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasCompactJoseToken(text) {
-    const jose = /\b([A-Za-z0-9_-]+)(?:\.[A-Za-z0-9_-]*)+/gu;
-    for (const match of text.matchAll(jose)) {
-        const parts = match[0].split(".");
-        const capturedAtEnd = match.index + match[0].length === text.length;
-        for (let index = 0; index < parts.length - 1; index += 1) {
-            const expected = compactJoseSegmentCount(parts[index]);
-            if (expected === undefined)
-                continue;
-            if (expected === 3 && parts[index + 1] === "")
-                continue;
-            if (parts.length - index >= expected)
-                return true;
-            if (capturedAtEnd)
-                return true;
-        }
-    }
-    return false;
-}
-function hasSecretIndicator(text) {
-    if (credentialIndicator.test(text))
-        return true;
-    if (hasPrivateKeyIndicator(text))
-        return true;
-    if (hasUrlCredentials(text))
-        return true;
-    if (hasAuthorizationCredentials(text))
-        return true;
-    if (hasProviderToken(text))
-        return true;
-    return hasCompactJoseToken(text);
-}
-/**
- * Mask the entire field when a known secret indicator is present, including
- * surrounding useful text. No value boundaries or source-language grammar are
- * inferred. Unlabelled arbitrary secrets and unknown encodings remain outside
- * detection; this is not a guarantee that unchanged text contains no secrets.
- */
-export function redactObservationText(input) {
-    if (hasSecretIndicator(input))
-        return REDACTED;
-    if (hasSecretIndicator(detectionText(input)))
-        return REDACTED;
-    return input;
-}
+import { redactSecretText as redactObservationText } from "../security/secret-text.js";
+export { redactObservationText };
 export function redactObservationSource(source, sourceKey) {
     const redacted = {
         app: redactObservationText(source.app).slice(0, 128),

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/secret-protection-protocol.d.ts

@@ -0,0 +1,6 @@
+/** Host-side observed-text protection before delivery, projection and transport.
+ * Command capture may temporarily retain unchecked bytes in private local files.
+ * Version 1 covers text and metadata; images are withheld when their associated
+ * text is suspect. It does not assert OCR or pixel-content inspection.
+ */
+export declare const HOST_SECRET_PROTECTION_CAPABILITY = "host_secret_protection_v1";

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

@@ -0,0 +1,6 @@
+/** Host-side observed-text protection before delivery, projection and transport.
+ * Command capture may temporarily retain unchecked bytes in private local files.
+ * Version 1 covers text and metadata; images are withheld when their associated
+ * text is suspect. It does not assert OCR or pixel-content inspection.
+ */
+export const HOST_SECRET_PROTECTION_CAPABILITY = "host_secret_protection_v1";

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/computer/companion-sessions.js

@@ -6,6 +6,8 @@ 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";
+import { protectDesktopResult } from "../security/desktop-result.js";
+import { protectObservedError } from "../security/observed-error.js";
 /** Connection-owned, bounded private sessions. No image is written to disk. */
 export class CompanionComputerSessions {
     platform;
@@ -30,9 +32,7 @@ export class CompanionComputerSessions {
             catch (error) {
                 return failureResult({
                     errorCode: "computer_native_operation_failed",
-                    message: error instanceof Error
-                        ? error.message
-                        : "The computer operation failed; observe before retrying.",
+                    message: protectObservedError(error, "The computer operation failed; observe before retrying."),
                 });
             }
         };
@@ -96,14 +96,15 @@ export class CompanionComputerSessions {
             const session = await this.acquire(id);
             this.eraseFrame(session);
             const result = await session.backend.execute(request, signal);
-            const { image, ...metadata } = result;
+            const { image: rawImage, ...rawMetadata } = result;
             try {
-                readNativeComputerResult(metadata);
+                readNativeComputerResult(rawMetadata);
             }
             catch (error) {
-                image?.bytes.fill(0);
+                rawImage?.bytes.fill(0);
                 throw error;
             }
+            const { image, ...metadata } = protectDesktopResult(result);
             if (!image)
                 return successResult({
                     output: "Native desktop observation.",

package/dist/src/computer-access/computer/unix-native-process.js

@@ -9,7 +9,7 @@ export function createUnixNativeProcess(options) {
     let failedReason;
     let buffer = Buffer.alloc(0);
     let queue = Promise.resolve();
-    let lastResult;
+    let lastDesktop;
     function interruptedResult(reason) {
         const dispatch = pending?.request.operation === "act"
             ? (pending.dispatch ?? {
@@ -19,13 +19,9 @@ export function createUnixNativeProcess(options) {
             })
             : undefined;
         const result = unavailableUnixDesktop(options.platform, reason, dispatch);
-        if (!lastResult)
+        if (!lastDesktop)
             return result;
-        return {
-            ...result,
-            desktop: { ...lastResult.desktop, available: false, reason },
-            windows: lastResult.windows,
-        };
+        return { ...result, desktop: { ...result.desktop, ...lastDesktop } };
     }
     function terminate(reason) {
         failedReason = reason;
@@ -38,6 +34,7 @@ export function createUnixNativeProcess(options) {
             retiring.once("exit", () => clearTimeout(hardStop));
         }
         child = undefined;
+        buffer.fill(0);
         buffer = Buffer.alloc(0);
     }
     function receiveLine(line) {
@@ -54,7 +51,18 @@ export function createUnixNativeProcess(options) {
         if (message.type !== "result")
             throw new Error("native_protocol_invalid");
         const result = readUnixNativeResult(message.result, options.platform);
-        lastResult = result;
+        // Retain only mechanical interruption identity, never observation content.
+        lastDesktop = {
+            binding: result.desktop.binding,
+            bounds: {
+                x: result.desktop.bounds.x,
+                y: result.desktop.bounds.y,
+                width: result.desktop.bounds.width,
+                height: result.desktop.bounds.height,
+            },
+            coordinateSpace: result.desktop.coordinateSpace,
+            targetingGuarantee: result.desktop.targetingGuarantee,
+        };
         pending.finish(result);
     }
     function ensureHelper() {
@@ -69,15 +77,19 @@ export function createUnixNativeProcess(options) {
         child.stdout.on("data", (chunk) => {
             if (closed || failedReason)
                 return;
-            buffer = Buffer.concat([buffer, chunk]);
+            const previous = buffer;
+            buffer = Buffer.concat([previous, chunk]);
+            previous.fill(0);
             if (buffer.length > NATIVE_JSON_LIMIT) {
                 terminate("computer_native_result_limit");
                 return;
             }
             let boundary = buffer.indexOf(10);
             while (boundary >= 0) {
-                const line = buffer.subarray(0, boundary).toString("utf8");
-                buffer = buffer.subarray(boundary + 1);
+                const received = buffer;
+                const line = received.subarray(0, boundary).toString("utf8");
+                buffer = Buffer.from(received.subarray(boundary + 1));
+                received.fill(0);
                 try {
                     receiveLine(line);
                 }

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,5 @@
 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";
+import type { SystemResultProtection } from "./system-result-protection.js";
+export declare function createSystemHandlers(run?: SystemProcessRunner, resolveTarget?: (id: SystemTargetId) => Promise<SystemTarget>, commandOutput?: SystemCommandOutputFactory, protection?: SystemResultProtection): Record<string, ToolImplementation>;