netlify-cli 8.0.7 → 8.1.0-rc

package/src/commands/lm/lm.js

@@ -0,0 +1,39 @@
+// @ts-check
+
+const { generateCommandsHelp, generateDescriptionHelp, generateExamplesHelp } = require('../../utils')
+
+const { createLmInfoCommand } = require('./lm-info')
+const { createLmInstallCommand } = require('./lm-install')
+const { createLmSetupCommand } = require('./lm-setup')
+const { createLmUninstallCommand } = require('./lm-uninstall')
+
+/**
+ * The lm command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const lm = (options, command) => {
+  command.help()
+}
+
+/**
+ * Creates the `netlify lm` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createLmCommand = (program) => {
+  createLmInfoCommand(program)
+  createLmInstallCommand(program)
+  createLmSetupCommand(program)
+  createLmUninstallCommand(program)
+
+  program
+    .command('lm')
+    .description('Handle Netlify Large Media operations')
+    .addHelpCommand('after', generateDescriptionHelp('The lm command will help you manage large media for a site'))
+    .addHelpCommand('after', generateExamplesHelp(['netlify lm:info', 'netlify lm:install', 'netlify lm:setup']))
+    .addHelpCommand('after', generateCommandsHelp('lm', program))
+    .action(lm)
+}
+
+module.exports = { createLmCommand }

package/src/commands/login/index.js

@@ -0,0 +1,6 @@
+const { createLoginCommand, login } = require('./login')
+
+module.exports = {
+  createLoginCommand,
+  login,
+}

package/src/commands/login/login.js

@@ -0,0 +1,52 @@
+// @ts-check
+const { chalk, exit, getToken, log } = require('../../utils')
+
+const msg = function (location) {
+  switch (location) {
+    case 'env':
+      return 'via process.env.NETLIFY_AUTH_TOKEN set in your terminal session'
+    case 'flag':
+      return 'via CLI --auth flag'
+    case 'config':
+      return 'via netlify config on your machine'
+    default:
+      return ''
+  }
+}
+
+/**
+ * The login command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const login = async (options, command) => {
+  const [accessToken, location] = await getToken()
+
+  command.setAnalyticsPayload({ new: options.new })
+
+  if (accessToken && !options.new) {
+    log(`Already logged in ${msg(location)}`)
+    log()
+    log(`Run ${chalk.cyanBright('netlify status')} for account details`)
+    log()
+    log(`To see all available commands run: ${chalk.cyanBright('netlify help')}`)
+    log()
+    return exit()
+  }
+
+  await command.expensivelyAuthenticate()
+}
+
+/**
+ * Creates the `netlify login` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createLoginCommand = (program) =>
+  program
+    .command('login')
+    .description('Login to your Netlify account')
+    .option('--new', 'Login to new Netlify account')
+    .action(login)
+
+module.exports = { createLoginCommand, login }

package/src/commands/logout/index.js

@@ -0,0 +1,5 @@
+const { createLogoutCommand } = require('./logout')
+
+module.exports = {
+  createLogoutCommand,
+}

package/src/commands/logout/logout.js

@@ -0,0 +1,43 @@
+// @ts-check
+const { exit, getToken, log, track } = require('../../utils')
+
+/**
+ * The logout command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const logout = async (options, command) => {
+  const [accessToken, location] = await getToken()
+
+  if (!accessToken) {
+    log(`Already logged out`)
+    log()
+    log('To login run "netlify login"')
+    exit()
+  }
+
+  await track('user_logout')
+
+  // unset userID without deleting key
+  command.netlify.globalConfig.set('userId', null)
+
+  if (location === 'env') {
+    log('The "process.env.NETLIFY_AUTH_TOKEN" is still set in your terminal session')
+    log()
+    log('To logout completely, unset the environment variable')
+    log()
+    exit()
+  }
+
+  log(`Logging you out of Netlify. Come back soon!`)
+}
+
+/**
+ * Creates the `netlify logout` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createLogoutCommand = (program) =>
+  program.command('logout', { hidden: true }).description('Logout of your Netlify account').action(logout)
+
+module.exports = { createLogoutCommand, logout }

package/src/commands/main.js

@@ -0,0 +1,117 @@
+// @ts-check
+const process = require('process')
+
+const inquirer = require('inquirer')
+const { findBestMatch } = require('string-similarity')
+
+const { NETLIFY_CYAN, USER_AGENT, chalk, error, execa, exit, getGlobalConfig, log, track, warn } = require('../utils')
+
+const SUGGESTION_TIMEOUT = 1e4
+
+const getVersionPage = async () => {
+  // performance optimization - load envinfo on demand
+  // eslint-disable-next-line node/global-require
+  const envinfo = require('envinfo')
+  const data = await envinfo.run({
+    System: ['OS', 'CPU'],
+    Binaries: ['Node', 'Yarn', 'npm'],
+    Browsers: ['Chrome', 'Edge', 'Firefox', 'Safari'],
+    npmGlobalPackages: ['netlify-cli'],
+  })
+
+  return `
+────────────────────┐
+ Environment Info   │
+────────────────────┘
+${data}
+${USER_AGENT}
+`
+}
+
+/**
+ * The main CLI command without any command (root action)
+ * @param {import('commander').OptionValues} options
+ * @param {import('./base-command').BaseCommand} command
+ */
+const mainCommand = async function (options, command) {
+  const globalConfig = await getGlobalConfig()
+
+  if (options.telemetryDisable) {
+    globalConfig.set('telemetryDisabled', true)
+    console.log('Netlify telemetry has been disabled')
+    console.log('You can renable it anytime with the --telemetry-enable flag')
+    exit()
+  }
+  if (options.telemetryEnable) {
+    globalConfig.set('telemetryDisabled', false)
+    console.log('Netlify telemetry has been enabled')
+    console.log('You can disable it anytime with the --telemetry-disable flag')
+    await track('user_telemetryEnabled')
+    exit()
+  }
+
+  if (command.args[0] === 'version') {
+    const versionPage = await getVersionPage()
+    log(versionPage)
+    exit()
+  }
+
+  warn(`${chalk.yellow(command.args[0])} is not a ${command.name()} command.`)
+
+  const allCommands = command.commands.map((cmd) => cmd.name())
+  const {
+    bestMatch: { target: suggestion },
+  } = findBestMatch(command.args[0], allCommands)
+
+  const applySuggestion = await new Promise((resolve) => {
+    const prompt = inquirer.prompt({
+      type: 'confirm',
+      name: 'suggestion',
+      message: `Did you mean ${chalk.blue(suggestion)}`,
+      default: false,
+    })
+
+    setTimeout(() => {
+      // @ts-ignore
+      prompt.ui.close()
+      resolve(false)
+    }, SUGGESTION_TIMEOUT)
+
+    // eslint-disable-next-line promise/catch-or-return
+    prompt.then((value) => resolve(value))
+  })
+  // create new log line
+  log()
+
+  if (!applySuggestion) {
+    error(`Run ${NETLIFY_CYAN(`${command.name()} help`)} for a list of available commands.`)
+  }
+
+  await execa(process.argv[0], [process.argv[1], suggestion], { stdio: 'inherit' })
+}
+
+/**
+ * Creates the `netlify functions:create` command
+ * @param {import('./base-command').BaseCommand} program
+ * @returns
+ */
+const createMainCommand = async (program) =>
+  program
+    .version(await getVersionPage(), '-v, --version')
+    .showSuggestionAfterError(true)
+    .option('--telemetry-disable', 'Disable telemetry')
+    .option('--telemetry-enable', 'Enables telemetry')
+    .configureHelp({
+      // TODO: Add custom formater to have same visual styling
+      //   formatHelp: (cmd, helper) => {
+      //     console.log(cmd, helper);
+      //     const longestFlag = Math.max(...cmd.options.map((option) => option.flags.length)) + 1;
+      //     const table = cmd.options.map(({flags, description}) => `  ${flags}${new Array(longestFlag-flags.length).fill().join(' ')}   {grey ${description}} `).join('\n')
+      //     return chalk`{bold OPTIONS}
+      // ${table}
+      // `
+      //   }
+    })
+    .action(mainCommand)
+
+module.exports = { createMainCommand }

