@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/web-ui/notifications/service.js

@@ -0,0 +1,131 @@
+import { NotificationDeliveryQueue } from "./delivery-queue.js";
+import { projectNotificationEvent } from "./event-projection.js";
+import { WebNotificationStore, notificationStorePath } from "./store.js";
+function isSuppressedReply(item, options) {
+    if (item.kind !== "reply")
+        return false;
+    return options.isViewing(item.environmentId, item.sessionId);
+}
+function permitsDesktopNotification(preferences, item) {
+    if (!preferences.desktopEnabled)
+        return false;
+    return preferences.kinds[item.kind];
+}
+/** Owns UI notification records, never session history or model execution. */
+export class WebNotificationService {
+    options;
+    stores = new Map();
+    queue = Promise.resolve();
+    deliveries = new NotificationDeliveryQueue();
+    abort = new AbortController();
+    now;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+    }
+    hasEnvironment = (id) => {
+        return this.options.hasEnvironment(id);
+    };
+    store(environmentId) {
+        const { paths } = this.options.environment(environmentId).services.config;
+        const path = notificationStorePath({
+            environmentId,
+            runtimeDir: paths.runtimeDir,
+            sessionsDir: paths.sessionsDir,
+        });
+        const existing = this.stores.get(path);
+        if (existing)
+            return existing;
+        const store = new WebNotificationStore(path, environmentId);
+        const opening = this.reconcileInterruptedDelivery(store).catch((error) => {
+            this.stores.delete(path);
+            throw error;
+        });
+        this.stores.set(path, opening);
+        return opening;
+    }
+    async reconcileInterruptedDelivery(store) {
+        await store.reconcilePendingDeliveries();
+        return store;
+    }
+    observe(event) {
+        if (this.abort.signal.aborted)
+            return;
+        const item = projectNotificationEvent(event, this.now());
+        if (!item || isSuppressedReply(item, this.options))
+            return;
+        if (!this.hasEnvironment(item.environmentId))
+            return;
+        this.queue = this.queue
+            .then(() => this.record(item))
+            .catch((error) => this.reportFailure(item.environmentId, error));
+    }
+    async record(item) {
+        const store = await this.store(item.environmentId);
+        const preferences = await store.getPreferences();
+        const shouldDeliver = permitsDesktopNotification(preferences, item);
+        const result = await store.upsert({
+            ...item,
+            delivery: { status: shouldDeliver ? "pending" : "disabled" },
+        });
+        if (!result.created)
+            return;
+        this.options.changed(item.environmentId);
+        if (!shouldDeliver)
+            return;
+        void this.deliveries
+            .enqueue(() => this.deliver(store, result.item))
+            .catch((error) => this.reportFailure(item.environmentId, error));
+    }
+    canSubmitDesktopNotification() {
+        return !this.abort.signal.aborted;
+    }
+    async desktopOutcome(item, preferences) {
+        if (!this.canSubmitDesktopNotification())
+            return {
+                status: "unavailable",
+                error: "ABot stopped before desktop delivery started.",
+            };
+        if (!permitsDesktopNotification(preferences, item))
+            return { status: "disabled" };
+        try {
+            return await this.options.deliver(item, this.abort.signal);
+        }
+        catch {
+            return {
+                status: "unknown",
+                error: "Desktop delivery was not confirmed.",
+            };
+        }
+    }
+    async deliver(store, item) {
+        const preferences = await store.getPreferences();
+        const delivery = await this.desktopOutcome(item, preferences);
+        await store.updateDelivery(item.id, delivery);
+        this.options.changed(item.environmentId);
+    }
+    reportFailure(environmentId, error) {
+        console.error(`Notification history unavailable for ${environmentId}:`, error);
+    }
+    list = async (environmentId, query) => (await this.store(environmentId)).list(query);
+    desktop = (_environmentId) => this.options.desktop();
+    markRead = async (environmentId, change) => {
+        const result = await (await this.store(environmentId)).markRead(change, this.now());
+        if (result.updated)
+            this.options.changed(environmentId);
+        return result;
+    };
+    setPreferences = async (environmentId, preferences) => {
+        const result = await (await this.store(environmentId)).setPreferences(preferences);
+        this.options.changed(environmentId);
+        return result;
+    };
+    async flush() {
+        await this.queue;
+        await this.deliveries.flush();
+    }
+    async stop() {
+        this.abort.abort();
+        await this.flush();
+    }
+}

