nx 23.3.0-beta.2 → 23.3.0-beta.4

package/dist/src/command-line/migrate/agentic/runner.js

@@ -1,29 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WINDOWS_COMMAND_LINE_BUDGET = void 0;
 exports.runAgentic = runAgentic;
-exports.adaptSpawnForWindowsShim = adaptSpawnForWindowsShim;
 const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
-const path_1 = require("path");
 const pc = tslib_1.__importStar(require("picocolors"));
 const logger_1 = require("../../../utils/logger");
 const output_1 = require("../../../utils/output");
 const migrate_analytics_1 = require("../migrate-analytics");
 const safe_prompt_1 = require("../safe-prompt");
+const close_agent_session_1 = require("./close-agent-session");
 const handoff_1 = require("./handoff");
-// How long to wait for the agent to exit gracefully after sending SIGINT once
-// a valid handoff has been written. Long enough for an interactive agent to
-// finish its current render and clean up; short enough that a frozen child
-// still gets escalated to SIGKILL in a sensible time.
-const AGENT_GRACEFUL_EXIT_MS = 5_000;
+const terminal_repair_1 = require("./terminal-repair");
+const windows_cmd_1 = require("./windows-cmd");
 /**
  * Spawns the selected agent with `stdio: 'inherit'`, swallows SIGINT while the
  * child is alive, waits for it to exit, and resolves the run's outcome from
  * the handoff file (or the user when the file is missing).
  */
 async function runAgentic(args) {
-    const { detected, definition, invocationContext, handoffFilePath, handoffsDir, handoffPollIntervalMs, gracefulExitMs = AGENT_GRACEFUL_EXIT_MS, forceKillWaitMs = FORCE_KILL_WAIT_MS, } = args;
+    const { detected, definition, invocationContext, handoffFilePath, handoffsDir, handoffPollIntervalMs, gracefulExitMs = close_agent_session_1.AGENT_GRACEFUL_EXIT_MS, forceKillWaitMs = close_agent_session_1.FORCE_KILL_WAIT_MS, } = args;
     const adapted = adaptWithinCommandLineBudget(detected, definition, invocationContext);
     let child;
     // Local alias so `@nx/workspace-require-windows-hide` recognizes the
@@ -50,7 +45,7 @@ async function runAgentic(args) {
     };
     process.on('SIGINT', swallowSigint);
     const handoffWatchAbort = new AbortController();
-    const exitPromise = waitForExit(child);
+    const exitPromise = (0, close_agent_session_1.waitForExit)(child);
     const handoffPromise = (0, handoff_1.waitForValidHandoff)(handoffFilePath, handoffsDir, {
         signal: handoffWatchAbort.signal,
         intervalMs: handoffPollIntervalMs,
@@ -68,27 +63,20 @@ async function runAgentic(args) {
             handoffPromise.then(() => 'handoff', () => 'exit'),
         ]);
         if (winner === 'handoff') {
-            await closeAgentSession(child, exitPromise, gracefulExitMs, forceKillWaitMs);
+            await (0, close_agent_session_1.closeAgentSession)(child, exitPromise, gracefulExitMs, forceKillWaitMs);
             // Extra safety bound so the orchestrator can't hang if the child
             // stays stuck after SIGKILL / taskkill (e.g. D-state on a hung NFS
             // read, or taskkill returning before the process actually exits).
-            await raceWithTimeout(exitPromise, forceKillWaitMs);
+            await (0, close_agent_session_1.raceWithTimeout)(exitPromise, forceKillWaitMs);
         }
     }
     finally {
         handoffWatchAbort.abort();
         process.removeListener('SIGINT', swallowSigint);
-        restoreTermiosAfterAgent();
+        (0, terminal_repair_1.restoreTermiosAfterAgent)();
     }
     return resolveFromHandoffOrPrompt(handoffFilePath, handoffsDir, userInterruptCount > 0, exitInfoToCause(exitInfo));
 }
