@netlify/build 29.28.1 → 29.29.0

package/lib/core/types.d.ts

@@ -6,6 +6,8 @@ export type BuildCLIFlags = {
     siteId: string;
     /** Netlify API token for authentication */
     token: string;
+    /** Netlify Deploy ID */
+    deployId: string;
     /**
      * Run in dry mode, i.e. printing steps without executing them
      * @default false

package/lib/error/parse/location.js

@@ -41,10 +41,14 @@ const getEventMessage = function (event) {
 const getApiLocation = function ({ endpoint, parameters }) {
     return `While calling the Netlify API endpoint '${endpoint}' with:\n${JSON.stringify(parameters, null, 2)}`;
 };
+const getDeployLocation = function ({ statusCode }) {
+    return `At deploy the stage with HTTP status code '${statusCode}'`;
+};
 const LOCATIONS = {
     buildCommand: getBuildCommandLocation,
     functionsBundling: getFunctionsBundlingLocation,
     coreStep: getCoreStepLocation,
     buildFail: getBuildFailLocation,
     api: getApiLocation,
+    deploy: getDeployLocation,
 };

package/lib/error/parse/serialize_status.d.ts

@@ -1,16 +1,13 @@
-export function serializeErrorStatus({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }: {
-    fullErrorInfo: {
-        title: any;
-        message: any;
-        locationInfo: any;
-        errorProps: any;
-        errorMetadata: any;
-    };
-    state: any;
-}): {
-    state: any;
-    title: any;
-    summary: any;
+import type { BuildError } from '../types.js';
+type ErrorState = 'failed_build' | 'failed_plugin' | 'canceled_build';
+export declare const serializeErrorStatus: ({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }: {
+    fullErrorInfo: BuildError;
+    state: ErrorState;
+}) => {
+    state: ErrorState;
+    title: string | (import("../types.js").TitleFunction & string);
+    summary: string;
     text: string | undefined;
     extraData: any;
 };
+export {};

package/lib/error/parse/serialize_status.js

@@ -1,4 +1,4 @@
-// Serialize an error object to `statuses` properties
+/* 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 };

package/lib/error/types.d.ts

@@ -52,9 +52,6 @@ declare enum StackType {
      * not printed
      */
     none = "none",
-    /**
-     * printed as is
-     */
     stack = "stack",
     /**
      * 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.
@@ -99,7 +96,11 @@ export type APILocation = {
     parameters?: any;
 };
 export declare const isAPILocation: (location?: ErrorLocation) => location is APILocation;
-export type ErrorLocation = BuildCommandLocation | FunctionsBundlingLocation | CoreStepLocation | PluginLocation | APILocation;
+export type DeployLocation = {
+    statusCode: string;
+};
+export declare const isDeployLocation: (location?: ErrorLocation) => location is DeployLocation;
+export type ErrorLocation = BuildCommandLocation | FunctionsBundlingLocation | CoreStepLocation | PluginLocation | APILocation | DeployLocation;
 /**
  * Given a BuildError, extract the relevant trace attributes to add to the on-going Span
  */
@@ -165,10 +166,13 @@ declare const ErrorTypeMap: {
     readonly pluginInternal: "pluginInternal";
     readonly ipc: "ipc";
     readonly corePlugin: "corePlugin";
+    readonly trustedPlugin: "trustedPlugin";
     readonly coreStep: "coreStep";
     readonly api: "api";
+    readonly deploy: "deploy";
+    readonly deployInternal: "deployInternal";
     readonly exception: "exception";
     readonly telemetry: "telemetry";
 };
-type ErrorTypes = keyof typeof ErrorTypeMap;
+export type ErrorTypes = keyof typeof ErrorTypeMap;
 export {};

package/lib/error/types.js

@@ -33,7 +33,7 @@ var StackType;
      * not printed
      */
     StackType["none"] = "none";
-    /**
+    /*
      * printed as is
      */
     StackType["stack"] = "stack";
@@ -62,6 +62,9 @@ export const isPluginLocation = function (location) {
 export const isAPILocation = function (location) {
     return typeof location?.endpoint === 'string';
 };
+export const isDeployLocation = function (location) {
+    return typeof location?.statusCode === 'string';
+};
 const buildErrorAttributePrefix = 'build.error';
 const errorLocationToTracingAttributes = function (location) {
     const locationAttributePrefix = `${buildErrorAttributePrefix}.location`;
@@ -95,6 +98,11 @@ const errorLocationToTracingAttributes = function (location) {
             [`${locationAttributePrefix}.api.endpoint`]: location.endpoint,
         };
     }
+    if (isDeployLocation(location)) {
+        return {
+            [`${locationAttributePrefix}.deploy.status_code`]: location.statusCode,
+        };
+    }
     return {};
 };
 /**
@@ -141,8 +149,11 @@ const ErrorTypeMap = {
     pluginInternal: 'pluginInternal',
     ipc: 'ipc',
     corePlugin: 'corePlugin',
+    trustedPlugin: 'trustedPlugin',
     coreStep: 'coreStep',
     api: 'api',
+    deploy: 'deploy',
+    deployInternal: 'deployInternal',
     exception: 'exception',
     telemetry: 'telemetry',
 };
@@ -293,6 +304,17 @@ const TYPES = {
         locationType: 'buildFail',
         severity: 'error',
     },
+    /**
+     * Trusted plugin internal error (all of our `@netlify/*` plugins).
+     */
+    trustedPlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'error',
+    },
     /**
      * Core step internal error
      */
