@abot-ai/runtime 1.6.0 → 1.8.0

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

@@ -0,0 +1,184 @@
+import { execFile } from "node:child_process";
+import { lstat, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, posix } from "node:path";
+import { promisify } from "node:util";
+import { ensurePrivateRuntimeDirectory } from "../../runtime/local-host/private-directory.js";
+import { renderWindowsInstallLinkLauncher, windowsInstallLinkLauncherPath, windowsInstallLinkRegistryScript, } from "./install-link-windows.js";
+import { renderMacInstallLinkHandler, requireAvailableMacInstallScheme, MAC_INSTALL_LINK_PLIST_SCRIPT, MAC_INSTALL_LINK_BUNDLE_ID, } from "./install-link-macos.js";
+const OWNER = "ABot managed installation links";
+const executeFile = promisify(execFile);
+function desktopArgument(value) {
+    if (/[\r\n\0]/u.test(value))
+        throw new Error("Unsupported Companion path.");
+    return ('"' +
+        value
+            .replaceAll("\\", "\\\\")
+            .replaceAll('"', '\\"')
+            .replaceAll("$", "\\$")
+            .replaceAll("`", "\\`")
+            .replaceAll("%", "%%") +
+        '"');
+}
+export function renderLinuxInstallLinkDesktop(options) {
+    return `[Desktop Entry]
+# ${OWNER}
+Type=Application
+Name=ABot Install
+Exec=${desktopArgument(options.nodePath)} ${desktopArgument(options.cliPath)} host open-link %u
+Terminal=false
+NoDisplay=true
+MimeType=x-scheme-handler/abot;
+`;
+}
+function registrationDirectory(options) {
+    return join(options.stateDir, "install-links");
+}
+async function run(options, file, args) {
+    if (options.execute)
+        return options.execute(file, args);
+    await executeFile(file, [...args], {
+        windowsHide: true,
+        timeout: 30_000,
+        maxBuffer: 16_384,
+    });
+}
+async function existingOwnedDirectory(path) {
+    const stat = await lstat(path).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return false;
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error("Installation-link directory is not owned.");
+    if ((await readFile(join(path, ".owner"), "utf8")) !== OWNER)
+        throw new Error("Installation-link directory is not owned.");
+    return true;
+}
+function hasAbsoluteLinuxDataHome(value) {
+    if (!value)
+        return false;
+    return posix.isAbsolute(value);
+}
+function linuxDesktopPath(options) {
+    const dataHome = process.env.XDG_DATA_HOME;
+    if (hasAbsoluteLinuxDataHome(dataHome))
+        return join(dataHome, "applications", "com.abot.install-links.desktop");
+    return join(options.homeDir, ".local", "share", "applications", "com.abot.install-links.desktop");
+}
+async function requireOwnedLinuxRegistration(path) {
+    const stat = await lstat(path).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return;
+    if (!stat.isFile() ||
+        stat.isSymbolicLink() ||
+        !(await readFile(path, "utf8")).includes("# " + OWNER))
+        throw new Error("Installation-link desktop registration is not owned.");
+}
+function isAvailableLinuxInstallScheme(handler) {
+    if (!handler)
+        return true;
+    return handler === "com.abot.install-links.desktop";
+}
+async function requireAvailableLinuxInstallScheme() {
+    const { stdout } = await executeFile("xdg-mime", ["query", "default", "x-scheme-handler/abot"], { timeout: 30_000, maxBuffer: 16_384 });
+    if (!isAvailableLinuxInstallScheme(stdout.trim()))
+        throw new Error("The abot URL scheme belongs to another application.");
+}
+export async function installCompanionInstallLinks(options) {
+    const directory = registrationDirectory(options);
+    if (!(await existingOwnedDirectory(directory))) {
+        await ensurePrivateRuntimeDirectory(directory);
+        await writeFile(join(directory, ".owner"), OWNER, {
+            flag: "wx",
+            mode: 0o600,
+        });
+    }
+    if (options.platform === "win32") {
+        const launcher = windowsInstallLinkLauncherPath(options);
+        await writeFile(launcher, renderWindowsInstallLinkLauncher(options), {
+            mode: 0o600,
+        });
+        await run(options, "powershell.exe", [
+            "-NoProfile",
+            "-NonInteractive",
+            "-EncodedCommand",
+            Buffer.from(windowsInstallLinkRegistryScript("install", launcher), "utf16le").toString("base64"),
+        ]);
+        return;
+    }
+    if (options.platform === "linux") {
+        const desktop = linuxDesktopPath(options);
+        await requireOwnedLinuxRegistration(desktop);
+        await requireAvailableLinuxInstallScheme();
+        await mkdir(dirname(desktop), { recursive: true, mode: 0o700 });
+        await writeFile(desktop, renderLinuxInstallLinkDesktop(options), {
+            mode: 0o600,
+        });
+        await run(options, "xdg-mime", [
+            "default",
+            "com.abot.install-links.desktop",
+            "x-scheme-handler/abot",
+        ]);
+        return;
+    }
+    if (options.platform === "darwin") {
+        await requireAvailableMacInstallScheme();
+        const source = join(directory, "handler.js");
+        const app = join(directory, "ABot Install.app");
+        await writeFile(source, renderMacInstallLinkHandler(options), {
+            mode: 0o600,
+        });
+        await rm(app, { recursive: true, force: true });
+        await run(options, "/usr/bin/osacompile", [
+            "-l",
+            "JavaScript",
+            "-o",
+            app,
+            source,
+        ]);
+        await run(options, "/usr/bin/osascript", [
+            "-l",
+            "JavaScript",
+            "-e",
+            MAC_INSTALL_LINK_PLIST_SCRIPT,
+            join(app, "Contents", "Info.plist"),
+        ]);
+        await run(options, "/usr/bin/codesign", [
+            "--force",
+            "--sign",
+            "-",
+            "--identifier",
+            MAC_INSTALL_LINK_BUNDLE_ID,
+            app,
+        ]);
+        await run(options, "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-f", app]);
+        return;
+    }
+    throw new Error("Installation links are not supported on this platform.");
+}
+export async function uninstallCompanionInstallLinks(options) {
+    const directory = registrationDirectory(options);
+    if (!(await existingOwnedDirectory(directory)))
+        return;
+    if (options.platform === "win32")
+        await run(options, "powershell.exe", [
+            "-NoProfile",
+            "-NonInteractive",
+            "-EncodedCommand",
+            Buffer.from(windowsInstallLinkRegistryScript("remove", windowsInstallLinkLauncherPath(options)), "utf16le").toString("base64"),
+        ]);
+    if (options.platform === "linux") {
+        const desktop = linuxDesktopPath(options);
+        await requireOwnedLinuxRegistration(desktop);
+        await rm(desktop, { force: true });
+    }
+    if (options.platform === "darwin")
+        await run(options, "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister", ["-u", join(directory, "ABot Install.app")]);
+    await rm(directory, { recursive: true });
+}

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

