opencode-discord-bot 0.0.1

package/src/Opencode/SdkOpencodeFailures.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test"
+import { Effect, Stream } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { makeSdkOpencode } from "./SdkOpencode.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+const options = { baseUrl: "http://127.0.0.1:4096", projectDir: "/repo" }
+
+describe("makeSdkOpencode failure paths", () => {
+  test("maps prompt attachment preparation failures", async () => {
+    const originalFetch = globalThis.fetch
+    const failingFetch: typeof fetch = Object.assign(() => Promise.reject(new Error("network down")), {
+      preconnect: () => {}
+    })
+    globalThis.fetch = failingFetch
+    const client = {
+      session: {
+        create: () => Promise.resolve({ data: { id: "session-1" }, error: undefined }),
+        promptAsync: () => Promise.resolve({ data: {}, error: undefined }),
+        abort: () => Promise.resolve({ data: {}, error: undefined })
+      },
+      event: {
+        subscribe: () => Promise.resolve({ stream: (async function* () {})() })
+      },
+      global: {
+        health: () => Promise.resolve({ data: { ok: true }, error: undefined })
+      }
+    }
+
+    const opencode = makeSdkOpencode(client, options)
+
+    try {
+      await expect(
+        opencode
+          .runPrompt({
+            prompt: "hello",
+            projectDir: "/repo",
+            scope,
+            parts: [{ type: "file", mime: "image/png", filename: "shot.png", url: "https://cdn/shot.png" }]
+          })
+          .pipe(Stream.runCollect, Effect.runPromise)
+      ).rejects.toMatchObject({ _tag: "OpencodeError", message: "failed to fetch image attachment shot.png: network down" })
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+
+  test("propagates SSE stream failures", async () => {
+    const client = {
+      session: {
+        create: () => Promise.resolve({ data: { id: "session-1" }, error: undefined }),
+        promptAsync: () => Promise.resolve({ data: {}, error: undefined }),
+        abort: () => Promise.resolve({ data: {}, error: undefined })
+      },
+      event: {
+        subscribe: () =>
+          Promise.resolve({
+            stream: (async function* () {
+              yield { type: "session.next.text.delta", properties: { sessionID: "session-1", delta: "ok" } }
+              throw new Error("stream blew up")
+            })()
+          })
+      },
+      global: {
+        health: () => Promise.resolve({ data: { ok: true }, error: undefined })
+      }
+    }
+
+    const opencode = makeSdkOpencode(client, options)
+
+    await expect(
+      opencode.runPrompt({ prompt: "hello", projectDir: "/repo", scope }).pipe(Stream.runCollect, Effect.runPromise)
+    ).rejects.toMatchObject({ _tag: "OpencodeError", message: "stream blew up" })
+  })
+
+  test("maps abort failures on an active session", async () => {
+    let releaseStream: (() => void) | undefined
+    const waiting = new Promise<void>((resolve) => {
+      releaseStream = resolve
+    })
+    const client = {
+      session: {
+        create: () => Promise.resolve({ data: { id: "session-1" }, error: undefined }),
+        promptAsync: () => Promise.resolve({ data: {}, error: undefined }),
+        abort: () => Promise.resolve({ data: undefined, error: "abort failed" })
+      },
+      event: {
+        subscribe: () =>
+          Promise.resolve({
+            stream: (async function* () {
+              yield { type: "session.next.text.delta", properties: { sessionID: "session-1", delta: "ok" } }
+              await waiting
+            })()
+          })
+      },
+      global: {
+        health: () => Promise.resolve({ data: { ok: true }, error: undefined })
+      }
+    }
+
+    const opencode = makeSdkOpencode(client, options)
+    const running = Effect.runPromise(opencode.runPrompt({ prompt: "hello", projectDir: "/repo", scope }).pipe(Stream.runDrain))
+    await new Promise((resolve) => setTimeout(resolve, 0))
+
+    await expect(opencode.abort(scope).pipe(Stream.runDrain, Effect.runPromise)).rejects.toMatchObject({
+      _tag: "OpencodeError",
+      message: "abort failed"
+    })
+
+    releaseStream?.()
+    await running.catch(() => {})
+  })
+})

package/src/Orchestrator/ContextAssembly.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from "bun:test"
+import type { DiscordMessage } from "../Schema.ts"
+import { assembleContextPrompt, formatDiscordMessage } from "./ContextAssembly.ts"
+
+const makeMessage = (id: string, content: string, extra: Partial<DiscordMessage> = {}): DiscordMessage => ({
+  id,
+  guildId: "g1",
+  channelId: "c1",
+  author: { id: `u-${id}`, displayName: `User ${id}`, nickname: `Nick ${id}`, isBot: false },
+  content,
+  timestamp: "2026-06-05T14:03:00.000Z",
+  mentions: [],
+  roleMentions: [],
+  everyoneMention: false,
+  hereMention: false,
+  attachments: [],
+  reactions: [],
+  channelType: "guild",
+  ...extra
+})
+
+describe("context assembly", () => {
+  test("renders the structured Discord envelope", () => {
+    const rendered = formatDiscordMessage(
+      makeMessage("1", "Can you refactor this?", {
+        attachments: [{ id: "a1", filename: "screenshot.png", contentType: "image/png", size: 12, url: "https://cdn/a1" }],
+        reactions: [
+          { emoji: "thumbs_up", count: 2 },
+          { emoji: "tada", count: 1 }
+        ]
+      })
+    )
+
+    expect(rendered).toContain("[Nick 1 | <@u-1> | 2026-06-05 14:03 UTC]")
+    expect(rendered).toContain("Can you refactor this?")
+    expect(rendered).toContain("(discord target: guildId=g1 channelId=c1 messageId=1)")
+    expect(rendered).toContain("(attachments: screenshot.png [image/png; 12 bytes; https://cdn/a1])")
+    expect(rendered).toContain("(reactions: thumbs_up x2, tada x1)")
+  })
+
+  test("dedupes context and includes the triggering message exactly once at the end", () => {
+    const trigger = makeMessage("3", "latest <@999>", { mentions: ["999"] })
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [makeMessage("1", "older"), trigger, makeMessage("2", "middle"), trigger],
+      triggerMessage: trigger,
+      maxMessages: 30,
+      maxChars: 10_000,
+      maxAttachmentBytes: 10_000
+    })
+
+    expect(prompt.messages.map((item) => item.id)).toEqual(["1", "2", "3"])
+    expect(prompt.text.match(/latest <@999>/g)).toHaveLength(1)
+    expect(prompt.text).toContain("<@id> pings that user in Discord")
+    expect(prompt.text).toContain("Use discord target metadata when calling bridge tools")
+    expect(prompt.text).toContain("Do not emit @everyone, @here, or role pings")
+  })
+
+  test("applies top-N and character budgets without dropping the trigger", () => {
+    const trigger = makeMessage("5", "trigger")
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [makeMessage("1", "one"), makeMessage("2", "two"), makeMessage("3", "three"), makeMessage("4", "four")],
+      triggerMessage: trigger,
+      maxMessages: 3,
+      maxChars: 250,
+      maxAttachmentBytes: 10_000
+    })
+
+    expect(prompt.messages.at(-1)?.id).toBe("5")
+    expect(prompt.messages.length).toBeLessThanOrEqual(3)
+    expect(prompt.text.length).toBeLessThanOrEqual(250)
+  })
+
+  test("surfaces queued intermediate messages before the latest trigger", () => {
+    const skipped = makeMessage("2", "intermediate <@999>", { mentions: ["999"] })
+    const trigger = makeMessage("3", "latest <@999>", { mentions: ["999"] })
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [makeMessage("1", "older"), skipped, trigger],
+      skippedMessages: [skipped],
+      triggerMessage: trigger,
+      maxMessages: 3,
+      maxChars: 10_000,
+      maxAttachmentBytes: 10_000
+    })
+
+    expect(prompt.messages.map((item) => item.id)).toEqual(["1", "2", "3"])
+    expect(prompt.text).toContain("(queued intermediate message)")
+    expect(prompt.text.indexOf("intermediate <@999>")).toBeLessThan(prompt.text.indexOf("latest <@999>"))
+  })
+
+  test("creates opencode file parts for supported attachments under the configured cap", () => {
+    const trigger = makeMessage("1", "see files", {
+      attachments: [
+        { id: "a1", filename: "screenshot.png", contentType: "image/png", size: 12, url: "https://cdn/screenshot.png" },
+        { id: "a2", filename: "movie.mp4", contentType: "video/mp4", size: 12, url: "https://cdn/movie.mp4" },
+        { id: "a3", filename: "large.pdf", contentType: "application/pdf", size: 100, url: "https://cdn/large.pdf" }
+      ]
+    })
+
+    const prompt = assembleContextPrompt({
+      botUserId: "999",
+      contextMessages: [trigger],
+      triggerMessage: trigger,
+      maxMessages: 30,
+      maxChars: 10_000,
+      maxAttachmentBytes: 50
+    })
+
+    expect(prompt.parts).toEqual([{ type: "file", mime: "image/png", filename: "screenshot.png", url: "https://cdn/screenshot.png" }])
+    expect(prompt.text).toContain("movie.mp4 [video/mp4; 12 bytes; https://cdn/movie.mp4]")
+    expect(prompt.text).toContain("large.pdf [application/pdf; 100 bytes; https://cdn/large.pdf]")
+  })
+})