@@ -314,6 +336,24 @@ const TYPES = {
         locationType: 'api',
         severity: 'error',
     },
+    /**
+     * Non-internal errors deploying files or functions
+     */
+    deploy: {
+        title: 'Error deploying',
+        stackType: 'none',
+        locationType: 'deploy',
+        severity: 'info',
+    },
+    /**
+     * Internal errors deploying files or functions
+     */
+    deployInternal: {
+        title: 'Internal error deploying',
+        stackType: 'none',
+        locationType: 'deploy',
+        severity: 'error',
+    },
     /**
      * `@netlify/build` threw an uncaught exception
      */

package/lib/plugins/events.d.ts

@@ -1,5 +1,5 @@
-export const isSoftFailEvent: any;
-export const runsAlsoOnBuildFailure: any;
-export const runsOnlyOnBuildFailure: any;
-export const runsAfterDeploy: any;
-export { DEV_EVENTS, EVENTS } from "@netlify/config";
+export { DEV_EVENTS, EVENTS } from '@netlify/config';
+export declare const isSoftFailEvent: any;
+export declare const runsAlsoOnBuildFailure: any;
+export declare const runsOnlyOnBuildFailure: any;
+export declare const runsAfterDeploy: any;

package/lib/plugins/spawn.js

@@ -36,7 +36,9 @@ const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv, s
         execPath: nodePath,
         env: childEnv,
         extendEnv: false,
-        stdio: isTrustedPlugin(pluginPackageJson) && systemLogFile ? ['pipe', 'pipe', 'pipe', 'ipc', systemLogFile] : undefined,
+        stdio: isTrustedPlugin(pluginPackageJson?.name) && systemLogFile
+            ? ['pipe', 'pipe', 'pipe', 'ipc', systemLogFile]
+            : undefined,
     });
     try {
         await getEventFromChild(childProcess, 'ready');

package/lib/plugins_core/blobs_upload/index.d.ts

@@ -0,0 +1,26 @@
+export declare const uploadBlobs: {
+    event: string;
+    coreStep: ({ debug, logs, deployId, buildDir, quiet, constants: { PUBLISH_DIR, SITE_ID, NETLIFY_API_TOKEN, API_URL }, }: {
+        debug: any;
+        logs: any;
+        deployId: any;
+        buildDir: any;
+        quiet: any;
+        constants: {
+            PUBLISH_DIR: any;
+            SITE_ID: any;
+            NETLIFY_API_TOKEN: any;
+            API_URL: any;
+        };
+    }) => Promise<{}>;
+    coreStepId: string;
+    coreStepName: string;
+    coreStepDescription: () => string;
+    condition: ({ deployId, buildDir, constants: { PUBLISH_DIR } }: {
+        deployId: any;
+        buildDir: any;
+        constants: {
+            PUBLISH_DIR: any;
+        };
+    }) => Promise<boolean>;
+};

package/lib/plugins_core/blobs_upload/index.js

@@ -0,0 +1,61 @@
+import { version as nodeVersion } from 'node:process';
+import { getDeployStore } from '@netlify/blobs';
+import pMap from 'p-map';
+import semver from 'semver';
+import { log, logError } from '../../log/logger.js';
+import { anyBlobsToUpload, getBlobsDir } from '../../utils/blobs.js';
+import { getKeysToUpload, getFileWithMetadata } from './utils.js';
+const coreStep = async function ({ debug, logs, deployId, buildDir, quiet, constants: { PUBLISH_DIR, SITE_ID, NETLIFY_API_TOKEN, API_URL }, }) {
+    const storeOpts = {
+        siteID: SITE_ID,
+        deployID: deployId,
+        token: NETLIFY_API_TOKEN,
+        apiURL: API_URL,
+    };
+    if (semver.lt(nodeVersion, '18.0.0')) {
+        const nodeFetch = await import('node-fetch');
+        storeOpts.fetch = nodeFetch.default;
+    }
+    const blobStore = getDeployStore(storeOpts);
+    const blobsDir = getBlobsDir({ buildDir, publishDir: PUBLISH_DIR });
+    const keys = await getKeysToUpload(blobsDir);
+    // We checked earlier, but let's be extra safe
+    if (keys.length === 0) {
+        if (!quiet) {
+            log(logs, 'No blobs to upload to deploy store.');
+        }
+        return {};
+    }
+    if (!quiet) {
+        log(logs, `Uploading ${keys.length} blobs to deploy store...`);
+    }
+    const uploadBlob = async (key) => {
+        if (debug && !quiet) {
+            log(logs, `- Uploading blob ${key}`, { indent: true });
+        }
+        const { data, metadata } = await getFileWithMetadata(blobsDir, key);
+        await blobStore.set(key, data, { metadata });
+    };
+    try {
+        await pMap(keys, uploadBlob, { concurrency: 10 });
+    }
+    catch (err) {
+        logError(logs, `Error uploading blobs to deploy store: ${err.message}`);
+        throw new Error(`Failed while uploading blobs to deploy store`);
+    }
+    if (!quiet) {
+        log(logs, `Done uploading blobs to deploy store.`);
+    }
+    return {};
+};
+const deployAndBlobsPresent = async function ({ deployId, buildDir, constants: { PUBLISH_DIR } }) {
+    return deployId && (await anyBlobsToUpload({ buildDir, publishDir: PUBLISH_DIR }));
+};
+export const uploadBlobs = {
+    event: 'onPostBuild',
+    coreStep,
+    coreStepId: 'blobs_upload',
+    coreStepName: 'Uploading blobs',
+    coreStepDescription: () => 'Uploading blobs to deploy store',
+    condition: deployAndBlobsPresent,
+};

package/lib/plugins_core/blobs_upload/utils.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+/** Given output directory, find all file paths to upload excluding metadata files */
+export declare function getKeysToUpload(blobsDir: string): Promise<string[]>;
+/** Read a file and its metadata file from the blobs directory */
+export declare function getFileWithMetadata(blobsDir: string, key: string): Promise<{
+    data: Buffer;
+    metadata: Record<string, string>;
+}>;

package/lib/plugins_core/blobs_upload/utils.js

@@ -0,0 +1,46 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fdir } from 'fdir';
+const METADATA_PREFIX = '$';
+const METADATA_SUFFIX = '.json';
+/** Given output directory, find all file paths to upload excluding metadata files */
+export async function getKeysToUpload(blobsDir) {
+    const files = await new fdir()
+        .withRelativePaths() // we want the relative path from the blobsDir
+        .filter((fpath) => !path.basename(fpath).startsWith(METADATA_PREFIX))
+        .crawl(blobsDir)
+        .withPromise();
+    // normalize the path separators to all use the forward slash
+    return files.map((f) => f.split(path.sep).join('/'));
+}
+/** Read a file and its metadata file from the blobs directory */
+export async function getFileWithMetadata(blobsDir, key) {
+    const contentPath = path.join(blobsDir, key);
+    const dirname = path.dirname(key);
+    const basename = path.basename(key);
+    const metadataPath = path.join(blobsDir, dirname, `${METADATA_PREFIX}${basename}${METADATA_SUFFIX}`);
+    const [data, metadata] = await Promise.all([readFile(contentPath), readMetadata(metadataPath)]).catch((err) => {
+        throw new Error(`Failed while reading '${key}' and its metadata: ${err.message}`);
+    });
+    return { data, metadata };
+}
+async function readMetadata(metadataPath) {
+    let metadataFile;
+    try {
+        metadataFile = await readFile(metadataPath, { encoding: 'utf8' });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            // no metadata file found, that's ok
+            return {};
+        }
+        throw err;
+    }
+    try {
+        return JSON.parse(metadataFile);
+    }
+    catch {
+        // Normalize the error message
+        throw new Error(`Error parsing metadata file '${metadataPath}'`);
+    }
+}

