netlify-cli 16.7.0 → 16.8.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "netlify-cli",
   "description": "Netlify command line tool",
-  "version": "16.7.0",
+  "version": "16.8.1",
   "author": "Netlify Inc.",
   "type": "module",
   "engines": {
@@ -44,13 +44,14 @@
   "dependencies": {
     "@bugsnag/js": "7.20.2",
     "@fastify/static": "6.10.2",
-    "@netlify/build": "29.22.5",
+    "@netlify/build": "29.23.1",
     "@netlify/build-info": "7.10.1",
     "@netlify/config": "20.9.0",
-    "@netlify/edge-bundler": "9.1.0",
+    "@netlify/edge-bundler": "9.3.0",
     "@netlify/local-functions-proxy": "1.1.1",
+    "@netlify/sdk": "^1.1.5",
     "@netlify/serverless-functions-api": "1.9.1",
-    "@netlify/zip-it-and-ship-it": "9.24.3",
+    "@netlify/zip-it-and-ship-it": "9.25.1",
     "@octokit/rest": "19.0.13",
     "ansi-escapes": "6.2.0",
     "ansi-styles": "6.2.1",
@@ -104,6 +105,7 @@
     "is-stream": "3.0.0",
     "is-wsl": "2.2.0",
     "isexe": "2.0.0",
+    "js-yaml": "^4.1.0",
     "jsonwebtoken": "9.0.1",
     "jwt-decode": "3.1.2",
     "lambda-local": "2.1.2",

package/src/commands/build/build.mjs

@@ -9,9 +9,11 @@ import { getEnvelopeEnv, normalizeContext } from '../../utils/env/index.mjs'
 /**
  * @param {import('../../lib/build.mjs').BuildConfig} options
  */
-const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
+export const checkOptions = ({ cachedConfig: { siteInfo = {} }, token }) => {
   if (!siteInfo.id) {
-    error('Could not find the site ID. Please run netlify link.')
+    error(
+      'Could not find the site ID. If your site is not on Netlify, please run `netlify init` or `netlify deploy` first. If it is, please run `netlify link`.',
+    )
   }
 
   if (!token) {

package/src/commands/deploy/deploy.mjs

@@ -475,12 +475,13 @@ const bundleEdgeFunctions = async (options, command) => {
  *
  * @param {object} config
  * @param {boolean} config.deployToProduction
+ * @param {boolean} config.isIntegrationDeploy If the user ran netlify integration:deploy instead of just netlify deploy
  * @param {boolean} config.json If the result should be printed as json message
  * @param {boolean} config.runBuildCommand If the build command should be run
  * @param {object} config.results
  * @returns {void}
  */
-const printResults = ({ deployToProduction, json, results, runBuildCommand }) => {
+const printResults = ({ deployToProduction, isIntegrationDeploy, json, results, runBuildCommand }) => {
   const msgData = {
     'Build logs': results.logsUrl,
     'Function logs': results.functionLogsUrl,
@@ -518,7 +519,11 @@ const printResults = ({ deployToProduction, json, results, runBuildCommand }) =>
     if (!deployToProduction) {
       log()
       log('If everything looks good on your draft URL, deploy it to your main site URL with the --prod flag.')
-      log(`${chalk.cyanBright.bold(`netlify deploy${runBuildCommand ? ' --build' : ''} --prod`)}`)
+      log(
+        `${chalk.cyanBright.bold(
+          `netlify ${isIntegrationDeploy ? 'integration:' : ''}deploy${runBuildCommand ? ' --build' : ''} --prod`,
+        )}`,
+      )
       log()
     }
   }
@@ -529,7 +534,7 @@ const printResults = ({ deployToProduction, json, results, runBuildCommand }) =>
  * @param {import('commander').OptionValues} options
  * @param {import('../base-command.mjs').default} command
  */
-const deploy = async (options, command) => {
+export const deploy = async (options, command) => {
   const { workingDir } = command
   const { api, site, siteInfo } = command.netlify
   const alias = options.alias || options.branch
@@ -675,8 +680,11 @@ const deploy = async (options, command) => {
   // @ts-ignore
   await restoreConfig(configMutations, { buildDir: deployFolder, configPath, redirectsPath })
 
+  const isIntegrationDeploy = command.name() === 'integration:deploy'
+
   printResults({
     runBuildCommand: options.build,
+    isIntegrationDeploy,
     json: options.json,
     results,
     deployToProduction,

package/src/commands/integration/deploy.mjs

@@ -0,0 +1,397 @@
+/* eslint-disable import/extensions */
+import { resolve } from 'path'
+import { exit, env } from 'process'
+
+// eslint-disable-next-line n/no-missing-import
+import { getConfiguration } from '@netlify/sdk/cli-utils'
+// eslint-disable-next-line n/no-unpublished-import
+import fs from 'fs-extra'
+import inquirer from 'inquirer'
+import yaml from 'js-yaml'
+import fetch from 'node-fetch'
+
+import { getBuildOptions } from '../../lib/build.mjs'
+import { getToken, chalk, log } from '../../utils/command-helpers.mjs'
+import { getSiteInformation } from '../../utils/dev.mjs'
+import { checkOptions } from '../build/build.mjs'
+import { deploy as siteDeploy } from '../deploy/deploy.mjs'
+
+function getIntegrationAPIUrl() {
+  return env.INTEGRATION_URL || 'https://api.netlifysdk.com'
+}
+
+export function areScopesEqual(localScopes, remoteScopes) {
+  if (localScopes.length !== remoteScopes.length) {
+    return false
+  }
+
+  return localScopes.every((scope) => remoteScopes.includes(scope))
+}
+
+function logScopeConfirmationMessage(localScopes, remoteScopes) {
+  log(chalk.yellow(`This integration is already registered. The current required scopes are:`))
+  for (const scope of remoteScopes) {
+    log(chalk.green(`- ${scope}`))
+  }
+  log(chalk.yellow('and will be updated to:'))
+  for (const scope of localScopes) {
+    log(chalk.green(`- ${scope}`))
+  }
+  log(chalk.yellow('if you continue. This will only affect future installations of the integration.'))
+}
+
+function formatScopesToWrite(registeredIntegrationScopes) {
+  let scopesToWrite = {}
+
+  for (const scope of registeredIntegrationScopes) {
+    const [resource, permission] = scope.split(':')
+    if (resource === 'all') {
+      scopesToWrite = { all: true }
+      break
+    } else {
+      if (!scopesToWrite[resource]) {
+        scopesToWrite[resource] = []
+      }
+      scopesToWrite[resource].push(permission)
+    }
+  }
+  return scopesToWrite
+}
+
+function formatScopesForRemote(scopes) {
+  const scopesToWrite = []
+  if (scopes.all) {
+    scopesToWrite.push('all')
+  } else {
+    const scopeResources = Object.keys(scopes)
+    scopeResources.forEach((resource) => {
+      const permissionsRequested = scopes[resource]
+      permissionsRequested.forEach((permission) => {
+        scopesToWrite.push(`${resource}:${permission}`)
+      })
+    })
+  }
+  return scopesToWrite.join(',')
+}
+
+function verifyRequiredFieldsAreInConfig(name, description, scopes, integrationLevel) {
+  const missingFields = []
+
+  if (!name) {
+    missingFields.push('name')
+  }
+  if (!description) {
+    missingFields.push('description')
+  }
+  if (!scopes) {
+    missingFields.push('scopes')
+  }
+  if (!integrationLevel) {
+    missingFields.push('integrationLevel')
+  }
+  if (missingFields.length !== 0) {
+    log(
+      chalk.yellow(
+        `You are missing the following fields for the integration to be deployed: ${missingFields.join(
+          ', ',
+        )}. Please add a these fields as an entry to the integration.yaml file and try again.`,
+      ),
+    )
+    log(
+      chalk.yellow(
+        'For more information on the required fields, please see the documentation: https://ntl.fyi/create-private-integration',
+      ),
+    )
+    return false
+  }
+  return true
+}
+
+// eslint-disable-next-line max-params
+export async function registerIntegration(workingDir, siteId, accountId, localIntegrationConfig, token) {
+  const { description, integrationLevel, name, scopes, slug } = localIntegrationConfig
+  log(chalk.yellow(`An integration associated with the site ID ${siteId} is not registered.`))
+  const registerPrompt = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'registerIntegration',
+      message: `Would you like to register this site as a private integration now?`,
+      default: false,
+    },
+  ])
+
+  if (!registerPrompt.registerIntegration) {
+    log(
+      chalk.white(
+        "Cancelling deployment. Please run 'netlify int deploy' again when you are ready to register the integration.",
+      ),
+    )
+    log(
+      chalk.white(
+        "You can also register the integration through the Netlify UI on the 'Integrations' > 'Create private integration' page",
+      ),
+    )
+    exit(1)
+  }
+
+  if (!verifyRequiredFieldsAreInConfig(name, description, scopes, integrationLevel)) {
+    exit(1)
+  }
+
+  log(chalk.white('Registering the integration...'))
+
+  const { body, statusCode } = await fetch(`${getIntegrationAPIUrl()}/${accountId}/integrations`, {
+    method: 'POST',
+    headers: {
+      'netlify-token': token,
+    },
+    body: JSON.stringify({
+      name,
+      slug,
+      description,
+      hostSiteId: siteId,
+      scopes: formatScopesForRemote(scopes),
+      integrationLevel,
+    }),
+  }).then(async (res) => {
+    const response = await res.json()
+    return { body: response, statusCode: res.status }
+  })
+
+  if (statusCode !== 201) {
+    log(chalk.red(`There was an error registering the integration:`))
+    log()
+    log(chalk.red(`-----------------------------------------------`))
+    log(chalk.red(body.msg))
+    log(chalk.red(`-----------------------------------------------`))
+    log()
+    log(chalk.red(`Please try again. If the problem persists, please contact support.`))
+    exit(1)
+  }
+
+  log(chalk.green(`Successfully registered the integration with the slug: ${body.slug}`))
+
+  const updatedIntegrationConfig = yaml.dump({
+    config: { name, description, slug: body.slug, scopes, integrationLevel },
+  })
+
+  const filePath = resolve(workingDir, 'integration.yaml')
+  await fs.writeFile(filePath, updatedIntegrationConfig)
+
+  log(chalk.yellow('Your integration.yaml file has been updated. Please commit and push these changes.'))
+}
+
+// eslint-disable-next-line max-params
+export async function updateIntegration(
+  workingDir,
+  options,
+  siteId,
+  accountId,
+  localIntegrationConfig,
+  token,
+  registeredIntegration,
+) {
+  let { description, integrationLevel, name, scopes, slug } = localIntegrationConfig
+
+  let integrationSlug = slug
+  if (slug !== registeredIntegration.slug) {
+    // Update the project's integration.yaml file with the remote slug since that will
+    // be considered the source of truth and is a value that can't be edited by the user.
+    // Let the user know they need to commit and push the changes.
+    integrationSlug = registeredIntegration.slug
+  }
+
+  if (!name) {
+    // Disabling this lint rule because the destructuring was not assigning the variable correct and leading to a bug
+    // eslint-disable-next-line prefer-destructuring
+    name = registeredIntegration.name
+  }
+
+  if (!description) {
+    // eslint-disable-next-line prefer-destructuring
+    description = registeredIntegration.description
+  }
+
+  if (!integrationLevel) {
+    // eslint-disable-next-line prefer-destructuring
+    integrationLevel = registeredIntegration.integrationLevel
+  }
+
+  // This is returned as a comma separated string and will be easier to manage here as an array
+  const registeredIntegrationScopes = registeredIntegration.scopes.split(',')
+
+  const scopeResources = Object.keys(scopes)
+  let localScopes = []
+
+  if (scopeResources.includes('all')) {
+    localScopes = ['all']
+  } else {
+    scopeResources.forEach((resource) => {
+      const permissionsRequested = scopes[resource]
+      permissionsRequested.forEach((permission) => {
+        localScopes.push(`${resource}:${permission}`)
+      })
+    })
+  }
+
+  if (!areScopesEqual(localScopes, registeredIntegrationScopes)) {
+    logScopeConfirmationMessage(localScopes, registeredIntegrationScopes)
+
+    const scopePrompt = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'updateScopes',
+        message: `Do you want to update the scopes?`,
+        default: false,
+      },
+    ])
+
+    let scopesToWrite
+    if (scopePrompt.updateScopes) {
+      // Update the scopes in remote
+      scopesToWrite = scopes
+      const { statusCode, updateResponse } = await fetch(
+        `${getIntegrationAPIUrl()}/${accountId}/integrations/${integrationSlug}`,
+        {
+          method: 'PUT',
+          headers: {
+            'netlify-token': token,
+          },
+          body: JSON.stringify({
+            name,
+            description,
+            hostSiteId: siteId,
+            scopes: localScopes.join(','),
+            integrationLevel,
+          }),
+        },
+      ).then(async (res) => {
+        const response = await res.json()
+        return { updateResponse: response, statusCode: res.status }
+      })
+
+      if (statusCode !== 200) {
+        log(
+          chalk.red(`There was an error updating the integration: ${updateResponse}`),
+          chalk.red('Please try again. If the problem persists, please contact support.'),
+        )
+        exit(1)
+      }
+    } else {
+      const useRegisteredScopesPrompt = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'useRegisteredScopes',
+          message: `Do you want to save the scopes registered for your integration in your local configuration file?`,
+          default: false,
+        },
+      ])
+
+      if (useRegisteredScopesPrompt.useRegisteredScopes) {
+        // Use the scopes that are already registered
+        log(chalk.white('Saving the currently registered scopes to the integration.yaml file.'))
+        scopesToWrite = formatScopesToWrite(registeredIntegrationScopes)
+      }
+
+      if (!useRegisteredScopesPrompt.useRegisteredScopes && options.prod) {
+        log(chalk.red('Unable to deploy your integration to production without updating the registered scopes.'))
+        exit(1)
+      }
+    }
+
+    const updatedIntegrationConfig = yaml.dump({
+      config: { name, description, slug: integrationSlug, scopes: scopesToWrite, integrationLevel },
+    })
+
+    const filePath = resolve(workingDir, 'integration.yaml')
+    await fs.writeFile(filePath, updatedIntegrationConfig)
+
+    log(chalk.yellow('Changes to the integration.yaml file are complete. Please commit and push these changes.'))
+  }
+}
+
+/**
+ * The deploy command for Netlify Integrations
+ * @param {import('commander').OptionValues} options
+ * * @param {import('../base-command.mjs').default} command
+ */
+const deploy = async (options, command) => {
+  const { api, cachedConfig, site, siteInfo } = command.netlify
+  const { id: siteId } = site
+  const [token] = await getToken()
+  const workingDir = resolve(command.workingDir)
+  const buildOptions = await getBuildOptions({
+    cachedConfig,
+    packagePath: command.workspacePackage,
+    token,
+    options,
+  })
+
+  // Confirm that a site is linked and that the user is logged in
+  checkOptions(buildOptions)
+
+  const { description, integrationLevel, name, scopes, slug } = await getConfiguration()
+  const localIntegrationConfig = { name, description, scopes, slug, integrationLevel }
+
+  const { accountId } = await getSiteInformation({
+    api,
+    site,
+    siteInfo,
+  })
+
+  const { body: registeredIntegration, statusCode } = await fetch(
+    `${getIntegrationAPIUrl()}/${accountId}/integrations?site_id=${siteId}`,
+    {
+      headers: {
+        'netlify-token': token,
+      },
+    },
+  ).then(async (res) => {
+    const body = await res.json()
+    return { body, statusCode: res.status }
+  })
+
+  // The integration is registered on the remote
+  statusCode === 200
+    ? await updateIntegration(
+        workingDir,
+        options,
+        siteId,
+        accountId,
+        localIntegrationConfig,
+        token,
+        registeredIntegration,
+      )
+    : await registerIntegration(workingDir, siteId, accountId, localIntegrationConfig, token)
+
+  // Set the prod flag to true if the integration is being initially registered because we don't want the user
+  // to be in a weird state where the card is appearing in the integrations list but there's no production
+  // version of the integration deployed
+  options = statusCode === 200 ? options : { ...options, prod: true }
+
+  // Deploy the integration to that site
+  await siteDeploy(options, command)
+
+  log(
+    `${chalk.cyanBright.bold(
+      `Your integration has been deployed. Next step is to enable it for a team or site.`,
+    )} https://ntl.fyi/create-private-integration`,
+  )
+}
+
+/**
+ * Creates the `netlify int deploy` command
+ * @param {import('../base-command.mjs').default} program
+ * @returns
+ */
+export const createDeployCommand = (program) =>
+  program
+    .command('integration:deploy')
+    .alias('int:deploy')
+    .description('Register, build, and deploy a private integration on Netlify')
+    .option('-p, --prod', 'Deploy to production', false)
+    .option('-b, --build', 'Build the integration', false)
+    .option('-a, --auth <token>', 'Netlify auth token to deploy with', env.NETLIFY_AUTH_TOKEN)
+    .option('-s, --site <name-or-id>', 'A site name or ID to deploy to', env.NETLIFY_SITE_ID)
+    .action(deploy)
+/* eslint-enable import/extensions */

package/src/commands/integration/index.mjs

@@ -0,0 +1,25 @@
+import { createDeployCommand } from './deploy.mjs'
+
+/**
+ * The int command
+ * @param {import('commander').OptionValues} options
+ * @param {import('../base-command.mjs').default} command
+ */
+const integrations = (options, command) => {
+  command.help()
+}
+
+/**
+ * Creates the `netlify integration` command
+ * @param {import('../base-command.mjs').default} program
+ * @returns
+ */
+export const createIntegrationCommand = (program) => {
+  createDeployCommand(program)
+
+  return program
+    .command('integration')
+    .alias('int')
+    .description('Manage Netlify Integrations built with the Netlify SDK')
+    .action(integrations)
+}

package/src/commands/main.mjs

@@ -22,6 +22,7 @@ import { createDevCommand } from './dev/index.mjs'
 import { createEnvCommand } from './env/index.mjs'
 import { createFunctionsCommand } from './functions/index.mjs'
 import { createInitCommand } from './init/index.mjs'
+import { createIntegrationCommand } from './integration/index.mjs'
 import { createLinkCommand } from './link/index.mjs'
 import { createLmCommand } from './lm/index.mjs'
 import { createLoginCommand } from './login/index.mjs'
@@ -191,6 +192,7 @@ export const createMainCommand = () => {
   createFunctionsCommand(program)
   createRecipesCommand(program)
   createInitCommand(program)
+  createIntegrationCommand(program)
   createLinkCommand(program)
   createLmCommand(program)
   createLoginCommand(program)

package/src/lib/build.mjs

@@ -3,6 +3,8 @@ import process from 'process'
 
 import build from '@netlify/build'
 
+import { isFeatureFlagEnabled } from '../utils/feature-flags.mjs'
+
 import { getBootstrapURL } from './edge-functions/bootstrap.mjs'
 import { featureFlags as edgeFunctionsFeatureFlags } from './edge-functions/consts.mjs'
 
@@ -58,7 +60,7 @@ export const getBuildOptions = ({
 const getFeatureFlagsFromSiteInfo = (siteInfo) => ({
   ...siteInfo.feature_flags,
   // see https://github.com/netlify/pod-dev-foundations/issues/581#issuecomment-1731022753
-  zisi_golang_use_al2: siteInfo.featureFlags?.cli_golang_use_al2,
+  zisi_golang_use_al2: isFeatureFlagEnabled('cli_golang_use_al2', siteInfo),
 })
 
 /**

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

@@ -8,5 +8,6 @@ export const PUBLIC_URL_PATH = '.netlify/internal/edge-functions'
 // Netlify Build.
 export const featureFlags = {
   edge_functions_config_export: true,
+  edge_functions_npm_modules: true,
   edge_functions_read_deno_config: true,
 }

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

@@ -8,7 +8,6 @@ import * as bundler from '@netlify/edge-bundler'
 import getAvailablePort from 'get-port'
 
 import { NETLIFYDEVERR, NETLIFYDEVWARN, chalk, error as printError, log } from '../../utils/command-helpers.mjs'
-import { isFeatureFlagEnabled } from '../../utils/feature-flags.mjs'
 import { getGeoLocation } from '../geo-location.mjs'
 import { getPathInProject } from '../settings.mjs'
 import { startSpinner, stopSpinner } from '../spinner.mjs'
@@ -110,7 +109,7 @@ export const initializeProxy = async ({
   const userFunctionsPath = config.build.edge_functions
   const isolatePort = await getAvailablePort()
   const buildFeatureFlags = {
-    edge_functions_npm_modules: isFeatureFlagEnabled('edge_functions_npm_modules', siteInfo),
+    edge_functions_npm_modules: true,
   }
   const runtimeFeatureFlags = ['edge_functions_bootstrap_failure_mode']
 

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

@@ -40,9 +40,6 @@ export class EdgeFunctionsRegistry {
   /** @type {RunIsolate} */
   #runIsolate
 
-  /** @type {boolean} */
-  #hasShownNPMWarning = false
-
   /** @type {Error | null} */
   #buildError = null
 
@@ -167,22 +164,13 @@ export class EdgeFunctionsRegistry {
    */
   async #build() {
     try {
-      const {
-        features = {},
-        functionsConfig,
-        graph,
-        success,
-      } = await this.#runIsolate(this.#functions, this.#env, {
-        getFunctionsConfig: true,
-      })
-
-      if (features.npmModules && !this.#hasShownNPMWarning) {
-        log(
-          `${NETLIFYDEVWARN} Support for npm modules in edge functions is an experimental feature. To learn more about the current state of this capability or to report a problem, refer to https://ntl.fyi/edge-functions-npm.`,
-        )
-
-        this.#hasShownNPMWarning = true
-      }
+      const { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success } = await this.#runIsolate(
+        this.#functions,
+        this.#env,
+        {
+          getFunctionsConfig: true,
+        },
+      )
 
       if (!success) {
         throw new Error('Build error')
@@ -207,6 +195,14 @@ export class EdgeFunctionsRegistry {
       )
 
       this.#processGraph(graph)
+
+      if (npmSpecifiersWithExtraneousFiles.length !== 0) {
+        const modules = npmSpecifiersWithExtraneousFiles.map((name) => chalk.yellow(name)).join(', ')
+
+        log(
+          `${NETLIFYDEVWARN} The following npm modules, which are directly or indirectly imported by an edge function, may not be supported: ${modules}. For more information, visit https://ntl.fyi/edge-functions-npm.`,
+        )
+      }
     } catch (error) {
       this.#buildError = error