@depup/nx 22.5.4-depup.0

package/src/daemon/server/handle-nx-console.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetNxConsoleStatus = handleGetNxConsoleStatus;
+exports.handleSetNxConsolePreferenceAndInstall = handleSetNxConsolePreferenceAndInstall;
+const nx_console_operations_1 = require("./nx-console-operations");
+// Module-level state for caching
+let cachedShouldPrompt = null;
+let isComputing = false;
+async function handleGetNxConsoleStatus() {
+    // Return cached result if available
+    if (cachedShouldPrompt !== null) {
+        const response = {
+            shouldPrompt: cachedShouldPrompt,
+        };
+        return {
+            response,
+            description: 'handleGetNxConsoleStatus',
+        };
+    }
+    // Kick off background computation if not already running
+    if (!isComputing) {
+        isComputing = true;
+        (0, nx_console_operations_1.getNxConsoleStatus)()
+            .then((result) => {
+            cachedShouldPrompt = result;
+            isComputing = false;
+        })
+            .catch(() => {
+            cachedShouldPrompt = null;
+            isComputing = false;
+        });
+    }
+    // Return false for shouldPrompt if cache not ready (main process will noop)
+    const response = {
+        shouldPrompt: false,
+    };
+    return {
+        response,
+        description: 'handleGetNxConsoleStatus',
+    };
+}
+async function handleSetNxConsolePreferenceAndInstall(preference) {
+    // Immediately update cache - we know the answer now!
+    // User answered the prompt, so we won't prompt again
+    cachedShouldPrompt = false;
+    const result = await (0, nx_console_operations_1.handleNxConsolePreferenceAndInstall)({ preference });
+    const response = {
+        installed: result.installed,
+    };
+    return {
+        response,
+        description: 'handleSetNxConsolePreferenceAndInstall',
+    };
+}

package/src/daemon/server/handle-nx-workspace-files.d.ts

@@ -0,0 +1,3 @@
+import { HandlerResult } from './server';
+export declare function handleNxWorkspaceFiles(projectRootMap: Record<string, string>): Promise<HandlerResult>;
+//# sourceMappingURL=handle-nx-workspace-files.d.ts.map

package/src/daemon/server/handle-nx-workspace-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-nx-workspace-files.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-nx-workspace-files.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,wBAAsB,sBAAsB,CAC1C,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACrC,OAAO,CAAC,aAAa,CAAC,CASxB"}

package/src/daemon/server/handle-nx-workspace-files.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleNxWorkspaceFiles = handleNxWorkspaceFiles;
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleNxWorkspaceFiles(projectRootMap) {
+    const files = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspace_root_1.workspaceRoot, projectRootMap);
+    return {
+        response: files,
+        description: 'handleNxWorkspaceFiles',
+    };
+}

package/src/daemon/server/handle-outputs-tracking.d.ts

@@ -0,0 +1,16 @@
+import { HandlerResult } from './server';
+export declare function handleRecordOutputsHash(payload: {
+    type: string;
+    data: {
+        outputs: string[];
+        hash: string;
+    };
+}): Promise<HandlerResult>;
+export declare function handleOutputsHashesMatch(payload: {
+    type: string;
+    data: {
+        outputs: string[];
+        hash: string;
+    };
+}): Promise<HandlerResult>;
+//# sourceMappingURL=handle-outputs-tracking.d.ts.map

package/src/daemon/server/handle-outputs-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-outputs-tracking.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-outputs-tracking.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAGzC,wBAAsB,uBAAuB,CAAC,OAAO,EAAE;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C,GAAG,OAAO,CAAC,aAAa,CAAC,CAezB;AAED,wBAAsB,wBAAwB,CAAC,OAAO,EAAE;IACtD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C,GAAG,OAAO,CAAC,aAAa,CAAC,CAkBzB"}

