netlify-cli 27.13.0 → 27.14.1

package/dist/commands/base-command.js

@@ -19,6 +19,7 @@ import { handleOptionError, isOptionError } from '../utils/command-error-handler
 import { EXIT_CODES } from '../utils/exit-codes.js';
 import { getFrameworksAPIPaths } from '../utils/frameworks-api.js';
 import { getSiteByName } from '../utils/get-site.js';
+import { getLocalApiTestOpts } from '../utils/local-api-test-opts.js';
 import { buildAuthorizeUrl } from '../utils/login-url.js';
 import openBrowser from '../utils/open-browser.js';
 import { isInteractive } from '../utils/scripted-commands.js';
@@ -653,6 +654,7 @@ export default class BaseCommand extends Command {
                 host: host,
                 pathPrefix: pathPrefix,
                 scheme: scheme,
+                testOpts: getLocalApiTestOpts({ host, scheme }),
                 offline: offline ?? flags.offline,
                 siteFeatureFlagPrefix: 'cli',
                 featureFlags: this.featureFlags,

package/dist/commands/deploy/deploy.js

@@ -172,9 +172,6 @@ const getDeployFilesFilter = ({ deployFolder, site }) => {
     // when site.root !== deployFolder the behaviour matches our buildbot
     const skipNodeModules = site.root === deployFolder;
     return (filename) => {
-        if (filename == null) {
-            return false;
-        }
         if (filename === deployFolder) {
             return true;
         }

package/dist/utils/deploy/deploy-site.d.ts

@@ -7,7 +7,6 @@ import type { DeployConfig } from './types.js';
 import type { DeployEnvironmentVariable } from '../env/deploy-env-vars.js';
 export type { DeployEvent };
 export interface DeploySiteOptions {
-    assetType?: 'file' | undefined;
     branch?: string;
     concurrentHash?: number;
     concurrentUpload?: number;
@@ -33,7 +32,7 @@ export interface DeploySiteOptions {
     tmpDir?: string;
     workingDir: string;
 }
-export declare const deploySite: (command: BaseCommand, api: NetlifyAPI, siteId: string, dir: string, { assetType, branch, concurrentHash, concurrentUpload, config, deployId, deployTimeout, draft, environment, filter, fnDir, functionsConfig, hashAlgorithm, manifestPath, maxRetry, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb, syncFileLimit, tmpDir, workingDir, }: DeploySiteOptions) => Promise<{
+export declare const deploySite: (command: BaseCommand, api: NetlifyAPI, siteId: string, dir: string, { branch, concurrentHash, concurrentUpload, config, deployId, deployTimeout, draft, environment, filter, fnDir, functionsConfig, hashAlgorithm, manifestPath, maxRetry, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb, syncFileLimit, tmpDir, workingDir, }: DeploySiteOptions) => Promise<{
     deployId: string;
     deploy: import("./util.js").ReadyDeploy;
     uploadList: (import("./upload-files.js").EdgeFunctionUploadFile | import("./upload-files.js").ServerUploadFile | File | (import("./upload-files.js").FunctionUploadFile & {

package/dist/utils/deploy/deploy-site.js

@@ -18,7 +18,7 @@ const buildStatsString = (possibleParts) => {
     }
     return `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`;
 };
-export const deploySite = async (command, api, siteId, dir, { assetType, branch, concurrentHash = DEFAULT_CONCURRENT_HASH, concurrentUpload = DEFAULT_CONCURRENT_UPLOAD, config, deployId, deployTimeout = DEFAULT_DEPLOY_TIMEOUT, draft = false, environment, filter, fnDir = [], functionsConfig, hashAlgorithm, manifestPath, maxRetry = DEFAULT_MAX_RETRY, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb = () => {
+export const deploySite = async (command, api, siteId, dir, { branch, concurrentHash = DEFAULT_CONCURRENT_HASH, concurrentUpload = DEFAULT_CONCURRENT_UPLOAD, config, deployId, deployTimeout = DEFAULT_DEPLOY_TIMEOUT, draft = false, environment, filter, fnDir = [], functionsConfig, hashAlgorithm, manifestPath, maxRetry = DEFAULT_MAX_RETRY, packagePath, serverEnabled, serverManifestPath, siteRoot, skipFunctionsCache, statusCb = () => {
     /* default to noop */
 }, syncFileLimit = DEFAULT_SYNC_LIMIT, tmpDir = temporaryDirectory(), workingDir, }) => {
     statusCb({
@@ -31,7 +31,6 @@ export const deploySite = async (command, api, siteId, dir, { assetType, branch,
     const dbMigrationsDistPath = await getDbMigrationsDistPathIfExists(workingDir);
     const [{ files: staticFiles, filesShaMap: staticShaMap }, { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules, server, serverShaMap }, configFile, { edgeFunctions, edgeFnShaMap },] = await Promise.all([
         hashFiles({
-            assetType,
             concurrentHash,
             directories: [dir, edgeFunctionsDistPath, deployConfigPath, dbMigrationsDistPath].filter((d) => Boolean(d)),
             filter,
@@ -47,6 +46,7 @@ export const deploySite = async (command, api, siteId, dir, { assetType, branch,
             statusCb,
             manifestPath,
             packagePath,
+            serverConfig: config.server,
             serverEnabled,
             serverManifestPath,
             skipFunctionsCache,

package/dist/utils/deploy/drop-api.js

@@ -62,37 +62,29 @@ export const uploadDropFile = async ({ apiBase, userAgent }, deployId, filePath,
     }
 };
 // TODO: Migrate to @netlify/api when Drop endpoints are in the OpenAPI spec.
-export const waitForDropDeploy = async ({ apiBase, userAgent }, siteId, deployId, timeout = DEFAULT_DEPLOY_TIMEOUT) => {
-    let deploy;
-    const checkDeploy = async () => {
-        const response = await fetch(`${apiBase}/sites/${siteId}/deploys/${deployId}`, {
-            headers: makeHeaders(userAgent),
-        });
-        if (!response.ok) {
-            return false;
-        }
-        const data = (await response.json());
-        if (data.state === 'ready') {
-            deploy = data;
-            return true;
-        }
-        if (data.state === 'error') {
-            // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- an empty error message falls back to the generic one
-            throw new Error(data.error_message || `Deploy ${deployId} had an error`);
-        }
-        return false;
-    };
-    await pWaitFor(checkDeploy, {
-        interval: DEPLOY_POLL,
-        timeout: {
-            milliseconds: timeout,
-            message: 'Timeout while waiting for deploy',
-        },
+export const waitForDropDeploy = async ({ apiBase, userAgent }, siteId, deployId, timeout = DEFAULT_DEPLOY_TIMEOUT) => await pWaitFor(async () => {
+    const response = await fetch(`${apiBase}/sites/${siteId}/deploys/${deployId}`, {
+        headers: makeHeaders(userAgent),
     });
-    // deploy is guaranteed to be set when pWaitFor resolves
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    return deploy;
-};
+    if (!response.ok) {
+        return false;
+    }
+    const data = (await response.json());
+    if (data.state === 'ready') {
+        return pWaitFor.resolveWith(data);
+    }
+    if (data.state === 'error') {
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing -- an empty error message falls back to the generic one
+        throw new Error(data.error_message || `Deploy ${deployId} had an error`);
+    }
+    return false;
+}, {
+    interval: DEPLOY_POLL,
+    timeout: {
+        milliseconds: timeout,
+        message: 'Timeout while waiting for deploy',
+    },
+});
 // TODO: Migrate to @netlify/api when Drop endpoints are in the OpenAPI spec.
 export const claimDropSite = async ({ apiBase, userAgent }, siteId, dropToken, authToken) => {
     const response = await fetch(`${apiBase}/drop/claim`, {
@@ -123,7 +115,6 @@ export const uploadDropFiles = async (apiOptions, deployId, uploadList, token, {
             msg: `(${String(index + 1)}/${String(uploadList.length)}) Uploading ${fileObj.normalizedPath}...`,
             phase: 'progress',
         });
-        let lastError;
         for (let attempt = 0; attempt <= maxRetry; attempt++) {
             try {
                 const body = fs.createReadStream(fileObj.filepath);
@@ -131,18 +122,13 @@ export const uploadDropFiles = async (apiOptions, deployId, uploadList, token, {
                 return;
             }
             catch (error) {
-                lastError = error;
-                if (lastError.status === 400 || lastError.status === 422) {
+                const isPermanentFailure = error instanceof Error && 'status' in error && (error.status === 400 || error.status === 422);
+                if (isPermanentFailure || attempt + 1 > maxRetry) {
                     throw error;
                 }
-                if (attempt < maxRetry) {
-                    await new Promise((resolve) => setTimeout(resolve, 1000 * (attempt + 1)));
-                }
+                await new Promise((resolve) => setTimeout(resolve, 1000 * (attempt + 1)));
             }
         }
-        if (lastError) {
-            throw lastError;
-        }
     };
     await pMap(uploadList, uploadFile, { concurrency: concurrentUpload });
     statusCb({

package/dist/utils/deploy/hash-config.d.ts

@@ -1,7 +1,7 @@
 import type { DeployConfig } from './types.js';
 import type { InlineUploadFile } from './upload-files.js';
 export declare const hashConfig: ({ config }: {
-    config: DeployConfig | undefined;
+    config: DeployConfig;
 }) => InlineUploadFile & {
     hash: string;
 };

package/dist/utils/deploy/hash-config.js

@@ -1,8 +1,6 @@
 import { createHash } from 'node:crypto';
 import tomlify from 'tomlify-j0.4';
 export const hashConfig = ({ config }) => {
-    if (!config)
-        throw new Error('Missing config option');
     const configString = serializeToml(config);
     const hash = createHash('sha1').update(configString).digest('hex');
     return {

package/dist/utils/deploy/hash-files.d.ts

@@ -1,10 +1,9 @@
 import type { File } from './file.js';
 import type { StatusCallback } from './status-cb.js';
-declare const hashFiles: ({ assetType, concurrentHash, directories, filter, hashAlgorithm, normalizer, statusCb, }: {
-    assetType?: 'file' | undefined;
+declare const hashFiles: ({ concurrentHash, directories, filter, hashAlgorithm, normalizer, statusCb, }: {
     concurrentHash: number;
     directories: string[];
-    filter: ((filename: string) => boolean) | undefined;
+    filter: (filename: string) => boolean;
     hashAlgorithm?: string | undefined;
     normalizer?: (file: File) => File;
     statusCb: StatusCallback;

package/dist/utils/deploy/hash-files.js

@@ -1,13 +1,11 @@
 import { pipeline } from 'stream/promises';
 import walker from 'folder-walker';
 import { fileFilterCtor, fileNormalizerCtor, hasherCtor, manifestCollectorCtor } from './hasher-segments.js';
-const hashFiles = async ({ assetType = 'file', concurrentHash, directories, filter, hashAlgorithm = 'sha1', normalizer, statusCb, }) => {
-    if (!filter)
-        throw new Error('Missing filter function option');
+const hashFiles = async ({ concurrentHash, directories, filter, hashAlgorithm = 'sha1', normalizer, statusCb, }) => {
     const fileStream = walker(directories, { filter });
     const fileFilter = fileFilterCtor();
     const hasher = hasherCtor({ concurrentHash, hashAlgorithm });
-    const fileNormalizer = fileNormalizerCtor({ assetType, normalizer });
+    const fileNormalizer = fileNormalizerCtor({ normalizer });
     // Written to by manifestCollector
     // normalizedPath: hash (wanted by deploy API)
     const files = {};

package/dist/utils/deploy/hash-fns.d.ts

@@ -1,53 +1,62 @@
-import { type Config as FunctionsConfig, type FunctionResult, type TrafficRules } from '@netlify/zip-it-and-ship-it';
+import { type Config as FunctionsConfig, type FunctionResult, type NetlifyServerConfig, type ServerResult } from '@netlify/zip-it-and-ship-it';
 import type BaseCommand from '../../commands/base-command.js';
 import type { StatusCallback } from './status-cb.js';
 import type { FunctionUploadFile, ServerUploadFile } from './upload-files.js';
+interface ServerPayload {
+    sha: string;
+    region?: string;
+    instance_size?: ServerResult['instanceSize'];
+    routes?: ServerResult['routes'];
+    excluded_routes?: ServerResult['excludedRoutes'];
+    runtime_version?: ServerResult['runtimeVersion'];
+}
 type HashedFunctionFile = FunctionUploadFile & {
     hash: string;
     relname: string;
 };
-declare const trafficRulesConfig: (trafficRules?: TrafficRules) => {
-    action: {
-        type: string;
-        config: {
-            rate_limit_config: {
-                algorithm: string;
-                window_size: number;
-                window_limit: number;
-            };
-            aggregate: {
-                keys: {
-                    type: string;
-                }[];
+declare const toFunctionConfigPayload: (func: FunctionResult) => {
+    display_name: string | undefined;
+    excluded_routes: import("@netlify/zip-it-and-ship-it").Route[] | undefined;
+    generator: string | undefined;
+    memory: number | undefined;
+    region: string | undefined;
+    routes: import("@netlify/zip-it-and-ship-it").ExtendedRoute[] | undefined;
+    build_data: import("@netlify/zip-it-and-ship-it/dist/utils/format_result.js").BuildData | undefined;
+    priority: number | undefined;
+    traffic_rules: {
+        action: {
+            type: string;
+            config: {
+                rate_limit_config: {
+                    algorithm: string;
+                    window_size: number;
+                    window_limit: number;
+                };
+                aggregate: {
+                    keys: {
+                        type: string;
+                    }[];
+                };
+                to: string | undefined;
             };
-            to: string | undefined;
         };
-    };
-} | undefined;
-interface FunctionConfigPayload {
-    display_name: FunctionResult['displayName'];
-    excluded_routes: FunctionResult['excludedRoutes'];
-    generator: FunctionResult['generator'];
-    memory: FunctionResult['memory'];
-    region: FunctionResult['region'];
-    routes: FunctionResult['routes'];
-    build_data: FunctionResult['buildData'];
-    priority: FunctionResult['priority'];
-    traffic_rules: ReturnType<typeof trafficRulesConfig>;
-    vcpu: FunctionResult['vcpu'];
-}
-declare const hashFns: (command: BaseCommand, directories: string[], { concurrentHash, functionsConfig, hashAlgorithm, manifestPath, packagePath, rootDir, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }: {
+    } | undefined;
+    vcpu: number | undefined;
+};
+type FunctionConfigPayload = ReturnType<typeof toFunctionConfigPayload>;
+declare const hashFns: (command: BaseCommand, directories: string[], { concurrentHash, functionsConfig, hashAlgorithm, manifestPath, packagePath, rootDir, serverConfig, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }: {
     concurrentHash?: number;
     functionsConfig?: FunctionsConfig | undefined;
     hashAlgorithm?: string | undefined;
     manifestPath?: string | undefined;
     packagePath?: string | undefined;
     rootDir?: string | undefined;
+    serverConfig?: NetlifyServerConfig | undefined;
     serverEnabled?: boolean | undefined;
     serverManifestPath?: string | undefined;
     skipFunctionsCache?: boolean | undefined;
     statusCb: StatusCallback;
-    tmpDir?: string | undefined;
+    tmpDir: string;
 }) => Promise<{
     functionSchedules?: {
         name: string;
@@ -55,13 +64,9 @@ declare const hashFns: (command: BaseCommand, directories: string[], { concurren
     }[] | undefined;
     functions: Record<string, string>;
     functionsWithNativeModules: FunctionResult[];
-    shaMap?: Record<string, never> | undefined;
     fnShaMap?: Record<string, HashedFunctionFile[]> | undefined;
     fnConfig?: Record<string, FunctionConfigPayload> | undefined;
-    server?: {
-        sha: string;
-        region?: string;
-    } | undefined;
+    server?: ServerPayload | undefined;
     serverShaMap?: Record<string, ServerUploadFile[]> | undefined;
 }>;
 export default hashFns;

package/dist/utils/deploy/hash-fns.js

@@ -52,7 +52,7 @@ const getFunctionZips = async ({ command, directories, functionsConfig, manifest
         config: functionsConfig,
     });
 };
-const getServerBundle = async ({ packagePath, rootDir, serverEnabled, serverManifestPath, tmpDir, }) => {
+const getServerBundle = async ({ packagePath, rootDir, serverConfig, serverEnabled, serverManifestPath, tmpDir, }) => {
     if (!serverEnabled) {
         return undefined;
     }
@@ -72,7 +72,7 @@ const getServerBundle = async ({ packagePath, rootDir, serverEnabled, serverMani
     if (entryPath === undefined) {
         return undefined;
     }
-    return await zipServer(entryPath, join(tmpDir, 'server'), { basePath: rootDir });
+    return await zipServer(entryPath, join(tmpDir, 'server'), { basePath: rootDir, config: serverConfig });
 };
 const trafficRulesConfig = (trafficRules) => {
     if (!trafficRules) {
@@ -93,14 +93,23 @@ const trafficRulesConfig = (trafficRules) => {
         },
     };
 };
-const hashFns = async (command, directories, { concurrentHash, functionsConfig, hashAlgorithm = 'sha256', manifestPath, packagePath, rootDir, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }) => {
+const toFunctionConfigPayload = (func) => ({
+    display_name: func.displayName,
+    excluded_routes: func.excludedRoutes,
+    generator: func.generator,
+    memory: func.memory,
+    region: func.region,
+    routes: func.routes,
+    build_data: func.buildData,
+    priority: func.priority,
+    traffic_rules: trafficRulesConfig(func.trafficRules),
+    vcpu: func.vcpu,
+});
+const hashFns = async (command, directories, { concurrentHash, functionsConfig, hashAlgorithm = 'sha256', manifestPath, packagePath, rootDir, serverConfig, serverEnabled, serverManifestPath, skipFunctionsCache, statusCb, tmpDir, }) => {
     // Exit early if there is nothing to bundle. A site can have a server without
     // any functions directory.
     if (directories.length === 0 && !serverEnabled) {
-        return { functions: {}, functionsWithNativeModules: [], shaMap: {} };
-    }
-    if (!tmpDir) {
-        throw new Error('Missing tmpDir directory for zipping files');
+        return { functions: {}, functionsWithNativeModules: [] };
     }
     const [functionZips, serverBundle] = await Promise.all([
         directories.length === 0
@@ -115,7 +124,7 @@ const hashFns = async (command, directories, { concurrentHash, functionsConfig,
                 statusCb,
                 tmpDir,
             }),
-        getServerBundle({ packagePath, rootDir, serverEnabled, serverManifestPath, tmpDir }),
+        getServerBundle({ packagePath, rootDir, serverConfig, serverEnabled, serverManifestPath, tmpDir }),
     ]);
     // ZISI's in-memory FunctionResult only nests bootstrap/runtime version into
     // buildData when writing the manifest cache. Reconstruct it for direct-zip paths.
@@ -145,7 +154,7 @@ const hashFns = async (command, directories, { concurrentHash, functionsConfig,
         priority,
         trafficRules,
     }));
-    const fnConfig = functionZips
+    const fnConfig = Object.fromEntries(functionZips
         .filter((func) => Boolean(func.displayName ||
         func.generator ||
         func.routes ||
@@ -155,21 +164,7 @@ const hashFns = async (command, directories, { concurrentHash, functionsConfig,
         func.region ||
         func.memory ||
         func.vcpu))
-        .reduce((funcs, curr) => ({
-        ...funcs,
-        [curr.name]: {
-            display_name: curr.displayName,
-            excluded_routes: curr.excludedRoutes,
-            generator: curr.generator,
-            memory: curr.memory,
-            region: curr.region,
-            routes: curr.routes,
-            build_data: curr.buildData,
-            priority: curr.priority,
-            traffic_rules: trafficRulesConfig(curr.trafficRules),
-            vcpu: curr.vcpu,
-        },
-    }), {});
+        .map((func) => [func.name, toFunctionConfigPayload(func)]));
     const functionSchedules = functionZips
         .map(({ name, schedule }) => schedule && { name, cron: schedule })
         .filter((schedule) => schedule !== '' && schedule !== undefined);
@@ -210,7 +205,16 @@ const hashServer = async (serverBundle, { concurrentHash, hashAlgorithm, statusC
         hasherCtor({ concurrentHash, hashAlgorithm }),
         manifestCollectorCtor(servers, serverShaMap, { statusCb }),
     ]);
-    return { server: { sha: Object.values(servers)[0], region: serverBundle.region }, serverShaMap };
+    const { excludedRoutes, instanceSize, region, routes, runtimeVersion } = serverBundle;
+    const server = {
+        sha: Object.values(servers)[0],
+        ...(region === undefined ? {} : { region }),
+        ...(instanceSize === undefined ? {} : { instance_size: instanceSize }),
+        ...(routes === undefined ? {} : { routes }),
+        ...(excludedRoutes === undefined ? {} : { excluded_routes: excludedRoutes }),
+        ...(runtimeVersion === undefined ? {} : { runtime_version: runtimeVersion }),
+    };
+    return { server, serverShaMap };
 };
 export default hashFns;
 //# sourceMappingURL=hash-fns.js.map

package/dist/utils/deploy/hasher-segments.d.ts

@@ -5,8 +5,7 @@ export declare const hasherCtor: ({ concurrentHash, hashAlgorithm }: {
     concurrentHash?: number;
     hashAlgorithm: string;
 }) => Transform;
-export declare const fileNormalizerCtor: ({ assetType, normalizer: normalizeFunction, }: {
-    assetType: 'file';
+export declare const fileNormalizerCtor: ({ normalizer: normalizeFunction }: {
     normalizer?: (file: File) => File;
 }) => Transform;
 export declare const manifestCollectorCtor: <T extends {

package/dist/utils/deploy/hasher-segments.js

@@ -28,11 +28,11 @@ export const hasherCtor = ({ concurrentHash, hashAlgorithm }) => {
     });
 };
 // Inject normalized file names into normalizedPath and assetType
-export const fileNormalizerCtor = ({ assetType, normalizer: normalizeFunction, }) => {
+export const fileNormalizerCtor = ({ normalizer: normalizeFunction }) => {
     return new Transform({
         objectMode: true,
         transform(fileObj, _, callback) {
-            const normalizedFile = { ...fileObj, assetType, normalizedPath: normalizePath(fileObj.relname) };
+            const normalizedFile = { ...fileObj, assetType: 'file', normalizedPath: normalizePath(fileObj.relname) };
             const result = normalizeFunction !== undefined ? normalizeFunction(normalizedFile) : normalizedFile;
             this.push(result);
             callback();

package/dist/utils/deploy/types.d.ts

@@ -13,5 +13,6 @@ export interface DeployConfig {
     functionsDirectory?: string;
     headers?: NetlifyConfig['headers'] | MinimalHeader[];
     redirects?: unknown[];
+    server?: NetlifyConfig['server'];
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/utils/deploy/upload-files.d.ts

@@ -4,10 +4,10 @@ export type UploadApi = Pick<NetlifyAPI, 'uploadDeployFile' | 'uploadDeployFunct
 interface UploadFileBase {
     filepath: string;
     normalizedPath: string;
-    body?: undefined;
 }
 export interface StaticUploadFile extends UploadFileBase {
     assetType: 'file';
+    body?: undefined;
 }
 export interface InlineUploadFile {
     assetType: 'file';

package/dist/utils/deploy/upload-files.js

@@ -22,9 +22,7 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
         phase: 'start',
     });
     const uploadFile = async (fileObj, index) => {
-        const { body, filepath, normalizedPath } = fileObj;
-        // FIXME(@netlify/api): octet-stream `body` is typed as `ReadStream` only, but an inline string body works too
-        const readStreamCtor = () => (body ?? fs.createReadStream(filepath));
+        const { normalizedPath } = fileObj;
         statusCb({
             type: 'upload',
             msg: `(${index}/${uploadList.length}) Uploading ${normalizedPath}...`,
@@ -32,8 +30,11 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
         });
         switch (fileObj.assetType) {
             case 'file': {
+                const { body, filepath } = fileObj;
                 return await retryUpload(() => api.uploadDeployFile({
-                    body: readStreamCtor,
+                    // FIXME(@netlify/api): `types.d.ts` hardcodes every `application/octet-stream` body as `ReadStream | (() => ReadStream)`,
+                    // ignoring the spec's `string` type; a string body works at runtime
+                    body: () => (body ?? fs.createReadStream(filepath)),
                     deployId,
                     path: encodeURI(normalizedPath),
                 }), maxRetry);
@@ -42,7 +43,7 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
                 const { invocationMode, runtime, timeout } = fileObj;
                 return await retryUpload((retryCount) => {
                     const params = {
-                        body: readStreamCtor,
+                        body: () => fs.createReadStream(fileObj.filepath),
                         deployId,
                         invocationMode,
                         timeout,
@@ -58,7 +59,7 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
             case 'edge-function': {
                 return await retryUpload((retryCount) => {
                     const params = {
-                        body: readStreamCtor,
+                        body: () => fs.createReadStream(fileObj.filepath),
                         deployId,
                         codeSha: normalizedPath,
                     };
@@ -71,7 +72,7 @@ const uploadFiles = async (api, deployId, uploadList, { concurrentUpload, maxRet
             case 'server': {
                 return await retryUpload((retryCount) => {
                     const params = {
-                        body: readStreamCtor,
+                        body: () => fs.createReadStream(fileObj.filepath),
                         deployId,
                         codeSha: fileObj.hash,
                     };
@@ -132,8 +133,9 @@ const retryUpload = (uploadFn, maxRetry) => new Promise((resolve, reject) => {
         // Do something when backoff starts, e.g. show to the
         // user the delay before next reconnection attempt.
     });
-    // eslint-disable-next-line @typescript-eslint/no-misused-promises -- FIXME: the listener's promise is discarded
-    fibonacciBackoff.on('ready', tryUpload);
+    fibonacciBackoff.on('ready', (retryIndex) => {
+        void tryUpload(retryIndex);
+    });
     fibonacciBackoff.on('fail', () => {
         reject(lastError);
     });

package/dist/utils/deploy/util.d.ts

@@ -2,6 +2,10 @@ import type { NetlifyAPI } from '@netlify/api';
 export declare const pluralize: (amount: number, noun: string) => string;
 export type Deploy = Awaited<ReturnType<NetlifyAPI['getSiteDeploy']>>;
 export type ReadyDeploy = Deploy & Required<Pick<Deploy, 'id' | 'site_id' | 'name' | 'admin_url' | 'url' | 'ssl_url' | 'deploy_url' | 'deploy_ssl_url'>>;
+export declare class DeployStateError extends Error {
+    readonly deploy: Deploy;
+    constructor(message: string, deploy: Deploy);
+}
 export declare const normalizePath: (relname: string) => string;
 export declare const waitForDiff: (api: Pick<NetlifyAPI, 'getSiteDeploy'>, deployId: string, siteId: string, timeout: number) => Promise<Deploy>;
 export declare const waitForDeploy: (api: Pick<NetlifyAPI, 'getSiteDeploy'>, deployId: string, siteId: string, timeout: number) => Promise<ReadyDeploy>;

package/dist/utils/deploy/util.js

@@ -2,6 +2,13 @@ import { sep } from 'path';
 import pWaitFor from 'p-wait-for';
 import { DEPLOY_POLL } from './constants.js';
 export const pluralize = (amount, noun) => `${amount} ${noun}${amount === 1 ? '' : 's'}`;
+export class DeployStateError extends Error {
+    deploy;
+    constructor(message, deploy) {
+        super(message);
+        this.deploy = deploy;
+    }
+}
 // normalize windows paths to unix paths
 export const normalizePath = (relname) => {
     if (relname.includes('#') || relname.includes('?')) {
@@ -9,70 +16,26 @@ export const normalizePath = (relname) => {
     }
     return relname.split(sep).join('/');
 };
+// https://github.com/netlify/bitballoon/blob/master/app/models/deploy.rb#L21-L33
+const DIFFED_STATES = new Set(['prepared', 'uploading', 'uploaded', 'ready']);
+const READY_STATES = new Set(['ready']);
+const pollDeployUntil = async (api, deployId, siteId, timeout, targetStates) => await pWaitFor(async () => {
+    const siteDeploy = await api.getSiteDeploy({ siteId, deployId });
+    if (siteDeploy.state === 'error') {
+        throw new DeployStateError(siteDeploy.error_message || `Deploy ${deployId} had an error`, siteDeploy);
+    }
+    return siteDeploy.state !== undefined && targetStates.has(siteDeploy.state) && pWaitFor.resolveWith(siteDeploy);
+}, {
+    interval: DEPLOY_POLL,
+    timeout: {
+        milliseconds: timeout,
+        message: 'Timeout while waiting for deploy',
+    },
+});
 // poll an async deployId until its done diffing
-export const waitForDiff = async (api, deployId, siteId, timeout) => {
-    const loadDeploy = async () => {
-        const siteDeploy = await api.getSiteDeploy({ siteId, deployId });
-        switch (siteDeploy.state) {
-            // https://github.com/netlify/bitballoon/blob/master/app/models/deploy.rb#L21-L33
-            case 'error': {
-                const deployError = new Error(siteDeploy.error_message || `Deploy ${deployId} had an error`);
-                deployError.deploy = siteDeploy;
-                throw deployError;
-            }
-            case 'prepared':
-            case 'uploading':
-            case 'uploaded':
-            case 'ready': {
-                return pWaitFor.resolveWith(siteDeploy);
-            }
-            case 'preparing':
-            default: {
-                return false;
-            }
-        }
-    };
-    const deploy = await pWaitFor(loadDeploy, {
-        interval: DEPLOY_POLL,
-        timeout: {
-            milliseconds: timeout,
-            message: 'Timeout while waiting for deploy',
-        },
-    });
-    return deploy;
-};
+export const waitForDiff = async (api, deployId, siteId, timeout) => await pollDeployUntil(api, deployId, siteId, timeout, DIFFED_STATES);
 // Poll a deployId until its ready
-export const waitForDeploy = async (api, deployId, siteId, timeout) => {
-    const loadDeploy = async () => {
-        const siteDeploy = await api.getSiteDeploy({ siteId, deployId });
-        switch (siteDeploy.state) {
-            // https://github.com/netlify/bitballoon/blob/master/app/models/deploy.rb#L21-L33
-            case 'error': {
-                const deployError = new Error(siteDeploy.error_message || `Deploy ${deployId} had an error`);
-                deployError.deploy = siteDeploy;
-                throw deployError;
-            }
-            case 'ready': {
-                return pWaitFor.resolveWith(siteDeploy);
-            }
-            case 'preparing':
-            case 'prepared':
-            case 'uploaded':
-            case 'uploading':
-            default: {
-                return false;
-            }
-        }
-    };
-    const deploy = await pWaitFor(loadDeploy, {
-        interval: DEPLOY_POLL,
-        timeout: {
-            milliseconds: timeout,
-            message: 'Timeout while waiting for deploy',
-        },
-    });
-    return deploy;
-};
+export const waitForDeploy = async (api, deployId, siteId, timeout) => (await pollDeployUntil(api, deployId, siteId, timeout, READY_STATES));
 // Transform the fileShaMap and fnShaMap into a generic shaMap that file-uploader.js can use
 export const getUploadList = (required, shaMap) => {
     if (!required || !shaMap)

package/dist/utils/init/agent-skills.js

@@ -199,8 +199,9 @@ const isOlderThan = async (file, ageMs) => {
 };
 const isSameEntry = async (a, b) => {
     try {
-        const [statA, statB] = await Promise.all([fs.lstat(a), fs.lstat(b)]);
-        return statA.ino !== 0 && statA.ino === statB.ino && statA.dev === statB.dev;
+        // As numbers, Windows file IDs lose precision and two directories can share one.
+        const [statA, statB] = await Promise.all([fs.lstat(a, { bigint: true }), fs.lstat(b, { bigint: true })]);
+        return statA.ino !== 0n && statA.ino === statB.ino && statA.dev === statB.dev;
     }
     catch {
         return false;

package/dist/utils/local-api-test-opts.d.ts

@@ -0,0 +1,8 @@
+export declare const getLocalApiTestOpts: ({ host, scheme, }: {
+    host?: string;
+    scheme?: string;
+}) => {
+    host: string;
+    scheme?: string;
+} | undefined;
+//# sourceMappingURL=local-api-test-opts.d.ts.map

package/dist/utils/local-api-test-opts.js

@@ -0,0 +1,14 @@
+const LOOPBACK_HOSTNAMES = new Set(['localhost', '127.0.0.1', '[::1]']);
+export const getLocalApiTestOpts = ({ host, scheme, }) => {
+    if (host === undefined) {
+        return undefined;
+    }
+    try {
+        const { hostname } = new URL(`http://${host}`);
+        return LOOPBACK_HOSTNAMES.has(hostname) ? { host, scheme } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+//# sourceMappingURL=local-api-test-opts.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify-cli",
-  "version": "27.13.0",
+  "version": "27.14.1",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -54,31 +54,31 @@
   "dependencies": {
     "@fastify/static": "^10.0.0",
     "@inquirer/prompts": "^8.7.2",
-    "@netlify/ai": "^1.0.1",
-    "@netlify/api": "^15.1.2",
-    "@netlify/blobs": "^11.1.3",
-    "@netlify/build": "^37.4.0",
+    "@netlify/ai": "^1.0.2",
+    "@netlify/api": "^15.1.3",
+    "@netlify/blobs": "^11.1.6",
+    "@netlify/build": "^37.5.1",
     "@netlify/build-info": "^11.3.0",
-    "@netlify/config": "^25.2.6",
-    "@netlify/dev": "^5.1.6",
-    "@netlify/dev-utils": "^6.0.3",
-    "@netlify/edge-bundler": "^16.1.2",
-    "@netlify/edge-functions": "^4.0.2",
+    "@netlify/config": "^25.3.0",
+    "@netlify/dev": "^5.1.10",
+    "@netlify/dev-utils": "^6.0.4",
+    "@netlify/edge-bundler": "^16.1.3",
+    "@netlify/edge-functions": "^4.0.3",
     "@netlify/edge-functions-bootstrap": "^3.2.0",
     "@netlify/headers-parser": "^10.1.1",
-    "@netlify/images": "^2.0.3",
+    "@netlify/images": "^2.0.5",
     "@netlify/local-functions-proxy": "^2.0.3",
     "@netlify/redirect-matcher": "^0.4.2",
     "@netlify/redirect-parser": "^16.1.1",
-    "@netlify/server-dev": "^0.1.3",
-    "@netlify/zip-it-and-ship-it": "^16.3.0",
+    "@netlify/server-dev": "^0.1.4",
+    "@netlify/zip-it-and-ship-it": "^16.4.1",
     "@opentelemetry/api": "~1.9.0",
     "@pnpm/tabtab": "^0.5.4",
     "ansi-escapes": "^7.3.0",
     "ansi-to-html": "^0.7.2",
     "ascii-table": "^0.0.9",
     "backoff": "^2.5.0",
-    "boxen": "^8.0.1",
+    "boxen": "^9.0.0",
     "chalk": "^6.0.0",
     "chokidar": "^5.0.0",
     "ci-info": "^4.4.0",
@@ -152,8 +152,8 @@
     "@bugsnag/js": "^8.6.0",
     "@eslint/compat": "^1.4.1",
     "@eslint/js": "^9.36.0",
-    "@netlify/functions": "^6.0.2",
-    "@netlify/types": "^3.2.0",
+    "@netlify/functions": "^6.0.3",
+    "@netlify/types": "^3.3.0",
     "@sindresorhus/slugify": "^3.0.0",
     "@tsconfig/node22": "22.0.5",
     "@tsconfig/recommended": "^1.0.13",
@@ -196,7 +196,7 @@
     "memfs": "^4.56.10",
     "nock": "^14.0.10",
     "npm-run-all2": "^8.0.4",
-    "oxfmt": "0.72.0",
+    "oxfmt": "0.73.0",
     "p-timeout": "^7.0.0",
     "picomatch": "^4.0.4",
     "pkg-pr-new": "^0.0.86",