@embeddables/cli 0.7.19 → 0.8.1

package/dist/commands/save.js

@@ -0,0 +1,597 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import { getAccessToken, getAuthenticatedSupabaseClient, isLoggedIn } from '../auth/index.js';
+import { getProjectId, writeProjectConfig } from '../config/index.js';
+import { compileAllPages } from '../compiler/index.js';
+import { formatError } from '../compiler/errors.js';
+import { promptForLocalEmbeddable, promptForProject } from '../prompts/index.js';
+import { WEB_APP_BASE_URL } from '../constants.js';
+import { captureException, createLogger, exit } from '../logger.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { translateJsonDiffToEditCommands } from '../helpers/json.js';
+import { generateId, inferEmbeddableFromCwd } from '../helpers/utils.js';
+/** Error with optional gray detail line (hint/next step) for the user. */
+class SaveError extends Error {
+    detail;
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = 'SaveError';
+    }
+}
+/**
+ * Parse response body as JSON. Returns null if body is not valid JSON (e.g. HTML error page).
+ */
+async function safeParseJson(response) {
+    try {
+        const data = await response.json();
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+function isSaveErrorResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'error' in value &&
+        typeof value.error === 'string');
+}
+function isSaveConflictResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        'latestVersionNumber' in value &&
+        'yourVersionNumber' in value &&
+        typeof value.latestVersionNumber === 'number' &&
+        typeof value.yourVersionNumber === 'number');
+}
+function isSaveResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        value.success === true &&
+        typeof value.data === 'object' &&
+        typeof value.data?.newVersionNumber === 'number');
+}
+/**
+ * Read `_version` from config.json for the given embeddable.
+ */
+function getVersionFromConfig(embeddableId) {
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        if (typeof config._version === 'number') {
+            return config._version;
+        }
+    }
+    catch {
+        // Ignore parse errors
+    }
+    return null;
+}
+/**
+ * Read `_branch_id` and `_branch_name` from config.json for the given embeddable.
+ */
+function getBranchFromConfig(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;
+    }
+}
+/** Slug for branch name/id for versioned filenames (e.g. "my branch" -> "my_branch"). */
+function slugForBranch(nameOrId) {
+    return (String(nameOrId)
+        .replace(/[^a-zA-Z0-9_.-]/g, '_')
+        .replace(/_+/g, '_') || 'main');
+}
+/** Get branch slug from config (_branch_name preferred, else _branch_id, else main). */
+function getBranchSlugFromConfig(embeddableId) {
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath))
+        return 'main';
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        const name = config._branch_name ?? config._branch_id;
+        if (typeof name === 'string' && name)
+            return slugForBranch(name);
+    }
+    catch {
+        /* ignore */
+    }
+    return 'main';
+}
+/**
+ * Update `_version` in config.json for the given embeddable.
+ */
+function setVersionInConfig(embeddableId, version) {
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        return;
+    }
+    try {
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        config._version = version;
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    }
+    catch {
+        // Ignore errors - versioned files are a fallback
+    }
+}
+/**
+ * Scan the .generated/ directory for versioned files (embeddable-v*.json or embeddable-*@*.json)
+ * and return the highest version number found.
+ */
+function getLatestVersionFromFiles(generatedDir) {
+    if (!fs.existsSync(generatedDir)) {
+        return null;
+    }
+    const files = fs.readdirSync(generatedDir);
+    const legacyPattern = /^embeddable-v(\d+)\.json$/;
+    const branchPattern = /^embeddable-[^@]+@(\d+)\.json$/;
+    let maxVersion = null;
+    for (const file of files) {
+        const match = file.match(legacyPattern) ?? file.match(branchPattern);
+        if (match) {
+            const version = parseInt(match[1], 10);
+            if (maxVersion === null || version > maxVersion) {
+                maxVersion = version;
+            }
+        }
+    }
+    return maxVersion;
+}
+/**
+ * Fetch active drafts from other users on the same version (status=DRAFT, not saved/discarded).
+ * Used to warn before saving that others may have unsaved edits.
+ */
+async function fetchOtherUsersDrafts(supabase, flowId, versionNumber, branchId, currentUserId) {
+    try {
+        let query = supabase
+            .from('flow_versions')
+            .select('id, author_id, author_name')
+            .eq('flow_id', flowId)
+            .eq('status', 'DRAFT')
+            .eq('version_number', versionNumber)
+            .not('draft_saved', 'is', true)
+            .not('draft_discarded', 'is', true)
+            .neq('author_id', currentUserId);
+        if (branchId === null) {
+            query = query.is('branch_id', null);
+        }
+        else {
+            query = query.eq('branch_id', branchId);
+        }
+        const { data, error } = await query;
+        if (error) {
+            return [];
+        }
+        return (data || []).map((row) => ({
+            id: row.id,
+            author_id: row.author_id,
+            author_name: row.author_name ?? null,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function runSave(opts) {
+    const logger = createLogger('runSave');
+    try {
+        await runSaveInner(opts);
+    }
+    catch (error) {
+        captureException(error);
+        if (error instanceof SaveError) {
+            stdout.error(`Save failed: ${error.message}`);
+            if (error.detail) {
+                stdout.dim(error.detail);
+            }
+        }
+        else if (error instanceof Error) {
+            stdout.error(`Save failed: ${error.message}`);
+        }
+        else {
+            stdout.error('Save failed with an unexpected error.');
+        }
+        logger.error('save failed', {
+            message: error instanceof Error ? error.message : 'unexpected error',
+        });
+        await exit(1);
+    }
+}
+async function runSaveInner(opts) {
+    const logger = createLogger('runSave');
+    // 1. Check login
+    if (!isLoggedIn()) {
+        stdout.warn('Not logged in.');
+        stdout.dim('Run "embeddables login" first.');
+        logger.error('not logged in');
+        await exit(1);
+        return;
+    }
+    // 2. Get access token
+    const accessToken = getAccessToken();
+    if (!accessToken) {
+        stdout.warn('Could not retrieve access token.');
+        stdout.dim('Run "embeddables login" to re-authenticate.');
+        logger.error('no access token');
+        await exit(1);
+        return;
+    }
+    // 3. Get embeddable ID (from option, cwd inference, or interactive prompt)
+    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({
+            message: 'Select an embeddable to save:',
+        });
+        if (!selected) {
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+        stdout.gap();
+    }
+    if (embeddableId) {
+        const embeddableCtx = getSentryContextFromEmbeddableConfig(embeddableId);
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...embeddableCtx,
+        });
+    }
+    // Resolve branch: explicit -b flag wins, otherwise use current branch from config (set by `embeddables branch`)
+    const currentBranch = opts.branch ? null : getBranchFromConfig(embeddableId);
+    const effectiveBranch = opts.branch ?? currentBranch?.branchId ?? undefined;
+    const effectiveBranchName = currentBranch?.branchName;
+    const branchLabel = effectiveBranch
+        ? effectiveBranchName
+            ? `${effectiveBranchName} (${effectiveBranch})`
+            : effectiveBranch
+        : 'main';
+    logger.info('save started', { fromVersion: opts.fromVersion });
+    // 4. Get project ID (from config or interactive prompt)
+    let projectId = getProjectId();
+    if (!projectId) {
+        stdout.step('No project configured. Fetching projects…');
+        const selectedProject = await promptForProject();
+        if (!selectedProject) {
+            await exit(1);
+            return;
+        }
+        projectId = selectedProject.id;
+        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();
+    }
+    // 5. Build (compile TSX → JSON) unless --skip-build is set
+    const generatedDir = path.join('embeddables', embeddableId, '.generated');
+    const outPath = path.join(generatedDir, 'embeddable.json');
+    if (!opts.skipBuild) {
+        const pagesGlob = `embeddables/${embeddableId}/pages/**/*.page.tsx`;
+        const stylesDir = path.join('embeddables', embeddableId, 'styles');
+        const configPath = path.join('embeddables', embeddableId, 'config.json');
+        try {
+            await stdout.withSpinner('Building embeddable…', async () => {
+                await compileAllPages({
+                    pagesGlob,
+                    outPath,
+                    pageKeyFrom: 'filename',
+                    stylesDir,
+                    embeddableId: embeddableId,
+                    configPath,
+                });
+            }, {
+                successText: 'Build successful',
+            });
+        }
+        catch (e) {
+            captureException(e);
+            stdout.error(formatError(e));
+            logger.error('build failed');
+            await exit(1);
+            return;
+        }
+    }
+    // 6. Read the compiled JSON
+    if (!fs.existsSync(outPath)) {
+        stdout.warn(`No compiled embeddable found at ${outPath}`);
+        stdout.dim('Run "embeddables build" or "embeddables pull" first.');
+        logger.error('compiled json not found', { outPath });
+        await exit(1);
+        return;
+    }
+    const jsonContent = fs.readFileSync(outPath, 'utf8');
+    let embeddableJson;
+    try {
+        embeddableJson = JSON.parse(jsonContent);
+    }
+    catch {
+        stdout.error('Failed to parse embeddable JSON.');
+        logger.error('failed to parse compiled json');
+        await exit(1);
+        return;
+    }
+    // Validate that pages array exists and is non-empty
+    if (!embeddableJson.pages ||
+        !Array.isArray(embeddableJson.pages) ||
+        embeddableJson.pages.length === 0) {
+        stdout.error('Embeddable JSON must contain a non-empty pages array.');
+        logger.error('empty pages array');
+        await exit(1);
+        return;
+    }
+    // 7. Determine fromVersionNumber
+    let fromVersionNumber;
+    if (opts.fromVersion) {
+        fromVersionNumber = parseInt(opts.fromVersion, 10);
+        if (isNaN(fromVersionNumber)) {
+            stdout.error(`Invalid --from-version value: ${opts.fromVersion}`);
+            logger.error('invalid from-version', { fromVersion: opts.fromVersion });
+            await exit(1);
+            return;
+        }
+    }
+    else {
+        // Primary: read _version from config.json; fallback: scan .generated/ for versioned files
+        const detectedVersion = getVersionFromConfig(embeddableId) ?? getLatestVersionFromFiles(generatedDir);
+        if (detectedVersion === null) {
+            stdout.error('Could not determine the current version number.');
+            stdout.dim('Make sure you have pulled the embeddable first (embeddables pull), or specify --from-version <number>.');
+            logger.error('could not determine version');
+            await exit(1);
+            return;
+        }
+        fromVersionNumber = detectedVersion;
+    }
+    setSentryContext({
+        versionNumber: fromVersionNumber,
+        branch: effectiveBranch
+            ? { id: effectiveBranch, name: effectiveBranchName ?? null }
+            : undefined,
+    });
+    stdout.infoBox([
+        ['ID', embeddableId],
+        ['Branch', branchLabel],
+        ['Version', `v${fromVersionNumber}`],
+    ]
+        .map(([k, v]) => `${k}: ${v}`)
+        .join('  ·  '));
+    // 7b. Check for other users' drafts on this version; warn and optionally abort
+    let currentUserId = null;
+    const supabase = await getAuthenticatedSupabaseClient();
+    if (supabase) {
+        const { data: { user }, } = await supabase.auth.getUser();
+        currentUserId = user?.id ?? null;
+        if (currentUserId) {
+            const branchIdForDrafts = effectiveBranch ?? null;
+            const otherDrafts = await fetchOtherUsersDrafts(supabase, embeddableId, fromVersionNumber, branchIdForDrafts, currentUserId);
+            if (otherDrafts.length > 0) {
+                const names = otherDrafts
+                    .map((d) => d.author_name?.trim() || d.author_id || 'Someone')
+                    .filter((n, i, a) => a.indexOf(n) === i);
+                const namesText = names.length === 1
+                    ? names[0]
+                    : `${names.slice(0, -1).join(', ')} and ${names[names.length - 1]}`;
+                stdout.gap();
+                stdout.warn(`${namesText} ${names.length === 1 ? 'has' : 'have'} unsaved edits on version ${fromVersionNumber}. Saving may cause conflicts.`);
+                const { prompt: promptWithCancel } = await import('../helpers/prompt.js');
+                const { proceed } = await promptWithCancel({
+                    type: 'confirm',
+                    name: 'proceed',
+                    message: 'Save anyway?',
+                    initial: false,
+                }, 1);
+                if (!proceed) {
+                    stdout.dim('Save cancelled.');
+                    await exit(0);
+                }
+                stdout.gap();
+            }
+        }
+    }
+    // 8. POST to save-version API
+    // Resolve current user id (required by API)
+    if (!currentUserId && supabase) {
+        const { data: { user }, } = await supabase.auth.getUser();
+        currentUserId = user?.id ?? null;
+    }
+    if (!currentUserId) {
+        throw new SaveError('You must be logged in to save.', 'Run "embeddables login" to authenticate.');
+    }
+    // Previous version JSON: from versioned snapshot file, or {} if not found (e.g. --from-version without pull)
+    const previousVersionPath = path.join(generatedDir, `embeddable-${getBranchSlugFromConfig(embeddableId)}@${fromVersionNumber}.json`);
+    const legacyVersionPath = path.join(generatedDir, `embeddable-v${fromVersionNumber}.json`);
+    const previousJsonContent = fs.existsSync(previousVersionPath)
+        ? fs.readFileSync(previousVersionPath, 'utf8')
+        : fs.existsSync(legacyVersionPath)
+            ? fs.readFileSync(legacyVersionPath, 'utf8')
+            : '{}';
+    const commands = translateJsonDiffToEditCommands({
+        previousObject: JSON.parse(previousJsonContent),
+        currentObject: JSON.parse(jsonContent),
+        basePath: [],
+    });
+    const body = {
+        userId: currentUserId,
+        embeddableId,
+        jsonString: JSON.stringify(embeddableJson),
+        projectId,
+        fromVersionNumber,
+        editHistoryLength: 1,
+        editHistoryDescriptions: [{ origin: 'CLI', description: 'Saved version from CLI' }],
+        editHistory: [
+            setMultipleFlowUpdates({
+                commands,
+                metadata: {
+                    description: 'Saved version from CLI',
+                    trigger: { origin: 'CLI', editor: 'CLI' },
+                },
+            }),
+        ],
+    };
+    if (opts.label) {
+        body.label = opts.label;
+    }
+    if (effectiveBranch) {
+        body.branchId = effectiveBranch;
+    }
+    const apiUrl = `${WEB_APP_BASE_URL}/api/embeddables/save-version`;
+    const headers = {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+    };
+    let response;
+    try {
+        response = await stdout.withSpinner(`Saving embeddable (v${fromVersionNumber})…`, async () => {
+            return fetch(apiUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(body),
+            });
+        }, { successText: 'Uploaded to server' });
+    }
+    catch (networkError) {
+        const message = networkError instanceof Error ? networkError.message : 'Network request failed';
+        if (message.includes('fetch') ||
+            message.includes('ECONNREFUSED') ||
+            message.includes('ETIMEDOUT') ||
+            message.includes('ENOTFOUND') ||
+            message.includes('network')) {
+            throw new SaveError(`Could not reach the server (${message}).`, `Check your connection and that the base URL is correct (currently ${WEB_APP_BASE_URL}).`);
+        }
+        throw new SaveError(`Network error: ${message}`, 'Check your network and firewall settings.');
+    }
+    if (response.status === 404) {
+        throw new SaveError('Save endpoint not found. The server may not support this feature or the URL may be incorrect.', `The request was sent to ${WEB_APP_BASE_URL}. If you use a custom deployment, ensure the save-version API is available there.`);
+    }
+    if (response.status === 401 || response.status === 403) {
+        throw new SaveError('Not authorized.', 'Run "embeddables login" to re-authenticate.');
+    }
+    if (response.status >= 500) {
+        throw new SaveError(`Server error (HTTP ${response.status}). Please try again later.`, 'If this keeps happening, try again later or contact support.');
+    }
+    if (response.status === 409) {
+        const conflictResult = await safeParseJson(response);
+        if (!conflictResult || !isSaveConflictResponse(conflictResult)) {
+            throw new SaveError(`Version conflict but invalid response (HTTP ${response.status}).`, 'Try saving again; if it persists, the server may be misconfigured.');
+        }
+        stdout.gap();
+        stdout.warn(`Version conflict: the server has version ${conflictResult.latestVersionNumber}, but you are saving from version ${conflictResult.yourVersionNumber}.`);
+        const { prompt: promptWithCancel } = await import('../helpers/prompt.js');
+        const { forceSave } = await promptWithCancel({
+            type: 'confirm',
+            name: 'forceSave',
+            message: 'A newer version exists on the server. Save anyway?',
+            initial: false,
+        }, 1);
+        if (!forceSave) {
+            stdout.dim('Save cancelled.');
+            await exit(0);
+        }
+        // Retry with force flag
+        let forceResponse;
+        try {
+            forceResponse = await stdout.withSpinner('Force-saving…', async () => {
+                return fetch(apiUrl, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify({ ...body, force: true }),
+                });
+            }, {
+                successText: 'Force save uploaded',
+            });
+        }
+        catch (forceNetworkError) {
+            const message = forceNetworkError instanceof Error ? forceNetworkError.message : 'Network request failed';
+            throw new SaveError(`Retry failed: ${message}`, 'The initial save hit a version conflict; the force-save retry could not reach the server.');
+        }
+        if (forceResponse.status === 404) {
+            throw new SaveError('Save endpoint not found. The server may not support this feature or the URL may be incorrect.', `The request was sent to ${WEB_APP_BASE_URL}. If you use a custom deployment, ensure the save-version API is available there.`);
+        }
+        const forceResult = await safeParseJson(forceResponse);
+        if (!forceResponse.ok) {
+            const errorMessage = forceResult && isSaveErrorResponse(forceResult)
+                ? forceResult.error
+                : `HTTP ${forceResponse.status}`;
+            throw new SaveError(errorMessage, 'If the problem persists, run "embeddables login" or try again later.');
+        }
+        if (!forceResult || !isSaveResponse(forceResult)) {
+            throw new SaveError(`Invalid response from server (HTTP ${forceResponse.status}).`, 'The server returned an unexpected format. Try again or contact support if it persists.');
+        }
+        const { newVersionNumber } = forceResult.data;
+        setVersionInConfig(embeddableId, newVersionNumber);
+        const branchSlug = getBranchSlugFromConfig(embeddableId);
+        const versionedPath = path.join(generatedDir, `embeddable-${branchSlug}@${newVersionNumber}.json`);
+        fs.mkdirSync(generatedDir, { recursive: true });
+        fs.writeFileSync(versionedPath, jsonContent, 'utf8');
+        stdout.gap();
+        stdout.successBox(`${pc.bold(`Version ${newVersionNumber}`)} ${stdout.symbols.rocket}\n${stdout.randomMessage('save')}`, { title: 'Saved' });
+        logger.info('save complete', { newVersionNumber, forced: true });
+        return;
+    }
+    const result = await safeParseJson(response);
+    if (!response.ok) {
+        const errorMessage = result && isSaveErrorResponse(result) ? result.error : `HTTP ${response.status}`;
+        throw new SaveError(errorMessage, 'If the problem persists, run "embeddables login" or try again later.');
+    }
+    if (!result || !isSaveResponse(result)) {
+        throw new SaveError(`Invalid response from server (HTTP ${response.status}).`, 'The server returned an unexpected format. Try again or contact support if it persists.');
+    }
+    const { newVersionNumber } = result.data;
+    // Update _version in config.json so future saves know the base version
+    setVersionInConfig(embeddableId, newVersionNumber);
+    // Also save the versioned file to .generated/ as a snapshot (embeddable-{branch}@{version}.json)
+    const branchSlug = getBranchSlugFromConfig(embeddableId);
+    const versionedPath = path.join(generatedDir, `embeddable-${branchSlug}@${newVersionNumber}.json`);
+    fs.mkdirSync(generatedDir, { recursive: true });
+    fs.writeFileSync(versionedPath, jsonContent, 'utf8');
+    stdout.gap();
+    stdout.successBox(`${pc.bold(`Version ${newVersionNumber}`)} ${stdout.symbols.rocket}\n${stdout.randomMessage('save')}`, { title: 'Saved' });
+    logger.info('save complete', { newVersionNumber });
+}
+function setMultipleFlowUpdates({ commands, metadata, }) {
+    const type = 'set_multiple_embeddable_updates';
+    const simpleCommandTypes = {
+        add: 'add_embeddable_property',
+        remove: 'remove_embeddable_property',
+        set: 'update_embeddable_property',
+        move: 'move_embeddable_property',
+    };
+    //* Map the commands to the correct type and data
+    const mappedCommands = commands.map((command) => ({
+        type: Object.keys(simpleCommandTypes).includes(command.type)
+            ? simpleCommandTypes[command.type]
+            : command.type,
+        data: command.data,
+    }));
+    return {
+        id: generateId('edit'),
+        type,
+        data: { commands: mappedCommands },
+        metadata,
+    };
+}

package/dist/commands/upgrade.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../src/commands/upgrade.ts"],"names":[],"mappings":"AAwBA,wBAAsB,UAAU,kBA4C/B"}

package/dist/commands/upgrade.js

@@ -0,0 +1,50 @@
+import { createRequire } from 'node:module';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import * as stdout from '../stdout.js';
+const require = createRequire(import.meta.url);
+function getCurrentVersion() {
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(__dirname, '..', '..', 'package.json');
+    const pkg = require(pkgPath);
+    return pkg.version;
+}
+async function getLatestVersion() {
+    const res = await fetch('https://registry.npmjs.org/@embeddables/cli/latest');
+    if (!res.ok) {
+        throw new Error(`Failed to fetch latest version: ${res.status}`);
+    }
+    const data = (await res.json());
+    return data.version;
+}
+export async function runUpgrade() {
+    try {
+        const currentVersion = getCurrentVersion();
+        const latestVersion = await stdout.withSpinner('Checking for updates…', async () => getLatestVersion(), { successText: (v) => `Checked registry (latest: ${v})` });
+        if (currentVersion === latestVersion) {
+            stdout.gap();
+            stdout.successBox(`Already on the latest version ${stdout.symbols.sparkles}\n\nv${latestVersion}`, { title: 'Up to date' });
+            stdout.gap();
+            return;
+        }
+        await stdout.withSpinner(`Upgrading ${currentVersion} → ${latestVersion}…`, async () => {
+            execSync(`npm install -g @embeddables/cli@latest`, { stdio: 'pipe' });
+        }, { successText: `Upgraded to @embeddables/cli@${latestVersion}` });
+        stdout.gap();
+        stdout.successBox(`v${currentVersion} → v${latestVersion} ${stdout.symbols.rocket}`, {
+            title: 'Upgrade complete',
+        });
+        stdout.gap();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('EACCES') || message.includes('permission')) {
+            stdout.error('Permission denied. Try running with sudo: sudo npm install -g @embeddables/cli@latest');
+        }
+        else {
+            stdout.error(`Error during upgrade: ${message}`);
+        }
+        process.exit(1);
+    }
+}

package/dist/compiler/errors.d.ts

@@ -0,0 +1,20 @@
+export declare class CompileError extends Error {
+    info?: {
+        file?: string;
+        line?: number;
+        column?: number;
+        pageKey?: string;
+        componentId?: string;
+        componentKey?: string;
+    } | undefined;
+    constructor(message: string, info?: {
+        file?: string;
+        line?: number;
+        column?: number;
+        pageKey?: string;
+        componentId?: string;
+        componentKey?: string;
+    } | undefined);
+}
+export declare function formatError(e: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/compiler/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/compiler/errors.ts"],"names":[],"mappings":"AAEA,qBAAa,YAAa,SAAQ,KAAK;IAG5B,IAAI,CAAC,EAAE;QACZ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB;gBARD,OAAO,EAAE,MAAM,EACR,IAAI,CAAC,EAAE;QACZ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,YAAY,CAAC,EAAE,MAAM,CAAA;KACtB,YAAA;CAIJ;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,UAkCrC"}