@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/web-ui/local-runtime/model-setup-service.js

@@ -0,0 +1,138 @@
+import { isDeepStrictEqual } from "node:util";
+import { realpath } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { mergeRuntimeModelAddition } from "../../../scripts/runtime-model-addition.js";
+import { ConfigFileConflictError, canonicalConfigFilePath, readConfigFileSnapshot, withConfigFileTransaction, } from "../../runtime/adapters/config-file-transaction.js";
+import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
+import { getConfigDashboardSnapshot, saveConfigDashboardFile, } from "../config-dashboard-backend.js";
+import { getModelSetupCatalog, modelConfigMap, readModelSetupSource, } from "./model-setup-catalog.js";
+import { ModelSetupError, parseModelSetupInput, } from "./model-setup-input.js";
+import { planModelProvider, prepareModelCredential, saveModelCredential, } from "./model-setup-provider.js";
+import { validateModelAddition } from "./model-setup-validation.js";
+import { buildModelSetupProfile, modelSetupResult, } from "./model-setup-identity.js";
+import { recoverCommittedModelAddition } from "./model-setup-retry.js";
+import { removeRuntimeModelDeclaration } from "./model-removal.js";
+import { isDiscoveredModelSetupProfileAtTarget, withModelSetupProfile, } from "./model-setup-profile-file.js";
+function isModelConfigLocationInsideWorkspace(rootDir, path) {
+    const location = relative(rootDir, path);
+    return !location.startsWith("..") && !isAbsolute(location);
+}
+function requireModelConfigLocationInsideWorkspace(rootDir, path) {
+    if (isModelConfigLocationInsideWorkspace(rootDir, path))
+        return;
+    throw new ModelSetupError("model_config_outside_workspace", "The selected configuration must be inside the workspace.", 409);
+}
+async function hasCommittedModelAddition(transaction, candidate) {
+    try {
+        const current = await readConfigFileSnapshot(transaction.path);
+        return isDeepStrictEqual(current.config, candidate);
+    }
+    catch {
+        return false;
+    }
+}
+export class ModelSetupService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    sourceOptions() {
+        return {
+            rootDir: this.options.rootDir,
+            configPath: this.options.getConfigPath(),
+        };
+    }
+    async catalog() {
+        return getModelSetupCatalog(await this.canonicalOptions());
+    }
+    async canonicalOptions() {
+        const source = readModelSetupSource(this.sourceOptions());
+        const rootDir = await realpath(this.options.rootDir);
+        // Rebase only the workspace prefix. Resolving inner parent links would
+        // change the Runtime's lexical resolution of references such as ../models.
+        const configPath = isModelConfigLocationInsideWorkspace(this.options.rootDir, source.path)
+            ? resolve(rootDir, relative(this.options.rootDir, source.path))
+            : source.path;
+        const canonicalConfigPath = await realpath(source.path);
+        requireModelConfigLocationInsideWorkspace(rootDir, configPath);
+        requireModelConfigLocationInsideWorkspace(rootDir, canonicalConfigPath);
+        requireModelConfigLocationInsideWorkspace(rootDir, await realpath(dirname(source.path)));
+        return { rootDir, configPath, canonicalConfigPath };
+    }
+    async remove(body) {
+        const options = await this.canonicalOptions();
+        return withConfigFileTransaction(options.canonicalConfigPath, (transaction) => removeRuntimeModelDeclaration(options, transaction, body));
+    }
+    async add(body) {
+        const input = parseModelSetupInput(body);
+        const options = await this.canonicalOptions();
+        return withConfigFileTransaction(options.canonicalConfigPath, (transaction) => this.save(options, input, transaction));
+    }
+    async save(options, input, transaction) {
+        const selectedPath = await canonicalConfigFilePath(options.configPath);
+        const hasLockedSelectedConfig = transaction.snapshot.exists && transaction.path === selectedPath;
+        if (!hasLockedSelectedConfig)
+            throw new ModelSetupError("config_changed", "The selected configuration changed while being opened. Reload Configuration before retrying.", 409);
+        const source = transaction.snapshot.config;
+        validateRuntimeConfigFile(source, transaction.path);
+        const models = modelConfigMap(source.models);
+        const dashboard = await getConfigDashboardSnapshot(options, transaction.snapshot);
+        const savedProfiles = modelConfigMap(models.profiles);
+        if (Object.hasOwn(savedProfiles, input.profileId))
+            return recoverCommittedModelAddition(options, models, input, transaction.snapshot.revision);
+        const discovered = dashboard.files.models.find((entry) => entry.id === input.profileId);
+        if (discovered &&
+            !(await isDiscoveredModelSetupProfileAtTarget(options, input.profileId, resolve(options.rootDir, discovered.path))))
+            throw new ModelSetupError("model_profile_exists", "Another model file already uses this profile ID. Choose another ID.", 409);
+        const provider = planModelProvider(modelConfigMap(models.providers), input);
+        const profile = await buildModelSetupProfile(provider, input);
+        const addition = {
+            profileId: input.profileId,
+            providerId: provider.id,
+            provider: provider.config,
+            profile,
+        };
+        await validateModelAddition(mergeRuntimeModelAddition(source, addition).config, options);
+        const credential = await prepareModelCredential(options, provider.config, input.apiKey);
+        return withModelSetupProfile(options, transaction, input.profileId, profile, async (declaration, assertProfileUnchanged) => {
+            const candidate = mergeRuntimeModelAddition(source, {
+                ...addition,
+                profile: declaration,
+            }).config;
+            await validateModelAddition(candidate, options);
+            await assertProfileUnchanged();
+            await this.commit(options, candidate, transaction, credential, assertProfileUnchanged);
+            return modelSetupResult(provider, input);
+        });
+    }
+    async commit(options, candidate, transaction, credential, assertProfileUnchanged) {
+        let credentialSaved = false;
+        let configSaveAttempted = false;
+        try {
+            credentialSaved = await saveModelCredential(options, credential);
+            await assertProfileUnchanged();
+            configSaveAttempted = true;
+            await saveConfigDashboardFile({
+                ...options,
+                kind: "runtime",
+                config: candidate,
+                transaction,
+            });
+        }
+        catch (error) {
+            if (error instanceof ModelSetupError) {
+                if (!credentialSaved || error.credentialSaved)
+                    throw error;
+                throw new ModelSetupError(error.code, error.message, error.statusCode, true);
+            }
+            if (error instanceof ConfigFileConflictError)
+                throw new ModelSetupError("config_changed", error.message, 409, credentialSaved);
+            const modelCommitted = configSaveAttempted &&
+                (await hasCommittedModelAddition(transaction, candidate));
+            if (!modelCommitted)
+                throw new ModelSetupError("model_save_failed", credentialSaved
+                    ? "The credential is saved, but the model save could not be confirmed. Refresh Configuration, then retry without re-entering the key if the model is missing."
+                    : "The model save could not be confirmed. Refresh Configuration before trying again.", 500, credentialSaved);
+        }
+    }
+}

