@depup/nx 22.5.4-depup.0

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tui-summary-life-cycle.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/tui-summary-life-cycle.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAE1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAc/C,wBAAgB,8BAA8B,CAAC,EAC7C,YAAY,EACZ,KAAK,EACL,SAAS,EACT,IAAI,EACJ,SAAS,EACT,iBAAiB,EACjB,eAAe,EACf,0BAA0B,GAC3B,EAAE;IACD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,IAAI,EAAE,CAAC;IACxB,0BAA0B,EAAE,CAAC,KAAK,EAAE,IAAI,KAAK,IAAI,CAAC;CACnD;eA+fkC,SAAS;;EAC3C"}

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTuiTerminalSummaryLifeCycle = getTuiTerminalSummaryLifeCycle;
+const node_os_1 = require("node:os");
+const output_1 = require("../../utils/output");
+const formatting_utils_1 = require("./formatting-utils");
+const pretty_time_1 = require("./pretty-time");
+const view_logs_utils_1 = require("./view-logs-utils");
+const figures = require("figures");
+const pc = require("picocolors");
+const task_history_life_cycle_1 = require("./task-history-life-cycle");
+const task_graph_utils_1 = require("../task-graph-utils");
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }) {
+    const lifeCycle = {};
+    const start = process.hrtime();
+    const targets = args.targets;
+    const totalTasks = tasks.length;
+    let totalCachedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCompletedTasks = 0;
+    let timeTakenText;
+    const failedTasks = new Set();
+    const inProgressTasks = new Set();
+    const stoppedTasks = new Set();
+    // Chunks accumulated progressively during task execution
+    const taskOutputChunks = {};
+    // Finalized output strings set on task completion — read by summary print functions
+    const tasksToTerminalOutputs = {};
+    const tasksToTaskStatus = {};
+    const taskIdsInTheOrderTheyStart = [];
+    const getTerminalOutput = (taskId) => tasksToTerminalOutputs[taskId] ?? taskOutputChunks[taskId]?.join('') ?? '';
+    lifeCycle.startTasks = (tasks) => {
+        for (let t of tasks) {
+            taskOutputChunks[t.id] ??= [];
+            taskIdsInTheOrderTheyStart.push(t.id);
+            inProgressTasks.add(t.id);
+        }
+    };
+    lifeCycle.appendTaskOutput = (taskId, output) => {
+        taskOutputChunks[taskId].push(output);
+    };
+    // TODO(@AgentEnder): The following 2 methods should be one but will need more refactoring
+    lifeCycle.printTaskTerminalOutput = (task, taskStatus, output) => {
+        tasksToTaskStatus[task.id] = taskStatus;
+        // Store the complete output for display in the summary
+        // This is called with the full output for cached tasks. For non-cached tasks,
+        // the output doesn't include the portion of the output that prints the command that was being ran.
+        if (output &&
+            !['failure', 'success'].includes(taskStatus)) {
+            tasksToTerminalOutputs[task.id] = output;
+        }
+    };
+    lifeCycle.setTaskStatus = (taskId, taskStatus) => {
+        if (taskStatus === 9 /* NativeTaskStatus.Stopped */) {
+            stoppedTasks.add(taskId);
+            inProgressTasks.delete(taskId);
+        }
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (const { task, status, terminalOutput } of taskResults) {
+            totalCompletedTasks++;
+            inProgressTasks.delete(task.id);
+            switch (status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    failedTasks.add(task.id);
+                    break;
+            }
+            // Store the final string directly — shares the same reference as
+            // TaskResultsLifeCycle, old chunks become GC-eligible
+            if (terminalOutput !== undefined) {
+                tasksToTerminalOutputs[task.id] = terminalOutput;
+                delete taskOutputChunks[task.id];
+            }
+        }
+    };
+    lifeCycle.endCommand = () => {
+        timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        resolveRenderIsDonePromise();
+    };
+    const printSummary = () => {
+        const isRunOne = initiatingProject && targets?.length === 1;
+        // Handles when the user interrupts the process
+        timeTakenText ??= (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        if (totalTasks === 0) {
+            console.log(`\n${output_1.output.applyNxPrefix('gray', 'No tasks were run')}\n`);
+            return;
+        }
+        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
+        const cancelled = 
+        // Some tasks were in progress...
+        inProgressTasks.size > 0 ||
+            // or some tasks had not started yet
+            totalTasks !== tasks.length ||
+            // the run had a continous task as a leaf...
+            // this is needed because continous tasks get marked as stopped when the process is interrupted
+            [...(0, task_graph_utils_1.getLeafTasks)(taskGraph)].filter((t) => taskGraph.tasks[t].continuous)
+                .length > 0;
+        if (isRunOne) {
+            printRunOneSummary({
+                failure,
+                cancelled,
+            });
+        }
+        else {
+            printRunManySummary({
+                failure,
+                cancelled,
+            });
+        }
+        (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)().printFlakyTasksMessage();
+    };
+    const printRunOneSummary = ({ failure, cancelled, }) => {
+        // Prints task outputs in the order they were completed
+        // above the summary, since run-one should print all task results.
+        for (const taskId of taskIdsInTheOrderTheyStart) {
+            const taskStatus = tasksToTaskStatus[taskId];
+            const terminalOutput = getTerminalOutput(taskId);
+            output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+        }
+        // Print vertical separator
+        const separatorLines = output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green');
+        for (const line of separatorLines) {
+            console.log(line);
+        }
+        if (!failure && !cancelled) {
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], targets, tasks)}`;
+            // Build success message with color applied to the entire block
+            const messageLines = [
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim(` (${timeTakenText})`)),
+            ];
+            const filteredOverrides = Object.entries(overrides).filter(
+            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+            ([flag]) => flag !== 'nxReleaseVersionData');
+            if (filteredOverrides.length > 0) {
+                messageLines.push('');
+                messageLines.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.green('With additional flags:'))}`);
+                filteredOverrides
+                    .map(([flag, value]) => pc.dim(pc.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
+                    .forEach((arg) => messageLines.push(arg));
+            }
+            if (totalCachedTasks > 0) {
+                messageLines.push(output_1.output.dim(`${node_os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            // Print the entire success message block with green color
+            console.log(output_1.output.colors.green(messageLines.join(node_os_1.EOL)));
+        }
+        else if (!cancelled) {
+            let text = `Ran target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`;
+            if (tasks.length > 1) {
+                text += ` and ${output_1.output.bold(tasks.length - 1)} task(s) they depend on`;
+            }
+            // Build failure message lines
+            const messageLines = [
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
+            ];
+            const filteredOverrides = Object.entries(overrides).filter(
+            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+            ([flag]) => flag !== 'nxReleaseVersionData');
+            if (filteredOverrides.length > 0) {
+                messageLines.push('');
+                messageLines.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.red('With additional flags:'))}`);
+                filteredOverrides
+                    .map(([flag, value]) => pc.dim(pc.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
+                    .forEach((arg) => messageLines.push(arg));
+            }
+            messageLines.push('');
+            messageLines.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`);
+            messageLines.push(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`);
+            const viewLogs = (0, view_logs_utils_1.viewLogsFooterRows)(totalFailedTasks);
+            messageLines.push(...viewLogs);
+            // Print the entire failure message block with red color
+            console.log(output_1.output.colors.red(messageLines.join(node_os_1.EOL)));
+        }
+        else {
+            console.log(output_1.output.applyNxPrefix('red', output_1.output.colors.red(`Cancelled running target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`) + output_1.output.dim(` (${timeTakenText})`)));
+        }
+        // adds some vertical space after the summary to avoid bunching against terminal
+        console.log('');
+    };
+    const printRunManySummary = ({ failure, cancelled, }) => {
+        console.log('');
+        // Collect checklist lines to print after task outputs
+        const checklistLines = [];
+        // Sort tasks by status: successful tasks first, failed tasks at the end
+        const sortedTaskIds = [...taskIdsInTheOrderTheyStart].sort((a, b) => {
+            const statusA = tasksToTaskStatus[a];
+            const statusB = tasksToTaskStatus[b];
+            const isFailureA = statusA === 'failure' || !statusA ? 1 : 0;
+            const isFailureB = statusB === 'failure' || !statusB ? 1 : 0;
+            return isFailureA - isFailureB;
+        });
+        // First pass: Print task outputs and collect checklist lines
+        for (const taskId of sortedTaskIds) {
+            const taskStatus = tasksToTaskStatus[taskId];
+            const terminalOutput = getTerminalOutput(taskId);
+            // Task Status is null?
+            if (!taskStatus) {
+                output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+                output_1.output.addNewline();
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.cyan(figures.squareSmallFilled)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+            else if (taskStatus === 'failure') {
+                output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
+                output_1.output.addNewline();
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+            else if (taskStatus === 'local-cache') {
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}  ${output_1.output.dim('[local cache]')}`);
+            }
+            else if (taskStatus === 'local-cache-kept-existing') {
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}  ${output_1.output.dim('[existing outputs match the cache, left as is]')}`);
+            }
+            else if (taskStatus === 'remote-cache') {
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}  ${output_1.output.dim('[remote cache]')}`);
+            }
+            else if (taskStatus === 'success') {
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+            else {
+                checklistLines.push(`${LEFT_PAD}${output_1.output.colors.green(figures.tick)}${SPACER}${output_1.output.colors.gray('nx run ')}${taskId}`);
+            }
+        }
+        // Print all checklist lines together
+        console.log();
+        for (const line of checklistLines) {
+            console.log(line);
+        }
+        // Print vertical separator
+        const separatorLines = output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green');
+        for (const line of separatorLines) {
+            console.log(line);
+        }
+        if (totalSuccessfulTasks + stoppedTasks.size === totalTasks) {
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const successSummaryRows = [
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + pc.dim(pc.white(` (${timeTakenText})`))),
+            ];
+            const filteredOverrides = Object.entries(overrides).filter(
+            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+            ([flag]) => flag !== 'nxReleaseVersionData');
+            if (filteredOverrides.length > 0) {
+                successSummaryRows.push('');
+                successSummaryRows.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.green('With additional flags:'))}`);
+                filteredOverrides
+                    .map(([flag, value]) => pc.dim(pc.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
+                    .forEach((arg) => successSummaryRows.push(arg));
+            }
+            if (totalCachedTasks > 0) {
+                successSummaryRows.push(output_1.output.dim(`${node_os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            console.log(successSummaryRows.join(node_os_1.EOL));
+        }
+        else {
+            const text = `${cancelled ? 'Cancelled while running' : 'Ran'} ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const failureSummaryRows = [
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + pc.dim(pc.white(` (${timeTakenText})`))),
+            ];
+            const filteredOverrides = Object.entries(overrides).filter(
+            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+            ([flag]) => flag !== 'nxReleaseVersionData');
+            if (filteredOverrides.length > 0) {
+                failureSummaryRows.push('');
+                failureSummaryRows.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.red('With additional flags:'))}`);
+                filteredOverrides
+                    .map(([flag, value]) => pc.dim(pc.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
+                    .forEach((arg) => failureSummaryRows.push(arg));
+            }
+            failureSummaryRows.push('');
+            if (totalCompletedTasks > 0) {
+                if (totalSuccessfulTasks > 0) {
+                    failureSummaryRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`), '');
+                }
+                if (totalFailedTasks > 0) {
+                    const numFailedToPrint = 5;
+                    const failedTasksForPrinting = Array.from(failedTasks).slice(0, numFailedToPrint);
+                    failureSummaryRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} targets failed, including the following:`, '', `${failedTasksForPrinting
+                        .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                        .join('\n')}`, '');
+                    if (failedTasks.size > numFailedToPrint) {
+                        failureSummaryRows.push(output_1.output.dim(`${EXTENDED_LEFT_PAD}...and ${failedTasks.size - numFailedToPrint} more...`));
+                    }
+                }
+                if (totalCompletedTasks !== totalTasks) {
+                    const remainingTasks = totalTasks - totalCompletedTasks;
+                    if (inProgressTasks.size) {
+                        failureSummaryRows.push(`${LEFT_PAD}${output_1.output.colors.red(figures.ellipsis)}${SPACER}${inProgressTasks.size}${`/${totalTasks}`} targets were in progress, including the following:`, '', `${Array.from(inProgressTasks)
+                            .map((t) => `${EXTENDED_LEFT_PAD}${output_1.output.colors.red('-')} ${output_1.output.formatCommand(t.toString())}`)
+                            .join(node_os_1.EOL)}`, '');
+                    }
+                    if (remainingTasks - inProgressTasks.size > 0) {
+                        failureSummaryRows.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.colors.red(figures.ellipsis)}${SPACER}${remainingTasks - inProgressTasks.size}${`/${totalTasks}`} targets had not started.`), '');
+                    }
+                }
+                failureSummaryRows.push(...(0, view_logs_utils_1.viewLogsFooterRows)(failedTasks.size));
+            }
+            console.log(output_1.output.colors.red(failureSummaryRows.join(node_os_1.EOL)));
+        }
+        // adds some vertical space after the summary to avoid bunching against terminal
+        console.log('');
+    };
+    return { lifeCycle: lifeCycle, printSummary };
+}

