netlify-cli 27.5.1 → 27.6.0

package/dist/commands/base-command.js

@@ -15,10 +15,11 @@ import inquirer from 'inquirer';
 import inquirerAutocompletePrompt from 'inquirer-autocomplete-prompt';
 import { deepMerge, pick } from '../utils/object-utilities.js';
 import { getAgent } from '../lib/http-agent.js';
-import { NETLIFY_CYAN, USER_AGENT, chalk, logAndThrowError, logJson, exit, getToken, log, version, normalizeConfig, padLeft, pollForToken, sortOptions, warn, logError, } from '../utils/command-helpers.js';
+import { NETLIFY_CYAN, USER_AGENT, chalk, logAndThrowError, logJson, exit, getRequestUserAgent, getToken, log, version, normalizeConfig, padLeft, pollForToken, sortOptions, warn, logError, } from '../utils/command-helpers.js';
 import { handleOptionError, isOptionError } from '../utils/command-error-handler.js';
 import { getFrameworksAPIPaths } from '../utils/frameworks-api.js';
 import { getSiteByName } from '../utils/get-site.js';
+import { buildAuthorizeUrl } from '../utils/login-url.js';
 import openBrowser from '../utils/open-browser.js';
 import { isInteractive } from '../utils/scripted-commands.js';
 import { identify, reportError, setCommandForErrorReporting, track } from '../utils/telemetry/index.js';