package/src/Orchestrator/ContextAssembly.ts

@@ -0,0 +1,120 @@
+import type { OpencodePromptFilePart } from "../Opencode/OpencodePort.ts"
+import type { DiscordMessage } from "../Schema.ts"
+
+export type ContextPrompt = {
+  readonly text: string
+  readonly messages: ReadonlyArray<DiscordMessage>
+  readonly parts: ReadonlyArray<OpencodePromptFilePart>
+}
+
+type ContextInput = {
+  readonly botUserId: string
+  readonly contextMessages: ReadonlyArray<DiscordMessage>
+  readonly triggerMessage: DiscordMessage
+  readonly skippedMessages?: ReadonlyArray<DiscordMessage> | undefined
+  readonly maxMessages: number
+  readonly maxChars: number
+  readonly maxAttachmentBytes: number
+}
+
+const preamble = (botUserId: string) =>
+  `Discord bridge context for <@${botUserId}>. <@id> pings that user in Discord. Use discord target metadata when calling bridge tools. Do not emit @everyone, @here, or role pings unless explicitly allowed.`
+
+const timestamp = (value: string): string => {
+  const date = new Date(value)
+  const year = date.getUTCFullYear()
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0")
+  const day = String(date.getUTCDate()).padStart(2, "0")
+  const hour = String(date.getUTCHours()).padStart(2, "0")
+  const minute = String(date.getUTCMinutes()).padStart(2, "0")
+  return `${year}-${month}-${day} ${hour}:${minute} UTC`
+}
+
+const attachmentSummary = (message: DiscordMessage): string | undefined => {
+  if (message.attachments.length === 0) return undefined
+  return `(attachments: ${message.attachments
+    .map((item) => `${item.filename} [${item.contentType ?? "unknown"}; ${item.size} bytes; ${item.url}]`)
+    .join(", ")})`
+}
+
+const reactionSummary = (message: DiscordMessage): string | undefined => {
+  if (message.reactions.length === 0) return undefined
+  return `(reactions: ${message.reactions.map((item) => `${item.emoji} x${item.count}`).join(", ")})`
+}
+
+const targetSummary = (message: DiscordMessage): string => {
+  const thread = message.threadId === undefined ? "" : ` threadId=${message.threadId}`
+  return `(discord target: guildId=${message.guildId} channelId=${message.channelId}${thread} messageId=${message.id})`
+}
+
+const isForwardableMime = (mime: string): boolean =>
+  mime.startsWith("image/") || mime === "application/pdf" || mime.startsWith("audio/") || mime.startsWith("text/")
+
+const attachmentParts = (messages: ReadonlyArray<DiscordMessage>, maxBytes: number): ReadonlyArray<OpencodePromptFilePart> =>
+  messages.flatMap((message) =>
+    message.attachments.flatMap((attachment) => {
+      const mime = attachment.contentType
+      if (mime === undefined || attachment.size > maxBytes || !isForwardableMime(mime)) return []
+      return [{ type: "file", mime, filename: attachment.filename, url: attachment.url } satisfies OpencodePromptFilePart]
+    })
+  )
+
+export const formatDiscordMessage = (message: DiscordMessage): string => {
+  const label = message.author.nickname ?? message.author.displayName
+  const lines = [`[${label} | <@${message.author.id}> | ${timestamp(message.timestamp)}]`, message.content]
+  lines.push(targetSummary(message))
+  const attachments = attachmentSummary(message)
+  const reactions = reactionSummary(message)
+  if (attachments !== undefined) lines.push(attachments)
+  if (reactions !== undefined) lines.push(reactions)
+  return lines.join("\n")
+}
+
+const dedupeContext = (input: ContextInput): ReadonlyArray<DiscordMessage> => {
+  const seen = new Set<string>()
+  const context: Array<DiscordMessage> = []
+  const maxMessages = Math.max(1, input.maxMessages)
+  const skipped = (input.skippedMessages ?? [])
+    .filter((message) => message.id !== input.triggerMessage.id)
+    .filter((message) => {
+      if (seen.has(message.id)) return false
+      seen.add(message.id)
+      return true
+    })
+    .slice(-Math.max(0, maxMessages - 1))
+  const skippedIds = new Set(skipped.map((message) => message.id))
+  for (const message of input.contextMessages) {
+    if (message.id === input.triggerMessage.id || skippedIds.has(message.id) || seen.has(message.id)) continue
+    seen.add(message.id)
+    context.push(message)
+  }
+  const retainedLimit = Math.max(0, maxMessages - skipped.length - 1)
+  const retained = context.slice(Math.max(0, context.length - retainedLimit))
+  return [...retained, ...skipped, input.triggerMessage]
+}
+
+const renderPrompt = (
+  botUserId: string,
+  messages: ReadonlyArray<DiscordMessage>,
+  skippedMessages: ReadonlyArray<DiscordMessage>
+): string => {
+  const skippedIds = new Set(skippedMessages.map((message) => message.id))
+  return [
+    preamble(botUserId),
+    ...messages.map((message) => `${skippedIds.has(message.id) ? "(queued intermediate message)\n" : ""}${formatDiscordMessage(message)}`)
+  ].join("\n\n")
+}
+
+export const assembleContextPrompt = (input: ContextInput): ContextPrompt => {
+  const skippedMessages = input.skippedMessages ?? []
+  const messages = [...dedupeContext(input)]
+  while (messages.length > 1 && renderPrompt(input.botUserId, messages, skippedMessages).length > input.maxChars) {
+    messages.shift()
+  }
+  const text = renderPrompt(input.botUserId, messages, skippedMessages)
+  return {
+    messages,
+    parts: attachmentParts(messages, input.maxAttachmentBytes),
+    text: text.length <= input.maxChars ? text : text.slice(0, input.maxChars)
+  }
+}

