opencode-discord-bot 0.0.1

package/src/Discord/DiscordGateway.test.ts

@@ -0,0 +1,215 @@
+import { describe, expect, test } from "bun:test"
+import { Events, GatewayIntentBits, Partials } from "discord.js"
+import { Effect } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import {
+  contextReactionPartials,
+  type DiscordGatewayClient,
+  makeDiscordGatewayClient,
+  requiredGatewayIntents,
+  startDiscordGateway
+} from "./DiscordGateway.ts"
+
+const collection = <A>(items: ReadonlyArray<A>) => ({ values: () => items[Symbol.iterator]() })
+
+class FakeGatewayClient implements DiscordGatewayClient {
+  readonly user: { readonly id: string } | null
+  readonly channels = { fetch: () => Promise.resolve(null) }
+  readonly createdCommands: Array<readonly [{ readonly name: string; readonly description: string }, string | undefined]> = []
+  readonly application = {
+    commands: {
+      create: (command: { readonly name: string; readonly description: string }, guildId?: string) => {
+        this.createdCommands.push([command, guildId])
+        return Promise.resolve({})
+      }
+    }
+  }
+  readonly listeners = new Map<string, Array<(value: unknown) => void>>()
+  destroyed = false
+
+  constructor(user: { readonly id: string } | null = { id: "bot-1" }) {
+    this.user = user
+  }
+
+  on(event: string, listener: (value: unknown) => void): DiscordGatewayClient {
+    this.listeners.set(event, [...(this.listeners.get(event) ?? []), listener])
+    return this
+  }
+
+  once(event: string, listener: (value: unknown) => void): DiscordGatewayClient {
+    const wrapped = (value: unknown) => {
+      this.listeners.set(
+        event,
+        (this.listeners.get(event) ?? []).filter((item) => item !== wrapped)
+      )
+      listener(value)
+    }
+    return this.on(event, wrapped)
+  }
+
+  emit(event: string, value: unknown): void {
+    for (const listener of this.listeners.get(event) ?? []) listener(value)
+  }
+
+  login(): Promise<string> {
+    this.emit(Events.ClientReady, this)
+    return Promise.resolve("token")
+  }
+
+  destroy(): Promise<void> {
+    this.destroyed = true
+    return Promise.resolve()
+  }
+}
+
+const message = (
+  overrides: {
+    readonly channel?: {
+      readonly id: string
+      readonly parentId?: string | null
+      readonly isDMBased?: () => boolean
+      readonly isThread?: () => boolean
+    }
+    readonly guildId?: string | null
+    readonly channelId?: string
+    readonly authorBot?: boolean
+  } = {}
+) => ({
+  id: "m1",
+  guildId: overrides.guildId ?? "g1",
+  channelId: overrides.channelId ?? "c1",
+  channel: overrides.channel ?? { id: "c1", isDMBased: () => false, isThread: () => false },
+  author: { id: "u1", username: "alice", displayName: "Alice", bot: overrides.authorBot ?? false },
+  member: { nickname: "ali" },
+  content: "hello <@bot-1>",
+  createdAt: new Date("2026-06-05T14:03:00.000Z"),
+  mentions: { users: collection([{ id: "bot-1" }]), roles: collection([{ id: "r1" }]), everyone: false },
+  attachments: collection([{ id: "a1", name: "a.txt", contentType: "text/plain", size: 1, url: "https://example.test/a.txt" }]),
+  reactions: { cache: collection([{ emoji: { name: "rocket", identifier: "rocket" }, count: 2 }]) },
+  system: false,
+  inGuild: () => overrides.guildId !== null
+})
+
+describe("Discord gateway constants", () => {
+  test("requests guild message intents but no DM intents", () => {
+    expect(requiredGatewayIntents).toEqual([
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.GuildMessageReactions
+    ])
+    expect(requiredGatewayIntents.includes(GatewayIntentBits.DirectMessages)).toBe(false)
+    expect(contextReactionPartials).toEqual([Partials.Message, Partials.Reaction, Partials.User])
+  })
+
+  test("constructs the production discord.js client", () => {
+    const client = makeDiscordGatewayClient()
+
+    expect(client).toBeDefined()
+    client.destroy()
+  })
+})
+
+describe("startDiscordGateway", () => {
+  test("logs in, registers stop, maps guild messages, and destroys on scope close", async () => {
+    const client = new FakeGatewayClient()
+    const messages: Array<unknown> = []
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const gateway = yield* startDiscordGateway({
+            token: "token",
+            guildId: "g1",
+            createClient: () => client,
+            onMessage: (item, bot) => Effect.sync(() => messages.push({ item, bot })),
+            onStop: () => Effect.void
+          })
+
+          client.emit(Events.MessageCreate, message())
+          yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 0)))
+
+          expect(gateway.bot).toEqual({ userId: "bot-1" })
+          expect(client.createdCommands[0]).toEqual([
+            { name: "stop", description: "Stop the active opencode turn in this Discord scope." },
+            "g1"
+          ])
+          expect(messages).toEqual([
+            {
+              bot: { userId: "bot-1" },
+              item: {
+                id: "m1",
+                guildId: "g1",
+                channelId: "c1",
+                author: { id: "u1", displayName: "Alice", nickname: "ali", isBot: false },
+                content: "hello <@bot-1>",
+                timestamp: "2026-06-05T14:03:00.000Z",
+                mentions: ["bot-1"],
+                roleMentions: ["r1"],
+                everyoneMention: false,
+                hereMention: false,
+                attachments: [{ id: "a1", filename: "a.txt", contentType: "text/plain", size: 1, url: "https://example.test/a.txt" }],
+                reactions: [{ emoji: "rocket", count: 2 }],
+                channelType: "guild",
+                isSystem: false
+              }
+            }
+          ])
+        })
+      )
+    )
+
+    expect(client.destroyed).toBe(true)
+  })
+
+  test("preserves thread scopes, ignores DMs, and dispatches slash stop", async () => {
+    const client = new FakeGatewayClient()
+    const messages: Array<unknown> = []
+    const stops: Array<DiscordScope> = []
+    let replied = false
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          yield* startDiscordGateway({
+            token: "token",
+            createClient: () => client,
+            onMessage: (item) => Effect.sync(() => messages.push(item)),
+            onStop: (scope) => Effect.sync(() => stops.push(scope))
+          })
+
+          client.emit(Events.MessageCreate, message({ channelId: "t1", channel: { id: "t1", parentId: "c1", isThread: () => true } }))
+          client.emit(Events.MessageCreate, message({ guildId: null, channel: { id: "dm1", isDMBased: () => true } }))
+          client.emit(Events.InteractionCreate, {
+            commandName: "stop",
+            guildId: "g1",
+            channelId: "t1",
+            channel: { id: "t1", parentId: "c1", isThread: () => true },
+            isChatInputCommand: () => true,
+            inGuild: () => true,
+            reply: () => {
+              replied = true
+              return Promise.resolve({})
+            }
+          })
+          client.emit(Events.InteractionCreate, {
+            commandName: "stop",
+            guildId: "g1",
+            channelId: "t2",
+            channel: { id: "t2", isThread: () => true },
+            isChatInputCommand: () => true,
+            inGuild: () => true
+          })
+          yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 0)))
+
+          expect(messages).toEqual([expect.objectContaining({ guildId: "g1", channelId: "c1", threadId: "t1" })])
+          expect(stops).toEqual([
+            { guildId: "g1", channelId: "c1", threadId: "t1" },
+            { guildId: "g1", channelId: "t2", threadId: "t2" }
+          ])
+          expect(replied).toBe(true)
+        })
+      )
+    )
+  })
+})