package/src/daemon/server/handle-outputs-tracking.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRecordOutputsHash = handleRecordOutputsHash;
+exports.handleOutputsHashesMatch = handleOutputsHashesMatch;
+const outputs_tracking_1 = require("./outputs-tracking");
+async function handleRecordOutputsHash(payload) {
+    try {
+        await (0, outputs_tracking_1.recordOutputsHash)(payload.data.outputs, payload.data.hash);
+        return {
+            description: 'recordOutputsHash',
+            response: '{}',
+        };
+    }
+    catch (e) {
+        return {
+            description: 'recordOutputsHash failed',
+            error: new Error(`Critical error when recording metadata about outputs: '${e.message}'.`),
+        };
+    }
+}
+async function handleOutputsHashesMatch(payload) {
+    try {
+        const res = await (0, outputs_tracking_1.outputsHashesMatch)(payload.data.outputs, payload.data.hash);
+        return {
+            response: res,
+            description: 'outputsHashesMatch',
+        };
+    }
+    catch (e) {
+        return {
+            description: 'outputsHashesMatch failed',
+            error: new Error(`Critical error when verifying the contents of the outputs haven't changed: '${e.message}'.`),
+        };
+    }
+}

package/src/daemon/server/handle-process-in-background.d.ts

@@ -0,0 +1,7 @@
+import { HandlerResult } from './server';
+export declare function handleProcessInBackground(payload: {
+    type: string;
+    requirePath: string;
+    data: any;
+}): Promise<HandlerResult>;
+//# sourceMappingURL=handle-process-in-background.d.ts.map

package/src/daemon/server/handle-process-in-background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-process-in-background.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-process-in-background.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAIzC,wBAAsB,yBAAyB,CAAC,OAAO,EAAE;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,GAAG,CAAC;CACX,GAAG,OAAO,CAAC,aAAa,CAAC,CA2BzB"}

package/src/daemon/server/handle-process-in-background.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProcessInBackground = handleProcessInBackground;
+const logger_1 = require("../logger");
+const installation_directory_1 = require("../../utils/installation-directory");
+async function handleProcessInBackground(payload) {
+    let fn;
+    try {
+        fn = require(require.resolve(payload.requirePath, {
+            paths: (0, installation_directory_1.getNxRequirePaths)(),
+        })).default;
+    }
+    catch (e) {
+        return {
+            description: `Unable to require ${payload.requirePath}`,
+            error: new Error(`Unable to require ${payload.requirePath}`),
+        };
+    }
+    try {
+        const response = await fn(payload.data, logger_1.serverLogger);
+        return {
+            response,
+            description: payload.type,
+        };
+    }
+    catch (e) {
+        return {
+            description: `Error when processing ${payload.type}.`,
+            error: e,
+        };
+    }
+}

package/src/daemon/server/handle-request-project-graph.d.ts

@@ -0,0 +1,3 @@
+import { HandlerResult } from './server';
+export declare function handleRequestProjectGraph(): Promise<HandlerResult>;
+//# sourceMappingURL=handle-request-project-graph.d.ts.map

package/src/daemon/server/handle-request-project-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-request-project-graph.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-request-project-graph.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,aAAa,CAAC,CAyCxE"}

package/src/daemon/server/handle-request-project-graph.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestProjectGraph = handleRequestProjectGraph;
+const perf_hooks_1 = require("perf_hooks");
+const socket_utils_1 = require("../socket-utils");
+const logger_1 = require("../logger");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleRequestProjectGraph() {
+    try {
+        perf_hooks_1.performance.mark('server-connection');
+        logger_1.serverLogger.requestLog('Client Request for Project Graph Received');
+        const result = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        if (result.error) {
+            return {
+                description: `Error when preparing serialized project graph.`,
+                error: result.error,
+            };
+        }
+        const serializedResult = (0, socket_utils_1.serializeResult)(result.error, result.serializedProjectGraph, result.serializedSourceMaps);
+        if (!serializedResult) {
+            return {
+                description: `Error when serializing project graph result.`,
+                error: new Error('Critical error when serializing server result, check server logs'),
+            };
+        }
+        perf_hooks_1.performance.mark('serialized-project-graph-ready');
+        perf_hooks_1.performance.measure('total for creating and serializing project graph', 'server-connection', 'serialized-project-graph-ready');
+        return { response: serializedResult, description: 'project-graph' };
+    }
+    catch (e) {
+        return {
+            description: `Unexpected error when creating Project Graph.`,
+            error: e,
+        };
+    }
+}

