@embeddables/cli 0.7.19 → 0.8.1

package/dist/commands/inspect.js

@@ -0,0 +1,293 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { reverseCompile } from '../compiler/reverse.js';
+import { compileAllPages } from '../compiler/index.js';
+import { formatError } from '../compiler/errors.js';
+import { captureException, createLogger, exit } from '../logger.js';
+import * as stdout from '../stdout.js';
+/**
+ * Normalize custom_validation_function strings so literal "\\n" (backslash-n) becomes real newline.
+ * (Copied from pull.ts — the engine sometimes returns double-escaped newlines.)
+ */
+function normalizeCustomValidationFunctionsInFlow(flow) {
+    function walkComponent(comp) {
+        const v = comp.custom_validation_function;
+        if (typeof v === 'string') {
+            comp.custom_validation_function = v.replace(/\\n/g, '\n');
+        }
+        const children = comp.components ?? comp.buttons;
+        if (Array.isArray(children)) {
+            for (const c of children) {
+                if (c && typeof c === 'object')
+                    walkComponent(c);
+            }
+        }
+    }
+    const pages = flow.pages;
+    if (Array.isArray(pages)) {
+        for (const page of pages) {
+            if (page && typeof page === 'object' && Array.isArray(page.components)) {
+                for (const comp of page.components) {
+                    if (comp && typeof comp === 'object')
+                        walkComponent(comp);
+                }
+            }
+        }
+    }
+    const components = flow.components;
+    if (Array.isArray(components)) {
+        for (const comp of components) {
+            if (comp && typeof comp === 'object')
+                walkComponent(comp);
+        }
+    }
+}
+/**
+ * Compare two JSON objects and return a summary of differences.
+ * Returns null if they are identical.
+ */
+function compareJson(original, rebuilt) {
+    const originalStr = JSON.stringify(original, null, 2);
+    const rebuiltStr = JSON.stringify(rebuilt, null, 2);
+    if (originalStr === rebuiltStr) {
+        return { identical: true, summary: 'Original and rebuilt JSON are identical.' };
+    }
+    // Find key-level differences at the top level
+    const allKeys = new Set([...Object.keys(original), ...Object.keys(rebuilt)]);
+    const diffs = [];
+    for (const key of allKeys) {
+        const inOrig = key in original;
+        const inRebuilt = key in rebuilt;
+        if (!inOrig && inRebuilt) {
+            diffs.push(`  + "${key}": present in rebuilt but not original`);
+        }
+        else if (inOrig && !inRebuilt) {
+            diffs.push(`  - "${key}": present in original but not rebuilt`);
+        }
+        else {
+            const origVal = JSON.stringify(original[key]);
+            const rebuiltVal = JSON.stringify(rebuilt[key]);
+            if (origVal !== rebuiltVal) {
+                if (key === 'pages' && Array.isArray(original[key]) && Array.isArray(rebuilt[key])) {
+                    const origPages = original[key];
+                    const rebuiltPages = rebuilt[key];
+                    if (origPages.length !== rebuiltPages.length) {
+                        diffs.push(`  ~ "pages": ${origPages.length} pages in original, ${rebuiltPages.length} in rebuilt`);
+                    }
+                    else {
+                        const changedPages = [];
+                        for (let i = 0; i < origPages.length; i++) {
+                            if (JSON.stringify(origPages[i]) !== JSON.stringify(rebuiltPages[i])) {
+                                changedPages.push(origPages[i].key || `index ${i}`);
+                            }
+                        }
+                        diffs.push(`  ~ "pages": ${changedPages.length}/${origPages.length} page(s) differ: ${changedPages.join(', ')}`);
+                    }
+                }
+                else if (key === 'styles') {
+                    const origCount = typeof original[key] === 'object' ? Object.keys(original[key]).length : 0;
+                    const rebuiltCount = typeof rebuilt[key] === 'object' ? Object.keys(rebuilt[key]).length : 0;
+                    diffs.push(`  ~ "styles": ${origCount} selector(s) in original, ${rebuiltCount} in rebuilt`);
+                }
+                else {
+                    // Truncate for readability
+                    const maxLen = 80;
+                    const origPreview = origVal && origVal.length > maxLen ? origVal.slice(0, maxLen) + '...' : origVal;
+                    const rebuiltPreview = rebuiltVal && rebuiltVal.length > maxLen
+                        ? rebuiltVal.slice(0, maxLen) + '...'
+                        : rebuiltVal;
+                    diffs.push(`  ~ "${key}": differs`);
+                    diffs.push(`      original: ${origPreview}`);
+                    diffs.push(`      rebuilt:  ${rebuiltPreview}`);
+                }
+            }
+        }
+    }
+    return {
+        identical: false,
+        summary: `Found ${diffs.filter((d) => d.startsWith('  ')).length} top-level difference(s):\n${diffs.join('\n')}`,
+    };
+}
+export async function runInspect(opts) {
+    const logger = createLogger('runInspect');
+    const embeddableId = opts.id;
+    const totalTimer = stdout.timer();
+    stdout.header('Embeddable Inspector', 'Fetches, reverse-compiles, and rebuilds an embeddable for debugging.');
+    // 1. Fetch embeddable JSON from engine
+    const versionParam = opts.version || 'latest';
+    const engineOrigin = opts.engine || 'https://engine.embeddables.com';
+    let url = `${engineOrigin}/${embeddableId}?version=${versionParam}`;
+    if (opts.branch)
+        url += `&embeddable_branch=${opts.branch}`;
+    let flow;
+    let pullVersion;
+    try {
+        const result = await stdout.withSpinner(`Fetching from ${engineOrigin}…`, async () => {
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch embeddable: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            if (!data.flow) {
+                throw new Error("Response does not contain a 'flow' property");
+            }
+            return data;
+        }, { successText: 'Fetched embeddable' });
+        flow = result.flow;
+        pullVersion = result.version ?? result.embeddable_version ?? flow.version;
+        normalizeCustomValidationFunctionsInFlow(flow);
+        stdout.kvRow([
+            ['ID', embeddableId],
+            ['Version', String(pullVersion ?? 'unknown')],
+            ['Pages', String(flow.pages?.length ?? 0)],
+        ]);
+    }
+    catch (error) {
+        captureException(error);
+        stdout.error(`Failed to fetch embeddable: ${error instanceof Error ? error.message : String(error)}`);
+        logger.error('inspect fetch failed', {
+            message: error instanceof Error ? error.message : String(error),
+        });
+        await exit(1);
+        return;
+    }
+    // 2. Write original JSON to disk
+    const baseDir = path.join('embeddables', embeddableId);
+    const generatedDir = path.join(baseDir, '.generated');
+    const originalJsonPath = path.join(generatedDir, 'embeddable-original.json');
+    fs.mkdirSync(generatedDir, { recursive: true });
+    const originalJson = JSON.stringify(flow, null, 2);
+    fs.writeFileSync(originalJsonPath, originalJson, 'utf8');
+    // 3. Clear any existing files before reverse-compiling
+    const pagesDir = path.join(baseDir, 'pages');
+    const stylesDir = path.join(baseDir, 'styles');
+    const computedFieldsDir = path.join(baseDir, 'computed-fields');
+    const actionsDir = path.join(baseDir, 'actions');
+    const globalComponentsDir = path.join(baseDir, 'global-components');
+    let clearedCount = 0;
+    for (const [dir, ext] of [
+        [pagesDir, '.page.tsx'],
+        [stylesDir, '.css'],
+        [computedFieldsDir, '.js'],
+        [actionsDir, '.js'],
+        [globalComponentsDir, '.location.tsx'],
+    ]) {
+        if (fs.existsSync(dir)) {
+            const files = fs.readdirSync(dir).filter((f) => f.endsWith(ext));
+            for (const file of files) {
+                fs.unlinkSync(path.join(dir, file));
+            }
+            clearedCount += files.length;
+        }
+    }
+    if (clearedCount > 0) {
+        stdout.dim(`Cleaned up ${clearedCount} existing files`);
+    }
+    // 4. Reverse compile: JSON -> React code
+    try {
+        await stdout.withSpinner('Reverse-compiling JSON → React…', async () => {
+            stdout.mute();
+            try {
+                await reverseCompile(flow, embeddableId, {
+                    fix: opts.fix ?? true, // Default to fix mode for inspect
+                    preserve: true,
+                });
+            }
+            finally {
+                stdout.unmute();
+            }
+        }, {
+            successText: 'Reverse compile complete',
+        });
+    }
+    catch (error) {
+        captureException(error);
+        stdout.error(`Reverse compile failed: ${error instanceof Error ? error.message : String(error)}`);
+        logger.error('inspect reverse-compile failed', {
+            message: error instanceof Error ? error.message : String(error),
+        });
+        await exit(1);
+        return;
+    }
+    // 5. List generated files for visibility
+    stdout.gap();
+    const treeEntries = [];
+    const collectDir = (dir, label) => {
+        if (!fs.existsSync(dir))
+            return;
+        const files = fs.readdirSync(dir).filter((f) => !f.startsWith('.'));
+        if (files.length === 0)
+            return;
+        treeEntries.push(`${label}/ (${files.length} files)`);
+    };
+    collectDir(pagesDir, 'pages');
+    collectDir(stylesDir, 'styles');
+    collectDir(computedFieldsDir, 'computed-fields');
+    collectDir(actionsDir, 'actions');
+    collectDir(globalComponentsDir, 'global-components');
+    if (treeEntries.length > 0) {
+        stdout.fileTree(`embeddables/${embeddableId}/`, treeEntries);
+    }
+    // 6. Build: React code -> JSON
+    const rebuiltJsonPath = path.join(generatedDir, 'embeddable-rebuilt.json');
+    const pagesGlob = `embeddables/${embeddableId}/pages/**/*.page.tsx`;
+    try {
+        await stdout.withSpinner('Rebuilding React → JSON…', async () => {
+            await compileAllPages({
+                pagesGlob,
+                outPath: rebuiltJsonPath,
+                pageKeyFrom: 'filename',
+                stylesDir,
+                embeddableId,
+                fixLint: true,
+            });
+        }, {
+            successText: `Build complete → ${rebuiltJsonPath}`,
+        });
+    }
+    catch (error) {
+        captureException(error);
+        stdout.error(`Build failed: ${formatError(error)}`);
+        logger.error('inspect build failed', {
+            message: error instanceof Error ? error.message : String(error),
+        });
+        await exit(1);
+        return;
+    }
+    // 7. Compare original vs rebuilt
+    stdout.gap();
+    try {
+        const rebuiltContent = fs.readFileSync(rebuiltJsonPath, 'utf8');
+        const rebuilt = JSON.parse(rebuiltContent);
+        const result = compareJson(flow, rebuilt);
+        if (result.identical) {
+            stdout.box(`${pc.green(result.summary)}`, {
+                borderColor: 'green',
+                title: 'Comparison',
+            });
+        }
+        else {
+            stdout.box(`${pc.yellow(result.summary)}`, {
+                borderColor: 'yellow',
+                title: 'Comparison',
+            });
+        }
+    }
+    catch (error) {
+        stdout.error(`Comparison failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // 8. Summary
+    stdout.gap();
+    stdout.kvBlock([
+        ['Original JSON', originalJsonPath],
+        ['Rebuilt JSON', rebuiltJsonPath],
+        ['React code', `${baseDir}/pages/`],
+    ]);
+    stdout.gap();
+    stdout.successBox(`Completed in ${totalTimer()} ${stdout.symbols.sparkles}`);
+    logger.info('inspect complete', {
+        version: String(pullVersion ?? 'unknown'),
+        embeddableId,
+    });
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+export declare function runLogin(): Promise<void>;
+//# sourceMappingURL=login.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAYA,wBAAsB,QAAQ,kBA2H7B"}

package/dist/commands/login.js

@@ -0,0 +1,117 @@
+import { getSupabaseClient, writeAuthConfig, readAuthConfig, SUPABASE_URL, SUPABASE_ANON_KEY, } from '../auth/index.js';
+import { prompt } from '../helpers/prompt.js';
+import { captureException, createLogger, exit } from '../logger.js';
+import * as stdout from '../stdout.js';
+export async function runLogin() {
+    const logger = createLogger('runLogin');
+    try {
+        const supabase = getSupabaseClient();
+        // Check if already logged in
+        const existingConfig = readAuthConfig();
+        if (existingConfig?.access_token) {
+            const { overwrite } = await prompt({
+                type: 'confirm',
+                name: 'overwrite',
+                message: 'You are already logged in. Do you want to log in again?',
+                initial: false,
+            });
+            if (!overwrite) {
+                stdout.dim('Login cancelled.');
+                return;
+            }
+        }
+        // Prompt for email
+        const { email } = await prompt({
+            type: 'text',
+            name: 'email',
+            message: 'Enter your email address:',
+            validate: (value) => {
+                if (!value)
+                    return 'Email is required';
+                if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                    return 'Please enter a valid email address';
+                }
+                return true;
+            },
+        });
+        if (!email) {
+            stdout.dim('Login cancelled.');
+            return;
+        }
+        // Send OTP code
+        const sendSpinner = stdout.spinner('Sending verification code…');
+        const { error: sendError } = await supabase.auth.signInWithOtp({ email });
+        if (sendError) {
+            sendSpinner.fail('Failed to send verification code');
+            stdout.error(`Error sending verification code: ${sendError.message}`);
+            logger.error('failed to send OTP', { message: sendError.message });
+            await exit(1);
+        }
+        sendSpinner.succeed('Verification code sent!');
+        stdout.dim('Check your email for the code.');
+        stdout.gap();
+        // Prompt for OTP code
+        const { code } = await prompt({
+            type: 'text',
+            name: 'code',
+            message: 'Enter the verification code from your email:',
+            validate: (value) => {
+                if (!value)
+                    return 'Verification code is required';
+                if (!/^\d{6}$/.test(value.trim())) {
+                    return 'Please enter a valid 6-digit code';
+                }
+                return true;
+            },
+        });
+        if (!code) {
+            stdout.dim('Login cancelled.');
+            return;
+        }
+        // Verify OTP code
+        const verifySpinner = stdout.spinner('Verifying code…');
+        const { data, error: verifyError } = await supabase.auth.verifyOtp({
+            email,
+            token: code.trim(),
+            type: 'email',
+        });
+        if (verifyError) {
+            verifySpinner.fail('Verification failed');
+            stdout.error(`Error verifying code: ${verifyError.message}`);
+            logger.error('failed to verify OTP', { message: verifyError.message });
+            await exit(1);
+        }
+        if (!data.session) {
+            verifySpinner.fail('No session returned');
+            stdout.error('No session returned from verification');
+            logger.error('no session returned from verification');
+            await exit(1);
+            return;
+        }
+        // Store auth config
+        const config = {
+            access_token: data.session.access_token,
+            refresh_token: data.session.refresh_token,
+            expires_at: data.session.expires_at || Math.floor(Date.now() / 1000) + 3600, // Default 1 hour if not provided
+            supabase_url: SUPABASE_URL,
+            supabase_anon_key: SUPABASE_ANON_KEY,
+        };
+        writeAuthConfig(config);
+        verifySpinner.succeed(`Logged in! ${stdout.randomMessage('login')}`);
+        logger.info('login complete');
+    }
+    catch (error) {
+        if (error.name === 'ExitPrompt') {
+            // User cancelled prompt (Ctrl+C)
+            stdout.gap();
+            stdout.dim('Login cancelled.');
+            await exit(0);
+        }
+        else {
+            captureException(error);
+            stdout.error(`Error during login: ${error.message}`);
+            logger.error('login failed', { message: error.message });
+            await exit(1);
+        }
+    }
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,2 @@
+export declare function runLogout(): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../src/commands/logout.ts"],"names":[],"mappings":"AAIA,wBAAsB,SAAS,kBAe9B"}

package/dist/commands/logout.js

@@ -0,0 +1,19 @@
+import { deleteAuthConfig, isLoggedIn } from '../auth/index.js';
+import { createLogger, exit } from '../logger.js';
+import * as stdout from '../stdout.js';
+export async function runLogout() {
+    const logger = createLogger('runLogout');
+    try {
+        if (!isLoggedIn()) {
+            stdout.dim('You are not currently logged in.');
+            return;
+        }
+        deleteAuthConfig();
+        stdout.success('Logged out. See you next time!');
+    }
+    catch (error) {
+        stdout.error(`Error during logout: ${error.message}`);
+        logger.error('logout failed', { message: error.message });
+        await exit(1);
+    }
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,16 @@
+export type RunPullOptions = {
+    id?: string;
+    out?: string;
+    branch?: string;
+    branchName?: string;
+    /** Explicit version number to pull. If omitted, defaults to "latest" unless selectVersion is true. */
+    version?: string | number;
+    /** When true, show interactive version selector (triggered by `--version` with no value). */
+    selectVersion?: boolean;
+    /** When true, pull main and clear saved branch (e.g. when user explicitly selects "main" in branch switcher). */
+    useMain?: boolean;
+    fix?: boolean;
+    preserve?: boolean;
+};
+export declare function runPull(opts: RunPullOptions): Promise<void>;
+//# sourceMappingURL=pull.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../src/commands/pull.ts"],"names":[],"mappings":"AAiIA,MAAM,MAAM,cAAc,GAAG;IAC3B,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sGAAsG;IACtG,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB,6FAA6F;IAC7F,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,iHAAiH;IACjH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,cAAc,iBA6UjD"}