@ggui-ai/mcp-server 0.2.0-alpha.4 → 0.3.0-rc.0

package/dist/console-llm-keys-routes.js

@@ -0,0 +1,443 @@
+/**
+ * BYOK LLM-keys plane — gated /ggui/console/llm-keys. Two postures:
+ *
+ *   - `gateMode: 'admin-token'` (default — OSS-personal):
+ *     gate accepts the admin bearer. Single global keyset; the
+ *     /settings UI lets the operator paste keys for everyone.
+ *   - `gateMode: 'auth-adapter'` (multi-tenant): gate
+ *     calls the server's `AuthAdapter`. Each user's keys are
+ *     scoped by `scopeFromRequest` (default: `userId`/`appId`).
+ *
+ * Wire shape (same in both gates):
+ *   GET    /ggui/console/llm-keys                 — list providers + presence
+ *   POST   /ggui/console/llm-keys                 — set { provider, key }
+ *   DELETE /ggui/console/llm-keys/:provider       — clear (idempotent)
+ *   POST   /ggui/console/llm-keys/:provider/probe — auth-validation probe
+ *
+ * Plaintext is NEVER returned on GET — unlike pairing tokens, an LLM
+ * key is a one-way paste (operator already has the key elsewhere; the
+ * server is just persisting it). The presence + source signal is
+ * enough for the /settings UI.
+ */
+import { resolveIdentity, UnauthenticatedError } from "./auth.js";
+import { applyDevtoolSecurityHeaders } from "./console-headers.js";
+const ADMIN_COOKIE_NAME_LLM = "ggui_console_admin";
+/**
+ * The LLM_PROVIDERS allowlist matches `LlmProvider` minus `bedrock`
+ * (which is IAM-based and never paste-resolvable — see byok-resolver
+ * PROVIDER_ENV_NAMES bedrock note). Order is the operator-facing
+ * display order: anthropic first since the OSS triad ships claude
+ * as the default model.
+ */
+const LLM_PROVIDERS = [
+    "anthropic",
+    "openai",
+    "google",
+    "openrouter",
+];
+/**
+ * Mirror of `byok-resolver.ts::PROVIDER_ENV_NAMES` — env-var name
+ * ordered list per provider, first non-empty wins. Mirrored rather
+ * than imported because `@ggui-ai/cli` is downstream of this
+ * package and we can't depend back the other direction.
+ */
+const PROVIDER_ENV_NAMES = {
+    anthropic: ["ANTHROPIC_API_KEY"],
+    google: ["GOOGLE_API_KEY", "GEMINI_API_KEY"],
+    openai: ["OPENAI_API_KEY"],
+    openrouter: ["OPENROUTER_API_KEY"],
+};
+/**
+ * Mount the LLM-keys routes onto the express app. Returns nothing —
+ * the routes self-register.
+ */
+export function mountConsoleLlmKeysRoutes(opts) {
+    const { app, providerKeys, gateMode, adminToken, auth, logger } = opts;
+    const defaultScope = (_req, identity) => {
+        if (identity) {
+            if (identity.identity.kind === "user") {
+                return identity.identity.userId;
+            }
+            if (identity.identity.kind === "app") {
+                return identity.identity.appId;
+            }
+        }
+        return "global";
+    };
+    const scopeFromRequest = opts.scopeFromRequest ?? defaultScope;
+    const requestHasAdminAuthLlm = (req) => {
+        if (adminToken === null)
+            return false;
+        const authHeader = req.headers["authorization"];
+        if (typeof authHeader === "string") {
+            const match = /^Bearer\s+(.+)$/i.exec(authHeader.trim());
+            if (match && match[1] === adminToken)
+                return true;
+        }
+        const cookieHeader = req.headers["cookie"];
+        if (typeof cookieHeader === "string") {
+            for (const raw of cookieHeader.split(";")) {
+                const trimmed = raw.trim();
+                const eq = trimmed.indexOf("=");
+                if (eq <= 0)
+                    continue;
+                const name = trimmed.slice(0, eq);
+                if (name !== ADMIN_COOKIE_NAME_LLM)
+                    continue;
+                const value = decodeURIComponent(trimmed.slice(eq + 1));
+                if (value === adminToken)
+                    return true;
+            }
+        }
+        return false;
+    };
+    // Per-request identity stash. Populated by the gate when in
+    // 'auth-adapter' mode; left null under 'admin-token'. Route
+    // handlers read it via `getRequestIdentity(req)` so the scope
+    // resolver receives the resolved AuthResult without re-running
+    // `resolveIdentity`.
+    const llmKeysIdentityByRequest = new WeakMap();
+    const getRequestIdentity = (req) => llmKeysIdentityByRequest.get(req) ?? null;
+    // Path-prefix gate.
+    //
+    //   admin-token → same shape as /keys (Bearer admin OR
+    //                 ggui_console_admin cookie).
+    //   auth-adapter → calls `resolveIdentity(auth, req)`. `kind:'builder'`
+    //                  is rejected with 401 — the multi-tenant posture
+    //                  is meaningless without a real per-caller id.
+    app.use("/ggui/console/llm-keys", (req, res, next) => {
+        if (gateMode === "admin-token") {
+            if (requestHasAdminAuthLlm(req))
+                return next();
+            applyDevtoolSecurityHeaders(res);
+            res.status(401).json({ error: "admin_auth_required" });
+            return;
+        }
+        // 'auth-adapter' — the multi-tenant gate.
+        resolveIdentity(auth, req)
+            .then((identity) => {
+            if (identity.identity.kind === "builder") {
+                applyDevtoolSecurityHeaders(res);
+                res.status(401).json({
+                    error: "tenant_required",
+                    message: "Multi-tenant /llm-keys requires an end-user or app identity. " +
+                        'The configured AuthAdapter resolved kind:"builder" — pair a ' +
+                        'real user/app bearer or use providerKeysGate:"admin-token".',
+                });
+                return;
+            }
+            llmKeysIdentityByRequest.set(req, identity);
+            next();
+        })
+            .catch((err) => {
+            applyDevtoolSecurityHeaders(res);
+            if (err instanceof UnauthenticatedError) {
+                res.status(401).json({ error: "unauthenticated" });
+                return;
+            }
+            logger.warn("console_llm_keys_auth_failed", { error: String(err) });
+            res.status(500).json({ error: "auth_unexpected_error" });
+        });
+    });
+    // GET /ggui/console/llm-keys — list providers + presence.
+    // Each row reports:
+    //   - name:       'anthropic' | 'openai' | 'google' | 'openrouter'
+    //   - configured: boolean — true when EITHER env OR file has a key
+    //   - source:     'env' | 'file' | null — env wins on collision
+    //   - envName:    which env var fired (only present when source='env')
+    //   - envNames:   the env-var names this provider accepts
+    //                 (informational — the /settings UI shows them so
+    //                 operators know they can `export` instead of pasting)
+    app.get("/ggui/console/llm-keys", async (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        try {
+            const scope = scopeFromRequest(req, getRequestIdentity(req));
+            const filePresent = new Set(await providerKeys.listProviders(scope));
+            // Build rows with an optional 12-char prefix preview so the
+            // operator can confirm WHICH key is loaded without exposing
+            // the secret. 12 chars covers the discriminating prefix
+            // (`sk-ant-api03`, `sk-ant-oat01`, `sk-or-v1-…`, etc.) while
+            // staying safely under the entropy floor — these prefixes
+            // are not secret on their own.
+            const rows = await Promise.all(LLM_PROVIDERS.map(async (provider) => {
+                const envNames = PROVIDER_ENV_NAMES[provider];
+                let envHit;
+                let envValue;
+                for (const name of envNames) {
+                    const value = process.env[name];
+                    if (value !== undefined && value.length > 0) {
+                        envHit = name;
+                        envValue = value;
+                        break;
+                    }
+                }
+                const inFile = filePresent.has(provider);
+                const source = envHit !== undefined ? "env" : inFile ? "file" : null;
+                let keyPreview;
+                if (envValue !== undefined) {
+                    keyPreview = envValue.slice(0, 12);
+                }
+                else if (inFile) {
+                    try {
+                        const ref = await providerKeys.get(scope, provider);
+                        if (ref)
+                            keyPreview = ref.key.slice(0, 12);
+                    }
+                    catch {
+                        // Best-effort — preview is advisory; never block the GET.
+                    }
+                }
+                return {
+                    name: provider,
+                    configured: source !== null,
+                    source,
+                    ...(envHit !== undefined ? { envName: envHit } : {}),
+                    envNames: [...envNames],
+                    inFile,
+                    ...(keyPreview !== undefined ? { keyPreview } : {}),
+                };
+            }));
+            res.json({
+                providers: rows,
+                scope,
+            });
+        }
+        catch (err) {
+            logger.warn("console_llm_keys_list_failed", {
+                error: String(err),
+            });
+            res.status(500).json({
+                error: "list_failed",
+                message: err instanceof Error
+                    ? `LLM keys list failed — ${err.message}`
+                    : `LLM keys list failed — ${String(err)}`,
+            });
+        }
+    });
+    // POST /ggui/console/llm-keys — set a provider's key.
+    // Body: { provider: 'anthropic'|'openai'|..., key: string }.
+    // Returns: { provider, source: 'file', envOverridden: boolean }.
+    // `envOverridden: true` means the operator pasted a key but env
+    // var also set — the resolver still picks env. The /settings UI
+    // surfaces this so operators don't think their paste is in effect.
+    app.post("/ggui/console/llm-keys", async (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        const body = req.body;
+        const provider = typeof body?.provider === "string" ? body.provider : "";
+        const key = typeof body?.key === "string" ? body.key.trim() : "";
+        if (!LLM_PROVIDERS.includes(provider)) {
+            res.status(400).json({
+                error: "invalid_provider",
+                message: `provider must be one of ${LLM_PROVIDERS.join(", ")}.`,
+            });
+            return;
+        }
+        if (key.length === 0 || key.length > 4096) {
+            res.status(400).json({
+                error: "invalid_key",
+                message: "`key` is required (non-empty string, ≤4096 chars).",
+            });
+            return;
+        }
+        try {
+            const typedProvider = provider;
+            const scope = scopeFromRequest(req, getRequestIdentity(req));
+            await providerKeys.set(scope, typedProvider, key);
+            const envNames = PROVIDER_ENV_NAMES[typedProvider];
+            let envOverride;
+            for (const name of envNames) {
+                const value = process.env[name];
+                if (value !== undefined && value.length > 0) {
+                    envOverride = name;
+                    break;
+                }
+            }
+            res.json({
+                provider: typedProvider,
+                source: "file",
+                envOverridden: envOverride !== undefined,
+                ...(envOverride !== undefined ? { envName: envOverride } : {}),
+            });
+        }
+        catch (err) {
+            logger.warn("console_llm_keys_set_failed", {
+                error: String(err),
+                provider,
+            });
+            res.status(500).json({
+                error: "set_failed",
+                message: err instanceof Error
+                    ? `LLM key set failed — ${err.message}`
+                    : `LLM key set failed — ${String(err)}`,
+            });
+        }
+    });
+    // DELETE /ggui/console/llm-keys/:provider — clear (idempotent).
+    // 204 even when the key wasn't set; mirrors `ProviderKeyStore.delete`
+    // contract. NEVER touches env — the operator owns env separately.
+    app.delete("/ggui/console/llm-keys/:provider", async (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        const provider = req.params["provider"];
+        if (!LLM_PROVIDERS.includes(provider)) {
+            res.status(400).json({
+                error: "invalid_provider",
+                message: `provider must be one of ${LLM_PROVIDERS.join(", ")}.`,
+            });
+            return;
+        }
+        try {
+            const typedProvider = provider;
+            const scope = scopeFromRequest(req, getRequestIdentity(req));
+            await providerKeys.delete(scope, typedProvider);
+            res.status(204).end();
+        }
+        catch (err) {
+            logger.warn("console_llm_keys_delete_failed", {
+                error: String(err),
+                provider,
+            });
+            res.status(500).json({
+                error: "delete_failed",
+                message: err instanceof Error
+                    ? `LLM key delete failed — ${err.message}`
+                    : `LLM key delete failed — ${String(err)}`,
+            });
+        }
+    });
+    // POST /ggui/console/llm-keys/:provider/probe — auth-validation health
+    // probe for the configured key. Hits each provider's cheapest
+    // auth-checking endpoint with a 5s timeout. Status code is always
+    // 200 — the `ok` flag carries the verdict so the UI can paint a dot
+    // without branching on HTTP status. NEVER returns or logs the key
+    // value (latency + ok-flag + provider name only).
+    const probeProvider = async (provider, key) => {
+        const start = Date.now();
+        const ac = new AbortController();
+        const timer = setTimeout(() => {
+            ac.abort();
+        }, 5000);
+        try {
+            let url;
+            const headers = {};
+            if (provider === "anthropic") {
+                url = "https://api.anthropic.com/v1/models?limit=1";
+                headers["x-api-key"] = key;
+                headers["anthropic-version"] = "2023-06-01";
+            }
+            else if (provider === "openai") {
+                url = "https://api.openai.com/v1/models";
+                headers["Authorization"] = `Bearer ${key}`;
+            }
+            else if (provider === "google") {
+                // Google uses query-param key auth — no Authorization header.
+                url = `https://generativelanguage.googleapis.com/v1beta/models?pageSize=1&key=${encodeURIComponent(key)}`;
+            }
+            else {
+                // openrouter — auth/key endpoint validates without listing.
+                url = "https://openrouter.ai/api/v1/auth/key";
+                headers["Authorization"] = `Bearer ${key}`;
+            }
+            const res = await globalThis.fetch(url, {
+                method: "GET",
+                headers,
+                signal: ac.signal,
+            });
+            const latencyMs = Date.now() - start;
+            if (res.ok) {
+                return { ok: true, latencyMs };
+            }
+            let detail = "";
+            try {
+                const body = (await res.json());
+                const errField = body.error;
+                const errMessage = typeof errField === "string"
+                    ? errField
+                    : errField !== null &&
+                        typeof errField === "object" &&
+                        "message" in errField &&
+                        typeof errField.message === "string"
+                        ? errField.message
+                        : typeof body.message === "string"
+                            ? body.message
+                            : "";
+                if (errMessage.length > 0)
+                    detail = ` ${errMessage}`;
+            }
+            catch {
+                // Non-JSON body — error code alone is enough for the dot.
+            }
+            return {
+                ok: false,
+                latencyMs,
+                error: `HTTP ${res.status}${detail}`.slice(0, 200),
+            };
+        }
+        catch (err) {
+            const latencyMs = Date.now() - start;
+            return {
+                ok: false,
+                latencyMs,
+                error: String(err).slice(0, 200),
+            };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    app.post("/ggui/console/llm-keys/:provider/probe", async (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        const provider = req.params["provider"];
+        if (!LLM_PROVIDERS.includes(provider)) {
+            res.status(400).json({
+                error: "invalid_provider",
+                message: `provider must be one of ${LLM_PROVIDERS.join(", ")}.`,
+            });
+            return;
+        }
+        try {
+            const typedProvider = provider;
+            // Resolve env-first-then-file, mirroring the GET handler's
+            // source rule. Env wins on collision so the probe matches what
+            // the generation pipeline would actually send.
+            const envNames = PROVIDER_ENV_NAMES[typedProvider];
+            let resolvedKey = null;
+            for (const name of envNames) {
+                const value = process.env[name];
+                if (value !== undefined && value.length > 0) {
+                    resolvedKey = value;
+                    break;
+                }
+            }
+            if (resolvedKey === null) {
+                const scope = scopeFromRequest(req, getRequestIdentity(req));
+                const ref = await providerKeys.get(scope, typedProvider);
+                if (ref !== null && ref.key.length > 0) {
+                    resolvedKey = ref.key;
+                }
+            }
+            if (resolvedKey === null) {
+                res.status(400).json({ ok: false, error: "not_configured" });
+                return;
+            }
+            const result = await probeProvider(typedProvider, resolvedKey);
+            logger.info("console_llm_keys_probe", {
+                provider: typedProvider,
+                ok: result.ok,
+                latencyMs: result.latencyMs,
+            });
+            res.json(result);
+        }
+        catch (err) {
+            logger.warn("console_llm_keys_probe_failed", {
+                error: String(err),
+                provider,
+            });
+            res.status(500).json({
+                error: "probe_failed",
+                message: err instanceof Error
+                    ? `LLM key probe failed — ${err.message}`
+                    : `LLM key probe failed — ${String(err)}`,
+            });
+        }
+    });
+}

package/dist/console-mcp-tools-routes.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Console MCP-tool inventory route.
+ *
+ *   GET /ggui/console/mcp/tools — registered MCP-tool inventory for
+ *   the console SPA's `/mcp` page. Operator-facing "what tools does
+ *   my server expose?" — same handler set the `/mcp` JSON-RPC
+ *   endpoint surfaces via `tools/list`, but rendered as cards
+ *   instead of curl output.
+ *
+ * Currently LIST-only — name + title? + description + input/output
+ * JSON Schema. A "test invoke" form is deferred — invoking a tool
+ * from the console needs a same-origin bearer claim story (console
+ * session cookie currently authenticates only the live-channel WS
+ * upgrade).
+ *
+ * Schema conversion: handlers carry Zod raw shapes; the wire
+ * needs JSON Schema. `z.toJSONSchema(z.object(rawShape))` does
+ * the conversion. Failure (e.g. an exotic Zod type the v4
+ * converter doesn't yet support) reports `{}` for that field
+ * and warn-logs — operators still see name + description, just
+ * without typed input/output detail.
+ */
+import type { SharedHandler } from "@ggui-ai/mcp-server-handlers";
+import type { Express } from "express";
+import { type ZodRawShape } from "zod";
+import type { Logger } from "./logger.js";
+interface MountOptions {
+    /** Express app to mount onto. */
+    readonly app: Express;
+    /** Composed handler list the inventory projects. */
+    readonly handlers: ReadonlyArray<SharedHandler<ZodRawShape, ZodRawShape>>;
+    /** Structured logger for schema-conversion warnings. */
+    readonly logger: Logger;
+}
+/**
+ * Mount `GET /ggui/console/mcp/tools` onto the express app. Returns
+ * nothing — the route self-registers.
+ */
+export declare function mountConsoleMcpToolsRoutes(opts: MountOptions): void;
+export {};
+//# sourceMappingURL=console-mcp-tools-routes.d.ts.map

package/dist/console-mcp-tools-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-mcp-tools-routes.d.ts","sourceRoot":"","sources":["../src/console-mcp-tools-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACvC,OAAO,EAAK,KAAK,WAAW,EAAE,MAAM,KAAK,CAAC;AAE1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,UAAU,YAAY;IACpB,iCAAiC;IACjC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,aAAa,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC;IAC1E,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAwCnE"}

package/dist/console-mcp-tools-routes.js

@@ -0,0 +1,60 @@
+/**
+ * Console MCP-tool inventory route.
+ *
+ *   GET /ggui/console/mcp/tools — registered MCP-tool inventory for
+ *   the console SPA's `/mcp` page. Operator-facing "what tools does
+ *   my server expose?" — same handler set the `/mcp` JSON-RPC
+ *   endpoint surfaces via `tools/list`, but rendered as cards
+ *   instead of curl output.
+ *
+ * Currently LIST-only — name + title? + description + input/output
+ * JSON Schema. A "test invoke" form is deferred — invoking a tool
+ * from the console needs a same-origin bearer claim story (console
+ * session cookie currently authenticates only the live-channel WS
+ * upgrade).
+ *
+ * Schema conversion: handlers carry Zod raw shapes; the wire
+ * needs JSON Schema. `z.toJSONSchema(z.object(rawShape))` does
+ * the conversion. Failure (e.g. an exotic Zod type the v4
+ * converter doesn't yet support) reports `{}` for that field
+ * and warn-logs — operators still see name + description, just
+ * without typed input/output detail.
+ */
+import { z } from "zod";
+import { applyDevtoolSecurityHeaders } from "./console-headers.js";
+/**
+ * Mount `GET /ggui/console/mcp/tools` onto the express app. Returns
+ * nothing — the route self-registers.
+ */
+export function mountConsoleMcpToolsRoutes(opts) {
+    const { app, handlers, logger } = opts;
+    app.get("/ggui/console/mcp/tools", async (_req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        const safeToJsonSchema = (shape) => {
+            try {
+                return z.toJSONSchema(z.object(shape));
+            }
+            catch (err) {
+                logger.warn("console_mcp_tools_schema_conversion_failed", {
+                    error: String(err),
+                });
+                return {};
+            }
+        };
+        const tools = handlers.map((h) => {
+            const summary = {
+                name: h.name,
+                ...(h.title !== undefined ? { title: h.title } : {}),
+                description: h.description,
+                inputSchema: safeToJsonSchema(h.inputSchema),
+                outputSchema: safeToJsonSchema(h.outputSchema),
+            };
+            return summary;
+        });
+        // Stable sort by name for deterministic operator reading order
+        // — handlers are registered in module-import order, which is
+        // arbitrary from the operator's perspective.
+        tools.sort((a, b) => a.name.localeCompare(b.name));
+        res.json({ tools, total: tools.length });
+    });
+}

package/dist/console-registry-routes.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Console blueprint-catalog read/maintenance routes.
+ *
+ *   GET    /ggui/console/registry                  — declared-blueprint +
+ *          primitive catalog (boot-time content).
+ *   GET    /ggui/console/blueprints/cached         — intent-keyed
+ *          generation-cache listing (legacy surface).
+ *   DELETE /ggui/console/blueprints/cached/:id     — invalidate one entry.
+ *   POST   /ggui/console/blueprints/cached/clear   — bulk-clear the scope.
+ *   GET    /ggui/console/blueprints/registry       — contract-keyed runtime
+ *          registry the matcher actually consults (per-row tier
+ *          diagnostics: kind, contractKey, hitCount, lastHitAt,
+ *          provenance).
+ *
+ * `/registry` sources:
+ *   - `blueprints[]`  ← `uiRegistry?.list()` (full manifest entries;
+ *     surfaces `name` + `description?` + `category?`). Same registry
+ *     the `/ggui/console/blueprint/:id` endpoint resolves against, so
+ *     the /registry click-through to /preview/<id> is guaranteed to
+ *     hit the same dataset.
+ *   - `primitives[]` ← `primitiveCatalogs` (`DiscoveredPrimitiveCatalog`
+ *     shape from `@ggui-ai/project-config`). Each entry flattens
+ *     one primitive per row, tagging it with its catalog's
+ *     `source` ('package' | 'local') + `import` specifier.
+ *
+ * Scope: read-only on `/registry` (authoring happens on disk and the
+ * server re-reads on boot; zero-config is an honest empty shape).
+ * The cache/registry surfaces are scoped to `DEFAULT_BUILDER_APP_ID`
+ * because the OSS server is single-tenant by construction — same
+ * scope the render handler writes to, so list/invalidate/clear see
+ * what the real cache writes.
+ *
+ * Enumeration gate: `listGenerationCache` + `clearGenerationCache` +
+ * `listBlueprints` require an EnumerableVectorStore. Every OSS
+ * default satisfies it (`InMemoryVectorStore`, `SqliteVectorStore`);
+ * deployments that wire a non-enumerable backend get an honest `501`
+ * with a reason code rather than a silent empty list or a runtime
+ * throw.
+ *
+ * No bearer auth (same rule as the other console endpoints —
+ * same-origin operator-facing).
+ */
+import type { VectorStore } from "@ggui-ai/mcp-server-core";
+import type { DiscoveredPrimitiveCatalog } from "@ggui-ai/project-config/node";
+import type { UiRegistry } from "@ggui-ai/ui-registry";
+import type { Express } from "express";
+import type { Logger } from "./logger.js";
+interface MountOptions {
+    /** Express app to mount onto. */
+    readonly app: Express;
+    /** Declared-blueprint registry (absent = empty `blueprints[]`). */
+    readonly uiRegistry?: UiRegistry;
+    /** Discovered primitive catalogs (absent = empty `primitives[]`). */
+    readonly primitiveCatalogs?: ReadonlyArray<DiscoveredPrimitiveCatalog>;
+    /** Vector store backing the generation cache + runtime registry. */
+    readonly vectors: VectorStore;
+    /** Structured logger. */
+    readonly logger: Logger;
+}
+/**
+ * Mount the console catalog routes onto the express app. Returns
+ * nothing — the routes self-register.
+ */
+export declare function mountConsoleRegistryRoutes(opts: MountOptions): void;
+export {};
+//# sourceMappingURL=console-registry-routes.d.ts.map

package/dist/console-registry-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-registry-routes.d.ts","sourceRoot":"","sources":["../src/console-registry-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAS5D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,UAAU,YAAY;IACpB,iCAAiC;IACjC,QAAQ,CAAC,GAAG,EAAE,OAAO,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,UAAU,CAAC,EAAE,UAAU,CAAC;IACjC,qEAAqE;IACrE,QAAQ,CAAC,iBAAiB,CAAC,EAAE,aAAa,CAAC,0BAA0B,CAAC,CAAC;IACvE,oEAAoE;IACpE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CA4PnE"}