@ggui-ai/cli 0.1.0-rc.1

package/dist/serve-fallback.js

@@ -0,0 +1,122 @@
+/**
+ * `ggui serve` agent-plan resolver — the §10.2a fallback matrix.
+ *
+ * Reads `ggui.json` via `@ggui-ai/project-config/node`, resolves the
+ * `agent.entry` (if any) via `./agent-resolution.ts`, and returns a
+ * `ResolvedAgentPlan` that the CLI runner hands straight to
+ * `runServe`. Pure-ish — does real file I/O so tests exercise it
+ * with `mkdtempSync` + `writeFileSync` rather than mocking.
+ *
+ * Split out from `cli.ts` so the bin's top-level `main()` call
+ * doesn't fire when the test runner imports this module.
+ */
+import { dirname } from 'node:path';
+import { findGguiJson, GguiJsonLoadError, safeLoadGguiJson, } from '@ggui-ai/project-config/node';
+import { buildAgentRuntime, resolveAgentCommand, } from './agent-resolution.js';
+/**
+ * Apply the §10.2a matrix. Throws `GguiJsonLoadError` for cases 3
+ * (malformed JSON, schema failure) and a generic `Error` for case
+ * 4 (unsupported agent.entry extension / missing file hint).
+ *
+ * Returns a `ResolvedAgentPlan` for cases 1, 2, 5, and 6:
+ *
+ *   1. `--mcp-only`                          → disabled, silent
+ *   2. no ggui.json found                    → disabled, warn
+ *   5. ggui.json present, no agent.entry     → disabled, warn
+ *   6. valid agent.entry                     → running, no warn
+ */
+export function resolveAgentPlan(opts) {
+    // `--mcp-only` short-circuits agent supervision but still loads the
+    // manifest so the caller sees the storage block (and the project
+    // root, used to resolve relative storage paths against the manifest
+    // dir rather than CWD). Malformed manifest still escalates.
+    if (opts.mcpOnly) {
+        const { manifest, projectRoot } = tryLoadManifest(opts.cwd);
+        return {
+            status: { kind: 'disabled', reason: '--mcp-only' },
+            warnings: [],
+            manifest,
+            projectRoot,
+        };
+    }
+    const manifestPath = findGguiJson(opts.cwd);
+    if (!manifestPath) {
+        return {
+            status: { kind: 'disabled', reason: 'no ggui.json' },
+            warnings: [
+                'no ggui.json found — running MCP-only. ' +
+                    'create ggui.json with agent.entry to run your agent alongside.',
+            ],
+            manifest: null,
+            projectRoot: null,
+        };
+    }
+    const loaded = safeLoadGguiJson(manifestPath);
+    if (!loaded.success) {
+        throw loaded.error;
+    }
+    const manifest = loaded.data;
+    const projectRoot = dirname(manifestPath);
+    if (!manifest.agent?.entry) {
+        return {
+            status: { kind: 'disabled', reason: 'ggui.json has no agent.entry' },
+            warnings: [
+                `${manifestPath} found but agent.entry is not set — running MCP-only. ` +
+                    'add agent.entry to run your agent.',
+            ],
+            manifest,
+            projectRoot,
+        };
+    }
+    const resolution = resolveAgentCommand(manifest.agent.entry, projectRoot);
+    if (!resolution.ok) {
+        throw new Error(`ggui.json agent.entry: ${resolution.error}`);
+    }
+    const adapter = buildAgentRuntime(resolution);
+    const supervision = {
+        adapter,
+        startInput: {
+            projectRoot,
+            project: {
+                slug: manifest.app.slug,
+                name: manifest.app.name,
+                protocol: manifest.protocol,
+            },
+            entry: resolution.entry,
+        },
+        ...(opts.onAgentEvent ? { onEvent: opts.onAgentEvent } : {}),
+    };
+    return {
+        status: {
+            kind: 'running',
+            entry: manifest.agent.entry,
+            language: resolution.language,
+        },
+        supervision,
+        warnings: [],
+        manifest,
+        projectRoot,
+    };
+}
+/**
+ * Best-effort manifest load for the `--mcp-only` path. Returns
+ * `{manifest: null, projectRoot: null}` when no manifest is on disk
+ * (MCP-only runs fine without a manifest, so we don't warn here).
+ * Malformed / schema-invalid manifests still throw to the CLI
+ * wrapper — operators running `--mcp-only` with a broken file want
+ * to know.
+ */
+function tryLoadManifest(cwd) {
+    const manifestPath = findGguiJson(cwd);
+    if (!manifestPath)
+        return { manifest: null, projectRoot: null };
+    const loaded = safeLoadGguiJson(manifestPath);
+    if (!loaded.success)
+        throw loaded.error;
+    return { manifest: loaded.data, projectRoot: dirname(manifestPath) };
+}
+/**
+ * Re-export for tests that want to assert on malformed-config
+ * handling without importing project-config transitively.
+ */
+export { GguiJsonLoadError };

