@abot-ai/runtime 1.5.0 → 1.7.0

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

@@ -0,0 +1,102 @@
+import { isHostIdentifier, isHostRecord } from "../../computer-access/companion/protocol.js";
+import { isMacPermissionAction, MACOS_PERMISSION_CAPABILITY, MACOS_PERMISSION_OPERATION, readMacPermissionResult, } from "../../computer-access/companion/permission-protocol.js";
+import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
+import { readBody, sendJson } from "../local-runtime/http.js";
+import { isNativeRuntimePermissionRequest } from "./native-permission-route.js";
+export const HOST_PERMISSION_PATH = "/web-api/runtime/system-host/permissions";
+function readPermissionInput(value) {
+    if (!isHostRecord(value))
+        return undefined;
+    const { hostId, connectionId, ...action } = value;
+    if (!isHostIdentifier(hostId))
+        return undefined;
+    if (!isHostIdentifier(connectionId))
+        return undefined;
+    if (!isMacPermissionAction(action))
+        return undefined;
+    return { hostId, connectionId, ...action };
+}
+/** User-only setup endpoint; permission actions are never exposed as model tools. */
+export class HostPermissionRoute {
+    connection;
+    native;
+    busy = false;
+    constructor(connection, native) {
+        this.connection = connection;
+        this.native = native;
+    }
+    hasCurrentMacBinding(input) {
+        const status = this.connection.status();
+        if (!status.connected)
+            return false;
+        if (status.identity?.os !== "macos")
+            return false;
+        if (status.hostId !== input.hostId)
+            return false;
+        return status.connectionId === input.connectionId;
+    }
+    async handle(request, response) {
+        if (request.method !== "POST") {
+            sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+            return;
+        }
+        if (!acceptConfigMutationRequest(request, response))
+            return;
+        let input;
+        let body;
+        try {
+            const raw = await readBody(request, { maxBytes: 1024 });
+            body = JSON.parse(raw.toString());
+            input = readPermissionInput(body);
+        }
+        catch { /* malformed or oversized input is rejected before dispatch */ }
+        if (isNativeRuntimePermissionRequest(body) && this.native) {
+            await this.native.handle(request, response, body);
+            return;
+        }
+        if (!input) {
+            sendJson(response, 400, { ok: false, error: "macos_permissions_input_invalid" });
+            return;
+        }
+        if (!this.hasCurrentMacBinding(input)) {
+            sendJson(response, 409, { ok: false, error: "macos_permissions_host_changed", message: "Refresh Computer access and check the current Mac connection." });
+            return;
+        }
+        if (!this.connection.status().capabilities?.includes(MACOS_PERMISSION_CAPABILITY)) {
+            sendJson(response, 409, { ok: false, error: "macos_permissions_update_required", message: "Update this Mac connection before preparing its permissions." });
+            return;
+        }
+        if (this.busy) {
+            sendJson(response, 409, { ok: false, error: "macos_permissions_busy", message: "A permission check or request is already in progress." });
+            return;
+        }
+        this.busy = true;
+        const stop = new AbortController();
+        const timeout = setTimeout(() => stop.abort(), 50_000);
+        const disconnected = () => { if (!response.writableEnded)
+            stop.abort(); };
+        response.once("close", disconnected);
+        try {
+            const { hostId, connectionId, ...action } = input;
+            const result = await this.connection.execute({
+                hostId, connectionId, operation: MACOS_PERMISSION_OPERATION,
+                params: { target: "macos", ...action }, abortSignal: stop.signal,
+            });
+            if (!this.hasCurrentMacBinding(input)) {
+                sendJson(response, 409, { ok: false, error: "macos_permissions_host_changed", message: "The Mac connection changed. Check its permissions again." });
+                return;
+            }
+            const permissionResult = result.ok ? readMacPermissionResult(result.data) : undefined;
+            if (!permissionResult) {
+                sendJson(response, 503, { ok: false, error: "macos_permissions_check_failed", message: "Permission preparation did not complete. Check the Mac connection and Swift developer tools, then check again." });
+                return;
+            }
+            sendJson(response, 200, { ok: true, hostId, connectionId, scope: "companion", ...permissionResult });
+        }
+        finally {
+            clearTimeout(timeout);
+            response.removeListener("close", disconnected);
+            this.busy = false;
+        }
+    }
+}

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

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