package/src/Orchestrator/Orchestrator.ts

@@ -0,0 +1,67 @@
+import { Effect } from "effect"
+import type { RuntimeConfig } from "../Config.ts"
+import type { DiscordService } from "../Discord/DiscordPort.ts"
+import type { OpencodeService } from "../Opencode/OpencodePort.ts"
+import { renderOpencodeEvents } from "../Render/Renderer.ts"
+import type { BotIdentity, DiscordMessage } from "../Schema.ts"
+import { assembleContextPrompt } from "./ContextAssembly.ts"
+import { isThreadActiveFromContext, shouldTriggerTurn, toDiscordScope } from "./Triggering.ts"
+
+type HandleOptions = {
+  readonly bot: BotIdentity
+  readonly config: RuntimeConfig
+  readonly discord: DiscordService
+  readonly opencode: OpencodeService
+}
+
+type HandleResult = {
+  readonly handled: boolean
+}
+
+const redactError = (message: string): string => message.replace(/secret[-_a-z0-9]*/gi, "[redacted]")
+
+export const handleDiscordMessage = Effect.fn("handleDiscordMessage")(function* (
+  message: DiscordMessage,
+  options: HandleOptions,
+  skippedMessages: ReadonlyArray<DiscordMessage> = []
+) {
+  const scope = toDiscordScope(message)
+  const directTrigger = shouldTriggerTurn(message, options.bot, false)
+  let context: ReadonlyArray<DiscordMessage> | undefined
+  let activeThread = false
+
+  if (!directTrigger && message.threadId !== undefined && options.config.threads.activeByRecentBotParticipation) {
+    context = yield* options.discord.fetchContext(scope, options.config.context.messages)
+    activeThread = isThreadActiveFromContext(context, options.bot)
+  }
+
+  if (!shouldTriggerTurn(message, options.bot, activeThread)) return { handled: false } satisfies HandleResult
+
+  const contextMessages = context ?? (yield* options.discord.fetchContext(scope, options.config.context.messages))
+  const prompt = assembleContextPrompt({
+    botUserId: options.bot.userId,
+    contextMessages,
+    triggerMessage: message,
+    skippedMessages,
+    maxMessages: options.config.context.messages,
+    maxChars: options.config.context.maxChars,
+    maxAttachmentBytes: options.config.context.attachmentMaxBytes
+  })
+
+  const events = options.opencode.runPrompt({
+    prompt: prompt.text,
+    parts: prompt.parts,
+    projectDir: options.config.opencode.projectDir,
+    scope,
+    ...(options.config.opencode.model === undefined ? {} : { model: options.config.opencode.model }),
+    ...(options.config.opencode.agent === undefined ? {} : { agent: options.config.opencode.agent })
+  })
+
+  yield* renderOpencodeEvents(events, scope, options.config, options.discord).pipe(
+    Effect.catchTag("OpencodeError", (error) =>
+      options.discord.postMessage(scope, `opencode is unavailable or returned an error: ${redactError(error.message)}`)
+    )
+  )
+
+  return { handled: true } satisfies HandleResult
+})

