@abot-ai/runtime 1.6.0 → 1.7.0

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

@@ -0,0 +1,42 @@
+import type { SessionMetadata } from "../../sessions/metadata/projection.js";
+import type { WebReadState } from "./store.js";
+/** The home dashboard's count and three recent chats must not become page-local. */
+export declare function sessionListOverview(records: SessionMetadata[], archivedIds: unknown, state?: WebReadState): {
+    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;
+};

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

@@ -0,0 +1,16 @@
+import { projectSessionReadState } from "./projection.js";
+import { unavailableSessionReadState } from "./availability.js";
+/** The home dashboard's count and three recent chats must not become page-local. */
+export function sessionListOverview(records, archivedIds, state) {
+    const archived = new Set(Array.isArray(archivedIds) ? archivedIds : []);
+    const visible = records.filter(({ summary }) => !archived.has(summary.id));
+    let unreadCount = 0;
+    const recent = visible.slice(0, 3).map(({ summary, messages }) => ({
+        ...summary,
+        ...(state ? projectSessionReadState(state, summary.id, messages) : unavailableSessionReadState(summary.id)),
+    }));
+    if (state)
+        for (const { summary, messages } of visible)
+            unreadCount += projectSessionReadState(state, summary.id, messages).unreadCount;
+    return { sessions: recent, unreadCount, hasUnavailableReadState: !state };
+}

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

@@ -0,0 +1,15 @@
+import type { SessionMetadata } from "../../sessions/metadata/projection.js";
+export type SessionPageQuery = {
+    cursor?: string | null;
+    query?: string;
+    archived?: boolean;
+    pinnedSessionIds?: string[];
+    orderedSessionIds?: string[];
+    archivedSessionIds?: string[];
+};
+export declare function sessionMetadataPage(records: SessionMetadata[], input: SessionPageQuery, limit: number): {
+    records: SessionMetadata[];
+    total: number;
+    archivedCount: number;
+    nextCursor: string | null;
+};

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

@@ -0,0 +1,42 @@
+function compareKeys(left, right) {
+    return left[0] - right[0] || left[1] - right[1] || left[2] - right[2] || left[3].localeCompare(right[3]);
+}
+function readCursor(cursor) {
+    try {
+        const key = JSON.parse(Buffer.from(cursor, "base64url").toString());
+        if (!Array.isArray(key) || key.length !== 4)
+            throw new Error();
+        if (!key.slice(0, 3).every(Number.isFinite) || typeof key[3] !== "string")
+            throw new Error();
+        return key;
+    }
+    catch {
+        throw new Error("session_cursor_invalid");
+    }
+}
+function readIds(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((id) => typeof id === "string");
+}
+export function sessionMetadataPage(records, input, limit) {
+    const archived = new Set(readIds(input.archivedSessionIds));
+    const pinned = new Map(readIds(input.pinnedSessionIds).map((id, index) => [id, index]));
+    const ordered = new Map(readIds(input.orderedSessionIds).map((id, index) => [id, index]));
+    const query = typeof input.query === "string" ? input.query.trim().toLowerCase() : "";
+    const archivedCount = records.filter(({ summary }) => archived.has(summary.id)).length;
+    const entries = records.filter(({ summary }) => archived.has(summary.id) === (input.archived === true))
+        .filter(({ summary }) => [summary.id, summary.title, summary.lastMessagePreview].some((text) => text.toLowerCase().includes(query)))
+        .map((record) => {
+        const { id, updatedAt } = record.summary;
+        const key = [pinned.has(id) ? 0 : 1, pinned.get(id) ?? ordered.get(id) ?? -1, -updatedAt, id];
+        return { record, key };
+    }).sort((left, right) => compareKeys(left.key, right.key));
+    const anchor = input.cursor ? readCursor(input.cursor) : null;
+    const remaining = anchor ? entries.filter(({ key }) => compareKeys(key, anchor) > 0) : entries;
+    const page = remaining.slice(0, limit);
+    return {
+        records: page.map(({ record }) => record), total: entries.length, archivedCount,
+        nextCursor: remaining.length > limit ? Buffer.from(JSON.stringify(page.at(-1).key)).toString("base64url") : null,
+    };
+}

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

@@ -1,11 +1,12 @@
-import type { SessionSnapshotMessage } from "../../sessions/types.js";
+import type { SessionMessageIdentity } from "../../sessions/snapshot.js";
+import type { SessionMessageMetadata } from "../../sessions/metadata/projection.js";
 import type { WebReadState } from "./store.js";
 export type ReadBoundary = {
     readThroughMessageId?: unknown;
     readThroughRequestId?: unknown;
 };
-export declare function advanceReadCursor(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[], boundary: ReadBoundary, now: number): void;
-export declare function projectSessionReadState(state: WebReadState, sessionId: string, messages: SessionSnapshotMessage[]): {
+export declare function advanceReadCursor(state: WebReadState, sessionId: string, messages: SessionMessageIdentity[], boundary: ReadBoundary, now: number): void;
+export declare function projectSessionReadState(state: WebReadState, sessionId: string, messages: SessionMessageMetadata[]): {
     sessionId: string;
     readStateStatus: "available";
     unreadCount: number;

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-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>;
 }