netlify-cli 27.15.0 → 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/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/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.15.0",
+  "version": "27.16.0",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -55,20 +55,20 @@
     "@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.7.0",
-    "@netlify/build-info": "^11.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.6.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",