opencode-discord-bot 0.0.1

package/src/Orchestrator/TurnManager.test.ts

@@ -0,0 +1,180 @@
+import { describe, expect, test } from "bun:test"
+import { Deferred, Duration, Effect, Fiber, Ref, Stream } from "effect"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { makeMemoryOpencode } from "../Opencode/MemoryOpencode.ts"
+import { OpencodeError, type OpencodeService } from "../Opencode/OpencodePort.ts"
+import type { DiscordScope } from "../Schema.ts"
+import { createTurnManager } from "./TurnManager.ts"
+
+const channelScope: DiscordScope = { guildId: "g1", channelId: "c1" }
+const threadScope: DiscordScope = { guildId: "g1", channelId: "c1", threadId: "t1" }
+
+describe("TurnManager", () => {
+  test("serializes work per Discord scope and allows different scopes in parallel", async () => {
+    const order = await Effect.runPromise(
+      Effect.gen(function* () {
+        const manager = createTurnManager(makeMemoryOpencode([]), makeMemoryDiscord())
+        const firstStarted = yield* Deferred.make<void>()
+        const releaseFirst = yield* Deferred.make<void>()
+        const seen = yield* Ref.make<ReadonlyArray<string>>([])
+
+        const first = yield* manager
+          .runExclusive(
+            channelScope,
+            Effect.gen(function* () {
+              yield* Ref.update(seen, (values) => [...values, "same-1-start"])
+              yield* Deferred.succeed(firstStarted, void 0)
+              yield* Deferred.await(releaseFirst)
+              yield* Ref.update(seen, (values) => [...values, "same-1-end"])
+            })
+          )
+          .pipe(Effect.forkChild)
+
+        yield* Deferred.await(firstStarted)
+        const second = yield* manager
+          .runExclusive(
+            channelScope,
+            Ref.update(seen, (values) => [...values, "same-2"])
+          )
+          .pipe(Effect.forkChild)
+        const parallel = yield* manager
+          .runExclusive(
+            threadScope,
+            Ref.update(seen, (values) => [...values, "other-scope"])
+          )
+          .pipe(Effect.forkChild)
+
+        yield* Fiber.join(parallel)
+        expect(yield* Ref.get(seen)).toEqual(["same-1-start", "other-scope"])
+
+        yield* Deferred.succeed(releaseFirst, void 0)
+        yield* Fiber.join(first)
+        yield* Fiber.join(second)
+        return yield* Ref.get(seen)
+      })
+    )
+
+    expect(order).toEqual(["same-1-start", "other-scope", "same-1-end", "same-2"])
+  })
+
+  test("/stop interrupts the active turn fiber, calls opencode abort, and clears transient state", async () => {
+    const opencode = makeMemoryOpencode([])
+    const manager = createTurnManager(opencode, makeMemoryDiscord())
+
+    const result = await Effect.runPromise(
+      Effect.gen(function* () {
+        const started = yield* Deferred.make<void>()
+        const finalizerRan = yield* Ref.make(false)
+        const fiber = yield* manager.startTurn(
+          channelScope,
+          "session-1",
+          Effect.gen(function* () {
+            yield* Deferred.succeed(started, void 0)
+            yield* Effect.never
+          }).pipe(Effect.ensuring(Ref.set(finalizerRan, true)))
+        )
+
+        yield* Deferred.await(started)
+        expect(yield* manager.isActive(channelScope)).toBe(true)
+        const stop = yield* manager.stop(channelScope)
+        yield* Fiber.await(fiber)
+        return { stop, finalizerRan: yield* Ref.get(finalizerRan), active: yield* manager.isActive(channelScope) }
+      })
+    )
+
+    expect(result).toEqual({ stop: { stopped: true }, finalizerRan: true, active: false })
+    expect(opencode.aborted).toEqual(["c1"])
+  })
+
+  test("clears active turns that finish before callers can stop them", async () => {
+    const opencode = makeMemoryOpencode([])
+    const manager = createTurnManager(opencode, makeMemoryDiscord())
+
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const fiber = yield* manager.startTurn(channelScope, "session-1", Effect.void)
+        yield* Fiber.join(fiber)
+        expect(yield* manager.isActive(channelScope)).toBe(false)
+      })
+    )
+
+    expect(opencode.aborted).toEqual([])
+  })
+
+  test("honors the optional global active-turn cap across scopes", async () => {
+    const order = await Effect.runPromise(
+      Effect.gen(function* () {
+        const manager = createTurnManager(makeMemoryOpencode([]), makeMemoryDiscord(), { globalMaxActiveTurns: 1 })
+        const firstStarted = yield* Deferred.make<void>()
+        const releaseFirst = yield* Deferred.make<void>()
+        const seen = yield* Ref.make<ReadonlyArray<string>>([])
+
+        const first = yield* manager
+          .runExclusive(
+            channelScope,
+            Effect.gen(function* () {
+              yield* Ref.update(seen, (values) => [...values, "first-start"])
+              yield* Deferred.succeed(firstStarted, void 0)
+              yield* Deferred.await(releaseFirst)
+              yield* Ref.update(seen, (values) => [...values, "first-end"])
+            })
+          )
+          .pipe(Effect.forkChild)
+
+        yield* Deferred.await(firstStarted)
+        const second = yield* manager
+          .runExclusive(
+            threadScope,
+            Ref.update(seen, (values) => [...values, "second"])
+          )
+          .pipe(Effect.forkChild)
+        expect(yield* Ref.get(seen)).toEqual(["first-start"])
+
+        yield* Deferred.succeed(releaseFirst, void 0)
+        yield* Fiber.join(first)
+        yield* Fiber.join(second)
+        return yield* Ref.get(seen)
+      })
+    )
+
+    expect(order).toEqual(["first-start", "first-end", "second"])
+  })
+
+  test("aborts and clears turns that exceed the configured max duration", async () => {
+    const opencode = makeMemoryOpencode([])
+    const manager = createTurnManager(opencode, makeMemoryDiscord(), { maxTurn: Duration.millis(1) })
+
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const fiber = yield* manager.startTurn(channelScope, "session-1", Effect.never)
+        yield* Fiber.await(fiber)
+        expect(yield* manager.isActive(channelScope)).toBe(false)
+      })
+    )
+
+    expect(opencode.aborted).toEqual(["c1"])
+  })
+
+  test("still clears timed-out turns when opencode abort fails", async () => {
+    const opencode: OpencodeService = {
+      checkHealth: Effect.void,
+      runPrompt: () => Stream.empty,
+      abort: () => Stream.fail(new OpencodeError({ message: "abort failed" }))
+    }
+    const manager = createTurnManager(opencode, makeMemoryDiscord(), { maxTurn: Duration.millis(1) })
+
+    await Effect.runPromise(
+      Effect.gen(function* () {
+        const fiber = yield* manager.startTurn(channelScope, "session-1", Effect.never)
+        yield* Fiber.await(fiber)
+        expect(yield* manager.isActive(channelScope)).toBe(false)
+      })
+    )
+  })
+
+  test("/stop reports when this process has no active turn", async () => {
+    const manager = createTurnManager(makeMemoryOpencode([]), makeMemoryDiscord())
+
+    await expect(Effect.runPromise(manager.stop(channelScope))).resolves.toEqual({ stopped: false, reason: "no-active-turn" })
+  })
+})

