netlify 27.4.3 → 27.5.0

package/dist/commands/clone/clone.d.ts

@@ -1,7 +1,13 @@
 import type BaseCommand from '../base-command.js';
 import type { CloneOptionValues } from './option_values.js';
+export declare const getCredentialHelper: () => string;
+export declare const finalizeClone: (options: CloneOptionValues, command: BaseCommand, workingDir: string, linkOverrides: {
+    id?: string;
+    name?: string;
+    gitRemoteUrl?: string;
+}) => Promise<void>;
 export declare const clone: (options: CloneOptionValues, command: BaseCommand, args: {
     repo: string;
     targetDir?: string;
-}) => Promise<undefined>;
+}) => Promise<void>;
 //# sourceMappingURL=clone.d.ts.map

package/dist/commands/clone/clone.js

@@ -1,9 +1,23 @@
+import { resolve } from 'path';
+import { LocalState } from '@netlify/dev-utils';
 import inquirer from 'inquirer';
 import { normalizeRepoUrl } from '../../utils/normalize-repo-url.js';
-import { chalk, logAndThrowError, log } from '../../utils/command-helpers.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 { 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) => {
     const { selectedDir } = await inquirer.prompt([
         {
@@ -23,42 +37,213 @@ const cloneRepo = async (repoUrl, targetDir, debug) => {
         throw new Error(`Failed to clone repository: ${error instanceof Error ? error.message : (error?.toString() ?? '')}`);
     }
 };
-export const clone = async (options, command, args) => {
-    await command.authenticate();
-    const { repoUrl, httpsUrl, repoName } = normalizeRepoUrl(args.repo);
-    const targetDir = args.targetDir ?? (await getTargetDir(`./${repoName}`));
-    const cloneSpinner = startSpinner({ text: `Cloning repository to ${chalk.cyan(targetDir)}` });
+// Under `npx`/`pnpx`/`npm exec`, `process.argv[1]` points into a temp cache dir that
+// gets cleaned up, so a git credential helper pinned to that path breaks after the
+// fact. Fall back to the resolved invocation (e.g. `npx netlify`) in that case.
+export const getCredentialHelper = () => {
+    const cliCommand = netlifyCommand();
+    const invocation = cliCommand === 'netlify' ? `'${process.execPath}' '${resolve(process.argv[1])}'` : cliCommand;
+    return `!${invocation} git-credential`;
+};
+const configureGitAuth = async (repoDir) => {
+    await execa('git', ['config', `credential.https://${NETLIFY_GIT_HOST}.helper`, ''], { cwd: repoDir });
+    await execa('git', ['config', '--add', `credential.https://${NETLIFY_GIT_HOST}.helper`, getCredentialHelper()], {
+        cwd: repoDir,
+    });
+    await execa('git', ['config', 'http.postBuffer', '524288000'], { cwd: repoDir });
+};
+const cloneFromNetlifyGit = async (repoUrl, targetDir, debug) => {
     try {
-        await cloneRepo(repoUrl, targetDir, options.debug ?? false);
+        await execa('git', [
+            '-c',
+            `credential.https://${NETLIFY_GIT_HOST}.helper=`,
+            '-c',
+            `credential.https://${NETLIFY_GIT_HOST}.helper=${getCredentialHelper()}`,
+            'clone',
+            repoUrl,
+            targetDir,
+        ], {
+            ...(debug ? { stdio: 'inherit' } : {}),
+        });
     }
     catch (error) {
-        return logAndThrowError(error);
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to clone repository: ${message}`);
     }
-    cloneSpinner.success(`Cloned repository to ${chalk.cyan(targetDir)}`);
-    command.workingDir = targetDir;
+};
+const parseNetlifySiteInput = (input) => {
+    const netlifyAppUrlRegex = /^https?:\/\/([^.]+)\.netlify\.app\/?$/;
+    const netlifyAppUrlMatch = netlifyAppUrlRegex.exec(input);
+    if (netlifyAppUrlMatch) {
+        return { isNetlifySite: true, siteName: netlifyAppUrlMatch[1] };
+    }
+    const appNetlifyUrlRegex = /^https?:\/\/app\.netlify\.com\/(?:sites|projects)\/([^/]+)\/?/;
+    const appNetlifyUrlMatch = appNetlifyUrlRegex.exec(input);
+    if (appNetlifyUrlMatch) {
+        return { isNetlifySite: true, siteName: appNetlifyUrlMatch[1] };
+    }
+    if (!input.includes('/') && !input.includes(':') && !input.includes('.')) {
+        return { isNetlifySite: true, siteName: input };
+    }
+    return { isNetlifySite: false };
+};
+// FIXME(serhalp): This suffers from the same egregious performance problem as `link`/`init`.
+// We should fix it rather than keep spreading it.
+const lookupSiteByName = async (api, siteName) => {
+    try {
+        const sites = await api.listSites({ name: siteName, filter: 'all' });
+        const site = sites.find((s) => s.name === siteName);
+        return site ? site : null;
+    }
+    catch (error) {
+        if (error.status === 404) {
+            return null;
+        }
+        throw error;
+    }
+};
+export const finalizeClone = async (options, command, workingDir, linkOverrides) => {
+    // `workingDir` may be relative (e.g. a user-entered target dir), and must be resolved
+    // against the *current* cwd before it changes below, not after.
+    const absoluteWorkingDir = resolve(workingDir);
+    command.workingDir = absoluteWorkingDir;
     // TODO(serhalp): This shouldn't be necessary but `getPathInProject` does not take
     // `command.workingDir` into account. Carefully fix this and remove this line.
-    process.chdir(targetDir);
+    process.chdir(absoluteWorkingDir);
+    // `command.netlify.repositoryRoot`/`state` were resolved from the pre-clone working
+    // directory before this command's action ran, so `link()` below would otherwise read
+    // and write against the original directory instead of the freshly cloned one.
+    command.netlify.repositoryRoot = absoluteWorkingDir;
+    command.netlify.state = new LocalState(absoluteWorkingDir);
     const { id, name, ...globalOptions } = options;
-    const linkOptions = {
-        ...globalOptions,
-        id,
-        name,
-        // Use the normalized HTTPS URL as the canonical git URL for linking to ensure
-        // we have a consistent URL format for looking up projects.
-        gitRemoteUrl: httpsUrl,
-    };
-    await link(linkOptions, command);
+    await link({ ...globalOptions, ...linkOverrides }, command);
+};
+const logCloneSuccess = (targetDir, { credentialsConfigured = false, devCommand } = {}) => {
     log();
     log(chalk.green('✔ Your project is ready to go!'));
     log(`→ Next, enter your project directory using ${chalk.cyanBright(`cd ${targetDir}`)}`);
     log();
     log(`→ You can now run other ${chalk.cyanBright('netlify')} CLI commands in this directory`);
+    if (credentialsConfigured) {
+        log(`Git is configured to use your Netlify credentials for this repository.`);
+    }
     log(`→ To build and deploy your project: ${chalk.cyanBright('netlify deploy')}`);
-    if (command.netlify.config.dev?.command) {
-        log(`→ To run your dev server: ${chalk.cyanBright(command.netlify.config.dev.command)}`);
+    if (devCommand) {
+        log(`→ To run your dev server: ${chalk.cyanBright(devCommand)}`);
     }
     log(`→ To see all available commands: ${chalk.cyanBright('netlify help')}`);
     log();
 };
+const cloneFromNetlifyGitService = async (options, command, args, siteInfo) => {
+    const [token] = await getToken();
+    if (!token) {
+        return logAndThrowError(`No authentication token found. Run ${chalk.cyanBright('netlify login')} to authenticate first.`);
+    }
+    const accountSlug = siteInfo.account_slug;
+    const siteSlug = siteInfo.name;
+    if (!accountSlug || !siteSlug) {
+        return logAndThrowError('Could not determine account or site slug from the site.');
+    }
+    const repoUrl = `https://${NETLIFY_GIT_HOST}/${accountSlug}/${siteSlug}.git`;
+    const targetDir = args.targetDir ?? (await getTargetDir(`./${siteSlug}`));
+    const resolvedTargetDir = resolve(targetDir);
+    log(`Remote: ${chalk.dim(repoUrl)}`);
+    const cloneSpinner = startSpinner({ text: `Cloning repository to ${chalk.cyan(targetDir)}` });
+    try {
+        await cloneFromNetlifyGit(repoUrl, resolvedTargetDir, options.debug ?? false);
+    }
+    catch (error) {
+        cloneSpinner.error();
+        return logAndThrowError(error);
+    }
+    cloneSpinner.success(`Cloned repository to ${chalk.cyan(targetDir)}`);
+    const configSpinner = startSpinner({ text: 'Configuring git credentials' });
+    try {
+        await configureGitAuth(resolvedTargetDir);
+    }
+    catch (error) {
+        configSpinner.error();
+        return logAndThrowError(error);
+    }
+    configSpinner.success('Configured git credentials');
+    await finalizeClone(options, command, resolvedTargetDir, { id: siteInfo.id });
+    logCloneSuccess(targetDir, { credentialsConfigured: true });
+};
+const isInsideGitRepo = async () => {
+    try {
+        await execa('git', ['rev-parse', '--is-inside-work-tree']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const clone = async (options, command, args) => {
+    await command.authenticate();
+    const { api, site } = command.netlify;
+    if (site.id) {
+        return logAndThrowError(`This directory is already linked to a Netlify project. Run ${chalk.cyanBright('netlify clone')} from outside any existing linked project directory.`);
+    }
+    if (await isInsideGitRepo()) {
+        return logAndThrowError(`This directory is already inside a git repository. Run ${chalk.cyanBright('netlify clone')} from outside any existing git repository.`);
+    }
+    const parsedInput = parseNetlifySiteInput(args.repo);
+    if (parsedInput.isNetlifySite) {
+        const siteSpinner = startSpinner({ text: `Looking up site ${chalk.cyan(parsedInput.siteName)}...` });
+        const siteInfo = await lookupSiteByName(api, parsedInput.siteName);
+        if (!siteInfo) {
+            siteSpinner.error();
+            return logAndThrowError(`Could not find a Netlify site named "${parsedInput.siteName}"`);
+        }
+        siteSpinner.success(`Found site ${chalk.cyan(siteInfo.name)}`);
+        const connectedRepoUrl = siteInfo.build_settings?.repo_url;
+        if (connectedRepoUrl && isNetlifyGitServiceUrl(connectedRepoUrl)) {
+            log(`Site is connected to Netlify's managed git service.`);
+            log(`Cloning from Netlify's managed git service...`);
+            log();
+            return cloneFromNetlifyGitService(options, command, args, siteInfo);
+        }
+        if (connectedRepoUrl) {
+            log(`Site has a connected repository: ${chalk.dim(connectedRepoUrl)}`);
+            log(`Cloning from the connected repository...`);
+            log();
+            const { repoUrl, repoName } = normalizeRepoUrl(connectedRepoUrl);
+            const targetDir = args.targetDir ?? (await getTargetDir(`./${repoName}`));
+            const cloneSpinner = startSpinner({ text: `Cloning repository to ${chalk.cyan(targetDir)}` });
+            try {
+                await cloneRepo(repoUrl, targetDir, options.debug ?? false);
+            }
+            catch (error) {
+                cloneSpinner.error();
+                return logAndThrowError(error);
+            }
+            cloneSpinner.success(`Cloned repository to ${chalk.cyan(targetDir)}`);
+            await finalizeClone(options, command, targetDir, { id: siteInfo.id, gitRemoteUrl: connectedRepoUrl });
+            logCloneSuccess(targetDir);
+        }
+        else {
+            log(`Site does not have a connected repository.`);
+            log(`Cloning from Netlify's managed git service...`);
+            log();
+            return cloneFromNetlifyGitService(options, command, args, siteInfo);
+        }
+    }
+    else {
+        const { repoUrl, httpsUrl, repoName } = normalizeRepoUrl(args.repo);
+        const targetDir = args.targetDir ?? (await getTargetDir(`./${repoName}`));
+        const cloneSpinner = startSpinner({ text: `Cloning repository to ${chalk.cyan(targetDir)}` });
+        try {
+            await cloneRepo(repoUrl, targetDir, options.debug ?? false);
+        }
+        catch (error) {
+            cloneSpinner.error();
+            return logAndThrowError(error);
+        }
+        cloneSpinner.success(`Cloned repository to ${chalk.cyan(targetDir)}`);
+        // Use the normalized HTTPS URL as the canonical git URL for linking to ensure
+        // we have a consistent URL format for looking up projects.
+        await finalizeClone(options, command, targetDir, { id: options.id, name: options.name, gitRemoteUrl: httpsUrl });
+        logCloneSuccess(targetDir, { devCommand: command.netlify.config.dev?.command });
+    }
+};
 //# sourceMappingURL=clone.js.map

package/dist/commands/clone/index.js

@@ -1,23 +1,34 @@
 import terminalLink from 'terminal-link';
 export const createCloneCommand = (program) => program
     .command('clone')
-    .description(`Clone a remote repository and link it to an existing project on Netlify
-Use this command when the existing Netlify project is already configured to deploy from the existing repo.
+    // TODO(serhalp): When making this feature public, add this line:
+    // When cloning a Netlify site without a connected repository, the repository will be cloned from Netlify's managed git service with automatic credential configuration.
+    .description(`Clone a repository and link it to a Netlify project
 
-If you specify a target directory, the repo will be cloned into that directory. By default, a directory will be created with the name of the repo.
+You can clone from:
+- A GitHub/GitLab repository URL or shorthand (e.g., owner/repo)
+- A Netlify site name (e.g., my-site)
+- A Netlify site URL (e.g., https://my-site.netlify.app)
 
-To specify a project, use --id or --name. By default, the Netlify project to link will be automatically detected if exactly one project found is found with a matching git URL. If we cannot find such a project, you will be interactively prompted to select one.`)
-    .argument('<repo>', 'URL of the repository to clone or Github `owner/repo` (required)')
+When cloning a Netlify site that has a connected repository, the repository will be cloned from the connected source (GitHub, GitLab, etc.).
+
+
+If you specify a target directory, the repo will be cloned into that directory. By default, a directory will be created with the name of the repo or site.`)
+    .argument('<repository>', 'Repository URL, GitHub shorthand (owner/repo), Netlify site name, or Netlify site URL')
     .argument('[targetDir]', 'directory in which to clone the repository - will be created if it does not exist')
-    .option('--id <id>', 'ID of existing Netlify project to link to')
-    .option('--name <name>', 'Name of existing Netlify project to link to')
+    .option('--id <id>', 'ID of existing Netlify project to link to (only for GitHub/GitLab repos)')
+    .option('--name <name>', 'Name of existing Netlify project to link to (only for GitHub/GitLab repos)')
     .addExamples([
+    'netlify clone my-site-name',
+    'netlify clone https://my-site.netlify.app',
+    'netlify clone https://app.netlify.com/sites/my-site',
     'netlify clone vibecoder/next-unicorn',
     'netlify clone https://github.com/vibecoder/next-unicorn.git',
     'netlify clone git@github.com:vibecoder/next-unicorn.git',
     'netlify clone vibecoder/next-unicorn ./next-unicorn-shh-secret',
     'netlify clone --id 123-123-123-123 vibecoder/next-unicorn',
     'netlify clone --name my-project-name vibecoder/next-unicorn',
+    'netlify clone my-site-name ./local-folder',
 ])
     .addHelpText('after', () => {
     const docsUrl = 'https://docs.netlify.com/cli/get-started/#link-and-unlink-sites';

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

@@ -0,0 +1,7 @@
+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>;
+//# sourceMappingURL=git-credential.d.ts.map

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

@@ -0,0 +1,39 @@
+import process from 'process';
+import readline from 'readline';
+import { getToken } from '../../utils/command-helpers.js';
+export const NETLIFY_GIT_HOST = 'git.netlify.com';
+export const parseGitCredentialInput = async (input) => {
+    const rl = readline.createInterface({
+        input,
+        terminal: false,
+    });
+    const data = {};
+    for await (const line of rl) {
+        if (line === '')
+            break;
+        const [key, ...valueParts] = line.split('=');
+        if (key) {
+            data[key] = valueParts.join('=');
+        }
+    }
+    return data;
+};
+export const writeCredentials = (output, token) => {
+    output.write(`username=x-access-token\n`);
+    output.write(`password=${token}\n`);
+};
+export const gitCredential = async (operation, _options) => {
+    if (operation !== 'get') {
+        return;
+    }
+    const input = await parseGitCredentialInput(process.stdin);
+    if (input.host?.split(':')[0] !== NETLIFY_GIT_HOST) {
+        return;
+    }
+    const [token] = await getToken();
+    if (!token) {
+        return;
+    }
+    writeCredentials(process.stdout, token);
+};
+//# sourceMappingURL=git-credential.js.map

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

@@ -0,0 +1,3 @@
+import type BaseCommand from '../base-command.js';
+export declare const createGitCredentialCommand: (program: BaseCommand) => BaseCommand;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,9 @@
+export const createGitCredentialCommand = (program) => program
+    .command('git-credential', { hidden: true })
+    .description('Git credential helper for Netlify authentication (used internally by git)')
+    .argument('<operation>', 'Git credential operation (get, store, erase)')
+    .action(async (operation, options) => {
+    const { gitCredential } = await import('./git-credential.js');
+    await gitCredential(operation, options);
+});
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,3 @@
+import type { BaseOptionValues } from '../base-command.js';
+export type GitCredentialOptionValues = BaseOptionValues;
+//# sourceMappingURL=option_values.d.ts.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=option_values.js.map

package/dist/commands/logs/index.js

@@ -84,12 +84,15 @@ export const createLogsCommand = (program) => {
         .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'))
+        .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('-l, --level <levels...>', `Log levels to include. Choices are:${CLI_LOG_LEVEL_CHOICES_STRING}`))
         .addOption(new Option('--json', 'Output logs as JSON Lines'))
         .addExamples([
         'netlify logs',
         'netlify logs --since 1h',
+        'netlify logs --source deploy --deploy-id <deploy-id> --since 7d',
+        'netlify logs --source functions --deploy-id <deploy-id>',
         'netlify logs --source functions --function checkout --since 24h',
         'netlify logs --source edge-functions --since 30m',
         'netlify logs --source deploy --source functions --since 1h',

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

@@ -1,4 +1,19 @@
-import { OptionValues } from 'commander';
+import type { NetlifyAPI } from '@netlify/api';
 import type BaseCommand from '../base-command.js';
-export declare const logsCommand: (options: OptionValues, command: BaseCommand) => Promise<undefined>;
+import type { LogsOptionValues } from './option_values.js';
+type Source = 'functions' | 'edge-functions' | 'deploy';
+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[];
+    client: NetlifyAPI;
+    siteId: string;
+    accessToken: string | null | undefined;
+    deployId?: string;
+    deployTargeted: boolean;
+    functionNames: string[];
+    edgeFunctionNames: string[];
+    levelsToPrint: string[];
+    json: boolean;
+}) => Promise<undefined>;
+export {};
 //# sourceMappingURL=logs.d.ts.map

package/dist/commands/logs/logs.js

@@ -1,11 +1,12 @@
 import { chalk, log, logAndThrowError, netlifyCommand } from '../../utils/command-helpers.js';
-import { createColorAssigner, formatJsonLine, formatLogLine, parseTimeValue, resolveDeployIdFromUrl, SOURCE_INDICATORS, SOURCE_LABELS, } from './log-api.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, findLatestReadyDeploy, streamDeploy, } from './sources/deploy.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'];
 const DEFAULT_SINCE = '10m';
+const DEPLOY_STREAM_IDLE_CLOSE_MS = 3_000;
 const parseSources = (rawSources) => {
     const sources = [];
     for (const s of rawSources) {
@@ -122,9 +123,22 @@ export const logsCommand = async (options, command) => {
         }
     }
     let deployId;
-    if (options.url) {
+    let deployTargeted = false;
+    if (options.deployId) {
+        const explicitDeployId = options.deployId.trim();
+        if (!DEPLOY_ID_RE.test(explicitDeployId)) {
+            return logAndThrowError(`Invalid --deploy-id value: ${explicitDeployId}. Expected a deploy ID.`);
+        }
+        if (options.url) {
+            return logAndThrowError('--deploy-id cannot be used together with --url.');
+        }
+        deployId = explicitDeployId;
+        deployTargeted = true;
+    }
+    else if (options.url) {
         try {
             deployId = await resolveDeployIdFromUrl(options.url, client, siteId, siteInfo);
+            deployTargeted = deployId !== undefined;
         }
         catch (error) {
             const message = error.message;
@@ -170,20 +184,20 @@ export const logsCommand = async (options, command) => {
             }
         }
         if (!deployId) {
-            const latestId = await findLatestReadyDeploy(client, siteId);
+            const latestId = sources.includes('deploy')
+                ? await findLatestFinishedDeploy(client, siteId)
+                : await findLatestReadyDeploy(client, siteId);
             if (latestId) {
                 deployId = latestId;
             }
         }
     }
-    const apiBase = client.basePath;
     const sinceValue = options.since ?? DEFAULT_SINCE;
     const untilValue = options.until;
     if (historicalRange) {
         await runHistoricalMode({
             sources,
             client,
-            apiBase,
             siteId,
             accessToken: client.accessToken,
             deployId,
@@ -206,17 +220,18 @@ export const logsCommand = async (options, command) => {
         siteId,
         accessToken: client.accessToken,
         deployId,
+        deployTargeted,
         functionNames,
         edgeFunctionNames,
         levelsToPrint,
         json,
     });
 };
-const runHistoricalMode = async ({ sources, client, apiBase, siteId, accessToken, deployId, functionNames, edgeFunctionNames, from, to, levelsToPrint, json, timeDescription, }) => {
+const runHistoricalMode = async ({ sources, client, siteId, accessToken, deployId, functionNames, edgeFunctionNames, from, to, levelsToPrint, json, timeDescription, }) => {
     const allEntries = [];
     if (sources.includes('deploy') && deployId) {
         const deployEntries = await fetchDeployHistoricalLogs({
-            apiBase,
+            siteId,
             accessToken,
             deployId,
             from,
@@ -264,20 +279,23 @@ const runHistoricalMode = async ({ sources, client, apiBase, siteId, accessToken
         printEntry(entry, levelsToPrint, json, assignColor(key));
     }
 };
-const runFollowMode = async ({ sources, client, siteId, accessToken, deployId, functionNames, edgeFunctionNames, levelsToPrint, json, }) => {
+export const runFollowMode = async ({ sources, client, siteId, accessToken, deployId, deployTargeted, functionNames, edgeFunctionNames, levelsToPrint, json, }) => {
     const assignColor = createColorAssigner();
     const onEntry = (entry) => {
         const key = `${entry.source}:${entry.name}`;
         printEntry(entry, levelsToPrint, json, assignColor(key));
     };
-    if (sources.includes('deploy') && deployId) {
-        const buildingDeployId = await findCurrentBuildingDeploy(client, siteId);
-        if (buildingDeployId) {
-            streamDeploy(siteId, buildingDeployId, accessToken, onEntry, () => {
+    if (sources.includes('deploy')) {
+        const deployStreamId = deployTargeted ? deployId : await findCurrentBuildingDeploy(client, siteId);
+        if (deployStreamId) {
+            const finished = deployTargeted
+                ? await isDeployFinished(client, siteId, deployStreamId).catch(() => false)
+                : false;
+            streamDeploy(siteId, deployStreamId, accessToken, onEntry, () => {
                 if (!json) {
                     log(chalk.dim('Deploy stream closed.'));
                 }
-            });
+            }, { closeWhenIdleMs: finished ? DEPLOY_STREAM_IDLE_CLOSE_MS : undefined });
         }
     }
     if (sources.includes('functions')) {

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

@@ -0,0 +1,14 @@
+import type { BaseOptionValues } from '../base-command.js';
+export type LogsOptionValues = BaseOptionValues & {
+    source?: string[];
+    function?: string[];
+    edgeFunction?: string[];
+    since?: string;
+    until?: string;
+    follow?: boolean;
+    url?: string;
+    deployId?: string;
+    level?: string[];
+    json?: boolean;
+};
+//# sourceMappingURL=option_values.d.ts.map

package/dist/commands/logs/option_values.js

@@ -0,0 +1,3 @@
+// This type lives in a separate file to prevent import cycles.
+export {};
+//# sourceMappingURL=option_values.js.map

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

@@ -1,13 +1,17 @@
 import type { NetlifyAPI } from '@netlify/api';
 import type { LogEntry } from '../log-api.js';
-export declare const fetchDeployHistoricalLogs: ({ apiBase, accessToken, deployId, from, to, }: {
-    apiBase: string;
+export declare const fetchDeployHistoricalLogs: ({ siteId, accessToken, deployId, from, to, }: {
+    siteId: string;
     accessToken: string | null | undefined;
     deployId: string;
     from: number;
     to: number;
 }) => Promise<LogEntry[]>;
-export declare const streamDeploy: (siteId: string, deployId: string, accessToken: string | null | undefined, onEntry: (entry: LogEntry) => void, onClose: () => void) => (() => void);
+export declare const streamDeploy: (siteId: string, deployId: string, accessToken: string | null | undefined, onEntry: (entry: LogEntry) => void, onClose: () => void, { closeWhenIdleMs }?: {
+    closeWhenIdleMs?: number;
+}) => (() => void);
 export declare const findCurrentBuildingDeploy: (client: NetlifyAPI, siteId: string) => Promise<string | undefined>;
 export declare const findLatestReadyDeploy: (client: NetlifyAPI, siteId: string) => Promise<string | undefined>;
+export declare const findLatestFinishedDeploy: (client: NetlifyAPI, siteId: string) => Promise<string | undefined>;
+export declare const isDeployFinished: (client: NetlifyAPI, siteId: string, deployId: string) => Promise<boolean>;
 //# sourceMappingURL=deploy.d.ts.map