package/dist/src/web-ui/notifications/storage-schema.d.ts

@@ -0,0 +1,15 @@
+import type { NotificationDelivery, NotificationPreferences, WebNotification } from "./contracts.js";
+export type NotificationStoreState = {
+    version: 1;
+    environmentId: string;
+    items: WebNotification[];
+    preferences: NotificationPreferences;
+};
+export declare function isNotificationRecord(value: unknown): value is Record<string, unknown>;
+export declare function hasOnlyNotificationFields(value: Record<string, unknown>, allowed: readonly string[]): boolean;
+export declare function isNotificationIdentifier(value: unknown): value is string;
+export declare function isNotificationTimestamp(value: unknown): value is number;
+export declare function isNotificationPreferences(value: unknown): value is NotificationPreferences;
+export declare function isNotificationDelivery(value: unknown): value is NotificationDelivery;
+export declare function isWebNotification(value: unknown, environmentId: string): value is WebNotification;
+export declare function decodeNotificationState(raw: string, environmentId: string): NotificationStoreState;

package/dist/src/web-ui/notifications/storage-schema.js

@@ -0,0 +1,170 @@
+export function isNotificationRecord(value) {
+    if (value === null)
+        return false;
+    if (typeof value !== "object")
+        return false;
+    return !Array.isArray(value);
+}
+export function hasOnlyNotificationFields(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+export function isNotificationIdentifier(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim() !== value)
+        return false;
+    if (!value.length)
+        return false;
+    if (value.length > 512)
+        return false;
+    return !/[\u0000-\u001f\u007f]/u.test(value);
+}
+export function isNotificationTimestamp(value) {
+    if (typeof value !== "number")
+        return false;
+    if (!Number.isSafeInteger(value))
+        return false;
+    return value >= 0;
+}
+function isNotificationText(value, maximum) {
+    if (typeof value !== "string")
+        return false;
+    return value.length <= maximum;
+}
+export function isNotificationPreferences(value) {
+    if (!isNotificationRecord(value))
+        return false;
+    if (!hasOnlyNotificationFields(value, ["desktopEnabled", "kinds"]))
+        return false;
+    if (typeof value.desktopEnabled !== "boolean")
+        return false;
+    if (!isNotificationRecord(value.kinds))
+        return false;
+    const kinds = ["reply", "failure", "approval", "proposal"];
+    const preferences = value.kinds;
+    if (!hasOnlyNotificationFields(preferences, kinds))
+        return false;
+    return kinds.every((kind) => typeof preferences[kind] === "boolean");
+}
+export function isNotificationDelivery(value) {
+    if (!isNotificationRecord(value))
+        return false;
+    if (!hasOnlyNotificationFields(value, ["status", "error"]))
+        return false;
+    const statuses = [
+        "pending",
+        "submitted",
+        "disabled",
+        "unavailable",
+        "failed",
+        "unknown",
+    ];
+    if (typeof value.status !== "string")
+        return false;
+    if (!statuses.includes(value.status))
+        return false;
+    if (value.error === undefined)
+        return true;
+    return isNotificationText(value.error, 4096);
+}
+function hasBoundNotificationSource(value) {
+    if (typeof value.sourceUrl !== "string")
+        return false;
+    if (!value.sourceUrl.startsWith("/chat?"))
+        return false;
+    try {
+        const url = new URL(value.sourceUrl, "http://notification.local");
+        if (url.origin !== "http://notification.local")
+            return false;
+        if (url.pathname !== "/chat")
+            return false;
+        if (url.hash)
+            return false;
+        if (url.searchParams.get("environment") !== value.environmentId)
+            return false;
+        if (url.searchParams.get("session") !== value.sessionId)
+            return false;
+        if (url.searchParams.getAll("environment").length !== 1)
+            return false;
+        if (url.searchParams.getAll("session").length !== 1)
+            return false;
+        return [...url.searchParams.keys()].every((key) => ["environment", "session"].includes(key));
+    }
+    catch {
+        return false;
+    }
+}
+export function isWebNotification(value, environmentId) {
+    if (!isNotificationRecord(value))
+        return false;
+    const fields = [
+        "id",
+        "kind",
+        "title",
+        "body",
+        "createdAt",
+        "readAt",
+        "environmentId",
+        "sessionId",
+        "requestId",
+        "sourceUrl",
+        "delivery",
+    ];
+    if (!hasOnlyNotificationFields(value, fields))
+        return false;
+    if (!isNotificationIdentifier(value.id))
+        return false;
+    if (typeof value.kind !== "string")
+        return false;
+    if (!["reply", "failure", "approval", "proposal"].includes(value.kind))
+        return false;
+    if (!isNotificationText(value.title, 1024))
+        return false;
+    if (!value.title.trim())
+        return false;
+    if (!isNotificationText(value.body, 16384))
+        return false;
+    if (!isNotificationTimestamp(value.createdAt))
+        return false;
+    if (value.readAt !== null && !isNotificationTimestamp(value.readAt))
+        return false;
+    if (value.environmentId !== environmentId)
+        return false;
+    if (!isNotificationIdentifier(value.sessionId))
+        return false;
+    if (value.requestId !== undefined &&
+        !isNotificationIdentifier(value.requestId))
+        return false;
+    if (!hasBoundNotificationSource(value))
+        return false;
+    return isNotificationDelivery(value.delivery);
+}
+export function decodeNotificationState(raw, environmentId) {
+    const value = JSON.parse(raw);
+    if (!isNotificationRecord(value))
+        throw new Error("Invalid notification storage.");
+    if (value.version !== 1)
+        throw new Error("Unsupported notification storage version.");
+    if (value.environmentId !== environmentId)
+        throw new Error("Notification storage environment mismatch.");
+    if (!hasOnlyNotificationFields(value, [
+        "version",
+        "environmentId",
+        "items",
+        "preferences",
+    ]))
+        throw new Error("Unexpected notification storage fields.");
+    if (!isNotificationPreferences(value.preferences))
+        throw new Error("Invalid notification preferences.");
+    if (!Array.isArray(value.items))
+        throw new Error("Invalid notification history.");
+    const seen = new Set();
+    for (const item of value.items) {
+        if (!isWebNotification(item, environmentId))
+            throw new Error("Invalid stored notification.");
+        if (seen.has(item.id))
+            throw new Error("Duplicate stored notification.");
+        seen.add(item.id);
+    }
+    return value;
+}

