@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/web-ui/link-preview/metadata.d.ts

@@ -0,0 +1,9 @@
+import type { PublicHttpResponse } from "../../shared/public-http/public-http.js";
+export type LinkPreview = Readonly<{
+    url: string;
+    title: string;
+    description: string;
+    imageUrl: string;
+    siteName: string;
+}>;
+export declare function readLinkPreviewMetadata(response: PublicHttpResponse): LinkPreview;

package/dist/src/web-ui/link-preview/metadata.js

@@ -0,0 +1,97 @@
+import { Parser } from "htmlparser2";
+import { parsePublicHttpUrl } from "../../shared/public-http/network-policy.js";
+const METADATA_KEYS = new Set([
+    "og:title",
+    "og:description",
+    "og:image",
+    "og:site_name",
+    "twitter:title",
+    "twitter:description",
+    "twitter:image",
+    "description",
+]);
+function boundedText(value, maxChars) {
+    return value.replace(/\s+/gu, " ").trim().slice(0, maxChars);
+}
+function firstMetadata(values, keys) {
+    for (const key of keys) {
+        const value = values.get(key);
+        if (value?.trim())
+            return value;
+    }
+    return "";
+}
+function resolvePreviewImage(raw, pageUrl) {
+    if (!raw.trim())
+        return "";
+    if (raw.length > 4_096)
+        return "";
+    try {
+        return parsePublicHttpUrl(new URL(raw, pageUrl).toString()).toString();
+    }
+    catch {
+        return "";
+    }
+}
+function decodePage(response) {
+    const contentType = response.headers["content-type"] ?? "";
+    const charset = /charset\s*=\s*["']?([^\s;"']+)/iu.exec(contentType)?.[1] ?? "utf-8";
+    try {
+        return new TextDecoder(charset).decode(response.body);
+    }
+    catch {
+        return new TextDecoder().decode(response.body);
+    }
+}
+export function readLinkPreviewMetadata(response) {
+    const values = new Map();
+    let title = "";
+    let insideTitle = false;
+    let headFinished = false;
+    const parser = new Parser({
+        onopentag(name, attributes) {
+            if (name === "body")
+                headFinished = true;
+            if (headFinished)
+                return;
+            if (name === "title")
+                insideTitle = true;
+            if (name !== "meta")
+                return;
+            const key = (attributes.property ||
+                attributes.name ||
+                "").toLowerCase();
+            if (!METADATA_KEYS.has(key))
+                return;
+            if (values.has(key))
+                return;
+            values.set(key, (attributes.content ?? "").slice(0, 4_096));
+        },
+        ontext(text) {
+            if (!insideTitle)
+                return;
+            if (headFinished)
+                return;
+            title = (title + text).slice(0, 1_024);
+        },
+        onclosetag(name) {
+            if (name === "title")
+                insideTitle = false;
+            if (name === "head")
+                headFinished = true;
+        },
+    }, { decodeEntities: true });
+    parser.end(decodePage(response));
+    const hostname = new URL(response.finalUrl).hostname;
+    return Object.freeze({
+        url: response.finalUrl,
+        title: boundedText(firstMetadata(values, ["og:title", "twitter:title"]) || title, 200) || hostname,
+        description: boundedText(firstMetadata(values, [
+            "og:description",
+            "twitter:description",
+            "description",
+        ]), 320),
+        imageUrl: resolvePreviewImage(firstMetadata(values, ["og:image", "twitter:image"]), response.finalUrl),
+        siteName: boundedText(firstMetadata(values, ["og:site_name"]), 80) || hostname,
+    });
+}

package/dist/src/web-ui/link-preview/preview-cache.d.ts

@@ -0,0 +1,4 @@
+export declare function createPreviewCache<Value>(maxEntries: number, now?: () => number): Readonly<{
+    get(key: string): Value | undefined;
+    set(key: string, value: Value, ttlMs: number): void;
+}>;

package/dist/src/web-ui/link-preview/preview-cache.js

@@ -0,0 +1,23 @@
+export function createPreviewCache(maxEntries, now = Date.now) {
+    const entries = new Map();
+    const discardExpired = () => {
+        for (const [key, entry] of entries) {
+            if (entry.expiresAt <= now())
+                entries.delete(key);
+        }
+    };
+    return Object.freeze({
+        get(key) {
+            discardExpired();
+            return entries.get(key)?.value;
+        },
+        set(key, value, ttlMs) {
+            discardExpired();
+            entries.delete(key);
+            entries.set(key, { value, expiresAt: now() + ttlMs });
+            while (entries.size > maxEntries) {
+                entries.delete(entries.keys().next().value);
+            }
+        },
+    });
+}

package/dist/src/web-ui/link-preview/raster-response.d.ts

@@ -0,0 +1,9 @@
+import type { PublicHttpResponse } from "../../shared/public-http/public-http.js";
+export type PreviewImage = Readonly<{
+    contentType: string;
+    body: Uint8Array;
+}>;
+export declare function previewMediaType(response: PublicHttpResponse): string;
+export declare function isSuccessfulPreviewResponse(response: PublicHttpResponse): boolean;
+export declare function isHtmlPreviewResponse(response: PublicHttpResponse): boolean;
+export declare function readPreviewRaster(response: PublicHttpResponse): PreviewImage | null;

package/dist/src/web-ui/link-preview/raster-response.js

@@ -0,0 +1,49 @@
+export function previewMediaType(response) {
+    return (response.headers["content-type"] ?? "")
+        .split(";", 1)[0]
+        .trim()
+        .toLowerCase();
+}
+export function isSuccessfulPreviewResponse(response) {
+    if (response.status < 200)
+        return false;
+    if (response.status >= 300)
+        return false;
+    const encoding = response.headers["content-encoding"];
+    if (!encoding)
+        return true;
+    return encoding.toLowerCase() === "identity";
+}
+export function isHtmlPreviewResponse(response) {
+    const type = previewMediaType(response);
+    return type === "text/html" || type === "application/xhtml+xml";
+}
+function hasRasterSignature(type, bytes) {
+    if (type === "image/png") {
+        return bytes
+            .subarray(0, 8)
+            .equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]));
+    }
+    if (type === "image/jpeg") {
+        return bytes.subarray(0, 3).equals(Buffer.from([255, 216, 255]));
+    }
+    if (type === "image/gif") {
+        return ["GIF87a", "GIF89a"].includes(bytes.subarray(0, 6).toString("ascii"));
+    }
+    if (type !== "image/webp")
+        return false;
+    if (bytes.subarray(0, 4).toString("ascii") !== "RIFF")
+        return false;
+    return bytes.subarray(8, 12).toString("ascii") === "WEBP";
+}
+export function readPreviewRaster(response) {
+    if (!isSuccessfulPreviewResponse(response))
+        return null;
+    if (response.partialContent)
+        return null;
+    const contentType = previewMediaType(response);
+    const body = Buffer.from(response.body);
+    if (!hasRasterSignature(contentType, body))
+        return null;
+    return Object.freeze({ contentType, body });
+}

