@embeddables/cli 0.14.4 → 0.15.0-beta.0

package/dist/commands/dangerously-publish.js

@@ -0,0 +1,731 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import pc from 'picocolors';
+import * as Sentry from '@sentry/node';
+import { getAccessToken, getAuthenticatedSupabaseClient, isLoggedIn } from '../auth/index.js';
+import { getProjectId } 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, readEmbeddableContext } from '../helpers/utils.js';
+import { withSpan } from '../tracing.js';
+/** Slug used for `embeddable-{slug}@{version}.json` snapshots (main-line publish only). */
+const PUBLISH_VERSION_FILE_BRANCH_SLUG = 'main';
+class PublishError extends Error {
+    detail;
+    constructor(message, detail) {
+        super(message);
+        this.detail = detail;
+        this.name = 'PublishError';
+    }
+}
+/** Default network timeout for publish-related API calls. */
+const DEFAULT_FETCH_TIMEOUT_MS = 30_000;
+/** Server error when STAGING is requested but the version is no longer SAVED (e.g. already STAGING). */
+const STAGING_GATE_ERROR_SUBSTRING = 'Version is not in saved status to be pushed to staging';
+/**
+ * Runs fetch with a timeout so CLI commands do not hang indefinitely.
+ *
+ * @param url - Target request URL.
+ * @param options - Standard fetch options.
+ * @param timeoutMs - Abort timeout in milliseconds.
+ * @returns A fetch Response when the request completes in time.
+ */
+async function fetchWithTimeout(url, options, timeoutMs = DEFAULT_FETCH_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Normalizes abort detection across runtimes for timed-out network calls.
+ *
+ * @param error - Unknown thrown error from fetch.
+ * @returns True when error indicates an aborted request.
+ */
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}
+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');
+}
+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;
+}
+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
+    }
+}
+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;
+}
+function parseCliPositiveInteger(params) {
+    const { raw } = params;
+    const isIntegerLike = /^\d+$/.test(raw);
+    const parsed = Number(raw);
+    if (!isIntegerLike || !Number.isInteger(parsed) || parsed <= 0) {
+        return null;
+    }
+    return parsed;
+}
+/**
+ * Version to promote without save: `--publish-version`, then `config.json` `_version`,
+ * then highest version from `.generated` JSON filenames.
+ */
+function resolveVersionNumberForPublishOnly(params) {
+    const { publishVersionRaw, embeddableId, generatedDir } = params;
+    if (publishVersionRaw !== undefined && publishVersionRaw !== '') {
+        const parsedPublish = parseCliPositiveInteger({ raw: publishVersionRaw });
+        if (parsedPublish === null) {
+            return { ok: false, error: `Invalid --publish-version value: ${publishVersionRaw}` };
+        }
+        return { ok: true, versionNumber: parsedPublish };
+    }
+    const configVersion = getVersionFromConfig(embeddableId);
+    if (configVersion !== null) {
+        return { ok: true, versionNumber: configVersion };
+    }
+    const latestFromFiles = getLatestVersionFromFiles(generatedDir);
+    if (latestFromFiles !== null) {
+        return { ok: true, versionNumber: latestFromFiles };
+    }
+    return {
+        ok: false,
+        error: 'Could not determine which version to publish.',
+        dim: 'Set _version in embeddables/<id>/config.json, or use --publish-version <n>. To build, save a new version, and publish it, use --save.',
+    };
+}
+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',
+    };
+    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,
+    };
+}
+/**
+ * Push a saved version to staging or production.
+ */
+async function pushToEnvironment(params) {
+    const { embeddableId, projectId, versionNumber, targetStatus, skipStagingIfAlreadyPromoted } = params;
+    const accessToken = getAccessToken();
+    if (!accessToken) {
+        throw new PublishError('Could not retrieve access token.', 'Run "embeddables login" to re-authenticate.');
+    }
+    const apiUrl = `${WEB_APP_BASE_URL}/api/embeddables/set-version-status`;
+    const headers = {
+        Authorization: `Bearer ${accessToken}`,
+        'Content-Type': 'application/json',
+    };
+    const envLabel = targetStatus === 'STAGING' ? 'staging' : 'production';
+    const requestBody = {
+        embeddableId,
+        projectId,
+        versionNumber,
+        status: targetStatus,
+    };
+    try {
+        await stdout.withSpinner(`Publishing to ${envLabel} (v${versionNumber})…`, async () => {
+            const response = await fetchWithTimeout(apiUrl, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(requestBody),
+            });
+            if (response.ok) {
+                return { outcome: 'published' };
+            }
+            const errorData = await safeParseJson(response);
+            const errorMessage = errorData?.error ?? `HTTP ${response.status}`;
+            if (skipStagingIfAlreadyPromoted === true &&
+                targetStatus === 'STAGING' &&
+                response.status === 400 &&
+                errorMessage.includes(STAGING_GATE_ERROR_SUBSTRING)) {
+                return { outcome: 'skipped_staging_already_promoted' };
+            }
+            throw new PublishError(`Failed to publish to ${envLabel}: ${errorMessage}`);
+        }, {
+            successText: (pushResult) => pushResult.outcome === 'skipped_staging_already_promoted'
+                ? 'Already on staging; continuing…'
+                : `Published to ${envLabel}`,
+        });
+    }
+    catch (error) {
+        if (error instanceof PublishError) {
+            throw error;
+        }
+        if (isAbortError(error)) {
+            throw new PublishError(`Failed to publish to ${envLabel}: request timed out after ${DEFAULT_FETCH_TIMEOUT_MS}ms`);
+        }
+        const message = error instanceof Error ? error.message : 'Network request failed';
+        throw new PublishError(`Failed to publish to ${envLabel}: ${message}`);
+    }
+}
+async function pushToTargetEnvironments(params) {
+    const { embeddableId, projectId, versionNumber, targetEnv, viaStaging } = params;
+    if (targetEnv === 'STAGING') {
+        await pushToEnvironment({
+            embeddableId,
+            projectId,
+            versionNumber,
+            targetStatus: 'STAGING',
+        });
+        return;
+    }
+    if (viaStaging) {
+        await pushToEnvironment({
+            embeddableId,
+            projectId,
+            versionNumber,
+            targetStatus: 'STAGING',
+            skipStagingIfAlreadyPromoted: true,
+        });
+    }
+    await pushToEnvironment({
+        embeddableId,
+        projectId,
+        versionNumber,
+        targetStatus: 'PROD',
+    });
+}
+/**
+ * Publishes an embeddable to staging or production.
+ *
+ * By default promotes the existing server version from `config.json` `_version` (no new version).
+ * With `saveNewVersion: true`, builds, saves a new version via the API, then publishes it.
+ */
+export async function runDangerouslyPublish(opts) {
+    const logger = createLogger('runDangerouslyPublish');
+    const publishStart = performance.now();
+    try {
+        // Validate options
+        if (opts.staging && opts.prod) {
+            stdout.error('Cannot use --staging and --prod together.');
+            stdout.dim('Choose one target environment.');
+            await exit(1);
+            return;
+        }
+        if (!opts.staging && !opts.prod) {
+            stdout.error('Must specify --staging or --prod flag.');
+            stdout.dim('Example: embeddables dangerously-publish --staging');
+            await exit(1);
+            return;
+        }
+        if (opts.viaStaging === true && !opts.prod) {
+            stdout.error('--via-staging can only be used with --prod.');
+            stdout.dim('Example: embeddables dangerously-publish --prod --via-staging');
+            await exit(1);
+            return;
+        }
+        if (opts.saveNewVersion === true && opts.prod === true && opts.viaStaging !== true) {
+            stdout.error('--save with --prod requires --via-staging (new versions must be on staging before production).');
+            stdout.dim('Example: embeddables dangerously-publish --save --prod --via-staging');
+            await exit(1);
+            return;
+        }
+        const targetEnv = opts.staging ? 'STAGING' : 'PROD';
+        const envLabel = opts.staging ? 'staging' : 'production';
+        // 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
+        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 publish:',
+            });
+            if (!selected) {
+                await exit(1);
+                return;
+            }
+            embeddableId = selected;
+            stdout.gap();
+        }
+        if (embeddableId) {
+            const embeddableCtx = getSentryContextFromEmbeddableConfig(embeddableId);
+            setSentryContext({
+                embeddable: { id: embeddableId },
+                ...embeddableCtx,
+            });
+        }
+        const branchGate = readEmbeddableContext(embeddableId);
+        if (branchGate.branchId) {
+            stdout.error('dangerously-publish is only for the main line. This checkout is on a branch.');
+            stdout.dim('Switch to main with embeddables branches switch, or use the Builder.');
+            logger.error('publish blocked: branch checkout', { embeddableId, branchId: branchGate.branchId });
+            await exit(1);
+            return;
+        }
+        const branchLabel = 'main';
+        logger.info('dangerously-publish started', {
+            saveNewVersion: opts.saveNewVersion === true,
+            target: targetEnv,
+        });
+        // 4. Get project ID
+        let projectId = opts.projectId ?? getProjectId();
+        if (!projectId) {
+            stdout.step('No project configured. Fetching projects…');
+            const selectedProject = await promptForProject();
+            if (!selectedProject) {
+                await exit(1);
+                return;
+            }
+            projectId = selectedProject.id;
+        }
+        const generatedDir = path.join('embeddables', embeddableId, '.generated');
+        // Default: promote an existing server version (config `_version` / --publish-version / `.generated/`). No save-version.
+        if (opts.saveNewVersion !== true) {
+            const resolvedPublish = resolveVersionNumberForPublishOnly({
+                publishVersionRaw: opts.publishVersion,
+                embeddableId,
+                generatedDir,
+            });
+            if (!resolvedPublish.ok) {
+                stdout.error(resolvedPublish.error);
+                if (resolvedPublish.dim) {
+                    stdout.dim(resolvedPublish.dim);
+                }
+                logger.error('could not resolve version for publish', { embeddableId });
+                await exit(1);
+                return;
+            }
+            const versionNumberToPublish = resolvedPublish.versionNumber;
+            logger.info('dangerously-publish publish existing version', {
+                versionNumber: versionNumberToPublish,
+                target: targetEnv,
+            });
+            const publishExistingCtx = readEmbeddableContext(embeddableId);
+            stdout.embeddableInfoBox({
+                title: publishExistingCtx.title,
+                id: embeddableId,
+                branch: branchLabel,
+                version: `v${versionNumberToPublish}`,
+            });
+            setSentryContext({
+                versionNumber: versionNumberToPublish,
+            });
+            await pushToTargetEnvironments({
+                embeddableId,
+                projectId,
+                versionNumber: versionNumberToPublish,
+                targetEnv,
+                viaStaging: opts.viaStaging === true,
+            });
+            Sentry.metrics.count('cli.publish.completed', 1, {
+                attributes: {
+                    embeddableId: embeddableId,
+                    version: versionNumberToPublish,
+                    target: targetEnv,
+                    publishExisting: true,
+                    viaStaging: opts.viaStaging === true,
+                },
+            });
+            stdout.gap();
+            stdout.successBox(`${pc.bold(`Version ${versionNumberToPublish}`)} is live on ${envLabel} ${stdout.symbols.rocket}\n${stdout.randomMessage('save')}`, { title: 'Published' });
+            stdout.gap();
+            logger.info('publish complete', { versionNumber: versionNumberToPublish, target: targetEnv });
+            Sentry.metrics.distribution('cli.publish.duration', performance.now() - publishStart, {
+                unit: 'millisecond',
+                attributes: { embeddableId: embeddableId, target: targetEnv },
+            });
+            return;
+        }
+        // 5. Build (--save: create a new saved version, then publish it)
+        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 withSpan('publish.build', 'cli.build', async () => {
+                        await compileAllPages({
+                            pagesGlob,
+                            outPath,
+                            pageKeyFrom: 'filename',
+                            stylesDir,
+                            embeddableId: embeddableId,
+                            configPath,
+                        });
+                    }, { embeddableId: embeddableId });
+                }, {
+                    successText: 'Build successful',
+                    failText: 'Build failed',
+                });
+                Sentry.metrics.count('cli.build.completed', 1, {
+                    attributes: { command: 'dangerously-publish', embeddableId: embeddableId },
+                });
+            }
+            catch (e) {
+                Sentry.metrics.count('cli.build.failed', 1, {
+                    attributes: { command: 'dangerously-publish', embeddableId: embeddableId },
+                });
+                captureException(e, 'Publish build failed');
+                process.stderr.write(formatError(e));
+                logger.error('build failed');
+                await exit(1);
+                return;
+            }
+        }
+        // 6. Read 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;
+        }
+        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 (config `_version` or highest from `.generated/` snapshots)
+        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 that config.json has _version or .generated/ has versioned snapshots.');
+            logger.error('could not determine version');
+            await exit(1);
+            return;
+        }
+        const fromVersionNumber = detectedVersion;
+        setSentryContext({
+            versionNumber: fromVersionNumber,
+        });
+        const ctx = readEmbeddableContext(embeddableId);
+        stdout.embeddableInfoBox({
+            title: ctx.title,
+            id: embeddableId,
+            branch: branchLabel,
+            version: `v${fromVersionNumber}`,
+        });
+        // 8. Get current user ID from the authenticated auth client.
+        const supabase = await getAuthenticatedSupabaseClient();
+        if (!supabase) {
+            throw new PublishError('Could not initialize authenticated client.', 'Run "embeddables login" to re-authenticate.');
+        }
+        const { data: { user }, error: userError, } = await supabase.auth.getUser();
+        if (userError) {
+            throw new PublishError('Could not retrieve authenticated user.', userError.message);
+        }
+        const currentUserId = user?.id;
+        if (!currentUserId) {
+            throw new PublishError('You must be logged in to publish.', 'Run "embeddables login" to authenticate.');
+        }
+        // 9. Prepare edit history
+        const previousVersionPath = path.join(generatedDir, `embeddable-${PUBLISH_VERSION_FILE_BRANCH_SLUG}@${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 and published to ${envLabel} from CLI` },
+            ],
+            editHistory: [
+                setMultipleFlowUpdates({
+                    commands,
+                    metadata: {
+                        description: `Saved and published to ${envLabel} from CLI`,
+                        trigger: { origin: 'CLI', editor: 'CLI' },
+                    },
+                }),
+            ],
+        };
+        if (opts.label) {
+            body.label = opts.label;
+        }
+        body.branchId = null;
+        // 10. Save to server
+        const apiUrl = `${WEB_APP_BASE_URL}/api/embeddables/save-version`;
+        const headers = {
+            Authorization: `Bearer ${accessToken}`,
+            'Content-Type': 'application/json',
+        };
+        let response;
+        const uploadStart = performance.now();
+        try {
+            response = await stdout.withSpinner(`Saving embeddable (v${fromVersionNumber})…`, async () => {
+                return withSpan('publish.upload', 'cli.save', async () => {
+                    return fetchWithTimeout(apiUrl, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify(body),
+                    });
+                }, { embeddableId: embeddableId, 'api.endpoint': apiUrl });
+            }, { successText: 'Saved to server' });
+            Sentry.metrics.distribution('cli.publish.upload_duration', performance.now() - uploadStart, {
+                unit: 'millisecond',
+                attributes: { embeddableId: embeddableId },
+            });
+        }
+        catch (networkError) {
+            if (isAbortError(networkError)) {
+                throw new PublishError(`Could not reach the server: request timed out after ${DEFAULT_FETCH_TIMEOUT_MS}ms`);
+            }
+            const message = networkError instanceof Error ? networkError.message : 'Network request failed';
+            throw new PublishError(`Could not reach the server: ${message}`);
+        }
+        if (response.status === 404) {
+            throw new PublishError('Save endpoint not found.');
+        }
+        if (response.status === 401 || response.status === 403) {
+            throw new PublishError('Not authorized.', 'Run "embeddables login" to re-authenticate.');
+        }
+        if (response.status >= 500) {
+            throw new PublishError(`Server error (HTTP ${response.status}). Please try again later.`);
+        }
+        if (response.status === 409) {
+            Sentry.metrics.count('cli.publish.version_conflict', 1, {
+                attributes: { embeddableId: embeddableId },
+            });
+            const conflictResult = await safeParseJson(response);
+            if (!conflictResult || !isSaveConflictResponse(conflictResult)) {
+                throw new PublishError(`Version conflict but invalid response (HTTP ${response.status}).`);
+            }
+            stdout.gap();
+            stdout.warn(`Version conflict: the server has version ${conflictResult.latestVersionNumber}, but you are saving from version ${conflictResult.yourVersionNumber}.`);
+            if (!opts.force) {
+                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('Publish cancelled.');
+                    await exit(0);
+                    return;
+                }
+            }
+            // Retry with force flag
+            let forceResponse;
+            try {
+                forceResponse = await stdout.withSpinner('Force-saving…', async () => {
+                    return fetchWithTimeout(apiUrl, {
+                        method: 'POST',
+                        headers,
+                        body: JSON.stringify({ ...body, force: true }),
+                    });
+                }, {
+                    successText: 'Force save uploaded',
+                });
+            }
+            catch (forceNetworkError) {
+                if (isAbortError(forceNetworkError)) {
+                    throw new PublishError(`Retry failed: request timed out after ${DEFAULT_FETCH_TIMEOUT_MS}ms`);
+                }
+                const message = forceNetworkError instanceof Error ? forceNetworkError.message : 'Network request failed';
+                throw new PublishError(`Retry failed: ${message}`);
+            }
+            if (!forceResponse.ok) {
+                const forceResult = await safeParseJson(forceResponse);
+                const errorMessage = forceResult && isSaveErrorResponse(forceResult)
+                    ? forceResult.error
+                    : `HTTP ${forceResponse.status}`;
+                throw new PublishError(errorMessage);
+            }
+            const forceResult = await safeParseJson(forceResponse);
+            if (!forceResult || !isSaveResponse(forceResult)) {
+                throw new PublishError('Invalid response from server after force save.');
+            }
+            response = forceResponse;
+        }
+        const result = await safeParseJson(response);
+        if (!response.ok) {
+            const errorMessage = result && isSaveErrorResponse(result) ? result.error : `HTTP ${response.status}`;
+            throw new PublishError(errorMessage);
+        }
+        if (!result || !isSaveResponse(result)) {
+            throw new PublishError('Invalid response from server.');
+        }
+        const { newVersionNumber } = result.data;
+        // Update local version
+        setVersionInConfig(embeddableId, newVersionNumber);
+        const versionedPath = path.join(generatedDir, `embeddable-${PUBLISH_VERSION_FILE_BRANCH_SLUG}@${newVersionNumber}.json`);
+        fs.mkdirSync(generatedDir, { recursive: true });
+        fs.writeFileSync(versionedPath, jsonContent, 'utf8');
+        // 11–12. Publish to staging and/or production (--prod alone goes straight to prod unless --via-staging)
+        await pushToTargetEnvironments({
+            embeddableId,
+            projectId,
+            versionNumber: newVersionNumber,
+            targetEnv,
+            viaStaging: opts.viaStaging === true,
+        });
+        Sentry.metrics.count('cli.publish.completed', 1, {
+            attributes: {
+                embeddableId: embeddableId,
+                version: newVersionNumber,
+                target: targetEnv,
+                viaStaging: opts.viaStaging === true,
+            },
+        });
+        stdout.gap();
+        stdout.successBox(`${pc.bold(`Version ${newVersionNumber}`)} is live on ${envLabel} ${stdout.symbols.rocket}\n${stdout.randomMessage('save')}`, { title: 'Published' });
+        stdout.gap();
+        logger.info('publish complete', { newVersionNumber, target: targetEnv });
+        Sentry.metrics.distribution('cli.publish.duration', performance.now() - publishStart, {
+            unit: 'millisecond',
+            attributes: { embeddableId: embeddableId, target: targetEnv },
+        });
+    }
+    catch (error) {
+        Sentry.metrics.count('cli.publish.failed', 1, {
+            attributes: { embeddableId: opts.id ?? 'unknown' },
+        });
+        captureException(error, 'Publish failed');
+        if (error instanceof PublishError) {
+            stdout.error(`Publish failed: ${error.message}`);
+            if (error.detail) {
+                stdout.dim(error.detail);
+            }
+        }
+        else if (error instanceof Error) {
+            stdout.error(`Publish failed: ${error.message}`);
+        }
+        else {
+            stdout.error('Publish failed with an unexpected error.');
+        }
+        logger.error('publish failed', {
+            message: error instanceof Error ? error.message : 'unexpected error',
+        });
+        await exit(1);
+    }
+}
+//# sourceMappingURL=dangerously-publish.js.map