package/lib/plugins_core/deploy/buildbot_client.d.ts

@@ -1,12 +1,24 @@
 /// <reference types="node" resolution-mode="require"/>
-export function createBuildbotClient(buildbotServerSocket: any): net.Socket;
-export const connectBuildbotClient: (...args: any[]) => Promise<any>;
-export function closeBuildbotClient(client: any): Promise<void>;
-export function deploySiteWithBuildbotClient({ client, events, buildDir, repositoryRoot, constants }: {
+import net from 'net';
+/**
+ * Creates the Buildbot IPC client we use to initiate the deploy
+ */
+export declare const createBuildbotClient: (buildbotServerSocket: string) => net.Socket;
+/**
+ * Emits the connect event
+ */
+export declare const connectBuildbotClient: (...args: unknown[]) => Promise<void>;
+/**
+ * Closes the buildbot client and its connection
+ */
+export declare const closeBuildbotClient: (client: net.Socket) => Promise<void>;
+/**
+ * Initates the deploy with the given buildbot client
+ */
+export declare const deploySiteWithBuildbotClient: ({ client, events, buildDir, repositoryRoot, constants }: {
     client: any;
     events: any;
     buildDir: any;
     repositoryRoot: any;
     constants: any;
-}): Promise<undefined>;
-import net from 'net';
+}) => Promise<undefined>;

package/lib/plugins_core/deploy/buildbot_client.js

@@ -5,80 +5,111 @@ import { pEvent } from 'p-event';
 import { addErrorInfo } from '../../error/info.js';
 import { runsAfterDeploy } from '../../plugins/events.js';
 import { addAsyncErrorMessage } from '../../utils/errors.js';
+/**
+ * Actions supported by the deploy server.
+ */
+var Action;
+(function (Action) {
+    /**
+     * Initiate the deploy.
+     */
+    Action["DeploySite"] = "deploySite";
+    /**
+     * Initiate the deploy, wait and hand back control to `@netlify/build` once the site is live.
+     */
+    Action["DeploySiteAndWait"] = "deploySiteAndAwaitLive";
+})(Action || (Action = {}));
+/**
+ * Creates the Buildbot IPC client we use to initiate the deploy
+ */
 export const createBuildbotClient = function (buildbotServerSocket) {
     const connectionOpts = getConnectionOpts(buildbotServerSocket);
     const client = net.createConnection(connectionOpts);
     return client;
 };
-// Windows does not support Unix sockets well, so we also support `host:port`
+/**
+ * Windows does not support Unix sockets well, so we also support `host:port`
+ */
 const getConnectionOpts = function (buildbotServerSocket) {
     if (!buildbotServerSocket.includes(':')) {
         return { path: buildbotServerSocket };
     }
     const [host, port] = buildbotServerSocket.split(':');
-    return { host, port };
+    return { host, port: Number(port) };
 };
