@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/prompts/uploadPrompt.d.ts

@@ -0,0 +1,9 @@
+type UploadPromptResponse = {
+    src: string;
+    dest: string;
+};
+export declare function uploadPrompt(promptOptions?: {
+    src?: string;
+    dest?: string;
+}): Promise<UploadPromptResponse>;
+export {};

package/lib/prompts/uploadPrompt.js

@@ -0,0 +1,32 @@
+import path from 'path';
+import { getCwd } from '@hubspot/local-dev-lib/path';
+import { promptUser } from './promptUtils.js';
+import { lib } from '../../lang/en.js';
+export async function uploadPrompt(promptOptions = {}) {
+    return promptUser([
+        {
+            name: 'src',
+            message: lib.prompts.uploadPrompt.enterSrc,
+            when: !promptOptions.src,
+            default: '.',
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.uploadPrompt.errors.srcRequired;
+                }
+                return true;
+            },
+        },
+        {
+            name: 'dest',
+            message: lib.prompts.uploadPrompt.enterDest,
+            when: !promptOptions.dest,
+            default: path.basename(getCwd()),
+            validate: (input) => {
+                if (!input) {
+                    return lib.prompts.uploadPrompt.errors.destRequired;
+                }
+                return true;
+            },
+        },
+    ]);
+}

package/lib/sandboxes.d.ts

@@ -0,0 +1,14 @@
+import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+import { SandboxAccountType } from '../types/Sandboxes.js';
+export declare const SANDBOX_TYPE_MAP: {
+    [key: string]: SandboxAccountType;
+};
+export declare const SANDBOX_TYPE_MAP_V2: {
+    readonly STANDARD_SANDBOX: "STANDARD";
+    readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
+};
+export declare function getSandboxTypeAsString(accountType?: AccountType): string;
+export declare function getHasSandboxesByType(parentAccountConfig: HubSpotConfigAccount, type: AccountType): boolean;
+export declare function validateSandboxUsageLimits(accountConfig: HubSpotConfigAccount, sandboxType: AccountType, env: Environment): Promise<void>;
+export declare function handleSandboxCreateError(err: unknown, env: Environment, name: string, accountId: number): never;

package/lib/sandboxes.js

@@ -0,0 +1,105 @@
+import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
+import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
+import { logError } from './errorHandlers/index.js';
+import { uiAccountDescription } from './ui/index.js';
+export const SANDBOX_TYPE_MAP = {
+    dev: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    developer: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    development: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+    standard: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+};
+export const SANDBOX_TYPE_MAP_V2 = {
+    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
+    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
+};
+export function getSandboxTypeAsString(accountType) {
+    if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+        return 'development'; // Only place we're using this specific name
+    }
+    return 'standard';
+}
+export function getHasSandboxesByType(parentAccountConfig, type) {
+    const parentPortalId = parentAccountConfig.accountId;
+    const accountsList = getAllConfigAccounts();
+    for (const portal of accountsList) {
+        if ((portal.parentAccountId !== null ||
+            portal.parentAccountId !== undefined) &&
+            portal.parentAccountId === parentPortalId &&
+            portal.accountType &&
+            portal.accountType === type) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
+    const accountId = accountConfig.accountId;
+    if (!accountId) {
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
+    }
+    const { data: { usage }, } = await getSandboxUsageLimits(accountId);
+    if (!usage) {
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
+    }
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+        if (usage['DEVELOPER'].available === 0) {
+            const devSandboxLimit = usage['DEVELOPER'].limit;
+            const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
+            if (hasDevelopmentSandboxes) {
+                throw new Error(lib.sandbox.create.developer.failure.alreadyInConfig(accountId, devSandboxLimit));
+            }
+            else {
+                const baseUrl = getHubSpotWebsiteOrigin(env);
+                throw new Error(lib.sandbox.create.developer.failure.limit(accountId, devSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/development`));
+            }
+        }
+    }
+    if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
+        if (usage['STANDARD'].available === 0) {
+            const standardSandboxLimit = usage['STANDARD'].limit;
+            const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
+            if (hasStandardSandboxes) {
+                throw new Error(lib.sandbox.create.standard.failure.alreadyInConfig(accountId, standardSandboxLimit));
+            }
+            else {
+                const baseUrl = getHubSpotWebsiteOrigin(env);
+                throw new Error(lib.sandbox.create.standard.failure.limit(accountId, standardSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/standard`));
+            }
+        }
+    }
+}
+export function handleSandboxCreateError(err, env, name, accountId) {
+    if (isMissingScopeError(err)) {
+        uiLogger.error(lib.sandbox.create.failure.scopes.message);
+        const websiteOrigin = getHubSpotWebsiteOrigin(env);
+        const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+        uiLogger.info(lib.sandbox.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
+    }
+    else if (isSpecifiedError(err, {
+        statusCode: 403,
+        category: 'BANNED',
+        subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
+    })) {
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure.invalidUser(name, accountId));
+        uiLogger.log('');
+    }
+    else if (isSpecifiedError(err, {
+        statusCode: 403,
+        category: 'BANNED',
+        subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
+    })) {
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure['403Gating'](name, accountId));
+        uiLogger.log('');
+    }
+    else {
+        logError(err);
+    }
+    throw err;
+}

