@depup/nx 23.2.1-depup.8 → 23.3.0-depup.0

package/dist/src/ultracache/config.d.ts

@@ -0,0 +1,21 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+export interface UltracacheCloudOptions {
+    accessToken?: string;
+    nxCloudId?: string;
+    url?: string;
+    cloud?: boolean;
+}
+export interface UltracacheEnv {
+    NX_CLOUD_USE_ULTRACACHE?: string;
+    NX_NO_CLOUD?: string;
+    /** Whether the run's env holds an Nx Cloud token. */
+    hasNxCloudToken?: boolean;
+}
+/**
+ * Off unless a CI run opts in with `NX_CLOUD_USE_ULTRACACHE=true` in a
+ * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
+ * `env` defaults to this process's.
+ */
+export declare function isUltracacheConfigurationFetchEnabled(nxJson: NxJsonConfiguration, runnerOptions?: UltracacheCloudOptions, env?: UltracacheEnv): boolean;
+/** The subset of this run's environment the decision reads. */
+export declare function ultracacheEnv(env?: NodeJS.ProcessEnv): UltracacheEnv;

package/dist/src/ultracache/config.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUltracacheConfigurationFetchEnabled = isUltracacheConfigurationFetchEnabled;
+exports.ultracacheEnv = ultracacheEnv;
+const is_ci_1 = require("../utils/is-ci");
+const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
+/**
+ * Off unless a CI run opts in with `NX_CLOUD_USE_ULTRACACHE=true` in a
+ * workspace that uses Nx Cloud, since there is nothing to fetch from otherwise.
+ * `env` defaults to this process's.
+ */
+function isUltracacheConfigurationFetchEnabled(nxJson, runnerOptions = {}, env = ultracacheEnv()) {
+    if (env.NX_NO_CLOUD === 'true' ||
+        nxJson.neverConnectToCloud ||
+        runnerOptions.cloud === false ||
+        env.NX_CLOUD_USE_ULTRACACHE !== 'true' ||
+        !(0, is_ci_1.isCI)()) {
+        return false;
+    }
+    return !!env.hasNxCloudToken || (0, nx_cloud_utils_1.isNxCloudConfigured)(nxJson);
+}
+/** The subset of this run's environment the decision reads. */
+function ultracacheEnv(env = process.env) {
+    return {
+        NX_CLOUD_USE_ULTRACACHE: env.NX_CLOUD_USE_ULTRACACHE,
+        NX_NO_CLOUD: env.NX_NO_CLOUD,
+        hasNxCloudToken: !!(env.NX_CLOUD_ACCESS_TOKEN || env.NX_CLOUD_AUTH_TOKEN),
+    };
+}

package/dist/src/ultracache/fetch.d.ts

@@ -0,0 +1,21 @@
+import type { UltracacheCloudOptions } from './config';
+/** The Nx Cloud client's `readUltracacheConfigurations` contract, as far as nx uses it. */
+export interface ReadUltracacheConfigurationsOptions {
+    workspaceRoot?: string;
+    nxCloudOptions?: UltracacheCloudOptions;
+    timeoutMs?: number;
+}
+export interface ReadUltracacheConfiguration {
+    commit: string;
+    inputs: readonly string[];
+    outputs: readonly string[];
+}
+export interface ReadUltracacheConfigurationsResult {
+    configurations: Readonly<Record<string, ReadUltracacheConfiguration>>;
+}
+/**
+ * Reads HEAD's Ultracache configurations from Nx Cloud. Throws with a `code`
+ * saying why it could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_CONFIGURATIONS`.
+ */
+export declare function fetchUltracacheConfigurations(runnerOptions: UltracacheCloudOptions): Promise<ReadUltracacheConfigurationsResult>;