package/dist/src/web-ui/notifications/store.d.ts

@@ -0,0 +1,26 @@
+import { type NotificationDelivery, type NotificationListQuery, type NotificationPage, type NotificationPreferences, type NotificationReadChange, type NotificationReadResult, type WebNotification } from "./contracts.js";
+export declare function notificationStorePath(input: {
+    runtimeDir: string;
+    sessionsDir: string;
+    environmentId: string;
+}): string;
+/** Web UI history only: no writes to Runtime sessions or model-visible context. */
+export declare class WebNotificationStore {
+    private readonly environmentId;
+    private readonly path;
+    constructor(path: string, environmentId: string);
+    private load;
+    private save;
+    private transaction;
+    initialize(): Promise<void>;
+    reconcilePendingDeliveries(): Promise<void>;
+    upsert(item: WebNotification): Promise<{
+        item: WebNotification;
+        created: boolean;
+    }>;
+    list(query?: NotificationListQuery): Promise<NotificationPage>;
+    updateDelivery(id: string, delivery: NotificationDelivery): Promise<boolean>;
+    markRead(change: NotificationReadChange, now?: number): Promise<NotificationReadResult>;
+    getPreferences(): Promise<NotificationPreferences>;
+    setPreferences(preferences: NotificationPreferences): Promise<NotificationPreferences>;
+}

package/dist/src/web-ui/notifications/store.js

