@ohos-ports/nx 17.3.2-beta.0

package/src/daemon/server/project-graph-incremental-recomputation.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUpdatedAndDeletedFiles = exports.getCachedSerializedProjectGraphPromise = exports.currentProjectGraph = exports.currentProjectFileMapCache = exports.fileMapWithFiles = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const nx_json_1 = require("../../config/nx-json");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const build_project_graph_1 = require("../../project-graph/build-project-graph");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const nx_deps_cache_1 = require("../../project-graph/nx-deps-cache");
+const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
+const logger_1 = require("./logger");
+let cachedSerializedProjectGraphPromise;
+const collectedUpdatedFiles = new Set();
+const collectedDeletedFiles = new Set();
+let storedWorkspaceConfigHash;
+let waitPeriod = 100;
+let scheduledTimeoutId;
+let knownExternalNodes = {};
+async function getCachedSerializedProjectGraphPromise() {
+    try {
+        // recomputing it now on demand. we can ignore the scheduled timeout
+        if (scheduledTimeoutId) {
+            clearTimeout(scheduledTimeoutId);
+            scheduledTimeoutId = undefined;
+        }
+        // reset the wait time
+        waitPeriod = 100;
+        await resetInternalStateIfNxDepsMissing();
+        if (collectedUpdatedFiles.size == 0 && collectedDeletedFiles.size == 0) {
+            if (!cachedSerializedProjectGraphPromise) {
+                cachedSerializedProjectGraphPromise =
+                    processFilesAndCreateAndSerializeProjectGraph();
+            }
+        }
+        else {
+            cachedSerializedProjectGraphPromise =
+                processFilesAndCreateAndSerializeProjectGraph();
+        }
+        return await cachedSerializedProjectGraphPromise;
+    }
+    catch (e) {
+        return {
+            error: e,
+            serializedProjectGraph: null,
+            serializedSourceMaps: null,
+            projectGraph: null,
+            fileMap: null,
+            allWorkspaceFiles: null,
+            rustReferences: null,
+        };
+    }
+}
+exports.getCachedSerializedProjectGraphPromise = getCachedSerializedProjectGraphPromise;
+function addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles) {
+    for (let f of [...createdFiles, ...updatedFiles]) {
+        collectedDeletedFiles.delete(f);
+        collectedUpdatedFiles.add(f);
+    }
+    for (let f of deletedFiles) {
+        collectedUpdatedFiles.delete(f);
+        collectedDeletedFiles.add(f);
+    }
+    if (updatedFiles.length > 0 || deletedFiles.length > 0) {
+        (0, file_watcher_sockets_1.notifyFileWatcherSockets)(null, updatedFiles, deletedFiles);
+    }
+    if (createdFiles.length > 0) {
+        waitPeriod = 100; // reset it to process the graph faster
+    }
+    if (!scheduledTimeoutId) {
+        scheduledTimeoutId = setTimeout(async () => {
+            scheduledTimeoutId = undefined;
+            if (waitPeriod < 4000) {
+                waitPeriod = waitPeriod * 2;
+            }
+            cachedSerializedProjectGraphPromise =
+                processFilesAndCreateAndSerializeProjectGraph();
+            await cachedSerializedProjectGraphPromise;
+            if (createdFiles.length > 0) {
+                (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, null, null);
+            }
+        }, waitPeriod);
+    }
+}
+exports.addUpdatedAndDeletedFiles = addUpdatedAndDeletedFiles;
+function computeWorkspaceConfigHash(projectsConfigurations) {
+    const projectConfigurationStrings = Object.entries(projectsConfigurations)
+        .sort(([projectNameA], [projectNameB]) => projectNameA.localeCompare(projectNameB))
+        .map(([projectName, projectConfig]) => `${projectName}:${JSON.stringify(projectConfig)}`);
+    return (0, file_hasher_1.hashArray)(projectConfigurationStrings);
+}
+async function processCollectedUpdatedAndDeletedFiles({ projects, externalNodes, projectRootMap }, updatedFileHashes, deletedFiles) {
+    try {
+        const workspaceConfigHash = computeWorkspaceConfigHash(projects);
+        // when workspace config changes we cannot incrementally update project file map
+        if (workspaceConfigHash !== storedWorkspaceConfigHash) {
+            storedWorkspaceConfigHash = workspaceConfigHash;
+            ({ ...exports.fileMapWithFiles } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap));
+            knownExternalNodes = externalNodes;
+        }
+        else {
+            if (exports.fileMapWithFiles) {
+                exports.fileMapWithFiles = (0, file_map_utils_1.updateFileMap)(projects, exports.fileMapWithFiles.rustReferences, updatedFileHashes, deletedFiles);
+            }
+            else {
+                exports.fileMapWithFiles = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+            }
+        }
+        collectedUpdatedFiles.clear();
+        collectedDeletedFiles.clear();
+    }
+    catch (e) {
+        // this is expected
+        // for instance, project.json can be incorrect or a file we are trying to has
+        // has been deleted
+        // we are resetting internal state to start from scratch next time a file changes
+        // given the user the opportunity to fix the error
+        // if Nx requests the project graph prior to the error being fixed,
+        // the error will be propagated
+        logger_1.serverLogger.log(`Error detected when recomputing project file map: ${e.message}`);
+        resetInternalState();
+        throw e;
+    }
+}
+async function processFilesAndCreateAndSerializeProjectGraph() {
+    try {
+        perf_hooks_1.performance.mark('hash-watched-changes-start');
+        const updatedFiles = [...collectedUpdatedFiles.values()];
+        const deletedFiles = [...collectedDeletedFiles.values()];
+        let updatedFileHashes = (0, workspace_context_1.updateFilesInContext)(updatedFiles, deletedFiles);
+        perf_hooks_1.performance.mark('hash-watched-changes-end');
+        perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
+        logger_1.serverLogger.requestLog(`Updated workspace context based on watched changes, recomputing project graph...`);
+        logger_1.serverLogger.requestLog([...updatedFiles.values()]);
+        logger_1.serverLogger.requestLog([...deletedFiles]);
+        const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
+        const graphNodes = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+        await processCollectedUpdatedAndDeletedFiles(graphNodes, updatedFileHashes, deletedFiles);
+        return createAndSerializeProjectGraph(graphNodes);
+    }
+    catch (err) {
+        return Promise.resolve({
+            error: err,
+            projectGraph: null,
+            fileMap: null,
+            rustReferences: null,
+            allWorkspaceFiles: null,
+            serializedProjectGraph: null,
+            serializedSourceMaps: null,
+        });
+    }
+}
+function copyFileData(d) {
+    return d.map((t) => ({ ...t }));
+}
+function copyFileMap(m) {
+    const c = {
+        nonProjectFiles: copyFileData(m.nonProjectFiles),
+        projectFileMap: {},
+    };
+    for (let p of Object.keys(m.projectFileMap)) {
+        c.projectFileMap[p] = copyFileData(m.projectFileMap[p]);
+    }
+    return c;
+}
+async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
+    try {
+        perf_hooks_1.performance.mark('create-project-graph-start');
+        const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
+        const allWorkspaceFiles = copyFileData(exports.fileMapWithFiles.allWorkspaceFiles);
+        const rustReferences = exports.fileMapWithFiles.rustReferences;
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), true);
+        exports.currentProjectFileMapCache = projectFileMapCache;
+        exports.currentProjectGraph = projectGraph;
+        perf_hooks_1.performance.mark('create-project-graph-end');
+        perf_hooks_1.performance.measure('total execution time for createProjectGraph()', 'create-project-graph-start', 'create-project-graph-end');
+        perf_hooks_1.performance.mark('json-stringify-start');
+        const serializedProjectGraph = JSON.stringify(projectGraph);
+        const serializedSourceMaps = JSON.stringify(sourceMaps);
+        perf_hooks_1.performance.mark('json-stringify-end');
+        perf_hooks_1.performance.measure('serialize graph', 'json-stringify-start', 'json-stringify-end');
+        return {
+            error: null,
+            projectGraph,
+            fileMap,
+            allWorkspaceFiles,
+            serializedProjectGraph,
+            serializedSourceMaps,
+            rustReferences,
+        };
+    }
+    catch (e) {
+        logger_1.serverLogger.log(`Error detected when creating a project graph: ${e.message}`);
+        return {
+            error: e,
+            projectGraph: null,
+            fileMap: null,
+            allWorkspaceFiles: null,
+            serializedProjectGraph: null,
+            serializedSourceMaps: null,
+            rustReferences: null,
+        };
+    }
+}
+async function resetInternalState() {
+    cachedSerializedProjectGraphPromise = undefined;
+    exports.fileMapWithFiles = undefined;
+    exports.currentProjectFileMapCache = undefined;
+    exports.currentProjectGraph = undefined;
+    collectedUpdatedFiles.clear();
+    collectedDeletedFiles.clear();
+    (0, workspace_context_1.resetWorkspaceContext)();
+    waitPeriod = 100;
+}
+async function resetInternalStateIfNxDepsMissing() {
+    try {
+        if (!(0, fileutils_1.fileExists)(nx_deps_cache_1.nxProjectGraph) && cachedSerializedProjectGraphPromise) {
+            await resetInternalState();
+        }
+    }
+    catch (e) {
+        await resetInternalState();
+    }
+}

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Server, Socket } from 'net';
+export type HandlerResult = {
+    description: string;
+    error?: any;
+    response?: string;
+};
+export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>): Promise<void>;
+export declare function startServer(): Promise<Server>;

