fix(desktop): bootstrap v2 background service (#39309)

packages/desktop/src/main/background-cli.ts

@@ -0,0 +1,125 @@
+import { execFile } from "node:child_process"
+import { existsSync } from "node:fs"
+import { chmod, copyFile, mkdir, rename, rm } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import { fileURLToPath } from "node:url"
+import { promisify } from "node:util"
+import { app } from "electron"
+
+const execFileAsync = promisify(execFile)
+const root = dirname(fileURLToPath(import.meta.url))
+const stateHome = process.env.XDG_STATE_HOME
+const desktopStateNames = ["ai.opencode.desktop.dev", "ai.opencode.desktop.beta", "ai.opencode.desktop"]
+
+type Logger = {
+  log(message: string, meta?: Record<string, unknown>): void
+  error(message: string, meta?: Record<string, unknown>): void
+}
+
+export async function startBackgroundCli(logger: Logger, shellStateHome?: string) {
+  const bundled = app.isPackaged
+    ? join(process.resourcesPath, executableName())
+    : join(root, "../../resources", executableName())
+  logger.log("v2 CLI executable resolved", { bundled, packaged: app.isPackaged })
+  const version = await run(bundled, ["--version"], logger)
+  const binary = app.isPackaged ? await installCli(bundled, version, logger) : bundled
+
+  const candidates = [
+    ...new Set([stateHome, shellStateHome, ...desktopStateNames.map((name) => join(app.getPath("appData"), name))]),
+  ].filter((candidate) => candidate === undefined || existsSync(candidate))
+  const discovered = await Promise.all(
+    candidates.map(async (candidate) => ({
+      stateHome: candidate,
+      url: serviceUrl(await run(binary, ["service", "status"], logger, { stateHome: candidate })),
+    })),
+  )
+  const found = discovered.find((candidate) => candidate.url !== undefined)
+  logger.log("v2 CLI background instance checked", {
+    detected: Boolean(found),
+    ...endpoint(found?.url),
+  })
+
+  const daemonStateHome = found?.stateHome ?? stateHome
+  const url = await run(binary, ["service", "start"], logger, { stateHome: daemonStateHome })
+  const password = await run(binary, ["service", "get", "password"], logger, {
+    redact: true,
+    stateHome: daemonStateHome,
+  })
+  logger.log("v2 CLI background service ready", {
+    existing: Boolean(found),
+    username: "opencode",
+    ...endpoint(url),
+  })
+  return {
+    url,
+    username: "opencode",
+    password,
+  }
+}
+
+async function installCli(source: string, version: string, logger: Logger) {
+  const directory = join(app.getPath("userData"), "cli", version.replace(/[^a-zA-Z0-9._-]/g, "-"))
+  const destination = join(directory, executableName())
+  if (existsSync(destination)) {
+    logger.log("v2 CLI staged executable reused", { path: destination, version })
+    return destination
+  }
+
+  const temp = destination + `.${process.pid}.tmp`
+  await mkdir(directory, { recursive: true })
+  await copyFile(source, temp)
+  if (process.platform !== "win32") await chmod(temp, 0o755)
+  await rename(temp, destination).catch(async (error) => {
+    await rm(temp, { force: true })
+    throw error
+  })
+  logger.log("v2 CLI executable staged", { source, path: destination, version })
+  return destination
+}
+
+async function run(
+  binary: string,
+  args: string[],
+  logger: Logger,
+  options: { redact?: boolean; stateHome?: string } = {},
+) {
+  logger.log("v2 CLI command started", { binary, args })
+  const env = { ...process.env }
+  if (options.stateHome === undefined) delete env.XDG_STATE_HOME
+  else env.XDG_STATE_HOME = options.stateHome
+  return execFileAsync(binary, args, { env, windowsHide: true }).then(
+    (result) => {
+      const stdout = result.stdout.trim()
+      const stderr = result.stderr.trim()
+      logger.log("v2 CLI command completed", { args, stdout: options.redact ? "[redacted]" : stdout, stderr })
+      return stdout
+    },
+    (error: unknown) => {
+      const output = error as { stdout?: string; stderr?: string }
+      logger.error("v2 CLI command failed", {
+        args,
+        error: error instanceof Error ? error.message : String(error),
+        stdout: options.redact && output.stdout ? "[redacted]" : (output.stdout?.trim() ?? ""),
+        stderr: output.stderr?.trim() ?? "",
+      })
+      throw error
+    },
+  )
+}
+
+function serviceUrl(status: string) {
+  if (URL.canParse(status)) return status
+  if (!status.startsWith("running ")) return
+  const url = status.slice("running ".length).trim()
+  return URL.canParse(url) ? url : undefined
+}
+
+function endpoint(url: string | undefined) {
+  if (!url || !URL.canParse(url)) return {}
+  const parsed = new URL(url)
+  return { url, hostname: parsed.hostname, port: parsed.port }
+}
+
+function executableName() {
+  return process.platform === "win32" ? "opencode-cli.exe" : "opencode-cli"
+}

packages/desktop/src/main/index.ts

@@ -1,7 +1,6 @@
 import { randomUUID } from "node:crypto"
 import { mkdirSync, rmSync } from "node:fs"
 import * as http from "node:http"
-import { createServer } from "node:net"
 import { homedir, tmpdir } from "node:os"
 import { join } from "node:path"
 import { getCACertificates, setDefaultCACertificates } from "node:tls"
@@ -25,13 +24,7 @@ import {
   isFirstLaunchOnboardingPending,
   isOldLayoutEligible,
 } from "./onboarding"
-import {
-  getDefaultServerUrl,
-  preferAppEnv,
-  setDefaultServerUrl,
-  spawnLocalServer,
-  type SidecarListener,
-} from "./server"
+import { getDefaultServerUrl, preferAppEnv, setDefaultServerUrl } from "./server"
 import { setupAutoUpdater, showUpdaterDialog } from "./updater"
 import { safeWebContentsURL } from "./window-state"
 import {
@@ -48,6 +41,7 @@ import { registerWslIpcHandlers } from "./wsl/ipc"
 import { spawnWslSidecar } from "./wsl/sidecar"
 import { migrate } from "./migrate"
 import { cleanupStoreFiles } from "./store-cleanup"
+import { startBackgroundCli } from "./background-cli"
 
 const APP_NAMES: Record<string, string> = {
   dev: "OpenCode Dev",
@@ -63,7 +57,6 @@ const TEST_ONBOARDING = process.env.OPENCODE_TEST_ONBOARDING === "1"
 const jsCallStackFeature = "DocumentPolicyIncludeJSCallStacksInCrashReports"
 
 let logger: ReturnType<typeof initLogging>
-let server: SidecarListener | null = null
 
 const pendingDeepLinks: string[] = []
 
@@ -83,13 +76,6 @@ function emitDeepLinks(urls: string[]) {
   if (win) sendDeepLinks(win, urls)
 }
 
-async function killSidecar() {
-  if (!server) return
-  const current = server
-  server = null
-  await current.stop()
-}
-
 function ensureLoopbackNoProxy() {
   const loopback = ["127.0.0.1", "localhost", "::1"]
   const upsert = (key: string) => {
@@ -162,10 +148,7 @@ const main = Effect.gen(function* () {
       },
     },
   )
-  const stopSidecars = async () => {
-    await killSidecar()
-    wslServers.stopAll()
-  }
+  const stopSidecars = async () => wslServers.stopAll()
   const relaunch = () => {
     setAppQuitting()
     void stopSidecars().finally(() => {
@@ -198,7 +181,7 @@ const main = Effect.gen(function* () {
     return
   }
 
-  preferAppEnv(app.getPath("userData"))
+  const shellEnv = preferAppEnv(app.getPath("userData"))
 
   app.on("second-instance", (_event: Event, argv: string[]) => {
     const urls = argv.filter((arg: string) => arg.startsWith("opencode://"))
@@ -271,7 +254,7 @@ const main = Effect.gen(function* () {
   setDockIcon()
   const updater = setupAutoUpdater(stopSidecars)
   registerIpcHandlers({
-    killSidecar: () => killSidecar(),
+    killSidecar: () => undefined,
     relaunch,
     awaitInitialization: Effect.fnUntraced(
       function* () {
@@ -312,68 +295,22 @@ const main = Effect.gen(function* () {
     ),
   )
 
-  const port = yield* Effect.gen(function* () {
-    const fromEnv = process.env.OPENCODE_PORT
-    if (fromEnv) {
-      const parsed = Number.parseInt(fromEnv, 10)
-      if (!Number.isNaN(parsed)) return parsed
-    }
-
-    const res = yield* Deferred.make<number, unknown>()
-    const server = createServer()
-    server.on("error", (e) => Deferred.failSync(res, () => e))
-    server.listen(0, "127.0.0.1", () => {
-      const address = server.address()
-      if (typeof address !== "object" || !address) {
-        server.close()
-        Deferred.failSync(res, () => new Error("Failed to get port"))
-        return
-      }
-      const port = address.port
-      server.close(() => Effect.runSync(Deferred.succeed(res, port)))
-    })
-
-    return yield* Deferred.await(res)
-  })
-  const hostname = "127.0.0.1"
-  const url = `http://${hostname}:${port}`
-  const password = randomUUID()
-
   const loadingTask = yield* Effect.gen(function* () {
-    logger.log("sidecar connection started", { url })
-
     ensureLoopbackNoProxy()
     useEnvProxy()
 
-    logger.log("spawning sidecar", { url })
-    const { listener, health } = yield* Effect.promise(() =>
-      spawnLocalServer(hostname, port, password, {
-        userDataPath: app.getPath("userData"),
-        onStdout: (message) => writeLog("server", "stdout", { message }),
-        onStderr: (message) => writeLog("server", "stderr", { message }, "warn"),
-        onExit: (code) => writeLog("utility", "sidecar exited", { code }, "warn"),
-      }),
-    )
-    server = listener
+    logger.log("starting v2 background service")
+    const sidecar = yield* Effect.promise(() => startBackgroundCli(logger, shellEnv?.XDG_STATE_HOME))
     yield* Deferred.succeed(serverReady, {
-      url,
-      username: "opencode",
-      password,
+      url: sidecar.url,
+      username: sidecar.username,
+      password: sidecar.password,
     })
 
     if (process.platform === "win32") {
       void wslServers.initialize().catch((error) => logger.error("wsl server initialization failed", error))
     }
 
-    yield* Effect.promise(() => health.wait).pipe(
-      Effect.timeout("30 seconds"),
-      Effect.catch((e) =>
-        Effect.sync(() => {
-          logger.error("sidecar health check failed", e.toString())
-        }),
-      ),
-    )
-
     logger.log("loading task finished")
   }).pipe(forwardInitializationFailure(serverReady), Effect.forkChild)
 

packages/desktop/src/main/server.ts

@@ -43,13 +43,15 @@ export function setDefaultServerUrl(url: string | null) {
 
 export function preferAppEnv(userDataPath: string) {
   const shell = process.platform === "win32" ? null : getUserShell()
+  const shellEnv = shell ? loadShellEnv(shell, getLogger()) : null
   Object.assign(process.env, {
-    ...(shell ? loadShellEnv(shell, getLogger()) : null),
+    ...shellEnv,
     OPENCODE_EXPERIMENTAL_ICON_DISCOVERY: "true",
     OPENCODE_EXPERIMENTAL_FILEWATCHER: "true",
     OPENCODE_CLIENT: "desktop",
     XDG_STATE_HOME: process.env.XDG_STATE_HOME ?? userDataPath,
   })
+  return shellEnv
 }
 
 export async function spawnLocalServer(