@ggui-ai/mcp-server 0.1.0-rc.1

package/dist/console-headers.js

@@ -0,0 +1,49 @@
+import { GGUI_SESSION_SHELL_SCRIPT_HASH } from './mcp-apps-outbound.js';
+/**
+ * The CSP directive string. Exported so tests can assert against the
+ * exact shape without hard-coding the directive order inside the test
+ * file. Change this string and a focused header test catches the
+ * regression.
+ */
+export const DEVTOOL_CSP = [
+    "default-src 'none'",
+    `script-src 'self' blob: data: ${GGUI_SESSION_SHELL_SCRIPT_HASH}`,
+    // Google Fonts CDN allowlisted for the brand-kit Inter + Geist Mono
+    // pair used by the public welcome page (`/`). The same allowlist
+    // applies to every console-served HTML — every page may opt to load
+    // these fonts; pages that don't reference them pay zero cost.
+    "style-src 'self' 'unsafe-inline' https://fonts.googleapis.com",
+    "connect-src 'self'",
+    "img-src 'self' data:",
+    "font-src 'self' https://fonts.gstatic.com",
+    "frame-ancestors 'none'",
+    "base-uri 'none'",
+    "form-action 'self'",
+].join('; ');
+/**
+ * Other security headers applied alongside CSP. Split from `DEVTOOL_CSP`
+ * so tests can enumerate them separately. Keep this list small +
+ * well-justified — every header is a compat risk on the operator's
+ * browser matrix.
+ */
+export const DEVTOOL_SECURITY_HEADERS = [
+    ['Content-Security-Policy', DEVTOOL_CSP],
+    ['X-Content-Type-Options', 'nosniff'],
+    ['X-Frame-Options', 'DENY'],
+    ['Referrer-Policy', 'strict-origin-when-cross-origin'],
+    ['Cross-Origin-Opener-Policy', 'same-origin'],
+];
+/**
+ * Apply the console security header set to a response. Pure
+ * side-effect on `res`; returns `void`. Safe to call multiple times on
+ * the same response — `setHeader` overwrites.
+ *
+ * Accepts both Express `Response` and raw Node `ServerResponse` so the
+ * `express.static` `setHeaders(res, path, stat)` callback (which passes
+ * `ServerResponse`) can reuse the same helper.
+ */
+export function applyDevtoolSecurityHeaders(res) {
+    for (const [name, value] of DEVTOOL_SECURITY_HEADERS) {
+        res.setHeader(name, value);
+    }
+}

