@netlify/build 29.0.0-rc → 29.0.0

package/lib/log/messages/dry.js

@@ -0,0 +1,41 @@
+import figures from 'figures';
+import { logMessage, logSubHeader } from '../logger.js';
+import { THEME } from '../theme.js';
+export const logDryRunStart = function ({ logs, eventWidth, stepsCount }) {
+    const columnWidth = getDryColumnWidth(eventWidth, stepsCount);
+    const line = '─'.repeat(columnWidth);
+    const secondLine = '─'.repeat(columnWidth);
+    logSubHeader(logs, 'Netlify Build Commands');
+    logMessage(logs, `For more information on build events see the docs https://github.com/netlify/build
+
+Running \`netlify build\` will execute this build flow
+
+${THEME.header(`┌─${line}─┬─${secondLine}─┐
+│ ${DRY_HEADER_NAMES[0].padEnd(columnWidth)} │ ${DRY_HEADER_NAMES[1].padEnd(columnWidth)} │
+└─${line}─┴─${secondLine}─┘`)}`);
+};
+export const logDryRunStep = function ({ logs, step: { event, packageName, coreStepDescription }, index, netlifyConfig, eventWidth, stepsCount, }) {
+    const columnWidth = getDryColumnWidth(eventWidth, stepsCount);
+    const fullName = getFullName(coreStepDescription, netlifyConfig, packageName);
+    const line = '─'.repeat(columnWidth);
+    const countText = `${index + 1}. `;
+    const downArrow = stepsCount === index + 1 ? '  ' : ` ${figures.arrowDown}`;
+    const eventWidthA = columnWidth - countText.length - downArrow.length;
+    logMessage(logs, `${THEME.header(`┌─${line}─┐`)}
+${THEME.header(`│ ${countText}${event.padEnd(eventWidthA)}${downArrow} │`)} ${fullName}
+${THEME.header(`└─${line}─┘ `)}`);
+};
+const getFullName = function (coreStepDescription, netlifyConfig, packageName) {
+    return coreStepDescription === undefined
+        ? `Plugin ${THEME.highlightWords(packageName)}`
+        : coreStepDescription({ netlifyConfig });
+};
+const getDryColumnWidth = function (eventWidth, stepsCount) {
+    const symbolsWidth = `${stepsCount}`.length + COLUMN_EXTRA_WIDTH;
+    return Math.max(eventWidth + symbolsWidth, DRY_HEADER_NAMES[1].length);
+};
+const COLUMN_EXTRA_WIDTH = 4;
+const DRY_HEADER_NAMES = ['Event', 'Location'];
+export const logDryRunEnd = function (logs) {
+    logMessage(logs, `\nIf this looks good to you, run \`netlify build\` to execute the build\n`);
+};

package/lib/log/messages/install.js

@@ -0,0 +1,25 @@
+import { isRuntime } from '../../utils/runtime.js';
+import { log, logArray, logSubHeader } from '../logger.js';
+export const logInstallMissingPlugins = function (logs, packages) {
+    const runtimes = packages.filter((pkg) => isRuntime(pkg));
+    const plugins = packages.filter((pkg) => !isRuntime(pkg));
+    if (plugins.length !== 0) {
+        logSubHeader(logs, 'Installing plugins');
+        logArray(logs, packages);
+    }
+    if (runtimes.length !== 0) {
+        const [nextRuntime] = runtimes;
+        logSubHeader(logs, `Using Next.js Runtime - v${nextRuntime.pluginPackageJson.version}`);
+    }
+};
+export const logInstallLocalPluginsDeps = function (logs, localPluginsOptions) {
+    const packages = localPluginsOptions.map(getPackageName);
+    logSubHeader(logs, 'Installing local plugins dependencies');
+    logArray(logs, packages);
+};
+export const logInstallFunctionDependencies = function () {
+    log(undefined, 'Installing functions dependencies');
+};
+const getPackageName = function ({ packageName }) {
+    return packageName;
+};

package/lib/log/messages/ipc.js