package/lib/schema.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@hubspot/local-dev-lib/types/Schemas';
+export declare function logSchemas(schemas: Array<Schema>): void;
+export declare function listSchemas(accountId: number): Promise<void>;

package/lib/schema.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import { table, getBorderCharacters } from 'table';
+import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
+import { uiLogger } from './ui/logger.js';
+export function logSchemas(schemas) {
+    const data = schemas
+        .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
+        .sort((a, b) => (a[1] > b[1] ? 1 : -1));
+    if (data.length === 0) {
+        uiLogger.log('No Schemas were found');
+        return;
+    }
+    data.unshift([
+        chalk.bold('Label'),
+        chalk.bold('Name'),
+        chalk.bold('objectTypeId'),
+    ]);
+    const tableConfig = {
+        singleLine: true,
+        border: getBorderCharacters('honeywell'),
+    };
+    uiLogger.log(table(data, tableConfig));
+}
+export async function listSchemas(accountId) {
+    const { data } = await fetchObjectSchemas(accountId);
+    logSchemas(data.results);
+}

package/lib/serverlessLogs.d.ts

@@ -0,0 +1,4 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { FunctionLog, GetFunctionLogsResponse } from '@hubspot/local-dev-lib/types/Functions';
+export declare function tailLogs(accountId: number, name: string, fetchLatest: () => HubSpotPromise<FunctionLog>, tailCall: (after?: string) => HubSpotPromise<GetFunctionLogsResponse>, compact?: boolean): Promise<void>;
+export declare function outputBuildLog(buildLogUrl: string): Promise<string>;

package/lib/serverlessLogs.js