package/dist/console-llm-trace.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Console-facing LLM trace sink + REST/SSE endpoints powering
+ * `/devtools/llm-trace` in the @ggui-ai/console SPA.
+ *
+ * This is the OSS-default sink the `ggui serve` process registers via
+ * {@link setLlmTraceSink}. A hosted closed runtime may swap in a
+ * durable sink (e.g. Redis-backed) — the harness only knows about the
+ * {@link LlmTraceSink} contract.
+ *
+ * **Two surfaces, both admin-gated:**
+ *   - `GET /ggui/console/llm-trace/recent?limit=<n>` — JSON snapshot
+ *     of the ring buffer's most recent N events, oldest-first within
+ *     the page. Used for initial page load.
+ *   - `GET /ggui/console/llm-trace/stream` — SSE stream of new events
+ *     as they fire. Heartbeat every 15s to keep proxies awake.
+ *
+ * **Memory bound.** Default capacity = 200 events. Each event carries
+ * the full system + user prompt — at ~25KB/event that's ~5MB peak.
+ * Operator can override via `createGguiServer({ llmTrace: { capacity }})`
+ * if running on a small box.
+ */
+import type { Express } from 'express';
+import type { LlmTraceEvent, LlmTraceSink } from '@ggui-ai/ui-gen/harness/llm-trace-sink';
+/** SSE listener — receives one event per LLM call. */
+type SseListener = (event: LlmTraceEvent) => void;
+/**
+ * In-memory ring buffer + listener fanout. Implements
+ * {@link LlmTraceSink} so it can be passed to
+ * {@link setLlmTraceSink}.
+ *
+ * **Why a class, not a closure.** Tests + operators read state
+ * (`recent()`, listener count) — instance methods on a class beat a
+ * pile of getter functions captured in scope. The shape is also the
+ * extension point if a hosted closed runtime wants to subclass and
+ * pipe events to Redis / DDB / S3 in addition to the ring buffer.
+ */
+export declare class BoundedLlmTraceSink implements LlmTraceSink {
+    private readonly capacity;
+    private readonly buffer;
+    private readonly listeners;
+    constructor(opts?: {
+        readonly capacity?: number;
+    });
+    emit(event: LlmTraceEvent): void;
+    /**
+     * Snapshot of the most-recent `limit` events, oldest-first within
+     * the returned slice (so the operator UI can append in chronological
+     * order without re-sorting).
+     */
+    recent(limit: number): readonly LlmTraceEvent[];
+    /** Subscribe to live events. Returns an unsubscribe function. */
+    subscribe(listener: SseListener): () => void;
+    /** Listener count — for tests + the eventual `/devtools/info` view. */
+    listenerCount(): number;
+    /** Buffer size — for tests + future bound enforcement assertions. */
+    size(): number;
+}
+/**
+ * Mount the `/ggui/console/llm-trace/recent` + `/.../stream` routes on
+ * `app`. Caller is responsible for installing the admin gate
+ * middleware on these paths beforehand — this function does not
+ * re-implement auth.
+ */
+export declare function mountConsoleLlmTraceRoutes(app: Express, sink: BoundedLlmTraceSink): void;
+export {};
+//# sourceMappingURL=console-llm-trace.d.ts.map

package/dist/console-llm-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-llm-trace.d.ts","sourceRoot":"","sources":["../src/console-llm-trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACb,MAAM,wCAAwC,CAAC;AAGhD,sDAAsD;AACtD,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAElD;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,YAAW,YAAY;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAUjD,IAAI,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAchC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,aAAa,EAAE;IAK/C,iEAAiE;IACjE,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,IAAI;IAO5C,uEAAuE;IACvE,aAAa,IAAI,MAAM;IAIvB,qEAAqE;IACrE,IAAI,IAAI,MAAM;CAGf;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,mBAAmB,GACxB,IAAI,CA8CN"}

package/dist/console-llm-trace.js