@@ -0,0 +1,29 @@
+import { log } from '../logger.js';
+const logVerbose = function (logs, verbose, message) {
+    if (!verbose) {
+        return;
+    }
+    log(logs, message);
+};
+export const logSendingEventToChild = function (logs, verbose) {
+    logVerbose(logs, verbose, 'Step starting.');
+};
+export const logSentEventToChild = function (logs, verbose) {
+    logVerbose(logs, verbose, 'Step started.');
+};
+export const logPluginMethodStart = function (verbose) {
+    logVerbose(undefined, verbose, 'Plugin logic started.');
+};
+export const logPluginMethodEnd = function (verbose) {
+    logVerbose(undefined, verbose, 'Plugin logic ended.');
+};
+export const logSendingEventToParent = function (verbose, error) {
+    const message = error instanceof Error ? `Step erroring.\n${error.stack}` : 'Stop closing.';
+    logVerbose(undefined, verbose, message);
+};
+export const logReceivedEventFromChild = function (logs, verbose) {
+    logVerbose(logs, verbose, 'Step ended.');
+};
+export const logStepCompleted = function (logs, verbose) {
+    logVerbose(logs, verbose, 'Step completed.');
+};

package/lib/log/messages/mutations.js

@@ -0,0 +1,62 @@
+import { promises as fs } from 'fs';
+import { inspect } from 'util';
+import { pathExists } from 'path-exists';
+import { log, logMessage, logSubHeader } from '../logger.js';
+export const logConfigMutations = function (logs, newConfigMutations, debug) {
+    const configMutationsToLog = debug ? newConfigMutations : newConfigMutations.filter(shouldLogConfigMutation);
+    configMutationsToLog.forEach(({ keysString, value }) => {
+        logConfigMutation(logs, keysString, value);
+    });
+};
+// Some configuration mutations are only logged in debug mode
+const shouldLogConfigMutation = function ({ keysString }) {
+    return !HIDDEN_PROPS.some((hiddenProp) => keysString.startsWith(hiddenProp));
+};
+// `functions` is an object which can have thousands of properties, one per
+// function file. This can be very verbose, especially for plugins which create
+// many function files like Essential Next.js
+const HIDDEN_PROPS = ['functions'];
+const logConfigMutation = function (logs, keysString, value) {
+    const newValue = shouldHideConfigValue(keysString) ? '' : ` to ${inspect(value, { colors: false })}`;
+    log(logs, `Netlify configuration property "${keysString}" value changed${newValue}.`);
+};
+const shouldHideConfigValue = function (keysString) {
+    return SECRET_PROPS.some((secretProp) => keysString.startsWith(secretProp));
+};
+const SECRET_PROPS = ['build.environment'];
+export const logConfigOnUpload = async function ({ logs, configPath, debug }) {
+    if (!debug) {
+        return;
+    }
+    logSubHeader(logs, 'Uploaded config');
+    if (!(await pathExists(configPath))) {
+        logMessage(logs, 'No netlify.toml');
+        return;
+    }
+    const configContents = await fs.readFile(configPath, 'utf8');
+    logMessage(logs, configContents.trim());
+};
+export const logHeadersOnUpload = async function ({ logs, headersPath, debug }) {
+    if (!debug) {
+        return;
+    }
+    logSubHeader(logs, 'Uploaded headers');
+    if (!(await pathExists(headersPath))) {
+        logMessage(logs, 'No headers');
+        return;
+    }
+    const headersContents = await fs.readFile(headersPath, 'utf8');
+    logMessage(logs, headersContents.trim());
+};
+export const logRedirectsOnUpload = async function ({ logs, redirectsPath, debug }) {
+    if (!debug) {
+        return;
+    }
+    logSubHeader(logs, 'Uploaded redirects');
+    if (!(await pathExists(redirectsPath))) {
+        logMessage(logs, 'No redirects\n');
+        return;
+    }
+    const redirectsContents = await fs.readFile(redirectsPath, 'utf8');
+    logMessage(logs, `${redirectsContents.trim()}\n`);
+};

package/{src → lib}/log/messages/plugins.js

