fix(wsl): stop starting servers on teardown

Teardown cleared startup tokens but only awaited sidecars that had finished starting, so a reload could start a replacement beside the old process and disable or quit could leave a WSL server running. Each start now carries an abort handle: teardown cancels CLI discovery and health polling, kills a spawned server, and resolves only after it exits. A cancelled start shows the server as stopped.
Hona · Oct 1, 2026 · Sep 30, 2026 · Sep 30, 2026 · Sep 30, 2026 · Sep 30, 2026
commit 85924c51cadbdc4e26e034fc3bc134e2aeb7b19d
diff --git a/packages/gui-extensions/src/wsl/main.ts b/packages/gui-extensions/src/wsl/main.ts
@@ -46,12 +46,13 @@ const setup: Setup = (ctx) => {
           await runtime.installCli(distro, { version: cli.version, binary })
         }
       : (distro, build) => runtime.installCli(distro, build),
-    spawnSidecar: (distro) => {
+    spawnSidecar: (distro, signal) => {
       log("info", "spawning wsl sidecar", { distro })
       return spawnWslSidecar(distro, {
         runtime,
         t,
         packaged,
+        signal,
         onLine: (line) => log("info", "wsl sidecar", { distro, stream: line.stream, text: line.text }),
       })
     },

diff --git a/packages/gui-extensions/src/wsl/servers.test.ts b/packages/gui-extensions/src/wsl/servers.test.ts
@@ -0,0 +1,39 @@
+import { expect, test } from "bun:test"
+import { spawn, type ChildProcess } from "node:child_process"
+import type { WslServerConfig } from "./contract"
+import type { WslRuntime } from "./runtime"
+import { createWslServersController } from "./servers"
+
+test("teardown during a pending start resolves only after the started process exited", async () => {
+  const children: ChildProcess[] = []
+  const saved: WslServerConfig[] = []
+  const controller = createWslServersController({
+    cli: { version: "1.0.0" },
+    runtime: {} as WslRuntime,
+    t: (key) => key,
+    log: () => undefined,
+    installCli: async () => undefined,
+    readServers: () => saved,
+    writeServers: (servers) => saved.splice(0, saved.length, ...servers),
+    // A real server process that never turns healthy; an abort ends it and rejects once it exited.
+    spawnSidecar: (_distro, signal) => {
+      const child = spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { stdio: "ignore" })
+      children.push(child)
+      return new Promise((_, reject) =>
+        signal.addEventListener(
+          "abort",
+          () => {
+            child.once("exit", () => reject(signal.reason))
+            child.kill()
+          },
+          { once: true },
+        ),
+      )
+    },
+  })
+  await controller.addServer("Debian")
+  while (!children.length) await Bun.sleep(1)
+  expect(children[0].exitCode).toBeNull()
+  await controller.stopServers()
+  expect(children[0].exitCode !== null || children[0].signalCode !== null).toBe(true)
+})
diff --git a/packages/gui-extensions/src/wsl/servers.ts b/packages/gui-extensions/src/wsl/servers.ts
@@ -22,7 +22,8 @@ type WslServersControllerOptions = {
   runtime: WslRuntime
   t: Context["t"]
   log: (level: "info" | "error", message: string, data: Record<string, unknown>) => void
-  spawnSidecar: (distro: string) => Promise<RunningSidecar>
+  /** Rejects once signal aborts, after any process it started has exited. */
+  spawnSidecar: (distro: string, signal: AbortSignal) => Promise<RunningSidecar>
   installCli: (distro: string, cli: WslCliBuild) => Promise<void>
   readServers: () => WslServerConfig[]
   writeServers: (servers: WslServerConfig[]) => void
@@ -40,7 +41,9 @@ export function createWslServersController(options: WslServersControllerOptions)
   let state: WslServersState = initialState()
   const listeners = new Set<() => void>()
   const sidecars = new Map<string, RunningSidecar>()
-  const starts = new Map<string, symbol>()
+  // Starts in flight. Stopping one aborts its CLI discovery and health polling and waits until its process exited,
+  // so a restart, reload, disable or quit never leaves a sidecar running beside or after it.
+  const starts = new Map<string, { readonly abort: AbortController; readonly done: Promise<void> }>()
   let closed = false
 
   const emit = () => {
@@ -137,13 +140,20 @@ export function createWslServersController(options: WslServersControllerOptions)
     if (!item) return
     await stopServer(id)
     if (closed) return
-    const token = Symbol()
-    starts.set(id, token)
+    const abort = new AbortController()
+    const startup = { abort, done: launch(id, item.config.distro, abort) }
+    starts.set(id, startup)
+    await startup.done
+  }
+
+  const launch = async (id: string, distro: string, abort: AbortController) => {
+    // A later start or a stop replaced this one.
+    const current = () => starts.get(id)?.abort === abort
     setRuntime(id, { kind: "starting" })
-    options.log("info", "wsl sidecar starting", { id, distro: item.config.distro })
+    options.log("info", "wsl sidecar starting", { id, distro })
     try {
-      const sidecar = await options.spawnSidecar(item.config.distro)
-      if (starts.get(id) !== token) {
+      const sidecar = await options.spawnSidecar(distro, abort.signal)
+      if (!current()) {
         await sidecar.stop()
         return
       }
@@ -159,26 +169,28 @@ export function createWslServersController(options: WslServersControllerOptions)
         sidecars.delete(id)
         const message = t("error.serverExited", { code: code ?? "null", signal: signal ?? "null" })
         setRuntime(id, { kind: "failed", message })
-        options.log("error", "wsl sidecar exited", { id, distro: item.config.distro, code, signal })
+        options.log("error", "wsl sidecar exited", { id, distro, code, signal })
       })
-      void refreshCliCheckSafely(id, item.config.distro)
-      options.log("info", "wsl sidecar ready", { id, distro: item.config.distro, url: sidecar.url })
+      void refreshCliCheckSafely(id, distro)
+      options.log("info", "wsl sidecar ready", { id, distro, url: sidecar.url })
     } catch (error) {
-      if (starts.get(id) !== token) return
+      if (!current()) return
       starts.delete(id)
       const message = error instanceof Error ? error.message : String(error)
       setRuntime(id, { kind: "failed", message })
-      options.log("error", "wsl sidecar failed to start", { id, distro: item.config.distro, message })
+      options.log("error", "wsl sidecar failed to start", { id, distro, message })
     }
   }
 
   const stopServer = async (id: string) => {
+    const startup = starts.get(id)
     starts.delete(id)
+    startup?.abort.abort()
+    await startup?.done
     const existing = sidecars.get(id)
-    if (!existing) return
     sidecars.delete(id)
-    await existing.stop()
-    setRuntime(id, { kind: "stopped" })
+    await existing?.stop()
+    if (startup || existing) setRuntime(id, { kind: "stopped" })
   }
 
   const runJob = async <T>(job: WslJob, runner: () => Promise<T>) => {
@@ -291,8 +303,13 @@ export function createWslServersController(options: WslServersControllerOptions)
 
     async stopServers() {
       closed = true
+      const pending = [...starts.values()]
       starts.clear()
-      await Promise.all([...sidecars.values()].map((sidecar) => sidecar.stop()))
+      pending.forEach((startup) => startup.abort.abort())
+      await Promise.all([
+        ...pending.map((startup) => startup.done),
+        ...[...sidecars.values()].map((sidecar) => sidecar.stop()),
+      ])
       sidecars.clear()
     },
   }

