@netlify/build 29.0.0-rc → 29.0.0

package/lib/error/parse/location.js

@@ -0,0 +1,50 @@
+import { getBuildCommandDescription, getPluginOrigin } from '../../log/description.js';
+// Retrieve an error's location to print in logs.
+// Each error type has its own logic (or none if there's no location to print).
+export const getLocationInfo = function ({ stack, location, locationType }) {
+    // No location to print
+    if (locationType === undefined && stack === undefined) {
+        return;
+    }
+    // The location is only the stack trace
+    if (locationType === undefined) {
+        return stack;
+    }
+    const locationString = LOCATIONS[locationType](location);
+    return [locationString, stack].filter(Boolean).join('\n');
+};
+const getBuildCommandLocation = function ({ buildCommand, buildCommandOrigin }) {
+    const description = getBuildCommandDescription(buildCommandOrigin);
+    return `In ${description}:
+${buildCommand}`;
+};
+const getFunctionsBundlingLocation = function ({ functionName, functionType }) {
+    if (functionType === 'edge') {
+        return 'While bundling edge function';
+    }
+    return `While bundling function "${functionName}"`;
+};
+const getCoreStepLocation = function ({ coreStepName }) {
+    return `During ${coreStepName}`;
+};
+const getBuildFailLocation = function ({ event, packageName, loadedFrom, origin }) {
+    const eventMessage = getEventMessage(event);
+    const pluginOrigin = getPluginOrigin(loadedFrom, origin);
+    return `${eventMessage} "${packageName}" ${pluginOrigin}`;
+};
+const getEventMessage = function (event) {
+    if (event === 'load') {
+        return `While loading`;
+    }
+    return `In "${event}" event in`;
+};
+const getApiLocation = function ({ endpoint, parameters }) {
+    return `While calling the Netlify API endpoint '${endpoint}' with:\n${JSON.stringify(parameters, null, 2)}`;
+};
+const LOCATIONS = {
+    buildCommand: getBuildCommandLocation,
+    functionsBundling: getFunctionsBundlingLocation,
+    coreStep: getCoreStepLocation,
+    buildFail: getBuildFailLocation,
+    api: getApiLocation,
+};

package/lib/error/parse/normalize.js

@@ -0,0 +1,24 @@
+// Ensure error is an `Error` instance.
+// If is an `Error` instance but is missing usual `Error` properties, we make
+// sure its static properties are preserved.
+export const normalizeError = function (error) {
+    if (Array.isArray(error)) {
+        return normalizeArray(error);
+    }
+    if (!(error instanceof Error)) {
+        return new Error(String(error));
+    }
+    if (typeof error.message !== 'string') {
+        error.message = String(error);
+    }
+    if (typeof error.stack !== 'string') {
+        Error.captureStackTrace(error, normalizeError);
+    }
+    return error;
+};
+// Some libraries throw arrays of Errors
+const normalizeArray = function (errorArray) {
+    const [error, ...errors] = errorArray.map(normalizeError);
+    error.errors = errors;
+    return error;
+};

package/lib/error/parse/parse.js

