opencode-discord-bot 0.0.1

package/src/Render/Renderer.test.ts

@@ -0,0 +1,249 @@
+import { describe, expect, test } from "bun:test"
+import { Duration, Effect, Stream } from "effect"
+import { defaultConfig } from "../Config.ts"
+import { DiscordError, type DiscordService } from "../Discord/DiscordPort.ts"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { opencodeEventStream } from "../Opencode/EventMapping.ts"
+import { OpencodeError } from "../Opencode/OpencodePort.ts"
+import type { DiscordScope } from "../Schema.ts"
+import { renderOpencodeEvents } from "./Renderer.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+describe("renderOpencodeEvents", () => {
+  test("renders snapshots, tool typing, and changed-file summaries", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([
+          { type: "tool-start", title: "Running tests" },
+          { type: "text-snapshot", text: "Done" },
+          { type: "changed-files", files: 3, insertions: 42, deletions: 7 },
+          { type: "tool-end" },
+          { type: "idle" }
+        ]),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.typingScopes).toEqual([scope])
+    expect(discord.messages).toEqual([
+      { scope, content: "Running tests..." },
+      { scope, content: "Done" }
+    ])
+    expect(discord.edits).toEqual([
+      { scope, messageId: "posted-2", content: "Done\n\nChanged: 3 files (+42/-7)" },
+      { scope, messageId: "posted-1", content: "Tool finished." }
+    ])
+  })
+
+  test("streams text by posting once and editing as deltas arrive", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([{ type: "text-delta", text: "Hel" }, { type: "text-delta", text: "lo" }, { type: "idle" }]),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.typingScopes).toEqual([scope])
+    expect(discord.messages).toEqual([{ scope, content: "Hel" }])
+    expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "Hello" }])
+  })
+
+  test("refreshes the final answer when completion stops an active typing phase", async () => {
+    const discord = makeMemoryDiscord()
+    const config = { ...defaultConfig, streaming: { ...defaultConfig.streaming, showToolStatus: false } }
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([{ type: "text-delta", text: "Done" }, { type: "tool-start", title: "Checking" }, { type: "idle" }]),
+        scope,
+        config,
+        discord
+      )
+    )
+
+    expect(discord.typingScopes).toEqual([scope, scope])
+    expect(discord.messages).toEqual([{ scope, content: "Done" }])
+    expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "Done" }])
+  })
+
+  test("starts typing before the first stream event arrives", async () => {
+    const discord = makeMemoryDiscord()
+    let releaseStream: (() => void) | undefined
+    const waiting = new Promise<void>((resolve) => {
+      releaseStream = resolve
+    })
+
+    const running = Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromAsyncIterable(
+          (async function* () {
+            await waiting
+            yield { type: "text-delta" as const, text: "Hello" }
+            yield { type: "idle" as const }
+          })(),
+          () => new OpencodeError({ message: "stream failed" })
+        ),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    await new Promise((resolve) => setTimeout(resolve, 0))
+    expect(discord.typingScopes).toEqual([scope])
+    expect(discord.messages).toEqual([])
+
+    releaseStream?.()
+    await running
+
+    expect(discord.messages).toEqual([{ scope, content: "Hello" }])
+  })
+
+  test("posts continuation messages when streamed content exceeds the Discord limit", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(Stream.fromIterable([{ type: "text-delta", text: "a".repeat(2001) }]), scope, defaultConfig, discord)
+    )
+
+    expect(discord.messages.map((item) => item.content.length)).toEqual([2000, 1])
+  })
+
+  test("deletes stale continuation messages when a later snapshot is shorter", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([
+          { type: "text-delta", text: "a".repeat(2001) },
+          { type: "text-snapshot", text: "short" }
+        ]),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.messages.map((item) => item.content.length)).toEqual([2000, 1])
+    expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "short" }])
+    expect(discord.deletes).toEqual([{ scope, messageId: "posted-2" }])
+  })
+
+  test("does not post the Discord context prompt from user message part events", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        opencodeEventStream(
+          Stream.fromIterable([
+            { type: "message.updated", properties: { sessionID: "s1", info: { id: "user-message", role: "user" } } },
+            {
+              type: "message.part.updated",
+              properties: {
+                sessionID: "s1",
+                part: { sessionID: "s1", messageID: "user-message", type: "text", text: "Discord bridge context" }
+              }
+            },
+            { type: "session.next.text.ended", properties: { sessionID: "s1", text: "Normal answer" } },
+            { type: "session.idle", properties: { sessionID: "s1" } }
+          ])
+        ),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.messages).toEqual([{ scope, content: "Normal answer" }])
+    expect(discord.edits).toEqual([])
+  })
+})
+
+describe("renderOpencodeEvents guards", () => {
+  test("can suppress changed-file summaries", async () => {
+    const discord = makeMemoryDiscord()
+    const config = { ...defaultConfig, streaming: { ...defaultConfig.streaming, changedFilesSummary: false } }
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([
+          { type: "text-delta", text: "Done" },
+          { type: "changed-files", files: 1, insertions: 1, deletions: 0 }
+        ]),
+        scope,
+        config,
+        discord
+      )
+    )
+
+    expect(discord.messages).toEqual([{ scope, content: "Done" }])
+  })
+
+  test("omits changed-file summaries when nothing changed", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(
+        Stream.fromIterable([
+          { type: "text-delta", text: "Done" },
+          { type: "changed-files", files: 0, insertions: 0, deletions: 0 },
+          { type: "idle" }
+        ]),
+        scope,
+        defaultConfig,
+        discord
+      )
+    )
+
+    expect(discord.messages).toEqual([{ scope, content: "Done" }])
+    expect(discord.edits).toEqual([])
+  })
+
+  test("neutralizes mass mentions by default", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      renderOpencodeEvents(Stream.fromIterable([{ type: "text-delta", text: "@everyone @here <@&123>" }]), scope, defaultConfig, discord)
+    )
+
+    expect(discord.messages).toEqual([{ scope, content: "@ everyone @ here <@& 123>" }])
+  })
+
+  test("honors Discord retry-after metadata when retrying output", async () => {
+    const memory = makeMemoryDiscord()
+    let attempts = 0
+    const discord: DiscordService = {
+      ...memory,
+      postMessage: (target, content) =>
+        Effect.gen(function* () {
+          attempts += 1
+          if (attempts === 1) return yield* Effect.fail(new DiscordError({ message: "rate limited", retryAfter: Duration.millis(0) }))
+          return yield* memory.postMessage(target, content)
+        })
+    }
+
+    await Effect.runPromise(
+      renderOpencodeEvents(Stream.fromIterable([{ type: "text-delta", text: "hello" }]), scope, defaultConfig, discord)
+    )
+
+    expect(attempts).toBe(2)
+    expect(memory.messages).toEqual([{ scope, content: "hello" }])
+  })
+
+  test("fails on opencode error events", async () => {
+    await expect(
+      renderOpencodeEvents(Stream.fromIterable([{ type: "error", message: "boom" }]), scope, defaultConfig, makeMemoryDiscord()).pipe(
+        Effect.runPromise
+      )
+    ).rejects.toMatchObject({ _tag: "OpencodeError", message: "boom" })
+  })
+})

