netlify-cli 8.0.7 → 8.1.0-rc

package/src/commands/{deploy.js → deploy/deploy.js}

@@ -1,30 +1,40 @@
-const path = require('path')
-const process = require('process')
+// @ts-check
+const { stat } = require('fs').promises
+const { basename, resolve } = require('path')
+const { cwd, env } = require('process')
 
 const { restoreConfig, updateConfig } = require('@netlify/config')
-const { flags: flagsLib } = require('@oclif/command')
-const chalk = require('chalk')
 const { get } = require('dot-prop')
 const inquirer = require('inquirer')
 const isObject = require('lodash/isObject')
 const prettyjson = require('prettyjson')
 
-const { cancelDeploy } = require('../lib/api')
-const { getBuildOptions, runBuild } = require('../lib/build')
-const { statAsync } = require('../lib/fs')
-const { normalizeFunctionsConfig } = require('../lib/functions/config')
-const { getLogMessage } = require('../lib/log')
-const { startSpinner, stopSpinner } = require('../lib/spinner')
-const Command = require('../utils/command')
-const { error, exit, getToken, log, logJson, warn } = require('../utils/command-helpers')
-const { deploySite } = require('../utils/deploy/deploy-site')
-const { deployEdgeHandlers } = require('../utils/edge-handlers')
-const { getFunctionsManifestPath, getInternalFunctionsDir } = require('../utils/functions')
-const { NETLIFYDEV, NETLIFYDEVERR, NETLIFYDEVLOG } = require('../utils/logo')
-const { openBrowser } = require('../utils/open-browser')
-
-const LinkCommand = require('./link')
-const SitesCreateCommand = require('./sites/create')
+const { cancelDeploy } = require('../../lib/api')
+const { getBuildOptions, runBuild } = require('../../lib/build')
+const { normalizeFunctionsConfig } = require('../../lib/functions/config')
+const { getLogMessage } = require('../../lib/log')
+const { startSpinner, stopSpinner } = require('../../lib/spinner')
+const {
+  NETLIFYDEV,
+  NETLIFYDEVERR,
+  NETLIFYDEVLOG,
+  chalk,
+  deployEdgeHandlers,
+  deploySite,
+  error,
+  exit,
+  generateDescriptionHelp,
+  generateExamplesHelp,
+  getFunctionsManifestPath,
+  getInternalFunctionsDir,
+  getToken,
+  log,
+  logJson,
+  openBrowser,
+  warn,
+} = require('../../utils')
+const { link } = require('../link')
+const { sitesCreate } = require('../sites')
 
 const DEFAULT_DEPLOY_TIMEOUT = 1.2e6
 
@@ -43,26 +53,35 @@ const triggerDeploy = async ({ api, siteData, siteId }) => {
   }
 }
 
