@abot-ai/runtime 1.3.0 → 1.4.0

package/dist/src/web-ui/app/styles/46-system-host.css

@@ -0,0 +1,132 @@
+.system-host-panel {
+  max-width: 760px;
+  padding: 12px 0;
+  font-size: var(--font-size-sm);
+  line-height: 1.6;
+}
+
+.system-host-heading,
+.system-host-actions {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+}
+
+.system-host-heading h2 {
+  margin: 0 0 6px;
+  font-size: var(--font-size-3xl);
+  font-weight: 500;
+}
+
+.system-host-heading p,
+.system-host-note {
+  color: var(--config-muted, var(--muted));
+}
+
+.system-host-heading p {
+  margin: 0;
+}
+
+.system-host-heading button {
+  flex-shrink: 0;
+}
+
+.system-host-status {
+  padding-block: 12px;
+  border-block: 1px solid var(--line);
+}
+
+.system-host-identity {
+  display: grid;
+  gap: 6px;
+  margin-block: 20px;
+}
+
+.system-host-identity > div {
+  display: grid;
+  grid-template-columns: 140px minmax(0, 1fr);
+  gap: 16px;
+}
+
+.system-host-identity dt {
+  color: var(--config-muted, var(--muted));
+}
+
+.system-host-identity dd {
+  margin: 0;
+  overflow-wrap: anywhere;
+}
+
+.system-host-download {
+  padding: 12px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  background: var(--control-bg);
+  overflow-wrap: anywhere;
+}
+
+.system-host-restart {
+  border-left: 2px solid var(--amber);
+  padding: 8px 12px;
+  color: var(--amber);
+}
+
+.system-host-actions {
+  justify-content: flex-start;
+  flex-wrap: wrap;
+  margin-top: 20px;
+}
+
+.system-host-setup-notice {
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 4px 10px;
+  width: min(100%, 860px);
+  margin-bottom: 8px;
+  padding: 7px 10px;
+  border: 1px solid var(--line);
+  border-radius: 8px;
+  color: var(--muted);
+  background: var(--control-bg);
+  font-size: var(--font-size-sm);
+  line-height: 1.5;
+}
+
+.system-host-setup-notice:not([hidden]) {
+  display: flex;
+}
+
+.system-host-setup-notice > span {
+  flex: 1 1 220px;
+}
+
+.system-host-setup-notice button {
+  padding: 2px 4px;
+  border: 0;
+  background: transparent;
+  font-size: inherit;
+  font-weight: 400;
+}
+
+.system-host-setup-link {
+  color: var(--accent);
+}
+
+.system-host-setup-dismiss {
+  color: var(--muted);
+}
+
+.messages-list[hidden] ~ .composer-dock .system-host-setup-notice {
+  display: none;
+}
+
+@media (max-width: 520px) {
+  .system-host-heading {
+    flex-direction: column;
+  }
+  .system-host-identity > div {
+    grid-template-columns: 110px minmax(0, 1fr);
+    gap: 10px;
+  }
+}

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

@@ -2,7 +2,9 @@
 @import url("./styles/00-tokens-base.css");
 @import url("./styles/10-shell-sessions.css");
 @import url("./styles/12-conversation-sidebar.css");
+@import url("./styles/13-projects.css");
 @import url("./styles/20-chat-composer.css");
+@import url("./styles/19-runtime-setup.css");
 @import url("./styles/21-composer-controls.css");
 @import url("./styles/22-composer-context-window.css");
 @import url("./styles/23-composer-plan.css");
@@ -11,14 +13,22 @@
 @import url("./styles/26-message-content.css");
 @import url("./styles/27-conversation-tools.css");
 @import url("./styles/28-conversation-status.css");
+@import url("./styles/29-conversation-file-preview.css");
 @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-runtime-setup-plugins.css");
+@import url("./styles/43-model-setup.css");
+@import url("./styles/44-model-provider-cards.css");
 @import url("./styles/35-memory-onboarding.css");
 @import url("./styles/36-memory-management.css");
 @import url("./styles/37-config-operations.css");