@@ -5,12 +5,15 @@ import { readBody, sendJson } from "../local-runtime/http.js";
 import { hostBearerCredential } from "./native-authorization.js";
 import { renderCompanionInstaller, } from "./installers.js";
 import { InstallerInputError } from "./installer-contract.js";
+import { WINDOWS_COMPANION_STORE_URL } from "../../computer-access/companion/windows-store/identity.js";
 import { readInstallerCompanionBundle } from "./companion-bundle.js";
 import { LocalHostConnection, LOCAL_HOST_SETUP_PATH } from "./local-connection.js";
+import { handleWindowsStoreConnection, WINDOWS_STORE_CONNECTION_PATH } from "./windows-store-route.js";
+import { HostSetupMutation } from "./setup-mutation.js";
 const setupPath = "/web-api/runtime/system-host/setup";
 const bundlePath = "/web-api/runtime/system-host/bundle";
 export function isHostSetupRoute(pathname) {
-    return [setupPath, bundlePath, LOCAL_HOST_SETUP_PATH].includes(pathname);
+    return [setupPath, bundlePath, LOCAL_HOST_SETUP_PATH, WINDOWS_STORE_CONNECTION_PATH].includes(pathname);
 }
 export function sendHostSetupInputError(response, error) {
     if (!(error instanceof InstallerInputError))
@@ -37,6 +40,9 @@ function isSetupPlatformRequest(value) {
         return true;
     return platform === "windows" || platform === "macos";
 }
+function canDownloadCompanionInstaller(platform) {
+    return platform === "macos" || platform === "linux";
+}
 function requestRuntimeOrigin(request) {
     const encrypted = "encrypted" in request.socket && request.socket.encrypted;
     return new URL(`${encrypted ? "https" : "http"}://${request.headers.host}`)
@@ -45,21 +51,29 @@ function requestRuntimeOrigin(request) {
 /** GUI writes use same-origin JSON; native code downloads use the expiring setup grant. */
 export class HostSetupRoutes {
     dependencies;
+    mutation = new HostSetupMutation();
     local;
     constructor(dependencies) {
         this.dependencies = dependencies;
-        this.local = new LocalHostConnection({ ...dependencies, bundle: () => this.bundle() });
+        this.local = new LocalHostConnection({ ...dependencies, mutation: this.mutation, bundle: () => this.bundle() });
     }
     rejectConcurrentMutation(response) {
-        return this.local.rejectConcurrentMutation(response);
+        return this.mutation.rejectConcurrentMutation(response);
     }
-    async close() { await this.local.close(); }
+    async close() { await this.mutation.close(); }
     async bundle() {
         if (this.dependencies.bundleFile)
             return readFile(this.dependencies.bundleFile);
         return readInstallerCompanionBundle();
     }
     async handle(request, response, pathname) {
+        if (pathname === WINDOWS_STORE_CONNECTION_PATH) {
+            await handleWindowsStoreConnection(request, response, {
+                ...this.dependencies,
+                mutation: this.mutation,
+            });
+            return;
+        }
         if (pathname === LOCAL_HOST_SETUP_PATH) {
             await this.local.handle(request, response);
             return;
@@ -89,10 +103,21 @@ export class HostSetupRoutes {
             });
             return;
         }
-        if (this.rejectConcurrentMutation(response))
+        const platform = input.platform;
+        if (!canDownloadCompanionInstaller(platform)) {
+            sendJson(response, 410, {
+                ok: false,
+                error: "windows_store_required",
+                message: "Install or update ABot AI Companion through Microsoft Store.",
+                storeUrl: WINDOWS_COMPANION_STORE_URL,
+            });
             return;
+        }
+        await this.mutation.run(response, () => this.issueSetupInstaller(request, response, platform));
+    }
+    async issueSetupInstaller(request, response, platform) {
         const readiness = await this.dependencies.readiness();
-        if (!readiness.platforms.includes(input.platform)) {
+        if (!readiness.platforms.includes(platform)) {
             sendJson(response, 409, {
                 ok: false,
                 error: "host_setup_not_required",
@@ -103,14 +128,12 @@ export class HostSetupRoutes {
         // Read and hash the exact running build before creating a setup grant.
         const bundle = await this.bundle();
         await this.dependencies.prepareCompanion();
-        if (this.rejectConcurrentMutation(response))
-            return;
         const upgrading = Boolean(this.dependencies.store.host());
         const pairing = upgrading
             ? this.dependencies.store.beginBundleUpgrade()
             : this.dependencies.store.begin(15 * 60_000);
         const installer = await renderCompanionInstaller({
-            platform: input.platform,
+            platform,
             url: requestRuntimeOrigin(request),
             code: pairing.code,
             expiresAt: pairing.expiresAt,

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

@@ -0,0 +1,9 @@
+import type { ServerResponse } from "node:http";
+/** One installation owns one in-flight computer setup across connection routes. */
+export declare class HostSetupMutation {
+    private pending?;
+    get busy(): boolean;
+    rejectConcurrentMutation(response: ServerResponse): boolean;
+    run(response: ServerResponse, operation: () => Promise<void>): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+import { sendJson } from "../local-runtime/http.js";
+/** One installation owns one in-flight computer setup across connection routes. */
+export class HostSetupMutation {
+    pending;
+    get busy() { return this.pending !== undefined; }
+    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;
+    }
+    async run(response, operation) {
+        if (this.rejectConcurrentMutation(response))
+            return;
+        const pending = Promise.resolve().then(operation);
+        this.pending = pending;
+        try {
+            await pending;
+        }
+        finally {
+            if (this.pending === pending)
+                this.pending = undefined;
+        }
+    }
+    async close() { await this.pending?.catch(() => undefined); }
+}

package/dist/src/web-ui/system-host-setup/windows-store-route.d.ts

@@ -0,0 +1,13 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { HostPairingStore } from "../../computer-access/companion/pairing-store.js";
+import type { HostReadiness } from "./readiness.js";
+import type { HostSetupMutation } from "./setup-mutation.js";
+export declare const WINDOWS_STORE_CONNECTION_PATH = "/web-api/runtime/system-host/store-connect";
+type StoreConnectionDependencies = Readonly<{
+    store: HostPairingStore;
+    readiness(): Promise<HostReadiness>;
+    prepareCompanion(): Promise<void>;
+    mutation: HostSetupMutation;
+}>;
+export declare function handleWindowsStoreConnection(request: IncomingMessage, response: ServerResponse, dependencies: StoreConnectionDependencies): Promise<void>;
+export {};

package/dist/src/web-ui/system-host-setup/windows-store-route.js

@@ -0,0 +1,68 @@
+import { COMPANION_RELEASE_VERSION } from "../../computer-access/companion/release-version.js";
+import { createStoreConnectionLink, normalizeStoreConnectionOrigin } from "../../computer-access/companion/windows-store/connection-link.js";
+import { WINDOWS_COMPANION_STORE_URL } from "../../computer-access/companion/windows-store/identity.js";
+import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
+import { readBody, sendJson } from "../local-runtime/http.js";
+export const WINDOWS_STORE_CONNECTION_PATH = "/web-api/runtime/system-host/store-connect";
+function canStartWindowsStoreConnection(readiness) {
+    if (!readiness.platforms.includes("windows"))
+        return false;
+    if (readiness.restartRequired)
+        return false;
+    if (readiness.route === "wsl_interop")
+        return false;
+    return readiness.route !== "native";
+}
+function hasEmptyConnectionBody(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    return Object.keys(value).length === 0;
+}
+export async function handleWindowsStoreConnection(request, response, dependencies) {
+    response.setHeader("Cache-Control", "no-store");
+    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 { /* rejected below */ }
+    if (!hasEmptyConnectionBody(body)) {
+        sendJson(response, 400, { ok: false, error: "invalid_store_connection_request" });
+        return;
+    }
+    await dependencies.mutation.run(response, () => issueWindowsStoreConnection(request, response, dependencies));
+}
+async function issueWindowsStoreConnection(request, response, dependencies) {
+    if (!canStartWindowsStoreConnection(await dependencies.readiness())) {
+        sendJson(response, 409, { ok: false, error: "host_setup_not_required", message: "Refresh the computer connection status." });
+        return;
+    }
+    const encrypted = "encrypted" in request.socket && request.socket.encrypted;
+    let origin;
+    try {
+        origin = normalizeStoreConnectionOrigin(`${encrypted ? "https" : "http"}://${request.headers.host}`);
+    }
+    catch {
+        sendJson(response, 400, { ok: false, error: "host_store_connection_rejected", message: "Store connection requires a local HTTP Runtime origin on this computer." });
+        return;
+    }
+    await dependencies.prepareCompanion();
+    const previous = dependencies.store.host();
+    const pairing = previous ? dependencies.store.beginBundleUpgrade() : dependencies.store.begin(15 * 60_000);
+    try {
+        const launchUrl = createStoreConnectionLink({
+            version: 1, url: origin, code: pairing.code, expiresAt: pairing.expiresAt,
+            companionRelease: COMPANION_RELEASE_VERSION,
+            ...(previous ? { upgradeHostId: previous.hostId } : {}),
+        });
+        sendJson(response, 200, { ok: true, launchUrl, expiresAt: pairing.expiresAt, storeUrl: WINDOWS_COMPANION_STORE_URL });
+    }
+    catch {
+        sendJson(response, 400, { ok: false, error: "host_store_connection_rejected", message: "Store connection requires a local HTTP Runtime origin on this computer." });
+    }
+}

package/docs/configuration.md

@@ -17,6 +17,21 @@ local paths, and profile choices there. The provider, concrete model id, and
 default profile are required configuration; the runtime does not supply a
 built-in model choice.
 
+## Web UI history pages
+
+`webUi.pageSize` controls the number of sessions or messages loaded per page in
+ordinary conversations and SPARK. It defaults to `20` and accepts a positive integer:
+
+```json
+{ "webUi": { "pageSize": 20 } }
+```
+
+The Web UI loads more sessions while scrolling down and older messages while
+scrolling up. Message activity travels with the corresponding message page.
+Read state and active requests remain independent of the displayed page.
+Pagination does not truncate model history or change the session file format;
+opening a conversation still reads its canonical JSON file before projecting a page.
+
 ## Secrets
 
 Do not put secret values in JSON config. Store them in `.env`, service
@@ -427,6 +442,37 @@ secrets declarations, and skill bindings remain in each plugin package.
 Runtime orchestration does not hardcode concrete tool names or use the catalog
 to classify the user request.
 
+
+A model profile can further restrict that catalog with `plugins.deny`, including
+inside its linked `models/<profile>.config.json` file:
+
+```json
+{
+  "plugins": {
+    "deny": ["filesystem.read_file", "memory"]
+  }
+}
+```
+
+These selectors use the same matching rules as the global deny list. They can
+only remove globally available capabilities. Omission or an empty list adds no
+model restriction. The effective primary profile selected for the request owns
+the restriction for the entire request, including delegated roles, per-step
+model overrides and approval resumes. Both Supervisor/Worker and Execution
+Agent use the same filtered catalog and execution guard. This metadata stays in
+the Runtime and is not sent to the model provider. Plugin loading and
+`prepareRequest` hooks remain part of the existing shared plugin lifecycle.
+
+In the Web UI **Models** workspace, expand **Plugin access** to allow or block
+plugins for the selected model. Expand a plugin to control its individual tools.
+The switches edit exact plugin IDs and qualified `plugin.tool` deny selectors;
+turning a plugin off and on preserves its individual tool restrictions. Counts
+show the tools available after global and model restrictions. Save the model
+file, then apply configuration changes. Global restrictions still apply and
+cannot be lifted here. Shared bare-tool rules, wildcards, missing-plugin IDs and
+selectors that affect another plugin remain unchanged; review them under
+**Saved rules** and edit them in the displayed model configuration file.
+
 For public or multi-model installs, keep each model's detailed calibration in a
 separate model profile file instead of expanding the main runtime config:
 

package/docs/installation.md

@@ -145,6 +145,42 @@ Computer access connection shared by SYSTEM tools, ABot Spark and compatible
 plugins. Direct native/WSL command access can already work; the shared companion
 adds desktop access and background collection without a second ABot Spark setup.
 
+#### Windows: Microsoft Store connection
+
+**ABot AI Companion** is available from
+[Microsoft Store](https://apps.microsoft.com/detail/9PK2FDQQLQS9).
+The product ID is `9PK2FDQQLQS9`.
+
+Start with the computer connection card on **Home**, or the optional **Computer**
+setup step:
+
+1. Choose **Install from Microsoft Store** to open **ABot AI Companion**.
+2. Install it once on the Windows computer you want to connect.
+3. Return to ABot and choose **I already have it**.
+4. Choose **Open Companion**. The browser may ask permission to open it.
+5. Check the Runtime address shown by Companion and approve the connection.
+6. Companion shows connection progress; this can take a few seconds. Wait for
+   **Your computer is ready** in the Web UI.
+
+If Companion is already installed, start at step 3. The short-lived connection
+link is a private invitation; do not share it. Request a new link if it expires.
+The Web UI confirms the live connection rather than guessing whether the app is
+installed.
+
+If the computer is already paired but offline, choose **Open Companion**, then
+start the saved connection in the app. If you disconnected inside Companion or
+removed its saved connection, choose **Set up again** in ABot. Confirm the
+reset, then open Companion and approve the new connection. Re-pairing revokes the
+previous computer connection; it does not erase saved insights.
+
+Store updates are intended to preserve the saved pairing. Computer actions and
+optional Spark collection retain their existing, separate permission controls.
+Computer content used by ABot may reach your selected model provider. Installation
+alone does not start Spark collection. See [Windows Companion Store delivery](windows-companion-store.md)
+for connection details and update compatibility.
+
+#### macOS
+
 When ABot runs natively on your Mac, open its local Web UI and choose **Connect
 this Mac**. ABot uses its installed Node runtime and companion bundle, pairs the
 computer and enables startup at sign-in. This path does not download a Finder
@@ -159,25 +195,61 @@ loopback; a remote Runtime needs a local port forward. Direct connections to a
 remote network address are not supported. Mac desktop tools and Spark collection
 still require local Swift tools and the relevant macOS privacy permissions.
 
-**Spark permissions on macOS:** Computer access **Ready** confirms the connection;
-collection additionally needs Accessibility permission. Companion setup keeps a
+**Prepare macOS permissions before chatting:** The optional Computer setup step
+and **Home → Computer access** show separate preparation for desktop tools through
+the **Companion** and direct **SYSTEM commands through the active Runtime**.
+Connection status and operating-system permission status are separate; grants
+for one route do not establish access for the other. Check Screen Recording and
+Accessibility in each available route, then request its missing permission from
+that section and follow macOS settings. Checking does not capture a screen,
+read window content, type, or start Spark collection. Recheck after granting
+access; if macOS requires a restart, finish it before starting a conversation.
+
+Companion setup keeps a
 private copy of its Node executable at `~/.abot/host-companion/runtime/node` and
-uses that same path at sign-in, independently of NVM version paths. Start Spark
-collection to request consent, then authorize that executable in **System
+uses that same path at sign-in, independently of NVM version paths. Authorize
+the executable identified by the permission panel in **System
 Settings → Privacy & Security → Accessibility** (called **Device Control & Data
 Access** on some macOS versions). Use **+**, **Command–Shift–G**, and the path above
 if needed. The entry may be named `node`; verify the path before approving it.
-The collector checks approval for at most two minutes without reading content.
-After granting access, choose **Restart collection** in Home or Spark to check
-again. Setup reuses identical runtime bytes; replacing the runtime can require
-consent again. Screen recording and input permissions for other desktop tools
-are separate.
-
-For Windows or Linux, download setup and run it in that computer's graphical
-login. Windows setup installs the companion and a private Node runtime; Linux
-uses an existing Node.js installation. Setup pairs automatically and enables
-startup at sign-in. Wait for **Ready** in the Web UI; downloading alone does not
-establish a connection. WSL uses the same Windows companion setup, which does
+Setup reuses identical runtime bytes; replacing the runtime can require consent
+again. Spark collection remains separately controlled and does not start when
+permissions are prepared.
+
+Native SYSTEM commands launched by ABot through Terminal or another application
+have that caller's permission identity, separate from the Companion. Their panel
+checks the process owning the selected Runtime environment, even when the Web
+server is attached to a different process. Inspect the displayed computer and
+executable, follow the macOS prompt for that route, and recheck after changing
+access. A replaced Runtime or a different environment requires a new check.
+If macOS asks to reopen Terminal or ABot, do that before starting a conversation.
+Permission preparation does not restart either process automatically.
+
+This Runtime preparation is available from a local Web connection on the Mac;
+unsupported or unavailable routes are shown explicitly. The CLI remains useful
+for setup before ABot starts or for diagnosis from the same Terminal/application:
+
+```bash
+abot host permissions
+abot host permissions --request screen-recording
+abot host permissions --request accessibility
+```
+
+The first command only checks. The request commands may show an operating-system
+prompt; approve the identity shown by macOS and check again afterward. They do
+not change Computer access pairing or send a model request. Application-specific
+Automation/Apple Events and protected-file access may still require separate
+consent for the applications or locations used by a later SYSTEM command.
+
+#### Linux and WSL
+
+For Linux, download setup and run it in that computer's graphical login. Setup
+uses an existing Node.js installation, pairs automatically and enables startup
+at sign-in. Wait for **Ready** in the Web UI; downloading alone does not establish
+a connection. This Linux flow is unchanged by the Windows Store integration.
+
+Running ABot in WSL and existing WSL interop access are unchanged. To connect the
+Windows desktop to a WSL Runtime, use the Windows Companion flow above; it does
 not require changing interop settings or restarting the distribution.
 
 Installation does not enable ABot Spark collection or disabled plugin tools.
@@ -323,22 +395,3 @@ profile without changing runtime policy or another model's settings.
 
 The repository ignores `.env`, `local/runtime.config.json`, `.runtime/`, and
 `dist/`. Do not commit local secrets or generated runtime state.
-
-## Verify Package Surface
-
-Before publishing or opening a release PR:
-
-```bash
-npm test -- --run
-npm run build
-npm run smoke:runtime-package
-npm run check:runtime-package
-npm run smoke:packed-runtime-package
-git diff --check
-```
-
-`npm run build` regenerates `runtime.config.schema.json`, clears stale `dist`,
-and compiles the published TypeScript declarations.
-
-For the full public release checklist, see
-[`docs/publishing.md`](publishing.md).