nx 23.3.0-beta.2 → 23.3.0-beta.3

package/dist/src/command-line/migrate/execute-migration.js

@@ -20,6 +20,7 @@ exports.isAngularMigration = isAngularMigration;
 const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
 const child_process_1 = require("child_process");
+const string_decoder_1 = require("string_decoder");
 const path_1 = require("path");
 const semver_1 = require("semver");
 const handle_import_1 = require("../../utils/handle-import");
@@ -29,12 +30,12 @@ const logger_1 = require("../../utils/logger");
 const text_1 = require("./text");
 const package_json_1 = require("../../utils/package-json");
 const package_manager_1 = require("../../utils/package-manager");
-const output_1 = require("../../utils/output");
 const fs_1 = require("fs");
 const installation_directory_1 = require("../../utils/installation-directory");
 const shell_quoting_1 = require("../../utils/shell-quoting");
 const project_graph_1 = require("../../project-graph/project-graph");
 const version_utils_1 = require("./version-utils");
+const deferred_output_1 = require("./deferred-output");
 function readPackageMigrationConfig(packageName, dir) {
     const { path: packageJsonPath, packageJson: json } = (0, package_json_1.readModulePackageJson)(packageName, (0, installation_directory_1.getNxRequirePaths)(dir));
     const config = (0, package_json_1.readNxMigrateConfig)(json);
@@ -61,32 +62,68 @@ function readPackageMigrationConfig(packageName, dir) {
         };
     }
 }
