server: Disable exit/watchdog timers if detached

Background Info:

- In Unix-like environments, the child process would sometimes not exit even when the parent did.
- The exit/watchdog timers were created due to address this behavior. See the docstring of setupExitTimer().
- The 'detached' flag would not be honored in Unix-like environments, and looks to stay open regardless in some cases.

Problem:

If a language server was set as detached in the ServerOptions, and we wanted it to not exit on parent exit, it would
still exit due to the setupExitTimer()

Solution:

- A server will know that it is detached by the cli process argument: '--detached'
 - The client side code to inject this is in a following commit
- The exit/watchdog timers will not run if the detached flag is true
- When the input stream to the server ends due to parent terminating, the server would also. This PR
  changes it to skip this if detached.

Signed-off-by: nkomonen-amazon <nkomonen@amazon.com>

Author: nkomonen-amazon

server/src/node/main.ts

@@ -26,6 +26,41 @@ export namespace Files {
 	export const resolveModulePath = fm.resolveModulePath;
 }
 
+let _isDetached: boolean | undefined = undefined;
+
+/**
+ * @returns {boolean} True if the process is detached from its parent, false otherwise.
+ *
+ * @description
+ * When a process is detached, it will continue running even if it's parent process
+ * terminates. **But EXIT notifications from the client will be honored regardless.**
+ *
+ * @remarks
+ * This function assumes the parent process has been properly configured with
+ * necessary settings (e.g., using `child_process.unref()`).
+ */
+function isDetached() {
+	// cached result
+	if (_isDetached !== undefined) {
+		return _isDetached;
+	}
+
+	if(process.argv.includes('--detached')) {
+		setDetached();
+	} else {
+		_isDetached = false;
+	}
+	return _isDetached;
+
+	function setDetached() {
+		_isDetached = true;
+
+		// Ignores the default behavior when then parent/child communication
+		// channel (e.g. IPC) disconnects, the child terminates.
+		process.on('disconnect', () => {});
+	}
+}
+
 let _protocolConnection: ProtocolConnection | undefined;
 function endProtocolConnection(): void {
 	if (_protocolConnection === undefined) {
@@ -38,10 +73,23 @@ function endProtocolConnection(): void {
 		// did and we can't send an end into the connection.
 	}
 }
+
 let _shutdownReceived: boolean = false;
 let exitTimer: NodeJS.Timer | undefined = undefined;
 
+
+/**
+ * May auto-exit the server if the parent process does not exist.
+ *
+ * We need this due to different behaviors between OS's when the parent terminates:
+ * - Windows terminates the child
+ * - Unix-like may not terminate the child
+ */
 function setupExitTimer(): void {
+	if (isDetached()) {
+		return;
+	}
+
 	const argName = '--clientProcessId';
 	function runTimer(value: string): void {
 		try {
@@ -79,6 +127,10 @@ setupExitTimer();
 
 const watchDog: WatchDog = {
 	initialize: (params: InitializeParams): void => {
+		if (isDetached()) {
+			return;
+		}
+
 		const processId = params.processId;
 		if (Is.number(processId) && exitTimer === undefined) {
 			// We received a parent process id. Set up a timer to periodically check
@@ -105,7 +157,6 @@ const watchDog: WatchDog = {
 	}
 };
 
-
 /**
  * Creates a new connection based on the processes command line arguments:
  *
@@ -249,11 +300,15 @@ function _createConnection<PConsole = _, PTracer = _, PTelemetry = _, PClient =
 		const inputStream = <NodeJS.ReadableStream>input;
 		inputStream.on('end', () => {
 			endProtocolConnection();
-			process.exit(_shutdownReceived ? 0 : 1);
+			if (!isDetached()) {
+				process.exit(_shutdownReceived ? 0 : 1);
+			}
 		});
 		inputStream.on('close', () => {
 			endProtocolConnection();
-			process.exit(_shutdownReceived ? 0 : 1);
+			if (!isDetached()) {
+				process.exit(_shutdownReceived ? 0 : 1);
+			}
 		});
 	}