@@ -1,39 +1,25 @@
-import { log, logArray, logWarning, logSubHeader } from '../logger.js'
-
+import { log, logArray, logWarning, logSubHeader } from '../logger.js';
 export const logPluginsFetchError = function (logs, message) {
-  logWarning(
-    logs,
-    `
+    logWarning(logs, `
 Warning: could not fetch latest plugins list. Plugins versions might not be the latest.
-${message}`,
-  )
-}
-
+${message}`);
+};
 export const logPluginsList = function ({ pluginsList, debug, logs }) {
-  if (!debug) {
-    return
-  }
-
-  // eslint-disable-next-line fp/no-mutating-methods
-  const pluginsListArray = Object.entries(pluginsList).map(getPluginsListItem).sort()
-
-  logSubHeader(logs, 'Available plugins')
-  logArray(logs, pluginsListArray)
-}
-
+    if (!debug) {
+        return;
+    }
+    const pluginsListArray = Object.entries(pluginsList).map(getPluginsListItem).sort();
+    logSubHeader(logs, 'Available plugins');
+    logArray(logs, pluginsListArray);
+};
 const getPluginsListItem = function ([packageName, versions]) {
-  return `${packageName}@${versions[0].version}`
-}
-
+    return `${packageName}@${versions[0].version}`;
+};
 export const logFailPluginWarning = function (methodName, event) {
-  logWarning(
-    undefined,
-    `Plugin error: since "${event}" happens after deploy, the build has already succeeded and cannot fail anymore. This plugin should either:
+    logWarning(undefined, `Plugin error: since "${event}" happens after deploy, the build has already succeeded and cannot fail anymore. This plugin should either:
 - use utils.build.failPlugin() instead of utils.build.${methodName}() to clarify that the plugin failed, but not the build.
-- use "onPostBuild" instead of "${event}" if the plugin failure should make the build fail too. Please note that "onPostBuild" (unlike "${event}") happens before deploy.`,
-  )
-}
-
+- use "onPostBuild" instead of "${event}" if the plugin failure should make the build fail too. Please note that "onPostBuild" (unlike "${event}") happens before deploy.`);
+};
 export const logDeploySuccess = function (logs) {
-  log(logs, 'Site deploy was successfully initiated')
-}
+    log(logs, 'Site deploy was successfully initiated');
+};

package/lib/log/messages/status.js

@@ -0,0 +1,14 @@
+import { logMessage, logHeader, logSubHeader } from '../logger.js';
+import { THEME } from '../theme.js';
+export const logStatuses = function (logs, statuses) {
+    logHeader(logs, 'Summary');
+    statuses.forEach((status) => {
+        logStatus(logs, status);
+    });
+};
+const logStatus = function (logs, { packageName, title = `Plugin ${packageName} ran successfully`, summary, text }) {
+    const titleA = title.includes(packageName) ? title : `${packageName}: ${title}`;
+    const body = text === undefined ? summary : `${summary}\n${THEME.dimWords(text)}`;
+    logSubHeader(logs, titleA);
+    logMessage(logs, body);
+};

package/lib/log/messages/steps.js

@@ -0,0 +1,18 @@
+import { getLogHeaderFunc } from '../header_func.js';
+import { log, logMessage } from '../logger.js';
+import { THEME } from '../theme.js';
+export const logStepStart = function ({ logs, event, packageName, coreStepDescription, index, error, netlifyConfig }) {
+    const description = getDescription({ coreStepDescription, netlifyConfig, packageName, event });
+    const logHeaderFunc = getLogHeaderFunc(error);
+    logHeaderFunc(logs, `${index + 1}. ${description}`);
+    logMessage(logs, '');
+};
+const getDescription = function ({ coreStepDescription, netlifyConfig, packageName, event }) {
+    return coreStepDescription === undefined ? `${packageName} (${event} event)` : coreStepDescription({ netlifyConfig });
+};
+export const logBuildCommandStart = function (logs, buildCommand) {
+    log(logs, THEME.highlightWords(`$ ${buildCommand}`));
+};
+export const logStepSuccess = function (logs) {
+    logMessage(logs, '');
+};

