@abot-ai/runtime 1.6.0 → 1.8.0

package/dist/src/web-ui/app/styles.css

@@ -18,6 +18,9 @@
 @import url("./styles/30-inspector-config.css");
 @import url("./styles/40-config-workspace.css");
 @import url("./styles/41-plugin-management.css");
+@import url("./styles/42-model-plugin-permissions.css");
+@import url("./styles/41-plugin-discovery.css");
+@import url("./styles/41-plugin-configuration.css");
 @import url("./styles/42-runtime-setup-plugins.css");
 @import url("./styles/43-model-setup.css");
 @import url("./styles/44-model-provider-cards.css");
@@ -40,6 +43,7 @@
 @import url("./styles/45-bridge-setup.css");
 @import url("./styles/46-system-host.css");
 @import url("./styles/11-workspace-header-width.css");
+@import url("./styles/11-product-links.css");
 @import url("./styles/28-tool-approval-card.css");
 @import url("./styles/14-startup-screen.css");
 @import url("./styles/93-compact-viewport.css");
@@ -49,6 +53,7 @@
 @import url("./styles/43-co-worker-applications.css");
 @import url("./styles/48-notifications.css");
 @import url("./styles/49-macos-permission.css");
+@import url("./styles/49-collection-consent.css");
 @import url("./styles/50-automations.css");
 @import url("./styles/51-automation-editor-actions.css");
 @import url("./styles/51-automation-templates.css");
@@ -57,3 +62,4 @@
 @import url("./styles/53-automation-schema-inputs.css");
 @import url("./styles/54-spark-chat.css");
 @import url("./styles/94-automations-responsive.css");
+@import url("./styles/64-workspace-storage.css");

package/dist/src/web-ui/client-state/contracts.d.ts

@@ -0,0 +1,15 @@
+/** Installation-owned UI state. These records never become model context. */
+export type ClientPreferences = Record<string, string>;
+export type ClientState = {
+    version: 1;
+    revision: number;
+    introductionSeen: boolean;
+    preferences: ClientPreferences;
+    queue: string;
+};
+export declare function emptyClientState(): ClientState;
+export declare class ClientStateError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(code: string, message: string, status?: number);
+}

package/dist/src/web-ui/client-state/contracts.js

@@ -0,0 +1,13 @@
+export function emptyClientState() {
+    return { version: 1, revision: 0, introductionSeen: false,
+        preferences: { "abot-web.lastToolPermissionMode": "ask" }, queue: "" };
+}
+export class ClientStateError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}

package/dist/src/web-ui/client-state/preference-shapes.d.ts

@@ -0,0 +1,2 @@
+export declare function isPreferenceObject(value: unknown): value is Record<string, unknown>;
+export declare function assertPreferenceShape(key: string, value: unknown): void;

package/dist/src/web-ui/client-state/preference-shapes.js

@@ -0,0 +1,80 @@
+import { ClientStateError } from "./contracts.js";
+const modes = new Set(["ask", "full_access", "full_plus"]);
+export function isPreferenceObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isStringList(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function hasOnlyFields(value, fields) {
+    return Object.keys(value).every((key) => fields.includes(key));
+}
+function isSessionMode(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["toolPermissionMode", "savedAt"]))
+        return false;
+    if (typeof value.toolPermissionMode !== "string" || !modes.has(value.toolPermissionMode))
+        return false;
+    return Number.isFinite(value.savedAt);
+}
+function isSidebarPreference(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["archivedSessionIds", "orderedSessionIds"]))
+        return false;
+    return isStringList(value.archivedSessionIds) && isStringList(value.orderedSessionIds);
+}
+function isLauncherPosition(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["x", "y"]))
+        return false;
+    return Number.isFinite(value.x) && Number.isFinite(value.y);
+}
+function isGuidancePreference(value) {
+    if (!isPreferenceObject(value))
+        return false;
+    if (!hasOnlyFields(value, ["offeredOn", "dismissed", "reviewed"]))
+        return false;
+    if (value.offeredOn !== undefined && typeof value.offeredOn !== "string")
+        return false;
+    if (value.dismissed !== undefined && (!isStringList(value.dismissed) || value.dismissed.length > 8))
+        return false;
+    if (value.reviewed === undefined)
+        return true;
+    if (!Array.isArray(value.reviewed) || value.reviewed.length > 200)
+        return false;
+    const seen = new Set();
+    for (const item of value.reviewed) {
+        if (!isPreferenceObject(item))
+            return false;
+        if (!hasOnlyFields(item, ["id", "updatedAt"]))
+            return false;
+        if (typeof item.id !== "string" || typeof item.updatedAt !== "string")
+            return false;
+        if (seen.has(item.id))
+            return false;
+        seen.add(item.id);
+    }
+    return true;
+}
+function hasPreferenceShape(key, value) {
+    if (key === "abot-web.pinnedSessions")
+        return isStringList(value);
+    if (key === "abot.spark.launcher.position.v1")
+        return isLauncherPosition(value);
+    if (key.startsWith("abot-web.homeGuidance."))
+        return isGuidancePreference(value);
+    if (!isPreferenceObject(value))
+        return false;
+    if (key === "abot-web.sessionModes")
+        return Object.values(value).every(isSessionMode);
+    if (key === "abot-web.sessionSidebarByEnvironment")
+        return Object.values(value).every(isSidebarPreference);
+    return Object.values(value).every((item) => typeof item === "string");
+}
+export function assertPreferenceShape(key, value) {
+    if (!hasPreferenceShape(key, value))
+        throw new ClientStateError("invalid_preferences", "Invalid workspace preferences or unbounded memory review receipts.");
+}