package/dist/spawn-cloudflared.d.ts

@@ -0,0 +1,61 @@
+/**
+ * `spawnCloudflaredTunnel` — auto-tunnel helper for `ggui serve --public`.
+ *
+ * The local-dev → claude.ai integration loop has a well-known trap:
+ * every demo session would otherwise need to manually run
+ * `cloudflared tunnel --url http://localhost:6781`, grep the URL from
+ * its noisy stderr, then restart `ggui serve --public-base-url <url>`
+ * with that value pinned. `runtimeUrl` is auto-derived from
+ * `X-Forwarded-Host` and no longer depends on `publicBaseUrl`, but
+ * production deployments still need the URL pinned for OAuth callbacks
+ * and email magic-links. This helper closes the gap: one `--public`
+ * flag spawns cloudflared, parses its URL, and threads it into the
+ * boot config.
+ *
+ * **Trust posture.** This helper does NOT mask the public exposure. It
+ * is the operator's explicit opt-in (`--public`); when combined with
+ * `--dev-allow-all` the CLI front-end requires a second flag
+ * (`--i-know-its-public`) to prevent accidentally serving any-bearer
+ * auth over the internet.
+ *
+ * **Process management.** The spawned child is the operator's only
+ * dependency on the host's `cloudflared` binary; we don't bundle it.
+ * On `close()`, SIGTERM → SIGKILL fallback after 5s. AbortSignal
+ * support lets the CLI lifecycle (Ctrl-C handler in `runServe`)
+ * tear down cloudflared in lockstep with the server.
+ */
+export interface SpawnCloudflaredOptions {
+    /** Local port the tunnel forwards to. */
+    readonly port: number;
+    /** Optional override of the binary path. Defaults to `cloudflared`
+     *  on PATH; operators wrap with `--cloudflared-bin <path>` when
+     *  installed outside PATH. */
+    readonly binary?: string;
+    /** Optional AbortSignal — fires SIGTERM on the child when aborted. */
+    readonly signal?: AbortSignal;
+    /** Optional logger seam. Default no-op. */
+    readonly onLog?: (line: string) => void;
+    /** URL-detection timeout. */
+    readonly urlTimeoutMs?: number;
+}
+export interface SpawnCloudflaredResult {
+    /** Public `https://<random>.trycloudflare.com` URL extracted from
+     *  cloudflared's stderr. */
+    readonly url: string;
+    /** Tear down the tunnel. Idempotent; safe to call multiple times. */
+    close(): Promise<void>;
+}
+/**
+ * Spawn `cloudflared tunnel --url http://localhost:<port>` and resolve
+ * with the assigned trycloudflare URL. Rejects when:
+ *
+ *   - The binary can't be spawned (cloudflared not installed / wrong
+ *     path / permission denied). Error message includes the install
+ *     hint.
+ *   - cloudflared exits before printing a URL. Error includes any
+ *     captured stderr tail.
+ *   - URL detection times out. Error includes elapsed time + last
+ *     ~10 lines of stderr so the operator can diagnose.
+ */
+export declare function spawnCloudflaredTunnel(opts: SpawnCloudflaredOptions): Promise<SpawnCloudflaredResult>;
+//# sourceMappingURL=spawn-cloudflared.d.ts.map

package/dist/spawn-cloudflared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-cloudflared.d.ts","sourceRoot":"","sources":["../src/spawn-cloudflared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAeH,MAAM,WAAW,uBAAuB;IACtC,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;kCAE8B;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,2CAA2C;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,6BAA6B;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC;gCAC4B;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,qEAAqE;IACrE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,sBAAsB,CAAC,CA6IjC"}

package/dist/spawn-cloudflared.js