package/lib/log/old_version.js

@@ -0,0 +1,32 @@
+import { stdout } from 'process';
+import UpdateNotifier from 'update-notifier';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+// Many build errors happen in local builds that do not use the latest version
+// of `@netlify/build`. We print a warning message on those.
+// We only print this when Netlify CLI has been used. Programmatic usage might
+// come from a deep dependency calling `@netlify/build` and user might not be
+// able to take any upgrade action, making the message noisy.
+export const logOldCliVersionError = function ({ mode, testOpts }) {
+    if (mode !== 'cli') {
+        return;
+    }
+    const corePackageJson = getCorePackageJson(testOpts);
+    UpdateNotifier({ pkg: corePackageJson, updateCheckInterval: 1 }).notify({
+        message: OLD_VERSION_MESSAGE,
+        shouldNotifyInNpmScript: true,
+    });
+};
+const getCorePackageJson = function (testOpts) {
+    // TODO: Find a way to test this without injecting code in the `src/`
+    if (testOpts.oldCliLogs) {
+        // `update-notifier` does not do anything if not in a TTY.
+        // In tests, we need to monkey patch this
+        // Mutation is required due to how `stdout.isTTY` works
+        stdout.isTTY = true;
+        return { ...ROOT_PACKAGE_JSON, version: '0.0.1' };
+    }
+    return ROOT_PACKAGE_JSON;
+};
+const OLD_VERSION_MESSAGE = `Please update netlify-cli to its latest version.
+If netlify-cli is already the latest version,
+please update your dependencies lock file instead.`;

package/lib/log/serialize.js

@@ -0,0 +1,10 @@
+import { dump } from 'js-yaml';
+export const serializeObject = function (object) {
+    return dump(object, { noRefs: true, sortKeys: true, lineWidth: Number.POSITIVE_INFINITY }).trimEnd();
+};
+export const serializeArray = function (array) {
+    return array.map(addDash).join('\n');
+};
+const addDash = function (string) {
+    return ` - ${string}`;
+};

package/lib/log/stream.js

@@ -0,0 +1,68 @@
+import { stdout, stderr } from 'process';
+import { promisify } from 'util';
+// TODO: replace with `timers/promises` after dropping Node < 15.0.0
+const pSetTimeout = promisify(setTimeout);
+// We try to use `stdio: inherit` because it keeps `stdout/stderr` as `TTY`,
+// which solves many problems. However we can only do it in build.command.
+// Plugins have several events, so need to be switch on and off instead.
+// In buffer mode (`logs` not `undefined`), `pipe` is necessary.
+export const getBuildCommandStdio = function (logs) {
+    if (logs !== undefined) {
+        return 'pipe';
+    }
+    return 'inherit';
+};
+// Add build command output
+export const handleBuildCommandOutput = function ({ stdout: commandStdout, stderr: commandStderr }, logs) {
+    if (logs === undefined) {
+        return;
+    }
+    pushBuildCommandOutput(commandStdout, logs.stdout);
+    pushBuildCommandOutput(commandStderr, logs.stderr);
+};
+const pushBuildCommandOutput = function (output, logsArray) {
+    if (output === '') {
+        return;
+    }
+    logsArray.push(output);
+};
+// Start plugin step output
+export const pipePluginOutput = function (childProcess, logs) {
+    if (logs === undefined) {
+        return streamOutput(childProcess);
+    }
+    return pushOutputToLogs(childProcess, logs);
+};
+// Stop streaming/buffering plugin step output
+export const unpipePluginOutput = async function (childProcess, logs, listeners) {
+    // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
+    await pSetTimeout(0);
+    if (logs === undefined) {
+        return unstreamOutput(childProcess);
+    }
+    unpushOutputToLogs(childProcess, logs, listeners);
+};
+// Usually, we stream stdout/stderr because it is more efficient
+const streamOutput = function (childProcess) {
+    childProcess.stdout.pipe(stdout);
+    childProcess.stderr.pipe(stderr);
+};
+const unstreamOutput = function (childProcess) {
+    childProcess.stdout.unpipe(stdout);
+    childProcess.stderr.unpipe(stderr);
+};
+// In tests, we push to the `logs` array instead
+const pushOutputToLogs = function (childProcess, logs) {
+    const stdoutListener = logsListener.bind(null, logs.stdout);
+    const stderrListener = logsListener.bind(null, logs.stderr);
+    childProcess.stdout.on('data', stdoutListener);
+    childProcess.stderr.on('data', stderrListener);
+    return { stdoutListener, stderrListener };
+};
+const logsListener = function (logs, chunk) {
+    logs.push(chunk.toString().trimEnd());
+};
+const unpushOutputToLogs = function (childProcess, logs, { stdoutListener, stderrListener }) {
+    childProcess.stdout.removeListener('data', stdoutListener);
+    childProcess.stderr.removeListener('data', stderrListener);
+};

