fix(cli): elect one service process

packages/cli/src/server-process.ts

@@ -7,10 +7,11 @@ import { LayerNode } from "@opencode-ai/core/effect/layer-node"
 import { Global } from "@opencode-ai/core/global"
 import { InstallationVersion } from "@opencode-ai/core/installation/version"
 import { AppProcess } from "@opencode-ai/core/process"
+import { EffectFlock } from "@opencode-ai/core/util/effect-flock"
 import { start } from "@opencode-ai/server/process"
 import { randomBytes, randomUUID } from "node:crypto"
 import path from "node:path"
-import { Effect, FileSystem, Logger, Option, Redacted, Schedule, Schema } from "effect"
+import { Effect, Exit, FileSystem, Logger, Option, Redacted, Schedule, Schema, Scope } from "effect"
 import { HttpServer } from "effect/unstable/http"
 import { Env } from "./env"
 import { ServiceConfig } from "./services/service-config"
@@ -27,7 +28,7 @@ export type Options = {
 export const run = Effect.fn("cli.server-process.run")((options: Options) =>
   processEffect(options).pipe(
     Effect.provide(Updater.layer),
-    Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node]))),
+    Effect.provide(AppNodeBuilder.build(LayerNode.group([Global.node, AppProcess.node, EffectFlock.node]))),
     Effect.provide(NodeServices.layer),
   ),
 )
@@ -36,6 +37,16 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
   if (options.mode === "service") yield* Effect.sync(() => process.chdir(Global.Path.home))
   return yield* Effect.scoped(
     Effect.gen(function* () {
+      const serviceOptions = options.mode === "service" ? yield* ServiceConfig.options() : undefined
+      const lockScope = serviceOptions === undefined ? undefined : yield* acquireServiceLock(serviceOptions.file)
+      if (
+        serviceOptions !== undefined &&
+        lockScope !== undefined &&
+        (yield* Service.discover(serviceOptions)) !== undefined
+      ) {
+        yield* Scope.close(lockScope, Exit.void)
+        return
+      }
       const environmentPassword = yield* Env.password
       // Keep the lease credential out of the environment inherited by tools.
       if (options.mode === "stdio") {
@@ -55,7 +66,10 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
         port: Option.fromNullishOr(options.port ?? config.port),
         password,
       }).pipe(Effect.provide(Logger.layer([], { mergeWithExisting: false })))
-      if (options.mode === "service") yield* register(address, password)
+      if (lockScope !== undefined) {
+        yield* register(address, password)
+        yield* Scope.close(lockScope, Exit.void)
+      }
       const url = HttpServer.formatAddress(address)
       console.log(options.mode === "stdio" ? JSON.stringify({ url }) : `server listening on ${url}`)
       if (options.mode === "default" && !environmentPassword) console.log(`server password ${password}`)
@@ -66,6 +80,16 @@ const processEffect = Effect.fnUntraced(function* (options: Options) {
   )
 })
 
+const acquireServiceLock = Effect.fnUntraced(function* (file: string) {
+  const flock = yield* EffectFlock.Service
+  const scope = yield* Scope.make()
+  yield* Effect.addFinalizer((exit) => Scope.close(scope, exit))
+  yield* flock
+    .acquire(`service:${file}`, undefined, { staleMs: 3_000, timeoutMs: 3_000 })
+    .pipe(Effect.provideService(Scope.Scope, scope))
+  return scope
+})
+
 // The latest atomic registration wins. A displaced process notices the new id,
 // exits, and cannot remove its successor's registration from its finalizer.
 const infoJson = Schema.fromJsonString(Service.Info)

packages/cli/test/service.test.ts

@@ -1,7 +1,8 @@
 import { NodeFileSystem } from "@effect/platform-node"
+import { Service } from "@opencode-ai/client/effect"
 import { Global } from "@opencode-ai/core/global"
 import { expect, test } from "bun:test"
-import { Effect } from "effect"
+import { Effect, Schema } from "effect"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
@@ -24,3 +25,47 @@ test("local channel stores service config with the local service filename", asyn
     await fs.rm(root, { recursive: true, force: true })
   }
 })
+
+test("concurrent service processes elect one server", async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-service-election-"))
+  const env = {
+    ...process.env,
+    HOME: root,
+    OPENCODE_DB: path.join(root, "opencode.db"),
+    OPENCODE_TEST_HOME: root,
+    XDG_CACHE_HOME: path.join(root, "cache"),
+    XDG_CONFIG_HOME: path.join(root, "config"),
+    XDG_DATA_HOME: path.join(root, "data"),
+    XDG_STATE_HOME: path.join(root, "state"),
+  }
+  const command = [process.execPath, path.join(import.meta.dir, "../src/index.ts"), "serve", "--service"]
+  const first = Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" })
+  const second = Bun.spawn(command, { env, stderr: "pipe", stdout: "ignore" })
+
+  try {
+    const registration = path.join(root, "state", "opencode", "service-local.json")
+    const info = await waitForInfo(registration)
+    const winner = info.pid === first.pid ? first : second
+    const loser = info.pid === first.pid ? second : first
+    const exited = await Promise.race([loser.exited.then(() => true), Bun.sleep(10_000).then(() => false)])
+
+    expect(exited).toBe(true)
+    expect(winner.exitCode).toBe(null)
+  } finally {
+    first.kill("SIGTERM")
+    second.kill("SIGTERM")
+    await Promise.all([first.exited, second.exited])
+    await fs.rm(root, { recursive: true, force: true })
+  }
+})
+
+async function waitForInfo(file: string) {
+  for (let attempt = 0; attempt < 200; attempt++) {
+    const value = await Bun.file(file)
+      .json()
+      .catch(() => undefined)
+    if (value !== undefined) return Schema.decodeUnknownPromise(Service.Info)(value)
+    await Bun.sleep(50)
+  }
+  throw new Error("Timed out waiting for service registration")
+}