package/dist/src/ultracache/fetch.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUltracacheConfigurations = fetchUltracacheConfigurations;
+const resolution_helpers_1 = require("../nx-cloud/resolution-helpers");
+const update_manager_1 = require("../nx-cloud/update-manager");
+const workspace_root_1 = require("../utils/workspace-root");
+const READ_TIMEOUT_MS = 10_000;
+/**
+ * Reads HEAD's Ultracache configurations from Nx Cloud. Throws with a `code`
+ * saying why it could not: the client's own, or `NO_CLOUD_CLIENT`, `UNSUPPORTED_CLIENT` or
+ * `NO_CONFIGURATIONS`.
+ */
+async function fetchUltracacheConfigurations(runnerOptions) {
+    const client = await loadCloudClient(runnerOptions).catch((e) => {
+        throw codedError('NO_CLOUD_CLIENT', e instanceof Error ? e.message : String(e));
+    });
+    if (!client) {
+        throw codedError('NO_CLOUD_CLIENT', 'The Nx Cloud client could not be loaded');
+    }
+    if (typeof client.readUltracacheConfigurations !== 'function') {
+        throw codedError('UNSUPPORTED_CLIENT', 'The installed Nx Cloud client does not expose Ultracache configurations; update nx-cloud');
+    }
+    const result = await client.readUltracacheConfigurations({
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        nxCloudOptions: runnerOptions,
+        timeoutMs: READ_TIMEOUT_MS,
+    });
+    if (!result) {
+        // The client returns `null` only for a `knownUpdatedAt` match, which nx
+        // never sends; treat it as nothing to serve rather than a broken reply.
+        throw codedError('NO_CONFIGURATIONS', 'Nx Cloud returned no Ultracache configurations');
+    }
+    return result;
+}
+async function loadCloudClient(runnerOptions) {
+    const client = (await (0, update_manager_1.verifyOrUpdateNxCloudClient)(runnerOptions))
+        ?.nxCloudClient;
+    client?.configureLightClientRequire()((0, resolution_helpers_1.findAncestorNodeModules)(__dirname, []));
+    return client;
+}
+function codedError(code, message) {
+    return Object.assign(new Error(message), { code });
+}

package/dist/src/ultracache/overrides.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectGraph } from '../config/project-graph';
+import type { TaskGraph } from '../config/task-graph';
+import { type UltracacheEligibilityOptions, type UltracacheReport, type UltracacheConfigurations, type TaskUltracacheSettings } from '../native';
+/**
+ * Each task's Ultracache settings: all the native eligibility walk reads
+ * from a task. `null`, not `undefined`: the native map drops `undefined` keys.
+ */
+export declare function getUltracacheSettings(taskGraph: TaskGraph): Record<string, TaskUltracacheSettings | null>;
+/** The eligibility walk's view of the run's tasks, as JS resolves it. */
+export declare function ultracacheEligibilityOptions(projectGraph: ProjectGraph, taskGraph: TaskGraph): UltracacheEligibilityOptions;
+/**
+ * Reports which tasks in `taskGraph` hash from `configurations` and why the rest
+ * do not, with the same eligibility walk the planner uses, without building a
+ * planner (no project-graph transfer). Never fetches, never throws. Feeds
+ * the `--verbose` run summary.
+ */
+export declare function buildUltracacheOverrides(projectGraph: ProjectGraph, taskGraph: TaskGraph, configurations: UltracacheConfigurations): UltracacheReport;

package/dist/src/ultracache/overrides.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUltracacheSettings = getUltracacheSettings;
+exports.ultracacheEligibilityOptions = ultracacheEligibilityOptions;
+exports.buildUltracacheOverrides = buildUltracacheOverrides;
+const native_1 = require("../native");
+const project_graph_1 = require("../project-graph/project-graph");
+const utils_1 = require("../tasks-runner/utils");
+const customHasherMemo = new WeakMap();
+/**
+ * Tasks whose executor ships a custom hasher; they are never hashed from
+ * their Ultracache configuration. Detected here because executors are
+ * resolved in JS, by the factory's presence only — invoking it would load
+ * user modules.
+ */
+function customHasherTaskIds(projectGraph, taskGraph) {
+    const memoized = customHasherMemo.get(taskGraph);
+    if (memoized) {
+        return memoized;
+    }
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    const ids = Object.values(taskGraph.tasks)
+        .filter((task) => {
+        try {
+            return !!(0, utils_1.getExecutorForTask)(task, projects).hasherFactory;
+        }
+        catch {
+            // An unresolvable executor fails later, at execution; it is not a
+            // reason to withhold its configuration here.
+            return false;
+        }
+    })
+        .map((task) => task.id);
+    customHasherMemo.set(taskGraph, ids);
+    return ids;
+}
+/**
+ * Each task's Ultracache settings: all the native eligibility walk reads
+ * from a task. `null`, not `undefined`: the native map drops `undefined` keys.
+ */
+function getUltracacheSettings(taskGraph) {
+    return Object.fromEntries(Object.entries(taskGraph.tasks).map(([id, task]) => [
+        id,
+        task.ultracache ?? null,
+    ]));
+}
+/** The eligibility walk's view of the run's tasks, as JS resolves it. */
+function ultracacheEligibilityOptions(projectGraph, taskGraph) {
+    return {
+        customHasherTaskIds: customHasherTaskIds(projectGraph, taskGraph),
+    };
+}
+/**
+ * Reports which tasks in `taskGraph` hash from `configurations` and why the rest
+ * do not, with the same eligibility walk the planner uses, without building a
+ * planner (no project-graph transfer). Never fetches, never throws. Feeds
+ * the `--verbose` run summary.
+ */
+function buildUltracacheOverrides(projectGraph, taskGraph, configurations) {
+    return (0, native_1.getUltracacheReport)(configurations, getUltracacheSettings(taskGraph), ultracacheEligibilityOptions(projectGraph, taskGraph));
+}