package/src/Discord/DiscordGateway.ts

@@ -0,0 +1,140 @@
+import { Client, Events, GatewayIntentBits, Partials } from "discord.js"
+import { Effect } from "effect"
+import type { BotIdentity, DiscordMessage, DiscordScope } from "../Schema.ts"
+import { type DiscordJsChannelLike, type DiscordJsClientLike, type DiscordJsMessageLike, fromDiscordJsMessage } from "./DiscordJsDiscord.ts"
+
+export const requiredGatewayIntents: ReadonlyArray<GatewayIntentBits> = [
+  GatewayIntentBits.Guilds,
+  GatewayIntentBits.GuildMessages,
+  GatewayIntentBits.MessageContent,
+  GatewayIntentBits.GuildMessageReactions
+] as const
+
+export const contextReactionPartials: ReadonlyArray<Partials> = [Partials.Message, Partials.Reaction, Partials.User]
+
+type InteractionLike = {
+  readonly commandName: string
+  readonly guildId: string | null
+  readonly channelId: string | null
+  readonly channel: DiscordJsChannelLike | null
+  readonly isChatInputCommand: () => boolean
+  readonly inGuild?: () => boolean
+  readonly reply?: (input: { readonly content: string; readonly ephemeral: boolean }) => Promise<unknown>
+}
+
+export type DiscordGatewayClient = DiscordJsClientLike & {
+  readonly application: {
+    readonly commands: {
+      readonly create: (command: { readonly name: string; readonly description: string }, guildId?: string) => Promise<unknown>
+    }
+  } | null
+  readonly on: (event: string, listener: (value: unknown) => void) => DiscordGatewayClient
+  readonly once: (event: string, listener: (value: unknown) => void) => DiscordGatewayClient
+  readonly login: (token?: string) => Promise<string>
+  readonly destroy: () => Promise<void> | void
+}
+
+export type DiscordGateway = {
+  readonly bot: BotIdentity
+  readonly client: DiscordGatewayClient
+}
+
+export type DiscordGatewayOptions = {
+  readonly token: string
+  readonly guildId?: string | undefined
+  readonly createClient?: (() => DiscordGatewayClient) | undefined
+  readonly onMessage: (message: DiscordMessage, bot: BotIdentity) => Effect.Effect<void, unknown>
+  readonly onStop: (scope: DiscordScope, bot: BotIdentity) => Effect.Effect<void, unknown>
+}
+
+const stopCommand = {
+  name: "stop",
+  description: "Stop the active opencode turn in this Discord scope."
+} as const
+
+export const makeDiscordGatewayClient = (): DiscordGatewayClient =>
+  new Client({
+    intents: [...requiredGatewayIntents],
+    partials: [...contextReactionPartials]
+  })
+
+const runCallback = (effect: Effect.Effect<void, unknown>): void => {
+  void Effect.runPromise(effect.pipe(Effect.catch((error) => Effect.logError(`Discord gateway handler failed: ${String(error)}`))))
+}
+
+const botFromReady = (ready: unknown, client: DiscordGatewayClient): BotIdentity => {
+  const candidate = typeof ready === "object" && ready !== null && "user" in ready ? ready.user : client.user
+  if (typeof candidate === "object" && candidate !== null && "id" in candidate && typeof candidate.id === "string")
+    return { userId: candidate.id }
+  if (client.user !== null) return { userId: client.user.id }
+  throw new Error("Discord gateway became ready without a bot user id")
+}
+
+const interactionScope = (interaction: InteractionLike): DiscordScope | undefined => {
+  if (interaction.inGuild?.() === false || interaction.guildId === null || interaction.channelId === null) return undefined
+  const channel = interaction.channel
+  if (channel?.isDMBased?.() === true) return undefined
+  if (channel?.isThread?.() === true) {
+    return { guildId: interaction.guildId, channelId: channel.parentId ?? interaction.channelId, threadId: interaction.channelId }
+  }
+  return { guildId: interaction.guildId, channelId: interaction.channelId }
+}
+
+const isInteraction = (value: unknown): value is InteractionLike =>
+  typeof value === "object" &&
+  value !== null &&
+  "isChatInputCommand" in value &&
+  typeof value.isChatInputCommand === "function" &&
+  "commandName" in value &&
+  typeof value.commandName === "string"
+
+const isGatewayMessage = (value: unknown): value is DiscordJsMessageLike =>
+  typeof value === "object" && value !== null && "author" in value && "mentions" in value && "channel" in value
+
+const registerStopCommand = (client: DiscordGatewayClient, guildId: string | undefined): Effect.Effect<void> =>
+  Effect.tryPromise({
+    try: async () => {
+      if (client.application === null) return
+      await client.application.commands.create(stopCommand, guildId)
+    },
+    catch: () => undefined
+  }).pipe(Effect.catch(() => Effect.void))
+
+export const startDiscordGateway = Effect.fn("startDiscordGateway")(function* (options: DiscordGatewayOptions) {
+  const client = options.createClient?.() ?? makeDiscordGatewayClient()
+  const bot = yield* Effect.acquireRelease(
+    Effect.tryPromise({
+      try: async () => {
+        const ready = new Promise<BotIdentity>((resolve, reject) => {
+          client.once(Events.ClientReady, (value) => {
+            try {
+              resolve(botFromReady(value, client))
+            } catch (cause) {
+              reject(cause)
+            }
+          })
+        })
+
+        client.on(Events.MessageCreate, (raw) => {
+          if (!isGatewayMessage(raw)) return
+          const mapped = fromDiscordJsMessage(raw)
+          if (mapped !== undefined && client.user !== null) runCallback(options.onMessage(mapped, { userId: client.user.id }))
+        })
+        client.on(Events.InteractionCreate, (raw) => {
+          if (!isInteraction(raw) || !raw.isChatInputCommand() || raw.commandName !== "stop") return
+          const scope = interactionScope(raw)
+          if (scope === undefined || client.user === null) return
+          if (raw.reply !== undefined) void raw.reply({ content: "Stop request received.", ephemeral: true }).catch(() => undefined)
+          runCallback(options.onStop(scope, { userId: client.user.id }))
+        })
+        await client.login(options.token)
+        return await ready
+      },
+      catch: (cause) => (cause instanceof Error ? cause : new Error("Discord gateway startup failed"))
+    }),
+    () => Effect.promise(() => Promise.resolve(client.destroy())).pipe(Effect.catch(() => Effect.void))
+  )
+
+  yield* registerStopCommand(client, options.guildId)
+  return { bot, client } satisfies DiscordGateway
+})