package/src/daemon/server/handle-request-shutdown.d.ts

@@ -0,0 +1,6 @@
+import { Server } from 'net';
+export declare function handleRequestShutdown(server: Server, numberOfConnections: number): Promise<{
+    description: string;
+    response: string;
+}>;
+//# sourceMappingURL=handle-request-shutdown.d.ts.map

package/src/daemon/server/handle-request-shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-request-shutdown.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-request-shutdown.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAI7B,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,MAAM;;;GAqB5B"}

package/src/daemon/server/handle-request-shutdown.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestShutdown = handleRequestShutdown;
+const shutdown_utils_1 = require("./shutdown-utils");
+const server_1 = require("./server");
+async function handleRequestShutdown(server, numberOfConnections) {
+    // 1 connection is the client asking to shut down
+    if (numberOfConnections > 1) {
+        return {
+            description: `Unable to shutdown the daemon. ${numberOfConnections} connections are open.`,
+            response: '{}',
+        };
+    }
+    else {
+        setTimeout(async () => {
+            await (0, shutdown_utils_1.handleServerProcessTermination)({
+                server,
+                reason: 'Request to shutdown',
+                sockets: server_1.openSockets,
+            });
+        }, 0);
+        return {
+            description: 'Shutdown initiated',
+            response: '{}',
+        };
+    }
+}

package/src/daemon/server/handle-task-history.d.ts

@@ -0,0 +1,14 @@
+import type { TaskRun, TaskTarget } from '../../native';
+export declare function handleRecordTaskRuns(taskRuns: TaskRun[]): Promise<{
+    response: string;
+    description: string;
+}>;
+export declare function handleGetFlakyTasks(hashes: string[]): Promise<{
+    response: string[];
+    description: string;
+}>;
+export declare function handleGetEstimatedTaskTimings(targets: TaskTarget[]): Promise<{
+    response: Record<string, number>;
+    description: string;
+}>;
+//# sourceMappingURL=handle-task-history.d.ts.map

package/src/daemon/server/handle-task-history.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-task-history.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-task-history.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAExD,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE;;;GAO7D;AAED,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE;;;GAOzD;AAED,wBAAsB,6BAA6B,CAAC,OAAO,EAAE,UAAU,EAAE;;;GAOxE"}

package/src/daemon/server/handle-task-history.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRecordTaskRuns = handleRecordTaskRuns;
+exports.handleGetFlakyTasks = handleGetFlakyTasks;
+exports.handleGetEstimatedTaskTimings = handleGetEstimatedTaskTimings;
+const task_history_1 = require("../../utils/task-history");
+async function handleRecordTaskRuns(taskRuns) {
+    const taskHistory = (0, task_history_1.getTaskHistory)();
+    await taskHistory.recordTaskRuns(taskRuns);
+    return {
+        response: 'true',
+        description: 'handleRecordTaskRuns',
+    };
+}
+async function handleGetFlakyTasks(hashes) {
+    const taskHistory = (0, task_history_1.getTaskHistory)();
+    const history = await taskHistory.getFlakyTasks(hashes);
+    return {
+        response: history,
+        description: 'handleGetFlakyTasks',
+    };
+}
+async function handleGetEstimatedTaskTimings(targets) {
+    const taskHistory = (0, task_history_1.getTaskHistory)();
+    const history = await taskHistory.getEstimatedTaskTimings(targets);
+    return {
+        response: history,
+        description: 'handleGetEstimatedTaskTimings',
+    };
+}

package/src/daemon/server/handle-tasks-execution-hooks.d.ts

