@netlify/build 28.0.1-beta → 28.0.1

package/lib/plugins/manifest/check.js

@@ -0,0 +1,85 @@
+import { addErrorInfo } from '../../error/info.js';
+import { serializeObject } from '../../log/serialize.js';
+import { THEME } from '../../log/theme.js';
+// Check that plugin inputs match the validation specified in "manifest.yml"
+// Also assign default values
+export const checkInputs = function ({ inputs, manifest: { inputs: rules = [] }, packageName, pluginPackageJson, loadedFrom, origin, }) {
+    try {
+        const inputsA = addDefaults(inputs, rules);
+        checkRequiredInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin });
+        checkUnknownInputs({ inputs: inputsA, rules, packageName, pluginPackageJson, loadedFrom, origin });
+        return inputsA;
+    }
+    catch (error) {
+        error.message = `${error.message}
+
+${THEME.errorSubHeader('Plugin inputs')}
+${serializeObject(inputs)}`;
+        throw error;
+    }
+};
+// Add "inputs[*].default"
+const addDefaults = function (inputs, rules) {
+    const defaults = rules.filter(hasDefault).map(getDefault);
+    return Object.assign({}, ...defaults, inputs);
+};
+const hasDefault = function (rule) {
+    return rule.default !== undefined;
+};
+const getDefault = function ({ name, default: defaultValue }) {
+    return { [name]: defaultValue };
+};
+// Check "inputs[*].required"
+const checkRequiredInputs = function ({ inputs, rules, packageName, pluginPackageJson, loadedFrom, origin }) {
+    const missingInputs = rules.filter((rule) => isMissingRequired(inputs, rule));
+    if (missingInputs.length === 0) {
+        return;
+    }
+    const names = missingInputs.map(getName);
+    const error = new Error(`Required inputs for plugin "${packageName}": ${names.join(', ')}`);
+    addInputError({ error, name: names[0], packageName, pluginPackageJson, loadedFrom, origin });
+    throw error;
+};
+const isMissingRequired = function (inputs, { name, required }) {
+    return required && inputs[name] === undefined;
+};
+const getName = function ({ name }) {
+    return name;
+};
+// Check each "inputs[*].*" property for a specific input
+const checkUnknownInputs = function ({ inputs, rules, packageName, pluginPackageJson, loadedFrom, origin }) {
+    const knownInputs = rules.map(getName);
+    const unknownInputs = Object.keys(inputs).filter((name) => !knownInputs.includes(name));
+    if (unknownInputs.length === 0) {
+        return;
+    }
+    const unknownInputsMessage = getUnknownInputsMessage({ packageName, knownInputs, unknownInputs });
+    const error = new Error(`${unknownInputsMessage}
+Check your plugin configuration to be sure that:
+  - the input name is spelled correctly
+  - the input is included in the plugin's available configuration options
+  - the plugin's input requirements have not changed`);
+    const [name] = unknownInputs;
+    addInputError({ error, name, packageName, pluginPackageJson, loadedFrom, origin });
+    throw error;
+};
+const getUnknownInputsMessage = function ({ packageName, knownInputs, unknownInputs }) {
+    const unknownInputsStr = unknownInputs.map(quoteWord).join(', ');
+    if (knownInputs.length === 0) {
+        return `Plugin "${packageName}" does not accept any inputs but you specified: ${unknownInputsStr}`;
+    }
+    const knownInputsStr = knownInputs.map(quoteWord).join(', ');
+    return `Unknown inputs for plugin "${packageName}": ${unknownInputsStr}
+Plugin inputs should be one of: ${knownInputsStr}`;
+};
+const quoteWord = function (word) {
+    return `"${word}"`;
+};
+// Add error information
+const addInputError = function ({ error, name, packageName, pluginPackageJson, loadedFrom, origin }) {
+    addErrorInfo(error, {
+        type: 'pluginInput',
+        plugin: { packageName, pluginPackageJson },
+        location: { event: 'load', packageName, input: name, loadedFrom, origin },
+    });
+};

package/lib/plugins/manifest/load.js