@@ -0,0 +1,67 @@
+import { serializeObject } from '../../log/serialize.js';
+import { getErrorInfo } from '../info.js';
+import { getTypeInfo } from '../type.js';
+import { getLocationInfo } from './location.js';
+import { normalizeError } from './normalize.js';
+import { getPluginInfo } from './plugin.js';
+import { getErrorProps } from './properties.js';
+import { getStackInfo } from './stack.js';
+// Add additional type-specific error information
+export const getFullErrorInfo = function ({ error, colors, debug }) {
+    const basicErrorInfo = parseErrorInfo(error);
+    const { message, stack, errorProps, errorInfo, errorInfo: { location = {}, plugin = {}, tsConfig }, severity, title, stackType, locationType, showErrorProps, rawStack, errorMetadata, } = basicErrorInfo;
+    const titleA = getTitle(title, errorInfo);
+    const { message: messageA, stack: stackA } = getStackInfo({ message, stack, stackType, rawStack, severity, debug });
+    const pluginInfo = getPluginInfo(plugin, location);
+    const tsConfigInfo = getTsConfigInfo(tsConfig);
+    const locationInfo = getLocationInfo({ stack: stackA, location, locationType });
+    const errorPropsA = getErrorProps({ errorProps, showErrorProps, colors });
+    return {
+        ...basicErrorInfo,
+        title: titleA,
+        message: messageA,
+        tsConfigInfo,
+        pluginInfo,
+        locationInfo,
+        errorProps: errorPropsA,
+        errorMetadata,
+    };
+};
+// Serialize the `tsConfig` error information
+const getTsConfigInfo = function (tsConfig) {
+    if (tsConfig === undefined) {
+        return;
+    }
+    return serializeObject(tsConfig);
+};
+// Parse error instance into all the basic properties containing information
+export const parseErrorInfo = function (error) {
+    const { message, stack, ...errorProps } = normalizeError(error);
+    const [errorInfo, errorPropsA] = getErrorInfo(errorProps);
+    const { errorMetadata } = errorInfo;
+    const { type, severity, title, group, stackType, locationType, showErrorProps, showInBuildLog = true, rawStack, } = getTypeInfo(errorInfo);
+    const basicErrorInfo = {
+        message,
+        stack,
+        errorProps: errorPropsA,
+        errorInfo,
+        type,
+        severity,
+        title,
+        group,
+        stackType,
+        locationType,
+        showInBuildLog,
+        showErrorProps,
+        rawStack,
+        errorMetadata,
+    };
+    return basicErrorInfo;
+};
+// Retrieve title to print in logs
+const getTitle = function (title, errorInfo) {
+    if (typeof title !== 'function') {
+        return title;
+    }
+    return title(errorInfo);
+};

package/lib/error/parse/plugin.js

@@ -0,0 +1,55 @@
+// Retrieve plugin's package.json details to include in error messages.
+// Please note `pluginPackageJson` has been normalized by `normalize-package-data`.
+export const getPluginInfo = function ({ pluginPackageJson = {} }, { packageName, loadedFrom }) {
+    if (Object.keys(pluginPackageJson).length === 0) {
+        return;
+    }
+    return Object.entries(FIELDS)
+        .map(([name, getField]) => serializeField({ name, getField, pluginPackageJson, packageName, loadedFrom }))
+        .filter(Boolean)
+        .join('\n');
+};
+// Serialize a single package.json field
+const serializeField = function ({ name, getField, pluginPackageJson, packageName, loadedFrom }) {
+    const field = getField(pluginPackageJson, { packageName, loadedFrom });
+    if (field === undefined) {
+        return;
+    }
+    const nameA = `${name}:`.padEnd(NAME_PADDING);
+    return `${nameA}${field}`;
+};
+const NAME_PADDING = 16;
+const getPackage = function (pluginPackageJson, { packageName }) {
+    return packageName;
+};
+const getVersion = function ({ version }) {
+    if (version === '') {
+        return;
+    }
+    return version;
+};
+export const getHomepage = function (pluginPackageJson = {}, { loadedFrom } = {}) {
+    return (getRepository(pluginPackageJson) ||
+        getNpmLink(pluginPackageJson, { loadedFrom }) ||
+        getIssuesLink(pluginPackageJson));
+};
+const getRepository = function ({ repository: { url } = {} }) {
+    return url;
+};
+const getNpmLink = function ({ name }, { loadedFrom }) {
+    if (!name || loadedFrom === 'local') {
+        return;
+    }
+    return `https://www.npmjs.com/package/${name}`;
+};
+const getIssuesLink = function ({ bugs: { url } = {} }) {
+    return url;
+};
+// List of package.json to serialize
+const FIELDS = {
+    Package: getPackage,
+    Version: getVersion,
+    Repository: getRepository,
+    'npm link': getNpmLink,
+    'Report issues': getIssuesLink,
+};

package/lib/error/parse/properties.js

@@ -0,0 +1,16 @@
+import { inspect } from 'util';
+import { omit } from '../../utils/omit.js';
+// In uncaught exceptions, print error static properties
+export const getErrorProps = function ({ errorProps, showErrorProps, colors }) {
+    if (!showErrorProps) {
+        return;
+    }
+    const errorPropsA = omit(errorProps, CLEANED_ERROR_PROPS);
+    if (Object.keys(errorPropsA).length === 0) {
+        return;
+    }
+    return inspect(errorPropsA, { colors, depth: INSPECT_MAX_DEPTH });
+};
+const INSPECT_MAX_DEPTH = 5;
+// Remove error static properties that should not be logged
+const CLEANED_ERROR_PROPS = ['requireStack'];

