nx 23.3.0 → 24.0.0-beta.1

package/dist/src/tasks-runner/tasks-schedule.d.ts

@@ -2,16 +2,23 @@ import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { TaskReadiness } from '../native';
 export interface Batch {
     id: string;
     executorName: string;
     taskGraph: TaskGraph;
 }
+export interface TasksScheduleHooks {
+    readinessElsewhere?: (producerId: string) => TaskReadiness | null;
+    onReadinessHold?: (producerId: string) => void;
+}
 export declare class TasksSchedule {
     private readonly projectGraph;
     private readonly projects;
     private readonly taskGraph;
     private readonly options;
+    private readonly fullTaskGraph;
+    private readonly hooks;
     private notScheduledTaskGraph;
     private reverseTaskDeps;
     private reverseProjectGraph;
@@ -19,14 +26,21 @@ export declare class TasksSchedule {
     private scheduledBatches;
     private scheduledTasks;
     private runningTasks;
+    private pendingStart;
     private completedTasks;
+    private readiness;
+    private probedProducers;
     private scheduleRequestsExecutionChain;
     private estimatedTaskTimings;
     private projectDependencies;
     private batchCounters;
-    constructor(projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
+    constructor(projectGraph: ProjectGraph, projects: Record<string, ProjectConfiguration>, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions, fullTaskGraph?: TaskGraph, hooks?: TasksScheduleHooks);
     init(): Promise<void>;
     scheduleNextTasks(): Promise<void>;
+    markContinuousTaskStarted(taskId: string): void;
+    markReady(taskId: string): void;
+    markReadinessFailed(taskId: string): void;
+    markReadinessPending(taskId: string): void;
     hasTasks(): boolean;
     complete(taskIds: string[]): void;
     getAllScheduledTasks(): {
@@ -42,7 +56,10 @@ export declare class TasksSchedule {
     private scheduleBatches;
     private scheduleBatch;
     private processTaskForBatches;
+    private probedProducersOf;
+    private isProducerReady;
     private canBatchTaskBeScheduled;
+    private areContinuousDependenciesReady;
     private canBeScheduled;
     getEstimatedTaskTimings(): Record<string, number>;
 }

package/dist/src/tasks-runner/tasks-schedule.js

@@ -5,12 +5,15 @@ const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const operators_1 = require("../project-graph/operators");
 const task_history_1 = require("../utils/task-history");
+const ready_when_1 = require("./readiness/ready-when");
 class TasksSchedule {
-    constructor(projectGraph, projects, taskGraph, options) {
+    constructor(projectGraph, projects, taskGraph, options, fullTaskGraph = taskGraph, hooks = {}) {
         this.projectGraph = projectGraph;
         this.projects = projects;
         this.taskGraph = taskGraph;
         this.options = options;
+        this.fullTaskGraph = fullTaskGraph;
+        this.hooks = hooks;
         this.notScheduledTaskGraph = this.taskGraph;
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
         this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
@@ -18,7 +21,13 @@ class TasksSchedule {
         this.scheduledBatches = [];
         this.scheduledTasks = [];
         this.runningTasks = new Set();
+        // Continuous tasks with ready edges, queued but not spawned; their
+        // dependents stay unreleased
+        this.pendingStart = new Set();
         this.completedTasks = new Set();
+        this.readiness = new Map();
+        // Read from the full graph: an agent worker's own graph has no edges
+        this.probedProducers = (0, ready_when_1.getReadyDependencies)(this.fullTaskGraph, this.projectGraph);
         this.scheduleRequestsExecutionChain = Promise.resolve();
         this.estimatedTaskTimings = {};
         this.projectDependencies = {};
@@ -38,6 +47,18 @@ class TasksSchedule {
             this.scheduleRequestsExecutionChain.then(() => this.scheduleTasks());
         await this.scheduleRequestsExecutionChain;
     }
+    markContinuousTaskStarted(taskId) {
+        this.pendingStart.delete(taskId);
+    }
+    markReady(taskId) {
+        this.readiness.set(taskId, 'ready');
+    }
+    markReadinessFailed(taskId) {
+        this.readiness.set(taskId, 'failed');
+    }
+    markReadinessPending(taskId) {
+        this.readiness.delete(taskId);
+    }
     hasTasks() {
         return (this.scheduledBatches.length +
             this.scheduledTasks.length +
@@ -116,6 +137,10 @@ class TasksSchedule {
         for (const taskId of taskIds) {
             this.scheduledTasks.push(taskId);
             this.runningTasks.add(taskId);
+            const task = this.taskGraph.tasks[taskId];
+            if (task.continuous && this.probedProducersOf(task).length > 0) {
+                this.pendingStart.add(taskId);
+            }
         }
         this.sortScheduledTasks();
     }
@@ -182,6 +207,15 @@ class TasksSchedule {
         if (!this.canBatchTaskBeScheduled(task, batches[rootExecutorName])) {
             return;
         }
+        // A batch never waits, so a task joins one once its probed producers are
+        // ready. A continuous task that something waits on, or that declares a
+        // probe, runs alone: only that path records its start and readiness
+        if ((task.continuous &&
+            (this.reverseTaskDeps[task.id].length > 0 ||
+                (0, ready_when_1.getReadyWhenConfig)(task, this.projectGraph) != null)) ||
+            this.probedProducersOf(task).some((id) => !this.isProducerReady(id))) {
+            return;
+        }
         const { batchImplementationFactory, preferBatch } = (0, utils_1.getExecutorForTask)(task, this.projects);
         const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
         if (rootExecutorName !== executorName) {
@@ -222,17 +256,41 @@ class TasksSchedule {
             await this.processTaskForBatches(batches, depTask, rootExecutorName, false, visitedInBatch);
         }
     }
+    probedProducersOf(task) {
+        return this.probedProducers[task.id] ?? [];
+    }
+    isProducerReady(producerId) {
+        if (this.taskGraph.tasks[producerId]) {
+            return this.readiness.get(producerId) === 'ready';
+        }
+        return this.hooks.readinessElsewhere?.(producerId) === 1 /* TaskReadiness.Ready */;
+    }
     canBatchTaskBeScheduled(task, batchTaskGraph) {
         // task self needs to support parallelism (undefined defaults to parallel)
-        // all deps have either completed or belong to the same batch
+        // all deps have either completed or belong to the same batch, and every
+        // continuous dep has started, and is ready where the edge asks for it
         return (task.parallelism !== false &&
-            this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
+            this.taskGraph.dependencies[task.id].every(({ id }) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]) &&
+            this.areContinuousDependenciesReady(task.id));
+    }
+    // A producer outside this task graph is polled by the task itself
+    areContinuousDependenciesReady(taskId) {
+        const started = this.taskGraph.continuousDependencies[taskId].every(({ id }) => this.runningTasks.has(id) && !this.pendingStart.has(id));
+        if (!started) {
+            return false;
+        }
+        const pendingProducer = this.probedProducersOf(this.taskGraph.tasks[taskId]).find((id) => this.taskGraph.tasks[id] && !this.readiness.has(id));
+        if (pendingProducer) {
+            this.hooks.onReadinessHold?.(pendingProducer);
+            return false;
+        }
+        return true;
     }
     canBeScheduled(taskId) {
-        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
-        const hasContinuousDependenciesStarted = this.taskGraph.continuousDependencies[taskId].every((id) => this.runningTasks.has(id));
+        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every(({ id }) => this.completedTasks.has(id));
+        const continuousDependenciesReady = this.areContinuousDependenciesReady(taskId);
         // if dependencies have not completed, cannot schedule
-        if (!hasDependenciesCompleted || !hasContinuousDependenciesStarted) {
+        if (!hasDependenciesCompleted || !continuousDependenciesReady) {
             return false;
         }
         // if there are no running tasks, can schedule anything

package/dist/src/tasks-runner/utils.d.ts

@@ -2,7 +2,6 @@ import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectConfiguration, TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { LegacyDependsOnLocation } from './legacy-depends-on-warning';
 export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
     projects: string[];
 };
@@ -10,9 +9,8 @@ export declare function getDependencyConfigs({ project, target }: {
     project: string;
     target: string;
 }, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[] | undefined;
-export type DependsOnEntryLocation = LegacyDependsOnLocation;
-export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[], location?: DependsOnEntryLocation): NormalizedTargetDependencyConfig[];
-export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph, location?: DependsOnEntryLocation): NormalizedTargetDependencyConfig;
+export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph): NormalizedTargetDependencyConfig;
 export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string | TargetDependencyConfig, graph: ProjectGraph, currentProject?: string): TargetDependencyConfig;
 export declare function expandWildcardTargetConfiguration(dependencyConfig: NormalizedTargetDependencyConfig, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
 export declare function readProjectAndTargetFromTargetString(targetString: string, projects: Record<string, ProjectGraphProjectNode>, currentProject?: string): {
@@ -20,7 +18,7 @@ export declare function readProjectAndTargetFromTargetString(targetString: strin
     target: string;
 };
 export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
-export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig, currentProject?: string, location?: DependsOnEntryLocation): Omit<TargetDependencyConfig, 'projects'> & {
+export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig): Omit<TargetDependencyConfig, 'projects'> & {
     projects?: string[];
 };
 export declare function validateOutputs(outputs: string[]): void;
@@ -49,6 +47,8 @@ export declare function getExecutorForTask(task: Task, projects: Record<string,
     isNxExecutor: boolean;
 };
 export declare function getCustomHasher(task: Task, projects: Record<string, ProjectConfiguration>): CustomHasher | null;
+/** Test-only: forget which executors have been warned about. */
+export declare function resetCustomHasherDeprecationWarnings(): void;
 /**
  * `taskGraph` pruned to `required`, which must already hold its dependencies.
  * Unknown ids are ignored: a sync generator can remove a task after selection.
@@ -64,3 +64,18 @@ export declare function shouldStreamOutput(task: Task, initiatingProject: string
 export declare function isCacheableTask(task: Task): boolean;
 export declare function unparse(options: Object): string[];
 export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;
+/**
+ * Distinguishes two invocations of the same task for the recursive invocation
+ * detector. The task id alone would report `nx run app:build --flag` invoked
+ * from within `app:build` as a loop, so the detector pairs the id with this
+ * hash and only treats an exact repeat as an immediate loop.
+ *
+ * The hash cannot decide recursion on its own. Arguments that accumulate
+ * through forwarding (`app:build` -> `app:build hello` -> `app:build hello
+ * hello`) hash differently on every hop, so the tracker also bounds how many
+ * ancestors may be running one task id.
+ *
+ * `__overrides_unparsed__` is dropped, matching how the task hasher treats it:
+ * it restates the other keys as raw argv, down to flag order and spelling.
+ */
+export declare function hashTaskOverrides(task: Task): string;

package/dist/src/tasks-runner/utils.js

@@ -17,6 +17,7 @@ exports.getExecutorNameForTask = getExecutorNameForTask;
 exports.expandInitiatingTasksThroughNoop = expandInitiatingTasksThroughNoop;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
+exports.resetCustomHasherDeprecationWarnings = resetCustomHasherDeprecationWarnings;
 exports.pruneToSelectedTasks = pruneToSelectedTasks;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
@@ -28,37 +29,35 @@ exports.shouldStreamOutput = shouldStreamOutput;
 exports.isCacheableTask = isCacheableTask;
 exports.unparse = unparse;
 exports.createTaskId = createTaskId;
+exports.hashTaskOverrides = hashTaskOverrides;
 const minimatch_1 = require("minimatch");
 const node_path_1 = require("node:path");
 const posix_1 = require("node:path/posix");
 const executor_utils_1 = require("../command-line/run/executor-utils");
+const file_hasher_1 = require("../hasher/file-hasher");
 const native_1 = require("../native");
 const fileutils_1 = require("../utils/fileutils");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
-const legacy_depends_on_warning_1 = require("./legacy-depends-on-warning");
 const globs_1 = require("../utils/globs");
 const long_running_target_1 = require("../utils/long-running-target");
+const output_1 = require("../utils/output");
 const path_1 = require("../utils/path");
 const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
 const split_target_1 = require("../utils/split-target");
 const workspace_root_1 = require("../utils/workspace-root");
 const is_tui_enabled_1 = require("./is-tui-enabled");
 function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
-    const legacyViolations = [];
-    const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
+    return (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
         // This is passed into `run-command` from programmatic invocations
         extraTargetDependencies[target] ??
-        []).flatMap((config, index) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames, { ownerTarget: target, index, legacyViolations }));
-    if (legacyViolations.length) {
-        (0, legacy_depends_on_warning_1.flushLegacyDependsOnViolations)(project, target, legacyViolations, projectGraph.nodes[project]?.data?.root);
-    }
-    return dependencyConfigs;
+        []).flatMap((config) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames));
 }
-function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames, location) {
-    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph, location), allTargetNames);
+function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames) {
+    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph), allTargetNames);
 }