-function runInstall(nxWorkspaceRoot, phase = 'pre-migration', rerunCommand) {
+/**
+ * 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.
+ */
+function runInstall(nxWorkspaceRoot, phase = 'pre-migration', rerunCommand, sink) {
     const cwd = nxWorkspaceRoot ?? process.cwd();
     const packageManager = (0, package_manager_1.detectPackageManager)(cwd);
     const pmCommands = (0, package_manager_1.getPackageManagerCommand)(packageManager, cwd);
+    const out = sink ?? deferred_output_1.terminalOutput;
     const installCommand = `${pmCommands.install} ${pmCommands.ignoreScriptsFlag ?? ''}`;
-    output_1.output.log({
+    out.notice('log', {
         title: `Running '${installCommand}' to make sure necessary packages are installed`,
     });
     return new Promise((resolve, reject) => {
-        // For npm, pipe stderr so we can detect peer dependency errors while still
-        // mirroring it live to the user's terminal. Other package managers inherit
-        // stderr directly since we don't need to inspect their output.
+        // npm's stderr is piped so peer dependency errors can be detected in it.
+        // Without a sink it is mirrored live and other package managers inherit
+        // stderr directly, since their output is not inspected.
         const shouldCaptureStderr = packageManager === 'npm';
         const child = (0, child_process_1.spawn)(installCommand, {
             shell: true,
-            stdio: ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
+            stdio: sink
+                ? ['ignore', 'pipe', 'pipe']
+                : ['inherit', 'inherit', shouldCaptureStderr ? 'pipe' : 'inherit'],
             windowsHide: true,
             cwd,
         });
+        // Decoded per stream: a chunk boundary can split a multi-byte character,
+        // and a sequence still incomplete at the end is what `end()` returns.
+        const stdoutText = new string_decoder_1.StringDecoder('utf8');
+        const stderrText = new string_decoder_1.StringDecoder('utf8');
+        child.stdout?.on('data', (chunk) => out.raw(stdoutText.write(chunk)));
+        child.stdout?.on('end', () => out.raw(stdoutText.end()));
         const stderrChunks = [];
         child.stderr?.on('data', (chunk) => {
-            process.stderr.write(chunk);
-            stderrChunks.push(chunk);
+            if (sink) {
+                out.raw(stderrText.write(chunk));
+            }
+            else {
+                process.stderr.write(chunk);
+            }
+            if (shouldCaptureStderr)
+                stderrChunks.push(chunk);
+        });
+        if (sink)
+            child.stderr.on('end', () => out.raw(stderrText.end()));
+        // With a sink the rejection waits for `close`, which follows the streams'
+        // `end`: a caller must be able to render what it collected on rejection.
+        let spawnError = null;
+        child.on('error', (error) => {
+            if (sink) {
+                spawnError = error;
+            }
+            else {
+                reject(error);
+            }
         });
-        child.on('error', reject);
         child.on('close', (code) => {
+            if (spawnError) {
+                reject(spawnError);
+                return;
+            }
             if (code === 0) {
                 resolve();
                 return;
@@ -98,7 +135,7 @@ function runInstall(nxWorkspaceRoot, phase = 'pre-migration', rerunCommand) {
                     // (CLI migrate, `nx repair`, single-migration runner, etc.) surfaces
                     // it consistently. Top-level callers catch `NpmPeerDepsInstallError`
                     // and return a non-zero exit code without re-logging.
-                    logNpmPeerDepsError(phase, rerunCommand);
+                    logNpmPeerDepsError(phase, rerunCommand, out);
                     reject(new NpmPeerDepsInstallError());
                     return;
                 }
@@ -143,7 +180,7 @@ function formatSingleMigrationRerunCommand(migrationId) {
         : migrationId;
     return `nx migrate --run-migration=${id}`;
 }
-function logNpmPeerDepsError(phase, rerunCommand = 'nx migrate --run-migrations') {
+function logNpmPeerDepsError(phase, rerunCommand = 'nx migrate --run-migrations', out = deferred_output_1.terminalOutput) {
     const peerDepsResolutionSteps = [
         'Recommended approaches (in order of preference):',
         '',
@@ -160,7 +197,7 @@ function logNpmPeerDepsError(phase, rerunCommand = 'nx migrate --run-migrations'
         `   ${rerunCommand} --skip-install`,
     ];
     if (phase === 'pre-migration') {
-        output_1.output.error({
+        out.notice('error', {
             title: 'You need to resolve the peer dependency conflicts before the migration can continue',
             bodyLines: [
                 ...peerDepsResolutionSteps,
@@ -173,7 +210,7 @@ function logNpmPeerDepsError(phase, rerunCommand = 'nx migrate --run-migrations'
         });
     }
     else {
-        output_1.output.error({
+        out.notice('error', {
             title: 'Some migrations have been applied, but installing the updated dependencies failed',
             bodyLines: [
                 ...peerDepsResolutionSteps,
@@ -187,10 +224,10 @@ function logNpmPeerDepsError(phase, rerunCommand = 'nx migrate --run-migrations'
         });
     }
 }
-function logSkippedPostMigrationInstall(root) {
+function logSkippedPostMigrationInstall(root, out = deferred_output_1.terminalOutput) {
     const packageManager = (0, package_manager_1.detectPackageManager)(root);
     const installCommand = (0, package_manager_1.getPackageManagerCommand)(packageManager, root).install;
-    output_1.output.warn({
+    out.notice('warn', {
         title: 'Migrations updated your dependencies, but the install was skipped',
         bodyLines: [`Run "${installCommand}" to install the updated dependencies.`],
     });

package/dist/src/command-line/migrate/migrate-commits.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedAgentic } from './agentic/types';
+import { type MigrateOutputSink } from './deferred-output';
 /**
  * Discriminated result for `commitMigrationIfRequested`. Distinguishes the
  * shapes the executor needs to react to:
@@ -7,9 +8,8 @@ import type { ResolvedAgentic } from './agentic/types';
  *   HEAD` failed transiently — by contract the diff is no longer in the
  *   working tree.
  * - `no-changes`: commits were requested but there was nothing to commit.
- * - `failed`: the commit attempt itself errored. The diff remains in the
- *   working tree; the executor uses this signal to track pending migrations
- *   so the next successful commit can annotate its body.
+ * - `failed`: the attempt errored, possibly after the commit landed; tracked
+ *   as pending so the next successful commit can annotate its body.
  * - `disabled`: commits are off for this run.
  */
 export type CommitResult = {
@@ -37,7 +37,7 @@ export declare function commitMigrationIfRequested(root: string, migration: {
 }, shouldCreateCommits: boolean, commitPrefix: string, installDepsIfChanged: () => Promise<void>, pendingMigrations?: ReadonlyArray<{
     package: string;
     name: string;
-}>, failureGuidance?: string): Promise<CommitResult>;
+}>, failureGuidance?: string, out?: MigrateOutputSink): Promise<CommitResult>;
 /**
  * Commits any pre-existing working-tree state into a dedicated "checkpoint"
  * commit before the first migration runs. Without this, the first migration's

package/dist/src/command-line/migrate/migrate-commits.js

@@ -15,6 +15,7 @@ const logger_1 = require("../../utils/logger");
 const output_1 = require("../../utils/output");
 const types_1 = require("./agentic/types");
 const safe_prompt_1 = require("./safe-prompt");
+const deferred_output_1 = require("./deferred-output");
 // `git add -A` captures an orchestrated run's scratch state whenever the
 // ignore rule that normally hides it goes missing mid-run (a checkout, a
 // .gitignore edit, or the migration's own changes).
@@ -28,7 +29,7 @@ const MIGRATE_COMMIT_EXCLUDES = [types_1.MIGRATE_RUNS_RELATIVE_DIR];
  * behavior; a caller with no later commit or recap to absorb the diff (the
  * standalone single-migration worker) passes its own.
  */
-async function commitMigrationIfRequested(root, migration, shouldCreateCommits, commitPrefix, installDepsIfChanged, pendingMigrations = [], failureGuidance = 'The next successful commit will absorb it and reference this migration in its body; if no later commit lands, the end-of-run output will list this migration so you can commit or revert manually.') {
+async function commitMigrationIfRequested(root, migration, shouldCreateCommits, commitPrefix, installDepsIfChanged, pendingMigrations = [], failureGuidance = 'Any uncommitted changes will be included in the next successful commit, which will reference this migration; if they remain uncommitted, the end-of-run output will list this migration so you can commit or revert them manually.', out = deferred_output_1.terminalOutput) {
     if (!shouldCreateCommits)
         return { status: 'disabled' };
     await installDepsIfChanged();
@@ -36,22 +37,22 @@ async function commitMigrationIfRequested(root, migration, shouldCreateCommits,
     // dir, or the prompt half made no change: log neutrally, not as an error.
     // The probe excludes what the commit excludes, else the commit fails empty.
     if (!(0, git_utils_1.hasUncommittedChanges)(root, MIGRATE_COMMIT_EXCLUDES)) {
-        logger_1.logger.info(pc.dim(`- No changes to commit for ${migration.name}.`));
+        out.line('dim', `- No changes to commit for ${migration.name}.`);
         return { status: 'no-changes' };
     }
     const commitMessage = buildCommitMessage(`${commitPrefix}${migration.name}`, pendingMigrations);
     try {
-        const sha = (0, git_utils_1.tryCommitChanges)(commitMessage, root, MIGRATE_COMMIT_EXCLUDES);
+        const sha = await (0, git_utils_1.tryCommitChangesAsync)(commitMessage, root, MIGRATE_COMMIT_EXCLUDES);
         if (sha)
             return { status: 'committed', sha };
         // null = commit landed but `git rev-parse HEAD` failed (see
-        // `tryCommitChanges`). Degraded-but-correct — log yellow, not red.
-        logger_1.logger.info(pc.yellow(`The commit for ${migration.name} was created, but its sha could not be resolved (\`git rev-parse HEAD\` failed transiently). Continuing without recording the sha for this step.`));
+        // `tryCommitChangesAsync`). Degraded-but-correct — log yellow, not red.
+        out.line('yellow', `The commit for ${migration.name} was created, but its sha could not be resolved (\`git rev-parse HEAD\` failed transiently). Continuing without recording the sha for this step.`);
         return { status: 'committed', sha: null };
     }
     catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        logger_1.logger.info(pc.red(`Could not create a commit for ${migration.name}:\n${reason}\nThe migration's diff remains in the working tree; inspect with \`git status\` / \`git diff\` to review. ${failureGuidance}`));
+        out.line('red', `The commit for ${migration.name} failed:\n${reason}\nCheck \`git status\` and \`git log\`; the commit may have landed despite this error. ${failureGuidance}`);
         return { status: 'failed', reason };
     }
 }

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

@@ -30,6 +30,7 @@ const tar_1 = require("../../utils/tar");
 const write_formatted_json_file_1 = require("../../utils/write-formatted-json-file");
 const shell_quoting_1 = require("../../utils/shell-quoting");
 const logger_1 = require("../../utils/logger");
+const native_1 = require("../../native");
 const git_utils_1 = require("../../utils/git-utils");
 const package_json_1 = require("../../utils/package-json");
 const package_manager_1 = require("../../utils/package-manager");
@@ -2126,6 +2127,20 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
     }
     const migrationsJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, opts.runMigrations));
     const migrations = migrationsJson.migrations;
+    // Defer the nx package lookup until an orchestrated branch needs this payload.
+    const orchestratorInitInput = (createCommits) => ({
+        root,
+        migrationsJson,
+        createCommits,
+        commitPrefix,
+        // The flag only, never NX_MIGRATE_SKIP_INSTALL: the wrapper's local
+        // re-exec sets that env var for its own hop, and it says nothing about
+        // what the user asked for.
+        skipInstall: shouldSkipInstall,
+        installedNxVersion: (0, package_json_1.readModulePackageJson)('nx', (0, installation_directory_1.getNxRequirePaths)(root))
+            .packageJson.version,
+        validate: opts.validate,
+    });
     // An outer agent drives the loop, so hand off to the orchestrator instead of
     // the classic loop: init either starts a fresh run or resumes an already-
     // active one. `--run-id` reconciles are dispatched separately and never
@@ -2164,20 +2179,10 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
                 return;
             }
         }
-        const { packageJson: orchestratorNxPackageJson } = (0, package_json_1.readModulePackageJson)('nx', (0, installation_directory_1.getNxRequirePaths)(root));
+        const init = orchestratorInitInput(effectiveCreateCommits);
         const { runOrchestratorInit } = require('./run');
-        return await runOrchestratorInit({
-            root,
-            migrationsJson,
-            createCommits: effectiveCreateCommits,
-            commitPrefix,
-            // The flag only, never NX_MIGRATE_SKIP_INSTALL: the wrapper's local
-            // re-exec sets that env var for its own hop, and it says nothing about
-            // what the user asked for.
-            skipInstall: shouldSkipInstall,
-            installedNxVersion: orchestratorNxPackageJson.version,
-            validate: opts.validate,
-        });
+        await runOrchestratorInit(init);
+        return;
     }
     (0, migrate_analytics_1.reportMigrateRunStart)({
         createCommits: shouldCreateCommits ?? false,
@@ -2213,6 +2218,16 @@ async function runMigrations(root, opts, args, isVerbose, shouldCreateCommits, c
         !(await (0, migrate_commits_1.confirmMigrationCommitsOnDefaultBranch)(root, 'running migrations'))) {
         return;
     }
+    // Dark: with the env var set, the agent drives the whole run through the
+    // orchestrator from one session instead of being spawned per step. Not
+    // under WASM, where the broker has no native lock to detect a dead parent.
+    if (agentic.kind === 'enabled' &&
+        process.env.NX_MIGRATE_ORCHESTRATOR === 'true' &&
+        !native_1.IS_WASM) {
+        const init = orchestratorInitInput(effectiveCreateCommits);
+        const { runMasterSession } = require('./agentic/master/run-master-session');
+        return await runMasterSession({ ...init, agent: agentic.selectedAgent });
+    }
     const shouldRunValidation = resolveShouldRunValidation({
         validate: opts.validate,
         agenticKind: agentic.kind,

package/dist/src/command-line/migrate/run/broker.d.ts

@@ -0,0 +1,138 @@
+import { type DeferredOutputRecord } from '../deferred-output';
+import { type CommitResult } from '../migrate-commits';
+import { type MigrateRunPolicy, type MigrateRunState, type MigrateStep, type MigrateTreeOperation } from './run-state';
+export declare const BROKER_ENV_VAR = "NX_MIGRATE_BROKER";
+export type BrokerRequestKind = 'commit' | 'install' | 'fold-install' | 'action-install' | 'reset';
+export type InstallSeam = 'install' | 'fold-install' | 'action-install';
+export interface BrokerRequest {
+    kind: BrokerRequestKind;
+    stepId: string;
+    attempt: number;
+    invocation?: string;
+}
+export type BrokerResult = {
+    kind: 'commit';
+    result: CommitResult;
+    absorbedStepIds: string[];
+    output: DeferredOutputRecord[];
+} | {
+    kind: 'installed';
+    output: DeferredOutputRecord[];
+} | {
+    kind: 'install-failed';
+    message: string;
+    peerDeps: boolean;
+    output: DeferredOutputRecord[];
+} | {
+    kind: 'reset';
+    error?: string;
+} | {
+    kind: 'stale';
+};
+export interface BrokeredCommit {
+    result: CommitResult;
+    absorbedStepIds: string[];
+    /**
+     * True when the session's parent ran the commit and recorded whatever it
+     * produced before answering, so the caller appends nothing. False for an
+     * in-process commit, which the caller records.
+     */
+    recorded: boolean;
+}
+/** The request no longer matches the step: another attempt owns it. */
+export declare class BrokerStaleRequestError extends Error {
+}
+/**
+ * The advertised parent could not accept the request, or went away before
+ * answering it. It may have landed the install or the commit; the tree and
+ * the run state say.
+ */
+export declare class BrokerUnavailableError extends Error {
+}
+/** Another live process holds the working tree for an operation of its own. */
+export declare class TreeBusyError extends Error {
+}
+export interface TreeOperationRequest {
+    kind: BrokerRequestKind | 'checkpoint';
+    stepId?: string;
+    attempt?: number;
+}
+export interface TreeLease {
+    readonly owner: string;
+    markedStepId?: string;
+    release(): void;
+}
+/**
+ * Owned by the scope that runs an operation and its state write: a seam that
+ * acquires in process writes the lease here before its fallible callback
+ * runs, and the scope releases it in a `finally` once the write landed or
+ * failed. A brokered call leaves it empty; the parent holds its own.
+ */
+export interface TreeScope {
+    lease?: TreeLease;
+}
+/**
+ * Reserves the working tree for one operation in a single fresh-state write:
+ * the request must still be at its seam (else the attempt moved on and the
+ * request is stale), and no other live process may hold a reservation.
+ * A reservation whose owner process is gone holds nothing.
+ */
+export declare function acquireTreeOperation(dir: string, request: TreeOperationRequest, owner?: string): TreeLease;
+/**
+ * Owner-checked: a lease released late never drops a newer reservation, nor
+ * the mark it set.
+ */
+export declare function releaseTreeOperation(dir: string, owner: string, markedStepId?: string): void;
+/** The reservation a live process other than `owner` holds, if any. */
+export declare function liveTreeOperation(state: MigrateRunState, owner?: string): MigrateTreeOperation | undefined;
+export declare function treeBusyMessage(held: MigrateTreeOperation): string;
+export declare function treeOperationLabel(held: Pick<MigrateTreeOperation, 'kind' | 'stepId'>): string;
+export declare function brokerDir(runDirPath: string): string;
+/**
+ * Runs the step's install and commit where they can land: in this process
+ * unless a parent session advertised its broker, in which case the request
+ * goes to the parent and the answer comes back with the output the parent
+ * collected, printed here. The absorbed step ids come from whichever side
+ * ran the commit, so the ledger entry names what its `git add -A` took.
+ */
+export declare function commitStepTree(dir: string, step: MigrateStep, absorbedStepIds: string[], commitInProcess: () => Promise<CommitResult>, scope: TreeScope): Promise<BrokeredCommit>;
+/**
+ * The same for a step that owes only its install: no commit is due, or the
+ * commit waits for a fold.
+ */
+export declare function installStepTree(dir: string, step: MigrateStep, seam: InstallSeam, installInProcess: () => Promise<void>, scope: TreeScope): Promise<void>;
+/**
+ * The same for the reset a clean retry of a failed or died step needs. Runs
+ * `resetInProcess` under the reservation, or asks the parent, which resets
+ * against the state it reads then; a reset that could not run throws.
+ */
+export declare function resetStepTree(dir: string, step: MigrateStep, resetInProcess: () => void, scope: TreeScope): Promise<void>;
+/**
+ * The parent side. Holds one exclusive lock for the session's lifetime so a
+ * waiting step can tell a slow parent from a dead one, answers each request
+ * once, and removes its own requests on close; its answers stay for the steps
+ * still reading them. Requests carrying another session's nonce belong to
+ * that session and are never touched. Whether to install or commit comes from
+ * the policy the session started with, never from run state, which the
+ * agent's sandbox can write.
+ */
+export declare class MigrateCommitBroker {
+    private readonly root;
+    private readonly dir;
+    private readonly reconcileCommand;
+    private readonly policy;
+    readonly nonce: string;
+    private readonly handled;
+    private inFlight;
+    private readonly lock;
+    constructor(root: string, dir: string, reconcileCommand: string, policy: MigrateRunPolicy);
+    /** The request whose operation this process is running right now. */
+    get requestInFlight(): BrokerRequest | null;
+    /** Answers this session's unanswered requests, one at a time. */
+    service(): Promise<void>;
+    private record;
+    private answer;
+    /** Releases the lock; call after the last `service` settled. */
+    close(): void;
+    private notADirectory;
+}