@depup/nx 23.1.2-depup.1 → 23.2.0-depup.0

package/dist/src/utils/ignore.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OXFMT_IGNORE_OPTIONS = void 0;
 exports.getIgnoreObject = getIgnoreObject;
 exports.createIgnoreChainResolver = createIgnoreChainResolver;
 exports.isIgnoredByChain = isIgnoredByChain;
+exports.createAncestorAwareIgnoreChecker = createAncestorAwareIgnoreChecker;
 exports.isAlwaysIgnored = isAlwaysIgnored;
 exports.createGitIgnoreChecker = createGitIgnoreChecker;
 exports.createPrettierIgnoreChecker = createPrettierIgnoreChecker;
+exports.createOxfmtIgnoreChecker = createOxfmtIgnoreChecker;
 exports.posixDirname = posixDirname;
 exports.addEntryToGitIgnore = addEntryToGitIgnore;
 const ignore = require("ignore");
@@ -93,7 +96,7 @@ function createIgnoreChainResolver(read, filenames, merge) {
  * that same note. Here they are simply the entry's matchers: any one excluding
  * wins, and a negation counts only if none excluded.
  *
- * Two preconditions, both satisfied by a pruning walk and neither enforced:
+ * Two preconditions, neither enforced here:
  *
  * - `filePath` is workspace-relative POSIX and must sit under every `dir` in the
  *   chain, which holds when the chain came from that file's own directory.
@@ -101,9 +104,10 @@ function createIgnoreChainResolver(read, filenames, merge) {
  *   re-include a file inside an excluded directory, and this does not implement
  *   that rule: asked directly about `dist/keep.ts` with a root `dist/` and a
  *   nested `dist/.gitignore` holding `!keep.ts`, it answers "not ignored" where
- *   git says ignored (measured). `visitNotIgnoredFiles` never asks, because it
- *   prunes `dist/` before descending - which is what makes its answers match
- *   git, and why that pruning is load-bearing for correctness rather than speed.
+ *   git says ignored (measured). A pruning walk like `visitNotIgnoredFiles`
+ *   satisfies it by never asking about anything under `dist/`; a per-file
+ *   caller cannot, so it goes through `createAncestorAwareIgnoreChecker`,
+ *   which checks the ancestors before asking the chain.
  */
 function isIgnoredByChain(chain, filePath) {
     for (const { dir, matchers } of chain) {
@@ -122,6 +126,45 @@ function isIgnoredByChain(chain, filePath) {
     }
     return false;
 }
+/**
+ * The chain's answers plus git's excluded-ancestor rule: nothing inside an
+ * ignored directory can be re-included, so a nested negation must not
+ * resurrect a file whose ancestor an outer file excluded - the case
+ * `isIgnoredByChain` alone gets wrong (see its second precondition). The
+ * oxfmt CLI follows the same rule (measured against 0.60.0: a scan skips a
+ * nested `!keep.ts` under a root-ignored `dist/`), so every per-file caller -
+ * the cascading tree checkers and the disk-backed resolver in
+ * `formatters/oxfmt.ts` - goes through here.
+ *
+ * A directory's own ignore files cannot un-ignore the directory itself, so
+ * its verdict comes from its parent's chain - probed with a trailing slash,
+ * which is what makes a directory-only pattern like `dist/` match. Verdicts
+ * are memoized per directory, so a batch of files shares its ancestor walks.
+ */
+function createAncestorAwareIgnoreChecker(resolve) {
+    const ignoredDirs = new Map();
+    const isIgnoredDirectory = (dir) => {
+        if (dir === '') {
+            return false;
+        }
+        const cached = ignoredDirs.get(dir);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const parent = posixDirname(dir);
+        const ignored = isIgnoredDirectory(parent) ||
+            isIgnoredByChain(resolve(parent), `${dir}/`);
+        ignoredDirs.set(dir, ignored);
+        return ignored;
+    };
+    return {
+        isIgnoredFile: (filePath) => {
+            const dir = posixDirname(filePath);
+            return (isIgnoredDirectory(dir) || isIgnoredByChain(resolve(dir), filePath));
+        },
+        isIgnoredDirectory,
+    };
+}
 let alwaysIgnored;
 /**
  * Directories that should never be walked, whatever the workspace's own ignore
@@ -174,16 +217,55 @@ function createPrettierIgnoreChecker(tree) {
         merge: false,
     });
 }
+/**
+ * What oxfmt ignores: prettier's two files, but resolved from each file's own
+ * directory upwards rather than the workspace root - measured against the
+ * oxfmt 0.60.0 CLI, which differs from prettier on exactly that axis. Still
+ * one matcher per file rather than merged.
+ *
+ * A config's `ignorePatterns` is not an ignore file and is not read here;
+ * `formatFilesWithOxfmt` applies it rooted at that config's directory.
+ */
+function createOxfmtIgnoreChecker(tree) {
+    return createTreeIgnoreChecker(tree, exports.OXFMT_IGNORE_OPTIONS);
+}
+/**
+ * Exported, unlike git's and prettier's, because oxfmt has two consumers:
+ * this tree-backed checker and the disk-backed resolver in
+ * `formatters/oxfmt.ts`. A shared value is the only thing that keeps them
+ * agreeing, so do not restate these three anywhere.
+ *
+ * `satisfies` rather than an annotation keeps the values literal - an
+ * annotation widens `cascade` and `merge` to `boolean` (measured in the
+ * declaration emit).
+ */
+exports.OXFMT_IGNORE_OPTIONS = {
+    filenames: ['.gitignore', '.prettierignore'],
+    cascade: true,
+    merge: false,
+};
 function createTreeIgnoreChecker(tree, { filenames, cascade, merge }) {
     const resolve = createIgnoreChainResolver((path) => tree.read(path, 'utf-8'), filenames, merge);
-    // `probe` may carry a trailing slash; `path` never does. The chain is keyed by
-    // real directories, and `posixDirname('dist/')` is `'dist'` rather than the
-    // parent, so the lookup always uses the slash-less form.
-    const check = (path, probe) => isAlwaysIgnored(probe) ||
-        isIgnoredByChain(resolve(cascade ? posixDirname(path) : ''), probe);
+    if (cascade) {
+        // Cascading resolution and the excluded-ancestor rule travel together:
+        // both come from git, and the one cascading tool that is not git - oxfmt -
+        // applies both (measured, see `createAncestorAwareIgnoreChecker`).
+        const checker = createAncestorAwareIgnoreChecker(resolve);
+        return {
+            isIgnoredFile: (path) => isAlwaysIgnored(path) || checker.isIgnoredFile(path),
+            // The trailing slash is what makes a directory-only pattern like `dist/`
+            // match - `ignore` will not match it against the bare `dist`.
+            isIgnoredDirectory: (path) => isAlwaysIgnored(`${path}/`) || checker.isIgnoredDirectory(path),
+        };
+    }
+    // Root-only: the whole chain is the root's, so no ancestor holds ignore
+    // files of its own, and within one matcher `ignore` itself refuses to
+    // re-include under an excluded directory (measured). Nothing is left for an
+    // ancestor walk to add.
+    const check = (probe) => isAlwaysIgnored(probe) || isIgnoredByChain(resolve(''), probe);
     return {
-        isIgnoredFile: (path) => check(path, path),
-        isIgnoredDirectory: (path) => check(path, `${path}/`),
+        isIgnoredFile: (path) => check(path),
+        isIgnoredDirectory: (path) => check(`${path}/`),
     };
 }
 /**

package/dist/src/utils/kill-child-on-host-exit.d.ts

@@ -0,0 +1,7 @@
+import type { ChildProcess } from 'node:child_process';
+/**
+ * Kill `cp` (and its descendants) when this process exits, unless it has
+ * already exited on its own.
+ */
+export declare function killChildOnHostExit(cp: ChildProcess): void;
+export declare function killTrackedChildren(): void;

package/dist/src/utils/kill-child-on-host-exit.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.killChildOnHostExit = killChildOnHostExit;
+exports.killTrackedChildren = killTrackedChildren;
+const native_1 = require("../native");
+// Children spawned by this process that must not outlive it. Plugin workers
+// are torn down with `process.exit`, which leaves spawned build tools (gradle,
+// maven, ...) orphaned and still holding their project locks.
+const trackedChildren = new Set();
+let exitHookRegistered = false;
+/**
+ * Kill `cp` (and its descendants) when this process exits, unless it has
+ * already exited on its own.
+ */
+function killChildOnHostExit(cp) {
+    if (!cp.pid)
+        return;
+    trackedChildren.add(cp.pid);
+    const untrack = () => {
+        trackedChildren.delete(cp.pid);
+        // Whichever fires first, drop both — otherwise the other stays registered
+        // on a child that is already gone.
+        cp.off('exit', untrack);
+        cp.off('error', untrack);
+    };
+    cp.once('exit', untrack);
+    cp.once('error', untrack);
+    if (!exitHookRegistered) {
+        exitHookRegistered = true;
+        process.once('exit', killTrackedChildren);
+    }
+}
+function killTrackedChildren() {
+    for (const pid of trackedChildren) {
+        try {
+            // 'exit' handlers must be synchronous, so no graceful variant here.
+            (0, native_1.killProcessTree)(pid, 'SIGTERM');
+        }
+        catch { }
+    }
+    trackedChildren.clear();
+}

package/dist/src/utils/nx-console-prompt.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureNxConsoleInstalled = ensureNxConsoleInstalled;
-const enquirer_1 = require("enquirer");
+const prompt_helpers_1 = require("./prompt-helpers");
 const os_1 = require("os");
 const output_1 = require("./output");
 const native_1 = require("../native");
@@ -50,13 +50,10 @@ async function promptForNxConsoleInstallation() {
                 '- Explore your workspace visually',
             ],
         });
-        const { shouldInstallNxConsole } = await (0, enquirer_1.prompt)({
-            type: 'confirm',
-            name: 'shouldInstallNxConsole',
+        return await (0, prompt_helpers_1.confirmationPrompt)({
             message: 'Install Nx Console? (you can uninstall anytime)',
-            initial: true,
+            onCancel: () => false,
         });
-        return shouldInstallNxConsole;
     }
     catch (error) {
         return false;

package/dist/src/utils/nx-tmp-dir.d.ts

@@ -8,6 +8,11 @@
  * Consumed by the native binding loader, so keep this file limited to local
  * helpers that themselves use Node builtins only.
  */
+export declare const NX_TMP_DIR_POSIX = "/tmp/.nx";
+/**
+ * Windows has no /tmp, named pipes are not subject to filesystem sandboxing,
+ * and per-user temp dirs are stable there, so the OS temp dir is fine.
+ */
 export declare const NX_TMP_DIR: string;
 /**
  * Owner-only runtime root for the current user. No user segment on Windows —

package/dist/src/utils/nx-tmp-dir.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NX_HOME_TMP_DIR = exports.NX_USER_TMP_DIR = exports.NX_TMP_DIR = void 0;
+exports.NX_HOME_TMP_DIR = exports.NX_USER_TMP_DIR = exports.NX_TMP_DIR = exports.NX_TMP_DIR_POSIX = void 0;
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const owned_private_dir_1 = require("./owned-private-dir");
@@ -14,7 +14,12 @@ const owned_private_dir_1 = require("./owned-private-dir");
  * Consumed by the native binding loader, so keep this file limited to local
  * helpers that themselves use Node builtins only.
  */
-exports.NX_TMP_DIR = (0, node_os_1.platform)() === 'win32' ? (0, node_path_1.join)((0, node_os_1.tmpdir)(), '.nx') : '/tmp/.nx';
+exports.NX_TMP_DIR_POSIX = '/tmp/.nx';
+/**
+ * Windows has no /tmp, named pipes are not subject to filesystem sandboxing,
+ * and per-user temp dirs are stable there, so the OS temp dir is fine.
+ */
+exports.NX_TMP_DIR = (0, node_os_1.platform)() === 'win32' ? (0, node_path_1.join)((0, node_os_1.tmpdir)(), '.nx') : exports.NX_TMP_DIR_POSIX;
 /**
  * Owner-only runtime root for the current user. No user segment on Windows —
  * `%TMP%` is already per-account, and the segment would only cost path length.

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

@@ -1,5 +1,65 @@
 import { WriteStream } from 'tty';
 import type { TaskStatus } from '../tasks-runner/tasks-runner';
+/**
+ * The statuses whose output can be collapsed to a single line: the task did the
+ * work, or the cache stood in for it.
+ */
+export type CollapsibleTaskStatus = Extract<TaskStatus, 'success' | 'local-cache' | 'local-cache-kept-existing' | 'remote-cache'>;
+/**
+ * `static-failures-only` is `static` with successful tasks collapsed to a single
+ * line. They select the same life cycle and differ only in what it prints, so
+ * everywhere the life cycle is chosen, the TUI is ruled out, or output is
+ * routed, the two behave identically.
+ */
+export declare function isStaticOutputStyle(outputStyle: string | undefined): boolean;
+/**
+ * Whether a run prints every task's output in full rather than collapsing the
+ * ones that succeeded. Both static life cycles and the batch renderer have to
+ * agree on this, so they read it from here rather than each deriving it.
+ *
+ * Exactly one style collapses, and it is also what a run that named no style
+ * gets. Every other style prints in full because it was asked for explicitly,
+ * so none may quietly withhold output. Note the static life cycles serve more
+ * styles than the static-sounding ones: `shouldUseDynamicLifeCycle` bails on
+ * `isCI()` before it looks at the style at all, so in CI `dynamic` and `tui`
+ * land here too. This is written as a deny-list for that reason — a new style
+ * prints in full until someone decides otherwise, rather than silently
+ * collapsing because an allow-list did not list it.
+ *
+ * Resolving the absent case here rather than assigning `outputStyle` upstream is
+ * deliberate: the value is also read by the orchestrator to decide whether a
+ * task streams, and naming the default there stops `shouldStreamOutput` from
+ * ever being consulted — including for the continuous tasks that must stream.
+ */
+export declare function printsFullTaskOutput(args: {
+    verbose?: boolean;
+    outputStyle?: string;
+}): boolean;
+/**
+ * Whether task output should be wrapped in collapsible log groups. Grouping
+ * requires each task's output to be written as one contiguous block, which is
+ * why batch mode's implicit streaming backs off when this is on. It does not
+ * govern streaming in general — an explicit `--output-style`, the TUI, and
+ * long running tasks all still stream.
+ */
+export declare function isLogGroupingEnabled(): boolean;
+/**
+ * Whether a batch task's output should be held back from the live stream and
+ * rendered inside a fold instead. A batch worker writes to stdout/stderr live,
+ * so forwarding that copy would put its bytes outside the group and defeat the
+ * fold; what is held back is written to a file and rendered by the orchestrator.
+ *
+ * Note it is the captured file, not each task's `terminalOutput`, that makes
+ * this lossless. A worker is free to write bytes it attributes to no task —
+ * `@nx/maven`'s exit-code dump, `@nx/gradle`'s configuration phase — and those
+ * appear in no `terminalOutput` at all, so the fold has to be able to fall back
+ * to the file. See `TaskOrchestrator.printGroupedBatchOutput` for when it does.
+ *
+ * This is only worth doing when grouping is on and the user has not asked to
+ * stream — an explicit stream style (which sets NX_STREAM_OUTPUT) wants the
+ * live copy, folds or not.
+ */
+export declare function shouldGroupBatchOutput(): boolean;
 export interface CLIErrorMessageConfig {
     title: string;
     bodyLines?: string[];
@@ -48,7 +108,66 @@ declare class CLIOutput {
     bold: import("picocolors/types").Formatter;
     underline: import("picocolors/types").Formatter;
     dim: import("picocolors/types").Formatter;
+    /**
+     * Whether the terminal is positioned at the start of a line. Task output does
+     * not reliably end in a newline, so writers that must begin on a fresh line
+     * ask for one via {@link ensureLineStart} rather than guessing.
+     *
+     * Holding that true means a writer that can leave the cursor mid-line has to
+     * be routed through this class or declared to it. The ones that exist today:
+     *
+     * - This class's own writes, via {@link writeToStream}.
+     * - A batch worker's live output, via {@link writeTaskOutputChunk}.
+     * - `nx:run-commands`, which is the only executor that runs in the main
+     *   process (`task-orchestrator.ts` gates that on the executor name), and
+     *   whose raw writes go through {@link writeTaskOutputChunk} for this reason.
+     *   Its `addColorAndPrefix` splits on newlines without ever appending one, so
+     *   its chunks routinely end mid-line.
+     * - A pseudo-terminal task, which cannot be routed: the native side writes to
+     *   this process's stdout from Rust, at arbitrary PTY read boundaries. It
+     *   declares itself via {@link noteExternalWrite} instead, which is why that
+     *   exists.
+     *
+     * Two bypasses are deliberate and safe, both because they re-emit output a
+     * whole line at a time via `formatPrefixedLines`, which appends `EOL` to every
+     * line it writes: forked task streaming through
+     * `NodeChildProcessWithNonDirectOutput`'s `addPrefixTransformer`, and
+     * `writePrefixedLines` for a main-process `nx:run-commands` under
+     * `NX_PREFIX_OUTPUT`.
+     *
+     * One bypass is known and is NOT safe. With `NX_NATIVE_COMMAND_RUNNER=false`,
+     * `forkProcessLegacy` forks with inherited stdio and yields
+     * `NodeChildProcessWithDirectOutput`, whose child writes straight to this
+     * process's fd 1 at arbitrary boundaries — unroutable and undeclarable from
+     * here. Line tracking is simply wrong on that path; it degrades to the
+     * pre-tracking behavior of a glued marker rather than to anything new. Do not
+     * read this list as closed: it is what is known, and the way to tell you are
+     * adding to it is that you are writing to stdout during a run without going
+     * through {@link writeToStream}, {@link writeTaskOutputChunk} or
+     * {@link noteExternalWrite}.
+     */
+    private atLineStart;
     private writeToStream;
+    /**
+     * Forwards a chunk of a task's output live, keeping {@link atLineStart}
+     * accurate. Batch workers write raw chunks that routinely end mid-line, and a
+     * collapsed summary line must not be glued onto one.
+     *
+     * @internal Not part of the output API plugins may rely on.
+     */
+    writeTaskOutputChunk(chunk: string | Buffer, stream?: WriteStream): void;
+    /**
+     * Declares output this class could not route — a pseudo-terminal task's, which
+     * the native side writes straight to our stdout — so the next writer needing a
+     * fresh line asks for one instead of trusting a stale position.
+     *
+     * The chunk is inspected rather than assumed mid-line, so output that did end
+     * on a line boundary does not cost a blank line. PTY chunks often end in an
+     * escape sequence after the newline, and that reads as mid-line, which is the
+     * safe direction to be wrong in: a spare newline, never a glued one.
+     */
+    noteExternalWrite(chunk?: string | Buffer): void;
+    private ensureLineStart;
     overwriteLine(lineText?: string): void;
     private writeOutputTitle;
     private writeOptionalOutputBody;
@@ -66,6 +185,40 @@ declare class CLIOutput {
     logRawLine(message: string): void;
     logCommand(message: string, taskStatus?: TaskStatus): void;
     logCommandOutput(message: string, taskStatus: TaskStatus, output: string): void;
+    /**
+     * A single line standing in for a task's full output, used when the output
+     * itself carries no information worth printing (a success, or a cache hit).
+     * Statuses that carry a diagnosable body are deliberately not accepted here.
+     */
+    logCommandSummary(message: string, taskStatus: CollapsibleTaskStatus): void;
+    /**
+     * A one-line stand-in for a task whose full output is shown elsewhere — used
+     * for the tasks of a batch rendered as a single log group rather than per
+     * task. `note` points the reader at that group.
+     */
+    logCommandRedirect(message: string, taskStatus: Exclude<TaskStatus, 'skipped'>, note: string): void;
+    /**
+     * Prints a batch's combined output as one log group. A batch runner's
+     * diagnostics — a crash, a config-phase error, a runner summary — belong to no
+     * single task, so the group is labelled with the batch rather than a task.
+     *
+     * The batch's own output is copied straight from the file it was captured
+     * into, so an arbitrarily long log costs a fixed amount of memory here.
+     * Nothing is withheld: this rendering is chosen because the whole log was
+     * asked for, because no task claimed any of it, or because a task failed or
+     * was stopped — in which case repeating claimed bytes beside the per-task
+     * blocks is deliberate (see TaskOrchestrator.printGroupedBatchOutput).
+     */
+    logBatchGroup(label: string, body: {
+        capturedOutputPath?: string;
+        trailer?: string;
+    }, taskStatus: TaskStatus): void;
+    /**
+     * Copies a file to stdout a chunk at a time. Reading it into one string would
+     * reintroduce the unbounded growth that writing it to disk avoided, and a
+     * long batch log can exceed the maximum length of a JS string.
+     */
+    private copyFileToStream;
     private getCommandWithStatus;
     private getStatusIcon;
     private normalizeMessage;