package/dist/src/web-ui/client-state/preferences.d.ts

@@ -0,0 +1,3 @@
+import { type ClientPreferences } from "./contracts.js";
+export declare function decodePreference(key: string, value: unknown): unknown;
+export declare function updatePreference(preferences: ClientPreferences, input: Record<string, unknown>): void;

package/dist/src/web-ui/client-state/preferences.js

@@ -0,0 +1,84 @@
+import { isDeepStrictEqual } from "node:util";
+import { ClientStateError } from "./contracts.js";
+import { assertPreferenceShape, isPreferenceObject as isObject } from "./preference-shapes.js";
+const scalarKeys = new Set(["abot-web.environmentId", "abot-web.lastToolPermissionMode"]);
+const jsonKeys = new Set([
+    "abot-web.pinnedSessions", "abot-web.currentSessionByEnvironment", "abot-web.sessionModes",
+    "abot-web.sessionModels", "abot-web.lastModelByEnvironment", "abot-web.sessionSidebarByEnvironment",
+    "abot.spark.launcher.position.v1",
+]);
+const modes = new Set(["ask", "full_access", "full_plus"]);
+function assertBoundedJson(value, depth = 0) {
+    if (depth > 8)
+        throw new ClientStateError("invalid_preferences", "Workspace preferences are too deeply nested.");
+    if (!value || typeof value !== "object")
+        return;
+    for (const child of Object.values(value)) {
+        assertBoundedJson(child, depth + 1);
+    }
+}
+function isGuidanceKey(key) {
+    // encodeURIComponent leaves these punctuation characters unescaped. The
+    // request and state byte limits bound keys without restricting profile IDs.
+    return /^abot-web\.homeGuidance\.(?:[A-Za-z0-9_.!~*'()-]|%[0-9A-Fa-f]{2})+$/.test(key);
+}
+export function decodePreference(key, value) {
+    if (!scalarKeys.has(key) && !jsonKeys.has(key) && !isGuidanceKey(key))
+        throw new ClientStateError("invalid_preferences", "Unknown workspace preference.");
+    if (value === null)
+        return undefined;
+    if (typeof value !== "string" || value.length > 524_288)
+        throw new ClientStateError("invalid_preferences", "Invalid workspace preference value.");
+    if (scalarKeys.has(key)) {
+        if (key.endsWith("lastToolPermissionMode") && !modes.has(value))
+            throw new ClientStateError("invalid_preferences", "Select Ask, Full or Full+.");
+        return value;
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(value);
+    }
+    catch {
+        throw new ClientStateError("invalid_preferences", "Workspace preferences must contain JSON.");
+    }
+    assertBoundedJson(decoded);
+    assertPreferenceShape(key, decoded);
+    return decoded;
+}
+function ownPreferenceField(record, key) {
+    return Object.hasOwn(record, key) ? record[key] : undefined;
+}
+function mergeChangedFields(before, after, current) {
+    if (isDeepStrictEqual(before, after))
+        return current;
+    if (before === undefined && isObject(after) && isObject(current))
+        return mergeChangedFields({}, after, current);
+    if (isObject(before) && isObject(after) && isObject(current)) {
+        const result = Object.assign(Object.create(null), current);
+        for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+            const next = mergeChangedFields(ownPreferenceField(before, key), ownPreferenceField(after, key), ownPreferenceField(current, key));
+            if (next === undefined)
+                delete result[key];
+            else
+                result[key] = next;
+        }
+        return result;
+    }
+    if (!isDeepStrictEqual(current, before) && !isDeepStrictEqual(current, after))
+        throw new ClientStateError("preferences_changed", "These settings changed in another window. Reload before saving again.", 409);
+    return after;
+}
+export function updatePreference(preferences, input) {
+    const key = typeof input.key === "string" ? input.key : "";
+    const before = decodePreference(key, input.before);
+    const after = decodePreference(key, input.value);
+    const current = decodePreference(key, preferences[key] ?? null);
+    const merged = mergeChangedFields(before, after, current);
+    if (merged === undefined) {
+        delete preferences[key];
+        return;
+    }
+    const value = scalarKeys.has(key) ? String(merged) : JSON.stringify(merged);
+    decodePreference(key, value);
+    preferences[key] = value;
+}

package/dist/src/web-ui/client-state/queue.d.ts

@@ -0,0 +1,3 @@
+import { type ClientState } from "./contracts.js";
+/** Runs within the store transaction: a queue item can be released by only one caller. */
+export declare function changeClientQueue(state: ClientState, input: Record<string, unknown>): unknown;

package/dist/src/web-ui/client-state/queue.js

@@ -0,0 +1,43 @@
+import { createSessionComposerQueue } from "../app/lib/session-composer-queue.js";
+import { ClientStateError } from "./contracts.js";
+function queueScope(input) {
+    if (!input || typeof input !== "object")
+        throw new ClientStateError("invalid_queue_scope", "A conversation is required.");
+    const scope = input;
+    for (const value of [scope.environmentId, scope.sessionId]) {
+        if (typeof value !== "string" || !value.trim())
+            throw new ClientStateError("invalid_queue_scope", "Invalid conversation identity.");
+    }
+    return { environmentId: scope.environmentId, sessionId: scope.sessionId };
+}
+/** Runs within the store transaction: a queue item can be released by only one caller. */
+export function changeClientQueue(state, input) {
+    const scope = queueScope(input.scope);
+    const ownerId = typeof input.ownerId === "string" && input.ownerId.length <= 128 ? input.ownerId : null;
+    const requiresRecoveryOwner = ["claim", "begin", "uncertain"].includes(String(input.action));
+    if (requiresRecoveryOwner && !ownerId)
+        throw new ClientStateError("invalid_queue_owner", "A window identity is required to recover a queued message.");
+    const queue = createSessionComposerQueue({ ownerId, storage: {
+            getItem: () => state.queue || null,
+            setItem: (_key, value) => { state.queue = value; },
+        } });
+    const token = typeof input.releaseToken === "string" ? input.releaseToken : "";
+    const requestId = typeof input.requestId === "string" ? input.requestId : "";
+    if (input.action === "claim")
+        return queue.claimBlockedRelease(scope, token, { takeover: input.takeover === true });
+    if (input.action === "begin")
+        return queue.beginBlockedSend(scope, token);
+    if (input.action === "uncertain")
+        return queue.markBlockedUncertain(scope, token);
+    if (input.action === "enqueue")
+        return queue.enqueue(scope, input.item);
+    if (input.action === "release")
+        return queue.releaseForTerminal(scope, requestId);
+    if (input.action === "bind")
+        return queue.bindReleasedSuccess(scope, token, requestId);
+    if (input.action === "rebind")
+        return queue.rebindBlocked(scope, requestId);
+    if (input.action === "update")
+        return queue.updateBlockedRelease(scope, token, input.item);
+    throw new ClientStateError("invalid_queue_action", "Unknown message queue operation.");
+}

package/dist/src/web-ui/client-state/routes.d.ts

@@ -0,0 +1,7 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare class WebClientStateRoutes {
+    private readonly changed;
+    private readonly store;
+    constructor(rootDir: string, changed?: () => void);
+    handle(request: IncomingMessage, response: ServerResponse, pathname: string): Promise<boolean>;
+}

package/dist/src/web-ui/client-state/routes.js

@@ -0,0 +1,58 @@
+import { acceptConfigMutationRequest } from "../local-runtime/config-mutation-request.js";
+import { readBody, readJsonBody, sendJson } from "../local-runtime/http.js";
+import { ClientStateError } from "./contracts.js";
+import { updatePreference } from "./preferences.js";
+import { WebClientStateStore } from "./store.js";
+import { changeClientQueue } from "./queue.js";
+export class WebClientStateRoutes {
+    changed;
+    store;
+    constructor(rootDir, changed = () => { }) {
+        this.changed = changed;
+        this.store = new WebClientStateStore(rootDir);
+    }
+    async handle(request, response, pathname) {
+        if (pathname !== "/web-ui-state")
+            return false;
+        response.setHeader("cache-control", "no-store");
+        try {
+            if (request.method === "GET") {
+                const { state } = await this.store.transaction(() => null);
+                sendJson(response, 200, { ok: true, state });
+                return true;
+            }
+            if (request.method !== "POST") {
+                sendJson(response, 405, { ok: false, error: "method_not_allowed" });
+                return true;
+            }
+            if (!acceptConfigMutationRequest(request, response))
+                return true;
+            const input = readJsonBody(await readBody(request, { maxBytes: 1024 * 1024 }));
+            const saved = await this.store.transaction((state) => {
+                if (input.kind === "preference") {
+                    updatePreference(state.preferences, input);
+                    return null;
+                }
+                if (input.kind === "queue")
+                    return changeClientQueue(state, input);
+                if (input.kind === "introduction") {
+                    state.introductionSeen = true;
+                    return null;
+                }
+                throw new ClientStateError("invalid_state_operation", "Unknown workspace state operation.");
+            });
+            sendJson(response, 200, { ok: true, ...saved });
+            try {
+                this.changed();
+            }
+            catch { /* Persistence already succeeded; clients also refresh on focus. */ }
+        }
+        catch (error) {
+            const known = error instanceof ClientStateError;
+            sendJson(response, known ? error.status : 500, { ok: false,
+                error: known ? error.code : "workspace_state_unavailable",
+                message: known ? error.message : "Workspace settings could not be saved or loaded. Existing data was preserved. Reload before continuing." });
+        }
+        return true;
+    }
+}

package/dist/src/web-ui/client-state/store.d.ts

@@ -0,0 +1,14 @@
+import { type ClientState } from "./contracts.js";
+/** One installation; independent of listener ports, browser profiles and operating system. */
+export declare class WebClientStateStore {
+    private initialization?;
+    readonly directory: string;
+    readonly path: string;
+    constructor(rootDir: string);
+    private load;
+    private save;
+    transaction<T>(operation: (state: ClientState) => T): Promise<{
+        result: T;
+        state: ClientState;
+    }>;
+}

package/dist/src/web-ui/client-state/store.js

@@ -0,0 +1,88 @@
+import { open, readFile, rm, lstat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { withFileLock } from "../../runtime/adapters/long-term-memory/file-lock.js";
+import { ensurePrivateRuntimeDirectory } from "../../runtime/local-host/private-directory.js";
+import { replacePreparedSessionFile } from "../../sessions/prepared-session-replacement.js";
+import { isPersistedStore } from "../app/lib/session-composer-queue.js";
+import { ClientStateError, emptyClientState } from "./contracts.js";
+import { decodePreference } from "./preferences.js";
+const maxStateBytes = 8 * 1024 * 1024;
+function decodeState(raw) {
+    const state = JSON.parse(raw);
+    if (state?.version !== 1 || !Number.isSafeInteger(state.revision) || state.revision < 0 ||
+        typeof state.introductionSeen !== "boolean" || !state.preferences ||
+        typeof state.preferences !== "object" || Array.isArray(state.preferences) || typeof state.queue !== "string")
+        throw new Error("Workspace state is invalid. Its existing file has been preserved.");
+    for (const [key, value] of Object.entries(state.preferences))
+        decodePreference(key, value);
+    if (state.queue && !isPersistedStore(JSON.parse(state.queue)))
+        throw new Error("Saved message queue is invalid. Its existing file has been preserved.");
+    return state;
+}
+/** One installation; independent of listener ports, browser profiles and operating system. */
+export class WebClientStateStore {
+    initialization;
+    directory;
+    path;
+    constructor(rootDir) {
+        this.directory = resolve(rootDir, ".runtime", "web-ui", "client-state");
+        this.path = join(this.directory, "state.json");
+    }
+    async load() {
+        try {
+            const info = await lstat(this.path);
+            if (!info.isFile() || info.isSymbolicLink() || info.size > maxStateBytes)
+                throw new Error("Workspace state must be a bounded regular file.");
+            return decodeState(await readFile(this.path, "utf8"));
+        }
+        catch (error) {
+            if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+                return emptyClientState();
+            throw error;
+        }
+    }
+    async save(state) {
+        const raw = JSON.stringify(state);
+        if (Buffer.byteLength(raw) > maxStateBytes)
+            throw new ClientStateError("workspace_storage_full", "Workspace settings and queued messages exceed their storage limit. No saved data was discarded.", 413);
+        decodeState(raw);
+        const temporary = `${this.path}.${randomUUID()}.tmp`;
+        try {
+            const file = await open(temporary, "wx", 0o600);
+            try {
+                await file.writeFile(raw);
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+            await replacePreparedSessionFile(temporary, this.path);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+    async transaction(operation) {
+        const initializing = this.initialization ??= ensurePrivateRuntimeDirectory(this.directory);
+        try {
+            await initializing;
+        }
+        catch (error) {
+            // A later explicit reload may try again after the directory is repaired.
+            if (this.initialization === initializing)
+                this.initialization = undefined;
+            throw error;
+        }
+        return withFileLock(join(this.directory, "state.lock"), async () => {
+            const state = await this.load();
+            const before = JSON.stringify(state);
+            const result = operation(state);
+            if (JSON.stringify(state) !== before) {
+                state.revision += 1;
+                await this.save(state);
+            }
+            return { result, state };
+        });
+    }
+}

package/dist/src/web-ui/local-runtime/api-router.js

@@ -88,6 +88,11 @@ export class LocalRuntimeApiRouter {
         }));
         this.plugins = new PluginManagementRoutes({
             rootDir: options.rootDir ?? process.cwd(),
+            requireMutationIdle: () => this.environments.requirePluginMutationIdle(this.requests.healthDetails().length > 0),
+            removalRuntime: {
+                applyConfiguration: (revision) => this.applyWhenRequestsIdle(revision),
+                requireInactive: (pluginId, capabilities) => this.environments.requirePluginInactive(pluginId, capabilities),
+            },
             getConfigPath: () => options.configPath ?? process.env.LLM_RUNTIME_CONFIG_FILE,
         });
         this.readStates = new WebSessionReadStates((id) => this.environments.get(id));
@@ -101,7 +106,7 @@ export class LocalRuntimeApiRouter {
         }));
         this.memoryManagement = new LongTermMemoryManagementRoutes((environmentId) => this.environments.get(environmentId).services.longTermMemory);
     }