@@ -0,0 +1,38 @@
+import { promises as fs } from 'fs';
+import { load as loadYaml, JSON_SCHEMA } from 'js-yaml';
+import { addErrorInfo } from '../../error/info.js';
+import { validateManifest } from './validate.js';
+// Load "manifest.yml" using its file path
+export const loadManifest = async function ({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin }) {
+    try {
+        const rawManifest = await loadRawManifest(manifestPath);
+        const manifest = await parseManifest(rawManifest);
+        validateManifest(manifest, rawManifest);
+        return manifest;
+    }
+    catch (error) {
+        addErrorInfo(error, {
+            type: 'pluginValidation',
+            plugin: { packageName, pluginPackageJson },
+            location: { event: 'load', packageName, loadedFrom, origin },
+        });
+        throw error;
+    }
+};
+const loadRawManifest = async function (manifestPath) {
+    try {
+        return await fs.readFile(manifestPath, 'utf8');
+    }
+    catch (error) {
+        error.message = `Could not load plugin's "manifest.yml"\n${error.message}`;
+        throw error;
+    }
+};
+const parseManifest = async function (rawManifest) {
+    try {
+        return await loadYaml(rawManifest, { schema: JSON_SCHEMA, json: true });
+    }
+    catch (error) {
+        throw new Error(`Could not parse plugin's "manifest.yml"\n${error.message}`);
+    }
+};

package/lib/plugins/manifest/main.js

@@ -0,0 +1,17 @@
+import { addPluginLoadErrorStatus } from '../../status/load_error.js';
+import { checkInputs } from './check.js';
+import { loadManifest } from './load.js';
+import { getManifestPath } from './path.js';
+// Load plugin's `manifest.yml`
+export const useManifest = async function ({ packageName, loadedFrom, origin, inputs }, { pluginDir, packageDir, pluginPackageJson, pluginPackageJson: { version }, debug }) {
+    const manifestPath = await getManifestPath({ pluginDir, packageDir, packageName });
+    try {
+        const manifest = await loadManifest({ manifestPath, packageName, pluginPackageJson, loadedFrom, origin });
+        const inputsA = checkInputs({ inputs, manifest, packageName, pluginPackageJson, loadedFrom, origin });
+        return { manifest, inputs: inputsA };
+    }
+    catch (error) {
+        addPluginLoadErrorStatus({ error, packageName, version, debug });
+        throw error;
+    }
+};

package/lib/plugins/manifest/path.js

@@ -0,0 +1,24 @@
+import { locatePath } from 'locate-path';
+import { addErrorInfo } from '../../error/info.js';
+// Retrieve "manifest.yml" path for a specific plugin
+export const getManifestPath = async function ({ pluginDir, packageDir, packageName }) {
+    const dirs = [pluginDir, packageDir]
+        .filter(Boolean)
+        .flatMap((dir) => MANIFEST_FILENAMES.map((filename) => `${dir}/${filename}`));
+    const manifestPath = await locatePath(dirs);
+    validateManifestExists(manifestPath, packageName);
+    return manifestPath;
+};
+const validateManifestExists = function (manifestPath, packageName) {
+    if (manifestPath !== undefined) {
+        return;
+    }
+    const error = new Error(`The plugin "${packageName}" is missing a "manifest.yml".
+This might mean:
+  - The plugin "package" name is misspelled
+  - The plugin "package" points to a Node module that is not a Netlify Build plugin
+  - If you're developing a plugin, please see the documentation at https://docs.netlify.com/configure-builds/build-plugins/create-plugins/#anatomy-of-a-plugin`);
+    addErrorInfo(error, { type: 'resolveConfig' });
+    throw error;
+};
+const MANIFEST_FILENAMES = ['manifest.yml', 'manifest.yaml'];

package/lib/plugins/manifest/validate.js