package/lib/error/parse/serialize_log.js

@@ -0,0 +1,34 @@
+import { THEME } from '../../log/theme.js';
+// Serialize an error object into a title|body string to print in logs
+export const serializeLogError = function ({ fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, tsConfigInfo, errorProps }, }) {
+    const body = getBody({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity });
+    return { title, body };
+};
+const getBody = function ({ message, pluginInfo, locationInfo, tsConfigInfo, errorProps, severity }) {
+    if (severity === 'none') {
+        return message;
+    }
+    return Object.entries({
+        message,
+        tsConfigInfo,
+        pluginInfo,
+        locationInfo,
+        errorProps,
+    })
+        .filter(blockHasValue)
+        .map(serializeBlock)
+        .join('\n\n');
+};
+const blockHasValue = function ([, value]) {
+    return value !== undefined;
+};
+const serializeBlock = function ([key, value]) {
+    return `${THEME.errorSubHeader(LOG_BLOCK_NAMES[key])}\n${value}`;
+};
+const LOG_BLOCK_NAMES = {
+    message: 'Error message',
+    pluginInfo: 'Plugin details',
+    locationInfo: 'Error location',
+    tsConfigInfo: 'TypeScript configuration',
+    errorProps: 'Error properties',
+};

package/lib/error/parse/serialize_status.js

@@ -0,0 +1,18 @@
+// Serialize an error object to `statuses` properties
+export const serializeErrorStatus = function ({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }) {
+    const text = getText({ locationInfo, errorProps });
+    return { state, title, summary: message, text, extraData: errorMetadata };
+};
+const getText = function ({ locationInfo, errorProps }) {
+    const parts = [locationInfo, getErrorProps(errorProps)].filter(Boolean);
+    if (parts.length === 0) {
+        return;
+    }
+    return parts.join('\n\n');
+};
+const getErrorProps = function (errorProps) {
+    if (errorProps === undefined) {
+        return;
+    }
+    return `Error properties:\n${errorProps}`;
+};

package/lib/error/parse/stack.js

@@ -0,0 +1,34 @@
+import { cleanStacks } from './clean_stack.js';
+// Retrieve the stack trace
+export const getStackInfo = function ({ message, stack, stackType, rawStack, severity, debug }) {
+    const { message: messageA, stack: stackA } = splitStackInfo({ message, stack, stackType });
+    const messageB = severity === 'none' ? messageA.replace(SUCCESS_ERROR_NAME, '') : messageA;
+    const stackB = cleanStacks({ stack: stackA, rawStack, debug });
+    return { message: messageB, stack: stackB };
+};
+const splitStackInfo = function ({ message, stack, stackType }) {
+    // Some errors should not show any stack trace
+    if (stackType === 'none') {
+        return { message };
+    }
+    // Some errors have their stack trace inside `error.message` instead of
+    // `error.stack` due to IPC
+    if (stackType === 'message') {
+        return splitStack(message);
+    }
+    return splitStack(stack);
+};
+const splitStack = function (string) {
+    const lines = string.split('\n');
+    const stackIndex = lines.findIndex(isStackTrace);
+    if (stackIndex === -1) {
+        return { message: string };
+    }
+    const messageA = lines.slice(0, stackIndex).join('\n');
+    const stackA = lines.slice(stackIndex).join('\n');
+    return { message: messageA, stack: stackA };
+};
+const isStackTrace = function (line) {
+    return line.trim().startsWith('at ');
+};
+const SUCCESS_ERROR_NAME = 'Error: ';

package/lib/error/report.js