package/dist/src/web-ui/link-preview/routes.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type LinkPreviewService } from "./service.js";
+export declare function createLinkPreviewRouteHandler(service?: LinkPreviewService): (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;

package/dist/src/web-ui/link-preview/routes.js

@@ -0,0 +1,97 @@
+import { createLinkPreviewService, } from "./service.js";
+function isMatchingPreviewOrigin(rawOrigin, request) {
+    const host = request.headers.host;
+    if (!host)
+        return false;
+    try {
+        const origin = new URL(rawOrigin);
+        const protocol = "encrypted" in request.socket ? "https:" : "http:";
+        if (origin.protocol !== protocol)
+            return false;
+        return origin.host === host;
+    }
+    catch {
+        return false;
+    }
+}
+function isSameOriginPreviewRequest(request) {
+    const fetchSite = request.headers["sec-fetch-site"];
+    if (fetchSite === "same-origin")
+        return true;
+    if (fetchSite)
+        return false;
+    const origin = request.headers.origin;
+    if (origin)
+        return isMatchingPreviewOrigin(origin, request);
+    const referer = request.headers.referer;
+    if (referer)
+        return isMatchingPreviewOrigin(referer, request);
+    return false;
+}
+function sendUnavailable(response, status = 200) {
+    response.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+        "x-content-type-options": "nosniff",
+    });
+    response.end(JSON.stringify({ ok: false, error: "preview_unavailable" }));
+}
+function isExplicitMetadataRequest(request) {
+    return request.headers["x-abot-link-preview"] === "1";
+}
+async function servePreviewMetadata(request, response, url, service) {
+    if (!isExplicitMetadataRequest(request)) {
+        sendUnavailable(response, 403);
+        return;
+    }
+    const preview = await service.getPreview(url.searchParams.get("url") ?? "");
+    if (!preview) {
+        sendUnavailable(response);
+        return;
+    }
+    response.writeHead(200, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+        "x-content-type-options": "nosniff",
+    });
+    response.end(JSON.stringify({ ok: true, preview }));
+}
+async function servePreviewImage(response, url, service) {
+    const image = await service.getImage(url.searchParams.get("id") ?? "");
+    if (!image) {
+        sendUnavailable(response, 404);
+        return;
+    }
+    response.writeHead(200, {
+        "content-type": image.contentType,
+        "content-length": image.body.byteLength,
+        "cache-control": "private, max-age=300",
+        "x-content-type-options": "nosniff",
+        "content-security-policy": "default-src 'none'; sandbox",
+        "cross-origin-resource-policy": "same-origin",
+    });
+    response.end(image.body);
+}
+export function createLinkPreviewRouteHandler(service = createLinkPreviewService()) {
+    return async (request, response) => {
+        const url = new URL(request.url || "/", "http://localhost");
+        const isMetadataRoute = url.pathname === "/web-link-preview";
+        const isImageRoute = url.pathname === "/web-link-preview/image";
+        if (!isMetadataRoute && !isImageRoute)
+            return false;
+        if (request.method !== "GET") {
+            sendUnavailable(response, 405);
+            return true;
+        }
+        if (!isSameOriginPreviewRequest(request)) {
+            sendUnavailable(response, 403);
+            return true;
+        }
+        if (isMetadataRoute) {
+            await servePreviewMetadata(request, response, url, service);
+            return true;
+        }
+        await servePreviewImage(response, url, service);
+        return true;
+    };
+}

