netlify-cli 15.10.0-rc.1 → 15.11.0

package/src/commands/build/build.mjs

@@ -2,7 +2,6 @@
 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'
 
@@ -34,18 +33,11 @@ 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,

package/src/commands/deploy/deploy.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 import { stat } from 'fs/promises'
 import { basename, resolve } from 'path'
-import { env } from 'process'
+import { cwd, env } from 'process'
 
 import { runCoreSteps } from '@netlify/build'
 import { restoreConfig, updateConfig } from '@netlify/config'
@@ -64,18 +64,16 @@ const triggerDeploy = async ({ api, options, siteData, siteId }) => {
 /**
  * g
  * @param {object} config
- * @param {string} config.workingDir The process working directory
  * @param {object} config.config
  * @param {import('commander').OptionValues} config.options
  * @param {object} config.site
  * @param {object} config.siteData
  * @returns {Promise<string>}
  */
-const getDeployFolder = async ({ config, options, site, siteData, workingDir }) => {
-  console.log()
+const getDeployFolder = async ({ config, options, site, siteData }) => {
   let deployFolder
   if (options.dir) {
-    deployFolder = resolve(site.root, options.dir)
+    deployFolder = resolve(cwd(), options.dir)
   } else if (config?.build?.publish) {
     deployFolder = resolve(site.root, config.build.publish)
   } else if (siteData?.build_settings?.dir) {
@@ -84,13 +82,14 @@ const getDeployFolder = async ({ config, options, site, siteData, workingDir })
 
   if (!deployFolder) {
     log('Please provide a publish directory (e.g. "public" or "dist" or "."):')
+    log(cwd())
     const { promptPath } = await inquirer.prompt([
       {
         type: 'input',
         name: 'promptPath',
         message: 'Publish directory',
         default: '.',
-        filter: (input) => resolve(workingDir, input),
+        filter: (input) => resolve(cwd(), input),
       },
     ])
     deployFolder = promptPath
@@ -129,15 +128,14 @@ const validateDeployFolder = async ({ deployFolder }) => {
  * @param {import('commander').OptionValues} config.options
  * @param {object} config.site
  * @param {object} config.siteData
- * @param {string} config.workingDir // The process working directory
  * @returns {string}
  */
-const getFunctionsFolder = ({ config, options, site, siteData, workingDir }) => {
+const getFunctionsFolder = ({ config, options, site, siteData }) => {
   let functionsFolder
   // Support "functions" and "Functions"
   const funcConfig = config.functionsDirectory
   if (options.functions) {
-    functionsFolder = resolve(workingDir, options.functions)
+    functionsFolder = resolve(cwd(), options.functions)
   } else if (funcConfig) {
     functionsFolder = resolve(site.root, funcConfig)
   } else if (siteData?.build_settings?.functions_dir) {
@@ -180,21 +178,12 @@ const validateFolders = async ({ deployFolder, functionsFolder }) => {
   return { deployFolderStat, functionsFolderStat }
 }
 
-/**
- * @param {object} config
- * @param {string} config.deployFolder
- * @param {*} config.site
- * @returns
- */
 const getDeployFilesFilter = ({ deployFolder, site }) => {
   // site.root === deployFolder can happen when users run `netlify deploy --dir .`
   // in that specific case we don't want to publish the repo node_modules
   // when site.root !== deployFolder the behaviour matches our buildbot
   const skipNodeModules = site.root === deployFolder
 
-  /**
-   * @param {string} filename
-   */
   return (filename) => {
     if (filename == null) {
       return false
@@ -507,7 +496,6 @@ const printResults = ({ deployToProduction, json, results, runBuildCommand }) =>
  * @param {import('../base-command.mjs').default} command
  */
 const deploy = async (options, command) => {
-  const { workingDir } = command
   const { api, site, siteInfo } = command.netlify
   const alias = options.alias || options.branch
 
@@ -572,18 +560,16 @@ const deploy = async (options, command) => {
       siteInfo: siteData,
     })
   }
-
   const { configMutations = [], newConfig } = await handleBuild({
     cachedConfig: command.netlify.cachedConfig,
     options,
   })
   const config = newConfig || command.netlify.config
 
-  const deployFolder = await getDeployFolder({ workingDir, options, config, site, siteData })
-  const functionsFolder = getFunctionsFolder({ workingDir, options, config, site, siteData })
+  const deployFolder = await getDeployFolder({ options, config, site, siteData })
+  const functionsFolder = getFunctionsFolder({ options, config, site, siteData })
   const { configPath } = site
   const edgeFunctionsConfig = command.netlify.config.edge_functions
-  console.log({ functionsFolder, edgeFunctionsConfig })
 
   // build flag wasn't used and edge functions exist
   if (!options.build && edgeFunctionsConfig && edgeFunctionsConfig.length !== 0) {

package/src/commands/dev/dev.mjs

@@ -9,6 +9,7 @@ import { printBanner } from '../../utils/banner.mjs'
 import {
   BANG,
   chalk,
+  exit,
   log,
   NETLIFYDEV,
   NETLIFYDEVERR,
@@ -34,7 +35,7 @@ import { createDevExecCommand } from './dev-exec.mjs'
  * @param {object} config
  * @param {*} config.api
  * @param {import('commander').OptionValues} config.options
- * @param {import('../../utils/types.js').ServerSettings} config.settings
+ * @param {*} config.settings
  * @param {*} config.site
  * @param {*} config.state
  * @returns
@@ -67,9 +68,6 @@ const handleLiveTunnel = async ({ api, options, settings, site, state }) => {
   }
 }
 
-/**
- * @param {string} args
- */
 const validateShortFlagArgs = (args) => {
   if (args.startsWith('=')) {
     throw new Error(
@@ -96,13 +94,11 @@ const dev = async (options, command) => {
   const { api, cachedConfig, config, repositoryRoot, site, siteInfo, state } = command.netlify
   config.dev = { ...config.dev }
   config.build = { ...config.build }
-  /** @type {import('./types.js').DevConfig} */
+  /** @type {import('./types').DevConfig} */
   const devConfig = {
     framework: '#auto',
-    autoLaunch: Boolean(options.open),
     ...(config.functionsDirectory && { functions: config.functionsDirectory }),
     ...(config.build.publish && { publish: config.build.publish }),
-    ...(config.build.base && { base: config.build.base }),
     ...config.dev,
     ...options,
   }
@@ -128,17 +124,20 @@ const dev = async (options, command) => {
     siteInfo,
   })
 
-  /** @type {import('../../utils/types.js').ServerSettings} */
-  let settings
+  /** @type {Partial<import('../../utils/types').ServerSettings>} */
+  let settings = {}
   try {
-    settings = await detectServerSettings(devConfig, options, command)
+    settings = await detectServerSettings(devConfig, options, site.root, {
+      site: {
+        id: site.id,
+        url: siteUrl,
+      },
+    })
 
     cachedConfig.config = getConfigWithPlugins(cachedConfig.config, settings)
   } catch (error_) {
-    if (error_ && typeof error_ === 'object' && 'message' in error_) {
-      log(NETLIFYDEVERR, error_.message)
-    }
-    process.exit(1)
+    log(NETLIFYDEVERR, error_.message)
+    exit(1)
   }
 
   command.setAnalyticsPayload({ live: options.live })
@@ -152,9 +151,10 @@ const dev = async (options, command) => {
   log(`${NETLIFYDEVWARN} Setting up local development server`)
 
   const { configPath: configPathOverride } = await runDevTimeline({
-    command,
+    cachedConfig,
     options,
     settings,
+    site,
     env: {
       URL: url,
       DEPLOY_URL: url,
@@ -188,11 +188,8 @@ const dev = async (options, command) => {
 
   // TODO: We should consolidate this with the existing config watcher.
   const getUpdatedConfig = async () => {
-    const { config: newConfig } = await command.getConfig({
-      cwd: command.workingDir,
-      offline: true,
-      state,
-    })
+    const cwd = options.cwd || process.cwd()
+    const { config: newConfig } = await command.getConfig({ cwd, offline: true, state })
     const normalizedNewConfig = normalizeConfig(newConfig)
 
     return normalizedNewConfig
@@ -205,7 +202,6 @@ const dev = async (options, command) => {
     config,
     configPath: configPathOverride,
     debug: options.debug,
-    projectDir: command.workingDir,
     env,
     getUpdatedConfig,
     inspectSettings,
@@ -252,7 +248,6 @@ export const createDevCommand = (program) => {
         .argParser((value) => Number.parseInt(value))
         .hideHelp(true),
     )
-    .addOption(new Option('--no-open', 'disables the automatic opening of a browser window'))
     .option('--target-port <port>', 'port of target app server', (value) => Number.parseInt(value))
     .option('--framework <name>', 'framework to use. Defaults to #auto which automatically detects a framework')
     .option('-d ,--dir <path>', 'dir with static files')

package/src/commands/functions/functions-create.mjs

@@ -3,7 +3,7 @@ import cp from 'child_process'
 import fs from 'fs'
 import { mkdir, readdir, unlink } from 'fs/promises'
 import { createRequire } from 'module'
-import path, { dirname, join, relative } from 'path'
+import path, { dirname } from 'path'
 import process from 'process'
 import { fileURLToPath, pathToFileURL } from 'url'
 import { promisify } from 'util'
@@ -12,6 +12,7 @@ import copyTemplateDirOriginal from 'copy-template-dir'
 import { findUp } from 'find-up'
 import fuzzy from 'fuzzy'
 import inquirer from 'inquirer'
+import inquirerAutocompletePrompt from 'inquirer-autocomplete-prompt'
 import fetch from 'node-fetch'
 import ora from 'ora'
 
@@ -30,10 +31,8 @@ const templatesDir = path.resolve(dirname(fileURLToPath(import.meta.url)), '../.
 
 const showRustTemplates = process.env.NETLIFY_EXPERIMENTAL_BUILD_RUST_SOURCE === 'true'
 
-/**
- * Ensure that there's a sub-directory in `src/functions-templates` named after
- * each `value` property in this list.
- */
+// Ensure that there's a sub-directory in `src/functions-templates` named after
+// each `value` property in this list.
 const languages = [
   { name: 'JavaScript', value: 'javascript' },
   { name: 'TypeScript', value: 'typescript' },
@@ -92,28 +91,23 @@ const filterRegistry = function (registry, input) {
     })
 }
 
-/**
- * @param {string} lang
- * @param {'edge' | 'serverless'} funcType
- */
 const formatRegistryArrayForInquirer = async function (lang, funcType) {
-  const folders = await readdir(path.join(templatesDir, lang), { withFileTypes: true })
+  const folderNames = await readdir(path.join(templatesDir, lang))
 
   const imports = await Promise.all(
-    folders
-      .filter((folder) => Boolean(folder?.isDirectory()))
-      .map(async ({ name }) => {
-        try {
-          const templatePath = path.join(templatesDir, lang, name, '.netlify-function-template.mjs')
-          const template = await import(pathToFileURL(templatePath))
-          return template.default
-        } catch {
-          // noop if import fails we don't break the whole inquirer
-        }
+    folderNames
+      // filter out markdown files
+      .filter((folderName) => !folderName.endsWith('.md'))
+      .map(async (folderName) => {
+        const templatePath = path.join(templatesDir, lang, folderName, '.netlify-function-template.mjs')
+        const template = await import(pathToFileURL(templatePath))
+
+        return template.default
       }),
   )
+
   const registry = imports
-    .filter((template) => template?.functionType === funcType)
+    .filter((template) => template.functionType === funcType)
     .sort((templateA, templateB) => {
       const priorityDiff = (templateA.priority || DEFAULT_PRIORITY) - (templateB.priority || DEFAULT_PRIORITY)
 
@@ -142,7 +136,7 @@ const formatRegistryArrayForInquirer = async function (lang, funcType) {
 /**
  * pick template from our existing templates
  * @param {import('commander').OptionValues} config
- * @param {'edge' | 'serverless'} funcType
+ *
  */
 const pickTemplate = async function ({ language: languageFromFlag }, funcType) {
   const specialCommands = [
@@ -178,6 +172,8 @@ const pickTemplate = async function ({ language: languageFromFlag }, funcType) {
     language = languageFromPrompt
   }
 
+  inquirer.registerPrompt('autocomplete', inquirerAutocompletePrompt)
+
   let templatesForLanguage
 
   try {
@@ -211,7 +207,6 @@ const pickTemplate = async function ({ language: languageFromFlag }, funcType) {
 
 const DEFAULT_PRIORITY = 999
 
-/** @returns {Promise<'edge' | 'serverless'>} */
 const selectTypeOfFunc = async () => {
   const functionTypes = [
     { name: 'Edge function (Deno)', value: 'edge' },
@@ -229,100 +224,92 @@ const selectTypeOfFunc = async () => {
   return functionType
 }
 
-/**
- * @param {import('../base-command.mjs').default} command
- */
 const ensureEdgeFuncDirExists = function (command) {
   const { config, site } = command.netlify
   const siteId = site.id
+  let functionsDirHolder = config.build.edge_functions
 
   if (!siteId) {
     error(`${NETLIFYDEVERR} No site id found, please run inside a site directory or \`netlify link\``)
   }
 
-  const functionsDir = config.build?.edge_functions ?? join(command.workingDir, 'netlify/edge-functions')
-  const relFunctionsDir = relative(command.workingDir, functionsDir)
+  if (!functionsDirHolder) {
+    functionsDirHolder = 'netlify/edge-functions'
+  }
 
-  if (!fs.existsSync(functionsDir)) {
+  if (!fs.existsSync(functionsDirHolder)) {
     log(
       `${NETLIFYDEVLOG} Edge Functions directory ${chalk.magenta.inverse(
-        relFunctionsDir,
+        functionsDirHolder,
       )} does not exist yet, creating it...`,
     )
 
-    fs.mkdirSync(functionsDir, { recursive: true })
+    fs.mkdirSync(functionsDirHolder, { recursive: true })
 
-    log(`${NETLIFYDEVLOG} Edge Functions directory ${chalk.magenta.inverse(relFunctionsDir)} created.`)
+    log(`${NETLIFYDEVLOG} Edge Functions directory ${chalk.magenta.inverse(functionsDirHolder)} created.`)
   }
-
-  return functionsDir
+  return functionsDirHolder
 }
 
 /**
- * Prompts the user to choose a functions directory
+ * Get functions directory (and make it if necessary)
  * @param {import('../base-command.mjs').default} command
- * @returns {Promise<string>} - functions directory or throws an error
+ * @returns {Promise<string|never>} - functions directory or throws an error
  */
-const promptFunctionsDirectory = async (command) => {
-  const { api, relConfigFilePath, site } = command.netlify
-  log(`\n${NETLIFYDEVLOG} functions directory not specified in ${relConfigFilePath} or UI settings`)
+const ensureFunctionDirExists = async function (command) {
+  const { api, config, site } = command.netlify
+  const siteId = site.id
+  let functionsDirHolder = config.functionsDirectory
 
-  if (!site.id) {
-    error(`${NETLIFYDEVERR} No site id found, please run inside a site directory or \`netlify link\``)
-  }
+  if (!functionsDirHolder) {
+    log(`${NETLIFYDEVLOG} functions directory not specified in netlify.toml or UI settings`)
 
-  const { functionsDir } = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'functionsDir',
-      message: 'Enter the path, relative to your site, where your functions should live:',
-      default: 'netlify/functions',
-    },
-  ])
+    if (!siteId) {
+      error(`${NETLIFYDEVERR} No site id found, please run inside a site directory or \`netlify link\``)
+    }
 
-  try {
-    log(`${NETLIFYDEVLOG} updating site settings with ${chalk.magenta.inverse(functionsDir)}`)
-
-    // @ts-ignore Typings of API are not correct
-    await api.updateSite({
-      siteId: site.id,
-      body: {
-        build_settings: {
-          functions_dir: functionsDir,
-        },
+    const { functionsDir } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'functionsDir',
+        message:
+          'Enter the path, relative to your site’s base directory in your repository, where your functions should live:',
+        default: 'netlify/functions',
       },
-    })
+    ])
 
-    log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(functionsDir)} updated in site settings`)
-  } catch {
-    throw error('Error updating site settings')
-  }
-  return functionsDir
-}
+    functionsDirHolder = functionsDir
 
-/**
- * Get functions directory (and make it if necessary)
- * @param {import('../base-command.mjs').default} command
- * @returns {Promise<string>} - functions directory or throws an error
- */
-const ensureFunctionDirExists = async function (command) {
-  const { config } = command.netlify
-  const functionsDirHolder =
-    config.functionsDirectory || join(command.workingDir, await promptFunctionsDirectory(command))
-  const relFunctionsDirHolder = relative(command.workingDir, functionsDirHolder)
+    try {
+      log(`${NETLIFYDEVLOG} updating site settings with ${chalk.magenta.inverse(functionsDirHolder)}`)
+
+      // @ts-ignore Typings of API are not correct
+      await api.updateSite({
+        siteId: site.id,
+        body: {
+          build_settings: {
+            functions_dir: functionsDirHolder,
+          },
+        },
+      })
 
-  if (!fs.existsSync(functionsDirHolder)) {
+      log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(functionsDirHolder)} updated in site settings`)
+    } catch {
+      throw error('Error updating site settings')
+    }
+  }
+
+  if (!(await fileExistsAsync(functionsDirHolder))) {
     log(
       `${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(
-        relFunctionsDirHolder,
+        functionsDirHolder,
       )} does not exist yet, creating it...`,
     )
 
     await mkdir(functionsDirHolder, { recursive: true })
 
-    log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(relFunctionsDirHolder)} created`)
+    log(`${NETLIFYDEVLOG} functions directory ${chalk.magenta.inverse(functionsDirHolder)} created`)
   }
-
   return functionsDirHolder
 }
 
@@ -383,24 +370,20 @@ const downloadFromURL = async function (command, options, argumentName, function
   }
 }
 
-/**
- * Takes a list of existing packages and a list of packages required by a
- * function, and returns the packages from the latter that aren't present
- * in the former. The packages are returned as an array of strings with the
- * name and version range (e.g. '@netlify/functions@0.1.0').
- */
+// Takes a list of existing packages and a list of packages required by a
+// function, and returns the packages from the latter that aren't present
+// in the former. The packages are returned as an array of strings with the
+// name and version range (e.g. '@netlify/functions@0.1.0').
 const getNpmInstallPackages = (existingPackages = {}, neededPackages = {}) =>
   Object.entries(neededPackages)
     .filter(([name]) => existingPackages[name] === undefined)
     .map(([name, version]) => `${name}@${version}`)
 
-/**
- * When installing a function's dependencies, we first try to find a site-level
- * `package.json` file. If we do, we look for any dependencies of the function
- * that aren't already listed as dependencies of the site and install them. If
- * we don't do this check, we may be upgrading the version of a module used in
- * another part of the project, which we don't want to do.
- */
+// When installing a function's dependencies, we first try to find a site-level
+// `package.json` file. If we do, we look for any dependencies of the function
+// that aren't already listed as dependencies of the site and install them. If
+// we don't do this check, we may be upgrading the version of a module used in
+// another part of the project, which we don't want to do.
 const installDeps = async ({ functionPackageJson, functionPath, functionsDir }) => {
   const { dependencies: functionDependencies, devDependencies: functionDevDependencies } = require(functionPackageJson)
   const sitePackageJson = await findUp('package.json', { cwd: functionsDir })
@@ -447,8 +430,8 @@ const installDeps = async ({ functionPackageJson, functionPath, functionsDir })
  * @param {import('../base-command.mjs').default} command
  * @param {import('commander').OptionValues} options
  * @param {string} argumentName
- * @param {string} functionsDir Absolute path of the functions directory
- * @param {'edge' | 'serverless'} funcType
+ * @param {string} functionsDir
+ * @param {string} funcType
  */
 // eslint-disable-next-line max-params
 const scaffoldFromTemplate = async function (command, options, argumentName, functionsDir, funcType) {
@@ -460,7 +443,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
         name: 'chosenUrl',
         message: 'URL to clone: ',
         type: 'input',
-        validate: (/** @type {string} */ val) => Boolean(validateRepoURL(val)),
+        validate: (val) => Boolean(validateRepoURL(val)),
         // make sure it is not undefined and is a valid filename.
         // this has some nuance i have ignored, eg crossenv and i18n concerns
       },
@@ -523,7 +506,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
     }
 
     if (funcType === 'edge') {
-      registerEFInToml(name, command.netlify)
+      registerEFInToml(name)
     }
 
     await installAddons(command, addons, path.resolve(functionPath))
@@ -648,15 +631,9 @@ const installAddons = async function (command, functionAddons, fnPath) {
   return Promise.all(arr)
 }
 
-/**
- *
- * @param {string} funcName
- * @param {import('../types.js').NetlifyOptions} options
- */
-const registerEFInToml = async (funcName, options) => {
-  const { configFilePath, relConfigFilePath } = options
-  if (!fs.existsSync(configFilePath)) {
-    log(`${NETLIFYDEVLOG} \`${relConfigFilePath}\` file does not exist yet. Creating it...`)
+const registerEFInToml = async (funcName) => {
+  if (!fs.existsSync('netlify.toml')) {
+    log(`${NETLIFYDEVLOG} \`netlify.toml\` file does not exist yet. Creating it...`)
   }
 
   let { funcPath } = await inquirer.prompt([
@@ -679,22 +656,17 @@ const registerEFInToml = async (funcName, options) => {
   const functionRegister = `\n\n[[edge_functions]]\nfunction = "${funcName}"\npath = "${funcPath}"`
 
   try {
-    fs.promises.appendFile(configFilePath, functionRegister)
+    fs.promises.appendFile('netlify.toml', functionRegister)
     log(
-      `${NETLIFYDEVLOG} Function '${funcName}' registered for route \`${funcPath}\`. To change, edit your \`${relConfigFilePath}\` file.`,
+      `${NETLIFYDEVLOG} Function '${funcName}' registered for route \`${funcPath}\`. To change, edit your \`netlify.toml\` file.`,
     )
   } catch {
-    error(`${NETLIFYDEVERR} Unable to register function. Please check your \`${relConfigFilePath}\` file.`)
+    error(`${NETLIFYDEVERR} Unable to register function. Please check your \`netlify.toml\` file.`)
   }
 }
 
-/**
- * we used to allow for a --dir command,
- * but have retired that to force every scaffolded function to be a directory
- * @param {string} functionsDir
- * @param {string} name
- * @returns
- */
+// we used to allow for a --dir command,
+// but have retired that to force every scaffolded function to be a directory
 const ensureFunctionPathIsOk = function (functionsDir, name) {
   const functionPath = path.join(functionsDir, name)
   if (fs.existsSync(functionPath)) {
@@ -706,7 +678,6 @@ const ensureFunctionPathIsOk = function (functionsDir, name) {
 
 /**
  * The functions:create command
- * @param {string} name
  * @param {import('commander').OptionValues} options
  * @param {import('../base-command.mjs').default} command
  */

package/src/commands/functions/functions-invoke.mjs

@@ -2,6 +2,7 @@
 import fs from 'fs'
 import { createRequire } from 'module'
 import path from 'path'
+import process from 'process'
 
 import inquirer from 'inquirer'
 import fetch from 'node-fetch'
@@ -55,18 +56,14 @@ const formatQstring = function (querystring) {
   return ''
 }
 
-/**
- * process payloads from flag
- * @param {string} payloadString
- * @param {string} workingDir
- */
-const processPayloadFromFlag = function (payloadString, workingDir) {
+/** process payloads from flag */
+const processPayloadFromFlag = function (payloadString) {
   if (payloadString) {
     // case 1: jsonstring
     let payload = tryParseJSON(payloadString)
     if (payload) return payload
     // case 2: jsonpath
-    const payloadpath = path.join(workingDir, payloadString)
+    const payloadpath = path.join(process.cwd(), payloadString)
     const pathexists = fs.existsSync(payloadpath)
     if (pathexists) {
       try {
@@ -144,11 +141,11 @@ const getFunctionToTrigger = function (options, argumentName) {
  * @param {import('../base-command.mjs').default} command
  */
 const functionsInvoke = async (nameArgument, options, command) => {
-  const { config, relConfigFilePath } = command.netlify
+  const { config } = command.netlify
 
   const functionsDir = options.functions || (config.dev && config.dev.functions) || config.functionsDirectory
   if (typeof functionsDir === 'undefined') {
-    error(`functions directory is undefined, did you forget to set it in ${relConfigFilePath}?`)
+    error('functions directory is undefined, did you forget to set it in netlify.toml?')
   }
 
   if (!options.port)
@@ -213,7 +210,7 @@ const functionsInvoke = async (nameArgument, options, command) => {
       // }
     }
   }
-  const payload = processPayloadFromFlag(options.payload, command.workingDir)
+  const payload = processPayloadFromFlag(options.payload)
   body = { ...body, ...payload }
 
   try {