@@ -0,0 +1,27 @@
+import { isNetlifyMaintainedPlugin } from '../plugins/internal.js';
+import { closeClient, normalizeTagName, startClient } from '../report/statsd.js';
+import { getErrorInfo } from './info.js';
+const TOP_PARENT_TAG = 'run_netlify_build';
+// Record error rates of the build phase for monitoring.
+// Sends to statsd daemon.
+export const reportError = async function ({ error, statsdOpts: { host, port }, framework, }) {
+    if (host === undefined) {
+        return;
+    }
+    const [errorInfo] = getErrorInfo(error);
+    const pluginName = errorInfo.plugin ? normalizeTagName(errorInfo.plugin.packageName) : null;
+    // only send tracking if it is a known plugin
+    if (pluginName && !isNetlifyMaintainedPlugin(pluginName)) {
+        return;
+    }
+    const parent = pluginName ? pluginName : TOP_PARENT_TAG;
+    const stage = pluginName ? errorInfo.location?.event : errorInfo.stage;
+    const client = await startClient(host, port);
+    const frameworkTag = framework === undefined ? {} : { framework };
+    client.increment('buildbot.build.stage.error', 1, {
+        stage: stage ?? 'system',
+        parent,
+        ...frameworkTag,
+    });
+    await closeClient(client);
+};

package/lib/error/type.js

@@ -0,0 +1,177 @@
+// Retrieve error-type specific information
+export const getTypeInfo = function ({ type }) {
+    const typeA = TYPES[type] === undefined ? DEFAULT_TYPE : type;
+    return { type: typeA, ...TYPES[typeA] };
+};
+// List of error types, and their related properties
+// Related to build error logs:
+//  - `showInBuildLog`: `true` when we want this error to show in build logs (defaults to true)
+//  - `title`: main title shown in build error logs and in the UI (statuses)
+//  - `locationType`: retrieve a human-friendly location of the error, printed
+//    in build error logs
+//  - `showErrorProps`: `true` when the `Error` instance static properties
+//    should be printed in build error logs. Only useful when the `Error`
+//    instance was not created by us.
+//  - `rawStack`: `true` when the stack trace should be cleaned up
+//  - `stackType`: how the stack trace should appear in build error logs:
+//      - `none`: not printed
+//      - `stack`: printed as is
+//      - `message`: printed as is, but taken from `error.message`.
+//        Used when `error.stack` is not being correct due to the error being
+//        passed between different processes.
+//  - `severity`: error severity (also used by Bugsnag):
+//      - `success`: build success
+//      - `none`: not an error, e.g. build cancellation
+//      - `info`: user error
+//      - `warning`: community plugin error
+//      - `error`: system error, including core plugin error
+// Related to Bugsnag:
+//  - `group`: main title shown in Bugsnag. Also used to group errors together
+//    in Bugsnag, combined with `error.message`.
+//    Defaults to `title`.
+// New error types should be added to Bugsnag since we use it for automated
+// monitoring (through its Slack integration). The steps in Bugsnag are:
+//  - Create a new bookmark. Try to re-use the search filter of an existing
+//    bookmark with a similar error type, but only changing the `errorClass`.
+//    Make sure to check the box "Share with my team".
+//  - Add the `errorClass` to the search filter of either the "All warnings" or
+//    "All errors" bookmark depending on whether we should get notified on Slack
+//    for new errors of that type. You must use the bookmark menu action "Update
+//    with current filters"
+const TYPES = {
+    // Plugin called `utils.build.cancelBuild()`
+    cancelBuild: {
+        title: ({ location: { packageName } }) => `Build canceled by ${packageName}`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'none',
+    },
+    // User configuration error (`@netlify/config`, wrong Node.js version)
+    resolveConfig: {
+        title: 'Configuration error',
+        stackType: 'none',
+        severity: 'info',
+    },
+    // Error while installing user packages (missing plugins, local plugins or functions dependencies)
+    dependencies: {
+        title: 'Dependencies installation error',
+        stackType: 'none',
+        severity: 'info',
+    },
+    // User misconfigured a plugin
+    pluginInput: {
+        title: ({ location: { packageName, input } }) => `Plugin "${packageName}" invalid input "${input}"`,
+        stackType: 'none',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    // User package.json sets an unsupported plugin version
+    pluginUnsupportedVersion: {
+        title: 'Unsupported plugin version detected',
+        stackType: 'none',
+        severity: 'info',
+    },
+    // `build.command` non-0 exit code
+    buildCommand: {
+        title: '"build.command" failed',
+        group: ({ location: { buildCommand } }) => buildCommand,
+        stackType: 'message',
+        locationType: 'buildCommand',
+        severity: 'info',
+    },
+    // User error during Functions bundling
+    functionsBundling: {
+        title: ({ location: { functionName, functionType } }) => {
+            if (functionType === 'edge') {
+                return 'Bundling of edge function failed';
+            }
+            return `Bundling of function "${functionName}" failed`;
+        },
+        group: ({ location: { functionType = 'serverless' } }) => `Bundling of ${functionType} function failed`,
+        stackType: 'none',
+        locationType: 'functionsBundling',
+        severity: 'info',
+    },
+    // Plugin called `utils.build.failBuild()`
+    failBuild: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    // Plugin called `utils.build.failPlugin()`
+    failPlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    // Plugin has an invalid shape
+    pluginValidation: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    // Plugin threw an uncaught exception
+    pluginInternal: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    // Bug while orchestrating child processes
+    ipc: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'none',
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    // Core plugin internal error
+    corePlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'error',
+    },
+    // Core step internal error
+    coreStep: {
+        title: ({ location: { coreStepName } }) => `Internal error during "${coreStepName}"`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'coreStep',
+        severity: 'error',
+    },
+    // Request error when `@netlify/build` was calling Netlify API
+    api: {
+        title: ({ location: { endpoint } }) => `API error on "${endpoint}"`,
+        stackType: 'message',
+        showErrorProps: true,
+        locationType: 'api',
+        severity: 'error',
+    },
+    // `@netlify/build` threw an uncaught exception
+    exception: {
+        title: 'Core internal error',
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        severity: 'error',
+    },
+    // Errors related with the telemetry output
+    telemetry: {
+        showInBuildLog: false,
+        title: 'Telemetry error',
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        severity: 'error',
+    },
+};
+// When no error type matches, it's an uncaught exception, i.e. a bug
+const DEFAULT_TYPE = 'exception';

