netlify-cli 8.0.7 → 8.1.0-rc

package/src/commands/dev/index.js

@@ -1,337 +1,5 @@
-// @ts-check
-const path = require('path')
-const process = require('process')
-const { promisify } = require('util')
+const { createDevCommand } = require('./dev')
 
-const { flags: flagsLib } = require('@oclif/command')
-const boxen = require('boxen')
-const chalk = require('chalk')
-const execa = require('execa')
-const StaticServer = require('static-server')
-const stripAnsiCc = require('strip-ansi-control-characters')
-const waitPort = require('wait-port')
-
-const { startFunctionsServer } = require('../../lib/functions/server')
-const Command = require('../../utils/command')
-const { exit, log, warn } = require('../../utils/command-helpers')
-const { detectServerSettings } = require('../../utils/detect-server-settings')
-const { getSiteInformation, injectEnvVariables } = require('../../utils/dev')
-const { startLiveTunnel } = require('../../utils/live-tunnel')
-const { NETLIFYDEV, NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN } = require('../../utils/logo')
-const { openBrowser } = require('../../utils/open-browser')
-const { startProxy } = require('../../utils/proxy')
-const { startForwardProxy } = require('../../utils/traffic-mesh')
-
-const startStaticServer = async ({ settings }) => {
-  const server = new StaticServer({
-    rootPath: settings.dist,
-    name: 'netlify-dev',
-    port: settings.frameworkPort,
-    templates: {
-      notFound: path.join(settings.dist, '404.html'),
-    },
-  })
-
-  await promisify(server.start.bind(server))()
-  log(`\n${NETLIFYDEVLOG} Static server listening to`, settings.frameworkPort)
-}
-
-const isNonExistingCommandError = ({ command, error }) => {
-  // `ENOENT` is only returned for non Windows systems
-  // See https://github.com/sindresorhus/execa/pull/447
-  if (error.code === 'ENOENT') {
-    return true
-  }
-
-  // if the command is a package manager we let it report the error
-  if (['yarn', 'npm'].includes(command)) {
-    return false
-  }
-
-  // this only works on English versions of Windows
-  return (
-    typeof error.message === 'string' && error.message.includes('is not recognized as an internal or external command')
-  )
-}
-
-/**
- * Run a command and pipe stdout, stderr and stdin
- * @param {string} command
- * @param {NodeJS.ProcessEnv} env
- * @returns {execa.ExecaChildProcess<string>}
- */
-const runCommand = (command, env = {}) => {
-  const commandProcess = execa.command(command, {
-    preferLocal: true,
-    // we use reject=false to avoid rejecting synchronously when the command doesn't exist
-    reject: false,
-    env,
-    // windowsHide needs to be false for child process to terminate properly on Windows
-    windowsHide: false,
-  })
-
-  commandProcess.stdout.pipe(stripAnsiCc.stream()).pipe(process.stdout)
-  commandProcess.stderr.pipe(stripAnsiCc.stream()).pipe(process.stderr)
-  process.stdin.pipe(commandProcess.stdin)
-
-  // we can't try->await->catch since we don't want to block on the framework server which
-  // is a long running process
-  // eslint-disable-next-line promise/catch-or-return,promise/prefer-await-to-then
-  commandProcess.then(async () => {
-    const result = await commandProcess
-    const [commandWithoutArgs] = command.split(' ')
-    // eslint-disable-next-line promise/always-return
-    if (result.failed && isNonExistingCommandError({ command: commandWithoutArgs, error: result })) {
-      log(
-        NETLIFYDEVERR,
-        `Failed running command: ${command}. Please verify ${chalk.magenta(`'${commandWithoutArgs}'`)} exists`,
-      )
-    } else {
-      const errorMessage = result.failed
-        ? `${NETLIFYDEVERR} ${result.shortMessage}`
-        : `${NETLIFYDEVWARN} "${command}" exited with code ${result.exitCode}`
-
-      log(`${errorMessage}. Shutting down Netlify Dev server`)
-    }
-    process.exit(1)
-  })
-  ;['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP', 'exit'].forEach((signal) => {
-    process.on(signal, () => {
-      commandProcess.kill('SIGTERM', { forceKillAfterTimeout: 500 })
-      process.exit()
-    })
-  })
-
-  return commandProcess
-}
-
-/**
- * Start a static server if the `useStaticServer` is provided or a framework specific server
- * @param {object} config
- * @param {import('../../utils/types').ServerSettings} config.settings
- * @returns {Promise<void>}
- */
-const startFrameworkServer = async function ({ settings }) {
-  if (settings.useStaticServer) {
-    if (settings.command) {
-      runCommand(settings.command, settings.env)
-    }
-    return await startStaticServer({ settings })
-  }
-
-  log(`${NETLIFYDEVLOG} Starting Netlify Dev with ${settings.framework || 'custom config'}`)
-
-  runCommand(settings.command, settings.env)
-
-  try {
-    const open = await waitPort({
-      port: settings.frameworkPort,
-      output: 'silent',
-      timeout: FRAMEWORK_PORT_TIMEOUT,
-      ...(settings.pollingStrategies.includes('HTTP') && { protocol: 'http' }),
-    })
-
-    if (!open) {
-      throw new Error(`Timed out waiting for port '${settings.frameworkPort}' to be open`)
-    }
-  } catch {
-    log(NETLIFYDEVERR, `Netlify Dev could not connect to localhost:${settings.frameworkPort}.`)
-    log(NETLIFYDEVERR, `Please make sure your framework server is running on port ${settings.frameworkPort}`)
-    exit(1)
-  }
-}
-
-// 10 minutes
-const FRAMEWORK_PORT_TIMEOUT = 6e5
-
-const startProxyServer = async ({ addonsUrls, flags, settings, site }) => {
-  let url
-  if (flags.edgeHandlers || flags.trafficMesh) {
-    url = await startForwardProxy({
-      port: settings.port,
-      frameworkPort: settings.frameworkPort,
-      functionsPort: settings.functionsPort,
-      publishDir: settings.dist,
-      debug: flags.debug,
-      locationDb: flags.locationDb,
-      jwtRolesPath: settings.jwtRolePath,
-      jwtSecret: settings.jwtSecret,
-    })
-    if (!url) {
-      log(NETLIFYDEVERR, `Unable to start forward proxy on port '${settings.port}'`)
-      exit(1)
-    }
-  } else {
-    url = await startProxy(settings, addonsUrls, site.configPath, site.root)
-    if (!url) {
-      log(NETLIFYDEVERR, `Unable to start proxy server on port '${settings.port}'`)
-      exit(1)
-    }
-  }
-  return url
-}
-
-const handleLiveTunnel = async ({ api, flags, settings, site }) => {
-  if (flags.live) {
-    const sessionUrl = await startLiveTunnel({
-      siteId: site.id,
-      netlifyApiToken: api.accessToken,
-      localPort: settings.port,
-    })
-    process.env.BASE_URL = sessionUrl
-    return sessionUrl
-  }
-}
-
-const printBanner = ({ url }) => {
-  const banner = chalk.bold(`${NETLIFYDEVLOG} Server now ready on ${url}`)
-
-  log(
-    boxen(banner, {
-      padding: 1,
-      margin: 1,
-      align: 'center',
-      borderColor: '#00c7b7',
-    }),
-  )
+module.exports = {
+  createDevCommand,
 }
-
-class DevCommand extends Command {
-  async init() {
-    this.commandContext = 'dev'
-    await super.init()
-  }
-
-  async run() {
-    log(`${NETLIFYDEV}`)
-    const { flags } = this.parse(DevCommand)
-    const { api, config, site, siteInfo } = this.netlify
-    config.dev = { ...config.dev }
-    config.build = { ...config.build }
-    /** @type {import('./types').DevConfig} */
-    const devConfig = {
-      framework: '#auto',
-      ...(config.functionsDirectory && { functions: config.functionsDirectory }),
-      ...(config.build.publish && { publish: config.build.publish }),
-      ...config.dev,
-      ...flags,
-    }
-
-    if (flags.trafficMesh) {
-      warn(
-        '--trafficMesh and -t are deprecated and will be removed in the near future. Please use --edgeHandlers or -e instead.',
-      )
-    }
-
-    await injectEnvVariables({ env: this.netlify.cachedConfig.env, site })
-    const { addonsUrls, capabilities, siteUrl, timeouts } = await getSiteInformation({
-      flags,
-      api,
-      site,
-      siteInfo,
-    })
-
-    /** @type {Partial<import('../../utils/types').ServerSettings>} */
-    let settings = {}
-    try {
-      settings = await detectServerSettings(devConfig, flags, site.root)
-    } catch (error) {
-      log(NETLIFYDEVERR, error.message)
-      exit(1)
-    }
-
-    this.setAnalyticsPayload({ projectType: settings.framework || 'custom', live: flags.live })
-
-    await startFunctionsServer({
-      config,
-      settings,
-      site,
-      siteUrl,
-      capabilities,
-      timeouts,
-    })
-    await startFrameworkServer({ settings })
-
-    let url = await startProxyServer({ flags, settings, site, addonsUrls })
-
-    const liveTunnelUrl = await handleLiveTunnel({ flags, site, api, settings })
-    url = liveTunnelUrl || url
-
-    if (devConfig.autoLaunch !== false) {
-      await openBrowser({ url, silentBrowserNoneError: true })
-    }
-
-    process.env.URL = url
-    process.env.DEPLOY_URL = url
-
-    printBanner({ url })
-  }
-}
-
-DevCommand.description = `Local dev server
-The dev command will run a local dev server with Netlify's proxy and redirect rules
-`
-
-DevCommand.examples = [
-  '$ netlify dev',
-  '$ netlify dev -d public',
-  '$ netlify dev -c "hugo server -w" --targetPort 1313',
-]
-
-DevCommand.strict = false
-
-DevCommand.flags = {
-  command: flagsLib.string({
-    char: 'c',
-    description: 'command to run',
-  }),
-  port: flagsLib.integer({
-    char: 'p',
-    description: 'port of netlify dev',
-  }),
-  targetPort: flagsLib.integer({
-    description: 'port of target app server',
-  }),
-  framework: flagsLib.string({
-    description: 'framework to use. Defaults to #auto which automatically detects a framework',
-  }),
-  staticServerPort: flagsLib.integer({
-    description: 'port of the static app server used when no framework is detected',
-    hidden: true,
-  }),
-  dir: flagsLib.string({
-    char: 'd',
-    description: 'dir with static files',
-  }),
-  functions: flagsLib.string({
-    char: 'f',
-    description: 'specify a functions folder to serve',
-  }),
-  offline: flagsLib.boolean({
-    char: 'o',
-    description: 'disables any features that require network access',
-  }),
-  live: flagsLib.boolean({
-    char: 'l',
-    description: 'start a public live session',
-    default: false,
-  }),
-  edgeHandlers: flagsLib.boolean({
-    char: 'e',
-    hidden: true,
-    description: 'activates the Edge Handlers runtime',
-  }),
-  trafficMesh: flagsLib.boolean({
-    char: 't',
-    hidden: true,
-    description: '(DEPRECATED: use --edgeHandlers or -e instead) uses Traffic Mesh for proxying requests',
-  }),
-  locationDb: flagsLib.string({
-    description: 'specify the path to a local GeoIP location database in MMDB format',
-    char: 'g',
-    hidden: true,
-  }),
-  ...DevCommand.flags,
-}
-
-module.exports = DevCommand

package/src/commands/env/env-get.js

@@ -0,0 +1,51 @@
+// @ts-check
+const { log, logJson } = require('../../utils')
+
+/**
+ * The env:get command
+ * @param {string} name Environment variable name
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ */
+const envGet = async (name, options, command) => {
+  const { api, cachedConfig, site } = command.netlify
+  const siteId = site.id
+
+  if (!siteId) {
+    log('No site id found, please run inside a site folder or `netlify link`')
+    return false
+  }
+
+  const siteData = await api.getSite({ siteId })
+
+  const { value } = cachedConfig.env[name] || {}
+
+  // Return json response for piping commands
+  if (options.json) {
+    logJson(value ? { [name]: value } : {})
+    return false
+  }
+
+  if (!value) {
+    log(`Environment variable ${name} not set for site ${siteData.name}`)
+    return false
+  }
+
+  log(value)
+}
+
+/**
+ * Creates the `netlify env:get` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createEnvGetCommand = (program) =>
+  program
+    .command('env:get')
+    .argument('<name>', 'Environment variable name')
+    .description('Get resolved value of specified environment variable (includes netlify.toml)')
+    .action(async (name, options, command) => {
+      await envGet(name, options, command)
+    })
+
+module.exports = { createEnvGetCommand }

package/src/commands/env/env-import.js

@@ -0,0 +1,93 @@
+// @ts-check
+const { readFile } = require('fs').promises
+
+const AsciiTable = require('ascii-table')
+const dotenv = require('dotenv')
+const isEmpty = require('lodash/isEmpty')
+
+const { exit, log, logJson } = require('../../utils')
+
+/**
+ * The env:import command
+ * @param {string} fileName .env file to import
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const envImport = async (fileName, options, command) => {
+  const { api, site } = command.netlify
+  const siteId = site.id
+
+  if (!siteId) {
+    log('No site id found, please run inside a site folder or `netlify link`')
+    return false
+  }
+
+  const siteData = await api.getSite({ siteId })
+
+  // Get current environment variables set in the UI
+  const {
+    build_settings: { env = {} },
+  } = siteData
+
+  let importedEnv = {}
+  try {
+    const envFileContents = await readFile(fileName, 'utf-8')
+    importedEnv = dotenv.parse(envFileContents)
+  } catch (error) {
+    log(error.message)
+    exit(1)
+  }
+
+  if (isEmpty(importedEnv)) {
+    log(`No environment variables found in file ${fileName} to import`)
+    return false
+  }
+
+  // Apply environment variable updates
+  const siteResult = await api.updateSite({
+    siteId,
+    body: {
+      build_settings: {
+        // Only set imported variables if --replaceExisting or otherwise merge
+        // imported ones with the current environment variables.
+        env: options.replaceExisting ? importedEnv : { ...env, ...importedEnv },
+      },
+    },
+  })
+
+  // Return new environment variables of site if using json flag
+  if (options.json) {
+    logJson(siteResult.build_settings.env)
+    return false
+  }
+
+  // List newly imported environment variables in a table
+  log(`site: ${siteData.name}`)
+  const table = new AsciiTable(`Imported environment variables`)
+
+  table.setHeading('Key', 'Value')
+  table.addRowMatrix(Object.entries(importedEnv))
+  log(table.toString())
+}
+
+/**
+ * Creates the `netlify env:import` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createEnvImportCommand = (program) =>
+  program
+    .command('env:import')
+    .argument('<fileName>', '.env file to import')
+    .option(
+      '-r, --replaceExisting',
+      'Replace all existing variables instead of merging them with the current ones',
+      false,
+    )
+    .description('Import and set environment variables from .env file')
+    .action(async (fileName, options, command) => {
+      await envImport(fileName, options, command)
+    })
+
+module.exports = { createEnvImportCommand }

package/src/commands/env/env-list.js

@@ -0,0 +1,63 @@
+// @ts-check
+const AsciiTable = require('ascii-table')
+const isEmpty = require('lodash/isEmpty')
+
+const { log, logJson } = require('../../utils')
+
+/**
+ * The env:list command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const envList = async (options, command) => {
+  const { api, cachedConfig, site } = command.netlify
+  const siteId = site.id
+
+  if (!siteId) {
+    log('No site id found, please run inside a site folder or `netlify link`')
+    return false
+  }
+
+  const siteData = await api.getSite({ siteId })
+  const environment = Object.fromEntries(
+    Object.entries(cachedConfig.env)
+      // Omitting general variables to reduce noise.
+      .filter(([, variable]) => variable.sources[0] !== 'general')
+      .map(([key, variable]) => [key, variable.value]),
+  )
+
+  // Return json response for piping commands
+  if (options.json) {
+    logJson(environment)
+    return false
+  }
+
+  if (isEmpty(environment)) {
+    log(`No environment variables set for site ${siteData.name}`)
+    return false
+  }
+
+  // List environment variables using a table
+  log(`site: ${siteData.name}`)
+  const table = new AsciiTable(`Environment variables`)
+
+  table.setHeading('Key', 'Value')
+  table.addRowMatrix(Object.entries(environment))
+  log(table.toString())
+}
+
+/**
+ * Creates the `netlify env:list` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createEnvListCommand = (program) =>
+  program
+    .command('env:list')
+    .description('Lists resolved environment variables for site (includes netlify.toml)')
+    .action(async (options, command) => {
+      await envList(options, command)
+    })
+
+module.exports = { createEnvListCommand }

package/src/commands/env/env-set.js

@@ -0,0 +1,67 @@
+// @ts-check
+const { log, logJson } = require('../../utils')
+
+/**
+ * The env:set command
+ * @param {string} name Environment variable name
+ * @param {string} value Value to set to
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const envSet = async (name, value, options, command) => {
+  const { api, site } = command.netlify
+  const siteId = site.id
+
+  if (!siteId) {
+    log('No site id found, please run inside a site folder or `netlify link`')
+    return false
+  }
+
+  const siteData = await api.getSite({ siteId })
+
+  // Get current environment variables set in the UI
+  const {
+    build_settings: { env = {} },
+  } = siteData
+
+  const newEnv = {
+    ...env,
+    [name]: value,
+  }
+
+  // Apply environment variable updates
+  const siteResult = await api.updateSite({
+    siteId,
+    body: {
+      build_settings: {
+        env: newEnv,
+      },
+    },
+  })
+
+  // Return new environment variables of site if using json flag
+  if (options.json) {
+    logJson(siteResult.build_settings.env)
+    return false
+  }
+
+  log(`Set environment variable ${name}=${value} for site ${siteData.name}`)
+}
+
+/**
+ * Creates the `netlify env:set` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createEnvSetCommand = (program) =>
+  program
+    .command('env:set')
+    .argument('<name>', 'Environment variable name')
+    .argument('[value]', 'Value to set to', '')
+    .description('Set value of environment variable')
+    .action(async (name, value, options, command) => {
+      await envSet(name, value, options, command)
+    })
+
+module.exports = { createEnvSetCommand }

package/src/commands/env/env-unset.js

@@ -0,0 +1,66 @@
+// @ts-check
+const { log, logJson } = require('../../utils')
+
+/**
+ * The env:unset command
+ * @param {string} name Environment variable name
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command').BaseCommand} command
+ * @returns {Promise<boolean>}
+ */
+const envUnset = async (name, options, command) => {
+  const { api, site } = command.netlify
+  const siteId = site.id
+
+  if (!siteId) {
+    log('No site id found, please run inside a site folder or `netlify link`')
+    return false
+  }
+
+  const siteData = await api.getSite({ siteId })
+
+  // Get current environment variables set in the UI
+  const {
+    build_settings: { env = {} },
+  } = siteData
+
+  const newEnv = env
+
+  // Delete environment variable from current variables
+  delete newEnv[name]
+
+  // Apply environment variable updates
+  const siteResult = await api.updateSite({
+    siteId,
+    body: {
+      build_settings: {
+        env: newEnv,
+      },
+    },
+  })
+
+  // Return new environment variables of site if using json flag
+  if (options.json) {
+    logJson(siteResult.build_settings.env)
+    return false
+  }
+
+  log(`Unset environment variable ${name} for site ${siteData.name}`)
+}
+
+/**
+ * Creates the `netlify env:unset` command
+ * @param {import('../base-command').BaseCommand} program
+ * @returns
+ */
+const createEnvUnsetCommand = (program) =>
+  program
+    .command('env:unset')
+    .aliases(['env:delete', 'env:remove'])
+    .argument('<name>', 'Environment variable name')
+    .description('Unset an environment variable which removes it from the UI')
+    .action(async (name, options, command) => {
+      await envUnset(name, options, command)
+    })
+
+module.exports = { createEnvUnsetCommand }