package/dist/src/ultracache/report.d.ts

@@ -0,0 +1,13 @@
+import type { UltracacheReport } from '../native';
+export interface UltracacheSummary {
+    /** The heading, e.g. "Ultracache: 12 tasks hashed from their configuration, 3 fell back". */
+    line: string;
+    /** Per-reason detail under it. */
+    bodyLines: string[];
+}
+/**
+ * Formats the once-per-run verbose summary of a run that resolved Ultracache
+ * configurations: `result` is what hashing used, `status` whether they were
+ * fetched or already stored.
+ */
+export declare function formatUltracacheSummary(result: UltracacheReport, status: 'fetched' | 'cached'): UltracacheSummary;

package/dist/src/ultracache/report.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUltracacheSummary = formatUltracacheSummary;
+/**
+ * Formats the once-per-run verbose summary of a run that resolved Ultracache
+ * configurations: `result` is what hashing used, `status` whether they were
+ * fetched or already stored.
+ */
+function formatUltracacheSummary(result, status) {
+    const used = result.used.length;
+    const withheld = result.diagnostics.filter((d) => d.taskId != null);
+    const byReason = countByReason(withheld);
+    const fellBack = withheld.length;
+    const setLevel = result.diagnostics.find((d) => d.taskId == null);
+    const line = setLevel
+        ? `Ultracache: none used (unreadable configurations: ${setLevel.message})`
+        : `Ultracache: ${plural(used, 'task')} hashed from their configuration, ${plural(fellBack, 'task')} fell back${fellBack ? ` (${summarizeReasons(byReason)})` : ''}`;
+    const bodyLines = [`configurations: ${status}`];
+    bodyLines.push(`commit ${result.resolution.requestedCommit}, configurations for ${result.resolution.tasks} tasks`);
+    for (const d of result.diagnostics) {
+        bodyLines.push(describeDiagnostic(d));
+    }
+    return { line, bodyLines };
+}
+function describeDiagnostic(d) {
+    switch (d.reason) {
+        case 'unreadable-set':
+            return `unreadable Ultracache configurations: ${d.message}`;
+        case 'disabled':
+            return `${d.taskId}: ultracache.mode is off`;
+        case 'autofix-disabled':
+            return `${d.taskId}: ultracache.mode is not on`;
+        case 'custom-hasher':
+            return `${d.taskId}: uses a custom hasher`;
+        case 'missing':
+            return `${d.taskId}: no Ultracache configuration for this task`;
+        case 'invalid-glob':
+            return `${d.taskId}: configuration glob "${d.glob}" is not a valid files glob`;
+        case 'escapes-workspace':
+            return `${d.taskId}: configuration glob "${d.glob}" escapes the workspace`;
+        default:
+            return `${d.taskId ? `${d.taskId}: ` : ''}${d.reason}`;
+    }
+}
+function countByReason(diagnostics) {
+    const counts = new Map();
+    for (const d of diagnostics) {
+        if (d.taskId != null) {
+            counts.set(d.reason, (counts.get(d.reason) ?? 0) + 1);
+        }
+    }
+    return counts;
+}
+function summarizeReasons(counts) {
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+        .map(([reason, n]) => `${n} ${reason}`)
+        .join(', ');
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}

package/dist/src/ultracache/store.d.ts