package/src/Orchestrator/StopCommand.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { makeMemoryOpencode } from "../Opencode/MemoryOpencode.ts"
+import type { DiscordScope } from "../Schema.ts"
+import { handleStopCommand } from "./StopCommand.ts"
+import { createTurnManager } from "./TurnManager.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+describe("handleStopCommand", () => {
+  test("posts a no-active-turn response when there is no transient handle", async () => {
+    const discord = makeMemoryDiscord()
+    const manager = createTurnManager(makeMemoryOpencode([]), discord)
+
+    await Effect.runPromise(handleStopCommand(scope, manager, discord))
+
+    expect(discord.messages).toEqual([{ scope, content: "There is no known active turn in this process." }])
+  })
+})

package/src/Orchestrator/StopCommand.ts

@@ -0,0 +1,14 @@
+import { Effect } from "effect"
+import type { DiscordService } from "../Discord/DiscordPort.ts"
+import type { DiscordScope } from "../Schema.ts"
+import type { TurnManager } from "./TurnManager.ts"
+
+export const handleStopCommand = Effect.fn("handleStopCommand")(function* (
+  scope: DiscordScope,
+  turns: TurnManager,
+  discord: DiscordService
+) {
+  const result = yield* turns.stop(scope)
+  const content = result.stopped ? "Stopped the active turn." : "There is no known active turn in this process."
+  yield* discord.postMessage(scope, content)
+})

