netlify-cli 27.14.3 → 27.16.0

package/dist/commands/deploy/deploy.js

@@ -35,6 +35,7 @@ import hashFiles from '../../utils/deploy/hash-files.js';
 import { deployFileNormalizer, getEdgeFunctionsDistPathIfExists } from '../../utils/deploy/process-files.js';
 import { link } from '../link/link.js';
 import { sitesCreate } from '../sites/sites-create.js';
+import { remoteDeploy } from './remote-deploy.js';
 import boxen from 'boxen';
 import terminalLink from 'terminal-link';
 import { anyEdgeFunctionsDirectoryExists } from '../../lib/edge-functions/get-directories.js';
@@ -559,7 +560,7 @@ const bundleEdgeFunctions = async (options, command) => {
         phase: 'stop',
     });
 };
-const printResults = ({ deployToProduction, uploadSourceZip, json, results, runBuildCommand, }) => {
+const printResults = ({ deployToProduction, uploadSourceZip, json, results, prodCommand, }) => {
     const msgData = {
         'Build logs': terminalLink(results.logsUrl, results.logsUrl, { fallback: false }),
         'Function logs': terminalLink(results.functionLogsUrl, results.functionLogsUrl, { fallback: false }),
@@ -585,6 +586,9 @@ const printResults = ({ deployToProduction, uploadSourceZip, json, results, runB
         if (uploadSourceZip) {
             jsonData.source_zip_filename = results.sourceZipFileName;
         }
+        if (results.commitSha) {
+            jsonData.commit_sha = results.commitSha;
+        }
         logJson(jsonData);
         exit(0);
     }
@@ -602,7 +606,7 @@ const printResults = ({ deployToProduction, uploadSourceZip, json, results, runB
         if (!deployToProduction) {
             log();
             log('If everything looks good on your draft URL, deploy it to your main project URL with the --prod flag:');
-            log(`netlify deploy${runBuildCommand ? '' : ' --no-build'} --prod`);
+            log(prodCommand);
             log();
         }
     }
@@ -626,7 +630,7 @@ const printResults = ({ deployToProduction, uploadSourceZip, json, results, runB
         if (!deployToProduction) {
             log();
             log('If everything looks good on your draft URL, deploy it to your main project URL with the --prod flag:');
-            log(chalk.cyanBright.bold(`netlify deploy${runBuildCommand ? '' : ' --no-build'} --prod`));
+            log(chalk.cyanBright.bold(prodCommand));
             log();
         }
     }
@@ -787,6 +791,9 @@ const ensureSiteExists = async (options, command, site, siteInfo) => {
     if (hasSiteData) {
         return siteInfo;
     }
+    if (options.remote) {
+        return logAndThrowError('--remote needs an existing Netlify project connected to a git repository. Run netlify link to link this directory to one, or pass --site.');
+    }
     if (options.createSite) {
         return createSiteWithFlags(options, command, site);
     }
@@ -940,7 +947,13 @@ export const deploy = async (options, command) => {
     const { workingDir } = command;
     const { api, site, siteInfo } = command.netlify;
     const alias = options.alias || options.branch;
-    command.setAnalyticsPayload({ open: options.open, prod: options.prod, json: options.json, alias: Boolean(alias) });
+    command.setAnalyticsPayload({
+        open: options.open,
+        prod: options.prod,
+        json: options.json,
+        alias: Boolean(alias),
+        remote: Boolean(options.remote),
+    });
     if (options.allowAnonymous) {
         const [token] = await getToken(options.auth);
         if (token) {
@@ -969,7 +982,19 @@ export const deploy = async (options, command) => {
     }
     const deployToProduction = !options.draft && (options.prod || (options.prodIfUnlocked && !(siteData.published_deploy?.locked ?? false)));
     let results = {};
-    if (options.build) {
+    let prodCommand = `netlify deploy${options.build ? '' : ' --no-build'} --prod`;
+    if (options.remote) {
+        results = await remoteDeploy({
+            api,
+            workingDir,
+            options,
+            siteData,
+            deployToProduction,
+            prepareProductionDeploy: () => prepareProductionDeploy({ siteData, api, options, command }),
+        });
+        prodCommand = 'netlify deploy --remote --prod';
+    }
+    else if (options.build) {
         const deployMetadata = await createDeploy({ alias, api, command, deployToProduction, options, siteData, siteId });
         const deployId = deployMetadata.id;
         const skewProtectionToken = deployMetadata.skew_protection_token;
@@ -1037,7 +1062,7 @@ export const deploy = async (options, command) => {
         });
     }
     printResults({
-        runBuildCommand: options.build,
+        prodCommand,
         json: options.json,
         results,
         deployToProduction,

package/dist/commands/deploy/index.js

@@ -4,15 +4,25 @@ import terminalLink from 'terminal-link';
 import { normalizeContext } from '../../utils/env/index.js';
 import { findDuplicateKey, mergeDeployEnvVars, parseDeployEnvVar } from '../../utils/env/deploy-env-vars.js';
 import { chalk, logAndThrowError, warn } from '../../utils/command-helpers.js';
+const BUILD_RELATED_OPTIONS = [
+    'build',
+    'context',
+    'dir',
+    'env',
+    'functions',
+    'secretEnv',
+    'skipFunctionsCache',
+    'uploadSourceZip',
+];
 export const createDeployCommand = (program) => program
     .command('deploy')
     .description(`Deploy your project to Netlify
 
-Builds and deploys your project to Netlify. Creates a draft deploy by default.
+Builds your project locally, or on Netlify with --remote, and deploys it to Netlify. Creates a draft deploy by default.
 Use --prod to deploy directly to your live site.
 
 The deploy command will:
-- Build your project (unless --no-build is specified)
+- Build your project locally (unless --no-build or --remote is specified)
 - Upload static files, functions, and edge functions
 - Process redirects and headers from netlify.toml or _redirects/_headers files
 - Provide deploy and function logs URLs
@@ -38,6 +48,7 @@ For detailed configuration options, see the Netlify documentation.`)
     .option('--json', 'Output deployment data as JSON')
     .option('--timeout <number>', 'Timeout to wait for deployment to finish', (value) => Number.parseInt(value))
     .addOption(new Option('--trigger', 'Trigger a new build of your project on Netlify without uploading local files').conflicts('build'))
+    .addOption(new Option('--remote', 'Build your project on Netlify instead of locally. Useful when building with native packages, on devices with limited resources or missing toolchains. Build logs stream in real time and are available on Netlify.').conflicts([...BUILD_RELATED_OPTIONS, 'alias', 'allowAnonymous', 'branch', 'createSite', 'siteName', 'trigger']))
     .addOption(new Option('--build', 'Do not use - this is now the default. Will be removed in future versions.')
     .default(true)
     .hideHelp(true))
@@ -66,6 +77,8 @@ For detailed configuration options, see the Netlify documentation.`)
     'netlify deploy --message "A message with an $ENV_VAR"',
     'netlify deploy --auth $NETLIFY_AUTH_TOKEN',
     'netlify deploy --trigger',
+    'netlify deploy --remote # Build on Netlify and deploy a draft',
+    'netlify deploy --remote --prod',
     'netlify deploy --context deploy-preview',
     'netlify deploy --env "NODE_ENV=production" --env "API_URL=https://api.example.com"',
     'netlify deploy --env "NODE_ENV=production" --secret-env "DATABASE_PASSWORD=$DB_PASSWORD"',

package/dist/commands/deploy/option_values.d.ts

@@ -17,6 +17,7 @@ export type DeployOptionValues = BaseOptionValues & {
     open: boolean;
     prod: boolean;
     prodIfUnlocked: boolean;
+    remote?: boolean;
     secretEnv?: DeployEnvironmentVariable[];
     site?: string;
     siteName?: string;

package/dist/commands/deploy/remote/follow.d.ts

@@ -0,0 +1,8 @@
+import type { NetlifyAPI } from '@netlify/api';
+export declare const followDeploy: (api: NetlifyAPI, { siteId, deployId, timeoutMs, onLogLine, }: {
+    siteId: string;
+    deployId: string;
+    timeoutMs: number;
+    onLogLine?: (line: string) => void;
+}) => Promise<import("../../../utils/deploy/util.js").ReadyDeploy>;
+//# sourceMappingURL=follow.d.ts.map

package/dist/commands/deploy/remote/follow.js

@@ -0,0 +1,17 @@
+import { streamDeploy } from '../../logs/sources/deploy.js';
+import { waitForDeploy } from '../../../utils/deploy/util.js';
+// The log stream is best-effort; the deploy's state decides success.
+export const followDeploy = async (api, { siteId, deployId, timeoutMs, onLogLine, }) => {
+    const stopStreaming = onLogLine
+        ? streamDeploy(siteId, deployId, api.accessToken, (entry) => {
+            onLogLine(entry.message);
+        }, () => undefined)
+        : undefined;
+    try {
+        return await waitForDeploy(api, deployId, siteId, timeoutMs);
+    }
+    finally {
+        stopStreaming?.();
+    }
+};
+//# sourceMappingURL=follow.js.map

package/dist/commands/deploy/remote/git.d.ts

@@ -0,0 +1,27 @@
+export interface GitCommand {
+    args: string[];
+    cwd: string;
+    exitCode: number;
+    stderr: string;
+}
+export type GitCommandObserver = (command: GitCommand) => void;
+export interface GitContext {
+    cwd: string;
+    onCommand?: GitCommandObserver;
+}
+interface Remote {
+    name: string;
+    url: string;
+}
+export declare const getRemotes: (ctx: GitContext) => Promise<Remote[]>;
+export declare const getHead: (ctx: GitContext) => Promise<string>;
+export declare const getGitVersion: (ctx: GitContext) => Promise<string>;
+export declare const getCurrentBranch: (ctx: GitContext) => Promise<string>;
+export declare const getUpstream: (ctx: GitContext) => Promise<string>;
+export declare const getWorkTreeStatus: (ctx: GitContext) => Promise<{
+    hasChanges: boolean;
+    untracked: string[];
+}>;
+export declare const getRemoteBranchesContaining: (ctx: GitContext, sha: string) => Promise<string[]>;
+export {};
+//# sourceMappingURL=git.d.ts.map

package/dist/commands/deploy/remote/git.js

@@ -0,0 +1,61 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import semver from 'semver';
+const execFileAsync = promisify(execFile);
+// `code` is the exit code once git ran, or a string like ENOENT when it couldn't start.
+const isFailedCommand = (error) => error instanceof Error && 'code' in error && typeof error.code === 'number';
+const run = async (ctx, args) => {
+    let result;
+    try {
+        // GIT_OPTIONAL_LOCKS keeps read-only commands like `git status` from refreshing the user's index.
+        const env = { ...process.env, GIT_OPTIONAL_LOCKS: '0' };
+        const { stdout, stderr } = await execFileAsync('git', args, { cwd: ctx.cwd, env });
+        result = { exitCode: 0, stdout, stderr };
+    }
+    catch (error) {
+        if (!isFailedCommand(error)) {
+            throw new Error(`Couldn't run git: ${String(error)}`, { cause: error });
+        }
+        result = { exitCode: error.code, stdout: error.stdout ?? '', stderr: error.stderr ?? '' };
+    }
+    ctx.onCommand?.({ args, cwd: ctx.cwd, exitCode: result.exitCode, stderr: result.stderr.trimEnd() });
+    return result;
+};
+const git = async (ctx, args) => {
+    const { exitCode, stdout, stderr } = await run(ctx, args);
+    if (exitCode !== 0) {
+        throw new Error(`git ${args[0]} failed: ${stderr.trimEnd() || stdout}`);
+    }
+    return stdout.trim();
+};
+const tryGit = async (ctx, args) => {
+    const { exitCode, stdout } = await run(ctx, args);
+    return exitCode === 0 ? stdout.trim() : '';
+};
+export const getRemotes = async (ctx) => {
+    const names = (await tryGit(ctx, ['remote'])).split('\n').filter(Boolean);
+    return Promise.all(names.map(async (name) => ({ name, url: await git(ctx, ['remote', 'get-url', name]) })));
+};
+export const getHead = (ctx) => tryGit(ctx, ['rev-parse', '--verify', 'HEAD']);
+export const getGitVersion = async (ctx) => {
+    const output = await tryGit(ctx, ['version']).catch(() => '');
+    return semver.coerce(output)?.version ?? '';
+};
+// Full ref names, since short ones become ambiguous when a local branch is named like a remote one
+// (e.g. `origin/main`).
+const stripRefPrefix = (ref, prefix) => (ref.startsWith(prefix) ? ref.slice(prefix.length) : '');
+export const getCurrentBranch = async (ctx) => stripRefPrefix(await tryGit(ctx, ['symbolic-ref', '--quiet', 'HEAD']), 'refs/heads/');
+export const getUpstream = async (ctx) => stripRefPrefix(await tryGit(ctx, ['rev-parse', '--symbolic-full-name', '@{upstream}']), 'refs/remotes/');
+export const getWorkTreeStatus = async (ctx) => {
+    const lines = (await git(ctx, ['status', '--porcelain', '--untracked-files=normal'])).split('\n').filter(Boolean);
+    return {
+        hasChanges: lines.some((line) => !line.startsWith('?? ')),
+        untracked: lines.filter((line) => line.startsWith('?? ')).map((line) => line.slice(3)),
+    };
+};
+const listRemoteBranches = async (ctx, filter) => {
+    const output = await tryGit(ctx, ['branch', '--remotes', ...filter, '--format=%(refname:lstrip=2)']);
+    return output.split('\n').filter((name) => name !== '' && !name.endsWith('/HEAD'));
+};
+export const getRemoteBranchesContaining = (ctx, sha) => listRemoteBranches(ctx, ['--contains', sha]);
+//# sourceMappingURL=git.js.map

package/dist/commands/deploy/remote/source.d.ts

@@ -0,0 +1,25 @@
+import type { SiteInfo } from '../../../utils/types.js';
+import { type GitCommandObserver } from './git.js';
+export type RemoteSource = {
+    kind: 'external';
+    repoUrl: string;
+    head: string;
+    branch: string;
+    untracked: string[];
+};
+export interface SourceCommit {
+    sha: string;
+    branch?: string;
+}
+/** A problem the user can fix, as opposed to an unexpected failure. */
+export declare class RemoteBuildError extends Error {
+    readonly name = "RemoteBuildError";
+}
+export declare const resolveRemoteSource: ({ siteInfo, workingDir, onCommand, production, }: {
+    siteInfo: SiteInfo;
+    workingDir: string;
+    onCommand?: GitCommandObserver;
+    production?: boolean;
+}) => Promise<RemoteSource>;
+export declare const prepareSourceCommit: (source: RemoteSource) => Promise<SourceCommit>;
+//# sourceMappingURL=source.d.ts.map

package/dist/commands/deploy/remote/source.js

@@ -0,0 +1,88 @@
+import semver from 'semver';
+import { isNetlifyGitUrl, isSameRepository } from '../../../utils/netlify-git.js';
+import { getCurrentBranch, getGitVersion, getHead, getRemotes, getUpstream, getRemoteBranchesContaining, getWorkTreeStatus, } from './git.js';
+/** A problem the user can fix, as opposed to an unexpected failure. */
+export class RemoteBuildError extends Error {
+    name = 'RemoteBuildError';
+}
+const describeGitProblem = (version) => {
+    if (!version) {
+        return "--remote uses git, which isn't installed or isn't on your PATH. Install git, then deploy again.";
+    }
+    // 2.13 added `git branch --format`.
+    if (semver.lt(version, '2.13.0')) {
+        return `--remote needs git 2.13 or later, but you have ${version}. Update git, then deploy again.`;
+    }
+    return undefined;
+};
+const inspectClone = async (ctx, repoUrl, productionBranch) => {
+    const head = await getHead(ctx);
+    if (!head) {
+        return {
+            pushed: false,
+            reason: `This directory isn't a clone of ${repoUrl}, which Netlify builds this project from. Run this from a clone of it.`,
+        };
+    }
+    // Another remote having the commit doesn't mean the provider can build it.
+    const providerRemotes = (await getRemotes(ctx))
+        .filter(({ url }) => isSameRepository(url, repoUrl))
+        .map(({ name }) => name);
+    if (providerRemotes.length === 0) {
+        return {
+            pushed: false,
+            reason: `This repository has no remote for ${repoUrl}, which Netlify builds this project from. Run this from a clone of it, or add a remote for it.`,
+        };
+    }
+    const { hasChanges, untracked } = await getWorkTreeStatus(ctx);
+    if (hasChanges) {
+        return {
+            pushed: false,
+            reason: `You have uncommitted changes. Netlify builds this project from ${repoUrl}, so commit them and push them to ${productionBranch} or another branch, then deploy again.`,
+        };
+    }
+    const remoteOf = (ref) => providerRemotes.find((remote) => ref.startsWith(`${remote}/`));
+    const pushedTo = (await getRemoteBranchesContaining(ctx, head)).filter((ref) => remoteOf(ref) !== undefined);
+    if (pushedTo.length === 0) {
+        return {
+            pushed: false,
+            reason: `Your checked-out commit isn't on ${repoUrl} as of your last fetch. Push it to ${productionBranch} or another branch (or fetch, if you already pushed it), then deploy again.`,
+        };
+    }
+    // Only a branch the user evidently pushed this commit to, never a guess among other branches that
+    // happen to contain it.
+    const currentBranch = await getCurrentBranch(ctx);
+    const candidates = [
+        await getUpstream(ctx),
+        ...(currentBranch ? providerRemotes.map((remote) => `${remote}/${currentBranch}`) : []),
+    ];
+    const ref = candidates.find((candidate) => pushedTo.includes(candidate));
+    return { pushed: true, head, branch: ref?.slice((remoteOf(ref) ?? '').length + 1), untracked };
+};
+export const resolveRemoteSource = async ({ siteInfo, workingDir, onCommand, production = false, }) => {
+    const settings = siteInfo.build_settings;
+    if (!settings?.repo_url) {
+        throw new RemoteBuildError("This project isn't connected to a git repository, so Netlify can't build it. Connect one in the project's build settings, or run netlify deploy without --remote to build locally instead.");
+    }
+    const productionBranch = settings.repo_branch;
+    const ctx = { cwd: workingDir, onCommand };
+    if (settings.provider !== 'netlify-git' && !isNetlifyGitUrl(settings.repo_url)) {
+        const gitProblem = describeGitProblem(await getGitVersion(ctx));
+        if (gitProblem) {
+            throw new RemoteBuildError(gitProblem);
+        }
+        const repoUrl = settings.repo_url;
+        const clone = await inspectClone(ctx, repoUrl, productionBranch);
+        if (clone.pushed) {
+            // Any pushed commit can go to production: the build fetches it by SHA, not from the branch.
+            const branch = production ? productionBranch : clone.branch;
+            if (!branch) {
+                throw new RemoteBuildError(`Couldn't tell which branch to build ${clone.head.slice(0, 7)} as: it isn't on your checked-out branch's upstream or a branch of the same name on ${repoUrl}. Check out the branch you pushed it to, then deploy again.`);
+            }
+            return { kind: 'external', repoUrl, head: clone.head, branch, untracked: clone.untracked };
+        }
+        throw new RemoteBuildError(clone.reason);
+    }
+    throw new RemoteBuildError("Remote builds aren't supported yet for projects on Netlify Git. Run netlify deploy without --remote to build locally instead.");
+};
+export const prepareSourceCommit = (source) => Promise.resolve({ sha: source.head, branch: source.branch });
+//# sourceMappingURL=source.js.map

package/dist/commands/deploy/remote-deploy.d.ts

@@ -0,0 +1,19 @@
+import type { NetlifyAPI } from '@netlify/api';
+import { type DeployUrls } from '../../utils/deploy/deploy-urls.js';
+import type { SiteInfo } from '../../utils/types.js';
+import type { DeployOptionValues } from './option_values.js';
+export interface RemoteDeployResults extends DeployUrls {
+    siteId: string;
+    siteName: string;
+    deployId: string;
+    commitSha: string;
+}
+export declare const remoteDeploy: ({ api, workingDir, options, siteData, deployToProduction, prepareProductionDeploy, }: {
+    api: NetlifyAPI;
+    workingDir: string;
+    options: DeployOptionValues;
+    siteData: SiteInfo;
+    deployToProduction: boolean;
+    prepareProductionDeploy: () => Promise<void>;
+}) => Promise<RemoteDeployResults>;
+//# sourceMappingURL=remote-deploy.d.ts.map

package/dist/commands/deploy/remote-deploy.js

@@ -0,0 +1,126 @@
+import { confirm } from '@inquirer/prompts';
+import { TimeoutError } from 'p-wait-for';
+import terminalLink from 'terminal-link';
+import { startSpinner } from '../../lib/spinner.js';
+import { chalk, exit, log, logAndThrowError, NETLIFYDEVLOG, warn } from '../../utils/command-helpers.js';
+import { DEFAULT_DEPLOY_TIMEOUT } from '../../utils/deploy/constants.js';
+import { getDeploySource } from '../../utils/deploy/deploy-source.js';
+import { getDeployUrls } from '../../utils/deploy/deploy-urls.js';
+import { prepareSourceCommit, RemoteBuildError, resolveRemoteSource, } from './remote/source.js';
+import { followDeploy } from './remote/follow.js';
+import { DeployStateError } from '../../utils/deploy/util.js';
+import { isInteractive } from '../../utils/scripted-commands.js';
+const describeSource = (source) => `Checking your commit is on ${source.repoUrl}`;
+const describeMode = (source) => `external (${source.repoUrl}), nothing is pushed`;
+const describeUntracked = (files, sha, repoUrl) => {
+    const shown = files.slice(0, 5).join(', ');
+    const more = files.length > 5 ? ` and ${String(files.length - 5)} more` : '';
+    return `${String(files.length)} untracked ${files.length === 1 ? 'file' : 'files'} won't be in this deploy, since Netlify builds ${sha} from ${repoUrl}: ${shown}${more}`;
+};
+const logGitCommand = (debugLog) => ({ args, cwd, exitCode, stderr }) => {
+    debugLog(`git ${args.join(' ')} (in ${cwd}) exited ${String(exitCode)}`);
+    if (exitCode !== 0 && stderr) {
+        debugLog(stderr);
+    }
+};
+export const remoteDeploy = async ({ api, workingDir, options, siteData, deployToProduction, prepareProductionDeploy, }) => {
+    const quiet = Boolean(options.json || options.silent);
+    const siteId = siteData.id;
+    const timeoutMs = options.timeout ? options.timeout * 1000 : DEFAULT_DEPLOY_TIMEOUT;
+    const debugLog = options.debug
+        ? (message) => {
+            log(`${NETLIFYDEVLOG} ${chalk.dim(message)}`);
+        }
+        : undefined;
+    const onCommand = debugLog && logGitCommand(debugLog);
+    let source;
+    let commit;
+    // Debug output would interleave with the spinner's redraws.
+    const spinner = debugLog ? undefined : startSpinner({ text: 'Preparing your source for a remote build' });
+    try {
+        const { provider, repo_url: repoUrl, repo_branch: productionBranch } = siteData.build_settings ?? {};
+        debugLog?.(`Project repository: ${repoUrl ?? '(none)'} (${provider ?? 'no provider'}), production branch ${productionBranch ?? '(none)'}`);
+        source = await resolveRemoteSource({
+            siteInfo: siteData,
+            workingDir,
+            onCommand,
+            production: deployToProduction,
+        });
+        debugLog?.(`Mode: ${describeMode(source)}`);
+        spinner?.update({ text: describeSource(source) });
+        commit = await prepareSourceCommit(source);
+    }
+    catch (error) {
+        spinner?.error();
+        if (error instanceof RemoteBuildError) {
+            return logAndThrowError(error.message);
+        }
+        throw error;
+    }
+    const shortSha = commit.sha.slice(0, 7);
+    const foundText = `Found ${shortSha} on ${source.repoUrl}`;
+    if (spinner) {
+        spinner.success({ text: foundText });
+    }
+    else {
+        log(`${chalk.green('✔')} ${foundText}`);
+    }
+    if (source.untracked.length !== 0) {
+        warn(describeUntracked(source.untracked, shortSha, source.repoUrl));
+        if (isInteractive() && !quiet && !(await confirm({ message: 'Deploy anyway?', default: true }))) {
+            exit(0);
+        }
+    }
+    // After the checks above, so we never unlock production and then bail.
+    if (deployToProduction) {
+        await prepareProductionDeploy();
+    }
+    debugLog?.(`Requesting a ${deployToProduction ? 'production' : 'draft'} build of ${commit.sha} on branch ${commit.branch ?? '(none)'}`);
+    let build;
+    try {
+        build = (await api.createSiteBuild({
+            siteId,
+            branch: commit.branch,
+            title: options.message,
+            // @ts-expect-error FIXME(@netlify/api): `createSiteBuild` doesn't declare `commit_sha`, `draft` or `deploy_source`; the client drops undeclared query params, so they go in the body
+            body: { commit_sha: commit.sha, draft: !deployToProduction, deploy_source: getDeploySource() },
+        }));
+    }
+    catch (error) {
+        const { json, message } = error;
+        return logAndThrowError(`Couldn't start a build of ${commit.sha}: ${json?.message ?? json?.error ?? message}`);
+    }
+    debugLog?.(`Build ${build.id}, deploy ${build.deploy_id}`);
+    const { logsUrl } = getDeployUrls({ id: build.deploy_id, admin_url: siteData.admin_url }, { deployToProduction });
+    log(`${NETLIFYDEVLOG} Building ${shortSha} on Netlify (${terminalLink('↗ View deploy logs', logsUrl)})`);
+    log('');
+    try {
+        const deploy = await followDeploy(api, {
+            siteId,
+            deployId: build.deploy_id,
+            timeoutMs,
+            onLogLine: quiet
+                ? undefined
+                : (line) => {
+                    log(`${chalk.dim('│')} ${line.trimEnd()}`);
+                },
+        });
+        return {
+            siteId,
+            siteName: siteData.name,
+            deployId: build.deploy_id,
+            commitSha: commit.sha,
+            ...getDeployUrls(deploy, { deployToProduction }),
+        };
+    }
+    catch (error) {
+        if (error instanceof DeployStateError) {
+            return logAndThrowError(`Deploy failed: ${error.message}\n\nDeploy logs: ${logsUrl}`);
+        }
+        if (error instanceof TimeoutError) {
+            return logAndThrowError(`Timed out after ${String(timeoutMs / 1000)} seconds waiting for the deploy to finish. It may still be running on Netlify; to wait longer, pass a larger --timeout.\n\nDeploy logs: ${logsUrl}`);
+        }
+        return logAndThrowError(`${error.message}\n\nThe build may still be running on Netlify. Deploy logs: ${logsUrl}`);
+    }
+};
+//# sourceMappingURL=remote-deploy.js.map

package/dist/commands/logs/index.js

@@ -78,14 +78,15 @@ export const createLogsCommand = (program) => {
         'functions',
         'edge-functions',
         'deploy',
+        'server',
     ]))
         .addOption(new Option('--function <name...>', 'Filter to specific functions by name'))
         .addOption(new Option('--edge-function <name...>', 'Filter to specific edge functions by name or path'))
         .addOption(new Option('--since <time>', 'Start of the historical log window. Accepts a duration (e.g. 10m, 1h, 24h) or an ISO 8601 timestamp. Defaults to 10m'))
         .addOption(new Option('--until <time>', 'End of the historical log window. Accepts a duration or an ISO 8601 timestamp (defaults to now)'))
         .addOption(new Option('-f, --follow', 'Stream logs in real time instead of showing historical logs'))
-        .addOption(new Option('-u, --url <url>', 'Show logs for the deploy behind the given URL. Supports deploy permalinks and branch subdomains. Can be used with all sources.'))
-        .addOption(new Option('-d, --deploy-id <deploy-id>', 'Show logs for a specific deploy by ID, including failed builds. Can be used with all sources.'))
+        .addOption(new Option('-u, --url <url>', 'Show logs for the deploy behind the given URL. Supports deploy permalinks and branch subdomains. Can be used with all sources except server.'))
+        .addOption(new Option('-d, --deploy-id <deploy-id>', 'Show logs for a specific deploy by ID, including failed builds. Can be used with all sources except server.'))
         .addOption(new Option('-l, --level <levels...>', `Log levels to include. Choices are:${CLI_LOG_LEVEL_CHOICES_STRING}`))
         .addOption(new Option('--json', 'Output logs as JSON Lines'))
         .addExamples([
@@ -96,6 +97,8 @@ export const createLogsCommand = (program) => {
         'netlify logs --source functions --function checkout --since 24h',
         'netlify logs --source edge-functions --since 30m',
         'netlify logs --source deploy --source functions --since 1h',
+        'netlify logs --source server --since 30m',
+        'netlify logs --follow --source server',
         'netlify logs --follow',
         'netlify logs --follow --source functions --source edge-functions',
         'netlify logs --json --since 1h',

package/dist/commands/logs/log-api.d.ts

@@ -4,7 +4,7 @@ export declare const DEPLOY_ID_RE: RegExp;
 export declare const SOURCE_INDICATORS: Record<LogEntry['source'], string>;
 export declare const SOURCE_LABELS: Record<LogEntry['source'], string>;
 export interface LogEntry {
-    source: 'function' | 'edge-function' | 'deploy';
+    source: 'function' | 'edge-function' | 'deploy' | 'server';
     name: string;
     ts: number;
     level: string;

package/dist/commands/logs/log-api.js

@@ -7,11 +7,13 @@ export const SOURCE_INDICATORS = {
     function: '𝒇',
     'edge-function': '🌐',
     deploy: '🚀',
+    server: '🖥️',
 };
 export const SOURCE_LABELS = {
     function: 'Function',
     'edge-function': 'Edge function',
     deploy: 'Deploy',
+    server: 'Server',
 };
 const DURATION_LIKE_RE = /^\d+(\.\d+)?\s*[a-z]/i;
 export const parseTimeValue = (input, now = Date.now()) => {

package/dist/commands/logs/logs.d.ts

@@ -1,7 +1,7 @@
 import type { NetlifyAPI } from '@netlify/api';
 import type BaseCommand from '../base-command.js';
 import type { LogsOptionValues } from './option_values.js';
-type Source = 'functions' | 'edge-functions' | 'deploy';
+type Source = 'functions' | 'edge-functions' | 'deploy' | 'server';
 export declare const logsCommand: (options: LogsOptionValues, command: BaseCommand) => Promise<undefined>;
 export declare const runFollowMode: ({ sources, client, siteId, accessToken, deployId, deployTargeted, functionNames, edgeFunctionNames, levelsToPrint, json, }: {
     sources: Source[];

package/dist/commands/logs/logs.js

@@ -1,10 +1,11 @@
-import { chalk, log, logAndThrowError, netlifyCommand } from '../../utils/command-helpers.js';
+import { chalk, log, logAndThrowError, logError, netlifyCommand, warn } from '../../utils/command-helpers.js';
 import { createColorAssigner, DEPLOY_ID_RE, formatJsonLine, formatLogLine, parseTimeValue, resolveDeployIdFromUrl, SOURCE_INDICATORS, SOURCE_LABELS, } from './log-api.js';
 import { LOG_LEVELS_LIST, CLI_LOG_LEVEL_CHOICES_STRING } from './log-levels.js';
 import { fetchDeployHistoricalLogs, findCurrentBuildingDeploy, findLatestFinishedDeploy, findLatestReadyDeploy, isDeployFinished, streamDeploy, } from './sources/deploy.js';
 import { fetchEdgeFunctionHistoricalLogs, streamEdgeFunctions } from './sources/edge-functions.js';
 import { fetchFunctionHistoricalLogs, listFunctions, selectFunctions, streamFunctions, validateFunctionCount, } from './sources/functions.js';
-const VALID_SOURCES = ['functions', 'edge-functions', 'deploy'];
+import { fetchServerHistoricalLogs, streamServer } from './sources/server.js';
+const VALID_SOURCES = ['functions', 'edge-functions', 'deploy', 'server'];
 const DEFAULT_SINCE = '10m';
 const DEPLOY_STREAM_IDLE_CLOSE_MS = 3_000;
 const parseSources = (rawSources) => {
@@ -23,6 +24,7 @@ const SOURCE_TO_ENTRY_SOURCE = {
     functions: 'function',
     'edge-functions': 'edge-function',
     deploy: 'deploy',
+    server: 'server',
 };
 const humanizeTimeRange = (sinceValue, untilValue) => {
     if (!sinceValue && !untilValue) {
@@ -45,6 +47,8 @@ const printHeader = (sources, timeDescription, isFollow) => {
                 return 'edge functions';
             case 'deploy':
                 return 'deploy';
+            case 'server':
+                return 'server';
         }
     });
     const sourceList = sourceNames.length <= 2
@@ -122,6 +126,9 @@ export const logsCommand = async (options, command) => {
             sources = ['functions', 'edge-functions'];
         }
     }
+    if (sources.includes('server') && (options.deployId || options.url)) {
+        return logAndThrowError('Server logs cannot be filtered by deploy. Remove --deploy-id and --url, or the server source.');
+    }
     let deployId;
     let deployTargeted = false;
     if (options.deployId) {
@@ -265,6 +272,19 @@ const runHistoricalMode = async ({ sources, client, siteId, accessToken, deployI
         });
         allEntries.push(...entries);
     }
+    let serverLogsTruncated = false;
+    if (sources.includes('server')) {
+        const { entries, truncated } = await fetchServerHistoricalLogs({
+            apiBase: client.basePath,
+            siteId,
+            accessToken,
+            from,
+            to,
+            levels: levelsToPrint,
+        });
+        allEntries.push(...entries);
+        serverLogsTruncated = truncated;
+    }
     allEntries.sort((a, b) => a.ts - b.ts);
     if (allEntries.length === 0) {
         log('No logs found for the given time range.');
@@ -278,6 +298,15 @@ const runHistoricalMode = async ({ sources, client, siteId, accessToken, deployI
         const key = `${entry.source}:${entry.name}`;
         printEntry(entry, levelsToPrint, json, assignColor(key));
     }
+    if (serverLogsTruncated) {
+        const message = 'Only the most recent server logs are shown. Narrow --since/--until to see older ones.';
+        if (json) {
+            process.stderr.write(`Warning: ${message}\n`);
+        }
+        else {
+            warn(message);
+        }
+    }
 };
 export const runFollowMode = async ({ sources, client, siteId, accessToken, deployId, deployTargeted, functionNames, edgeFunctionNames, levelsToPrint, json, }) => {
     const assignColor = createColorAssigner();
@@ -316,5 +345,15 @@ export const runFollowMode = async ({ sources, client, siteId, accessToken, depl
     if (sources.includes('edge-functions') && deployId) {
         streamEdgeFunctions(siteId, deployId, accessToken, edgeFunctionNames, onEntry);
     }
+    if (sources.includes('server')) {
+        streamServer({
+            apiBase: client.basePath,
+            siteId,
+            accessToken,
+            levels: levelsToPrint,
+            onEntry,
+            onError: logError,
+        });
+    }
 };
 //# sourceMappingURL=logs.js.map

package/dist/commands/logs/sources/server.d.ts

@@ -0,0 +1,22 @@
+import type { LogEntry } from '../log-api.js';
+export declare const fetchServerHistoricalLogs: (options: {
+    apiBase: string;
+    siteId: string;
+    accessToken: string | null | undefined;
+    from: number;
+    to: number;
+    levels?: string[];
+}) => Promise<{
+    entries: LogEntry[];
+    truncated: boolean;
+}>;
+export declare const streamServer: ({ apiBase, siteId, accessToken, levels, onEntry, onError, intervalMs, }: {
+    apiBase: string;
+    siteId: string;
+    accessToken: string | null | undefined;
+    levels?: string[];
+    onEntry: (entry: LogEntry) => void;
+    onError?: (error: Error) => void;
+    intervalMs?: number;
+}) => (() => void);
+//# sourceMappingURL=server.d.ts.map

package/dist/commands/logs/sources/server.js

@@ -0,0 +1,141 @@
+import { debugFetch } from '../log-api.js';
+// The API serves up to 500 lines a page and stops paging 10,000 lines back.
+const PER_PAGE = 500;
+const MAX_PAGES = 1 + 10_000 / PER_PAGE;
+// Lines are stored a few seconds after their time, so each poll looks back
+// this far and drops what the previous poll already returned.
+const LOOK_BACK_MS = 10_000;
+const POLL_INTERVAL_MS = 2_000;
+// Retrying cannot change these answers, so following stops on them.
+const PERMANENT_FAILURE_STATUSES = new Set([401, 403, 404]);
+// The API filters by at most one severity, and only these, though lines can
+// carry other levels too.
+const FILTERABLE_SEVERITIES = new Set(['error', 'warn', 'info']);
+const severityFor = (levels) => levels?.length === 1 && FILTERABLE_SEVERITIES.has(levels[0]) ? levels[0] : undefined;
+class ServerLogsRequestError extends Error {
+    status;
+    constructor(status, statusText) {
+        super(`Failed to fetch server logs: ${status.toString()} ${statusText}`);
+        this.status = status;
+    }
+}
+const lineKey = (line) => `${line.timestamp.toString()}|${line.actor_id}|${line.severity}|${line.body}`;
+const countKeys = (lines) => {
+    const counts = new Map();
+    for (const line of lines) {
+        const key = lineKey(line);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+};
+const toEntry = (line) => ({
+    source: 'server',
+    // The dashboard shows instances by the first 8 characters of their ID too.
+    name: line.actor_id ? line.actor_id.slice(0, 8) : 'server',
+    ts: line.timestamp,
+    level: line.severity ? line.severity.toUpperCase() : 'INFO',
+    message: line.body,
+});
+const fetchServerLogLines = async ({ apiBase, siteId, accessToken, from, to, levels, }) => {
+    // The API pages newest first and sends millisecond timestamps, though it
+    // orders by finer ones, so reversing is what keeps same-millisecond lines in order.
+    const lines = [];
+    const severity = severityFor(levels);
+    for (let page = 1; page <= MAX_PAGES; page++) {
+        const url = new URL(`${apiBase}/sites/${encodeURIComponent(siteId)}/observability/server/logs`);
+        url.searchParams.set('from_ts', String(from));
+        url.searchParams.set('to_ts', String(to));
+        url.searchParams.set('page', String(page));
+        url.searchParams.set('per_page', String(PER_PAGE));
+        if (severity) {
+            url.searchParams.set('severity', severity);
+        }
+        const response = await debugFetch(url.toString(), {
+            headers: {
+                Authorization: `Bearer ${accessToken ?? ''}`,
+            },
+        });
+        if (!response.ok) {
+            throw new ServerLogsRequestError(response.status, response.statusText);
+        }
+        const body = (await response.json());
+        lines.push(...(body.logs ?? []));
+        if (!body.has_next_page) {
+            return { lines: lines.reverse(), truncated: false };
+        }
+    }
+    return { lines: lines.reverse(), truncated: true };
+};
+export const fetchServerHistoricalLogs = async (options) => {
+    const { lines, truncated } = await fetchServerLogLines(options);
+    return { entries: lines.map(toEntry), truncated };
+};
+export const streamServer = ({ apiBase, siteId, accessToken, levels, onEntry, onError, intervalMs = POLL_INTERVAL_MS, }) => {
+    let newest = Date.now();
+    let seen = new Map();
+    let failing = false;
+    let truncating = false;
+    let stopped = false;
+    let timer;
+    const poll = async () => {
+        try {
+            const { lines, truncated } = await fetchServerLogLines({
+                apiBase,
+                siteId,
+                accessToken,
+                levels,
+                from: newest - LOOK_BACK_MS,
+                to: Date.now(),
+            });
+            if (stopped) {
+                return;
+            }
+            // Lines carry no ID, so identical ones are told apart by how many of them
+            // the previous poll returned.
+            const unclaimed = new Map(seen);
+            const fresh = lines
+                .filter((line) => {
+                const key = lineKey(line);
+                const count = unclaimed.get(key) ?? 0;
+                unclaimed.set(key, count - 1);
+                return count <= 0;
+            })
+                .sort((a, b) => a.timestamp - b.timestamp);
+            for (const line of fresh) {
+                onEntry(toEntry(line));
+            }
+            // The API pages newest first, so a truncated window loses its oldest lines for good.
+            if (truncated && !truncating) {
+                onError?.(new Error('Server logs are arriving faster than they can be shown, so some lines were skipped.'));
+            }
+            truncating = truncated;
+            // The next window starts inside this one, so only these lines can repeat.
+            seen = countKeys(lines);
+            newest = fresh.reduce((max, line) => Math.max(max, line.timestamp), newest);
+            failing = false;
+        }
+        catch (error) {
+            const failure = error instanceof Error ? error : new Error(String(error));
+            if (error instanceof ServerLogsRequestError && PERMANENT_FAILURE_STATUSES.has(error.status)) {
+                stopped = true;
+                onError?.(failure);
+                return;
+            }
+            // The next poll's window still covers what this one missed, so a run of
+            // failures is reported once.
+            if (!failing) {
+                failing = true;
+                onError?.(failure);
+            }
+        }
+        if (!stopped) {
+            timer = setTimeout(() => void poll(), intervalMs);
+        }
+    };
+    void poll();
+    return () => {
+        stopped = true;
+        clearTimeout(timer);
+    };
+};
+//# sourceMappingURL=server.js.map

package/dist/lib/edge-functions/proxy.js

@@ -125,7 +125,7 @@ const prepareServer = async ({ aiGatewayContext, command, config, configPath, de
             debug,
             distImportMapPath: join(projectDir, distImportMapPath),
             featureFlags,
-            formatExportTypeError: (name) => `${NETLIFYDEVERR} ${chalk.red('Failed')} to load Edge Function ${chalk.yellow(name)}. The file does not seem to have a function as the default export.`,
+            formatExportTypeError: (name) => `${NETLIFYDEVERR} ${chalk.red('Failed')} to load Edge Function ${chalk.yellow(name)}. The file does not seem to have a function, or an object with a \`fetch\` method, as the default export.`,
             formatImportError: (name) => `${NETLIFYDEVERR} ${chalk.red('Failed')} to run Edge Function ${chalk.yellow(name)}:`,
             inspectSettings,
             port,

package/dist/utils/create-stream-promise.d.ts

@@ -1,5 +1,11 @@
 import { Buffer } from 'buffer';
 import type { Readable } from 'stream';
+export declare class StreamBodyTooBigError extends Error {
+    constructor();
+}
+export declare class StreamTimeoutError extends Error {
+    constructor();
+}
 declare const createStreamPromise: (stream: Readable, timeoutSeconds: number, bytesLimit?: number) => Promise<Buffer>;
 export default createStreamPromise;
 //# sourceMappingURL=create-stream-promise.d.ts.map

package/dist/utils/create-stream-promise.js

@@ -2,6 +2,18 @@ import { Buffer } from 'buffer';
 const SEC_TO_MILLISEC = 1e3;
 // 6 MiB
 const DEFAULT_BYTES_LIMIT = 6e6;
+export class StreamBodyTooBigError extends Error {
+    constructor() {
+        super('Stream body too big');
+        this.name = 'StreamBodyTooBigError';
+    }
+}
+export class StreamTimeoutError extends Error {
+    constructor() {
+        super('Request timed out waiting for body');
+        this.name = 'StreamTimeoutError';
+    }
+}
 const createStreamPromise = function (stream, timeoutSeconds, bytesLimit = DEFAULT_BYTES_LIMIT) {
     return new Promise(function streamPromiseFunc(resolve, reject) {
         let data = [];
@@ -10,7 +22,7 @@ const createStreamPromise = function (stream, timeoutSeconds, bytesLimit = DEFAU
         if (timeoutSeconds != null && Number.isFinite(timeoutSeconds)) {
             timeoutId = setTimeout(() => {
                 data = null;
-                reject(new Error('Request timed out waiting for body'));
+                reject(new StreamTimeoutError());
             }, timeoutSeconds * SEC_TO_MILLISEC);
         }
         stream.on('data', function onData(chunk) {
@@ -21,7 +33,7 @@ const createStreamPromise = function (stream, timeoutSeconds, bytesLimit = DEFAU
             dataLength += chunk.length;
             if (dataLength > bytesLimit) {
                 data = null;
-                reject(new Error('Stream body too big'));
+                reject(new StreamBodyTooBigError());
             }
             else {
                 data.push(chunk);

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

@@ -3,5 +3,6 @@ export interface DeploySourceFields {
     agent_runner_id?: string;
     agent_runner_session_id?: string;
 }
+export declare const getDeploySource: () => string;
 export declare const getDeploySourceFields: () => DeploySourceFields;
 //# sourceMappingURL=deploy-source.d.ts.map

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

@@ -1,8 +1,9 @@
+export const getDeploySource = () => process.env.NETLIFY_DEPLOY_SOURCE || 'cli';
 export const getDeploySourceFields = () => {
     const agentRunnerId = process.env.NETLIFY_AGENT_RUNNER_ID;
     const agentRunnerSessionId = process.env.NETLIFY_AGENT_RUNNER_SESSION_ID;
     return {
-        deploy_source: process.env.NETLIFY_DEPLOY_SOURCE || 'cli',
+        deploy_source: getDeploySource(),
         ...(agentRunnerId ? { agent_runner_id: agentRunnerId } : {}),
         ...(agentRunnerSessionId ? { agent_runner_session_id: agentRunnerSessionId } : {}),
     };

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

@@ -9,6 +9,7 @@ interface ServerPayload {
     routes?: ServerResult['routes'];
     excluded_routes?: ServerResult['excludedRoutes'];
     runtime_version?: ServerResult['runtimeVersion'];
+    scale?: ServerResult['scale'];
 }
 type HashedFunctionFile = FunctionUploadFile & {
     hash: string;

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

@@ -205,7 +205,7 @@ const hashServer = async (serverBundle, { concurrentHash, hashAlgorithm, statusC
         hasherCtor({ concurrentHash, hashAlgorithm }),
         manifestCollectorCtor(servers, serverShaMap, { statusCb }),
     ]);
-    const { excludedRoutes, instanceSize, region, routes, runtimeVersion } = serverBundle;
+    const { excludedRoutes, instanceSize, region, routes, runtimeVersion, scale } = serverBundle;
     const server = {
         sha: Object.values(servers)[0],
         ...(region === undefined ? {} : { region }),
@@ -213,6 +213,7 @@ const hashServer = async (serverBundle, { concurrentHash, hashAlgorithm, statusC
         ...(routes === undefined ? {} : { routes }),
         ...(excludedRoutes === undefined ? {} : { excluded_routes: excludedRoutes }),
         ...(runtimeVersion === undefined ? {} : { runtime_version: runtimeVersion }),
+        ...(scale === undefined ? {} : { scale }),
     };
     return { server, serverShaMap };
 };

package/dist/utils/netlify-git.d.ts

@@ -1,3 +1,4 @@
 export declare const NETLIFY_GIT_HOST = "git.netlify.com";
 export declare const isNetlifyGitUrl: (repoUrl: string) => boolean;
+export declare const isSameRepository: (a: string, b: string) => boolean;
 //# sourceMappingURL=netlify-git.d.ts.map

package/dist/utils/netlify-git.js

@@ -9,4 +9,31 @@ export const isNetlifyGitUrl = (repoUrl) => {
         return false;
     }
 };
+// Reduces `https://host/owner/repo.git`, `ssh://git@host/owner/repo` and `git@host:owner/repo.git` to
+// `host/owner/repo`, ignoring credentials, case and a trailing `.git`. Local paths have no host.
+const getRepositoryKey = (repoUrl) => {
+    const parse = () => {
+        if (repoUrl.startsWith('/')) {
+            return { host: '', path: repoUrl };
+        }
+        const scpLike = /^(?:[^@/]+@)?([^:/]+):(?!\/\/)(.+)$/.exec(repoUrl);
+        if (scpLike) {
+            return { host: scpLike[1], path: scpLike[2] };
+        }
+        try {
+            const { hostname, pathname } = new URL(repoUrl);
+            return { host: hostname, path: pathname };
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const parsed = parse();
+    const path = parsed?.path.replace(/^\/+|\/+$/g, '').replace(/\.git$/, '');
+    return parsed && path ? `${parsed.host}/${path}`.toLowerCase() : undefined;
+};
+export const isSameRepository = (a, b) => {
+    const keyA = getRepositoryKey(a);
+    return keyA !== undefined && keyA === getRepositoryKey(b);
+};
 //# sourceMappingURL=netlify-git.js.map

package/dist/utils/proxy.js

@@ -28,8 +28,8 @@ import { fileExistsAsync, isFileAsync } from '../lib/fs.js';
 import { getFormHandler } from '../lib/functions/form-submissions-handler.js';
 import { DEFAULT_FUNCTION_URL_EXPRESSION } from '../lib/functions/registry.js';
 import { initializeProxy as initializeImageProxy, isImageRequest } from '../lib/images/proxy.js';
-import { NETLIFYDEVLOG, NETLIFYDEVWARN, chalk, log, logError, warn, } from './command-helpers.js';
-import createStreamPromise from './create-stream-promise.js';
+import { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN, chalk, log, logError, warn, } from './command-helpers.js';
+import createStreamPromise, { StreamBodyTooBigError, StreamTimeoutError } from './create-stream-promise.js';
 import { NFFunctionName, NFFunctionRoute, NFRequestID, headersForPath, parseHeaders } from './headers.js';
 import { generateRequestID } from './request-id.js';
 import { createRewriter, onChanges } from './rules-proxy.js';
@@ -350,6 +350,13 @@ const initializeProxy = async function ({ config, configPath, distDir, env, host
                 return;
             }
         }
+        if (res instanceof http.ServerResponse && res.headersSent) {
+            if (!res.writableEnded) {
+                log(NETLIFYDEVWARN, `Could not finish proxying ${req.url ?? ''}: ${err.message}`);
+                res.destroy();
+            }
+            return;
+        }
         if (res instanceof http.ServerResponse) {
             res.writeHead(500, {
                 'Content-Type': 'text/plain',
@@ -547,9 +554,27 @@ const initializeProxy = async function ({ config, configPath, distDir, env, host
     };
     return handlers;
 };
+const rejectRequestBody = (req, res, error) => {
+    if (!(error instanceof StreamBodyTooBigError || error instanceof StreamTimeoutError)) {
+        res.destroy();
+        return;
+    }
+    const status = error instanceof StreamBodyTooBigError ? 413 : 408;
+    log(NETLIFYDEVWARN, `Responded to ${req.method ?? ''} ${req.url ?? ''} with ${status.toString()}: ${error.message}`);
+    res.writeHead(status);
+    res.end(http.STATUS_CODES[status]);
+};
 const onRequest = async ({ api, edgeFunctionsProxy, env, functionsRegistry, functionsServer, imageProxy, proxy, rewriter, serverHandler, settings, siteInfo, }, req, res) => {
-    req.originalBody =
-        req.method && ['GET', 'OPTIONS', 'HEAD'].includes(req.method) ? null : await createStreamPromise(req, BYTES_LIMIT);
+    try {
+        req.originalBody =
+            req.method && ['GET', 'OPTIONS', 'HEAD'].includes(req.method)
+                ? null
+                : await createStreamPromise(req, REQUEST_BODY_TIMEOUT_SECONDS);
+    }
+    catch (error) {
+        rejectRequestBody(req, res, error);
+        return;
+    }
     if (isImageRequest(req)) {
         return imageProxy(req, res);
     }
@@ -740,7 +765,7 @@ export const startProxy = async function ({ accountId, aiGatewayContext, api, bl
         jwtRoleClaim: settings.jwtRolePath,
         projectDir,
     });
-    const onRequestWithOptions = onRequest.bind(undefined, {
+    const requestOptions = {
         proxy,
         rewriter,
         serverHandler,
@@ -752,7 +777,19 @@ export const startProxy = async function ({ accountId, aiGatewayContext, api, bl
         siteInfo,
         env,
         api,
-    });
+    };
+    const onRequestWithOptions = (req, res) => {
+        onRequest(requestOptions, req, res).catch((error) => {
+            console.error(NETLIFYDEVERR, 'Failed to handle request to', req.url, error);
+            if (res.headersSent) {
+                res.destroy();
+            }
+            else {
+                res.writeHead(500);
+                res.end('Could not proxy request.');
+            }
+        });
+    };
     const primaryServer = settings.https
         ? https.createServer({ cert: settings.https.cert, key: settings.https.key }, onRequestWithOptions)
         : http.createServer(onRequestWithOptions);
@@ -797,5 +834,5 @@ export const startProxy = async function ({ accountId, aiGatewayContext, api, bl
     await Promise.all(eventQueue);
     return getProxyUrl(settings);
 };
-const BYTES_LIMIT = 30;
+const REQUEST_BODY_TIMEOUT_SECONDS = 30;
 //# sourceMappingURL=proxy.js.map

package/dist/utils/socketeer.js

@@ -1,2 +1,9 @@
-export const SOCKETEER_URL = process.env.NETLIFY_SOCKETEER_URL ?? 'wss://socketeer.services.netlify.com';
+const getSocketeerUrl = () => {
+    // An empty value means unset, as with NETLIFY_API_URL.
+    if (process.env.NETLIFY_SOCKETEER_URL) {
+        return process.env.NETLIFY_SOCKETEER_URL;
+    }
+    return 'wss://socketeer.services.netlify.com';
+};
+export const SOCKETEER_URL = getSocketeerUrl();
 //# sourceMappingURL=socketeer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify-cli",
-  "version": "27.14.3",
+  "version": "27.16.0",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -55,23 +55,23 @@
     "@fastify/static": "^10.0.0",
     "@inquirer/prompts": "^8.7.2",
     "@netlify/ai": "^1.0.2",
-    "@netlify/api": "^15.1.3",
+    "@netlify/api": "^15.1.4",
     "@netlify/blobs": "^11.1.6",
-    "@netlify/build": "^37.5.1",
-    "@netlify/build-info": "^11.3.0",
-    "@netlify/config": "^25.3.0",
+    "@netlify/build": "^37.7.1",
+    "@netlify/build-info": "^11.3.1",
+    "@netlify/config": "^25.5.0",
     "@netlify/dev": "^5.1.10",
     "@netlify/dev-utils": "^6.0.4",
-    "@netlify/edge-bundler": "^16.1.3",
+    "@netlify/edge-bundler": "^16.2.0",
     "@netlify/edge-functions": "^4.0.3",
     "@netlify/edge-functions-bootstrap": "^3.2.0",
     "@netlify/headers-parser": "^10.1.1",
     "@netlify/images": "^2.0.5",
     "@netlify/local-functions-proxy": "^2.0.3",
-    "@netlify/redirect-matcher": "^0.4.2",
+    "@netlify/redirect-matcher": "^0.7.0",
     "@netlify/redirect-parser": "^16.1.1",
     "@netlify/server-dev": "^0.1.4",
-    "@netlify/zip-it-and-ship-it": "^16.4.1",
+    "@netlify/zip-it-and-ship-it": "^16.6.0",
     "@opentelemetry/api": "~1.9.0",
     "@pnpm/tabtab": "^0.5.4",
     "ansi-escapes": "^7.3.0",
@@ -149,7 +149,7 @@
   },
   "devDependencies": {
     "@babel/preset-react": "^7.27.1",
-    "@bugsnag/js": "^8.6.0",
+    "@bugsnag/js": "^9.0.0",
     "@eslint/compat": "^1.4.1",
     "@eslint/js": "^9.36.0",
     "@netlify/functions": "^6.0.3",