@@ -0,0 +1,167 @@
+/**
+ * `spawnCloudflaredTunnel` — auto-tunnel helper for `ggui serve --public`.
+ *
+ * The local-dev → claude.ai integration loop has a well-known trap:
+ * every demo session would otherwise need to manually run
+ * `cloudflared tunnel --url http://localhost:6781`, grep the URL from
+ * its noisy stderr, then restart `ggui serve --public-base-url <url>`
+ * with that value pinned. `runtimeUrl` is auto-derived from
+ * `X-Forwarded-Host` and no longer depends on `publicBaseUrl`, but
+ * production deployments still need the URL pinned for OAuth callbacks
+ * and email magic-links. This helper closes the gap: one `--public`
+ * flag spawns cloudflared, parses its URL, and threads it into the
+ * boot config.
+ *
+ * **Trust posture.** This helper does NOT mask the public exposure. It
+ * is the operator's explicit opt-in (`--public`); when combined with
+ * `--dev-allow-all` the CLI front-end requires a second flag
+ * (`--i-know-its-public`) to prevent accidentally serving any-bearer
+ * auth over the internet.
+ *
+ * **Process management.** The spawned child is the operator's only
+ * dependency on the host's `cloudflared` binary; we don't bundle it.
+ * On `close()`, SIGTERM → SIGKILL fallback after 5s. AbortSignal
+ * support lets the CLI lifecycle (Ctrl-C handler in `runServe`)
+ * tear down cloudflared in lockstep with the server.
+ */
+import { spawn } from 'node:child_process';
+/** Configured upper bound on how long we wait for cloudflared to
+ *  print its public URL. Cold quick-tunnel typically takes 2-5s;
+ *  setting too low surfaces a flaky "no URL detected" error to the
+ *  operator before the tunnel actually fails. 30s is generous. */
+const DEFAULT_URL_TIMEOUT_MS = 30_000;
+/** Matcher for the trycloudflare URL inside cloudflared's stderr.
+ *  cloudflared's exact log format has been stable since 2023; if it
+ *  changes, this regex is the single point of impact. */
+const TRYCLOUDFLARE_URL_RE = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+/**
+ * Spawn `cloudflared tunnel --url http://localhost:<port>` and resolve
+ * with the assigned trycloudflare URL. Rejects when:
+ *
+ *   - The binary can't be spawned (cloudflared not installed / wrong
+ *     path / permission denied). Error message includes the install
+ *     hint.
+ *   - cloudflared exits before printing a URL. Error includes any
+ *     captured stderr tail.
+ *   - URL detection times out. Error includes elapsed time + last
+ *     ~10 lines of stderr so the operator can diagnose.
+ */
+export function spawnCloudflaredTunnel(opts) {
+    const binary = opts.binary ?? 'cloudflared';
+    const port = opts.port;
+    const timeout = opts.urlTimeoutMs ?? DEFAULT_URL_TIMEOUT_MS;
+    const log = opts.onLog ?? (() => { });
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(binary, ['tunnel', '--url', `http://localhost:${port}`, '--no-autoupdate'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch (err) {
+            reject(new Error(`Failed to spawn ${binary}: ${err.message}. ` +
+                `Install cloudflared from https://github.com/cloudflare/cloudflared/releases.`));
+            return;
+        }
+        // Tail buffer for error context — cap so a chatty cloudflared
+        // version doesn't balloon memory.
+        const stderrTail = [];
+        const MAX_TAIL = 50;
+        let url;
+        let urlResolved = false;
+        let closed = false;
+        const startedAt = Date.now();
+        const timer = setTimeout(() => {
+            if (!urlResolved) {
+                reject(new Error(`cloudflared did not emit a tunnel URL within ${timeout}ms. ` +
+                    `Last stderr lines:\n${stderrTail.slice(-10).join('\n')}`));
+                void close();
+            }
+        }, timeout);
+        function handleLine(line) {
+            log(line);
+            stderrTail.push(line);
+            if (stderrTail.length > MAX_TAIL) {
+                stderrTail.shift();
+            }
+            if (urlResolved)
+                return;
+            const match = line.match(TRYCLOUDFLARE_URL_RE);
+            if (match) {
+                url = match[0];
+                urlResolved = true;
+                clearTimeout(timer);
+                resolve({
+                    url,
+                    close,
+                });
+            }
+        }
+        // cloudflared logs to BOTH stdout and stderr depending on version
+        // — wire both through the same line-handler so the regex catches
+        // wherever it lands.
+        function attachLineReader(stream) {
+            let buf = '';
+            stream.setEncoding('utf8');
+            stream.on('data', (chunk) => {
+                buf += chunk;
+                let nl = buf.indexOf('\n');
+                while (nl !== -1) {
+                    const line = buf.slice(0, nl).trimEnd();
+                    buf = buf.slice(nl + 1);
+                    if (line.length > 0)
+                        handleLine(line);
+                    nl = buf.indexOf('\n');
+                }
+            });
+        }
+        if (child.stderr)
+            attachLineReader(child.stderr);
+        if (child.stdout)
+            attachLineReader(child.stdout);
+        child.on('error', (err) => {
+            clearTimeout(timer);
+            if (!urlResolved) {
+                reject(new Error(`cloudflared spawn error: ${err.message}. ` +
+                    `Verify the binary is installed and executable.`));
+            }
+        });
+        child.on('exit', (code, sig) => {
+            clearTimeout(timer);
+            if (!urlResolved) {
+                reject(new Error(`cloudflared exited (code=${code}, signal=${sig}) before ` +
+                    `emitting a tunnel URL (elapsed ${Date.now() - startedAt}ms). ` +
+                    `Last stderr lines:\n${stderrTail.slice(-10).join('\n')}`));
+            }
+        });
+        function close() {
+            if (closed)
+                return Promise.resolve();
+            closed = true;
+            return new Promise((resolveClose) => {
+                if (child.killed || child.exitCode !== null) {
+                    resolveClose();
+                    return;
+                }
+                const killTimer = setTimeout(() => {
+                    if (!child.killed && child.exitCode === null) {
+                        child.kill('SIGKILL');
+                    }
+                }, 5000);
+                child.once('exit', () => {
+                    clearTimeout(killTimer);
+                    resolveClose();
+                });
+                child.kill('SIGTERM');
+            });
+        }
+        if (opts.signal) {
+            if (opts.signal.aborted) {
+                void close();
+            }
+            else {
+                opts.signal.addEventListener('abort', () => void close(), {
+                    once: true,
+                });
+            }
+        }
+    });
+}

