netlify-cli 27.12.1 → 27.14.0

package/dist/commands/agents/agents-stop.js

@@ -38,8 +38,8 @@ export const agentsStop = async (id, options, command) => {
         }
         // Stop the agent task
         const stopSpinnerInstance = startSpinner({ text: 'Stopping agent task...' });
-        const response = await fetch(`${apiOpts.scheme ?? 'https'}://${apiOpts.host ?? api.host}/api/v1/agent_runners/${id}`, {
-            method: 'DELETE',
+        const response = await fetch(`${apiOpts.scheme ?? 'https'}://${apiOpts.host ?? api.host}/api/v1/agent_runners/${id}/stop`, {
+            method: 'POST',
             headers: {
                 Authorization: `Bearer ${api.accessToken ?? ''}`,
                 'User-Agent': apiOpts.userAgent,

package/dist/commands/base-command.js

@@ -234,6 +234,8 @@ export default class BaseCommand extends Command {
         const getCommands = (command) => {
             const parentCommand = this.name() === 'netlify' ? command : command.parent;
             return (parentCommand?.commands
+                // subcommands nested with `.command()` rather than named `parent:child`, e.g. `database connect`
+                .concat(this.name() === 'netlify' ? [] : command.commands)
                 .filter((cmd) => {
                 if (cmd._hidden)
                     return false;
@@ -242,11 +244,13 @@ export default class BaseCommand extends Command {
                     // don't include subcommands on the main page
                     return !cmd.name().includes(':');
                 }
-                return cmd.name().startsWith(`${command.name()}:`);
+                return cmd.name().startsWith(`${command.name()}:`) || cmd.parent === command;
             })
                 .sort((a, b) => a.name().localeCompare(b.name())) || []);
         };
-        help.longestSubcommandTermLength = (command) => getCommands(command).reduce((max, cmd) => Math.max(max, cmd.name().length), 0);
+        /** nested subcommands are shown by their full path, e.g. `database migrations apply` */
+        const getCommandTerm = (cmd) => cmd.parent && cmd.parent.name() !== 'netlify' ? `${getCommandTerm(cmd.parent)} ${cmd.name()}` : cmd.name();
+        help.longestSubcommandTermLength = (command) => getCommands(command).reduce((max, cmd) => Math.max(max, getCommandTerm(cmd).length), 0);
         /** override the longestOptionTermLength to react on hide options flag */
         help.longestOptionTermLength = (command, helper) => (!command.noBaseOptions &&
             helper.visibleOptions(command).reduce((max, option) => Math.max(max, helper.optionTerm(option).length), 0)) ||
@@ -313,7 +317,7 @@ export default class BaseCommand extends Command {
                     '',
                 ];
             }
-            const commandList = getCommands(command).map((cmd) => formatItem(cmd.name(), helper.subcommandDescription(cmd).split('\n')[0], true));
+            const commandList = getCommands(command).map((cmd) => formatItem(getCommandTerm(cmd), helper.subcommandDescription(cmd).split('\n')[0], true));
             if (commandList.length !== 0) {
                 output = [...output, chalk.bold('COMMANDS'), formatHelpList(commandList), ''];
             }

package/dist/commands/deploy/deploy.js

@@ -72,7 +72,7 @@ const getDeployFolder = async ({ command, config, options, site, siteData, }) =>
             ? resolve(command.jsWorkspaceRoot || site.root, options.dir)
             : resolve(command.workingDir, options.dir);
     }
-    else if (config?.build?.publish) {
+    else if (config.build.publish) {
         deployFolder = resolve(site.root, config.build.publish);
     }
     else if (siteData?.build_settings?.dir) {
@@ -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;
         }
@@ -252,10 +249,7 @@ const generateDeployCommand = (options, availableTeams, command) => {
     return parts.join(' ');
 };
 const prepareProductionDeploy = async ({ api, siteData, options, command, }) => {
-    if (typeof siteData.published_deploy === 'object' &&
-        // eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- FIXME: a non-object `published_deploy` must not count as locked
-        siteData.published_deploy !== null &&
-        siteData.published_deploy.locked) {
+    if (siteData.published_deploy?.locked) {
         log(`\n${NETLIFYDEVERR} Deployments are "locked" for production context of this project\n`);
         const overrideCommand = generateDeployCommand({ ...options, prodIfUnlocked: true, prod: false }, [], command);
         if (!isInteractive()) {
@@ -275,6 +269,19 @@ const prepareProductionDeploy = async ({ api, siteData, options, command, }) =>
         log(`\n${NETLIFYDEVLOG} "Auto publishing" has been enabled for production context\n`);
     }
 };
+const createDeploy = async ({ alias, api, command, deployToProduction, options, siteData, siteId, }) => {
+    if (deployToProduction) {
+        await prepareProductionDeploy({ siteData, api, options, command });
+    }
+    const draft = options.draft || (!deployToProduction && !alias);
+    const createDeployBody = {
+        draft,
+        branch: alias,
+        include_upload_url: options.uploadSourceZip,
+        ...getDeploySourceFields(),
+    };
+    return (await api.createSiteDeploy({ siteId, title: options.message, body: createDeployBody }));
+};
 const hasErrorMessage = (actual, expected) => {
     if (typeof actual === 'string') {
         return actual.includes(expected);
@@ -372,7 +379,7 @@ const uploadDeployBlobs = async ({ cachedConfig, deployId, options, packagePath,
         phase: 'stop',
     });
 };
-const runDeploy = async ({ alias, api, command, config, deployFolder, deployTimeout, deployToProduction, functionsConfig, functionsFolder, options, packagePath, silent, site, siteData, siteId, skipFunctionsCache, title, deployId: existingDeployId, }) => {
+const runDeploy = async ({ alias, api, command, config, deployFolder, deployTimeout, deployToProduction, functionsConfig, functionsFolder, options, packagePath, silent, site, siteData, siteId, skipFunctionsCache, deployId: existingDeployId, }) => {
     let results;
     let deployId = existingDeployId;
     let uploadSourceZipResult;
@@ -380,21 +387,15 @@ const runDeploy = async ({ alias, api, command, config, deployFolder, deployTime
         // We won't have a deploy ID if we run the command with `--no-build`.
         // In this case, we must create the deploy.
         if (!deployId) {
-            if (deployToProduction) {
-                await prepareProductionDeploy({ siteData, api, options, command });
-            }
-            const draft = options.draft || (!deployToProduction && !alias);
-            const createDeployBody = {
-                draft,
-                branch: alias,
-                include_upload_url: options.uploadSourceZip,
-                ...getDeploySourceFields(),
-            };
-            const createDeployResponse = (await api.createSiteDeploy({
+            const createDeployResponse = await createDeploy({
+                alias,
+                api,
+                command,
+                deployToProduction,
+                options,
+                siteData,
                 siteId,
-                title,
-                body: createDeployBody,
-            }));
+            });
             deployId = createDeployResponse.id;
             if (options.uploadSourceZip &&
                 createDeployResponse.source_zip_upload_url &&
@@ -458,7 +459,7 @@ const runDeploy = async ({ alias, api, command, config, deployFolder, deployTime
             workingDir: command.workingDir,
             manifestPath: manifestPath ?? undefined,
             packagePath,
-            serverEnabled: Boolean(siteData?.feature_flags?.netlify_build_server_standalone),
+            serverEnabled: Boolean(siteData.feature_flags?.netlify_build_server_standalone),
             serverManifestPath: serverManifestPath ?? undefined,
             skipFunctionsCache,
             siteRoot: site.root,
@@ -708,7 +709,6 @@ const prepAndRunDeploy = async ({ api, command, config, deployToProduction, opti
         siteData,
         siteId,
         skipFunctionsCache: options.skipFunctionsCache,
-        title: options.message,
         deployId,
     });
     return results;
@@ -831,7 +831,7 @@ const anonymousDeploy = async (options, command) => {
         }
     };
     const checkForFunctions = async () => {
-        const functionsFolder = getFunctionsFolder({ config, options, site, siteData: {}, workingDir });
+        const functionsFolder = getFunctionsFolder({ config, options, site, workingDir });
         const internalFunctionsDir = await getInternalFunctionsDir({ base: site.root });
         const frameworksFunctionsDir = command.netlify.frameworksAPIPaths.functions.path;
         const hasFunctions = (await dirHasFiles(functionsFolder)) ||
@@ -861,10 +861,9 @@ const anonymousDeploy = async (options, command) => {
     }
     const deployFolder = await getDeployFolder({
         command,
-        config: command.netlify.config,
+        config,
         options,
         site,
-        siteData: {},
     });
     await validateDeployFolder(deployFolder);
     const edgeFunctionsDistPath = await getEdgeFunctionsDistPathIfExists(workingDir);
@@ -983,22 +982,8 @@ export const deploy = async (options, command) => {
     const deployToProduction = !options.draft && (options.prod || (options.prodIfUnlocked && !(siteData.published_deploy?.locked ?? false)));
     let results = {};
     if (options.build) {
-        if (deployToProduction) {
-            await prepareProductionDeploy({ siteData, api, options, command });
-        }
-        const draft = options.draft || (!deployToProduction && !alias);
-        const createDeployBody = {
-            draft,
-            branch: alias,
-            include_upload_url: options.uploadSourceZip,
-            ...getDeploySourceFields(),
-        };
-        const deployMetadata = (await api.createSiteDeploy({
-            siteId,
-            title: options.message,
-            body: createDeployBody,
-        }));
-        const deployId = deployMetadata.id || '';
+        const deployMetadata = await createDeploy({ alias, api, command, deployToProduction, options, siteData, siteId });
+        const deployId = deployMetadata.id;
         const skewProtectionToken = deployMetadata.skew_protection_token;
         let sourceZipFileName;
         if (options.uploadSourceZip &&

package/dist/commands/sites/sites-create.js

@@ -5,7 +5,7 @@ import { chalk, logAndThrowError, log, logJson, warn } from '../../utils/command
 import getRepoData from '../../utils/get-repo-data.js';
 import { configureRepo } from '../../utils/init/config.js';
 import { isInteractive } from '../../utils/scripted-commands.js';
-import { resolveTeamForNonInteractive } from '../../utils/team.js';
+import { requireTeams, resolveTeamForNonInteractive } from '../../utils/team.js';
 import { track } from '../../utils/telemetry/index.js';
 import { MAX_SITE_NAME_LENGTH } from '../../utils/validation.js';
 import { link } from '../link/link.js';
@@ -29,9 +29,10 @@ export const sitesCreate = async (options, command) => {
             log(`Using team: ${team.name}`);
         }
         else {
+            const teams = requireTeams(accounts);
             accountSlug = await select({
                 message: 'Team:',
-                choices: accounts.map((account) => ({
+                choices: teams.map((account) => ({
                     value: account.slug,
                     name: account.name,
                 })),

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/team.d.ts

@@ -1,4 +1,5 @@
 import type { MinimalAccount } from './types.js';
+export declare const requireTeams: (accounts: MinimalAccount[] | undefined) => MinimalAccount[];
 export declare const resolveTeam: (accounts: MinimalAccount[]) => MinimalAccount | undefined;
 export declare const resolveTeamForNonInteractive: (accounts: MinimalAccount[], commandExample: string) => MinimalAccount;
 //# sourceMappingURL=team.d.ts.map

package/dist/utils/team.js

@@ -1,4 +1,11 @@
 import { logAndThrowError } from './command-helpers.js';
+export const requireTeams = (accounts) => {
+    const teams = accounts ?? [];
+    if (teams.length === 0) {
+        return logAndThrowError('No teams available. Please ensure you have access to at least one team.');
+    }
+    return teams;
+};
 export const resolveTeam = (accounts) => {
     if (accounts.length === 1) {
         return accounts[0];
@@ -6,14 +13,12 @@ export const resolveTeam = (accounts) => {
     return accounts.find((acc) => acc.default);
 };
 export const resolveTeamForNonInteractive = (accounts, commandExample) => {
-    if (accounts.length === 0) {
-        return logAndThrowError('No teams available. Please ensure you have access to at least one team.');
-    }
-    const team = resolveTeam(accounts);
+    const teams = requireTeams(accounts);
+    const team = resolveTeam(teams);
     if (team) {
         return team;
     }
-    const availableTeams = accounts.map((t) => t.slug).join(', ');
+    const availableTeams = teams.map((t) => t.slug).join(', ');
     return logAndThrowError(`Multiple teams available. Please specify which team to use.\n` +
         `Available teams: ${availableTeams}\n\n` +
         `Example: ${commandExample}\n\n` +

package/dist/utils/telemetry/report-error.js

@@ -3,9 +3,8 @@ import { dirname, join } from 'path';
 import process, { version as nodejsVersion } from 'process';
 import { fileURLToPath } from 'url';
 import { getGlobalConfigStore } from '@netlify/dev-utils';
-import { isCI } from 'ci-info';
 import execa from '../execa.js';
-import { cliVersion } from './utils.js';
+import { cliVersion, isTelemetryDisabledByEnv } from './utils.js';
 const dirPath = dirname(fileURLToPath(import.meta.url));
 let currentCommand;
 export const setCommandForErrorReporting = (command) => {
@@ -21,7 +20,7 @@ export const setCommandForErrorReporting = (command) => {
  */
 // @ts-expect-error TS(7006) FIXME: Parameter 'error' implicitly has an 'any' type.
 export const reportError = async function (error, config = {}) {
-    if (isCI) {
+    if (isTelemetryDisabledByEnv()) {
         return;
     }
     // convert a NotifiableError to an error class

package/dist/utils/telemetry/telemetry.js

@@ -2,10 +2,10 @@ import { dirname, join } from 'path';
 import process, { version as nodejsVersion } from 'process';
 import { fileURLToPath } from 'url';
 import { getGlobalConfigStore } from '@netlify/dev-utils';
-import { isCI } from 'ci-info';
+import { id as ciVendor, isPR } from 'ci-info';
 import { getDrivingAgent } from '../agent-detection.js';
 import execa from '../execa.js';
-import { isTelemetryDisabled, cliVersion } from './utils.js';
+import { isTelemetryDisabled, isTelemetryDisabledByEnv, cliVersion } from './utils.js';
 import isValidEventName from './validation.js';
 const dirPath = dirname(fileURLToPath(import.meta.url));
 function send(type, payload) {
@@ -49,11 +49,15 @@ const getAgentProperties = () => {
         agent_other_value: agent?.otherValue,
     };
 };
+const getCIProperties = () => ({
+    ci_vendor: ciVendor ?? undefined,
+    ci_is_pr: isPR ?? undefined,
+});
 /**
  * Tracks a custom event with the provided payload
  */
 export async function track(eventName, payload = {}) {
-    if (isCI) {
+    if (isTelemetryDisabledByEnv()) {
         return;
     }
     const globalConfig = await getGlobalConfigStore();
@@ -78,12 +82,12 @@ export async function track(eventName, payload = {}) {
         anonymousId: cliId,
         duration,
         status,
-        properties: { ...properties, nodejsVersion, cliVersion, ...getAgentProperties() },
+        properties: { ...properties, nodejsVersion, cliVersion, ...getAgentProperties(), ...getCIProperties() },
     };
     return send('track', defaultData);
 }
 export async function identify(payload) {
-    if (isCI) {
+    if (isTelemetryDisabledByEnv()) {
         return;
     }
     const globalConfig = await getGlobalConfigStore();

package/dist/utils/telemetry/utils.d.ts

@@ -1,3 +1,4 @@
 export declare const cliVersion: string;
 export declare const isTelemetryDisabled: (config: any) => any;
+export declare const isTelemetryDisabledByEnv: () => boolean;
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils/telemetry/utils.js

@@ -1,7 +1,11 @@
+import process from 'process';
 import getCLIPackageJson from '../get-cli-package-json.js';
 export const { version: cliVersion } = await getCLIPackageJson();
 // @ts-expect-error TS(7006) FIXME: Parameter 'config' implicitly has an 'any' type.
 export const isTelemetryDisabled = function (config) {
     return config.get('telemetryDisabled');
 };
+const isEnabledFlag = (value) => value !== undefined && !['', '0', 'false'].includes(value);
+// An env var opt-out matters in CI, where the global config written by `--telemetry-disable` rarely persists.
+export const isTelemetryDisabledByEnv = () => isEnabledFlag(process.env.NETLIFY_TELEMETRY_DISABLED) || isEnabledFlag(process.env.DO_NOT_TRACK);
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify-cli",
-  "version": "27.12.1",
+  "version": "27.14.0",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -55,11 +55,11 @@
     "@fastify/static": "^10.0.0",
     "@inquirer/prompts": "^8.7.2",
     "@netlify/ai": "^1.0.1",
-    "@netlify/api": "^15.1.2",
+    "@netlify/api": "^15.1.3",
     "@netlify/blobs": "^11.1.3",
-    "@netlify/build": "^37.4.0",
+    "@netlify/build": "^37.5.0",
     "@netlify/build-info": "^11.3.0",
-    "@netlify/config": "^25.2.6",
+    "@netlify/config": "^25.3.0",
     "@netlify/dev": "^5.1.6",
     "@netlify/dev-utils": "^6.0.3",
     "@netlify/edge-bundler": "^16.1.2",
@@ -71,14 +71,14 @@
     "@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/zip-it-and-ship-it": "^16.4.0",
     "@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",
@@ -182,7 +182,7 @@
     "@types/write-file-atomic": "^4.0.3",
     "@types/ws": "^8.18.1",
     "@types/yauzl": "^2.10.3",
-    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/coverage-v8": "^5.0.0",
     "@vitest/eslint-plugin": "1.3.13",
     "c8": "^10.1.3",
     "cheerio": "^1.1.2",
@@ -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",
@@ -210,7 +210,7 @@
     "typescript-eslint": "~8.65.0",
     "typescript-native": "npm:typescript@~7.0.2",
     "verdaccio": "^6.3.2",
-    "vitest": "^4.1.11"
+    "vitest": "^5.0.0"
   },
   "engines": {
     "node": ">=22.13.0"