Something went wrong. Try again.
opencode v2 mirror
Something went wrong. Try again.
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306import { expect } from "bun:test"import { Deferred, Effect, Exit, Fiber, Schema } from "effect"import { Bus } from "@opencode/core/bus"import { Command } from "@opencode/core/command"import { Plugin } from "@opencode/core/plugin"import { PluginHooks } from "@opencode/core/plugin/hooks"import { Rpc } from "@opencode/core/rpc"import { testEffect } from "./lib/effect"import { PluginTestLayer } from "./plugin/fixture"
const it = testEffect(PluginTestLayer)
it.live("removes a failed plugin's hooks and RPC handlers without affecting healthy plugins", () => Effect.gen(function* () { const plugins = yield* Plugin.Service const commands = yield* Command.Service const hooks = yield* PluginHooks.Service const rpc = yield* Rpc.Service const cleaned = yield* Deferred.make<void>() const invoked: string[] = [] let fail = false yield* plugins.activate( ["broken", "healthy"].map((id) => ({ id, revision: "1", effect: (ctx) => Effect.gen(function* () { // Finalizers run in reverse order, so this signals after registration cleanup. if (id === "broken") yield* Effect.addFinalizer(() => Deferred.succeed(cleaned, undefined)) yield* ctx.command.transform((editor) => { editor.add({ name: id, execute: () => Effect.void }) if (id === "broken" && fail) throw new Error("transform failed") }) yield* ctx.shell.hook("create.before", () => Effect.sync(() => void invoked.push(id))) yield* ctx.rpc .register( Rpc.define({ id, methods: { check: { input: Schema.Struct({}), output: Schema.String } }, events: {} }), { check: () => Effect.succeed(id) }, ) .pipe(Effect.orDie) if (id === "broken") yield* Effect.addFinalizer(() => plugins.awaitActivation) }), })), ) const trigger = hooks.trigger("shell", "create.before", { command: "echo fixture", cwd: ".", timeout: 1_000, shell: "sh", env: {}, }) yield* trigger expect(invoked).toEqual(["broken", "healthy"]) expect(yield* rpc.call("broken", "check", {})).toBe("broken") expect(yield* rpc.call("healthy", "check", {})).toBe("healthy") expect((yield* commands.list()).map((command) => command.name)).toEqual(["broken", "healthy"])
fail = true yield* commands.reload() yield* Deferred.await(cleaned).pipe(Effect.timeout("1 second")) invoked.length = 0 yield* trigger expect(invoked).toEqual(["healthy"]) expect(yield* rpc.call("broken", "check", {}).pipe(Effect.flip)).toMatchObject({ type: "rpc.unavailable" }) expect(yield* rpc.call("healthy", "check", {})).toBe("healthy") expect((yield* commands.list()).map((command) => command.name)).toEqual(["healthy"]) expect((yield* plugins.list()).map((plugin) => plugin.state.status)).toEqual(["failed", "active"]) }),)
Array.of("reload", "teardown").forEach((boundary) => it.live(`does not join queued failed-plugin cleanup during ${boundary}`, () => Effect.gen(function* () { const plugins = yield* Plugin.Service const commands = yield* Command.Service const entered = yield* Deferred.make<void>() const escape = yield* Deferred.make<void>() const cleaned = yield* Deferred.make<void>() let fail = false yield* plugins.activate([ { id: "changing", revision: "1", effect: (ctx) => Effect.gen(function* () { yield* ctx.command.transform((editor) => { editor.add({ name: "changing", description: "old", execute: () => Effect.void }) if (fail) throw new Error("changing failed") }) yield* Effect.addFinalizer(() => Deferred.succeed(entered, undefined).pipe( Effect.andThen(plugins.awaitActivation.pipe(Effect.raceFirst(Deferred.await(escape)))), Effect.andThen(Deferred.succeed(cleaned, undefined)), ), ) }), }, { id: "trigger", revision: "1", effect: () => Effect.addFinalizer(() => boundary === "teardown" ? commands.reload().pipe(Effect.andThen(commands.list()), Effect.asVoid) : Effect.void, ), }, ]) fail = true const activation = yield* (boundary === "reload" ? commands.reload() : Effect.void).pipe( Effect.andThen( plugins.activate([ { id: "changing", revision: "2", effect: (ctx) => ctx.command .transform((editor) => editor.add({ name: "changing", description: "new", execute: () => Effect.void }), ) .pipe(Effect.asVoid), }, ]), ), Effect.forkChild({ startImmediately: true }), ) yield* Deferred.await(entered) const result = yield* Fiber.join(activation).pipe(Effect.timeout("250 millis"), Effect.exit) // Allow teardown to finish even if activation incorrectly joins the old finalizer. yield* Deferred.succeed(escape, undefined) yield* Fiber.join(activation) yield* plugins.awaitActivation yield* Deferred.await(cleaned) expect(Exit.isSuccess(result)).toBe(true) expect((yield* plugins.list())[0]?.state).toEqual({ status: "active" }) expect(yield* commands.get("changing")).toMatchObject({ description: "new" }) }), ),)
it.live("does not restore a disabled generation with a pending failure when its replacement fails setup", () => Effect.gen(function* () { const plugins = yield* Plugin.Service const commands = yield* Command.Service const loads: string[] = [] let fail = false const generation = (revision: string): Plugin.Generation => ({ id: "replacement", revision, effect: (ctx) => Effect.gen(function* () { loads.push(revision) if (revision === "2") yield* Effect.die("setup failed") yield* ctx.command.transform((editor) => { editor.add({ name: "replacement", execute: () => Effect.void }) if (fail) throw new Error("replay failed") }) }), }) yield* plugins.activate([generation("1")]) fail = true yield* commands.reload() yield* plugins.activate([generation("2")]) yield* plugins.awaitActivation expect(loads).toEqual(["1", "2"]) expect((yield* plugins.list())[0]?.state.status).toBe("failed") expect(yield* commands.get("replacement")).toBeUndefined() }),)
Array.of("pending", "reported").forEach((status) => it.live(`preserves ${status} failures when an earlier plugin changes`, () => Effect.gen(function* () { const plugins = yield* Plugin.Service const commands = yield* Command.Service const loads: string[] = [] let fail = true const generation = (id: string, revision: string): Plugin.Generation => ({ id, revision, effect: (ctx) => Effect.gen(function* () { loads.push(`${id}@${revision}`) yield* ctx.command.transform((editor) => { editor.add({ name: id, execute: () => Effect.void }) if (id === "broken" && fail) throw new Error("broken failed") }) }), }) const broken = generation("broken", "1") const later = generation("later", "1") yield* plugins.activate([generation("earlier", "1"), broken, later]) if (status === "reported") yield* plugins.awaitActivation fail = false yield* plugins.activate([generation("earlier", "2"), broken, later]) yield* plugins.awaitActivation expect(loads).toEqual(["earlier@1", "broken@1", "later@1", "earlier@2", "later@1"]) const failed = (yield* plugins.list())[1]?.state expect(failed).toMatchObject({ status: "failed", ref: expect.stringMatching(/^err_/) }) expect((yield* commands.list()).map((entry) => entry.name)).toEqual(["earlier", "later"])
// Reordering and removing other plugins must preserve the same failure too. yield* plugins.activate([later, broken, generation("earlier", "2")]) yield* plugins.awaitActivation expect((yield* plugins.list())[1]?.state).toEqual(failed) expect((yield* commands.list()).map((entry) => entry.name)).toEqual(["later", "earlier"]) yield* plugins.activate([broken, later]) yield* plugins.awaitActivation expect((yield* plugins.list())[0]?.state).toEqual(failed) expect(loads.filter((entry) => entry === "broken@1")).toHaveLength(1)
yield* plugins.activate([generation("broken", "2"), later]) yield* plugins.awaitActivation expect((yield* plugins.list())[0]?.state).toEqual({ status: "active" }) expect(yield* commands.get("broken")).toBeDefined() expect(loads.filter((entry) => entry === "broken@2")).toHaveLength(1) }), ),)
it.live("continues failure reporting and cleanup after a plugin update observer fails", () => Effect.gen(function* () { const plugins = yield* Plugin.Service const commands = yield* Command.Service const bus = yield* Bus.Service const cleaned: string[] = [] let fail = false let failPublication = true yield* plugins.activate( ["first", "second"].map((id) => ({ id, revision: "1", effect: (ctx) => Effect.gen(function* () { yield* Effect.addFinalizer(() => Effect.sync(() => void cleaned.push(id))) yield* ctx.command.transform((editor) => { editor.add({ name: id, execute: () => Effect.void }) if (fail) throw new Error(`${id} failed`) }) }), })), ) yield* Effect.acquireRelease( bus.listen((event) => { if (event.type !== Plugin.Event.Updated.type || !failPublication) return Effect.void failPublication = false return Effect.die("observer failed") }), (unsubscribe) => unsubscribe, ) fail = true yield* commands.reload() const ready = yield* plugins.awaitActivation.pipe(Effect.timeout("250 millis"), Effect.exit) expect(Exit.isSuccess(ready)).toBe(true) expect((yield* plugins.list()).map((entry) => entry.state.status)).toEqual(["failed", "failed"]) expect(cleaned.toSorted()).toEqual(["first", "second"]) expect(yield* commands.list()).toEqual([]) }),)
it.live("settles readiness before shutdown joins a disabled plugin's finalizers", () => Effect.gen(function* () { const plugins = yield* Plugin.Service const commands = yield* Command.Service const entered = yield* Deferred.make<void>() const escape = yield* Deferred.make<void>() let fail = false yield* plugins.activate([ { id: "closing", revision: "1", effect: (ctx) => Effect.gen(function* () { yield* ctx.command.transform((editor) => { editor.add({ name: "closing", execute: () => Effect.void }) if (fail) throw new Error("closing failed") }) yield* Effect.addFinalizer(() => Deferred.succeed(entered, undefined).pipe( Effect.andThen(plugins.awaitActivation.pipe(Effect.raceFirst(Deferred.await(escape)))), ), ) }), }, ]) fail = true const shutdown = yield* commands .reload() .pipe(Effect.andThen(plugins.close(Exit.void)), Effect.forkChild({ startImmediately: true })) yield* Deferred.await(entered) const result = yield* Fiber.join(shutdown).pipe(Effect.timeout("250 millis"), Effect.exit) // Release the fixture even on the old implementation, rather than hanging test teardown. yield* Deferred.succeed(escape, undefined) yield* Fiber.join(shutdown) expect(Exit.isSuccess(result)).toBe(true) const release = yield* plugins.hold() yield* plugins.awaitActivation let restarted = false yield* plugins.activate([ { id: "after-close", revision: "1", effect: () => Effect.sync(() => void (restarted = true)) }, ]) yield* release expect(restarted).toBe(false) }),)