@@ -0,0 +1,91 @@
+import isPlainObj from 'is-plain-obj';
+import { THEME } from '../../log/theme.js';
+// Validate `manifest.yml` syntax
+export const validateManifest = function (manifest, rawManifest) {
+    try {
+        validateBasic(manifest);
+        validateUnknownProps(manifest);
+        validateName(manifest);
+        validateInputs(manifest);
+    }
+    catch (error) {
+        error.message = `Plugin's "manifest.yml" ${error.message}
+
+${THEME.errorSubHeader('manifest.yml')}
+${rawManifest.trim()}`;
+        throw error;
+    }
+};
+const validateBasic = function (manifest) {
+    if (!isPlainObj(manifest)) {
+        throw new Error('must be a plain object');
+    }
+};
+const validateUnknownProps = function (manifest) {
+    const unknownProp = Object.keys(manifest).find((key) => !VALID_PROPS.has(key));
+    if (unknownProp !== undefined) {
+        throw new Error(`unknown property "${unknownProp}"`);
+    }
+};
+const VALID_PROPS = new Set(['name', 'inputs']);
+const validateName = function ({ name }) {
+    if (name === undefined) {
+        throw new Error('must contain a "name" property');
+    }
+    if (typeof name !== 'string') {
+        throw new TypeError('"name" property must be a string');
+    }
+};
+const validateInputs = function ({ inputs }) {
+    if (inputs === undefined) {
+        return;
+    }
+    if (!isArrayOfObjects(inputs)) {
+        throw new Error('"inputs" property must be an array of objects');
+    }
+    inputs.forEach(validateInput);
+};
+const isArrayOfObjects = function (objects) {
+    return Array.isArray(objects) && objects.every(isPlainObj);
+};
+const validateInput = function (input, index) {
+    try {
+        validateUnknownInputProps(input);
+        validateInputName(input);
+        validateInputDescription(input);
+        validateInputRequired(input);
+    }
+    catch (error) {
+        error.message = `"inputs" property is invalid.
+Input at position ${index} ${error.message}.`;
+        throw error;
+    }
+};
+const validateUnknownInputProps = function (input) {
+    const unknownProp = Object.keys(input).find((key) => !VALID_INPUT_PROPS.has(key));
+    if (unknownProp !== undefined) {
+        throw new Error(`has an unknown property "${unknownProp}"`);
+    }
+};
+const VALID_INPUT_PROPS = new Set(['name', 'description', 'required', 'default']);
+const validateInputName = function ({ name }) {
+    if (name === undefined) {
+        throw new Error('must contain a "name" property');
+    }
+    if (typeof name !== 'string') {
+        throw new TypeError('"name" property must be a string');
+    }
+};
+const validateInputDescription = function ({ description }) {
+    if (description === undefined) {
+        return;
+    }
+    if (typeof description !== 'string') {
+        throw new TypeError('"description" property must be a string');
+    }
+};
+const validateInputRequired = function ({ required }) {
+    if (required !== undefined && typeof required !== 'boolean') {
+        throw new Error('"required" property must be a boolean');
+    }
+};

package/lib/plugins/node_version.js

@@ -0,0 +1,30 @@
+import { version as currentVersion, execPath } from 'process';
+import semver from 'semver';
+import { addErrorInfo } from '../error/info.js';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+// Local plugins and `package.json`-installed plugins use user's preferred Node.js version if higher than our minimum
+// supported version. Else default to the system Node version.
+// Local and programmatic builds use `@netlify/build` Node.js version, which is
+// usually the system's Node.js version.
+// If the user Node version does not satisfy our supported engine range use our own system Node version
+export const addPluginsNodeVersion = function ({ pluginsOptions, nodePath, userNodeVersion }) {
+    const currentNodeVersion = semver.clean(currentVersion);
+    return pluginsOptions.map((pluginOptions) => addPluginNodeVersion({ pluginOptions, currentNodeVersion, userNodeVersion, nodePath }));
+};
+const addPluginNodeVersion = function ({ pluginOptions, pluginOptions: { loadedFrom }, currentNodeVersion, userNodeVersion, nodePath, }) {
+    return (loadedFrom === 'local' || loadedFrom === 'package.json') &&
+        semver.satisfies(userNodeVersion, ROOT_PACKAGE_JSON.engines.node)
+        ? { ...pluginOptions, nodePath, nodeVersion: userNodeVersion }
+        : { ...pluginOptions, nodePath: execPath, nodeVersion: currentNodeVersion };
+};
+// Ensure Node.js version is compatible with plugin's `engines.node`
+export const checkNodeVersion = function ({ nodeVersion, packageName, pluginPackageJson: { engines: { node: pluginNodeVersionRange } = {} } = {}, }) {
+    if (pluginNodeVersionRange && !semver.satisfies(nodeVersion, pluginNodeVersionRange)) {
+        throwUserError(`The Node.js version is ${nodeVersion} but the plugin "${packageName}" requires ${pluginNodeVersionRange}`);
+    }
+};
+const throwUserError = function (message) {
+    const error = new Error(message);
+    addErrorInfo(error, { type: 'resolveConfig' });
+    throw error;
+};