package/dist/theme-command.d.ts

@@ -0,0 +1,4 @@
+export declare const THEME_HELP = "ggui theme \u2014 validate + inspect operator-authored DTCG themes\n\nUsage:\n  ggui theme <subcommand> [options]\n\nSubcommands:\n  validate <path>   Validate a JSON theme file against the ThemeDocumentV1 schema.\n\nRun `ggui theme <subcommand> --help` for subcommand-specific options.\n";
+export declare const THEME_VALIDATE_HELP = "ggui theme validate \u2014 validate a DTCG theme file\n\nUsage:\n  ggui theme validate <path>\n\nArguments:\n  <path>    Path to a JSON theme document (e.g. `./theme.json`).\n\nExit codes:\n  0   theme is valid\n  1   theme file is unreadable, not JSON, or fails schema validation\n  2   bad CLI usage (missing path argument)\n";
+export declare function runThemeCommand(args: readonly string[]): Promise<number>;
+//# sourceMappingURL=theme-command.d.ts.map

package/dist/theme-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-command.d.ts","sourceRoot":"","sources":["../src/theme-command.ts"],"names":[],"mappings":"AA2BA,eAAO,MAAM,UAAU,qSAStB,CAAC;AAEF,eAAO,MAAM,mBAAmB,4UAY/B,CAAC;AAEF,wBAAsB,eAAe,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAc9E"}

package/dist/theme-command.js