package/src/Orchestrator/TurnManager.ts

@@ -0,0 +1,179 @@
+import { Deferred, type Duration, Effect, Fiber, Semaphore, Stream } from "effect"
+import type { DiscordService } from "../Discord/DiscordPort.ts"
+import type { OpencodeService } from "../Opencode/OpencodePort.ts"
+import type { DiscordScope } from "../Schema.ts"
+
+type ActiveTurn = {
+  readonly scope: DiscordScope
+  readonly sessionId?: string | undefined
+  readonly fiber: Fiber.Fiber<void, never>
+}
+
+type PendingTurn = {
+  readonly scope: DiscordScope
+  readonly sessionId?: string | undefined
+  readonly effect: Effect.Effect<void, never>
+}
+
+type StopResult = { readonly stopped: true } | { readonly stopped: false; readonly reason: "no-active-turn" }
+
+export type TurnManager = {
+  readonly runExclusive: <A, E, R>(scope: DiscordScope, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  readonly startTurn: (
+    scope: DiscordScope,
+    sessionId: string | undefined,
+    effect: Effect.Effect<void, never>
+  ) => Effect.Effect<Fiber.Fiber<void, never>>
+  readonly stop: (scope: DiscordScope) => Effect.Effect<StopResult>
+  readonly isActive: (scope: DiscordScope) => Effect.Effect<boolean>
+}
+
+export type TurnManagerOptions = {
+  readonly strategy?: "queue" | "burst" | undefined
+  readonly globalMaxActiveTurns?: number | null | undefined
+  readonly maxTurn?: Duration.Duration | null | undefined
+}
+
+const scopeKey = (scope: DiscordScope): string => scope.threadId ?? scope.channelId
+
+export const createTurnManager = (opencode: OpencodeService, _discord: DiscordService, options: TurnManagerOptions = {}): TurnManager => {
+  const locks = new Map<string, Semaphore.Semaphore>()
+  const activeTurns = new Map<string, ActiveTurn>()
+  const queuedTurns = new Map<string, PendingTurn>()
+  const currentFibers = new Map<string, Fiber.Fiber<void, never>>()
+  const waitingTurns = new Map<string, Set<Fiber.Fiber<void, never>>>()
+  const globalLock =
+    options.globalMaxActiveTurns === undefined || options.globalMaxActiveTurns === null
+      ? undefined
+      : Semaphore.makeUnsafe(Math.max(1, Math.floor(options.globalMaxActiveTurns)))
+
+  const lockFor = (scope: DiscordScope): Semaphore.Semaphore => {
+    const key = scopeKey(scope)
+    const existing = locks.get(key)
+    if (existing !== undefined) return existing
+    const next = Semaphore.makeUnsafe(1)
+    locks.set(key, next)
+    return next
+  }
+
+  const withGlobalLimit = <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => globalLock?.withPermit(effect) ?? effect
+
+  const withMaxTurn = (scope: DiscordScope, effect: Effect.Effect<void, never>): Effect.Effect<void, never> => {
+    if (options.maxTurn === undefined || options.maxTurn === null) return effect
+    return effect.pipe(
+      Effect.timeoutOrElse({
+        duration: options.maxTurn,
+        orElse: () =>
+          opencode.abort(scope).pipe(
+            Stream.runDrain,
+            Effect.catch(() => Effect.void)
+          )
+      })
+    )
+  }
+
+  const runExclusive: TurnManager["runExclusive"] = (scope, effect) => withGlobalLimit(lockFor(scope).withPermit(effect))
+
+  const hasWaitingTurn = (key: string): boolean => (waitingTurns.get(key)?.size ?? 0) > 0
+
+  const addWaitingTurn = (key: string, fiber: Fiber.Fiber<void, never>): void => {
+    const waiting = waitingTurns.get(key) ?? new Set<Fiber.Fiber<void, never>>()
+    waiting.add(fiber)
+    waitingTurns.set(key, waiting)
+  }
+
+  const removeWaitingTurn = (key: string, fiber: Fiber.Fiber<void, never>): void => {
+    const waiting = waitingTurns.get(key)
+    if (waiting === undefined) return
+    waiting.delete(fiber)
+    if (waiting.size === 0) waitingTurns.delete(key)
+  }
+
+  const completeTurn = (key: string, fiber: Fiber.Fiber<void, never>): Effect.Effect<void> =>
+    Effect.gen(function* () {
+      yield* Effect.sync(() => removeWaitingTurn(key, fiber))
+      if (activeTurns.get(key)?.fiber === fiber) activeTurns.delete(key)
+      const queued = queuedTurns.get(key)
+      if (queued === undefined) {
+        if (currentFibers.get(key) === fiber) currentFibers.delete(key)
+        return
+      }
+      queuedTurns.delete(key)
+      yield* launchTurn(queued).pipe(Effect.asVoid)
+    })
+
+  const launchTurn = Effect.fn("launchTurn")(function* (turn: PendingTurn) {
+    const key = scopeKey(turn.scope)
+    const startGate = yield* Deferred.make<void>()
+    const self = yield* Deferred.make<Fiber.Fiber<void, never>>()
+    const fiber = yield* Effect.gen(function* () {
+      yield* Deferred.await(startGate)
+      const current = yield* Deferred.await(self)
+      yield* runExclusive(
+        turn.scope,
+        Effect.gen(function* () {
+          yield* Effect.sync(() => {
+            removeWaitingTurn(key, current)
+            activeTurns.set(key, { scope: turn.scope, sessionId: turn.sessionId, fiber: current })
+          })
+          yield* withMaxTurn(turn.scope, turn.effect)
+        })
+      )
+    })
+      .pipe(Effect.ensuring(Deferred.await(self).pipe(Effect.flatMap((current) => completeTurn(key, current)))))
+      .pipe(Effect.forkDetach)
+
+    yield* Effect.sync(() => {
+      addWaitingTurn(key, fiber)
+      currentFibers.set(key, fiber)
+    })
+    yield* Deferred.succeed(self, fiber)
+    yield* Deferred.succeed(startGate, void 0)
+    return fiber
+  })
+
+  const startTurn: TurnManager["startTurn"] = (scope, sessionId, effect) =>
+    Effect.gen(function* () {
+      const key = scopeKey(scope)
+      const turn = { scope, sessionId, effect } satisfies PendingTurn
+      const current = currentFibers.get(key)
+      if (current !== undefined && options.strategy !== "burst") {
+        queuedTurns.set(key, turn)
+        return current
+      }
+      return yield* launchTurn(turn)
+    })
+
+  const stop: TurnManager["stop"] = (scope) =>
+    Effect.gen(function* () {
+      const key = scopeKey(scope)
+      const active = activeTurns.get(key)
+      const waiting = [...(waitingTurns.get(key) ?? [])]
+      const queued = queuedTurns.get(key)
+      if (active === undefined && waiting.length === 0 && queued === undefined) return { stopped: false, reason: "no-active-turn" } as const
+
+      activeTurns.delete(key)
+      queuedTurns.delete(key)
+      currentFibers.delete(key)
+      waitingTurns.delete(key)
+      if (active !== undefined) {
+        yield* opencode.abort(active.scope).pipe(
+          Stream.runDrain,
+          Effect.catch(() => Effect.void)
+        )
+        yield* Fiber.interrupt(active.fiber)
+      }
+      for (const fiber of waiting) {
+        yield* Fiber.interrupt(fiber).pipe(Effect.catch(() => Effect.void))
+      }
+      return { stopped: true } as const
+    })
+
+  const isActive: TurnManager["isActive"] = (scope) =>
+    Effect.sync(() => {
+      const key = scopeKey(scope)
+      return activeTurns.has(key) || currentFibers.has(key) || hasWaitingTurn(key) || queuedTurns.has(key)
+    })
+
+  return { runExclusive, startTurn, stop, isActive }
+}

package/src/Orchestrator/TurnManagerStrategy.test.ts

@@ -0,0 +1,136 @@
+import { expect, test } from "bun:test"
+import { Deferred, Effect, Fiber, Ref } from "effect"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { makeMemoryOpencode } from "../Opencode/MemoryOpencode.ts"
+import type { DiscordScope } from "../Schema.ts"
+import { createTurnManager } from "./TurnManager.ts"
+
+const channelScope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+test("queue strategy keeps only the latest pending turn per Discord scope", async () => {
+  const order = await Effect.runPromise(
+    Effect.gen(function* () {
+      const manager = createTurnManager(makeMemoryOpencode([]), makeMemoryDiscord(), { strategy: "queue" })
+      const firstStarted = yield* Deferred.make<void>()
+      const releaseFirst = yield* Deferred.make<void>()
+      const thirdRan = yield* Deferred.make<void>()
+      const seen = yield* Ref.make<ReadonlyArray<string>>([])
+
+      const first = yield* manager.startTurn(
+        channelScope,
+        "session-1",
+        Effect.gen(function* () {
+          yield* Ref.update(seen, (values) => [...values, "first"])
+          yield* Deferred.succeed(firstStarted, void 0)
+          yield* Deferred.await(releaseFirst)
+        })
+      )
+      yield* Deferred.await(firstStarted)
+
+      const second = yield* manager.startTurn(
+        channelScope,
+        "session-2",
+        Ref.update(seen, (values) => [...values, "second"])
+      )
+      const third = yield* manager.startTurn(
+        channelScope,
+        "session-3",
+        Effect.gen(function* () {
+          yield* Ref.update(seen, (values) => [...values, "third"])
+          yield* Deferred.succeed(thirdRan, void 0)
+        })
+      )
+
+      expect(second).toBe(first)
+      expect(third).toBe(first)
+
+      yield* Deferred.succeed(releaseFirst, void 0)
+      yield* Fiber.join(first)
+      yield* Deferred.await(thirdRan)
+      return yield* Ref.get(seen)
+    })
+  )
+
+  expect(order).toEqual(["first", "third"])
+})
+
+test("burst strategy serializes every started turn for a busy scope", async () => {
+  const order = await Effect.runPromise(
+    Effect.gen(function* () {
+      const manager = createTurnManager(makeMemoryOpencode([]), makeMemoryDiscord(), { strategy: "burst" })
+      const firstStarted = yield* Deferred.make<void>()
+      const releaseFirst = yield* Deferred.make<void>()
+      const seen = yield* Ref.make<ReadonlyArray<string>>([])
+
+      const first = yield* manager.startTurn(
+        channelScope,
+        "session-1",
+        Effect.gen(function* () {
+          yield* Ref.update(seen, (values) => [...values, "first"])
+          yield* Deferred.succeed(firstStarted, void 0)
+          yield* Deferred.await(releaseFirst)
+        })
+      )
+      yield* Deferred.await(firstStarted)
+
+      const second = yield* manager.startTurn(
+        channelScope,
+        "session-2",
+        Ref.update(seen, (values) => [...values, "second"])
+      )
+      const third = yield* manager.startTurn(
+        channelScope,
+        "session-3",
+        Ref.update(seen, (values) => [...values, "third"])
+      )
+
+      expect(second).not.toBe(first)
+      expect(third).not.toBe(first)
+
+      yield* Deferred.succeed(releaseFirst, void 0)
+      yield* Fiber.join(first)
+      yield* Fiber.join(second)
+      yield* Fiber.join(third)
+      return yield* Ref.get(seen)
+    })
+  )
+
+  expect(order).toEqual(["first", "second", "third"])
+})
+
+test("stop cancels active and waiting burst turns for the same scope", async () => {
+  const opencode = makeMemoryOpencode([])
+  const result = await Effect.runPromise(
+    Effect.gen(function* () {
+      const manager = createTurnManager(opencode, makeMemoryDiscord(), { strategy: "burst" })
+      const firstStarted = yield* Deferred.make<void>()
+      const firstFinalized = yield* Ref.make(false)
+      const secondStarted = yield* Ref.make(false)
+
+      const first = yield* manager.startTurn(
+        channelScope,
+        "session-1",
+        Effect.gen(function* () {
+          yield* Deferred.succeed(firstStarted, void 0)
+          yield* Effect.never
+        }).pipe(Effect.ensuring(Ref.set(firstFinalized, true)))
+      )
+      yield* Deferred.await(firstStarted)
+      const second = yield* manager.startTurn(channelScope, "session-2", Ref.set(secondStarted, true))
+
+      const stop = yield* manager.stop(channelScope)
+      yield* Fiber.await(first)
+      yield* Fiber.await(second)
+
+      return {
+        active: yield* manager.isActive(channelScope),
+        firstFinalized: yield* Ref.get(firstFinalized),
+        secondStarted: yield* Ref.get(secondStarted),
+        stop
+      }
+    })
+  )
+
+  expect(result).toEqual({ active: false, firstFinalized: true, secondStarted: false, stop: { stopped: true } })
+  expect(opencode.aborted).toEqual(["c1"])
+})

package/src/PublicContracts.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { makeLiveChatSdkDiscord } from "./Discord/ChatSdkDiscord.ts"
+import { Discord } from "./Discord/DiscordPort.ts"
+import { makeMemoryDiscord } from "./Discord/MemoryDiscord.ts"
+import { makeMemoryOpencode } from "./Opencode/MemoryOpencode.ts"
+import { Opencode } from "./Opencode/OpencodePort.ts"
+import { makeLiveSdkOpencode } from "./Opencode/SdkOpencode.ts"
+import type { DiscordAuthor, DiscordReaction, Snowflake, ToolTarget } from "./Schema.ts"
+import { ToolTargetSchema } from "./Schema.ts"
+
+describe("public contracts", () => {
+  test("keeps Effect service tags and live adapter factories exported", () => {
+    expect(Discord).toBeDefined()
+    expect(Opencode).toBeDefined()
+    expect(makeLiveChatSdkDiscord({ botToken: "token", applicationId: "123", publicKey: "0".repeat(64) })).toBeDefined()
+    expect(makeLiveSdkOpencode({ baseUrl: "http://127.0.0.1:4096", projectDir: "/repo" })).toBeDefined()
+    expect(ToolTargetSchema).toBeDefined()
+  })
+
+  test("provides and retrieves Effect service tags", async () => {
+    const discord = makeMemoryDiscord()
+    const opencode = makeMemoryOpencode([])
+
+    const services = await Effect.gen(function* () {
+      return { discord: yield* Discord, opencode: yield* Opencode }
+    }).pipe(Effect.provideService(Discord, discord), Effect.provideService(Opencode, opencode), Effect.runPromise)
+
+    expect(services.discord).toBe(discord)
+    expect(services.opencode).toBe(opencode)
+  })
+
+  test("keeps exported schema-adjacent types usable", () => {
+    const snowflake: Snowflake = "123"
+    const author: DiscordAuthor = { id: snowflake, displayName: "Alice", isBot: false }
+    const reaction: DiscordReaction = { emoji: "rocket", count: 1 }
+    const target: ToolTarget = { guildId: "g1", channelId: "c1" }
+
+    expect(author.id).toBe("123")
+    expect(reaction.count).toBe(1)
+    expect(target.channelId).toBe("c1")
+  })
+})