package/lib/log/theme.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+/**
+ * Color theme. Please use this instead of requiring chalk directly,
+ * to ensure consistent colors.
+ */
+export const THEME = {
+    // Main headers
+    header: chalk.cyanBright.bold,
+    // Single lines used as sub-headers
+    subHeader: chalk.cyan.bold,
+    // One of several words that should be highlighted inside a line
+    highlightWords: chalk.cyan,
+    // Same for errors
+    errorHeader: chalk.redBright.bold,
+    errorSubHeader: chalk.red.bold,
+    errorLine: chalk.redBright,
+    errorHighlightWords: chalk.redBright.bold,
+    // Same for warnings
+    warningHeader: chalk.yellowBright.bold,
+    warningSubHeader: chalk.yellow.bold,
+    warningLine: chalk.yellowBright,
+    warningHighlightWords: chalk.yellowBright.bold,
+    // One of several words that should be dimmed inside a line
+    dimWords: chalk.gray,
+    // No colors
+    none: (string) => string,
+};

package/lib/plugins/child/diff.js

@@ -0,0 +1,46 @@
+import { isDeepStrictEqual } from 'util';
+import isPlainObj from 'is-plain-obj';
+import rfdc from 'rfdc';
+const clone = rfdc();
+// Copy `netlifyConfig` so we can compare before/after mutating it
+export const cloneNetlifyConfig = function (netlifyConfig) {
+    return clone(netlifyConfig);
+};
+// Diff `netlifyConfig` before and after mutating it to retrieve an array of
+// `configMutations` objects.
+// We need to keep track of the changes on `netlifyConfig` so they can be
+// processed later to:
+//  - Warn plugin authors when mutating read-only properties
+//  - Apply the change to `netlifyConfig` in the parent process so it can
+//    run `@netlify/config` to normalize and validate the new values
+// `configMutations` is passed to parent process as JSON
+export const getConfigMutations = function (netlifyConfig, netlifyConfigCopy, event) {
+    const configMutations = diffObjects(netlifyConfig, netlifyConfigCopy, []);
+    return configMutations.map((configMutation) => getConfigMutation(configMutation, event));
+};
+// We only recurse over plain objects, not arrays. Which means array properties
+// can only be modified all at once.
+const diffObjects = function (objA, objB, parentKeys) {
+    const allKeys = [...new Set([...Object.keys(objA), ...Object.keys(objB)])];
+    return allKeys.flatMap((key) => {
+        const valueA = objA[key];
+        const valueB = objB[key];
+        const keys = [...parentKeys, key];
+        if (isPlainObj(valueA) && isPlainObj(valueB)) {
+            return diffObjects(valueA, valueB, keys);
+        }
+        if (isDeepStrictEqual(valueA, valueB)) {
+            return [];
+        }
+        return [{ keys, value: valueB }];
+    });
+};
+const getConfigMutation = function ({ keys, value }, event) {
+    const serializedKeys = keys.map(String);
+    return {
+        keys: serializedKeys,
+        keysString: serializedKeys.join('.'),
+        value,
+        event,
+    };
+};

package/lib/plugins/child/error.js

