netlify-cli 27.14.2 → 27.15.0

package/dist/commands/clone/clone.js

@@ -5,19 +5,9 @@ import { normalizeRepoUrl } from '../../utils/normalize-repo-url.js';
 import { chalk, logAndThrowError, log, getToken, netlifyCommand } from '../../utils/command-helpers.js';
 import { runGit } from '../../utils/run-git.js';
 import execa from '../../utils/execa.js';
-import { NETLIFY_GIT_HOST } from '../git-credential/git-credential.js';
+import { isNetlifyGitUrl, NETLIFY_GIT_HOST } from '../../utils/netlify-git.js';
 import { link } from '../link/link.js';
 import { startSpinner } from '../../lib/spinner.js';
-const NETLIFY_GIT_SERVICE_HOST = 'hgit.services-prod.nsvcs.net';
-const isNetlifyGitServiceUrl = (repoUrl) => {
-    try {
-        const host = new URL(repoUrl).host;
-        return host === NETLIFY_GIT_HOST || host === NETLIFY_GIT_SERVICE_HOST;
-    }
-    catch {
-        return false;
-    }
-};
 const getTargetDir = async (defaultDir) => {
     return await input({
         message: 'Where should we clone the repository?',
@@ -192,7 +182,7 @@ export const clone = async (options, command, args) => {
         }
         siteSpinner.success(`Found site ${chalk.cyan(siteInfo.name)}`);
         const connectedRepoUrl = siteInfo.build_settings?.repo_url;
-        if (connectedRepoUrl && isNetlifyGitServiceUrl(connectedRepoUrl)) {
+        if (connectedRepoUrl && isNetlifyGitUrl(connectedRepoUrl)) {
             log(`Site is connected to Netlify's managed git service.`);
             log(`Cloning from Netlify's managed git service...`);
             log();

package/dist/commands/deploy/deploy.js

@@ -19,6 +19,7 @@ import { NETLIFY_CYAN_HEX, NETLIFYDEVERR, NETLIFYDEVLOG, chalk, logAndThrowError
 import { DEFAULT_CONCURRENT_HASH, DEFAULT_DEPLOY_TIMEOUT } from '../../utils/deploy/constants.js';
 import { deploySite } from '../../utils/deploy/deploy-site.js';
 import { getDeploySourceFields } from '../../utils/deploy/deploy-source.js';
+import { getDeployUrls } from '../../utils/deploy/deploy-urls.js';
 import { uploadSourceZip } from '../../utils/deploy/upload-source-zip.js';
 import { getEnvelopeEnv } from '../../utils/env/index.js';
 import { mergeDeployEnvVars } from '../../utils/env/deploy-env-vars.js';
@@ -472,24 +473,11 @@ const runDeploy = async ({ alias, api, command, config, deployFolder, deployTime
         }
         return reportDeployError({ error: error, failAndExit: logAndThrowError });
     }
-    const siteUrl = results.deploy.ssl_url || results.deploy.url;
-    const deployUrl = results.deploy.deploy_ssl_url || results.deploy.deploy_url;
-    const logsUrl = `${results.deploy.admin_url}/deploys/${results.deploy.id}`;
-    let functionLogsUrl = `${results.deploy.admin_url}/logs/functions`;
-    let edgeFunctionLogsUrl = `${results.deploy.admin_url}/logs/edge-functions`;
-    if (!deployToProduction) {
-        functionLogsUrl += `?scope=deploy:${deployId}`;
-        edgeFunctionLogsUrl += `?scope=deployid:${deployId}`;
-    }
     return {
         siteId: results.deploy.site_id,
         siteName: results.deploy.name,
         deployId: results.deployId,
-        siteUrl,
-        deployUrl,
-        logsUrl,
-        functionLogsUrl,
-        edgeFunctionLogsUrl,
+        ...getDeployUrls(results.deploy, { deployToProduction }),
         sourceZipFileName: uploadSourceZipResult?.sourceZipFileName,
     };
 };

package/dist/commands/git-credential/git-credential.d.ts

@@ -1,6 +1,5 @@
 import type { Readable, Writable } from 'stream';
 import type { GitCredentialOptionValues } from './option_values.js';
-export declare const NETLIFY_GIT_HOST = "git.netlify.com";
 export declare const parseGitCredentialInput: (input: Readable) => Promise<Partial<Record<string, string>>>;
 export declare const writeCredentials: (output: Writable, token: string) => void;
 export declare const gitCredential: (operation: string, _options: GitCredentialOptionValues) => Promise<void>;

package/dist/commands/git-credential/git-credential.js

@@ -1,7 +1,7 @@
 import process from 'process';
 import readline from 'readline';
 import { getToken } from '../../utils/command-helpers.js';
-export const NETLIFY_GIT_HOST = 'git.netlify.com';
+import { NETLIFY_GIT_HOST } from '../../utils/netlify-git.js';
 export const parseGitCredentialInput = async (input) => {
     const rl = readline.createInterface({
         input,

package/dist/commands/logs/build.js

@@ -1,6 +1,7 @@
 import { select } from '@inquirer/prompts';
 import { log, chalk } from '../../utils/command-helpers.js';
 import { getWebSocket } from '../../utils/websockets/index.js';
+import { SOCKETEER_URL } from '../../utils/socketeer.js';
 export function getName({ deploy, userId }) {
     let normalisedName = '';
     const isUserDeploy = deploy.user_id === userId;
@@ -51,7 +52,7 @@ export const logsBuild = async (_options, command) => {
         deploy = deploys.find((dep) => dep.id === result) || deploy;
     }
     const { id } = deploy;
-    const ws = getWebSocket(`wss://socketeer.services.netlify.com/build/logs`);
+    const ws = getWebSocket(`${SOCKETEER_URL}/build/logs`);
     ws.on('open', function open() {
         ws.send(JSON.stringify({ deploy_id: id, site_id: siteId, access_token: client.accessToken }));
     });

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/deploy.js

@@ -1,4 +1,5 @@
 import { getWebSocket } from '../../../utils/websockets/index.js';
+import { SOCKETEER_URL } from '../../../utils/socketeer.js';
 const DEPLOY_LOG_REPLAY_TIMEOUT_MS = 30_000;
 const DEPLOY_STREAM_START_TIMEOUT_MS = 20_000;
 const parseDeployLogTimestamp = (message) => {
@@ -29,7 +30,7 @@ const parseDeployLogMessage = (data) => {
 };
 export const fetchDeployHistoricalLogs = async ({ siteId, accessToken, deployId, from, to, }) => {
     const collected = [];
-    const ws = getWebSocket('wss://socketeer.services.netlify.com/build/logs');
+    const ws = getWebSocket(`${SOCKETEER_URL}/build/logs`);
     await new Promise((resolve, reject) => {
         let settled = false;
         const finish = (error) => {
@@ -84,7 +85,7 @@ export const fetchDeployHistoricalLogs = async ({ siteId, accessToken, deployId,
         .sort((a, b) => a.ts - b.ts);
 };
 export const streamDeploy = (siteId, deployId, accessToken, onEntry, onClose, { closeWhenIdleMs } = {}) => {
-    const ws = getWebSocket('wss://socketeer.services.netlify.com/build/logs');
+    const ws = getWebSocket(`${SOCKETEER_URL}/build/logs`);
     let closeTimer;
     const scheduleClose = (ms) => {
         clearTimeout(closeTimer);

package/dist/commands/logs/sources/edge-functions.js

@@ -1,4 +1,5 @@
 import { getWebSocket } from '../../../utils/websockets/index.js';
+import { SOCKETEER_URL } from '../../../utils/socketeer.js';
 import { buildEdgeFunctionLogsUrl, debugFetch, fetchHistoricalLogs } from '../log-api.js';
 export const listEdgeFunctions = async (apiBase, accessToken, deployId) => {
     const response = await debugFetch(`${apiBase}/api/v1/deploys/${encodeURIComponent(deployId)}/edge_functions`, {
@@ -41,7 +42,7 @@ export const fetchEdgeFunctionHistoricalLogs = async ({ siteId, accessToken, fro
     }));
 };
 export const streamEdgeFunctions = (siteId, deployId, accessToken, filterNames, onEntry) => {
-    const ws = getWebSocket('wss://socketeer.services.netlify.com/edge-function/logs');
+    const ws = getWebSocket(`${SOCKETEER_URL}/edge-function/logs`);
     ws.on('open', () => {
         ws.send(JSON.stringify({
             deploy_id: deployId,

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

@@ -1,4 +1,5 @@
 import { getWebSocket } from '../../../utils/websockets/index.js';
+import { SOCKETEER_URL } from '../../../utils/socketeer.js';
 import { buildFunctionLogsUrl, fetchHistoricalLogs } from '../log-api.js';
 const MAX_CONCURRENT_FUNCTIONS = 10;
 export const listFunctions = async (client, siteId, deployId) => {
@@ -45,7 +46,7 @@ export const fetchFunctionHistoricalLogs = async ({ functions, siteId, accessTok
 export const streamFunctions = (functions, siteId, accessToken, onEntry) => {
     const sockets = [];
     for (const fn of functions) {
-        const ws = getWebSocket('wss://socketeer.services.netlify.com/function/logs');
+        const ws = getWebSocket(`${SOCKETEER_URL}/function/logs`);
         sockets.push(ws);
         ws.on('open', () => {
             ws.send(JSON.stringify({

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/utils/deploy/deploy-urls.d.ts

@@ -0,0 +1,20 @@
+export interface DeployUrls {
+    siteUrl: string;
+    deployUrl: string;
+    logsUrl: string;
+    functionLogsUrl: string;
+    edgeFunctionLogsUrl: string;
+}
+interface DeployUrlFields {
+    id?: string;
+    ssl_url?: string;
+    url?: string;
+    deploy_ssl_url?: string;
+    deploy_url?: string;
+    admin_url?: string;
+}
+export declare const getDeployUrls: (deploy: DeployUrlFields, { deployToProduction }: {
+    deployToProduction: boolean;
+}) => DeployUrls;
+export {};
+//# sourceMappingURL=deploy-urls.d.ts.map

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

@@ -0,0 +1,14 @@
+export const getDeployUrls = (deploy, { deployToProduction }) => {
+    const functionLogsUrl = `${deploy.admin_url ?? ''}/logs/functions`;
+    const edgeFunctionLogsUrl = `${deploy.admin_url ?? ''}/logs/edge-functions`;
+    return {
+        siteUrl: deploy.ssl_url ?? deploy.url ?? '',
+        deployUrl: deploy.deploy_ssl_url ?? deploy.deploy_url ?? '',
+        logsUrl: `${deploy.admin_url ?? ''}/deploys/${deploy.id ?? ''}`,
+        functionLogsUrl: deployToProduction ? functionLogsUrl : `${functionLogsUrl}?scope=deploy:${deploy.id ?? ''}`,
+        edgeFunctionLogsUrl: deployToProduction
+            ? edgeFunctionLogsUrl
+            : `${edgeFunctionLogsUrl}?scope=deployid:${deploy.id ?? ''}`,
+    };
+};
+//# sourceMappingURL=deploy-urls.js.map

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

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

package/dist/utils/netlify-git.js

@@ -0,0 +1,12 @@
+export const NETLIFY_GIT_HOST = 'git.netlify.com';
+const NETLIFY_GIT_SERVICE_HOST = 'hgit.services-prod.nsvcs.net';
+export const isNetlifyGitUrl = (repoUrl) => {
+    try {
+        const { host } = new URL(repoUrl);
+        return host === NETLIFY_GIT_HOST || host === NETLIFY_GIT_SERVICE_HOST;
+    }
+    catch {
+        return false;
+    }
+};
+//# sourceMappingURL=netlify-git.js.map

package/dist/utils/proxy.js

@@ -582,6 +582,9 @@ const onRequest = async ({ api, edgeFunctionsProxy, env, functionsRegistry, func
                     for (let index = 0; index < req.rawHeaders.length; index += 2) {
                         headers.append(req.rawHeaders[index], req.rawHeaders[index + 1]);
                     }
+                    // The server handler gets a `Request` with no socket, so it reads the
+                    // client's address from this header to set `context.ip`.
+                    headers.set('x-forwarded-for', req.socket.remoteAddress ?? '');
                     const response = await serverMatch.handle(new Request(requestURL, {
                         body: req.originalBody,
                         headers,

package/dist/utils/socketeer.d.ts

@@ -0,0 +1,2 @@
+export declare const SOCKETEER_URL: string;
+//# sourceMappingURL=socketeer.d.ts.map

package/dist/utils/socketeer.js

@@ -0,0 +1,2 @@
+export const SOCKETEER_URL = process.env.NETLIFY_SOCKETEER_URL ?? 'wss://socketeer.services.netlify.com';
+//# sourceMappingURL=socketeer.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify-cli",
-  "version": "27.14.2",
+  "version": "27.15.0",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -57,9 +57,9 @@
     "@netlify/ai": "^1.0.2",
     "@netlify/api": "^15.1.3",
     "@netlify/blobs": "^11.1.6",
-    "@netlify/build": "^37.5.1",
+    "@netlify/build": "^37.7.0",
     "@netlify/build-info": "^11.3.0",
-    "@netlify/config": "^25.3.0",
+    "@netlify/config": "^25.5.0",
     "@netlify/dev": "^5.1.10",
     "@netlify/dev-utils": "^6.0.4",
     "@netlify/edge-bundler": "^16.1.3",
@@ -71,7 +71,7 @@
     "@netlify/redirect-matcher": "^0.4.2",
     "@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",
@@ -139,7 +139,7 @@
     "semver": "^7.7.2",
     "source-map-support": "^0.5.21",
     "terminal-link": "^5.0.0",
-    "toml": "^4.0.0",
+    "toml": "^5.0.0",
     "tomlify-j0.4": "^3.0.0",
     "ulid": "^3.0.1",
     "update-notifier": "^7.3.1",