@depup/nx 23.2.1-depup.7 → 23.3.0-depup.0

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateGraph = generateGraph;
+exports.selectedFor = selectedFor;
+exports.taskGraphForSelection = taskGraphForSelection;
 exports.getExpandedTaskInputs = getExpandedTaskInputs;
 const tslib_1 = require("tslib");
 const crypto_1 = require("crypto");
@@ -22,6 +24,9 @@ const typescript_1 = require("../../plugins/js/utils/typescript");
 const operators_1 = require("../../project-graph/operators");
 const project_graph_1 = require("../../project-graph/project-graph");
 const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
+const utils_1 = require("../../tasks-runner/utils");
+const run_command_1 = require("../../tasks-runner/run-command");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
 const all_file_data_1 = require("../../utils/all-file-data");
 const command_line_utils_1 = require("../../utils/command-line-utils");
 const native_1 = require("../../native");
@@ -178,6 +183,17 @@ async function generateGraph(args, affectedProjects) {
         }
     }
     let prunedGraph = (0, operators_1.pruneExternalNodes)(rawGraph);
+    // `nx graph --targets` has no command to take a selection from, so it draws
+    // the projects' targets.
+    const jsonTaskSelection = () => args.targets?.length
+        ? (resolveSelection(args.taskSelection) ??
+            (0, run_command_1.selectTasksForProjects)(rawGraph, args.projects?.length
+                ? args.projects
+                : [...(0, project_graph_utils_1.runnableForTarget)(rawGraph.nodes, args.targets)], {
+                targets: args.targets,
+                configuration: args.configuration,
+            }, {}, {}, false))
+        : undefined;
     const projects = Object.values(prunedGraph.nodes);
     projects.sort((a, b) => {
         return a.name.localeCompare(b.name);
@@ -231,7 +247,7 @@ async function generateGraph(args, affectedProjects) {
     let html = (0, node_fs_1.readFileSync)((0, node_path_1.join)(__dirname, '../../core/graph/index.html'), 'utf-8');
     prunedGraph = filterGraph(prunedGraph, args.focus || null, excludePatterns);
     if (args.print || args.file === 'stdout') {
-        console.log(JSON.stringify(await createJsonOutput(prunedGraph, rawGraph, args.projects, args.targets), null, 2));
+        console.log(JSON.stringify(await createJsonOutput(prunedGraph, rawGraph, jsonTaskSelection()), null, 2));
         await output_1.output.drain();
         await new Promise((res) => setImmediate(res));
         process.exit(0);
@@ -258,7 +274,7 @@ async function generateGraph(args, affectedProjects) {
             });
             const { projectGraphClientResponse } = await createProjectGraphAndSourceMapClientResponse(affectedProjects);
             const taskGraphClientResponse = args.targets
-                ? await createTaskGraphForTargetsAndProjects(args.targets, args.projects)
+                ? await createTaskGraphForTargetsAndProjects(args.targets, args.projects, args.configuration, args.taskSelection)
                 : await createTaskGraphClientResponse();
             const taskInputsReponse = await createExpandedTaskInputResponse(taskGraphClientResponse, projectGraphClientResponse);
             const environmentJs = buildEnvironmentJs(excludePatterns, args.watch, !!args.file && args.file.endsWith('html') ? 'build' : 'serve', projectGraphClientResponse, taskGraphClientResponse, taskInputsReponse, sourceMaps);
@@ -275,7 +291,7 @@ async function generateGraph(args, affectedProjects) {
         }
         else if (ext === '.json') {
             (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(fullFilePath), { recursive: true });
-            const json = await createJsonOutput(prunedGraph, rawGraph, args.projects, args.targets);
+            const json = await createJsonOutput(prunedGraph, rawGraph, jsonTaskSelection());
             (0, fileutils_1.writeJsonFile)(fullFilePath, json);
             output_1.output.success({
                 title: `JSON output created in ${fileFolderPath}`,
@@ -297,7 +313,13 @@ async function generateGraph(args, affectedProjects) {
         let app;
         let url;
         try {
-            const result = await startServer(html, environmentJs, args.host || '127.0.0.1', args.port || 4211, args.watch, affectedProjects, args.focus, args.groupByFolder, excludePatterns);
+            const result = await startServer(html, environmentJs, args.host || '127.0.0.1', args.port || 4211, args.watch, affectedProjects, args.focus, args.groupByFolder, excludePatterns, typeof args.taskSelection === 'object' && args.taskSelection.taskIds
+                ? {
+                    targets: args.targets,
+                    configuration: args.configuration,
+                    taskIds: args.taskSelection.taskIds,
+                }
+                : undefined);
             app = result.app;
             url = result.url;
         }
@@ -383,7 +405,7 @@ function findAvailablePort(startPort, host = '127.0.0.1') {
         });
     });
 }
-async function startServer(html, environmentJs, host, port = 4211, watchForChanges = true, affected = [], focus = null, groupByFolder = false, exclude = []) {
+async function startServer(html, environmentJs, host, port = 4211, watchForChanges = true, affected = [], focus = null, groupByFolder = false, exclude = [], selection) {
     let unregisterFileWatcher;
     if (watchForChanges && !client_1.daemonClient.enabled()) {
         output_1.output.warn({
@@ -427,14 +449,15 @@ async function startServer(html, environmentJs, host, port = 4211, watchForChang
         if (sanitizePath === 'task-graph.json') {
             const projectsParam = parsedUrl.searchParams.get('projects');
             const targetsParam = parsedUrl.searchParams.get('targets');
-            const configuration = parsedUrl.searchParams.get('configuration');
+            const configuration = parsedUrl.searchParams.get('configuration') || undefined;
             res.writeHead(200, { 'Content-Type': 'application/json' });
             if (targetsParam) {
                 const targetNames = targetsParam.split(' ').filter(Boolean);
                 const projectNames = projectsParam
                     ? projectsParam.split(' ').filter(Boolean)
                     : undefined;
-                return res.end(JSON.stringify(await createTaskGraphForTargetsAndProjects(targetNames, projectNames, configuration)));
+                const request = selectedFor(targetNames, configuration, selection);
+                return res.end(JSON.stringify(await createTaskGraphForTargetsAndProjects(targetNames, projectNames, request.configuration, { taskIds: request.taskIds })));
             }
             // load all task graphs if there's no targets specified
             return res.end(JSON.stringify(await createTaskGraphClientResponse()));
@@ -726,7 +749,7 @@ async function createTaskGraphClientResponse(pruneExternal = false) {
     try {
         const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, {}, projects, targets, undefined, {});
         node_perf_hooks_1.performance.mark('task graph generation:end');
-        const planner = new native_1.HashPlanner(nxJson, (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(graph)));
+        const planner = new native_1.HashPlanner(nxJson, (0, transform_objects_1.transformProjectGraphForRust)(graph));
         node_perf_hooks_1.performance.mark('task hash plan generation:start');
         const taskIds = Object.keys(taskGraph.tasks);
         const plans = taskIds.length > 0 ? planner.getPlans(taskIds, taskGraph) : {};
@@ -774,10 +797,40 @@ function clearTaskGraphCache() {
     expandedTaskInputsCache.clear();
 }
 /**
- * Creates a single task graph for multiple projects with multiple targets
- * If no projects specified, returns graph for all projects with the targets
+ * The selection applies only to a page asking for its exact targets with its configuration
+ * or none (the ids carry it); anything else would prune to nothing, so it is shown whole.
+ */
+function selectedFor(targets, configuration, selection) {
+    const applies = selection &&
+        targets.length === selection.targets.length &&
+        targets.every((target) => selection.targets.includes(target)) &&
+        (configuration === undefined || configuration === selection.configuration);
+    return applies
+        ? { configuration: selection.configuration, taskIds: selection.taskIds }
+        : { configuration };
+}
+function resolveSelection(selection) {
+    return typeof selection === 'function' ? selection() : selection;
+}
+/**
+ * The task graph to draw: the selection's own when it has one, otherwise built
+ * and, given ids, pruned to them. The live graph rebuilds per request, so it
+ * passes only ids.
+ */
+function taskGraphForSelection(build, selection) {
+    if (selection?.taskGraph) {
+        return selection.taskGraph;
+    }
+    const taskGraph = build();
+    return selection?.taskIds
+        ? (0, utils_1.pruneToSelectedTasks)(taskGraph, selection.taskIds)
+        : taskGraph;
+}
+/**
+ * The task graph client response for `targetNames`: `selection`'s graph when given,
+ * else built for `projectNames` (default: every project with one of the targets).
  */
-async function createTaskGraphForTargetsAndProjects(targetNames, projectNames, configuration) {
+async function createTaskGraphForTargetsAndProjects(targetNames, projectNames, configuration, selection) {
     // Get project graph
     let graph;
     try {
@@ -801,10 +854,11 @@ async function createTaskGraphForTargetsAndProjects(targetNames, projectNames, c
             .map(([projectName]) => projectName);
     }
     try {
-        // Create single task graph
-        const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, {}, projectsToUse, targetNames, configuration, {});
+        const taskGraph = taskGraphForSelection(() => (0, create_task_graph_1.createTaskGraph)(graph, {}, projectsToUse, targetNames, configuration, {}), 
+        // Built in here, so an error is reported in the page like any other.
+        resolveSelection(selection));
         node_perf_hooks_1.performance.mark(`task graph generation:end`);
-        const planner = new native_1.HashPlanner(nxJson, (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(graph)));
+        const planner = new native_1.HashPlanner(nxJson, (0, transform_objects_1.transformProjectGraphForRust)(graph));
         node_perf_hooks_1.performance.mark('task hash plan generation:start');
         const taskIds = Object.keys(taskGraph.tasks);
         const plans = taskIds.length > 0 ? planner.getPlans(taskIds, taskGraph) : {};
@@ -850,17 +904,51 @@ async function getExpandedTaskInputs(depGraphClientResponse, expandedTaskInputsC
     expandedTaskInputsCache.set(taskId, result);
     return result;
 }
+// A brace group ({a,b}.json) carries commas, so a glob list joined with
+// commas can only be split at brace depth zero.
+function splitGlobGroup(group) {
+    const globs = [];
+    let current = '';
+    let depth = 0;
+    for (const char of group) {
+        if (char === '{') {
+            depth++;
+        }
+        else if (char === '}' && depth > 0) {
+            depth--;
+        }
+        if (char === ',' && depth === 0) {
+            globs.push(current);
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    globs.push(current);
+    // An unbalanced `{` would swallow the rest of the list; a plain split is
+    // the better guess then.
+    return depth === 0 ? globs : group.split(',');
+}
 function expandInputs(inputs, project, allWorkspaceFiles, depGraphClientResponse) {
     const projectNames = depGraphClientResponse.projects.map((p) => p.name);
     const workspaceRootInputs = [];
     const projectRootInputs = [];
     const externalInputs = [];
     const otherInputs = [];
+    const filesInputs = [];
     inputs.forEach((input) => {
         // grouped workspace inputs look like workspace:[pattern,otherPattern]
         if (input.startsWith('workspace:[')) {
-            const inputs = input.substring(11, input.length - 1).split(',');
-            workspaceRootInputs.push(...inputs);
+            workspaceRootInputs.push(...splitGlobGroup(input.substring(11, input.length - 1)));
+            return;
+        }
+        // Disk-backed groups look like files:[glob,!otherGlob]. They expand on
+        // disk, so they must be matched before the `:` catch-all below classifies
+        // them as external dependencies.
+        const diskBacked = /^files:\[(.*)\]$/.exec(input);
+        if (diskBacked) {
+            filesInputs.push(splitGlobGroup(diskBacked[1]));
             return;
         }
         const maybeProjectName = input.split(':')[0];
@@ -881,6 +969,7 @@ function expandInputs(inputs, project, allWorkspaceFiles, depGraphClientResponse
         }
     });
     const workspaceRootsExpanded = getExpandedWorkspaceRoots(workspaceRootInputs, allWorkspaceFiles);
+    const filesExpanded = filesInputs.flatMap((globs) => (0, native_1.expandFilesInput)(workspace_root_1.workspaceRoot, globs));
     const otherInputsExpanded = otherInputs.map((input) => {
         if (input === 'TsConfig') {
             return (0, node_path_1.relative)(workspace_root_1.workspaceRoot, (0, typescript_1.getRootTsConfigPath)());
@@ -908,7 +997,11 @@ function expandInputs(inputs, project, allWorkspaceFiles, depGraphClientResponse
         return acc;
     }, {});
     return {
-        general: [...workspaceRootsExpanded, ...otherInputsExpanded],
+        general: [
+            ...workspaceRootsExpanded,
+            ...filesExpanded,
+            ...otherInputsExpanded,
+        ],
         ...projectRootsExpanded,
         external: externalInputs,
     };
@@ -943,12 +1036,12 @@ function getExpandedWorkspaceRoots(workspaceRootInputs, allWorkspaceFiles) {
     workspaceRootsExpanded.sort();
     return workspaceRootsExpanded;
 }
-async function createJsonOutput(prunedGraph, rawGraph, projects, targets) {
+async function createJsonOutput(prunedGraph, rawGraph, taskSelection) {
     const response = {
         graph: prunedGraph,
     };
-    if (targets?.length) {
-        const taskGraph = (0, create_task_graph_1.createTaskGraph)(rawGraph, {}, projects, targets, undefined, {});
+    if (taskSelection) {
+        const taskGraph = taskSelection.taskGraph;
         const hasher = (0, create_task_hasher_1.createTaskHasher)(rawGraph, (0, configuration_1.readNxJson)());
         let tasks = Object.values(taskGraph.tasks);
         // Match the runtime path: each task is hashed against its own env so

package/dist/src/command-line/init/implementation/add-nx-to-monorepo.js

@@ -65,9 +65,6 @@ async function addNxToMonorepo(options, guided = true) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
         await (0, utils_1.initCloud)('nx-init-monorepo');
     }
-    else if (nxCloudChoice === 'never') {
-        (0, utils_1.setNeverConnectToCloud)(repoRoot);
-    }
 }
 // scanning package.json files
 function allProjectPackageJsonFiles(repoRoot) {

package/dist/src/command-line/init/implementation/add-nx-to-nest.js

@@ -92,9 +92,6 @@ async function addNxToNest(options, packageJson) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
         await (0, utils_1.initCloud)('nx-init-nest');
     }
-    else if (nxCloudChoice === 'never') {
-        (0, utils_1.setNeverConnectToCloud)(repoRoot);
-    }
 }
 function addNestPluginToPackageJson(repoRoot) {
     const path = (0, path_1.join)(repoRoot, `package.json`);

package/dist/src/command-line/init/implementation/add-nx-to-npm-repo.js

@@ -64,7 +64,4 @@ async function addNxToNpmRepo(options, guided = true) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
         await (0, utils_1.initCloud)('nx-init-npm-repo');
     }
-    else if (nxCloudChoice === 'never') {
-        (0, utils_1.setNeverConnectToCloud)(repoRoot);
-    }
 }

package/dist/src/command-line/init/implementation/angular/index.js

@@ -56,9 +56,6 @@ async function addNxToAngularCliRepo(options) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
         await (0, utils_1.initCloud)('nx-init-angular');
     }
-    else if (nxCloudChoice === 'never') {
-        (0, utils_1.setNeverConnectToCloud)(repoRoot);
-    }
 }
 async function collectCacheableOperations(options) {
     let cacheableOperations;

package/dist/src/command-line/init/implementation/angular/legacy-angular-versions.js

@@ -119,9 +119,6 @@ async function getLegacyMigrationFunctionIfApplicable(repoRoot, options) {
             output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
             await (0, utils_1.initCloud)('nx-init-angular');
         }
-        else if (nxCloudChoice === 'never') {
-            (0, utils_1.setNeverConnectToCloud)(repoRoot);
-        }
     };
 }
 async function installDependencies(repoRoot, pkgInfo, pmc) {

package/dist/src/command-line/init/implementation/format.js

@@ -72,8 +72,7 @@ command = 'nx init') {
     // already finished.
     //
     // Chunked as `nx format` chunks: the Angular flow records a `project.json`
-    // per project. The prettier path is sized against its quoted length; oxfmt
-    // goes through execFile and gets raw paths.
+    // per project.
     let formatter = null;
     try {
         formatter = (0, formatters_1.detectFormatter)(repoRoot);
@@ -93,7 +92,7 @@ command = 'nx init') {
             // batch, but exits 2 on one unsupported file, which would end a
             // successful init with a spurious warning and prettier's own stderr.
             const supported = await (0, prettier_1.filterToPrettierSupportedFiles)(files);
-            for (const chunk of (0, chunkify_1.chunkify)(supported, undefined, (pattern) => (0, prettier_1.quoteForShell)(pattern).length)) {
+            for (const chunk of (0, chunkify_1.chunkify)(supported)) {
                 if (chunk.length) {
                     (0, prettier_1.writeWithPrettier)(chunk, repoRoot);
                 }

package/dist/src/command-line/init/implementation/utils.d.ts

@@ -24,7 +24,6 @@ export declare function toErrorString(error: unknown): string;
 export declare function readErrorStderr(error: unknown): string;
 export declare function extractErrorName(error: unknown, stderr: string): string;
 export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo' | 'nx-init-turborepo'): Promise<void>;
-export declare function setNeverConnectToCloud(repoRoot: string): void;
 export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;
 export declare function markRootPackageJsonAsNxProjectLegacy(repoRoot: string, cacheableScripts: string[], pmc: PackageManagerCommands): void;
 export declare function markPackageJsonAsNxProject(packageJsonPath: string): void;

package/dist/src/command-line/init/implementation/utils.js

@@ -10,7 +10,6 @@ exports.toErrorString = toErrorString;
 exports.readErrorStderr = readErrorStderr;
 exports.extractErrorName = extractErrorName;
 exports.initCloud = initCloud;
-exports.setNeverConnectToCloud = setNeverConnectToCloud;
 exports.addVsCodeRecommendedExtensions = addVsCodeRecommendedExtensions;
 exports.markRootPackageJsonAsNxProjectLegacy = markRootPackageJsonAsNxProjectLegacy;
 exports.markPackageJsonAsNxProject = markPackageJsonAsNxProject;
@@ -253,13 +252,17 @@ function updateGitIgnore(root) {
 }
 function runInstall(repoRoot, packageManager = (0, package_manager_1.detectPackageManager)(repoRoot), pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager)) {
     let command = pmc.install;
+    const env = { ...process.env };
     // Plugins added during init can pull build-script deps whose allowBuilds
     // entries are only recorded by their init generators after this install;
-    // warn and skip for this one install, like pnpm 10 did.
+    // warn and skip for this one install, like pnpm 10 did. pnpm 12 gave
+    // `--config` a meaning of its own and takes the setting from the
+    // environment instead.
     if (packageManager === 'pnpm') {
         try {
             if ((0, semver_1.gte)((0, package_manager_1.getPackageManagerVersion)('pnpm', repoRoot), '11.0.0')) {
                 command += ' --config.strictDepBuilds=false';
+                env.PNPM_CONFIG_STRICT_DEP_BUILDS = 'false';
             }
         }
         catch {
@@ -272,6 +275,7 @@ function runInstall(repoRoot, packageManager = (0, package_manager_1.detectPacka
             encoding: 'utf8',
             cwd: repoRoot,
             windowsHide: true,
+            env,
         });
     }
     catch (e) {
@@ -341,13 +345,6 @@ async function initCloud(installationSource) {
     });
     await (0, connect_to_nx_cloud_1.printSuccessMessage)(token, installationSource);
 }
-function setNeverConnectToCloud(repoRoot) {
-    const nxJsonPath = (0, path_1.join)(repoRoot, 'nx.json');
-    const nxJson = (0, fileutils_1.readJsonFile)(nxJsonPath);
-    nxJson.neverConnectToCloud = true;
-    (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
-    (0, format_1.recordInitWrite)(nxJsonPath);
-}
 function addVsCodeRecommendedExtensions(repoRoot, extensions) {
     const vsCodeExtensionsPath = (0, path_1.join)(repoRoot, '.vscode/extensions.json');
     if ((0, fileutils_1.fileExists)(vsCodeExtensionsPath)) {

package/dist/src/command-line/init/init-v2.js

@@ -379,9 +379,6 @@ async function runInit(options, baseMeta) {
     if (nxCloudChoice === 'yes') {
         await (0, utils_1.initCloud)('nx-init');
     }
-    else if (nxCloudChoice === 'never') {
-        (0, utils_1.setNeverConnectToCloud)(repoRoot);
-    }
     const analyticsPrompt = await (0, analytics_prompt_1.ensureAnalyticsPreferenceSet)(repoRoot, options.interactive);
     await (0, ab_testing_1.recordStat)({
         command: 'init',

package/dist/src/command-line/migrate/agentic/capture-generator-output.d.ts

@@ -3,11 +3,36 @@
  * preserving the original behavior. Does not intercept
  * `process.{stdout,stderr}.write` — those bypass `console` and would also
  * pick up unrelated framework output. Restoration is idempotent.
+ *
+ * `flush()` returns at most `MAX_GENERATOR_OUTPUT_BYTES`: up to the first
+ * `HEAD_BYTES` of output, a marker with the omitted byte count, and the most
+ * recent output. The terminal still receives everything through the tee.
  */
 export interface GeneratorOutputCapture {
     flush(): string;
     restore(): void;
 }
+export declare const MAX_GENERATOR_OUTPUT_BYTES = 16384;
+export declare const MARKER_BYTES: number;
+export declare class BoundedOutput {
+    private readonly head;
+    private headBytes;
+    private headOpen;
+    private headSplit;
+    private readonly tail;
+    private tailBytes;
+    private omitted;
+    append(record: string): void;
+    render(): string;
+}
+export declare class BoundedChunks {
+    private head;
+    private headOpen;
+    private tail;
+    private omitted;
+    append(chunk: string): void;
+    render(): string;
+}
 export declare function installGeneratorOutputCapture(): GeneratorOutputCapture;
 /**
  * Convenience wrapper that installs the capture, runs `fn`, restores on

package/dist/src/command-line/migrate/agentic/capture-generator-output.js

@@ -1,9 +1,127 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoundedChunks = exports.BoundedOutput = exports.MARKER_BYTES = exports.MAX_GENERATOR_OUTPUT_BYTES = void 0;
 exports.installGeneratorOutputCapture = installGeneratorOutputCapture;
 exports.withGeneratorOutputCapture = withGeneratorOutputCapture;
 const node_util_1 = require("node:util");
 const logger_1 = require("../../../utils/logger");
+const handoff_1 = require("./handoff");
+exports.MAX_GENERATOR_OUTPUT_BYTES = 16384;
+const HEAD_BYTES = 4096;
+const omittedMarker = (omitted) => `[nx migrate: ${omitted} bytes of output omitted]`;
+// Reserved at the widest number spelling so a growing count cannot push a
+// flush over the cap.
+exports.MARKER_BYTES = Buffer.byteLength(`\n${omittedMarker(Number.MAX_VALUE)}\n`);
+const TAIL_LIMIT = exports.MAX_GENERATOR_OUTPUT_BYTES - HEAD_BYTES - exports.MARKER_BYTES;
+// Keeps the last `maxBytes` of `value`, cut on a code point.
+function keepTailUtf8(value, maxBytes) {
+    let start = value.length;
+    let kept = 0;
+    while (start > 0) {
+        const low = value.charCodeAt(start - 1);
+        const high = start > 1 ? value.charCodeAt(start - 2) : 0;
+        const from = low >= 0xdc00 && low <= 0xdfff && high >= 0xd800 && high <= 0xdbff
+            ? start - 2
+            : start - 1;
+        const bytes = Buffer.byteLength(value.slice(from, start));
+        if (kept + bytes > maxBytes)
+            break;
+        kept += bytes;
+        start = from;
+    }
+    return value.slice(start);
+}
+// The head/marker/tail buffer behind `flush()` above.
+class BoundedOutput {
+    constructor() {
+        this.head = [];
+        this.headBytes = 0;
+        this.headOpen = true;
+        // The head ends mid-record, so no newline separates it from the tail.
+        this.headSplit = false;
+        this.tail = [];
+        this.tailBytes = 0;
+        this.omitted = 0;
+    }
+    append(record) {
+        if (this.headOpen) {
+            const separator = this.head.length ? 1 : 0;
+            const bytes = Buffer.byteLength(record);
+            if (this.headBytes + separator + bytes <= HEAD_BYTES) {
+                this.head.push(record);
+                this.headBytes += separator + bytes;
+                return;
+            }
+            this.headOpen = false;
+            const prefix = (0, handoff_1.truncateUtf8)(record, HEAD_BYTES - this.headBytes - separator);
+            if (prefix) {
+                this.head.push(prefix);
+                this.headBytes += separator + Buffer.byteLength(prefix);
+                this.headSplit = true;
+                record = record.slice(prefix.length);
+            }
+        }
+        // Each tail record is charged its bytes plus a following newline; the last
+        // record's unused newline is one byte of slack at render time.
+        const cost = Buffer.byteLength(record) + 1;
+        this.tail.push({ text: record, cost });
+        this.tailBytes += cost;
+        while (this.tailBytes > TAIL_LIMIT && this.tail.length > 1) {
+            const dropped = this.tail.shift().cost;
+            this.tailBytes -= dropped;
+            this.omitted += dropped;
+        }
+        if (this.tailBytes > TAIL_LIMIT) {
+            const text = keepTailUtf8(this.tail[0].text, TAIL_LIMIT - 1);
+            const kept = Buffer.byteLength(text) + 1;
+            this.omitted += this.tailBytes - kept;
+            this.tail[0] = { text, cost: kept };
+            this.tailBytes = kept;
+        }
+    }
+    render() {
+        const head = this.head.join('\n');
+        const tail = this.tail.map((record) => record.text).join('\n');
+        if (this.omitted > 0) {
+            return `${head}\n${omittedMarker(this.omitted)}\n${tail}`;
+        }
+        if (!this.tail.length)
+            return head;
+        return this.headSplit ? head + tail : `${head}\n${tail}`;
+    }
+}
+exports.BoundedOutput = BoundedOutput;
+// The same head/marker/tail bound over a byte stream: chunks carry no record
+// boundary, so the cuts land on code points wherever the budgets run out and
+// the result does not depend on how the stream was chunked.
+class BoundedChunks {
+    constructor() {
+        this.head = '';
+        this.headOpen = true;
+        this.tail = '';
+        this.omitted = 0;
+    }
+    append(chunk) {
+        if (this.headOpen) {
+            const prefix = (0, handoff_1.truncateUtf8)(chunk, HEAD_BYTES - Buffer.byteLength(this.head));
+            this.head += prefix;
+            chunk = chunk.slice(prefix.length);
+            if (!chunk)
+                return;
+            this.headOpen = false;
+        }
+        const joined = this.tail + chunk;
+        this.tail = keepTailUtf8(joined, TAIL_LIMIT);
+        this.omitted += Buffer.byteLength(joined) - Buffer.byteLength(this.tail);
+    }
+    render() {
+        if (this.omitted > 0) {
+            return `${this.head}\n${omittedMarker(this.omitted)}\n${this.tail}`;
+        }
+        return this.head + this.tail;
+    }
+}
+exports.BoundedChunks = BoundedChunks;
 const CONSOLE_METHODS = [
     'log',
     'warn',
@@ -20,15 +138,13 @@ const NOOP_CAPTURE = {
     restore: () => { },
 };
 function installGeneratorOutputCapture() {
-    // Refuse to layer if the previous install never restored. Returns a noop
-    // handle so callers' `flush()` / `restore()` calls remain safe.
     for (const method of CONSOLE_METHODS) {
         if (console[method][CAPTURED_MARKER]) {
             logger_1.logger.verbose(`nx migrate: refusing to layer a second generator-output capture; the previous one was not restored. This typically means a caller skipped its \`try/finally\`. The inner caller's \`flush()\` will return empty, but its console output is still being captured by the outer install.`);
             return NOOP_CAPTURE;
         }
     }
-    const buffer = [];
+    const buffer = new BoundedOutput();
     const originals = new Map();
     for (const method of CONSOLE_METHODS) {
         originals.set(method, console[method]);
@@ -36,7 +152,7 @@ function installGeneratorOutputCapture() {
         const wrapper = ((...args) => {
             original(...args);
             try {
-                buffer.push((0, node_util_1.format)(...args));
+                buffer.append((0, node_util_1.format)(...args));
             }
             catch {
                 // `format` is robust against the common pathologies but a user arg
@@ -55,7 +171,7 @@ function installGeneratorOutputCapture() {
     let restored = false;
     return {
         flush() {
-            return buffer.join('\n');
+            return buffer.render();
         },
         restore() {
             if (restored)

package/dist/src/command-line/migrate/agentic/close-agent-session.d.ts

@@ -0,0 +1,21 @@
+import { type ChildProcess } from 'child_process';
+export declare const AGENT_GRACEFUL_EXIT_MS = 5000;
+export declare const FORCE_KILL_WAIT_MS = 500;
+export interface ExitInfo {
+    code?: number | null;
+    signal?: NodeJS.Signals | null;
+    error?: Error;
+}
+export declare function waitForExit(child: ChildProcess): Promise<ExitInfo>;
+/**
+ * Stops a running agent process.
+ *
+ * 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.
+ */
+export declare function closeAgentSession(child: ChildProcess, exitPromise: Promise<ExitInfo>, gracefulExitMs: number, forceKillWaitMs: number): Promise<void>;
+export declare function raceWithTimeout(promise: Promise<unknown>, timeoutMs: number): Promise<void>;