@@ -0,0 +1,154 @@
+import https from 'https';
+import chalk from 'chalk';
+import { uiLogger } from './ui/logger.js';
+import { isHubSpotHttpError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
+import { SCOPE_GROUPS, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
+import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { fetchScopeData } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { outputLogs } from './ui/serverlessFunctionLogs.js';
+import { logError, ApiErrorContext } from './errorHandlers/index.js';
+import SpinniesManager from './ui/SpinniesManager.js';
+import { handleExit, handleKeypress } from './process.js';
+import { lib } from '../lang/en.js';
+const TAIL_DELAY = 5000;
+function base64EncodeString(valueToEncode) {
+    if (typeof valueToEncode !== 'string') {
+        return valueToEncode;
+    }
+    const stringBuffer = Buffer.from(valueToEncode);
+    return encodeURIComponent(stringBuffer.toString('base64'));
+}
+async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
+    const accountConfig = getConfigAccountById(accountId);
+    if (!accountConfig) {
+        return;
+    }
+    const { authType } = accountConfig;
+    if (authType !== PERSONAL_ACCESS_KEY_AUTH_METHOD.value) {
+        return;
+    }
+    let scopesData;
+    try {
+        const resp = await fetchScopeData(accountId, scopeGroup);
+        scopesData = resp.data;
+    }
+    catch (e) {
+        uiLogger.debug(lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError(scopeGroup));
+        uiLogger.debug(e);
+        return;
+    }
+    const { portalScopesInGroup, userScopesInGroup } = scopesData;
+    if (!portalScopesInGroup.length) {
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope);
+        return;
+    }
+    if (!portalScopesInGroup.every(s => userScopesInGroup.includes(s))) {
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope);
+    }
+    else {
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope);
+    }
+}
+export async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false) {
+    let initialAfter = '';
+    try {
+        const { data: latestLog } = await fetchLatest();
+        initialAfter = latestLog && base64EncodeString(latestLog.id);
+    }
+    catch (e) {
+        // A 404 means no latest log exists(never executed)
+        if (isHubSpotHttpError(e) && e.status !== 404) {
+            if (isMissingScopeError(e)) {
+                await verifyAccessKeyAndUserAccess(accountId, SCOPE_GROUPS.CMS_FUNCTIONS);
+            }
+            else {
+                await logError(e, new ApiErrorContext({ accountId }));
+            }
+        }
+    }
+    return new Promise(resolve => {
+        function cleanup() {
+            SpinniesManager.remove('tailLogs');
+            SpinniesManager.remove('stopMessage');
+        }
+        let resolved = false;
+        const onTerminate = async () => {
+            if (resolved)
+                return;
+            resolved = true;
+            cleanup();
+            resolve();
+        };
+        handleExit(onTerminate);
+        handleKeypress(key => {
+            if ((key.ctrl && key.name == 'c') || key.name === 'q') {
+                onTerminate();
+            }
+        });
+        async function tail(after) {
+            let latestLog;
+            let nextAfter;
+            try {
+                const { data } = await tailCall(after);
+                latestLog = data;
+                nextAfter = latestLog.paging.next.after;
+            }
+            catch (e) {
+                if (isHubSpotHttpError(e) && e.status !== 404) {
+                    logError(e, new ApiErrorContext({
+                        accountId,
+                    }));
+                }
+                await onTerminate();
+                return;
+            }
+            if (latestLog && latestLog.results.length) {
+                outputLogs(latestLog, {
+                    compact,
+                });
+            }
+            setTimeout(async () => {
+                await tail(nextAfter);
+            }, TAIL_DELAY);
+        }
+        SpinniesManager.add('tailLogs', {
+            text: `Following logs for ${name}`,
+        });
+        SpinniesManager.add('stopMessage', {
+            text: `> Press ${chalk.bold('q')} to stop following`,
+            status: 'non-spinnable',
+        });
+        tail(initialAfter);
+    });
+}
+export async function outputBuildLog(buildLogUrl) {
+    if (!buildLogUrl) {
+        uiLogger.debug('Unable to display build output. No build log URL was provided.');
+        return '';
+    }
+    return new Promise(resolve => {
+        try {
+            https
+                .get(buildLogUrl, response => {
+                if (response.statusCode === 404) {
+                    resolve('');
+                }
+                let data = '';
+                response.on('data', chunk => {
+                    data += chunk;
+                });
+                response.on('end', () => {
+                    uiLogger.log(data);
+                    resolve(data);
+                });
+            })
+                .on('error', () => {
+                uiLogger.error('The build log could not be retrieved.');
+            });
+        }
+        catch (e) {
+            uiLogger.error('The build log could not be retrieved.');
+            resolve('');
+        }
+    });
+}

package/lib/testUtils.d.ts

@@ -0,0 +1,14 @@
+import { HubSpotPromise } from '@hubspot/local-dev-lib/types/Http';
+import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
+type MockErrorResponse = {
+    status: number;
+    data: {
+        message?: string;
+        errorType?: string;
+        category?: string;
+        subCategory?: string;
+    };
+};
+export declare function mockHubSpotHttpResponse<T>(data?: any): HubSpotPromise<T>;
+export declare function mockHubSpotHttpError(message: string, response: MockErrorResponse): HubSpotHttpError;
+export {};

package/lib/testUtils.js

@@ -0,0 +1,18 @@
+import { HubSpotHttpError } from '@hubspot/local-dev-lib/models/HubSpotHttpError';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function mockHubSpotHttpResponse(data) {
+    return Promise.resolve({
+        data,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: {
+            headers: {},
+        },
+    });
+}
+export function mockHubSpotHttpError(message, response) {
+    return new HubSpotHttpError(message, {
+        cause: { isAxiosError: true, response },
+    });
+}