@@ -0,0 +1,20 @@
+import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+export declare function handleRunPreTasksExecution(context: PreTasksExecutionContext): Promise<{
+    response: NodeJS.ProcessEnv[];
+    description: string;
+    error?: undefined;
+} | {
+    error: any;
+    description: string;
+    response?: undefined;
+}>;
+export declare function handleRunPostTasksExecution(context: PostTasksExecutionContext): Promise<{
+    response: string;
+    description: string;
+    error?: undefined;
+} | {
+    error: any;
+    description: string;
+    response?: undefined;
+}>;
+//# sourceMappingURL=handle-tasks-execution-hooks.d.ts.map

package/src/daemon/server/handle-tasks-execution-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-tasks-execution-hooks.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-tasks-execution-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,wCAAwC,CAAC;AAMhD,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,wBAAwB;;;;;;;;GAclC;AACD,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,yBAAyB;;;;;;;;GAcnC"}

package/src/daemon/server/handle-tasks-execution-hooks.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRunPreTasksExecution = handleRunPreTasksExecution;
+exports.handleRunPostTasksExecution = handleRunPostTasksExecution;
+const tasks_execution_hooks_1 = require("../../project-graph/plugins/tasks-execution-hooks");
+async function handleRunPreTasksExecution(context) {
+    try {
+        const envs = await (0, tasks_execution_hooks_1.runPreTasksExecution)(context);
+        return {
+            response: envs,
+            description: 'handleRunPreTasksExecution',
+        };
+    }
+    catch (e) {
+        return {
+            error: e,
+            description: `Error when running preTasksExecution.`,
+        };
+    }
+}
+async function handleRunPostTasksExecution(context) {
+    try {
+        await (0, tasks_execution_hooks_1.runPostTasksExecution)(context);
+        return {
+            response: 'true',
+            description: 'handleRunPostTasksExecution',
+        };
+    }
+    catch (e) {
+        return {
+            error: e,
+            description: `Error when running postTasksExecution.`,
+        };
+    }
+}

package/src/daemon/server/handle-update-workspace-context.d.ts

@@ -0,0 +1,3 @@
+import type { HandlerResult } from './server';
+export declare function handleUpdateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<HandlerResult>;
+//# sourceMappingURL=handle-update-workspace-context.d.ts.map

package/src/daemon/server/handle-update-workspace-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handle-update-workspace-context.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/handle-update-workspace-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,wBAAsB,4BAA4B,CAChD,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,EACtB,YAAY,EAAE,MAAM,EAAE,GACrB,OAAO,CAAC,aAAa,CAAC,CAOxB"}

package/src/daemon/server/handle-update-workspace-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdateWorkspaceContext = handleUpdateWorkspaceContext;
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleUpdateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
+    (0, project_graph_incremental_recomputation_1.addUpdatedAndDeletedFiles)(createdFiles, updatedFiles, deletedFiles);
+    return {
+        response: '{}',
+        description: 'handleUpdateContextFiles',
+    };
+}

package/src/daemon/server/nx-console-operations.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Gets the Nx Console status (whether we should prompt the user to install).
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @returns boolean indicating whether we should prompt the user
+ */
+export declare function getNxConsoleStatus({ inner, }?: {
+    inner?: boolean;
+}): Promise<boolean>;
+/**
+ * Handles user preference submission and installs Nx Console if requested.
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @param preference - whether the user wants to install Nx Console
+ * @returns object indicating whether installation succeeded
+ */
+export declare function handleNxConsolePreferenceAndInstall({ preference, inner, }: {
+    preference: boolean;
+    inner?: boolean;
+}): Promise<{
+    installed: boolean;
+}>;
+/**
+ * Clean up the latest Nx installation on daemon shutdown.
+ */
+export declare function cleanupLatestNxInstallation(): void;
+export declare function getNxConsoleStatusImpl(): Promise<boolean>;
+export declare function handleNxConsolePreferenceAndInstallImpl(preference: boolean): Promise<{
+    installed: boolean;
+}>;
+//# sourceMappingURL=nx-console-operations.d.ts.map

