nx 23.3.0-beta.7 → 23.3.0-beta.9

package/dist/src/native/index.d.ts

@@ -97,13 +97,13 @@ export declare class HashPlanInspector {
 export declare class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
   /**
-   * `snapshots` is this run's I/O snapshot set; a task with an eligible
-   * entry hashes its observed reads instead of its declared filesets.
+   * `configurations` is this run's Ultracache configurations; a task with an
+   * eligible entry hashes its observed reads instead of its declared filesets.
    * `options` carries the task ids decided in JS, where executors and
    * target configuration are resolved.
    */
-  getPlans(taskIds: Array<string>, taskGraph: TaskGraph, snapshots?: IoSnapshots | undefined | null, options?: IoSnapshotEligibilityOptions | undefined | null): Record<string, string[]>
-  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph, snapshots?: IoSnapshots | undefined | null, options?: IoSnapshotEligibilityOptions | undefined | null): ExternalObject<Record<string, Array<HashInstruction>>>
+  getPlans(taskIds: Array<string>, taskGraph: TaskGraph, configurations?: UltracacheConfigurations | undefined | null, options?: UltracacheEligibilityOptions | undefined | null): Record<string, string[]>
+  getPlansReference(taskIds: Array<string>, taskGraph: TaskGraph, configurations?: UltracacheConfigurations | undefined | null, options?: UltracacheEligibilityOptions | undefined | null): ExternalObject<Record<string, Array<HashInstruction>>>
 }
 
 export declare class HttpRemoteCache {
@@ -127,43 +127,6 @@ export declare class ImportResult {
   staticImportExpressions: Array<string>
 }
 
-/**
- * One stored version of a commit's snapshot set. Handed to the hash planner as-is.
- * A fresh import holds every entry; a handle reopened from storage reads
- * them per task as they are asked for and remembers them, so it costs the
- * tasks it plans rather than the workspace's whole set.
- */
-export declare class IoSnapshots {
-  get commit(): string
-  get resolution(): IoSnapshotResolution
-}
-
-/**
- * The workspace database's snapshot sets. Each import is its own version,
- * keyed by commit and fetch time, so a run that pinned one keeps reading it
- * while a newer one is imported. Failures throw with a `code` JS maps to a
- * skip reason: `STORE_UNAVAILABLE`, `INVALID_RESPONSE` or `WRITE_FAILED`.
- */
-export declare class IoSnapshotStore {
-  constructor(db: ExternalObject<NxDbConnection>)
-  /**
-   * Stores the set the Nx Cloud client read for `requested_commit` as a new
-   * version, and returns it with every entry in hand.
-   */
-  import(options: IoSnapshotImportOptions): IoSnapshots
-  /**
-   * The newest stored set for `commit`, without touching the network;
-   * `null` when none is stored, its row cannot be read, or it was fetched
-   * more than `max_age_ms` ago. Reads only the version's summary row.
-   */
-  get(commit: string, maxAgeMs?: number | undefined | null): IoSnapshots | null
-  /**
-   * Exactly the version of `commit` fetched at `fetched_at`; `null` when it
-   * is not stored or its row cannot be read.
-   */
-  getVersion(commit: string, fetchedAt: number): IoSnapshots | null
-}
-
 export declare class NxCache {
   cacheDirectory: string
   constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<NxDbConnection>, linkTaskDetails?: boolean | undefined | null, maxCacheSize?: number | undefined | null)
@@ -325,6 +288,43 @@ export declare class TaskInvocationTracker {
   cleanupStale(): void
 }
 
+/**
+ * One stored version of a commit's Ultracache configurations. Handed to the hash planner as-is.
+ * A fresh import holds every entry; a handle reopened from storage reads
+ * them per task as they are asked for and remembers them, so it costs the
+ * tasks it plans rather than the workspace's whole set.
+ */
+export declare class UltracacheConfigurations {
+  get commit(): string
+  get resolution(): UltracacheConfigurationResolution
+}
+
+/**
+ * The workspace database's Ultracache configurations. Each import is its own version,
+ * keyed by commit and fetch time, so a run that pinned one keeps reading it
+ * while a newer one is imported. Failures throw with a `code` JS maps to a
+ * skip reason: `STORE_UNAVAILABLE`, `INVALID_RESPONSE` or `WRITE_FAILED`.
+ */
+export declare class UltracacheConfigurationStore {
+  constructor(db: ExternalObject<NxDbConnection>)
+  /**
+   * Stores the set the Nx Cloud client read for `requested_commit` as a new
+   * version, and returns it with every entry in hand.
+   */
+  import(options: UltracacheConfigurationImportOptions): UltracacheConfigurations
+  /**
+   * The newest stored set for `commit`, without touching the network;
+   * `null` when none is stored, its row cannot be read, or it was fetched
+   * more than `max_age_ms` ago. Reads only the version's summary row.
+   */
+  get(commit: string, maxAgeMs?: number | undefined | null): UltracacheConfigurations | null
+  /**
+   * Exactly the version of `commit` fetched at `fetched_at`; `null` when it
+   * is not stored or its row cannot be read.
+   */
+  getVersion(commit: string, fetchedAt: number): UltracacheConfigurations | null
+}
+
 export declare class WorkspaceContext {
   workspaceRoot: string
   constructor(workspaceRoot: string, cacheDir: string, options?: WorkspaceContextOptions | undefined | null)
@@ -435,6 +435,29 @@ export interface AffectedOptions {
   workspaceRoot: string
 }
 
+/**
+ * Why the change reached each task. Covers every task it reached, not just
+ * the selection, so a reason naming a producer can be looked up too.
+ */
+export interface AffectedTaskExplanation {
+  /**
+   * The reached tasks the change touched directly, sorted: a matched input,
+   * or always touched. Every other reached task was carried through outputs.
+   */
+  touched: Array<string>
+  /** Consumer -> the reached producers whose outputs it reads. */
+  producersOf: Record<string, Array<string>>
+  /** Changed project configs no longer on disk. Every task was seeded for them. */
+  deletedProjectConfigs: Array<string>
+  /**
+   * What each matching plan instruction matched. Shared rather than copied
+   * per task: one lib's fileset can be in the plan of every dependent.
+   */
+  inputMatches: Array<TaskInputMatches>
+  /** Per reached task, the indexes of the matches above that its plan holds. */
+  taskInputMatches: Record<string, Array<number>>
+}
+
 export declare function affectedTasks(projectGraph: ExternalObject<ProjectGraph>, hashPlans: ExternalObject<Record<string, Array<HashInstruction>>>, taskGraph: TaskGraph, changedFiles: Array<string>, options: AffectedTasksOptions): AffectedTaskSelection
 
 export interface AffectedTaskSelection {
@@ -442,6 +465,8 @@ export interface AffectedTaskSelection {
   affected: Array<string>
   /** `affected` plus everything it depends on, sorted: what a run keeps. */
   required: Array<string>
+  /** Why the change reached each task. Only when `explain` was asked for. */
+  explanation?: AffectedTaskExplanation
 }
 
 export interface AffectedTasksOptions {
@@ -490,6 +515,8 @@ export interface AffectedTasksOptions {
    * project's tsconfig `paths` entries, rather than none.
    */
   selectivelyHashTsConfig: boolean
+  /** Whether to return why each task was reached, for `--explain`. */
+  explain: boolean
 }
 
 export interface BatchInfo {
@@ -712,31 +739,26 @@ export declare function getFilesForOutputsBatch(directory: string, entriesBatch:
  */
 export declare function getHardcodedIgnorePatterns(): Array<string>
 
-/**
- * Tasks whose snapshot read another task's outputs: they hash after their
- * producers ran, because those files only exist then. Needs no project graph,
- * so the client can call it before the first hashing wave on the daemon path.
- * Opted-out and custom-hasher tasks are not excluded: deferring a task that
- * ends up hashed natively only delays its hash, it never changes it.
- */
-export declare function getIoSnapshotDeferredTaskIds(snapshots: IoSnapshots, taskGraph: TaskGraph): Array<string>
-
-/** The eligibility report, for the run summary. */
-export declare function getIoSnapshotReport(snapshots: IoSnapshots, tasks: Record<string, TaskUltracacheConfiguration | null>, options?: IoSnapshotEligibilityOptions | undefined | null): IoSnapshotReport
-
 /**
  * If `workspace_root` is inside a git worktree, returns the main repo root.
  * Returns `None` when already in the main repo (or not in a git repo at all).
  */
 export declare function getMainWorktreeRoot(workspaceRoot: string): string | null
 
+export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
+
 /**
- * Observed outputs per eligible task, for the runner to union into
- * `task.outputs`.
+ * Tasks whose Ultracache configuration read another task's outputs: they
+ * hash after their producers ran, because those files only exist then. Needs
+ * no project graph, so the client can call it before the first hashing wave
+ * on the daemon path.
+ * Opted-out and custom-hasher tasks are not excluded: deferring a task that
+ * ends up hashed natively only delays its hash, it never changes it.
  */
-export declare function getObservedIoSnapshotOutputs(snapshots: IoSnapshots, tasks: Record<string, TaskUltracacheConfiguration | null>, options?: IoSnapshotEligibilityOptions | undefined | null): Record<string, Array<string>>
+export declare function getUltracacheDeferredTaskIds(configurations: UltracacheConfigurations, taskGraph: TaskGraph): Array<string>
 
-export declare function getTransformableOutputs(outputs: Array<string>): Array<string>
+/** The eligibility report, for the run summary. */
+export declare function getUltracacheReport(configurations: UltracacheConfigurations, tasks: Record<string, TaskUltracacheSettings | null>, options?: UltracacheEligibilityOptions | undefined | null): UltracacheReport
 
 /**
  * Group information - union of different process group types
@@ -815,6 +837,16 @@ export declare function initializeTelemetry(connection: ExternalObject<NxDbConne
  */
 export declare function initializeTelemetryWithSessionId(sessionId: string, workspaceId: string, userId: string | undefined | null, nxVersion: string, packageManagerName: string, packageManagerVersion: string | undefined | null, nodeVersion: string, osArch: string, osPlatform: string, osRelease: string, isCi: boolean, isNxCloud: boolean): void
 
+/** A changed file that reached a task, and the input pattern it reached it by. */
+export interface InputMatch {
+  file: string
+  /**
+   * The fileset that matched. Absent for an instruction with no pattern to
+   * name, such as the root tsconfig.
+   */
+  pattern?: string
+}
+
 export interface InputsInput {
   input: string
   dependencies?: boolean
@@ -830,46 +862,6 @@ export interface InvocationRecord {
   taskId: string
 }
 
-/**
- * Why a task (or the whole run) hashes natively; `reason` is rendered by the
- * run summary.
- */
-export interface IoSnapshotDiagnostic {
-  reason: string
-  taskId?: string
-  glob?: string
-  message?: string
-}
-
-/** What JS knows about a run's tasks that the eligibility walk needs. */
-export interface IoSnapshotEligibilityOptions {
-  /** Tasks whose executor ships a custom hasher. */
-  customHasherTaskIds?: Array<string>
-}
-
-/** The snapshot set the Nx Cloud client read for HEAD, as JS hands it over. */
-export interface IoSnapshotImportOptions {
-  requestedCommit: string
-  /** `Record<taskId, { commit, inputs, outputs }>` as JSON. */
-  snapshotsJson: string
-}
-
-export interface IoSnapshotReport {
-  /** Task ids hashed from their snapshot. */
-  used: Array<string>
-  /** Subset of `used` whose snapshot also contributes observed outputs. */
-  tasksWithOutputs: Array<string>
-  diagnostics: Array<IoSnapshotDiagnostic>
-  resolution: IoSnapshotResolution
-}
-
-/** What was resolved for a commit; stored beside its entries. */
-export interface IoSnapshotResolution {
-  requestedCommit: string
-  fetchedAt: number
-  tasks: number
-}
-
 export const IS_WASM: boolean
 
 /**
@@ -1134,8 +1126,8 @@ export interface Task {
   parallelism?: boolean
   /** This denotes if the task runs continuously */
   continuous?: boolean
-  /** The target's ultracache configuration, if declared */
-  ultracache?: TaskUltracacheConfiguration
+  /** The target's Ultracache settings, if declared */
+  ultracache?: TaskUltracacheSettings
 }
 
 /** Graph of Tasks to be executed */
@@ -1161,6 +1153,25 @@ export interface TaskHashDetails {
   runtime?: Record<string, string>
 }
 
+/**
+ * What reached one task: the files its filesets matched and the packages it
+ * hashes that moved.
+ */
+export interface TaskInputMatches {
+  files: Array<InputMatch>
+  /** External node names the plan hashes one by one that moved. */
+  packages: Array<string>
+  /** The plan hashes every external dependency, and one moved. */
+  allExternals: boolean
+  /** Changed config files of the projects whose configuration the plan hashes. */
+  projectConfigs: Array<string>
+  /**
+   * Ecosystems a change moved whole, without naming packages, that the plan
+   * hashes packages of. Reported once rather than per package.
+   */
+  movedEcosystems: Array<string>
+}
+
 /**
  * The result of a completed Task.
  *
@@ -1204,8 +1215,8 @@ export interface TaskTarget {
   configuration?: string
 }
 
-/** Ultracache configuration of a task's target */
-export interface TaskUltracacheConfiguration {
+/** Ultracache settings of a task's target */
+export interface TaskUltracacheSettings {
   /** How this target's tasks participate. Defaults to `on`. */
   mode?: 'on' | 'warn' | 'error' | 'off'
   /**
@@ -1257,8 +1268,39 @@ export interface TuiConfig {
   suppressHints?: boolean
 }
 
+/** The Ultracache configurations the Nx Cloud client read for HEAD, as JS hands them over. */
+export interface UltracacheConfigurationImportOptions {
+  requestedCommit: string
+  /** `Record<taskId, { commit, inputs, outputs }>` as JSON. */
+  configurationsJson: string
+}
+
+/** What was resolved for a commit; stored beside its entries. */
+export interface UltracacheConfigurationResolution {
+  requestedCommit: string
+  fetchedAt: number
+  tasks: number
+}
+
 /**
- * How a target's tasks participate in ultracache. Nx Cloud only: nothing in
+ * Why a task (or the whole run) hashes natively; `reason` is rendered by the
+ * run summary.
+ */
+export interface UltracacheDiagnostic {
+  reason: string
+  taskId?: string
+  glob?: string
+  message?: string
+}
+
+/** What JS knows about a run's tasks that the eligibility walk needs. */
+export interface UltracacheEligibilityOptions {
+  /** Tasks whose executor ships a custom hasher. */
+  customHasherTaskIds?: Array<string>
+}
+
+/**
+ * How a target's tasks participate in Ultracache. Nx Cloud only: nothing in
  * the OSS runner records or applies IO, so every mode behaves as `Off` without
  * it.
  */
@@ -1282,6 +1324,13 @@ export declare const enum UltracacheMode {
   Off = 'off'
 }
 
+export interface UltracacheReport {
+  /** Task ids hashed from their Ultracache configuration. */
+  used: Array<string>
+  diagnostics: Array<UltracacheDiagnostic>
+  resolution: UltracacheConfigurationResolution
+}
+
 export interface UpdatedWorkspaceFiles {
   fileMap: FileMap
   externalReferences: NxWorkspaceFilesExternals

package/dist/src/native/native-bindings.js

@@ -584,8 +584,6 @@ module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.HttpRemoteCache = nativeBinding.HttpRemoteCache
 module.exports.IgnoredIndexReader = nativeBinding.IgnoredIndexReader
 module.exports.ImportResult = nativeBinding.ImportResult
-module.exports.IoSnapshots = nativeBinding.IoSnapshots
-module.exports.IoSnapshotStore = nativeBinding.IoSnapshotStore
 module.exports.NxCache = nativeBinding.NxCache
 module.exports.NxConsolePreferences = nativeBinding.NxConsolePreferences
 module.exports.NxPluginCapabilities = nativeBinding.NxPluginCapabilities
@@ -596,6 +594,8 @@ module.exports.RustPseudoTerminal = nativeBinding.RustPseudoTerminal
 module.exports.TaskDetails = nativeBinding.TaskDetails
 module.exports.TaskHasher = nativeBinding.TaskHasher
 module.exports.TaskInvocationTracker = nativeBinding.TaskInvocationTracker
+module.exports.UltracacheConfigurations = nativeBinding.UltracacheConfigurations
+module.exports.UltracacheConfigurationStore = nativeBinding.UltracacheConfigurationStore
 module.exports.WorkspaceContext = nativeBinding.WorkspaceContext
 module.exports.affectedTasks = nativeBinding.affectedTasks
 module.exports.BatchStatus = nativeBinding.BatchStatus
@@ -618,11 +618,10 @@ module.exports.getDefaultMaxCacheSize = nativeBinding.getDefaultMaxCacheSize
 module.exports.getEventDimensions = nativeBinding.getEventDimensions
 module.exports.getFilesForOutputsBatch = nativeBinding.getFilesForOutputsBatch
 module.exports.getHardcodedIgnorePatterns = nativeBinding.getHardcodedIgnorePatterns
-module.exports.getIoSnapshotDeferredTaskIds = nativeBinding.getIoSnapshotDeferredTaskIds
-module.exports.getIoSnapshotReport = nativeBinding.getIoSnapshotReport
 module.exports.getMainWorktreeRoot = nativeBinding.getMainWorktreeRoot
-module.exports.getObservedIoSnapshotOutputs = nativeBinding.getObservedIoSnapshotOutputs
 module.exports.getTransformableOutputs = nativeBinding.getTransformableOutputs
+module.exports.getUltracacheDeferredTaskIds = nativeBinding.getUltracacheDeferredTaskIds
+module.exports.getUltracacheReport = nativeBinding.getUltracacheReport
 module.exports.GroupType = nativeBinding.GroupType
 module.exports.hashArray = nativeBinding.hashArray
 module.exports.hashFile = nativeBinding.hashFile

package/dist/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -11,6 +11,7 @@ const url_shorten_1 = require("../../utilities/url-shorten");
 const get_cloud_options_1 = require("../../utilities/get-cloud-options");
 const path_1 = require("path");
 const git_utils_1 = require("../../../utils/git-utils");
+const http_client_1 = require("../../../utils/http-client");
 function printCloudConnectionDisabledMessage() {
     output_1.output.error({
         title: `Connections to Nx Cloud are disabled for this workspace`,
@@ -46,10 +47,13 @@ function getNxInitDate() {
 }
 async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
-    const response = await require('axios').post(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
-        workspaceName,
-        installationSource,
-        nxInitDate,
+    const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
+        method: 'POST',
+        data: {
+            workspaceName,
+            installationSource,
+            nxInitDate,
+        },
     });
     if (response.data.message) {
         throw new Error(response.data.message);
@@ -58,10 +62,13 @@ async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxIni
 }
 async function createNxCloudWorkspaceV2(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
-    const response = await require('axios').post(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
-        workspaceName,
-        installationSource,
-        nxInitDate,
+    const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
+        method: 'POST',
+        data: {
+            workspaceName,
+            installationSource,
+            nxInitDate,
+        },
     });
     if (response.data.message) {
         throw new Error(response.data.message);

package/dist/src/nx-cloud/update-manager.d.ts

@@ -1,5 +1,5 @@
 import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
-import type { ReadIoSnapshotsOptions, ReadIoSnapshotsResult } from '../io-snapshots/fetch';
+import type { ReadUltracacheConfigurationsOptions, ReadUltracacheConfigurationsResult } from '../ultracache/fetch';
 import { TasksRunner } from '../tasks-runner/tasks-runner';
 import { RemoteCacheV2 } from '../tasks-runner/default-tasks-runner';
 export declare class NxCloudEnterpriseOutdatedError extends Error {
@@ -13,8 +13,8 @@ export interface NxCloudClient {
     commands: Record<string, () => Promise<void>>;
     nxCloudTasksRunner: TasksRunner<CloudTaskRunnerOptions>;
     getRemoteCache: () => RemoteCacheV2;
-    /** Clients that expose I/O snapshots; see `fetchIoSnapshots`. */
-    readIoSnapshots?: (options: ReadIoSnapshotsOptions) => Promise<ReadIoSnapshotsResult | null>;
+    /** Clients that expose Ultracache configurations; see `fetchUltracacheConfigurations`. */
+    readUltracacheConfigurations?: (options: ReadUltracacheConfigurationsOptions) => Promise<ReadUltracacheConfigurationsResult | null>;
 }
 export declare function verifyOrUpdateNxCloudClient(options?: {
     url?: string;

package/dist/src/nx-cloud/update-manager.js

@@ -6,9 +6,11 @@ exports.getBundleInstallDefaultLocation = getBundleInstallDefaultLocation;
 const tslib_1 = require("tslib");
 const fs_1 = require("fs");
 const zlib_1 = require("zlib");
+const stream_1 = require("stream");
 const path_1 = require("path");
 const os_1 = require("os");
-const axios_1 = require("./utilities/axios");
+const nx_cloud_http_client_1 = require("./utilities/nx-cloud-http-client");
+const http_client_1 = require("../utils/http-client");
 const debug_logger_1 = require("./debug-logger");
 const tar = tslib_1.__importStar(require("tar-stream"));
 const cache_directory_1 = require("../utils/cache-directory");
@@ -32,14 +34,14 @@ async function verifyOrUpdateNxCloudClient(options) {
     const currentBundle = getLatestInstalledRunnerBundle();
     const apiUrl = process.env.NX_CLOUD_API || options?.url || 'https://cloud.nx.app';
     if (shouldVerifyInstalledRunnerBundle(currentBundle)) {
-        const axios = (0, axios_1.createApiAxiosInstance)(options);
+        const httpClient = (0, nx_cloud_http_client_1.createApiHttpClient)(options);
         let verifyBundleResponse;
         try {
-            verifyBundleResponse = await verifyCurrentBundle(axios, currentBundle);
+            verifyBundleResponse = await verifyCurrentBundle(httpClient, currentBundle);
         }
         catch (e) {
             // Enterprise image compatibility, to be removed
-            if (e.message === 'Request failed with status code 404' && apiUrl) {
+            if (e instanceof http_client_1.HttpError && e.status === 404 && apiUrl) {
                 throw new NxCloudEnterpriseOutdatedError(apiUrl);
             }
             (0, debug_logger_1.debugLog)('Could not verify bundle. Resetting validation timer and using previously installed or default runner. Error: ', e);
@@ -72,7 +74,7 @@ async function verifyOrUpdateNxCloudClient(options) {
         if (version === 'NX_ENTERPRISE_OUTDATED_IMAGE') {
             throw new NxCloudEnterpriseOutdatedError(apiUrl);
         }
-        const fullPath = await downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url);
+        const fullPath = await downloadAndExtractClientBundle(httpClient, runnerBundleInstallDirectory, version, url);
         (0, debug_logger_1.debugLog)('Done: ', fullPath);
         const nxCloudClient = require(fullPath);
         if (nxCloudClient.commands === undefined) {
@@ -157,8 +159,8 @@ function shouldVerifyInstalledRunnerBundle(currentBundle) {
     }
     return true;
 }
-async function verifyCurrentBundle(axios, currentBundle) {
-    return axios.get('/nx-cloud/client/verify', {
+async function verifyCurrentBundle(httpClient, currentBundle) {
+    return httpClient.get('/nx-cloud/client/verify', {
         params: currentBundle
             ? {
                 version: currentBundle.version,
@@ -209,10 +211,10 @@ function hashDirectory(dir) {
     const combinedHashes = hashes.sort().join('');
     return (0, crypto_1.createHash)('sha256').update(combinedHashes).digest('hex');
 }
-async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirectory, version, url) {
+async function downloadAndExtractClientBundle(httpClient, runnerBundleInstallDirectory, version, url) {
     let resp;
     try {
-        resp = await axios.get(url, {
+        resp = await httpClient.get(url, {
             responseType: 'stream',
         });
     }
@@ -238,6 +240,8 @@ async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirector
             else if (headers.type === 'file') {
                 const outputFilePath = (0, path_1.join)(bundleExtractLocation, headers.name);
                 const writeStream = (0, fs_1.createWriteStream)(outputFilePath);
+                // Surface disk errors through the pipeline instead of crashing
+                writeStream.on('error', (e) => extract.destroy(e));
                 stream.pipe(writeStream);
                 // Continue the tar stream after the write stream closes
                 writeStream.on('close', () => {
@@ -246,15 +250,17 @@ async function downloadAndExtractClientBundle(axios, runnerBundleInstallDirector
                 stream.resume();
             }
         });
-        extract.on('error', (e) => {
-            rej(e);
-        });
         extract.on('finish', function () {
             removeOldClientBundles(version);
             writeBundleVerificationLock();
             res(bundleExtractLocation);
         });
-        resp.data.pipe((0, zlib_1.createGunzip)()).pipe(extract);
+        // pipeline propagates download/gunzip errors that .pipe() would leave
+        // uncaught
+        (0, stream_1.pipeline)(resp.data, (0, zlib_1.createGunzip)(), extract, (e) => {
+            if (e)
+                rej(e);
+        });
     });
 }
 function removeOldClientBundles(currentInstallVersion) {

package/dist/src/nx-cloud/utilities/client.d.ts

@@ -5,6 +5,6 @@ export declare class UnknownCommandError extends Error {
     constructor(command: string, availableCommands: string[]);
 }
 export declare function getCloudClient(options: CloudTaskRunnerOptions): Promise<{
-    invoke: (command: string, exit?: boolean) => void;
+    invoke: (command: string, exit?: boolean) => Promise<void>;
     availableCommands: string[];
 }>;

package/dist/src/nx-cloud/utilities/client.js

@@ -19,7 +19,7 @@ async function getCloudClient(options) {
     return {
         invoke: (command, exit = true) => {
             if (command in nxCloudClient.commands) {
-                nxCloudClient.commands[command]()
+                return nxCloudClient.commands[command]()
                     .then(() => {
                     if (exit) {
                         process.exit(0);

package/dist/src/nx-cloud/utilities/is-workspace-claimed.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isWorkspaceClaimed = isWorkspaceClaimed;
 const get_cloud_options_1 = require("./get-cloud-options");
+const http_client_1 = require("../../utils/http-client");
 async function isWorkspaceClaimed(accessToken) {
     if (!accessToken)
         return false;
@@ -10,7 +11,7 @@ async function isWorkspaceClaimed(accessToken) {
         const requestData = (0, get_cloud_options_1.isNxCloudId)(accessToken)
             ? { nxCloudId: accessToken }
             : { nxCloudAccessToken: accessToken };
-        const response = await require('axios').post(`${apiUrl}/nx-cloud/is-workspace-claimed`, requestData);
+        const response = await (0, http_client_1.httpRequest)(`${apiUrl}/nx-cloud/is-workspace-claimed`, { method: 'POST', data: requestData });
         if (response.data.message) {
             return false;
         }

package/dist/src/nx-cloud/utilities/nx-cloud-http-client.d.ts

@@ -0,0 +1,5 @@
+import { type HttpClient } from '../../utils/http-client';
+export declare function createApiHttpClient(options?: {
+    url?: string;
+    customProxyConfigPath?: string;
+}): HttpClient;

package/dist/src/nx-cloud/utilities/nx-cloud-http-client.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApiHttpClient = createApiHttpClient;
+const http_client_1 = require("../../utils/http-client");
+const environment_1 = require("./environment");
+function createApiHttpClient(options) {
+    if (options?.customProxyConfigPath) {
+        const { logger } = require('../../utils/logger');
+        // The client bundle still reads this file for its own requests
+        logger.warn('customProxyConfigPath is not used for downloading the Nx Cloud client. Set HTTP_PROXY/HTTPS_PROXY/NO_PROXY (and NODE_EXTRA_CA_CERTS for custom certificates) instead.');
+    }
+    return (0, http_client_1.createHttpClient)({
+        baseURL: process.env.NX_CLOUD_API || options?.url || 'https://cloud.nx.app',
+        timeout: environment_1.NX_CLOUD_NO_TIMEOUTS ? environment_1.UNLIMITED_TIMEOUT : 10000,
+    });
+}