package/lib/install/functions.js

@@ -0,0 +1,20 @@
+import { dirname } from 'path';
+import readdirp from 'readdirp';
+import { logInstallFunctionDependencies } from '../log/messages/install.js';
+import { installDependencies } from './main.js';
+// Install dependencies of Netlify Functions
+export const installFunctionDependencies = async function (functionsSrc, isLocal) {
+    const packagePaths = await getPackagePaths(functionsSrc);
+    if (packagePaths.length === 0) {
+        return;
+    }
+    logInstallFunctionDependencies();
+    const packageRoots = packagePaths.map(getPackageRoot);
+    await Promise.all(packageRoots.map((packageRoot) => installDependencies({ packageRoot, isLocal })));
+};
+const getPackagePaths = function (functionsSrc) {
+    return readdirp.promise(functionsSrc, { depth: 1, fileFilter: 'package.json' });
+};
+const getPackageRoot = function ({ fullPath }) {
+    return dirname(fullPath);
+};

package/lib/install/local.js

@@ -0,0 +1,45 @@
+import { packageDirectory } from 'pkg-dir';
+import { logInstallLocalPluginsDeps } from '../log/messages/install.js';
+import { installDependencies } from './main.js';
+// Install dependencies of local plugins.
+// Users must add this plugin to their `netlify.toml` `plugins` to use this
+// feature. We don't want to provide it by default because this makes build
+// slow and buggy.
+export const installLocalPluginsDependencies = async function ({ plugins, pluginsOptions, buildDir, mode, logs }) {
+    if (!plugins.some(isLocalInstallOptIn)) {
+        return;
+    }
+    const localPluginsOptions = getLocalPluginsOptions(pluginsOptions);
+    if (localPluginsOptions.length === 0) {
+        return;
+    }
+    const localPluginsOptionsA = await removeMainRoot(localPluginsOptions, buildDir);
+    if (localPluginsOptionsA.length === 0) {
+        return;
+    }
+    logInstallLocalPluginsDeps(logs, localPluginsOptionsA);
+    await Promise.all(localPluginsOptionsA.map(({ packageDir }) => installDependencies({ packageRoot: packageDir, isLocal: mode !== 'buildbot' })));
+};
+const isLocalInstallOptIn = function (plugin) {
+    return plugin.package === LOCAL_INSTALL_PLUGIN_NAME;
+};
+export const LOCAL_INSTALL_PLUGIN_NAME = '@netlify/plugin-local-install-core';
+// Core plugins and non-local plugins already have their dependencies installed
+const getLocalPluginsOptions = function (pluginsOptions) {
+    return pluginsOptions.filter(isLocalPlugin).filter(isUnique).filter(hasPackageDir);
+};
+const isLocalPlugin = function ({ loadedFrom }) {
+    return loadedFrom === 'local';
+};
+// Remove duplicates
+const isUnique = function ({ packageDir }, index, pluginsOptions) {
+    return pluginsOptions.slice(index + 1).every((pluginOption) => pluginOption.packageDir !== packageDir);
+};
+const hasPackageDir = function ({ packageDir }) {
+    return packageDir !== undefined;
+};
+// We only install dependencies of local plugins that have their own `package.json`
+const removeMainRoot = async function (localPluginsOptions, buildDir) {
+    const mainPackageDir = await packageDirectory({ cwd: buildDir });
+    return localPluginsOptions.filter(({ packageDir }) => packageDir !== mainPackageDir);
+};

