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

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/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/usageTracking.js

@@ -44,11 +44,14 @@ export async function trackCommandUsage(command, meta = {}, accountId) {
     uiLogger.debug(`Attempting to track usage of "${command}" command`);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getConfigAccountById(accountId);
-        authType =
-            accountConfig && accountConfig.authType
-                ? accountConfig.authType
-                : API_KEY_AUTH_METHOD.value;
+        try {
+            const accountConfig = getConfigAccountById(accountId);
+            authType =
+                accountConfig && accountConfig.authType
+                    ? accountConfig.authType
+                    : API_KEY_AUTH_METHOD.value;
+        }
+        catch (e) { }
     }
     return trackCliInteraction({
         action: 'cli-command',

package/package.json

@@ -1,14 +1,13 @@
 {
     "name": "@hubspot/cli",
-    "version": "8.0.10-experimental.2",
+    "version": "8.0.10-experimental.3",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "type": "module",
     "dependencies": {
-        "@hubspot/cms-dev-server": "1.2.16",
         "@hubspot/local-dev-lib": "5.1.2",
-        "@hubspot/project-parsing-lib": "0.2.0-experimental.2",
+        "@hubspot/project-parsing-lib": "0.13.0-beta.0",
         "@hubspot/serverless-dev-runtime": "7.0.7",
         "@hubspot/ui-extensions-dev-server": "2.0.0",
         "@inquirer/prompts": "7.1.0",

package/lib/__tests__/sandboxSync.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/__tests__/sandboxSync.test.js

@@ -1,147 +0,0 @@
-import { uiLogger } from '../ui/logger.js';
-import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
-import { getConfigAccountIfExists, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { mockHubSpotHttpError } from '../testUtils.js';
-import { getAvailableSyncTypes } from '../sandboxes.js';
-import { syncSandbox } from '../sandboxSync.js';
-import SpinniesManager from '../ui/SpinniesManager.js';
-vi.mock('@hubspot/local-dev-lib/api/sandboxSync');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../sandboxes');
-vi.mock('../ui/SpinniesManager');
-const mockedUiLogger = uiLogger;
-const mockedInitiateSync = initiateSync;
-const mockedGetConfigAccountIfExists = getConfigAccountIfExists;
-const mockedGetConfigAccountById = getConfigAccountById;
-const mockedGetAvailableSyncTypes = getAvailableSyncTypes;
-const mockedSpinniesInit = SpinniesManager.init;
-const mockedSpinniesAdd = SpinniesManager.add;
-const mockedSpinniesSucceed = SpinniesManager.succeed;
-const mockedSpinniesFail = SpinniesManager.fail;
-describe('lib/sandboxSync', () => {
-    const mockEnv = 'qa';
-    const mockParentAccount = {
-        name: 'Parent Account',
-        accountId: 123,
-        accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-        env: mockEnv,
-        authType: 'personalaccesskey',
-    };
-    const mockChildAccount = {
-        name: 'Child Account',
-        accountId: 456,
-        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-        env: mockEnv,
-        authType: 'personalaccesskey',
-    };
-    const mockChildAccountWithMissingId = {
-        name: 'Child Account',
-        accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-        env: mockEnv,
-        authType: 'personalaccesskey',
-    };
-    const mockSyncTasks = [{ type: 'mock-sync-type' }];
-    beforeEach(() => {
-        mockedGetConfigAccountIfExists
-            .mockReturnValueOnce(mockChildAccount)
-            .mockReturnValueOnce(mockParentAccount);
-        mockedGetAvailableSyncTypes.mockResolvedValue(mockSyncTasks);
-        // Mock SpinniesManager methods to prevent spinner errors
-        mockedSpinniesInit.mockImplementation(() => { });
-        mockedSpinniesAdd.mockImplementation(() => { });
-        mockedSpinniesSucceed.mockImplementation(() => { });
-        mockedSpinniesFail.mockImplementation(() => { });
-        // Mock account config for uiAccountDescription calls
-        mockedGetConfigAccountById.mockImplementation(accountId => {
-            if (accountId === mockChildAccount.accountId) {
-                return mockChildAccount;
-            }
-            if (accountId === mockParentAccount.accountId) {
-                return mockParentAccount;
-            }
-            return undefined; // Don't throw, just return undefined for unknown accounts
-        });
-    });
-    describe('syncSandbox()', () => {
-        it('successfully syncs a sandbox with provided sync tasks', async () => {
-            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks);
-            expect(mockedSpinniesInit).toHaveBeenCalled();
-            expect(mockedSpinniesAdd).toHaveBeenCalled();
-            expect(mockedInitiateSync).toHaveBeenCalledWith(mockParentAccount.accountId, mockChildAccount.accountId, mockSyncTasks, mockChildAccount.accountId);
-            expect(mockedSpinniesSucceed).toHaveBeenCalled();
-        });
-        it('fetches sync types when no tasks are provided', async () => {
-            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, []);
-            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
-            expect(mockedGetAvailableSyncTypes).toHaveBeenCalledWith(mockParentAccount, mockChildAccount);
-            expect(mockedInitiateSync).toHaveBeenCalled();
-        });
-        it('throws error when account IDs are missing', async () => {
-            const errorRegex = new RegExp(`because your account has been removed from`);
-            await expect(syncSandbox(mockChildAccountWithMissingId, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toThrow(errorRegex);
-        });
-        it('handles sync in progress error', async () => {
-            const error = mockHubSpotHttpError('', {
-                status: 429,
-                data: {
-                    category: 'RATE_LIMITS',
-                    subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
-                },
-            });
-            mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
-            expect(mockedSpinniesFail).toHaveBeenCalled();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because there's another sync in progress/));
-        });
-        it('handles invalid user error', async () => {
-            const error = mockHubSpotHttpError('', {
-                status: 403,
-                data: {
-                    category: 'BANNED',
-                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
-                },
-            });
-            mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
-            expect(mockedSpinniesFail).toHaveBeenCalled();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/because your account has been removed from/));
-        });
-        it('handles not super admin error', async () => {
-            const error = mockHubSpotHttpError('', {
-                status: 403,
-                data: {
-                    category: 'BANNED',
-                    subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
-                },
-            });
-            mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
-            expect(mockedSpinniesFail).toHaveBeenCalled();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/Couldn't run the sync because you are not a super admin in/));
-        });
-        it('handles sandbox not found error', async () => {
-            const error = mockHubSpotHttpError('', {
-                status: 404,
-                data: {
-                    category: 'OBJECT_NOT_FOUND',
-                    subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
-                },
-            });
-            mockedInitiateSync.mockRejectedValue(error);
-            await expect(syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks)).rejects.toEqual(error);
-            expect(mockedSpinniesFail).toHaveBeenCalled();
-            expect(mockedUiLogger.error).toHaveBeenCalledWith(expect.stringMatching(/may have been deleted through the UI/));
-        });
-        it('displays slim info message when specified', async () => {
-            mockedInitiateSync.mockResolvedValue({ status: 'SUCCESS' });
-            await syncSandbox(mockChildAccount, mockParentAccount, mockEnv, mockSyncTasks, true);
-            expect(mockedUiLogger.info).not.toHaveBeenCalled();
-            expect(mockedSpinniesSucceed).toHaveBeenCalledWith('sandboxSync', expect.objectContaining({
-                text: expect.stringMatching(/Initiated sync of object definitions from production to /),
-            }));
-        });
-    });
-});

package/lib/sandboxSync.d.ts

@@ -1,4 +0,0 @@
-import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
-import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxSyncTask } from '../types/Sandboxes.js';
-export declare function syncSandbox(accountConfig: HubSpotConfigAccount, parentAccountConfig: HubSpotConfigAccount, env: Environment, syncTasks: Array<SandboxSyncTask>, slimInfoMessage?: boolean): Promise<void>;

package/lib/sandboxSync.js

@@ -1,102 +0,0 @@
-import SpinniesManager from './ui/SpinniesManager.js';
-import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
-import { uiLogger } from './ui/logger.js';
-import { initiateSync } from '@hubspot/local-dev-lib/api/sandboxSync';
-import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { lib } from '../lang/en.js';
-import { getAvailableSyncTypes, getSandboxTypeAsString } from './sandboxes.js';
-import { debugError, logError, ApiErrorContext, } from './errorHandlers/index.js';
-import { uiAccountDescription, uiLine, uiCommandDisabledBanner, } from './ui/index.js';
-import { isDevelopmentSandbox } from './accountTypes.js';
-export async function syncSandbox(accountConfig, parentAccountConfig, env, syncTasks, slimInfoMessage = false) {
-    const accountId = accountConfig.accountId;
-    const parentAccountId = parentAccountConfig.accountId;
-    const isDevSandbox = isDevelopmentSandbox(accountConfig);
-    if (!accountId || !parentAccountId) {
-        throw new Error(lib.sandbox.sync.failure.invalidUser(uiAccountDescription(accountId), uiAccountDescription(parentAccountId)));
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    let availableSyncTasks = syncTasks;
-    const baseUrl = getHubSpotWebsiteOrigin(env);
-    const syncStatusUrl = `${baseUrl}/sandboxes-developer/${parentAccountId}/${getSandboxTypeAsString(accountConfig.accountType)}`;
-    try {
-        // If no sync tasks exist, fetch sync types based on default account. Parent account required for fetch
-        if (!availableSyncTasks ||
-            (typeof availableSyncTasks === 'object' &&
-                availableSyncTasks.length === 0)) {
-            availableSyncTasks = await getAvailableSyncTypes(parentAccountConfig, accountConfig);
-        }
-        SpinniesManager.add('sandboxSync', {
-            text: lib.sandbox.sync.loading.startSync,
-        });
-        await initiateSync(parentAccountId, accountId, availableSyncTasks, accountId);
-        const spinniesText = isDevSandbox
-            ? lib.sandbox.sync.loading.succeedDevSb(accountId)
-            : lib.sandbox.sync.loading.succeed(accountId);
-        SpinniesManager.succeed('sandboxSync', {
-            text: slimInfoMessage
-                ? lib.sandbox.sync.loading.successDevSbInfo(accountId, syncStatusUrl)
-                : spinniesText,
-        });
-    }
-    catch (err) {
-        debugError(err);
-        SpinniesManager.fail('sandboxSync', {
-            text: lib.sandbox.sync.loading.fail(accountId),
-        });
-        uiLogger.log('');
-        if (isSpecifiedError(err, {
-            statusCode: 403,
-            category: 'BANNED',
-            subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USER',
-        })) {
-            uiLogger.error(lib.sandbox.sync.failure.invalidUser(uiAccountDescription(accountId), uiAccountDescription(parentAccountId)));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 429,
-            category: 'RATE_LIMITS',
-            subCategory: 'sandboxes-sync-api.SYNC_IN_PROGRESS',
-        })) {
-            uiLogger.error(lib.sandbox.sync.failure.syncInProgress(`${baseUrl}/sandboxes-developer/${parentAccountId}/syncactivitylog`));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 403,
-            category: 'BANNED',
-            subCategory: 'sandboxes-sync-api.SYNC_NOT_ALLOWED_INVALID_USERID',
-        })) {
-            // This will only trigger if a user is not a super admin of the target account.
-            uiLogger.error(lib.sandbox.sync.failure.notSuperAdmin(accountId));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 404,
-            category: 'OBJECT_NOT_FOUND',
-            subCategory: 'SandboxErrors.SANDBOX_NOT_FOUND',
-        })) {
-            uiLogger.error(lib.sandbox.sync.failure.objectNotFound(accountId));
-        }
-        else if (isSpecifiedError(err, {
-            statusCode: 404,
-        })) {
-            uiCommandDisabledBanner('hs sandbox sync', 'https://developers.hubspot.com/docs/developer-tooling/local-development/hubspot-cli/project-commands');
-        }
-        else {
-            logError(err, new ApiErrorContext({
-                accountId: parentAccountId,
-                request: 'sandbox sync',
-            }));
-        }
-        uiLogger.log('');
-        throw err;
-    }
-    if (!slimInfoMessage) {
-        uiLogger.log('');
-        uiLine();
-        uiLogger.info(isDevSandbox
-            ? lib.sandbox.sync.info.syncMessageDevSb(syncStatusUrl)
-            : lib.sandbox.sync.info.syncMessage(syncStatusUrl));
-        uiLine();
-        uiLogger.log('');
-    }
-}