@@ -0,0 +1,185 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { defaultNotificationPreferences, NotificationInputError, } from "./contracts.js";
+import { parseNotificationReadChange } from "./request-input.js";
+import { compareNotificationsNewestFirst, decodeNotificationCursor, encodeNotificationCursor, isNotificationBeforeCursor, notificationPageLimit, } from "./query.js";
+import { decodeNotificationState, isNotificationDelivery, isNotificationIdentifier, isNotificationPreferences, isNotificationTimestamp, isWebNotification, } from "./storage-schema.js";
+const pendingTransactions = new Map();
+export function notificationStorePath(input) {
+    const identity = JSON.stringify([
+        input.environmentId,
+        resolve(input.sessionsDir),
+    ]);
+    const filename = createHash("sha256").update(identity).digest("hex") + ".json";
+    return join(input.runtimeDir, "web-ui", "notifications", filename);
+}
+function isMissingNotificationFile(error) {
+    if (!(error instanceof Error))
+        return false;
+    if (!("code" in error))
+        return false;
+    return error.code === "ENOENT";
+}
+function countUnreadNotifications(state) {
+    return state.items.filter((item) => item.readAt === null).length;
+}
+function hasPendingNotificationDelivery(item) {
+    return item.delivery.status === "pending";
+}
+function needsNotificationReadChange(item, change) {
+    if ("ids" in change && !change.ids.includes(item.id))
+        return false;
+    return (item.readAt !== null) !== change.read;
+}
+/** Web UI history only: no writes to Runtime sessions or model-visible context. */
+export class WebNotificationStore {
+    environmentId;
+    path;
+    constructor(path, environmentId) {
+        this.environmentId = environmentId;
+        if (!isNotificationIdentifier(environmentId))
+            throw new NotificationInputError("Invalid notification environment.");
+        this.path = resolve(path);
+    }
+    async load() {
+        try {
+            return decodeNotificationState(await readFile(this.path, "utf8"), this.environmentId);
+        }
+        catch (error) {
+            if (isMissingNotificationFile(error))
+                return null;
+            throw error;
+        }
+    }
+    async save(state) {
+        await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
+        const temporary = `${this.path}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(temporary, JSON.stringify(state), {
+                encoding: "utf8",
+                mode: 0o600,
+                flag: "wx",
+            });
+            await rename(temporary, this.path);
+        }
+        catch (error) {
+            await rm(temporary, { force: true }).catch(() => undefined);
+            throw error;
+        }
+    }
+    async transaction(operation) {
+        const prior = pendingTransactions.get(this.path) ?? Promise.resolve();
+        const pending = prior
+            .catch(() => undefined)
+            .then(async () => {
+            const existing = await this.load();
+            const state = existing ?? {
+                version: 1,
+                environmentId: this.environmentId,
+                items: [],
+                preferences: defaultNotificationPreferences(),
+            };
+            const before = JSON.stringify(state);
+            const result = operation(state);
+            if (!existing || before !== JSON.stringify(state))
+                await this.save(state);
+            return structuredClone(result);
+        });
+        pendingTransactions.set(this.path, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            if (pendingTransactions.get(this.path) === pending)
+                pendingTransactions.delete(this.path);
+        }
+    }
+    initialize() {
+        return this.transaction(() => undefined);
+    }
+    reconcilePendingDeliveries() {
+        return this.transaction((state) => {
+            for (const item of state.items) {
+                if (!hasPendingNotificationDelivery(item))
+                    continue;
+                item.delivery = {
+                    status: "unknown",
+                    error: "ABot restarted before delivery was confirmed. This notification was not sent again.",
+                };
+            }
+        });
+    }
+    upsert(item) {
+        if (!isWebNotification(item, this.environmentId))
+            throw new NotificationInputError("Invalid notification.");
+        const inserted = structuredClone(item);
+        return this.transaction((state) => {
+            const existing = state.items.find((candidate) => candidate.id === inserted.id);
+            if (existing)
+                return { item: existing, created: false };
+            state.items.push(inserted);
+            return { item: inserted, created: true };
+        });
+    }
+    list(query = {}) {
+        const limit = notificationPageLimit(query);
+        const cursor = decodeNotificationCursor(query.before, this.environmentId);
+        return this.transaction((state) => {
+            const ordered = state.items
+                .filter((item) => isNotificationBeforeCursor(item, cursor))
+                .sort(compareNotificationsNewestFirst);
+            const items = ordered.slice(0, limit);
+            const hasOlderItems = ordered.length > limit;
+            return {
+                items,
+                unreadCount: countUnreadNotifications(state),
+                nextCursor: hasOlderItems
+                    ? encodeNotificationCursor(items[items.length - 1])
+                    : null,
+                preferences: state.preferences,
+            };
+        });
+    }
+    updateDelivery(id, delivery) {
+        if (!isNotificationIdentifier(id))
+            throw new NotificationInputError("Invalid notification identity.");
+        if (!isNotificationDelivery(delivery))
+            throw new NotificationInputError("Invalid notification delivery.");
+        const receipt = structuredClone(delivery);
+        return this.transaction((state) => {
+            const item = state.items.find((candidate) => candidate.id === id);
+            if (!item)
+                return false;
+            item.delivery = receipt;
+            return true;
+        });
+    }
+    markRead(change, now = Date.now()) {
+        const selection = parseNotificationReadChange(change);
+        if (!isNotificationTimestamp(now))
+            throw new NotificationInputError("Invalid notification read time.");
+        return this.transaction((state) => {
+            let updated = 0;
+            for (const item of state.items) {
+                if (!needsNotificationReadChange(item, selection))
+                    continue;
+                item.readAt = selection.read ? now : null;
+                updated += 1;
+            }
+            return { updated, unreadCount: countUnreadNotifications(state) };
+        });
+    }
+    getPreferences() {
+        return this.transaction((state) => state.preferences);
+    }
+    setPreferences(preferences) {
+        if (!isNotificationPreferences(preferences))
+            throw new NotificationInputError("Invalid notification preferences.");
+        const saved = structuredClone(preferences);
+        return this.transaction((state) => {
+            state.preferences = saved;
+            return saved;
+        });
+    }
+}

package/dist/src/web-ui/server.js

@@ -203,7 +203,7 @@ export function startWebUiServer(overrides = {}) {
     }
     const handleLinkPreview = createLinkPreviewRouteHandler();
     const systemHost = localRuntimeBackend
-        ? new WebSystemHostService(rootDir)
+        ? new WebSystemHostService(rootDir, () => localRuntimeBackend.notifyHostConnectionChanged())
         : null;
     const allowPublishedLoopback = allowsPublishedLoopbackAuthority(options.host);
     const server = createServer((req, res) => {

package/dist/src/web-ui/session-read-state/projection.js

@@ -15,6 +15,9 @@ function cursorIndex(messages, cursor) {
 function requestedAssistantIndex(messages, boundary) {
     const id = boundary.readThroughMessageId;
     const hasNumericBoundary = typeof id === "number" && Number.isSafeInteger(id) && id >= 0;
+    const hasStringBoundary = typeof id === "string" && id.length > 0;
+    if (hasStringBoundary)
+        return messages.findIndex((message) => message.role === "assistant" && message.id === id);
     if (hasNumericBoundary)
         return messages.findIndex((message) => message.role === "assistant" && String(message.id) === String(id));
     const requestId = boundary.readThroughRequestId;

package/dist/src/web-ui/system-host-service.d.ts

@@ -9,7 +9,7 @@ export declare class WebSystemHostService {
     private broker?;
     private starting?;
     private closing;
-    constructor(rootDir: string);
+    constructor(rootDir: string, connectionChanged?: () => void);
     private ensureStarted;
     /** Native upgrade is separate from browser realtime and requires its own credential. */
     handleUpgrade(request: IncomingMessage, socket: Duplex, head: Buffer, listenHost?: string): boolean;

package/dist/src/web-ui/system-host-service.js

@@ -1,11 +1,11 @@
 import { join } from "node:path";
 import { WebSocketServer } from "ws";
-import { HostConnection } from "../../plugins/system/source/companion/connection.js";
-import { HostPairingStore } from "../../plugins/system/source/companion/pairing-store.js";
-import { startHostBroker } from "../../plugins/system/source/companion/broker-server.js";
-import { hostStateDirectory } from "../../plugins/system/source/companion/private-store.js";
-import { HOST_SOCKET_PATH, HOST_WIRE_MAX_BYTES, } from "../../plugins/system/source/companion/protocol.js";
-import { isProcessOwnerAlive, requireCurrentProcessOwnerIdentity, } from "../../plugins/system/source/companion/process-owner-identity.js";
+import { HostConnection } from "../computer-access/companion/connection.js";
+import { HostPairingStore } from "../computer-access/companion/pairing-store.js";
+import { startHostBroker } from "../computer-access/companion/broker-server.js";
+import { hostStateDirectory } from "../computer-access/companion/private-store.js";
+import { HOST_SOCKET_PATH, HOST_WIRE_MAX_BYTES, } from "../computer-access/companion/protocol.js";
+import { isProcessOwnerAlive, requireCurrentProcessOwnerIdentity, } from "../computer-access/companion/process-owner-identity.js";
 import { ensurePrivateRuntimeDirectory } from "../runtime/local-host/private-directory.js";
 import { acquireFileLock } from "../runtime/adapters/long-term-memory/file-lock/acquisition.js";
 import { acceptConfigMutationRequest } from "./local-runtime/config-mutation-request.js";
@@ -14,6 +14,8 @@ import { hostBearerCredential } from "./system-host-setup/native-authorization.j
 import { hasTrustedSystemHostUpgrade, rejectSystemHostUpgrade } from "./system-host-upgrade-authority.js";
 import { readHostReadiness } from "./system-host-setup/readiness.js";
 import { HostSetupRoutes, isHostSetupRoute, sendHostSetupInputError } from "./system-host-setup/routes.js";
+import { reportHostStartupFailure } from "./system-host-startup-diagnostic.js";
+import { withLocalMacSetup } from "./system-host-setup/local-setup-availability.js";
 function isSystemHostRoute(pathname) {
     if (pathname === "/web-api/runtime/system-host")
         return true;
@@ -32,10 +34,10 @@ export class WebSystemHostService {
     broker;
     starting;
     closing = false;
-    constructor(rootDir) {
+    constructor(rootDir, connectionChanged) {
         this.rootDir = rootDir;
         this.store = new HostPairingStore(rootDir);
-        this.connection = new HostConnection(this.store);
+        this.connection = new HostConnection(this.store, connectionChanged);
         this.setup = new HostSetupRoutes({
             store: this.store,
             readiness: () => readHostReadiness(this.connection.status()),
@@ -55,6 +57,7 @@ export class WebSystemHostService {
             }));
         })().catch((error) => {
             this.starting = undefined;
+            reportHostStartupFailure(error);
             throw error;
         });
         return this.starting;
@@ -100,7 +103,7 @@ export class WebSystemHostService {
             if (request.method === "GET" &&
                 pathname === "/web-api/runtime/system-host") {
                 const status = this.connection.status();
-                const readiness = await readHostReadiness(status);
+                const readiness = withLocalMacSetup(request, await readHostReadiness(status));
                 sendJson(response, 200, { ok: true, ...status, readiness });
                 return true;
             }
@@ -117,16 +120,21 @@ export class WebSystemHostService {
             }
             if (request.method === "POST" && pathname.endsWith("/pairing")) {
                 await this.ensureStarted();
+                if (this.setup.rejectConcurrentMutation(response))
+                    return true;
                 sendJson(response, 200, { ok: true, ...this.store.begin() });
                 return true;
             }
             if (request.method === "DELETE" &&
                 pathname === "/web-api/runtime/system-host") {
                 await this.ensureStarted();
+                if (this.setup.rejectConcurrentMutation(response))
+                    return true;
                 this.store.revoke();
                 this.connection.disconnect();
                 const status = this.connection.status();
-                sendJson(response, 200, { ok: true, ...status, readiness: await readHostReadiness(status) });
+                sendJson(response, 200, { ok: true, ...status,
+                    readiness: withLocalMacSetup(request, await readHostReadiness(status)) });
                 return true;
             }
             sendJson(response, 405, { ok: false, error: "method_not_allowed" });
@@ -151,6 +159,7 @@ export class WebSystemHostService {
         if (this.closing)
             return;
         this.closing = true;
+        await this.setup.close();
         await this.starting?.catch(() => undefined);
         this.connection.close();
         await this.broker?.close();

package/dist/src/web-ui/system-host-setup/companion-linux.d.ts

@@ -0,0 +1,3 @@
+import { type CompanionInstallerInput } from "./installer-contract.js";
+/** Native desktop install; Node and desktop accessibility dependencies remain user-managed. */
+export declare function renderLinuxCompanionScript(input: CompanionInstallerInput): string;