openAgent

1import { Global } from "@opencode-ai/core/global"
2import { InstallationVersion } from "@opencode-ai/core/installation/version"
3import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
4import { ServerAuth } from "@opencode-ai/server/auth"
5import { Context, Effect, FileSystem, Layer, Option, Schedule, Schema, Scope } from "effect"
6import { HttpServer } from "effect/unstable/http"
7import { randomBytes, randomUUID } from "crypto"
8import { spawn } from "node:child_process"
9import path from "path"
10 
11export interface Interface {
12  readonly client: () => Effect.Effect<ReturnType<typeof createOpencodeClient>, unknown>
13  readonly transport: () => Effect.Effect<{ url: string; headers: RequestInit["headers"] }, unknown>
14  readonly start: () => Effect.Effect<string, Error>
15  readonly status: () => Effect.Effect<string | undefined>
16  readonly stop: () => Effect.Effect<void, unknown>
17  readonly password: (value?: string) => Effect.Effect<string, unknown>
18  readonly register: (address: HttpServer.Address) => Effect.Effect<void, unknown, Scope.Scope>
19}
20 
21export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Daemon") {}
22 
23const Registration = Schema.Struct({
24  id: Schema.optional(Schema.String),
25  version: Schema.optional(Schema.String),
26  url: Schema.String,
27  pid: Schema.Int.check(Schema.isGreaterThan(0)),
28})
29type Registration = typeof Registration.Type
30 
31function sameRegistration(left: Registration, right: Registration) {
32  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
33}
34 
35export const layer = Layer.effect(
36  Service,
37  Effect.gen(function* () {
38    const fs = yield* FileSystem.FileSystem
39    const directory = Global.Path.state
40    const file = path.join(directory, "server.json")
41    const passwordFile = path.join(directory, "password")
42    const decodeRegistration = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
43 
44    const password = Effect.fn("cli.daemon.password")(function* (value?: string) {
45      const existing = yield* fs.readFileString(passwordFile).pipe(Effect.catch(() => Effect.succeed(undefined)))
46      if (value === undefined && existing) return existing
47 
48      // Keep one private credential across server restarts so discovered clients
49      // can reconnect without exposing a password flag or environment variable.
50      const generated = value ?? randomBytes(32).toString("base64url")
51      const temp = passwordFile + ".tmp"
52      yield* fs.makeDirectory(directory, { recursive: true })
53      yield* fs.writeFileString(temp, generated, { mode: 0o600 })
54      yield* fs.rename(temp, passwordFile)
55      return generated
56    })
57 
58    const registration = Effect.fnUntraced(function* () {
59      return yield* fs.readFileString(file).pipe(Effect.flatMap(decodeRegistration))
60    })
61 
62    const createClient = Effect.fnUntraced(function* (url: string) {
63      return createOpencodeClient({ baseUrl: url, headers: ServerAuth.headers({ password: yield* password() }) })
64    })
65 
66    const healthy = Effect.fnUntraced(function* () {
67      const info = yield* registration()
68      const client = yield* createClient(info.url)
69      const response = yield* Effect.tryPromise(() => client.v2.health.get({ signal: AbortSignal.timeout(2_000) }))
70      if (response.data?.healthy === true) return info
71      return yield* Effect.fail(new Error("Registered server is not healthy"))
72    })
73 
74    const compatible = Effect.fnUntraced(function* () {
75      const info = yield* healthy()
76      if (info.version === InstallationVersion) return info
77      return yield* Effect.fail(new Error("Registered server version does not match the client"))
78    })
79 
80    const signal = (pid: number, signal: NodeJS.Signals) =>
81      Effect.try({ try: () => process.kill(pid, signal), catch: (cause) => cause }).pipe(Effect.ignore)
82 
83    const awaitStopped = Effect.fnUntraced(function* (pid: number) {
84      const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(
85        Effect.orElseSucceed(() => false),
86      )
87      if (!running) return true
88      return yield* Effect.fail(new Error(`Server process ${pid} is still running`))
89    })
90 
91    const stopProcess = Effect.fnUntraced(function* (info: Registration) {
92      const current = yield* healthy().pipe(Effect.option)
93      if (Option.isNone(current) || !sameRegistration(current.value, info)) return
94 
95      yield* signal(info.pid, "SIGTERM")
96      const stopped = yield* awaitStopped(info.pid).pipe(
97        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
98        Effect.option,
99      )
100      if (Option.isSome(stopped)) return
101 
102      const latest = yield* healthy().pipe(Effect.option)
103      if (Option.isNone(latest) || !sameRegistration(latest.value, info)) return
104      yield* signal(info.pid, "SIGKILL")
105      yield* awaitStopped(info.pid).pipe(
106        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
107      )
108    })
109 
110    const start = Effect.fn("cli.daemon.start")(function* () {
111      const existing = yield* healthy().pipe(Effect.option)
112      const found = Option.getOrUndefined(existing)
113      const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
114      if (found?.version === InstallationVersion && compiled) return found.url
115      if (found) yield* stopProcess(found).pipe(Effect.ignore)
116 
117      const entrypoint = compiled ? undefined : process.argv[1]
118      if (!compiled && entrypoint === undefined)
119        return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
120      yield* Effect.try({
121        try: () => {
122          spawn(process.execPath, [...(entrypoint ? [entrypoint] : []), "serve", "--register"], {
123            detached: true,
124            stdio: "ignore",
125          }).unref()
126        },
127        catch: (cause) => new Error("Failed to start server", { cause }),
128      })
129 
130      return yield* compatible().pipe(
131        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
132        Effect.map((info) => info.url),
133        Effect.mapError(() => new Error("Failed to start server")),
134      )
135    })
136 
137    const transport = Effect.fn("cli.daemon.transport")(function* () {
138      return { url: yield* start(), headers: ServerAuth.headers({ password: yield* password() }) }
139    })
140 
141    const client = Effect.fn("cli.daemon.client")(function* () {
142      const connection = yield* transport()
143      return createOpencodeClient({ baseUrl: connection.url, headers: connection.headers })
144    })
145 
146    const status = Effect.fn("cli.daemon.status")(function* () {
147      const existing = yield* healthy().pipe(Effect.option)
148      const found = Option.getOrUndefined(existing)
149      if (found?.version === InstallationVersion) return found.url
150      if (found) return undefined
151      yield* fs.remove(file).pipe(Effect.ignore)
152      return undefined
153    })
154 
155    const stop = Effect.fn("cli.daemon.stop")(function* () {
156      const existing = yield* healthy().pipe(Effect.option)
157      // A stale registration may point at a PID that has since been reused by
158      // another process. Only signal the PID after authenticating the server.
159      if (Option.isNone(existing)) return yield* fs.remove(file).pipe(Effect.ignore)
160      yield* stopProcess(existing.value)
161      yield* fs.remove(file).pipe(Effect.ignore)
162    })
163 
164    const register = Effect.fn("cli.daemon.register")(function* (address: HttpServer.Address) {
165      const id = randomUUID()
166      const temp = file + "." + id + ".tmp"
167      yield* fs.makeDirectory(directory, { recursive: true })
168      yield* fs.writeFileString(
169        temp,
170        JSON.stringify({ id, version: InstallationVersion, url: HttpServer.formatAddress(address), pid: process.pid }),
171        { mode: 0o600 },
172      )
173      yield* fs.rename(temp, file)
174      yield* registration().pipe(
175        Effect.flatMap((info) => (info.id === id ? Effect.void : signal(process.pid, "SIGTERM"))),
176        Effect.catch(() => signal(process.pid, "SIGTERM")),
177        Effect.repeat(Schedule.spaced("10 seconds")),
178        Effect.forkScoped,
179      )
180      yield* Effect.addFinalizer(() =>
181        registration().pipe(
182          Effect.flatMap((info) => (info.id === id ? fs.remove(file) : Effect.void)),
183          Effect.ignore,
184        ),
185      )
186    })
187 
188    return Service.of({ client, transport, start, status, stop, password, register })
189  }),
190)
191 
192export * as Daemon from "./daemon"
193