Fix race condition when launching Oxide helper process

Author: thecrypticace

packages/tailwindcss-language-server/src/oxide-session.ts

@@ -4,6 +4,11 @@ import * as path from 'node:path'
 import * as fs from 'node:fs/promises'
 import { type ScanOptions, type ScanResult } from './oxide'
 
+interface ServerHandle {
+  helper: proc.ChildProcess
+  connection: rpc.MessageConnection
+}
+
 /**
  * This helper starts a session in which we can use Oxide in *another process*
  * to communicate content scanning results.
@@ -19,75 +24,98 @@ import { type ScanOptions, type ScanResult } from './oxide'
  *   us sidestep the problem as the process will only be running as needed.
  */
 export class OxideSession {
-  helper: proc.ChildProcess | null = null
-  connection: rpc.MessageConnection | null = null
+  /**
+   * A cached helper path
+   *
+   * We store this so the lookup happens at most once
+   */
+  private static helperPath: Promise<string> | null = null
+
+  /**
+   * An object that represents the connection to the server
+   *
+   * This ensures that either everything is initialized or nothing is
+   */
+  private server: Promise<ServerHandle> | null = null
 
   public async scan(options: ScanOptions): Promise<ScanResult> {
-    await this.startIfNeeded()
+    let server = await this.startIfNeeded()
 
-    return await this.connection.sendRequest('scan', options)
+    return await server.connection.sendRequest('scan', options)
   }
 
-  async startIfNeeded(): Promise<void> {
-    if (this.connection) return
-
-    // TODO: Can we find a way to not require a build first?
-    // let module = path.resolve(path.dirname(__filename), './oxide-helper.ts')
-
-    let modulePaths = [
-      // Separate Language Server package
-      '../bin/oxide-helper.js',
-
-      // Bundled with the VSCode extension
-      '../dist/oxide-helper.js',
-    ]
+  async startIfNeeded(): Promise<ServerHandle> {
+    console.log('startIfNeeded?')
 
-    let module: string | null = null
+    this.server ??= this.start()
 
-    for (let relativePath of modulePaths) {
-      let filepath = path.resolve(path.dirname(__filename), relativePath)
+    return this.server
+  }
 
-      if (
-        await fs.access(filepath).then(
-          () => true,
-          () => false,
-        )
-      ) {
-        module = filepath
-        break
-      }
-    }
+  private async start(): Promise<ServerHandle> {
+    console.log('start server?')
 
-    if (!module) throw new Error('unable to load')
+    let helperPath = await OxideSession.locateHelper()
 
-    let helper = proc.fork(module)
+    let helper = proc.fork(helperPath)
     let connection = rpc.createMessageConnection(
       new rpc.IPCMessageReader(helper),
       new rpc.IPCMessageWriter(helper),
     )
 
     helper.on('disconnect', () => {
+      console.log('Helper disconnected')
       connection.dispose()
-      this.connection = null
-      this.helper = null
+      this.server = null
     })
 
     helper.on('exit', () => {
+      console.log('Helper exited')
       connection.dispose()
-      this.connection = null
-      this.helper = null
+      this.server = null
     })
 
     connection.listen()
 
-    this.helper = helper
-    this.connection = connection
+    return { helper, connection }
   }
 
   async stop() {
-    if (!this.helper) return
+    if (!this.server) return
+
+    let handle = await this.server
+    handle.helper.disconnect()
+    handle.helper.kill()
+  }
+
+  private static async locateHelper(): Promise<string> {
+    console.log('locate helper?')
+
+    // TODO: Can we find a way to not require a build first?
+    // let module = path.resolve(path.dirname(__filename), './oxide-helper.ts')
+
+    let modulePaths = [
+      // Separate Language Server package
+      '../bin/oxide-helper.js',
+
+      // Bundled with the VSCode extension
+      '../dist/oxide-helper.js',
+    ]
+
+    OxideSession.helperPath ??= (async () => {
+      for (let relativePath of modulePaths) {
+        let filepath = path.resolve(path.dirname(__filename), relativePath)
+        let exists = await fs.access(filepath).then(
+          () => true,
+          () => false,
+        )
+
+        if (exists) return filepath
+      }
+
+      throw new Error('unable to load')
+    })()
 
-    this.helper.disconnect()
-    this.helper.kill()
+    return OxideSession.helperPath
   }
 }