package/src/daemon/server/server.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = exports.handleResult = void 0;
+const fs_1 = require("fs");
+const net_1 = require("net");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+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");
+const fileutils_1 = require("../../utils/fileutils");
+const versions_1 = require("../../utils/versions");
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+const cache_1 = require("../cache");
+const socket_utils_1 = require("../socket-utils");
+const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
+const handle_hash_tasks_1 = require("./handle-hash-tasks");
+const handle_outputs_tracking_1 = require("./handle-outputs-tracking");
+const handle_process_in_background_1 = require("./handle-process-in-background");
+const handle_request_file_data_1 = require("./handle-request-file-data");
+const handle_request_project_graph_1 = require("./handle-request-project-graph");
+const handle_request_shutdown_1 = require("./handle-request-shutdown");
+const logger_1 = require("./logger");
+const outputs_tracking_1 = require("./outputs-tracking");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const shutdown_utils_1 = require("./shutdown-utils");
+const watcher_1 = require("./watcher");
+let performanceObserver;
+let workspaceWatcherError;
+let outputsWatcherError;
+let numberOfOpenConnections = 0;
+const server = (0, net_1.createServer)(async (socket) => {
+    numberOfOpenConnections += 1;
+    logger_1.serverLogger.log(`Established a connection. Number of open connections: ${numberOfOpenConnections}`);
+    (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+    if (!performanceObserver) {
+        performanceObserver = new perf_hooks_1.PerformanceObserver((list) => {
+            const entry = list.getEntries()[0];
+            logger_1.serverLogger.log(`Time taken for '${entry.name}'`, `${entry.duration}ms`);
+        });
+        performanceObserver.observe({ entryTypes: ['measure'] });
+    }
+    socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (message) => {
+        await handleMessage(socket, message);
+    }));
+    socket.on('error', (e) => {
+        logger_1.serverLogger.log('Socket error');
+        console.error(e);
+    });
+    socket.on('close', () => {
+        numberOfOpenConnections -= 1;
+        logger_1.serverLogger.log(`Closed a connection. Number of open connections: ${numberOfOpenConnections}`);
+        (0, file_watcher_sockets_1.removeRegisteredFileWatcherSocket)(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);
+    }
+    if (daemonIsOutdated()) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Lock files changed`, {
+            name: '',
+            message: 'LOCK-FILES-CHANGED',
+        });
+    }
+    (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+    const unparsedPayload = data;
+    let payload;
+    try {
+        payload = JSON.parse(unparsedPayload);
+    }
+    catch (e) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
+    }
+    if (payload.type === 'PING') {
+        await handleResult(socket, 'PING', () => Promise.resolve({ response: JSON.stringify(true), description: 'ping' }));
+    }
+    else if (payload.type === 'REQUEST_PROJECT_GRAPH') {
+        await handleResult(socket, 'REQUEST_PROJECT_GRAPH', () => (0, handle_request_project_graph_1.handleRequestProjectGraph)());
+    }
+    else if (payload.type === 'HASH_TASKS') {
+        await handleResult(socket, 'HASH_TASKS', () => (0, handle_hash_tasks_1.handleHashTasks)(payload));
+    }
+    else if (payload.type === 'REQUEST_FILE_DATA') {
+        await handleResult(socket, 'REQUEST_FILE_DATA', () => (0, handle_request_file_data_1.handleRequestFileData)());
+    }
+    else if (payload.type === 'PROCESS_IN_BACKGROUND') {
+        await handleResult(socket, 'PROCESS_IN_BACKGROUND', () => (0, handle_process_in_background_1.handleProcessInBackground)(payload));
+    }
+    else if (payload.type === 'RECORD_OUTPUTS_HASH') {
+        await handleResult(socket, 'RECORD_OUTPUTS_HASH', () => (0, handle_outputs_tracking_1.handleRecordOutputsHash)(payload));
+    }
+    else if (payload.type === 'OUTPUTS_HASHES_MATCH') {
+        await handleResult(socket, 'OUTPUTS_HASHES_MATCH', () => (0, handle_outputs_tracking_1.handleOutputsHashesMatch)(payload));
+    }
+    else if (payload.type === 'REQUEST_SHUTDOWN') {
+        await handleResult(socket, 'REQUEST_SHUTDOWN', () => (0, handle_request_shutdown_1.handleRequestShutdown)(server, numberOfOpenConnections));
+    }
+    else if (payload.type === 'REGISTER_FILE_WATCHER') {
+        file_watcher_sockets_1.registeredFileWatcherSockets.push({ socket, config: payload.config });
+    }
+    else {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
+    }
+}
+async function handleResult(socket, type, hrFn) {
+    const startMark = new Date();
+    const hr = await hrFn();
+    const doneHandlingMark = new Date();
+    if (hr.error) {
+        await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, hr.description, hr.error);
+    }
+    else {
+        await (0, shutdown_utils_1.respondToClient)(socket, hr.response, hr.description);
+    }
+    const endMark = new Date();
+    logger_1.serverLogger.log(`Handled ${type}. Handling time: ${doneHandlingMark.getTime() - startMark.getTime()}. Response time: ${endMark.getTime() - doneHandlingMark.getTime()}.`);
+}
+exports.handleResult = handleResult;
+function handleInactivityTimeout() {
+    if (numberOfOpenConnections > 0) {
+        logger_1.serverLogger.log(`There are ${numberOfOpenConnections} open connections. Reset 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`,
+        });
+    }
+}
+function registerProcessTerminationListeners() {
+    process
+        .on('SIGINT', () => (0, shutdown_utils_1.handleServerProcessTermination)({
+        server,
+        reason: 'received process SIGINT',
+    }))
+        .on('SIGTERM', () => (0, shutdown_utils_1.handleServerProcessTermination)({
+        server,
+        reason: 'received process SIGTERM',
+    }))
+        .on('SIGHUP', () => (0, shutdown_utils_1.handleServerProcessTermination)({
+        server,
+        reason: 'received process SIGHUP',
+    }));
+}
+let existingLockHash;
+function daemonIsOutdated() {
+    return nxVersionChanged() || lockFileHashChanged();
+}
+function nxVersionChanged() {
+    return versions_1.nxVersion !== getInstalledNxVersion();
+}
+const nxPackageJsonPath = require.resolve('nx/package.json');
+function getInstalledNxVersion() {
+    try {
+        const { version } = (0, fileutils_1.readJsonFile)(nxPackageJsonPath);
+        return version;
+    }
+    catch (e) {
+        // node modules are absent, so we can return null, which would shut down the daemon
+        return null;
+    }
+}
+function lockFileHashChanged() {
+    const lockHashes = [
+        (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'),
+    ]
+        .filter((file) => (0, fs_1.existsSync)(file))
+        .map((file) => (0, native_1.hashFile)(file));
+    const newHash = (0, file_hasher_1.hashArray)(lockHashes);
+    if (existingLockHash && newHash != existingLockHash) {
+        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 = async (err, changeEvents) => {
+    if (workspaceWatcherError) {
+        logger_1.serverLogger.watcherLog('Skipping handleWorkspaceChanges because of a previously recorded watcher error.');
+        return;
+    }
+    try {
+        (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
+        if (daemonIsOutdated()) {
+            await (0, shutdown_utils_1.handleServerProcessTermination)({
+                server,
+                reason: 'Lock file changed',
+            });
+            return;
+        }
+        if (err || !changeEvents || !changeEvents.length) {
+            let error = typeof err === 'string' ? new Error(err) : err;
+            logger_1.serverLogger.watcherLog('Unexpected workspace watcher error', error.message);
+            console.error(error);
+            workspaceWatcherError = error;
+            return;
+        }
+        logger_1.serverLogger.watcherLog((0, watcher_1.convertChangeEventsToLogMessage)(changeEvents));
+        const updatedFilesToHash = [];
+        const createdFilesToHash = [];
+        const deletedFiles = [];
+        for (const event of changeEvents) {
+            if (event.type === 'delete') {
+                deletedFiles.push(event.path);
+            }
+            else {
+                try {
+                    const s = (0, fs_1.statSync)((0, path_1.join)(workspace_root_1.workspaceRoot, event.path));
+                    if (s.isFile()) {
+                        if (event.type === 'update') {
+                            updatedFilesToHash.push(event.path);
+                        }
+                        else {
+                            createdFilesToHash.push(event.path);
+                        }
+                    }
+                }
+                catch (e) {
+                    // this can happen when the update file was deleted right after
+                }
+            }
+        }
+        (0, project_graph_incremental_recomputation_1.addUpdatedAndDeletedFiles)(createdFilesToHash, updatedFilesToHash, deletedFiles);
+    }
+    catch (err) {
+        logger_1.serverLogger.watcherLog(`Unexpected workspace error`, err.message);
+        console.error(err);
+        workspaceWatcherError = err;
+    }
+};
+const handleOutputsChanges = async (err, changeEvents) => {
+    try {
+        if (err || !changeEvents || !changeEvents.length) {
+            let error = typeof err === 'string' ? new Error(err) : err;
+            logger_1.serverLogger.watcherLog('Unexpected outputs watcher error', error.message);
+            console.error(error);
+            outputsWatcherError = error;
+            (0, outputs_tracking_1.disableOutputsTracking)();
+            return;
+        }
+        if (outputsWatcherError) {
+            return;
+        }
+        logger_1.serverLogger.watcherLog('Processing file changes in outputs');
+        (0, outputs_tracking_1.processFileChangesInOutputs)(changeEvents);
+    }
+    catch (err) {
+        logger_1.serverLogger.watcherLog(`Unexpected outputs watcher error`, err.message);
+        console.error(err);
+        outputsWatcherError = err;
+        (0, outputs_tracking_1.disableOutputsTracking)();
+    }
+};
+async function startServer() {
+    (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot);
+    // Persist metadata about the background process so that it can be cleaned up later if needed
+    await (0, cache_1.writeDaemonJsonProcessCache)({
+        processId: process.pid,
+    });
+    // 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)();
+    }
+    return new Promise(async (resolve, reject) => {
+        try {
+            server.listen(socket_utils_1.FULL_OS_SOCKET_PATH, async () => {
+                try {
+                    logger_1.serverLogger.log(`Started listening on: ${socket_utils_1.FULL_OS_SOCKET_PATH}`);
+                    // this triggers the storage of the lock file hash
+                    daemonIsOutdated();
+                    if (!(0, shutdown_utils_1.getWatcherInstance)()) {
+                        (0, shutdown_utils_1.storeWatcherInstance)(await (0, watcher_1.watchWorkspace)(server, handleWorkspaceChanges));
+                        logger_1.serverLogger.watcherLog(`Subscribed to changes within: ${workspace_root_1.workspaceRoot} (native)`);
+                    }
+                    if (!(0, shutdown_utils_1.getOutputWatcherInstance)()) {
+                        (0, shutdown_utils_1.storeOutputWatcherInstance)(await (0, watcher_1.watchOutputFiles)(handleOutputsChanges));
+                    }
+                    return resolve(server);
+                }
+                catch (err) {
+                    await handleWorkspaceChanges(err, []);
+                }
+            });
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+exports.startServer = startServer;

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

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+import type { Server, Socket } from 'net';
+import type { Watcher } from '../../native';
+export declare const SERVER_INACTIVITY_TIMEOUT_MS: 10800000;
+export declare function storeWatcherInstance(instance: Watcher): void;
+export declare function getWatcherInstance(): Watcher;
+export declare function storeOutputWatcherInstance(instance: Watcher): void;
+export declare function getOutputWatcherInstance(): Watcher;
+interface HandleServerProcessTerminationParams {
+    server: Server;
+    reason: string;
+}
+export declare function handleServerProcessTermination({ server, reason, }: HandleServerProcessTerminationParams): Promise<void>;
+export declare function resetInactivityTimeout(cb: () => void): void;
+export declare function respondToClient(socket: Socket, response: string, description: string): Promise<unknown>;
+export declare function respondWithErrorAndExit(socket: Socket, description: string, error: Error): Promise<void>;
+export {};

package/src/daemon/server/shutdown-utils.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.respondWithErrorAndExit = exports.respondToClient = exports.resetInactivityTimeout = exports.handleServerProcessTermination = exports.getOutputWatcherInstance = exports.storeOutputWatcherInstance = exports.getWatcherInstance = exports.storeWatcherInstance = exports.SERVER_INACTIVITY_TIMEOUT_MS = void 0;
+const workspace_root_1 = require("../../utils/workspace-root");
+const logger_1 = require("./logger");
+const socket_utils_1 = require("../socket-utils");
+const cache_1 = require("../cache");
+exports.SERVER_INACTIVITY_TIMEOUT_MS = 10800000; // 10800000 ms = 3 hours
+let watcherInstance;
+function storeWatcherInstance(instance) {
+    watcherInstance = instance;
+}
+exports.storeWatcherInstance = storeWatcherInstance;
+function getWatcherInstance() {
+    return watcherInstance;
+}
+exports.getWatcherInstance = getWatcherInstance;
+let outputWatcherInstance;
+function storeOutputWatcherInstance(instance) {
+    outputWatcherInstance = instance;
+}
+exports.storeOutputWatcherInstance = storeOutputWatcherInstance;
+function getOutputWatcherInstance() {
+    return outputWatcherInstance;
+}
+exports.getOutputWatcherInstance = getOutputWatcherInstance;
+async function handleServerProcessTermination({ server, reason, }) {
+    try {
+        server.close();
+        (0, cache_1.deleteDaemonJsonProcessCache)();
+        if (watcherInstance) {
+            await watcherInstance.stop();
+            logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (sources)`);
+        }
+        if (outputWatcherInstance) {
+            await outputWatcherInstance.stop();
+            logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (outputs)`);
+        }
+        logger_1.serverLogger.log(`Server stopped because: "${reason}"`);
+    }
+    finally {
+        process.exit(0);
+    }
+}
+exports.handleServerProcessTermination = handleServerProcessTermination;
+let serverInactivityTimerId;
+function resetInactivityTimeout(cb) {
+    if (serverInactivityTimerId) {
+        clearTimeout(serverInactivityTimerId);
+    }
+    serverInactivityTimerId = setTimeout(cb, exports.SERVER_INACTIVITY_TIMEOUT_MS);
+}
+exports.resetInactivityTimeout = resetInactivityTimeout;
+function respondToClient(socket, response, description) {
+    return new Promise(async (res) => {
+        if (description) {
+            logger_1.serverLogger.requestLog(`Responding to the client.`, description);
+        }
+        socket.write(`${response}${String.fromCodePoint(4)}`, (err) => {
+            if (err) {
+                console.error(err);
+            }
+            logger_1.serverLogger.log(`Done responding to the client`, description);
+            res(null);
+        });
+    });
+}
+exports.respondToClient = respondToClient;
+async function respondWithErrorAndExit(socket, description, error) {
+    // print some extra stuff in the error message
+    logger_1.serverLogger.requestLog(`Responding to the client with an error.`, description, error.message);
+    console.error(error);
+    error.message = `${error.message}\n\nBecause of the error the Nx daemon process has exited. The next Nx command is going to restart the daemon process.\nIf the error persists, please run "nx reset".`;
+    await respondToClient(socket, (0, socket_utils_1.serializeResult)(error, null, null), null);
+    process.exit(1);
+}
+exports.respondWithErrorAndExit = respondWithErrorAndExit;

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

@@ -0,0 +1 @@
+export {};

package/src/daemon/server/start.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const output_1 = require("../../utils/output");
+const server_1 = require("./server");
+const process = require("process");
+(async () => {
+    try {
+        await (0, server_1.startServer)();
+    }
+    catch (err) {
+        output_1.output.error({
+            title: err?.message ||
+                'Something unexpected went wrong when starting the server',
+        });
+        process.exit(1);
+    }
+})();

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { Server } from 'net';
+import type { WatchEvent } from '../../native';
+export type FileWatcherCallback = (err: Error | string | null, changeEvents: WatchEvent[] | null) => Promise<void>;
+export declare function watchWorkspace(server: Server, cb: FileWatcherCallback): Promise<import("../../native").Watcher>;
+export declare function watchOutputFiles(cb: FileWatcherCallback): Promise<import("../../native").Watcher>;
+/**
+ * NOTE: An event type of "create" will also apply to the case where the user has restored
+ * an original version of a file after modifying/deleting it by using git, so we adjust
+ * our log language accordingly.
+ */
+export declare function convertChangeEventsToLogMessage(changeEvents: WatchEvent[]): string;