@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/daemon/server/project-graph-listener-sockets.d.ts

@@ -0,0 +1,7 @@
+import { Socket } from 'net';
+import { ProjectGraph } from '../../config/project-graph';
+import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
+export declare let registeredProjectGraphListenerSockets: Socket[];
+export declare function removeRegisteredProjectGraphListenerSocket(socket: Socket): void;
+export declare function hasRegisteredProjectGraphListenerSockets(): boolean;
+export declare function notifyProjectGraphListenerSockets(projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, error: Error | null): Promise<void>;

package/dist/src/daemon/server/project-graph-listener-sockets.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registeredProjectGraphListenerSockets = void 0;
+exports.removeRegisteredProjectGraphListenerSocket = removeRegisteredProjectGraphListenerSocket;
+exports.hasRegisteredProjectGraphListenerSockets = hasRegisteredProjectGraphListenerSockets;
+exports.notifyProjectGraphListenerSockets = notifyProjectGraphListenerSockets;
+const server_1 = require("./server");
+const is_v8_serializer_enabled_1 = require("../is-v8-serializer-enabled");
+exports.registeredProjectGraphListenerSockets = [];
+function removeRegisteredProjectGraphListenerSocket(socket) {
+    exports.registeredProjectGraphListenerSockets =
+        exports.registeredProjectGraphListenerSockets.filter((s) => s !== socket);
+}
+function hasRegisteredProjectGraphListenerSockets() {
+    return exports.registeredProjectGraphListenerSockets.length > 0;
+}
+async function notifyProjectGraphListenerSockets(projectGraph, sourceMaps, error) {
+    if (!hasRegisteredProjectGraphListenerSockets()) {
+        return;
+    }
+    await Promise.all(exports.registeredProjectGraphListenerSockets.map((socket) => (0, server_1.handleResult)(socket, 'PROJECT_GRAPH_UPDATED', () => Promise.resolve({
+        description: 'Project graph updated',
+        response: { projectGraph, sourceMaps, error },
+    }), (0, is_v8_serializer_enabled_1.isV8SerializerEnabled)() ? 'v8' : 'json')));
+}

package/dist/src/daemon/server/restart-checks.d.ts

@@ -0,0 +1,22 @@
+import type { Server, Socket } from 'net';
+import type { ChangeBatch, FileData, WatchEvent } from '../../native';
+export declare function registerDaemonForRestartChecks(server: Server, sockets: Iterable<Socket>): void;
+/**
+ * The daemon's own process file, workspace-relative. It lives under the
+ * hardcoded-ignored .nx/workspace-data, so the watch admits it explicitly;
+ * that is how a daemon learns it has been replaced.
+ */
+export declare const relativeServerProcess: string;
+/** The paths out of a list of files and their hashes. */
+export declare function fileNames(files: FileData[]): string[];
+export declare function changedPaths(batch: ChangeBatch): string[];
+/**
+ * The watch's ignore rules are fixed when it starts, so an ignore-file edit
+ * needs a daemon restart to take effect. True when it stopped the daemon.
+ */
+export declare function restartDaemonIfIgnoreFilesChanged(paths: string[]): boolean;
+/**
+ * Stops this daemon when the events show another process has written the
+ * daemon's process file. True when it stopped the daemon.
+ */
+export declare function stopDaemonIfReplaced(events: WatchEvent[]): boolean;

