Fix issues surrounding opening files within code-server's terminal.

Author: GirlBossRush

src/node/cli.ts

@@ -737,10 +737,11 @@ export const shouldOpenInExistingInstance = async (args: Args): Promise<string |
   }
 
   // It's possible the user is trying to spawn another instance of code-server.
-  // Check if any unrelated flags are set (check against one because `_` always
-  // exists), that a file or directory was passed, and that the socket is
-  // active.
-  if (Object.keys(args).length === 1 && args._.length > 0) {
+  // 1. Check if any unrelated flags are set
+  // 2. That a file or directory was passed
+  // 3.  That the socket is active
+  // TODO: We check against 3 because some defaults always exist. This is fragile.
+  if (Object.keys(args).length === 3 && args._.length > 0) {
     const socketPath = await readSocketPath(DEFAULT_SOCKET_PATH)
     if (socketPath && (await canConnect(socketPath))) {
       return socketPath

src/node/constants.ts

@@ -18,6 +18,7 @@ export function getPackageJson(relativePath: string): JSONSchemaForNPMPackageJso
 
 const pkg = getPackageJson("../../package.json")
 
+export const pkgName = pkg.name || "code-server"
 export const version = pkg.version || "development"
 export const commit = pkg.commit || "development"
 export const rootPath = path.resolve(__dirname, "../..")

src/node/entry.ts

@@ -1,28 +1,40 @@
 import { logger } from "@coder/logger"
 import { optionDescriptions, parse, readConfigFile, setDefaults, shouldOpenInExistingInstance } from "./cli"
-import { commit, version } from "./constants"
+import { commit, pkgName, version } from "./constants"
 import { openInExistingInstance, runCodeServer, runVsCodeCli, shouldSpawnCliProcess } from "./main"
 import { monkeyPatchProxyProtocols } from "./proxy_agent"
-import { isChild, wrapper } from "./wrapper"
+import { loadAMDModule } from "./util"
+import { 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 (isChild(wrapper)) {
-    const args = await wrapper.handshake()
-    wrapper.preventExit()
-    const server = await runCodeServer(args)
-    wrapper.onDispose(() => server.dispose())
+
+  if (cliPipe || cliCommand) {
+    const remoteAgentMain = await loadAMDModule<CodeServerLib.RemoteCLIMain>("vs/server/remoteCli", "main")
+
+    remoteAgentMain(
+      {
+        productName: pkgName,
+        version,
+        commit,
+        executableName: pkgName,
+      },
+      process.argv.slice(2),
+    )
     return
   }
 
-  const cliArgs = await parse(process.argv.slice(2))
   const configArgs = await readConfigFile(cliArgs.config)
   const args = await setDefaults(cliArgs, configArgs)
 
@@ -64,7 +76,7 @@ async function entry(): Promise<void> {
     return openInExistingInstance(args, socketPath)
   }
 
-  return wrapper.start(args)
+  runCodeServer(args)
 }
 
 entry().catch((error) => {

src/node/wrapper.ts

@@ -143,64 +143,6 @@ 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
@@ -346,14 +288,7 @@ export class ParentProcess extends Process {
 /**
  * Process wrapper.
  */
-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
-}
+export const wrapper = new ParentProcess(require("../../package.json").version)
 
 // It's possible that the pipe has closed (for example if you run code-server
 // --version | head -1). Assume that means we're done.