@@ -0,0 +1,4 @@
+import type { NativeAutostartOptions } from "./autostart.js";
+export declare function renderWindowsInstallLinkLauncher(options: NativeAutostartOptions): string;
+export declare function windowsInstallLinkRegistryScript(action: "install" | "remove", launcher: string): string;
+export declare function windowsInstallLinkLauncherPath(options: NativeAutostartOptions): string;

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

@@ -0,0 +1,65 @@
+import { join } from "node:path";
+function vbsText(value) {
+    if (/[\r\n\0]/u.test(value))
+        throw new Error("Unsupported Companion path.");
+    return '"' + value.replaceAll('"', '""') + '"';
+}
+export function renderWindowsInstallLinkLauncher(options) {
+    if (/["\r\n\0]/u.test(options.nodePath + options.cliPath))
+        throw new Error("Unsupported Companion path.");
+    const prefix = `"${options.nodePath}" "${options.cliPath}" host open-link --encoded `;
+    return [
+        "' ABot managed installation links",
+        "If WScript.Arguments.Count <> 1 Then WScript.Quit 1",
+        "value = WScript.Arguments(0)",
+        "If InStr(value, Chr(34)) > 0 Or InStr(value, vbCr) > 0 Or InStr(value, vbLf) > 0 Then WScript.Quit 1",
+        "If Len(value) > 2048 Then WScript.Quit 1",
+        'Set stream = CreateObject("ADODB.Stream")',
+        "stream.Type = 2",
+        'stream.Charset = "utf-8"',
+        "stream.Open",
+        "stream.WriteText value",
+        "stream.Position = 0",
+        "stream.Type = 1",
+        "stream.Position = 3",
+        'Set document = CreateObject("Msxml2.DOMDocument.6.0")',
+        'Set encoded = document.createElement("encoded")',
+        'encoded.dataType = "bin.base64"',
+        "encoded.nodeTypedValue = stream.Read",
+        "stream.Close",
+        'value = Replace(Replace(encoded.text, vbCr, ""), vbLf, "")',
+        'Set shell = CreateObject("WScript.Shell")',
+        `shell.Run ${vbsText(prefix)} & value, 0, False`,
+        "",
+    ].join("\r\n");
+}
+export function windowsInstallLinkRegistryScript(action, launcher) {
+    const quoted = (value) => "'" + value.replaceAll("'", "''") + "'";
+    const command = `wscript.exe "${launcher}" "%1"`;
+    return `
+$ErrorActionPreference = 'Stop'
+$key = 'HKCU:\\Software\\Classes\\abot'
+$expected = ${quoted(launcher)}
+$exists = Test-Path -LiteralPath $key
+function Assert-OwnedInstallLinkRegistration([string]$path) {
+  if (!(Test-Path -LiteralPath $path)) { return }
+  $owner = (Get-ItemProperty -LiteralPath $path -Name ABotInstallLinkOwner -ErrorAction SilentlyContinue).ABotInstallLinkOwner
+  if ($owner -ne $expected) { throw 'The abot protocol belongs to another application.' }
+}
+Assert-OwnedInstallLinkRegistration $key
+${action === "remove"
+        ? "if ($exists) { Remove-Item -LiteralPath $key -Recurse -Force }"
+        : `
+Assert-OwnedInstallLinkRegistration 'Registry::HKEY_CLASSES_ROOT\\abot'
+New-Item -Path $key -Force | Out-Null
+Set-Item -LiteralPath $key -Value 'URL:ABot installation'
+New-ItemProperty -LiteralPath $key -Name 'URL Protocol' -Value '' -PropertyType String -Force | Out-Null
+New-ItemProperty -LiteralPath $key -Name ABotInstallLinkOwner -Value $expected -PropertyType String -Force | Out-Null
+New-Item -Path ($key + '\\shell\\open\\command') -Force | Out-Null
+Set-Item -LiteralPath ($key + '\\shell\\open\\command') -Value ${quoted(command)}
+`}
+`;
+}
+export function windowsInstallLinkLauncherPath(options) {
+    return join(options.stateDir, "install-links", "open-link.vbs");
+}

package/dist/src/computer-access/companion/install-link.d.ts

@@ -0,0 +1,9 @@
+import type { NativeHostState } from "./native-state.js";
+export declare function pluginInstallReviewUrl(link: string, runtimeUrl: string): string;
+/** The saved pairing owns the destination. Incoming links cannot select a host. */
+export declare function openPluginInstallLink(state: Pick<NativeHostState, "read">, link: string, open?: typeof openReviewBrowser): Promise<void>;
+declare function openReviewBrowser(url: string): Promise<void>;
+/** Windows Script Host expands percent-delimited environment variables in Run().
+ * The launcher sends base64 so a website URL can never interpolate local values. */
+export declare function parsePluginInstallArguments(args: readonly string[]): string;
+export {};

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-notifications.js

@@ -1,4 +1,5 @@
 import { failureResult, successResult, } from "../../plugin-sdk/index.js";
+import { redactSecretText } from "../security/secret-text.js";
 import { readDesktopNotification, } from "./notification-protocol.js";
 import { defaultNotificationLocations, } from "./notification-locations.js";
 import { sendWindowsNotification } from "./notification-windows.js";
@@ -49,7 +50,7 @@ export function createNotificationSession(platform, runtimeUrl, ready, renderer,
                             ? "notification_outcome_unknown"
                             : "notification_native_failed",
                         message: error instanceof Error
-                            ? error.message.slice(0, 1000)
+                            ? redactSecretText(error.message).slice(0, 1000)
                             : "Desktop notification submission failed.",
                     });
                 }
