From 45703853ee021bec4e1f7e8df0898059b946f688 Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Mon, 16 Nov 2026 22:17:58 +0100 Subject: [PATCH 1/5] test(opencode): restarted server stops shell children of an exited OpenCode server Co-authored-by: Claude Opus 5.5 --- .../src/server/OpenCodeServerLedger.test.ts | 21 +++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts index 3fcb52c898d68..56e865723ab56 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts @@ -143,6 +143,27 @@ 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("records a group whose spawned wrapper already exited", () => Effect.gen(function* () { const fs = yield* FileSystem.FileSystem; From 1f3a8af46ae23a409e0a70ebc6c72e88838a6fe6 Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Mon, 16 Nov 2026 22:21:13 +0100 Subject: [PATCH 2/5] fix(opencode): restarted server stops shell commands that outlive an exited OpenCode server The ledger only stopped a recorded group while its recorded member still ran, so commands an OpenCode server left in its group kept running after the server exited. A leaderless group recorded in the current boot is now stopped as well. Co-authored-by: Claude Opus 5.5 --- .../src/server/OpenCodeServerLedger.test.ts | 22 +++++++++ .../src/server/OpenCodeServerLedger.ts | 48 +++++++++++++------ packages/shared/src/HostProcess.ts | 7 +++ 3 files changed, 63 insertions(+), 14 deletions(-) diff --git a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts index 56e865723ab56..3cee80c964655 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts @@ -164,6 +164,28 @@ describe.each(observedPlatforms)("OpenCodeServerLedger observing as %s", (platfo }).pipe(provideHost), ); + it.live("leaves a leaderless group alone when it was recorded in an earlier boot", () => + 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 unrelated = yield* spawnGroup(SERVE_ARGS, `sleep 600 & read _ < '${gate}'; exit 0`); + yield* recordFromDeadServer(stateDir, unrelated); + yield* fs.writeFileString(gate, "\n"); + yield* unrelated.exited; + + const restarted = yield* OpenCodeServerLedger.make({ stateDir }).pipe( + Effect.provideService(HostProcess.BootTime, (yield* HostProcess.BootTime) + 3600), + ); + 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..e8cd66cf5f4f1 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, + boot: Schema.optionalKey(Schema.Int), }); type OpenCodeServerEntry = typeof OpenCodeServerEntry.Type; const OpenCodeServerEntryJson = Schema.fromJsonString(OpenCodeServerEntry); @@ -46,6 +47,7 @@ const ENTRY_DIRECTORY = "opencode-servers"; const ENTRY_FILE = /^\d+\.json$/; const STOP_POLL_INTERVAL = "50 millis"; const STOP_POLL_ATTEMPTS = 40; +const BOOT_TOLERANCE_SECONDS = 60; interface ObservedProcess { readonly pid: number; @@ -184,6 +186,7 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { ), ); + const boot = yield* HostProcess.BootTime; const ownerPid = input.ownerPid ?? process.pid; const ownerProcess = yield* observe(ownerPid); const owner = @@ -220,6 +223,7 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { port: server.port, stateDir: input.stateDir, owner, + boot, }; yield* writeFileStringAtomically({ filePath: entryPath, @@ -243,23 +247,39 @@ 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))), + ), + ); + + // Commands the server started can outlive it in its group. A reused pgid needs a new + // leader, which must exit too before its group is leaderless, so a leaderless group + // from the recorded boot is taken as the server's. + const leaderlessGroupRemains = Effect.fn("OpenCodeServerLedger.leaderlessGroupRemains")( + function* (entry: OpenCodeServerEntry) { + if (entry.boot === undefined || Math.abs(entry.boot - boot) > BOOT_TOLERANCE_SECONDS) { + return false; + } + const leader = yield* observe(entry.pgid); + if (leader !== undefined && !leader.zombie && leader.pgid === entry.pgid) return false; + return (yield* observeGroup(entry.pgid)).some((member) => !member.zombie); + }, + ); + + // Signals a group only while its recorded member still runs as recorded, or while the + // group lives on without a leader, so a recycled pid that leads its own group is never touched. 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, diff --git a/packages/shared/src/HostProcess.ts b/packages/shared/src/HostProcess.ts index e5e2f8e97f108..47b8fef3c4cc5 100644 --- a/packages/shared/src/HostProcess.ts +++ b/packages/shared/src/HostProcess.ts @@ -32,6 +32,13 @@ export const LinuxLibc = Context.Reference<"gnu" | "musl">( }, ); +// Epoch seconds, derived from uptime, so it shifts with wall-clock changes: compare with a tolerance. +export const BootTime = Context.Reference("@t3tools/shared/HostProcess/BootTime", { + // A reference default runs outside any Effect, so it has no Clock to read. + // @effect-diagnostics-next-line globalDate:off + defaultValue: () => Math.round(Date.now() / 1000 - NodeOS.uptime()), +}); + export const Hostname = Context.Reference("@t3tools/shared/HostProcess/Hostname", { defaultValue: () => NodeOS.hostname(), }); From b33092ae0ca8a217b6f9e671200ce55ec8e20d1c Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Mon, 16 Nov 2026 22:43:31 +0100 Subject: [PATCH 3/5] fix(opencode): verify ownership of surviving shell groups Record a unique inherited server marker and require it on a surviving member before stopping a leaderless group. Leave same-boot replacement groups with missing or different markers alone. Co-authored-by: GPT 6.1 Sol --- .../src/server/OpenCodeRuntime.ts | 3 ++ .../src/server/OpenCodeServerLedger.test.ts | 36 +++++++++++++ .../src/server/OpenCodeServerLedger.ts | 53 ++++++++++++++++--- 3 files changed, 85 insertions(+), 7 deletions(-) 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 3cee80c964655..02822bf03b16c 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, T3CODE_OPENCODE_SERVER_MARKER: yield* random.uuidV4() }, detached: true, stdio: ["ignore", "pipe", "ignore"], }); @@ -164,6 +169,37 @@ describe.each(observedPlatforms)("OpenCodeServerLedger observing as %s", (platfo }).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 T3CODE_OPENCODE_SERVER_MARKER" + : "T3CODE_OPENCODE_SERVER_MARKER=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("leaves a leaderless group alone when it was recorded in an earlier boot", () => 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 e8cd66cf5f4f1..2ad7c5e12c0b1 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.ts @@ -26,6 +26,7 @@ const OpenCodeServerEntry = Schema.Struct({ stateDir: Schema.String, owner: ProcessIdentity, boot: Schema.optionalKey(Schema.Int), + marker: Schema.optionalKey(Schema.String), }); type OpenCodeServerEntry = typeof OpenCodeServerEntry.Type; const OpenCodeServerEntryJson = Schema.fromJsonString(OpenCodeServerEntry); @@ -43,6 +44,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"; @@ -178,6 +181,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( @@ -213,6 +245,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, @@ -224,6 +257,7 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { stateDir: input.stateDir, owner, boot, + ...(marker !== undefined ? { marker } : {}), }; yield* writeFileStringAtomically({ filePath: entryPath, @@ -260,22 +294,27 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { ), ); - // Commands the server started can outlive it in its group. A reused pgid needs a new - // leader, which must exit too before its group is leaderless, so a leaderless group - // from the recorded boot is taken as the server's. + // A pgid can be reused within one boot after its original group empties. + // Surviving commands must carry the unique marker inherited from this server. const leaderlessGroupRemains = Effect.fn("OpenCodeServerLedger.leaderlessGroupRemains")( function* (entry: OpenCodeServerEntry) { - if (entry.boot === undefined || Math.abs(entry.boot - boot) > BOOT_TOLERANCE_SECONDS) { + if ( + !entry.marker || + entry.boot === undefined || + Math.abs(entry.boot - boot) > BOOT_TOLERANCE_SECONDS + ) { return false; } const leader = yield* observe(entry.pgid); if (leader !== undefined && !leader.zombie && leader.pgid === entry.pgid) return false; - return (yield* observeGroup(entry.pgid)).some((member) => !member.zombie); + for (const member of yield* observeGroup(entry.pgid)) { + if (!member.zombie && (yield* readMarker(member)) === entry.marker) return true; + } + return false; }, ); - // Signals a group only while its recorded member still runs as recorded, or while the - // group lives on without a leader, so a recycled pid that leads its own group is never touched. + // Identity or an inherited per-spawn marker is required before signalling the group. const stopOrphan = Effect.fn("OpenCodeServerLedger.stopOrphan")(function* ( entry: OpenCodeServerEntry, ) { From 04881925b99b931bbf1606745813a36acf8b8019 Mon Sep 17 00:00:00 2001 From: Wout Stiens <71498452+StiensWout@users.noreply.github.com> Date: Mon, 16 Nov 2026 22:48:12 +0100 Subject: [PATCH 4/5] docs(opencode): clarify marker ownership proof Co-authored-by: GPT 6.1 Sol --- packages/provider-opencode/src/server/OpenCodeServerLedger.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/provider-opencode/src/server/OpenCodeServerLedger.ts b/packages/provider-opencode/src/server/OpenCodeServerLedger.ts index 2ad7c5e12c0b1..71ae1e208af44 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.ts @@ -294,8 +294,8 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { ), ); - // A pgid can be reused within one boot after its original group empties. - // Surviving commands must carry the unique marker inherited from this server. + // The unique inherited marker proves ownership, including when a pgid is reused. + // The boot check is only an additional conservative guard. const leaderlessGroupRemains = Effect.fn("OpenCodeServerLedger.leaderlessGroupRemains")( function* (entry: OpenCodeServerEntry) { if ( From e706ef60281de3bd1a4358e21ac688c1fde31620 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 17 Nov 2026 01:29:06 +0000 Subject: [PATCH 5/5] refactor(opencode): drop the redundant boot-time guard from orphan cleanup The per-spawn marker is a random UUID, so a group carrying it cannot belong to an earlier boot; the boot comparison added no protection. Co-Authored-By: Claude Opus 5.5 --- .../src/server/OpenCodeServerLedger.test.ts | 28 ++----------------- .../src/server/OpenCodeServerLedger.ts | 16 ++--------- packages/shared/src/HostProcess.ts | 7 ----- 3 files changed, 6 insertions(+), 45 deletions(-) diff --git a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts index 02822bf03b16c..5a252b7b10c15 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.test.ts @@ -53,7 +53,7 @@ const spawnGroupLeader = (args: ReadonlyArray, script: string) => Effect.provide(SecureRandom.layerWebCrypto), ); const child = NodeChildProcess.spawn("/bin/sh", ["-c", groupLeaderGuard + script, ...args], { - env: { ...process.env, T3CODE_OPENCODE_SERVER_MARKER: yield* random.uuidV4() }, + env: { ...process.env, [OpenCodeServerLedger.SERVER_MARKER_ENV]: yield* random.uuidV4() }, detached: true, stdio: ["ignore", "pipe", "ignore"], }); @@ -181,8 +181,8 @@ describe.each(observedPlatforms)("OpenCodeServerLedger observing as %s", (platfo NodeChildProcess.execFileSync("mkfifo", [gate, ready]); const environment = marker === "missing" - ? "-u T3CODE_OPENCODE_SERVER_MARKER" - : "T3CODE_OPENCODE_SERVER_MARKER=unrelated-marker"; + ? `-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`, @@ -200,28 +200,6 @@ describe.each(observedPlatforms)("OpenCodeServerLedger observing as %s", (platfo }).pipe(provideHost), ); - it.live("leaves a leaderless group alone when it was recorded in an earlier boot", () => - 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 unrelated = yield* spawnGroup(SERVE_ARGS, `sleep 600 & read _ < '${gate}'; exit 0`); - yield* recordFromDeadServer(stateDir, unrelated); - yield* fs.writeFileString(gate, "\n"); - yield* unrelated.exited; - - const restarted = yield* OpenCodeServerLedger.make({ stateDir }).pipe( - Effect.provideService(HostProcess.BootTime, (yield* HostProcess.BootTime) + 3600), - ); - 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 71ae1e208af44..80cfa28c43c5c 100644 --- a/packages/provider-opencode/src/server/OpenCodeServerLedger.ts +++ b/packages/provider-opencode/src/server/OpenCodeServerLedger.ts @@ -25,7 +25,6 @@ const OpenCodeServerEntry = Schema.Struct({ port: Schema.Int, stateDir: Schema.String, owner: ProcessIdentity, - boot: Schema.optionalKey(Schema.Int), marker: Schema.optionalKey(Schema.String), }); type OpenCodeServerEntry = typeof OpenCodeServerEntry.Type; @@ -50,7 +49,6 @@ const ENTRY_DIRECTORY = "opencode-servers"; const ENTRY_FILE = /^\d+\.json$/; const STOP_POLL_INTERVAL = "50 millis"; const STOP_POLL_ATTEMPTS = 40; -const BOOT_TOLERANCE_SECONDS = 60; interface ObservedProcess { readonly pid: number; @@ -218,7 +216,6 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { ), ); - const boot = yield* HostProcess.BootTime; const ownerPid = input.ownerPid ?? process.pid; const ownerProcess = yield* observe(ownerPid); const owner = @@ -256,7 +253,6 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { port: server.port, stateDir: input.stateDir, owner, - boot, ...(marker !== undefined ? { marker } : {}), }; yield* writeFileStringAtomically({ @@ -294,17 +290,11 @@ export const make = Effect.fn("OpenCodeServerLedger.make")(function* (input: { ), ); - // The unique inherited marker proves ownership, including when a pgid is reused. - // The boot check is only an additional conservative guard. + // 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 || - entry.boot === undefined || - Math.abs(entry.boot - boot) > BOOT_TOLERANCE_SECONDS - ) { - return false; - } + 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)) { diff --git a/packages/shared/src/HostProcess.ts b/packages/shared/src/HostProcess.ts index 47b8fef3c4cc5..e5e2f8e97f108 100644 --- a/packages/shared/src/HostProcess.ts +++ b/packages/shared/src/HostProcess.ts @@ -32,13 +32,6 @@ export const LinuxLibc = Context.Reference<"gnu" | "musl">( }, ); -// Epoch seconds, derived from uptime, so it shifts with wall-clock changes: compare with a tolerance. -export const BootTime = Context.Reference("@t3tools/shared/HostProcess/BootTime", { - // A reference default runs outside any Effect, so it has no Clock to read. - // @effect-diagnostics-next-line globalDate:off - defaultValue: () => Math.round(Date.now() / 1000 - NodeOS.uptime()), -}); - export const Hostname = Context.Reference("@t3tools/shared/HostProcess/Hostname", { defaultValue: () => NodeOS.hostname(), });