package/src/Discord/DiscordGatewayFailures.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, test } from "bun:test"
+import { Events } from "discord.js"
+import { Effect } from "effect"
+import { type DiscordGatewayClient, startDiscordGateway } from "./DiscordGateway.ts"
+
+const emptyCollection = { values: () => [][Symbol.iterator]() }
+
+class FakeGatewayClient implements DiscordGatewayClient {
+  readonly channels = { fetch: () => Promise.resolve(null) }
+  readonly listeners = new Map<string, Array<(value: unknown) => void>>()
+  readonly application: DiscordGatewayClient["application"]
+
+  constructor(
+    readonly user: { readonly id: string } | null = { id: "bot-1" },
+    application: DiscordGatewayClient["application"] = { commands: { create: () => Promise.resolve({}) } }
+  ) {
+    this.application = application
+  }
+
+  on(event: string, listener: (value: unknown) => void): DiscordGatewayClient {
+    this.listeners.set(event, [...(this.listeners.get(event) ?? []), listener])
+    return this
+  }
+
+  once(event: string, listener: (value: unknown) => void): DiscordGatewayClient {
+    const wrapped = (value: unknown) => {
+      this.listeners.set(
+        event,
+        (this.listeners.get(event) ?? []).filter((item) => item !== wrapped)
+      )
+      listener(value)
+    }
+    return this.on(event, wrapped)
+  }
+
+  emit(event: string, value: unknown): void {
+    for (const listener of this.listeners.get(event) ?? []) listener(value)
+  }
+
+  login(): Promise<string> {
+    this.emit(Events.ClientReady, this)
+    return Promise.resolve("token")
+  }
+
+  destroy(): void {}
+}
+
+const message = () => ({
+  id: "m1",
+  guildId: "g1",
+  channelId: "c1",
+  channel: { id: "c1", isDMBased: () => false, isThread: () => false },
+  author: { id: "u1", username: "alice", bot: false },
+  content: "hello",
+  createdAt: new Date("2026-06-05T14:03:00.000Z"),
+  mentions: { users: emptyCollection, roles: emptyCollection, everyone: false },
+  attachments: emptyCollection,
+  reactions: { cache: emptyCollection },
+  system: false
+})
+
+describe("startDiscordGateway failure paths", () => {
+  test("falls back to the client user when ready payload has no user", async () => {
+    const client = new FakeGatewayClient()
+    client.login = () => {
+      client.emit(Events.ClientReady, {})
+      return Promise.resolve("token")
+    }
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const gateway = yield* startDiscordGateway({
+            token: "token",
+            createClient: () => client,
+            onMessage: () => Effect.void,
+            onStop: () => Effect.void
+          })
+
+          expect(gateway.bot).toEqual({ userId: "bot-1" })
+        })
+      )
+    )
+  })
+
+  test("handles callback failures and unavailable command registration", async () => {
+    const client = new FakeGatewayClient({ id: "bot-1" }, null)
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          yield* startDiscordGateway({
+            token: "token",
+            createClient: () => client,
+            onMessage: () => Effect.fail("message failed"),
+            onStop: () => Effect.fail("stop failed")
+          })
+
+          client.emit(Events.MessageCreate, message())
+          client.emit(Events.InteractionCreate, {
+            commandName: "stop",
+            guildId: "g1",
+            channelId: "c1",
+            channel: { id: "c1" },
+            isChatInputCommand: () => true,
+            inGuild: () => true
+          })
+          yield* Effect.promise(() => new Promise((resolve) => setTimeout(resolve, 0)))
+        })
+      )
+    )
+  })
+
+  test("fails startup when login fails or ready has no bot identity", async () => {
+    const loginFailure = new FakeGatewayClient()
+    loginFailure.login = () => Promise.reject(new Error("bad token"))
+    await expect(
+      Effect.runPromise(
+        Effect.scoped(
+          startDiscordGateway({
+            token: "token",
+            createClient: () => loginFailure,
+            onMessage: () => Effect.void,
+            onStop: () => Effect.void
+          })
+        )
+      )
+    ).rejects.toMatchObject({ message: "bad token" })
+
+    const missingIdentity = new FakeGatewayClient(null)
+    missingIdentity.login = () => {
+      missingIdentity.emit(Events.ClientReady, {})
+      return Promise.resolve("token")
+    }
+    await expect(
+      Effect.runPromise(
+        Effect.scoped(
+          startDiscordGateway({
+            token: "token",
+            createClient: () => missingIdentity,
+            onMessage: () => Effect.void,
+            onStop: () => Effect.void
+          })
+        )
+      )
+    ).rejects.toMatchObject({ message: "Discord gateway became ready without a bot user id" })
+  })
+})