package/dist/src/web-ui/link-preview/service.d.ts

@@ -0,0 +1,11 @@
+import { type PublicHttpClient } from "../../shared/public-http/public-http.js";
+import { type LinkPreview } from "./metadata.js";
+import { type PreviewImage } from "./raster-response.js";
+export type LinkPreviewService = Readonly<{
+    getPreview(rawUrl: string): Promise<LinkPreview | null>;
+    getImage(id: string): Promise<PreviewImage | null>;
+}>;
+export declare function createLinkPreviewService(dependencies?: {
+    httpClient?: PublicHttpClient;
+    now?: () => number;
+}): LinkPreviewService;

package/dist/src/web-ui/link-preview/service.js

@@ -0,0 +1,117 @@
+import { randomUUID } from "node:crypto";
+import { parsePublicHttpUrl } from "../../shared/public-http/network-policy.js";
+import { createPublicHttpClient, } from "../../shared/public-http/public-http.js";
+import { readLinkPreviewMetadata } from "./metadata.js";
+import { createPreviewCache } from "./preview-cache.js";
+import { isHtmlPreviewResponse, isSuccessfulPreviewResponse, readPreviewRaster, } from "./raster-response.js";
+const PREVIEW_TTL_MS = 5 * 60_000;
+const UNAVAILABLE_TTL_MS = 60_000;
+const MAX_PREVIEW_REQUESTS = 8;
+function normalizePreviewUrl(rawUrl) {
+    if (/[\s\p{Cc}]/u.test(rawUrl))
+        throw new Error("Preview URL contains whitespace or controls");
+    if (rawUrl.length > 4_096)
+        throw new Error("Preview URL too long");
+    const url = parsePublicHttpUrl(rawUrl);
+    url.hash = "";
+    return url.toString();
+}
+export function createLinkPreviewService(dependencies = {}) {
+    const client = dependencies.httpClient ?? createPublicHttpClient();
+    const now = dependencies.now ?? Date.now;
+    const previews = createPreviewCache(64, now);
+    const imageSources = createPreviewCache(64, now);
+    const images = createPreviewCache(32, now);
+    let activeRequests = 0;
+    const fetchPreviewResource = async (url, maxBytes) => {
+        if (activeRequests >= MAX_PREVIEW_REQUESTS)
+            return null;
+        activeRequests += 1;
+        try {
+            return await client.get({
+                url,
+                maxBytes,
+                maxRedirects: 3,
+                timeoutMs: 8_000,
+                headers: {
+                    Accept: "text/html,application/xhtml+xml,image/png,image/jpeg,image/gif,image/webp",
+                    "Accept-Encoding": "identity",
+                    "User-Agent": "abot-runtime-link-preview/1.0",
+                },
+            });
+        }
+        finally {
+            activeRequests -= 1;
+        }
+    };
+    const registerImage = (url, image) => {
+        const id = randomUUID();
+        imageSources.set(id, url, PREVIEW_TTL_MS);
+        if (image)
+            images.set(id, Promise.resolve(image), PREVIEW_TTL_MS);
+        return `/web-link-preview/image?id=${id}`;
+    };
+    const loadPreview = async (url) => {
+        const response = await fetchPreviewResource(url, 512 * 1024);
+        if (!response)
+            return null;
+        if (!isSuccessfulPreviewResponse(response))
+            return null;
+        const directImage = readPreviewRaster(response);
+        if (directImage) {
+            const hostname = new URL(response.finalUrl).hostname;
+            return Object.freeze({
+                url: response.finalUrl,
+                title: hostname,
+                description: "",
+                siteName: hostname,
+                imageUrl: registerImage(response.finalUrl, directImage),
+            });
+        }
+        if (!isHtmlPreviewResponse(response))
+            return null;
+        const preview = readLinkPreviewMetadata(response);
+        return Object.freeze({
+            ...preview,
+            imageUrl: preview.imageUrl ? registerImage(preview.imageUrl) : "",
+        });
+    };
+    const loadImage = async (url) => {
+        const response = await fetchPreviewResource(url, 1024 * 1024);
+        if (!response)
+            return null;
+        return readPreviewRaster(response);
+    };
+    return Object.freeze({
+        async getPreview(rawUrl) {
+            let url;
+            try {
+                url = normalizePreviewUrl(rawUrl);
+            }
+            catch {
+                return null;
+            }
+            const cached = previews.get(url);
+            if (cached)
+                return await cached;
+            const pending = loadPreview(url).catch(() => null);
+            previews.set(url, pending, PREVIEW_TTL_MS);
+            const preview = await pending;
+            previews.set(url, pending, preview ? PREVIEW_TTL_MS : UNAVAILABLE_TTL_MS);
+            return preview;
+        },
+        async getImage(id) {
+            const url = imageSources.get(id);
+            if (!url)
+                return null;
+            const cached = images.get(id);
+            if (cached)
+                return await cached;
+            const pending = loadImage(url).catch(() => null);
+            images.set(id, pending, PREVIEW_TTL_MS);
+            const image = await pending;
+            images.set(id, pending, image ? PREVIEW_TTL_MS : UNAVAILABLE_TTL_MS);
+            return image;
+        },
+    });
+}

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

