Separate process wrappers and pass arguments

src/node/entry.ts

@@ -19,7 +19,7 @@ import { coderCloudBind } from "./coder-cloud"
 import { commit, version } from "./constants"
 import { register } from "./routes"
 import { humanPath, isFile, open } from "./util"
-import { ipcMain, WrapperProcess } from "./wrapper"
+import { isChild, wrapper } from "./wrapper"
 
 export const runVsCodeCli = (args: DefaultedArgs): void => {
   logger.debug("forking vs code cli...")
@@ -137,7 +137,7 @@ const main = async (args: DefaultedArgs): Promise<void> => {
       logger.info("  - Connected to cloud agent")
     } catch (err) {
       logger.error(err.message)
-      ipcMain.exit(1)
+      wrapper.exit(1)
     }
   }
 
@@ -154,19 +154,22 @@ const main = async (args: DefaultedArgs): Promise<void> => {
 }
 
 async function entry(): Promise<void> {
-  const cliArgs = parse(process.argv.slice(2))
-  const configArgs = await readConfigFile(cliArgs.config)
-  const args = await setDefaults(cliArgs, configArgs)
-
   // 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.
-  if (ipcMain.isChild) {
-    await ipcMain.handshake()
-    ipcMain.preventExit()
+  // 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()
     return main(args)
   }
 
+  const cliArgs = parse(process.argv.slice(2))
+  const configArgs = await readConfigFile(cliArgs.config)
+  const args = await setDefaults(cliArgs, configArgs)
+
   if (args.help) {
     console.log("code-server", version, commit)
     console.log("")
@@ -201,11 +204,10 @@ async function entry(): Promise<void> {
     return openInExistingInstance(args, socketPath)
   }
 
-  const wrapper = new WrapperProcess(require("../../package.json").version)
-  return wrapper.start()
+  return wrapper.start(args)
 }
 
 entry().catch((error) => {
   logger.error(error.message)
-  ipcMain.exit(error)
+  wrapper.exit(error)
 })

src/node/vscode.ts

@@ -1,4 +1,4 @@
-import { field, logger } from "@coder/logger"
+import { logger } from "@coder/logger"
 import * as cp from "child_process"
 import * as net from "net"
 import * as path from "path"
@@ -8,19 +8,18 @@ import { rootPath } from "./constants"
 import { settings } from "./settings"
 import { SocketProxyProvider } from "./socket"
 import { isFile } from "./util"
-import { ipcMain } from "./wrapper"
+import { onMessage, wrapper } from "./wrapper"
 
 export class VscodeProvider {
   public readonly serverRootPath: string
   public readonly vsRootPath: string
   private _vscode?: Promise<cp.ChildProcess>
-  private timeoutInterval = 10000 // 10s, matches VS Code's timeouts.
   private readonly socketProvider = new SocketProxyProvider()
 
   public constructor() {
     this.vsRootPath = path.resolve(rootPath, "lib/vscode")
     this.serverRootPath = path.join(this.vsRootPath, "out/vs/server")
-    ipcMain.onDispose(() => this.dispose())
+    wrapper.onDispose(() => this.dispose())
   }
 
   public async dispose(): Promise<void> {
@@ -69,10 +68,13 @@ export class VscodeProvider {
       vscode,
     )
 
-    const message = await this.onMessage(vscode, (message): message is ipc.OptionsMessage => {
-      // There can be parallel initializations so wait for the right ID.
-      return message.type === "options" && message.id === id
-    })
+    const message = await onMessage<ipc.VscodeMessage, ipc.OptionsMessage>(
+      vscode,
+      (message): message is ipc.OptionsMessage => {
+        // There can be parallel initializations so wait for the right ID.
+        return message.type === "options" && message.id === id
+      },
+    )
 
     return message.options
   }
@@ -104,61 +106,13 @@ export class VscodeProvider {
       dispose()
     })
 
-    this._vscode = this.onMessage(vscode, (message): message is ipc.ReadyMessage => {
+    this._vscode = onMessage<ipc.VscodeMessage, ipc.ReadyMessage>(vscode, (message): message is ipc.ReadyMessage => {
       return message.type === "ready"
     }).then(() => vscode)
 
     return this._vscode
   }
 
-  /**
-   * Listen to a single message from a process. Reject if the process errors,
-   * exits, or times out.
-   *
-   * `fn` is a function that determines whether the message is the one we're
-   * waiting for.
-   */
-  private onMessage<T extends ipc.VscodeMessage>(
-    proc: cp.ChildProcess,
-    fn: (message: ipc.VscodeMessage) => message is T,
-  ): Promise<T> {
-    return new Promise((resolve, reject) => {
-      const cleanup = () => {
-        proc.off("error", onError)
-        proc.off("exit", onExit)
-        proc.off("message", onMessage)
-        clearTimeout(timeout)
-      }
-
-      const timeout = setTimeout(() => {
-        cleanup()
-        reject(new Error("timed out"))
-      }, this.timeoutInterval)
-
-      const onError = (error: Error) => {
-        cleanup()
-        reject(error)
-      }
-
-      const onExit = (code: number | null) => {
-        cleanup()
-        reject(new Error(`VS Code exited unexpectedly with code ${code}`))
-      }
-
-      const onMessage = (message: ipc.VscodeMessage) => {
-        logger.trace("got message from vscode", field("message", message))
-        if (fn(message)) {
-          cleanup()
-          resolve(message)
-        }
-      }
-
-      proc.on("message", onMessage)
-      proc.on("error", onError)
-      proc.on("exit", onExit)
-    })
-  }
-
   /**
    * VS Code expects a raw socket. It will handle all the web socket frames.
    */