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

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

@@ -22,6 +22,7 @@ const run_id_1 = require("./run-id");
 const state_machine_1 = require("./state-machine");
 const state_lock_1 = require("./state-lock");
 const util_1 = require("./util");
+const broker_1 = require("./broker");
 const text_1 = require("../text");
 const agent_output_1 = require("./agent-output");
 const agent_work_payload_1 = require("./agent-work-payload");
@@ -98,10 +99,9 @@ async function runSingleMigrationWorker(input) {
 function readMigrationsSource(root, runId) {
     if (runId) {
         const dir = (0, run_state_1.runDir)(root, runId);
-        // A missing run.json would surface a raw ENOENT from readRunState's
-        // readFileSync; report it the way the orchestrator does instead, down to
-        // carrying no remediation: starting a run is a separate, gated entry point,
-        // and `--run-migrations` would run the whole plan in process instead.
+        // A missing run.json would surface a raw ENOENT from readRunState; report
+        // it the way the orchestrator does instead, with no remediation: starting
+        // a run is a gated entry point of its own.
         if (!(0, run_state_1.hasRunState)(dir)) {
             throw new Error(`No migrate run '${runId}' was found under ${types_1.MIGRATE_RUNS_RELATIVE_DIR}.`);
         }
@@ -358,177 +358,180 @@ async function runRecorded(root, runId, migration, skipInstall, isVerbose) {
     // invocation may have claimed a later attempt whose flag `step` predates.
     const startedStep = state.steps.find((s) => s.id === step.id);
     const generatorAlreadyCompleted = startedStep.generatorCompleted === true;
-    // The run records its own install policy because dispensed worker commands
-    // are re-invoked by the loop and never carry the user's flags; an explicit
-    // --skip-install on this invocation still applies on top of it.
+    // Dispensed worker commands never carry the user's flags, so the run records
+    // its install policy. An explicit --skip-install here applies only to the
+    // installs this process runs itself; a parent session answers from its own.
     const effectiveSkipInstall = state.skipInstall === true || skipInstall;
     // The run records the resolved validation policy at init; absent (a state
     // predating the field) falls back to the same default init applies.
     const shouldValidate = state.validate !== false;
+    // The tree reservation an in-process install or commit takes is held until
+    // the transition that records this attempt's outcome is written.
+    const scope = {};
     // Called before a retry hands the step's work back: the prompt or validation
     // may need the dependencies the earlier attempt's generator added.
-    const reinstallFromBaseline = () => recordingInstallFailure(dir, step.id, () => (0, util_1.installDepsChangedSinceDispense)(root, dir, startedStep, effectiveSkipInstall, `${(0, execute_migration_1.formatSingleMigrationRerunCommand)(migrationId)} --run-id=${runId}`));
+    const reinstallFromBaseline = () => (0, broker_1.installStepTree)(dir, startedStep, 'install', () => recordingInstallFailure(dir, step.id, () => (0, util_1.installDepsChangedSinceDispense)(root, dir, startedStep, effectiveSkipInstall, `${(0, execute_migration_1.formatSingleMigrationRerunCommand)(migrationId)} --run-id=${runId}`)), scope);
     let outcome;
     let awaitingKind;
     const payloadPath = (0, agent_work_payload_1.agentWorkPayloadPath)(dir, step.id, startedStep.attempt);
     try {
-        if ((0, migration_shape_1.isPromptOnlyMigration)(migration)) {
-            emitOrPrintPrompt(root, migration, agenticKind, {
-                persistPath: payloadPath,
-            });
-            awaitingKind = 'migration-prompt';
-        }
-        else if (generatorAlreadyCompleted &&
-            startedStep.agenticWaived !== true &&
-            (0, migration_shape_1.isHybridMigration)(migration)) {
-            await reinstallFromBaseline();
-            const carried = (0, agent_work_payload_1.latestStoredAgentWorkPayload)(dir, step.id, startedStep.attempt, startedStep.generatorCompletedAtAttempt, {
-                migrationId,
-                kind: 'migration-prompt',
-                promptPath: migration.prompt,
-            });
-            if (carried) {
-                reemitCarriedAgentWork(migrationId, 'migration-prompt', payloadPath, carried);
-            }
-            else {
+        try {
+            if ((0, migration_shape_1.isPromptOnlyMigration)(migration)) {
                 emitOrPrintPrompt(root, migration, agenticKind, {
                     persistPath: payloadPath,
                 });
+                awaitingKind = 'migration-prompt';
             }
-            awaitingKind = 'migration-prompt';
-        }
-        else if (generatorAlreadyCompleted &&
-            startedStep.validationOwed === true) {
-            // The persisted flag is the only record that these changes still owe a
-            // validation pass: the decision needed the generator result, which is
-            // gone with the attempt that made it, and a true waiver never writes the
-            // flag. The commit stays with the fold, as on a first attempt.
-            await reinstallFromBaseline();
-            const carried = (0, agent_work_payload_1.latestStoredAgentWorkPayload)(dir, step.id, startedStep.attempt, startedStep.generatorCompletedAtAttempt, { migrationId, kind: 'generator-validation' });
-            if (carried) {
-                reemitCarriedAgentWork(migrationId, 'generator-validation', payloadPath, carried);
+            else if (generatorAlreadyCompleted &&
+                startedStep.agenticWaived !== true &&
+                (0, migration_shape_1.isHybridMigration)(migration)) {
+                await reinstallFromBaseline();
+                const carried = (0, agent_work_payload_1.latestStoredAgentWorkPayload)(dir, step.id, startedStep.attempt, startedStep.generatorCompletedAtAttempt, {
+                    migrationId,
+                    kind: 'migration-prompt',
+                    promptPath: migration.prompt,
+                });
+                if (carried) {
+                    reemitCarriedAgentWork(migrationId, 'migration-prompt', payloadPath, carried);
+                }
+                else {
+                    emitOrPrintPrompt(root, migration, agenticKind, {
+                        persistPath: payloadPath,
+                    });
+                }
+                awaitingKind = 'migration-prompt';
+            }
+            else if (generatorAlreadyCompleted &&
+                startedStep.validationOwed === true) {
+                // The flag is the only record that these changes still owe a validation
+                // pass; the decision needed the generator result, which is gone with the
+                // attempt that made it. The commit stays with the fold.
+                await reinstallFromBaseline();
+                const carried = (0, agent_work_payload_1.latestStoredAgentWorkPayload)(dir, step.id, startedStep.attempt, startedStep.generatorCompletedAtAttempt, { migrationId, kind: 'generator-validation' });
+                if (carried) {
+                    reemitCarriedAgentWork(migrationId, 'generator-validation', payloadPath, carried);
+                }
+                else {
+                    emitValidationBlock(root, migration, undefined, {
+                        persistPath: payloadPath,
+                    });
+                }
+                awaitingKind = 'generator-validation';
+            }
+            else if (generatorAlreadyCompleted) {
+                state = await finishCompletedGenerator(dir, root, state, startedStep, migration, effectiveSkipInstall, runId, scope);
+                outcome = buildOutcome([], [], 'The generator ran in an earlier attempt; this attempt completed its install and commit.', root);
             }
             else {
-                emitValidationBlock(root, migration, undefined, {
-                    persistPath: payloadPath,
+                const installer = new execute_migration_1.ChangedDepInstaller(root, effectiveSkipInstall, `${(0, execute_migration_1.formatSingleMigrationRerunCommand)(migrationId)} --run-id=${runId}`);
+                // Read once; the run and the hybrid documentation resolution share it.
+                const resolvedCollection = (0, execute_migration_1.readMigrationCollection)(migration.package, root);
+                const { changes, nextSteps, agentContext, skipAgentic, logs, madeChanges, } = await (0, execute_migration_1.runNxOrAngularMigration)(root, migration, isVerbose, 
+                // Captured whenever an agent step may consume it: a hybrid's prompt
+                // payload, or the validation pass over the generator's changes.
+                (0, migration_shape_1.isHybridMigration)(migration) || shouldValidate, resolvedCollection);
+                // Mirrors the classic loop's waiver semantics (migrate.ts): the two must
+                // agree on when an AI step was owed for skipAgentic to waive.
+                const validationApplies = shouldValidate && !(0, migration_shape_1.isHybridMigration)(migration) && changes.length > 0;
+                const waivedAgenticStep = skipAgentic && ((0, migration_shape_1.isHybridMigration)(migration) || validationApplies);
+                const validationOwed = validationApplies && !waivedAgenticStep;
+                const promptOwed = (0, migration_shape_1.isHybridMigration)(migration) && !waivedAgenticStep;
+                // Recorded before the commit is attempted: from here on the changes are
+                // in the tree, so a failed install or commit must leave a retry with
+                // only those left to do rather than running the generator again.
+                state = transition(dir, {
+                    type: 'markGeneratorCompleted',
+                    stepId: step.id,
+                    agenticWaived: waivedAgenticStep,
+                    validationOwed,
+                    madeChanges,
                 });
+                if (waivedAgenticStep) {
+                    (0, migrate_output_1.logWaivedAgenticStep)(migration, agentContext);
+                }
+                else if (!(0, migration_shape_1.isHybridMigration)(migration) && !validationApplies) {
+                    forwardDroppedAgentContext(migration, agentContext, agenticKind);
+                }
+                // Stored before the install: a failed install fails the attempt, and
+                // the retry re-hands this payload instead of a context-free one.
+                const impl = { logs, changes, agentContext };
+                const owed = validationOwed
+                    ? validationPayload(root, migration, impl, resolvedCollection)
+                    : promptOwed
+                        ? promptPayload(root, migration, impl, resolvedCollection)
+                        : undefined;
+                if (owed) {
+                    (0, agent_work_payload_1.persistAgentWorkPayload)(payloadPath, owed);
+                }
+                const install = () => recordingInstallFailure(dir, step.id, () => installer.installDepsIfChanged());
+                // A no-op step's commit would absorb prior pending diffs under its name;
+                // a step handing work back defers its commit to the fold, so the
+                // migration still lands as one commit. The install runs either way: the
+                // agent may run tasks that need what the generator added.
+                if (state.createCommits &&
+                    madeChanges &&
+                    !validationOwed &&
+                    !promptOwed) {
+                    state = await commitStepChanges(dir, root, state, startedStep, migration, install, scope);
+                }
+                else {
+                    await (0, broker_1.installStepTree)(dir, startedStep, 'install', install, scope);
+                }
+                if (installer.skippedInstall) {
+                    (0, execute_migration_1.logSkippedPostMigrationInstall)(root);
+                }
+                else if (installer.installed) {
+                    (0, util_1.recordInstallLanded)(root, dir, step.id);
+                }
+                printNextSteps(migration, nextSteps);
+                if (validationOwed) {
+                    emitValidationPayload(migrationId, owed);
+                    awaitingKind = 'generator-validation';
+                }
+                else if (promptOwed) {
+                    emitPromptForOuterAgent(migrationId, owed, true);
+                    awaitingKind = 'migration-prompt';
+                }
+                else {
+                    outcome = buildOutcome(changes, nextSteps, migration.description, root);
+                }
             }
-            awaitingKind = 'generator-validation';
         }
-        else if (generatorAlreadyCompleted) {
-            // Reached when the earlier attempt waived the AI step, or none was owed
-            // (no changes, validation off, or an older-nx state).
-            state = await finishCompletedGenerator(dir, root, state, startedStep, migration, effectiveSkipInstall, runId);
-            outcome = buildOutcome([], [], 'The generator ran in an earlier attempt; this attempt completed its install and commit.', root);
+        catch (e) {
+            // Another attempt owns the step, and `fail` is not attempt-bound.
+            if (e instanceof broker_1.BrokerStaleRequestError)
+                throw e;
+            // The failed-step dispense surfaces this so the agent can decide
+            // retry-vs-skip; carry the error's first line, not a full stack.
+            transition(dir, {
+                type: 'fail',
+                stepId: step.id,
+                finishedAt: (0, util_1.nowIso)(),
+                outcome: { summary: (0, util_1.summarizeError)(e) },
+            });
+            throw e;
         }
-        else {
-            const installer = new execute_migration_1.ChangedDepInstaller(root, effectiveSkipInstall, `${(0, execute_migration_1.formatSingleMigrationRerunCommand)(migrationId)} --run-id=${runId}`);
-            // Read once; the run and the hybrid documentation resolution share it.
-            const resolvedCollection = (0, execute_migration_1.readMigrationCollection)(migration.package, root);
-            const { changes, nextSteps, agentContext, skipAgentic, logs, madeChanges, } = await (0, execute_migration_1.runNxOrAngularMigration)(root, migration, isVerbose, 
-            // Captured whenever an agent step may consume it: a hybrid's prompt
-            // payload, or the validation pass over the generator's changes.
-            (0, migration_shape_1.isHybridMigration)(migration) || shouldValidate, resolvedCollection);
-            // Mirrors the classic loop's waiver semantics (migrate.ts): the two must
-            // agree on when an AI step was owed for skipAgentic to waive.
-            const validationApplies = shouldValidate && !(0, migration_shape_1.isHybridMigration)(migration) && changes.length > 0;
-            const waivedAgenticStep = skipAgentic && ((0, migration_shape_1.isHybridMigration)(migration) || validationApplies);
-            const validationOwed = validationApplies && !waivedAgenticStep;
-            const promptOwed = (0, migration_shape_1.isHybridMigration)(migration) && !waivedAgenticStep;
-            // Recorded before the commit is attempted: from here on the changes are
-            // in the tree, so a failed install or commit must leave a retry with
-            // only those left to do rather than running the generator again. The
-            // waiver and the owed validation ride along so that retry re-emits
-            // exactly the agent work this attempt decided was owed.
-            state = transition(dir, {
-                type: 'markGeneratorCompleted',
+        // Handed-back work is applied by a separate actor, so parking exits
+        // successfully rather than failing the step.
+        if (awaitingKind !== undefined) {
+            transition(dir, {
+                type: 'awaitPromptOutcome',
                 stepId: step.id,
-                agenticWaived: waivedAgenticStep,
-                validationOwed,
-                madeChanges,
+                finishedAt: (0, util_1.nowIso)(),
+                awaitingKind,
             });
-            if (waivedAgenticStep) {
-                (0, migrate_output_1.logWaivedAgenticStep)(migration, agentContext);
-            }
-            else if (!(0, migration_shape_1.isHybridMigration)(migration) && !validationApplies) {
-                forwardDroppedAgentContext(migration, agentContext, agenticKind);
-            }
-            // Stored before the install: a failed install fails the attempt, and
-            // the retry re-hands this payload instead of a context-free one.
-            const impl = { logs, changes, agentContext };
-            const owed = validationOwed
-                ? validationPayload(root, migration, impl, resolvedCollection)
-                : promptOwed
-                    ? promptPayload(root, migration, impl, resolvedCollection)
-                    : undefined;
-            if (owed) {
-                (0, agent_work_payload_1.persistAgentWorkPayload)(payloadPath, owed);
-            }
-            const install = () => recordingInstallFailure(dir, step.id, () => installer.installDepsIfChanged());
-            // Commits follow the run config, not CLI flags, and only when the
-            // generator changed something: a no-op step's commit would absorb prior
-            // pending diffs under its name. A step handing work back defers its
-            // commit to the fold, so the migration lands as one commit and a failed
-            // hand-back leaves the changes uncommitted for review, as in the classic
-            // loop. The install still runs first: the agent may run tasks that need
-            // what the generator added.
-            if (state.createCommits &&
-                madeChanges &&
-                !validationOwed &&
-                !promptOwed) {
-                state = await commitStepChanges(dir, root, state, step, migration, install);
-            }
-            else {
-                await install();
-            }
-            if (installer.skippedInstall) {
-                (0, execute_migration_1.logSkippedPostMigrationInstall)(root);
-            }
-            else if (installer.installed) {
-                (0, util_1.recordInstallLanded)(root, dir, step.id);
-            }
-            printNextSteps(migration, nextSteps);
-            if (validationOwed) {
-                emitValidationPayload(migrationId, owed);
-                awaitingKind = 'generator-validation';
-            }
-            else if (promptOwed) {
-                emitPromptForOuterAgent(migrationId, owed, true);
-                awaitingKind = 'migration-prompt';
-            }
-            else {
-                outcome = buildOutcome(changes, nextSteps, migration.description, root);
-            }
+            return;
         }
-    }
-    catch (e) {
-        // The failed-step dispense surfaces this so the agent can decide
-        // retry-vs-skip; carry the error's first line, not a full stack.
         transition(dir, {
-            type: 'fail',
+            type: 'succeed',
             stepId: step.id,
             finishedAt: (0, util_1.nowIso)(),
-            outcome: { summary: (0, util_1.summarizeError)(e) },
+            ...(outcome ? { outcome } : {}),
         });
-        throw e;
     }
-    // Handed-back work is applied by a separate actor, so parking exits
-    // successfully rather than failing the step.
-    if (awaitingKind !== undefined) {
-        transition(dir, {
-            type: 'awaitPromptOutcome',
-            stepId: step.id,
-            finishedAt: (0, util_1.nowIso)(),
-            awaitingKind,
-        });
-        return;
+    finally {
+        scope.lease?.release();
     }
-    transition(dir, {
-        type: 'succeed',
-        stepId: step.id,
-        finishedAt: (0, util_1.nowIso)(),
-        ...(outcome ? { outcome } : {}),
-    });
 }
 // Applies a step event to the freshest on-disk state under the lock, writes it,
 // and returns it. Reading fresh is what makes a racing worker's 'start' see the
@@ -561,49 +564,52 @@ async function recordingInstallFailure(dir, stepId, install) {
 // on the install or the commit. The generator's changes are already in the
 // tree, so only those two are left, and the install compares against the
 // step's persisted baseline rather than against what that generator wrote.
-async function finishCompletedGenerator(dir, root, state, step, migration, skipInstall, runId) {
+async function finishCompletedGenerator(dir, root, state, step, migration, skipInstall, runId, scope) {
     const migrationId = `${migration.package}:${migration.name}`;
     const installDeps = () => recordingInstallFailure(dir, step.id, () => (0, util_1.installDepsChangedSinceDispense)(root, dir, step, skipInstall, `${(0, execute_migration_1.formatSingleMigrationRerunCommand)(migrationId)} --run-id=${runId}`));
     // Same no-op guard as the first attempt. Only an explicit false skips the
     // commit: absent means an older nx wrote the marker without recording the
     // answer, and the commit is kept as that version's retries did.
     if (!state.createCommits || step.generatorMadeChanges === false) {
-        await installDeps();
+        await (0, broker_1.installStepTree)(dir, step, 'install', installDeps, scope);
         return state;
     }
-    return commitStepChanges(dir, root, state, step, migration, installDeps);
+    return commitStepChanges(dir, root, state, step, migration, installDeps, scope);
 }
 // Installs what the step changed, commits it, and records the result in the
 // ledger, shared by a step's first attempt and by one that only has the commit
 // left to do. The absorbed step ids are computed before the commit so the
 // ledger entry and the commit body name the same ones.
-async function commitStepChanges(dir, root, state, step, migration, installDeps) {
+async function commitStepChanges(dir, root, state, step, migration, installDeps, scope) {
     const absorbedStepIds = (0, state_machine_1.uncoveredFailedStepIds)(state).filter((id) => id !== step.id);
-    let result;
+    let commit;
     try {
-        result = await (0, migrate_commits_1.commitMigrationIfRequested)(root, migration, true, state.commitPrefix, installDeps, (0, state_machine_1.stepsToPendingMigrations)(state, absorbedStepIds));
+        commit = await (0, broker_1.commitStepTree)(dir, step, absorbedStepIds, () => (0, migrate_commits_1.commitMigrationIfRequested)(root, migration, true, state.commitPrefix, installDeps, (0, state_machine_1.stepsToPendingMigrations)(state, absorbedStepIds)), scope);
     }
     catch (commitError) {
-        // A post-migration install failure leaves the diff uncommitted; record the
-        // debt so only a landed entry can cover it.
-        appendCommit(dir, { kind: 'failed', stepIds: [step.id] });
+        // Nothing ran for a stale or refused request, so there is no debt.
+        if (commitError instanceof broker_1.BrokerStaleRequestError ||
+            commitError instanceof broker_1.TreeBusyError) {
+            throw commitError;
+        }
+        // The install failed, or the session ended unanswered and the commit may
+        // or may not have landed; record the debt until a landed entry covers it.
+        recordCommitEntry(dir, { kind: 'failed', stepIds: [step.id] });
         throw commitError;
     }
-    if (result.status === 'failed') {
+    if (commit.result.status === 'failed') {
         (0, util_1.warnCommitFailed)(migration.name);
     }
-    const entry = (0, state_machine_1.commitResultToLedgerEntry)(result, step.id, absorbedStepIds);
-    return entry ? appendCommit(dir, entry) : state;
+    const entry = (0, state_machine_1.commitResultToLedgerEntry)(commit.result, step.id, commit.absorbedStepIds);
+    // A session's parent records what it commits itself, receipt included.
+    return entry && !commit.recorded ? recordCommitEntry(dir, entry) : state;
 }
 // The git commit itself already ran outside the lock; only this pure append is
 // locked. A landed entry carries the resolved issues of every step it names,
 // same as the orchestrator's fold and adopt appends: an absorbed step's
 // resolutions would otherwise land unattached.
-function appendCommit(dir, entry) {
-    return (0, state_lock_1.updateRunState)(dir, (fresh) => ({
-        ...fresh,
-        commits: [...fresh.commits, (0, issues_1.attachIssueIdsToCommitEntry)(fresh, entry)],
-    }));
+function recordCommitEntry(dir, entry) {
+    return (0, state_lock_1.updateRunState)(dir, (fresh) => (0, state_machine_1.appendCommit)(fresh, (0, issues_1.attachIssueIdsToCommitEntry)(fresh, entry)));
 }
 function buildOutcome(changes, nextSteps, description, root) {
     const outcome = {};
@@ -668,7 +674,7 @@ async function runAgenticStep(agenticRun, input) {
 // commit's diff, so it passes its own guidance instead of the default.
 // `commitMigrationIfRequested` logs a failed commit itself with that guidance.
 function attemptStandaloneCommit(root, migration, createCommits, commitPrefix, installDepsIfChanged) {
-    return (0, migrate_commits_1.commitMigrationIfRequested)(root, migration, createCommits, commitPrefix, installDepsIfChanged, [], 'Commit or revert the changes manually.');
+    return (0, migrate_commits_1.commitMigrationIfRequested)(root, migration, createCommits, commitPrefix, installDepsIfChanged, [], 'Commit or revert any remaining uncommitted changes manually.');
 }
 async function commitAndLogAgenticOutcome(args) {
     const commit = await attemptStandaloneCommit(args.root, args.migration, args.createCommits, args.commitPrefix, args.installDepsIfChanged);