package/dist/src/daemon/server/restart-checks.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeServerProcess = void 0;
+exports.registerDaemonForRestartChecks = registerDaemonForRestartChecks;
+exports.fileNames = fileNames;
+exports.changedPaths = changedPaths;
+exports.restartDaemonIfIgnoreFilesChanged = restartDaemonIfIgnoreFilesChanged;
+exports.stopDaemonIfReplaced = stopDaemonIfReplaced;
+const path_1 = require("path");
+const path_2 = require("../../utils/path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const cache_1 = require("../cache");
+const shutdown_utils_1 = require("./shutdown-utils");
+// Kept apart from server.ts: the recomputation module needs these, and
+// importing server.ts starts a server.
+let daemon;
+function registerDaemonForRestartChecks(server, sockets) {
+    daemon = { server, sockets };
+}
+/**
+ * The daemon's own process file, workspace-relative. It lives under the
+ * hardcoded-ignored .nx/workspace-data, so the watch admits it explicitly;
+ * that is how a daemon learns it has been replaced.
+ */
+exports.relativeServerProcess = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, cache_1.serverProcessJsonPath));
+/** The paths out of a list of files and their hashes. */
+function fileNames(files) {
+    return files.map(({ file }) => file);
+}
+function changedPaths(batch) {
+    return [
+        ...fileNames(batch.createdFiles),
+        ...fileNames(batch.updatedFiles),
+        ...batch.deletedFiles,
+    ];
+}
+// Mirrors the per-directory ignore files create_filter reads (watch_filterer.rs).
+// The sources it honours that cannot trigger a restart from here — because they
+// are never watched — only take effect on the next daemon start: .git/info/exclude
+// (under the hardcoded-ignored .git), the global core.excludesFile (outside the
+// tree), and parent .gitignore files above the workspace root.
+const IGNORE_FILE_NAMES = ['.gitignore', '.nxignore'];
+/**
+ * The watch's ignore rules are fixed when it starts, so an ignore-file edit
+ * needs a daemon restart to take effect. True when it stopped the daemon.
+ */
+function restartDaemonIfIgnoreFilesChanged(paths) {
+    for (const path of paths) {
+        const basename = path.slice(path.lastIndexOf('/') + 1);
+        if (IGNORE_FILE_NAMES.includes(basename)) {
+            stopDaemon('Stopping the daemon the set of ignored files changed (native)');
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Stops this daemon when the events show another process has written the
+ * daemon's process file. True when it stopped the daemon.
+ */
+function stopDaemonIfReplaced(events) {
+    const replaced = events.some((event) => event.path === exports.relativeServerProcess &&
+        (0, cache_1.getDaemonProcessIdSync)() !== process.pid);
+    if (replaced) {
+        stopDaemon('this process is no longer the current daemon (native)');
+    }
+    return replaced;
+}
+function stopDaemon(reason) {
+    if (!daemon)
+        return;
+    (0, shutdown_utils_1.handleServerProcessTermination)({
+        server: daemon.server,
+        reason,
+        sockets: daemon.sockets,
+    });
+}

package/dist/src/daemon/server/server.d.ts

@@ -0,0 +1,11 @@
+import { Server, Socket } from 'net';
+import '../../utils/perf-logging';
+export type HandlerResult = {
+    description: string;
+    error?: any;
+    response?: string | object | boolean;
+};
+export declare const openSockets: Set<Socket>;
+export declare function handleMessage(socket: Socket, data: Buffer): Promise<void>;
+export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>, mode: 'json' | 'v8'): Promise<void>;
+export declare function startServer(): Promise<Server>;

package/dist/src/daemon/server/server.js

@@ -0,0 +1,489 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSockets = void 0;
+exports.handleMessage = handleMessage;
+exports.handleResult = handleResult;
+exports.startServer = startServer;
+const fs_1 = require("fs");
+const permission_errors_1 = require("../../utils/permission-errors");
+const socket_refused_exit_code_1 = require("../../utils/socket-refused-exit-code");
+const net_1 = require("net");
+const path_1 = require("path");
+const analytics_1 = require("../../analytics");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const native_1 = require("../../native");
+const consume_messages_from_socket_1 = require("../../utils/consume-messages-from-socket");
+require("../../utils/perf-logging");
+const versions_1 = require("../../utils/versions");
+const workspace_root_1 = require("../../utils/workspace-root");
+const cache_1 = require("../cache");
+const is_nx_version_mismatch_1 = require("../is-nx-version-mismatch");
+const installed_nx_version_1 = require("../../utils/installed-nx-version");
+const logger_1 = require("../logger");
+const configure_ai_agents_1 = require("../message-types/configure-ai-agents");
+const daemon_message_1 = require("../message-types/daemon-message");
+const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
+const force_shutdown_1 = require("../message-types/force-shutdown");
+const get_context_file_data_1 = require("../message-types/get-context-file-data");
+const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
+const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
+const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const get_plugin_capabilities_1 = require("../message-types/get-plugin-capabilities");
+const select_affected_tasks_1 = require("../message-types/select-affected-tasks");
+const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
+const glob_1 = require("../message-types/glob");
+const hash_glob_1 = require("../message-types/hash-glob");
+const nx_console_1 = require("../message-types/nx-console");
+const register_project_graph_listener_1 = require("../message-types/register-project-graph-listener");
+const run_tasks_execution_hooks_1 = require("../message-types/run-tasks-execution-hooks");
+const task_history_1 = require("../message-types/task-history");
+const update_workspace_context_1 = require("../message-types/update-workspace-context");
+const socket_utils_1 = require("../socket-utils");
+const file_change_events_1 = require("./file-watching/file-change-events");
+const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
+const handle_configure_ai_agents_1 = require("./handle-configure-ai-agents");
+const handle_context_file_data_1 = require("./handle-context-file-data");
+const handle_flush_sync_generator_changes_to_disk_1 = require("./handle-flush-sync-generator-changes-to-disk");
+const handle_force_shutdown_1 = require("./handle-force-shutdown");
+const handle_client_env_1 = require("./handle-client-env");
+const handle_get_files_in_directory_1 = require("./handle-get-files-in-directory");
+const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
+const handle_get_plugin_capabilities_1 = require("./handle-get-plugin-capabilities");
+const handle_select_affected_tasks_1 = require("./handle-select-affected-tasks");
+const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
+const handle_glob_1 = require("./handle-glob");
+const handle_hash_glob_1 = require("./handle-hash-glob");
+const handle_hash_tasks_1 = require("./handle-hash-tasks");
+const handle_nx_console_1 = require("./handle-nx-console");
+const handle_nx_workspace_files_1 = require("./handle-nx-workspace-files");
+const handle_outputs_tracking_1 = require("./handle-outputs-tracking");
+const handle_process_in_background_1 = require("./handle-process-in-background");
+const handle_request_project_graph_1 = require("./handle-request-project-graph");
+const handle_request_shutdown_1 = require("./handle-request-shutdown");
+const handle_task_history_1 = require("./handle-task-history");
+const handle_tasks_execution_hooks_1 = require("./handle-tasks-execution-hooks");
+const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
+const handle_watch_events_1 = require("./handle-watch-events");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const restart_checks_1 = require("./restart-checks");
+const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
+const shutdown_utils_1 = require("./shutdown-utils");
+const sync_generators_1 = require("./sync-generators");
+const workspace_context_1 = require("../../utils/workspace-context");
+const is_ci_1 = require("../../utils/is-ci");
+let workspaceWatcherError;
+global.NX_DAEMON = true;
+process.env.NX_DAEMON_PROCESS = 'true';
+let numberOfOpenConnections = 0;
+exports.openSockets = new Set();
+const server = (0, net_1.createServer)(async (socket) => {
+    numberOfOpenConnections += 1;
+    exports.openSockets.add(socket);
+    logger_1.serverLogger.log(`Established a connection. Number of open connections: ${numberOfOpenConnections}`);
+    (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+    socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (message) => {
+        // A rejection here would otherwise be unhandled and take the daemon
+        // down with it, failing every other client's request too.
+        await handleMessage(socket, message).catch(async (e) => {
+            await (0, shutdown_utils_1.respondWithError)(socket, 'Error handling message', e);
+        });
+    }, (err) => {
+        logger_1.serverLogger.log(`Framing error: ${err.message}`);
+        // The stream cannot resynchronize, so close it and let the client
+        // observe the disconnect instead of waiting on a reply.
+        (0, shutdown_utils_1.respondWithError)(socket, 'Malformed message', err).finally(() => socket.destroy());
+    }));
+    socket.on('error', (e) => {
+        logger_1.serverLogger.log(`Socket error: ${e.message}`);
+        (0, file_watcher_sockets_1.removeRegisteredFileWatcherSocket)(socket);
+        (0, project_graph_listener_sockets_1.removeRegisteredProjectGraphListenerSocket)(socket);
+    });
+    socket.on('close', () => {
+        numberOfOpenConnections -= 1;
+        exports.openSockets.delete(socket);
+        logger_1.serverLogger.log(`Closed a connection. Number of open connections: ${numberOfOpenConnections}`);
+        (0, file_watcher_sockets_1.removeRegisteredFileWatcherSocket)(socket);
+        (0, project_graph_listener_sockets_1.removeRegisteredProjectGraphListenerSocket)(socket);
+    });
+});
+registerProcessTerminationListeners();
+async function handleMessage(socket, data) {
+    if (workspaceWatcherError) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `File watcher error in the workspace '${workspace_root_1.workspaceRoot}'.`, workspaceWatcherError);
+    }
+    const watchTerminalError = (0, handle_watch_events_1.getWatchTerminalError)();
+    if (watchTerminalError) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `File watcher error in the workspace '${workspace_root_1.workspaceRoot}'.`, watchTerminalError);
+    }
+    (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+    const unparsedPayload = data;
+    let payload;
+    // Reply in the format the client used.
+    const mode = (0, consume_messages_from_socket_1.isJsonMessage)(unparsedPayload) ? 'json' : 'v8';
+    logger_1.serverLogger.log(`Received raw message of length ${unparsedPayload.length}`);
+    try {
+        payload = (0, consume_messages_from_socket_1.parseMessage)(unparsedPayload);
+    }
+    catch (e) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${(0, consume_messages_from_socket_1.describeMessage)(unparsedPayload, { maxBytes: 200 })}`));
+    }
+    logger_1.serverLogger.log(`Received ${mode} message of type ${payload.type}`);
+    // A mismatch means the client reached the wrong daemon (e.g. a shared
+    // NX_SOCKET_DIR). Respond, but stay alive for our own workspace.
+    if ((0, daemon_message_1.isDaemonMessage)(payload)) {
+        try {
+            (0, daemon_message_1.assertNotForeignWorkspaceMessage)(payload, workspace_root_1.workspaceRoot);
+        }
+        catch (e) {
+            await (0, shutdown_utils_1.respondWithError)(socket, `Workspace root mismatch`, e);
+            return;
+        }
+    }
+    if ((0, daemon_message_1.isDaemonMessage)(payload) && payload.env) {
+        await (0, handle_client_env_1.handleClientEnv)(payload.env);
+    }
+    if (payload.type === 'PING') {
+        await handleResult(socket, 'PING', () => Promise.resolve({ response: true, description: 'ping' }), mode);
+    }
+    else if (payload.type === 'REQUEST_PROJECT_GRAPH') {
+        await handleResult(socket, 'REQUEST_PROJECT_GRAPH', () => (0, handle_request_project_graph_1.handleRequestProjectGraph)(socket), mode);
+    }
+    else if (payload.type === 'HASH_TASKS') {
+        await handleResult(socket, 'HASH_TASKS', () => (0, handle_hash_tasks_1.handleHashTasks)(payload), mode);
+    }
+    else if (payload.type === 'HASH_TASKS_UPFRONT') {
+        await handleResult(socket, 'HASH_TASKS_UPFRONT', () => (0, handle_hash_tasks_1.handleHashTasksUpfront)(payload), mode);
+    }
+    else if (payload.type === 'PROCESS_IN_BACKGROUND') {
+        await handleResult(socket, 'PROCESS_IN_BACKGROUND', () => (0, handle_process_in_background_1.handleProcessInBackground)(payload), mode);
+    }
+    else if (payload.type === 'RECORD_OUTPUTS_HASH_BATCH') {
+        await handleResult(socket, 'RECORD_OUTPUTS_HASH_BATCH', () => (0, handle_outputs_tracking_1.handleRecordOutputsHashBatch)(payload), mode);
+    }
+    else if (payload.type === 'OUTPUTS_HASHES_MATCH_BATCH') {
+        await handleResult(socket, 'OUTPUTS_HASHES_MATCH_BATCH', () => (0, handle_outputs_tracking_1.handleOutputsHashesMatchBatch)(payload), mode);
+    }
+    else if (payload.type === 'REQUEST_SHUTDOWN') {
+        await handleResult(socket, 'REQUEST_SHUTDOWN', () => (0, handle_request_shutdown_1.handleRequestShutdown)(server, numberOfOpenConnections), mode);
+    }
+    else if (payload.type === 'REGISTER_FILE_WATCHER') {
+        file_watcher_sockets_1.registeredFileWatcherSockets.push({ socket, config: payload.config });
+    }
+    else if ((0, register_project_graph_listener_1.isRegisterProjectGraphListenerMessage)(payload)) {
+        project_graph_listener_sockets_1.registeredProjectGraphListenerSockets.push(socket);
+    }
+    else if ((0, glob_1.isHandleGlobMessage)(payload)) {
+        await handleResult(socket, glob_1.GLOB, () => (0, handle_glob_1.handleGlob)(payload.globs, payload.exclude), mode);
+    }
+    else if ((0, glob_1.isHandleMultiGlobMessage)(payload)) {
+        await handleResult(socket, glob_1.MULTI_GLOB, () => (0, handle_glob_1.handleMultiGlob)(payload.globs, payload.exclude), mode);
+    }
+    else if ((0, get_nx_workspace_files_1.isHandleNxWorkspaceFilesMessage)(payload)) {
+        await handleResult(socket, get_nx_workspace_files_1.GET_NX_WORKSPACE_FILES, () => (0, handle_nx_workspace_files_1.handleNxWorkspaceFiles)(payload.projectRootMap), mode);
+    }
+    else if ((0, get_files_in_directory_1.isHandleGetFilesInDirectoryMessage)(payload)) {
+        await handleResult(socket, get_files_in_directory_1.GET_FILES_IN_DIRECTORY, () => (0, handle_get_files_in_directory_1.handleGetFilesInDirectory)(payload.dir), mode);
+    }
+    else if ((0, get_context_file_data_1.isHandleContextFileDataMessage)(payload)) {
+        await handleResult(socket, get_context_file_data_1.GET_CONTEXT_FILE_DATA, () => (0, handle_context_file_data_1.handleContextFileData)(), mode);
+    }
+    else if ((0, hash_glob_1.isHandleHashGlobMessage)(payload)) {
+        await handleResult(socket, hash_glob_1.HASH_GLOB, () => (0, handle_hash_glob_1.handleHashGlob)(payload.globs, payload.exclude), mode);
+    }
+    else if ((0, hash_glob_1.isHandleHashMultiGlobMessage)(payload)) {
+        await handleResult(socket, hash_glob_1.HASH_GLOB, () => (0, handle_hash_glob_1.handleHashMultiGlob)(payload.globGroups), mode);
+    }
+    else if ((0, task_history_1.isHandleGetFlakyTasksMessage)(payload)) {
+        await handleResult(socket, task_history_1.GET_FLAKY_TASKS, () => (0, handle_task_history_1.handleGetFlakyTasks)(payload.hashes), mode);
+    }
+    else if ((0, task_history_1.isHandleGetEstimatedTaskTimings)(payload)) {
+        await handleResult(socket, task_history_1.GET_ESTIMATED_TASK_TIMINGS, () => (0, handle_task_history_1.handleGetEstimatedTaskTimings)(payload.targets), mode);
+    }
+    else if ((0, task_history_1.isHandleWriteTaskRunsToHistoryMessage)(payload)) {
+        await handleResult(socket, task_history_1.RECORD_TASK_RUNS, () => (0, handle_task_history_1.handleRecordTaskRuns)(payload.taskRuns), mode);
+    }
+    else if ((0, force_shutdown_1.isHandleForceShutdownMessage)(payload)) {
+        await handleResult(socket, 'FORCE_SHUTDOWN', () => (0, handle_force_shutdown_1.handleForceShutdown)(server), mode);
+    }
+    else if ((0, get_sync_generator_changes_1.isHandleGetSyncGeneratorChangesMessage)(payload)) {
+        await handleResult(socket, get_sync_generator_changes_1.GET_SYNC_GENERATOR_CHANGES, () => (0, handle_get_sync_generator_changes_1.handleGetSyncGeneratorChanges)(payload.generators), mode);
+    }
+    else if ((0, flush_sync_generator_changes_to_disk_1.isHandleFlushSyncGeneratorChangesToDiskMessage)(payload)) {
+        await handleResult(socket, flush_sync_generator_changes_to_disk_1.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK, () => (0, handle_flush_sync_generator_changes_to_disk_1.handleFlushSyncGeneratorChangesToDisk)(payload.generators), mode);
+    }
+    else if ((0, get_registered_sync_generators_1.isHandleGetRegisteredSyncGeneratorsMessage)(payload)) {
+        await handleResult(socket, get_registered_sync_generators_1.GET_REGISTERED_SYNC_GENERATORS, () => (0, handle_get_registered_sync_generators_1.handleGetRegisteredSyncGenerators)(), mode);
+    }
+    else if ((0, get_plugin_capabilities_1.isHandleGetPluginCapabilitiesMessage)(payload)) {
+        await handleResult(socket, get_plugin_capabilities_1.GET_PLUGIN_CAPABILITIES, () => (0, handle_get_plugin_capabilities_1.handleGetPluginCapabilities)(), mode);
+    }
+    else if ((0, select_affected_tasks_1.isHandleSelectAffectedTasksMessage)(payload)) {
+        await handleResult(socket, select_affected_tasks_1.SELECT_AFFECTED_TASKS, () => (0, handle_select_affected_tasks_1.handleSelectAffectedTasks)(payload.request), mode);
+    }
+    else if ((0, update_workspace_context_1.isHandleUpdateWorkspaceContextMessage)(payload)) {
+        await handleResult(socket, update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT, () => (0, handle_update_workspace_context_1.handleUpdateWorkspaceContext)(payload.createdFiles, payload.updatedFiles, payload.deletedFiles), mode);
+    }
+    else if ((0, run_tasks_execution_hooks_1.isHandlePreTasksExecutionMessage)(payload)) {
+        await handleResult(socket, run_tasks_execution_hooks_1.PRE_TASKS_EXECUTION, () => (0, handle_tasks_execution_hooks_1.handleRunPreTasksExecution)(payload.context), mode);
+    }
+    else if ((0, run_tasks_execution_hooks_1.isHandlePostTasksExecutionMessage)(payload)) {
+        await handleResult(socket, run_tasks_execution_hooks_1.POST_TASKS_EXECUTION, () => (0, handle_tasks_execution_hooks_1.handleRunPostTasksExecution)(payload.context), mode);
+    }
+    else if ((0, nx_console_1.isHandleGetNxConsoleStatusMessage)(payload)) {
+        await handleResult(socket, nx_console_1.GET_NX_CONSOLE_STATUS, () => (0, handle_nx_console_1.handleGetNxConsoleStatus)(), mode);
+    }
+    else if ((0, nx_console_1.isHandleSetNxConsolePreferenceAndInstallMessage)(payload)) {
+        await handleResult(socket, nx_console_1.SET_NX_CONSOLE_PREFERENCE_AND_INSTALL, () => (0, handle_nx_console_1.handleSetNxConsolePreferenceAndInstall)(payload.preference), mode);
+    }
+    else if ((0, configure_ai_agents_1.isHandleGetConfigureAiAgentsStatusMessage)(payload)) {
+        await handleResult(socket, configure_ai_agents_1.GET_CONFIGURE_AI_AGENTS_STATUS, () => (0, handle_configure_ai_agents_1.handleGetConfigureAiAgentsStatus)(), mode);
+    }
+    else if ((0, configure_ai_agents_1.isHandleResetConfigureAiAgentsStatusMessage)(payload)) {
+        await handleResult(socket, configure_ai_agents_1.RESET_CONFIGURE_AI_AGENTS_STATUS, () => (0, handle_configure_ai_agents_1.handleResetConfigureAiAgentsStatus)(), mode);
+    }
+    else {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${(0, consume_messages_from_socket_1.describeMessage)(unparsedPayload, { maxBytes: 200 })}`));
+    }
+}
+async function handleResult(socket, type, hrFn, mode) {
+    let hr;
+    const startMark = new Date();
+    try {
+        hr = await hrFn();
+    }
+    catch (error) {
+        hr = { description: `[${type}]`, error };
+    }
+    const doneHandlingMark = new Date();
+    if (hr.error) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, hr.description, hr.error);
+    }
+    else {
+        logger_1.serverLogger.log(`Serializing response for ${type} message in ${mode} mode`);
+        const response = typeof hr.response === 'string'
+            ? Buffer.from(hr.response, 'utf8')
+            : (0, socket_utils_1.serializeWithFallback)(hr.response, mode);
+        logger_1.serverLogger.log(`Responding to ${type} message`);
+        await (0, shutdown_utils_1.respondToClient)(socket, response, hr.description);
+    }
+    const endMark = new Date();
+    logger_1.serverLogger.log(`Handled ${mode} message ${type}. Handling time: ${doneHandlingMark.getTime() - startMark.getTime()}. Response time: ${endMark.getTime() - doneHandlingMark.getTime()}.`);
+}
+function handleInactivityTimeout() {
+    if ((0, file_watcher_sockets_1.hasRegisteredFileWatcherSockets)() ||
+        (0, project_graph_listener_sockets_1.hasRegisteredProjectGraphListenerSockets)()) {
+        logger_1.serverLogger.log(`There are open file watchers or project graph listeners. Resetting inactivity timer.`);
+        (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+    }
+    else {
+        (0, shutdown_utils_1.handleServerProcessTermination)({
+            server,
+            reason: `${shutdown_utils_1.SERVER_INACTIVITY_TIMEOUT_MS}ms of inactivity`,
+            sockets: exports.openSockets,
+        });
+    }
+}
+function registerProcessTerminationListeners() {
+    process
+        .on('SIGINT', () => (0, shutdown_utils_1.handleServerProcessTermination)({
+        server,
+        reason: 'received process SIGINT',
+        sockets: exports.openSockets,
+    }))
+        .on('SIGTERM', () => (0, shutdown_utils_1.handleServerProcessTermination)({
+        server,
+        reason: 'received process SIGTERM',
+        sockets: exports.openSockets,
+    }))
+        .on('SIGHUP', () => (0, shutdown_utils_1.handleServerProcessTermination)({
+        server,
+        reason: 'received process SIGHUP',
+        sockets: exports.openSockets,
+    }));
+}
+let existingLockHash;
+function daemonIsOutdated() {
+    if ((0, is_nx_version_mismatch_1.isNxVersionMismatch)()) {
+        return 'NX_VERSION_CHANGED';
+    }
+    else if (lockFileHashChanged()) {
+        return 'LOCK_FILES_CHANGED';
+    }
+    return null;
+}
+function lockFileHashChanged() {
+    const lockFiles = [
+        (0, path_1.join)(workspace_root_1.workspaceRoot, 'package-lock.json'),
+        (0, path_1.join)(workspace_root_1.workspaceRoot, 'yarn.lock'),
+        (0, path_1.join)(workspace_root_1.workspaceRoot, 'pnpm-lock.yaml'),
+        (0, path_1.join)(workspace_root_1.workspaceRoot, 'bun.lockb'),
+        (0, path_1.join)(workspace_root_1.workspaceRoot, 'bun.lock'),
+    ];
+    const existingFiles = lockFiles.filter((file) => (0, fs_1.existsSync)(file));
+    const lockHashes = existingFiles.map((file) => (0, native_1.hashFile)(file));
+    const newHash = (0, file_hasher_1.hashArray)(lockHashes);
+    if (existingLockHash && newHash != existingLockHash) {
+        logger_1.serverLogger.log(`[Server] lock file hash changed! old=${existingLockHash}, new=${newHash}`);
+        existingLockHash = newHash;
+        return true;
+    }
+    else {
+        existingLockHash = newHash;
+        return false;
+    }
+}
+/**
+ * When applicable files in the workspaces are changed (created, updated, deleted),
+ * we need to recompute the cached serialized project graph so that it is readily
+ * available for the next client request to the server.
+ */
+const handleWorkspaceChanges = (err, batch) => {
+    if (workspaceWatcherError) {
+        logger_1.serverLogger.watcherLog('Skipping handleWorkspaceChanges because of a previously recorded watcher error.');
+        return;
+    }
+    try {
+        (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+        if (err) {
+            let error = typeof err === 'string' ? new Error(err) : err;
+            logger_1.serverLogger.watcherLog('Unexpected workspace watcher error', error.message);
+            console.error(error);
+            workspaceWatcherError = error;
+            (0, file_watcher_sockets_1.notifyFileWatcherSocketsOfError)(error);
+            return;
+        }
+        (0, project_graph_incremental_recomputation_1.routeAppliedChanges)(batch);
+    }
+    catch (err) {
+        logger_1.serverLogger.watcherLog(`Unexpected workspace error`, err.message);
+        console.error(err);
+        workspaceWatcherError = err;
+        (0, file_watcher_sockets_1.notifyFileWatcherSocketsOfError)(err);
+    }
+};
+async function startServer() {
+    // The workspace context owns the daemon's one watch and starts it before
+    // it scans, so a file written during boot is visible to one or the other.
+    if (!(0, workspace_context_1.isWatchingWorkspaceContext)()) {
+        (0, restart_checks_1.registerDaemonForRestartChecks)(server, exports.openSockets);
+        (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot, {
+            watch: true,
+            alwaysWatch: [restart_checks_1.relativeServerProcess],
+        });
+        (0, workspace_context_1.subscribeToWorkspaceChanges)(workspace_root_1.workspaceRoot, handleWorkspaceChanges);
+        logger_1.serverLogger.watcherLog(`Subscribed to changes within: ${workspace_root_1.workspaceRoot} (native)`);
+    }
+    // Initialize analytics for daemon process
+    await (0, analytics_1.startAnalytics)();
+    const socketPath = (0, socket_utils_1.getFullOsSocketPath)();
+    // Log daemon startup information for debugging
+    logger_1.serverLogger.log(`New daemon starting from: ${__filename}`);
+    logger_1.serverLogger.log(`New daemon __dirname: ${__dirname}`);
+    logger_1.serverLogger.log(`New daemon nxVersion: ${versions_1.nxVersion}`);
+    logger_1.serverLogger.log(`New daemon getInstalledNxVersion(): ${(0, installed_nx_version_1.getInstalledNxVersion)()}`);
+    // Persist metadata about the background process so that it can be cleaned up later if needed
+    await (0, cache_1.writeDaemonJsonProcessCache)({
+        processId: process.pid,
+        socketPath,
+        nxVersion: versions_1.nxVersion,
+    });
+    // See notes in socket-command-line-utils.ts on OS differences regarding clean up of existings connections.
+    if (!socket_utils_1.isWindows) {
+        (0, socket_utils_1.killSocketOrPath)();
+    }
+    logger_1.serverLogger.log(`[Server] Starting outdated check interval (20ms)`);
+    setInterval(() => {
+        if ((0, cache_1.getDaemonProcessIdSync)() !== process.pid) {
+            return (0, shutdown_utils_1.handleServerProcessTermination)({
+                server,
+                reason: 'this process is no longer the current daemon (native)',
+                sockets: exports.openSockets,
+            });
+        }
+        const outdated = daemonIsOutdated();
+        if (outdated) {
+            logger_1.serverLogger.log(`[Server] Daemon outdated: ${outdated}`);
+            if (outdated === 'LOCK_FILES_CHANGED') {
+                // Lock file changes - restart daemon, clients will reconnect
+                logger_1.serverLogger.log('[Server] Restarting daemon...');
+                (0, shutdown_utils_1.handleServerProcessTerminationWithRestart)({
+                    server,
+                    reason: outdated,
+                    sockets: exports.openSockets,
+                });
+            }
+            else {
+                // Version changes or other reasons - just shut down, don't restart
+                logger_1.serverLogger.log('[Server] Shutting down daemon (no restart)...');
+                (0, shutdown_utils_1.handleServerProcessTermination)({
+                    server,
+                    reason: outdated,
+                    sockets: exports.openSockets,
+                });
+            }
+        }
+    }, 20).unref();
+    return new Promise(async (resolve, reject) => {
+        // `listen` reports a failed bind asynchronously on the server, which the
+        // try below cannot catch — without this an EACCES became an uncaught
+        // exception whose only trace was the daemon log the client never reads.
+        // The exit code is what carries the errno to the client, which otherwise
+        // sees only a missing socket and cannot tell a refusal from a cold start.
+        server.on('error', (error) => {
+            logger_1.serverLogger.log(`Failed to listen on: ${socketPath} (${error.message})`);
+            process.exit((0, permission_errors_1.isPermissionDenied)(error) ? socket_refused_exit_code_1.SOCKET_REFUSED_EXIT_CODE : 1);
+        });
+        try {
+            server.listen(socketPath, async () => {
+                try {
+                    logger_1.serverLogger.log(`Started listening on: ${socketPath}`);
+                    // Linux gates connect() on write permission to the socket file; macOS/BSD gate
+                    // on the directory, which is already 0700. Done after listen because
+                    // net.Server.listen takes no mode and umask is process-global.
+                    if (!socket_utils_1.isWindows) {
+                        try {
+                            (0, fs_1.chmodSync)(socketPath, 0o600);
+                        }
+                        catch {
+                            // Best effort; the 0700 socket directory is the primary control.
+                        }
+                    }
+                    // this triggers the storage of the lock file hash
+                    daemonIsOutdated();
+                    // Every event the watch delivers, gitignored outputs and dotenv
+                    // files included.
+                    (0, workspace_context_1.subscribeToWatchEvents)(workspace_root_1.workspaceRoot, (err, events) => {
+                        if (!err && events && (0, restart_checks_1.stopDaemonIfReplaced)(events)) {
+                            return;
+                        }
+                        if (err || events?.length) {
+                            (0, handle_watch_events_1.handleWatchEvents)(err, events);
+                        }
+                    });
+                    // listen for project graph recomputation events to collect and schedule sync generators
+                    (0, project_graph_incremental_recomputation_1.registerProjectGraphRecomputationListener)(sync_generators_1.collectAndScheduleSyncGenerators);
+                    // register file change listener to invalidate sync generator cache
+                    (0, file_change_events_1.registerFileChangeListener)(sync_generators_1.clearSyncGeneratorsCache);
+                    (0, project_graph_incremental_recomputation_1.scheduleInitialProjectGraphComputation)();
+                    // Prime the Nx Console and AI agents caches in the background. Both
+                    // pull nx@latest, and the CLI never shows their results in CI.
+                    if (!(0, is_ci_1.isCI)()) {
+                        (0, handle_nx_console_1.handleGetNxConsoleStatus)().catch(() => {
+                            // Ignore errors, this is a background operation
+                        });
+                        (0, handle_configure_ai_agents_1.handleGetConfigureAiAgentsStatus)().catch(() => {
+                            // Ignore errors, this is a background operation
+                        });
+                    }
+                    return resolve(server);
+                }
+                catch (err) {
+                    await handleWorkspaceChanges(err, null);
+                }
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}

package/dist/src/daemon/server/shutdown-utils.d.ts

@@ -0,0 +1,18 @@
+import type { Server, Socket } from 'net';
+export declare const SERVER_INACTIVITY_TIMEOUT_MS: 10800000;
+interface HandleServerProcessTerminationParams {
+    server: Server;
+    reason: string;
+    sockets: Iterable<Socket>;
+}
+export declare function handleServerProcessTermination({ server, reason, sockets, }: HandleServerProcessTerminationParams): Promise<void>;
+export declare function handleServerProcessTerminationWithRestart({ server, reason, sockets, }: HandleServerProcessTerminationParams): Promise<void>;
+export declare function resetInactivityTimeout(cb: () => void): void;
+export declare function respondToClient(socket: Socket, response: Buffer, description: string): Promise<unknown>;
+/**
+ * Send an error to the client without terminating the daemon. Use this when the
+ * daemon should keep running for other clients after refusing a request.
+ */
+export declare function respondWithError(socket: Socket, description: string, error: Error): Promise<void>;
+export declare function respondWithErrorAndExit(socket: Socket, description: string, error: Error): Promise<void>;
+export {};