package/src/Orchestrator/Triggering.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test"
+import type { BotIdentity, DiscordMessage } from "../Schema.ts"
+import { isThreadActiveFromContext, shouldTriggerTurn, toDiscordScope } from "./Triggering.ts"
+
+const bot: BotIdentity = { userId: "999" }
+
+const message = (overrides: Partial<DiscordMessage> = {}): DiscordMessage => ({
+  id: "m1",
+  guildId: "g1",
+  channelId: "c1",
+  author: { id: "123", displayName: "Alice", isBot: false },
+  content: "hello <@999>",
+  timestamp: "2026-06-05T14:03:00.000Z",
+  mentions: ["999"],
+  roleMentions: [],
+  everyoneMention: false,
+  hereMention: false,
+  attachments: [],
+  reactions: [],
+  channelType: "guild",
+  ...overrides
+})
+
+describe("shouldTriggerTurn", () => {
+  test("direct guild mention triggers in the same channel scope", () => {
+    const input = message()
+
+    expect(shouldTriggerTurn(input, bot, false)).toBe(true)
+    expect(toDiscordScope(input)).toEqual({ guildId: "g1", channelId: "c1" })
+  })
+
+  test("thread mention triggers in the thread scope", () => {
+    const input = message({ threadId: "t1" })
+
+    expect(shouldTriggerTurn(input, bot, false)).toBe(true)
+    expect(toDiscordScope(input)).toEqual({ guildId: "g1", channelId: "c1", threadId: "t1" })
+  })
+
+  test("ignores DMs, bots, self, system messages, and mass mentions", () => {
+    expect(shouldTriggerTurn(message({ channelType: "dm" }), bot, false)).toBe(false)
+    expect(shouldTriggerTurn(message({ author: { id: "321", displayName: "Bot", isBot: true } }), bot, false)).toBe(false)
+    expect(shouldTriggerTurn(message({ author: { id: "999", displayName: "Self", isBot: true } }), bot, false)).toBe(false)
+    expect(shouldTriggerTurn(message({ isSystem: true }), bot, false)).toBe(false)
+    expect(
+      shouldTriggerTurn(message({ content: "@everyone", mentions: [], everyoneMention: true, roleMentions: ["role1"] }), bot, false)
+    ).toBe(false)
+  })
+
+  test("active thread follow-ups can trigger without a repeated mention", () => {
+    const followUp = message({ content: "continue", mentions: [], threadId: "t1" })
+    const context = [message({ id: "m0", author: { id: "999", displayName: "Bridge", isBot: true }, threadId: "t1" })]
+
+    expect(isThreadActiveFromContext(context, bot)).toBe(true)
+    expect(shouldTriggerTurn(followUp, bot, true)).toBe(true)
+  })
+})

