@embeddables/cli 0.8.0 → 0.8.2

package/dist/commands/pull.js

@@ -0,0 +1,395 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { reverseCompile } from '../compiler/reverse.js';
+import { getAccessToken, isLoggedIn } from '../auth/index.js';
+import { getProjectId, writeProjectConfig } from '../config/index.js';
+import { promptForProject, promptForEmbeddable, fetchEmbeddableMetadata, fetchRecentVersions, promptForVersion, } from '../prompts/index.js';
+import { captureException, createLogger, exit } from '../logger.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+/**
+ * Normalize custom_validation_function strings so literal "\\n" (backslash-n) becomes real newline.
+ * The API sometimes returns these double-escaped; dataOutputs/computedFields code is written
+ * as raw file content so they don't get double-escaped when written to embeddable.json.
+ */
+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);
+        }
+    }
+}
+/** Slug for branch name/id for use in filenames (e.g. "my branch" -> "my_branch"). */
+function slugForBranch(nameOrId) {
+    return (String(nameOrId)
+        .replace(/[^a-zA-Z0-9_.-]/g, '_')
+        .replace(/_+/g, '_') || 'main');
+}
+/** Versioned embeddable filename: embeddable-{branchSlug}@{version}.json */
+function getVersionedBasename(version, branchSlug) {
+    const v = typeof version === 'number' ? version : String(version);
+    return `embeddable-${branchSlug}@${v}.json`;
+}
+/** Read current _branch_id and _branch_name from config (set when on a branch via `embeddables branch`). */
+function getCurrentBranchFromConfig(embeddableId) {
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath))
+        return null;
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const branchId = config._branch_id;
+        if (typeof branchId !== 'string' || !branchId)
+            return null;
+        const branchName = config._branch_name;
+        return { branchId, branchName: typeof branchName === 'string' ? branchName : undefined };
+    }
+    catch {
+        return null;
+    }
+}
+/** Write _version, _branch_id, _branch_name to config.json. Called early and in finally so it always runs. */
+function writePullMetadataToConfig(embeddableId, version, branch, branchName) {
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    let config = {};
+    try {
+        if (fs.existsSync(configPath)) {
+            try {
+                const content = fs.readFileSync(configPath, 'utf8');
+                config = JSON.parse(content);
+            }
+            catch {
+                /* use empty config */
+            }
+        }
+        if (version != null) {
+            const n = typeof version === 'number' ? version : parseInt(String(version), 10);
+            if (!isNaN(n))
+                config._version = n;
+        }
+        if (branch) {
+            config._branch_id = branch;
+            if (branchName)
+                config._branch_name = branchName;
+            else
+                delete config._branch_name;
+        }
+        else {
+            delete config._branch_id;
+            delete config._branch_name;
+        }
+        fs.mkdirSync(path.dirname(configPath), { recursive: true });
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    }
+    catch (err) {
+        stdout.warn(`Could not write config.json: ${err instanceof Error ? err.message : err}`);
+    }
+}
+export async function runPull(opts) {
+    const logger = createLogger('runPull');
+    const totalTimer = stdout.timer();
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    // Re-apply project/org from config after chdir so embeddables.json in project root is used
+    setSentryContext(getSentryContextFromProjectConfig());
+    // If no ID provided, try to get it interactively
+    if (!embeddableId) {
+        if (!isLoggedIn()) {
+            stdout.warn('No embeddable ID provided and not logged in.');
+            stdout.dim('Use --id <embeddable-id> or run "embeddables login" for interactive selection.');
+            logger.error('not logged in and no embeddable id');
+            await exit(1);
+            return;
+        }
+        let projectId = getProjectId();
+        // If no project ID configured, prompt for project selection
+        if (!projectId) {
+            const selectedProject = await stdout.withSpinner('Fetching projects…', async () => {
+                return promptForProject();
+            }, { successText: 'Projects loaded' });
+            if (!selectedProject) {
+                logger.error('project selection failed');
+                await exit(1);
+                return;
+            }
+            projectId = selectedProject.id;
+            // Save the selected project to config
+            writeProjectConfig({
+                org_id: selectedProject.org_id || undefined,
+                org_title: selectedProject.org_title || undefined,
+                project_id: projectId,
+                project_name: selectedProject.title || undefined,
+            });
+            stdout.success('Saved project to embeddables.json');
+            stdout.gap();
+        }
+        stdout.step('Fetching embeddables from project…');
+        const selected = await promptForEmbeddable(projectId, {
+            message: 'Select an embeddable to pull:',
+            prioritizeLocal: true,
+        });
+        if (!selected) {
+            logger.error('embeddable selection failed');
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+        stdout.gap();
+    }
+    if (embeddableId) {
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...getSentryContextFromEmbeddableConfig(embeddableId),
+        });
+    }
+    // When useMain, pull main and ignore/clear saved branch. Otherwise stay on current branch when no --branch.
+    const currentFromConfig = opts.useMain || opts.branch != null ? null : getCurrentBranchFromConfig(embeddableId);
+    const effectiveBranch = opts.useMain ? undefined : (opts.branch ?? currentFromConfig?.branchId);
+    const effectiveBranchName = opts.useMain
+        ? undefined
+        : (opts.branchName ?? currentFromConfig?.branchName);
+    const outPath = opts.out || path.join('embeddables', embeddableId, '.generated', 'embeddable.json');
+    const branchLabel = effectiveBranch
+        ? effectiveBranchName
+            ? `${effectiveBranchName} (${effectiveBranch})`
+            : effectiveBranch
+        : 'main';
+    if (effectiveBranch) {
+        setSentryContext({ branch: { id: effectiveBranch, name: effectiveBranchName ?? null } });
+    }
+    // Resolve version:
+    //   --version (no value) → interactive selector
+    //   --version <n>        → specific version
+    //   (omitted)            → latest
+    let versionParam;
+    if (opts.selectVersion) {
+        stdout.step('Fetching recent versions…');
+        const recentVersions = await fetchRecentVersions(embeddableId, effectiveBranch ?? null);
+        const selected = await promptForVersion(recentVersions, {
+            message: 'Select a version to pull:',
+        });
+        versionParam = selected === null ? 'latest' : String(selected);
+        stdout.gap();
+    }
+    else if (opts.version !== undefined && opts.version !== '') {
+        const v = String(opts.version).toLowerCase();
+        versionParam = v === 'latest' ? 'latest' : v;
+    }
+    else {
+        versionParam = 'latest';
+    }
+    let url = `https://engine.embeddables.com/${embeddableId}?version=${versionParam}`;
+    if (effectiveBranch)
+        url += `&embeddable_branch=${effectiveBranch}`;
+    logger.info('pull started');
+    let pullVersion;
+    try {
+        // Fetch embeddable
+        const fetchResult = await stdout.withSpinner(`Fetching embeddable (branch: ${branchLabel})…`, async () => {
+            // Add authentication header if available
+            const accessToken = getAccessToken();
+            const headers = {};
+            if (accessToken) {
+                headers['Authorization'] = `Bearer ${accessToken}`;
+            }
+            const response = await fetch(url, { headers });
+            if (!response.ok) {
+                throw new Error(`Failed to fetch embeddable: ${response.status} ${response.statusText}`);
+            }
+            const data = await response.json();
+            const flow = data.flow;
+            if (!flow) {
+                throw new Error("Response does not contain a 'flow' property");
+            }
+            // Normalize custom_validation_function: literal \n (backslash-n) -> real newline (so embeddable.json is correct)
+            normalizeCustomValidationFunctionsInFlow(flow);
+            return { flow, data };
+        }, { successText: 'Fetched embeddable' });
+        const { flow, data } = fetchResult;
+        // Save to embeddables/<id>/.generated/embeddable.json
+        fs.mkdirSync(path.dirname(outPath), { recursive: true });
+        const flowJson = JSON.stringify(flow, null, 2);
+        fs.writeFileSync(outPath, flowJson, 'utf8');
+        pullVersion =
+            data.version ?? data.embeddable_version ?? flow.version;
+        const version = pullVersion;
+        const branchSlug = slugForBranch(effectiveBranchName ?? effectiveBranch ?? 'main');
+        // Also save version-specific file (e.g. embeddable-main@135.json or embeddable-my_branch@135.json)
+        let filesWritten = 1;
+        if (version != null) {
+            const versionStr = typeof version === 'string' ? version : String(version);
+            const versionedBasename = getVersionedBasename(versionStr, branchSlug);
+            const versionedPath = path.join(path.dirname(outPath), versionedBasename);
+            fs.writeFileSync(versionedPath, flowJson, 'utf8');
+            filesWritten++;
+        }
+        // Persist _version and _branch_id in config.json immediately so they survive reverseCompile
+        writePullMetadataToConfig(embeddableId, version, effectiveBranch, effectiveBranchName);
+        // Fetch and save flow metadata from DB (title, archived, created_at)
+        const metadata = await fetchEmbeddableMetadata(embeddableId);
+        if (metadata) {
+            const metadataPath = path.join('embeddables', embeddableId, 'metadata.json');
+            fs.mkdirSync(path.dirname(metadataPath), { recursive: true });
+            fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + '\n', 'utf8');
+            filesWritten++;
+        }
+        const versionForSentry = pullVersion != null && !isNaN(Number(pullVersion)) ? Number(pullVersion) : undefined;
+        setSentryContext({
+            embeddable: { id: embeddableId, title: metadata?.title ?? null },
+            versionNumber: versionForSentry,
+        });
+        stdout.infoBox([
+            ['ID', embeddableId],
+            ['Branch', branchLabel],
+            ['Version', String(pullVersion ?? 'unknown')],
+            ['Pages', String(flow.pages?.length ?? 0)],
+        ]
+            .map(([k, v]) => `${k}: ${v}`)
+            .join('  ·  '));
+        // Clear existing pages, styles, computed-fields, actions, and global-components before generating new ones
+        const pagesDir = path.join('embeddables', embeddableId, 'pages');
+        const stylesDir = path.join('embeddables', embeddableId, 'styles');
+        const computedFieldsDir = path.join('embeddables', embeddableId, 'computed-fields');
+        const actionsDir = path.join('embeddables', embeddableId, 'actions');
+        const globalComponentsDir = path.join('embeddables', embeddableId, '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`);
+        }
+        // Run reverse compiler (pass pullMetadata so config.json gets _version and _branch_id even on fix retry)
+        const versionNum = version != null && !isNaN(Number(version)) ? Number(version) : undefined;
+        const pullMetadata = {
+            version: versionNum,
+            branchId: effectiveBranch,
+            branchName: effectiveBranchName,
+        };
+        let usedFix = opts.fix;
+        try {
+            await stdout.withSpinner('Reverse-compiling…', async () => {
+                stdout.mute();
+                try {
+                    await reverseCompile(flow, embeddableId, {
+                        fix: opts.fix,
+                        preserve: opts.preserve,
+                        pullMetadata,
+                    });
+                }
+                finally {
+                    stdout.unmute();
+                }
+            }, {
+                successText: 'Reverse compile complete',
+            });
+        }
+        catch (compileError) {
+            // If fix mode wasn't already enabled, offer to retry with fix mode
+            if (!opts.fix && compileError instanceof Error) {
+                stdout.gap();
+                stdout.warn('Reverse compile issue:');
+                stdout.warn(`  ${compileError.message}`);
+                stdout.gap();
+                const { prompt: promptWithCancel } = await import('../helpers/prompt.js');
+                const response = await promptWithCancel({
+                    type: 'confirm',
+                    name: 'fix',
+                    message: 'Would you like to retry with auto-fix enabled? (removes problematic components)',
+                    initial: true,
+                }, 1);
+                if (response.fix) {
+                    usedFix = true;
+                    await stdout.withSpinner('Retrying with auto-fix…', async () => {
+                        stdout.mute();
+                        try {
+                            await reverseCompile(flow, embeddableId, {
+                                fix: true,
+                                preserve: opts.preserve,
+                                pullMetadata,
+                            });
+                        }
+                        finally {
+                            stdout.unmute();
+                        }
+                    }, {
+                        successText: 'Reverse compile complete (with fixes)',
+                    });
+                }
+                else {
+                    await exit(1);
+                }
+            }
+            else {
+                throw compileError;
+            }
+        }
+        // Persist mutated flow when fixes were applied (e.g. parent_key -> parent_id)
+        if (usedFix) {
+            const flowJson = JSON.stringify(flow, null, 2);
+            fs.writeFileSync(outPath, flowJson, 'utf8');
+            if (version != null) {
+                const versionStr = typeof version === 'string' ? version : String(version);
+                const versionedBasename = getVersionedBasename(versionStr, branchSlug);
+                const versionedPath = path.join(path.dirname(outPath), versionedBasename);
+                fs.writeFileSync(versionedPath, flowJson, 'utf8');
+            }
+        }
+        stdout.gap();
+        stdout.successBox(`Pulled in ${totalTimer()} ${stdout.symbols.bolt} ${stdout.randomMessage('pull')}`);
+        logger.info('pull complete', { version: String(pullVersion ?? 'unknown') });
+    }
+    catch (error) {
+        captureException(error);
+        stdout.error(`Error pulling embeddable: ${error instanceof Error ? error.message : String(error)}`);
+        logger.error('pull failed', { message: error instanceof Error ? error.message : String(error) });
+        await exit(1);
+    }
+    finally {
+        // Always persist _version and _branch_id once we've fetched (so config is correct even if reverseCompile failed or was retried with fix)
+        if (embeddableId != null && pullVersion !== undefined) {
+            writePullMetadataToConfig(embeddableId, pullVersion, effectiveBranch, effectiveBranchName);
+        }
+    }
+}