package/src/Render/Renderer.ts

@@ -0,0 +1,159 @@
+import { Cause, Clock, Duration, Effect, Fiber, Schedule, Stream } from "effect"
+import type { RuntimeConfig } from "../Config.ts"
+import type { DiscordError, DiscordService } from "../Discord/DiscordPort.ts"
+import { sanitizeDiscordContent } from "../Discord/Safety.ts"
+import { OpencodeError } from "../Opencode/OpencodePort.ts"
+import type { DiscordScope, OpencodeEvent } from "../Schema.ts"
+import { splitDiscordMarkdown } from "./Splitting.ts"
+
+const changedSummary = (event: Extract<OpencodeEvent, { readonly type: "changed-files" }>) =>
+  `Changed: ${event.files} files (+${event.insertions}/-${event.deletions})`
+
+const hasChangedFiles = (event: Extract<OpencodeEvent, { readonly type: "changed-files" }>): boolean =>
+  event.files > 0 || event.insertions > 0 || event.deletions > 0
+
+type PostedChunk = {
+  readonly id: string
+  content: string
+}
+
+const discordRetrySchedule = Schedule.fromStepWithMetadata(
+  Effect.succeed((metadata: Schedule.InputMetadata<DiscordError>) => {
+    if (metadata.attempt > 2) return Cause.done(metadata.attempt)
+    const fallback = Duration.millis(250 * 2 ** (metadata.attempt - 1))
+    return Effect.succeed([metadata.attempt, metadata.input.retryAfter ?? fallback] as [number, Duration.Duration])
+  })
+)
+
+const retryDiscord = <A, R>(effect: Effect.Effect<A, DiscordError, R>): Effect.Effect<A, DiscordError, R> =>
+  effect.pipe(Effect.retry(discordRetrySchedule))
+
+export const renderOpencodeEvents = Effect.fn("renderOpencodeEvents")(function* (
+  events: Stream.Stream<OpencodeEvent, OpencodeError>,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  discord: DiscordService
+) {
+  let answer = ""
+  let changed: string | undefined
+  const posted: Array<PostedChunk> = []
+  const updateIntervalMs = Math.max(0, Duration.toMillis(config.streaming.updateInterval))
+  let lastFlushAt = Number.NEGATIVE_INFINITY
+  let typingFiber: Fiber.Fiber<void, never> | undefined
+  let status: PostedChunk | undefined
+  let finished = false
+
+  const visibleContent = () => sanitizeDiscordContent(changed === undefined ? answer : `${answer}\n\n${changed}`.trim(), config.guards)
+  const startTyping = Effect.fn("startDiscordTyping")(function* () {
+    if (typingFiber !== undefined) return
+    yield* retryDiscord(discord.sendTyping(scope)).pipe(Effect.catch(() => Effect.void))
+    typingFiber = yield* Effect.forever(
+      Effect.gen(function* () {
+        yield* Effect.sleep(Duration.seconds(8))
+        yield* retryDiscord(discord.sendTyping(scope)).pipe(Effect.catch(() => Effect.void))
+      })
+    ).pipe(Effect.forkChild({ startImmediately: true }))
+  })
+  const stopTyping = Effect.fn("stopDiscordTyping")(function* () {
+    const fiber = typingFiber
+    typingFiber = undefined
+    if (fiber === undefined) return false
+    yield* Fiber.interrupt(fiber).pipe(Effect.catch(() => Effect.void))
+    return true
+  })
+  const renderStatus = Effect.fn("renderDiscordToolStatus")(function* (content: string) {
+    if (!config.streaming.showToolStatus) return
+    const safe = sanitizeDiscordContent(content, config.guards)
+    if (status === undefined) {
+      const created = yield* retryDiscord(discord.postMessage(scope, safe))
+      status = { id: created.id, content: safe }
+    } else if (status.content !== safe) {
+      yield* retryDiscord(discord.editMessage(scope, status.id, safe))
+      status.content = safe
+    }
+  })
+  const writeChunk = Effect.fn("writeDiscordRenderChunk")(function* (index: number, chunk: string, forceEdit = false) {
+    const existing = posted[index]
+    if (existing === undefined) {
+      const created = yield* retryDiscord(discord.postMessage(scope, chunk))
+      posted.push({ id: created.id, content: chunk })
+    } else if (forceEdit || existing.content !== chunk) {
+      yield* retryDiscord(discord.editMessage(scope, existing.id, chunk))
+      existing.content = chunk
+    }
+  })
+  const flush = Effect.fn("flushDiscordRender")(function* (force = false, forceEdit = false) {
+    const chunks = splitDiscordMarkdown(visibleContent())
+    if (chunks.length === 0) return
+    const now = yield* Clock.currentTimeMillis
+    if (!force && posted.length > 0 && now - lastFlushAt < updateIntervalMs) return
+    for (let index = 0; index < chunks.length; index += 1) {
+      const chunk = chunks[index]
+      if (chunk === undefined) continue
+      yield* writeChunk(index, chunk, forceEdit)
+    }
+    for (let index = posted.length - 1; index >= chunks.length; index -= 1) {
+      const stale = posted[index]
+      if (stale === undefined) continue
+      yield* retryDiscord(discord.deleteMessage(scope, stale.id))
+      posted.splice(index, 1)
+    }
+    lastFlushAt = now
+  })
+  const finish = Effect.fn("finishDiscordRender")(function* () {
+    if (finished) return
+    finished = true
+    const wasTyping = yield* stopTyping()
+    yield* flush(true, wasTyping)
+  })
+
+  yield* startTyping()
+  yield* events
+    .pipe(
+      Stream.runForEach((event) =>
+        Effect.gen(function* () {
+          switch (event.type) {
+            case "tool-start": {
+              yield* startTyping()
+              yield* renderStatus(`${event.title}...`)
+              break
+            }
+            case "tool-end": {
+              yield* renderStatus("Tool finished.")
+              break
+            }
+            case "idle": {
+              yield* finish()
+              break
+            }
+            case "text-delta": {
+              yield* stopTyping()
+              answer += event.text
+              yield* flush(posted.length === 0)
+              break
+            }
+            case "text-snapshot": {
+              yield* stopTyping()
+              answer = event.text
+              yield* flush(true)
+              break
+            }
+            case "changed-files": {
+              if (config.streaming.changedFilesSummary && hasChangedFiles(event)) {
+                changed = changedSummary(event)
+                yield* flush(true)
+              }
+              break
+            }
+            case "error": {
+              yield* stopTyping()
+              return yield* Effect.fail(new OpencodeError({ message: event.message }))
+            }
+          }
+        })
+      )
+    )
+    .pipe(Effect.ensuring(stopTyping()))
+
+  yield* finish()
+})