package/lib/plugins/options.js

@@ -0,0 +1,55 @@
+import { dirname } from 'path';
+import { installLocalPluginsDependencies } from '../install/local.js';
+import { measureDuration } from '../time/main.js';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+import { getPackageJson } from '../utils/package.js';
+import { useManifest } from './manifest/main.js';
+import { checkNodeVersion } from './node_version.js';
+import { resolvePluginsPath } from './resolve.js';
+// Load core plugins and user plugins
+const tGetPluginsOptions = async function ({ pluginsOptions, netlifyConfig: { plugins }, siteInfo, buildDir, nodePath, packageJson, userNodeVersion, mode, api, logs, debug, sendStatus, testOpts, featureFlags, }) {
+    const pluginsOptionsA = await resolvePluginsPath({
+        pluginsOptions,
+        siteInfo,
+        buildDir,
+        nodePath,
+        packageJson,
+        userNodeVersion,
+        mode,
+        api,
+        logs,
+        debug,
+        sendStatus,
+        testOpts,
+        featureFlags,
+    });
+    const pluginsOptionsB = await Promise.all(pluginsOptionsA.map((pluginOptions) => loadPluginFiles({ pluginOptions, debug })));
+    const pluginsOptionsC = pluginsOptionsB.filter(isNotRedundantCorePlugin);
+    await installLocalPluginsDependencies({ plugins, pluginsOptions: pluginsOptionsC, buildDir, mode, logs });
+    return { pluginsOptions: pluginsOptionsC };
+};
+export const getPluginsOptions = measureDuration(tGetPluginsOptions, 'get_plugins_options');
+// Retrieve plugin's main file path.
+// Then load plugin's `package.json` and `manifest.yml`.
+const loadPluginFiles = async function ({ pluginOptions, pluginOptions: { pluginPath, nodeVersion, packageName }, debug, }) {
+    const pluginDir = dirname(pluginPath);
+    const { packageDir, packageJson: pluginPackageJson } = await getPackageJson(pluginDir);
+    checkNodeVersion({ nodeVersion, packageName, pluginPackageJson });
+    const { manifest, inputs } = await useManifest(pluginOptions, { pluginDir, packageDir, pluginPackageJson, debug });
+    return { ...pluginOptions, pluginDir, packageDir, pluginPackageJson, manifest, inputs };
+};
+// Core plugins can only be included once.
+// For example, when testing core plugins, they might be included as local plugins,
+// in which case they should not be included twice.
+const isNotRedundantCorePlugin = function (pluginOptionsA, index, pluginsOptions) {
+    return (pluginOptionsA.loadedFrom !== 'core' ||
+        pluginsOptions.every((pluginOptionsB) => pluginOptionsA.manifest.name !== pluginOptionsB.manifest.name || pluginOptionsA === pluginOptionsB));
+};
+// Retrieve information about @netlify/build when an error happens there and not
+// in a plugin
+export const getSpawnInfo = function () {
+    return {
+        plugin: { packageName: ROOT_PACKAGE_JSON.name, pluginPackageJson: ROOT_PACKAGE_JSON },
+        location: { event: 'load', packageName: ROOT_PACKAGE_JSON.name, loadedFrom: 'core', origin: 'core' },
+    };
+};

package/lib/plugins/pinned_version.js