-const getDeployFolder = async ({ config, flags, site, siteData }) => {
+/**
+ * g
+ * @param {object} config
+ * @param {object} config.config
+ * @param {import('commander').OptionValues} config.options
+ * @param {object} config.site
+ * @param {object} config.siteData
+ * @returns {Promise<string>}
+ */
+const getDeployFolder = async ({ config, options, site, siteData }) => {
   let deployFolder
-  if (flags.dir) {
-    deployFolder = path.resolve(process.cwd(), flags.dir)
+  if (options.dir) {
+    deployFolder = resolve(cwd(), options.dir)
   } else if (get(config, 'build.publish')) {
-    deployFolder = path.resolve(site.root, get(config, 'build.publish'))
+    deployFolder = resolve(site.root, get(config, 'build.publish'))
   } else if (get(siteData, 'build_settings.dir')) {
-    deployFolder = path.resolve(site.root, get(siteData, 'build_settings.dir'))
+    deployFolder = resolve(site.root, get(siteData, 'build_settings.dir'))
   }
 
   if (!deployFolder) {
     log('Please provide a publish directory (e.g. "public" or "dist" or "."):')
-    log(process.cwd())
+    log(cwd())
     const { promptPath } = await inquirer.prompt([
       {
         type: 'input',
         name: 'promptPath',
         message: 'Publish directory',
         default: '.',
-        filter: (input) => path.resolve(process.cwd(), input),
+        filter: (input) => resolve(cwd(), input),
       },
     ])
     deployFolder = promptPath
@@ -72,9 +91,10 @@ const getDeployFolder = async ({ config, flags, site, siteData }) => {
 }
 
 const validateDeployFolder = async ({ deployFolder }) => {
-  let stat
+  /** @type {import('fs').Stats} */
+  let stats
   try {
-    stat = await statAsync(deployFolder)
+    stats = await stat(deployFolder)
   } catch (error_) {
     if (error_.code === 'ENOENT') {
       return error(`No such directory ${deployFolder}! Did you forget to run a build?`)
@@ -87,33 +107,43 @@ const validateDeployFolder = async ({ deployFolder }) => {
     throw error_
   }
 
-  if (!stat.isDirectory()) {
+  if (!stats.isDirectory()) {
     return error('Deploy target must be a path to a directory')
   }
-  return stat
+  return stats
 }
 
-const getFunctionsFolder = ({ config, flags, site, siteData }) => {
+/**
+ * get the functions directory
+ * @param {object} config
+ * @param {object} config.config
+ * @param {import('commander').OptionValues} config.options
+ * @param {object} config.site
+ * @param {object} config.siteData
+ * @returns {string}
+ */
+const getFunctionsFolder = ({ config, options, site, siteData }) => {
   let functionsFolder
   // Support "functions" and "Functions"
   const funcConfig = config.functionsDirectory
-  if (flags.functions) {
-    functionsFolder = path.resolve(process.cwd(), flags.functions)
+  if (options.functions) {
+    functionsFolder = resolve(cwd(), options.functions)
   } else if (funcConfig) {
-    functionsFolder = path.resolve(site.root, funcConfig)
+    functionsFolder = resolve(site.root, funcConfig)
   } else if (get(siteData, 'build_settings.functions_dir')) {
-    functionsFolder = path.resolve(site.root, get(siteData, 'build_settings.functions_dir'))
+    functionsFolder = resolve(site.root, get(siteData, 'build_settings.functions_dir'))
   }
   return functionsFolder
 }
 
 const validateFunctionsFolder = async ({ functionsFolder }) => {
-  let stat
+  /** @type {import('fs').Stats} */
+  let stats
   if (functionsFolder) {
     // we used to hard error if functions folder is specified but doesn't exist
     // but this was too strict for onboarding. we can just log a warning.
     try {
-      stat = await statAsync(functionsFolder)
+      stats = await stat(functionsFolder)
     } catch (error_) {
       if (error_.code === 'ENOENT') {
         log(
@@ -127,11 +157,11 @@ const validateFunctionsFolder = async ({ functionsFolder }) => {
     }
   }
 
-  if (stat && !stat.isDirectory()) {
+  if (stats && !stats.isDirectory()) {
     error('Functions folder must be a path to a directory')
   }
 
-  return stat
+  return stats
 }
 
 const validateFolders = async ({ deployFolder, functionsFolder }) => {
@@ -154,12 +184,12 @@ const getDeployFilesFilter = ({ deployFolder, site }) => {
       return true
     }
 
-    const basename = path.basename(filename)
+    const base = basename(filename)
     const skipFile =
-      (skipNodeModules && basename === 'node_modules') ||
-      (basename.startsWith('.') && basename !== '.well-known') ||
-      basename.startsWith('__MACOSX') ||
-      basename.includes('/.')
+      (skipNodeModules && base === 'node_modules') ||
+      (base.startsWith('.') && base !== '.well-known') ||
+      base.startsWith('__MACOSX') ||
+      base.includes('/.')
 
     return !skipFile
   }
@@ -226,18 +256,50 @@ const reportDeployError = ({ error_, failAndExit }) => {
   }
 }
 
+const deployProgressCb = function () {
+  /**
+   * @type {Record<string, import('ora').Ora>}
+   */
+  const events = {}
+  return (event) => {
+    switch (event.phase) {
+      case 'start': {
+        events[event.type] = startSpinner({
+          text: event.msg,
+        })
+        return
+      }
+      case 'progress': {
+        const spinner = events[event.type]
+        if (spinner) {
+          spinner.text = event.msg
+        }
+        return
+      }
+      case 'stop':
+      default: {
+        stopSpinner({ spinner: events[event.type], text: event.msg })
+        delete events[event.type]
+      }
+    }
+  }
+}
+
 const runDeploy = async ({
   alias,
   api,
   configPath,
   deployFolder,
+  deployTimeout,
   deployToProduction,
-  flags,
   functionsConfig,
   functionsFolder,
+  silent,
   site,
   siteData,
   siteId,
+  skipFunctionsCache,
+  title,
 }) => {
   let results
   let deployId
@@ -249,11 +311,9 @@ const runDeploy = async ({
     }
 
     const draft = !deployToProduction && !alias
-    const title = flags.message
     results = await api.createSiteDeploy({ siteId, title, body: { draft, branch: alias } })
     deployId = results.id
 
-    const silent = flags.json || flags.silent
     await deployEdgeHandlers({
       site,
       deployId,
@@ -266,15 +326,15 @@ const runDeploy = async ({
     // functions from the rightmost directories. In this case, we want user
     // functions to take precedence over internal functions.
     const functionDirectories = [internalFunctionsFolder, functionsFolder].filter(Boolean)
-    const skipFunctionsCache = flags['skip-functions-cache'] === true
     const manifestPath = skipFunctionsCache ? null : await getFunctionsManifestPath({ base: site.root })
 
+    // @ts-ignore
     results = await deploySite(api, siteId, deployFolder, {
       configPath,
       fnDir: functionDirectories,
       functionsConfig,
       statusCb: silent ? () => {} : deployProgressCb(),
-      deployTimeout: flags.timeout * SEC_TO_MILLISEC || DEFAULT_DEPLOY_TIMEOUT,
+      deployTimeout,
       syncFileLimit: SYNC_FILE_LIMIT,
       // pass an existing deployId to update
       deployId,
@@ -304,24 +364,40 @@ const runDeploy = async ({
   }
 }
 
-const handleBuild = async ({ context, flags }) => {
-  if (!flags.build) {
+/**
+ *
+ * @param {object} config
+ * @param {*} config.cachedConfig
+ * @param {import('commander').OptionValues} config.options The options of the command
+ * @returns
+ */
+const handleBuild = async ({ cachedConfig, options }) => {
+  if (!options.build) {
     return {}
   }
   const [token] = await getToken()
-  const options = await getBuildOptions({
-    context,
+  const resolvedOptions = await getBuildOptions({
+    cachedConfig,
     token,
-    flags,
+    options,
   })
-  const { configMutations, exitCode, newConfig } = await runBuild(options)
+  const { configMutations, exitCode, newConfig } = await runBuild(resolvedOptions)
   if (exitCode !== 0) {
     exit(exitCode)
   }
   return { newConfig, configMutations }
 }
 
-const printResults = ({ deployToProduction, flags, results }) => {
+/**
+ *
+ * @param {object} config
+ * @param {boolean} config.deployToProduction
+ * @param {boolean} config.json If the result should be printed as json message
+ * @param {boolean} config.runBuildCommand If the build command should be run
+ * @param {object} config.results
+ * @returns {void}
+ */
+const printResults = ({ deployToProduction, json, results, runBuildCommand }) => {
   const msgData = {
     Logs: `${results.logsUrl}`,
     'Unique Deploy URL': results.deployUrl,
@@ -338,7 +414,7 @@ const printResults = ({ deployToProduction, flags, results }) => {
   log()
 
   // Json response for piping commands
-  if (flags.json) {
+  if (json) {
     const jsonData = {
       name: results.name,
       site_id: results.site_id,
@@ -359,133 +435,181 @@ const printResults = ({ deployToProduction, flags, results }) => {
     if (!deployToProduction) {
       log()
       log('If everything looks good on your draft URL, deploy it to your main site URL with the --prod flag.')
-      log(`${chalk.cyanBright.bold(`netlify deploy${flags.build ? ' --build' : ''} --prod`)}`)
+      log(`${chalk.cyanBright.bold(`netlify deploy${runBuildCommand ? ' --build' : ''} --prod`)}`)
       log()
     }
   }
 }
 
-class DeployCommand extends Command {
-  async run() {
-    const { flags } = this.parse(DeployCommand)
-    const { api, site } = this.netlify
-    const alias = flags.alias || flags.branch
+/**
+ * The deploy command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const deploy = async (options, command) => {
+  const { api, site } = command.netlify
+  const alias = options.alias || options.branch
 
-    this.setAnalyticsPayload({ open: flags.open, prod: flags.prod, json: flags.json, alias: Boolean(alias) })
+  command.setAnalyticsPayload({ open: options.open, prod: options.prod, json: options.json, alias: Boolean(alias) })
 
-    if (flags.branch) {
-      warn('--branch flag has been renamed to --alias and will be removed in future versions')
-    }
+  if (options.branch) {
+    warn('--branch flag has been renamed to --alias and will be removed in future versions')
+  }
 
-    await this.authenticate(flags.auth)
-
-    let siteId = flags.site || site.id
-    let siteData = {}
-    if (siteId) {
-      try {
-        siteData = await api.getSite({ siteId })
-      } catch (error_) {
-        // TODO specifically handle known cases (e.g. no account access)
-        if (error_.status === 404) {
-          error('Site not found')
-        } else {
-          error(error_.message)
-        }
-      }
-    } else {
-      log("This folder isn't linked to a site yet")
-      const NEW_SITE = '+  Create & configure a new site'
-      const EXISTING_SITE = 'Link this directory to an existing site'
-
-      const initializeOpts = [EXISTING_SITE, NEW_SITE]
-
-      const { initChoice } = await inquirer.prompt([
-        {
-          type: 'list',
-          name: 'initChoice',
-          message: 'What would you like to do?',
-          choices: initializeOpts,
-        },
-      ])
-      // create site or search for one
-      if (initChoice === NEW_SITE) {
-        // run site:create command
-        siteData = await SitesCreateCommand.run([])
-        site.id = siteData.id
-        siteId = site.id
-      } else if (initChoice === EXISTING_SITE) {
-        // run link command
-        siteData = await LinkCommand.run([], false)
-        site.id = siteData.id
-        siteId = site.id
+  await command.authenticate(options.auth)
+
+  let siteId = options.site || site.id
+  let siteData = {}
+  if (siteId) {
+    try {
+      siteData = await api.getSite({ siteId })
+    } catch (error_) {
+      // TODO specifically handle known cases (e.g. no account access)
+      if (error_.status === 404) {
+        error('Site not found')
+      } else {
+        error(error_.message)
       }
     }
+  } else {
+    log("This folder isn't linked to a site yet")
+    const NEW_SITE = '+  Create & configure a new site'
+    const EXISTING_SITE = 'Link this directory to an existing site'
 
-    const deployToProduction = flags.prod || (flags.prodIfUnlocked && !siteData.published_deploy.locked)
+    const initializeOpts = [EXISTING_SITE, NEW_SITE]
 
-    if (flags.trigger) {
-      return triggerDeploy({ api, siteId, siteData })
+    const { initChoice } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'initChoice',
+        message: 'What would you like to do?',
+        choices: initializeOpts,
+      },
+    ])
+    // create site or search for one
+    if (initChoice === NEW_SITE) {
+      siteData = await sitesCreate({}, command)
+      site.id = siteData.id
+      siteId = site.id
+    } else if (initChoice === EXISTING_SITE) {
+      siteData = await link({}, command)
+      site.id = siteData.id
+      siteId = site.id
     }
+  }
 
-    const { newConfig, configMutations = [] } = await handleBuild({ context: this, flags })
-    const config = newConfig || this.netlify.config
-
-    const deployFolder = await getDeployFolder({ flags, config, site, siteData })
-    const functionsFolder = getFunctionsFolder({ flags, config, site, siteData })
-    const { configPath } = site
-
-    log(
-      prettyjson.render({
-        'Deploy path': deployFolder,
-        'Functions path': functionsFolder,
-        'Configuration path': configPath,
-      }),
-    )
+  const deployToProduction = options.prod || (options.prodIfUnlocked && !siteData.published_deploy.locked)
 
-    const { functionsFolderStat } = await validateFolders({
-      deployFolder,
-      functionsFolder,
-    })
-    const functionsConfig = normalizeFunctionsConfig({ functionsConfig: config.functions, projectRoot: site.root })
+  if (options.trigger) {
+    return triggerDeploy({ api, siteId, siteData })
+  }
 
-    const redirectsPath = `${deployFolder}/_redirects`
-    await updateConfig(configMutations, {
-      buildDir: deployFolder,
-      configPath,
-      redirectsPath,
-      context: this.netlify.cachedConfig.context,
-      branch: this.netlify.cachedConfig.branch,
-    })
-    const results = await runDeploy({
-      flags,
-      deployToProduction,
-      site,
-      siteData,
-      api,
-      siteId,
-      deployFolder,
-      functionsConfig,
-      configPath,
-      // pass undefined functionsFolder if doesn't exist
-      functionsFolder: functionsFolderStat && functionsFolder,
-      alias,
-    })
+  const { newConfig, configMutations = [] } = await handleBuild({
+    cachedConfig: command.netlify.cachedConfig,
+    options,
+  })
+  const config = newConfig || command.netlify.config
+
+  const deployFolder = await getDeployFolder({ options, config, site, siteData })
+  const functionsFolder = getFunctionsFolder({ options, config, site, siteData })
+  const { configPath } = site
+
+  log(
+    prettyjson.render({
+      'Deploy path': deployFolder,
+      'Functions path': functionsFolder,
+      'Configuration path': configPath,
+    }),
+  )
+
+  const { functionsFolderStat } = await validateFolders({
+    deployFolder,
+    functionsFolder,
+  })
+  const functionsConfig = normalizeFunctionsConfig({ functionsConfig: config.functions, projectRoot: site.root })
+
+  const redirectsPath = `${deployFolder}/_redirects`
+  // @ts-ignore
+  await updateConfig(configMutations, {
+    buildDir: deployFolder,
+    configPath,
+    redirectsPath,
+    context: command.netlify.cachedConfig.context,
+    branch: command.netlify.cachedConfig.branch,
+  })
+  const results = await runDeploy({
+    alias,
+    api,
+    configPath,
+    deployFolder,
+    deployTimeout: options.timeout * SEC_TO_MILLISEC || DEFAULT_DEPLOY_TIMEOUT,
+    deployToProduction,
+    functionsConfig,
+    // pass undefined functionsFolder if doesn't exist
+    functionsFolder: functionsFolderStat && functionsFolder,
+    silent: options.json || options.silent,
+    site,
+    siteData,
+    siteId,
+    skipFunctionsCache: options.skipFunctionsCache,
+    title: options.message,
+  })
 
-    await restoreConfig(configMutations, { buildDir: deployFolder, configPath, redirectsPath })
+  // @ts-ignore
+  await restoreConfig(configMutations, { buildDir: deployFolder, configPath, redirectsPath })
 
-    printResults({ flags, results, deployToProduction })
+  printResults({
+    runBuildCommand: options.build,
+    json: options.json,
+    results,
+    deployToProduction,
+  })
 
-    if (flags.open) {
-      const urlToOpen = deployToProduction ? results.siteUrl : results.deployUrl
-      await openBrowser({ url: urlToOpen })
-      exit()
-    }
+  if (options.open) {
+    const urlToOpen = deployToProduction ? results.siteUrl : results.deployUrl
+    await openBrowser({ url: urlToOpen })
+    exit()
   }
 }
 
-DeployCommand.description = `Create a new deploy from the contents of a folder
-
-Deploys from the build settings found in the netlify.toml file, or settings from the API.
+/**
+ * Creates the `netlify deploy` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createDeployCommand = (program) =>
+  program
+    .command('deploy')
+    .description('Create a new deploy from the contents of a folder')
+    .option('-d, --dir <path>', 'Specify a folder to deploy')
+    .option('-f, --functions', 'Specify a functions folder to deploy')
+    .option('-p, --prod', 'Deploy to production', false)
+    .option('--prodIfUnlocked', 'Deploy to production if unlocked, create a draft otherwise', false)
+    .option(
+      '--alias <name>',
+      'Specifies the alias for deployment, the string at the beginning of the deploy subdomain. Useful for creating predictable deployment URLs. Avoid setting an alias string to the same value as a deployed branch. `alias` doesn’t create a branch deploy and can’t be used in conjunction with the branch subdomain feature. Maximum 37 characters.',
+    )
+    .option(
+      '-b, --branch <name>',
+      'Serves the same functionality as --alias. Deprecated and will be removed in future versions',
+    )
+    .option('-o, --open', 'Open site after deploy', false)
+    .option('-m, --message <message>', 'A short message to include in the deploy log')
+    .option('-a, --auth <token>', 'Netlify auth token to deploy with', env.NETLIFY_AUTH_TOKEN)
+    .option('-s, --site <id>', 'A site ID to deploy to', env.NETLIFY_SITE_ID)
+    .option('--json', 'Output deployment data as JSON')
+    .option('--timeout <number>', 'Timeout to wait for deployment to finish', (value) => Number.parseInt(value))
+    .option('--trigger', 'Trigger a new build of your site on Netlify without uploading local files')
+    .option('--build', 'Run build command before deploying')
+    .option(
+      '--skip-functions-cache',
+      'Ignore any functions created as part of a previous `build` or `deploy` commands, forcing them to be bundled again as part of the deployment',
+      false,
+    )
+    .addHelpText(
+      'after',
+      generateDescriptionHelp(
+        `Deploys from the build settings found in the netlify.toml file, or settings from the API.
 
 The following environment variables can be used to override configuration file lookups and prompts:
 
@@ -547,121 +671,25 @@ Function entry points are determined by the file name and name of the folder the
 functions/
 ├── aFolderlessFunctionEntrypoint.js
 └── functionName/
-    ├── notTheEntryPoint.js
-    └── functionName.js
+  ├── notTheEntryPoint.js
+  └── functionName.js
 \`\`\`
 
-Support for package.json's main field, and intrinsic index.js entrypoints are coming soon.
-`
-
-DeployCommand.examples = [
-  'netlify deploy',
-  'netlify deploy --prod',
-  'netlify deploy --prod --open',
-  'netlify deploy --prodIfUnlocked',
-  'netlify deploy --message "A message with an $ENV_VAR"',
-  'netlify deploy --auth $NETLIFY_AUTH_TOKEN',
-  'netlify deploy --trigger',
-]
-
-DeployCommand.flags = {
-  dir: flagsLib.string({
-    char: 'd',
-    description: 'Specify a folder to deploy',
-  }),
-  functions: flagsLib.string({
-    char: 'f',
-    description: 'Specify a functions folder to deploy',
-  }),
-  prod: flagsLib.boolean({
-    char: 'p',
-    description: 'Deploy to production',
-    default: false,
-    exclusive: ['alias', 'branch', 'prodIfUnlocked'],
-  }),
-  prodIfUnlocked: flagsLib.boolean({
-    description: 'Deploy to production if unlocked, create a draft otherwise',
-    default: false,
-    exclusive: ['alias', 'branch', 'prod'],
-  }),
-  alias: flagsLib.string({
-    description:
-      'Specifies the alias for deployment, the string at the beginning of the deploy subdomain. Useful for creating predictable deployment URLs. Avoid setting an alias string to the same value as a deployed branch. `alias` doesn’t create a branch deploy and can’t be used in conjunction with the branch subdomain feature. Maximum 37 characters.',
-  }),
-  branch: flagsLib.string({
-    char: 'b',
-    description: 'Serves the same functionality as --alias. Deprecated and will be removed in future versions',
-  }),
-  open: flagsLib.boolean({
-    char: 'o',
-    description: 'Open site after deploy',
-    default: false,
-  }),
-  message: flagsLib.string({
-    char: 'm',
-    description: 'A short message to include in the deploy log',
-  }),
-  auth: flagsLib.string({
-    char: 'a',
-    description: 'Netlify auth token to deploy with',
-    env: 'NETLIFY_AUTH_TOKEN',
-  }),
-  site: flagsLib.string({
-    char: 's',
-    description: 'A site ID to deploy to',
-    env: 'NETLIFY_SITE_ID',
-  }),
-  json: flagsLib.boolean({
-    description: 'Output deployment data as JSON',
-  }),
-  timeout: flagsLib.integer({
-    description: 'Timeout to wait for deployment to finish',
-  }),
-  trigger: flagsLib.boolean({
-    description: 'Trigger a new build of your site on Netlify without uploading local files',
-    exclusive: ['build'],
-  }),
-  build: flagsLib.boolean({
-    description: 'Run build command before deploying',
-  }),
-  'skip-functions-cache': flagsLib.boolean({
-    description:
-      'Ignore any functions created as part of a previous `build` or `deploy` commands, forcing them to be bundled again as part of the deployment',
-    default: false,
-  }),
-  ...DeployCommand.flags,
-}
-
-const deployProgressCb = function () {
-  const events = {}
-  // event: {
-  //         type: name-of-step
-  //         msg: msg to print
-  //         phase: [start, progress, stop]
-  // }
-  //
-  return (event) => {
-    switch (event.phase) {
-      case 'start': {
-        events[event.type] = startSpinner({
-          text: event.msg,
-        })
-        return
-      }
-      case 'progress': {
-        const spinner = events[event.type]
-        if (spinner) {
-          spinner.text = event.msg
-        }
-        return
-      }
-      case 'stop':
-      default: {
-        stopSpinner({ spinner: events[event.type], text: event.msg })
-        delete events[event.type]
-      }
-    }
-  }
-}
+Support for package.json's main field, and intrinsic index.js entrypoints are coming soon.`,
+      ),
+    )
+    .addHelpText(
+      'after',
+      generateExamplesHelp([
+        'netlify deploy',
+        'netlify deploy --prod',
+        'netlify deploy --prod --open',
+        'netlify deploy --prodIfUnlocked',
+        'netlify deploy --message "A message with an $ENV_VAR"',
+        'netlify deploy --auth $NETLIFY_AUTH_TOKEN',
+        'netlify deploy --trigger',
+      ]),
+    )
+    .action(deploy)
 
-module.exports = DeployCommand
+module.exports = { createDeployCommand }