netlify-cli 15.11.0 → 16.0.0-alpha.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "15.11.0",
+  "version": "16.0.0-alpha.0",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
-    "node": "^14.18.0 || >=16.0.0"
+    "node": ">=16.16.0"
   },
   "files": [
     "/bin",
@@ -44,11 +44,10 @@
   "dependencies": {
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
-    "@netlify/build": "29.17.3",
+    "@netlify/build": "29.19.0",
     "@netlify/build-info": "7.7.3",
-    "@netlify/config": "20.6.4",
+    "@netlify/config": "20.8.0",
     "@netlify/edge-bundler": "8.17.1",
-    "@netlify/framework-info": "9.8.10",
     "@netlify/local-functions-proxy": "1.1.1",
     "@netlify/serverless-functions-api": "1.5.2",
     "@netlify/zip-it-and-ship-it": "9.13.1",

package/src/commands/base-command.mjs

@@ -1,13 +1,18 @@
 // @ts-check
+import { existsSync } from 'fs'
+import { join, relative, resolve } from 'path'
 import process from 'process'
 import { format } from 'util'
 
-import { Project } from '@netlify/build-info'
+import { DefaultLogger, Project } from '@netlify/build-info'
 // eslint-disable-next-line import/extensions, n/no-missing-import
-import { NodeFS } from '@netlify/build-info/node'
+import { NodeFS, NoopLogger } from '@netlify/build-info/node'
 import { resolveConfig } from '@netlify/config'
 import { Command, Option } from 'commander'
 import debug from 'debug'
+import { findUp } from 'find-up'
+import inquirer from 'inquirer'
+import inquirerAutocompletePrompt from 'inquirer-autocomplete-prompt'
 import merge from 'lodash/merge.js'
 import { NetlifyAPI } from 'netlify'
 
@@ -30,22 +35,31 @@ import getGlobalConfig from '../utils/get-global-config.mjs'
 import { getSiteByName } from '../utils/get-site.mjs'
 import openBrowser from '../utils/open-browser.mjs'
 import StateConfig from '../utils/state-config.mjs'
-import { identify, track } from '../utils/telemetry/index.mjs'
+import { identify, reportError, track } from '../utils/telemetry/index.mjs'
 
-// Netlify CLI client id. Lives in bot@netlify.com
+// load the autocomplete plugin
+inquirer.registerPrompt('autocomplete', inquirerAutocompletePrompt)
+/** Netlify CLI client id. Lives in bot@netlify.com */
 // TODO: setup client for multiple environments
 const CLIENT_ID = 'd6f37de6614df7ae58664cfca524744d73807a377f5ee71f1a254f78412e3750'
 
 const NANO_SECS_TO_MSECS = 1e6
-// The fallback width for the help terminal
+/** The fallback width for the help terminal */
 const FALLBACK_HELP_CMD_WIDTH = 80
 
 const HELP_$ = NETLIFY_CYAN('$')
-// indent on commands or description on the help page
+/** indent on commands or description on the help page */
 const HELP_INDENT_WIDTH = 2
-// separator width between term and description
+/** separator width between term and description */
 const HELP_SEPARATOR_WIDTH = 5
 
+/**
+ * A list of commands where we don't have to perform the workspace selection at.
+ * Those commands work with the system or are not writing any config files that need to be
+ * workspace aware.
+ */
+const COMMANDS_WITHOUT_WORKSPACE_OPTIONS = new Set(['api', 'recipes', 'completion', 'status', 'switch', 'login', 'lm'])
+
 /**
  * Formats a help list correctly with the correct indent
  * @param {string[]} textArray
@@ -64,30 +78,83 @@ const getDuration = function (startTime) {
 }
 
 /**
- * The netlify object inside each command with the state
- * @typedef NetlifyOptions
- * @type {object}
- * @property {import('netlify').NetlifyAPI} api
- * @property {*} repositoryRoot
- * @property {object} site
- * @property {*} site.root
- * @property {*} site.configPath
- * @property {*} site.id
- * @property {*} siteInfo
- * @property {*} config
- * @property {*} cachedConfig
- * @property {*} globalConfig
- * @property {import('../../utils/state-config.mjs').default} state,
+ * Retrieves a workspace package based of the filter flag that is provided.
+ * If the filter flag does not match a workspace package or is not defined then it will prompt with an autocomplete to select a package
+ * @param {Project} project
+ * @param {string=} filter
+ * @returns {Promise<string>}
  */
+async function selectWorkspace(project, filter) {
+  const selected = project.workspace?.packages.find((pkg) => {
+    if (
+      project.relativeBaseDirectory &&
+      project.relativeBaseDirectory.length !== 0 &&
+      pkg.path.startsWith(project.relativeBaseDirectory)
+    ) {
+      return true
+    }
+    return (pkg.name && pkg.name === filter) || pkg.path === filter
+  })
+
+  if (!selected) {
+    log()
+    log(chalk.cyan(`We've detected multiple sites inside your repository`))
+
+    const { result } = await inquirer.prompt({
+      name: 'result',
+      type: 'autocomplete',
+      message: 'Select the site you want to work with',
+      source: (/** @type {string} */ _, input = '') =>
+        (project.workspace?.packages || [])
+          .filter((pkg) => pkg.path.includes(input))
+          .map((pkg) => ({
+            name: `${pkg.name ? `${chalk.bold(pkg.name)}  ` : ''}${pkg.path}  ${chalk.dim(
+              `--filter ${pkg.name || pkg.path}`,
+            )}`,
+            value: pkg.path,
+          })),
+    })
+
+    return result
+  }
+  return selected.path
+}
 
 /** Base command class that provides tracking and config initialization */
 export default class BaseCommand extends Command {
-  /** @type {NetlifyOptions} */
+  /**
+   * The netlify object inside each command with the state
+   * @type {import('./types.js').NetlifyOptions}
+   */
   netlify
 
   /** @type {{ startTime: bigint, payload?: any}} */
   analytics = { startTime: process.hrtime.bigint() }
 
+  /** @type {Project} */
+  project
+
+  /**
+   * The working directory that is used for reading the `netlify.toml` file and storing the state.
+   * In a monorepo context this must not be the process working directory and can be an absolute path to the
+   * Package/Site that should be worked in.
+   */
+  // here we actually want to disable the lint rule as its value is set
+  // eslint-disable-next-line workspace/no-process-cwd
+  workingDir = process.cwd()
+
+  /**
+   * The workspace root if inside a mono repository.
+   * Must not be the repository root!
+   * @type {string|undefined}
+   */
+  jsWorkspaceRoot
+  /**
+   * The current workspace package we should execute the commands in
+   * @type {string|undefined}
+   */
+  workspacePackage
+
   /**
    * IMPORTANT this function will be called for each command!
    * Don't do anything expensive in there.
@@ -95,49 +162,56 @@ export default class BaseCommand extends Command {
    * @returns
    */
   createCommand(name) {
-    return (
-      new BaseCommand(name)
-        // If  --silent or --json flag passed disable logger
-        .addOption(new Option('--json', 'Output return values as JSON').hideHelp(true))
-        .addOption(new Option('--silent', 'Silence CLI output').hideHelp(true))
-        .addOption(new Option('--cwd <cwd>').hideHelp(true))
-        .addOption(new Option('-o, --offline').hideHelp(true))
-        .addOption(new Option('--auth <token>', 'Netlify auth token').hideHelp(true))
-        .addOption(
-          new Option(
-            '--httpProxy [address]',
-            'Old, prefer --http-proxy. Proxy server address to route requests through.',
-          )
-            .default(process.env.HTTP_PROXY || process.env.HTTPS_PROXY)
-            .hideHelp(true),
-        )
-        .addOption(
-          new Option(
-            '--httpProxyCertificateFilename [file]',
-            'Old, prefer --http-proxy-certificate-filename. Certificate file to use when connecting using a proxy server.',
-          )
-            .default(process.env.NETLIFY_PROXY_CERTIFICATE_FILENAME)
-            .hideHelp(true),
+    const base = new BaseCommand(name)
+      // If  --silent or --json flag passed disable logger
+      .addOption(new Option('--json', 'Output return values as JSON').hideHelp(true))
+      .addOption(new Option('--silent', 'Silence CLI output').hideHelp(true))
+      .addOption(new Option('--cwd <cwd>').hideHelp(true))
+      .addOption(new Option('-o, --offline').hideHelp(true))
+      .addOption(new Option('--auth <token>', 'Netlify auth token').hideHelp(true))
+      .addOption(
+        new Option('--httpProxy [address]', 'Old, prefer --http-proxy. Proxy server address to route requests through.')
+          .default(process.env.HTTP_PROXY || process.env.HTTPS_PROXY)
+          .hideHelp(true),
+      )
+      .addOption(
+        new Option(
+          '--httpProxyCertificateFilename [file]',
+          'Old, prefer --http-proxy-certificate-filename. Certificate file to use when connecting using a proxy server.',
         )
-        .option(
+          .default(process.env.NETLIFY_PROXY_CERTIFICATE_FILENAME)
+          .hideHelp(true),
+      )
+      .addOption(
+        new Option(
           '--http-proxy-certificate-filename [file]',
           'Certificate file to use when connecting using a proxy server',
-          process.env.NETLIFY_PROXY_CERTIFICATE_FILENAME,
         )
-        .option(
-          '--http-proxy [address]',
-          'Proxy server address to route requests through.',
-          process.env.HTTP_PROXY || process.env.HTTPS_PROXY,
-        )
-        .option('--debug', 'Print debugging information')
-        .hook('preAction', async (_parentCommand, actionCommand) => {
-          debug(`${name}:preAction`)('start')
-          this.analytics = { startTime: process.hrtime.bigint() }
-          // @ts-ignore cannot type actionCommand as BaseCommand
-          await this.init(actionCommand)
-          debug(`${name}:preAction`)('end')
-        })
-    )
+          .default(process.env.NETLIFY_PROXY_CERTIFICATE_FILENAME)
+          .hideHelp(true),
+      )
+      .addOption(
+        new Option('--httpProxy [address]', 'Proxy server address to route requests through.')
+          .default(process.env.HTTP_PROXY || process.env.HTTPS_PROXY)
+          .hideHelp(true),
+      )
+      .option('--debug', 'Print debugging information')
+
+    // only add the `--filter` option to commands that are workspace aware
+    if (!COMMANDS_WITHOUT_WORKSPACE_OPTIONS.has(name)) {
+      base.option('--filter <app>', 'For monorepos, specify the name of the application to run the command in')
+    }
+
+    return base.hook('preAction', async (_parentCommand, actionCommand) => {
+      if (actionCommand.opts()?.debug) {
+        process.env.DEBUG = '*'
+      }
+      debug(`${name}:preAction`)('start')
+      this.analytics = { startTime: process.hrtime.bigint() }
+      // @ts-ignore cannot type actionCommand as BaseCommand
+      await this.init(actionCommand)
+      debug(`${name}:preAction`)('end')
+    })
   }
 
   /** @private */
@@ -149,7 +223,7 @@ export default class BaseCommand extends Command {
     return this
   }
 
-  /** The examples list for the command (used inside doc generation and help page) */
+  /** @type {string[]} The examples list for the command (used inside doc generation and help page) */
   examples = []
 
   /**
@@ -172,23 +246,27 @@ export default class BaseCommand extends Command {
       const term =
         this.name() === 'netlify'
           ? `${HELP_$} ${command.name()} [COMMAND]`
-          : `${HELP_$} ${command.parent.name()} ${command.name()} ${command.usage()}`
+          : `${HELP_$} ${command.parent?.name()} ${command.name()} ${command.usage()}`
 
       return padLeft(term, HELP_INDENT_WIDTH)
     }
 
+    /**
+     * @param {BaseCommand} command
+     */
     const getCommands = (command) => {
       const parentCommand = this.name() === 'netlify' ? command : command.parent
-      return parentCommand.commands.filter((cmd) => {
-        // eslint-disable-next-line no-underscore-dangle
-        if (cmd._hidden) return false
-        // the root command
-        if (this.name() === 'netlify') {
-          // don't include subcommands on the main page
-          return !cmd.name().includes(':')
-        }
-        return cmd.name().startsWith(`${command.name()}:`)
-      })
+      return (
+        parentCommand?.commands.filter((cmd) => {
+          if (cmd._hidden) return false
+          // the root command
+          if (this.name() === 'netlify') {
+            // don't include subcommands on the main page
+            return !cmd.name().includes(':')
+          }
+          return cmd.name().startsWith(`${command.name()}:`)
+        }) || []
+      )
     }
 
     /**
@@ -281,9 +359,8 @@ export default class BaseCommand extends Command {
       }
 
       // Aliases
-      // eslint-disable-next-line no-underscore-dangle
+
       if (command._aliases.length !== 0) {
-        // eslint-disable-next-line no-underscore-dangle
         const aliases = command._aliases.map((alias) => formatItem(`${parentCommand.name()} ${alias}`, null, true))
         output = [...output, chalk.bold('ALIASES'), formatHelpList(aliases), '']
       }
@@ -337,6 +414,11 @@ export default class BaseCommand extends Command {
     }
   }
 
+  /**
+   *
+   * @param {string|undefined} tokenFromFlag
+   * @returns
+   */
   async authenticate(tokenFromFlag) {
     const [token] = await getToken(tokenFromFlag)
     if (token) {
@@ -406,6 +488,10 @@ export default class BaseCommand extends Command {
     return accessToken
   }
 
+  /**
+   * Adds some data to the analytics payload
+   * @param {Record<string, unknown>} payload
+   */
   setAnalyticsPayload(payload) {
     const newPayload = { ...this.analytics.payload, ...payload }
     this.analytics = { ...this.analytics, payload: newPayload }
@@ -418,12 +504,58 @@ export default class BaseCommand extends Command {
    */
   async init(actionCommand) {
     debug(`${actionCommand.name()}:init`)('start')
-    const options = actionCommand.opts()
-    const cwd = options.cwd || process.cwd()
-    // Get site id & build state
-    const state = new StateConfig(cwd)
+    const flags = actionCommand.opts()
+    // here we actually want to use the process.cwd as we are setting the workingDir
+    // eslint-disable-next-line workspace/no-process-cwd
+    this.workingDir = flags.cwd || process.cwd()
+
+    // ==================================================
+    // Create a Project and run the Heuristics to detect
+    // if we are running inside a monorepo or not.
+    // ==================================================
+
+    // retrieve the repository root
+    const rootDir = await getRepositoryRoot()
+    // Get framework, add to analytics payload for every command, if a framework is set
+    const fs = new NodeFS()
+    // disable logging inside the project and FS if not in debug mode
+    fs.logger = actionCommand.opts()?.debug ? new DefaultLogger('debug') : new NoopLogger()
+    this.project = new Project(fs, this.workingDir, rootDir)
+      .setEnvironment(process.env)
+      .setNodeVersion(process.version)
+      // eslint-disable-next-line promise/prefer-await-to-callbacks
+      .setReportFn((err, reportConfig) => {
+        reportError(err, {
+          severity: reportConfig?.severity || 'error',
+          metadata: reportConfig?.metadata,
+        })
+      })
+    const frameworks = await this.project.detectFrameworks()
+    /** @type { string|undefined} */
+    let packageConfig = flags.config ? resolve(flags.config) : undefined
+    // check if we have detected multiple projects inside which one we have to perform our operations.
+    // only ask to select one if on the workspace root
+    if (
+      !COMMANDS_WITHOUT_WORKSPACE_OPTIONS.has(actionCommand.name()) &&
+      this.project.workspace?.packages.length &&
+      this.project.workspace.isRoot
+    ) {
+      this.workspacePackage = await selectWorkspace(this.project, actionCommand.opts().filter)
+      this.workingDir = join(this.project.jsWorkspaceRoot, this.workspacePackage)
+    }
 
-    const [token] = await getToken(options.auth)
+    this.jsWorkspaceRoot = this.project.jsWorkspaceRoot
+    // detect if a toml exists in this package.
+    const tomlFile = join(this.workingDir, 'netlify.toml')
+    if (!packageConfig && existsSync(tomlFile)) {
+      packageConfig = tomlFile
+    }
+
+    // ==================================================
+    // Retrieve Site id and build state from the state.json
+    // ==================================================
+    const state = new StateConfig(this.workingDir)
+    const [token] = await getToken(flags.auth)
 
     const apiUrlOpts = {
       userAgent: USER_AGENT,
@@ -437,12 +569,25 @@ export default class BaseCommand extends Command {
         process.env.NETLIFY_API_URL === `${apiUrl.protocol}//${apiUrl.host}` ? '/api/v1' : apiUrl.pathname
     }
 
-    const cachedConfig = await actionCommand.getConfig({ cwd, state, token, ...apiUrlOpts })
+    // ==================================================
+    // Start retrieving the configuration through the
+    // configuration file and the API
+    // ==================================================
+    const cachedConfig = await actionCommand.getConfig({
+      cwd: this.jsWorkspaceRoot || this.workingDir,
+      repositoryRoot: rootDir,
+      packagePath: this.workspacePackage,
+      // The config flag needs to be resolved from the actual process working directory
+      configFilePath: packageConfig,
+      state,
+      token,
+      ...apiUrlOpts,
+    })
     const { buildDir, config, configPath, repositoryRoot, siteInfo } = cachedConfig
     const normalizedConfig = normalizeConfig(config)
     const agent = await getAgent({
-      httpProxy: options.httpProxy,
-      certificateFile: options.httpProxyCertificateFilename,
+      httpProxy: flags.httpProxy,
+      certificateFile: flags.httpProxyCertificateFilename,
     })
     const apiOpts = { ...apiUrlOpts, agent }
     const api = new NetlifyAPI(token || '', apiOpts)
@@ -454,33 +599,44 @@ export default class BaseCommand extends Command {
     // options.site as a site name (and not just site id) was introduced for the deploy command, so users could
     // deploy by name along with by id
     let siteData = siteInfo
-    if (!siteData.url && options.site) {
-      siteData = await getSiteByName(api, options.site)
+    if (!siteData.url && flags.site) {
+      siteData = await getSiteByName(api, flags.site)
     }
 
     const globalConfig = await getGlobalConfig()
 
-    // Get framework, add to analytics payload for every command, if a framework is set
-    const fs = new NodeFS()
-    const project = new Project(fs, buildDir)
-    const frameworks = await project.detectFrameworks()
-
+    // ==================================================
+    // Perform analytics reporting
+    // ==================================================
     const frameworkIDs = frameworks?.map((framework) => framework.id)
-
     if (frameworkIDs?.length !== 0) {
       this.setAnalyticsPayload({ frameworks: frameworkIDs })
     }
-
     this.setAnalyticsPayload({
-      packageManager: project.packageManager?.name,
-      buildSystem: project.buildSystems.map(({ id }) => id),
+      monorepo: Boolean(this.project.workspace),
+      packageManager: this.project.packageManager?.name,
+      buildSystem: this.project.buildSystems.map(({ id }) => id),
     })
 
+    // set the project and the netlify api object on the command,
+    // to be accessible inside each command.
+    actionCommand.project = this.project
+    actionCommand.workingDir = this.workingDir
+    actionCommand.workspacePackage = this.workspacePackage
+    actionCommand.jsWorkspaceRoot = this.jsWorkspaceRoot
+
+    // Either an existing configuration file from `@netlify/config` or a file path
+    // that should be used for creating it.
+    const configFilePath = configPath || join(this.workingDir, 'netlify.toml')
+
     actionCommand.netlify = {
       // api methods
       api,
       apiOpts,
+      // The absolute repository root (detected through @netlify/config)
       repositoryRoot,
+      configFilePath,
+      relConfigFilePath: relative(repositoryRoot, configFilePath),
       // current site context
       site: {
         root: buildDir,
@@ -508,26 +664,38 @@ export default class BaseCommand extends Command {
 
   /**
    * Find and resolve the Netlify configuration
-   * @param {*} config
-   * @returns {ReturnType<import('@netlify/config/src/main')>}
+   * @param {object} config
+   * @param {string} config.cwd
+   * @param {string|null=} config.token
+   * @param {*} config.state
+   * @param {boolean=} config.offline
+   * @param {string=} config.configFilePath An optional path to the netlify configuration file e.g. netlify.toml
+   * @param {string=} config.packagePath
+   * @param {string=} config.repositoryRoot
+   * @param {string=} config.host
+   * @param {string=} config.pathPrefix
+   * @param {string=} config.scheme
+   * @returns {ReturnType<typeof resolveConfig>}
    */
   async getConfig(config) {
-    const options = this.opts()
-    const { cwd, host, offline = options.offline, pathPrefix, scheme, state, token } = config
+    // the flags that are passed to the command like `--debug` or `--offline`
+    const flags = this.opts()
 
     try {
       return await resolveConfig({
-        config: options.config,
-        cwd,
-        context: options.context || process.env.CONTEXT || this.getDefaultContext(),
-        debug: this.opts().debug,
-        siteId: options.siteId || (typeof options.site === 'string' && options.site) || state.get('siteId'),
-        token,
+        config: config.configFilePath,
+        packagePath: config.packagePath,
+        repositoryRoot: config.repositoryRoot,
+        cwd: config.cwd,
+        context: flags.context || process.env.CONTEXT || this.getDefaultContext(),
+        debug: flags.debug,
+        siteId: flags.siteId || (typeof flags.site === 'string' && flags.site) || config.state.get('siteId'),
+        token: config.token,
         mode: 'cli',
-        host,
-        pathPrefix,
-        scheme,
-        offline,
+        host: config.host,
+        pathPrefix: config.pathPrefix,
+        scheme: config.scheme,
+        offline: config.offline ?? flags.offline,
         siteFeatureFlagPrefix: 'cli',
       })
     } catch (error_) {
@@ -539,17 +707,17 @@ export default class BaseCommand extends Command {
       //
       // @todo Replace this with a mechanism for calling `resolveConfig` with more granularity (i.e. having
       // the option to say that we don't need API data.)
-      if (isUserError && !offline && token) {
-        if (this.opts().debug) {
+      if (isUserError && !config.offline && config.token) {
+        if (flags.debug) {
           error(error_, { exit: false })
           warn('Failed to resolve config, falling back to offline resolution')
         }
-        return this.getConfig({ cwd, offline: true, state, token })
+        // recursive call with trying to resolve offline
+        return this.getConfig({ ...config, offline: true })
       }
 
       const message = isUserError ? error_.message : error_.stack
-      console.error(message)
-      exit(1)
+      error(message, { exit: true })
     }
   }
 
@@ -558,13 +726,22 @@ export default class BaseCommand extends Command {
    * set. The default context is `dev` most of the time, but some commands may
    * wish to override that.
    *
-   * @returns {string}
+   * @returns {'production' | 'dev'}
    */
   getDefaultContext() {
-    if (this.name() === 'serve') {
-      return 'production'
-    }
+    return this.name() === 'serve' ? 'production' : 'dev'
+  }
+}
 
-    return 'dev'
+/**
+ * Retrieves the repository root through a git command.
+ * Returns undefined if not a git project.
+ * @param {string} [cwd] The optional current working directory
+ * @returns {Promise<string|undefined>}
+ */
+async function getRepositoryRoot(cwd) {
+  const res = await findUp('.git', { cwd, type: 'directory' })
+  if (res) {
+    return join(res, '..')
   }
 }

package/src/commands/build/build.mjs

@@ -2,6 +2,7 @@
 import process from 'process'
 
 import { getBuildOptions, runBuild } from '../../lib/build.mjs'
+import { detectFrameworkSettings } from '../../utils/build-info.mjs'
 import { error, exit, getToken } from '../../utils/command-helpers.mjs'
 import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
 
@@ -33,11 +34,18 @@ const injectEnv = async function (command, { api, buildOptions, context, siteInf
  * @param {import('../base-command.mjs').default} command
  */
 const build = async (options, command) => {
+  const { cachedConfig, siteInfo } = command.netlify
   command.setAnalyticsPayload({ dry: options.dry })
   // Retrieve Netlify Build options
   const [token] = await getToken()
+  const settings = await detectFrameworkSettings(command, 'build')
+
+  // override the build command with the detection result if no command is specified through the config
+  if (!cachedConfig.config.build.command) {
+    cachedConfig.config.build.command = settings?.buildCommand
+    cachedConfig.config.build.commandOrigin = 'heuristics'
+  }
 
-  const { cachedConfig, siteInfo } = command.netlify
   const buildOptions = await getBuildOptions({
     cachedConfig,
     token,