@@ -0,0 +1,83 @@
+import { handleBuildError } from '../error/handle.js';
+import { getMajorVersion } from '../utils/semver.js';
+// Retrieve plugin's pinned major versions by fetching the latest `PluginRun`
+// Only applies to `netlify.toml`-only installed plugins.
+export const addPinnedVersions = async function ({ pluginsOptions, api, siteInfo: { id: siteId }, sendStatus }) {
+    if (!sendStatus || api === undefined || !siteId) {
+        return pluginsOptions;
+    }
+    const packages = pluginsOptions.filter(shouldFetchPinVersion).map(getPackageName);
+    if (packages.length === 0) {
+        return pluginsOptions;
+    }
+    const pluginRuns = await api.getLatestPluginRuns({ site_id: siteId, packages, state: 'success' });
+    const pluginsOptionsA = pluginsOptions.map((pluginOption) => addPinnedVersion(pluginOption, pluginRuns));
+    return pluginsOptionsA;
+};
+const shouldFetchPinVersion = function ({ pinnedVersion, loadedFrom, origin }) {
+    return pinnedVersion === undefined && loadedFrom === 'auto_install' && origin === 'config';
+};
+const getPackageName = function ({ packageName }) {
+    return packageName;
+};
+const addPinnedVersion = function (pluginOptions, pluginRuns) {
+    const foundPluginRun = pluginRuns.find((pluginRun) => pluginRun.package === pluginOptions.packageName);
+    if (foundPluginRun === undefined) {
+        return pluginOptions;
+    }
+    const pinnedVersion = getMajorVersion(foundPluginRun.version);
+    return pinnedVersion === undefined ? pluginOptions : { ...pluginOptions, pinnedVersion };
+};
+// Send an API request to pin plugins' major versions.
+// Only applies to UI-installed plugins.
+export const pinPlugins = async function ({ pluginsOptions, failedPlugins, api, siteInfo: { id: siteId }, childEnv, mode, netlifyConfig, errorMonitor, logs, debug, testOpts, sendStatus, }) {
+    if ((mode !== 'buildbot' && !sendStatus) || api === undefined || !siteId) {
+        return;
+    }
+    const pluginsOptionsA = pluginsOptions.filter((pluginOptions) => shouldPinVersion({ pluginOptions, failedPlugins }));
+    await Promise.all(pluginsOptionsA.map((pluginOptions) => pinPlugin({
+        pluginOptions,
+        api,
+        childEnv,
+        mode,
+        netlifyConfig,
+        errorMonitor,
+        logs,
+        debug,
+        testOpts,
+        siteId,
+    })));
+};
+// Only pin version if:
+//  - the plugin's version has not been pinned yet
+//  - the plugin was installed in the UI
+//  - both the build and the plugin succeeded
+const shouldPinVersion = function ({ pluginOptions: { packageName, pinnedVersion, loadedFrom, origin }, failedPlugins, }) {
+    return (pinnedVersion === undefined &&
+        loadedFrom === 'auto_install' &&
+        origin === 'ui' &&
+        !failedPlugins.includes(packageName));
+};
+const pinPlugin = async function ({ pluginOptions: { packageName, pluginPackageJson: { version }, }, api, childEnv, mode, netlifyConfig, errorMonitor, logs, debug, testOpts, siteId, }) {
+    const pinnedVersion = getMajorVersion(version);
+    try {
+        await api.updatePlugin({
+            package: encodeURIComponent(packageName),
+            site_id: siteId,
+            body: { pinned_version: pinnedVersion },
+        });
+        // Bitballoon API randomly fails with 502.
+        // Builds should be successful when this API call fails, but we still want
+        // to report the error both in logs and in error monitoring.
+    }
+    catch (error) {
+        if (shouldIgnoreError(error)) {
+            return;
+        }
+        await handleBuildError(error, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts });
+    }
+};
+// Status is 404 if the plugin is uninstalled while the build is ongoing.
+const shouldIgnoreError = function ({ status }) {
+    return status === 404;
+};

package/lib/plugins/resolve.js

