@hubspot/cli 6.4.0-beta.1 → 7.0.0-experimental.0

package/commands/project/add.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
 const { logger } = require('@hubspot/local-dev-lib/logger');
-const { getAccountId } = require('@hubspot/local-dev-lib/config');
 const { logError } = require('../../lib/errorHandlers/index');
 const { fetchReleaseData } = require('@hubspot/local-dev-lib/github');
 const { trackCommandUsage } = require('../../lib/usageTracking');
@@ -17,10 +16,10 @@ exports.command = 'add';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
+    const { derivedAccountId } = options;
     logger.log('');
     logger.log(i18n(`${i18nKey}.creatingComponent.message`));
     logger.log('');
-    const accountId = getAccountId(options);
     const releaseData = await fetchReleaseData(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH);
     const projectComponentsVersion = releaseData.tag_name;
     const components = await getProjectComponentsByVersion(projectComponentsVersion);
@@ -29,7 +28,7 @@ exports.handler = async (options) => {
     if (!component) {
         component = components.find(t => t.path === options.type);
     }
-    trackCommandUsage('project-add', null, accountId);
+    trackCommandUsage('project-add', null, derivedAccountId);
     try {
         await createProjectComponent(component, name, projectComponentsVersion);
         logger.log('');

package/commands/project/cloneApp.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
 const path = require('path');
 const fs = require('fs');
-const { addAccountOptions, addConfigOptions, getAccountId, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
 const { trackCommandUsage, trackCommandMetadataUsage, } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { i18n } = require('../../lib/lang');
@@ -27,10 +27,10 @@ exports.command = 'clone-app';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
-    const accountId = getAccountId(options);
-    const accountConfig = getAccountConfig(accountId);
-    const accountName = uiAccountDescription(accountId);
-    trackCommandUsage('clone-app', {}, accountId);
+    const { derivedAccountId } = options;
+    const accountConfig = getAccountConfig(derivedAccountId);
+    const accountName = uiAccountDescription(derivedAccountId);
+    trackCommandUsage('clone-app', {}, derivedAccountId);
     if (!isAppDeveloperAccount(accountConfig)) {
         uiLine();
         logger.error(i18n(`${i18nKey}.errors.invalidAccountTypeTitle`));
@@ -42,58 +42,54 @@ exports.handler = async (options) => {
         process.exit(EXIT_CODES.SUCCESS);
     }
     let appId;
-    let name;
-    let location;
+    let projectName;
+    let projectDest;
     try {
         appId = options.appId;
         if (!appId) {
             const appIdResponse = await selectPublicAppPrompt({
-                accountId,
+                accountId: derivedAccountId,
                 accountName,
                 options,
                 isMigratingApp: false,
             });
             appId = appIdResponse.appId;
         }
-        const projectResponse = await createProjectPrompt('', options, true);
-        name = projectResponse.name;
-        location = projectResponse.location;
+        const { name, dest } = await createProjectPrompt('', options, true);
+        projectName = name;
+        projectDest = options.dest || dest;
     }
     catch (error) {
-        logError(error, new ApiErrorContext({ accountId }));
+        logError(error, new ApiErrorContext({ accountId: derivedAccountId }));
         process.exit(EXIT_CODES.ERROR);
     }
+    await trackCommandMetadataUsage('clone-app', { status: 'STARTED' }, derivedAccountId);
     try {
         SpinniesManager.init();
         SpinniesManager.add('cloneApp', {
             text: i18n(`${i18nKey}.cloneStatus.inProgress`),
         });
-        const { data: { exportId }, } = await cloneApp(accountId, appId);
-        const { status } = await poll(checkCloneStatus, accountId, exportId);
+        const { data: { exportId }, } = await cloneApp(derivedAccountId, appId);
+        const { status } = await poll(checkCloneStatus, derivedAccountId, exportId);
         if (status === 'SUCCESS') {
             // Ensure correct project folder structure exists
-            const baseDestPath = path.resolve(getCwd(), location);
+            const baseDestPath = path.resolve(getCwd(), projectDest);
             const absoluteDestPath = path.resolve(baseDestPath, 'src', 'app');
             fs.mkdirSync(absoluteDestPath, { recursive: true });
             // Extract zipped app files and place them in correct directory
-            const { data: zippedApp } = await downloadClonedProject(accountId, exportId);
-            await extractZipArchive(zippedApp, sanitizeFileName(name), absoluteDestPath, {
+            const { data: zippedApp } = await downloadClonedProject(derivedAccountId, exportId);
+            await extractZipArchive(zippedApp, sanitizeFileName(projectName), absoluteDestPath, {
                 includesRootDir: true,
                 hideLogs: true,
             });
             // Create hsproject.json file
             const configPath = path.join(baseDestPath, PROJECT_CONFIG_FILE);
             const configContent = {
-                name,
+                name: projectName,
                 srcDir: 'src',
                 platformVersion: '2023.2',
             };
             const success = writeProjectConfig(configPath, configContent);
-            trackCommandMetadataUsage('clone-app', {
-                type: name,
-                assetType: appId,
-                successful: success,
-            }, accountId);
             SpinniesManager.succeed('cloneApp', {
                 text: i18n(`${i18nKey}.cloneStatus.done`),
                 succeedColor: 'white',
@@ -103,33 +99,35 @@ exports.handler = async (options) => {
             }
             logger.log('');
             uiLine();
-            logger.success(i18n(`${i18nKey}.cloneStatus.success`, { location }));
+            logger.success(i18n(`${i18nKey}.cloneStatus.success`, { dest }));
             logger.log('');
             process.exit(EXIT_CODES.SUCCESS);
         }
     }
     catch (error) {
-        trackCommandMetadataUsage('clone-app', { projectName: name, appId, status: 'FAILURE', error }, accountId);
+        await trackCommandMetadataUsage('clone-app', { status: 'FAILURE' }, derivedAccountId);
         SpinniesManager.fail('cloneApp', {
             text: i18n(`${i18nKey}.cloneStatus.failure`),
             failColor: 'white',
         });
         // Migrations endpoints return a response object with an errors property. The errors property contains an array of errors.
         if (error.errors && Array.isArray(error.errors)) {
-            error.errors.forEach(e => logError(e, new ApiErrorContext({ accountId })));
+            error.errors.forEach(e => logError(e, new ApiErrorContext({ accountId: derivedAccountId })));
         }
         else {
-            logError(error, new ApiErrorContext({ accountId }));
+            logError(error, new ApiErrorContext({ accountId: derivedAccountId }));
         }
     }
+    await trackCommandMetadataUsage('clone-app', { status: 'SUCCESS' }, derivedAccountId);
+    process.exit(EXIT_CODES.SUCCESS);
 };
 exports.builder = yargs => {
     yargs.options({
-        location: {
-            describe: i18n(`${i18nKey}.options.location.describe`),
+        dest: {
+            describe: i18n(`${i18nKey}.options.dest.describe`),
             type: 'string',
         },
-        appId: {
+        'app-id': {
             describe: i18n(`${i18nKey}.options.appId.describe`),
             type: 'number',
         },

package/commands/project/create.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-const { addAccountOptions, addConfigOptions, getAccountId, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { getCwd } = require('@hubspot/local-dev-lib/path');
@@ -19,16 +19,16 @@ exports.command = 'create';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
-    const accountId = getAccountId(options);
+    const { derivedAccountId } = options;
     const hasCustomTemplateSource = Boolean(options.templateSource);
     let githubRef = '';
     if (!hasCustomTemplateSource) {
         const releaseData = await fetchReleaseData(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH);
         githubRef = releaseData.tag_name;
     }
-    const { name, template, location } = await createProjectPrompt(githubRef, options);
-    trackCommandUsage('project-create', { type: template.name }, accountId);
-    await createProjectConfig(path.resolve(getCwd(), options.location || location), options.name || name, template, options.templateSource, githubRef);
+    const { name, template, dest } = await createProjectPrompt(githubRef, options);
+    trackCommandUsage('project-create', { type: template.name }, derivedAccountId);
+    await createProjectConfig(path.resolve(getCwd(), options.dest || dest), options.name || name, template, options.templateSource, githubRef);
     logger.log('');
     logger.log(chalk.bold(i18n(`${i18nKey}.logs.welcomeMessage`)));
     uiFeatureHighlight([
@@ -44,15 +44,15 @@ exports.builder = yargs => {
             describe: i18n(`${i18nKey}.options.name.describe`),
             type: 'string',
         },
-        location: {
-            describe: i18n(`${i18nKey}.options.location.describe`),
+        dest: {
+            describe: i18n(`${i18nKey}.options.dest.describe`),
             type: 'string',
         },
         template: {
             describe: i18n(`${i18nKey}.options.template.describe`),
             type: 'string',
         },
-        templateSource: {
+        'template-source': {
             describe: i18n(`${i18nKey}.options.templateSource.describe`),
             type: 'string',
         },

package/commands/project/deploy.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
 const chalk = require('chalk');
-const { addAccountOptions, addConfigOptions, getAccountId, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { logError, ApiErrorContext } = require('../../lib/errorHandlers/index');
 const { logger } = require('@hubspot/local-dev-lib/logger');
@@ -38,17 +38,17 @@ const validateBuildId = (buildId, deployedBuildId, latestBuildId, projectName, a
 };
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
-    const accountId = getAccountId(options);
-    const accountConfig = getAccountConfig(accountId);
+    const { derivedAccountId } = options;
+    const accountConfig = getAccountConfig(derivedAccountId);
     const { project: projectOption, buildId: buildIdOption } = options;
     const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-deploy', { type: accountType }, accountId);
+    trackCommandUsage('project-deploy', { type: accountType }, derivedAccountId);
     const { projectConfig } = await getProjectConfig();
     let projectName = projectOption;
     if (!projectOption && projectConfig) {
         projectName = projectConfig.name;
     }
-    const namePromptResponse = await projectNamePrompt(accountId, {
+    const namePromptResponse = await projectNamePrompt(derivedAccountId, {
         project: projectName,
     });
     if (!projectName && namePromptResponse.projectName) {
@@ -56,13 +56,13 @@ exports.handler = async (options) => {
     }
     let buildIdToDeploy = buildIdOption;
     try {
-        const { data: { latestBuild, deployedBuildId }, } = await fetchProject(accountId, projectName);
+        const { data: { latestBuild, deployedBuildId }, } = await fetchProject(derivedAccountId, projectName);
         if (!latestBuild || !latestBuild.buildId) {
             logger.error(i18n(`${i18nKey}.errors.noBuilds`));
             return process.exit(EXIT_CODES.ERROR);
         }
         if (buildIdToDeploy) {
-            const validationResult = validateBuildId(buildIdToDeploy, deployedBuildId, latestBuild.buildId, projectName, accountId);
+            const validationResult = validateBuildId(buildIdToDeploy, deployedBuildId, latestBuild.buildId, projectName, derivedAccountId);
             if (validationResult !== true) {
                 logger.error(validationResult);
                 return process.exit(EXIT_CODES.ERROR);
@@ -75,7 +75,7 @@ exports.handler = async (options) => {
                 default: latestBuild.buildId === deployedBuildId
                     ? undefined
                     : latestBuild.buildId,
-                validate: () => validateBuildId(buildId, deployedBuildId, latestBuild.buildId, projectName, accountId),
+                validate: () => validateBuildId(buildId, deployedBuildId, latestBuild.buildId, projectName, derivedAccountId),
             });
             buildIdToDeploy = deployBuildIdPromptResponse.buildId;
         }
@@ -83,20 +83,20 @@ exports.handler = async (options) => {
             logger.error(i18n(`${i18nKey}.errors.noBuildId`));
             return process.exit(EXIT_CODES.ERROR);
         }
-        const { data: deployResp } = await deployProject(accountId, projectName, buildIdToDeploy);
+        const { data: deployResp } = await deployProject(derivedAccountId, projectName, buildIdToDeploy);
         if (!deployResp || deployResp.error) {
             logger.error(i18n(`${i18nKey}.errors.deploy`, {
                 details: deployResp.error.message,
             }));
             return process.exit(EXIT_CODES.ERROR);
         }
-        await pollDeployStatus(accountId, projectName, deployResp.id, buildIdToDeploy);
+        await pollDeployStatus(derivedAccountId, projectName, deployResp.id, buildIdToDeploy);
     }
     catch (e) {
         if (isHubSpotHttpError(e) && e.status === 404) {
             logger.error(i18n(`${i18nKey}.errors.projectNotFound`, {
                 projectName: chalk.bold(projectName),
-                accountIdentifier: uiAccountDescription(accountId),
+                accountIdentifier: uiAccountDescription(derivedAccountId),
                 command: uiCommandReference('hs project upload'),
             }));
         }
@@ -104,7 +104,10 @@ exports.handler = async (options) => {
             logger.error(e.message);
         }
         else {
-            logError(e, new ApiErrorContext({ accountId, request: 'project deploy' }));
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                request: 'project deploy',
+            }));
         }
         return process.exit(EXIT_CODES.ERROR);
     }
@@ -116,7 +119,7 @@ exports.builder = yargs => {
             type: 'string',
         },
         build: {
-            alias: ['buildId'],
+            alias: ['build-id'],
             describe: i18n(`${i18nKey}.options.build.describe`),
             type: 'number',
         },

package/commands/project/dev.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-const { addAccountOptions, addConfigOptions, getAccountId, addUseEnvironmentOptions, addTestingOptions, } = require('../../lib/commonOpts');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { handleExit } = require('../../lib/process');
@@ -18,14 +18,14 @@ const { getValidEnv } = require('@hubspot/local-dev-lib/environment');
 const { findProjectComponents, getProjectComponentTypes, COMPONENT_TYPES, } = require('../../lib/projectStructure');
 const { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, createNewProjectForLocalDev, createInitialBuildForNewProject, useExistingDevTestAccount, checkIfAccountFlagIsSupported, checkIfParentAccountIsAuthed, } = require('../../lib/localDev');
 const i18nKey = 'commands.project.subcommands.dev';
-exports.command = 'dev [--account]';
+exports.command = 'dev';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
-    const accountId = getAccountId(options);
-    const accountConfig = getAccountConfig(accountId);
-    const env = getValidEnv(getEnv(accountId));
-    trackCommandUsage('project-dev', null, accountId);
+    const { derivedAccountId } = options;
+    const accountConfig = getAccountConfig(derivedAccountId);
+    const env = getValidEnv(getEnv(derivedAccountId));
+    trackCommandUsage('project-dev', null, derivedAccountId);
     const { projectConfig, projectDir } = await getProjectConfig();
     uiBetaTag(i18n(`${i18nKey}.logs.betaMessage`));
     logger.log(uiLink(i18n(`${i18nKey}.logs.learnMoreLocalDevServer`), 'https://developers.hubspot.com/docs/platform/project-cli-commands#start-a-local-development-server'));
@@ -54,11 +54,11 @@ exports.handler = async (options) => {
     const defaultAccountIsRecommendedType = isDeveloperTestAccount(accountConfig) ||
         (!hasPublicApps && isSandbox(accountConfig));
     // The account that the project must exist in
-    let targetProjectAccountId = options.account ? accountId : null;
+    let targetProjectAccountId = derivedAccountId;
     // The account that we are locally testing against
-    let targetTestingAccountId = options.account ? accountId : null;
+    let targetTestingAccountId = derivedAccountId;
     // Check that the default account or flag option is valid for the type of app in this project
-    if (options.account) {
+    if (derivedAccountId) {
         checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
         if (hasPublicApps) {
             targetProjectAccountId = accountConfig.parentAccountId;
@@ -69,14 +69,14 @@ exports.handler = async (options) => {
     }
     // The user is targeting an account type that we recommend developing on
     if (!targetProjectAccountId && defaultAccountIsRecommendedType) {
-        targetTestingAccountId = accountId;
+        targetTestingAccountId = derivedAccountId;
         await confirmDefaultAccountIsTarget(accountConfig, hasPublicApps);
         if (hasPublicApps) {
             checkIfParentAccountIsAuthed(accountConfig);
             targetProjectAccountId = accountConfig.parentAccountId;
         }
         else {
-            targetProjectAccountId = accountId;
+            targetProjectAccountId = derivedAccountId;
         }
     }
     let createNewSandbox = false;
@@ -94,13 +94,13 @@ exports.handler = async (options) => {
             isAppDeveloperAccount(accountConfig) && createNestedAccount;
     }
     if (createNewSandbox) {
-        targetProjectAccountId = await createSandboxForLocalDev(accountId, accountConfig, env);
+        targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
         // We will be running our tests against this new sandbox account
         targetTestingAccountId = targetProjectAccountId;
     }
     if (createNewDeveloperTestAccount) {
-        targetTestingAccountId = await createDeveloperTestAccountForLocalDev(accountId, accountConfig, env);
-        targetProjectAccountId = accountId;
+        targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env);
+        targetProjectAccountId = derivedAccountId;
     }
     // eslint-disable-next-line prefer-const
     let { projectExists, project } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {

package/commands/project/download.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
 const path = require('path');
 const chalk = require('chalk');
-const { getAccountId, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { getCwd, sanitizeFileName } = require('@hubspot/local-dev-lib/path');
 const { logError, ApiErrorContext } = require('../../lib/errorHandlers/index');
@@ -17,7 +17,7 @@ const { i18n } = require('../../lib/lang');
 const { uiBetaTag } = require('../../lib/ui');
 const i18nKey = 'commands.project.subcommands.download';
 const { EXIT_CODES } = require('../../lib/enums/exitCodes');
-exports.command = 'download [--project]';
+exports.command = 'download';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
@@ -26,35 +26,34 @@ exports.handler = async (options) => {
         logger.error(i18n(`${i18nKey}.warnings.cannotDownloadWithinProject`));
         process.exit(EXIT_CODES.ERROR);
     }
-    const { project, dest, buildNumber } = options;
+    const { project, dest, build, derivedAccountId } = options;
     const { project: promptedProjectName } = await downloadProjectPrompt(options);
     let projectName = promptedProjectName || project;
-    const accountId = getAccountId(options);
-    trackCommandUsage('project-download', null, accountId);
+    trackCommandUsage('project-download', null, derivedAccountId);
     try {
-        const { projectExists } = await ensureProjectExists(accountId, projectName, {
+        const { projectExists } = await ensureProjectExists(derivedAccountId, projectName, {
             allowCreate: false,
             noLogs: true,
         });
         if (!projectExists) {
             logger.error(i18n(`${i18nKey}.errors.projectNotFound`, {
                 projectName: chalk.bold(projectName),
-                accountId: chalk.bold(accountId),
+                accountId: chalk.bold(derivedAccountId),
             }));
             const { name: promptedProjectName } = await downloadProjectPrompt(options);
             projectName = promptedProjectName || project;
         }
         const absoluteDestPath = dest ? path.resolve(getCwd(), dest) : getCwd();
-        let buildNumberToDownload = buildNumber;
+        let buildNumberToDownload = build;
         if (!buildNumberToDownload) {
-            const { data: projectBuildsResult } = await fetchProjectBuilds(accountId, projectName);
+            const { data: projectBuildsResult } = await fetchProjectBuilds(derivedAccountId, projectName);
             const { results: projectBuilds } = projectBuildsResult;
             if (projectBuilds && projectBuilds.length) {
                 const latestBuild = projectBuilds[0];
                 buildNumberToDownload = latestBuild.buildId;
             }
         }
-        const { data: zippedProject } = await downloadProject(accountId, projectName, buildNumberToDownload);
+        const { data: zippedProject } = await downloadProject(derivedAccountId, projectName, buildNumberToDownload);
         await extractZipArchive(zippedProject, sanitizeFileName(projectName), path.resolve(absoluteDestPath), { includesRootDir: false });
         logger.log(i18n(`${i18nKey}.logs.downloadSucceeded`, {
             buildId: buildNumberToDownload,
@@ -63,11 +62,16 @@ exports.handler = async (options) => {
         process.exit(EXIT_CODES.SUCCESS);
     }
     catch (e) {
-        logError(e, new ApiErrorContext({ accountId, request: 'project download' }));
+        logError(e, new ApiErrorContext({
+            accountId: derivedAccountId,
+            request: 'project download',
+        }));
         process.exit(EXIT_CODES.ERROR);
     }
 };
 exports.builder = yargs => {
+    addAccountOptions(yargs);
+    addConfigOptions(yargs);
     addUseEnvironmentOptions(yargs);
     yargs.options({
         project: {
@@ -78,8 +82,9 @@ exports.builder = yargs => {
             describe: i18n(`${i18nKey}.options.dest.describe`),
             type: 'string',
         },
-        buildNumber: {
-            describe: i18n(`${i18nKey}.options.buildNumber.describe`),
+        build: {
+            describe: i18n(`${i18nKey}.options.build.describe`),
+            alias: ['build-id'],
             type: 'number',
         },
     });

package/commands/project/listBuilds.js

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 // @ts-nocheck
-const path = require('path');
-const { addAccountOptions, addConfigOptions, getAccountId, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { i18n } = require('../../lib/lang');
 const { logError, ApiErrorContext } = require('../../lib/errorHandlers/index');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { fetchProject, fetchProjectBuilds, } = require('@hubspot/local-dev-lib/api/projects');
 const { getTableContents, getTableHeader } = require('../../lib/ui/table');
-const { getCwd } = require('@hubspot/local-dev-lib/path');
 const { uiBetaTag, uiLink } = require('../../lib/ui');
 const { loadAndValidateOptions } = require('../../lib/validation');
 const { getProjectConfig, getProjectDetailUrl, validateProjectConfig, } = require('../../lib/projects');
@@ -17,29 +15,36 @@ const moment = require('moment');
 const { promptUser } = require('../../lib/prompts/promptUtils');
 const { isHubSpotHttpError } = require('@hubspot/local-dev-lib/errors/index');
 const i18nKey = 'commands.project.subcommands.listBuilds';
-exports.command = 'list-builds [path]';
+exports.command = 'list-builds';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
     await loadAndValidateOptions(options);
-    const { path: projectPath, limit } = options;
-    const accountId = getAccountId(options);
-    trackCommandUsage('project-list-builds', null, accountId);
-    const cwd = projectPath ? path.resolve(getCwd(), projectPath) : getCwd();
-    const { projectConfig, projectDir } = await getProjectConfig(cwd);
-    validateProjectConfig(projectConfig, projectDir);
-    logger.debug(`Fetching builds for project at path: ${projectPath}`);
+    const { project: projectFlagValue, limit, derivedAccountId } = options;
+    trackCommandUsage('project-list-builds', null, derivedAccountId);
+    let projectName = projectFlagValue;
+    if (!projectName) {
+        const { projectConfig, projectDir } = await getProjectConfig();
+        validateProjectConfig(projectConfig, projectDir);
+        projectName = projectConfig.name;
+    }
     const fetchAndDisplayBuilds = async (project, options) => {
-        const { data: { results, paging }, } = await fetchProjectBuilds(accountId, project.name, options);
+        const { data: { results, paging }, } = await fetchProjectBuilds(derivedAccountId, project.name, options);
         const currentDeploy = project.deployedBuildId;
         if (options && options.after) {
-            logger.log(`Showing the next ${results.length} builds for ${project.name}`);
+            logger.log(i18n(`${i18nKey}.logs.showingNextBuilds`, {
+                count: results.length,
+                projectName: project.name,
+            }));
         }
         else {
-            logger.log(`Showing the ${results.length} most recent builds for ${project.name}. ` +
-                uiLink('View all builds in project details.', getProjectDetailUrl(project.name, accountId)));
+            logger.log(i18n(`${i18nKey}.logs.showingRecentBuilds`, {
+                count: results.length,
+                projectName: project.name,
+                viewBuildsLink: uiLink(i18n(`${i18nKey}.logs.viewAllBuildsLink`), getProjectDetailUrl(project.name, derivedAccountId)),
+            }));
         }
         if (results.length === 0) {
-            logger.log('No builds found.');
+            logger.log(i18n(`${i18nKey}.errors.noBuilds`));
         }
         else {
             const builds = results.map(build => {
@@ -75,40 +80,40 @@ exports.handler = async (options) => {
         if (paging && paging.next) {
             await promptUser({
                 name: 'more',
-                message: 'Press <enter> to load more, or ctrl+c to exit',
+                message: i18n(`${i18nKey}.continueOrExitPrompt`),
             });
             await fetchAndDisplayBuilds(project, { limit, after: paging.next.after });
         }
     };
     try {
-        const { data: project } = await fetchProject(accountId, projectConfig.name);
+        const { data: project } = await fetchProject(derivedAccountId, projectName);
         await fetchAndDisplayBuilds(project, { limit });
     }
     catch (e) {
         if (isHubSpotHttpError(e) && e.status === 404) {
-            logger.error(`Project ${projectConfig.name} not found. `);
+            logger.error(i18n(`${i18nKey}.errors.projectNotFound`, { projectName }));
         }
         else {
-            logError(e, new ApiErrorContext({ accountId, projectName: projectConfig.name }));
+            logError(e, new ApiErrorContext({
+                accountId: derivedAccountId,
+                projectName,
+            }));
         }
     }
 };
 exports.builder = yargs => {
-    yargs.positional('path', {
-        describe: 'Path to a project folder',
-        type: 'string',
-    });
     yargs.options({
+        project: {
+            describe: i18n(`${i18nKey}.options.project.describe`),
+            type: 'string',
+        },
         limit: {
-            describe: 'Max number of builds to load',
+            describe: i18n(`${i18nKey}.options.limit.describe`),
             type: 'string',
         },
     });
     yargs.example([
-        [
-            '$0 project list-builds myProjectFolder',
-            'Fetch a list of builds for a project within the myProjectFolder folder',
-        ],
+        ['$0 project list-builds', i18n(`${i18nKey}.examples.default`)],
     ]);
     addConfigOptions(yargs);
     addAccountOptions(yargs);

package/commands/project/logs.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const { getEnv } = require('@hubspot/local-dev-lib/config');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/local-dev-lib/urls');
 const { ENVIRONMENTS, } = require('@hubspot/local-dev-lib/constants/environments');
-const { getAccountId, addUseEnvironmentOptions, } = require('../../lib/commonOpts');
+const { addUseEnvironmentOptions } = require('../../lib/commonOpts');
 const { trackCommandUsage } = require('../../lib/usageTracking');
 const { logger } = require('@hubspot/local-dev-lib/logger');
 const { getTableContents, getTableHeader } = require('../../lib/ui/table');
@@ -50,11 +50,11 @@ function logPreamble() {
 exports.command = 'logs';
 exports.describe = uiBetaTag(i18n(`${i18nKey}.describe`), false);
 exports.handler = async (options) => {
-    const accountId = getAccountId(options);
-    trackCommandUsage('project-logs', null, accountId);
+    const { derivedAccountId } = options;
+    trackCommandUsage('project-logs', null, derivedAccountId);
     await loadAndValidateOptions(options);
     try {
-        await ProjectLogsManager.init(accountId);
+        await ProjectLogsManager.init(derivedAccountId);
         const { functionName } = await projectLogsPrompt({
             functionChoices: ProjectLogsManager.getFunctionNames(),
             promptOptions: options,
@@ -65,7 +65,7 @@ exports.handler = async (options) => {
     }
     catch (e) {
         logError(e, {
-            accountId,
+            accountId: derivedAccountId,
             projectName: ProjectLogsManager.projectName,
         });
         return process.exit(EXIT_CODES.ERROR);