package/lib/theme/cmsDevServerProcess.d.ts

@@ -0,0 +1,12 @@
+import { ChildProcess } from 'child_process';
+interface DevServerOptions {
+    absoluteSrc: string;
+    accountName?: string;
+    noSsl?: boolean;
+    port?: number;
+    generateFieldsTypes?: boolean;
+    resetSession?: boolean;
+    dest: string;
+}
+export declare function spawnDevServer(options: DevServerOptions): Promise<ChildProcess>;
+export {};

package/lib/theme/cmsDevServerProcess.js

@@ -0,0 +1,148 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { getConfigFilePath } from '@hubspot/local-dev-lib/config';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { lib } from '../../lang/en.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// cms-dev-server version to install to isolated cache
+const TARGET_CMS_DEV_SERVER_VERSION = '1.2.16';
+/**
+ * Ensures cms-dev-server is installed in an isolated cache directory.
+ * This prevents React version conflicts with the CLI.
+ */
+async function ensureCmsDevServerCache(targetVersion) {
+    const cacheDir = path.join(os.homedir(), '.hscli', '.module-cache');
+    const packageJsonPath = path.join(cacheDir, 'node_modules', '@hubspot', 'cms-dev-server', 'package.json');
+    // Check if already installed with correct version
+    let needsInstall = true;
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const installedPackage = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (installedPackage.version === targetVersion) {
+                needsInstall = false;
+            }
+        }
+        catch (e) {
+            // If we can't read the package.json, reinstall
+            needsInstall = true;
+        }
+    }
+    if (needsInstall) {
+        // Show spinner during install (can take 10-30 seconds)
+        SpinniesManager.init({
+            succeedColor: 'white',
+        });
+        SpinniesManager.add('cms-dev-server-install', {
+            text: lib.theme.cmsDevServerProcess.installStarted(targetVersion),
+        });
+        // Create cache directory
+        fs.mkdirSync(cacheDir, { recursive: true });
+        // Clear old installation if exists
+        const nodeModulesDir = path.join(cacheDir, 'node_modules');
+        if (fs.existsSync(nodeModulesDir)) {
+            fs.rmSync(nodeModulesDir, { recursive: true, force: true });
+        }
+        // Install cms-dev-server with production dependencies only (async to allow spinner)
+        await new Promise((resolve, reject) => {
+            const installProcess = spawn('npm', [
+                'install',
+                `@hubspot/cms-dev-server@${targetVersion}`,
+                '--production',
+                '--no-save',
+                '--loglevel=error',
+            ], {
+                cwd: cacheDir,
+                stdio: 'ignore', // Suppress npm output
+            });
+            installProcess.on('close', code => {
+                if (code === 0) {
+                    SpinniesManager.succeed('cms-dev-server-install', {
+                        text: lib.theme.cmsDevServerProcess.installSucceeded,
+                    });
+                    resolve();
+                }
+                else {
+                    SpinniesManager.fail('cms-dev-server-install', {
+                        text: lib.theme.cmsDevServerProcess.installFailed,
+                    });
+                    reject(new Error(lib.theme.cmsDevServerProcess.installFailed));
+                }
+            });
+            installProcess.on('error', error => {
+                SpinniesManager.fail('cms-dev-server-install', {
+                    text: lib.theme.cmsDevServerProcess.installFailed,
+                });
+                reject(error);
+            });
+        });
+    }
+    return cacheDir;
+}
+export async function spawnDevServer(options) {
+    const { absoluteSrc, accountName, noSsl, port, generateFieldsTypes, resetSession, dest, } = options;
+    // Ensure cms-dev-server is installed in isolated cache
+    const cacheDir = await ensureCmsDevServerCache(TARGET_CMS_DEV_SERVER_VERSION);
+    // Get config path to pass to createDevServer
+    let configPath = '';
+    try {
+        configPath = process.env.HUBSPOT_CONFIG_PATH || getConfigFilePath();
+    }
+    catch (e) {
+        // Config file doesn't exist - cms-dev-server will handle this gracefully
+    }
+    // Copy the runner script to the cache directory so imports resolve from there
+    // This is critical: Node resolves ES module imports relative to the script location,
+    // not the cwd. By copying the script to the cache directory, imports will resolve
+    // from the cache's node_modules (React 18) instead of the CLI's node_modules (React 19)
+    const sourceRunnerPath = path.join(__dirname, 'cmsDevServerRunner.js');
+    const targetRunnerPath = path.join(cacheDir, 'cmsPreviewRunner.js');
+    fs.copyFileSync(sourceRunnerPath, targetRunnerPath);
+    // Set environment variables to pass configuration to the runner script
+    const env = { ...process.env };
+    env.CMS_DEV_SERVER_SRC = absoluteSrc;
+    env.CMS_DEV_SERVER_DEST = dest;
+    env.CMS_DEV_SERVER_CONFIG = configPath;
+    env.CMS_DEV_SERVER_ACCOUNT = accountName || '';
+    env.CMS_DEV_SERVER_SSL = (!noSsl).toString();
+    env.CMS_DEV_SERVER_FIELD_GEN = Boolean(generateFieldsTypes).toString();
+    env.CMS_DEV_SERVER_RESET_SESSION = Boolean(resetSession).toString();
+    if (port) {
+        env.PORT = port.toString();
+    }
+    // Suppress Node.js deprecation warnings
+    env.NODE_NO_WARNINGS = '1';
+    // Spawn Node with the runner script from the isolated cache directory
+    // This ensures complete isolation from CLI's React 19
+    const devServer = spawn('node', [targetRunnerPath], {
+        stdio: 'inherit',
+        env,
+        cwd: cacheDir,
+    });
+    // Handle process events
+    devServer.on('error', error => {
+        console.error(lib.theme.cmsDevServerProcess.serverStartError(error));
+        process.exit(1);
+    });
+    devServer.on('exit', (code, signal) => {
+        if (code !== 0 && code !== null) {
+            console.error(lib.theme.cmsDevServerProcess.serverExit(code));
+            process.exit(code);
+        }
+        if (signal) {
+            console.error(lib.theme.cmsDevServerProcess.serverKill(signal));
+            process.exit(1);
+        }
+    });
+    // Handle CLI termination
+    process.once('SIGINT', () => {
+        devServer.kill('SIGINT');
+    });
+    process.once('SIGTERM', () => {
+        devServer.kill('SIGTERM');
+    });
+    return devServer;
+}