@@ -0,0 +1,105 @@
+import { applyDevtoolSecurityHeaders } from './console-headers.js';
+/**
+ * In-memory ring buffer + listener fanout. Implements
+ * {@link LlmTraceSink} so it can be passed to
+ * {@link setLlmTraceSink}.
+ *
+ * **Why a class, not a closure.** Tests + operators read state
+ * (`recent()`, listener count) — instance methods on a class beat a
+ * pile of getter functions captured in scope. The shape is also the
+ * extension point if a hosted closed runtime wants to subclass and
+ * pipe events to Redis / DDB / S3 in addition to the ring buffer.
+ */
+export class BoundedLlmTraceSink {
+    capacity;
+    buffer = [];
+    listeners = new Set();
+    constructor(opts) {
+        const cap = opts?.capacity ?? 200;
+        if (!Number.isFinite(cap) || cap <= 0) {
+            throw new Error(`BoundedLlmTraceSink: capacity must be a positive integer, got ${cap}`);
+        }
+        this.capacity = Math.floor(cap);
+    }
+    emit(event) {
+        this.buffer.push(event);
+        if (this.buffer.length > this.capacity) {
+            this.buffer.shift();
+        }
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // One bad listener must not block fan-out to others.
+            }
+        }
+    }
+    /**
+     * Snapshot of the most-recent `limit` events, oldest-first within
+     * the returned slice (so the operator UI can append in chronological
+     * order without re-sorting).
+     */
+    recent(limit) {
+        const n = Math.max(0, Math.min(limit, this.buffer.length));
+        return this.buffer.slice(-n);
+    }
+    /** Subscribe to live events. Returns an unsubscribe function. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /** Listener count — for tests + the eventual `/devtools/info` view. */
+    listenerCount() {
+        return this.listeners.size;
+    }
+    /** Buffer size — for tests + future bound enforcement assertions. */
+    size() {
+        return this.buffer.length;
+    }
+}
+/**
+ * Mount the `/ggui/console/llm-trace/recent` + `/.../stream` routes on
+ * `app`. Caller is responsible for installing the admin gate
+ * middleware on these paths beforehand — this function does not
+ * re-implement auth.
+ */
+export function mountConsoleLlmTraceRoutes(app, sink) {
+    // GET /ggui/console/llm-trace/recent?limit=<n> — JSON snapshot.
+    app.get('/ggui/console/llm-trace/recent', (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        const limitRaw = req.query['limit'];
+        let limit = 100;
+        if (typeof limitRaw === 'string') {
+            const parsed = Number.parseInt(limitRaw, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                limit = Math.min(500, parsed);
+            }
+        }
+        res.json({ events: sink.recent(limit) });
+    });
+    // GET /ggui/console/llm-trace/stream — SSE live stream.
+    // Heartbeat comment every 15s so reverse proxies don't kill the
+    // connection on idle. Client cleanup unregisters the listener.
+    app.get('/ggui/console/llm-trace/stream', (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        res.setHeader('content-type', 'text/event-stream');
+        res.setHeader('cache-control', 'no-store');
+        res.setHeader('connection', 'keep-alive');
+        // Flush headers immediately so the EventSource starts receiving.
+        res.flushHeaders?.();
+        const heartbeat = setInterval(() => {
+            // SSE comment frame — clients ignore but proxies see traffic.
+            res.write(': ping\n\n');
+        }, 15000);
+        const off = sink.subscribe((event) => {
+            res.write(`data: ${JSON.stringify(event)}\n\n`);
+        });
+        req.on('close', () => {
+            clearInterval(heartbeat);
+            off();
+        });
+    });
+}

package/dist/console-payloads.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Console-facing payload trace sink + REST/SSE endpoints powering
+ * `/devtools/payloads` in the @ggui-ai/console SPA.
+ *
+ * This is the OSS-default sink the `ggui serve` process registers via
+ * {@link setPayloadTraceSink}. A hosted closed runtime may swap in a
+ * durable sink (e.g. Redis-backed) — the handlers only know about the
+ * {@link PayloadTraceSink} contract.
+ *
+ * **Two surfaces, both admin-gated:**
+ *   - `GET /ggui/console/payloads/recent?limit=<n>` — JSON snapshot
+ *     of the ring buffer's most recent N events, oldest-first within
+ *     the page. Used for initial page load.
+ *   - `GET /ggui/console/payloads/stream` — SSE stream of new events
+ *     as they fire. Heartbeat every 15s to keep proxies awake.
+ *
+ * **Memory bound.** Default capacity = 100 events (vs LlmTraceSink's
+ * 200). Each `ggui_push` payload may carry full componentCode, base64
+ * blobs, or a fat `story.context`, so cap is tighter to keep peak
+ * memory bounded. At ~50 KB / event the worst-case ring is ~5 MB.
+ * Operator can override at construction.
+ */
+import type { Express } from 'express';
+import type { PayloadTraceEvent, PayloadTraceSink } from '@ggui-ai/mcp-server-handlers/session-mutations';
+/** SSE listener — receives one event per accepted payload. */
+type SseListener = (event: PayloadTraceEvent) => void;
+/**
+ * In-memory ring buffer + listener fanout. Implements
+ * {@link PayloadTraceSink} so it can be passed to
+ * {@link setPayloadTraceSink}.
+ *
+ * **Why a class, not a closure.** Tests + operators read state
+ * (`recent()`, listener count) — instance methods on a class beat a
+ * pile of getter functions captured in scope. The shape is also the
+ * extension point if a hosted closed runtime wants to subclass and
+ * pipe events to Redis / DDB / S3 in addition to the ring buffer.
+ */
+export declare class BoundedPayloadTraceSink implements PayloadTraceSink {
+    private readonly capacity;
+    private readonly buffer;
+    private readonly listeners;
+    constructor(opts?: {
+        readonly capacity?: number;
+    });
+    emit(event: PayloadTraceEvent): void;
+    /**
+     * Snapshot of the most-recent `limit` events, oldest-first within
+     * the returned slice (so the operator UI can append in chronological
+     * order without re-sorting).
+     */
+    recent(limit: number): readonly PayloadTraceEvent[];
+    /** Subscribe to live events. Returns an unsubscribe function. */
+    subscribe(listener: SseListener): () => void;
+    /** Listener count — for tests + the eventual `/devtools/info` view. */
+    listenerCount(): number;
+    /** Buffer size — for tests + future bound enforcement assertions. */
+    size(): number;
+}
+/**
+ * Mount the `/ggui/console/payloads/recent` + `/.../stream` routes on
+ * `app`. Caller is responsible for installing the admin gate
+ * middleware on these paths beforehand — this function does not
+ * re-implement auth.
+ */
+export declare function mountConsolePayloadsRoutes(app: Express, sink: BoundedPayloadTraceSink): void;
+export {};
+//# sourceMappingURL=console-payloads.d.ts.map

