@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/session-read-state/service.d.ts

@@ -1,3 +1,4 @@
+import { type SessionPageQuery } from "./pagination.js";
 import type { RuntimeConfig, SessionStore } from "../../runtime/ports.js";
 import type { SessionSnapshot } from "../../sessions/types.js";
 import { type ReadBoundary } from "./projection.js";
@@ -30,13 +31,6 @@ export declare class WebSessionReadStates {
         lastReadMessageId: string | number | null;
         latestMessageId: string | number | null;
         latestAssistantMessageId: string | number | null;
-    } | {
-        sessionId: string;
-        readStateStatus: "unavailable";
-        unreadCount: null;
-        hasUnread: null;
-        lastReadAt: null;
-        lastReadMessageId: null;
     } | {
         sessionId: string;
         readStateStatus: "available";
@@ -46,6 +40,13 @@ export declare class WebSessionReadStates {
         lastReadAt: number;
         latestMessageId: string | number | null;
         latestAssistantMessageId: string | number | null;
+    } | {
+        sessionId: string;
+        readStateStatus: "unavailable";
+        unreadCount: null;
+        hasUnread: null;
+        lastReadAt: null;
+        lastReadMessageId: null;
     }>;
     mark(environmentId: string, sessionId: string, boundary: ReadBoundary): Promise<{
         sessionId: string;
@@ -82,7 +83,49 @@ export declare class WebSessionReadStates {
         latestMessageId: string | number | null;
         latestAssistantMessageId: string | number | null;
     } | null>;
-    list(environmentId: string): Promise<{
+    list(environmentId: string, query?: SessionPageQuery): Promise<{
+        overview?: {
+            sessions: ({
+                sessionId: string;
+                readStateStatus: "available";
+                unreadCount: number;
+                hasUnread: boolean;
+                lastReadMessageId: string | null;
+                lastReadAt: number;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
+                id: string;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+            } | {
+                sessionId: string;
+                readStateStatus: "unavailable";
+                unreadCount: null;
+                hasUnread: null;
+                lastReadAt: null;
+                lastReadMessageId: null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
+                id: string;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+            })[];
+            unreadCount: number;
+            hasUnavailableReadState: boolean;
+        } | undefined;
+        total: number;
+        archivedCount: number;
+        nextCursor: string | null;
         sessions: {
             sessionId: string;
             readStateStatus: "available";
@@ -92,21 +135,117 @@ export declare class WebSessionReadStates {
             lastReadAt: number;
             latestMessageId: string | number | null;
             latestAssistantMessageId: string | number | null;
+            kind?: import("../../sessions/spark-session.js").SessionKind;
+            project?: import("../../sessions/project-binding.js").SessionProject;
+            id: string;
             title: string;
             createdAt: number;
             updatedAt: number;
             lastMessagePreview: string;
             lastMessageAt: number | null;
-            project?: Readonly<{
+        }[];
+    } | {
+        overview?: {
+            sessions: ({
+                sessionId: string;
+                readStateStatus: "available";
+                unreadCount: number;
+                hasUnread: boolean;
+                lastReadMessageId: string | null;
+                lastReadAt: number;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
                 id: string;
-                name: string;
-                directory: string;
-            }> | undefined;
-            kind?: "spark" | undefined;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+            } | {
+                sessionId: string;
+                readStateStatus: "unavailable";
+                unreadCount: null;
+                hasUnread: null;
+                lastReadAt: null;
+                lastReadMessageId: null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
+                id: string;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+            })[];
+            unreadCount: number;
+            hasUnavailableReadState: boolean;
+        } | undefined;
+        nextCursor: null;
+        sessions: {
+            sessionId: string;
+            readStateStatus: "available";
+            unreadCount: number;
+            hasUnread: boolean;
+            lastReadMessageId: string | null;
+            lastReadAt: number;
+            latestMessageId: string | number | null;
+            latestAssistantMessageId: string | number | null;
+            kind?: import("../../sessions/spark-session.js").SessionKind;
+            project?: import("../../sessions/project-binding.js").SessionProject;
             id: string;
+            title: string;
+            createdAt: number;
+            updatedAt: number;
+            lastMessagePreview: string;
+            lastMessageAt: number | null;
         }[];
-        nextCursor: null;
     } | {
+        overview?: {
+            sessions: ({
+                sessionId: string;
+                readStateStatus: "available";
+                unreadCount: number;
+                hasUnread: boolean;
+                lastReadMessageId: string | null;
+                lastReadAt: number;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
+                id: string;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+            } | {
+                sessionId: string;
+                readStateStatus: "unavailable";
+                unreadCount: null;
+                hasUnread: null;
+                lastReadAt: null;
+                lastReadMessageId: null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
+                id: string;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+            })[];
+            unreadCount: number;
+            hasUnavailableReadState: boolean;
+        } | undefined;
+        total: number;
+        archivedCount: number;
+        nextCursor: string | null;
         sessions: {
             sessionId: string;
             readStateStatus: "unavailable";
@@ -114,6 +253,9 @@ export declare class WebSessionReadStates {
             hasUnread: null;
             lastReadAt: null;
             lastReadMessageId: null;
+            kind?: import("../../sessions/spark-session.js").SessionKind;
+            project?: import("../../sessions/project-binding.js").SessionProject;
+            id: string;
             title: string;
             createdAt: number;
             updatedAt: number;
@@ -121,15 +263,66 @@ export declare class WebSessionReadStates {
             lastMessageAt: number | null;
             latestMessageId: string | number | null;
             latestAssistantMessageId: string | number | null;
-            project?: Readonly<{
+        }[];
+    } | {
+        overview?: {
+            sessions: ({
+                sessionId: string;
+                readStateStatus: "available";
+                unreadCount: number;
+                hasUnread: boolean;
+                lastReadMessageId: string | null;
+                lastReadAt: number;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
+                id: string;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+            } | {
+                sessionId: string;
+                readStateStatus: "unavailable";
+                unreadCount: null;
+                hasUnread: null;
+                lastReadAt: null;
+                lastReadMessageId: null;
+                kind?: import("../../sessions/spark-session.js").SessionKind;
+                project?: import("../../sessions/project-binding.js").SessionProject;
                 id: string;
-                name: string;
-                directory: string;
-            }> | undefined;
-            kind?: "spark" | undefined;
+                title: string;
+                createdAt: number;
+                updatedAt: number;
+                lastMessagePreview: string;
+                lastMessageAt: number | null;
+                latestMessageId: string | number | null;
+                latestAssistantMessageId: string | number | null;
+            })[];
+            unreadCount: number;
+            hasUnavailableReadState: boolean;
+        } | undefined;
+        nextCursor: null;
+        sessions: {
+            sessionId: string;
+            readStateStatus: "unavailable";
+            unreadCount: null;
+            hasUnread: null;
+            lastReadAt: null;
+            lastReadMessageId: null;
+            kind?: import("../../sessions/spark-session.js").SessionKind;
+            project?: import("../../sessions/project-binding.js").SessionProject;
             id: string;
+            title: string;
+            createdAt: number;
+            updatedAt: number;
+            lastMessagePreview: string;
+            lastMessageAt: number | null;
+            latestMessageId: string | number | null;
+            latestAssistantMessageId: string | number | null;
         }[];
-        nextCursor: null;
     }>;
 }
 export {};

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

@@ -1,9 +1,11 @@
+import { sessionListOverview } from "./overview.js";
+import { sessionMetadataPage } from "./pagination.js";
+import { webPageSize } from "../local-runtime/history-pagination.js";
 import { createHash } from "node:crypto";
 import { join, resolve } from "node:path";
-import { SessionService } from "../../sessions/session-service.js";
+import { listSessionMetadata } from "../../sessions/metadata/store.js";
 import { isSparkSession } from "../../sessions/spark-session.js";
 import { markVisibleAssistantMessages, projectVisibleSessionReadState, visibleReadMessageIds, visibleReadObservations } from "./visible-messages.js";
-import { clientVisibleMessages, toSessionListItem, toSnapshotMessage, } from "../../sessions/record/projection.js";
 import { WebReadStateStore } from "./store.js";
 import { captureReadStateAvailability, unavailableSessionReadState, } from "./availability.js";
 import { advanceReadCursor, projectSessionReadState, } from "./projection.js";
@@ -42,8 +44,8 @@ export class WebSessionReadStates {
     }
     async project(environmentId, snapshot) {
         const result = await captureReadStateAvailability(() => this.store(environmentId).transaction((state) => isSparkSession(snapshot)
-            ? projectVisibleSessionReadState(state, snapshot.sessionId, snapshot.messages)
-            : projectSessionReadState(state, snapshot.sessionId, snapshot.messages)));
+            ? projectVisibleSessionReadState(state, snapshot.sessionId, (snapshot.messageIndex ?? snapshot.messages))
+            : projectSessionReadState(state, snapshot.sessionId, (snapshot.messageIndex ?? snapshot.messages))));
         if (result.readStateStatus === "unavailable")
             return unavailableSessionReadState(snapshot.sessionId);
         return result.value;
@@ -54,14 +56,14 @@ export class WebSessionReadStates {
         const sessions = this.getEnvironment(environmentId).services.sessions;
         return store.transaction(async (state) => {
             const snapshot = await sessions.getSessionSnapshot(sessionId, {
-                includeRequests: false,
+                includeRequests: false, identitiesOnly: true,
             });
             if (!snapshot)
                 return null;
             if (isSparkSession(snapshot))
-                return projectVisibleSessionReadState(state, sessionId, snapshot.messages);
-            advanceReadCursor(state, sessionId, snapshot.messages, boundary, this.now());
-            return projectSessionReadState(state, sessionId, snapshot.messages);
+                return projectVisibleSessionReadState(state, sessionId, (snapshot.messageIndex ?? snapshot.messages));
+            advanceReadCursor(state, sessionId, (snapshot.messageIndex ?? snapshot.messages), boundary, this.now());
+            return projectSessionReadState(state, sessionId, (snapshot.messageIndex ?? snapshot.messages));
         });
     }
     async markVisible(environmentId, sessionId, input, generation, visibleMessages) {
@@ -69,38 +71,38 @@ export class WebSessionReadStates {
         const observations = visibleReadObservations(ids, visibleMessages);
         const sessions = this.getEnvironment(environmentId).services.sessions;
         return this.store(environmentId).transaction(async (state) => {
-            const snapshot = await sessions.getSessionSnapshot(sessionId, { includeRequests: false });
+            const snapshot = await sessions.getSessionSnapshot(sessionId, { includeRequests: false, identitiesOnly: true });
             if (!snapshot || !isSparkSession(snapshot))
                 return null;
-            markVisibleAssistantMessages(state, sessionId, snapshot.messages, observations, generation, this.now());
-            return projectVisibleSessionReadState(state, sessionId, snapshot.messages);
+            markVisibleAssistantMessages(state, sessionId, (snapshot.messageIndex ?? snapshot.messages), observations, generation, this.now());
+            return projectVisibleSessionReadState(state, sessionId, (snapshot.messageIndex ?? snapshot.messages));
         });
     }
-    async list(environmentId) {
+    async list(environmentId, query) {
         const { sessionsDir } = this.getEnvironment(environmentId).services.config.paths;
-        // One canonical disk enumeration avoids mutable offset pages and sending
-        // every request event across the managed Runtime's bounded RPC transport.
-        const records = await new SessionService({ sessionsDir }).getAllSessions();
-        const projectedSessions = records.filter((record) => !isSparkSession(record)).map((record) => ({
-            summary: toSessionListItem(record),
-            messages: clientVisibleMessages(record.messages).map((message) => toSnapshotMessage(record.id, message, record.requests ?? [])),
-        }));
+        const records = await listSessionMetadata(sessionsDir);
+        const projectedSessions = records.filter((record) => record.interactive)
+            .filter((record) => !isSparkSession(record.summary));
+        const page = query ? sessionMetadataPage(projectedSessions, query, webPageSize(this.getEnvironment(environmentId).services.config))
+            : { records: projectedSessions, nextCursor: null };
+        const { records: selected, ...pageInfo } = page;
         const result = await captureReadStateAvailability(() => this.store(environmentId).transaction((state) => {
-            const sessions = projectedSessions.map(({ summary, messages }) => {
+            const sessions = selected.map(({ summary, messages }) => {
                 return {
                     ...summary,
                     ...projectSessionReadState(state, summary.id, messages),
                 };
             });
-            return { sessions, nextCursor: null };
+            return { sessions, ...pageInfo, ...(query && !query.cursor ? { overview: sessionListOverview(projectedSessions, query.archivedSessionIds, state) } : {}) };
         }));
         if (result.readStateStatus === "unavailable")
             return {
-                sessions: projectedSessions.map(({ summary }) => ({
+                sessions: selected.map(({ summary }) => ({
                     ...summary,
                     ...unavailableSessionReadState(summary.id),
                 })),
-                nextCursor: null,
+                ...pageInfo,
+                ...(query && !query.cursor ? { overview: sessionListOverview(projectedSessions, query.archivedSessionIds) } : {}),
             };
         return result.value;
     }

package/dist/src/web-ui/session-read-state/visible-messages.d.ts

@@ -1,4 +1,4 @@
-import type { SessionSnapshotMessage } from "../../sessions/types.js";
+import type { SessionMessageIdentity } from "../../sessions/snapshot.js";
 import type { WebReadState } from "./store.js";
 export type VisibleMessageReceipt = {
     messageId: string;
@@ -14,8 +14,8 @@ export declare function isVisibleMessageReadState(value: unknown): value is Visi
 export declare function readVisibleMessageReceipts(value: unknown): WebReadState["visibleMessages"];
 export declare function visibleReadMessageIds(input: unknown): string[];
 export declare function visibleReadObservations(ids: readonly string[], input: unknown): VisibleMessageReceipt[];
-export declare function markVisibleAssistantMessages(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[], observations: readonly VisibleMessageReceipt[], generation: unknown, now: number): void;
-export declare function projectVisibleSessionReadState(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[]): {
+export declare function markVisibleAssistantMessages(state: WebReadState, sessionId: string, messages: SessionMessageIdentity[], observations: readonly VisibleMessageReceipt[], generation: unknown, now: number): void;
+export declare function projectVisibleSessionReadState(state: WebReadState, sessionId: string, messages: SessionMessageIdentity[]): {
     sessionId: string;
     readStateStatus: "available";
     unreadMessageIds: (string | number)[];

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

@@ -4,6 +4,9 @@ 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 { readCollectionConsent } from "../computer-access/collection-consent.js";
+import { readRuntimeCollectionSource } from "../computer-access/observation-source.js";
+import { COLLECTION_CONSENT_PATH, handleCollectionConsent } from "./system-host-setup/collection-consent-route.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";
@@ -21,6 +24,8 @@ import { NativeRuntimePermissionRoute } from "./system-host-setup/native-permiss
 function isSystemHostRoute(pathname) {
     if (pathname === "/web-api/runtime/system-host")
         return true;
+    if (pathname === COLLECTION_CONSENT_PATH)
+        return true;
     return pathname === "/web-api/runtime/system-host/pairing";
 }
 export class WebSystemHostService {
@@ -102,6 +107,10 @@ export class WebSystemHostService {
             return false;
         response.setHeader("cache-control", "no-store");
         try {
+            if (pathname === COLLECTION_CONSENT_PATH) {
+                await handleCollectionConsent(request, response, this.rootDir);
+                return true;
+            }
             if (pathname === HOST_PERMISSION_PATH) {
                 await this.permissions.handle(request, response);
                 return true;
@@ -115,7 +124,8 @@ export class WebSystemHostService {
                 const status = this.connection.status();
                 const readiness = withLocalMacSetup(request, await readHostReadiness(status));
                 const nativePermissions = await this.nativePermissions.status(request);
-                sendJson(response, 200, { ok: true, ...status, readiness, nativePermissions });
+                sendJson(response, 200, { ok: true, ...status, readiness, nativePermissions,
+                    collectionSource: readRuntimeCollectionSource(), collectionConsent: readCollectionConsent(this.rootDir) });
                 return true;
             }
             if (!acceptConfigMutationRequest(request, response))
@@ -145,7 +155,8 @@ export class WebSystemHostService {
                 this.connection.disconnect();
                 const status = this.connection.status();
                 sendJson(response, 200, { ok: true, ...status,
-                    readiness: withLocalMacSetup(request, await readHostReadiness(status)) });
+                    readiness: withLocalMacSetup(request, await readHostReadiness(status)),
+                    collectionSource: readRuntimeCollectionSource(), collectionConsent: readCollectionConsent(this.rootDir) });
                 return true;
             }
             sendJson(response, 405, { ok: false, error: "method_not_allowed" });

package/dist/src/web-ui/system-host-setup/collection-consent-route.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare const COLLECTION_CONSENT_PATH = "/web-api/runtime/system-host/collection-consent";
+export declare function handleCollectionConsent(request: IncomingMessage, response: ServerResponse, rootDir: string): Promise<void>;

package/dist/src/web-ui/system-host-setup/collection-consent-route.js

@@ -0,0 +1,30 @@
+import { acceptCollectionConsent } from "../../computer-access/collection-consent.js";
+import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
+import { readBody, sendJson } from "../local-runtime/http.js";
+export const COLLECTION_CONSENT_PATH = "/web-api/runtime/system-host/collection-consent";
+function hasExplicitCollectionAcknowledgment(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    if (Object.keys(value).length !== 1)
+        return false;
+    return value.acknowledged === true;
+}
+export async function handleCollectionConsent(request, response, rootDir) {
+    if (request.method !== "POST") {
+        sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+        return;
+    }
+    if (!acceptConfigMutationRequest(request, response))
+        return;
+    let body;
+    try {
+        body = JSON.parse((await readBody(request, { maxBytes: 1_024 })).toString());
+    }
+    catch { /* malformed or oversized input is rejected below */ }
+    if (!hasExplicitCollectionAcknowledgment(body)) {
+        sendJson(response, 400, { ok: false, error: "invalid_collection_acknowledgment" });
+        return;
+    }
+    const collectionConsent = await acceptCollectionConsent(rootDir);
+    sendJson(response, 200, { ok: true, collectionConsent });
+}

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

@@ -15,7 +15,7 @@ export function renderLinuxCompanionScript(input) {
 set -euo pipefail
 umask 077
 if [ "$(uname -s)" != 'Linux' ]; then echo 'Run this setup on the Linux desktop host.' >&2; exit 1; fi
-if [ -n "\${WSL_DISTRO_NAME:-}" ]; then echo 'For a Windows desktop, use the Windows companion installer outside WSL.' >&2; exit 1; fi
+if [ -n "\${WSL_DISTRO_NAME:-}" ]; then echo 'For a Windows desktop, install ABot AI Companion from Microsoft Store on Windows.' >&2; exit 1; fi
 if [ -z "\${DISPLAY:-}" ] && [ -z "\${WAYLAND_DISPLAY:-}" ]; then echo 'Run this setup from your graphical desktop session.' >&2; exit 1; fi
 NODE=$(command -v node || true)
 if [ -z "$NODE" ] || [ ! -x "$NODE" ]; then echo 'Node.js 20.19+ or 22.12+ must already be installed on this computer.' >&2; exit 1; fi

package/dist/src/web-ui/system-host-setup/installer-contract.d.ts

@@ -1,7 +1,7 @@
 export declare class InstallerInputError extends Error {
 }
 export type CompanionInstallerInput = Readonly<{
-    platform: "windows" | "macos" | "linux";
+    platform: "macos" | "linux";
     url: string;
     code: string;
     bundleSha256: string;

package/dist/src/web-ui/system-host-setup/installer-contract.js

@@ -10,8 +10,8 @@ function hasLocalInstallerHost(hostname) {
     return isNativeLoopbackAddress(hostname);
 }
 export function validateCompanionInstaller(input) {
-    if (!["windows", "macos", "linux"].includes(input.platform))
-        throw new InstallerInputError("Choose Windows, macOS or Linux.");
+    if (!["macos", "linux"].includes(input.platform))
+        throw new InstallerInputError("Choose macOS or Linux. Windows Companion is installed and updated through Microsoft Store.");
     if (/[\x00-\x1f\x7f]/u.test(input.url))
         throw new InstallerInputError("The Runtime origin must not contain control characters.");
     let url;

package/dist/src/web-ui/system-host-setup/installers.js

@@ -1,6 +1,5 @@
 import JSZip from "jszip";
 import { validateCompanionInstaller, validateWslDistribution, } from "./installer-contract.js";
-import { renderWindowsCompanionScript } from "./companion-windows.js";
 import { renderMacCompanionScript } from "./companion-macos.js";
 import { renderLinuxCompanionScript } from "./companion-linux.js";
 import { renderWindowsWslInteropScript } from "./wsl-interop-windows.js";
@@ -13,12 +12,6 @@ export async function renderCompanionInstaller(raw) {
             mimeType: "application/x-sh",
             contentBase64: Buffer.from(renderLinuxCompanionScript(input), "utf8").toString("base64"),
         };
-    if (input.platform === "windows")
-        return {
-            filename: "ABot-Connect-Computer.cmd",
-            mimeType: "application/octet-stream",
-            contentBase64: Buffer.from(renderWindowsCompanionScript(input), "utf8").toString("base64"),
-        };
     const zip = new JSZip();
     zip.file("ABot-Connect-Computer.command", renderMacCompanionScript(input), {
         unixPermissions: 0o100755,

package/dist/src/web-ui/system-host-setup/local-connection.d.ts

@@ -2,20 +2,23 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import type { HostPairingStore } from "../../computer-access/companion/pairing-store.js";
 import { installLocalMacCompanion } from "../../computer-access/companion/local-installation.js";
 import type { HostReadiness } from "./readiness.js";
+import { HostSetupMutation } from "./setup-mutation.js";
 export declare const LOCAL_HOST_SETUP_PATH = "/web-api/runtime/system-host/connect-local";
 export declare class LocalHostConnection {
     private readonly dependencies;
-    private pending?;
+    private readonly mutation;
     constructor(dependencies: {
         store: HostPairingStore;
         readiness(): Promise<HostReadiness>;
         prepareCompanion(): Promise<void>;
         bundle(): Promise<Buffer>;
         install?: typeof installLocalMacCompanion;
+        mutation?: HostSetupMutation;
     });
     get busy(): boolean;
     rejectConcurrentMutation(response: ServerResponse): boolean;
     handle(request: IncomingMessage, response: ServerResponse): Promise<void>;
+    private completeConnection;
     private connect;
     close(): Promise<void>;
 }

package/dist/src/web-ui/system-host-setup/local-connection.js

@@ -2,23 +2,21 @@ import { installLocalMacCompanion, LocalCompanionSetupError } from "../../comput
 import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
 import { readBody, sendJson } from "../local-runtime/http.js";
 import { canSetUpLocalMac, localMacSetupRuntimeUrl } from "./local-setup-availability.js";
+import { HostSetupMutation } from "./setup-mutation.js";
 export const LOCAL_HOST_SETUP_PATH = "/web-api/runtime/system-host/connect-local";
 function isEmptyLocalSetupRequest(body) {
     return JSON.stringify(body) === "{}";
 }
 export class LocalHostConnection {
     dependencies;
-    pending;
+    mutation;
     constructor(dependencies) {
         this.dependencies = dependencies;
+        this.mutation = dependencies.mutation ?? new HostSetupMutation();
     }
-    get busy() { return this.pending !== undefined; }
+    get busy() { return this.mutation.busy; }
     rejectConcurrentMutation(response) {
-        if (!this.busy)
-            return false;
-        sendJson(response, 409, { ok: false, error: "host_setup_in_progress",
-            message: "Computer access is being connected. Wait for setup to finish." });
-        return true;
+        return this.mutation.rejectConcurrentMutation(response);
     }
     async handle(request, response) {
         if (request.method !== "POST") {
@@ -37,18 +35,17 @@ export class LocalHostConnection {
             sendJson(response, 400, { ok: false, error: "unexpected_host_configuration_fields" });
             return;
         }
+        await this.mutation.run(response, () => this.completeConnection(request, response));
+    }
+    async completeConnection(request, response) {
         const readiness = await this.dependencies.readiness();
         if (!canSetUpLocalMac(request, readiness)) {
             sendJson(response, 409, { ok: false, error: "host_local_setup_unavailable",
                 message: "Direct setup requires ABot running natively on this Mac through its local address. Use a pairing code on the Mac for Docker or a forwarded Runtime." });
             return;
         }
-        if (this.rejectConcurrentMutation(response))
-            return;
-        const pending = this.connect(localMacSetupRuntimeUrl(request));
-        this.pending = pending;
         try {
-            await pending;
+            await this.connect(localMacSetupRuntimeUrl(request));
             sendJson(response, 200, { ok: true });
         }
         catch (error) {
@@ -56,10 +53,6 @@ export class LocalHostConnection {
                 throw error;
             sendJson(response, 503, { ok: false, error: error.code, message: error.message });
         }
-        finally {
-            if (this.pending === pending)
-                this.pending = undefined;
-        }
     }
     async connect(url) {
         const bundle = await this.dependencies.bundle();
@@ -73,5 +66,5 @@ export class LocalHostConnection {
             ...(host ? { upgradeHostId: host.hostId } : {}),
         });
     }
-    async close() { await this.pending?.catch(() => undefined); }
+    async close() { await this.mutation.close(); }
 }

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

@@ -12,12 +12,14 @@ export type HostSetupRouteDependencies = {
 /** GUI writes use same-origin JSON; native code downloads use the expiring setup grant. */
 export declare class HostSetupRoutes {
     private readonly dependencies;
+    private readonly mutation;
     private readonly local;
     constructor(dependencies: HostSetupRouteDependencies);
     rejectConcurrentMutation(response: ServerResponse): boolean;
     close(): Promise<void>;
     private bundle;
     handle(request: IncomingMessage, response: ServerResponse, pathname: string): Promise<void>;
+    private issueSetupInstaller;
     private downloadBundle;
     private hasCurrentSetupGrant;
 }