@@ -0,0 +1,154 @@
+/**
+ * `ggui theme <subcommand>` — operator-facing theme tooling.
+ *
+ * Today only `validate <path>` ships: reads a DTCG `theme.json` from
+ * disk, runs `safeParseThemeDocument` from `@ggui-ai/project-config`,
+ * and prints either a one-line success summary or a per-issue error
+ * list. Schema lives in `@ggui-ai/project-config` and is the single
+ * source of truth — this command never re-implements validation.
+ *
+ * Sibling of `gadget-command.ts` / `blueprint-command.ts`. Kept thin
+ * so future subcommands (`theme preview`, `theme diff`, …) drop in
+ * alongside `validate` without restructuring.
+ *
+ * Exit codes:
+ *   0  valid
+ *   1  invalid (schema violations rendered to stderr) or unreadable
+ *      input file
+ *   2  bad CLI usage (missing path, unknown subcommand, `--help` from
+ *      an empty router invocation)
+ */
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { safeParseThemeDocument, } from '@ggui-ai/project-config';
+export const THEME_HELP = `ggui theme — validate + inspect operator-authored DTCG themes
+
+Usage:
+  ggui theme <subcommand> [options]
+
+Subcommands:
+  validate <path>   Validate a JSON theme file against the ThemeDocumentV1 schema.
+
+Run \`ggui theme <subcommand> --help\` for subcommand-specific options.
+`;
+export const THEME_VALIDATE_HELP = `ggui theme validate — validate a DTCG theme file
+
+Usage:
+  ggui theme validate <path>
+
+Arguments:
+  <path>    Path to a JSON theme document (e.g. \`./theme.json\`).
+
+Exit codes:
+  0   theme is valid
+  1   theme file is unreadable, not JSON, or fails schema validation
+  2   bad CLI usage (missing path argument)
+`;
+export async function runThemeCommand(args) {
+    const [sub, ...rest] = args;
+    if (!sub || sub === '--help' || sub === '-h') {
+        process.stdout.write(THEME_HELP);
+        return sub ? 0 : 2;
+    }
+    switch (sub) {
+        case 'validate':
+            return runValidate(rest);
+        default:
+            process.stderr.write(`ggui theme: unknown subcommand "${sub}"\n\n`);
+            process.stderr.write(THEME_HELP);
+            return 2;
+    }
+}
+/* -------------------------------------------------------------------------- */
+/* validate                                                                   */
+/* -------------------------------------------------------------------------- */
+async function runValidate(args) {
+    if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) {
+        process.stdout.write(THEME_VALIDATE_HELP);
+        return 0;
+    }
+    if (args.length === 0) {
+        process.stderr.write(`ggui theme validate: missing <path> argument\n\n`);
+        process.stderr.write(THEME_VALIDATE_HELP);
+        return 2;
+    }
+    // Drop bare `--` if the operator used it as the long-flag terminator.
+    const positional = args.filter((a) => a !== '--');
+    const filePath = positional[0];
+    if (!filePath) {
+        process.stderr.write(`ggui theme validate: missing <path> argument\n\n`);
+        process.stderr.write(THEME_VALIDATE_HELP);
+        return 2;
+    }
+    if (positional.length > 1) {
+        process.stderr.write(`ggui theme validate: too many arguments (expected exactly one path)\n\n`);
+        process.stderr.write(THEME_VALIDATE_HELP);
+        return 2;
+    }
+    const absPath = resolve(process.cwd(), filePath);
+    let raw;
+    try {
+        raw = await readFile(absPath, 'utf-8');
+    }
+    catch (err) {
+        process.stderr.write(`ggui theme validate: cannot read ${absPath} — ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        process.stderr.write(`ggui theme validate: ${absPath} is not valid JSON — ${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    const result = safeParseThemeDocument(parsed);
+    if (!result.success) {
+        process.stderr.write(`ggui theme validate: ${absPath} failed schema validation (${result.error.issues.length} issue${result.error.issues.length === 1 ? '' : 's'})\n`);
+        for (const issue of result.error.issues) {
+            const path = issue.path.length === 0
+                ? '<root>'
+                : issue.path
+                    .map((seg) => typeof seg === 'number' ? `[${seg}]` : String(seg))
+                    .join('.');
+            process.stderr.write(`  · ${path}: ${issue.message}\n`);
+        }
+        return 1;
+    }
+    for (const line of describeValidTheme(absPath, result.data)) {
+        process.stdout.write(`${line}\n`);
+    }
+    return 0;
+}
+/**
+ * Build the success-path stdout lines. Pure so tests can pin the copy.
+ * Green styling is applied only when stdout is a TTY — pipes/captures
+ * stay clean for grep + assertions.
+ */
+function describeValidTheme(absPath, theme) {
+    const lines = [];
+    const mark = process.stdout.isTTY ? '✓' : '✓';
+    const nameSuffix = theme.$name ? ` (${theme.$name})` : '';
+    lines.push(`${mark} Theme valid${nameSuffix}`);
+    lines.push(`  file: ${absPath}`);
+    // Color palette count: each top-level entry in `color` is either a
+    // single-token role (e.g. `surface`) or a nested palette (e.g.
+    // `primary: { 50: …, 100: … }`). Both count as one palette/role —
+    // operators care about "how many colour groups did I declare?", not
+    // "how many leaf colour tokens".
+    const paletteCount = Object.keys(theme.color).length;
+    lines.push(`  color: ${paletteCount} palette${paletteCount === 1 ? '' : 's'}/role${paletteCount === 1 ? '' : 's'}`);
+    const optional = [];
+    if (theme.motion !== undefined)
+        optional.push('motion');
+    if (theme.accessibility !== undefined)
+        optional.push('accessibility');
+    if (theme.zIndex !== undefined)
+        optional.push('zIndex');
+    if (theme.canvas !== undefined)
+        optional.push('canvas');
+    lines.push(optional.length === 0
+        ? `  optional blocks: none`
+        : `  optional blocks: ${optional.join(', ')}`);
+    return lines;
+}

package/dist/theme-file-uploader.d.ts

@@ -0,0 +1,8 @@
+import type { ThemeFileUploader } from '@ggui-ai/mcp-server';
+/**
+ * Build a {@link ThemeFileUploader} bound to the directory holding
+ * `manifestPath`. The returned function writes
+ * `<dir>/<filename>` atomically. Idempotent for equal inputs.
+ */
+export declare function createThemeFileUploader(manifestPath: string): ThemeFileUploader;
+//# sourceMappingURL=theme-file-uploader.d.ts.map

package/dist/theme-file-uploader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-file-uploader.d.ts","sourceRoot":"","sources":["../src/theme-file-uploader.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAK7D;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,iBAAiB,CA6B/E"}

package/dist/theme-file-uploader.js

@@ -0,0 +1,58 @@
+/**
+ * `themeFileUploader` factory for `ggui serve`.
+ *
+ * Pairs with `createThemeWriter`: the upload route on the OSS server
+ * writes a DTCG theme document to a file alongside `ggui.json`, then
+ * calls the regular theme writer to point the manifest at that file.
+ *
+ * This factory ONLY handles the file-write half. The route ordering
+ * (uploader → writer) is the server's responsibility — see
+ * `mountDevtoolThemeRoutes` in `@ggui-ai/mcp-server`.
+ *
+ * Behavior:
+ *
+ *   - `filename` is gated upstream by the route (alphanumeric, `.json`
+ *     suffix, no path separators, no reserved-name shadowing). We
+ *     re-validate here as belt-and-braces — programmatic embedders
+ *     that called the seam directly should also get a clear refusal
+ *     rather than a silent path-traversal write.
+ *   - The file is written into `dirname(manifestPath)`, atomically
+ *     (`tmp` + `rename` + `fsync`) — same pattern the existing theme
+ *     writer uses for `ggui.json`.
+ *   - Content is serialised with 2-space indent and a trailing newline,
+ *     matching the manifest's formatting so the operator's repo stays
+ *     consistent.
+ */
+import { dirname, join } from 'node:path';
+import { promises as fs } from 'node:fs';
+const SAFE_FILENAME_RE = /^[a-zA-Z0-9._-]+\.json$/;
+const FORBIDDEN_FILENAMES = new Set(['ggui.json', 'package.json']);
+/**
+ * Build a {@link ThemeFileUploader} bound to the directory holding
+ * `manifestPath`. The returned function writes
+ * `<dir>/<filename>` atomically. Idempotent for equal inputs.
+ */
+export function createThemeFileUploader(manifestPath) {
+    const projectDir = dirname(manifestPath);
+    return async (filename, content) => {
+        if (!SAFE_FILENAME_RE.test(filename)) {
+            throw new Error(`themeFileUploader: filename must match /^[a-zA-Z0-9._-]+\\.json$/ — got ${JSON.stringify(filename)}`);
+        }
+        if (FORBIDDEN_FILENAMES.has(filename)) {
+            throw new Error(`themeFileUploader: filename "${filename}" would shadow a reserved file.`);
+        }
+        const target = join(projectDir, filename);
+        const next = `${JSON.stringify(content, null, 2)}\n`;
+        const tmp = `${target}.tmp`;
+        await fs.mkdir(projectDir, { recursive: true });
+        const handle = await fs.open(tmp, 'w');
+        try {
+            await handle.writeFile(next, 'utf-8');
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await fs.rename(tmp, target);
+    };
+}

package/dist/theme-writer.d.ts

@@ -0,0 +1,8 @@
+import type { ThemeWriter } from '@ggui-ai/mcp-server';
+/**
+ * Build a {@link ThemeWriter} bound to the manifest at `manifestPath`.
+ * The returned function is async, idempotent for equal inputs, and
+ * crash-safe via a `tmp` + `rename` write.
+ */
+export declare function createThemeWriter(manifestPath: string): ThemeWriter;
+//# sourceMappingURL=theme-writer.d.ts.map

package/dist/theme-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme-writer.d.ts","sourceRoot":"","sources":["../src/theme-writer.ts"],"names":[],"mappings":"AA6CA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,CA8DnE"}