Readd parent wrapper for hot reload.

src/node/entry.ts

@@ -4,21 +4,13 @@ import { commit, pkgName, version } from "./constants"
 import { openInExistingInstance, runCodeServer, runVsCodeCli, shouldSpawnCliProcess } from "./main"
 import { monkeyPatchProxyProtocols } from "./proxy_agent"
 import { loadAMDModule } from "./util"
-import { wrapper } from "./wrapper"
+import { isChild, wrapper } from "./wrapper"
 
 const cliPipe = process.env["VSCODE_IPC_HOOK_CLI"] as string
 const cliCommand = process.env["VSCODE_CLIENT_COMMAND"] as string
 
 async function entry(): Promise<void> {
   monkeyPatchProxyProtocols()
-  const cliArgs = await parse(process.argv.slice(2))
-
-  // There's no need to check flags like --help or to spawn in an existing
-  // instance for the child process because these would have already happened in
-  // the parent and the child wouldn't have been spawned. We also get the
-  // arguments from the parent so we don't have to parse twice and to account
-  // for environment manipulation (like how PASSWORD gets removed to avoid
-  // leaking to child processes).
 
   if (cliPipe || cliCommand) {
     const remoteAgentMain = await loadAMDModule<CodeServerLib.RemoteCLIMain>("vs/server/remoteCli", "main")
@@ -35,6 +27,21 @@ async function entry(): Promise<void> {
     return
   }
 
+  // There's no need to check flags like --help or to spawn in an existing
+  // instance for the child process because these would have already happened in
+  // the parent and the child wouldn't have been spawned. We also get the
+  // arguments from the parent so we don't have to parse twice and to account
+  // for environment manipulation (like how PASSWORD gets removed to avoid
+  // leaking to child processes).
+  if (isChild(wrapper)) {
+    const args = await wrapper.handshake()
+    wrapper.preventExit()
+    const server = await runCodeServer(args)
+    wrapper.onDispose(() => server.dispose())
+    return
+  }
+
+  const cliArgs = await parse(process.argv.slice(2))
   const configArgs = await readConfigFile(cliArgs.config)
   const args = await setDefaults(cliArgs, configArgs)
 
@@ -76,7 +83,7 @@ async function entry(): Promise<void> {
     return openInExistingInstance(args, socketPath)
   }
 
-  runCodeServer(args)
+  return wrapper.start(args)
 }
 
 entry().catch((error) => {

src/node/wrapper.ts

@@ -143,6 +143,64 @@ abstract class Process {
   }
 }
 
+/**
+ * Child process that will clean up after itself if the parent goes away and can
+ * perform a handshake with the parent and ask it to relaunch.
+ */
+class ChildProcess extends Process {
+  public logger = logger.named(`child:${process.pid}`)
+
+  public constructor(private readonly parentPid: number) {
+    super()
+
+    // Kill the inner process if the parent dies. This is for the case where the
+    // parent process is forcefully terminated and cannot clean up.
+    setInterval(() => {
+      try {
+        // process.kill throws an exception if the process doesn't exist.
+        process.kill(this.parentPid, 0)
+      } catch (_) {
+        // Consider this an error since it should have been able to clean up
+        // the child process unless it was forcefully killed.
+        this.logger.error(`parent process ${parentPid} died`)
+        this._onDispose.emit(undefined)
+      }
+    }, 5000)
+  }
+
+  /**
+   * Initiate the handshake and wait for a response from the parent.
+   */
+  public async handshake(): Promise<DefaultedArgs> {
+    this.send({ type: "handshake" })
+    const message = await onMessage<ParentMessage, ParentHandshakeMessage>(
+      process,
+      (message): message is ParentHandshakeMessage => {
+        return message.type === "handshake"
+      },
+      this.logger,
+    )
+    return message.args
+  }
+
+  /**
+   * Notify the parent process that it should relaunch the child.
+   */
+  public relaunch(version: string): void {
+    this.send({ type: "relaunch", version })
+  }
+
+  /**
+   * Send a message to the parent.
+   */
+  private send(message: ChildMessage): void {
+    if (!process.send) {
+      throw new Error("not spawned with IPC")
+    }
+    process.send(message)
+  }
+}
+
 /**
  * Parent process wrapper that spawns the child process and performs a handshake
  * with it. Will relaunch the child if it receives a SIGUSR1 or is asked to by
@@ -288,7 +346,14 @@ export class ParentProcess extends Process {
 /**
  * Process wrapper.
  */
-export const wrapper = new ParentProcess(require("../../package.json").version)
+export const wrapper =
+  typeof process.env.CODE_SERVER_PARENT_PID !== "undefined"
+    ? new ChildProcess(parseInt(process.env.CODE_SERVER_PARENT_PID))
+    : new ParentProcess(require("../../package.json").version)
+
+export function isChild(proc: ChildProcess | ParentProcess): proc is ChildProcess {
+  return proc instanceof ChildProcess
+}
 
 // It's possible that the pipe has closed (for example if you run code-server
 // --version | head -1). Assume that means we're done.