+@import url("./styles/37-runtime-activation.css");
 @import url("./styles/38-schedules.css");
 @import url("./styles/38-schedule-workspace.css");
 @import url("./styles/90-responsive.css");
 @import url("./styles/91-schedules-responsive.css");
 @import url("./styles/18-dashboard.css");
 @import url("./styles/92-dashboard-responsive.css");
+@import url("./styles/45-bridge-setup.css");
+@import url("./styles/46-system-host.css");

package/dist/src/web-ui/config-dashboard-backend.d.ts

@@ -1,3 +1,4 @@
+import { type ConfigFileSnapshot, type ConfigFileTransaction } from "../runtime/adapters/config-file-transaction.js";
 type JsonRecord = Record<string, unknown>;
 export type ConfigFileKind = "runtime" | "requestRunner" | "model";
 type ConfigFileDescriptor = {
@@ -6,7 +7,9 @@ type ConfigFileDescriptor = {
     label: string;
     path: string;
     exists: boolean;
+    revision: string;
     config: JsonRecord;
+    invalidJson?: ConfigFileSnapshot["invalidJson"];
     source?: {
         type: "inlineModelProfile";
         runtimeConfigPath: string;
@@ -33,6 +36,8 @@ export declare function saveConfigDashboardFile(params: {
     kind: ConfigFileKind;
     id?: string;
     config: unknown;
+    expectedRevision?: string;
+    transaction?: ConfigFileTransaction;
 }): Promise<{
     ok: true;
     file: ConfigFileDescriptor;

package/dist/src/web-ui/config-dashboard-backend.js

@@ -1,6 +1,8 @@
-import { existsSync } from "node:fs";
-import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
+import { readdir, realpath } from "node:fs/promises";
+import { assignDiscoveredModelIds } from "./config-dashboard-model-identity.js";
+import { canonicalConfigFilePath, readConfigFileSnapshot, } from "../runtime/adapters/config-file-transaction.js";
 import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
+import { withConfigDashboardRootTransaction, withConfigDashboardTargetTransaction, } from "./config-dashboard-save-transaction.js";
 import { DEFAULT_RUNTIME_CONFIG_FILE } from "../runtime/config/constants.js";
 import { REQUEST_INVOKED_STEP_IDS } from "../runtime/config/runner/contracts.js";
 import { assertSupportedRequestRunnerConfigVersion } from "../runtime/config/runner/schema-version.js";
@@ -26,26 +28,6 @@ function ensureInsideRoot(rootDir, filePath) {
         throw new Error("config file is outside the workspace root");
     }
 }
-async function readJsonObject(filePath) {
-    let raw = "";
-    try {
-        raw = await readFile(filePath, "utf-8");
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT") {
-            return {};
-        }
-        throw error;
-    }
-    const parsed = JSON.parse(raw);
-    if (!isRecord(parsed)) {
-        throw new Error(`Invalid JSON object at ${filePath}`);
-    }
-    return parsed;
-}
 function modelRefsFromRuntimeConfig(params) {
     const { mainConfigPath, runtimeConfig } = params;
     const models = isRecord(runtimeConfig.models) ? runtimeConfig.models : {};
@@ -117,7 +99,7 @@ async function discoverModelRefs(params) {
     }
     return [
         ...configured,
-        ...discovered.sort((left, right) => left.id.localeCompare(right.id)),
+        ...assignDiscoveredModelIds(configured.map(({ id }) => id), discovered),
     ];
 }
 function configRefFrom(value) {
@@ -128,47 +110,28 @@ function configRefFrom(value) {
 }
 async function readDescriptor(params) {
     ensureInsideRoot(params.rootDir, params.path);
+    const path = await canonicalConfigFilePath(params.path);
+    ensureInsideRoot(await realpath(params.rootDir), path);
+    const snapshot = params.snapshot ??
+        (await readConfigFileSnapshot(path, {
+            allowMalformedJson: params.kind !== "runtime",
+        }));
     return {
         kind: params.kind,
         id: params.id,
         label: params.label,
         path: safeRelativePath(params.rootDir, params.path),
-        exists: existsSync(params.path),
-        config: params.config ?? (await readJsonObject(params.path)),
+        exists: snapshot.exists,
+        revision: snapshot.revision,
+        config: params.config ?? snapshot.config,
+        ...(snapshot.invalidJson ? { invalidJson: snapshot.invalidJson } : {}),
         ...(params.source ? { source: params.source } : {}),
     };
 }
-function backupPathFor(filePath) {
-    const stamp = new Date()
-        .toISOString()
-        .replace(/[-:]/g, "")
-        .replace(/\.\d{3}Z$/, "Z");
-    return `${filePath}.${stamp}.bak`;
-}
-async function writeJsonObject(filePath, config) {
-    await mkdir(dirname(filePath), { recursive: true });
-    let backupPath;
-    try {
-        const current = await readFile(filePath, "utf-8");
-        backupPath = backupPathFor(filePath);
-        await writeFile(backupPath, current, "utf-8");
-    }
-    catch (error) {
-        if (!(error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT")) {
-            throw error;
-        }
-    }
-    const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-    await writeFile(tempPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
-    await rename(tempPath, filePath);
-    return backupPath ? { backupPath } : {};
-}
 export async function getConfigDashboardSnapshot(params) {
     const mainConfigPath = resolveMainConfigPath(params.rootDir, params.configPath);
-    const runtimeConfig = await readJsonObject(mainConfigPath);
+    const runtimeSnapshot = await readConfigFileSnapshot(mainConfigPath);
+    const runtimeConfig = runtimeSnapshot.config;
     const configDir = dirname(mainConfigPath);
     const requestRunnerRef = configRefFrom(runtimeConfig.requestRunner);
     const requestRunnerPath = requestRunnerRef
@@ -198,6 +161,7 @@ export async function getConfigDashboardSnapshot(params) {
                 id: "runtime",
                 label: "Runtime",
                 path: mainConfigPath,
+                snapshot: runtimeSnapshot,
             }),
             requestRunner,
             models: await Promise.all(modelRefs.map((model) => readDescriptor({
@@ -206,79 +170,95 @@ export async function getConfigDashboardSnapshot(params) {
                 id: model.id,
                 label: basename(model.path).replace(/\.json$/u, ""),
                 path: resolveRefPath(mainConfigPath, model.path),
-                ...(model.inlineConfig ? { config: model.inlineConfig } : {}),
+                ...(model.inlineConfig
+                    ? { config: model.inlineConfig, snapshot: runtimeSnapshot }
+                    : {}),
                 ...(model.source ? { source: model.source } : {}),
             }))),
         },
     };
 }
+function selectConfigDashboardTarget(snapshot, kind, id) {
+    if (kind === "runtime")
+        return snapshot.files.runtime;
+    if (kind === "requestRunner")
+        return snapshot.files.requestRunner;
+    return snapshot.files.models.find((model) => model.id === id);
+}
+function validateDashboardRequestRunnerCandidate(kind, snapshot, candidate, filePath) {
+    if (kind !== "requestRunner")
+        return;
+    if (snapshot.exists && !snapshot.invalidJson)
+        assertSupportedRequestRunnerConfigVersion(snapshot.config, filePath);
+    parseRequestRunnerConfig(candidate, filePath);
+}
 export async function saveConfigDashboardFile(params) {
     if (!isRecord(params.config)) {
         throw new Error("config must be a JSON object");
     }
-    const snapshot = await getConfigDashboardSnapshot({
-        rootDir: params.rootDir,
-        configPath: params.configPath,
-    });
-    const target = params.kind === "runtime"
-        ? snapshot.files.runtime
-        : params.kind === "requestRunner"
-            ? snapshot.files.requestRunner
-            : snapshot.files.models.find((model) => model.id === params.id);
-    if (!target) {
-        throw new Error("config file target was not found");
-    }
-    const filePath = resolve(params.rootDir, target.path);
-    if (target.source?.type === "inlineModelProfile") {
-        const runtimeConfigPath = target.source.runtimeConfigPath;
-        ensureInsideRoot(params.rootDir, runtimeConfigPath);
-        const runtimeConfig = await readJsonObject(runtimeConfigPath);
-        const models = isRecord(runtimeConfig.models) ? runtimeConfig.models : {};
-        const profiles = isRecord(models.profiles) ? models.profiles : {};
-        runtimeConfig.models = {
-            ...models,
-            profiles: {
-                ...profiles,
-                [target.source.profileId]: params.config,
-            },
-        };
-        const result = await writeJsonObject(runtimeConfigPath, runtimeConfig);
-        const nextSnapshot = await getConfigDashboardSnapshot({
+    const mainConfigPath = resolveMainConfigPath(params.rootDir, params.configPath);
+    ensureInsideRoot(params.rootDir, mainConfigPath);
+    const runtimePath = await canonicalConfigFilePath(mainConfigPath);
+    ensureInsideRoot(await realpath(params.rootDir), runtimePath);
+    return withConfigDashboardRootTransaction(runtimePath, params.transaction, async (rootTransaction) => {
+        const snapshot = await getConfigDashboardSnapshot({
             rootDir: params.rootDir,
             configPath: params.configPath,
         });
-        const file = nextSnapshot.files.models.find((model) => model.id === target.id);
-        if (!file) {
-            throw new Error("inline model profile was not found after save");
+        const target = selectConfigDashboardTarget(snapshot, params.kind, params.id);
+        if (!target) {
+            throw new Error("config file target was not found");
         }
-        return {
-            ok: true,
-            file,
-            ...(result.backupPath
-                ? { backupPath: safeRelativePath(params.rootDir, result.backupPath) }
-                : {}),
+        const filePath = await canonicalConfigFilePath(resolve(params.rootDir, target.path));
+        ensureInsideRoot(await realpath(params.rootDir), filePath);
+        const save = async (transaction) => {
+            if (transaction.path !== filePath)
+                throw new Error("Configuration transaction target does not match.");
+            if (!isRecord(params.config))
+                throw new Error("config must be a JSON object");
+            let candidate = params.config;
+            if (target.source?.type === "inlineModelProfile") {
+                const runtimeConfig = transaction.snapshot.config;
+                const models = isRecord(runtimeConfig.models)
+                    ? runtimeConfig.models
+                    : {};
+                const profiles = isRecord(models.profiles) ? models.profiles : {};
+                candidate = {
+                    ...runtimeConfig,
+                    models: {
+                        ...models,
+                        profiles: {
+                            ...profiles,
+                            [target.source.profileId]: params.config,
+                        },
+                    },
+                };
+            }
+            validateDashboardRequestRunnerCandidate(target.kind, transaction.snapshot, candidate, filePath);
+            const result = await transaction.write(candidate, {
+                expectedRevision: params.expectedRevision,
+            });
+            const file = await readDescriptor({
+                rootDir: params.rootDir,
+                kind: target.kind,
+                id: target.id,
+                label: target.label,
+                path: filePath,
+                snapshot: transaction.snapshot,
+                ...(target.source
+                    ? { source: target.source, config: params.config }
+                    : {}),
+            });
+            return {
+                ok: true,
+                file,
+                ...(result.backupPath
+                    ? {
+                        backupPath: safeRelativePath(params.rootDir, result.backupPath),
+                    }
+                    : {}),
+            };
         };
-    }
-    ensureInsideRoot(params.rootDir, filePath);
-    if (target.kind === "requestRunner") {
-        if (target.exists) {
-            assertSupportedRequestRunnerConfigVersion(target.config, filePath);
-        }
-        parseRequestRunnerConfig(params.config, filePath);
-    }
-    const result = await writeJsonObject(filePath, params.config);
-    const file = await readDescriptor({
-        rootDir: params.rootDir,
-        kind: target.kind,
-        id: target.id,
-        label: target.label,
-        path: filePath,
+        return withConfigDashboardTargetTransaction(rootTransaction, filePath, save);
     });
-    return {
-        ok: true,
-        file,
-        ...(result.backupPath
-            ? { backupPath: safeRelativePath(params.rootDir, result.backupPath) }
-            : {}),
-    };
 }

package/dist/src/web-ui/config-dashboard-model-identity.d.ts

@@ -0,0 +1,7 @@
+type DiscoveredModelIdentity = {
+    id: string;
+    path: string;
+};
+/** Dashboard-only file identities never rename configured Runtime profiles. */
+export declare function assignDiscoveredModelIds<T extends DiscoveredModelIdentity>(configuredIds: readonly string[], discovered: readonly T[]): T[];
+export {};

package/dist/src/web-ui/config-dashboard-model-identity.js

@@ -0,0 +1,45 @@
+import { sep } from "node:path";
+function canPreserveDiscoveredModelId(id, counts, configuredIds) {
+    if (!id)
+        return false;
+    if (id.trim() !== id)
+        return false;
+    if (counts.get(id) !== 1)
+        return false;
+    return !configuredIds.has(id);
+}
+function availableModelPathId(path, reserved) {
+    const encodedPath = path.split(sep).map(encodeURIComponent).join("/");
+    let id = `file:${encodedPath}`;
+    while (reserved.has(id))
+        id = `file:${id}`;
+    return id;
+}
+function compareDiscoveredModelIds(left, right) {
+    if (left.id < right.id)
+        return -1;
+    if (left.id > right.id)
+        return 1;
+    return 0;
+}
+/** Dashboard-only file identities never rename configured Runtime profiles. */
+export function assignDiscoveredModelIds(configuredIds, discovered) {
+    const configured = new Set(configuredIds);
+    const counts = new Map();
+    for (const { id } of discovered)
+        counts.set(id, (counts.get(id) ?? 0) + 1);
+    const preserved = new Set(discovered
+        .filter(({ id }) => canPreserveDiscoveredModelId(id, counts, configured))
+        .map(({ id }) => id));
+    // Reserve all ordinary names first, independent of filesystem iteration order.
+    const reserved = new Set([...configured, ...preserved]);
+    return discovered
+        .map((ref) => {
+        if (preserved.has(ref.id))
+            return ref;
+        const id = availableModelPathId(ref.path, reserved);
+        reserved.add(id);
+        return { ...ref, id };
+    })
+        .sort(compareDiscoveredModelIds);
+}

package/dist/src/web-ui/config-dashboard-save-transaction.d.ts

@@ -0,0 +1,5 @@
+import { type ConfigFileTransaction } from "../runtime/adapters/config-file-transaction.js";
+/** Resolve linked targets only while holding their canonical Runtime lock. */
+export declare function withConfigDashboardRootTransaction<T>(runtimePath: string, transaction: ConfigFileTransaction | undefined, operation: (root: ConfigFileTransaction) => Promise<T>): Promise<T>;
+/** The Runtime lock is always first; aliases of that same file reuse it. */
+export declare function withConfigDashboardTargetTransaction<T>(root: ConfigFileTransaction, targetPath: string, operation: (target: ConfigFileTransaction) => Promise<T>): Promise<T>;

package/dist/src/web-ui/config-dashboard-save-transaction.js

@@ -0,0 +1,21 @@
+import { withConfigFileTransaction, } from "../runtime/adapters/config-file-transaction.js";
+function requireRuntimeTransaction(transaction, runtimePath) {
+    if (transaction.path !== runtimePath)
+        throw new Error("Runtime configuration transaction target does not match.");
+}
+/** Resolve linked targets only while holding their canonical Runtime lock. */
+export async function withConfigDashboardRootTransaction(runtimePath, transaction, operation) {
+    if (!transaction)
+        return withConfigFileTransaction(runtimePath, operation);
+    // Never acquire a root lock while a caller is holding a child-only lock.
+    requireRuntimeTransaction(transaction, runtimePath);
+    return operation(transaction);
+}
+/** The Runtime lock is always first; aliases of that same file reuse it. */
+export async function withConfigDashboardTargetTransaction(root, targetPath, operation) {
+    if (targetPath === root.path)
+        return operation(root);
+    return withConfigFileTransaction(targetPath, operation, {
+        allowMalformedJson: true,
+    });
+}

package/dist/src/web-ui/environment-config.d.ts

@@ -0,0 +1,17 @@
+export type WebUiEnvironmentOption = {
+    id: string;
+    label: string;
+    isDefault: boolean;
+};
+export type WebUiEnvironmentConfig = {
+    defaultEnvironmentId: string;
+    environments: WebUiEnvironmentOption[];
+};
+export declare function resolveWebUiEnvironmentConfig(params: {
+    rootDir: string;
+    configPath?: string;
+    defaultEnvironmentId?: string;
+}): {
+    defaultEnvironmentId: string;
+    environments: WebUiEnvironmentOption[];
+};

package/dist/src/web-ui/environment-config.js

@@ -0,0 +1,60 @@
+import { inspectRuntimeConfigFileWithMeta } from "../runtime/config/loader.js";
+const DEFAULT_ENVIRONMENT_ID = "prod";
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function getConfigString(value, key) {
+    if (!isRecord(value))
+        return "";
+    const raw = value[key];
+    return typeof raw === "string" ? raw.trim() : "";
+}
+export function resolveWebUiEnvironmentConfig(params) {
+    const overrideDefault = params.defaultEnvironmentId?.trim() ?? "";
+    const fallbackDefault = overrideDefault || DEFAULT_ENVIRONMENT_ID;
+    const fallback = {
+        defaultEnvironmentId: fallbackDefault,
+        environments: [
+            {
+                id: fallbackDefault,
+                label: fallbackDefault,
+                isDefault: true,
+            },
+        ],
+    };
+    let config;
+    try {
+        config = inspectRuntimeConfigFileWithMeta(params.rootDir, params.configPath).config;
+    }
+    catch {
+        // Runtime configuration errors belong to the backend catalog response so
+        // the Web UI can start and present the actionable setup error.
+        return fallback;
+    }
+    const environment = isRecord(config.environment)
+        ? config.environment
+        : undefined;
+    const profiles = isRecord(environment?.profiles)
+        ? environment.profiles
+        : undefined;
+    const profileIds = profiles
+        ? Object.keys(profiles).filter((id) => id.trim().length > 0)
+        : [];
+    const configuredDefault = getConfigString(environment, "default");
+    const defaultEnvironmentId = overrideDefault ||
+        configuredDefault ||
+        profileIds[0] ||
+        DEFAULT_ENVIRONMENT_ID;
+    const environmentIds = profileIds.length > 0 ? [...profileIds] : [defaultEnvironmentId];
+    if (!environmentIds.includes(defaultEnvironmentId)) {
+        environmentIds.unshift(defaultEnvironmentId);
+    }
+    return {
+        defaultEnvironmentId,
+        environments: environmentIds.map((id) => ({
+            id,
+            label: id,
+            isDefault: id === defaultEnvironmentId,
+        })),
+    };
+}

package/dist/src/web-ui/forwarded-loopback-policy.d.ts

@@ -0,0 +1,2 @@
+/** Only the deployment owner can assert that Docker publishes exclusively on loopback. */
+export declare function allowsPublishedLoopbackAuthority(listenHost: string): boolean;

package/dist/src/web-ui/forwarded-loopback-policy.js

@@ -0,0 +1,14 @@
+import { observeSystemHost, readSystemHostFacts, } from "../../plugins/system/source/host-observation.js";
+function hasExplicitLoopbackPublishTrust() {
+    return process.env.ABOT_WEB_TRUST_LOOPBACK_PUBLISH === "1";
+}
+/** Only the deployment owner can assert that Docker publishes exclusively on loopback. */
+export function allowsPublishedLoopbackAuthority(listenHost) {
+    if (!hasExplicitLoopbackPublishTrust())
+        return false;
+    const wildcardListener = ["0.0.0.0", "::", "[::]", "*"].includes(listenHost.trim().toLowerCase());
+    if (!wildcardListener)
+        return false;
+    const observed = observeSystemHost(readSystemHostFacts());
+    return observed.environment === "container";
+}

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

@@ -6,13 +6,20 @@ export declare class LocalRuntimeApiRouter {
     private readonly options;
     private readonly environments;
     private readonly requests;
+    private readonly conversationFiles;
     private readonly attachments;
+    private readonly setup;
+    private readonly modelSetup;
+    private readonly setupEmbedding;
+    private readonly plugins;
     private readonly memoryManagement;
     private readonly memoryOnboarding;
     private readonly schedules;
     private readonly readStates;
     private readonly sessions;
+    private readonly projects;
     constructor(options: ResolvedLocalRuntimeBackendOptions, environments: RuntimeEnvironmentRegistry, requests: LocalRequestExecution);
+    private applyWhenRequestsIdle;
     initializeSessionReadState(environmentIds: readonly string[]): Promise<void>;
     handle(req: IncomingMessage, res: ServerResponse): Promise<void>;
 }