netlify-cli 17.10.1 → 17.11.0

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

@@ -1,9 +1,14 @@
+import { readFile } from 'fs/promises';
+import { join } from 'path';
 import { fileURLToPath } from 'url';
 import { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN, nonNullable, chalk, log, warn, watchDebounced, isNodeError, } from '../../utils/command-helpers.js';
+import { getPathInProject } from '../settings.js';
+import { INTERNAL_EDGE_FUNCTIONS_FOLDER } from './consts.js';
 const featureFlags = { edge_functions_correct_order: true };
 export class EdgeFunctionsRegistry {
-    constructor({ bundler, config, configPath, directories, env, getUpdatedConfig, internalDirectories, internalFunctions, projectDir, runIsolate, servePath, }) {
+    constructor({ bundler, config, configPath, directories, env, getUpdatedConfig, importMapFromTOML, projectDir, runIsolate, servePath, }) {
         this.buildError = null;
+        this.declarationsFromDeployConfig = [];
         this.dependencyPaths = new Map();
         this.directoryWatchers = new Map();
         this.functionPaths = new Map();
@@ -14,11 +19,11 @@ export class EdgeFunctionsRegistry {
         this.bundler = bundler;
         this.configPath = configPath;
         this.directories = directories;
-        this.internalDirectories = internalDirectories;
         this.getUpdatedConfig = getUpdatedConfig;
         this.runIsolate = runIsolate;
         this.servePath = servePath;
-        this.declarationsFromDeployConfig = internalFunctions;
+        this.projectDir = projectDir;
+        this.importMapFromTOML = importMapFromTOML;
         this.declarationsFromTOML = EdgeFunctionsRegistry.getDeclarationsFromTOML(config);
         this.env = EdgeFunctionsRegistry.getEnvironmentVariables(env);
         this.buildError = null;
@@ -28,7 +33,7 @@ export class EdgeFunctionsRegistry {
         this.userFunctions = [];
         this.internalFunctions = [];
         this.initialScan = this.doInitialScan();
-        this.setupWatchers(projectDir);
+        this.setupWatchers();
     }
     async doInitialScan() {
         await this.scanForFunctions();
@@ -306,13 +311,40 @@ export class EdgeFunctionsRegistry {
         }
         const { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success } = await this.runIsolate(this.functions, this.env, {
             getFunctionsConfig: true,
+            importMapPaths: [this.importMapFromTOML, this.importMapFromDeployConfig].filter(nonNullable),
         });
         return { functionsConfig, graph, npmSpecifiersWithExtraneousFiles, success };
     }
+    get internalDirectory() {
+        return join(this.projectDir, getPathInProject([INTERNAL_EDGE_FUNCTIONS_FOLDER]));
+    }
+    async readDeployConfig() {
+        const manifestPath = join(this.internalDirectory, 'manifest.json');
+        try {
+            const contents = await readFile(manifestPath, 'utf8');
+            const manifest = JSON.parse(contents);
+            return manifest;
+        }
+        catch { }
+    }
+    async scanForDeployConfig() {
+        const deployConfig = await this.readDeployConfig();
+        if (!deployConfig) {
+            return;
+        }
+        if (deployConfig.version !== 1) {
+            throw new Error('Unsupported manifest format');
+        }
+        this.declarationsFromDeployConfig = deployConfig.functions;
+        this.importMapFromDeployConfig = deployConfig.import_map
+            ? join(this.internalDirectory, deployConfig.import_map)
+            : undefined;
+    }
     async scanForFunctions() {
         const [internalFunctions, userFunctions] = await Promise.all([
-            this.bundler.find(this.internalDirectories),
+            this.bundler.find([this.internalDirectory]),
             this.bundler.find(this.directories),
+            this.scanForDeployConfig(),
         ]);
         const functions = [...internalFunctions, ...userFunctions];
         const newFunctions = functions.filter((func) => {
@@ -327,7 +359,7 @@ export class EdgeFunctionsRegistry {
         this.userFunctions = userFunctions;
         return { all: functions, new: newFunctions, deleted: deletedFunctions };
     }
-    async setupWatchers(projectDir) {
+    async setupWatchers() {
         if (!this.configPath) {
             return;
         }
@@ -344,16 +376,16 @@ export class EdgeFunctionsRegistry {
         // directories, they might be importing files that are located in
         // parent directories. So we watch the entire project directory for
         // changes.
-        await this.setupWatcherForDirectory(projectDir);
+        await this.setupWatcherForDirectory();
     }
-    async setupWatcherForDirectory(directory) {
+    async setupWatcherForDirectory() {
         const ignored = [`${this.servePath}/**`];
-        const watcher = await watchDebounced(directory, {
+        const watcher = await watchDebounced(this.projectDir, {
             ignored,
             onAdd: () => this.checkForAddedOrDeletedFunctions(),
             onChange: (paths) => this.handleFileChange(paths),
             onUnlink: () => this.checkForAddedOrDeletedFunctions(),
         });
-        this.directoryWatchers.set(directory, watcher);
+        this.directoryWatchers.set(this.projectDir, watcher);
     }
 }

package/src/lib/exec-fetcher.js

@@ -4,7 +4,6 @@ import { fetchLatest, fetchVersion, newerVersion, updateAvailable } from 'gh-rel
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module 'isex... Remove this comment to see the full error message
 import isExe from 'isexe';
 import { NETLIFYDEVWARN, error, getTerminalLink, log } from '../utils/command-helpers.js';
-// @ts-expect-error TS(7034) FIXME: Variable 'execa' implicitly has type 'any' in some... Remove this comment to see the full error message
 import execa from '../utils/execa.js';
 const isWindows = () => process.platform === 'win32';
 // @ts-expect-error TS(7031) FIXME: Binding element 'packageName' implicitly has an 'a... Remove this comment to see the full error message
@@ -47,7 +46,6 @@ pattern, }) => {
     if (!exists) {
         return true;
     }
-    // @ts-expect-error TS(7005) FIXME: Variable 'execa' implicitly has an 'any' type.
     const { stdout } = await execa(execPath, execArgs);
     if (!stdout) {
         return false;

package/src/lib/functions/local-proxy.js

@@ -1,7 +1,6 @@
 import { stdout } from 'process';
 // @ts-expect-error TS(7016) FIXME: Could not find a declaration file for module '@net... Remove this comment to see the full error message
 import { getBinaryPath as getFunctionsProxyPath } from '@netlify/local-functions-proxy';
-// @ts-expect-error TS(7034) FIXME: Variable 'execa' implicitly has type 'any' in some... Remove this comment to see the full error message
 import execa from '../../utils/execa.js';
 // @ts-expect-error TS(7031) FIXME: Binding element 'binaryPath' implicitly has an 'an... Remove this comment to see the full error message
 export const runFunctionsProxy = ({ binaryPath, context, directory, event, name, timeout }) => {
@@ -34,8 +33,7 @@ export const runFunctionsProxy = ({ binaryPath, context, directory, event, name,
         '--timeout',
         `${timeout}s`,
     ];
-    // @ts-expect-error TS(7005) FIXME: Variable 'execa' implicitly has an 'any' type.
     const proxyProcess = execa(functionsProxyPath, parameters);
-    proxyProcess.stderr.pipe(stdout);
+    proxyProcess.stderr?.pipe(stdout);
     return proxyProcess;
 };

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

@@ -51,7 +51,6 @@ export default class NetlifyFunction {
         this.name = name;
         this.displayName = displayName ?? name;
         this.projectRoot = projectRoot;
-        // @ts-expect-error TS(2339) FIXME: Property 'runtime' does not exist on type 'Netlify... Remove this comment to see the full error message
         this.runtime = runtime;
         this.timeoutBackground = timeoutBackground;
         this.timeoutSynchronous = timeoutSynchronous;
@@ -142,7 +141,9 @@ export default class NetlifyFunction {
             return { includedFiles, srcFilesDiff };
         }
         catch (error) {
-            this.buildError = error;
+            if (error instanceof Error) {
+                this.buildError = error;
+            }
             return { error };
         }
     }
@@ -164,7 +165,6 @@ export default class NetlifyFunction {
     async invoke(event = {}, context = {}) {
         await this.buildQueue;
         if (this.buildError) {
-            // @ts-expect-error TS(2339) FIXME: Property 'buildError' does not exist on type 'Netl... Remove this comment to see the full error message
             return { result: null, error: { errorMessage: this.buildError.message } };
         }
         const timeout = this.isBackground ? this.timeoutBackground : this.timeoutSynchronous;

package/src/lib/functions/registry.js

@@ -13,6 +13,7 @@ import runtimes from './runtimes/index.js';
 export const DEFAULT_FUNCTION_URL_EXPRESSION = /^\/.netlify\/(functions|builders)\/([^/]+).*/;
 const TYPES_PACKAGE = '@netlify/functions';
 const ZIP_EXTENSION = '.zip';
+const isInternalFunction = (func) => func.mainFile.includes(getPathInProject([INTERNAL_FUNCTIONS_FOLDER]));
 /**
  * @typedef {"buildError" | "extracted" | "loaded" | "missing-types-package" | "reloaded" | "reloading" | "removed"} FunctionEvent
  */
@@ -149,7 +150,6 @@ export class FunctionsRegistry {
                     ? `rename the function file to ${chalk.underline(newFilename)}. Refer to https://ntl.fyi/functions-runtime for more information`
                     : `refer to https://ntl.fyi/functions-runtime`;
                 const warning = `The function is using the legacy CommonJS format. To start using ES modules, ${action}.`;
-                // @ts-expect-error TS(2322) FIXME: Type 'string' is not assignable to type 'never'.
                 FunctionsRegistry.logEvent(event, { func, warnings: [warning] });
             }
             else {
@@ -230,14 +230,7 @@ export class FunctionsRegistry {
     }
     /**
      * Logs an event associated with functions.
-     *
-     * @param {FunctionEvent} event
-     * @param {object} data
-     * @param {NetlifyFunction} [data.func]
-     * @param {string[]} [data.warnings]
-     * @returns
      */
-    // @ts-expect-error TS(7006) FIXME: Parameter 'event' implicitly has an 'any' type.
     static logEvent(event, { func, warnings = [] }) {
         let warningsText = '';
         if (warnings.length !== 0) {
@@ -280,18 +273,13 @@ export class FunctionsRegistry {
     }
     /**
      * Adds a function to the registry
-     *
-     * @param {string} name
-     * @param {NetlifyFunction} funcBeforeHook
-     * @param {boolean} [isReload]
-     * @returns
      */
-    // @ts-expect-error TS(7006) FIXME: Parameter 'name' implicitly has an 'any' type.
     async registerFunction(name, funcBeforeHook, isReload = false) {
         const { runtime } = funcBeforeHook;
         // The `onRegister` hook allows runtimes to modify the function before it's
         // registered, or to prevent it from being registered altogether if the
         // hook returns `null`.
+        // @ts-expect-error FIXME
         const func = typeof runtime.onRegister === 'function' ? runtime.onRegister(funcBeforeHook) : funcBeforeHook;
         if (func === null) {
             return;
@@ -339,31 +327,24 @@ export class FunctionsRegistry {
     /**
      * A proxy to zip-it-and-ship-it's `listFunctions` method. It exists just so
      * that we can mock it in tests.
-     * @param  {Parameters<listFunctions>} args
-     * @returns
      */
-    // @ts-expect-error TS(7019) FIXME: Rest parameter 'args' implicitly has an 'any[]' ty... Remove this comment to see the full error message
     // eslint-disable-next-line class-methods-use-this
     async listFunctions(...args) {
-        // @ts-expect-error TS(2556) FIXME: A spread argument must either have a tuple type or... Remove this comment to see the full error message
         return await listFunctions(...args);
     }
     /**
      * Takes a list of directories and scans for functions. It keeps tracks of
      * any functions in those directories that we've previously seen, and takes
      * care of registering and unregistering functions as they come and go.
-     *
-     * @param {string[]} relativeDirs
      */
-    // @ts-expect-error TS(7006) FIXME: Parameter 'relativeDirs' implicitly has an 'any' t... Remove this comment to see the full error message
     async scan(relativeDirs) {
-        // @ts-expect-error TS(7006) FIXME: Parameter 'dir' implicitly has an 'any' type.
-        const directories = relativeDirs.filter(Boolean).map((dir) => (isAbsolute(dir) ? dir : join(this.projectRoot, dir)));
+        const directories = relativeDirs
+            .filter((dir) => Boolean(dir))
+            .map((dir) => (isAbsolute(dir) ? dir : join(this.projectRoot, dir)));
         // check after filtering to filter out [undefined] for example
         if (directories.length === 0) {
             return;
         }
-        // @ts-expect-error TS(7006) FIXME: Parameter 'path' implicitly has an 'any' type.
         await Promise.all(directories.map((path) => FunctionsRegistry.prepareDirectoryScan(path)));
         const functions = await this.listFunctions(directories, {
             featureFlags: {
@@ -373,10 +354,18 @@ export class FunctionsRegistry {
             // @ts-expect-error TS(2339) FIXME: Property 'config' does not exist on type 'Function... Remove this comment to see the full error message
             config: this.config.functions,
         });
+        // user-defined functions take precedence over internal functions,
+        // so we want to ignore any internal functions where there's a user-defined one with the same name
+        const ignoredFunctions = new Set(functions
+            .filter((func) => isInternalFunction(func) &&
+            this.functions.has(func.name) &&
+            !isInternalFunction(this.functions.get(func.name)))
+            .map((func) => func.name));
         // Before registering any functions, we look for any functions that were on
         // the previous list but are missing from the new one. We unregister them.
         const deletedFunctions = [...this.functions.values()].filter((oldFunc) => {
-            const isFound = functions.some((newFunc) => newFunc.name === oldFunc.name && newFunc.mainFile === oldFunc.mainFile);
+            const isFound = functions.some((newFunc) => ignoredFunctions.has(newFunc.name) ||
+                (newFunc.name === oldFunc.name && newFunc.mainFile === oldFunc.mainFile));
             return !isFound;
         });
         await Promise.all(deletedFunctions.map((func) => this.unregisterFunction(func)));
@@ -386,6 +375,9 @@ export class FunctionsRegistry {
         // where the last ones precede the previous ones. This is why
         // we reverse the array so we get the right functions precedence in the CLI.
         functions.reverse().map(async ({ displayName, mainFile, name, runtime: runtimeName }) => {
+            if (ignoredFunctions.has(name)) {
+                return;
+            }
             const runtime = runtimes[runtimeName];
             // If there is no matching runtime, it means this function is not yet
             // supported in Netlify Dev.
@@ -400,7 +392,6 @@ export class FunctionsRegistry {
                 blobsContext: this.blobsContext,
                 // @ts-expect-error TS(2339) FIXME: Property 'config' does not exist on type 'Function... Remove this comment to see the full error message
                 config: this.config,
-                // @ts-expect-error TS(7006) FIXME: Parameter 'directory' implicitly has an 'any' type... Remove this comment to see the full error message
                 directory: directories.find((directory) => mainFile.startsWith(directory)),
                 mainFile,
                 name,
@@ -430,7 +421,6 @@ export class FunctionsRegistry {
             }
             FunctionsRegistry.logEvent('removed', { func });
         });
-        // @ts-expect-error TS(7006) FIXME: Parameter 'path' implicitly has an 'any' type.
         await Promise.all(directories.map((path) => this.setupDirectoryWatcher(path)));
     }
     /**

package/src/lib/functions/runtimes/go/index.js

@@ -1,7 +1,6 @@
 import { dirname, extname } from 'path';
 import { platform } from 'process';
 import { temporaryFile } from 'tempy';
-// @ts-expect-error TS(7034) FIXME: Variable 'execa' implicitly has type 'any' in some... Remove this comment to see the full error message
 import execa from '../../../../utils/execa.js';
 import { runFunctionsProxy } from '../../local-proxy.js';
 const isWindows = platform === 'win32';
@@ -9,7 +8,6 @@ export const name = 'go';
 // @ts-expect-error TS(7031) FIXME: Binding element 'binaryPath' implicitly has an 'an... Remove this comment to see the full error message
 const build = async ({ binaryPath, functionDirectory }) => {
     try {
-        // @ts-expect-error TS(7005) FIXME: Variable 'execa' implicitly has an 'any' type.
         await execa('go', ['build', '-o', binaryPath], { cwd: functionDirectory });
         return { binaryPath, srcFiles: [functionDirectory] };
     }
@@ -24,7 +22,6 @@ const build = async ({ binaryPath, functionDirectory }) => {
 // @ts-expect-error TS(7031) FIXME: Binding element 'cwd' implicitly has an 'any' type... Remove this comment to see the full error message
 const checkGoInstallation = async ({ cwd }) => {
     try {
-        // @ts-expect-error TS(7005) FIXME: Variable 'execa' implicitly has an 'any' type.
         await execa('go', ['version'], { cwd });
         return true;
     }

package/src/lib/functions/runtimes/index.js

@@ -1,40 +1,6 @@
 import * as go from './go/index.js';
 import * as js from './js/index.js';
 import * as rust from './rust/index.js';
-/* eslint-enable import/no-namespace */
-/**
- * @callback BuildFunction
- * @param {object} func
- * @returns {Promise<{srcFiles: string[], buildPath?: string}>}
- */
-/**
- * @callback GetBuildFunction
- * @param  {{ config: object, context: object, errorExit: function, func: object, functionsDirectory: string, projectRoot: string }} params
- * @returns {Promise<BuildFunction>}
- */
-/**
- * @callback InvokeFunction
- * @param  {{ context: object, event: object, func: object, timeout: number }} params
- * @returns {Promise<{ body: object, statusCode: number }>}
- */
-/**
- * @callback OnDirectoryScanFunction
- * @param  {{ directory: string }} params
- * @returns {Promise<undefined>}
- */
-/**
- * @callback OnRegisterFunction
- * @param  {object} func
- * @returns {object|null}
- */
-/**
- * @typedef {object} Runtime
- * @property {GetBuildFunction} getBuildFunction
- * @property {InvokeFunction} invokeFunction
- * @property {OnDirectoryScanFunction} [onDirectoryScan]
- * @property {OnRegisterFunction} [onRegister]
- * @property {string} name
- */
 const runtimes = {
     [go.name]: go,
     [js.name]: js,

package/src/lib/functions/runtimes/js/builders/netlify-lambda.js

@@ -1,7 +1,6 @@
 import { readFile } from 'fs/promises';
 import { resolve } from 'path';
-import minimist from 'minimist';
-// @ts-expect-error TS(7034) FIXME: Variable 'execa' implicitly has type 'any' in some... Remove this comment to see the full error message
+import { program } from 'commander';
 import execa from '../../../../../utils/execa.js';
 import { fileExistsAsync } from '../../../../fs.js';
 import { memoizedBuild } from '../../../memoized-build.js';
@@ -15,18 +14,19 @@ export const detectNetlifyLambda = async function ({ packageJson } = {}) {
     const matchingScripts = Object.entries(scripts).filter(([, script]) => script.match(/netlify-lambda\s+build/));
     for (const [key, script] of matchingScripts) {
         // E.g. ["netlify-lambda", "build", "functions/folder"]
-        // @ts-expect-error TS(2571) FIXME: Object is of type 'unknown'.
-        const match = minimist(script.split(' '), {
-            // these are all valid options for netlify-lambda
-            boolean: ['s', 'static'],
-            string: ['c', 'config', 'p', 'port', 'b', 'babelrc', 't', 'timeout'],
-        });
+        // these are all valid options for netlify-lambda
+        program
+            .option('-s, --static')
+            .option('-c, --config [file]')
+            .option('-p, --port [number]')
+            .option('-b, --babelrc [file]')
+            .option('-t, --timeout [delay]');
+        program.parse(script.split(' ') ?? []);
         // We are not interested in 'netlify-lambda' and 'build' commands
-        const functionDirectories = match._.slice(2);
+        const functionDirectories = program.args.filter((arg) => !['netlify-lambda', 'build'].includes(arg));
         if (functionDirectories.length === 1) {
             const srcFiles = [resolve(functionDirectories[0])];
             const yarnExists = await fileExistsAsync('yarn.lock');
-            // @ts-expect-error TS(7005) FIXME: Variable 'execa' implicitly has an 'any' type.
             const buildCommand = () => execa(yarnExists ? 'yarn' : 'npm', ['run', key]);
             return {
                 build: async ({ cache = {} } = {}) => {

package/src/lib/functions/runtimes/rust/index.js

@@ -3,7 +3,6 @@ import { dirname, extname, join, resolve } from 'path';
 import { platform } from 'process';
 import { findUp } from 'find-up';
 import toml from 'toml';
-// @ts-expect-error TS(7034) FIXME: Variable 'execa' implicitly has type 'any' in some... Remove this comment to see the full error message
 import execa from '../../../../utils/execa.js';
 import { SERVE_FUNCTIONS_FOLDER } from '../../../../utils/functions/functions.js';
 import { getPathInProject } from '../../../settings.js';
@@ -18,7 +17,6 @@ const build = async ({ func }) => {
     const crateName = await getCrateName(functionDirectory);
     const binaryName = `${crateName}${isWindows ? '.exe' : ''}`;
     const binaryPath = join(targetDirectory, 'debug', binaryName);
-    // @ts-expect-error TS(7005) FIXME: Variable 'execa' implicitly has an 'any' type.
     await execa('cargo', ['build', '--target-dir', targetDirectory], {
         cwd: functionDirectory,
     });

package/src/lib/functions/server.js

@@ -25,20 +25,31 @@ const buildClientContext = function (headers) {
     const parts = headers.authorization.split(' ');
     if (parts.length !== 2 || parts[0] !== 'Bearer')
         return;
+    const identity = {
+        url: 'https://netlify-dev-locally-emulated-identity.netlify.com/.netlify/identity',
+        token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb3VyY2UiOiJuZXRsaWZ5IGRldiIsInRlc3REYXRhIjoiTkVUTElGWV9ERVZfTE9DQUxMWV9FTVVMQVRFRF9JREVOVElUWSJ9.2eSDqUOZAOBsx39FHFePjYj12k0LrxldvGnlvDu3GMI',
+        // you can decode this with https://jwt.io/
+        // just says
+        // {
+        //   "source": "netlify dev",
+        //   "testData": "NETLIFY_DEV_LOCALLY_EMULATED_IDENTITY"
+        // }
+    };
+    // This data is available on both the context root and under custom.netlify for retro-compatibility.
+    // In the future it will only be available in custom.netlify.
+    // @ts-expect-error
+    const user = jwtDecode(parts[1]);
+    const netlifyContext = JSON.stringify({
+        identity: identity,
+        user: user,
+    });
     try {
         return {
-            identity: {
-                url: 'https://netlify-dev-locally-emulated-identity.netlify.com/.netlify/identity',
-                token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb3VyY2UiOiJuZXRsaWZ5IGRldiIsInRlc3REYXRhIjoiTkVUTElGWV9ERVZfTE9DQUxMWV9FTVVMQVRFRF9JREVOVElUWSJ9.2eSDqUOZAOBsx39FHFePjYj12k0LrxldvGnlvDu3GMI',
-                // you can decode this with https://jwt.io/
-                // just says
-                // {
-                //   "source": "netlify dev",
-                //   "testData": "NETLIFY_DEV_LOCALLY_EMULATED_IDENTITY"
-                // }
+            identity: identity,
+            user: user,
+            custom: {
+                netlify: Buffer.from(netlifyContext).toString('base64'),
             },
-            // @ts-expect-error
-            user: jwtDecode(parts[1]),
         };
     }
     catch {
@@ -114,7 +125,7 @@ export const createHandler = function (options) {
             'client-ip': [remoteAddress],
             'x-nf-client-connection-ip': [remoteAddress],
             'x-nf-account-id': [options.accountId],
-            'x-nf-site-id': [options?.siteInfo?.id] ?? 'unlinked',
+            'x-nf-site-id': [options?.siteInfo?.id ?? 'unlinked'],
             [efHeaders.Geo]: Buffer.from(JSON.stringify(geoLocation)).toString('base64'),
         }).reduce((prev, [key, value]) => ({ ...prev, [key]: Array.isArray(value) ? value : [value] }), {});
         const rawQuery = new URLSearchParams(requestQuery).toString();
@@ -217,7 +228,6 @@ const getFunctionsServer = (options) => {
 // @ts-expect-error TS(7006) FIXME: Parameter 'options' implicitly has an 'any' type.
 export const startFunctionsServer = async (options) => {
     const { blobsContext, capabilities, command, config, debug, loadDistFunctions, settings, site, siteInfo, siteUrl, timeouts, } = options;
-    // @ts-expect-error TS(2345) FIXME: Argument of type '{ base: any; }' is not assignabl... Remove this comment to see the full error message
     const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root });
     const functionsDirectories = [];
     let manifest;

package/src/utils/banner.js

@@ -1,8 +1,7 @@
 import boxen from 'boxen';
 import { chalk, log, NETLIFYDEVLOG } from './command-helpers.js';
-// @ts-expect-error TS(7031) FIXME: Binding element 'url' implicitly has an 'any' type... Remove this comment to see the full error message
-export const printBanner = ({ url }) => {
-    const banner = chalk.bold(`${NETLIFYDEVLOG} Server now ready on ${url}`);
+export const printBanner = (options) => {
+    const banner = chalk.bold(`${NETLIFYDEVLOG} Server now ready on ${options.url}`);
     log(boxen(banner, {
         padding: 1,
         margin: 1,

package/src/utils/build-info.js

@@ -3,28 +3,19 @@ import inquirer from 'inquirer';
 import { chalk, log } from './command-helpers.js';
 /**
  * Filters the inquirer settings based on the input
- * @param {ReturnType<typeof formatSettingsArrForInquirer>} scriptInquirerOptions
- * @param {string} input
  */
-// @ts-expect-error TS(7006) FIXME: Parameter 'scriptInquirerOptions' implicitly has a... Remove this comment to see the full error message
 const filterSettings = function (scriptInquirerOptions, input) {
-    // @ts-expect-error TS(7006) FIXME: Parameter 'scriptInquirerOption' implicitly has an... Remove this comment to see the full error message
     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)));
-    // @ts-expect-error TS(7006) FIXME: Parameter 't' implicitly has an 'any' type.
     return scriptInquirerOptions.filter((t) => filteredSettingNames.has(t.name));
 };
-/** @typedef {import('@netlify/build-info').Settings} Settings */
 /**
- * @param {Settings[]} settings
- * @param {'dev' | 'build'} type The type of command (dev or build)
+ * Formats the settings to present it as an array for the inquirer input so that it can choose one
  */
-// @ts-expect-error TS(7006) FIXME: Parameter 'settings' implicitly has an 'any' type.
 const formatSettingsArrForInquirer = function (settings, type = 'dev') {
-    // @ts-expect-error TS(7006) FIXME: Parameter 'setting' implicitly has an 'any' type.
     return settings.map((setting) => {
         const cmd = type === 'dev' ? setting.devCommand : setting.buildCommand;
         return {
@@ -35,13 +26,26 @@ const formatSettingsArrForInquirer = function (settings, type = 'dev') {
     });
 };
 /**
- * Uses @netlify/build-info to detect the dev settings and port based on the framework
+ * Detects and filters the build setting for a project and a command
+ */
+export async function detectBuildSettings(command) {
+    const { project, workspacePackage } = command;
+    const buildSettings = await project.getBuildSettings(project.workspace ? workspacePackage : '');
+    return buildSettings
+        .filter((setting) => {
+        if (project.workspace && project.relativeBaseDirectory && setting.packagePath) {
+            return project.relativeBaseDirectory.startsWith(setting.packagePath);
+        }
+        return true;
+    })
+        .filter((setting) => setting.devCommand);
+}
+/**
+ * Uses `@netlify/build-info` to detect the dev settings and port based on the framework
  * and the build system that is used.
- * @param {import('../commands/base-command.js').default} command
- * @param {'dev' | 'build'} type The type of command (dev or build)
- * @returns {Promise<Settings | undefined>}
+ * @param command The base command
+ * @param type The type of command (dev or build)
  */
-// @ts-expect-error TS(7006) FIXME: Parameter 'command' implicitly has an 'any' type.
 export const detectFrameworkSettings = async (command, type = 'dev') => {
     const { relConfigFilePath } = command.netlify;
     const settings = await detectBuildSettings(command);
@@ -49,16 +53,14 @@ export const detectFrameworkSettings = async (command, type = 'dev') => {
         return settings[0];
     }
     if (settings.length > 1) {
-        /** multiple matching detectors, make the user choose */
+        // multiple matching detectors, make the user choose
         const scriptInquirerOptions = formatSettingsArrForInquirer(settings, type);
-        /** @type {{chosenSettings: Settings}} */
         const { chosenSettings } = await inquirer.prompt({
             name: 'chosenSettings',
             message: `Multiple possible ${type} commands found`,
-            // @ts-expect-error TS(2769) FIXME: No overload matches this call.
+            // @ts-expect-error is not known by the types as it uses the autocomplete plugin
             type: 'autocomplete',
-            // @ts-expect-error TS(7006) FIXME: Parameter '_' implicitly has an 'any' type.
-            source(/** @type {string} */ _, input = '') {
+            source(_, input = '') {
                 if (!input)
                     return scriptInquirerOptions;
                 // only show filtered results
@@ -78,22 +80,3 @@ command = "${chosenSettings.devCommand}"
         return chosenSettings;
     }
 };
-/**
- * Detects and filters the build setting for a project and a command
- * @param {import('../commands/base-command.js').default} command
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'command' implicitly has an 'any' type.
-export const detectBuildSettings = async (command) => {
-    const { project, workspacePackage } = command;
-    const buildSettings = await project.getBuildSettings(project.workspace ? workspacePackage : '');
-    return (buildSettings
-        // @ts-expect-error TS(7006) FIXME: Parameter 'setting' implicitly has an 'any' type.
-        .filter((setting) => {
-        if (project.workspace && project.relativeBaseDirectory && setting.packagePath) {
-            return project.relativeBaseDirectory.startsWith(setting.packagePath);
-        }
-        return true;
-    })
-        // @ts-expect-error TS(7006) FIXME: Parameter 'setting' implicitly has an 'any' type.
-        .filter((setting) => setting.devCommand));
-};

package/src/utils/command-helpers.js

@@ -158,22 +158,14 @@ export const warn = (message = '') => {
     const bang = chalk.yellow(BANG);
     log(` ${bang}   Warning: ${message}`);
 };
-/**
- * throws an error or log it
- * @param {unknown} message
- * @param {object} [options]
- * @param {boolean} [options.exit]
- */
+/** Throws an error or logs it */
 export const error = (message = '', options = {}) => {
-    const err = 
-    // @ts-expect-error TS(2358) FIXME: The left-hand side of an 'instanceof' expression m... Remove this comment to see the full error message
-    message instanceof Error
+    const err = message instanceof Error
         ? message
         : // eslint-disable-next-line unicorn/no-nested-ternary
             typeof message === 'string'
                 ? new Error(message)
-                : /** @type {Error} */ { message, stack: undefined, name: 'Error' };
-    // @ts-expect-error TS(2339) FIXME: Property 'exit' does not exist on type '{}'.
+                : { message, stack: undefined, name: 'Error' };
     if (options.exit === false) {
         const bang = chalk.red(BANG);
         if (process.env.DEBUG) {