@@ -9,7 +9,10 @@ export declare class LocalRuntimeApiRouter {
     private readonly attachments;
     private readonly memoryManagement;
     private readonly memoryOnboarding;
+    private readonly schedules;
+    private readonly readStates;
+    private readonly sessions;
     constructor(options: ResolvedLocalRuntimeBackendOptions, environments: RuntimeEnvironmentRegistry, requests: LocalRequestExecution);
+    initializeSessionReadState(environmentIds: readonly string[]): Promise<void>;
     handle(req: IncomingMessage, res: ServerResponse): Promise<void>;
-    private readState;
 }

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

@@ -1,11 +1,14 @@
+import { WebSessionRoutes } from "./session-routes.js";
+import { WebSessionReadStates } from "../session-read-state/service.js";
 import { getRuntimeConfig, getRuntimeConfigSchema, } from "../../runtime/admin/config-control.js";
 import { getRuntimeStatus, tailRuntimeLog, } from "../../runtime/admin/system-control.js";
 import { getConfigDashboardSnapshot, saveConfigDashboardFile, } from "../config-dashboard-backend.js";
-import { deleteSessionAttachmentsIfSupported, LocalAttachmentRoutes, } from "./attachment-routes.js";
+import { LocalAttachmentRoutes } from "./attachment-routes.js";
 import { createLocalLongTermMemoryOnboardingService } from "../../runtime/adapters/long-term-memory/onboarding-service.js";
 import { getString, pathSegments, readBody, readConfigFileKind, readJsonBody, requestEnvironmentId, sendJson, } from "./http.js";
 import { LongTermMemoryManagementRoutes } from "./memory-management-routes.js";
 import { LongTermMemoryOnboardingRoutes } from "./memory-onboarding-routes.js";