package/dist/console-payloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-payloads.d.ts","sourceRoot":"","sources":["../src/console-payloads.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,SAAS,CAAC;AAC1D,OAAO,KAAK,EACV,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,gDAAgD,CAAC;AAGxD,8DAA8D;AAC9D,KAAK,WAAW,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,YAAW,gBAAgB;IAC9D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAClD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;gBAExC,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE;IAUjD,IAAI,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI;IAcpC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,iBAAiB,EAAE;IAKnD,iEAAiE;IACjE,SAAS,CAAC,QAAQ,EAAE,WAAW,GAAG,MAAM,IAAI;IAO5C,uEAAuE;IACvE,aAAa,IAAI,MAAM;IAIvB,qEAAqE;IACrE,IAAI,IAAI,MAAM;CAGf;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE,uBAAuB,GAC5B,IAAI,CA8CN"}

package/dist/console-payloads.js

@@ -0,0 +1,105 @@
+import { applyDevtoolSecurityHeaders } from './console-headers.js';
+/**
+ * In-memory ring buffer + listener fanout. Implements
+ * {@link PayloadTraceSink} so it can be passed to
+ * {@link setPayloadTraceSink}.
+ *
+ * **Why a class, not a closure.** Tests + operators read state
+ * (`recent()`, listener count) — instance methods on a class beat a
+ * pile of getter functions captured in scope. The shape is also the
+ * extension point if a hosted closed runtime wants to subclass and
+ * pipe events to Redis / DDB / S3 in addition to the ring buffer.
+ */
+export class BoundedPayloadTraceSink {
+    capacity;
+    buffer = [];
+    listeners = new Set();
+    constructor(opts) {
+        const cap = opts?.capacity ?? 100;
+        if (!Number.isFinite(cap) || cap <= 0) {
+            throw new Error(`BoundedPayloadTraceSink: capacity must be a positive integer, got ${cap}`);
+        }
+        this.capacity = Math.floor(cap);
+    }
+    emit(event) {
+        this.buffer.push(event);
+        if (this.buffer.length > this.capacity) {
+            this.buffer.shift();
+        }
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // One bad listener must not block fan-out to others.
+            }
+        }
+    }
+    /**
+     * Snapshot of the most-recent `limit` events, oldest-first within
+     * the returned slice (so the operator UI can append in chronological
+     * order without re-sorting).
+     */
+    recent(limit) {
+        const n = Math.max(0, Math.min(limit, this.buffer.length));
+        return this.buffer.slice(-n);
+    }
+    /** Subscribe to live events. Returns an unsubscribe function. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    /** Listener count — for tests + the eventual `/devtools/info` view. */
+    listenerCount() {
+        return this.listeners.size;
+    }
+    /** Buffer size — for tests + future bound enforcement assertions. */
+    size() {
+        return this.buffer.length;
+    }
+}
+/**
+ * Mount the `/ggui/console/payloads/recent` + `/.../stream` routes on
+ * `app`. Caller is responsible for installing the admin gate
+ * middleware on these paths beforehand — this function does not
+ * re-implement auth.
+ */
+export function mountConsolePayloadsRoutes(app, sink) {
+    // GET /ggui/console/payloads/recent?limit=<n> — JSON snapshot.
+    app.get('/ggui/console/payloads/recent', (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        const limitRaw = req.query['limit'];
+        let limit = 100;
+        if (typeof limitRaw === 'string') {
+            const parsed = Number.parseInt(limitRaw, 10);
+            if (Number.isFinite(parsed) && parsed > 0) {
+                limit = Math.min(500, parsed);
+            }
+        }
+        res.json({ events: sink.recent(limit) });
+    });
+    // GET /ggui/console/payloads/stream — SSE live stream.
+    // Heartbeat comment every 15s so reverse proxies don't kill the
+    // connection on idle. Client cleanup unregisters the listener.
+    app.get('/ggui/console/payloads/stream', (req, res) => {
+        applyDevtoolSecurityHeaders(res);
+        res.setHeader('content-type', 'text/event-stream');
+        res.setHeader('cache-control', 'no-store');
+        res.setHeader('connection', 'keep-alive');
+        // Flush headers immediately so the EventSource starts receiving.
+        res.flushHeaders?.();
+        const heartbeat = setInterval(() => {
+            // SSE comment frame — clients ignore but proxies see traffic.
+            res.write(': ping\n\n');
+        }, 15000);
+        const off = sink.subscribe((event) => {
+            res.write(`data: ${JSON.stringify(event)}\n\n`);
+        });
+        req.on('close', () => {
+            clearInterval(heartbeat);
+            off();
+        });
+    });
+}

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