package/dist/commands/save.d.ts

@@ -0,0 +1,30 @@
+import type { HistoryCommand } from '../types-builder.js';
+export type EditHistoryDescription = {
+    origin: string;
+    description: string;
+} | {
+    overflowed: boolean;
+};
+export type SaveEmbeddableVersionParams = {
+    embeddableId: string;
+    jsonString: string;
+    userId: string;
+    projectId: string;
+    label?: string;
+    fromVersionNumber: number;
+    editHistoryLength?: number;
+    editHistoryDescriptions?: EditHistoryDescription[];
+    workingDraftId?: string;
+    editHistoryStorageKey?: string;
+    editHistory?: HistoryCommand[];
+    branchId?: string | null;
+    branchMergedId?: string | null;
+};
+export declare function runSave(opts: {
+    id?: string;
+    label?: string;
+    branch?: string;
+    skipBuild?: boolean;
+    fromVersion?: string;
+}): Promise<void>;
+//# sourceMappingURL=save.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"save.d.ts","sourceRoot":"","sources":["../../src/commands/save.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAGV,cAAc,EACf,MAAM,qBAAqB,CAAA;AAuC5B,MAAM,MAAM,sBAAsB,GAC9B;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,UAAU,EAAE,OAAO,CAAA;CAAE,CAAA;AAE3B,MAAM,MAAM,2BAA2B,GAAG;IACxC,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iBAAiB,EAAE,MAAM,CAAA;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,uBAAuB,CAAC,EAAE,sBAAsB,EAAE,CAAA;IAClD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,WAAW,CAAC,EAAE,cAAc,EAAE,CAAA;IAC9B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC/B,CAAA;AAkND,wBAAsB,OAAO,CAAC,IAAI,EAAE;IAClC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,iBAqBA"}