package/src/Render/Splitting.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test"
+import { splitDiscordMarkdown } from "./Splitting.ts"
+
+describe("splitDiscordMarkdown", () => {
+  test("returns no chunks for empty output", () => {
+    expect(splitDiscordMarkdown("")).toEqual([])
+  })
+
+  test("hard-splits a single oversized line", () => {
+    expect(splitDiscordMarkdown("x".repeat(25), 10)).toEqual(["x".repeat(10), "x".repeat(10), "x".repeat(5)])
+  })
+
+  test("keeps every chunk within Discord's 2000 character limit", () => {
+    const chunks = splitDiscordMarkdown(`${"a".repeat(1990)}\n${"b".repeat(1990)}`)
+
+    expect(chunks.length).toBeGreaterThan(1)
+    expect(chunks.every((chunk) => chunk.length <= 2000)).toBe(true)
+    expect(chunks.join("\n").replaceAll("\n", "")).toContain("a".repeat(100))
+  })
+
+  test("preserves code fences across continuation messages", () => {
+    const source = `before\n\`\`\`ts\n${"const value = 1\n".repeat(180)}\`\`\`\nafter`
+    const chunks = splitDiscordMarkdown(source)
+
+    expect(chunks.length).toBeGreaterThan(1)
+    expect(chunks.every((chunk) => chunk.length <= 2000)).toBe(true)
+    expect(chunks.at(0)?.endsWith("\n```")).toBe(true)
+    expect(chunks.at(1)?.startsWith("```ts\n")).toBe(true)
+  })
+})