@@ -0,0 +1,41 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
+import { UltracacheConfigurationStore, type UltracacheConfigurations } from '../native';
+import { type UltracacheCloudOptions, type UltracacheEnv } from './config';
+import { type ReadUltracacheConfigurationsResult } from './fetch';
+/**
+ * What resolving this run's Ultracache configurations came to. Only an
+ * outcome that resolved carries them.
+ */
+export type UltracacheConfigurationOutcome = {
+    status: 'fetched' | 'cached';
+    configurations: UltracacheConfigurations;
+} | {
+    status: 'skipped';
+    reason: string;
+    message: string;
+};
+export declare function skippedUltracacheOutcome(reason: string, message: string): UltracacheConfigurationOutcome;
+/** The configurations an outcome resolved to, if any. */
+export declare function configurationsOf(outcome: UltracacheConfigurationOutcome | null): UltracacheConfigurations | undefined;
+/** The Ultracache configuration store in this process's workspace database. */
+export declare function getUltracacheConfigurationStore(): UltracacheConfigurationStore;
+/**
+ * Stores the configurations the Nx Cloud client read for `requestedCommit` and
+ * returns their handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
+ */
+export declare function importUltracacheConfigurations(requestedCommit: string, configurations: ReadUltracacheConfigurationsResult['configurations']): UltracacheConfigurations;
+/**
+ * The stored version `importUltracacheConfigurations` returned, reopened by its commit and
+ * `resolution.fetchedAt`, so other processes hash from it without importing
+ * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
+ */
+export declare function openUltracacheConfigurations(commit: string, fetchedAt: number): UltracacheConfigurations | null;
+/**
+ * This run's Ultracache configurations for HEAD, in the process that owns the
+ * fetch: the newest stored set, otherwise what Nx Cloud reads, imported into
+ * the store. The Nx Cloud client imports a fresh set when each CI run starts,
+ * so a stored set is never older than its run. Returns `null` when Ultracache
+ * is not enabled for this workspace; never throws.
+ */
+export declare function loadUltracacheConfigurationsForRun(nxJson: NxJsonConfiguration, runnerOptions: UltracacheCloudOptions, env?: UltracacheEnv): Promise<UltracacheConfigurationOutcome | null>;