@@ -0,0 +1,110 @@
+import { addErrorInfo } from '../error/info.js';
+import { installMissingPlugins } from '../install/missing.js';
+import { resolvePath, tryResolvePath } from '../utils/resolve.js';
+import { addExpectedVersions } from './expected_version.js';
+import { addPluginsNodeVersion } from './node_version.js';
+import { addPinnedVersions } from './pinned_version.js';
+// Try to find plugins in four places, by priority order:
+//  - already loaded (core plugins)
+//  - local plugin
+//  - external plugin already installed in `node_modules`, most likely through `package.json`
+//  - automatically installed by us, to `.netlify/plugins/`
+export const resolvePluginsPath = async function ({ pluginsOptions, siteInfo, buildDir, nodePath, packageJson, userNodeVersion, mode, api, logs, debug, sendStatus, testOpts, featureFlags, }) {
+    const autoPluginsDir = getAutoPluginsDir(buildDir);
+    const pluginsOptionsA = await Promise.all(pluginsOptions.map((pluginOptions) => resolvePluginPath({ pluginOptions, buildDir, autoPluginsDir })));
+    const pluginsOptionsB = addPluginsNodeVersion({
+        pluginsOptions: pluginsOptionsA,
+        nodePath,
+        userNodeVersion,
+        logs,
+    });
+    const pluginsOptionsC = await addPinnedVersions({ pluginsOptions: pluginsOptionsB, api, siteInfo, sendStatus });
+    const pluginsOptionsD = await addExpectedVersions({
+        pluginsOptions: pluginsOptionsC,
+        autoPluginsDir,
+        packageJson,
+        debug,
+        logs,
+        buildDir,
+        testOpts,
+        featureFlags,
+    });
+    const pluginsOptionsE = await handleMissingPlugins({
+        pluginsOptions: pluginsOptionsD,
+        autoPluginsDir,
+        mode,
+        logs,
+    });
+    return pluginsOptionsE;
+};
+// Find the path to the directory used to install plugins automatically.
+// It is a subdirectory of `buildDir`, so that the plugin can require the
+// project's dependencies (peer dependencies).
+const getAutoPluginsDir = function (buildDir) {
+    return `${buildDir}/${AUTO_PLUGINS_DIR}`;
+};
+const AUTO_PLUGINS_DIR = '.netlify/plugins/';
+const resolvePluginPath = async function ({ pluginOptions, pluginOptions: { packageName, loadedFrom }, buildDir, autoPluginsDir, }) {
+    // Core plugins
+    if (loadedFrom !== undefined) {
+        return pluginOptions;
+    }
+    const localPackageName = normalizeLocalPackageName(packageName);
+    // Local plugins
+    if (localPackageName.startsWith('.')) {
+        const { path: localPath, error } = await tryResolvePath(localPackageName, buildDir);
+        validateLocalPluginPath(error, localPackageName);
+        return { ...pluginOptions, pluginPath: localPath, loadedFrom: 'local' };
+    }
+    // Plugin added to `package.json`
+    const { path: manualPath } = await tryResolvePath(packageName, buildDir);
+    if (manualPath !== undefined) {
+        return { ...pluginOptions, pluginPath: manualPath, loadedFrom: 'package.json' };
+    }
+    // Previously automatically installed
+    const { path: automaticPath } = await tryResolvePath(packageName, autoPluginsDir);
+    if (automaticPath !== undefined) {
+        return { ...pluginOptions, pluginPath: automaticPath, loadedFrom: 'auto_install' };
+    }
+    // Happens if the plugin:
+    //  - name is mispelled
+    //  - is not in our official list
+    //  - is in our official list but has not been installed by this site yet
+    return { ...pluginOptions, loadedFrom: 'auto_install' };
+};
+// `packageName` starting with `/` are relative to the build directory
+const normalizeLocalPackageName = function (packageName) {
+    if (packageName.startsWith('/')) {
+        return `.${packageName}`;
+    }
+    return packageName;
+};
+// When requiring a local plugin with an invalid file path
+const validateLocalPluginPath = function (error, localPackageName) {
+    if (error !== undefined) {
+        error.message = `Plugin could not be found using local path: ${localPackageName}\n${error.message}`;
+        addErrorInfo(error, { type: 'resolveConfig' });
+        throw error;
+    }
+};
+// Install plugins from the official list that have not been previously installed.
+// Print a warning if they have not been installed through the UI.
+const handleMissingPlugins = async function ({ pluginsOptions, autoPluginsDir, mode, logs }) {
+    const missingPlugins = pluginsOptions.filter(isMissingPlugin);
+    if (missingPlugins.length === 0) {
+        return pluginsOptions;
+    }
+    await installMissingPlugins({ missingPlugins, autoPluginsDir, mode, logs });
+    return await Promise.all(pluginsOptions.map((pluginOptions) => resolveMissingPluginPath({ pluginOptions, autoPluginsDir })));
+};
+// Resolve the plugins that just got automatically installed
+const resolveMissingPluginPath = async function ({ pluginOptions, pluginOptions: { packageName }, autoPluginsDir }) {
+    if (!isMissingPlugin(pluginOptions)) {
+        return pluginOptions;
+    }
+    const pluginPath = await resolvePath(packageName, autoPluginsDir);
+    return { ...pluginOptions, pluginPath };
+};
+const isMissingPlugin = function ({ isMissing }) {
+    return isMissing;
+};