@@ -0,0 +1,26 @@
+import logProcessErrors from 'log-process-errors';
+import { errorToJson } from '../../error/build.js';
+import { addDefaultErrorInfo, isBuildError } from '../../error/info.js';
+import { normalizeError } from '../../error/parse/normalize.js';
+import { sendEventToParent } from '../ipc.js';
+// Handle any top-level error and communicate it back to parent
+export const handleError = async function (error, verbose) {
+    const errorA = normalizeError(error);
+    addDefaultErrorInfo(errorA, { type: 'pluginInternal' });
+    const errorPayload = errorToJson(errorA);
+    await sendEventToParent('error', errorPayload, verbose, errorA);
+};
+// On uncaught exceptions and unhandled rejections, print the stack trace.
+// Also, prevent child processes from crashing on uncaught exceptions.
+export const handleProcessErrors = function () {
+    logProcessErrors({ log: handleProcessError, exitOn: [] });
+};
+const handleProcessError = async function (error, level, originalError) {
+    if (level !== 'error') {
+        console[level](error);
+        return;
+    }
+    // Do not use log-process-errors prettification with errors thrown by `utils.build.*`
+    const errorA = isBuildError(originalError) ? originalError : error;
+    await handleError(errorA);
+};

package/lib/plugins/child/lazy.js

@@ -0,0 +1,15 @@
+import memoizeOne from 'memoize-one';
+// Add a `object[propName]` whose value is the return value of `getFunc()`, but
+// is only retrieved when accessed.
+export const addLazyProp = function (object, propName, getFunc) {
+    const mGetFunc = memoizeOne(getFunc, returnTrue);
+    // Mutation is required due to the usage of `Object.defineProperty()`
+    Object.defineProperty(object, propName, {
+        get: mGetFunc,
+        enumerable: true,
+        configurable: true,
+    });
+};
+const returnTrue = function () {
+    return true;
+};

package/lib/plugins/child/load.js

@@ -0,0 +1,22 @@
+import filterObj from 'filter-obj';
+import { getLogic } from './logic.js';
+import { registerTypeScript } from './typescript.js';
+import { validatePlugin } from './validate.js';
+// Load context passed to every plugin method.
+// This also requires the plugin file and fire its top-level function.
+// This also validates the plugin.
+// Do it when parent requests it using the `load` event.
+// Also figure out the list of plugin steps. This is also passed to the parent.
+export const load = async function ({ pluginPath, inputs, packageJson, verbose }) {
+    const tsNodeService = registerTypeScript(pluginPath);
+    const logic = await getLogic({ pluginPath, inputs, tsNodeService });
+    validatePlugin(logic);
+    const methods = filterObj(logic, isEventHandler);
+    const events = Object.keys(methods);
+    // Context passed to every event handler
+    const context = { methods, inputs, packageJson, verbose };
+    return { events, context };
+};
+const isEventHandler = function (event, value) {
+    return typeof value === 'function';
+};

package/lib/plugins/child/logic.js

