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

package/lib/serverlessLogs.js

@@ -1,154 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/__tests__/migrate.test.d.ts

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

package/lib/theme/__tests__/migrate.test.js

@@ -1,247 +0,0 @@
-import { getProjectThemeDetails, migrateThemes, } from '@hubspot/project-parsing-lib/themes';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { confirmPrompt } from '../../prompts/promptUtils.js';
-import { writeProjectConfig, } from '../../projects/config.js';
-import { ensureProjectExists } from '../../projects/ensureProjectExists.js';
-import { fetchMigrationApps } from '../../app/migrate.js';
-import { getHasMigratableThemes, validateMigrationAppsAndThemes, handleThemesMigration, migrateThemesV2, } from '../migrate.js';
-import { lib } from '../../../lang/en.js';
-vi.mock('@hubspot/project-parsing-lib/themes');
-vi.mock('../../prompts/promptUtils');
-vi.mock('../../projects/config');
-vi.mock('../../projects/ensureProjectExists');
-vi.mock('../../app/migrate');
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../../ui/SpinniesManager', () => ({
-    default: {
-        init: vi.fn(),
-        add: vi.fn(),
-        succeed: vi.fn(),
-        fail: vi.fn(),
-        remove: vi.fn(),
-    },
-}));
-const mockedGetProjectThemeDetails = getProjectThemeDetails;
-const mockedMigrateThemes = migrateThemes;
-const mockedConfirmPrompt = confirmPrompt;
-const mockedWriteProjectConfig = writeProjectConfig;
-const mockedEnsureProjectExists = ensureProjectExists;
-const mockedFetchMigrationApps = fetchMigrationApps;
-const mockedGetConfigAccountById = getConfigAccountById;
-const ACCOUNT_ID = 123;
-const PROJECT_NAME = 'Test Project';
-const PLATFORM_VERSION = '2025.2';
-const MOCK_PROJECT_DIR = '/mock/project/dir';
-const createLoadedProjectConfig = (name) => ({
-    projectConfig: { name, srcDir: 'src', platformVersion: '2024.1' },
-    projectDir: MOCK_PROJECT_DIR,
-});
-describe('lib/theme/migrate', () => {
-    beforeEach(() => {
-        // Mock account config for the test account ID
-        mockedGetConfigAccountById.mockReturnValue({
-            accountId: ACCOUNT_ID,
-            name: 'Test Account',
-            authType: 'personalaccesskey',
-            auth: {
-                tokenInfo: {
-                    accessToken: 'test-token',
-                },
-            },
-            env: 'prod',
-        });
-    });
-    describe('getHasMigratableThemes', () => {
-        it('should return false when no projectConfig is provided', async () => {
-            const result = await getHasMigratableThemes();
-            expect(result).toEqual({
-                hasMigratableThemes: false,
-                migratableThemesCount: 0,
-            });
-        });
-        it('should return false when projectConfig is missing required properties', async () => {
-            const invalidProjectConfig = {
-                projectConfig: { name: undefined, srcDir: 'src' },
-                projectDir: undefined,
-            };
-            const result = await getHasMigratableThemes(invalidProjectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: false,
-                migratableThemesCount: 0,
-            });
-        });
-        it('should return true when there are legacy themes', async () => {
-            mockedGetProjectThemeDetails.mockResolvedValue({
-                legacyThemeDetails: [
-                    {
-                        configFilepath: 'src/theme.json',
-                        themePath: 'src/theme',
-                        themeConfig: {
-                            secret_names: ['my-secret'],
-                        },
-                    },
-                ],
-                legacyReactThemeDetails: [],
-            });
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const result = await getHasMigratableThemes(projectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: true,
-                migratableThemesCount: 1,
-            });
-        });
-        it('should return true when there are legacy React themes', async () => {
-            mockedGetProjectThemeDetails.mockResolvedValue({
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [
-                    {
-                        configFilepath: 'src/react-theme.json',
-                        themePath: 'src/react-theme',
-                        themeConfig: {
-                            secretNames: ['my-secret'],
-                        },
-                    },
-                ],
-            });
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const result = await getHasMigratableThemes(projectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: true,
-                migratableThemesCount: 1,
-            });
-        });
-        it('should return true when there are both legacy and React themes', async () => {
-            mockedGetProjectThemeDetails.mockResolvedValue({
-                legacyThemeDetails: [
-                    {
-                        configFilepath: 'src/theme.json',
-                        themePath: 'src/theme',
-                        themeConfig: {
-                            secret_names: ['my-secret'],
-                        },
-                    },
-                ],
-                legacyReactThemeDetails: [
-                    {
-                        configFilepath: 'src/react-theme.json',
-                        themePath: 'src/react-theme',
-                        themeConfig: {
-                            secretNames: ['my-secret'],
-                        },
-                    },
-                ],
-            });
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            const result = await getHasMigratableThemes(projectConfig);
-            expect(result).toEqual({
-                hasMigratableThemes: true,
-                migratableThemesCount: 2,
-            });
-        });
-    });
-    describe('validateMigrationAppsAndThemes', () => {
-        it('should throw an error when apps and themes are both present', async () => {
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            await expect(validateMigrationAppsAndThemes(1, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAndAppsNotAllowed);
-        });
-        it('should throw an error when no project config is provided', async () => {
-            await expect(validateMigrationAppsAndThemes(0)).rejects.toThrow(lib.migrate.errors.project.noProjectForThemesMigration);
-        });
-        it('should not throw an error when validation passes', async () => {
-            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            await expect(validateMigrationAppsAndThemes(0, projectConfig)).resolves.not.toThrow();
-        });
-    });
-    describe('handleThemesMigration', () => {
-        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-        beforeEach(() => {
-            mockedMigrateThemes.mockResolvedValue({
-                migrated: true,
-                failureReason: undefined,
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [],
-            });
-            mockedWriteProjectConfig.mockReturnValue(true);
-        });
-        it('should throw an error when project config is invalid', async () => {
-            const invalidProjectConfig = {
-                projectConfig: { name: PROJECT_NAME, srcDir: undefined },
-                projectDir: undefined,
-            };
-            await expect(handleThemesMigration(invalidProjectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
-        });
-        it('should successfully migrate themes and update project config', async () => {
-            await handleThemesMigration(projectConfig, PLATFORM_VERSION);
-            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
-            expect(mockedWriteProjectConfig).toHaveBeenCalledWith(`${MOCK_PROJECT_DIR}/hsproject.json`, expect.objectContaining({
-                platformVersion: PLATFORM_VERSION,
-            }));
-        });
-        it('should throw an error when theme migration fails', async () => {
-            mockedMigrateThemes.mockResolvedValue({
-                migrated: false,
-                failureReason: 'Migration failed',
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [],
-            });
-            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow('Migration failed');
-        });
-        it('should throw an error when project config write fails', async () => {
-            mockedWriteProjectConfig.mockReturnValue(false);
-            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToUpdateProjectConfig);
-        });
-        it('should throw an error when migrateThemes throws an exception', async () => {
-            mockedMigrateThemes.mockRejectedValue(new Error('Unexpected error'));
-            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToMigrateThemes);
-        });
-    });
-    describe('migrateThemesV2', () => {
-        const options = {
-            platformVersion: PLATFORM_VERSION,
-        };
-        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-        const themeCount = 2;
-        beforeEach(() => {
-            mockedEnsureProjectExists.mockResolvedValue({ projectExists: true });
-            mockedFetchMigrationApps.mockResolvedValue({
-                migratableApps: [],
-                unmigratableApps: [],
-            });
-            mockedConfirmPrompt.mockResolvedValue(true);
-            mockedMigrateThemes.mockResolvedValue({
-                migrated: true,
-                failureReason: undefined,
-                legacyThemeDetails: [],
-                legacyReactThemeDetails: [],
-            });
-            mockedWriteProjectConfig.mockReturnValue(true);
-        });
-        it('should throw an error when project config is invalid', async () => {
-            const invalidProjectConfig = {
-                projectConfig: undefined,
-                projectDir: MOCK_PROJECT_DIR,
-            };
-            await expect(migrateThemesV2(ACCOUNT_ID, options, themeCount, invalidProjectConfig)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
-        });
-        it('should throw an error when project does not exist', async () => {
-            mockedEnsureProjectExists.mockResolvedValue({ projectExists: false });
-            await expect(migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig)).rejects.toThrow(lib.migrate.errors.project.doesNotExist(ACCOUNT_ID));
-        });
-        it('should proceed with migration when user confirms', async () => {
-            await migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig);
-            expect(mockedFetchMigrationApps).toHaveBeenCalledWith(ACCOUNT_ID, PLATFORM_VERSION, { projectConfig });
-            expect(mockedConfirmPrompt).toHaveBeenCalledWith(lib.migrate.prompt.proceed, { defaultAnswer: false });
-            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
-        });
-        it('should exit without migrating when user cancels', async () => {
-            mockedConfirmPrompt.mockResolvedValue(false);
-            await migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig);
-            expect(mockedMigrateThemes).not.toHaveBeenCalled();
-        });
-        it('should validate migration apps and themes', async () => {
-            await migrateThemesV2(ACCOUNT_ID, options, themeCount, projectConfig);
-            // The validation is called internally, so we verify it through the error handling
-            expect(mockedFetchMigrationApps).toHaveBeenCalled();
-        });
-    });
-});

package/lib/theme/cmsDevServerProcess.d.ts

@@ -1,12 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/**
- * 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 {};