package/lib/theme/cmsDevServerRunner.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This script runs in an isolated cache directory with cms-dev-server installed.
+ * It is spawned as a separate process to avoid React version conflicts with the CLI.
+ *
+ * Arguments are passed via environment variables:
+ * - CMS_DEV_SERVER_SRC: Source directory path
+ * - CMS_DEV_SERVER_DEST: Destination path
+ * - CMS_DEV_SERVER_CONFIG: Config file path (optional)
+ * - CMS_DEV_SERVER_ACCOUNT: Account name (optional)
+ * - CMS_DEV_SERVER_SSL: 'true' or 'false'
+ * - CMS_DEV_SERVER_FIELD_GEN: 'true' or 'false'
+ * - CMS_DEV_SERVER_RESET_SESSION: 'true' or 'false'
+ */
+export {};

package/lib/theme/cmsDevServerRunner.js

@@ -0,0 +1,90 @@
+// @ts-nocheck
+/**
+ * This script runs in an isolated cache directory with cms-dev-server installed.
+ * It is spawned as a separate process to avoid React version conflicts with the CLI.
+ *
+ * Arguments are passed via environment variables:
+ * - CMS_DEV_SERVER_SRC: Source directory path
+ * - CMS_DEV_SERVER_DEST: Destination path
+ * - CMS_DEV_SERVER_CONFIG: Config file path (optional)
+ * - CMS_DEV_SERVER_ACCOUNT: Account name (optional)
+ * - CMS_DEV_SERVER_SSL: 'true' or 'false'
+ * - CMS_DEV_SERVER_FIELD_GEN: 'true' or 'false'
+ * - CMS_DEV_SERVER_RESET_SESSION: 'true' or 'false'
+ */
+// Suppress library deprecation warnings (e.g., body-parser)
+process.noDeprecation = true;
+// Dynamic imports to use the isolated cms-dev-server installation
+const { createDevServer } = await import('@hubspot/cms-dev-server');
+const { walk } = await import('@hubspot/local-dev-lib/fs');
+const { createIgnoreFilter } = await import('@hubspot/local-dev-lib/ignoreRules');
+const { isAllowedExtension } = await import('@hubspot/local-dev-lib/path');
+const { FILE_UPLOAD_RESULT_TYPES } = await import('@hubspot/local-dev-lib/constants/files');
+const cliProgress = (await import('cli-progress')).default;
+// Read configuration from environment variables
+const src = process.env.CMS_DEV_SERVER_SRC;
+const dest = process.env.CMS_DEV_SERVER_DEST;
+const configPath = process.env.CMS_DEV_SERVER_CONFIG || '';
+const accountName = process.env.CMS_DEV_SERVER_ACCOUNT || '';
+const sslEnabled = process.env.CMS_DEV_SERVER_SSL === 'true';
+const fieldGenEnabled = process.env.CMS_DEV_SERVER_FIELD_GEN === 'true';
+const resetSession = process.env.CMS_DEV_SERVER_RESET_SESSION === 'true';
+// Get uploadable files for preview
+let filePaths = [];
+try {
+    filePaths = await walk(src);
+}
+catch (e) {
+    console.error('Error walking directory:', e);
+}
+filePaths = filePaths
+    .filter(file => isAllowedExtension(file))
+    .filter(createIgnoreFilter(false));
+// Create progress bar for initial upload
+function startProgressBar(numFiles) {
+    const initialUploadProgressBar = new cliProgress.SingleBar({
+        gracefulExit: true,
+        format: '[{bar}] {percentage}% | {value}/{total} | {label}',
+        hideCursor: true,
+    }, cliProgress.Presets.rect);
+    initialUploadProgressBar.start(numFiles, 0, {
+        label: 'Preparing upload...',
+    });
+    let uploadsHaveStarted = false;
+    return {
+        onAttemptCallback: () => { },
+        onSuccessCallback: () => {
+            initialUploadProgressBar.increment();
+            if (!uploadsHaveStarted) {
+                uploadsHaveStarted = true;
+                initialUploadProgressBar.update(0, {
+                    label: 'Uploading files...',
+                });
+            }
+        },
+        onFirstErrorCallback: () => { },
+        onRetryCallback: () => { },
+        onFinalErrorCallback: () => initialUploadProgressBar.increment(),
+        // eslint-disable-next-line
+        onFinishCallback: (results) => {
+            initialUploadProgressBar.update(numFiles, {
+                label: 'Upload complete',
+            });
+            initialUploadProgressBar.stop();
+            results.forEach(result => {
+                if (result.resultType === FILE_UPLOAD_RESULT_TYPES.FAILURE) {
+                    console.error(`Failed to upload ${result.file}`);
+                }
+            });
+        },
+    };
+}
+const themePreviewOptions = {
+    filePaths,
+    startProgressBar,
+    resetSession,
+    dest,
+};
+createDevServer(src, false, // storybook
+configPath, accountName, sslEnabled, fieldGenEnabled, themePreviewOptions);
+export {};

package/lib/theme/migrate.d.ts

@@ -0,0 +1,13 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { LoadedProjectConfig } from '../projects/config.js';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs.js';
+export type MigrateThemesArgs = CommonArgs & AccountArgs & EnvironmentArgs & ConfigArgs & {
+    platformVersion: string;
+};
+export declare function getHasMigratableThemes(projectConfig?: LoadedProjectConfig): Promise<{
+    hasMigratableThemes: boolean;
+    migratableThemesCount: number;
+}>;
+export declare function validateMigrationAppsAndThemes(hasApps: number, projectConfig?: LoadedProjectConfig): Promise<void>;
+export declare function handleThemesMigration(projectConfig: LoadedProjectConfig, platformVersion: string): Promise<void>;
+export declare function migrateThemesV2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateThemesArgs>, themeCount: number, projectConfig: LoadedProjectConfig): Promise<void>;