Skip to content

Commit c637878

Browse files
fix(opencode): close audit-v13 wave J-B instance-store liveness + ordering findings
1 parent 88777b8 commit c637878

2 files changed

Lines changed: 137 additions & 26 deletions

File tree

‎packages/opencode/src/project/instance-store.ts‎

Lines changed: 51 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -30,21 +30,29 @@ export class Service extends Context.Service<Service, Interface>()("@opencode/In
3030

3131
export const use = serviceUse(Service)
3232

33-
interface Entry {
33+
/**
34+
* A directory-global teardown in flight. Every cached entry carries one; an uncached `dispose`
35+
* creates a standalone tracker so a concurrent `reload` still serializes with its disposers
36+
* (NEW-V13-06).
37+
*/
38+
interface TeardownTracker {
39+
/**
40+
* Resolves when the directory-global `runDisposers` settles, even if the teardown fiber was
41+
* interrupted while it was in flight.
42+
*/
43+
readonly teardown: Deferred.Deferred<void>
44+
/** Whether the teardown reached `runDisposers`, so `teardown` settles on its own. */
45+
teardownStarted: boolean
46+
}
47+
48+
interface Entry extends TeardownTracker {
3449
readonly deferred: Deferred.Deferred<InstanceContext>
3550
/** Outstanding `provide` leases; a leased entry is never evicted (D-P1-05). */
3651
uses: number
3752
/** Set synchronously once a teardown claims the entry; a `provide` that observes it reloads. */
3853
disposed: boolean
3954
/** Resolves when a claimed teardown finished and the entry left the cache. */
4055
readonly closed: Deferred.Deferred<void>
41-
/**
42-
* Resolves when this entry's directory-global `runDisposers` settles, even if the teardown
43-
* fiber was interrupted while it was in flight.
44-
*/
45-
readonly teardown: Deferred.Deferred<void>
46-
/** Whether this entry's claim reached `runDisposers`, so `teardown` settles on its own. */
47-
teardownStarted: boolean
4856
}
4957

5058
const makeEntry = (): Entry => ({
@@ -68,8 +76,9 @@ const layer: Layer.Layer<Service, never, Project.Service | InstanceBootstrap.Ser
6876
const cache = new Map<string, Entry>()
6977
// Disposers are directory-global and keep running after an interrupt, even though the
7078
// interrupted entry has already left `cache`. Track those in-flight teardowns by directory
71-
// so a `reload` can wait for them before booting a replacement (NEW-V12-06).
72-
const teardowns = new Map<string, Set<Entry>>()
79+
// so a `reload` can wait for them before booting a replacement (NEW-V12-06). Trackers can
80+
// outlive their entry (uncached `dispose`), so the set holds trackers, not entries.
81+
const teardowns = new Map<string, Set<TeardownTracker>>()
7382

7483
const boot = (input: LoadInput & { directory: string }) =>
7584
Effect.gen(function* () {
@@ -133,34 +142,50 @@ const layer: Layer.Layer<Service, never, Project.Service | InstanceBootstrap.Ser
133142

134143
const disposeContext = Effect.fn("InstanceStore.disposeContext")(function* (ctx: InstanceContext, entry?: Entry) {
135144
yield* Effect.logInfo("disposing instance", { directory: ctx.directory })
145+
// Track every directory-global teardown, including one started for a context that was never
146+
// cached (`dispose` on a foreign context), so a concurrent `reload` cannot boot a
147+
// replacement while its disposers still run (NEW-V13-06).
148+
const tracker: TeardownTracker = entry ?? { teardown: Deferred.makeUnsafe<void>(), teardownStarted: false }
136149
const teardown = yield* Effect.sync(() => {
137150
const promise = runDisposers(ctx.directory)
138-
if (entry) {
139-
entry.teardownStarted = true
140-
const pending = teardowns.get(ctx.directory) ?? new Set<Entry>()
141-
pending.add(entry)
142-
teardowns.set(ctx.directory, pending)
143-
const settle = () => {
144-
const active = teardowns.get(ctx.directory)
145-
if (active) {
146-
active.delete(entry)
147-
if (active.size === 0) teardowns.delete(ctx.directory)
148-
}
149-
Deferred.doneUnsafe(entry.teardown, Effect.void)
151+
tracker.teardownStarted = true
152+
const pending = teardowns.get(ctx.directory) ?? new Set<TeardownTracker>()
153+
pending.add(tracker)
154+
teardowns.set(ctx.directory, pending)
155+
const settle = () => {
156+
const active = teardowns.get(ctx.directory)
157+
if (active) {
158+
active.delete(tracker)
159+
if (active.size === 0) teardowns.delete(ctx.directory)
150160
}
151-
promise.then(settle, settle)
161+
Deferred.doneUnsafe(tracker.teardown, Effect.void)
152162
}
163+
promise.then(settle, settle)
153164
return promise
154165
})
155166
yield* Effect.promise(() => teardown)
156167
yield* emitDisposed({ directory: ctx.directory, project: ctx.project.id })
157168
})
158169

170+
// Bounded so a disposer that never settles cannot wedge the directory forever
171+
// (REGRESSION-V13-01): past the bound the replacement boots anyway and the deviation is
172+
// logged. The normal interrupted-teardown path still waits for the real disposers
173+
// (NEW-V12-06). `load`/`provide` stay ungated on purpose (REGRESSION-2 fast-alive).
174+
const TEARDOWN_DRAIN_TIMEOUT_MS = 2_000
159175
const awaitTeardowns = (directory: string) =>
160176
Effect.gen(function* () {
161-
const pending = teardowns.get(directory)
162-
if (!pending || pending.size === 0) return
163-
yield* Effect.forEach([...pending], (entry) => Deferred.await(entry.teardown), { discard: true })
177+
const deadline = Date.now() + TEARDOWN_DRAIN_TIMEOUT_MS
178+
while (teardowns.has(directory)) {
179+
const pending = [...(teardowns.get(directory) ?? [])]
180+
if (pending.length === 0) return
181+
const settled = yield* Effect.forEach(pending, (tracker) => Deferred.isDone(tracker.teardown))
182+
if (settled.every(Boolean)) return
183+
if (Date.now() >= deadline) {
184+
yield* Effect.logWarning("instance teardown did not settle before reload", { directory: directory })
185+
return
186+
}
187+
yield* Effect.sleep("25 millis")
188+
}
164189
})
165190

166191
// Release a claimed entry: drop it from the cache (only if it is still the cached one, so a

‎packages/opencode/test/project/instance.test.ts‎

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -678,6 +678,92 @@ describe("InstanceStore", () => {
678678
30_000,
679679
)
680680

681+
it.live(
682+
"a stalled disposer does not wedge reload or provide (REGRESSION-V13-01)",
683+
() =>
684+
Effect.gen(function* () {
685+
const dir = yield* tmpdirScoped({ git: true })
686+
const store = yield* InstanceStore.Service
687+
const events: string[] = []
688+
let releaseDisposer: () => void = () => {}
689+
const gate = new Promise<void>((resolve) => {
690+
releaseDisposer = resolve
691+
})
692+
yield* registerDisposerScoped(async () => {
693+
events.push("dispose-start")
694+
await gate
695+
events.push("dispose-end")
696+
})
697+
yield* setBootstrap(
698+
Effect.sync(() => {
699+
events.push("boot")
700+
}),
701+
)
702+
703+
const first = yield* store.load({ directory: dir })
704+
const disposing = yield* store.dispose(first).pipe(Effect.forkScoped)
705+
yield* Effect.sleep("150 millis")
706+
yield* Fiber.interrupt(disposing)
707+
708+
// The stalled disposer may delay the replacement only up to the teardown bound; it must
709+
// never leave the directory wedged.
710+
const reloaded = yield* store.reload({ directory: dir }).pipe(Effect.timeoutOption("8 seconds"))
711+
expect(Option.isSome(reloaded)).toBe(true)
712+
713+
const alive = yield* store
714+
.provide({ directory: dir }, Effect.succeed("alive" as const))
715+
.pipe(Effect.timeoutOption("4 seconds"))
716+
expect(Option.isSome(alive)).toBe(true)
717+
718+
// Once the stalled disposer finally settles, the directory recovers fully.
719+
releaseDisposer()
720+
yield* Effect.gen(function* () {
721+
while (!events.includes("dispose-end")) yield* Effect.sleep("25 millis")
722+
}).pipe(Effect.timeoutOption("4 seconds"))
723+
expect(events.includes("dispose-end")).toBe(true)
724+
}),
725+
30_000,
726+
)
727+
728+
it.live(
729+
"reload serializes with a teardown from an uncached dispose (NEW-V13-06)",
730+
() =>
731+
Effect.gen(function* () {
732+
const dir = yield* tmpdirScoped({ git: true })
733+
const store = yield* InstanceStore.Service
734+
const events: string[] = []
735+
yield* registerDisposerScoped(async () => {
736+
events.push("dispose-start")
737+
await new Promise((resolve) => setTimeout(resolve, 400))
738+
events.push("dispose-end")
739+
})
740+
yield* setBootstrap(
741+
Effect.sync(() => {
742+
events.push("boot")
743+
}),
744+
)
745+
746+
const first = yield* store.load({ directory: dir })
747+
// The first dispose runs the cached path; afterwards the entry has left the cache, so the
748+
// second dispose tears down through `disposeContext` without an entry.
749+
yield* store.dispose(first)
750+
events.length = 0
751+
752+
const disposing = yield* store.dispose(first).pipe(Effect.forkScoped)
753+
yield* Effect.gen(function* () {
754+
while (!events.includes("dispose-start")) yield* Effect.sleep("10 millis")
755+
}).pipe(Effect.timeoutOption("2 seconds"))
756+
757+
const reloaded = yield* store.reload({ directory: dir }).pipe(Effect.timeoutOption("10 seconds"))
758+
expect(Option.isSome(reloaded)).toBe(true)
759+
yield* Fiber.join(disposing)
760+
761+
// The replacement must boot only after the uncached teardown's disposers settle.
762+
expect(events).toEqual(["dispose-start", "dispose-end", "boot"])
763+
}),
764+
30_000,
765+
)
766+
681767
it.live(
682768
"never uses a disposed context under concurrent provide/dispose (W5/F4a)",
683769
() =>

0 commit comments

Comments
 (0)