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

package/commands/project/dev/index.js

@@ -0,0 +1,174 @@
+import { trackCommandUsage } from '../../../lib/usageTracking.js';
+import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { getAllHsProfiles, } from '@hubspot/project-parsing-lib/profiles';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { uiLine } from '../../../lib/ui/index.js';
+import { deprecatedProjectDevFlow } from './deprecatedFlow.js';
+import { unifiedProjectDevFlow } from './unifiedFlow.js';
+import { isV2Project } from '../../../lib/projects/platformVersion.js';
+import { makeYargsBuilder } from '../../../lib/yargsUtils.js';
+import { loadProfile } from '../../../lib/projects/projectProfiles.js';
+import { commands } from '../../../lang/en.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { PromptExitError } from '../../../lib/errors/PromptExitError.js';
+import path from 'path';
+import { listPrompt } from '../../../lib/prompts/promptUtils.js';
+const command = 'dev';
+const describe = commands.project.dev.describe;
+function validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV2) {
+    // Legacy projects do not support targetTestingAccount and targetProjectAccount
+    if (testingAccount && projectAccount && !useV2) {
+        uiLogger.error(commands.project.dev.errors.unsupportedAccountFlagLegacy);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    if (userProvidedAccount && useV2) {
+        uiLogger.error(commands.project.dev.errors.unsupportedAccountFlagV2);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+async function handler(args) {
+    const { derivedAccountId, userProvidedAccount, testingAccount, projectAccount, } = args;
+    const { projectConfig, projectDir } = await getProjectConfig();
+    try {
+        validateProjectConfig(projectConfig, projectDir);
+    }
+    catch (error) {
+        logError(error);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const useV2Projects = isV2Project(projectConfig.platformVersion);
+    if (!projectDir) {
+        uiLogger.error(commands.project.dev.errors.noProjectConfig);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    validateAccountFlags(testingAccount, projectAccount, userProvidedAccount, useV2Projects);
+    uiLogger.log(commands.project.dev.logs.header);
+    if (useV2Projects) {
+        uiLogger.log(commands.project.dev.logs.learnMoreMessageV2);
+    }
+    else {
+        uiLogger.log(commands.project.dev.logs.learnMoreMessageLegacy);
+    }
+    let targetProjectAccountId;
+    let profile;
+    // Using the new --projectAccount flag
+    if (projectAccount) {
+        targetProjectAccountId =
+            getConfigAccountIfExists(projectAccount)?.accountId;
+        if (targetProjectAccountId) {
+            uiLogger.log('');
+            uiLogger.log(commands.project.dev.logs.projectAccountFlagExplanation(targetProjectAccountId));
+        }
+        // Using the legacy --account flag
+    }
+    else if (userProvidedAccount && derivedAccountId) {
+        targetProjectAccountId = derivedAccountId;
+    }
+    // Determine profile name: from flag or prompt
+    if (!targetProjectAccountId && isV2Project(projectConfig.platformVersion)) {
+        let profileName = args.profile;
+        if (!profileName) {
+            const existingProfiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
+            if (existingProfiles.length !== 0) {
+                profileName = await listPrompt(commands.project.dev.prompts.selectProfile, {
+                    choices: existingProfiles,
+                });
+            }
+        }
+        if (profileName) {
+            try {
+                profile = loadProfile(projectConfig, projectDir, profileName);
+                targetProjectAccountId = profile.accountId;
+                uiLogger.log('');
+                uiLogger.log(commands.project.dev.logs.profileProjectAccountExplanation(targetProjectAccountId, profileName));
+            }
+            catch (error) {
+                logError(error);
+                uiLine();
+                process.exit(EXIT_CODES.ERROR);
+            }
+        }
+    }
+    if (!targetProjectAccountId) {
+        // The user is not using profile or account flags, so we can use the derived accountId
+        targetProjectAccountId = derivedAccountId;
+        if (useV2Projects) {
+            uiLogger.log('');
+            uiLogger.log(commands.project.dev.logs.defaultProjectAccountExplanation(targetProjectAccountId));
+        }
+    }
+    trackCommandUsage('project-dev', {}, targetProjectAccountId);
+    try {
+        if (isV2Project(projectConfig.platformVersion)) {
+            const targetTestingAccountId = testingAccount
+                ? getConfigAccountIfExists(testingAccount)?.accountId
+                : undefined;
+            await unifiedProjectDevFlow({
+                args,
+                targetProjectAccountId,
+                providedTargetTestingAccountId: targetTestingAccountId,
+                projectConfig,
+                projectDir,
+                profileConfig: profile,
+            });
+        }
+        else {
+            await deprecatedProjectDevFlow({
+                args,
+                accountId: targetProjectAccountId,
+                projectConfig,
+                projectDir,
+            });
+        }
+    }
+    catch (e) {
+        if (e instanceof PromptExitError) {
+            process.exit(e.exitCode);
+        }
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function projectDevBuilder(yargs) {
+    yargs.option('profile', {
+        type: 'string',
+        alias: 'p',
+        description: commands.project.dev.options.profile,
+        hidden: true,
+    });
+    yargs.options('testing-account', {
+        type: 'string',
+        description: commands.project.dev.options.testingAccount,
+        implies: ['project-account'],
+    });
+    yargs.options('project-account', {
+        type: 'string',
+        description: commands.project.dev.options.projectAccount,
+        implies: ['testingAccount'],
+    });
+    yargs.option('account', {
+        alias: 'a',
+        describe: '',
+        type: 'string',
+        description: commands.project.dev.options.account,
+    });
+    yargs.example([['$0 project dev', commands.project.dev.examples.default]]);
+    yargs.conflicts('profile', 'account');
+    yargs.conflicts('profile', 'testing-account');
+    yargs.conflicts('profile', 'project-account');
+    return yargs;
+}
+export const builder = makeYargsBuilder(projectDevBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useEnvironmentOptions: true,
+});
+const projectDevCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectDevCommand;

package/commands/project/dev/unifiedFlow.d.ts

@@ -0,0 +1,14 @@
+import { ArgumentsCamelCase } from 'yargs';
+import type { HsProfileFile } from '@hubspot/project-parsing-lib/profiles';
+import { ProjectDevArgs } from '../../../types/Yargs.js';
+import { ProjectConfig } from '../../../types/Projects.js';
+type UnifiedProjectDevFlowArgs = {
+    args: ArgumentsCamelCase<ProjectDevArgs>;
+    targetProjectAccountId: number;
+    providedTargetTestingAccountId?: number;
+    projectConfig: ProjectConfig;
+    projectDir: string;
+    profileConfig?: HsProfileFile;
+};
+export declare function unifiedProjectDevFlow({ args, targetProjectAccountId, providedTargetTestingAccountId, projectConfig, projectDir, }: UnifiedProjectDevFlowArgs): Promise<void>;
+export {};

package/commands/project/dev/unifiedFlow.js

@@ -0,0 +1,162 @@
+import path from 'path';
+import util from 'util';
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { startPortManagerServer, stopPortManagerServer, } from '@hubspot/local-dev-lib/portManager';
+import { isTranslationError, translateForLocalDev, } from '@hubspot/project-parsing-lib/translate';
+import { getConfigAccountEnvironment, getAllConfigAccounts, getConfigAccountById, } from '@hubspot/local-dev-lib/config';
+import { logError } from '../../../lib/errorHandlers/index.js';
+import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
+import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
+import { createInitialBuildForNewProject, createNewProjectForLocalDev, compareLocalProjectToDeployed, checkAndInstallDependencies, } from '../../../lib/projects/localDev/helpers/project.js';
+import { useExistingDevTestAccount, createDeveloperTestAccountForLocalDev, selectAccountTypePrompt, createSandboxForLocalDev, } from '../../../lib/projects/localDev/helpers/account.js';
+import { selectDeveloperTestTargetAccountPrompt, selectSandboxTargetAccountPrompt, } from '../../../lib/prompts/projectDevTargetAccountPrompt.js';
+import LocalDevProcess from '../../../lib/projects/localDev/LocalDevProcess.js';
+import LocalDevWatcher from '../../../lib/projects/localDev/LocalDevWatcher.js';
+import { handleExit, handleKeypress } from '../../../lib/process.js';
+import { isTestAccountOrSandbox, isUnifiedAccount, } from '../../../lib/accountTypes.js';
+import { uiLogger } from '../../../lib/ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import LocalDevWebsocketServer from '../../../lib/projects/localDev/LocalDevWebsocketServer.js';
+import { confirmLocalDevIsNotRunning } from '../../../lib/projects/localDev/helpers/process.js';
+export async function unifiedProjectDevFlow({ args, targetProjectAccountId, providedTargetTestingAccountId, projectConfig, projectDir, }) {
+    await confirmLocalDevIsNotRunning();
+    const env = getConfigAccountEnvironment(targetProjectAccountId);
+    let projectNodes;
+    let projectProfileData;
+    // Get IR
+    try {
+        const intermediateRepresentation = await translateForLocalDev({
+            projectSourceDir: path.join(projectDir, projectConfig.srcDir),
+            platformVersion: projectConfig.platformVersion,
+            accountId: targetProjectAccountId,
+        }, { profile: args.profile });
+        projectNodes = intermediateRepresentation.intermediateNodesIndexedByUid;
+        projectProfileData = intermediateRepresentation.profileData;
+        uiLogger.debug(util.inspect(projectNodes, false, null, true));
+    }
+    catch (e) {
+        if (isTranslationError(e)) {
+            uiLogger.error(e.toString());
+        }
+        else {
+            logError(e);
+        }
+        return process.exit(EXIT_CODES.ERROR);
+    }
+    if (!Object.keys(projectNodes).length) {
+        uiLogger.error(commands.project.dev.errors.noRunnableComponents);
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    const targetProjectAccountConfig = getConfigAccountById(targetProjectAccountId);
+    if (!targetProjectAccountConfig) {
+        uiLogger.error(commands.project.dev.errors.noAccount(targetProjectAccountId));
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const accounts = getAllConfigAccounts();
+    const accountIsCombined = await isUnifiedAccount(targetProjectAccountConfig);
+    const targetProjectAccountIsTestAccountOrSandbox = isTestAccountOrSandbox(targetProjectAccountConfig);
+    if (!accountIsCombined) {
+        uiLogger.error(commands.project.dev.errors.accountNotCombined);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    let targetTestingAccountId = providedTargetTestingAccountId;
+    // Temporarily removing logic to use profile account as testing account
+    // if (profileConfig) {
+    //   // Bypass the prompt for the testing account if the user has a profile configured
+    //   targetTestingAccountId = profileConfig.accountId;
+    // } else
+    if (
+    // Bypass the prompt for the testing account if default account is already a test account
+    !targetTestingAccountId &&
+        targetProjectAccountIsTestAccountOrSandbox) {
+        targetTestingAccountId = targetProjectAccountId;
+        uiLogger.log(commands.project.dev.logs.defaultSandboxOrDevTestTestingAccountExplanation(targetProjectAccountId));
+    }
+    else if (!targetTestingAccountId) {
+        uiLogger.log('');
+        const accountType = await selectAccountTypePrompt(targetProjectAccountConfig);
+        if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
+            const devAccountPromptResponse = await selectDeveloperTestTargetAccountPrompt(accounts, targetProjectAccountConfig);
+            targetTestingAccountId =
+                devAccountPromptResponse.targetAccountId || undefined;
+            if (!!devAccountPromptResponse.notInConfigAccount) {
+                // When the developer test account isn't configured in the CLI config yet
+                // Walk the user through adding the account's PAK to the config
+                await useExistingDevTestAccount(env, devAccountPromptResponse.notInConfigAccount);
+            }
+            else if (devAccountPromptResponse.createNestedAccount) {
+                // Create a new developer test account and automatically add it to the CLI config
+                targetTestingAccountId = await createDeveloperTestAccountForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env, true);
+            }
+        }
+        else if (accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
+            const sandboxAccountPromptResponse = await selectSandboxTargetAccountPrompt(accounts, targetProjectAccountConfig);
+            targetTestingAccountId =
+                sandboxAccountPromptResponse.targetAccountId || undefined;
+            if (sandboxAccountPromptResponse.createNestedAccount) {
+                targetTestingAccountId = await createSandboxForLocalDev(targetProjectAccountId, targetProjectAccountConfig, env);
+            }
+        }
+        else {
+            targetTestingAccountId = targetProjectAccountId;
+        }
+    }
+    else {
+        uiLogger.log(commands.project.dev.logs.testingAccountFlagExplanation(targetTestingAccountId));
+    }
+    // Check if project exists in HubSpot
+    const { projectExists, project: uploadedProject } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {
+        allowCreate: false,
+        noLogs: true,
+    });
+    let project = uploadedProject;
+    if (projectExists && project) {
+        await compareLocalProjectToDeployed(projectConfig, targetProjectAccountId, project.deployedBuild?.buildId, projectNodes, args.profile);
+    }
+    else {
+        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, false, false);
+        await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, true, args.profile);
+    }
+    // Check for missing/outdated dependencies
+    await checkAndInstallDependencies();
+    // End setup, start local dev process
+    try {
+        await startPortManagerServer();
+    }
+    catch (e) {
+        logError(e);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const localDevProcess = new LocalDevProcess({
+        initialProjectNodes: projectNodes,
+        initialProjectProfileData: projectProfileData,
+        debug: args.debug,
+        profile: args.profile,
+        targetProjectAccountId,
+        targetTestingAccountId: targetTestingAccountId,
+        projectConfig,
+        projectDir,
+        projectData: project,
+        env,
+    });
+    const websocketServer = new LocalDevWebsocketServer(localDevProcess, args.debug);
+    const watcher = new LocalDevWatcher(localDevProcess);
+    await websocketServer.start();
+    await localDevProcess.start();
+    watcher.start();
+    handleKeypress(async (key) => {
+        if ((key.ctrl && key.name === 'c') || key.name === 'q') {
+            await Promise.all([
+                localDevProcess.stop(),
+                watcher.stop(),
+                websocketServer.shutdown(),
+            ]);
+        }
+    });
+    handleExit(({ isSIGHUP }) => {
+        localDevProcess.stop(!isSIGHUP);
+        watcher.stop();
+        websocketServer.shutdown();
+        stopPortManagerServer();
+    });
+}

package/commands/project/download.d.ts

@@ -0,0 +1,8 @@
+import { CommonArgs, ConfigArgs, AccountArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectDownloadArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
+    project?: string;
+    dest?: string;
+    build?: number;
+};
+declare const projectDownloadCommand: YargsCommandModule<unknown, ProjectDownloadArgs>;
+export default projectDownloadCommand;

package/commands/project/download.js

@@ -0,0 +1,95 @@
+import path from 'path';
+import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
+import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
+import { downloadProject, fetchProjectBuilds, } from '@hubspot/local-dev-lib/api/projects';
+import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
+import { PromptExitError } from '../../lib/errors/PromptExitError.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
+import { downloadProjectPrompt } from '../../lib/prompts/downloadProjectPrompt.js';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'download';
+const describe = commands.project.download.describe;
+async function handler(args) {
+    const { projectConfig } = await getProjectConfig();
+    if (projectConfig) {
+        uiLogger.error(commands.project.download.warnings.cannotDownloadWithinProject);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    const { dest, build, derivedAccountId } = args;
+    let buildNumberToDownload = build;
+    trackCommandUsage('project-download', undefined, derivedAccountId);
+    try {
+        const { project: projectName } = await downloadProjectPrompt(args);
+        if (!buildNumberToDownload) {
+            const { data: projectBuildsResult } = await fetchProjectBuilds(derivedAccountId, projectName);
+            const { results: projectBuilds } = projectBuildsResult;
+            if (projectBuilds && projectBuilds.length) {
+                const latestBuild = projectBuilds[0];
+                buildNumberToDownload = latestBuild.buildId;
+            }
+        }
+        if (!buildNumberToDownload) {
+            uiLogger.error(commands.project.download.errors.noBuildIdToDownload);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const sanitizedProjectName = sanitizeFileName(projectName);
+        const absoluteDestPath = dest
+            ? path.resolve(getCwd(), dest, sanitizedProjectName)
+            : path.resolve(getCwd(), sanitizedProjectName);
+        const { data: zippedProject } = await downloadProject(derivedAccountId, projectName, buildNumberToDownload);
+        await extractZipArchive(zippedProject, sanitizeFileName(projectName), path.resolve(absoluteDestPath));
+        uiLogger.log(commands.project.download.logs.downloadSucceeded(buildNumberToDownload, projectName));
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    catch (e) {
+        if (e instanceof PromptExitError) {
+            process.exit(e.exitCode);
+        }
+        logError(e, new ApiErrorContext({
+            accountId: derivedAccountId,
+            request: 'project download',
+        }));
+        process.exit(EXIT_CODES.ERROR);
+    }
+}
+function projectDownloadBuilder(yargs) {
+    yargs.options({
+        project: {
+            describe: commands.project.download.options.project.describe,
+            type: 'string',
+        },
+        dest: {
+            describe: commands.project.download.options.dest.describe,
+            type: 'string',
+        },
+        build: {
+            describe: commands.project.download.options.build.describe,
+            alias: ['build-id'],
+            type: 'number',
+        },
+    });
+    yargs.example([
+        [
+            '$0 project download --project=myProject --dest=myProjectFolder',
+            commands.project.download.examples.default,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectDownloadBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+    useAccountOptions: true,
+    useEnvironmentOptions: true,
+});
+const projectDownloadCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectDownloadCommand;

package/commands/project/installDeps.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, ConfigArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ProjectInstallDepsArgs = CommonArgs & ConfigArgs & {
+    packages?: string[];
+};
+declare const projectInstallDepsCommand: YargsCommandModule<unknown, ProjectInstallDepsArgs>;
+export default projectInstallDepsCommand;

package/commands/project/installDeps.js

@@ -0,0 +1,80 @@
+import { installPackages, getProjectPackageJsonLocations, } from '../../lib/dependencyManagement.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import { getProjectConfig } from '../../lib/projects/config.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import path from 'path';
+import { commands } from '../../lang/en.js';
+import { uiLogger } from '../../lib/ui/logger.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { logError } from '../../lib/errorHandlers/index.js';
+import { makeYargsBuilder } from '../../lib/yargsUtils.js';
+const command = 'install-deps [packages..]';
+const describe = commands.project.installDeps.help.describe;
+async function handler(args) {
+    const { derivedAccountId, packages } = args;
+    try {
+        trackCommandUsage('project-install-deps', undefined, derivedAccountId);
+        const projectConfig = await getProjectConfig();
+        if (!projectConfig || !projectConfig.projectDir) {
+            uiLogger.error(commands.project.installDeps.noProjectConfig);
+            return process.exit(EXIT_CODES.ERROR);
+        }
+        const { projectDir } = projectConfig;
+        let installLocations = await getProjectPackageJsonLocations();
+        if (packages) {
+            const { selectedInstallLocations } = await promptUser([
+                {
+                    name: 'selectedInstallLocations',
+                    type: 'checkbox',
+                    when: () => packages && packages.length > 0,
+                    message: commands.project.installDeps.installLocationPrompt,
+                    choices: installLocations.map(dir => ({
+                        name: path.relative(projectDir, dir),
+                        value: dir,
+                    })),
+                    validate: (choices) => {
+                        if (choices === undefined || choices.length === 0) {
+                            return commands.project.installDeps.installLocationPromptRequired;
+                        }
+                        return true;
+                    },
+                },
+            ]);
+            if (selectedInstallLocations) {
+                installLocations = selectedInstallLocations;
+            }
+        }
+        await installPackages({
+            packages,
+            installLocations,
+        });
+    }
+    catch (e) {
+        logError(e);
+        return process.exit(EXIT_CODES.ERROR);
+    }
+}
+function projectInstallDepsBuilder(yargs) {
+    yargs.example([
+        [
+            '$0 project install-deps',
+            commands.project.installDeps.help.installAppDepsExample,
+        ],
+        [
+            '$0 project install-deps dependency1 dependency2',
+            commands.project.installDeps.help.addDepToSubComponentExample,
+        ],
+    ]);
+    return yargs;
+}
+const builder = makeYargsBuilder(projectInstallDepsBuilder, command, describe, {
+    useGlobalOptions: true,
+    useConfigOptions: true,
+});
+const projectInstallDepsCommand = {
+    command,
+    describe,
+    handler,
+    builder,
+};
+export default projectInstallDepsCommand;

package/commands/project/lint.d.ts

@@ -0,0 +1,6 @@
+import { CommonArgs, YargsCommandModule } from '../../types/Yargs.js';
+export type ProjectLintArgs = CommonArgs & {
+    installMissingDeps?: boolean;
+};
+declare const projectLintCommand: YargsCommandModule<unknown, ProjectLintArgs>;
+export default projectLintCommand;