netlify-cli 15.10.0-rc.1 → 15.11.0

package/src/utils/detect-server-settings.mjs

@@ -1,28 +1,26 @@
 // @ts-check
 import { readFile } from 'fs/promises'
 import { EOL } from 'os'
-import { dirname, relative, resolve } from 'path'
-
-import { getFramework, getSettings } from '@netlify/build-info'
+import path from 'path'
+import process from 'process'
+
+import { Project } from '@netlify/build-info'
+// eslint-disable-next-line import/extensions, n/no-missing-import
+import { NodeFS } from '@netlify/build-info/node'
+import { getFramework, listFrameworks } from '@netlify/framework-info'
+import fuzzy from 'fuzzy'
 import getPort from 'get-port'
+import inquirer from 'inquirer'
+import inquirerAutocompletePrompt from 'inquirer-autocomplete-prompt'
 
-import { detectFrameworkSettings } from './build-info.mjs'
 import { NETLIFYDEVWARN, chalk, log } from './command-helpers.mjs'
 import { acquirePort } from './dev.mjs'
 import { getInternalFunctionsDir } from './functions/functions.mjs'
-import { getPluginsToAutoInstall } from './init/utils.mjs'
+import { reportError } from './telemetry/report-error.mjs'
 
-/** @param {string} str */
 const formatProperty = (str) => chalk.magenta(`'${str}'`)
-/** @param {string} str */
 const formatValue = (str) => chalk.green(`'${str}'`)
 