-// "The maximum length of the string that you can use at the command prompt is
-// 8191 characters".
-// https://learn.microsoft.com/troubleshoot/windows-client/shell-experience/command-line-string-limitation
-const WINDOWS_COMMAND_LINE_LIMIT = 8191;
-// Deliberate headroom below the documented limit for argument growth.
-const WINDOWS_COMMAND_LINE_RESERVE = 1000;
-exports.WINDOWS_COMMAND_LINE_BUDGET = WINDOWS_COMMAND_LINE_LIMIT - WINDOWS_COMMAND_LINE_RESERVE;
 /**
  * Builds Windows shim arguments within budget, trying the shorter context
  * before aborting. Rejects overflow to avoid truncated instructions.
@@ -97,7 +85,7 @@ exports.WINDOWS_COMMAND_LINE_BUDGET = WINDOWS_COMMAND_LINE_LIMIT - WINDOWS_COMMA
 function adaptWithinCommandLineBudget(detected, definition, invocationContext) {
     const adapt = (ctx) => {
         const spec = definition.buildInteractive(ctx);
-        return adaptSpawnForWindowsShim(detected.binary, spec.args, {
+        return (0, windows_cmd_1.adaptSpawnForWindowsShim)(detected.binary, spec.args, {
             stdio: 'inherit',
             cwd: spec.cwd ?? ctx.workspaceRoot,
             env: spec.env ? { ...process.env, ...spec.env } : process.env,
@@ -105,21 +93,21 @@ function adaptWithinCommandLineBudget(detected, definition, invocationContext) {
         });
     };
     const adapted = adapt(invocationContext);
-    if (withinCommandLineBudget(adapted)) {
+    if ((0, windows_cmd_1.withinCommandLineBudget)(adapted)) {
         return adapted;
     }
     const reduced = adapt({
         ...invocationContext,
         inlineSystemContext: invocationContext.inlineSystemContextFallback,
     });
-    if (withinCommandLineBudget(reduced)) {
+    if ((0, windows_cmd_1.withinCommandLineBudget)(reduced)) {
         logger_1.logger.info(pc.dim(`  Passing the agent a reduced system context. The full one does not fit on a Windows command line alongside these paths.`));
         return reduced;
     }
     output_1.output.error({
         title: `${detected.displayName} cannot be started for this migration step`,
         bodyLines: [
-            `Launching it needs a ${reduced.commandLineLength}-character command line. cmd.exe runs at most ${WINDOWS_COMMAND_LINE_LIMIT} characters, and nx stops at ${exports.WINDOWS_COMMAND_LINE_BUDGET} to leave room for what it cannot measure from here.`,
+            `Launching it needs a ${reduced.commandLineLength}-character command line. cmd.exe runs at most ${windows_cmd_1.WINDOWS_COMMAND_LINE_LIMIT} characters, and nx stops at ${windows_cmd_1.WINDOWS_COMMAND_LINE_BUDGET} to leave room for what it cannot measure from here.`,
             `The length is paths: the workspace root, at ${invocationContext.workspaceRoot.length} characters, and the migration's package and name, each repeated across several of them.`,
             ``,
             `Re-run with \`--agentic=false\` to apply the remaining migrations yourself. Moving the workspace to a shorter path can help too, but only for agents that put it on the command line.`,
@@ -127,10 +115,6 @@ function adaptWithinCommandLineBudget(detected, definition, invocationContext) {
     });
     throw new Error(`Cannot start ${detected.displayName}: the command line exceeds the Windows limit.`);
 }
-function withinCommandLineBudget(adapted) {
-    return (adapted.commandLineLength === undefined ||
-        adapted.commandLineLength <= exports.WINDOWS_COMMAND_LINE_BUDGET);
-}
 function exitInfoToCause(info) {
     const cause = {};
     // Include `code === 0` so the prompt can distinguish "agent exited cleanly
@@ -148,161 +132,6 @@ function exitInfoToCause(info) {
         cause.exitError = info.error.message;
     return cause;
 }
-function restoreTermiosAfterAgent() {
-    if (process.platform === 'win32')
-        return;
-    if (!process.stdin.isTTY)
-        return;
-    try {
-        // `stty sane` resets termios to a known cooked state via the kernel —
-        // independent of Node's libuv mode tracking (Node's setRawMode(false)
-        // short-circuits when libuv's per-handle mode is already NORMAL, even
-        // if the OS-level termios was changed out-of-band by the agent).
-        (0, child_process_1.execSync)('stty sane < /dev/tty', {
-            stdio: ['ignore', 'ignore', 'ignore'],
-            windowsHide: true,
-        });
-        // Carriage-return + clear to end of screen, to wipe any agent TUI
-        // cells below our row that subsequent log lines won't overwrite
-        // (e.g. a status footer past where our text wraps).
-        process.stdout.write('\r\x1B[J');
-    }
-    catch {
-        // best-effort — if stty isn't on PATH or /dev/tty isn't accessible,
-        // the worst case is the pre-existing staircase + cell-bleed output.
-    }
-}
-// Safety bound after force-kill. SIGKILL normally reaps in microseconds;
-// the bound exists for uninterruptible kernel calls or taskkill returning
-// before the process actually exits.
-const FORCE_KILL_WAIT_MS = 500;
-/**
- * Stops the agent process after a successful handoff.
- *
- * POSIX: SIGINT, then SIGKILL after a bounded wait. SIGTERM is skipped so a
- * child that ignored the first graceful signal does not get a second one.
- *
- * Windows: `taskkill /T /F`. `child.kill` is a `TerminateProcess` call whatever
- * the signal name, which on the `cmd.exe` shim path would kill the shim and
- * orphan the agent. `taskkill` failures are swallowed.
- */
-async function closeAgentSession(child, exitPromise, gracefulExitMs, forceKillWaitMs) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return;
-    if (process.platform === 'win32') {
-        await forceKillWindowsTree(child, exitPromise, forceKillWaitMs);
-        return;
-    }
-    // POSIX path.
-    try {
-        child.kill('SIGINT');
-    }
-    catch {
-        // child already gone between the check above and here
-        return;
-    }
-    let escalation;
-    try {
-        await Promise.race([
-            exitPromise,
-            new Promise((resolve) => {
-                escalation = setTimeout(resolve, gracefulExitMs);
-            }),
-        ]);
-    }
-    finally {
-        if (escalation)
-            clearTimeout(escalation);
-    }
-    if (child.exitCode !== null || child.signalCode !== null)
-        return;
-    // Graceful timeout elapsed without the agent exiting. SIGKILL is
-    // uncatchable; bound the post-kill wait so a pathological uninterruptible
-    // syscall can't hang us forever.
-    try {
-        child.kill('SIGKILL');
-    }
-    catch {
-        /* child already gone */
-    }
-    await raceWithTimeout(exitPromise, forceKillWaitMs);
-}
-async function forceKillWindowsTree(child, exitPromise, forceKillWaitMs) {
-    const pid = child.pid;
-    // `child.pid` is undefined only when spawn itself failed; the early-return
-    // guard in `closeAgentSession` should short-circuit that path. Reaching
-    // here without a pid means a narrow race between handoff-detection and
-    // error-event propagation — without a pid we can't taskkill, so wait
-    // briefly and return.
-    if (pid !== undefined) {
-        try {
-            (0, child_process_1.execSync)(`taskkill /T /F /PID ${pid}`, {
-                stdio: 'ignore',
-                windowsHide: true,
-                // Bound so a hung Windows shell can't block the orchestrator.
-                timeout: 2_000,
-            });
-        }
-        catch {
-            /* taskkill missing, pid already dead, or timed out — fall through */
-        }
-    }
-    await raceWithTimeout(exitPromise, forceKillWaitMs);
-}
-async function raceWithTimeout(promise, timeoutMs) {
-    let timer;
-    try {
-        await Promise.race([
-            promise,
-            new Promise((resolve) => {
-                timer = setTimeout(resolve, timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-// Merge window so a paired exit + error both land in the same ExitInfo
-// (e.g. error from IPC followed by exit when the process actually
-// terminates). For error-only paths like spawn ENOENT — where Node fires
-// error but never exit — this timer is the SOLE settlement mechanism.
-const EXIT_MERGE_WINDOW_MS = 10;
-function waitForExit(child) {
-    return new Promise((resolve) => {
-        const info = {};
-        let pending = null;
-        let settled = false;
-        const settle = () => {
-            if (settled)
-                return;
-            settled = true;
-            if (pending)
-                clearTimeout(pending);
-            resolve(info);
-        };
-        const onFirst = () => {
-            if (settled || pending)
-                return;
-            pending = setTimeout(settle, EXIT_MERGE_WINDOW_MS);
-        };
-        child.on('exit', (code, signal) => {
-            info.code = code;
-            info.signal = signal;
-            onFirst();
-        });
-        // `error` fires when spawn itself fails (e.g. binary disappeared between
-        // detection and run) OR alongside `exit` when the process started but
-        // emitted an error event later. Treat both as exit with no handoff so
-        // the ambiguous flow kicks in; field-merge so we don't drop the loser's
-        // contribution when both fire.
-        child.on('error', (error) => {
-            info.error = error;
-            onFirst();
-        });
-    });
-}
 async function resolveFromHandoffOrPrompt(handoffFilePath, handoffsDir, userInterrupted = false, cause = {}) {
     const read = (0, handoff_1.readHandoffWithReason)(handoffFilePath, handoffsDir);
     if (read.ok === true) {
@@ -346,72 +175,6 @@ async function resolveFromHandoffOrPrompt(handoffFilePath, handoffsDir, userInte
     }
     return promptAmbiguous(fullCause);
 }
-/**
- * Node's `spawn` cannot directly execute `.cmd` / `.bat` shims on Windows;
- * `which` resolves to those when an agent was installed via npm. Wrap them in
- * a `cmd.exe /c` invocation with `windowsVerbatimArguments` so quoting follows
- * the cmd.exe convention rather than Node's default cooking.
- *
- * On non-Windows or for non-shim binaries this is a passthrough.
- */
-function adaptSpawnForWindowsShim(binary, args, options) {
-    if (process.platform !== 'win32') {
-        return { binary, args: [...args], options };
-    }
-    const ext = (0, path_1.extname)(binary).toLowerCase();
-    if (ext !== '.cmd' && ext !== '.bat') {
-        return { binary, args: [...args], options };
-    }
-    assertNoLineBreaks(binary, args);
-    const cmdLine = [escapeCmdCommand(binary), ...args.map(escapeCmdArg)].join(' ');
-    const comspec = process.env.comspec || 'cmd.exe';
-    // Both modes are set rather than inherited, since a machine-wide registry
-    // setting can flip either: `/e:on` for the `%cd:~,%` substring, `/v:off` so a
-    // `!` stays literal. The outer quotes stop `cmd.exe /c` stripping the inner
-    // ones around the binary path.
-    const cmdArgs = ['/e:on', '/v:off', '/d', '/s', '/c', `"${cmdLine}"`];
-    return {
-        binary: comspec,
-        args: cmdArgs,
-        options: { ...options, windowsVerbatimArguments: true },
-        // `windowsVerbatimArguments` makes the command line the argv joined by
-        // single spaces, so this is what CreateProcess and then cmd.exe see.
-        commandLineLength: [comspec, ...cmdArgs].join(' ').length,
-    };
-}
-/** Rejects line breaks in shim commands to avoid truncated instructions. */
-function assertNoLineBreaks(binary, args) {
-    const offending = [binary, ...args].find((value) => /[\r\n]/.test(value));
-    if (offending !== undefined) {
-        throw new Error(`Cannot pass a multi-line argument to "${binary}" on Windows: cmd.exe truncates the command line at the line break. Offending argument: ${JSON.stringify(offending.slice(0, 120))}`);
-    }
-}
-const CMD_META_CHARS = /([()\][!^"`<>&|;, ])/g;
-function escapeCmdArg(arg) {
-    return neutralizePercent(caretEscape(quoteCmdArg(arg)));
-}
-function escapeCmdCommand(arg) {
-    // cmd.exe interprets the command portion through an extra parsing pass;
-    // apply the caret-escape twice so the .cmd shim sees the original.
-    return neutralizePercent(caretEscape(caretEscape(quoteCmdArg(arg))));
-}
-// Double backslashes before quotes for the MS C runtime argv parser.
-function quoteCmdArg(arg) {
-    return `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, '$1$1')}"`;
-}
-function caretEscape(quoted) {
-    return quoted.replace(CMD_META_CHARS, '^$1');
-}
-/**
- * Stops cmd.exe expanding `%VAR%` inside an argument. A caret cannot escape
- * `%`, since expansion runs before caret processing, so each `%` becomes
- * `%%cd:~,%`: `%cd:~,%` is a zero-length substring of a built-in and expands to
- * nothing, leaving the leading `%`. Runs after the caret passes so the `,` it
- * introduces stays uncareted, which the substring syntax requires.
- */
-function neutralizePercent(escaped) {
-    return escaped.replace(/%/g, '%%cd:~,%');
-}
 async function promptAmbiguous(cause) {
     // stderr blank line so the spacer lands in the same stream as output.warn
     // and the prompt — buffered stdout could otherwise reorder it and glue the

package/dist/src/command-line/migrate/agentic/terminal-repair.d.ts

@@ -0,0 +1 @@
+export declare function restoreTermiosAfterAgent(): void;

package/dist/src/command-line/migrate/agentic/terminal-repair.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreTermiosAfterAgent = restoreTermiosAfterAgent;
+const child_process_1 = require("child_process");
+function restoreTermiosAfterAgent() {
+    if (process.platform === 'win32')
+        return;
+    if (!process.stdin.isTTY)
+        return;
+    try {
+        // Not setRawMode(false): it short-circuits when libuv's per-handle mode
+        // is already NORMAL, even after the agent changed termios out-of-band.
+        // `stty sane` goes through the kernel instead.
+        (0, child_process_1.execSync)('stty sane < /dev/tty', {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            windowsHide: true,
+        });
+        // Carriage-return + clear to end of screen, to wipe any agent TUI
+        // cells below our row that subsequent log lines won't overwrite
+        // (e.g. a status footer past where our text wraps).
+        process.stdout.write('\r\x1B[J');
+    }
+    catch {
+        // Best-effort: if stty isn't on PATH or /dev/tty isn't accessible, the
+        // worst case is the pre-existing staircase + cell-bleed output.
+    }
+}

package/dist/src/command-line/migrate/agentic/windows-cmd.d.ts

@@ -0,0 +1,33 @@
+import type { SpawnOptions } from 'child_process';
+export declare function quoteCmdArg(arg: string): string;
+export declare function caretEscape(quoted: string): string;
+/**
+ * Stops cmd.exe expanding `%VAR%` inside an argument. A caret cannot escape
+ * `%`, since expansion runs before caret processing, so each `%` becomes
+ * `%%cd:~,%`: `%cd:~,%` is a zero-length substring of a built-in and expands to
+ * nothing, leaving the leading `%`. Runs after the caret passes so the `,` it
+ * introduces stays uncareted, which the substring syntax requires.
+ */
+export declare function neutralizePercent(escaped: string): string;
+export declare const WINDOWS_COMMAND_LINE_LIMIT = 8191;
+export declare const WINDOWS_COMMAND_LINE_BUDGET: number;
+export interface AdaptedSpawn {
+    binary: string;
+    args: string[];
+    options: SpawnOptions;
+    /**
+     * Length of the command line Windows will receive. Set only on the `cmd.exe`
+     * wrapper path.
+     */
+    commandLineLength?: number;
+}
+export declare function withinCommandLineBudget(adapted: AdaptedSpawn): boolean;
+/**
+ * Node's `spawn` cannot directly execute `.cmd` / `.bat` shims on Windows;
+ * `which` resolves to those when an agent was installed via npm. Wrap them in
+ * a `cmd.exe /c` invocation with `windowsVerbatimArguments` so quoting follows
+ * the cmd.exe convention rather than Node's default cooking.
+ *
+ * On non-Windows or for non-shim binaries this is a passthrough.
+ */
+export declare function adaptSpawnForWindowsShim(binary: string, args: readonly string[], options: SpawnOptions): AdaptedSpawn;

package/dist/src/command-line/migrate/agentic/windows-cmd.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WINDOWS_COMMAND_LINE_BUDGET = exports.WINDOWS_COMMAND_LINE_LIMIT = void 0;
+exports.quoteCmdArg = quoteCmdArg;
+exports.caretEscape = caretEscape;
+exports.neutralizePercent = neutralizePercent;
+exports.withinCommandLineBudget = withinCommandLineBudget;
+exports.adaptSpawnForWindowsShim = adaptSpawnForWindowsShim;
+const path_1 = require("path");
+// Backslash-escape embedded quotes per MS C runtime convention, then wrap in
+// quotes. Callers caret-escape cmd.exe metacharacters on top.
+function quoteCmdArg(arg) {
+    return `"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, '$1$1')}"`;
+}
+const CMD_META_CHARS = /([()\][!^"`<>&|;, ])/g;
+function caretEscape(quoted) {
+    return quoted.replace(CMD_META_CHARS, '^$1');
+}
+/**
+ * Stops cmd.exe expanding `%VAR%` inside an argument. A caret cannot escape
+ * `%`, since expansion runs before caret processing, so each `%` becomes
+ * `%%cd:~,%`: `%cd:~,%` is a zero-length substring of a built-in and expands to
+ * nothing, leaving the leading `%`. Runs after the caret passes so the `,` it
+ * introduces stays uncareted, which the substring syntax requires.
+ */
+function neutralizePercent(escaped) {
+    return escaped.replace(/%/g, '%%cd:~,%');
+}
+// "The maximum length of the string that you can use at the command prompt is
+// 8191 characters".
+// https://learn.microsoft.com/troubleshoot/windows-client/shell-experience/command-line-string-limitation
+exports.WINDOWS_COMMAND_LINE_LIMIT = 8191;
+// Absorbs cmd.exe's own accounting of the string, which cannot be measured
+// from here.
+const WINDOWS_COMMAND_LINE_RESERVE = 1000;
+exports.WINDOWS_COMMAND_LINE_BUDGET = exports.WINDOWS_COMMAND_LINE_LIMIT - WINDOWS_COMMAND_LINE_RESERVE;
+function withinCommandLineBudget(adapted) {
+    return (adapted.commandLineLength === undefined ||
+        adapted.commandLineLength <= exports.WINDOWS_COMMAND_LINE_BUDGET);
+}
+/**
+ * Node's `spawn` cannot directly execute `.cmd` / `.bat` shims on Windows;
+ * `which` resolves to those when an agent was installed via npm. Wrap them in
+ * a `cmd.exe /c` invocation with `windowsVerbatimArguments` so quoting follows
+ * the cmd.exe convention rather than Node's default cooking.
+ *
+ * On non-Windows or for non-shim binaries this is a passthrough.
+ */
+function adaptSpawnForWindowsShim(binary, args, options) {
+    if (process.platform !== 'win32') {
+        return { binary, args: [...args], options };
+    }
+    const ext = (0, path_1.extname)(binary).toLowerCase();
+    if (ext !== '.cmd' && ext !== '.bat') {
+        return { binary, args: [...args], options };
+    }
+    assertNoLineBreaks(binary, args);
+    const cmdLine = [escapeCmdCommand(binary), ...args.map(escapeCmdArg)].join(' ');
+    const comspec = process.env.comspec || 'cmd.exe';
+    // Both modes are set rather than inherited, since a machine-wide registry
+    // setting can flip either: `/e:on` for the `%cd:~,%` substring, `/v:off` so a
+    // `!` stays literal. The outer quotes stop `cmd.exe /c` stripping the inner
+    // ones around the binary path.
+    const cmdArgs = ['/e:on', '/v:off', '/d', '/s', '/c', `"${cmdLine}"`];
+    return {
+        binary: comspec,
+        args: cmdArgs,
+        options: { ...options, windowsVerbatimArguments: true },
+        // `windowsVerbatimArguments` makes the command line the argv joined by
+        // single spaces, so this is what CreateProcess and then cmd.exe see.
+        commandLineLength: [comspec, ...cmdArgs].join(' ').length,
+    };
+}
+// No escaping reproduces a line break on the other side, and cmd.exe truncates
+// the command line at it, so the call is refused.
+function assertNoLineBreaks(binary, args) {
+    const offending = [binary, ...args].find((value) => /[\r\n]/.test(value));
+    if (offending !== undefined) {
+        throw new Error(`Cannot pass a multi-line argument to "${binary}" on Windows: cmd.exe truncates the command line at the line break. Offending argument: ${JSON.stringify(offending.slice(0, 120))}`);
+    }
+}
+function escapeCmdArg(arg) {
+    return neutralizePercent(caretEscape(quoteCmdArg(arg)));
+}
+// cmd.exe parses the command portion twice, so it is caret-escaped twice.
+function escapeCmdCommand(arg) {
+    return neutralizePercent(caretEscape(caretEscape(quoteCmdArg(arg))));
+}

package/dist/src/command-line/migrate/deferred-output.d.ts

@@ -0,0 +1,44 @@
+export type NoticeLevel = 'log' | 'warn' | 'error';
+export type LineColor = 'dim' | 'yellow' | 'red';
+export interface MigrateOutputSink {
+    notice(level: NoticeLevel, message: {
+        title: string;
+        bodyLines?: string[];
+    }): void;
+    line(color: LineColor, text: string): void;
+    /** A chunk of a package manager's own output. */
+    raw(chunk: string): void;
+}
+export declare const terminalOutput: MigrateOutputSink;
+export type DeferredOutputRecord = {
+    kind: 'notice';
+    level: NoticeLevel;
+    title: string;
+    bodyLines?: string[];
+} | {
+    kind: 'line';
+    color: LineColor;
+    text: string;
+} | {
+    kind: 'raw';
+    text: string;
+};
+/**
+ * Collects the output as records that `replayDeferredOutput` prints later.
+ * The notices and lines are always kept; package manager output is bounded
+ * like generator output and rendered only on request. Render once the output
+ * is complete: a rendered collector accepts nothing more.
+ */
+export declare class DeferredOutputCollector implements MigrateOutputSink {
+    private readonly records;
+    private rendered;
+    private assertOpen;
+    notice(level: NoticeLevel, message: {
+        title: string;
+        bodyLines?: string[];
+    }): void;
+    line(color: LineColor, text: string): void;
+    raw(chunk: string): void;
+    render(rawOutput: 'keep' | 'drop'): DeferredOutputRecord[];
+}
+export declare function replayDeferredOutput(records: DeferredOutputRecord[], to?: MigrateOutputSink): void;

package/dist/src/command-line/migrate/deferred-output.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeferredOutputCollector = exports.terminalOutput = void 0;
+exports.replayDeferredOutput = replayDeferredOutput;
+const tslib_1 = require("tslib");
+const pc = tslib_1.__importStar(require("picocolors"));
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+exports.terminalOutput = {
+    notice: (level, message) => output_1.output[level](message),
+    line: (color, text) => logger_1.logger.info(pc[color](text)),
+    raw: (chunk) => process.stdout.write(chunk),
+};
+/**
+ * Collects the output as records that `replayDeferredOutput` prints later.
+ * The notices and lines are always kept; package manager output is bounded
+ * like generator output and rendered only on request. Render once the output
+ * is complete: a rendered collector accepts nothing more.
+ */
+class DeferredOutputCollector {
+    constructor() {
+        this.records = [];
+        this.rendered = false;
+    }
+    assertOpen() {
+        if (this.rendered) {
+            throw new Error('The deferred output was already rendered.');
+        }
+    }
+    notice(level, message) {
+        this.assertOpen();
+        this.records.push({ kind: 'notice', level, ...message });
+    }
+    line(color, text) {
+        this.assertOpen();
+        this.records.push({ kind: 'line', color, text });
+    }
+    raw(chunk) {
+        this.assertOpen();
+        let block = this.records[this.records.length - 1];
+        if (block?.kind !== 'raw-block') {
+            // Lazy: the non-agentic migrate path must not load the agentic chain.
+            const { BoundedChunks } = require('./agentic/capture-generator-output');
+            block = { kind: 'raw-block', buffer: new BoundedChunks() };
+            this.records.push(block);
+        }
+        block.buffer.append(chunk);
+    }
+    render(rawOutput) {
+        this.rendered = true;
+        const records = [];
+        for (const record of this.records) {
+            if (record.kind !== 'raw-block') {
+                records.push(record);
+                continue;
+            }
+            if (rawOutput === 'drop')
+                continue;
+            // The replay adds the final newline back.
+            const text = record.buffer.render();
+            records.push({
+                kind: 'raw',
+                text: text.endsWith('\n') ? text.slice(0, -1) : text,
+            });
+        }
+        return records;
+    }
+}
+exports.DeferredOutputCollector = DeferredOutputCollector;
+function replayDeferredOutput(records, to = exports.terminalOutput) {
+    for (const record of records) {
+        switch (record.kind) {
+            case 'notice':
+                to.notice(record.level, {
+                    title: record.title,
+                    bodyLines: record.bodyLines,
+                });
+                break;
+            case 'line':
+                to.line(record.color, record.text);
+                break;
+            case 'raw':
+                if (record.text)
+                    to.raw(`${record.text}\n`);
+                break;
+            default: {
+                const exhaustive = record;
+                throw new Error(`Unhandled output record: ${JSON.stringify(exhaustive)}`);
+            }
+        }
+    }
+}

package/dist/src/command-line/migrate/execute-migration.d.ts

@@ -1,12 +1,18 @@
 import { MigrationsJson } from '../../config/misc-interfaces';
 import { FileChange } from '../../generators/tree';
 import { ArrayPackageGroup, NxMigrationsConfiguration, PackageJson } from '../../utils/package-json';
+import { type MigrateOutputSink } from './deferred-output';
 interface PackageMigrationConfig extends NxMigrationsConfiguration {
     packageJson: PackageJson;
     packageGroup: ArrayPackageGroup;
 }
 export declare function readPackageMigrationConfig(packageName: string, dir: string): PackageMigrationConfig;
-export declare function runInstall(nxWorkspaceRoot?: string, phase?: MigrationInstallPhase, rerunCommand?: string): Promise<void>;
+/**
+ * With a `sink`, stdin is ignored and stdout and stderr are collected for a
+ * caller sharing the terminal. On POSIX the child stays in nx's process
+ * group. Without a sink, the install owns the terminal.
+ */
+export declare function runInstall(nxWorkspaceRoot?: string, phase?: MigrationInstallPhase, rerunCommand?: string, sink?: MigrateOutputSink): Promise<void>;
 export type MigrationInstallPhase = 'pre-migration' | 'post-migration';
 export declare class NpmPeerDepsInstallError extends Error {
     constructor();
@@ -20,8 +26,8 @@ export declare class NpmPeerDepsInstallError extends Error {
  */
 export declare function isNpmPeerDepsError(stderr: string): boolean;
 export declare function formatSingleMigrationRerunCommand(migrationId: string): string;
-export declare function logNpmPeerDepsError(phase: MigrationInstallPhase, rerunCommand?: string): void;
-export declare function logSkippedPostMigrationInstall(root: string): void;
+export declare function logNpmPeerDepsError(phase: MigrationInstallPhase, rerunCommand?: string, out?: MigrateOutputSink): void;
+export declare function logSkippedPostMigrationInstall(root: string, out?: MigrateOutputSink): void;
 export declare class ChangedDepInstaller {
     private readonly root;
     private readonly shouldSkipInstall;