package/dist/src/ultracache/store.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skippedUltracacheOutcome = skippedUltracacheOutcome;
+exports.configurationsOf = configurationsOf;
+exports.getUltracacheConfigurationStore = getUltracacheConfigurationStore;
+exports.importUltracacheConfigurations = importUltracacheConfigurations;
+exports.openUltracacheConfigurations = openUltracacheConfigurations;
+exports.loadUltracacheConfigurationsForRun = loadUltracacheConfigurationsForRun;
+const path_1 = require("path");
+const native_1 = require("../native");
+const db_connection_1 = require("../utils/db-connection");
+const git_utils_1 = require("../utils/git-utils");
+const logger_1 = require("../utils/logger");
+const output_1 = require("../utils/output");
+const workspace_root_1 = require("../utils/workspace-root");
+const config_1 = require("./config");
+const fetch_1 = require("./fetch");
+function skippedUltracacheOutcome(reason, message) {
+    return { status: 'skipped', reason, message };
+}
+/** The configurations an outcome resolved to, if any. */
+function configurationsOf(outcome) {
+    return outcome && outcome.status !== 'skipped'
+        ? outcome.configurations
+        : undefined;
+}
+// Reasons that indicate misconfiguration rather than an expected offline
+// state or a client that simply predates Ultracache.
+const WARNED_REASONS = new Set([
+    'unauthorized',
+    'invalid-response',
+    'write-failed',
+]);
+/** The Ultracache configuration store in this process's workspace database. */
+function getUltracacheConfigurationStore() {
+    return new native_1.UltracacheConfigurationStore((0, db_connection_1.getDbConnection)());
+}
+/**
+ * Stores the configurations the Nx Cloud client read for `requestedCommit` and
+ * returns their handle, for `runDiscreteTasks` and `runContinuousTasks`. Exposed to the
+ * client through `nx/nx-cloud-internals`. Throws with the store's `code`.
+ */
+function importUltracacheConfigurations(requestedCommit, configurations) {
+    return getUltracacheConfigurationStore().import({
+        requestedCommit,
+        configurationsJson: JSON.stringify(configurations),
+    });
+}
+/**
+ * The stored version `importUltracacheConfigurations` returned, reopened by its commit and
+ * `resolution.fetchedAt`, so other processes hash from it without importing
+ * it again. `null` when it isn't stored. Exposed through `nx/nx-cloud-internals`.
+ */
+function openUltracacheConfigurations(commit, fetchedAt) {
+    return getUltracacheConfigurationStore().getVersion(commit, fetchedAt);
+}
+/**
+ * This run's Ultracache configurations for HEAD, in the process that owns the
+ * fetch: the newest stored set, otherwise what Nx Cloud reads, imported into
+ * the store. The Nx Cloud client imports a fresh set when each CI run starts,
+ * so a stored set is never older than its run. Returns `null` when Ultracache
+ * is not enabled for this workspace; never throws.
+ */
+async function loadUltracacheConfigurationsForRun(nxJson, runnerOptions, env = (0, config_1.ultracacheEnv)()) {
+    if (!(0, config_1.isUltracacheConfigurationFetchEnabled)(nxJson, runnerOptions, env)) {
+        return null;
+    }
+    const head = (0, git_utils_1.getLatestCommitSha)();
+    if (!head) {
+        return reportUltracacheConfigurationResolution(skippedUltracacheOutcome('not-a-git-repo', 'Could not resolve HEAD'));
+    }
+    try {
+        const store = getUltracacheConfigurationStore();
+        const cached = () => {
+            const stored = store.get(head);
+            return (stored &&
+                reportUltracacheConfigurationResolution({
+                    status: 'cached',
+                    configurations: stored,
+                }));
+        };
+        return (cached() ??
+            // Processes that miss together fetch once: the rest find its set.
+            (await withUltracacheConfigurationFetchLock(async () => {
+                const stored = cached();
+                if (stored) {
+                    return stored;
+                }
+                const result = await (0, fetch_1.fetchUltracacheConfigurations)(runnerOptions);
+                return reportUltracacheConfigurationResolution({
+                    status: 'fetched',
+                    configurations: store.import({
+                        requestedCommit: head,
+                        configurationsJson: JSON.stringify(result.configurations),
+                    }),
+                });
+            })));
+    }
+    catch (e) {
+        // No fallback to an older set for this commit: it would hash from a
+        // recording the run could not refresh, and CI can hash natively instead.
+        return reportUltracacheConfigurationResolution(skippedUltracacheOutcome(reasonFromError(e), errorMessage(e)));
+    }
+}
+/** Runs `fetch` holding a lock beside the workspace database, across processes. */
+async function withUltracacheConfigurationFetchLock(fetch) {
+    if (native_1.IS_WASM) {
+        return fetch();
+    }
+    const lock = new native_1.FileLock((0, path_1.join)((0, db_connection_1.sharedWorkspaceDataDirectory)(workspace_root_1.workspaceRoot), 'ultracache-configuration.lock'));
+    while (!lock.tryLock()) {
+        await lock.wait();
+    }
+    try {
+        return await fetch();
+    }
+    finally {
+        lock.unlock();
+    }
+}
+const OFFLINE_CODES = new Set([
+    'ECONNABORTED',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'ENOTFOUND',
+    'EAI_AGAIN',
+    'ETIMEDOUT',
+]);
+/** A skip reason from an error's `code`: from the Nx Cloud read or the store. */
+function reasonFromError(e) {
+    const code = e?.code;
+    if (typeof code !== 'string')
+        return 'fetch-failed';
+    if (OFFLINE_CODES.has(code))
+        return 'offline';
+    return code.toLowerCase().replace(/_/g, '-');
+}
+function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
+/** Warns or logs what a resolution came to. */
+function reportUltracacheConfigurationResolution(outcome) {
+    if (outcome.status === 'skipped') {
+        if (WARNED_REASONS.has(outcome.reason)) {
+            output_1.output.warn({
+                title: `Nx Cloud Ultracache configurations are unavailable (${outcome.reason})`,
+                bodyLines: [outcome.message, 'Tasks will be hashed without them.'],
+            });
+        }
+        else {
+            logger_1.logger.verbose(`Skipping Nx Cloud Ultracache configurations (${outcome.reason}): ${outcome.message}`);
+        }
+        return outcome;
+    }
+    const { resolution } = outcome.configurations;
+    logger_1.logger.verbose(`Nx Cloud Ultracache configurations ${outcome.status}: ${resolution.tasks} tasks for ${resolution.requestedCommit.slice(0, 12)}`);
+    return outcome;
+}