package/src/Orchestrator/Triggering.ts

@@ -0,0 +1,26 @@
+import type { BotIdentity, DiscordMessage, DiscordScope } from "../Schema.ts"
+
+export const toDiscordScope = (message: DiscordMessage): DiscordScope => ({
+  guildId: message.guildId,
+  channelId: message.channelId,
+  ...(message.threadId === undefined ? {} : { threadId: message.threadId })
+})
+
+const isDirectMention = (message: DiscordMessage, bot: BotIdentity): boolean => message.mentions.includes(bot.userId)
+
+const canConsiderMessage = (message: DiscordMessage, bot: BotIdentity): boolean => {
+  if (message.channelType === "dm") return false
+  if (message.isSystem === true) return false
+  if (message.author.id === bot.userId) return false
+  if (message.author.isBot) return false
+  return true
+}
+
+export const shouldTriggerTurn = (message: DiscordMessage, bot: BotIdentity, activeThread: boolean): boolean => {
+  if (!canConsiderMessage(message, bot)) return false
+  if (isDirectMention(message, bot)) return true
+  return message.threadId !== undefined && activeThread
+}
+
+export const isThreadActiveFromContext = (messages: ReadonlyArray<DiscordMessage>, bot: BotIdentity): boolean =>
+  messages.some((message) => message.threadId !== undefined && (message.author.id === bot.userId || isDirectMention(message, bot)))