package/src/daemon/server/nx-console-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx-console-operations.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/nx-console-operations.ts"],"names":[],"mappings":"AAiBA;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,EACvC,KAAK,GACN,GAAE;IACD,KAAK,CAAC,EAAE,OAAO,CAAC;CACZ,GAAG,OAAO,CAAC,OAAO,CAAC,CAwCxB;AAED;;;;;;GAMG;AACH,wBAAsB,mCAAmC,CAAC,EACxD,UAAU,EACV,KAAK,GACN,EAAE;IACD,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAgDlC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,IAAI,CAOlD;AAED,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,OAAO,CAAC,CAsB/D;AAED,wBAAsB,uCAAuC,CAC3D,UAAU,EAAE,OAAO,GAClB,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAA;CAAE,CAAC,CAUjC"}

package/src/daemon/server/nx-console-operations.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxConsoleStatus = getNxConsoleStatus;
+exports.handleNxConsolePreferenceAndInstall = handleNxConsolePreferenceAndInstall;
+exports.cleanupLatestNxInstallation = cleanupLatestNxInstallation;
+exports.getNxConsoleStatusImpl = getNxConsoleStatusImpl;
+exports.handleNxConsolePreferenceAndInstallImpl = handleNxConsolePreferenceAndInstallImpl;
+const devkit_internals_1 = require("../../devkit-internals");
+const os_1 = require("os");
+const native_1 = require("../../native");
+const logger_1 = require("../logger");
+// Module-level state - persists across invocations within daemon lifecycle
+let latestNxTmpPath = null;
+let cleanupFn = null;
+const log = (...messageParts) => {
+    logger_1.serverLogger.log('[NX-CONSOLE]:', ...messageParts);
+};
+/**
+ * Gets the Nx Console status (whether we should prompt the user to install).
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @returns boolean indicating whether we should prompt the user
+ */
+async function getNxConsoleStatus({ inner, } = {}) {
+    // Use local implementation if explicitly requested
+    if (process.env.NX_USE_LOCAL === 'true' || inner === true) {
+        log('Using local implementation (NX_USE_LOCAL=true or inner call)');
+        return await getNxConsoleStatusImpl();
+    }
+    try {
+        // If we don't have a tmp path yet, pull latest Nx
+        if (latestNxTmpPath === null) {
+            log('Pulling latest Nx (latest) to check console status...');
+            const packageInstallResults = await (0, devkit_internals_1.installPackageToTmpAsync)('nx', 'latest');
+            latestNxTmpPath = packageInstallResults.tempDir;
+            cleanupFn = packageInstallResults.cleanup;
+            log('Successfully pulled latest Nx to', latestNxTmpPath);
+        }
+        else {
+            log('Reusing cached Nx installation from', latestNxTmpPath);
+        }
+        // Try to use the cached tmp path
+        const modulePath = require.resolve('nx/src/daemon/server/nx-console-operations.js', { paths: [latestNxTmpPath] });
+        const module = await Promise.resolve(`${modulePath}`).then(s => require(s));
+        const result = await module.getNxConsoleStatus({ inner: true });
+        log('Console status check completed, shouldPrompt:', result);
+        return result;
+    }
+    catch (error) {
+        // If tmp path failed (e.g., directory was deleted), fall back to local immediately
+        log('Failed to use latest Nx, falling back to local implementation. Error:', error.message);
+        return await getNxConsoleStatusImpl();
+    }
+}
+/**
+ * Handles user preference submission and installs Nx Console if requested.
+ * Uses latest Nx version if available, falls back to local implementation.
+ *
+ * @param preference - whether the user wants to install Nx Console
+ * @returns object indicating whether installation succeeded
+ */
+async function handleNxConsolePreferenceAndInstall({ preference, inner, }) {
+    log('Handling user preference:', preference);
+    // Use local implementation if explicitly requested
+    if (process.env.NX_USE_LOCAL === 'true' || inner === true) {
+        log('Using local implementation (NX_USE_LOCAL=true or inner call)');
+        return await handleNxConsolePreferenceAndInstallImpl(preference);
+    }
+    try {
+        // If we don't have a tmp path yet, pull latest Nx
+        if (latestNxTmpPath === null) {
+            log('Pulling latest Nx (latest) to handle preference and install...');
+            const packageInstallResults = await (0, devkit_internals_1.installPackageToTmpAsync)('nx', 'latest');
+            latestNxTmpPath = packageInstallResults.tempDir;
+            cleanupFn = packageInstallResults.cleanup;
+            log('Successfully pulled latest Nx to', latestNxTmpPath);
+        }
+        else {
+            log('Reusing cached Nx installation from', latestNxTmpPath);
+        }
+        // Try to use the cached tmp path
+        const modulePath = require.resolve('nx/src/daemon/server/nx-console-operations.js', { paths: [latestNxTmpPath] });
+        const module = await Promise.resolve(`${modulePath}`).then(s => require(s));
+        const result = await module.handleNxConsolePreferenceAndInstall({
+            preference,
+            inner: true,
+        });
+        log('Preference saved and installation', result.installed ? 'succeeded' : 'skipped/failed');
+        return result;
+    }
+    catch (error) {
+        // If tmp path failed (e.g., directory was deleted), fall back to local immediately
+        log('Failed to use latest Nx, falling back to local implementation. Error:', error.message);
+        return await handleNxConsolePreferenceAndInstallImpl(preference);
+    }
+}
+/**
+ * Clean up the latest Nx installation on daemon shutdown.
+ */
+function cleanupLatestNxInstallation() {
+    if (cleanupFn) {
+        log('Cleaning up latest Nx installation from', latestNxTmpPath);
+        cleanupFn();
+    }
+    latestNxTmpPath = null;
+    cleanupFn = null;
+}
+async function getNxConsoleStatusImpl() {
+    // If no cached preference, read from disk
+    const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+    const preference = preferences.getAutoInstallPreference();
+    const canInstallConsole = (0, native_1.canInstallNxConsole)();
+    // If user previously opted in but extension is not installed,
+    // they must have manually uninstalled it - respect that choice
+    if (preference === true && canInstallConsole) {
+        const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+        preferences.setAutoInstallPreference(false);
+        return false; // Don't prompt
+    }
+    // Noop if can't install
+    if (!canInstallConsole) {
+        return false;
+    }
+    // Prompt if we can install and user hasn't answered yet
+    return typeof preference !== 'boolean';
+}
+async function handleNxConsolePreferenceAndInstallImpl(preference) {
+    const preferences = new native_1.NxConsolePreferences((0, os_1.homedir)());
+    preferences.setAutoInstallPreference(preference);
+    let installed = false;
+    if (preference) {
+        installed = (0, native_1.installNxConsole)();
+    }
+    return { installed };
+}

package/src/daemon/server/outputs-tracking.d.ts

@@ -0,0 +1,9 @@
+import { WatchEvent } from '../../native';
+export declare function _recordOutputsHash(outputs: string[], hash: string): void;
+export declare function _outputsHashesMatch(outputs: string[], hash: string): boolean;
+export declare function recordedHash(output: string): string;
+export declare function recordOutputsHash(_outputs: string[], hash: string): Promise<void>;
+export declare function outputsHashesMatch(_outputs: string[], hash: string): Promise<boolean>;
+export declare function processFileChangesInOutputs(changeEvents: WatchEvent[], now?: number): void;
+export declare function disableOutputsTracking(): void;
+//# sourceMappingURL=outputs-tracking.d.ts.map

package/src/daemon/server/outputs-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputs-tracking.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/outputs-tracking.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAsB,MAAM,cAAc,CAAC;AAW9D,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,QAejE;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,WAWlE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,UAE1C;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,iBAIvE;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,oBAIxE;AASD,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,UAAU,EAAE,EAC1B,GAAG,GAAE,MAAkB,QA2BxB;AAED,wBAAgB,sBAAsB,SAErC"}