netlify-cli 27.14.3 → 27.15.0

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify-cli",
-  "version": "27.14.3",
+  "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",