-function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph, location) {
-    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig, currentProject, location);
+function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph) {
+    assertNotLegacyProjectsString(dependencyConfig, currentProject, graph);
+    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig);
     if (noStringConfig.projects) {
         dependencyConfig.projects = (0, find_matching_projects_1.findMatchingProjects)(noStringConfig.projects, graph.nodes);
     }
@@ -67,6 +66,13 @@ function normalizeDependencyConfigProjects(dependencyConfig, currentProject, gra
     }
     return dependencyConfig;
 }
+function assertNotLegacyProjectsString(dependencyConfig, currentProject, graph) {
+    const projects = dependencyConfig.projects;
+    if ((projects === 'self' || projects === 'dependencies') &&
+        !graph.nodes[projects]) {
+        throw new Error(`${currentProject} has a dependsOn entry using projects: '${projects}', which is no longer supported: ${JSON.stringify(dependencyConfig)}\nPlease run "nx repair" to repair your configuration`);
+    }
+}
 function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph, currentProject) {
     if (typeof dependencyConfigString !== 'string') {
         return dependencyConfigString;
@@ -133,23 +139,9 @@ function readProjectAndTargetFromTargetString(targetString, projects, currentPro
 function getOutputs(p, target, overrides) {
     return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
 }
-function normalizeTargetDependencyWithStringProjects(dependencyConfig, currentProject, location) {
+function normalizeTargetDependencyWithStringProjects(dependencyConfig) {
     if (typeof dependencyConfig.projects === 'string') {
-        // TODO(v24): Remove the `self` / `dependencies` magic-string shim.
-        // The v16 `update-depends-on-to-tokens` migration already rewrites
-        // these to the modern shape, and `nx repair` will re-run it on demand.
-        if (dependencyConfig.projects === 'self') {
-            (0, legacy_depends_on_warning_1.warnLegacyDependsOnMagicString)(currentProject, dependencyConfig, location);
-            delete dependencyConfig.projects;
-        }
-        else if (dependencyConfig.projects === 'dependencies') {
-            (0, legacy_depends_on_warning_1.warnLegacyDependsOnMagicString)(currentProject, dependencyConfig, location);
-            dependencyConfig.dependencies = true;
-            delete dependencyConfig.projects;
-        }
-        else {
-            dependencyConfig.projects = [dependencyConfig.projects];
-        }
+        dependencyConfig.projects = [dependencyConfig.projects];
     }
     return dependencyConfig;
 }
@@ -324,10 +316,10 @@ function expandInitiatingTasksThroughNoop(initiatingTasks, taskGraph, projectGra
             continue;
         if (getExecutorNameForTask(task, projectGraph) === 'nx:noop') {
             for (const dep of taskGraph.dependencies[taskId] ?? []) {
-                queue.push(dep);
+                queue.push(dep.id);
             }
             for (const dep of taskGraph.continuousDependencies[taskId] ?? []) {
-                queue.push(dep);
+                queue.push(dep.id);
             }
         }
         else {
@@ -341,9 +333,33 @@ function getExecutorForTask(task, projects) {
     const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, projects);
 }
+// TODO(v25): remove custom hasher support.
 function getCustomHasher(task, projects) {
     const factory = getExecutorForTask(task, projects).hasherFactory;
-    return factory ? factory() : null;
+    if (!factory) {
+        return null;
+    }
+    warnCustomHasherDeprecation(projects[task.target.project].targets[task.target.target].executor);
+    return factory();
+}
+const customHasherDeprecationWarned = new Set();
+function warnCustomHasherDeprecation(executor) {
+    if (customHasherDeprecationWarned.has(executor)) {
+        return;
+    }
+    customHasherDeprecationWarned.add(executor);
+    output_1.output.warn({
+        title: `The "${executor}" executor uses a custom hasher, which is deprecated and will be removed in Nx 25.`,
+        bodyLines: [
+            'Replace the custom hasher with target inputs, following the migration guide:',
+            'https://nx.dev/docs/kb/local-executors#replace-a-custom-hasher-with-inputs',
+            'If the executor comes from a third-party plugin, report this to its maintainers.',
+        ],
+    });
+}
+/** Test-only: forget which executors have been warned about. */
+function resetCustomHasherDeprecationWarnings() {
+    customHasherDeprecationWarned.clear();
 }
 /**
  * `taskGraph` pruned to `required`, which must already hold its dependencies.
@@ -370,8 +386,8 @@ function removeIdsFromTaskGraph(graph, ids, mapWithIds) {
     for (let id of Object.keys(mapWithIds)) {
         if (!removedSet.has(id)) {
             filteredMapWithIds[id] = mapWithIds[id];
-            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
-            continuousDependencies[id] = graph.continuousDependencies[id].filter((depId) => !removedSet.has(depId));
+            dependencies[id] = graph.dependencies[id].filter((dep) => !removedSet.has(dep.id));
+            continuousDependencies[id] = graph.continuousDependencies[id].filter((dep) => !removedSet.has(dep.id));
         }
     }
     return {
@@ -388,12 +404,12 @@ function calculateReverseDeps(taskGraph) {
     });
     Object.keys(taskGraph.dependencies).forEach((taskId) => {
         taskGraph.dependencies[taskId].forEach((d) => {
-            reverseTaskDeps[d].push(taskId);
+            reverseTaskDeps[d.id].push(taskId);
         });
     });
     Object.keys(taskGraph.continuousDependencies).forEach((taskId) => {
         taskGraph.continuousDependencies[taskId].forEach((d) => {
-            reverseTaskDeps[d].push(taskId);
+            reverseTaskDeps[d.id].push(taskId);
         });
     });
     return reverseTaskDeps;
@@ -457,3 +473,22 @@ function createTaskId(project, target, configuration) {
     }
     return id;
 }
+/**
+ * Distinguishes two invocations of the same task for the recursive invocation
+ * detector. The task id alone would report `nx run app:build --flag` invoked
+ * from within `app:build` as a loop, so the detector pairs the id with this
+ * hash and only treats an exact repeat as an immediate loop.
+ *
+ * The hash cannot decide recursion on its own. Arguments that accumulate
+ * through forwarding (`app:build` -> `app:build hello` -> `app:build hello
+ * hello`) hash differently on every hop, so the tracker also bounds how many
+ * ancestors may be running one task id.
+ *
+ * `__overrides_unparsed__` is dropped, matching how the task hasher treats it:
+ * it restates the other keys as raw argv, down to flag order and spelling.
+ */
+function hashTaskOverrides(task) {
+    const overrides = { ...task.overrides };
+    delete overrides['__overrides_unparsed__'];
+    return (0, file_hasher_1.hashObject)(overrides);
+}

package/dist/src/ultracache/overrides.js

@@ -19,6 +19,7 @@ function customHasherTaskIds(projectGraph, taskGraph) {
         return memoized;
     }
     const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    // TODO(v25): remove custom hasher support.
     const ids = Object.values(taskGraph.tasks)
         .filter((task) => {
         try {
@@ -48,6 +49,9 @@ function getUltracacheSettings(taskGraph) {
 function ultracacheEligibilityOptions(projectGraph, taskGraph) {
     return {
         customHasherTaskIds: customHasherTaskIds(projectGraph, taskGraph),
+        continuousTaskIds: Object.values(taskGraph.tasks)
+            .filter((task) => task.continuous)
+            .map((task) => task.id),
     };
 }
 /**

package/dist/src/utils/child-process.js

@@ -128,6 +128,7 @@ function runNxArgvSync(argv, options) {
     if (result.status !== 0) {
         const error = new Error(`Command failed: nx ${argv.join(' ')} (exit code ${result.status})`);
         error.status = result.status ?? 1;
+        error.signal = result.signal;
         throw error;
     }
 }

package/dist/src/utils/git-utils.d.ts

@@ -93,8 +93,13 @@ export declare function tryCommitChanges(commitMessage: string, directory: strin
 /**
  * `tryCommitChanges` for a process that has to stay responsive while git
  * runs: a signing prompt or a hook can hold the commit for minutes.
+ * `withoutTerminal` is for a caller sharing the terminal with another program:
+ * git runs without it (see `spawnWithoutTerminal`), so such a prompt fails the
+ * commit instead.
  */
-export declare function tryCommitChangesAsync(commitMessage: string, directory: string, excludePaths?: string[]): Promise<string | null>;
+export declare function tryCommitChangesAsync(commitMessage: string, directory: string, excludePaths?: string[], { withoutTerminal }?: {
+    withoutTerminal?: boolean;
+}): Promise<string | null>;
 /**
  * `git reset --hard <ref>` then `git clean -fd`, keeping `keepPaths` (git
  * exclusion patterns, repo-relative) out of the clean. Throws with git's

package/dist/src/utils/git-utils.js

@@ -30,6 +30,7 @@ const crypto = tslib_1.__importStar(require("crypto"));
 const fs = tslib_1.__importStar(require("fs"));
 const path_1 = require("path");
 const owned_private_dir_1 = require("./owned-private-dir");
+const spawn_without_terminal_1 = require("./spawn-without-terminal");
 function execFileAsync(file, args, execOptions) {
     return new Promise((res, rej) => {
         (0, child_process_1.execFile)(file, args, { ...execOptions, windowsHide: true }, (err, stdout) => {
@@ -870,11 +871,14 @@ function tryCommitChanges(commitMessage, directory, excludePaths = []) {
 /**
  * `tryCommitChanges` for a process that has to stay responsive while git
  * runs: a signing prompt or a hook can hold the commit for minutes.
+ * `withoutTerminal` is for a caller sharing the terminal with another program:
+ * git runs without it (see `spawnWithoutTerminal`), so such a prompt fails the
+ * commit instead.
  */
-async function tryCommitChangesAsync(commitMessage, directory, excludePaths = []) {
+async function tryCommitChangesAsync(commitMessage, directory, excludePaths = [], { withoutTerminal = false } = {}) {
     try {
         for (const { command, input } of commitCommands(commitMessage, excludePaths)) {
-            await execAsync(command, directory, input);
+            await execAsync(command, directory, input, withoutTerminal);
         }
     }
     catch (err) {
@@ -908,12 +912,14 @@ function commitFailure(err) {
     // for callers to inspect; otherwise only stderr/stdout text survives.
     return new Error(detail || (err instanceof Error ? err.message : String(err)), { cause: err });
 }
-function execAsync(command, cwd, input) {
+function execAsync(command, cwd, input, withoutTerminal) {
     return new Promise((res, rej) => {
-        const child = (0, child_process_1.exec)(command, { encoding: 'utf8', cwd, windowsHide: true }, 
         // The streams ride on the error as `execSync` reports them, so
         // `commitFailure` shapes both the same way.
-        (err, stdout, stderr) => err ? rej(Object.assign(err, { stdout, stderr })) : res());
+        const settle = (err, stdout, stderr) => err ? rej(Object.assign(err, { stdout, stderr })) : res();
+        const child = withoutTerminal
+            ? collectOutput((0, spawn_without_terminal_1.spawnWithoutTerminal)(command, { cwd }), command, settle)
+            : (0, child_process_1.exec)(command, { encoding: 'utf8', cwd, windowsHide: true }, settle);
         // Closed for every command, since `git commit -F -` reads to end of
         // input. A child that exits before reading raises EPIPE here, which the
         // exit callback already reports.
@@ -921,6 +927,21 @@ function execAsync(command, cwd, input) {
         child.stdin?.end(input ?? '');
     });
 }
+// What `exec` reports through its callback; `exec` itself ignores `detached`.
+function collectOutput(child, command, done) {
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.setEncoding('utf8').on('data', (chunk) => (stdout += chunk));
+    child.stderr?.setEncoding('utf8').on('data', (chunk) => (stderr += chunk));
+    child.once('error', (err) => done(err, stdout, stderr));
+    child.once('close', (code, signal) => done(code === 0
+        ? null
+        : Object.assign(new Error(`Command failed: ${command}`), {
+            code,
+            signal,
+        }), stdout, stderr));
+    return child;
+}
 /**
  * `git reset --hard <ref>` then `git clean -fd`, keeping `keepPaths` (git
  * exclusion patterns, repo-relative) out of the clean. Throws with git's

package/dist/src/utils/owned-private-dir.d.ts

@@ -25,7 +25,7 @@ export type OwnedRealDir = string & {
 export type OwnedPrivateDir = string & {
     readonly [ownedPrivateDirBrand]: true;
 };
-/** Why a guard refused a directory. Data, not a sentence: `remedyFor` decides on it. */
+/** Why a guard refused a directory. Data, not a sentence. */
 export type DirRefusal = {
     kind: 'not-created';
     dir: string;
@@ -65,8 +65,6 @@ export type GuardResult<T> = {
 };
 /** The user-facing sentence for a refusal. The only place wording is decided. */
 export declare function describeRefusal(r: DirRefusal): string;
-/** What the user can do about a refusal, or `undefined` when there is nothing. */
-export declare function remedyFor(r: DirRefusal): string | undefined;
 /** One refusal as an `Error`, so several can travel in an `AggregateError`. */
 export declare class DirectoryRefusedError extends Error {
     readonly refusal: DirRefusal;
@@ -98,20 +96,6 @@ export declare function canonicalDir(dir: string): string;
  * verified private directory beneath it.
  */
 export declare function isSafeSharedRoot(dir: string): GuardResult<SafeSharedRoot>;
-/**
- * Whether other users on this machine can write into `dir`. Gates whether a
- * refusal message may cite other users, so it must not over-report: `false` on
- * Windows, where libuv synthesizes `st_mode` from the READONLY attribute and
- * reports an ordinary per-account directory as `0666`, and `false` on a path
- * that cannot be inspected.
- *
- * `statSync`, not `lstatSync`: the question is about the directory that will be
- * used, not the link pointing at it. Link modes mislead in both directions —
- * Linux creates symlinks `0777`, macOS applies the umask. Nothing here decides
- * whether a path is accepted, so following the link costs nothing the guards
- * do not already re-check.
- */
-export declare function isPeerWritable(dir: string): boolean;
 /**
  * Create a shared container as sticky + world-writable if it does not exist,
  * and report whether the resulting path is safe for the current user.