-const eConnectBuildbotClient = async function (client) {
+/**
+ * Emits the connect event
+ */
+export const connectBuildbotClient = addAsyncErrorMessage(async (client) => {
     await pEvent(client, 'connect');
-};
-export const connectBuildbotClient = addAsyncErrorMessage(eConnectBuildbotClient, 'Could not connect to buildbot');
+}, 'Could not connect to buildbot');
+/**
+ * Closes the buildbot client and its connection
+ */
 export const closeBuildbotClient = async function (client) {
     if (client.destroyed) {
         return;
     }
     await promisify(client.end.bind(client))();
 };
-const cWritePayload = async function (buildbotClient, payload) {
+const writePayload = addAsyncErrorMessage(async (buildbotClient, payload) => {
     await promisify(buildbotClient.write.bind(buildbotClient))(JSON.stringify(payload));
-};
-const writePayload = addAsyncErrorMessage(cWritePayload, 'Could not send payload to buildbot');
-const cGetNextParsedResponsePromise = async function (buildbotClient) {
+}, 'Could not send payload to buildbot');
+const getNextParsedResponsePromise = addAsyncErrorMessage(async (buildbotClient) => {
     const data = await pEvent(buildbotClient, 'data');
     return JSON.parse(data);
-};
-const getNextParsedResponsePromise = addAsyncErrorMessage(cGetNextParsedResponsePromise, 'Invalid response from buildbot');
+}, 'Invalid response from buildbot');
+/**
+ * Initates the deploy with the given buildbot client
+ */
 export const deploySiteWithBuildbotClient = async function ({ client, events, buildDir, repositoryRoot, constants }) {
-    const action = shouldWaitForPostProcessing(events) ? 'deploySiteAndAwaitLive' : 'deploySite';
+    const action = shouldWaitForPostProcessing(events) ? Action.DeploySiteAndWait : Action.DeploySite;
     const deployDir = getDeployDir({ buildDir, repositoryRoot, constants });
     const payload = { action, deployDir };
-    const [{ succeeded, values: { error, error_type: errorType } = {} }] = await Promise.all([
-        getNextParsedResponsePromise(client),
-        writePayload(client, payload),
-    ]);
-    if (!succeeded) {
-        return handleDeployError(error, errorType);
+    const [response] = await Promise.all([getNextParsedResponsePromise(client), writePayload(client, payload)]);
+    if (!response.succeeded) {
+        const { error, code, error_type } = response?.values || {};
+        return handleDeployError(error, code, error_type);
     }
 };
-// The file paths in the buildbot are relative to the repository root.
-// However, the file paths in Build plugins, including `constants.PUBLISH_DIR`
-// are relative to the build directory, which is different when there is a
-// base directory. This converts it.
-// We need to call `normalize()` in case the publish directory is the
-// repository root, so `deployDir` is "." not ""
+/**
+ * The file paths in the buildbot are relative to the repository root.
+ * However, the file paths in Build plugins, including `constants.PUBLISH_DIR`
+ * are relative to the build directory, which is different when there is a
+ * base directory. This converts it.
+ * We need to call `normalize()` in case the publish directory is the
+ * repository root, so `deployDir` is "." not ""
+ */
 const getDeployDir = function ({ buildDir, repositoryRoot, constants: { PUBLISH_DIR } }) {
     const absolutePublishDir = resolve(buildDir, PUBLISH_DIR);
     const relativePublishDir = relative(repositoryRoot, absolutePublishDir);
     const deployDir = normalize(relativePublishDir);
     return deployDir;
 };
-// We distinguish between user errors and system errors during deploys
-const handleDeployError = function (error, errorType) {
-    const errorIs422 = error !== undefined && error.code === '422';
-    const errMsg = errorIs422
-        ? `
-    File upload failed because of mismatched SHAs.
-    This can happen when files are changed after the deployment process has started but before they are uploaded.
-
-    Error: ${error}
-    `
-        : `Deploy did not succeed: ${error}`;
-    const errorA = new Error(errMsg);
+/**
+ * We distinguish between user errors and system errors during deploys
+ */
+const handleDeployError = function (error, errorCode, errorType) {
+    if (errorCode !== undefined) {
+        const err = new Error(`Deploy did not succeed with HTTP Error ${errorCode}: ${error}`);
+        if (errorCode.startsWith('5')) {
+            const errorInfo = { type: 'deployInternal', location: { statusCode: errorCode } };
+            addErrorInfo(err, errorInfo);
+            throw err;
+        }
+        const errorInfo = { type: 'deploy', location: { statusCode: errorCode } };
+        addErrorInfo(err, errorInfo);
+        throw err;
+    }
+    const err = new Error(`Deploy did not succeed: ${error}`);
     const errorInfo = errorType === 'user' ? { type: 'resolveConfig' } : { type: 'coreStep', location: { coreStepName: 'Deploy site' } };
-    addErrorInfo(errorA, errorInfo);
-    throw errorA;
+    addErrorInfo(err, errorInfo);
+    throw err;
 };
-// We only wait for post-processing (last stage before site deploy) if the build
-// has some plugins that do post-deploy logic
+/**
+ * We only wait for post-processing (last stage before site deploy) if the build
+ * has some plugins that do post-deploy logic
+ */
 const shouldWaitForPostProcessing = function (events) {
     return events.some(hasPostDeployLogic);
 };

package/lib/plugins_core/pre_cleanup/index.d.ts

@@ -0,0 +1,18 @@
+export declare const preCleanup: {
+    event: string;
+    coreStep: ({ buildDir, constants: { PUBLISH_DIR } }: {
+        buildDir: any;
+        constants: {
+            PUBLISH_DIR: any;
+        };
+    }) => Promise<{}>;
+    coreStepId: string;
+    coreStepName: string;
+    coreStepDescription: () => string;
+    condition: ({ buildDir, constants: { PUBLISH_DIR } }: {
+        buildDir: any;
+        constants: {
+            PUBLISH_DIR: any;
+        };
+    }) => Promise<boolean>;
+};

package/lib/plugins_core/pre_cleanup/index.js

@@ -0,0 +1,23 @@
+import { rm } from 'node:fs/promises';
+import { anyBlobsToUpload, getBlobsDir } from '../../utils/blobs.js';
+const coreStep = async function ({ buildDir, constants: { PUBLISH_DIR } }) {
+    const blobsDir = getBlobsDir({ buildDir, publishDir: PUBLISH_DIR });
+    try {
+        await rm(blobsDir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore errors if it fails, we can continue anyway.
+    }
+    return {};
+};
+const blobsPresent = async function ({ buildDir, constants: { PUBLISH_DIR } }) {
+    return await anyBlobsToUpload({ buildDir, publishDir: PUBLISH_DIR });
+};
+export const preCleanup = {
+    event: 'onPreBuild',
+    coreStep,
+    coreStepId: 'pre_cleanup',
+    coreStepName: 'Pre cleanup',
+    coreStepDescription: () => 'Cleaning up leftover files from previous builds',
+    condition: blobsPresent,
+};

package/lib/steps/core_step.d.ts

@@ -1,4 +1,4 @@
-export declare const fireCoreStep: ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, edgeFunctionsBootstrapURL, }: {
+export declare const fireCoreStep: ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, quiet, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, edgeFunctionsBootstrapURL, deployId, }: {
     coreStep: any;
     coreStepId: any;
     coreStepName: any;
@@ -11,6 +11,7 @@ export declare const fireCoreStep: ({ coreStep, coreStepId, coreStepName, config
     buildbotServerSocket: any;
     events: any;
     logs: any;
+    quiet: any;
     nodePath: any;
     childEnv: any;
     context: any;
@@ -29,6 +30,7 @@ export declare const fireCoreStep: ({ coreStep, coreStepId, coreStepName, config
     userNodeVersion: any;
     explicitSecretKeys: any;
     edgeFunctionsBootstrapURL: any;
+    deployId: any;
 }) => Promise<{
     newEnvChanges: any;
     netlifyConfig: any;

package/lib/steps/core_step.js

@@ -2,7 +2,7 @@ import { setEnvChanges } from '../env/changes.js';
 import { addErrorInfo, isBuildError } from '../error/info.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
 // Fire a core step
-export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, edgeFunctionsBootstrapURL, }) {
+export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, constants, buildbotServerSocket, events, logs, quiet, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, edgeFunctionsBootstrapURL, deployId, }) {
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const childEnvA = setEnvChanges(envChanges, { ...childEnv });
@@ -16,6 +16,7 @@ export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName
             buildbotServerSocket,
             events,
             logs,
+            quiet,
             context,
             branch,
             childEnv: childEnvA,
@@ -31,6 +32,7 @@ export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName
             userNodeVersion,
             explicitSecretKeys,
             edgeFunctionsBootstrapURL,
+            deployId,
         });
         const { netlifyConfig: netlifyConfigA, configMutations: configMutationsA, headersPath: headersPathA, redirectsPath: redirectsPathA, } = await updateNetlifyConfig({
             configOpts,

package/lib/steps/error.d.ts

@@ -1,4 +1,14 @@
-export function handleStepError({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }: {
+import { ErrorTypes } from '../error/types.js';
+/**
+ * Handle build command errors and plugin errors:
+ *  - usually, propagate the error to make the build stop.
+ *  - `utils.build.cancelBuild()` also cancels the build by calling the API
+ *  - `utils.build.failPlugin()` or post-deploy errors do not make the build
+ *    stop, but are still reported, and prevent future events from the same
+ *    plugin.
+ * This also computes error statuses that are sent to the API.
+ */
+export declare const handleStepError: ({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }: {
     event: any;
     newError: any;
     childEnv: any;
@@ -11,38 +21,36 @@ export function handleStepError({ event, newError, childEnv, mode, api, errorMon
     logs: any;
     debug: any;
     testOpts: any;
-}): Promise<{
-    failedPlugin: any[];
+}) => Promise<{
+    failedPlugin: string[];
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 }> | Promise<{
     newError: any;
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 }> | {
     newError: any;
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 } | {
     newError: any;
 };
-export function getPluginErrorType(error: any, loadedFrom: any): {
-    type?: undefined;
-} | {
-    type: string;
+export declare const getPluginErrorType: (error: Error, loadedFrom: string, packageName?: string) => {
+    type?: ErrorTypes;
 };

package/lib/steps/error.js

@@ -2,15 +2,19 @@ import { cancelBuild } from '../error/cancel.js';
 import { handleBuildError } from '../error/handle.js';
 import { getFullErrorInfo, parseErrorInfo } from '../error/parse/parse.js';
 import { serializeErrorStatus } from '../error/parse/serialize_status.js';
+import { isPluginLocation } from '../error/types.js';
 import { isSoftFailEvent } from '../plugins/events.js';
 import { addErrorToActiveSpan, addEventToActiveSpan } from '../tracing/main.js';
-// Handle build command errors and plugin errors:
-//  - usually, propagate the error to make the build stop.
-//  - `utils.build.cancelBuild()` also cancels the build by calling the API
-//  - `utils.build.failPlugin()` or post-deploy errors do not make the build
-//    stop, but are still reported, and prevent future events from the same
-//    plugin.
-// This also computes error statuses that are sent to the API.
+import { isTrustedPlugin } from './plugin.js';
+/**
+ * Handle build command errors and plugin errors:
+ *  - usually, propagate the error to make the build stop.
+ *  - `utils.build.cancelBuild()` also cancels the build by calling the API
+ *  - `utils.build.failPlugin()` or post-deploy errors do not make the build
+ *    stop, but are still reported, and prevent future events from the same
+ *    plugin.
+ * This also computes error statuses that are sent to the API.
+ */
 export const handleStepError = function ({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }) {
     addErrorToActiveSpan(newError);
     // Core steps do not report error statuses
@@ -18,7 +22,7 @@ export const handleStepError = function ({ event, newError, childEnv, mode, api,
         return { newError };
     }
     const fullErrorInfo = getFullErrorInfo({ error: newError, colors: false, debug });
-    const { errorInfo: { location: { packageName } = {} }, message, title, type, } = fullErrorInfo;
+    const { errorInfo, message, title, type } = fullErrorInfo;
     if (type === 'failPlugin' || isSoftFailEvent(event)) {
         return handleFailPlugin({
             fullErrorInfo,
@@ -36,32 +40,40 @@ export const handleStepError = function ({ event, newError, childEnv, mode, api,
         const cancellationAttributes = {
             'build.cancellation.title': title,
             'build.cancellation.message': message,
-            'build.cancellation.packageName': packageName,
         };
+        if (isPluginLocation(errorInfo.location)) {
+            cancellationAttributes['build.cancellation.packageName'] = errorInfo.location.packageName;
+        }
         addEventToActiveSpan('build.cancelled', cancellationAttributes);
         return handleCancelBuild({ fullErrorInfo, newError, api, deployId });
     }
     return handleFailBuild({ fullErrorInfo, newError });
 };
-// On `utils.build.failPlugin()` or during `onSuccess` or `onEnd`
-const handleFailPlugin = async function ({ fullErrorInfo, fullErrorInfo: { errorInfo: { location: { packageName } = {} }, }, newError, childEnv, mode, errorMonitor, netlifyConfig, logs, debug, testOpts, }) {
+/* On `utils.build.failPlugin()` or during `onSuccess` or `onEnd` */
+const handleFailPlugin = async function ({ fullErrorInfo, newError, childEnv, mode, errorMonitor, netlifyConfig, logs, debug, testOpts, }) {
     const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_plugin' });
     await handleBuildError(newError, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts });
-    return { failedPlugin: [packageName], newStatus };
+    // TODO we should probably use type guard here, but due to the way we build these errorInfo objects I'm not 100%
+    // confident we have all the properties currently required by the type
+    const location = fullErrorInfo.errorInfo.location;
+    return { failedPlugin: [location.packageName], newStatus };
 };
-// On `utils.build.cancelBuild()`
+/* On `utils.build.cancelBuild()` */
 const handleCancelBuild = async function ({ fullErrorInfo, newError, api, deployId }) {
     const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'canceled_build' });
     await cancelBuild({ api, deployId });
     return { newError, newStatus };
 };
-// On `utils.build.failBuild()` or uncaught exception
+/* On `utils.build.failBuild()` or uncaught exception */
 const handleFailBuild = function ({ fullErrorInfo, newError }) {
     const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' });
     return { newError, newStatus };
 };
-// Unlike community plugins, core plugin bugs should be handled as system errors
-export const getPluginErrorType = function (error, loadedFrom) {
+/* Unlike community plugins, core plugin and trusted plugin bugs should be handled as system errors */
+export const getPluginErrorType = function (error, loadedFrom, packageName) {
+    if (isTrustedPluginBug(error, packageName)) {
+        return { type: 'trustedPlugin' };
+    }
     if (!isCorePluginBug(error, loadedFrom)) {
         return {};
     }
@@ -71,3 +83,7 @@ const isCorePluginBug = function (error, loadedFrom) {
     const { severity } = parseErrorInfo(error);
     return severity === 'warning' && loadedFrom === 'core';
 };
+const isTrustedPluginBug = function (error, packageName) {
+    const { severity } = parseErrorInfo(error);
+    return severity === 'warning' && isTrustedPlugin(packageName);
+};

package/lib/steps/get.js

@@ -1,9 +1,11 @@
 import { getUtils } from '../plugins/child/utils.js';
 import { DEV_EVENTS, EVENTS } from '../plugins/events.js';
+import { uploadBlobs } from '../plugins_core/blobs_upload/index.js';
 import { buildCommandCore } from '../plugins_core/build_command.js';
 import { deploySite } from '../plugins_core/deploy/index.js';
 import { bundleEdgeFunctions } from '../plugins_core/edge_functions/index.js';
 import { bundleFunctions } from '../plugins_core/functions/index.js';
+import { preCleanup } from '../plugins_core/pre_cleanup/index.js';
 import { saveArtifacts } from '../plugins_core/save_artifacts/index.js';
 import { scanForSecrets } from '../plugins_core/secrets_scanning/index.js';
 // Get all build steps
@@ -54,7 +56,17 @@ const getEventSteps = function (eventHandlers) {
     });
 };
 const addCoreSteps = function (steps) {
-    return [buildCommandCore, ...steps, bundleFunctions, bundleEdgeFunctions, scanForSecrets, deploySite, saveArtifacts];
+    return [
+        preCleanup,
+        buildCommandCore,
+        ...steps,
+        bundleFunctions,
+        bundleEdgeFunctions,
+        scanForSecrets,
+        uploadBlobs,
+        deploySite,
+        saveArtifacts,
+    ];
 };
 // Sort plugin steps by event order.
 const sortSteps = function (steps, events) {

package/lib/steps/plugin.d.ts

@@ -1,4 +1,4 @@
-export function isTrustedPlugin(pluginPackageJson: any): any;
+export function isTrustedPlugin(packageName: any): any;
 export function firePluginStep({ event, childProcess, packageName, packagePath, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, featureFlags, debug, verbose, }: {
     event: any;
     childProcess: any;

package/lib/steps/plugin.js

@@ -5,7 +5,7 @@ import { callChild } from '../plugins/ipc.js';
 import { getSuccessStatus } from '../status/success.js';
 import { getPluginErrorType } from './error.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
-export const isTrustedPlugin = (pluginPackageJson) => pluginPackageJson?.name?.startsWith('@netlify/');
+export const isTrustedPlugin = (packageName) => packageName?.startsWith('@netlify/');
 // Fire a plugin step
 export const firePluginStep = async function ({ event, childProcess, packageName, packagePath, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, featureFlags, debug, verbose, }) {
     const listeners = pipePluginOutput(childProcess, logs);
@@ -18,7 +18,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
                 event,
                 error,
                 envChanges,
-                featureFlags: isTrustedPlugin(pluginPackageJson) ? featureFlags : undefined,
+                featureFlags: isTrustedPlugin(pluginPackageJson?.name) ? featureFlags : undefined,
                 netlifyConfig,
                 constants,
             },
@@ -49,7 +49,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
         };
     }
     catch (newError) {
-        const errorType = getPluginErrorType(newError, loadedFrom);
+        const errorType = getPluginErrorType(newError, loadedFrom, packageName);
         addErrorInfo(newError, {
             ...errorType,
             plugin: { pluginPackageJson, packageName },

package/lib/steps/return.d.ts

@@ -24,20 +24,20 @@ export function getStepReturn({ event, packageName, newError, newEnvChanges, new
     quiet: any;
     metrics: any;
 }): Promise<{
-    failedPlugin: any[];
+    failedPlugin: string[];
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 }> | Promise<{
     newError: any;
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };

package/lib/steps/run_core_steps.js

@@ -39,7 +39,7 @@ const getBuildSteps = function (buildSteps) {
     const allSteps = getSteps([]).steps.filter(({ coreStepId }) => buildSteps.includes(coreStepId));
     return allSteps;
 };
-const executeBuildStep = async function ({ config, packagePath, defaultConfig, cachedConfig, debug, nodePath, functionsDistDir, edgeFunctionsDistDir, errorMonitor, mode, logs, errorParams, featureFlags, buildSteps, repositoryRoot, systemLog, edgeFunctionsBootstrapURL, }) {
+const executeBuildStep = async function ({ config, packagePath, defaultConfig, cachedConfig, debug, nodePath, functionsDistDir, edgeFunctionsDistDir, errorMonitor, mode, logs, errorParams, featureFlags, buildSteps, repositoryRoot, systemLog, edgeFunctionsBootstrapURL, deployId, token, quiet, }) {
     const configOpts = getConfigOpts({
         config,
         defaultConfig,
@@ -53,6 +53,7 @@ const executeBuildStep = async function ({ config, packagePath, defaultConfig, c
         cachedConfig,
         debug,
         logs,
+        quiet,
         nodePath,
         timers: [],
     });
@@ -64,6 +65,7 @@ const executeBuildStep = async function ({ config, packagePath, defaultConfig, c
         netlifyConfig,
         siteInfo,
         mode,
+        token,
     });
     Object.assign(errorParams, { netlifyConfig, siteInfo, childEnv, userNodeVersion });
     try {
@@ -80,6 +82,8 @@ const executeBuildStep = async function ({ config, packagePath, defaultConfig, c
             repositoryRoot: repositoryRootA,
             systemLog,
             edgeFunctionsBootstrapURL,
+            deployId,
+            quiet,
         });
         return {
             netlifyConfig: netlifyConfigA,
@@ -101,7 +105,7 @@ const executeBuildStep = async function ({ config, packagePath, defaultConfig, c
         throw error;
     }
 };
-const runBuildStep = async function ({ netlifyConfig, buildDir, nodePath, constants, logs, debug, featureFlags, childEnv, buildSteps, repositoryRoot, systemLog, edgeFunctionsBootstrapURL, }) {
+const runBuildStep = async function ({ netlifyConfig, buildDir, nodePath, constants, logs, debug, featureFlags, childEnv, buildSteps, repositoryRoot, systemLog, edgeFunctionsBootstrapURL, deployId, quiet, }) {
     const { netlifyConfig: netlifyConfigA, configMutations } = await runSteps({
         steps: getBuildSteps(buildSteps),
         buildDir,
@@ -116,6 +120,8 @@ const runBuildStep = async function ({ netlifyConfig, buildDir, nodePath, consta
         repositoryRoot,
         systemLog,
         edgeFunctionsBootstrapURL,
+        deployId,
+        quiet,
     });
     return { netlifyConfig: netlifyConfigA, configMutations };
 };

package/lib/steps/run_step.js

@@ -40,6 +40,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             buildDir,
             saveConfig,
             explicitSecretKeys,
+            deployId,
         });
         span.setAttribute('build.execution.step.should_run', shouldRun);
         if (!shouldRun) {
@@ -77,6 +78,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             error,
             logs,
             debug,
+            quiet,
             systemLog,
             verbose,
             saveConfig,
@@ -91,6 +93,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
             userNodeVersion,
             explicitSecretKeys,
             edgeFunctionsBootstrapURL,
+            deployId,
         });
         const newValues = await getStepReturn({
             event,
@@ -153,7 +156,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
 // or available. However, one might be created by a build plugin, in which case,
 // those core plugins should be triggered. We use a dynamic `condition()` to
 // model this behavior.
-const shouldRunStep = async function ({ event, packageName, error, packagePath, failedPlugins, netlifyConfig, condition, constants, buildbotServerSocket, buildDir, saveConfig, explicitSecretKeys, }) {
+const shouldRunStep = async function ({ event, packageName, error, packagePath, failedPlugins, netlifyConfig, condition, constants, buildbotServerSocket, buildDir, saveConfig, explicitSecretKeys, deployId, }) {
     if (failedPlugins.includes(packageName) ||
         (condition !== undefined &&
             !(await condition({
@@ -164,6 +167,7 @@ const shouldRunStep = async function ({ event, packageName, error, packagePath,
                 netlifyConfig,
                 saveConfig,
                 explicitSecretKeys,
+                deployId,
             })))) {
         return false;
     }
@@ -180,7 +184,7 @@ const getFireStep = function (packageName, coreStepId, event) {
     const parentTag = normalizeTagName(packageName);
     return measureDuration(tFireStep, event, { parentTag, category: 'pluginEvent' });
 };
-const tFireStep = function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, edgeFunctionsBootstrapURL, }) {
+const tFireStep = function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, packagePath, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, quiet, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, edgeFunctionsBootstrapURL, deployId, }) {
     if (coreStep !== undefined) {
         return fireCoreStep({
             coreStep,
@@ -195,6 +199,7 @@ const tFireStep = function ({ event, childProcess, packageName, pluginPackageJso
             buildbotServerSocket,
             events,
             logs,
+            quiet,
             nodePath,
             childEnv,
             context,
@@ -213,6 +218,7 @@ const tFireStep = function ({ event, childProcess, packageName, pluginPackageJso
             userNodeVersion,
             explicitSecretKeys,
             edgeFunctionsBootstrapURL,
+            deployId,
         });
     }
     return firePluginStep({

package/lib/utils/blobs.d.ts

@@ -0,0 +1,8 @@
+export declare const getBlobsDir: ({ buildDir, publishDir }: {
+    buildDir: any;
+    publishDir: any;
+}) => string;
+export declare const anyBlobsToUpload: ({ buildDir, publishDir }: {
+    buildDir: any;
+    publishDir: any;
+}) => Promise<boolean>;

package/lib/utils/blobs.js

@@ -0,0 +1,11 @@
+import path from 'node:path';
+import { fdir } from 'fdir';
+const BLOBS_PATH = '.netlify/blobs/deploy';
+export const getBlobsDir = function ({ buildDir, publishDir }) {
+    return path.resolve(buildDir, publishDir, BLOBS_PATH);
+};
+export const anyBlobsToUpload = async function ({ buildDir, publishDir }) {
+    const blobsDir = getBlobsDir({ buildDir, publishDir });
+    const { files } = await new fdir().onlyCounts().crawl(blobsDir).withPromise();
+    return files > 0;
+};

package/lib/utils/errors.d.ts

@@ -1 +1,7 @@
-export function addAsyncErrorMessage(asyncFunc: any, message: any): (...args: any[]) => Promise<any>;
+type asyncFunction<T> = (...args: unknown[]) => Promise<T>;
+/**
+ * Wrap an async function so it prepends an error message on exceptions.
+ * This helps locate errors.
+ */
+export declare const addAsyncErrorMessage: <T>(asyncFunc: asyncFunction<T>, message: string) => asyncFunction<T>;
+export {};

package/lib/utils/errors.js

@@ -1,5 +1,7 @@
-// Wrap an async function so it prepends an error message on exceptions.
-// This helps locate errors.
+/**
+ * Wrap an async function so it prepends an error message on exceptions.
+ * This helps locate errors.
+ */
 export const addAsyncErrorMessage = function (asyncFunc, message) {
     return async (...args) => {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.28.1",
+  "version": "29.29.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -66,6 +66,7 @@
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
     "@honeycombio/opentelemetry-node": "^0.5.0",
+    "@netlify/blobs": "^6.3.1",
     "@netlify/cache-utils": "^5.1.5",
     "@netlify/config": "^20.10.0",
     "@netlify/edge-bundler": "10.1.3",
@@ -95,11 +96,13 @@
     "log-process-errors": "^8.0.0",
     "map-obj": "^5.0.0",
     "memoize-one": "^6.0.0",
+    "node-fetch": "^3.3.2",
     "os-name": "^5.0.0",
     "p-event": "^5.0.0",
     "p-every": "^2.0.0",
     "p-filter": "^3.0.0",
     "p-locate": "^6.0.0",
+    "p-map": "^6.0.0",
     "p-reduce": "^3.0.0",
     "path-exists": "^5.0.0",
     "path-type": "^5.0.0",
@@ -154,5 +157,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "5aef135bf29606313b5e2547c4c7d77c8ff64d56"
+  "gitHead": "e8dbd893dbc701ebbcb1df50133a7c0353bdbc8c"
 }