@embeddables/cli 0.8.0 → 0.8.1

package/dist/auth/index.d.ts

@@ -0,0 +1,43 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+export declare const SUPABASE_URL = "https://ierxexdtyashuotcsjyo.supabase.co";
+export declare const SUPABASE_ANON_KEY = "sb_publishable_Vt8-msWNtn2hhOY3AA6RsQ_ueTx79Vo";
+export interface AuthConfig {
+    access_token: string;
+    refresh_token: string;
+    expires_at: number;
+    supabase_url: string;
+    supabase_anon_key: string;
+}
+/**
+ * Get the path to the auth config file
+ */
+export declare function getAuthFilePath(): string;
+/**
+ * Read auth config from file
+ */
+export declare function readAuthConfig(): AuthConfig | null;
+/**
+ * Write auth config to file
+ */
+export declare function writeAuthConfig(config: AuthConfig): void;
+/**
+ * Delete auth config file (logout)
+ */
+export declare function deleteAuthConfig(): void;
+/**
+ * Check if user is logged in (has valid auth config)
+ */
+export declare function isLoggedIn(): boolean;
+/**
+ * Get Supabase client instance
+ */
+export declare function getSupabaseClient(): SupabaseClient;
+/**
+ * Get authenticated Supabase client (with stored session)
+ */
+export declare function getAuthenticatedSupabaseClient(): Promise<SupabaseClient | null>;
+/**
+ * Get access token for authenticated requests
+ */
+export declare function getAccessToken(): string | null;
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAGpE,eAAO,MAAM,YAAY,6CAA6C,CAAA;AACtE,eAAO,MAAM,iBAAiB,mDAAmD,CAAA;AAEjF,MAAM,WAAW,UAAU;IACzB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAMD;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,UAAU,GAAG,IAAI,CAUlD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAGxD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAIvC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAcpC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAWlD;AAED;;GAEG;AACH,wBAAsB,8BAA8B,IAAI,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAcrF;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,IAAI,CAM9C"}