package/src/tasks-runner/life-cycles/view-logs-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function viewLogsFooterRows(failedTasks: number): string[];
+//# sourceMappingURL=view-logs-utils.d.ts.map

package/src/tasks-runner/life-cycles/view-logs-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-logs-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/tasks-runner/life-cycles/view-logs-utils.ts"],"names":[],"mappings":"AAMA,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,YAMrD"}

package/src/tasks-runner/life-cycles/view-logs-utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewLogsFooterRows = viewLogsFooterRows;
+const nx_json_1 = require("../../config/nx-json");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const VIEW_LOGS_MESSAGE = `Hint: Try "nx view-logs" to get structured, searchable errors logs in your browser.`;
+function viewLogsFooterRows(failedTasks) {
+    if (failedTasks >= 2 && !(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        return [``, output_1.output.dim(` ${VIEW_LOGS_MESSAGE}`)];
+    }
+    else {
+        return [];
+    }
+}

package/src/tasks-runner/process-metrics-service.d.ts

@@ -0,0 +1,54 @@
+import { GroupInfo, GroupType, Metadata, MetricsUpdate, ProcessMetadata, ProcessMetrics, SystemInfo } from '../native';
+export type { GroupInfo, GroupType, Metadata, MetricsUpdate, ProcessMetadata, ProcessMetrics, SystemInfo, };
+export type MetricsCallback = (event: MetricsUpdate) => void;
+/**
+ * Simplified service providing subscription-based access to Rust metrics collector
+ * Manages singleton access pattern for metrics collection during execution of tasks and CLI commands
+ * All methods handle errors internally to ensure metrics collection never breaks task execution
+ */
+declare class ProcessMetricsService {
+    private collector;
+    private cleanupRegistered;
+    constructor();
+    /**
+     * Register signal handlers for graceful shutdown
+     * Ensures collection thread is stopped cleanly on Ctrl+C or process termination
+     */
+    private registerCleanupHandlers;
+    /**
+     * Subscribe to push-based metrics notifications
+     * Collection starts automatically on first subscription (lazy start)
+     */
+    subscribe(callback: MetricsCallback): void;
+    /**
+     * Register a process for a task - creates anchor for discovery
+     * This is the core integration point - called from RunningTask constructors
+     */
+    registerTaskProcess(taskId: string, pid: number): void;
+    /**
+     * Register a batch with multiple tasks sharing a worker
+     */
+    registerBatch(batchId: string, taskIds: string[], pid: number): void;
+    /**
+     * Register the daemon process
+     */
+    registerDaemonProcess(pid: number): void;
+    /**
+     * Register a subprocess of the main CLI (e.g., plugin worker)
+     */
+    registerMainCliSubprocess(pid: number, alias?: string): void;
+    /**
+     * Get system information (CPU cores and total memory)
+     */
+    getSystemInfo(): SystemInfo | null;
+    /**
+     * Stop collection and cleanup
+     */
+    shutdown(): void;
+}
+/**
+ * Get or create the singleton ProcessMetricsService instance
+ * Lazy initialization - service only starts when first accessed
+ */
+export declare function getProcessMetricsService(): ProcessMetricsService;
+//# sourceMappingURL=process-metrics-service.d.ts.map

package/src/tasks-runner/process-metrics-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-metrics-service.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/process-metrics-service.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,SAAS,EACT,QAAQ,EACR,aAAa,EACb,eAAe,EACf,cAAc,EAEd,UAAU,EACX,MAAM,WAAW,CAAC;AAEnB,YAAY,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,aAAa,EACb,eAAe,EACf,cAAc,EACd,UAAU,GACX,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;AAE7D;;;;GAIG;AACH,cAAM,qBAAqB;IACzB,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,iBAAiB,CAAS;;IAmBlC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAe/B;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,IAAI;IA+B1C;;;OAGG;IACH,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAQtD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAQpE;;OAEG;IACH,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQxC;;OAEG;IACH,yBAAyB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI;IAQ5D;;OAEG;IACH,aAAa,IAAI,UAAU,GAAG,IAAI;IASlC;;OAEG;IACH,QAAQ,IAAI,IAAI;CAOjB;AAOD;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,qBAAqB,CAKhE"}

package/src/tasks-runner/process-metrics-service.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProcessMetricsService = getProcessMetricsService;
+const cache_1 = require("../daemon/cache");
+const native_1 = require("../native");
+/**
+ * Simplified service providing subscription-based access to Rust metrics collector
+ * Manages singleton access pattern for metrics collection during execution of tasks and CLI commands
+ * All methods handle errors internally to ensure metrics collection never breaks task execution
+ */
+class ProcessMetricsService {
+    constructor() {
+        this.collector = null;
+        this.cleanupRegistered = false;
+        try {
+            this.collector = new native_1.ProcessMetricsCollector();
+            // Register main nx process as CLI
+            this.collector.registerMainCliProcess(process.pid);
+            // Register daemon process if available
+            const daemonPid = (0, cache_1.getDaemonProcessIdSync)();
+            if (daemonPid) {
+                this.collector.registerDaemonProcess(daemonPid);
+            }
+        }
+        catch {
+            // Silent failure - metrics collection is optional and should never break task execution
+        }
+    }
+    /**
+     * Register signal handlers for graceful shutdown
+     * Ensures collection thread is stopped cleanly on Ctrl+C or process termination
+     */
+    registerCleanupHandlers() {
+        const cleanup = () => {
+            try {
+                this.shutdown();
+            }
+            catch {
+                // Silent failure during cleanup
+            }
+        };
+        // Handle various exit scenarios
+        process.on('SIGINT', cleanup);
+        process.on('SIGTERM', cleanup);
+        process.on('exit', cleanup);
+    }
+    /**
+     * Subscribe to push-based metrics notifications
+     * Collection starts automatically on first subscription (lazy start)
+     */
+    subscribe(callback) {
+        if (!this.collector) {
+            throw new Error('Metrics collector not initialized');
+        }
+        try {
+            // Start collection on first subscription (idempotent - safe to call multiple times)
+            this.collector.startCollection();
+            // Register cleanup handlers on first successful start
+            // If startCollection() threw, we never reach this line
+            if (!this.cleanupRegistered) {
+                this.registerCleanupHandlers();
+                this.cleanupRegistered = true;
+            }
+            // Wrap the user's callback to adapt from error-first pattern (err, data) => void
+            // to the simple pattern (event) => void that users expect
+            // The Rust side uses CalleeHandled which sends (null, data) on success
+            this.collector.subscribe((err, event) => {
+                if (err) {
+                    // Silently ignore errors - metrics collection is optional
+                    return;
+                }
+                callback(event);
+            });
+        }
+        catch {
+            // Silent failure - metrics collection is optional
+        }
+    }
+    /**
+     * Register a process for a task - creates anchor for discovery
+     * This is the core integration point - called from RunningTask constructors
+     */
+    registerTaskProcess(taskId, pid) {
+        try {
+            this.collector?.registerTaskProcess(taskId, pid);
+        }
+        catch {
+            // Silent failure - metrics collection is optional
+        }
+    }
+    /**
+     * Register a batch with multiple tasks sharing a worker
+     */
+    registerBatch(batchId, taskIds, pid) {
+        try {
+            this.collector?.registerBatch(batchId, taskIds, pid);
+        }
+        catch {
+            // Silent failure - metrics collection is optional
+        }
+    }
+    /**
+     * Register the daemon process
+     */
+    registerDaemonProcess(pid) {
+        try {
+            this.collector?.registerDaemonProcess(pid);
+        }
+        catch {
+            // Silent failure - metrics collection is optional
+        }
+    }
+    /**
+     * Register a subprocess of the main CLI (e.g., plugin worker)
+     */
+    registerMainCliSubprocess(pid, alias) {
+        try {
+            this.collector?.registerMainCliSubprocess(pid, alias);
+        }
+        catch {
+            // Silent failure - metrics collection is optional
+        }
+    }
+    /**
+     * Get system information (CPU cores and total memory)
+     */
+    getSystemInfo() {
+        try {
+            return this.collector?.getSystemInfo();
+        }
+        catch {
+            // Silent failure - metrics collection is optional
+            return null;
+        }
+    }
+    /**
+     * Stop collection and cleanup
+     */
+    shutdown() {
+        try {
+            this.collector?.stopCollection();
+        }
+        catch {
+            // Silent failure during cleanup
+        }
+    }
+}
+/**
+ * Singleton instance (lazily initialized)
+ */
+let instance = null;
+/**
+ * Get or create the singleton ProcessMetricsService instance
+ * Lazy initialization - service only starts when first accessed
+ */
+function getProcessMetricsService() {
+    if (!instance) {
+        instance = new ProcessMetricsService();
+    }
+    return instance;
+}

package/src/tasks-runner/pseudo-ipc.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Node IPC is specific to Node, but when spawning child processes in Rust, it won't have IPC.
+ *
+ * Thus, this is a wrapper which is spawned by Rust, which will create a Node IPC channel and pipe it to a ZeroMQ Channel
+ *
+ * Main Nx Process
+ *   * Calls Rust Fork Function
+ *     * `node fork.js`
+ *     * Create a Rust - Node.js Agnostic Channel aka Pseudo IPC Channel
+ *     * This returns RustChildProcess
+ *         * RustChildProcess.onMessage(msg => ());
+ *         * pseudo_ipc_channel.on_message() => tx.send(msg);
+ *   * Node.js Fork Wrapper (fork.js)
+ *     * fork(run-command.js) with `inherit` and `ipc`
+ *         * This will create a Node IPC Channel
+ *     * channel = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
+ */
+import { Serializable } from 'child_process';
+export interface PseudoIPCMessage {
+    type: 'TO_CHILDREN_FROM_PARENT' | 'TO_PARENT_FROM_CHILDREN' | 'CHILD_READY';
+    id: string | undefined;
+    message: Serializable;
+}
+export declare class PseudoIPCServer {
+    private path;
+    private sockets;
+    private server;
+    private childMessages;
+    constructor(path: string);
+    init(): Promise<void>;
+    private childReadyMap;
+    waitForChildReady(childId: string): Promise<void>;
+    private registerChildMessages;
+    sendMessageToChildren(message: Serializable): void;
+    sendMessageToChild(id: string, message: Serializable): void;
+    onMessageFromChildren(onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): void;
+    close(): void;
+}
+export declare class PseudoIPCClient {
+    private path;
+    private socket;
+    constructor(path: string);
+    sendMessageToParent(message: Serializable): void;
+    notifyChildIsReady(id: string): void;
+    onMessageFromParent(forkId: string, onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    close(): void;
+}
+//# sourceMappingURL=pseudo-ipc.d.ts.map

package/src/tasks-runner/pseudo-ipc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pseudo-ipc.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/pseudo-ipc.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAQH,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAgB7C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,yBAAyB,GAAG,yBAAyB,GAAG,aAAa,CAAC;IAC5E,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC;IACvB,OAAO,EAAE,YAAY,CAAC;CACvB;AAED,qBAAa,eAAe;IAUd,OAAO,CAAC,IAAI;IATxB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,MAAM,CAAqB;IAEnC,OAAO,CAAC,aAAa,CAIZ;gBAEW,IAAI,EAAE,MAAM;IAEhC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAiBrB,OAAO,CAAC,aAAa,CAAiC;IAEhD,iBAAiB,CAAC,OAAO,EAAE,MAAM;IAMvC,OAAO,CAAC,qBAAqB;IA8B7B,qBAAqB,CAAC,OAAO,EAAE,YAAY;IAU3C,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;IASpD,qBAAqB,CACnB,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,EAC1C,OAAO,GAAE,MAAM,IAAe,EAC9B,OAAO,GAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAkB;IAS7C,KAAK;CAIN;AAED,qBAAa,eAAe;IAGd,OAAO,CAAC,IAAI;IAFxB,OAAO,CAAC,MAAM,CAA0C;gBAEpC,IAAI,EAAE,MAAM;IAEhC,mBAAmB,CAAC,OAAO,EAAE,YAAY;IAQzC,kBAAkB,CAAC,EAAE,EAAE,MAAM;IAW7B,mBAAmB,CACjB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,EAC1C,OAAO,GAAE,MAAM,IAAe,EAC9B,OAAO,GAAE,CAAC,GAAG,EAAE,KAAK,KAAK,IAAkB;IAsB7C,KAAK;CAGN"}