@@ -0,0 +1,57 @@
+import { createRequire } from 'module';
+import { pathToFileURL } from 'url';
+import { ROOT_PACKAGE_JSON } from '../../utils/json.js';
+import { DEV_EVENTS, EVENTS } from '../events.js';
+import { addTsErrorInfo } from './typescript.js';
+const require = createRequire(import.meta.url);
+// Require the plugin file and fire its top-level function.
+// The returned object is the `logic` which includes all event handlers.
+export const getLogic = async function ({ pluginPath, inputs, tsNodeService }) {
+    const logic = await importLogic(pluginPath, tsNodeService);
+    const logicA = loadLogic({ logic, inputs });
+    return logicA;
+};
+const importLogic = async function (pluginPath, tsNodeService) {
+    try {
+        // `ts-node` is not available programmatically for pure ES modules yet,
+        // which is currently making it impossible for local plugins to use both
+        // pure ES modules and TypeScript.
+        if (tsNodeService !== undefined) {
+            return require(pluginPath);
+        }
+        // `pluginPath` is an absolute file path but `import()` needs URLs.
+        // Converting those with `pathToFileURL()` is needed especially on Windows
+        // where the drive letter would not work with `import()`.
+        const returnValue = await import(pathToFileURL(pluginPath));
+        // Plugins should use named exports, but we still support default exports
+        // for backward compatibility with CommonJS
+        return returnValue.default === undefined ? returnValue : returnValue.default;
+    }
+    catch (error) {
+        addTsErrorInfo(error, tsNodeService);
+        // We must change `error.stack` instead of `error.message` because some
+        // errors thrown from `import()` access `error.stack` before throwing.
+        // `error.stack` is lazily instantiated by Node.js, so changing
+        // `error.message` afterwards would not modify `error.stack`. Therefore, the
+        // resulting stack trace, which is printed in the build logs, would not
+        // include the additional message prefix.
+        error.stack = `Could not import plugin:\n${error.stack}`;
+        throw error;
+    }
+};
+const loadLogic = function ({ logic, inputs }) {
+    if (typeof logic !== 'function') {
+        return logic;
+    }
+    const metadata = {
+        events: new Set([...DEV_EVENTS, ...EVENTS]),
+        version: ROOT_PACKAGE_JSON.version,
+    };
+    try {
+        return logic(inputs, metadata);
+    }
+    catch (error) {
+        error.message = `Could not load plugin:\n${error.message}`;
+        throw error;
+    }
+};

package/lib/plugins/child/main.js

@@ -0,0 +1,37 @@
+import { setInspectColors } from '../../log/colors.js';
+import { sendEventToParent, getEventsFromParent } from '../ipc.js';
+import { handleProcessErrors, handleError } from './error.js';
+import { load } from './load.js';
+import { run } from './run.js';
+// Boot plugin child process.
+const bootPlugin = async function () {
+    const state = { context: { verbose: false } };
+    try {
+        handleProcessErrors();
+        setInspectColors();
+        // We need to fire them in parallel because `process.send()` can be slow
+        // to await, i.e. parent might send `load` event before child `ready` event
+        // returns.
+        await Promise.all([handleEvents(state), sendEventToParent('ready', {}, false)]);
+    }
+    catch (error) {
+        await handleError(error, state.context.verbose);
+    }
+};
+// Wait for events from parent to perform plugin methods
+const handleEvents = async function (state) {
+    await getEventsFromParent((callId, eventName, payload) => handleEvent({ callId, eventName, payload, state }));
+};
+// Each event can pass `context` information to the next event
+const handleEvent = async function ({ callId, eventName, payload, state, state: { context: { verbose }, }, }) {
+    try {
+        const { context, ...response } = await EVENTS[eventName](payload, state.context);
+        state.context = { ...state.context, ...context };
+        await sendEventToParent(callId, response, verbose);
+    }
+    catch (error) {
+        await handleError(error, verbose);
+    }
+};
+const EVENTS = { load, run };
+bootPlugin();

package/lib/plugins/child/run.js

@@ -0,0 +1,19 @@
+import { getNewEnvChanges, setEnvChanges } from '../../env/changes.js';
+import { logPluginMethodStart, logPluginMethodEnd } from '../../log/messages/ipc.js';
+import { cloneNetlifyConfig, getConfigMutations } from './diff.js';
+import { getUtils } from './utils.js';
+// Run a specific plugin event handler
+export const run = async function ({ event, error, constants, envChanges, netlifyConfig }, { methods, inputs, packageJson, verbose }) {
+    const method = methods[event];
+    const runState = {};
+    const utils = getUtils({ event, constants, runState });
+    const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig);
+    const runOptions = { utils, constants, inputs, netlifyConfig: netlifyConfigCopy, packageJson, error };
+    const envBefore = setEnvChanges(envChanges);
+    logPluginMethodStart(verbose);
+    await method(runOptions);
+    logPluginMethodEnd(verbose);
+    const newEnvChanges = getNewEnvChanges(envBefore, netlifyConfig, netlifyConfigCopy);
+    const configMutations = getConfigMutations(netlifyConfig, netlifyConfigCopy, event);
+    return { ...runState, newEnvChanges, configMutations };
+};