package/lib/install/main.js

@@ -0,0 +1,67 @@
+import { homedir } from 'os';
+import { execa } from 'execa';
+import { pathExists } from 'path-exists';
+import { addErrorInfo } from '../error/info.js';
+// Install Node.js dependencies in a specific directory
+export const installDependencies = function ({ packageRoot, isLocal }) {
+    return runCommand({ packageRoot, isLocal, type: 'install' });
+};
+// Add new Node.js dependencies, with exact semver ranges
+export const addExactDependencies = function ({ packageRoot, isLocal, packages }) {
+    return runCommand({ packageRoot, packages, isLocal, type: 'addExact' });
+};
+const runCommand = async function ({ packageRoot, packages = [], isLocal, type }) {
+    try {
+        const [command, ...args] = await getCommand({ packageRoot, type, isLocal });
+        await execa(command, [...args, ...packages], { cwd: packageRoot, all: true });
+    }
+    catch (error) {
+        const message = getErrorMessage(error.all);
+        const errorA = new Error(`Error while installing dependencies in ${packageRoot}\n${message}`);
+        addErrorInfo(errorA, { type: 'dependencies' });
+        throw errorA;
+    }
+};
+// Retrieve the shell command to install or add dependencies
+const getCommand = async function ({ packageRoot, type, isLocal }) {
+    const manager = await getManager(type, packageRoot);
+    const command = COMMANDS[manager][type];
+    const commandA = addYarnCustomCache(command, manager, isLocal);
+    return commandA;
+};
+const getManager = async function (type, packageRoot) {
+    // `addDependencies()` always uses npm
+    if (type === 'addExact') {
+        return 'npm';
+    }
+    if (await pathExists(`${packageRoot}/yarn.lock`)) {
+        return 'yarn';
+    }
+    return 'npm';
+};
+const COMMANDS = {
+    npm: {
+        addExact: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund', '--save-exact'],
+        install: ['npm', 'install', '--no-progress', '--no-audit', '--no-fund'],
+    },
+    yarn: {
+        install: ['yarn', 'install', '--no-progress', '--non-interactive'],
+    },
+};
+// In CI, yarn uses a custom cache folder
+const addYarnCustomCache = function (command, manager, isLocal) {
+    if (manager !== 'yarn' || isLocal) {
+        return command;
+    }
+    return [...command, '--cache-folder', YARN_CI_CACHE_DIR];
+};
+const YARN_CI_CACHE_DIR = `${homedir()}/.yarn_cache`;
+// Retrieve message to add to install errors
+const getErrorMessage = function (allOutput) {
+    return allOutput.split('\n').filter(isNotNpmLogMessage).join('\n');
+};
+// Debug logs shown at the end of npm errors is not useful in Netlify Build
+const isNotNpmLogMessage = function (line) {
+    return NPM_LOG_MESSAGES.every((message) => !line.includes(message));
+};
+const NPM_LOG_MESSAGES = ['complete log of this run', '-debug.log'];