@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -0,0 +1,72 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, symlink, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { NOTIFICATION_OWNER_MARKER, notificationInstallDirectory, } from "./notification-locations.js";
+import { assertNotificationBackingUnchanged, assertNotificationOwnershipUnchanged, readOwnedNotificationDirectory, renderNotificationLinkOwner, } from "./notification-directory-ownership.js";
+import { publishWindowsNotificationDirectory } from "./notification-directory-windows.js";
+import { runNotificationProcess, } from "./notification-process.js";
+function requiresNotificationDirectoryLink() {
+    return process.platform !== "win32";
+}
+export async function hasOwnedNotificationDirectory(locations) {
+    return Boolean(await readOwnedNotificationDirectory(locations));
+}
+async function publishOwnedNotificationDirectory(staged, locations, run) {
+    if (await hasOwnedNotificationDirectory(locations))
+        return false;
+    const directory = notificationInstallDirectory(locations);
+    try {
+        if (!requiresNotificationDirectoryLink()) {
+            await publishWindowsNotificationDirectory(staged, directory, run);
+            return false;
+        }
+        await symlink(basename(staged), directory, "dir");
+        return true;
+    }
+    catch (error) {
+        if (await hasOwnedNotificationDirectory(locations))
+            return false;
+        throw error;
+    }
+}
+export async function ensureOwnedNotificationDirectory(locations, run = runNotificationProcess) {
+    if (await hasOwnedNotificationDirectory(locations))
+        return;
+    const directory = notificationInstallDirectory(locations);
+    await mkdir(dirname(directory), { recursive: true, mode: 0o700 });
+    const staged = directory + ".data-" + randomUUID();
+    await mkdir(staged, { mode: 0o700 });
+    let retainBacking = false;
+    try {
+        await writeFile(join(staged, ".owner"), NOTIFICATION_OWNER_MARKER, {
+            flag: "wx",
+            mode: 0o600,
+            flush: true,
+        });
+        if (requiresNotificationDirectoryLink()) {
+            await writeFile(join(staged, ".owner-link"), renderNotificationLinkOwner(directory, staged), {
+                flag: "wx",
+                mode: 0o600,
+                flush: true,
+            });
+        }
+        retainBacking = await publishOwnedNotificationDirectory(staged, locations, run);
+    }
+    finally {
+        if (!retainBacking)
+            await rm(staged, { recursive: true, force: true });
+    }
+}
+export async function removeOwnedNotificationDirectory(locations) {
+    const owner = await readOwnedNotificationDirectory(locations);
+    if (!owner)
+        return;
+    await assertNotificationOwnershipUnchanged(owner);
+    if (owner.linkTarget === undefined) {
+        await rm(owner.directory, { recursive: true });
+        return;
+    }
+    await unlink(owner.directory);
+    await assertNotificationBackingUnchanged(owner);
+    await rm(owner.backing, { recursive: true });
+}

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

@@ -0,0 +1,10 @@
+import type { NativeAutostartOptions } from "./autostart.js";
+export { hasOwnedNotificationDirectory } from "./notification-directory.js";
+import { type NotificationLocations } from "./notification-locations.js";
+import { type NotificationProcessRunner } from "./notification-process.js";
+export declare function notificationLocationsFromStartup(startup: NativeAutostartOptions): NotificationLocations;
+export declare function linuxNotificationDesktopPath(locations: NotificationLocations): string;
+export declare function renderLinuxNotificationDesktop(runtimeUrl: string): string;
+export declare function stopMacNotificationApp(locations: NotificationLocations, run: NotificationProcessRunner): Promise<void>;
+export declare function installDesktopNotificationIdentity(startup: NativeAutostartOptions, runtimeUrl: string, run?: NotificationProcessRunner): Promise<void>;
+export declare function uninstallDesktopNotificationIdentity(startup: NativeAutostartOptions, run?: NotificationProcessRunner): Promise<void>;

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