@@ -374,14 +375,16 @@ export default class BaseCommand extends Command {
         }
     }
     async expensivelyAuthenticate() {
-        const webUI = process.env.NETLIFY_WEB_UI || 'https://app.netlify.com';
         log(`Logging into your Netlify account...`);
         // Create ticket for auth
         const ticket = await this.netlify.api.createTicket({
             clientId: CLIENT_ID,
         });
+        if (!ticket.id) {
+            return logAndThrowError('Failed to create login ticket');
+        }
         // Open browser for authentication
-        const authLink = `${webUI}/authorize?response_type=ticket&ticket=${ticket.id}`;
+        const authLink = buildAuthorizeUrl(ticket.id);
         log(`Opening ${authLink}`);
         const browserOpened = await openBrowser({ url: authLink });
         if (!browserOpened && !isInteractive() && ticket.id) {
@@ -502,7 +505,7 @@ export default class BaseCommand extends Command {
         const state = new LocalState(this.workingDir);
         const [token] = await getToken(flags.auth);
         const apiUrlOpts = {
-            userAgent: USER_AGENT,
+            userAgent: getRequestUserAgent(),
         };
         if (process.env.NETLIFY_API_URL) {
             const apiUrl = new URL(process.env.NETLIFY_API_URL);

package/dist/commands/login/login-request.js

@@ -1,15 +1,15 @@
 import { NetlifyAPI } from '@netlify/api';
 import { log, logAndThrowError, logJson } from '../../utils/command-helpers.js';
+import { buildAuthorizeUrl } from '../../utils/login-url.js';
 import { CLIENT_ID } from '../base-command.js';
 export const loginRequest = async (message, apiOpts) => {
-    const webUI = process.env.NETLIFY_WEB_UI || 'https://app.netlify.com';
     const api = new NetlifyAPI('', apiOpts);
     const ticket = await api.createTicket({ clientId: CLIENT_ID, body: { message } });
     if (!ticket.id) {
         return logAndThrowError('Failed to create login ticket');
     }
     const ticketId = ticket.id;
-    const url = `${webUI}/authorize?response_type=ticket&ticket=${ticketId}`;
+    const url = buildAuthorizeUrl(ticketId);
     logJson({
         ticket_id: ticketId,
         url,

package/dist/recipes/ai-context/context.d.ts

@@ -54,6 +54,6 @@ export declare const applyOverrides: (template: string, overrides?: string) => s
 export declare const getExistingContext: (path: string) => Promise<ParsedContextFile | null>;
 export declare const writeFile: (path: string, contents: string) => Promise<void>;
 export declare const deleteFile: (path: string) => Promise<void>;
-export declare const downloadAndWriteContextFiles: (consumer: ConsumerConfig, { command }: RunRecipeOptions) => Promise<void>;
+export declare const downloadAndWriteContextFiles: (consumer: ConsumerConfig, { command }: RunRecipeOptions) => Promise<boolean>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/recipes/ai-context/context.js

@@ -148,7 +148,7 @@ export const deleteFile = async (path) => {
     }
 };
 export const downloadAndWriteContextFiles = async (consumer, { command }) => {
-    await Promise.allSettled(Object.keys(consumer.contextScopes).map(async (contextKey) => {
+    const results = await Promise.allSettled(Object.keys(consumer.contextScopes).map(async (contextKey) => {
         const contextConfig = consumer.contextScopes[contextKey];
         const { contents: downloadedFile, minimumCLIVersion } = (await downloadFile(version, contextConfig, consumer).catch(() => null)) ?? {};
         if (!downloadedFile) {
@@ -168,7 +168,7 @@ export const downloadAndWriteContextFiles = async (consumer, { command }) => {
             if (existing.provider?.toLowerCase() === NETLIFY_PROVIDER) {
                 if (remote.version === existing.version) {
                     log(`You're all up to date! ${chalk.underline(absoluteFilePath)} contains the latest version of the context files.`);
-                    return;
+                    return false;
                 }
                 // We must preserve any overrides found in the existing file.
                 contents = applyOverrides(remote.contents, existing.overrides?.innerContents);
@@ -190,6 +190,12 @@ export const downloadAndWriteContextFiles = async (consumer, { command }) => {
         }
         await writeFile(absoluteFilePath, contents);
         log(`${existing ? 'Updated' : 'Created'} context files at ${chalk.underline(absoluteFilePath)}`);
+        return true;
     }));
+    const failure = results.find((result) => result.status === 'rejected');
+    if (failure) {
+        throw failure.reason;
+    }
+    return results.some((result) => result.status === 'fulfilled' && result.value);
 };
 //# sourceMappingURL=context.js.map

package/dist/recipes/ai-context/index.js

@@ -2,6 +2,7 @@ import { resolve } from 'node:path';
 import inquirer from 'inquirer';
 import execa from 'execa';
 import { logAndThrowError, log, version } from '../../utils/command-helpers.js';
+import { track } from '../../utils/telemetry/index.js';
 import { getExistingContext, NTL_DEV_MCP_FILE_NAME, getContextConsumers, deleteFile, downloadAndWriteContextFiles, } from './context.js';
 export const description = 'Manage context files for AI tools';
 // context consumers endpoints returns all supported IDE and other consumers
@@ -114,8 +115,9 @@ export const run = async (runOptions) => {
         log('No context files found for this consumer. Try again or let us know if this happens again via our support channels.');
         return;
     }
+    let wroteFiles = false;
     try {
-        await downloadAndWriteContextFiles(consumer, runOptions);
+        wroteFiles = await downloadAndWriteContextFiles(consumer, runOptions);
         // the deprecated MCP file path
         // let's remove that file if it exists.
         const priorContextFilePath = resolve(command?.workingDir ?? '', consumer.path, NTL_DEV_MCP_FILE_NAME);
@@ -128,5 +130,8 @@ export const run = async (runOptions) => {
     catch (error) {
         logAndThrowError(error);
     }
+    if (wroteFiles) {
+        await track('sites_aiContextInstalled', { consumer: consumer.key });
+    }
 };
 //# sourceMappingURL=index.js.map

package/dist/utils/agent-detection.d.ts

@@ -0,0 +1,11 @@
+export declare const CANONICAL_AGENT_NAMES: readonly ['claude', 'codex', 'copilot', 'gemini', 'cursor', 'opencode', 'kiro', 'cline', 'amp', 'warp', 'claudeai', 'chatgpt', 'other'];
+export type CanonicalAgentName = (typeof CANONICAL_AGENT_NAMES)[number];
+export type DrivingAgent = {
+    name: CanonicalAgentName;
+    source: string;
+    version?: string;
+    markers?: CanonicalAgentName[];
+    otherValue?: string;
+};
+export declare const getDrivingAgent: (env?: NodeJS.ProcessEnv) => DrivingAgent | undefined;
+//# sourceMappingURL=agent-detection.d.ts.map

package/dist/utils/agent-detection.js

@@ -0,0 +1,151 @@
+// Only markers an agent product sets on its own count as a signal; never infer from process names, terminals, or the process tree.
+// The result is untrusted attribution from the environment, for telemetry and labeling only, never for authorization.
+export const CANONICAL_AGENT_NAMES = [
+    'claude',
+    'codex',
+    'copilot',
+    'gemini',
+    'cursor',
+    'opencode',
+    'kiro',
+    'cline',
+    'amp',
+    'warp',
+    'claudeai',
+    'chatgpt',
+    'other',
+];
+const ANNOUNCED_NAME_TABLE = new Map([
+    ...CANONICAL_AGENT_NAMES.filter((name) => name !== 'other').map((name) => [name, name]),
+    ['claude-code', 'claude'],
+    ['claude-ai', 'claudeai'],
+    ['github-copilot', 'copilot'],
+    ['github-copilot-cli', 'copilot'],
+    ['github-copilot-vscode-agent', 'copilot'],
+    ['cursor-cli', 'cursor'],
+    ['gemini-cli', 'gemini'],
+    ['kiro-cli', 'kiro'],
+    ['warp-oz', 'warp'],
+]);
+const lookupAnnouncedName = (key) => ANNOUNCED_NAME_TABLE.get(key.replace(/_/g, '-'));
+const sanitizeAnnouncedValue = (raw) => raw.replace(/[^A-Za-z0-9_.-]/g, '').slice(0, 64);
+const nonEmpty = (value) => (value ? value : undefined);
+const parseAnnouncedName = (raw) => {
+    const atIndex = raw.indexOf('@');
+    const sanitized = sanitizeAnnouncedValue(atIndex === -1 ? raw : raw.slice(0, atIndex));
+    if (sanitized === '') {
+        return undefined;
+    }
+    const announcedVersion = atIndex === -1 ? undefined : nonEmpty(sanitizeAnnouncedValue(raw.slice(atIndex + 1)));
+    const key = sanitized.toLowerCase();
+    const exact = lookupAnnouncedName(key);
+    if (exact) {
+        return { name: exact, version: announcedVersion };
+    }
+    const withoutAgentSuffix = key.replace(/_agent$/, '');
+    const suffixMatch = lookupAnnouncedName(withoutAgentSuffix);
+    if (suffixMatch) {
+        return { name: suffixMatch, version: announcedVersion };
+    }
+    const lastUnderscore = withoutAgentSuffix.lastIndexOf('_');
+    if (lastUnderscore !== -1) {
+        const head = withoutAgentSuffix.slice(0, lastUnderscore);
+        const headMatch = lookupAnnouncedName(head);
+        if (headMatch) {
+            const tail = withoutAgentSuffix.slice(lastUnderscore + 1);
+            return { name: headMatch, version: announcedVersion ?? tail.replace(/-/g, '.') };
+        }
+    }
+    return { name: 'other', otherValue: sanitized, version: announcedVersion };
+};
+// Precedence, first match wins: NETLIFY_AGENT (explicit, even when unknown); markers only the process
+// running the command sets; AI_AGENT (explicit, even when unknown); markers inherited from an agent
+// session; runner/task markers such as Warp's last, since the agent inside the run is the more specific answer.
+const SIGNALS = [
+    {
+        source: 'NETLIFY_AGENT',
+        detect: (env) => (env.NETLIFY_AGENT === undefined ? undefined : parseAnnouncedName(env.NETLIFY_AGENT)),
+    },
+    {
+        source: 'CODEX_CI',
+        detect: (env) => (env.CODEX_CI === '1' ? { name: 'codex' } : undefined),
+    },
+    {
+        source: 'GEMINI_CLI',
+        detect: (env) => (env.GEMINI_CLI === '1' ? { name: 'gemini' } : undefined),
+    },
+    {
+        source: 'COPILOT_CLI',
+        detect: (env) => (env.COPILOT_CLI === '1' ? { name: 'copilot' } : undefined),
+    },
+    {
+        source: 'COPILOT_AGENT_SESSION_ID',
+        detect: (env) => (nonEmpty(env.COPILOT_AGENT_SESSION_ID) === undefined ? undefined : { name: 'copilot' }),
+    },
+    {
+        source: 'OPENCODE',
+        detect: (env) => env.OPENCODE === '1' && nonEmpty(env.OPENCODE_TERMINAL) === undefined ? { name: 'opencode' } : undefined,
+    },
+    {
+        source: 'AGENT_DISPLAY_OUT',
+        detect: (env) => nonEmpty(env.AGENT_DISPLAY_OUT) !== undefined && nonEmpty(env.AGENT_CONTEXT_OUT) !== undefined
+            ? { name: 'kiro' }
+            : undefined,
+    },
+    {
+        source: 'AI_AGENT',
+        detect: (env) => (env.AI_AGENT === undefined ? undefined : parseAnnouncedName(env.AI_AGENT)),
+    },
+    {
+        source: 'COPILOT_AGENT',
+        detect: (env) => (env.COPILOT_AGENT === '1' ? { name: 'copilot' } : undefined),
+    },
+    {
+        source: 'CURSOR_AGENT',
+        detect: (env) => (env.CURSOR_AGENT === '1' ? { name: 'cursor' } : undefined),
+    },
+    {
+        source: 'CLINE_ACTIVE',
+        detect: (env) => (env.CLINE_ACTIVE === 'true' ? { name: 'cline' } : undefined),
+    },
+    {
+        source: 'AGENT',
+        detect: (env) => (env.AGENT === 'amp' ? { name: 'amp' } : undefined),
+    },
+    {
+        source: 'CLAUDE_CODE_CHILD_SESSION',
+        detect: (env) => (env.CLAUDE_CODE_CHILD_SESSION === '1' ? { name: 'claude' } : undefined),
+    },
+    {
+        source: 'OZ_RUN_ID',
+        detect: (env) => (nonEmpty(env.OZ_RUN_ID) === undefined ? undefined : { name: 'warp' }),
+    },
+    {
+        source: 'WARP_RUN_ID',
+        detect: (env) => (nonEmpty(env.WARP_RUN_ID) === undefined ? undefined : { name: 'warp' }),
+    },
+];
+export const getDrivingAgent = (env = process.env) => {
+    const matches = [];
+    for (const signal of SIGNALS) {
+        const result = signal.detect(env);
+        if (result) {
+            matches.push({ source: signal.source, ...result });
+        }
+    }
+    if (matches.length === 0) {
+        return undefined;
+    }
+    const [winner] = matches;
+    const codexVersion = winner.source === 'CODEX_CI' ? nonEmpty(env.CODEX_VERSION) : undefined;
+    const version = winner.version ?? (codexVersion === undefined ? undefined : sanitizeAnnouncedValue(codexVersion));
+    const distinctNames = [...new Set(matches.map((match) => match.name))];
+    return {
+        name: winner.name,
+        source: winner.source,
+        ...(version ? { version } : {}),
+        ...(distinctNames.length >= 2 ? { markers: distinctNames } : {}),
+        ...(winner.name === 'other' ? { otherValue: winner.otherValue ?? '' } : {}),
+    };
+};
+//# sourceMappingURL=agent-detection.js.map

package/dist/utils/command-helpers.d.ts

@@ -15,6 +15,7 @@ export type ChalkInstance = ChalkInstancePrimitiveType;
 export declare const padLeft: (str: string, count: number, filler?: string) => string;
 export declare const version: string;
 export declare const USER_AGENT: string;
+export declare const getRequestUserAgent: (env?: NodeJS.ProcessEnv) => string;
 export declare const NETLIFY_CYAN: ChalkInstancePrimitiveType;
 export declare const NETLIFY_CYAN_HEX = "#28b5ac";
 export declare const NETLIFYDEVLOG: string;

package/dist/utils/command-helpers.js

@@ -7,6 +7,7 @@ import { Chalk } from 'chalk';
 import WSL from 'is-wsl';
 import terminalLink from 'terminal-link';
 import { startSpinner } from '../lib/spinner.js';
+import { getDrivingAgent } from './agent-detection.js';
 import getCLIPackageJson from './get-cli-package-json.js';
 import { reportError } from './telemetry/report-error.js';
 /** The parsed process argv without the binary only arguments and flags */
@@ -38,6 +39,10 @@ const arch = os.arch() === 'ia32' ? 'x86' : os.arch();
 const { name, version: packageVersion } = await getCLIPackageJson();
 export const version = packageVersion;
 export const USER_AGENT = `${name}/${version} ${platform}-${arch} node-${process.version}`;
+export const getRequestUserAgent = (env = process.env) => {
+    const agent = getDrivingAgent(env);
+    return agent ? `${USER_AGENT} agent/${agent.name}` : USER_AGENT;
+};
 /** A list of base command flags that needs to be sorted down on documentation and on help pages */
 const BASE_FLAGS = new Set(['--debug', '--http-proxy', '--http-proxy-certificate-filename']);
 export const NETLIFY_CYAN = chalk.rgb(40, 180, 170);

package/dist/utils/login-url.d.ts

@@ -0,0 +1,2 @@
+export declare const buildAuthorizeUrl: (ticketId: string, env?: NodeJS.ProcessEnv) => string;
+//# sourceMappingURL=login-url.d.ts.map

package/dist/utils/login-url.js

@@ -0,0 +1,25 @@
+import { getDrivingAgent } from './agent-detection.js';
+// By contract these two hold only a non-sensitive agent name[@version]. Every other marker's value is a flag,
+// a session or run id, or a path, none of which may reach a URL.
+const SOURCES_WITH_ANNOUNCED_VALUE = new Set(['NETLIFY_AGENT', 'AI_AGENT']);
+const sanitizeUtmTerm = (raw) => raw.replace(/[^A-Za-z0-9_.:@-]/g, '').slice(0, 64);
+const getUtmTerm = (source, env) => {
+    const value = SOURCES_WITH_ANNOUNCED_VALUE.has(source) ? env[source] : undefined;
+    return sanitizeUtmTerm(value ? `${source}:${value}` : source);
+};
+export const buildAuthorizeUrl = (ticketId, env = process.env) => {
+    const webUI = env.NETLIFY_WEB_UI || 'https://app.netlify.com';
+    const params = new URLSearchParams({
+        response_type: 'ticket',
+        ticket: ticketId,
+        utm_source: 'cli',
+        utm_campaign: 'integrations',
+    });
+    const agent = getDrivingAgent(env);
+    if (agent) {
+        params.set('utm_content', agent.name);
+        params.set('utm_term', getUtmTerm(agent.source, env));
+    }
+    return `${webUI}/authorize?${params.toString()}`;
+};
+//# sourceMappingURL=login-url.js.map

package/dist/utils/telemetry/telemetry.js

@@ -3,6 +3,7 @@ import process, { version as nodejsVersion } from 'process';
 import { fileURLToPath } from 'url';
 import { getGlobalConfigStore } from '@netlify/dev-utils';
 import { isCI } from 'ci-info';
+import { getDrivingAgent } from '../agent-detection.js';
 import execa from '../execa.js';
 import { isTelemetryDisabled, cliVersion } from './utils.js';
 import isValidEventName from './validation.js';
@@ -36,6 +37,18 @@ const eventConfig = {
         'user',
     ],
 };
+// Every key is always present so a caller's payload can never supply its own agent attribution;
+// undefined values are dropped when the event is serialized.
+const getAgentProperties = () => {
+    const agent = getDrivingAgent();
+    return {
+        agent: agent?.name,
+        agent_source: agent?.source,
+        agent_version: agent?.version,
+        agent_markers: agent?.markers,
+        agent_other_value: agent?.otherValue,
+    };
+};
 /**
  * Tracks a custom event with the provided payload
  */
@@ -65,7 +78,7 @@ export async function track(eventName, payload = {}) {
         anonymousId: cliId,
         duration,
         status,
-        properties: { ...properties, nodejsVersion, cliVersion },
+        properties: { ...properties, nodejsVersion, cliVersion, ...getAgentProperties() },
     };
     return send('track', defaultData);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "netlify-cli",
-  "version": "27.5.1",
+  "version": "27.6.0",
   "description": "Netlify command line tool",
   "keywords": [
     "api",
@@ -56,9 +56,9 @@
     "@netlify/ai": "^1.0.1",
     "@netlify/api": "^15.1.2",
     "@netlify/blobs": "^11.0.3",
-    "@netlify/build": "^36.4.7",
+    "@netlify/build": "^36.4.8",
     "@netlify/build-info": "^11.3.0",
-    "@netlify/config": "^25.2.4",
+    "@netlify/config": "^25.2.5",
     "@netlify/dev": "^5.0.5",
     "@netlify/dev-utils": "^6.0.1",
     "@netlify/edge-bundler": "^16.0.4",
@@ -68,7 +68,7 @@
     "@netlify/images": "^2.0.1",
     "@netlify/local-functions-proxy": "^2.0.3",
     "@netlify/redirect-parser": "^16.1.1",
-    "@netlify/zip-it-and-ship-it": "^15.5.0",
+    "@netlify/zip-it-and-ship-it": "^15.5.1",
     "@octokit/rest": "^22.0.0",
     "@opentelemetry/api": "^1.8.0",
     "@pnpm/tabtab": "^0.5.4",