@@ -76,7 +77,7 @@ export async function createNativeNotificationSession(platform, runtimeUrl, loca
             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)));
+                        redactSecretText(error instanceof Error ? error.message : String(error)));
                 });
         },
     }, (refreshSignal) => hasDesktopNotificationSupport(platform, locations, runNotificationProcess, refreshSignal));

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,9 @@
 import WebSocket from "ws";
+import { CompanionCommandOutput } from "./command-output.js";
+import { SYSTEM_OUTPUT_CAPABILITY } from "./command-output-protocol.js";
+import { HOST_SECRET_PROTECTION_CAPABILITY } from "./secret-protection-protocol.js";
+import { systemResultProtection } from "../security/system-results.js";
+import { redactSecretText } from "../security/secret-text.js";
 import { createNativePermissionHandlers } from "./native-permissions.js";
 import { MACOS_PERMISSION_CAPABILITY } from "./permission-protocol.js";
 import { nativeLoopbackSocketOptions } from "./native-loopback-lookup.js";
@@ -41,8 +46,11 @@ 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 ?? {
-        ...createSystemHandlers(),
+        ...commandOutput?.handlers(),
+        ...createSystemHandlers(undefined, undefined, undefined, systemResultProtection),
         ...computers.handlers(),
         ...notifications.handlers(),
         ...createNativePermissionHandlers(options.identity.os),
@@ -101,6 +109,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 +157,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 +176,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;
@@ -180,7 +194,7 @@ export async function connectNativeHost(options) {
             catch (error) {
                 if (!(error instanceof NativeOperationInputError))
                     throw error;
-                sendResult(message.id, operationFailure(error.message, error.code));
+                sendResult(message.id, operationFailure(redactSecretText(error.message), error.code));
                 return;
             }
             const handler = handlers[message.operation];
@@ -244,8 +258,10 @@ export async function connectNativeHost(options) {
                 version: HOST_PROTOCOL_VERSION,
                 identity: options.identity,
                 capabilities: [
+                    ...(options.handlers ? [] : [HOST_SECRET_PROTECTION_CAPABILITY]),
                     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/observation-filter.js

@@ -1,32 +1,8 @@
 import { createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
 import { isHostRecord } from "./protocol.js";
+import { isOwnApplicationObservation } from "../../shared/passive-observation-self-exclusion.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;
@@ -111,7 +87,7 @@ export class ObservationFilter {
         };
         if (!hasBoundedSourceMetadata(rawSource))
             return undefined;
-        if (isOwnWebUiWindowTitle(rawSource.title)) {
+        if (isOwnApplicationObservation(rawSource)) {
             this.lastSource = undefined;
             return undefined;
         }

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

@@ -11,6 +11,8 @@ export declare function desktopCollectorCommand(platform: string): {
 export declare function startDesktopCollector(options: {
     excludedApplications: readonly string[];
     onEvent(event: PassiveCollectorEvent): void;
+    /** Confirms helper exit or that no helper was created; close alone does not confirm either. */
+    onStopped?(): void;
     platform?: string;
     spawnProcess?: typeof spawn;
 }): DesktopCollector;

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

@@ -34,12 +34,19 @@ export function startDesktopCollector(options) {
     const command = desktopCollectorCommand(options.platform ?? process.platform);
     let child;
     let closed = false;
+    let stopped = false;
+    const confirmStopped = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        options.onStopped?.();
+    };
     let received = Buffer.alloc(0);
     let terminalStatus = false;
     const filter = new ObservationFilter(options.excludedApplications);
     const close = () => {
         closed = true;
-        if (!child?.pid)
+        if (stopped || !child?.pid)
             return;
         // POSIX language launchers can spawn an interpreter; stop the entire owned process group.
         if (process.platform !== "win32") {
@@ -59,6 +66,7 @@ export function startDesktopCollector(options) {
             state: "unavailable",
             reason: "platform_unsupported",
         });
+        confirmStopped();
         return { close };
     }
     if (process.platform === "darwin") {
@@ -77,19 +85,28 @@ export function startDesktopCollector(options) {
                 state: "unavailable",
                 reason: "macos_swift_tools_unavailable",
             });
+            confirmStopped();
             return { close };
         }
     }
     options.onEvent({ type: "status", state: "starting" });
-    child = (options.spawnProcess ?? spawn)(command.file, command.args, {
-        windowsHide: true,
-        detached: process.platform !== "win32",
-        stdio: ["pipe", "pipe", "pipe"],
-        env: {
-            ...process.env,
-            ABOT_OBSERVATION_EXCLUSIONS: JSON.stringify(options.excludedApplications),
-        },
-    });
+    try {
+        child = (options.spawnProcess ?? spawn)(command.file, command.args, {
+            windowsHide: true,
+            detached: process.platform !== "win32",
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                ABOT_OBSERVATION_EXCLUSIONS: JSON.stringify(options.excludedApplications),
+            },
+        });
+    }
+    catch {
+        options.onEvent({ type: "status", state: "failed", reason: "collector_start_failed" });
+        closed = true;
+        confirmStopped();
+        return { close };
+    }
     child.stdin?.on("error", () => { });
     child.stdin?.end(command.input);
     // Compiler/dependency diagnostics can contain local paths. Never forward them into model or general logs.
@@ -130,25 +147,34 @@ export function startDesktopCollector(options) {
         }
     });
     child.once("error", () => {
-        if (closed)
-            return;
-        options.onEvent({
-            type: "status",
-            state: "unavailable",
-            reason: "collector_dependency_unavailable",
-        });
-        close();
-    });
-    child.once("exit", (code) => {
-        if (closed)
-            return;
-        if (!terminalStatus)
+        try {
+            if (closed)
+                return;
             options.onEvent({
                 type: "status",
                 state: "unavailable",
-                reason: code === 0 ? "collector_stopped" : "collector_start_failed",
+                reason: "collector_dependency_unavailable",
             });
-        close();
+            close();
+        }
+        finally {
+            if (!child?.pid)
+                confirmStopped();
+        }
+    });
+    child.once("exit", (code) => {
+        try {
+            if (!closed && !terminalStatus)
+                options.onEvent({
+                    type: "status",
+                    state: "unavailable",
+                    reason: code === 0 ? "collector_stopped" : "collector_start_failed",
+                });
+        }
+        finally {
+            closed = true;
+            confirmStopped();
+        }
     });
     return { close };
 }