package/dist/src/utils/ab-testing.d.ts

@@ -1,4 +1,5 @@
 export declare const NX_CLOUD_URL = "https://nx.dev/nx-cloud";
+export declare const NX_CLOUD_DEMO_URL = "https://cloud.nx.app/demo/intro";
 /**
  * Clickable Nx Cloud marketing link for cloud prompt footers. The visible text
  * stays the clean `NX_CLOUD_URL` while clicks carry UTM attribution; terminals
@@ -7,6 +8,8 @@ export declare const NX_CLOUD_URL = "https://nx.dev/nx-cloud";
  * different commands.
  */
 export declare function nxCloudHyperlink(utmContent: string): string;
+/** Same as `nxCloudHyperlink`, pointing at the Nx Cloud demo (CLOUD-4640). */
+export declare function nxCloudDemoHyperlink(utmContent: string): string;
 /**
  * Meta payload types for recordStat telemetry (matches CNW format).
  */
@@ -25,7 +28,7 @@ export interface RecordStatMetaError {
     [key: string]: string | boolean;
 }
 export type RecordStatMeta = RecordStatMetaStart | RecordStatMetaComplete | RecordStatMetaError;
-export type MessageOptionKey = 'yes' | 'skip' | 'never';
+export type MessageOptionKey = 'yes' | 'skip';
 interface MessageData {
     code: string;
     message: string;

package/dist/src/utils/ab-testing.js

@@ -1,16 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.messages = exports.PromptMessages = exports.NX_CLOUD_URL = void 0;
+exports.messages = exports.PromptMessages = exports.NX_CLOUD_DEMO_URL = exports.NX_CLOUD_URL = void 0;
 exports.nxCloudHyperlink = nxCloudHyperlink;
+exports.nxCloudDemoHyperlink = nxCloudDemoHyperlink;
 exports.recordStat = recordStat;
-const tslib_1 = require("tslib");
 const node_child_process_1 = require("node:child_process");
 const is_ci_1 = require("./is-ci");
 const package_manager_1 = require("./package-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const terminal_link_1 = require("./terminal-link");
-const pc = tslib_1.__importStar(require("picocolors"));
+const http_client_1 = require("./http-client");
 exports.NX_CLOUD_URL = 'https://nx.dev/nx-cloud';
+exports.NX_CLOUD_DEMO_URL = 'https://cloud.nx.app/demo/intro';
 /**
  * Clickable Nx Cloud marketing link for cloud prompt footers. The visible text
  * stays the clean `NX_CLOUD_URL` while clicks carry UTM attribution; terminals
@@ -19,8 +20,14 @@ exports.NX_CLOUD_URL = 'https://nx.dev/nx-cloud';
  * different commands.
  */
 function nxCloudHyperlink(utmContent) {
-    const tracked = `${exports.NX_CLOUD_URL}?utm_source=nx-cli&utm_medium=cli&utm_campaign=nx-cloud-connect&utm_content=${utmContent}`;
-    return (0, terminal_link_1.terminalLink)(exports.NX_CLOUD_URL, tracked);
+    return trackedHyperlink(exports.NX_CLOUD_URL, utmContent);
+}
+/** Same as `nxCloudHyperlink`, pointing at the Nx Cloud demo (CLOUD-4640). */
+function nxCloudDemoHyperlink(utmContent) {
+    return trackedHyperlink(exports.NX_CLOUD_DEMO_URL, utmContent);
+}
+function trackedHyperlink(url, utmContent) {
+    return (0, terminal_link_1.terminalLink)(url, `${url}?utm_source=nx-cli&utm_medium=cli&utm_campaign=nx-cloud-connect&utm_content=${utmContent}`);
 }
 const messageOptions = {
     setupNxCloud: [
@@ -31,7 +38,6 @@ const messageOptions = {
             choices: [
                 { value: 'yes', name: 'Yes' },
                 { value: 'skip', name: 'Skip for now' },
-                { value: 'never', name: pc.dim("No, don't ask again") },
             ],
             footer: '\nFree for small teams. Remote caching and task distribution. 2-minute setup:',
         },
@@ -42,7 +48,6 @@ const messageOptions = {
             choices: [
                 { value: 'yes', name: 'Yes' },
                 { value: 'skip', name: 'Skip for now' },
-                { value: 'never', name: pc.dim("No, don't ask again") },
             ],
             footer: '\nLearn about it at',
             hint: `\n(it's free and can be disabled any time)`,
@@ -98,19 +103,17 @@ async function recordStat(opts) {
         if (!shouldRecordStats()) {
             return;
         }
-        const axios = require('axios');
-        await (axios['default'] ?? axios)
-            .create({
-            baseURL: (0, get_cloud_options_1.getCloudUrl)(),
+        await (0, http_client_1.httpRequest)(`${(0, get_cloud_options_1.getCloudUrl)()}/nx-cloud/stats`, {
+            method: 'POST',
             timeout: 400,
-        })
-            .post('/nx-cloud/stats', {
-            command: opts.command,
-            isCI: (0, is_ci_1.isCI)(),
-            useCloud: opts.useCloud,
-            meta: opts.meta
-                ? JSON.stringify({ ...opts.meta, nxVersion: opts.nxVersion })
-                : opts.nxVersion,
+            data: {
+                command: opts.command,
+                isCI: (0, is_ci_1.isCI)(),
+                useCloud: opts.useCloud,
+                meta: opts.meta
+                    ? JSON.stringify({ ...opts.meta, nxVersion: opts.nxVersion })
+                    : opts.nxVersion,
+            },
         });
     }
     catch (e) {

package/dist/src/utils/chunkify.d.ts

@@ -1,10 +1,4 @@
-export declare function chunkify(target: string[], maxChunkLength?: number, 
-/**
- * How long each entry will be once it reaches the command line. Callers that
- * quote or escape afterwards pass that transformation's length here, so the
- * chunk is sized against what is actually spawned rather than the raw string.
- */
-measure?: (item: string) => number): string[][];
+export declare function chunkify(target: string[], maxChunkLength?: number): string[][];
 /**
  * Get the maximum length of a command-line argument string based on current platform
  *

package/dist/src/utils/chunkify.js

@@ -3,18 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.chunkify = chunkify;
 exports.getMaxArgLength = getMaxArgLength;
 const TERMINAL_SIZE = getMaxArgLength();
-function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500, 
-/**
- * How long each entry will be once it reaches the command line. Callers that
- * quote or escape afterwards pass that transformation's length here, so the
- * chunk is sized against what is actually spawned rather than the raw string.
- */
-measure = (item) => item.length) {
+function chunkify(target, maxChunkLength = TERMINAL_SIZE - 500) {
     const chunks = [];
     let currentChunk = [];
     let currentChunkLength = 0;
     for (const file of target) {
-        const length = measure(file);
+        const length = file.length;
         if (
         // Prevent empty chunk if first file path is longer than maxChunkLength
         currentChunk.length &&

package/dist/src/utils/command-line-utils.d.ts

@@ -1,6 +1,7 @@
 import type { Arguments } from 'yargs';
 import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
+import type { OutputStyle } from '../command-line/yargs-utils/shared-options';
 export interface RawNxArgs extends NxArgs {
     prod?: boolean;
 }
@@ -27,7 +28,26 @@ export interface NxArgs {
     select?: string;
     graph?: string | boolean;
     skipNxCache?: boolean;
+    explain?: string | boolean;
     skipRemoteCache?: boolean;
+    /**
+     * The style the user named - CLI flag or `NX_DEFAULT_OUTPUT_STYLE`. Left
+     * undefined when they named none, and that absence is load-bearing: it is how
+     * the streaming and renderer-selection decisions tell "the user wants static"
+     * from "we defaulted to static", which stream continuous tasks differently.
+     */
+    specifiedOutputStyle?: OutputStyle;
+    /**
+     * What the run actually renders with, after the TUI, agent and failures-only
+     * defaults are applied. Always set. Every decision about what to PRINT reads
+     * this; every decision about what the user ASKED FOR reads the field above.
+     */
+    resolvedOutputStyle?: OutputStyle;
+    /**
+     * @deprecated Read `specifiedOutputStyle` for what the user named, or
+     * `resolvedOutputStyle` for what the run renders with. This will be removed
+     * in Nx 24.
+     */
     outputStyle?: string;
     tui?: boolean;
     nxBail?: boolean;