diff --git a/packages/gui-extensions/src/wsl/sidecar.ts b/packages/gui-extensions/src/wsl/sidecar.ts
@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process"
+import { spawn, type ChildProcess } from "node:child_process"
 import { randomUUID } from "node:crypto"
 import { createServer } from "node:net"
 import type { Context } from "../sdk/main"
@@ -17,15 +17,18 @@ export async function spawnWslSidecar(
     runtime: WslRuntime
     t: Context["t"]
     packaged: boolean
+    /** Aborts the start: CLI discovery, health polling, and the server process, which has exited when this rejects. */
+    signal: AbortSignal
     onLine?: (line: WslCommandLine) => void
     healthTimeoutMs?: number
   },
 ): Promise<WslSidecar> {
   const t = opts.t
-  const opencode = await opts.runtime.resolveCli(distro)
+  const opencode = await opts.runtime.resolveCli(distro, { signal: opts.signal })
   if (!opencode) throw new Error(t("error.opencodeNotInstalled", { distro }))
 
   const port = await allocatePort(t)
+  opts.signal.throwIfAborted()
   const password = randomUUID()
   const script = [
     "set -euo pipefail",
@@ -69,6 +72,9 @@ export async function spawnWslSidecar(
       ),
     )
   })
+  const aborted = Promise.withResolvers<never>()
+  const abort = () => aborted.reject(opts.signal.reason)
+  opts.signal.addEventListener("abort", abort, { once: true })
   const url = `http://127.0.0.1:${port}`
   const startup = new AbortController()
   const health = pollWslHealth(() => checkHealth(url, password), startup.signal)
@@ -82,29 +88,33 @@ export async function spawnWslSidecar(
       )),
   )
 
-  await Promise.race([health, exit, timedOut])
-    .catch((error) => {
-      child.kill()
+  await Promise.race([health, exit, timedOut, aborted.promise])
+    .catch(async (error) => {
+      await stop(child)
       throw error
     })
     .finally(() => {
       clearTimeout(timeout)
       startup.abort()
+      opts.signal.removeEventListener("abort", abort)
     })
   return {
-    stop: async () => {
-      if (child.exitCode !== null || child.signalCode !== null) return
-      await new Promise<void>((resolve) => {
-        child.once("exit", () => resolve())
-        child.kill()
-      })
-    },
+    stop: () => stop(child),
     onExit: (cb) => child.once("exit", cb),
     url,
     password,
   }
 }
 
+function stop(child: ChildProcess) {
+  // A process that never started or already exited has nothing to wait for.
+  if (child.pid === undefined || child.exitCode !== null || child.signalCode !== null) return Promise.resolve()
+  return new Promise<void>((resolve) => {
+    child.once("exit", () => resolve())
+    child.kill()
+  })
+}
+
 async function checkHealth(url: string, password: string) {
   const auth = Buffer.from(`opencode:${password}`).toString("base64")
   return fetch(new URL("/api/info", url), {