diff --git a/packages/provider-opencode/src/server/OpenCodeRuntime.ts b/packages/provider-opencode/src/server/OpenCodeRuntime.ts index ea2d7a7d76cac..05950b2c976d1 100644 --- a/packages/provider-opencode/src/server/OpenCodeRuntime.ts +++ b/packages/provider-opencode/src/server/OpenCodeRuntime.ts @@ -12,6 +12,7 @@ import { type QuestionAnswer, type QuestionRequest, } from "@opencode-ai/sdk/v2"; +import * as SecureRandom from "effect/crypto/SecureRandom"; import * as Cause from "effect/Cause"; import * as Context from "effect/Context"; import * as Deferred from "effect/Deferred"; @@ -505,6 +506,7 @@ function ensureRuntimeError( } const makeOpenCodeRuntime = Effect.gen(function* () { + const random = yield* SecureRandom.SecureRandom.pipe(Effect.provide(SecureRandom.layerWebCrypto)); const spawner = yield* ChildProcessSpawner.ChildProcessSpawner; const netService = yield* NetService.NetService; const hostPlatform = yield* HostProcess.Platform; @@ -630,6 +632,7 @@ const makeOpenCodeRuntime = Effect.gen(function* () { shell: spawnCommand.shell, env: { ...input.environment, + [OpenCodeServerLedger.SERVER_MARKER_ENV]: yield* random.uuidV4(), ...(serverPassword !== undefined ? { OPENCODE_SERVER_PASSWORD: serverPassword } : {}), // The value is set explicitly (rather than relying on inheritance) because // `extendEnv` is false whenever `input.environment` is provided. diff --git a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts index 3fcb52c898d68..5a252b7b10c15 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts @@ -5,6 +5,7 @@ import * as NodeReadline from "node:readline"; import * as NodeServices from "@effect/platform-node/NodeServices"; import { describe, expect, it } from "@effect/vitest"; import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as SecureRandom from "effect/crypto/SecureRandom"; import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; import * as Exit from "effect/Exit"; @@ -48,7 +49,11 @@ const groupLeaderGuard = `pgid="$(ps -o pgid= -p $$ 2>&1 | tr -d ' ')"; [ "$pgid // Yields the group, or a description of why this shell cannot be used as one. const spawnGroupLeader = (args: ReadonlyArray, script: string) => Effect.gen(function* () { + const random = yield* SecureRandom.SecureRandom.pipe( + Effect.provide(SecureRandom.layerWebCrypto), + ); const child = NodeChildProcess.spawn("/bin/sh", ["-c", groupLeaderGuard + script, ...args], { + env: { ...process.env, [OpenCodeServerLedger.SERVER_MARKER_ENV]: yield* random.uuidV4() }, detached: true, stdio: ["ignore", "pipe", "ignore"], }); @@ -143,6 +148,58 @@ describe.each(observedPlatforms)("OpenCodeServerLedger observing as %s", (platfo }).pipe(provideHost), ); + it.live("stops surviving shell children when the recorded server exits before restart", () => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const stateDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-opencode-ledger-" }); + const gate = path.join(stateDir, "gate"); + NodeChildProcess.execFileSync("mkfifo", [gate]); + const server = yield* spawnGroup(SERVE_ARGS, `sleep 600 & read _ < '${gate}'; exit 0`); + yield* recordFromDeadServer(stateDir, server); + yield* fs.writeFileString(gate, "\n"); + yield* server.exited; + expect(groupExists(server.pid)).toBe(true); + + const restarted = yield* OpenCodeServerLedger.make({ stateDir }); + yield* restarted.reapOrphans; + + expect(yield* fs.readDirectory(path.join(stateDir, "opencode-servers"))).toEqual([]); + expect(groupExists(server.pid)).toBe(false); + }).pipe(provideHost), + ); + + it.live.each(["missing", "different"])( + "leaves a same-boot leaderless replacement group with a %s marker alone", + (marker) => + Effect.gen(function* () { + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const stateDir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-opencode-ledger-" }); + const gate = path.join(stateDir, "gate"); + const ready = path.join(stateDir, "ready"); + NodeChildProcess.execFileSync("mkfifo", [gate, ready]); + const environment = + marker === "missing" + ? `-u ${OpenCodeServerLedger.SERVER_MARKER_ENV}` + : `${OpenCodeServerLedger.SERVER_MARKER_ENV}=unrelated-marker`; + const unrelated = yield* spawnGroup( + SERVE_ARGS, + `env ${environment} /bin/sh -c 'echo > "${ready}"; exec sleep 600' & read _ < '${gate}'; exit 0`, + ); + yield* fs.readFileString(ready); + yield* recordFromDeadServer(stateDir, unrelated); + yield* fs.writeFileString(gate, "\n"); + yield* unrelated.exited; + + const restarted = yield* OpenCodeServerLedger.make({ stateDir }); + yield* restarted.reapOrphans; + + expect(groupExists(unrelated.pid)).toBe(true); + expect(yield* fs.readDirectory(path.join(stateDir, "opencode-servers"))).toEqual([]); + }).pipe(provideHost), + ); + it.live("records a group whose spawned wrapper already exited", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; diff --git a/packages/provider-opencode/src/server/OpenCodeServerLedger.ts b/packages/provider-opencode/src/server/OpenCodeServerLedger.ts index fb3ea7645e9bf..80cfa28c43c5c 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.ts @@ -25,6 +25,7 @@ const OpenCodeServerEntry = Schema.Struct({ port: Schema.Int, stateDir: Schema.String, owner: ProcessIdentity, + marker: Schema.optionalKey(Schema.String), }); type OpenCodeServerEntry = typeof OpenCodeServerEntry.Type; const OpenCodeServerEntryJson = Schema.fromJsonString(OpenCodeServerEntry); @@ -42,6 +43,8 @@ export class OpenCodeServerLedger extends Context.Service< } >()("@t3tools/provider-opencode/server/OpenCodeServerLedger") {} +export const SERVER_MARKER_ENV = "T3CODE_OPENCODE_SERVER_MARKER"; + const ENTRY_DIRECTORY = "opencode-servers"; const ENTRY_FILE = /^\d+\.json$/; const STOP_POLL_INTERVAL = "50 millis"; @@ -176,6 +179,35 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { return Effect.succeed([]); }; + const readMarker = Effect.fn("OpenCodeServerLedger.readMarker")(function* ( + member: ObservedProcess, + ) { + const environment = yield* ( + platform === "linux" + ? fs.readFileString(`/proc/${member.pid}/environ`) + : spawner.string( + ChildProcess.make("/bin/ps", ["eww", "-p", String(member.pid), "-o", "command="], { + stdin: "ignore", + stderr: "ignore", + }), + ) + ).pipe( + Effect.timeout("5 seconds"), + Effect.orElseSucceed(() => ""), + ); + // BSD ps appends the environment to argv; assignments in argv are not ownership markers. + const prefix = `${member.command} `; + const values = + platform === "linux" + ? environment + : environment.trimStart().startsWith(prefix) + ? environment.trimStart().slice(prefix.length) + : ""; + const fields = values.split(platform === "linux" ? "\0" : /\s+/); + const marker = fields.find((field) => field.startsWith(`${SERVER_MARKER_ENV}=`)); + return marker?.slice(SERVER_MARKER_ENV.length + 1); + }); + const isRunning = (identity: ProcessIdentity) => observe(identity.pid).pipe( Effect.map( @@ -210,6 +242,7 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { return Effect.void; } const entryPath = path.join(directory, `${pgid}.json`); + const marker = yield* readMarker(member); const entry: OpenCodeServerEntry = { version: 1, pgid, @@ -220,6 +253,7 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { port: server.port, stateDir: input.stateDir, owner, + ...(marker !== undefined ? { marker } : {}), }; yield* writeFileStringAtomically({ filePath: entryPath, @@ -243,23 +277,38 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { ), ); - // Signals only a group whose recorded member still has the same pid, start - // time, and group and still has the same command line or serve arguments, so - // a recycled pid is never touched. + const recordedMemberRuns = (entry: OpenCodeServerEntry) => + observe(entry.pid).pipe( + Effect.map( + (observed) => + observed !== undefined && + !observed.zombie && + observed.startTime === entry.startTime && + observed.pgid === entry.pgid && + (observed.command === entry.command || + (entry.args !== undefined && runsServe(observed, entry.args))), + ), + ); + + // A per-spawn marker inherited by the server's children proves ownership after + // the recorded server exits, even when its pgid has been reused. + const leaderlessGroupRemains = Effect.fn("OpenCodeServerLedger.leaderlessGroupRemains")( + function* (entry: OpenCodeServerEntry) { + if (!entry.marker) return false; + const leader = yield* observe(entry.pgid); + if (leader !== undefined && !leader.zombie && leader.pgid === entry.pgid) return false; + for (const member of yield* observeGroup(entry.pgid)) { + if (!member.zombie && (yield* readMarker(member)) === entry.marker) return true; + } + return false; + }, + ); + + // Identity or an inherited per-spawn marker is required before signalling the group. const stopOrphan = Effect.fn("OpenCodeServerLedger.stopOrphan")(function* ( entry: OpenCodeServerEntry, ) { - const observed = yield* observe(entry.pid); - if ( - observed === undefined || - observed.zombie || - observed.startTime !== entry.startTime || - observed.pgid !== entry.pgid || - (observed.command !== entry.command && - (entry.args === undefined || !runsServe(observed, entry.args))) - ) { - return; - } + if (!(yield* recordedMemberRuns(entry)) && !(yield* leaderlessGroupRemains(entry))) return; yield* Effect.logInfo("Stopping an OpenCode server left by a previous T3 Code server", { pid: entry.pgid, port: entry.port,