package/src/Render/Splitting.ts

@@ -0,0 +1,68 @@
+const fenceStart = (line: string): string | undefined => {
+  const match = /^```([^`]*)\s*$/.exec(line.trim())
+  return match === null ? undefined : match[1]
+}
+
+const hardSplit = (text: string, limit: number): ReadonlyArray<string> => {
+  const chunks: Array<string> = []
+  for (let index = 0; index < text.length; index += limit) {
+    chunks.push(text.slice(index, index + limit))
+  }
+  return chunks
+}
+
+type SplitState = {
+  readonly chunks: Array<string>
+  current: string
+  openFence: string | undefined
+}
+
+const closeChunk = (state: SplitState) => {
+  if (state.current.length === 0) return
+  const suffix = state.openFence === undefined ? "" : "\n```"
+  state.chunks.push(`${state.current}${suffix}`)
+  state.current = state.openFence === undefined ? "" : `\`\`\`${state.openFence}\n`
+}
+
+const appendSegment = (state: SplitState, segment: string, limit: number) => {
+  const suffixLength = state.openFence === undefined ? 0 : 4
+  if (segment.length + suffixLength > limit) {
+    closeChunk(state)
+    appendOversizedSegment(state, segment, limit - suffixLength, suffixLength)
+    return
+  }
+  if (state.current.length + segment.length + suffixLength > limit) {
+    closeChunk(state)
+    state.current += segment.startsWith("\n") && state.current.length === 0 ? segment.slice(1) : segment
+    return
+  }
+  state.current += segment
+}
+
+const appendOversizedSegment = (state: SplitState, segment: string, limit: number, suffixLength: number) => {
+  for (const piece of hardSplit(segment, limit)) {
+    if (state.current.length + piece.length + suffixLength > limit) closeChunk(state)
+    state.current += piece
+  }
+}
+
+const updateFence = (state: SplitState, line: string) => {
+  const marker = fenceStart(line)
+  if (marker !== undefined) state.openFence = state.openFence === undefined ? marker : undefined
+}
+
+export const splitDiscordMarkdown = (text: string, limit = 2000): ReadonlyArray<string> => {
+  if (text.length <= limit) return text.length === 0 ? [] : [text]
+
+  const lines = text.split("\n")
+  const state: SplitState = { chunks: [], current: "", openFence: undefined }
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const segment = `${index === 0 ? "" : "\n"}${lines[index]}`
+    appendSegment(state, segment, limit)
+    updateFence(state, lines[index] ?? "")
+  }
+
+  if (state.current.length > 0) state.chunks.push(state.current)
+  return state.chunks
+}