package/dist/auth/index.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createClient } from '@supabase/supabase-js';
+// TODO: Move to environment variables
+export const SUPABASE_URL = 'https://ierxexdtyashuotcsjyo.supabase.co'; // Replace with actual Supabase URL
+export const SUPABASE_ANON_KEY = 'sb_publishable_Vt8-msWNtn2hhOY3AA6RsQ_ueTx79Vo'; // Replace with actual Supabase anon key
+// Store auth globally in user's home directory
+const AUTH_DIR = path.join(os.homedir(), '.embeddables');
+const AUTH_FILE = path.join(AUTH_DIR, 'auth.json');
+/**
+ * Get the path to the auth config file
+ */
+export function getAuthFilePath() {
+    return AUTH_FILE;
+}
+/**
+ * Read auth config from file
+ */
+export function readAuthConfig() {
+    try {
+        if (!fs.existsSync(AUTH_FILE)) {
+            return null;
+        }
+        const content = fs.readFileSync(AUTH_FILE, 'utf8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Write auth config to file
+ */
+export function writeAuthConfig(config) {
+    fs.mkdirSync(AUTH_DIR, { recursive: true });
+    fs.writeFileSync(AUTH_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+/**
+ * Delete auth config file (logout)
+ */
+export function deleteAuthConfig() {
+    if (fs.existsSync(AUTH_FILE)) {
+        fs.unlinkSync(AUTH_FILE);
+    }
+}
+/**
+ * Check if user is logged in (has valid auth config)
+ */
+export function isLoggedIn() {
+    const config = readAuthConfig();
+    if (!config) {
+        return false;
+    }
+    // Check if token is expired (with 5 minute buffer)
+    const now = Math.floor(Date.now() / 1000);
+    const expiresAt = config.expires_at;
+    if (expiresAt && expiresAt < now + 300) {
+        return false;
+    }
+    return !!config.access_token;
+}
+/**
+ * Get Supabase client instance
+ */
+export function getSupabaseClient() {
+    const config = readAuthConfig();
+    const url = config?.supabase_url || SUPABASE_URL;
+    const anonKey = config?.supabase_anon_key || SUPABASE_ANON_KEY;
+    return createClient(url, anonKey, {
+        auth: {
+            persistSession: false, // We handle session persistence ourselves
+            autoRefreshToken: false, // No auto refresh for now
+        },
+    });
+}
+/**
+ * Get authenticated Supabase client (with stored session)
+ */
+export async function getAuthenticatedSupabaseClient() {
+    const config = readAuthConfig();
+    if (!config || !isLoggedIn()) {
+        return null;
+    }
+    const client = getSupabaseClient();
+    // Set the session manually
+    await client.auth.setSession({
+        access_token: config.access_token,
+        refresh_token: config.refresh_token,
+    });
+    return client;
+}
+/**
+ * Get access token for authenticated requests
+ */
+export function getAccessToken() {
+    const config = readAuthConfig();
+    if (!config || !isLoggedIn()) {
+        return null;
+    }
+    return config.access_token;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,210 @@
+import * as Sentry from '@sentry/node';
+Sentry.init({
+    dsn: 'https://1660165be6d73c50814963e5c6bbd5dc@o4510046767742976.ingest.us.sentry.io/4510908525379584',
+    tracesSampleRate: 1.0,
+    enableLogs: true,
+    // debug: true,
+});
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Command, Option } from 'commander';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const require = createRequire(import.meta.url);
+const pkg = require(path.join(__dirname, '..', 'package.json'));
+Sentry.getCurrentScope().setAttributes({ cliVersion: pkg.version });
+import { isLoggedIn } from './auth/index.js';
+import { getSentryContextFromProjectConfig, setSentryContext, setSentryUserFromAuth, } from './sentry-context.js';
+import { runBranch } from './commands/branch.js';
+import { runBuild } from './commands/build.js';
+import { runDev } from './commands/dev.js';
+import { runBuilderOpen } from './commands/builder-open.js';
+import { runExperimentsConnect } from './commands/experiments-connect.js';
+import { runInit } from './commands/init.js';
+import { runInspect } from './commands/inspect.js';
+import { runLogin } from './commands/login.js';
+import { runLogout } from './commands/logout.js';
+import { runPull } from './commands/pull.js';
+import { runSave } from './commands/save.js';
+import { runUpgrade } from './commands/upgrade.js';
+import { exit } from './logger.js';
+import * as stdout from './stdout.js';
+/** Only these commands may run without being logged in. All others require login. */
+const COMMANDS_ALLOWED_WITHOUT_LOGIN = new Set(['login', 'logout', 'upgrade']);
+async function requireLogin(commandName) {
+    const baseCommand = commandName.split(' ')[0];
+    if (COMMANDS_ALLOWED_WITHOUT_LOGIN.has(baseCommand))
+        return;
+    if (isLoggedIn())
+        return;
+    stdout.warn('Not logged in.');
+    stdout.dim('Run "embeddables login" first.');
+    await exit(1);
+}
+/** Set Sentry context from config and auth for the current command. Config is set immediately; user is set in background so we don't block on auth. */
+function setSentryContextForCommand() {
+    setSentryContext(getSentryContextFromProjectConfig());
+    void setSentryUserFromAuth();
+}
+const program = new Command();
+program
+    .name('embeddables')
+    .description('Embeddables CLI')
+    .version(pkg.version, '-v, --version', 'Show CLI version')
+    .enablePositionalOptions();
+program
+    .command('init')
+    .description('Initialize a new Embeddables project')
+    .option('-p, --project-id <id>', 'Embeddables project ID')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(async (opts) => {
+    await requireLogin('init');
+    setSentryContextForCommand();
+    await runInit({ projectId: opts.projectId, yes: opts.yes });
+});
+program
+    .command('build')
+    .option('-i, --id <id>', 'Embeddable ID (will prompt if not provided)')
+    .option('-p, --pages <glob>', 'Pages glob')
+    .option('-o, --out <path>', 'Output json path')
+    .option('--fix', 'Apply lint fixes (duplicate IDs, keys/IDs starting with a number)')
+    .option('--pageKeyFrom <mode>', 'filename|export', 'filename')
+    .action(async (opts) => {
+    await requireLogin('build');
+    setSentryContextForCommand();
+    await runBuild(opts);
+});
+program
+    .command('dev')
+    .option('-i, --id <id>', 'Embeddable ID (will prompt if not provided)')
+    .option('-p, --pages <glob>', 'Pages glob')
+    .option('-o, --out <path>', 'Output json path')
+    .option('--fix', 'Apply lint fixes (duplicate IDs, keys/IDs starting with a number)')
+    .option('-L, --local', 'Use local engine (http://localhost:8787)')
+    .option('-e, --engine <url>', 'Engine origin', 'https://engine.embeddables.com')
+    .option('--port <n>', 'Dev proxy port', '3000')
+    .option('--overrideRoute <path>', 'Route to override in proxy (exact match, no wildcards yet)', '/init')
+    .option('--pageKeyFrom <mode>', 'filename|export', 'filename')
+    .action(async (opts) => {
+    await requireLogin('dev');
+    setSentryContextForCommand();
+    // --local flag overrides --engine to use local engine
+    if (opts.local) {
+        opts.engine = 'http://localhost:8787';
+    }
+    await runDev(opts);
+});
+program
+    .command('login')
+    .description('Login to Embeddables')
+    .action(async () => {
+    await runLogin();
+});
+program
+    .command('logout')
+    .description('Logout from Embeddables')
+    .action(async () => {
+    await runLogout();
+});
+program
+    .command('pull')
+    .description('Pull an embeddable from the cloud')
+    .option('-i, --id <id>', 'Embeddable ID to pull (interactive selection if not provided)')
+    .option('-o, --out <path>', 'Output json path')
+    .option('--version [version]', 'Version to pull; omit flag for latest, use without value for interactive selector, or pass a number')
+    .option('-b, --branch <branch_id>', 'Embeddable branch ID')
+    .option('-f, --fix', 'Fix by removing components missing required props (warn instead of error)')
+    .option('-p, --preserve', 'Preserve component order in config for forward compile')
+    .action(async (opts) => {
+    await requireLogin('pull');
+    setSentryContextForCommand();
+    const selectVersion = opts.version === true;
+    await runPull({
+        ...opts,
+        version: selectVersion ? undefined : opts.version,
+        selectVersion,
+    });
+});
+program
+    .command('inspect')
+    .description('Fetch, reverse-compile, and rebuild an embeddable for debugging')
+    .requiredOption('-i, --id <id>', 'Embeddable ID to inspect')
+    .option('--version <version>', 'Version to inspect (number or "latest")', 'latest')
+    .option('-b, --branch <branch_id>', 'Embeddable branch ID')
+    .option('-f, --fix', 'Fix by removing components missing required props', true)
+    .option('-e, --engine <url>', 'Engine origin', 'https://engine.embeddables.com')
+    .addOption(new Option('--bypass-auth').hideHelp())
+    .action(async (opts) => {
+    if (!opts.bypassAuth) {
+        await requireLogin('inspect');
+    }
+    setSentryContextForCommand();
+    await runInspect({
+        id: opts.id,
+        version: opts.version,
+        branch: opts.branch,
+        fix: opts.fix,
+        engine: opts.engine,
+    });
+});
+program
+    .command('save')
+    .description('Build and save an embeddable to the cloud')
+    .option('-i, --id <id>', 'Embeddable ID (will prompt if not provided)')
+    .option('-l, --label <label>', 'Human-readable label for this version')
+    .option('-b, --branch <branch_id>', 'Branch ID to save to')
+    .option('-s, --skip-build', 'Skip the build step and use existing compiled JSON')
+    .option('--from-version <number>', 'Base version number (auto-detected from local files if not provided)')
+    .action(async (opts) => {
+    await requireLogin('save');
+    setSentryContextForCommand();
+    await runSave({
+        id: opts.id,
+        label: opts.label,
+        branch: opts.branch,
+        skipBuild: opts.skipBuild,
+        fromVersion: opts.fromVersion,
+    });
+});
+program
+    .command('upgrade')
+    .description('Update the CLI to the latest stable version')
+    .action(async () => {
+    await runUpgrade();
+});
+program
+    .command('branch')
+    .description('Switch to a different branch of an embeddable')
+    .option('-i, --id <id>', 'Embeddable ID (will prompt if not provided)')
+    .action(async (opts) => {
+    await requireLogin('branch');
+    setSentryContextForCommand();
+    await runBranch(opts);
+});
+const builder = program.command('builder').description('Embeddables Builder utilities');
+builder
+    .command('open')
+    .description('Open the Embeddables Builder in the browser')
+    .option('-i, --id <id>', 'Embeddable ID (will prompt if not provided)')
+    .action(async (opts) => {
+    await requireLogin('builder open');
+    setSentryContextForCommand();
+    await runBuilderOpen({ id: opts.id });
+});
+const experiments = program.command('experiments').description('Manage embeddable experiments');
+experiments
+    .command('connect')
+    .description('Connect an experiment to an embeddable')
+    .option('-i, --id <id>', 'Embeddable ID (will prompt if not provided)')
+    .option('--experiment-id <id>', 'Experiment ID (will prompt to choose from project if not provided)')
+    .option('--experiment-key <key>', 'Experiment key (required if --experiment-id is set)')
+    .action(async (opts) => {
+    await requireLogin('experiments connect');
+    setSentryContextForCommand();
+    await runExperimentsConnect({
+        id: opts.id,
+        experimentId: opts.experimentId,
+        experimentKey: opts.experimentKey,
+    });
+});
+await program.parseAsync(process.argv);

package/dist/command-history.d.ts

@@ -0,0 +1,13 @@
+export interface CommandHistoryEntry {
+    command: string;
+    args: string[];
+    exitCode: number;
+    durationMs: number;
+    timestamp: string;
+    error?: string;
+}
+export declare function getHistoryFilePath(): string;
+export declare function readHistory(): CommandHistoryEntry[];
+export declare function writeHistoryEntry(entry: CommandHistoryEntry): void;
+export declare function getLastHistoryEntry(): CommandHistoryEntry | null;
+//# sourceMappingURL=command-history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command-history.d.ts","sourceRoot":"","sources":["../src/command-history.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED,wBAAgB,WAAW,IAAI,mBAAmB,EAAE,CAUnD;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAMlE;AAED,wBAAgB,mBAAmB,IAAI,mBAAmB,GAAG,IAAI,CAGhE"}

package/dist/command-history.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const MAX_ENTRIES = 20;
+const HISTORY_DIR = path.join(os.homedir(), '.embeddables');
+const HISTORY_FILE = path.join(HISTORY_DIR, 'history.json');
+export function getHistoryFilePath() {
+    return HISTORY_FILE;
+}
+export function readHistory() {
+    try {
+        if (!fs.existsSync(HISTORY_FILE))
+            return [];
+        const raw = fs.readFileSync(HISTORY_FILE, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+export function writeHistoryEntry(entry) {
+    const history = readHistory();
+    history.push(entry);
+    const trimmed = history.slice(-MAX_ENTRIES);
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(trimmed, null, 2), 'utf8');
+}
+export function getLastHistoryEntry() {
+    const history = readHistory();
+    return history.length > 0 ? history[history.length - 1] : null;
+}

package/dist/commands/branch.d.ts

@@ -0,0 +1,4 @@
+export declare function runBranch(opts: {
+    id?: string;
+}): Promise<void>;
+//# sourceMappingURL=branch.d.ts.map

package/dist/commands/branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch.d.ts","sourceRoot":"","sources":["../../src/commands/branch.ts"],"names":[],"mappings":"AASA,wBAAsB,SAAS,CAAC,IAAI,EAAE;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,iBAqEpD"}

package/dist/commands/branch.js

@@ -0,0 +1,67 @@
+import pc from 'picocolors';
+import { isLoggedIn } from '../auth/index.js';
+import { runPull } from './pull.js';
+import { promptForLocalEmbeddable, fetchBranches, promptForBranch } from '../prompts/index.js';
+import { createLogger, exit } from '../logger.js';
+import { getSentryContextFromProjectConfig, setSentryContext } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+export async function runBranch(opts) {
+    const logger = createLogger('runBranch');
+    // Check login status
+    if (!isLoggedIn()) {
+        stdout.warn('Not logged in.');
+        stdout.dim('Run "embeddables login" first.');
+        logger.error('not logged in');
+        await exit(1);
+    }
+    // Get embeddable ID
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    setSentryContext(getSentryContextFromProjectConfig());
+    if (!embeddableId) {
+        const selected = await promptForLocalEmbeddable();
+        if (!selected) {
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+    }
+    if (embeddableId) {
+        setSentryContext({ embeddable: { id: embeddableId } });
+    }
+    // Fetch branches for this embeddable
+    const branches = await stdout.withSpinner('Fetching branches…', async () => {
+        return fetchBranches(embeddableId);
+    }, {
+        successText: (b) => `Fetched ${b.length} branch(es)`,
+    });
+    if (branches.length === 0) {
+        stdout.warn('No branches found for this embeddable.');
+        stdout.dim('Branches are created in the Embeddables Builder.');
+        return;
+    }
+    // Prompt for branch selection
+    const selectedBranch = await promptForBranch(branches);
+    stdout.gap();
+    // Pull the selected branch
+    if (selectedBranch === null) {
+        // User selected "main" - pull without branch
+        stdout.step('Switching to main (latest published version)…');
+        await runPull({ id: embeddableId, useMain: true });
+    }
+    else {
+        setSentryContext({
+            branch: { id: selectedBranch.id, name: selectedBranch.name },
+        });
+        stdout.step(`Switching to branch: ${pc.bold(selectedBranch.name)}…`);
+        await runPull({
+            id: embeddableId,
+            branch: selectedBranch.id,
+            branchName: selectedBranch.name,
+        });
+    }
+}

package/dist/commands/build-workbench.d.ts

@@ -0,0 +1,5 @@
+export declare function runBuildWorkbench(opts: {
+    out?: string;
+    minify?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=build-workbench.d.ts.map

package/dist/commands/build-workbench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-workbench.d.ts","sourceRoot":"","sources":["../../src/commands/build-workbench.ts"],"names":[],"mappings":"AASA,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,iBA4H/E"}

package/dist/commands/build-workbench.js

@@ -0,0 +1,116 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import * as esbuild from 'esbuild';
+import postcss from 'postcss';
+import tailwindcss from '@tailwindcss/postcss';
+import autoprefixer from 'autoprefixer';
+import { createLogger, exit } from '../logger.js';
+import * as stdout from '../stdout.js';
+export async function runBuildWorkbench(opts) {
+    const logger = createLogger('runBuildWorkbench');
+    const outDir = opts.out || 'dist/workbench';
+    const shouldMinify = opts.minify ?? true;
+    // Check if wrangler config exists in outDir (native Cloudflare Git integration mode)
+    const hasWranglerConfig = fs.existsSync(path.join(outDir, 'wrangler.jsonc')) ||
+        fs.existsSync(path.join(outDir, 'wrangler.toml'));
+    stdout.step('Building Workbench for CDN deployment…');
+    stdout.gap();
+    // Ensure output directory exists
+    fs.mkdirSync(outDir, { recursive: true });
+    const workbenchEntry = path.join(process.cwd(), 'src', 'workbench', 'index.tsx');
+    const workbenchCssEntry = path.join(process.cwd(), 'src', 'workbench', 'workbench.css');
+    // Check that source files exist
+    if (!fs.existsSync(workbenchEntry)) {
+        stdout.error(`Workbench entry not found: ${workbenchEntry}`);
+        logger.error('workbench entry not found', { path: workbenchEntry });
+        await exit(1);
+    }
+    if (!fs.existsSync(workbenchCssEntry)) {
+        stdout.error(`Workbench CSS not found: ${workbenchCssEntry}`);
+        logger.error('workbench css not found', { path: workbenchCssEntry });
+        await exit(1);
+    }
+    // Build JavaScript bundle
+    const jsResult = await stdout.withSpinner('Building JavaScript bundle…', async () => {
+        return esbuild.build({
+            entryPoints: [workbenchEntry],
+            bundle: true,
+            format: 'iife',
+            globalName: '__EmbeddablesWorkbenchBundle',
+            platform: 'browser',
+            minify: shouldMinify,
+            sourcemap: shouldMinify ? false : 'inline',
+            write: false,
+            target: ['es2020', 'chrome80', 'firefox78', 'safari14'],
+        });
+    }, { successText: 'JavaScript bundle built' });
+    const jsOutput = jsResult.outputFiles?.[0];
+    if (!jsOutput) {
+        stdout.error('Failed to build JavaScript bundle');
+        logger.error('workbench js bundle build failed');
+        await exit(1);
+    }
+    // Build CSS
+    const cssResult = await stdout.withSpinner('Building CSS…', async () => {
+        const rawCss = fs.readFileSync(workbenchCssEntry, 'utf8');
+        return postcss([tailwindcss(), autoprefixer]).process(rawCss, {
+            from: workbenchCssEntry,
+        });
+    }, { successText: 'CSS built' });
+    // CORS headers file for Cloudflare static assets
+    const headersContent = `/*
+  Access-Control-Allow-Origin: *
+  Access-Control-Allow-Methods: GET, OPTIONS
+  Access-Control-Allow-Headers: Content-Type
+`;
+    if (hasWranglerConfig) {
+        // Native Cloudflare Git integration mode:
+        // Output directly to outDir/public
+        const publicDir = path.join(outDir, 'public');
+        fs.mkdirSync(publicDir, { recursive: true });
+        fs.writeFileSync(path.join(publicDir, 'workbench.js'), jsOutput.contents);
+        const jsSize = (jsOutput.contents.length / 1024).toFixed(1);
+        fs.writeFileSync(path.join(publicDir, 'workbench.css'), cssResult.css);
+        const cssSize = (cssResult.css.length / 1024).toFixed(1);
+        fs.writeFileSync(path.join(publicDir, '_headers'), headersContent);
+        stdout.success(`Build complete (JS: ${jsSize} KB, CSS: ${cssSize} KB)`);
+        stdout.dim('Using existing wrangler.toml for Cloudflare Git integration');
+    }
+    else {
+        // Standalone mode: output to outDir with nested cloudflare-worker folder
+        const jsPath = path.join(outDir, 'workbench.js');
+        fs.writeFileSync(jsPath, jsOutput.contents);
+        const jsSize = (jsOutput.contents.length / 1024).toFixed(1);
+        const cssPath = path.join(outDir, 'workbench.css');
+        fs.writeFileSync(cssPath, cssResult.css);
+        const cssSize = (cssResult.css.length / 1024).toFixed(1);
+        // Generate Cloudflare static site files
+        const workerDir = path.join(outDir, 'cloudflare');
+        fs.mkdirSync(workerDir, { recursive: true });
+        const wranglerConfig = generateWranglerConfig();
+        fs.writeFileSync(path.join(workerDir, 'wrangler.jsonc'), wranglerConfig);
+        const publicDir = path.join(workerDir, 'public');
+        fs.mkdirSync(publicDir, { recursive: true });
+        fs.copyFileSync(jsPath, path.join(publicDir, 'workbench.js'));
+        fs.copyFileSync(cssPath, path.join(publicDir, 'workbench.css'));
+        fs.writeFileSync(path.join(publicDir, '_headers'), headersContent);
+        stdout.success(`Build complete (JS: ${jsSize} KB, CSS: ${cssSize} KB)`);
+        stdout.gap();
+        stdout.dim(`Deploy: cd ${workerDir} && npx wrangler deploy`);
+    }
+    stdout.gap();
+    stdout.dim('Usage: Add ?workbench=true to any engine preview URL');
+    stdout.gap();
+}
+function generateWranglerConfig() {
+    return `{
+  // Embeddables Workbench - Static Assets
+  // Deploy: npx wrangler deploy
+  "name": "embeddables-workbench",
+  "compatibility_date": "2024-01-01",
+  "assets": {
+    "directory": "./public"
+  }
+}
+`;
+}

package/dist/commands/build.d.ts

@@ -0,0 +1,8 @@
+export declare function runBuild(opts: {
+    id?: string;
+    pages?: string;
+    out?: string;
+    fix?: boolean;
+    pageKeyFrom: 'filename' | 'export';
+}): Promise<void>;
+//# sourceMappingURL=build.d.ts.map

package/dist/commands/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/commands/build.ts"],"names":[],"mappings":"AAaA,wBAAsB,QAAQ,CAAC,IAAI,EAAE;IACnC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,WAAW,EAAE,UAAU,GAAG,QAAQ,CAAA;CACnC,iBA2DA"}