@@ -0,0 +1,201 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
+import { ensureOwnedNotificationDirectory, hasOwnedNotificationDirectory, removeOwnedNotificationDirectory, } from "./notification-directory.js";
+export { hasOwnedNotificationDirectory } from "./notification-directory.js";
+import { MAC_NOTIFICATION_STOP_SCRIPT, renderMacNotificationApplet, } from "./notification-macos.js";
+import { NOTIFICATION_APP_ID, NOTIFICATION_OWNER_MARKER, macNotificationAppPath, notificationInstallDirectory, } from "./notification-locations.js";
+import { notificationRuntimeOrigin } from "./notification-protocol.js";
+import { runNotificationProcess, } from "./notification-process.js";
+import { powershellNotificationArguments, WINDOWS_NOTIFICATION_IDENTITY_SCRIPT, } from "./notification-windows.js";
+import { configureMacNotificationBundle } from "./notification-macos-bundle.js";
+export function notificationLocationsFromStartup(startup) {
+    return {
+        stateDir: startup.stateDir,
+        homeDir: startup.homeDir,
+        appData: startup.appData,
+        xdgDataHome: process.env.XDG_DATA_HOME,
+    };
+}
+export function linuxNotificationDesktopPath(locations) {
+    const dataHome = locations.xdgDataHome && isAbsolute(locations.xdgDataHome)
+        ? locations.xdgDataHome
+        : join(locations.homeDir, ".local", "share");
+    return join(dataHome, "applications", NOTIFICATION_APP_ID + ".desktop");
+}
+function desktopArgument(value) {
+    return ('"' +
+        value
+            .replaceAll("\\", "\\\\")
+            .replaceAll('"', '\\"')
+            .replaceAll("%", "%%")
+            .replaceAll("$", "\\$")
+            .replaceAll("\u0060", "\\\u0060") +
+        '"');
+}
+export function renderLinuxNotificationDesktop(runtimeUrl) {
+    const url = notificationRuntimeOrigin(runtimeUrl) + "/notifications";
+    return [
+        "[Desktop Entry]",
+        "# " + NOTIFICATION_OWNER_MARKER,
+        "Type=Application",
+        "Name=ABot",
+        "Comment=ABot notifications",
+        "Exec=xdg-open " + desktopArgument(url),
+        "Terminal=false",
+        "NoDisplay=true",
+        "StartupNotify=false",
+        "",
+    ].join("\n");
+}
+async function assertLinuxDesktopOwnership(path) {
+    const stat = await lstat(path).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return false;
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error("notification_registration_not_owned");
+    if (!(await readFile(path, "utf8")).includes("# " + NOTIFICATION_OWNER_MARKER))
+        throw new Error("notification_registration_not_owned");
+    return true;
+}
+export async function stopMacNotificationApp(locations, run) {
+    await run({
+        file: "/usr/bin/osascript",
+        args: [
+            "-l",
+            "JavaScript",
+            "-e",
+            MAC_NOTIFICATION_STOP_SCRIPT,
+            macNotificationAppPath(locations),
+        ],
+    });
+}
+async function installMacNotificationApp(locations, run) {
+    const directory = notificationInstallDirectory(locations);
+    const source = join(directory, "notification-helper.js");
+    const temporary = join(directory, "ABot.next.app");
+    const app = macNotificationAppPath(locations);
+    await writeFile(source, renderMacNotificationApplet(locations.stateDir), {
+        mode: 0o600,
+    });
+    await rm(temporary, { recursive: true, force: true });
+    await run({
+        file: "/usr/bin/osacompile",
+        args: ["-l", "JavaScript", "-s", "-o", temporary, source],
+        timeoutMs: 30_000,
+    });
+    await configureMacNotificationBundle(temporary, run);
+    await run({
+        file: "/usr/bin/codesign",
+        args: [
+            "--force",
+            "--sign",
+            "-",
+            "--identifier",
+            NOTIFICATION_APP_ID,
+            temporary,
+        ],
+        timeoutMs: 30_000,
+    });
+    await stopMacNotificationApp(locations, run);
+    await rm(app, { recursive: true, force: true });
+    await rename(temporary, app);
+    await run({
+        file: "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister",
+        args: ["-f", app],
+    });
+}
+export async function installDesktopNotificationIdentity(startup, runtimeUrl, run = runNotificationProcess) {
+    const locations = notificationLocationsFromStartup(startup);
+    const directory = notificationInstallDirectory(locations);
+    await ensureOwnedNotificationDirectory(locations, run);
+    await rm(join(directory, ".ready"), { force: true });
+    await mkdir(join(directory, "pending"), { recursive: true, mode: 0o700 });
+    await registerDesktopNotificationIdentity(startup.platform, locations, runtimeUrl, run);
+    await writeFile(join(directory, ".ready"), startup.platform, { mode: 0o600 });
+}
+async function registerDesktopNotificationIdentity(platform, locations, runtimeUrl, run) {
+    if (platform === "win32") {
+        await run({
+            file: "powershell.exe",
+            args: powershellNotificationArguments(WINDOWS_NOTIFICATION_IDENTITY_SCRIPT),
+            input: JSON.stringify({
+                action: "install",
+                url: notificationRuntimeOrigin(runtimeUrl) + "/notifications",
+            }),
+        });
+        return;
+    }
+    if (platform === "darwin")
+        return installMacNotificationApp(locations, run);
+    if (platform === "linux")
+        return installLinuxNotificationIdentity(locations, runtimeUrl, run);
+    throw new Error("notification_platform_unsupported");
+}
+async function uninstallMacNotificationApp(locations, run) {
+    const app = macNotificationAppPath(locations);
+    const stat = await lstat(app).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!stat)
+        return;
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error("notification_registration_not_owned");
+    await stopMacNotificationApp(locations, run);
+    await run({
+        file: "/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister",
+        args: ["-u", app],
+    });
+}
+async function installLinuxNotificationIdentity(locations, runtimeUrl, run) {
+    const help = await run({ file: "notify-send", args: ["--help"] }).catch(() => {
+        throw new Error("Desktop notifications require notify-send from libnotify-bin on the Linux desktop.");
+    });
+    if (!["--wait", "--action", "--print-id"].every((option) => help.includes(option)))
+        throw new Error("Desktop notifications require a notify-send version with action support.");
+    await run({ file: "xdg-open", args: ["--version"] });
+    await run({ file: "gdbus", args: ["help"] }).catch(() => {
+        throw new Error("Desktop notification actions require gdbus from libglib2.0-bin on the Linux desktop.");
+    });
+    const path = linuxNotificationDesktopPath(locations);
+    await assertLinuxDesktopOwnership(path);
+    await mkdir(dirname(path), { recursive: true });
+    const content = renderLinuxNotificationDesktop(runtimeUrl);
+    const temporary = path + "." + randomUUID() + ".tmp";
+    const file = await open(temporary, "wx", 0o600);
+    try {
+        await file.writeFile(content).finally(() => file.close());
+        await assertLinuxDesktopOwnership(path);
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function uninstallDesktopNotificationIdentity(startup, run = runNotificationProcess) {
+    const locations = notificationLocationsFromStartup(startup);
+    if (!(await hasOwnedNotificationDirectory(locations)))
+        return;
+    if (startup.platform === "win32") {
+        await run({
+            file: "powershell.exe",
+            args: powershellNotificationArguments(WINDOWS_NOTIFICATION_IDENTITY_SCRIPT),
+            input: JSON.stringify({ action: "uninstall" }),
+        });
+    }
+    if (startup.platform === "darwin") {
+        await uninstallMacNotificationApp(locations, run);
+    }
+    if (startup.platform === "linux") {
+        const path = linuxNotificationDesktopPath(locations);
+        if (await assertLinuxDesktopOwnership(path))
+            await rm(path);
+    }
+    await removeOwnedNotificationDirectory(locations);
+}

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

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+import type { DesktopNotification } from "./notification-protocol.js";
+import { type NotificationProcessRunner } from "./notification-process.js";
+export declare function hasLinuxNotificationActions(run: NotificationProcessRunner, signal?: AbortSignal): Promise<boolean>;
+export declare function linuxNotificationArguments(notification: DesktopNotification): string[];
+/** Retain actions for the latest 32 desktop alerts; older history stays in ABot. */
+export declare class LinuxNotificationRenderer {
+    private readonly start;
+    private readonly run;
+    private readonly children;
+    private readonly shutdown;
+    private submissions;
+    constructor(start?: typeof spawn, run?: NotificationProcessRunner);
+    send(notification: DesktopNotification, signal?: AbortSignal): Promise<void>;
+    private needsListenerRecycling;
+    private recycleOldestListener;
+    private waitForListenerExit;
+    private submit;
+    close(): void;
+}

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

@@ -0,0 +1,207 @@
+import { spawn } from "node:child_process";
+import { NOTIFICATION_APP_ID } from "./notification-locations.js";
+import { runNotificationProcess, } from "./notification-process.js";
+function notificationMarkupText(value) {
+    return value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;");
+}
+export async function hasLinuxNotificationActions(run, signal) {
+    signal?.throwIfAborted();
+    const capabilities = await run({
+        file: "gdbus",
+        args: [
+            "call",
+            "--session",
+            "--dest",
+            "org.freedesktop.Notifications",
+            "--object-path",
+            "/org/freedesktop/Notifications",
+            "--method",
+            "org.freedesktop.Notifications.GetCapabilities",
+        ],
+        timeoutMs: 2000,
+        signal,
+    });
+    signal?.throwIfAborted();
+    return /['"]actions['"]/u.test(capabilities);
+}
+export function linuxNotificationArguments(notification) {
+    return [
+        "--app-name=ABot",
+        "--print-id",
+        "--wait",
+        "--action=default=Open in ABot",
+        "--hint=string:desktop-entry:" + NOTIFICATION_APP_ID,
+        "--hint=boolean:suppress-sound:true",
+        "--expire-time=86400000",
+        "--",
+        notification.title,
+        notificationMarkupText(notification.body),
+    ];
+}
+/** Retain actions for the latest 32 desktop alerts; older history stays in ABot. */
+export class LinuxNotificationRenderer {
+    start;
+    run;
+    children = new Map();
+    shutdown = new AbortController();
+    submissions = Promise.resolve();
+    constructor(start = spawn, run = runNotificationProcess) {
+        this.start = start;
+        this.run = run;
+    }
+    send(notification, signal) {
+        const lifetime = signal
+            ? AbortSignal.any([signal, this.shutdown.signal])
+            : this.shutdown.signal;
+        const submitted = this.submissions.then(() => this.submit(notification, lifetime));
+        this.submissions = submitted.catch(() => undefined);
+        return submitted;
+    }
+    needsListenerRecycling() {
+        return this.children.size >= 32;
+    }
+    async recycleOldestListener(signal) {
+        if (!this.needsListenerRecycling())
+            return;
+        const listener = this.children.values().next().value;
+        if (!listener)
+            return;
+        if (listener.nativeId) {
+            await this.run({
+                file: "gdbus",
+                args: [
+                    "call",
+                    "--session",
+                    "--dest",
+                    "org.freedesktop.Notifications",
+                    "--object-path",
+                    "/org/freedesktop/Notifications",
+                    "--method",
+                    "org.freedesktop.Notifications.CloseNotification",
+                    listener.nativeId,
+                ],
+                signal,
+                timeoutMs: 2000,
+            });
+        }
+        listener.stop();
+        await this.waitForListenerExit(listener, signal);
+    }
+    waitForListenerExit(listener, signal) {
+        return new Promise((resolve, reject) => {
+            const deadline = setTimeout(() => finish(new Error("notification_native_timeout")), 2000);
+            const abort = () => finish(new Error("notification_cancelled"));
+            function finish(error) {
+                clearTimeout(deadline);
+                signal.removeEventListener("abort", abort);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            }
+            signal.addEventListener("abort", abort, { once: true });
+            void listener.exited.then(() => finish());
+            if (signal.aborted)
+                abort();
+        });
+    }
+    async submit(notification, signal) {
+        signal.throwIfAborted();
+        if (!(await hasLinuxNotificationActions(this.run, signal)))
+            throw new Error("notification_actions_unavailable");
+        signal.throwIfAborted();
+        await this.recycleOldestListener(signal);
+        signal.throwIfAborted();
+        const child = this.start("notify-send", linuxNotificationArguments(notification), {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let markExited = () => undefined;
+        const listener = {
+            stop: () => undefined,
+            exited: new Promise((resolve) => {
+                markExited = resolve;
+            }),
+        };
+        this.children.set(child, listener);
+        return new Promise((resolve, reject) => {
+            let output = "";
+            let errors = "";
+            let submitted = false;
+            let settled = false;
+            let listening = true;
+            const deadline = setTimeout(() => fail(new Error("notification_native_timeout")), 10_000);
+            const abort = () => fail(new Error("notification_cancelled"));
+            function finish(error) {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(deadline);
+                signal?.removeEventListener("abort", abort);
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            }
+            function fail(error) {
+                if (!listening)
+                    return;
+                listening = false;
+                finish(error);
+                child.kill();
+            }
+            listener.stop = () => fail(new Error("notification_cancelled"));
+            signal?.addEventListener("abort", abort, { once: true });
+            child.stdout?.setEncoding("utf8").on("data", (chunk) => {
+                if (!listening)
+                    return;
+                output += chunk;
+                if (output.length > 4096) {
+                    fail(new Error("notification_native_output_limit"));
+                    return;
+                }
+                let boundary = output.indexOf("\n");
+                while (boundary >= 0) {
+                    const line = output.slice(0, boundary).trim();
+                    output = output.slice(boundary + 1);
+                    if (!submitted && /^[1-9][0-9]*$/.test(line)) {
+                        submitted = true;
+                        listener.nativeId = line;
+                        finish();
+                    }
+                    else if (submitted && line === "default") {
+                        void this.run({ file: "xdg-open", args: [notification.url] }).catch(() => { });
+                    }
+                    boundary = output.indexOf("\n");
+                }
+            });
+            child.stderr?.setEncoding("utf8").on("data", (chunk) => {
+                errors = (errors + chunk).slice(-4096);
+            });
+            child.once("error", (error) => {
+                listening = false;
+                this.children.delete(child);
+                markExited();
+                finish(error);
+            });
+            child.once("close", () => {
+                listening = false;
+                this.children.delete(child);
+                markExited();
+                if (!submitted)
+                    finish(new Error(errors.trim() || "notification_native_failed"));
+            });
+            if (signal?.aborted)
+                abort();
+        });
+    }
+    close() {
+        this.shutdown.abort();
+        for (const listener of this.children.values())
+            listener.stop();
+    }
+}

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

@@ -0,0 +1,12 @@
+export declare const NOTIFICATION_APP_ID = "com.abot.notifications";
+export declare const NOTIFICATION_OWNER_MARKER = "ABot managed desktop notifications v1";
+export declare const NOTIFICATION_WINDOWS_CLSID = "{E13CEAD1-5B60-4B49-9537-54836F743F2E}";
+export type NotificationLocations = Readonly<{
+    stateDir: string;
+    homeDir: string;
+    appData?: string;
+    xdgDataHome?: string;
+}>;
+export declare function defaultNotificationLocations(): NotificationLocations;
+export declare function notificationInstallDirectory(locations: NotificationLocations): string;
+export declare function macNotificationAppPath(locations: NotificationLocations): string;

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

@@ -0,0 +1,20 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const NOTIFICATION_APP_ID = "com.abot.notifications";
+export const NOTIFICATION_OWNER_MARKER = "ABot managed desktop notifications v1";
+export const NOTIFICATION_WINDOWS_CLSID = "{E13CEAD1-5B60-4B49-9537-54836F743F2E}";
+export function defaultNotificationLocations() {
+    const homeDir = homedir();
+    return {
+        homeDir,
+        stateDir: join(homeDir, ".abot", "host-companion"),
+        appData: process.env.APPDATA,
+        xdgDataHome: process.env.XDG_DATA_HOME,
+    };
+}
+export function notificationInstallDirectory(locations) {
+    return join(locations.stateDir, "notifications");
+}
+export function macNotificationAppPath(locations) {
+    return join(notificationInstallDirectory(locations), "ABot.app");
+}

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

@@ -0,0 +1,3 @@
+import type { NotificationProcessRunner } from "./notification-process.js";
+export declare function assertMacNotificationBundle(app: string, run: NotificationProcessRunner, signal?: AbortSignal): Promise<void>;
+export declare function configureMacNotificationBundle(app: string, run: NotificationProcessRunner): Promise<void>;

package/dist/src/computer-access/companion/notification-macos-bundle.js

@@ -0,0 +1,84 @@
+import { constants } from "node:fs";
+import { access, lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { NOTIFICATION_APP_ID } from "./notification-locations.js";
+/** Foundation retains compiler-owned plist values and their native types. */
+const MAC_NOTIFICATION_PLIST_SCRIPT = String.raw `
+ObjC.import('Foundation');
+function run(argv) {
+  var plist = $.NSMutableDictionary.alloc.initWithContentsOfFile($(argv[0]));
+  if (!plist) throw new Error('notification_bundle_plist_invalid');
+  if (argv[1]) {
+    var updates = JSON.parse(argv[1]);
+    Object.keys(updates).forEach(function(key) {
+      plist.setObjectForKey($(updates[key]), $(key));
+    });
+    if (!plist.writeToFileAtomically($(argv[0]), true))
+      throw new Error('notification_bundle_plist_write_failed');
+  }
+  return JSON.stringify({
+    executable: ObjC.unwrap(plist.objectForKey('CFBundleExecutable')),
+    identifier: ObjC.unwrap(plist.objectForKey('CFBundleIdentifier'))
+  });
+}
+`;
+function isBundleExecutableName(value) {
+    if (typeof value !== "string" || value.length === 0)
+        return false;
+    if (value === "." || value === "..")
+        return false;
+    return !/[\\/\u0000-\u001f\u007f]/.test(value);
+}
+async function assertBundleDirectory(path) {
+    const stat = await lstat(path);
+    if (!stat.isDirectory() || stat.isSymbolicLink())
+        throw new Error("notification_bundle_directory_invalid");
+}
+async function assertBundleFile(path) {
+    const stat = await lstat(path);
+    if (!stat.isFile() || stat.isSymbolicLink())
+        throw new Error("notification_bundle_file_invalid");
+}
+async function readBundleMetadata(app, run, signal) {
+    await assertBundleDirectory(app);
+    await assertBundleDirectory(join(app, "Contents"));
+    await assertBundleDirectory(join(app, "Contents", "MacOS"));
+    const plist = join(app, "Contents", "Info.plist");
+    await assertBundleFile(plist);
+    return JSON.parse(await run({
+        file: "/usr/bin/osascript",
+        args: ["-l", "JavaScript", "-e", MAC_NOTIFICATION_PLIST_SCRIPT, plist],
+        signal,
+    }));
+}
+async function assertBundleExecutable(app, executable) {
+    if (!isBundleExecutableName(executable))
+        throw new Error("notification_bundle_executable_invalid");
+    const path = join(app, "Contents", "MacOS", executable);
+    await assertBundleFile(path);
+    await access(path, constants.X_OK);
+}
+export async function assertMacNotificationBundle(app, run, signal) {
+    const metadata = await readBundleMetadata(app, run, signal);
+    if (metadata.identifier !== NOTIFICATION_APP_ID)
+        throw new Error("notification_bundle_identity_invalid");
+    await assertBundleExecutable(app, metadata.executable);
+}
+export async function configureMacNotificationBundle(app, run) {
+    const metadata = await readBundleMetadata(app, run);
+    await assertBundleExecutable(app, metadata.executable);
+    await run({
+        file: "/usr/bin/osascript",
+        args: ["-l", "JavaScript", "-e", MAC_NOTIFICATION_PLIST_SCRIPT,
+            join(app, "Contents", "Info.plist"), JSON.stringify({
+                CFBundleIdentifier: NOTIFICATION_APP_ID,
+                CFBundleName: "ABot",
+                CFBundleDisplayName: "ABot",
+                LSUIElement: true,
+                OSAAppletStayOpen: true,
+                OSAAppletShowStartupScreen: false,
+                NSHighResolutionCapable: true,
+            })],
+    });
+    await assertMacNotificationBundle(app, run);
+}

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

@@ -0,0 +1,11 @@
+import type { DesktopNotification } from "./notification-protocol.js";
+import { type NotificationLocations } from "./notification-locations.js";
+import { type NotificationProcessRunner } from "./notification-process.js";
+/**
+ * Runs inside the installed ABot.app, not osascript. NSUserNotification is the
+ * documented applet-compatible API; native macOS acceptance is required because
+ * Apple deprecated this API in favor of UserNotifications.
+ */
+export declare function renderMacNotificationApplet(stateDir: string): string;
+export declare function sendMacNotification(notification: DesktopNotification, locations: NotificationLocations, signal?: AbortSignal, run?: NotificationProcessRunner): Promise<void>;
+export declare const MAC_NOTIFICATION_STOP_SCRIPT: string;