package/src/Schema.ts

@@ -0,0 +1,93 @@
+import { Schema } from "effect"
+
+export type Snowflake = string
+
+export type DiscordScope = {
+  readonly guildId: Snowflake
+  readonly channelId: Snowflake
+  readonly threadId?: Snowflake
+}
+
+export type BotIdentity = {
+  readonly userId: Snowflake
+}
+
+export type DiscordAuthor = {
+  readonly id: Snowflake
+  readonly displayName: string
+  readonly nickname?: string
+  readonly isBot: boolean
+}
+
+export type DiscordAttachment = {
+  readonly id: string
+  readonly filename: string
+  readonly contentType?: string
+  readonly size: number
+  readonly url: string
+}
+
+export type DiscordReaction = {
+  readonly emoji: string
+  readonly count: number
+}
+
+export type DiscordMessage = {
+  readonly id: Snowflake
+  readonly guildId: Snowflake
+  readonly channelId: Snowflake
+  readonly threadId?: Snowflake
+  readonly author: DiscordAuthor
+  readonly content: string
+  readonly timestamp: string
+  readonly mentions: ReadonlyArray<Snowflake>
+  readonly roleMentions: ReadonlyArray<Snowflake>
+  readonly everyoneMention: boolean
+  readonly hereMention: boolean
+  readonly attachments: ReadonlyArray<DiscordAttachment>
+  readonly reactions: ReadonlyArray<DiscordReaction>
+  readonly channelType: "guild" | "dm"
+  readonly isSystem?: boolean
+}
+
+export type ToolTarget = {
+  readonly guildId?: string | undefined
+  readonly channelId?: string | undefined
+  readonly threadId?: string | undefined
+  readonly messageId?: string | undefined
+}
+
+export type ToolRequest = {
+  readonly action: string
+  readonly target: ToolTarget
+  readonly args: Readonly<Record<string, unknown>>
+}
+
+export type ToolResponse = { readonly ok: true; readonly result: unknown } | { readonly ok: false; readonly error: string }
+
+export type OpencodeEvent =
+  | { readonly type: "text-delta"; readonly text: string }
+  | { readonly type: "text-snapshot"; readonly text: string }
+  | { readonly type: "tool-start"; readonly title: string }
+  | { readonly type: "tool-end" }
+  | { readonly type: "changed-files"; readonly files: number; readonly insertions: number; readonly deletions: number }
+  | { readonly type: "idle" }
+  | { readonly type: "error"; readonly message: string }
+
+export const ToolTargetSchema = Schema.Struct({
+  guildId: Schema.optional(Schema.String),
+  channelId: Schema.optional(Schema.String),
+  threadId: Schema.optional(Schema.String),
+  messageId: Schema.optional(Schema.String)
+})
+
+export const ToolRequestSchema = Schema.Struct({
+  action: Schema.String,
+  target: ToolTargetSchema,
+  args: Schema.Record(Schema.String, Schema.Unknown)
+})
+
+export const ToolResponseSchema = Schema.Union([
+  Schema.Struct({ ok: Schema.Literal(true), result: Schema.Unknown }),
+  Schema.Struct({ ok: Schema.Literal(false), error: Schema.String })
+])

