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

package/lib/cms/devServerProcess.js

@@ -1,200 +0,0 @@
-import { spawn, execSync } 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';
-/**
- * Ensures cms-dev-server is installed in an isolated cache directory.
- * This prevents React version conflicts with the CLI.
- */
-function ensureCmsDevServerCache(targetVersion) {
-    const cacheDir = path.join(os.homedir(), '.hubspot', 'cms-dev-server-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) {
-        console.log(`Setting up isolated cms-dev-server ${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
-        try {
-            execSync(`npm install @hubspot/cms-dev-server@${targetVersion} --production --no-save --loglevel=error`, {
-                cwd: cacheDir,
-                stdio: 'ignore', // Suppress npm output
-            });
-            console.log('✓ cms-dev-server setup complete');
-        }
-        catch (e) {
-            console.error('Failed to install cms-dev-server:', e);
-            process.exit(1);
-        }
-    }
-    return cacheDir;
-}
-export function spawnDevServer(options) {
-    const { absoluteSrc, accountName, noSsl, port, generateFieldsTypes, resetSession, dest, } = options;
-    // Get the version from CLI's package.json
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const cliPackageJsonPath = path.join(__dirname, '../../package.json');
-    const cliPackageJson = JSON.parse(fs.readFileSync(cliPackageJsonPath, 'utf8'));
-    const targetVersion = cliPackageJson.dependencies['@hubspot/cms-dev-server'];
-    if (!targetVersion) {
-        console.error('Could not determine cms-dev-server version from package.json');
-        process.exit(1);
-    }
-    // Ensure cms-dev-server is installed in isolated cache
-    const cacheDir = ensureCmsDevServerCache(targetVersion);
-    // Build a Node script that imports and calls createDevServer
-    // This runs in the isolated cache directory, completely separate from CLI's node_modules
-    const script = `
-    // Suppress library deprecation warnings (e.g., body-parser)
-    process.noDeprecation = true;
-
-    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;
-
-    ${dest
-        ? `
-    // Get uploadable files for preview
-    let filePaths = [];
-    try {
-      filePaths = await walk(${JSON.stringify(absoluteSrc)});
-    } 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(),
-        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: ${Boolean(resetSession)},
-      dest: ${JSON.stringify(dest)},
-    };
-    `
-        : 'const themePreviewOptions = undefined;'}
-
-    createDevServer(
-      ${JSON.stringify(absoluteSrc)},
-      false, // storybook
-      '', // config (uses env var HUBSPOT_CONFIG_PATH)
-      ${JSON.stringify(accountName || '')},
-      ${!noSsl}, // sslEnabled
-      ${Boolean(generateFieldsTypes)}, // fieldGenEnabled
-      themePreviewOptions
-    );
-  `;
-    // Set environment variables
-    const env = { ...process.env };
-    if (port) {
-        env.PORT = port.toString();
-    }
-    // Suppress Node.js deprecation warnings
-    env.NODE_NO_WARNINGS = '1';
-    // Set config path so cms-dev-server can find hubspot.config.yaml
-    // Use existing env var if set, otherwise get the default config path
-    if (!env.HUBSPOT_CONFIG_PATH) {
-        try {
-            env.HUBSPOT_CONFIG_PATH = getConfigFilePath();
-        }
-        catch (e) {
-            // Config file doesn't exist - cms-dev-server will handle this gracefully
-        }
-    }
-    console.log(env.HUBSPOT_CONFIG_PATH);
-    // Spawn Node with the inline script from the isolated cache directory
-    // This ensures complete isolation from CLI's React 19
-    const devServer = spawn('node', ['--input-type=module', '-e', script], {
-        stdio: 'inherit',
-        env,
-        cwd: cacheDir,
-    });
-    // Handle process events
-    devServer.on('error', error => {
-        console.error('Failed to start dev server:', error);
-        process.exit(1);
-    });
-    devServer.on('exit', (code, signal) => {
-        if (code !== 0 && code !== null) {
-            console.error(`Dev server exited with code ${code}`);
-            process.exit(code);
-        }
-        if (signal) {
-            console.error(`Dev server killed with signal ${signal}`);
-            process.exit(1);
-        }
-    });
-    // Handle CLI termination
-    process.on('SIGINT', () => {
-        devServer.kill('SIGINT');
-    });
-    process.on('SIGTERM', () => {
-        devServer.kill('SIGTERM');
-    });
-    return devServer;
-}

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('');
-    }
-}

package/mcp-server/utils/__tests__/project.test.d.ts

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

package/mcp-server/utils/__tests__/project.test.js

@@ -1,140 +0,0 @@
-import { runCommandInDir } from '../project.js';
-import { execAsync } from '../command.js';
-import fs from 'fs';
-import path from 'path';
-vi.mock('../command', () => ({
-    execAsync: vi.fn(),
-    addFlag: vi.fn((command, flagName, value) => {
-        if (Array.isArray(value)) {
-            return `${command} --${flagName} ${value.map(item => `"${item}"`).join(' ')}`;
-        }
-        return `${command} --${flagName} "${value}"`;
-    }),
-}));
-vi.mock('fs');
-vi.mock('path');
-const mockExecAsync = execAsync;
-const mockExistsSync = fs.existsSync;
-const mockMkdirSync = fs.mkdirSync;
-const mockResolve = path.resolve;
-describe('mcp-server/utils/project', () => {
-    describe('runCommandInDir', () => {
-        const mockDirectory = '/test/directory';
-        const mockCommand = 'npm install';
-        const mockResolvedPath = '/resolved/test/directory';
-        beforeEach(() => {
-            mockResolve.mockReturnValue(mockResolvedPath);
-        });
-        it('should run command in existing directory', async () => {
-            const expectedResult = {
-                stdout: 'command output',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockMkdirSync).not.toHaveBeenCalled();
-            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            expect(result).toEqual(expectedResult);
-        });
-        it('should create directory if it does not exist', async () => {
-            const expectedResult = {
-                stdout: 'command output',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(false);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(mockExistsSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockMkdirSync).toHaveBeenCalledWith(mockDirectory);
-            expect(mockResolve).toHaveBeenCalledWith(mockDirectory);
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-            expect(result).toEqual(expectedResult);
-        });
-        it('should propagate execAsync errors', async () => {
-            const error = new Error('Command failed');
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockRejectedValue(error);
-            await expect(runCommandInDir(mockDirectory, mockCommand)).rejects.toThrow('Command failed');
-            expect(mockExecAsync).toHaveBeenCalledWith(mockCommand, expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should handle stderr in results', async () => {
-            const expectedResult = {
-                stdout: 'some output',
-                stderr: 'warning message',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            const result = await runCommandInDir(mockDirectory, mockCommand);
-            expect(result.stdout).toBe('some output');
-            expect(result.stderr).toBe('warning message');
-        });
-        it('should add --disable-usage-tracking flag to hs commands', async () => {
-            const hsCommand = 'hs project upload';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should not add --disable-usage-tracking flag to non-hs commands', async () => {
-            const nonHsCommand = 'npm install';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, nonHsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('npm install', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should add --disable-usage-tracking flag to hs commands with existing flags', async () => {
-            const hsCommand = 'hs project upload --profile prod';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs project upload --profile prod --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-        it('should handle hs commands that start with whitespace', async () => {
-            const hsCommand = 'hs init';
-            const expectedResult = {
-                stdout: 'success',
-                stderr: '',
-            };
-            mockExistsSync.mockReturnValue(true);
-            mockExecAsync.mockResolvedValue(expectedResult);
-            await runCommandInDir(mockDirectory, hsCommand);
-            expect(mockExecAsync).toHaveBeenCalledWith('hs init --disable-usage-tracking "true"', expect.objectContaining({
-                cwd: mockResolvedPath,
-                env: expect.any(Object),
-            }));
-        });
-    });
-});

package/mcp-server/utils/project.d.ts

@@ -1,5 +0,0 @@
-export interface CommandResults {
-    stderr: string;
-    stdout: string;
-}
-export declare function runCommandInDir(directory: string, command: string): Promise<CommandResults>;

package/mcp-server/utils/project.js

@@ -1,18 +0,0 @@
-import { addFlag, execAsync } from './command.js';
-import path from 'path';
-import fs from 'fs';
-export async function runCommandInDir(directory, command) {
-    if (!fs.existsSync(directory)) {
-        fs.mkdirSync(directory);
-    }
-    let finalCommand = command;
-    if (command.startsWith('hs ')) {
-        finalCommand = addFlag(finalCommand, 'disable-usage-tracking', true);
-    }
-    return execAsync(finalCommand, {
-        cwd: path.resolve(directory),
-        env: {
-            ...process.env,
-        },
-    });
-}