@@ -0,0 +1,111 @@
+/**
+ * Console theme picker routes — `GET /ggui/console/theme` +
+ * `POST /ggui/console/theme`.
+ *
+ * Shape:
+ *
+ *   GET /ggui/console/theme
+ *     → 200 {
+ *         presets: ThemeEntry[],   // from @ggui-ai/design#listThemes()
+ *         current: ThemeConfig | null,  // ggui.json#theme as parsed
+ *         writerEnabled: boolean,  // POST availability
+ *       }
+ *
+ *   POST /ggui/console/theme
+ *     body: ThemeConfig | null     // null = clear field, fall back to default
+ *     → 200 { ok: true }
+ *     → 400 { error: 'invalid_config', issue }    — schema rejected
+ *     → 501 { error: 'writer_not_configured' }    — opts.themeWriter omitted
+ *     → 500 { error: 'write_failed', message }    — writer threw
+ *
+ * Authentication: piggy-backs on the same admin gate the LLM-keys
+ * routes use — operator-only since the value persists to ggui.json,
+ * which the OSS server treats as trusted manifest input. End-users
+ * who paired into a session don't get to mutate the project's
+ * theme. Multi-tenant deployments may relax this in a follow-up by
+ * scoping overrides per user (overrides become server state, not
+ * file state).
+ */
+import type { Express, Request } from 'express';
+import { type ThemeConfig } from '@ggui-ai/project-config';
+/**
+ * Persists a theme selection back to disk. The mcp-server never
+ * touches the filesystem itself — `@ggui-ai/cli` provides the
+ * implementation that knows where `ggui.json` lives.
+ *
+ * `null` clears the field and falls the manifest back to the
+ * default-theme branch on next boot.
+ */
+export type ThemeWriter = (config: ThemeConfig | null) => Promise<void>;
+/**
+ * Writes an uploaded DTCG theme document next to `ggui.json` under the
+ * caller-supplied filename. Atomic + scoped to the project directory —
+ * the implementation rejects any filename containing path separators.
+ *
+ * Pairs with {@link ThemeWriter}: after a successful upload, the route
+ * calls `themeWriter({ file: './<filename>', mode })` so the manifest
+ * points at the freshly-saved file.
+ */
+export type ThemeFileUploader = (filename: string, content: unknown) => Promise<void>;
+interface MountOptions {
+    /**
+     * Express app to mount onto. The same app the rest of the console
+     * routes mount against.
+     */
+    app: Express;
+    /**
+     * Current resolved theme selection — what's parsed from ggui.json
+     * at boot. `null` when the manifest had no `theme` field. Read-only
+     * snapshot; subsequent picker GETs reflect what the operator saved
+     * via POST since the snapshot was taken (handled internally).
+     */
+    initialConfig: ThemeConfig | null;
+    /**
+     * Optional persister — mounted only when present. When omitted,
+     * POST returns 501 so the picker UI can surface a "read-only"
+     * banner instead of silently failing.
+     */
+    themeWriter?: ThemeWriter;
+    /**
+     * Optional file uploader — mounted only when present alongside
+     * `themeWriter`. When omitted, `POST /ggui/console/theme/upload`
+     * returns 501 and the picker hides its "Upload theme.json" affordance.
+     */
+    themeFileUploader?: ThemeFileUploader;
+    /**
+     * Auth gate — same callable the LLM-keys routes use. Returns
+     * `true` when the request carries a valid admin bearer/cookie.
+     */
+    requestHasAdminAuth: (req: Request) => boolean;
+    /**
+     * Optional change notifier — fires every time the operator's
+     * theme selection changes through `POST /ggui/console/theme` (or
+     * the `/upload` variant). The CLI uses this to mirror writes into
+     * a shared mutable state cell that the push handler's
+     * `themeProvider` reads, so a save reaches the next push without
+     * a server restart.
+     *
+     * Fires AFTER the on-disk write succeeds and AFTER the route's
+     * own internal cache updates. Errors thrown by the handler are
+     * caught and ignored — the route still returns 200 so the picker
+     * UI doesn't see a phantom failure for a downstream subscription
+     * issue. Operators with strict-observability needs should wire
+     * their own logger inside the callback.
+     *
+     * Optional: omitting this preserves the legacy per-restart
+     * behaviour (POST writes ggui.json; running server stays on the
+     * boot-baked theme until restart).
+     */
+    onConfigChange?: (next: ThemeConfig | null) => void;
+}
+/**
+ * Mount `GET /ggui/console/theme` + `POST /ggui/console/theme` onto
+ * the express app. Returns nothing — the routes self-register.
+ *
+ * The current-config state is held in-process (mutable closure) so
+ * subsequent GETs reflect the latest POST without re-reading
+ * ggui.json. Writes are durable via the supplied `themeWriter`.
+ */
+export declare function mountDevtoolThemeRoutes(opts: MountOptions): void;
+export {};
+//# sourceMappingURL=console-theme-routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"console-theme-routes.d.ts","sourceRoot":"","sources":["../src/console-theme-routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAY,MAAM,SAAS,CAAC;AAC1D,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,yBAAyB,CAAC;AAGjC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAExE;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,KACb,OAAO,CAAC,IAAI,CAAC,CAAC;AAUnB,UAAU,YAAY;IACpB;;;OAGG;IACH,GAAG,EAAE,OAAO,CAAC;IACb;;;;;OAKG;IACH,aAAa,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC;;;;OAIG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC;;;OAGG;IACH,mBAAmB,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;IAC/C;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;CACrD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CA4KhE"}