@hubspot/cli 8.0.10-experimental.1 → 8.0.10-experimental.3

package/lib/projects/watch.js

@@ -18,6 +18,7 @@ const standbyQueue = [];
 let currentBuildId;
 let handleBuildStatus;
 let handleUserInput;
+let handleWatchTermination = () => { };
 let timer;
 async function processStandByQueue(accountId, projectName, platformVersion) {
     queue.addAll(standbyQueue.map(({ filePath, remotePath, action }) => {
@@ -37,33 +38,39 @@ function debounceQueueBuild(accountId, projectName, platformVersion) {
         clearTimeout(timer);
     }
     timer = setTimeout(async () => {
-        uiLogger.debug(commands.project.watch.debug.pause);
-        queue.pause();
-        await queue.onIdle();
         try {
-            await queueBuild(accountId, projectName, platformVersion);
-            uiLogger.debug(commands.project.watch.debug.buildStarted);
-        }
-        catch (err) {
-            if (isSpecifiedError(err, {
-                subCategory: PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
-            })) {
-                uiLogger.log(commands.project.watch.logs.watchCancelledFromUi);
-                process.exit(0);
+            uiLogger.debug(commands.project.watch.debug.pause);
+            queue.pause();
+            await queue.onIdle();
+            try {
+                await queueBuild(accountId, projectName, platformVersion);
+                uiLogger.debug(commands.project.watch.debug.buildStarted);
+            }
+            catch (err) {
+                if (isSpecifiedError(err, {
+                    subCategory: PROJECT_ERROR_TYPES.MISSING_PROJECT_PROVISION,
+                })) {
+                    uiLogger.log(commands.project.watch.logs.watchCancelledFromUi);
+                    handleWatchTermination();
+                    return;
+                }
+                else {
+                    logError(err, new ApiErrorContext({ accountId }));
+                }
+                return;
             }
-            else {
-                logError(err, new ApiErrorContext({ accountId }));
+            await handleBuildStatus(accountId, projectName, currentBuildId);
+            await createNewStagingBuild(accountId, projectName, platformVersion);
+            if (standbyQueue.length > 0) {
+                await processStandByQueue(accountId, projectName, platformVersion);
             }
-            return;
+            queue.start();
+            uiLogger.log(commands.project.watch.logs.resuming);
+            uiLogger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
         }
-        await handleBuildStatus(accountId, projectName, currentBuildId);
-        await createNewStagingBuild(accountId, projectName, platformVersion);
-        if (standbyQueue.length > 0) {
-            await processStandByQueue(accountId, projectName, platformVersion);
+        catch (err) {
+            handleWatchTermination(err);
         }
-        queue.start();
-        uiLogger.log(commands.project.watch.logs.resuming);
-        uiLogger.log(`\n> Press ${chalk.bold('q')} to quit watching\n`);
     }, 2000);
 }
 async function queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action) {
@@ -111,7 +118,7 @@ async function createNewBuild(accountId, projectName, platformVersion) {
             await cancelStagedBuild(accountId, projectName);
             uiLogger.log(commands.project.watch.logs.previousStagingBuildCancelled);
         }
-        process.exit(1);
+        throw err;
     }
 }
 async function handleWatchEvent(accountId, projectName, platformVersion, projectSourceDir, filePath, action = 'upload') {
@@ -132,10 +139,11 @@ async function handleWatchEvent(accountId, projectName, platformVersion, project
         await queueFileOrFolder(accountId, projectName, platformVersion, filePath, remotePath, action);
     }
 }
-export async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn) {
+export async function createWatcher(accountId, projectConfig, projectDir, handleBuildStatusFn, handleUserInputFn, handleWatchTerminationFn) {
     const projectSourceDir = path.join(projectDir, projectConfig.srcDir);
     handleBuildStatus = handleBuildStatusFn;
     handleUserInput = handleUserInputFn;
+    handleWatchTermination = handleWatchTerminationFn;
     await createNewStagingBuild(accountId, projectConfig.name, projectConfig.platformVersion);
     const watcher = chokidar.watch(projectSourceDir, {
         ignoreInitial: true,

package/lib/prompts/downloadProjectPrompt.js

@@ -2,21 +2,22 @@ import { promptUser } from './promptUtils.js';
 import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
 import { logError, ApiErrorContext } from '../errorHandlers/index.js';
-import { uiLogger } from '../ui/logger.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { uiLogger } from '../ui/logger.js';
 async function createProjectsList(accountId) {
-    try {
-        if (accountId) {
-            const { data: projects } = await fetchProjects(accountId);
-            return projects.results;
-        }
+    if (!accountId) {
         uiLogger.error(lib.prompts.downloadProjectPrompt.errors.accountIdRequired);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.downloadProjectPrompt.errors.accountIdRequired, EXIT_CODES.ERROR);
+    }
+    try {
+        const { data: projects } = await fetchProjects(accountId);
+        return projects.results;
     }
     catch (e) {
-        logError(e, accountId ? new ApiErrorContext({ accountId }) : undefined);
-        process.exit(EXIT_CODES.ERROR);
+        logError(e, new ApiErrorContext({ accountId }));
+        throw new PromptExitError('Failed to fetch projects', EXIT_CODES.ERROR);
     }
 }
 export async function downloadProjectPrompt(promptOptions) {

package/lib/prompts/installAppPrompt.js

@@ -1,8 +1,9 @@
 import open from 'open';
 import { promptUser } from './promptUtils.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     uiLogger.log('');
     if (isReinstall) {
@@ -20,7 +21,7 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     });
     if (!isReinstall && !shouldOpenBrowser) {
         uiLogger.log(lib.prompts.installAppPrompt.decline);
-        process.exit(EXIT_CODES.SUCCESS);
+        throw new PromptExitError(lib.prompts.installAppPrompt.decline, EXIT_CODES.SUCCESS);
     }
     else if (!shouldOpenBrowser) {
         return;

package/lib/prompts/personalAccessKeyPrompt.js

@@ -6,8 +6,9 @@ import { uiLogger } from '../ui/logger.js';
 import { promptUser } from './promptUtils.js';
 import { getCliAccountNamePromptConfig, } from './accountNamePrompt.js';
 import { uiInfoSection } from '../ui/index.js';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 /**
  * Displays notification to user that we are about to open the browser,
  * then opens their browser to the personal-access-key shortlink
@@ -27,7 +28,7 @@ export async function personalAccessKeyPrompt({ env, account, }) {
         ]);
         if (!choice) {
             deleteConfigFileIfEmpty();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.personalAccessKeyPrompt.errors.authCancelled, EXIT_CODES.SUCCESS);
         }
         if (choice ===
             lib.prompts.personalAccessKeyPrompt.personalAccessKeyPromptChoices

package/lib/prompts/projectDevTargetAccountPrompt.js

@@ -6,6 +6,7 @@ import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
 import { uiAccountDescription } from '../ui/index.js';
 import { isSandbox } from '../accountTypes.js';
+import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 function mapNestedAccount(accountConfig) {
     const parentAccountId = accountConfig.parentAccountId ?? null;
@@ -23,20 +24,18 @@ function getNonConfigDeveloperTestAccountName(account) {
 }
 export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let choices = [];
     let sandboxUsage = {
         STANDARD: { used: 0, available: 0, limit: 0 },
         DEVELOPER: { used: 0, available: 0, limit: 0 },
     };
     try {
-        if (defaultAccountId) {
-            const { data } = await getSandboxUsageLimits(defaultAccountId);
-            sandboxUsage = data.usage;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await getSandboxUsageLimits(defaultAccountId);
+        sandboxUsage = data.usage;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch sandbox usage limits: ', err);
@@ -83,16 +82,14 @@ export async function selectSandboxTargetAccountPrompt(accounts, defaultAccountC
 }
 export async function selectDeveloperTestTargetAccountPrompt(accounts, defaultAccountConfig) {
     const defaultAccountId = defaultAccountConfig.accountId;
+    if (!defaultAccountId) {
+        uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
+        throw new PromptExitError(lib.prompts.projectDevTargetAccountPrompt.noAccountId, EXIT_CODES.ERROR);
+    }
     let devTestAccountsResponse;
     try {
-        if (defaultAccountId) {
-            const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
-            devTestAccountsResponse = data;
-        }
-        else {
-            uiLogger.error(lib.prompts.projectDevTargetAccountPrompt.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
+        const { data } = await fetchDeveloperTestAccounts(defaultAccountId);
+        devTestAccountsResponse = data;
     }
     catch (err) {
         uiLogger.debug('Unable to fetch developer test account usage limits: ', err);

package/lib/prompts/selectHubDBTablePrompt.js

@@ -4,25 +4,29 @@ import { lib } from '../../lang/en.js';
 import { debugError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchTables } from '@hubspot/local-dev-lib/api/hubdb';
-import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isValidPath, untildify } from '@hubspot/local-dev-lib/path';
+import { PromptExitError } from '../errors/PromptExitError.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchHubDBOptions(accountId) {
     try {
         const { data: { results: tables }, } = await fetchTables(accountId);
         if (tables.length === 0) {
             uiLogger.log(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()));
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.noTables(accountId.toString()), EXIT_CODES.SUCCESS);
         }
         return tables;
     }
     catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
         debugError(error, { accountId });
         uiLogger.error(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()));
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectHubDBTablePrompt.errors.errorFetchingTables(accountId.toString()), EXIT_CODES.ERROR);
     }
 }
 export async function selectHubDBTablePrompt({ accountId, options, skipDestPrompt = true, }) {
-    const hubdbTables = (await fetchHubDBOptions(accountId)) || [];
+    const hubdbTables = await fetchHubDBOptions(accountId);
     const id = options.tableId?.toString();
     const isValidTable = options.tableId && hubdbTables.find(table => table.id === id);
     return promptUser([

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -4,13 +4,14 @@ import { uiLine } from '../ui/index.js';
 import { logError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { PromptExitError } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
+    if (!accountId) {
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
+    }
     try {
-        if (!accountId) {
-            uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
         const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
         const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
         if (!filteredPublicApps.length ||
@@ -24,14 +25,19 @@ async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = fa
                 uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
             }
             uiLine();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
+                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
         }
         return filteredPublicApps;
     }
     catch (error) {
+        if (error instanceof PromptExitError) {
+            throw error;
+        }
         logError(error, accountId ? { accountId } : undefined);
         uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
     }
 }
 export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {

package/lib/sandboxes.d.ts

@@ -1,22 +1,14 @@
 import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxSyncTask, SandboxAccountType } from '../types/Sandboxes.js';
-export declare const SYNC_TYPES: {
-    readonly OBJECT_RECORDS: "object-records";
-};
+import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare const SANDBOX_TYPE_MAP: {
     [key: string]: SandboxAccountType;
 };
-export declare const SANDBOX_API_TYPE_MAP: {
-    readonly STANDARD_SANDBOX: 1;
-    readonly DEVELOPMENT_SANDBOX: 2;
-};
 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 getAvailableSyncTypes(parentAccountConfig: HubSpotConfigAccount, config: HubSpotConfigAccount): Promise<Array<SandboxSyncTask>>;
 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

@@ -1,5 +1,4 @@
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
 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';
@@ -8,19 +7,12 @@ 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 SYNC_TYPES = {
-    OBJECT_RECORDS: 'object-records',
-};
 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_API_TYPE_MAP = {
-    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
-    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
-};
 export const SANDBOX_TYPE_MAP_V2 = {
     [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
     [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
@@ -45,19 +37,6 @@ export function getHasSandboxesByType(parentAccountConfig, type) {
     }
     return false;
 }
-// Fetches available sync types for a given sandbox portal
-export async function getAvailableSyncTypes(parentAccountConfig, config) {
-    const parentPortalId = parentAccountConfig.accountId;
-    const portalId = config.accountId;
-    if (!parentPortalId || !portalId) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
-    if (!syncTypes) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    return syncTypes.map(t => ({ type: t.name }));
-}
 export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
     const accountId = accountConfig.accountId;
     if (!accountId) {

package/lib/serverlessLogs.js

@@ -9,7 +9,6 @@ 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 { EXIT_CODES } from './enums/exitCodes.js';
 import { lib } from '../lang/en.js';
 const TAIL_DELAY = 5000;
 function base64EncodeString(valueToEncode) {
@@ -19,19 +18,6 @@ function base64EncodeString(valueToEncode) {
     const stringBuffer = Buffer.from(valueToEncode);
     return encodeURIComponent(stringBuffer.toString('base64'));
 }
-function handleUserInput() {
-    const onTerminate = async () => {
-        SpinniesManager.remove('tailLogs');
-        SpinniesManager.remove('stopMessage');
-        process.exit(EXIT_CODES.SUCCESS);
-    };
-    handleExit(onTerminate);
-    handleKeypress(key => {
-        if ((key.ctrl && key.name == 'c') || key.name === 'q') {
-            onTerminate();
-        }
-    });
-}
 async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
     const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
@@ -80,40 +66,60 @@ export async function tailLogs(accountId, name, fetchLatest, tailCall, compact =
             }
         }
     }
-    async function tail(after) {
-        let latestLog;
-        let nextAfter;
-        try {
-            const { data } = await tailCall(after);
-            latestLog = data;
-            nextAfter = latestLog.paging.next.after;
+    return new Promise(resolve => {
+        function cleanup() {
+            SpinniesManager.remove('tailLogs');
+            SpinniesManager.remove('stopMessage');
         }
-        catch (e) {
-            if (isHubSpotHttpError(e) && e.status !== 404) {
-                logError(e, new ApiErrorContext({
-                    accountId,
-                }));
+        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();
             }
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        if (latestLog && latestLog.results.length) {
-            outputLogs(latestLog, {
-                compact,
-            });
+        });
+        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);
         }
-        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',
+        SpinniesManager.add('tailLogs', {
+            text: `Following logs for ${name}`,
+        });
+        SpinniesManager.add('stopMessage', {
+            text: `> Press ${chalk.bold('q')} to stop following`,
+            status: 'non-spinnable',
+        });
+        tail(initialAfter);
     });
-    handleUserInput();
-    await tail(initialAfter);
 }
 export async function outputBuildLog(buildLogUrl) {
     if (!buildLogUrl) {

package/lib/{cms/devServerProcess.d.ts → theme/cmsDevServerProcess.d.ts}

@@ -2,12 +2,11 @@ import { ChildProcess } from 'child_process';
 interface DevServerOptions {
     absoluteSrc: string;
     accountName?: string;
-    configPath?: string;
     noSsl?: boolean;
     port?: number;
     generateFieldsTypes?: boolean;
     resetSession?: boolean;
-    dest?: string;
+    dest: string;
 }
-export declare function spawnDevServer(options: DevServerOptions): ChildProcess;
+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;
+}