-    async applyWhenRequestsIdle() {
+    async applyWhenRequestsIdle(expectedRevision) {
         const hasAcknowledgedRequests = this.requests.healthDetails().length > 0;
         if (hasAcknowledgedRequests) {
             return {
@@ -109,7 +114,7 @@ export class LocalRuntimeApiRouter {
                 message: "Your agent is working. Wait for active conversations and Jobs to finish, then apply again.",
             };
         }
-        return this.environments.applyConfiguration();
+        return this.environments.applyConfiguration(expectedRevision);
     }
     async initializeSessionReadState(environmentIds) {
         for (const id of environmentIds) {
@@ -222,7 +227,7 @@ export class LocalRuntimeApiRouter {
             response: res,
         }))
             return;
-        if (await this.plugins.handle({ method, route, body, response: res }))
+        if (await this.plugins.handle({ method, route, body, request: req, response: res }))
             return;
         if (segments[0] === "schedules")
             await this.initializeSessionReadState([environmentId]);
@@ -320,10 +325,10 @@ export class LocalRuntimeApiRouter {
             });
             return;
         }
-        if ((method === "GET" && route === "chat/sessions") ||
+        if (((method === "GET" && route === "chat/sessions") || (method === "POST" && route === "chat/sessions/page")) ||
             (method === "POST" && route === "chat/messages")) {
             const setupRequirement = this.environments.setupRequirement(environmentId);
-            if (setupRequirement && method === "GET") {
+            if (setupRequirement && route !== "chat/messages") {
                 sendJson(res, 200, {
                     ok: true,
                     sessions: [],
@@ -350,7 +355,7 @@ export class LocalRuntimeApiRouter {
         if (await this.sessions.handle({
             method,
             segments,
-            body,
+            url, body,
             environmentId,
             environment,
             response: res,

package/dist/src/web-ui/local-runtime/approval-request-attachment.js

@@ -1,4 +1,5 @@
 import { createRequestSteeringInbox } from "../../runtime/request/request-steering.js";
+import { traceWebProjection } from "./request-control-observation.js";
 function hasMatchingRequestView(active, input) {
     if (active.environmentId !== input.environmentId)
         return false;
@@ -22,9 +23,13 @@ export async function attachApprovalRequest(input) {
             lastEventName: "tool.approval.required",
             events: [...input.events],
             finalState: null,
-            requestSteering: createRequestSteeringInbox({ requestId }),
+            requestSteering: createRequestSteeringInbox({
+                requestId,
+                diagnostics: { origin: "web_projection" },
+            }),
         };
         activeRequests.set(requestId, active);
+        traceWebProjection("projection.opened", requestId, active, "approval_attachment");
     }
     if (pending.run)
         return;
@@ -37,8 +42,10 @@ export async function attachApprovalRequest(input) {
             resolve();
         })
             .catch((error) => {
-            if (createdProjection && activeRequests.get(requestId) === projection)
-                activeRequests.delete(requestId);
+            if (createdProjection && activeRequests.get(requestId) === projection) {
+                const removed = activeRequests.delete(requestId);
+                traceWebProjection("projection.removed", requestId, projection, "attachment_error", removed);
+            }
             if (accepted)
                 input.publish(JSON.stringify({
                     type: "control",
@@ -51,8 +58,10 @@ export async function attachApprovalRequest(input) {
             .finally(() => {
             if (!projection.finalState)
                 return;
-            if (activeRequests.get(requestId) === projection)
-                activeRequests.delete(requestId);
+            if (activeRequests.get(requestId) === projection) {
+                const removed = activeRequests.delete(requestId);
+                traceWebProjection("projection.removed", requestId, projection, "attachment_terminal_settled", removed);
+            }
         });
     });
 }

package/dist/src/web-ui/local-runtime/configuration-activation-source.d.ts

@@ -4,4 +4,4 @@ export type ConfigurationActivationPreparation = {
     restoreConfiguration(): void;
 };
 /** Cooperating root and linked-file saves wait for activation or restoration to finish. */
-export declare function withConfigurationActivationSource(configPath: string, operation: (preparation: ConfigurationActivationPreparation) => Promise<RuntimeSetupActivation>): Promise<RuntimeSetupActivation>;
+export declare function withConfigurationActivationSource(configPath: string, operation: (preparation: ConfigurationActivationPreparation) => Promise<RuntimeSetupActivation>, expectedRevision?: string, pluginRootDir?: string): Promise<RuntimeSetupActivation>;

package/dist/src/web-ui/local-runtime/configuration-activation-source.js

@@ -1,4 +1,6 @@
-import { withConfigFileTransaction } from "../../runtime/adapters/config-file-transaction.js";
+import { requireRuntimeSetupEditSettled } from "./runtime-setup-edit-recovery.js";
+import { withPluginConfigurationLock } from "../../runtime/plugins/configuration-write.js";
+import { ConfigFileConflictError, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
 import { resolveRequestRunnerConfigReference } from "../../runtime/config/request-runner-config.js";
 import { invalidateRequestRunnerConfig } from "../../runtime/config/runner/loader.js";
 function restoreUnappliedRequestRunner(activation, preparation) {
@@ -7,8 +9,12 @@ function restoreUnappliedRequestRunner(activation, preparation) {
     preparation.restoreConfiguration();
 }
 /** Cooperating root and linked-file saves wait for activation or restoration to finish. */
-export function withConfigurationActivationSource(configPath, operation) {
+export function withConfigurationActivationSource(configPath, operation, expectedRevision, pluginRootDir) {
     return withConfigFileTransaction(configPath, async (transaction) => {
+        requireRuntimeSetupEditSettled(pluginRootDir ?? process.cwd());
+        if (expectedRevision !== undefined &&
+            transaction.snapshot.revision !== expectedRevision)
+            throw new ConfigFileConflictError();
         const runner = resolveRequestRunnerConfigReference({
             fileConfig: transaction.snapshot.config,
             mainConfigPath: configPath,
@@ -24,7 +30,9 @@ export function withConfigurationActivationSource(configPath, operation) {
             },
         };
         try {
-            const activation = await operation(preparation);
+            const activation = await (pluginRootDir
+                ? withPluginConfigurationLock(pluginRootDir, () => operation(preparation))
+                : operation(preparation));
             restoreUnappliedRequestRunner(activation, preparation);
             return activation;
         }

package/dist/src/web-ui/local-runtime/contracts.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimeSetupGatewayRestorePoint } from "../runtime-setup-gateway.js";
+import type { AppliedGatewayConfigurations, RuntimeSetupGatewayRestorePoint } from "../runtime-setup-gateway.js";
 import type { WebUiEnvironmentConfig } from "../environment-config.js";
 import type { RuntimeSetupActivation } from "./runtime-setup-input.js";
 import type { LocalRuntimeApplication } from "../../runtime/local-application.js";
@@ -11,9 +11,10 @@ export type LocalRuntimeBackendOptions = {
     defaultEnvironmentId: string;
     resolveEnvironmentConfig?: (configPath?: string) => WebUiEnvironmentConfig;
     providerAdapters?: ModelProviderAdapterRegistry;
-    onRuntimeSetup?: (configPath: string) => Promise<RuntimeSetupActivation>;
+    captureRuntimeSetupConfiguration?: (configPath?: string) => string | null;
+    onRuntimeSetup?: (configPath: string, applied?: AppliedGatewayConfigurations) => Promise<RuntimeSetupActivation>;
     createRuntimeSetupRestorePoint?: () => RuntimeSetupGatewayRestorePoint;
-    checkRuntimeSetupActivation?: (configPath: string) => Promise<RuntimeSetupActivation>;
+    checkRuntimeSetupActivation?: (configPath: string, applied?: AppliedGatewayConfigurations) => Promise<RuntimeSetupActivation>;
 };
 export type ResolvedLocalRuntimeBackendOptions = Omit<LocalRuntimeBackendOptions, "providerAdapters"> & {
     providerAdapters: ModelProviderAdapterRegistry;

package/dist/src/web-ui/local-runtime/environment-registry.d.ts

@@ -7,6 +7,7 @@ export declare class RuntimeEnvironmentRegistry {
     private readonly options;
     private readonly schedulerBindings;
     private readonly environments;
+    private readonly gatewayConfigurations;
     private stopped;
     private readonly desiredEnvironmentIds;
     private applying;
@@ -23,13 +24,16 @@ export declare class RuntimeEnvironmentRegistry {
         status(): Promise<import("../../computer-access/native-permission-contract.js").NativePermissionStatus>;
         prepare(input: import("../../computer-access/native-permission-contract.js").NativePermissionInput): Promise<import("../../computer-access/native-permission-contract.js").NativePermissionResult>;
     }> | undefined;
-    applyConfiguration(): Promise<RuntimeSetupActivation>;
+    requirePluginInactive(pluginId: string, capabilityIds: readonly string[]): void;
+    requirePluginMutationIdle(hasAcknowledgedRequests?: boolean): void;
+    applyConfiguration(expectedRevision?: string): Promise<RuntimeSetupActivation>;
     private applySavedConfiguration;
     private checkGatewayActivation;
     configure(configPath: string): void;
     modelCatalog(environmentId: string): RuntimeModelCatalogState;
     setupRequirement(environmentId: string): RuntimeSetupRequirement | null;
     get(environmentId: string): RuntimeEnvironment;
+    private captureGatewayConfiguration;
     private createEnvironment;
     start(environmentIds: readonly string[]): Promise<void>;
     private startEnvironment;