-/**
- * @param {object} options
- * @param {string} options.keyFile
- * @param {string} options.certFile
- * @returns {Promise<{ key: string, cert: string, keyFilePath: string, certFilePath: string }>}
- */
 const readHttpsSettings = async (options) => {
   if (typeof options !== 'object' || !options.keyFile || !options.certFile) {
     throw new TypeError(
@@ -40,43 +38,43 @@ const readHttpsSettings = async (options) => {
     throw new TypeError(`Certificate file configuration should be a string`)
   }
 
-  const [key, cert] = await Promise.allSettled([readFile(keyFile, 'utf-8'), readFile(certFile, 'utf-8')])
+  const [{ reason: keyError, value: key }, { reason: certError, value: cert }] = await Promise.allSettled([
+    readFile(keyFile, 'utf-8'),
+    readFile(certFile, 'utf-8'),
+  ])
 
-  if (key.status === 'rejected') {
-    throw new Error(`Error reading private key file: ${key.reason}`)
+  if (keyError) {
+    throw new Error(`Error reading private key file: ${keyError.message}`)
   }
-  if (cert.status === 'rejected') {
-    throw new Error(`Error reading certificate file: ${cert.reason}`)
+  if (certError) {
+    throw new Error(`Error reading certificate file: ${certError.message}`)
   }
 
-  return { key: key.value, cert: cert.value, keyFilePath: resolve(keyFile), certFilePath: resolve(certFile) }
+  return { key, cert, keyFilePath: path.resolve(keyFile), certFilePath: path.resolve(certFile) }
 }
 
-/**
- * Validates a property inside the devConfig to be of a given type
- * @param {import('../commands/dev/types.js').DevConfig} devConfig The devConfig
- * @param {keyof import('../commands/dev/types.js').DevConfig} property The property to validate
- * @param {'string' | 'number'} type The type it should have
- */
-function validateProperty(devConfig, property, type) {
-  // eslint-disable-next-line valid-typeof
-  if (devConfig[property] && typeof devConfig[property] !== type) {
+const validateStringProperty = ({ devConfig, property }) => {
+  if (devConfig[property] && typeof devConfig[property] !== 'string') {
     const formattedProperty = formatProperty(property)
     throw new TypeError(
-      `Invalid ${formattedProperty} option provided in config. The value of ${formattedProperty} option must be of type ${type}`,
+      `Invalid ${formattedProperty} option provided in config. The value of ${formattedProperty} option must be a string`,
+    )
+  }
+}
+
+const validateNumberProperty = ({ devConfig, property }) => {
+  if (devConfig[property] && typeof devConfig[property] !== 'number') {
+    const formattedProperty = formatProperty(property)
+    throw new TypeError(
+      `Invalid ${formattedProperty} option provided in config. The value of ${formattedProperty} option must be an integer`,
     )
   }
 }
 
-/**
- *
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- */
 const validateFrameworkConfig = ({ devConfig }) => {
-  validateProperty(devConfig, 'command', 'string')
-  validateProperty(devConfig, 'port', 'number')
-  validateProperty(devConfig, 'targetPort', 'number')
+  validateStringProperty({ devConfig, property: 'command' })
+  validateNumberProperty({ devConfig, property: 'port' })
+  validateNumberProperty({ devConfig, property: 'targetPort' })
 
   if (devConfig.targetPort && devConfig.targetPort === devConfig.port) {
     throw new Error(
@@ -87,11 +85,6 @@ const validateFrameworkConfig = ({ devConfig }) => {
   }
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {number=} config.detectedPort
- */
 const validateConfiguredPort = ({ detectedPort, devConfig }) => {
   if (devConfig.port && devConfig.port === detectedPort) {
     const formattedPort = formatProperty('port')
@@ -104,22 +97,13 @@ const validateConfiguredPort = ({ detectedPort, devConfig }) => {
 const DEFAULT_PORT = 8888
 const DEFAULT_STATIC_PORT = 3999
 
-/**
- * Logs a message that it was unable to determine the dist directory and falls back to the workingDir
- * @param {string} workingDir
- */
-const getDefaultDist = (workingDir) => {
+const getDefaultDist = () => {
   log(`${NETLIFYDEVWARN} Unable to determine public folder to serve files from. Using current working directory`)
   log(`${NETLIFYDEVWARN} Setup a netlify.toml file with a [dev] section to specify your dev server settings.`)
   log(`${NETLIFYDEVWARN} See docs at: https://cli.netlify.com/netlify-dev#project-detection`)
-  return workingDir
+  return process.cwd()
 }
 
-/**
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @returns {Promise<number>}
- */
 const getStaticServerPort = async ({ devConfig }) => {
   const port = await acquirePort({
     configuredPort: devConfig.staticServerPort,
@@ -132,16 +116,16 @@ const getStaticServerPort = async ({ devConfig }) => {
 
 /**
  *
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {import('commander').OptionValues} config.flags
- * @param {string} config.workingDir
- * @returns {Promise<Omit<import('./types.js').BaseServerSettings, 'command'> & {command?: string}>}
+ * @param {object} param0
+ * @param {import('../commands/dev/types.js').DevConfig} param0.devConfig
+ * @param {import('commander').OptionValues} param0.options
+ * @param {string} param0.projectDir
+ * @returns {Promise<import('./types.js').BaseServerSettings>}
  */
-const handleStaticServer = async ({ devConfig, flags, workingDir }) => {
-  validateProperty(devConfig, 'staticServerPort', 'number')
+const handleStaticServer = async ({ devConfig, options, projectDir }) => {
+  validateNumberProperty({ devConfig, property: 'staticServerPort' })
 
-  if (flags.dir) {
+  if (options.dir) {
     log(`${NETLIFYDEVWARN} Using simple static server because ${formatProperty('--dir')} flag was specified`)
   } else if (devConfig.framework === '#static') {
     log(
@@ -159,8 +143,8 @@ const handleStaticServer = async ({ devConfig, flags, workingDir }) => {
     )
   }
 
-  const dist = flags.dir || devConfig.publish || getDefaultDist(workingDir)
-  log(`${NETLIFYDEVWARN} Running static server from "${relative(dirname(workingDir), dist)}"`)
+  const dist = options.dir || devConfig.publish || getDefaultDist()
+  log(`${NETLIFYDEVWARN} Running static server from "${path.relative(path.dirname(projectDir), dist)}"`)
 
   const frameworkPort = await getStaticServerPort({ devConfig })
   return {
@@ -173,39 +157,144 @@ const handleStaticServer = async ({ devConfig, flags, workingDir }) => {
 
 /**
  * Retrieves the settings from a framework
- * @param {import('@netlify/build-info').Settings} [settings]
- * @returns {import('./types.js').BaseServerSettings | undefined}
+ * @param {import('./types.js').FrameworkInfo} framework
+ * @returns {import('./types.js').BaseServerSettings}
  */
-const getSettingsFromDetectedSettings = (settings) => {
-  if (!settings) {
-    return
-  }
+const getSettingsFromFramework = (framework) => {
+  const {
+    build: { directory: dist },
+    dev: {
+      commands: [command],
+      pollingStrategies = [],
+      port: frameworkPort,
+    },
+    env = {},
+    name: frameworkName,
+    plugins,
+    staticAssetsDirectory: staticDir,
+  } = framework
+
   return {
-    baseDirectory: settings.baseDirectory,
-    command: settings.devCommand,
-    frameworkPort: settings.frameworkPort,
-    dist: settings.dist,
-    framework: settings.framework.name,
-    env: settings.env,
-    pollingStrategies: settings.pollingStrategies,
-    plugins: getPluginsToAutoInstall(settings.plugins_from_config_file, settings.plugins_recommended),
+    command,
+    frameworkPort,
+    dist: staticDir || dist,
+    framework: frameworkName,
+    env,
+    pollingStrategies: pollingStrategies.map(({ name }) => name),
+    plugins,
   }
 }
 
+const hasDevCommand = (framework) => Array.isArray(framework.dev.commands) && framework.dev.commands.length !== 0
+
 /**
- * @param {import('../commands/dev/types.js').DevConfig} devConfig
+ * The new build setting detection with build systems and frameworks combined
+ * @param {string} projectDir
  */
-const hasCommandAndTargetPort = (devConfig) => devConfig.command && devConfig.targetPort
+const detectSettings = async (projectDir) => {
+  const fs = new NodeFS()
+  const project = new Project(fs, projectDir)
+
+  return await project.getBuildSettings()
+}
+
+/**
+ *
+ * @param {import('./types.js').BaseServerSettings | undefined} frameworkSettings
+ * @param {import('@netlify/build-info').Settings[]} newSettings
+ * @param {Record<string, Record<string, any>>} [metadata]
+ */
+const detectChangesInNewSettings = (frameworkSettings, newSettings, metadata) => {
+  /** @type {string[]} */
+  const message = ['']
+  const [setting] = newSettings
+
+  if (frameworkSettings?.framework !== setting?.framework.name) {
+    message.push(
+      `- Framework does not match:`,
+      `   [old]: ${frameworkSettings?.framework}`,
+      `   [new]: ${setting?.framework.name}`,
+      '',
+    )
+  }
+
+  if (frameworkSettings?.command !== setting?.devCommand) {
+    message.push(
+      `- command does not match:`,
+      `   [old]: ${frameworkSettings?.command}`,
+      `   [new]: ${setting?.devCommand}`,
+      '',
+    )
+  }
+
+  if (frameworkSettings?.dist !== setting?.dist) {
+    message.push(`- dist does not match:`, `   [old]: ${frameworkSettings?.dist}`, `   [new]: ${setting?.dist}`, '')
+  }
+
+  if (frameworkSettings?.frameworkPort !== setting?.frameworkPort) {
+    message.push(
+      `- frameworkPort does not match:`,
+      `   [old]: ${frameworkSettings?.frameworkPort}`,
+      `   [new]: ${setting?.frameworkPort}`,
+      '',
+    )
+  }
+
+  if (message.length !== 0) {
+    reportError(
+      {
+        name: 'NewSettingsDetectionMismatch',
+        errorMessage: 'New Settings detection does not match old one',
+        message: message.join('\n'),
+      },
+      { severity: 'info', metadata },
+    )
+  }
+}
+
+const detectFrameworkSettings = async ({ projectDir }) => {
+  const projectFrameworks = await listFrameworks({ projectDir })
+  const frameworks = projectFrameworks.filter((framework) => hasDevCommand(framework))
+
+  if (frameworks.length === 1) {
+    return getSettingsFromFramework(frameworks[0])
+  }
+
+  if (frameworks.length > 1) {
+    /** multiple matching detectors, make the user choose */
+    inquirer.registerPrompt('autocomplete', inquirerAutocompletePrompt)
+    const scriptInquirerOptions = formatSettingsArrForInquirer(frameworks)
+    const { chosenFramework } = await inquirer.prompt({
+      name: 'chosenFramework',
+      message: `Multiple possible start commands found`,
+      type: 'autocomplete',
+      source(_, input) {
+        if (!input || input === '') {
+          return scriptInquirerOptions
+        }
+        // only show filtered results
+        return filterSettings(scriptInquirerOptions, input)
+      },
+    })
+    log(
+      `Add ${formatProperty(
+        `framework = "${chosenFramework.id}"`,
+      )} to the [dev] section of your netlify.toml to avoid this selection prompt next time`,
+    )
+
+    return getSettingsFromFramework(chosenFramework)
+  }
+}
+
+const hasCommandAndTargetPort = ({ devConfig }) => devConfig.command && devConfig.targetPort
 
 /**
  * Creates settings for the custom framework
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {string} config.workingDir
+ * @param {*} param0
  * @returns {import('./types.js').BaseServerSettings}
  */
-const handleCustomFramework = ({ devConfig, workingDir }) => {
-  if (!hasCommandAndTargetPort(devConfig)) {
+const handleCustomFramework = ({ devConfig }) => {
+  if (!hasCommandAndTargetPort({ devConfig })) {
     throw new Error(
       `${formatProperty('command')} and ${formatProperty('targetPort')} properties are required when ${formatProperty(
         'framework',
@@ -215,100 +304,101 @@ const handleCustomFramework = ({ devConfig, workingDir }) => {
   return {
     command: devConfig.command,
     frameworkPort: devConfig.targetPort,
-    dist: devConfig.publish || getDefaultDist(workingDir),
+    dist: devConfig.publish || getDefaultDist(),
     framework: '#custom',
     pollingStrategies: devConfig.pollingStrategies || [],
   }
 }
 
-/**
- * Merges the framework settings with the devConfig
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {string} config.workingDir
- * @param {Partial<import('./types.js').BaseServerSettings>=} config.frameworkSettings
- */
-const mergeSettings = async ({ devConfig, frameworkSettings = {}, workingDir }) => {
-  const command = devConfig.command || frameworkSettings.command
-  const frameworkPort = devConfig.targetPort || frameworkSettings.frameworkPort
+const mergeSettings = async ({ devConfig, frameworkSettings = {} }) => {
+  const {
+    command: frameworkCommand,
+    dist,
+    env,
+    framework,
+    frameworkPort: frameworkDetectedPort,
+    pollingStrategies = [],
+  } = frameworkSettings
+
+  const command = devConfig.command || frameworkCommand
+  const frameworkPort = devConfig.targetPort || frameworkDetectedPort
   // if the framework doesn't start a server, we use a static one
   const useStaticServer = !(command && frameworkPort)
   return {
-    baseDirectory: devConfig.base || frameworkSettings.baseDirectory,
     command,
     frameworkPort: useStaticServer ? await getStaticServerPort({ devConfig }) : frameworkPort,
-    dist: devConfig.publish || frameworkSettings.dist || getDefaultDist(workingDir),
-    framework: frameworkSettings.framework,
-    env: frameworkSettings.env,
-    pollingStrategies: frameworkSettings.pollingStrategies || [],
+    dist: devConfig.publish || dist || getDefaultDist(),
+    framework,
+    env,
+    pollingStrategies,
     useStaticServer,
   }
 }
 
 /**
  * Handles a forced framework and retrieves the settings for it
- * @param {object} config
- * @param {import('../commands/dev/types.js').DevConfig} config.devConfig
- * @param {import('@netlify/build-info').Project} config.project
- * @param {string} config.workingDir
- * @param {string=} config.workspacePackage
+ * @param {*} param0
  * @returns {Promise<import('./types.js').BaseServerSettings>}
  */
-const handleForcedFramework = async ({ devConfig, project, workingDir, workspacePackage }) => {
+const handleForcedFramework = async ({ devConfig, projectDir }) => {
   // this throws if `devConfig.framework` is not a supported framework
-  const framework = await getFramework(devConfig.framework, project)
-  const settings = await getSettings(framework, project, workspacePackage || '')
-  const frameworkSettings = getSettingsFromDetectedSettings(settings)
-  return mergeSettings({ devConfig, workingDir, frameworkSettings })
+  const frameworkSettings = getSettingsFromFramework(await getFramework(devConfig.framework, { projectDir }))
+  return mergeSettings({ devConfig, frameworkSettings })
 }
 
 /**
  * Get the server settings based on the flags and the devConfig
  * @param {import('../commands/dev/types.js').DevConfig} devConfig
- * @param {import('commander').OptionValues} flags
- * @param {import('../commands/base-command.mjs').default} command
+ * @param {import('commander').OptionValues} options
+ * @param {string} projectDir
+ * @param {Record<string, Record<string, any>>} [metadata]
  * @returns {Promise<import('./types.js').ServerSettings>}
  */
-
-const detectServerSettings = async (devConfig, flags, command) => {
-  validateProperty(devConfig, 'framework', 'string')
+const detectServerSettings = async (devConfig, options, projectDir, metadata) => {
+  validateStringProperty({ devConfig, property: 'framework' })
 
   /** @type {Partial<import('./types.js').BaseServerSettings>} */
   let settings = {}
 
-  if (flags.dir || devConfig.framework === '#static') {
+  if (options.dir || devConfig.framework === '#static') {
     // serving files statically without a framework server
-    settings = await handleStaticServer({ flags, devConfig, workingDir: command.workingDir })
+    settings = await handleStaticServer({ options, devConfig, projectDir })
   } else if (devConfig.framework === '#auto') {
     // this is the default CLI behavior
 
-    const runDetection = !hasCommandAndTargetPort(devConfig)
-    const frameworkSettings = runDetection
-      ? getSettingsFromDetectedSettings(await detectFrameworkSettings(command, 'dev'))
-      : undefined
+    const runDetection = !hasCommandAndTargetPort({ devConfig })
+    const frameworkSettings = runDetection ? await detectFrameworkSettings({ projectDir }) : undefined
+    const newSettings = runDetection ? await detectSettings(projectDir) : undefined
+
+    // just report differences in the settings
+    detectChangesInNewSettings(frameworkSettings, newSettings || [], {
+      ...metadata,
+      settings: {
+        projectDir,
+        devConfig,
+        options,
+        old: frameworkSettings,
+        settings: newSettings,
+      },
+    })
+
     if (frameworkSettings === undefined && runDetection) {
       log(`${NETLIFYDEVWARN} No app server detected. Using simple static server`)
-      settings = await handleStaticServer({ flags, devConfig, workingDir: command.workingDir })
+      settings = await handleStaticServer({ options, devConfig, projectDir })
     } else {
       validateFrameworkConfig({ devConfig })
-
-      settings = await mergeSettings({ devConfig, frameworkSettings, workingDir: command.workingDir })
+      settings = await mergeSettings({ devConfig, frameworkSettings })
     }
 
-    settings.plugins = frameworkSettings?.plugins
+    settings.plugins = frameworkSettings && frameworkSettings.plugins
   } else if (devConfig.framework === '#custom') {
     validateFrameworkConfig({ devConfig })
     // when the users wants to configure `command` and `targetPort`
-    settings = handleCustomFramework({ devConfig, workingDir: command.workingDir })
+    settings = handleCustomFramework({ devConfig })
   } else if (devConfig.framework) {
     validateFrameworkConfig({ devConfig })
     // this is when the user explicitly configures a framework, e.g. `framework = "gatsby"`
-    settings = await handleForcedFramework({
-      devConfig,
-      project: command.project,
-      workingDir: command.workingDir,
-      workspacePackage: command.workspacePackage,
-    })
+    settings = await handleForcedFramework({ devConfig, projectDir })
   }
 
   validateConfiguredPort({ devConfig, detectedPort: settings.frameworkPort })
@@ -319,7 +409,7 @@ const detectServerSettings = async (devConfig, flags, command) => {
     errorMessage: `Could not acquire required ${formatProperty('port')}`,
   })
   const functionsDir = devConfig.functions || settings.functions
-  const internalFunctionsDir = await getInternalFunctionsDir({ base: command.workingDir })
+  const internalFunctionsDir = await getInternalFunctionsDir({ base: projectDir })
   const shouldStartFunctionsServer = Boolean(functionsDir || internalFunctionsDir)
 
   return {
@@ -333,6 +423,28 @@ const detectServerSettings = async (devConfig, flags, command) => {
   }
 }
 
+const filterSettings = function (scriptInquirerOptions, input) {
+  const filterOptions = scriptInquirerOptions.map((scriptInquirerOption) => scriptInquirerOption.name)
+  // TODO: remove once https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1394 is fixed
+  // eslint-disable-next-line unicorn/no-array-method-this-argument
+  const filteredSettings = fuzzy.filter(input, filterOptions)
+  const filteredSettingNames = new Set(
+    filteredSettings.map((filteredSetting) => (input ? filteredSetting.string : filteredSetting)),
+  )
+  return scriptInquirerOptions.filter((t) => filteredSettingNames.has(t.name))
+}
+
+const formatSettingsArrForInquirer = function (frameworks) {
+  const formattedArr = frameworks.map((framework) =>
+    framework.dev.commands.map((command) => ({
+      name: `[${chalk.yellow(framework.name)}] '${command}'`,
+      value: { ...framework, commands: [command] },
+      short: `${framework.name}-${command}`,
+    })),
+  )
+  return formattedArr.flat()
+}
+
 /**
  * Returns a copy of the provided config with any plugins provided by the
  * server settings

package/src/utils/framework-server.mjs

@@ -18,14 +18,13 @@ const FRAMEWORK_PORT_TIMEOUT = 6e5
 /**
  * Start a static server if the `useStaticServer` is provided or a framework specific server
  * @param {object} config
- * @param {import('./types.js').ServerSettings} config.settings
- * @param {string} config.cwd
+ * @param {Partial<import('./types').ServerSettings>} config.settings
  * @returns {Promise<StartReturnObject>}
  */
-export const startFrameworkServer = async function ({ cwd, settings }) {
+export const startFrameworkServer = async function ({ settings }) {
   if (settings.useStaticServer) {
     if (settings.command) {
-      runCommand(settings.command, { env: settings.env, cwd })
+      runCommand(settings.command, settings.env)
     }
     await startStaticServer({ settings })
 
@@ -38,7 +37,7 @@ export const startFrameworkServer = async function ({ cwd, settings }) {
     text: `Waiting for framework port ${settings.frameworkPort}. This can be configured using the 'targetPort' property in the netlify.toml`,
   })
 
-  runCommand(settings.command, { env: settings.env, spinner, cwd })
+  runCommand(settings.command, settings.env, spinner)
 
   let port
   try {
@@ -47,7 +46,7 @@ export const startFrameworkServer = async function ({ cwd, settings }) {
       host: 'localhost',
       output: 'silent',
       timeout: FRAMEWORK_PORT_TIMEOUT,
-      ...(settings.pollingStrategies?.includes('HTTP') && { protocol: 'http' }),
+      ...(settings.pollingStrategies.includes('HTTP') && { protocol: 'http' }),
     })
 
     if (!port.open) {

package/src/utils/functions/functions.mjs

@@ -17,7 +17,11 @@ export const SERVE_FUNCTIONS_FOLDER = 'functions-serve'
  * @returns {string}
  */
 export const getFunctionsDir = ({ config, options }, defaultValue) =>
-  options.functions || config.dev?.functions || config.functionsDirectory || config.dev?.Functions || defaultValue
+  options.functions ||
+  (config.dev && config.dev.functions) ||
+  config.functionsDirectory ||
+  (config.dev && config.dev.Functions) ||
+  defaultValue
 
 export const getFunctionsManifestPath = async ({ base }) => {
   const path = resolve(base, getPathInProject(['functions', 'manifest.json']))
@@ -33,13 +37,6 @@ export const getFunctionsDistPath = async ({ base }) => {
   return isDirectory ? path : null
 }
 
-/**
- * Retrieves the internal functions directory and creates it if ensureExists is provided
- * @param {object} config
- * @param {string} config.base
- * @param {boolean=} config.ensureExists
- * @returns
- */
 export const getInternalFunctionsDir = async ({ base, ensureExists }) => {
   const path = resolve(base, getPathInProject([INTERNAL_FUNCTIONS_FOLDER]))
 

package/src/utils/get-repo-data.mjs

@@ -1,5 +1,6 @@
 // @ts-check
 import { dirname } from 'path'
+import process from 'process'
 import util from 'util'
 
 import { findUp } from 'find-up'
@@ -13,14 +14,14 @@ import { log } from './command-helpers.mjs'
  *
  * @param {object} config
  * @param {string} [config.remoteName]
- * @param {string} config.workingDir
  * @returns
  */
-const getRepoData = async function ({ remoteName, workingDir }) {
+const getRepoData = async function ({ remoteName } = {}) {
   try {
+    const cwd = process.cwd()
     const [gitConfig, gitDirectory] = await Promise.all([
-      util.promisify(gitconfiglocal)(workingDir),
-      findUp('.git', { cwd: workingDir, type: 'directory' }),
+      util.promisify(gitconfiglocal)(cwd),
+      findUp('.git', { cwd, type: 'directory' }),
     ])
 
     if (!gitDirectory || !gitConfig || !gitConfig.remote || Object.keys(gitConfig.remote).length === 0) {
@@ -29,7 +30,7 @@ const getRepoData = async function ({ remoteName, workingDir }) {
 
     const baseGitPath = dirname(gitDirectory)
 
-    if (workingDir !== baseGitPath) {
+    if (cwd !== baseGitPath) {
       log(`Git directory located in ${baseGitPath}`)
     }
 

package/src/utils/init/config-github.mjs

@@ -207,7 +207,7 @@ export const configGithub = async ({ command, repoName, repoOwner, siteId }) =>
   const { netlify } = command
   const {
     api,
-    cachedConfig: { configPath },
+    cachedConfig: { configPath, env },
     config,
     globalConfig,
     repositoryRoot,
@@ -220,7 +220,7 @@ export const configGithub = async ({ command, repoName, repoOwner, siteId }) =>
     repositoryRoot,
     siteRoot,
     config,
-    command,
+    env,
   })
   await saveNetlifyToml({ repositoryRoot, config, configPath, baseDir, buildCmd, buildDir, functionsDir })