package/lib/plugins/spawn.js

@@ -0,0 +1,54 @@
+import { fileURLToPath } from 'url';
+import { execaNode } from 'execa';
+import { addErrorInfo } from '../error/info.js';
+import { logRuntime, logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins, } from '../log/messages/compatibility.js';
+import { measureDuration } from '../time/main.js';
+import { getEventFromChild } from './ipc.js';
+import { getSpawnInfo } from './options.js';
+const CHILD_MAIN_FILE = fileURLToPath(new URL('child/main.js', import.meta.url));
+// Start child processes used by all plugins
+// We fire plugins through child processes so that:
+//  - each plugin is sandboxed, e.g. cannot access/modify its parent `process`
+//    (for both security and safety reasons)
+//  - logs can be buffered which allows manipulating them for log shipping,
+//    transforming and parallel plugins
+const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs, debug }) {
+    logRuntime(logs, pluginsOptions);
+    logLoadingPlugins(logs, pluginsOptions, debug);
+    logOutdatedPlugins(logs, pluginsOptions);
+    logIncompatiblePlugins(logs, pluginsOptions);
+    const childProcesses = await Promise.all(pluginsOptions.map(({ pluginDir, nodePath }) => startPlugin({ pluginDir, nodePath, buildDir, childEnv })));
+    return { childProcesses };
+};
+export const startPlugins = measureDuration(tStartPlugins, 'start_plugins');
+const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv }) {
+    const childProcess = execaNode(CHILD_MAIN_FILE, {
+        cwd: buildDir,
+        preferLocal: true,
+        localDir: pluginDir,
+        nodePath,
+        execPath: nodePath,
+        env: childEnv,
+        extendEnv: false,
+        serialization: 'advanced',
+    });
+    try {
+        await getEventFromChild(childProcess, 'ready');
+        return { childProcess };
+    }
+    catch (error) {
+        const spawnInfo = getSpawnInfo();
+        addErrorInfo(error, spawnInfo);
+        throw error;
+    }
+};
+// Stop all plugins child processes
+export const stopPlugins = function (childProcesses) {
+    childProcesses.forEach(stopPlugin);
+};
+const stopPlugin = function ({ childProcess }) {
+    if (childProcess.connected) {
+        childProcess.disconnect();
+    }
+    childProcess.kill();
+};

package/lib/plugins_core/add.js

@@ -0,0 +1,35 @@
+import { listCorePlugins, isCorePlugin } from './list.js';
+// Add core plugins and user plugins together.
+// Do not allow user override of core plugins.
+export const addCorePlugins = function ({ netlifyConfig: { plugins }, constants }) {
+    const corePlugins = listCorePlugins(constants);
+    const allCorePlugins = corePlugins
+        .map((corePlugin) => addCoreProperties(corePlugin, plugins))
+        .filter((corePlugin) => !isOptionalCore(corePlugin, plugins));
+    const userPlugins = plugins.filter(isUserPlugin);
+    const allPlugins = [...userPlugins, ...allCorePlugins];
+    const pluginsOptions = allPlugins.map(normalizePluginOptions);
+    return pluginsOptions;
+};
+const addCoreProperties = function (corePlugin, plugins) {
+    const inputs = getCorePluginInputs(corePlugin, plugins);
+    return { ...corePlugin, inputs, loadedFrom: 'core', origin: 'core' };
+};
+// Core plugins can get inputs too
+const getCorePluginInputs = function (corePlugin, plugins) {
+    const configuredCorePlugin = plugins.find((plugin) => plugin.package === corePlugin.package);
+    if (configuredCorePlugin === undefined) {
+        return {};
+    }
+    return configuredCorePlugin.inputs;
+};
+// Optional core plugins requires user opt-in
+const isOptionalCore = function (pluginA, plugins) {
+    return pluginA.optional && plugins.every((pluginB) => pluginB.package !== pluginA.package);
+};
+const isUserPlugin = function (plugin) {
+    return !isCorePlugin(plugin.package);
+};
+const normalizePluginOptions = function ({ package: packageName, pluginPath, pinned_version: pinnedVersion, loadedFrom, origin, inputs, }) {
+    return { packageName, pluginPath, pinnedVersion, loadedFrom, origin, inputs };
+};