package/src/Tools/Scaffolding.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, test } from "bun:test"
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { ensureDiscordTools, renderDiscordToolFile } from "./Scaffolding.ts"
+
+describe("Discord tool scaffolding", () => {
+  test("renders a generated tool file with the injected loopback URL", () => {
+    const source = renderDiscordToolFile("http://127.0.0.1:8787")
+
+    expect(source).toContain("Generated by opencode-discord-bot")
+    expect(source).toContain("http://127.0.0.1:8787/tool")
+    expect(source).toContain("fetch")
+  })
+
+  test("creates and refreshes only generated files", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tools-"))
+
+    try {
+      const created = await ensureDiscordTools({ projectDir, bridgePort: 8787, enabled: true, autoInstall: true })
+      const toolPath = join(projectDir, ".opencode", "tools", "discord-bridge.ts")
+      const first = await readFile(toolPath, "utf8")
+
+      expect(created).toEqual([toolPath])
+      expect(first).toContain("http://127.0.0.1:8787/tool")
+
+      await ensureDiscordTools({ projectDir, bridgePort: 9999, enabled: true, autoInstall: true })
+      expect(await readFile(toolPath, "utf8")).toContain("http://127.0.0.1:9999/tool")
+
+      await writeFile(toolPath, "// operator file\n")
+      const skipped = await ensureDiscordTools({ projectDir, bridgePort: 7777, enabled: true, autoInstall: true })
+
+      expect(skipped).toEqual([])
+      expect(await readFile(toolPath, "utf8")).toBe("// operator file\n")
+
+      await writeFile(toolPath, `${renderDiscordToolFile("http://127.0.0.1:9999")}\n// operator edit\n`)
+      const edited = await ensureDiscordTools({ projectDir, bridgePort: 6666, enabled: true, autoInstall: true })
+
+      expect(edited).toEqual([])
+      expect(await readFile(toolPath, "utf8")).toContain("// operator edit")
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+
+  test("does nothing when auto install is disabled", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tools-disabled-"))
+
+    try {
+      await mkdir(join(projectDir, ".opencode"), { recursive: true })
+      expect(await ensureDiscordTools({ projectDir, bridgePort: 8787, enabled: true, autoInstall: false })).toEqual([])
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+})