+import { ScheduleManagementRoutes } from "./schedule-management-routes.js";
 function sendRuntimeSetupRequired(res, availability) {
     sendJson(res, 409, {
         ok: false,
@@ -21,10 +24,16 @@ export class LocalRuntimeApiRouter {
     attachments = new LocalAttachmentRoutes();
     memoryManagement;
     memoryOnboarding;
+    schedules;
+    readStates;
+    sessions;
     constructor(options, environments, requests) {
         this.options = options;
         this.environments = environments;
         this.requests = requests;
+        this.readStates = new WebSessionReadStates((id) => this.environments.get(id));
+        this.sessions = new WebSessionRoutes(this.readStates);
+        this.schedules = new ScheduleManagementRoutes((id) => this.environments.get(id));
         this.memoryOnboarding = new LongTermMemoryOnboardingRoutes(createLocalLongTermMemoryOnboardingService({
             rootDir: options.rootDir ?? process.cwd(),
             providerAdapters: options.providerAdapters,
@@ -32,6 +41,18 @@ export class LocalRuntimeApiRouter {
         }));
         this.memoryManagement = new LongTermMemoryManagementRoutes((environmentId) => this.environments.get(environmentId).services.longTermMemory);
     }
+    async initializeSessionReadState(environmentIds) {
+        for (const id of environmentIds) {
+            try {
+                if (this.environments.setupRequirement(id))
+                    continue;
+                await this.readStates.initialize(id);
+            }
+            catch (error) {
+                console.error(`Web UI read state unavailable for environment ${id}:`, error);
+            }
+        }
+    }
     async handle(req, res) {
         const url = new URL(req.url || "/", "http://localhost");
         const pathname = url.pathname.slice("/web-api".length) || "/";
@@ -63,6 +84,18 @@ export class LocalRuntimeApiRouter {
             ? null
             : readJsonBody(await readBody(req));
         const environmentId = requestEnvironmentId(url, body, this.options.defaultEnvironmentId);
+        if (segments[0] === "schedules")
+            await this.initializeSessionReadState([environmentId]);
+        if (await this.schedules.handle({
+            method,
+            segments,
+            url,
+            body,
+            environmentId,
+            response: res,
+        })) {
+            return;
+        }
         if (await this.memoryOnboarding.handle({
             method,
             route,
@@ -136,71 +169,15 @@ export class LocalRuntimeApiRouter {
             }
         }
         const environment = this.environments.get(environmentId);
-        if (method === "GET" && route === "chat/sessions") {
-            const result = await environment.services.sessions.listSessions();
-            sendJson(res, 200, { ok: true, ...result });
-            return;
-        }
-        if (method === "GET" &&
-            segments[0] === "chat" &&
-            segments[1] === "sessions" &&
-            segments[2] &&
-            segments[3] === "messages") {
-            const snapshot = await environment.services.sessions.getSessionSnapshot(segments[2], { includeRequests: true });
-            if (!snapshot) {
-                sendJson(res, 404, {
-                    ok: false,
-                    error: "session_not_found",
-                    messages: [],
-                    requests: [],
-                });
-                return;
-            }
-            sendJson(res, 200, {
-                ok: true,
-                sessionId: snapshot.sessionId,
-                title: snapshot.title,
-                messages: snapshot.messages,
-                requests: snapshot.requests,
-                nextCursor: snapshot.nextCursor,
-                readState: this.readState(snapshot.sessionId),
-            });
-            return;
-        }
-        if (method === "DELETE" &&
-            segments[0] === "chat" &&
-            segments[1] === "sessions" &&
-            segments[2] &&
-            segments[3] === "messages") {
-            const result = await environment.services.sessions.clearSessionMessages(segments[2]);
-            if (!result) {
-                sendJson(res, 404, { ok: false, error: "session_not_found" });
-                return;
-            }
-            await deleteSessionAttachmentsIfSupported(environment, segments[2]);
-            sendJson(res, 200, { ok: true, ...result });
-            return;
-        }
-        if (method === "DELETE" &&
-            segments[0] === "chat" &&
-            segments[1] === "sessions" &&
-            segments[2] &&
-            segments.length === 3) {
-            const result = await environment.services.sessions.deleteSessionWithStats(segments[2]);
-            if (result.deleted) {
-                await deleteSessionAttachmentsIfSupported(environment, segments[2]);
-            }
-            sendJson(res, 200, { ok: true, ...result });
-            return;
-        }
-        if (method === "POST" &&
-            segments[0] === "chat" &&
-            segments[1] === "sessions" &&
-            segments[2] &&
-            segments[3] === "read") {
-            sendJson(res, 200, { ok: true, readState: this.readState(segments[2]) });
+        if (await this.sessions.handle({
+            method,
+            segments,
+            body,
+            environmentId,
+            environment,
+            response: res,
+        }))
             return;
-        }
         if (method === "POST" && route === "chat/messages") {
             await this.requests.start(res, body ?? {}, environmentId, environment);
             return;
@@ -275,12 +252,4 @@ export class LocalRuntimeApiRouter {
         }
         sendJson(res, 404, { ok: false, error: "not_found" });
     }
-    readState(sessionId) {
-        return {
-            sessionId,
-            unreadCount: 0,
-            hasUnread: false,
-            lastReadAt: Date.now(),
-        };
-    }
 }

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

@@ -1,4 +1,4 @@
-import type { RuntimeApplication } from "../../runtime/composition.js";
+import type { LocalRuntimeApplication } from "../../runtime/local-application.js";
 import type { RequestSteeringInbox } from "../../runtime/request/request-steering.js";
 import type { ModelProviderAdapterRegistry } from "../../model-gateway/index.js";
 export type JsonObject = Record<string, unknown>;
@@ -11,7 +11,7 @@ export type LocalRuntimeBackendOptions = {
 export type ResolvedLocalRuntimeBackendOptions = Omit<LocalRuntimeBackendOptions, "providerAdapters"> & {
     providerAdapters: ModelProviderAdapterRegistry;
 };
-export type RuntimeEnvironment = RuntimeApplication;
+export type RuntimeEnvironment = LocalRuntimeApplication;
 export type RuntimeSetupRequirement = {
     status: "setup_required";
     code: "runtime_configuration_required";

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

@@ -1,11 +1,22 @@
+import { type LocalRuntimeApplicationOptions } from "../../runtime/local-application.js";
 import type { LocalRuntimeBackendOptions, RuntimeEnvironment, RuntimeModelCatalogState, RuntimeSetupRequirement } from "./contracts.js";
 export declare class RuntimeEnvironmentRegistry {
     private readonly options;
+    private readonly schedulerBindings;
     private readonly environments;
-    constructor(options: LocalRuntimeBackendOptions);
+    private stopped;
+    private stopping;
+    constructor(options: LocalRuntimeBackendOptions, schedulerBindings?: {
+        requestOptions?: LocalRuntimeApplicationOptions["scheduledRequestOptions"];
+        publish?: (event: Record<string, unknown>) => void;
+    });
     modelCatalog(environmentId: string): RuntimeModelCatalogState;
     setupRequirement(environmentId: string): RuntimeSetupRequirement | null;
     get(environmentId: string): RuntimeEnvironment;
+    start(environmentIds: readonly string[]): Promise<void>;
+    private startEnvironment;
+    stop(): Promise<void>;
+    private requireEnvironmentIntakeOpen;
     profileEnv(environmentId: string): Record<string, string | undefined>;
     private loadConfig;
     private emptyModelCatalog;