@hubspot/cli 3.0.9-beta.1 → 3.0.10-beta.1

package/commands/logs.js

@@ -1,4 +1,4 @@
-const ora = require('ora');
+const Spinnies = require('spinnies');
 const {
   addAccountOptions,
   addConfigOptions,
@@ -14,16 +14,7 @@ const {
   checkAndWarnGitInclusion,
 } = require('@hubspot/cli-lib');
 const { logger } = require('@hubspot/cli-lib/logger');
-const {
-  logServerlessFunctionApiErrorInstance,
-  ApiErrorContext,
-} = require('@hubspot/cli-lib/errorHandlers');
 const { outputLogs } = require('@hubspot/cli-lib/lib/logs');
-const {
-  getFunctionByPath,
-  getAppFunctionLogs,
-  getLatestAppFunctionLogs,
-} = require('@hubspot/cli-lib/api/functions');
 const {
   getFunctionLogs,
   getLatestFunctionLog,
@@ -43,9 +34,11 @@ const loadAndValidateOptions = async options => {
   }
 };
 
-const handleLatestLogsError = e => {
+const handleLogsError = (e, accountId, functionPath) => {
   if (e.statusCode === 404) {
-    logger.log('No logs found.');
+    logger.error(
+      `No logs were found for the function path '${functionPath}' in account ${accountId}.`
+    );
   }
 };
 
@@ -58,95 +51,43 @@ const endpointLog = async (accountId, options) => {
     }logs for function with path: ${functionPath}`
   );
 
-  const functionResp = await getFunctionByPath(accountId, functionPath).catch(
-    async e => {
-      await logServerlessFunctionApiErrorInstance(
-        accountId,
-        e,
-        new ApiErrorContext({ accountId, functionPath })
-      );
-      process.exit();
-    }
-  );
-  const functionId = functionResp.id;
-
-  logger.debug(`Retrieving logs for functionId: ${functionResp.id}`);
-
   let logsResp;
 
   if (follow) {
-    const spinner = ora(
-      `Waiting for log entries for '${functionPath}' on account '${accountId}'.\n`
-    );
-    const tailCall = after => getFunctionLogs(accountId, functionId, { after });
-    const fetchLatest = () => {
-      try {
-        getLatestFunctionLog(accountId, functionId);
-      } catch (e) {
-        handleLatestLogsError(e);
-      }
-    };
+    const spinnies = new Spinnies();
 
-    await tailLogs({
-      accountId,
-      compact,
-      spinner,
-      tailCall,
-      fetchLatest,
+    spinnies.add('tailLogs', {
+      text: `Waiting for log entries for '${functionPath}' on account '${accountId}'.\n`,
     });
-  } else if (latest) {
-    try {
-      logsResp = await getLatestFunctionLog(accountId, functionResp.id);
-    } catch (e) {
-      handleLatestLogsError(e);
-    }
-  } else {
-    logsResp = await getFunctionLogs(accountId, functionResp.id, options);
-  }
-
-  if (logsResp) {
-    return outputLogs(logsResp, options);
-  }
-};
-
-const appFunctionLog = async (accountId, options) => {
-  const { latest, follow, compact, functionName, appPath } = options;
-
-  let logsResp;
-
-  if (follow) {
-    const spinner = ora(
-      `Waiting for log entries for "${functionName}" on account "${accountId}".\n`
-    );
     const tailCall = after =>
-      getAppFunctionLogs(accountId, functionName, appPath, { after });
+      getFunctionLogs(accountId, functionPath, { after });
     const fetchLatest = () => {
       try {
-        getLatestAppFunctionLogs(accountId, functionName, appPath);
+        getLatestFunctionLog(accountId, functionPath);
       } catch (e) {
-        handleLatestLogsError(e);
+        handleLogsError(e, accountId, functionPath);
       }
     };
 
     await tailLogs({
       accountId,
       compact,
-      spinner,
+      spinnies,
       tailCall,
       fetchLatest,
     });
   } else if (latest) {
     try {
-      logsResp = await getLatestAppFunctionLogs(
-        accountId,
-        functionName,
-        appPath
-      );
+      logsResp = await getLatestFunctionLog(accountId, functionPath);
     } catch (e) {
-      handleLatestLogsError(e);
+      handleLogsError(e, accountId, functionPath);
     }
   } else {
-    logsResp = await getAppFunctionLogs(accountId, functionName, appPath, {});
+    try {
+      logsResp = await getFunctionLogs(accountId, functionPath, options);
+    } catch (e) {
+      handleLogsError(e, accountId, functionPath);
+    }
   }
 
   if (logsResp) {
@@ -160,17 +101,13 @@ exports.describe = 'get logs for a function';
 exports.handler = async options => {
   loadAndValidateOptions(options);
 
-  const { latest, functionName } = options;
+  const { latest } = options;
 
   const accountId = getAccountId(options);
 
   trackCommandUsage('logs', { latest }, accountId);
 
-  if (functionName) {
-    appFunctionLog(accountId, options);
-  } else {
-    endpointLog(accountId, options);
-  }
+  endpointLog(accountId, options);
 };
 
 exports.builder = yargs => {
@@ -180,16 +117,6 @@ exports.builder = yargs => {
   });
   yargs
     .options({
-      appPath: {
-        describe: 'path to the app',
-        type: 'string',
-        hidden: true,
-      },
-      functionName: {
-        describe: 'app function name',
-        type: 'string',
-        hidden: true,
-      },
       latest: {
         alias: 'l',
         describe: 'retrieve most recent log only',

package/commands/marketplaceValidate/validateTheme.js

@@ -75,7 +75,7 @@ exports.handler = async options => {
         .flat()
         .some(result => result.result === VALIDATION_RESULT.FATAL)
     ) {
-      process.exit(1);
+      process.exit(2);
     }
   });
 };

package/commands/project/deploy.js

@@ -1,3 +1,4 @@
+const path = require('path');
 const {
   addAccountOptions,
   addConfigOptions,
@@ -17,8 +18,13 @@ const {
   ApiErrorContext,
 } = require('@hubspot/cli-lib/errorHandlers');
 const { logger } = require('@hubspot/cli-lib/logger');
-const { deployProject } = require('@hubspot/cli-lib/api/fileMapper');
+const { deployProject, fetchProject } = require('@hubspot/cli-lib/api/dfs');
+const { getCwd } = require('@hubspot/cli-lib/path');
 const { validateAccount } = require('../../lib/validation');
+const {
+  getOrCreateProjectConfig,
+  pollDeployStatus,
+} = require('../../lib/projects');
 
 const loadAndValidateOptions = async options => {
   setLogLevel(options);
@@ -32,39 +38,56 @@ const loadAndValidateOptions = async options => {
   }
 };
 
-exports.command = 'deploy <path>';
+exports.command = 'deploy [path]';
 exports.describe = false;
 
 exports.handler = async options => {
   loadAndValidateOptions(options);
 
-  const { path: projectPath } = options;
+  const { path: projectPath, buildId } = options;
   const accountId = getAccountId(options);
 
   trackCommandUsage('project-deploy', { projectPath }, accountId);
 
+  const cwd = projectPath ? path.resolve(getCwd(), projectPath) : getCwd();
+  const projectConfig = await getOrCreateProjectConfig(cwd);
+
   logger.debug(`Deploying project at path: ${projectPath}`);
 
+  const getBuildId = async () => {
+    const { latestBuild } = await fetchProject(accountId, projectConfig.name);
+    if (latestBuild && latestBuild.buildId) {
+      return latestBuild.buildId;
+    }
+    logger.error('No latest build ID was found.');
+    return;
+  };
+
   try {
-    const deployResp = await deployProject(accountId, projectPath);
+    const deployedBuildId = buildId || (await getBuildId());
+
+    const deployResp = await deployProject(
+      accountId,
+      projectConfig.name,
+      deployedBuildId
+    );
 
     if (deployResp.error) {
       logger.error(`Deploy error: ${deployResp.error.message}`);
       return;
     }
 
-    logger.success(
-      `Deployed project in ${projectPath} on account ${accountId}.`
+    await pollDeployStatus(
+      accountId,
+      projectConfig.name,
+      deployResp.id,
+      deployedBuildId
     );
   } catch (e) {
     if (e.statusCode === 400) {
       logger.error(e.error.message);
     } else {
-      logApiErrorInstance(
-        accountId,
-        e,
-        new ApiErrorContext({ accountId, projectPath })
-      );
+      logApiErrorInstance(e, new ApiErrorContext({ accountId, projectPath }));
     }
   }
 };
@@ -75,6 +98,13 @@ exports.builder = yargs => {
     type: 'string',
   });
 
+  yargs.options({
+    buildId: {
+      describe: 'Project build ID to be deployed',
+      type: 'number',
+    },
+  });
+
   yargs.example([
     [
       '$0 project deploy myProjectFolder',

package/commands/project/logs.js

@@ -0,0 +1,196 @@
+const Spinnies = require('spinnies');
+const {
+  addAccountOptions,
+  addConfigOptions,
+  setLogLevel,
+  getAccountId,
+  addUseEnvironmentOptions,
+} = require('../../lib/commonOpts');
+const { trackCommandUsage } = require('../../lib/usageTracking');
+const { logDebugInfo } = require('../../lib/debugInfo');
+const {
+  loadConfig,
+  validateConfig,
+  checkAndWarnGitInclusion,
+} = require('@hubspot/cli-lib');
+const { logger } = require('@hubspot/cli-lib/logger');
+const { outputLogs } = require('@hubspot/cli-lib/lib/logs');
+const {
+  getProjectAppFunctionLogs,
+  getLatestProjectAppFunctionLog,
+} = require('@hubspot/cli-lib/api/functions');
+const { validateAccount } = require('../../lib/validation');
+const { tailLogs } = require('../../lib/serverlessLogs');
+
+const loadAndValidateOptions = async options => {
+  setLogLevel(options);
+  logDebugInfo(options);
+  const { config: configPath } = options;
+  loadConfig(configPath, options);
+  checkAndWarnGitInclusion();
+
+  if (!(validateConfig() && (await validateAccount(options)))) {
+    process.exit(1);
+  }
+};
+
+const handleLogsError = (e, accountId, projectName, appPath, functionName) => {
+  if (e.statusCode === 404) {
+    logger.error(
+      `No logs were found for the function name '${functionName}' in the app path '${appPath}' within the project '${projectName}' in account ${accountId}.`
+    );
+  }
+};
+
+const appFunctionLog = async (accountId, options) => {
+  const {
+    latest,
+    follow,
+    compact,
+    appPath,
+    functionName,
+    projectName,
+  } = options;
+
+  let logsResp;
+
+  if (follow) {
+    const spinnies = new Spinnies();
+
+    spinnies.add('tailLogs', {
+      text: `Waiting for log entries for '${functionName}' on account '${accountId}'.\n`,
+    });
+    const tailCall = after =>
+      getProjectAppFunctionLogs(accountId, functionName, projectName, appPath, {
+        after,
+      });
+    const fetchLatest = () => {
+      try {
+        return getLatestProjectAppFunctionLog(
+          accountId,
+          functionName,
+          projectName,
+          appPath
+        );
+      } catch (e) {
+        handleLogsError(e, accountId, projectName, appPath, functionName);
+      }
+    };
+
+    await tailLogs({
+      accountId,
+      compact,
+      spinnies,
+      tailCall,
+      fetchLatest,
+    });
+  } else if (latest) {
+    try {
+      logsResp = await getLatestProjectAppFunctionLog(
+        accountId,
+        functionName,
+        projectName,
+        appPath
+      );
+    } catch (e) {
+      handleLogsError(e, accountId, projectName, appPath, functionName);
+    }
+  } else {
+    try {
+      logsResp = await getProjectAppFunctionLogs(
+        accountId,
+        functionName,
+        projectName,
+        appPath,
+        {}
+      );
+    } catch (e) {
+      handleLogsError(e, accountId, projectName, appPath, functionName);
+    }
+  }
+
+  if (logsResp) {
+    return outputLogs(logsResp, options);
+  }
+};
+
+exports.command = 'logs [functionName]';
+exports.describe = 'get logs for a function within a project';
+
+exports.handler = async options => {
+  loadAndValidateOptions(options);
+
+  const { latest, functionName, projectName, appPath } = options;
+
+  if (!functionName) {
+    logger.error('You must pass a function name to retrieve logs for.');
+    process.exit(0);
+  } else if (!projectName) {
+    logger.error(
+      'You must specify a project name using the --projectName argument.'
+    );
+    process.exit(0);
+  } else if (!appPath) {
+    logger.error('You must specify an app path using the --appPath argument.');
+    process.exit(0);
+  }
+
+  const accountId = getAccountId(options);
+
+  trackCommandUsage('project-logs', { latest }, accountId);
+
+  appFunctionLog(accountId, options);
+};
+
+exports.builder = yargs => {
+  yargs.positional('functionName', {
+    describe: 'Serverless function name',
+    type: 'string',
+  });
+  yargs
+    .options({
+      appPath: {
+        describe: 'path to the app',
+        type: 'string',
+        hidden: true,
+      },
+      projectName: {
+        describe: 'name of the project',
+        type: 'string',
+        hidden: true,
+      },
+      latest: {
+        alias: 'l',
+        describe: 'retrieve most recent log only',
+        type: 'boolean',
+      },
+      compact: {
+        describe: 'output compact logs',
+        type: 'boolean',
+      },
+      follow: {
+        alias: ['t', 'tail', 'f'],
+        describe: 'follow logs',
+        type: 'boolean',
+      },
+      limit: {
+        alias: ['limit', 'n', 'max-count'],
+        describe: 'limit the number of logs to output',
+        type: 'number',
+      },
+    })
+    .conflicts('follow', 'limit');
+
+  yargs.example([
+    [
+      '$0 project logs my-function --appName="app" --projectName="my-project"',
+      'Get 5 most recent logs for function named "my-function" within the app named "app" within the project named "my-project"',
+    ],
+  ]);
+
+  addConfigOptions(yargs, true);
+  addAccountOptions(yargs, true);
+  addUseEnvironmentOptions(yargs, true);
+
+  return yargs;
+};

package/commands/project/upload.js

@@ -31,6 +31,8 @@ const {
   getProjectConfig,
   validateProjectConfig,
   pollBuildStatus,
+  ensureProjectExists,
+  pollDeployStatus,
 } = require('../../lib/projects');
 
 const loadAndValidateOptions = async options => {
@@ -49,7 +51,9 @@ exports.command = 'upload [path]';
 exports.describe = false;
 
 const uploadProjectFiles = async (accountId, projectName, filePath) => {
-  const spinnies = new Spinnies();
+  const spinnies = new Spinnies({
+    succeedColor: 'white',
+  });
 
   spinnies.add('upload', {
     text: `Uploading ${chalk.bold(projectName)} project files to ${chalk.bold(
@@ -57,9 +61,13 @@ const uploadProjectFiles = async (accountId, projectName, filePath) => {
     )}`,
   });
 
+  let buildId;
+
   try {
     const upload = await uploadProject(accountId, projectName, filePath);
 
+    buildId = upload.buildId;
+
     spinnies.succeed('upload', {
       text: `Uploaded ${chalk.bold(projectName)} project files to ${chalk.bold(
         accountId
@@ -67,9 +75,8 @@ const uploadProjectFiles = async (accountId, projectName, filePath) => {
     });
 
     logger.debug(
-      `Project "${projectName}" uploaded and build #${upload.buildId} created`
+      `Project "${projectName}" uploaded and build #${buildId} created`
     );
-    await pollBuildStatus(accountId, projectName, upload.buildId);
   } catch (err) {
     if (err.statusCode === 404) {
       return logger.error(
@@ -83,13 +90,16 @@ const uploadProjectFiles = async (accountId, projectName, filePath) => {
       )} project files to ${chalk.bold(accountId)}`,
     });
 
-    logApiErrorInstance(err, {
-      context: new ApiErrorContext({
+    logApiErrorInstance(
+      err,
+      new ApiErrorContext({
         accountId,
         projectName,
-      }),
-    });
+      })
+    );
   }
+
+  return { buildId };
 };
 
 exports.handler = async options => {
@@ -100,10 +110,14 @@ exports.handler = async options => {
 
   trackCommandUsage('project-upload', { projectPath }, accountId);
 
-  const cwd = projectPath ? path.resolve(getCwd(), projectPath) : getCwd();
-  const projectConfig = await getProjectConfig(cwd);
+  const projectDir = projectPath
+    ? path.resolve(getCwd(), projectPath)
+    : getCwd();
+  const projectConfig = await getProjectConfig(projectDir);
 
-  validateProjectConfig(projectConfig);
+  validateProjectConfig(projectConfig, projectDir);
+
+  await ensureProjectExists(accountId, projectConfig.name);
 
   const tempFile = tmp.fileSync({ postfix: '.zip' });
 
@@ -115,7 +129,64 @@ exports.handler = async options => {
   output.on('close', async function() {
     logger.debug(`Project files compressed: ${archive.pointer()} bytes`);
 
-    await uploadProjectFiles(accountId, projectConfig.name, tempFile.name);
+    const { buildId } = await uploadProjectFiles(
+      accountId,
+      projectConfig.name,
+      tempFile.name
+    );
+
+    const {
+      isAutoDeployEnabled,
+      deployStatusTaskLocator,
+      status,
+      subbuildStatuses,
+    } = await pollBuildStatus(accountId, projectConfig.name, buildId);
+
+    if (status === 'FAILURE') {
+      const failedSubbuilds = subbuildStatuses.filter(
+        subbuild => subbuild.status === 'FAILURE'
+      );
+
+      logger.log('-'.repeat(50));
+      logger.log(
+        `Build #${buildId} failed because there was a problem\nbuilding ${
+          failedSubbuilds.length === 1
+            ? failedSubbuilds[0].buildName
+            : failedSubbuilds.length + ' components'
+        }\n`
+      );
+      logger.log('See below for a summary of errors.');
+      logger.log('-'.repeat(50));
+
+      failedSubbuilds.forEach(subbuild => {
+        logger.log(
+          `\n--- ${subbuild.buildName} failed to build with the following error ---`
+        );
+        logger.error(subbuild.errorMessage);
+      });
+
+      return;
+    }
+
+    if (isAutoDeployEnabled && deployStatusTaskLocator) {
+      logger.log(
+        `Build #${buildId} succeeded. ${chalk.bold(
+          'Automatically deploying'
+        )} to ${accountId}`
+      );
+      await pollDeployStatus(
+        accountId,
+        projectConfig.name,
+        deployStatusTaskLocator.id,
+        buildId
+      );
+    } else {
+      logger.log('-'.repeat(50));
+      logger.log(chalk.bold(`Build #${buildId} succeeded\n`));
+      logger.log('🚀 Ready to take your project live?');
+      logger.log(`Run \`${chalk.hex('f5c26b')('hs project deploy')}\``);
+      logger.log('-'.repeat(50));
+    }
 
     try {
       tempFile.removeCallback();
@@ -131,8 +202,10 @@ exports.handler = async options => {
 
   archive.pipe(output);
 
-  archive.directory(path.resolve(cwd, projectConfig.srcDir), false, file =>
-    shouldIgnoreFile(file.name) ? false : file
+  archive.directory(
+    path.resolve(projectDir, projectConfig.srcDir),
+    false,
+    file => (shouldIgnoreFile(file.name) ? false : file)
   );
 
   archive.finalize();

package/commands/project.js

@@ -6,6 +6,7 @@ const {
 const deploy = require('./project/deploy');
 const init = require('./project/init');
 const upload = require('./project/upload');
+const logs = require('./project/logs');
 
 exports.command = 'project';
 exports.describe = false; //'Commands for working with projects';
@@ -19,6 +20,7 @@ exports.builder = yargs => {
   yargs.command(deploy).demandCommand(1, '');
   yargs.command(init).demandCommand(0, '');
   yargs.command(upload).demandCommand(0, '');
+  yargs.command(logs).demandCommand(1, '');
 
   return yargs;
 };

package/lib/__tests__/serverlessLogs.js

@@ -11,15 +11,15 @@ const ACCOUNT_ID = 123;
 describe('@hubspot/cli/lib/serverlessLogs', () => {
   describe('tailLogs()', () => {
     let stdinMock;
-    let spinner;
+    let spinnies;
 
     beforeEach(() => {
       jest.spyOn(process, 'exit').mockImplementation(() => {});
       stdinMock = mockStdIn.stdin();
-      spinner = {
-        start: jest.fn(),
-        stop: jest.fn(),
-        clear: jest.fn(),
+      spinnies = {
+        succeed: jest.fn(),
+        fail: jest.fn(),
+        stopAll: jest.fn(),
       };
     });
 
@@ -56,7 +56,7 @@ describe('@hubspot/cli/lib/serverlessLogs', () => {
       await tailLogs({
         accountId: ACCOUNT_ID,
         compact,
-        spinner,
+        spinnies,
         fetchLatest,
         tailCall,
       });
@@ -114,7 +114,7 @@ describe('@hubspot/cli/lib/serverlessLogs', () => {
       await tailLogs({
         accountId: ACCOUNT_ID,
         compact,
-        spinner,
+        spinnies,
         fetchLatest,
         tailCall,
       });
@@ -123,7 +123,6 @@ describe('@hubspot/cli/lib/serverlessLogs', () => {
         latestLogResponse,
         expect.objectContaining({ compact })
       );
-      expect(spinner.clear).toHaveBeenCalled();
       expect(tailCall).toHaveBeenCalledTimes(2);
     });
     it('handles no logs', async () => {
@@ -147,7 +146,7 @@ describe('@hubspot/cli/lib/serverlessLogs', () => {
       await tailLogs({
         accountId: ACCOUNT_ID,
         compact,
-        spinner,
+        spinnies,
         fetchLatest,
         tailCall,
       });

package/lib/links.js

@@ -1,3 +1,4 @@
+const supportsHyperlinks = require('supports-hyperlinks');
 const { getEnv } = require('@hubspot/cli-lib/lib/config');
 const { ENVIRONMENTS } = require('@hubspot/cli-lib/lib/constants');
 const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
@@ -120,9 +121,18 @@ const openLink = (accountId, shortcut) => {
   logger.success(`We opened ${match.url} in your browser`);
 };
 
+const link = (linkText, url) => {
+  if (supportsHyperlinks.stdout) {
+    return ['\u001B]8;;', url, '\u0007', linkText, '\u001B]8;;\u0007'].join('');
+  } else {
+    return `${linkText}: ${url}`;
+  }
+};
+
 module.exports = {
   getSiteLinks,
   getSiteLinksAsArray,
   logSiteLinks,
   openLink,
+  link,
 };

package/lib/projects.js

@@ -11,15 +11,43 @@ const { getHubSpotWebsiteOrigin } = require('@hubspot/cli-lib/lib/urls');
 const {
   ENVIRONMENTS,
   POLLING_DELAY,
-  PROJECT_BUILD_STATUS,
-  PROJECT_BUILD_STATUS_TEXT,
+  PROJECT_OVERALL_STATUS,
+  PROJECT_TEXT,
 } = require('@hubspot/cli-lib/lib/constants');
-const { getBuildStatus } = require('@hubspot/cli-lib/api/dfs');
+const {
+  getBuildStatus,
+  getDeployStatus,
+  fetchProject,
+  createProject,
+} = require('@hubspot/cli-lib/api/dfs');
+const {
+  logApiErrorInstance,
+  ApiErrorContext,
+} = require('@hubspot/cli-lib/errorHandlers');
 
-const isBuildComplete = build => {
+const PROJECT_STRINGS = {
+  BUILD: {
+    INITIALIZE: (name, numOfComponents) =>
+      `Building ${chalk.bold(
+        name
+      )}\n\nFound ${numOfComponents} components in this project ...\n`,
+    SUCCESS: name => `Built ${chalk.bold(name)}`,
+    FAIL: name => `Failed to build ${chalk.bold(name)}`,
+  },
+  DEPLOY: {
+    INITIALIZE: (name, numOfComponents) =>
+      `Deploying ${chalk.bold(
+        name
+      )}\n\nFound ${numOfComponents} components in this project ...\n`,
+    SUCCESS: name => `Deployed ${chalk.bold(name)}`,
+    FAIL: name => `Failed to deploy ${chalk.bold(name)}`,
+  },
+};
+
+const isTaskComplete = task => {
   return (
-    build.status === PROJECT_BUILD_STATUS.SUCCESS ||
-    build.status === PROJECT_BUILD_STATUS.FAILURE
+    task.status === PROJECT_OVERALL_STATUS.SUCCESS ||
+    task.status === PROJECT_OVERALL_STATUS.FAILURE
   );
 };
 
@@ -86,7 +114,7 @@ const getOrCreateProjectConfig = async projectPath => {
   return projectConfig;
 };
 
-const validateProjectConfig = projectConfig => {
+const validateProjectConfig = (projectConfig, projectDir) => {
   if (!projectConfig) {
     logger.error(
       `Project config not found. Try running 'hs project init' first.`
@@ -101,7 +129,7 @@ const validateProjectConfig = projectConfig => {
     process.exit(1);
   }
 
-  if (!fs.existsSync(projectConfig.srcDir)) {
+  if (!fs.existsSync(path.resolve(projectDir, projectConfig.srcDir))) {
     logger.error(
       `Project source directory '${projectConfig.srcDir}' does not exist.`
     );
@@ -109,6 +137,37 @@ const validateProjectConfig = projectConfig => {
   }
 };
 
+const ensureProjectExists = async (accountId, projectName) => {
+  try {
+    await fetchProject(accountId, projectName);
+  } catch (err) {
+    if (err.statusCode === 404) {
+      const { shouldCreateProject } = await prompt([
+        {
+          name: 'shouldCreateProject',
+          message: `The project ${projectName} does not exist in ${accountId}. Would you like to create it?`,
+          type: 'confirm',
+        },
+      ]);
+
+      if (shouldCreateProject) {
+        try {
+          return createProject(accountId, projectName);
+        } catch (err) {
+          return logApiErrorInstance(err, new ApiErrorContext({ accountId }));
+        }
+      } else {
+        return logger.log(
+          `Your project ${chalk.bold(
+            projectName
+          )} could not be found in ${chalk.bold(accountId)}.`
+        );
+      }
+    }
+    logApiErrorInstance(err, new ApiErrorContext({ accountId }));
+  }
+};
+
 const getProjectDetailUrl = (projectName, accountId) => {
   if (!projectName) return;
 
@@ -146,86 +205,107 @@ const showWelcomeMessage = (projectName, accountId) => {
   );
 };
 
-const pollBuildStatus = async (accountId, name, buildId) => {
-  const buildStatus = await getBuildStatus(accountId, name, buildId);
-  const spinnies = new Spinnies();
+const makeGetTaskStatus = taskType => {
+  let statusFn, statusText, statusStrings;
+  switch (taskType) {
+    case 'build':
+      statusFn = getBuildStatus;
+      statusText = PROJECT_TEXT.BUILD;
+      statusStrings = PROJECT_STRINGS.BUILD;
+      break;
+    case 'deploy':
+      statusFn = getDeployStatus;
+      statusText = PROJECT_TEXT.DEPLOY;
+      statusStrings = PROJECT_STRINGS.DEPLOY;
+      break;
+    default:
+      logger.error(`Cannot get status for task type ${taskType}`);
+  }
 
-  logger.log();
-  logger.log(`Building ${chalk.bold(name)}`);
-  logger.log();
-  logger.log(`Found ${buildStatus.subbuildStatuses.length} deployables ...`);
-  logger.log();
+  return async (accountId, taskName, taskId) => {
+    const spinnies = new Spinnies({
+      succeedColor: 'white',
+      failColor: 'white',
+    });
+
+    spinnies.add('overallTaskStatus', { text: 'Beginning' });
 
-  for (let subBuild of buildStatus.subbuildStatuses) {
-    spinnies.add(subBuild.buildName, {
-      text: `${chalk.bold(subBuild.buildName)} #${buildId} ${
-        PROJECT_BUILD_STATUS_TEXT[PROJECT_BUILD_STATUS.ENQUEUED]
-      }`,
+    const initialTaskStatus = await statusFn(accountId, taskName, taskId);
+
+    spinnies.update('overallTaskStatus', {
+      text: statusStrings.INITIALIZE(
+        taskName,
+        initialTaskStatus[statusText.SUBTASK_KEY].length
+      ),
     });
-  }
 
-  return new Promise((resolve, reject) => {
-    const pollInterval = setInterval(async () => {
-      const buildStatus = await getBuildStatus(accountId, name, buildId).catch(
-        reject
-      );
-      const { status, subbuildStatuses } = buildStatus;
-
-      if (Object.keys(spinnies.spinners).length) {
-        subbuildStatuses.forEach(subBuild => {
-          const updatedText = `${chalk.bold(subBuild.buildName)} #${buildId} ${
-            PROJECT_BUILD_STATUS_TEXT[subBuild.status]
-          }`;
-
-          switch (subBuild.status) {
-            case PROJECT_BUILD_STATUS.SUCCESS:
-              spinnies.succeed(subBuild.buildName, {
-                text: updatedText,
-              });
-              break;
-            case PROJECT_BUILD_STATUS.FAILURE:
-              spinnies.fail(subBuild.buildName, {
-                text: updatedText,
-              });
-              break;
-            default:
-              spinnies.update(subBuild.buildName, {
-                text: updatedText,
-              });
-              break;
-          }
-        });
-      }
+    for (let subTask of initialTaskStatus[statusText.SUBTASK_KEY]) {
+      spinnies.add(subTask[statusText.SUBTASK_NAME_KEY], {
+        text: `${chalk.bold(subTask[statusText.SUBTASK_NAME_KEY])} #${taskId} ${
+          statusText.STATUS_TEXT[statusText.STATES.ENQUEUED]
+        }\n`,
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      const pollInterval = setInterval(async () => {
+        const taskStatus = await statusFn(accountId, taskName, taskId).catch(
+          reject
+        );
+
+        const { status, [statusText.SUBTASK_KEY]: subTaskStatus } = taskStatus;
+
+        if (spinnies.hasActiveSpinners()) {
+          subTaskStatus.forEach(subTask => {
+            if (!spinnies.pick(subTask[statusText.SUBTASK_NAME_KEY])) {
+              return;
+            }
+
+            const updatedText = `${chalk.bold(
+              subTask[statusText.SUBTASK_NAME_KEY]
+            )} #${taskId} ${statusText.STATUS_TEXT[subTask.status]}\n`;
 
-      if (isBuildComplete(buildStatus)) {
-        clearInterval(pollInterval);
-
-        if (status === PROJECT_BUILD_STATUS.SUCCESS) {
-          logger.success(
-            `Your project ${chalk.bold(name)} ${
-              PROJECT_BUILD_STATUS_TEXT[status]
-            }.`
-          );
-        } else if (status === PROJECT_BUILD_STATUS.FAILURE) {
-          logger.error(
-            `Your project ${chalk.bold(name)} ${
-              PROJECT_BUILD_STATUS_TEXT[status]
-            }.`
-          );
-          subbuildStatuses.forEach(subBuild => {
-            if (subBuild.status === PROJECT_BUILD_STATUS.FAILURE) {
-              logger.error(
-                `${chalk.bold(subBuild.buildName)} failed to build. ${
-                  subBuild.errorMessage
-                }.`
-              );
+            switch (subTask.status) {
+              case statusText.STATES.SUCCESS:
+                spinnies.succeed(subTask[statusText.SUBTASK_NAME_KEY], {
+                  text: updatedText,
+                });
+                break;
+              case statusText.STATES.FAILURE:
+                spinnies.fail(subTask.buildName, {
+                  text: updatedText,
+                });
+                break;
+              default:
+                spinnies.update(subTask.buildName, {
+                  text: updatedText,
+                });
+                break;
             }
           });
+
+          if (isTaskComplete(taskStatus)) {
+            subTaskStatus.forEach(subBuild => {
+              spinnies.remove(subBuild[statusText.SUBTASK_NAME_KEY]);
+            });
+
+            if (status === statusText.STATES.SUCCESS) {
+              spinnies.succeed('overallTaskStatus', {
+                text: statusStrings.SUCCESS(taskName),
+              });
+            } else if (status === statusText.STATES.FAILURE) {
+              spinnies.fail('overallTaskStatus', {
+                text: statusStrings.FAIL(taskName),
+              });
+            }
+
+            clearInterval(pollInterval);
+            resolve(taskStatus);
+          }
         }
-        resolve(buildStatus);
-      }
-    }, POLLING_DELAY);
-  });
+      }, POLLING_DELAY);
+    });
+  };
 };
 
 module.exports = {
@@ -234,5 +314,7 @@ module.exports = {
   getOrCreateProjectConfig,
   validateProjectConfig,
   showWelcomeMessage,
-  pollBuildStatus,
+  pollBuildStatus: makeGetTaskStatus('build'),
+  pollDeployStatus: makeGetTaskStatus('deploy'),
+  ensureProjectExists,
 };

package/lib/serverlessLogs.js

@@ -17,7 +17,7 @@ const handleKeypressToExit = exit => {
   process.stdin.setRawMode(true);
   process.stdin.on('keypress', (str, key) => {
     if (key && ((key.ctrl && key.name == 'c') || key.name === 'escape')) {
-      exit();
+      exit(key.name === 'escape' ? 'esc' : 'ctrl+c');
     }
   });
 };
@@ -25,14 +25,12 @@ const handleKeypressToExit = exit => {
 const tailLogs = async ({
   accountId,
   compact,
-  spinner,
+  spinnies,
   fetchLatest,
   tailCall,
 }) => {
   let initialAfter;
 
-  spinner.start();
-
   try {
     const latestLog = await fetchLatest();
     initialAfter = base64EncodeString(latestLog.id);
@@ -54,8 +52,7 @@ const tailLogs = async ({
       latestLog = await tailCall(after);
       nextAfter = latestLog.paging.next.after;
     } catch (e) {
-      logger.info('Stopped polling due to error.');
-      spinner.clear();
+      spinnies.fail('tailLogs', { text: 'Stopped polling due to error.' });
       if (e.statusCode !== 404) {
         logApiErrorInstance(
           e,
@@ -68,7 +65,6 @@ const tailLogs = async ({
     }
 
     if (latestLog && latestLog.results.length) {
-      spinner.clear();
       outputLogs(latestLog, {
         compact,
       });
@@ -79,8 +75,10 @@ const tailLogs = async ({
     }, TAIL_DELAY);
   };
 
-  handleKeypressToExit(() => {
-    spinner.stop();
+  handleKeypressToExit(exitKey => {
+    spinnies.succeed('tailLogs', {
+      text: `Stopped polling because "${exitKey}" was pressed.`,
+    });
     process.exit();
   });
   await tail(initialAfter);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hubspot/cli",
-  "version": "3.0.9-beta.1",
+  "version": "3.0.10-beta.1",
   "description": "CLI for working with HubSpot",
   "license": "Apache-2.0",
   "repository": {
@@ -8,8 +8,8 @@
     "url": "https://github.com/HubSpot/hubspot-cms-tools"
   },
   "dependencies": {
-    "@hubspot/cli-lib": "^3.0.9-beta.1",
-    "@hubspot/serverless-dev-runtime": "^3.0.9-beta.1",
+    "@hubspot/cli-lib": "^3.0.10-beta.1",
+    "@hubspot/serverless-dev-runtime": "^3.0.10-beta.1",
     "archiver": "^5.3.0",
     "chalk": "^4.1.0",
     "express": "^4.17.1",
@@ -20,6 +20,7 @@
     "ora": "^4.0.3",
     "shelljs": "0.8.3",
     "spinnies": "^0.5.1",
+    "supports-hyperlinks": "^2.2.0",
     "tmp": "^0.2.1",
     "update-notifier": "3.0.1",
     "yargs": "15.4.1"
@@ -37,5 +38,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "51d04fddb68545a0bc89fc9eddbed89afe831ef5"
+  "gitHead": "d3426a88d8355cdae053f02853a535c09ba84a7b"
 }