package/src/commands/open/index.js

@@ -1,41 +1,5 @@
-const { flags: flagsLib } = require('@oclif/command')
+const { createOpenCommand } = require('./open')
 
-const { isEmptyCommand } = require('../../utils/check-command-inputs')
-const Command = require('../../utils/command')
-const showHelp = require('../../utils/show-help')
-
-const OpenAdminCommand = require('./admin')
-const OpenSiteCommand = require('./site')
-
-class OpenCommand extends Command {
-  async run() {
-    const { args, flags } = this.parse(OpenCommand)
-
-    // Show help on empty sub command
-    if (isEmptyCommand(flags, args)) {
-      showHelp(this.id)
-    }
-
-    if (flags.site) {
-      await OpenSiteCommand.run()
-    }
-    // Default open netlify admin
-    await OpenAdminCommand.run()
-  }
+module.exports = {
+  createOpenCommand,
 }
-
-OpenCommand.flags = {
-  ...OpenCommand.flags,
-  site: flagsLib.boolean({
-    description: 'Open site',
-  }),
-  admin: flagsLib.boolean({
-    description: 'Open Netlify site',
-  }),
-}
-
-OpenCommand.description = `Open settings for the site linked to the current folder`
-
-OpenCommand.examples = ['netlify open --site', 'netlify open --admin', 'netlify open:admin', 'netlify open:site']
-
-module.exports = OpenCommand

package/src/commands/open/open-admin.js

@@ -0,0 +1,56 @@
+const { error, exit, log, openBrowser, warn } = require('../../utils')
+
+/**
+ * The open:admin command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const openAdmin = async (options, command) => {
+  const { api, site } = command.netlify
+
+  await command.authenticate()
+
+  const siteId = site.id
+
+  if (!siteId) {
+    warn(`No Site ID found in current directory.
+Run \`netlify link\` to connect to this folder to a site`)
+    return false
+  }
+
+  let siteData
+  try {
+    siteData = await api.getSite({ siteId })
+    log(`Opening "${siteData.name}" site admin UI:`)
+    log(`> ${siteData.admin_url}`)
+  } catch (error_) {
+    // unauthorized
+    if (error_.status === 401) {
+      warn(`Log in with a different account or re-link to a site you have permission for`)
+      error(`Not authorized to view the currently linked site (${siteId})`)
+    }
+    // site not found
+    if (error_.status === 404) {
+      log()
+      log('Please double check this ID and verify you are logged in with the correct account')
+      log()
+      log('To fix this, run `netlify unlink` then `netlify link` to reconnect to the correct site ID')
+      log()
+      error(`Site "${siteId}" not found in account`)
+    }
+    error(error_)
+  }
+
+  await openBrowser({ url: siteData.admin_url })
+  exit()
+}
+
+/**
+ * Creates the `netlify open:admin` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createOpenAdminCommand = (program) =>
+  program.command('open:admin').description('Opens current site admin UI in Netlify').action(openAdmin)
+
+module.exports = { createOpenAdminCommand, openAdmin }

package/src/commands/open/open-site.js

@@ -0,0 +1,49 @@
+const { error, exit, log, openBrowser, warn } = require('../../utils')
+
+/**
+ * The open:site command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const openSite = async (options, command) => {
+  const { api, site } = command.netlify
+
+  await command.authenticate()
+
+  const siteId = site.id
+
+  if (!siteId) {
+    warn(`No Site ID found in current directory.
+Run \`netlify link\` to connect to this folder to a site`)
+    return false
+  }
+
+  let siteData
+  let url
+  try {
+    siteData = await api.getSite({ siteId })
+    url = siteData.ssl_url || siteData.url
+    log(`Opening "${siteData.name}" site url:`)
+    log(`> ${url}`)
+  } catch (error_) {
+    // unauthorized
+    if (error_.status === 401) {
+      warn(`Log in with a different account or re-link to a site you have permission for`)
+      error(`Not authorized to view the currently linked site (${siteId})`)
+    }
+    error(error_)
+  }
+
+  await openBrowser({ url })
+  exit()
+}
+
+/**
+ * Creates the `netlify open:site` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createOpenSiteCommand = (program) =>
+  program.command('open:site').description('Opens current site url in browser').action(openSite)
+
+module.exports = { createOpenSiteCommand, openSite }

package/src/commands/open/open.js

@@ -0,0 +1,42 @@
+const { generateCommandsHelp, generateExamplesHelp } = require('../../utils')
+
+const { createOpenAdminCommand, openAdmin } = require('./open-admin')
+const { createOpenSiteCommand, openSite } = require('./open-site')
+
+/**
+ * The open command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const open = async (options, command) => {
+  if (!options.site || !options.admin) {
+    command.help()
+  }
+
+  if (options.site) {
+    await openSite(options, command)
+  }
+  // Default open netlify admin
+  await openAdmin(options, command)
+}
+
+/**
+ * Creates the `netlify open` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createOpenCommand = (program) => {
+  createOpenAdminCommand(program)
+  createOpenSiteCommand(program)
+
+  return program
+    .command('open')
+    .description('Open settings for the site linked to the current folder')
+    .addHelpText(
+      'after',
+      generateExamplesHelp(['netlify open --site', 'netlify open --admin', 'netlify open:admin', 'netlify open:site']),
+    )
+    .addHelpText('after', generateCommandsHelp('open', program))
+    .action(open)
+}
+module.exports = { createOpenCommand }

package/src/commands/sites/index.js

@@ -1,22 +1,7 @@
-const { isEmptyCommand } = require('../../utils/check-command-inputs')
-const showHelp = require('../../utils/show-help')
-const { TrackedCommand } = require('../../utils/telemetry/tracked-command')
+const { createSitesCommand } = require('./sites')
+const { sitesCreate } = require('./sites-create')
 
-class SitesCommand extends TrackedCommand {
-  run() {
-    const { args, flags } = this.parse(SitesCommand)
-
-    // Show help on empty sub command
-    if (isEmptyCommand(flags, args)) {
-      showHelp(this.id)
-    }
-  }
+module.exports = {
+  createSitesCommand,
+  sitesCreate,
 }
-
-SitesCommand.description = `Handle various site operations
-The sites command will help you manage all your sites
-`
-
-SitesCommand.examples = ['netlify sites:create --name my-new-site', 'netlify sites:list']
-
-module.exports = SitesCommand

package/src/commands/sites/sites-create.js

@@ -0,0 +1,184 @@
+// @ts-check
+
+const slugify = require('@sindresorhus/slugify')
+const inquirer = require('inquirer')
+const pick = require('lodash/pick')
+const sample = require('lodash/sample')
+const prettyjson = require('prettyjson')
+const { v4: uuidv4 } = require('uuid')
+
+const { chalk, error, getRepoData, log, logJson, track, warn } = require('../../utils')
+const { configureRepo } = require('../../utils/init/config')
+
+const SITE_NAME_SUGGESTION_SUFFIX_LENGTH = 5
+
+/**
+ * The sites:create command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const sitesCreate = async (options, command) => {
+  const { api } = command.netlify
+
+  await command.authenticate()
+
+  const accounts = await api.listAccountsForUser()
+
+  let { accountSlug } = options
+  if (!accountSlug) {
+    const { accountSlug: accountSlugInput } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'accountSlug',
+        message: 'Team:',
+        choices: accounts.map((account) => ({
+          value: account.slug,
+          name: account.name,
+        })),
+      },
+    ])
+    accountSlug = accountSlugInput
+  }
+
+  const { name: nameFlag } = options
+  let user
+  let site
+
+  // Allow the user to reenter site name if selected one isn't available
+  const inputSiteName = async (name) => {
+    if (!user) user = await api.getCurrentUser()
+
+    if (!name) {
+      let { slug } = user
+      let suffix = ''
+
+      // If the user doesn't have a slug, we'll compute one. Because `full_name` is not guaranteed to be unique, we
+      // append a short randomly-generated ID to reduce the likelihood of a conflict.
+      if (!slug) {
+        slug = slugify(user.full_name || user.email)
+        suffix = `-${uuidv4().slice(0, SITE_NAME_SUGGESTION_SUFFIX_LENGTH)}`
+      }
+
+      const suggestions = [
+        `super-cool-site-by-${slug}${suffix}`,
+        `the-awesome-${slug}-site${suffix}`,
+        `${slug}-makes-great-sites${suffix}`,
+        `netlify-thinks-${slug}-is-great${suffix}`,
+        `the-great-${slug}-site${suffix}`,
+        `isnt-${slug}-awesome${suffix}`,
+      ]
+      const siteSuggestion = sample(suggestions)
+
+      console.log(
+        `Choose a unique site name (e.g. ${siteSuggestion}.netlify.app) or leave it blank for a random name. You can update the site name later.`,
+      )
+      const { name: nameInput } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'name',
+          message: 'Site name (optional):',
+          filter: (val) => (val === '' ? undefined : val),
+          validate: (input) => /^[a-zA-Z\d-]+$/.test(input) || 'Only alphanumeric characters and hyphens are allowed',
+        },
+      ])
+      name = nameInput
+    }
+
+    const body = {}
+    if (typeof name === 'string') {
+      body.name = name.trim()
+    }
+    try {
+      site = await api.createSiteInTeam({
+        accountSlug,
+        body,
+      })
+    } catch (error_) {
+      if (error_.status === 422) {
+        warn(`${name}.netlify.app already exists. Please try a different slug.`)
+        await inputSiteName()
+      } else {
+        error(`createSiteInTeam error: ${error_.status}: ${error_.message}`)
+      }
+    }
+  }
+  await inputSiteName(nameFlag)
+
+  log()
+  log(chalk.greenBright.bold.underline(`Site Created`))
+  log()
+
+  const siteUrl = site.ssl_url || site.url
+  log(
+    prettyjson.render({
+      'Admin URL': site.admin_url,
+      URL: siteUrl,
+      'Site ID': site.id,
+    }),
+  )
+
+  track('sites_created', {
+    siteId: site.id,
+    adminUrl: site.admin_url,
+    siteUrl,
+  })
+
+  if (options.withCi) {
+    log('Configuring CI')
+    const repoData = await getRepoData()
+    await configureRepo({ context: this, siteId: site.id, repoData, manual: options.manual })
+  }
+
+  if (options.json) {
+    logJson(
+      pick(site, [
+        'id',
+        'state',
+        'plan',
+        'name',
+        'custom_domain',
+        'domain_aliases',
+        'url',
+        'ssl_url',
+        'admin_url',
+        'screenshot_url',
+        'created_at',
+        'updated_at',
+        'user_id',
+        'ssl',
+        'force_ssl',
+        'managed_dns',
+        'deploy_url',
+        'account_name',
+        'account_slug',
+        'git_provider',
+        'deploy_hook',
+        'capabilities',
+        'id_domain',
+      ]),
+    )
+  }
+
+  return site
+}
+
+/**
+ * Creates the `netlify sites:create` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createSitesCreateCommand = (program) =>
+  program
+    .command('sites:create')
+    .description('Create an empty site (advanced)')
+    .option('-n, --name [name]', 'name of site')
+    .option('-a, --account-slug [slug]', 'account slug to create the site under')
+    .option('-c, --with-ci', 'initialize CI hooks during site creation')
+    .option('-m, --manual', 'force manual CI setup.  Used --with-ci flag')
+    .addHelpText(
+      'after',
+      `Create a blank site that isn't associated with any git remote. Does not link to the current working directory.`,
+    )
+    .action(sitesCreate)
+
+module.exports = { createSitesCreateCommand, sitesCreate }