netlify-cli 15.10.0 → 16.0.0-alpha.0

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

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

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

@@ -16,7 +16,7 @@ const normalizeFunction = function (deployedFunctions, { name, urlPath: url }) {
  * @param {import('../base-command.mjs').default} command
  */
 const functionsList = async (options, command) => {
-  const { config, siteInfo } = command.netlify
+  const { config, relConfigFilePath, siteInfo } = command.netlify
 
   const deploy = siteInfo.published_deploy || {}
   const deployedFunctions = deploy.available_functions || []
@@ -25,8 +25,8 @@ const functionsList = async (options, command) => {
 
   if (typeof functionsDir === 'undefined') {
     log('Functions directory is undefined')
-    log('Please verify functions.directory is set in your Netlify configuration file (netlify.toml/yml/json)')
-    log('See https://docs.netlify.com/configure-builds/file-based-configuration/ for more information')
+    log(`Please verify that 'functions.directory' is set in your Netlify configuration file ${relConfigFilePath}`)
+    log('Refer to https://docs.netlify.com/configure-builds/file-based-configuration/ for more information')
     exit(1)
   }
 

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

@@ -39,6 +39,7 @@ const functionsServe = async (options, command) => {
   await startFunctionsServer({
     config,
     debug: options.debug,
+    command,
     api,
     settings: { functions: functionsDir, functionsPort },
     site,

package/src/commands/init/init.mjs

@@ -196,7 +196,7 @@ export const init = async (options, command) => {
   }
 
   // Look for local repo
-  const repoData = await getRepoData({ remoteName: options.gitRemoteName })
+  const repoData = await getRepoData({ workingDir: command.workingDir, remoteName: options.gitRemoteName })
   if (repoData.error) {
     await handleNoGitRemoteAndExit({ command, error: repoData.error, state })
   }

package/src/commands/link/link.mjs

@@ -11,11 +11,11 @@ import { track } from '../../utils/telemetry/index.mjs'
 
 /**
  *
- * @param {import('../base-command.mjs').NetlifyOptions} netlify
+ * @param {import('../base-command.mjs').default} command
  * @param {import('commander').OptionValues} options
  */
-const linkPrompt = async (netlify, options) => {
-  const { api, state } = netlify
+const linkPrompt = async (command, options) => {
+  const { api, state } = command.netlify
 
   const SITE_NAME_PROMPT = 'Search by full or partial site name'
   const SITE_LIST_PROMPT = 'Choose from a list of your recently updated sites'
@@ -24,7 +24,7 @@ const linkPrompt = async (netlify, options) => {
   let GIT_REMOTE_PROMPT = 'Use the current git remote origin URL'
   let site
   // Get git remote data if exists
-  const repoData = await getRepoData({ remoteName: options.gitRemoteName })
+  const repoData = await getRepoData({ workingDir: command.workingDir, remoteName: options.gitRemoteName })
 
   let linkChoices = [SITE_NAME_PROMPT, SITE_LIST_PROMPT, SITE_ID_PROMPT]
 
@@ -326,7 +326,7 @@ export const link = async (options, command) => {
       kind: 'byName',
     })
   } else {
-    siteData = await linkPrompt(command.netlify, options)
+    siteData = await linkPrompt(command, options)
   }
   return siteData
 }

package/src/commands/serve/serve.mjs

@@ -38,6 +38,7 @@ const serve = async (options, command) => {
   const devConfig = {
     ...(config.functionsDirectory && { functions: config.functionsDirectory }),
     ...(config.build.publish && { publish: config.build.publish }),
+
     ...config.dev,
     ...options,
     // Override the `framework` value so that we start a static server and not
@@ -69,10 +70,9 @@ const serve = async (options, command) => {
   // Netlify Build are loaded.
   await getInternalFunctionsDir({ base: site.root, ensureExists: true })
 
-  /** @type {Partial<import('../../utils/types').ServerSettings>} */
-  let settings = {}
+  let settings = /** @type {import('../../utils/types.js').ServerSettings} */ ({})
   try {
-    settings = await detectServerSettings(devConfig, options, site.root)
+    settings = await detectServerSettings(devConfig, options, command)
 
     cachedConfig.config = getConfigWithPlugins(cachedConfig.config, settings)
   } catch (error_) {
@@ -87,7 +87,11 @@ const serve = async (options, command) => {
     `${NETLIFYDEVWARN} Changes will not be hot-reloaded, so if you need to rebuild your site you must exit and run 'netlify serve' again`,
   )
 
-  const { configPath: configPathOverride } = await runBuildTimeline({ cachedConfig, options, settings, site })
+  const { configPath: configPathOverride } = await runBuildTimeline({
+    command,
+    settings,
+    options,
+  })
 
   await startFunctionsServer({
     api,
@@ -117,8 +121,7 @@ const serve = async (options, command) => {
 
   // TODO: We should consolidate this with the existing config watcher.
   const getUpdatedConfig = async () => {
-    const cwd = options.cwd || process.cwd()
-    const { config: newConfig } = await command.getConfig({ cwd, offline: true, state })
+    const { config: newConfig } = await command.getConfig({ cwd: command.workingDir, offline: true, state })
     const normalizedNewConfig = normalizeConfig(newConfig)
 
     return normalizedNewConfig
@@ -135,6 +138,7 @@ const serve = async (options, command) => {
     getUpdatedConfig,
     inspectSettings,
     offline: options.offline,
+    projectDir: command.workingDir,
     settings,
     site,
     siteInfo,

package/src/commands/sites/sites-create-template.mjs

@@ -197,7 +197,7 @@ const sitesCreateTemplate = async (repository, options, command) => {
 
   if (options.withCi) {
     log('Configuring CI')
-    const repoData = await getRepoData()
+    const repoData = await getRepoData({ workingDir: command.workingDir })
     await configureRepo({ command, siteId: site.id, repoData, manual: options.manual })
   }
 

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

@@ -102,7 +102,7 @@ export const sitesCreate = async (options, command) => {
 
   if (options.withCi) {
     log('Configuring CI')
-    const repoData = await getRepoData()
+    const repoData = await getRepoData({ workingDir: command.workingDir })
     await configureRepo({ command, siteId: site.id, repoData, manual: options.manual })
   }
 

package/src/functions-templates/javascript/google-analytics/package.json

@@ -7,7 +7,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "engines": {
-    "node": "^14.18.0 || >=16.0.0"
+    "node": ">=16.16.0"
   },
   "keywords": [
     "netlify",

package/src/functions-templates/typescript/scheduled-function/package.json

@@ -16,7 +16,7 @@
   "license": "MIT",
   "dependencies": {
     "@netlify/functions": "^1.6.0",
-    "@types/node": "^14.18.9",
+    "@types/node": "^18.0.0",
     "typescript": "^4.5.5"
   }
 }

package/src/lib/edge-functions/deploy.mjs

@@ -8,8 +8,12 @@ import { EDGE_FUNCTIONS_FOLDER, PUBLIC_URL_PATH } from './consts.mjs'
 
 const distPath = getPathInProject([EDGE_FUNCTIONS_FOLDER])
 
-export const deployFileNormalizer = (rootDir, file) => {
-  const absoluteDistPath = join(rootDir, distPath)
+/**
+ * @param {string} workingDir
+ * @param {*} file
+ */
+export const deployFileNormalizer = (workingDir, file) => {
+  const absoluteDistPath = join(workingDir, distPath)
   const isEdgeFunction = file.root === absoluteDistPath
   const normalizedPath = isEdgeFunction ? `${PUBLIC_URL_PATH}/${file.normalizedPath}` : file.normalizedPath
 
@@ -19,9 +23,12 @@ export const deployFileNormalizer = (rootDir, file) => {
   }
 }
 
-export const getDistPathIfExists = async ({ rootDir }) => {
+/**
+ * @param {string} workingDir
+ */
+export const getDistPathIfExists = async (workingDir) => {
   try {
-    const absoluteDistPath = join(rootDir, distPath)
+    const absoluteDistPath = join(workingDir, distPath)
     const stats = await stat(absoluteDistPath)
 
     if (!stats.isDirectory()) {

package/src/lib/edge-functions/internal.mjs

@@ -1,14 +1,16 @@
 // @ts-check
 import { readFile, stat } from 'fs/promises'
 import { dirname, join, resolve } from 'path'
-import { cwd } from 'process'
 
 import { getPathInProject } from '../settings.mjs'
 
 import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.mjs'
 
-export const getInternalFunctions = async () => {
-  const path = join(cwd(), getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]))
+/**
+ * @param {string} workingDir
+ */
+export const getInternalFunctions = async (workingDir) => {
+  const path = join(workingDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]))
 
   try {
     const stats = await stat(path)

package/src/lib/edge-functions/proxy.mjs

@@ -1,7 +1,7 @@
 // @ts-check
 import { Buffer } from 'buffer'
-import { relative } from 'path'
-import { cwd, env } from 'process'
+import { join, relative } from 'path'
+import { env } from 'process'
 
 // eslint-disable-next-line import/no-namespace
 import * as bundler from '@netlify/edge-bundler'
@@ -62,6 +62,26 @@ export const createAccountInfoHeader = (accountInfo = {}) => {
   return Buffer.from(accountString).toString('base64')
 }
 
+/**
+ *
+ * @param {object} config
+ * @param {*} config.accountId
+ * @param {*} config.config
+ * @param {*} config.configPath
+ * @param {*} config.debug
+ * @param {*} config.env
+ * @param {*} config.geoCountry
+ * @param {*} config.geolocationMode
+ * @param {*} config.getUpdatedConfig
+ * @param {*} config.inspectSettings
+ * @param {*} config.mainPort
+ * @param {boolean=} config.offline
+ * @param {*} config.passthroughPort
+ * @param {*} config.projectDir
+ * @param {*} config.siteInfo
+ * @param {*} config.state
+ * @returns
+ */
 export const initializeProxy = async ({
   accountId,
   config,
@@ -79,7 +99,11 @@ export const initializeProxy = async ({
   siteInfo,
   state,
 }) => {
-  const { functions: internalFunctions, importMap, path: internalFunctionsPath } = await getInternalFunctions()
+  const {
+    functions: internalFunctions,
+    importMap,
+    path: internalFunctionsPath,
+  } = await getInternalFunctions(projectDir)
   const userFunctionsPath = config.build.edge_functions
   const isolatePort = await getAvailablePort()
 
@@ -133,7 +157,7 @@ export const initializeProxy = async ({
         )} matches declaration for edge function ${chalk.yellow(
           functionName,
         )}, but there's no matching function file in ${chalk.yellow(
-          relative(cwd(), userFunctionsPath),
+          relative(projectDir, userFunctionsPath),
         )}. Please visit ${chalk.blue('https://ntl.fyi/edge-create')} for more information.`,
       )
     })
@@ -193,7 +217,7 @@ const prepareServer = async ({
       ...getDownloadUpdateFunctions(),
       bootstrapURL: getBootstrapURL(),
       debug: env.NETLIFY_DENO_DEBUG === 'true',
-      distImportMapPath,
+      distImportMapPath: join(projectDir, distImportMapPath),
       formatExportTypeError: (name) =>
         `${NETLIFYDEVERR} ${chalk.red('Failed')} to load Edge Function ${chalk.yellow(
           name,

package/src/lib/functions/netlify-function.mjs

@@ -1,9 +1,14 @@
 // @ts-check
+import { version as nodeVersion } from 'process'
+
 import CronParser from 'cron-parser'
+import semver from 'semver'
 
 import { error as errorExit } from '../../utils/command-helpers.mjs'
 import { BACKGROUND } from '../../utils/functions/get-functions.mjs'
 
+const V2_MIN_NODE_VERSION = '18.0.0'
+
 // Returns a new set with all elements of `setA` that don't exist in `setB`.
 const difference = (setA, setB) => new Set([...setA].filter((item) => !setB.has(item)))
 
@@ -27,12 +32,13 @@ export default class NetlifyFunction {
     timeoutBackground,
     timeoutSynchronous,
   }) {
+    this.buildError = null
     this.config = config
     this.directory = directory
     this.errorExit = errorExit
     this.mainFile = mainFile
     this.name = name
-    this.displayName = displayName
+    this.displayName = displayName ?? name
     this.projectRoot = projectRoot
     this.runtime = runtime
     this.timeoutBackground = timeoutBackground
@@ -63,6 +69,10 @@ export default class NetlifyFunction {
     return Boolean(this.schedule)
   }
 
+  isSupported() {
+    return !(this.buildData?.runtimeAPIVersion === 2 && semver.lt(nodeVersion, V2_MIN_NODE_VERSION))
+  }
+
   async getNextRun() {
     if (!(await this.isScheduled())) {
       return null
@@ -93,11 +103,22 @@ export default class NetlifyFunction {
       const srcFilesDiff = this.getSrcFilesDiff(srcFilesSet)
 
       this.buildData = buildData
+      this.buildError = null
       this.srcFiles = srcFilesSet
       this.schedule = schedule || this.schedule
 
+      if (!this.isSupported()) {
+        throw new Error(
+          `Function requires Node.js version ${V2_MIN_NODE_VERSION} or above, but ${nodeVersion.slice(
+            1,
+          )} is installed. Refer to https://ntl.fyi/functions-node18 for information on how to update.`,
+        )
+      }
+
       return { includedFiles, srcFilesDiff }
     } catch (error) {
+      this.buildError = error
+
       return { error }
     }
   }
@@ -118,6 +139,10 @@ export default class NetlifyFunction {
   async invoke(event, context) {
     await this.buildQueue
 
+    if (this.buildError) {
+      return { result: null, error: { errorMessage: this.buildError.message } }
+    }
+
     const timeout = this.isBackground ? this.timeoutBackground : this.timeoutSynchronous
 
     try {

package/src/lib/functions/registry.mjs

@@ -6,15 +6,7 @@ import { env } from 'process'
 import { listFunctions } from '@netlify/zip-it-and-ship-it'
 import extractZip from 'extract-zip'
 
-import {
-  chalk,
-  getTerminalLink,
-  log,
-  NETLIFYDEVERR,
-  NETLIFYDEVLOG,
-  warn,
-  watchDebounced,
-} from '../../utils/command-helpers.mjs'
+import { chalk, log, NETLIFYDEVERR, NETLIFYDEVLOG, warn, watchDebounced } from '../../utils/command-helpers.mjs'
 import { INTERNAL_FUNCTIONS_FOLDER, SERVE_FUNCTIONS_FOLDER } from '../../utils/functions/functions.mjs'
 import { BACKGROUND_FUNCTIONS_WARNING } from '../log.mjs'
 import { getPathInProject } from '../settings.mjs'
@@ -70,21 +62,23 @@ export class FunctionsRegistry {
     )
   }
 
-  async buildFunctionAndWatchFiles(func, { verbose = false } = {}) {
-    if (verbose) {
-      log(`${NETLIFYDEVLOG} ${chalk.magenta('Reloading')} function ${chalk.yellow(func.name)}...`)
+  async buildFunctionAndWatchFiles(func, firstLoad = false) {
+    if (!firstLoad) {
+      log(`${NETLIFYDEVLOG} ${chalk.magenta('Reloading')} function ${chalk.yellow(func.displayName)}...`)
     }
 
-    const { error_, includedFiles, srcFilesDiff } = await func.build({ cache: this.buildCache })
+    const { error: buildError, includedFiles, srcFilesDiff } = await func.build({ cache: this.buildCache })
 
-    if (error_) {
+    if (buildError) {
       log(
-        `${NETLIFYDEVERR} ${chalk.red('Failed')} reloading function ${chalk.yellow(func.name)} with error:\n${
-          error_.message
+        `${NETLIFYDEVERR} ${chalk.red('Failed to load')} function ${chalk.yellow(func.displayName)}: ${
+          buildError.message
         }`,
       )
-    } else if (verbose) {
-      log(`${NETLIFYDEVLOG} ${chalk.green('Reloaded')} function ${chalk.yellow(func.name)}`)
+    } else {
+      const verb = firstLoad ? 'Loaded' : 'Reloaded'
+
+      log(`${NETLIFYDEVLOG} ${chalk.green(verb)} function ${chalk.yellow(func.displayName)}`)
     }
 
     // If the build hasn't resulted in any files being added or removed, there
@@ -116,7 +110,7 @@ export class FunctionsRegistry {
 
       const newWatcher = await watchDebounced(filesToWatch, {
         onChange: () => {
-          this.buildFunctionAndWatchFiles(func, { verbose: true })
+          this.buildFunctionAndWatchFiles(func, false)
         },
       })
 
@@ -163,14 +157,8 @@ export class FunctionsRegistry {
     }
 
     this.functions.set(name, func)
-    this.buildFunctionAndWatchFiles(func)
 
-    log(
-      `${NETLIFYDEVLOG} ${chalk.green('Loaded')} function ${getTerminalLink(
-        chalk.yellow(func.displayName || name),
-        func.url,
-      )}.`,
-    )
+    this.buildFunctionAndWatchFiles(func, true)
   }
 
   // This function is here so we can mock it in tests

package/src/lib/functions/runtimes/js/builders/zisi.mjs

@@ -105,8 +105,15 @@ const clearFunctionsCache = (functionsPath) => {
     .forEach(decache)
 }
 
-const getTargetDirectory = async ({ errorExit }) => {
-  const targetDirectory = path.resolve(getPathInProject([SERVE_FUNCTIONS_FOLDER]))
+/**
+ *
+ * @param {object} config
+ * @param {string} config.projectRoot
+ * @param {(msg: string) => void} config.errorExit
+ * @returns
+ */
+const getTargetDirectory = async ({ errorExit, projectRoot }) => {
+  const targetDirectory = path.resolve(projectRoot, getPathInProject([SERVE_FUNCTIONS_FOLDER]))
 
   try {
     await mkdir(targetDirectory, { recursive: true })
@@ -120,6 +127,16 @@ const getTargetDirectory = async ({ errorExit }) => {
 const netlifyConfigToZisiConfig = ({ config, projectRoot }) =>
   addFunctionsConfigDefaults(normalizeFunctionsConfig({ functionsConfig: config.functions, projectRoot }))
 
+/**
+ *
+ * @param {object} param0
+ * @param {*} param0.config
+ * @param {*} param0.directory
+ * @param {*} param0.errorExit
+ * @param {*} param0.func
+ * @param {*} param0.metadata
+ * @param {string} param0.projectRoot
+ */
 export default async function handler({ config, directory, errorExit, func, metadata, projectRoot }) {
   const functionsConfig = netlifyConfigToZisiConfig({ config, projectRoot })
 
@@ -153,7 +170,7 @@ export default async function handler({ config, directory, errorExit, func, meta
   // Enable source map support.
   sourceMapSupport.install()
 
-  const targetDirectory = await getTargetDirectory({ errorExit })
+  const targetDirectory = await getTargetDirectory({ projectRoot, errorExit })
 
   return {
     build: ({ cache = {} }) =>

package/src/lib/functions/runtimes/js/worker.mjs

@@ -11,7 +11,7 @@ if (isMainThread) {
 
 sourceMapSupport.install()
 
-lambdaLocal.getLogger().level = 'warn'
+lambdaLocal.getLogger().level = 'alert'
 
 const { clientContext, entryFilePath, event, timeoutMs } = workerData
 

package/src/lib/functions/server.mjs

@@ -220,7 +220,7 @@ const getFunctionsServer = (options) => {
 }
 
 export const startFunctionsServer = async (options) => {
-  const { capabilities, config, debug, loadDistFunctions, settings, site, siteUrl, timeouts } = options
+  const { capabilities, command, config, debug, loadDistFunctions, settings, site, siteUrl, timeouts } = options
   const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root })
   const functionsDirectories = []
 
@@ -250,7 +250,8 @@ export const startFunctionsServer = async (options) => {
     config,
     debug,
     isConnected: Boolean(siteUrl),
-    projectRoot: site.root,
+    // functions always need to be inside the packagePath if set inside a monorepo
+    projectRoot: command.workingDir,
     settings,
     timeouts,
   })

package/src/lib/spinner.mjs

@@ -17,7 +17,7 @@ export const startSpinner = ({ text }) =>
  * Stops the spinner with the following text
  * @param {object} config
  * @param {ora.Ora} config.spinner
- * @param {object} [config.error]
+ * @param {boolean} [config.error]
  * @param {string} [config.text]
  * @returns {void}
  */

package/src/recipes/vscode/index.mjs

@@ -1,3 +1,4 @@
+// @ts-check
 import { join } from 'path'
 
 import { DenoBridge } from '@netlify/edge-bundler'
@@ -27,15 +28,24 @@ const getPrompt = ({ fileExists, path }) => {
 const getEdgeFunctionsPath = ({ config, repositoryRoot }) =>
   config.build.edge_functions || join(repositoryRoot, 'netlify', 'edge-functions')
 
+/**
+ * @param {string} repositoryRoot
+ */
 const getSettingsPath = (repositoryRoot) => join(repositoryRoot, '.vscode', 'settings.json')
 
-const hasDenoVSCodeExt = async () => {
-  const { stdout: extensions } = await execa('code', ['--list-extensions'], { stderr: 'inherit' })
+/**
+ * @param {string} repositoryRoot
+ */
+const hasDenoVSCodeExt = async (repositoryRoot) => {
+  const { stdout: extensions } = await execa('code', ['--list-extensions'], { stderr: 'inherit', cwd: repositoryRoot })
   return extensions.split('\n').includes('denoland.vscode-deno')
 }
 
-const getDenoVSCodeExt = async () => {
-  await execa('code', ['--install-extension', 'denoland.vscode-deno'], { stdio: 'inherit' })
+/**
+ * @param {string} repositoryRoot
+ */
+const getDenoVSCodeExt = async (repositoryRoot) => {
+  await execa('code', ['--install-extension', 'denoland.vscode-deno'], { stdio: 'inherit', cwd: repositoryRoot })
 }
 
 const getDenoExtPrompt = () => {
@@ -49,6 +59,12 @@ const getDenoExtPrompt = () => {
   })
 }
 
+/**
+ * @param {object} params
+ * @param {*} params.config
+ * @param {string} params.repositoryRoot
+ * @returns
+ */
 export const run = async ({ config, repositoryRoot }) => {
   const deno = new DenoBridge({
     onBeforeDownload: () =>
@@ -66,9 +82,11 @@ export const run = async ({ config, repositoryRoot }) => {
   }
 
   try {
-    if (!(await hasDenoVSCodeExt())) {
+    if (!(await hasDenoVSCodeExt(repositoryRoot))) {
       const { confirm: denoExtConfirm } = await getDenoExtPrompt()
-      if (denoExtConfirm) getDenoVSCodeExt()
+      if (denoExtConfirm) {
+        getDenoVSCodeExt(repositoryRoot)
+      }
     }
   } catch {
     log(