package/dist/src/web-ui/local-runtime/model-setup-validation.d.ts

@@ -0,0 +1,6 @@
+/** Staging beside the selected source preserves every existing relative reference. */
+export declare function validateModelConfigurationChange(config: Record<string, unknown>, options: {
+    rootDir: string;
+    configPath: string;
+}): Promise<void>;
+export { validateModelConfigurationChange as validateModelAddition };

package/dist/src/web-ui/local-runtime/model-setup-validation.js

@@ -0,0 +1,34 @@
+import { randomUUID } from "node:crypto";
+import { rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { loadRuntimeConfig } from "../../runtime/config.js";
+import { isRecord } from "../../runtime/config/utils.js";
+import { validateRuntimeConfigFile } from "../../runtime/config/validation.js";
+/** Staging beside the selected source preserves every existing relative reference. */
+export async function validateModelConfigurationChange(config, options) {
+    validateRuntimeConfigFile(config, options.configPath);
+    const temporary = join(dirname(options.configPath), `.model-addition-validation-${randomUUID()}.json`);
+    try {
+        await writeFile(temporary, JSON.stringify(config), {
+            encoding: "utf8",
+            mode: 0o600,
+            flag: "wx",
+        });
+        const environment = isRecord(config.environment) ? config.environment : {};
+        const profileIds = isRecord(environment.profiles)
+            ? Object.keys(environment.profiles)
+            : [];
+        const environments = profileIds.length ? profileIds : [undefined];
+        for (const profileId of environments)
+            loadRuntimeConfig({
+                rootDir: options.rootDir,
+                configPath: temporary,
+                profileId,
+                env: { ...process.env },
+            });
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export { validateModelConfigurationChange as validateModelAddition };

package/dist/src/web-ui/local-runtime/pending-tool-approvals.d.ts

@@ -0,0 +1,29 @@
+import type { ToolApprovalController, ToolApprovalDecision, ToolApprovalRequest } from "../../runtime/ports.js";
+import type { ActiveRequest, JsonObject } from "./contracts.js";
+export type PendingWebToolApproval = {
+    environmentId: string;
+    sessionId: string;
+    requestId: string;
+    approvalId: string;
+    event: JsonObject;
+    generation?: string;
+    waitId?: string;
+    revision?: number;
+};
+export type WebToolApprovalDecision = Omit<PendingWebToolApproval, "event"> & ToolApprovalDecision & {
+    commandId?: string;
+};
+/** Own the transport's existing live promises; persisted events are never authority. */
+export declare class PendingToolApprovals implements ToolApprovalController {
+    private readonly activeRequest;
+    private readonly onChanged?;
+    private readonly pending;
+    constructor(activeRequest: (id: string) => ActiveRequest | undefined, onChanged?: ((requestId: string) => void) | undefined);
+    requestToolApproval(request: ToolApprovalRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<ToolApprovalDecision>;
+    private notifyChanged;
+    list(environmentId: string): PendingWebToolApproval[];
+    decide(decision: WebToolApprovalDecision): boolean;
+    resolveRealtime(message: JsonObject): void;
+}

package/dist/src/web-ui/local-runtime/pending-tool-approvals.js

@@ -0,0 +1,104 @@
+import { getString } from "./http.js";
+function isRequiredApprovalEvent(event, requestId, approvalId) {
+    if (event.name !== "tool.approval.required")
+        return false;
+    if (event.approvalId !== approvalId)
+        return false;
+    return event.requestId === requestId;
+}
+function findRequiredApprovalEvent(active, approvalId) {
+    return active.events.find((event) => isRequiredApprovalEvent(event, active.requestId, approvalId));
+}
+function isLiveApprovalRequest(active, environmentId) {
+    if (!active || active.finalState)
+        return false;
+    return active.environmentId === environmentId;
+}
+function canResolvePendingApproval(pending, active, decision) {
+    if (!pending || pending.requestId !== decision.requestId)
+        return false;
+    if (!isLiveApprovalRequest(active, decision.environmentId))
+        return false;
+    if (active.sessionId !== decision.sessionId)
+        return false;
+    return Boolean(findRequiredApprovalEvent(active, decision.approvalId));
+}
+/** Own the transport's existing live promises; persisted events are never authority. */
+export class PendingToolApprovals {
+    activeRequest;
+    onChanged;
+    pending = new Map();
+    constructor(activeRequest, onChanged) {
+        this.activeRequest = activeRequest;
+        this.onChanged = onChanged;
+    }
+    requestToolApproval(request, options) {
+        return new Promise((resolve) => {
+            if (options?.abortSignal?.aborted) {
+                resolve({ approved: false, reason: "Tool approval was cancelled." });
+                return;
+            }
+            const complete = (decision) => {
+                const removed = this.pending.delete(request.approvalId);
+                options?.abortSignal?.removeEventListener("abort", onAbort);
+                resolve(decision);
+                if (removed)
+                    this.notifyChanged(request.requestId);
+            };
+            const onAbort = () => complete({ approved: false, reason: "Tool approval was cancelled." });
+            options?.abortSignal?.addEventListener("abort", onAbort, { once: true });
+            this.pending.set(request.approvalId, {
+                requestId: request.requestId,
+                resolve: complete,
+            });
+            this.notifyChanged(request.requestId);
+        });
+    }
+    notifyChanged(requestId) {
+        try {
+            this.onChanged?.(requestId);
+        }
+        catch {
+            // Client refresh failures cannot change a pending approval decision.
+        }
+    }
+    list(environmentId) {
+        const approvals = [];
+        for (const [approvalId, pending] of this.pending) {
+            const active = this.activeRequest(pending.requestId);
+            if (!isLiveApprovalRequest(active, environmentId))
+                continue;
+            const event = findRequiredApprovalEvent(active, approvalId);
+            if (!event)
+                continue;
+            approvals.push({
+                environmentId,
+                sessionId: active.sessionId,
+                requestId: active.requestId,
+                approvalId,
+                event,
+            });
+        }
+        return approvals;
+    }
+    decide(decision) {
+        const pending = this.pending.get(decision.approvalId);
+        const active = this.activeRequest(decision.requestId);
+        if (!canResolvePendingApproval(pending, active, decision))
+            return false;
+        pending.resolve({ approved: decision.approved });
+        return true;
+    }
+    resolveRealtime(message) {
+        const approvalId = getString(message.approvalId);
+        if (!approvalId)
+            return;
+        const pending = this.pending.get(approvalId);
+        if (!pending)
+            return;
+        pending.resolve({
+            approved: message.approved === true,
+            reason: getString(message.reason).trim() || undefined,
+        });
+    }
+}

package/dist/src/web-ui/local-runtime/plugin-management-routes.d.ts

@@ -0,0 +1,14 @@
+import type { ServerResponse } from "node:http";
+export declare class PluginManagementRoutes {
+    private readonly options;
+    constructor(options: {
+        rootDir: string;
+        getConfigPath?: () => string | undefined;
+    });
+    handle(params: {
+        method: string;
+        route: string;
+        body: Record<string, unknown> | null;
+        response: ServerResponse;
+    }): Promise<boolean>;
+}

package/dist/src/web-ui/local-runtime/plugin-management-routes.js

@@ -0,0 +1,50 @@
+import { getRuntimePluginSnapshot, PluginManagementError, setRuntimePluginEnabled, } from "../plugin-management-service.js";
+import { sendJson } from "./http.js";
+export class PluginManagementRoutes {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async handle(params) {
+        if (params.route !== "runtime/plugins")
+            return false;
+        const options = {
+            rootDir: this.options.rootDir,
+            configPath: this.options.getConfigPath?.(),
+        };
+        try {
+            if (params.method === "GET") {
+                sendJson(params.response, 200, {
+                    ok: true,
+                    ...getRuntimePluginSnapshot(options),
+                });
+                return true;
+            }
+            if (params.method === "PUT") {
+                const result = await setRuntimePluginEnabled(options, params.body);
+                sendJson(params.response, 200, { ok: true, ...result });
+                return true;
+            }
+            sendJson(params.response, 405, {
+                ok: false,
+                error: "method_not_allowed",
+            });
+        }
+        catch (error) {
+            if (error instanceof PluginManagementError) {
+                sendJson(params.response, error.statusCode, {
+                    ok: false,
+                    error: error.code,
+                    message: error.message,
+                });
+                return true;
+            }
+            sendJson(params.response, 500, {
+                ok: false,
+                error: "plugin_management_failed",
+                message: "Plugin configuration could not be loaded or saved.",
+            });
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { JsonObject, RuntimeEnvironment } from "./contracts.js";
+type ProjectRouteRequest = {
+    method: string;
+    segments: readonly string[];
+    url: URL;
+    body: JsonObject | null;
+    environment: RuntimeEnvironment;
+    request: IncomingMessage;
+    response: ServerResponse;
+};
+/** Project management is an owner service; these routes only serialize it. */
+export declare class ProjectRoutes {
+    handle(request: ProjectRouteRequest): Promise<boolean>;
+    private dispatch;
+}
+export {};

package/dist/src/web-ui/local-runtime/project-routes.js

@@ -0,0 +1,93 @@
+import { acceptConfigMutationRequest } from "./config-mutation-request.js";
+import { getString, sendJson } from "./http.js";
+function isProjectCollection(segments) {
+    return segments.length === 1;
+}
+function isProjectFolderListing(segments) {
+    if (segments.length !== 2)
+        return false;
+    return segments[1] === "folders";
+}
+function isProjectSessionCreation(segments) {
+    if (segments.length !== 3)
+        return false;
+    return segments[2] === "sessions";
+}
+function isProjectMutationRequest(method) {
+    return method === "POST";
+}
+function acceptProjectRequest(request) {
+    if (!isProjectMutationRequest(request.method))
+        return true;
+    return acceptConfigMutationRequest(request.request, request.response);
+}
+function projectErrorStatus(code) {
+    if (["project_not_found", "project_directory_unavailable"].includes(code))
+        return 404;
+    if (code === "project_directory_unreadable")
+        return 403;
+    if (code === "project_folder_cursor_stale")
+        return 409;
+    if (code === "projects_unavailable")
+        return 503;
+    return 400;
+}
+function sendProjectError(response, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof Error && "code" in error
+        ? String(error.code)
+        : "project_operation_failed";
+    sendJson(response, projectErrorStatus(code), {
+        ok: false,
+        error: code,
+        message,
+    });
+}
+/** Project management is an owner service; these routes only serialize it. */
+export class ProjectRoutes {
+    async handle(request) {
+        if (request.segments[0] !== "projects")
+            return false;
+        if (!acceptProjectRequest(request))
+            return true;
+        try {
+            const service = request.environment.services.projects;
+            if (!service)
+                throw Object.assign(new Error("Projects are unavailable on this backend."), { code: "projects_unavailable" });
+            await this.dispatch(request, service);
+        }
+        catch (error) {
+            sendProjectError(request.response, error);
+        }
+        return true;
+    }
+    async dispatch(request, service) {
+        const { method, segments, body, response } = request;
+        if (method === "GET" && isProjectCollection(segments)) {
+            sendJson(response, 200, { ok: true, projects: await service.list() });
+            return;
+        }
+        if (method === "POST" && isProjectCollection(segments)) {
+            const project = await service.create({
+                directory: getString(body?.directory),
+                name: getString(body?.name),
+            });
+            sendJson(response, 201, { ok: true, project });
+            return;
+        }
+        if (method === "GET" && isProjectFolderListing(segments)) {
+            const page = await service.browseFolders({
+                path: getString(request.url.searchParams.get("path")),
+                cursor: getString(request.url.searchParams.get("cursor")),
+            });
+            sendJson(response, 200, { ok: true, ...page });
+            return;
+        }
+        if (method === "POST" && isProjectSessionCreation(segments)) {
+            const session = await service.createSession(segments[1]);
+            sendJson(response, 201, { ok: true, ...session });
+            return;
+        }
+        sendJson(response, 404, { ok: false, error: "not_found" });
+    }
+}

package/dist/src/web-ui/local-runtime/provider-credential-identity.d.ts

@@ -0,0 +1,3 @@
+/** Stable private credential binding shared by additive provider setup. */
+export declare function isolatedProviderCredentialName(providerId: string): string;
+export declare function hasProviderCredentialBinding(providers: Record<string, unknown>, apiKeyEnv: string): boolean;

package/dist/src/web-ui/local-runtime/provider-credential-identity.js

@@ -0,0 +1,18 @@
+import { createHash } from "node:crypto";
+import { isRecord } from "../../runtime/config/utils.js";
+/** Stable private credential binding shared by additive provider setup. */
+export function isolatedProviderCredentialName(providerId) {
+    const identity = createHash("sha256")
+        .update(providerId)
+        .digest("hex")
+        .slice(0, 24)
+        .toUpperCase();
+    return `ABOT_MODEL_PROVIDER_${identity}_API_KEY`;
+}
+export function hasProviderCredentialBinding(providers, apiKeyEnv) {
+    return Object.values(providers).some((provider) => {
+        if (!isRecord(provider))
+            return false;
+        return provider.apiKeyEnv === apiKeyEnv;
+    });
+}

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

@@ -8,6 +8,7 @@ export declare class LocalRealtimeController {
     private readonly environments;
     private readonly requests;
     private readonly clients;
+    private readonly approvals;
     constructor(options: LocalRuntimeBackendOptions, environments: RuntimeEnvironmentRegistry, requests: LocalRequestExecution, clients: RealtimeClientHub);
     connect(client: WebSocket): void;
     private handleMessage;

package/dist/src/web-ui/local-runtime/realtime-controller.js

@@ -1,14 +1,17 @@
 import { getNumber, getString, requestEnvironmentId } from "./http.js";
+import { ManagedWebToolApprovals } from "./managed-tool-approvals.js";
 export class LocalRealtimeController {
     options;
     environments;
     requests;
     clients;
+    approvals;
     constructor(options, environments, requests, clients) {
         this.options = options;
         this.environments = environments;
         this.requests = requests;
         this.clients = clients;
+        this.approvals = new ManagedWebToolApprovals((id) => environments.get(id), requests);
     }
     connect(client) {
         this.clients.add(client);
@@ -27,8 +30,20 @@ export class LocalRealtimeController {
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
             return;
         const message = parsed;
+        if (message.type === "notification_presence") {
+            this.clients.updatePresence(client, message);
+            return;
+        }
         if (message.type === "tool_approval_response") {
-            this.requests.resolveToolApproval(message);
+            const accepted = await this.approvals.resolveRealtime(message, this.options.defaultEnvironmentId ?? "");
+            this.clients.send(client, {
+                type: "tool_approval_ack",
+                approvalId: message.approvalId,
+                accepted,
+                environment: message.environment,
+                sessionId: message.sessionId,
+                ...(accepted ? {} : { reason: "approval_conflict_or_unavailable" }),
+            });
             return;
         }
         if (message.type === "steer_request") {
@@ -45,7 +60,11 @@ export class LocalRealtimeController {
             return;
         const environmentId = requestEnvironmentId(new URL("/", "http://localhost"), message, this.options.defaultEnvironmentId);
         const environment = this.environments.get(environmentId);
-        const replay = await environment.services.sessions.getRequestReplayById(requestId, getNumber(message.afterSeq));
+        let replay = await environment.services.sessions.getRequestReplayById(requestId, getNumber(message.afterSeq));
+        if (!replay?.finalState) {
+            await this.approvals.resume(environmentId, requestId);
+            replay = await environment.services.sessions.getRequestReplayById(requestId, getNumber(message.afterSeq));
+        }
         for (const event of replay?.events ?? []) {
             this.clients.send(client, { ...event, environment: environmentId });
         }

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

@@ -1,8 +1,16 @@
 import type WebSocket from "ws";
 import type { JsonObject } from "./contracts.js";
+import { NotificationPresence } from "../notifications/presence.js";
 export declare class RealtimeClientHub {
+    private readonly observe?;
     private readonly clients;
+    readonly presence: NotificationPresence;
+    constructor(observe?: ((payload: JsonObject) => void) | undefined);
     add(client: WebSocket): void;
     broadcast(payload: JsonObject): void;
     send(client: WebSocket, payload: JsonObject): void;
+    updatePresence(client: WebSocket, payload: JsonObject): void;
+    private canAcceptPresence;
+    private pruneNonOpenClients;
+    private remove;
 }

package/dist/src/web-ui/local-runtime/realtime-hub.js

@@ -1,18 +1,58 @@
+import { NotificationPresence } from "../notifications/presence.js";
+function isRealtimeClientOpen(client) {
+    return client.readyState === client.OPEN;
+}
 export class RealtimeClientHub {
+    observe;
     clients = new Set();
+    presence = new NotificationPresence();
+    constructor(observe) {
+        this.observe = observe;
+    }
     add(client) {
         this.clients.add(client);
-        const remove = () => this.clients.delete(client);
+        const remove = () => this.remove(client);
         client.on("close", remove);
         client.on("error", remove);
     }
     broadcast(payload) {
-        for (const client of this.clients)
-            this.send(client, payload);
+        this.pruneNonOpenClients();
+        this.observe?.(payload);
+        for (const client of this.clients) {
+            try {
+                this.send(client, payload);
+            }
+            catch {
+                this.remove(client);
+            }
+        }
     }
     send(client, payload) {
-        if (client.readyState !== client.OPEN)
+        if (!isRealtimeClientOpen(client))
             return;
         client.send(JSON.stringify(payload));
     }
+    updatePresence(client, payload) {
+        if (!this.canAcceptPresence(client)) {
+            this.presence.remove(client);
+            return;
+        }
+        this.presence.update(client, payload);
+    }
+    canAcceptPresence(client) {
+        if (!this.clients.has(client))
+            return false;
+        return isRealtimeClientOpen(client);
+    }
+    pruneNonOpenClients() {
+        for (const client of this.clients) {
+            if (isRealtimeClientOpen(client))
+                continue;
+            this.remove(client);
+        }
+    }
+    remove(client) {
+        this.clients.delete(client);
+        this.presence.remove(client);
+    }
 }

package/dist/src/web-ui/local-runtime/request-cancellation-route.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { RuntimeEnvironment } from "./contracts.js";
+export declare function cancelWebRequest(input: {
+    request: IncomingMessage;
+    response: ServerResponse;
+    body: Record<string, unknown> | null;
+    environment: RuntimeEnvironment;
+}): Promise<void>;