opencode-discord-bot 0.0.1

package/src/Bridge/ToolControl.ts

@@ -0,0 +1,260 @@
+import { lstat, realpath } from "node:fs/promises"
+import { isAbsolute, resolve, sep } from "node:path"
+import { Effect } from "effect"
+import type { RuntimeConfig, ToolConfig } from "../Config.ts"
+import type { DiscordService } from "../Discord/DiscordPort.ts"
+import { sanitizeDiscordContent } from "../Discord/Safety.ts"
+import type { DiscordScope, ToolRequest, ToolResponse } from "../Schema.ts"
+
+type ToolRequestOptions = {
+  readonly allowedScopes?: ReadonlyArray<DiscordScope> | undefined
+  readonly botId?: string | undefined
+}
+
+const actionFlag = (action: string): keyof ToolConfig | undefined => {
+  switch (action) {
+    case "addReaction":
+    case "removeReaction":
+      return "reactions"
+    case "attachFile":
+      return "attachFiles"
+    case "fetchHistory":
+      return "fetchHistory"
+    case "followUpMessage":
+      return "followUpMessages"
+    case "createThread":
+      return "createThread"
+    case "editOwnMessage":
+    case "deleteOwnMessage":
+      return "editDeleteOwn"
+    case "postOtherChannel":
+      return "postOtherChannels"
+    case "pin":
+    case "unpin":
+      return "pin"
+    default:
+      return undefined
+  }
+}
+
+const scopeFromRequest = (request: ToolRequest): DiscordScope | string => {
+  const { guildId, channelId, threadId } = request.target
+  if (guildId === undefined || channelId === undefined) return "Discord target must include guildId and channelId"
+  const values = [guildId, channelId, threadId]
+  if (values.some((value) => value?.toLowerCase() === "@me" || value?.toLowerCase() === "dm")) {
+    return "Discord DMs are not supported"
+  }
+  return { guildId, channelId, ...(threadId === undefined ? {} : { threadId }) }
+}
+
+const scopeKey = (scope: DiscordScope): string => `${scope.guildId}:${scope.channelId}:${scope.threadId ?? ""}`
+
+const isAllowedScope = (scope: DiscordScope, allowedScopes: ReadonlyArray<DiscordScope> | undefined): boolean =>
+  allowedScopes === undefined || allowedScopes.some((allowed) => scopeKey(allowed) === scopeKey(scope))
+
+const stringArg = (request: ToolRequest, key: string): string | undefined => {
+  const value = request.args[key]
+  return typeof value === "string" ? value : undefined
+}
+
+const attachmentPath = Effect.fn("attachmentPath")(function* (projectDir: string, input: string, maxBytes: number) {
+  if (isAbsolute(input) || input.includes(".."))
+    return { ok: false, error: "Attachment path must stay inside the project directory" } satisfies ToolResponse
+  const project = yield* Effect.tryPromise(() => realpath(projectDir)).pipe(Effect.catch(() => Effect.succeed(resolve(projectDir))))
+  const target = resolve(project, input)
+  const actual = yield* Effect.tryPromise(() => realpath(target)).pipe(Effect.catch(() => Effect.succeed(undefined)))
+  if (actual === undefined || !(actual === project || actual.startsWith(`${project}${sep}`))) {
+    return { ok: false, error: "Attachment path must stay inside the project directory" } satisfies ToolResponse
+  }
+  const stat = yield* Effect.tryPromise(() => lstat(actual)).pipe(Effect.catch(() => Effect.succeed(undefined)))
+  if (stat === undefined || !stat.isFile()) return { ok: false, error: "Attachment path must be a readable file" } satisfies ToolResponse
+  if (stat.size > maxBytes) return { ok: false, error: "Attachment exceeds the configured size limit" } satisfies ToolResponse
+  return actual
+})
+
+const disabled = (action: string): ToolResponse => ({ ok: false, error: `Action ${action} is disabled` })
+
+const followUp = Effect.fn("toolFollowUp")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  discord: DiscordService
+) {
+  const content = stringArg(request, "content")
+  if (content === undefined || content.trim() === "") return { ok: false, error: "content is required" } satisfies ToolResponse
+  const result = yield* discord.postMessage(scope, sanitizeDiscordContent(content, config.guards))
+  return { ok: true, result } satisfies ToolResponse
+})
+
+const reaction = Effect.fn("toolReaction")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  discord: DiscordService,
+  operation: "add" | "remove"
+) {
+  const messageId = request.target.messageId
+  const emoji = stringArg(request, "emoji")
+  if (messageId === undefined || emoji === undefined) return { ok: false, error: "messageId and emoji are required" } satisfies ToolResponse
+  if (operation === "add") {
+    yield* discord.addReaction(scope, messageId, emoji)
+    return { ok: true, result: { reacted: true } } satisfies ToolResponse
+  }
+  yield* discord.removeReaction(scope, messageId, emoji)
+  return { ok: true, result: { reacted: false } } satisfies ToolResponse
+})
+
+const fetchHistory = Effect.fn("toolFetchHistory")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  discord: DiscordService
+) {
+  const limit = typeof request.args.limit === "number" ? request.args.limit : config.context.messages
+  const result = yield* discord.fetchHistory(scope, limit)
+  return { ok: true, result } satisfies ToolResponse
+})
+
+const attachFile = Effect.fn("toolAttachFile")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  projectDir: string,
+  discord: DiscordService
+) {
+  const path = stringArg(request, "path")
+  if (path === undefined) return { ok: false, error: "path is required" } satisfies ToolResponse
+  const safePath = yield* attachmentPath(projectDir, path, config.context.attachmentMaxBytes)
+  if (typeof safePath !== "string") return safePath
+  const result = yield* discord.attachFile(scope, safePath)
+  return { ok: true, result } satisfies ToolResponse
+})
+
+const createThread = Effect.fn("toolCreateThread")(function* (request: ToolRequest, scope: DiscordScope, discord: DiscordService) {
+  const name = stringArg(request, "name")
+  if (name === undefined || name.trim() === "") return { ok: false, error: "name is required" } satisfies ToolResponse
+  const result = yield* discord.createThread(scope, name)
+  return { ok: true, result } satisfies ToolResponse
+})
+
+const ensureOwnMessage = Effect.fn("ensureOwnDiscordMessage")(function* (
+  messageId: string,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  discord: DiscordService,
+  options: ToolRequestOptions
+) {
+  if (options.botId === undefined) return "Bot identity is required to edit or delete bot-authored messages"
+  const history = yield* discord.fetchHistory(scope, config.context.messages)
+  const message = history.find((item) => item.id === messageId)
+  if (message?.author.id !== options.botId) return "messageId must refer to a bot-authored message"
+  return undefined
+})
+
+const editOwnMessage = Effect.fn("toolEditOwnMessage")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  discord: DiscordService,
+  options: ToolRequestOptions
+) {
+  const messageId = request.target.messageId
+  const content = stringArg(request, "content")
+  if (messageId === undefined || content === undefined || content.trim() === "") {
+    return { ok: false, error: "messageId and content are required" } satisfies ToolResponse
+  }
+  const ownMessageError = yield* ensureOwnMessage(messageId, scope, config, discord, options)
+  if (ownMessageError !== undefined) return { ok: false, error: ownMessageError } satisfies ToolResponse
+  yield* discord.editMessage(scope, messageId, sanitizeDiscordContent(content, config.guards))
+  return { ok: true, result: { edited: true } } satisfies ToolResponse
+})
+
+const deleteOwnMessage = Effect.fn("toolDeleteOwnMessage")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  config: RuntimeConfig,
+  discord: DiscordService,
+  options: ToolRequestOptions
+) {
+  const messageId = request.target.messageId
+  if (messageId === undefined) return { ok: false, error: "messageId is required" } satisfies ToolResponse
+  const ownMessageError = yield* ensureOwnMessage(messageId, scope, config, discord, options)
+  if (ownMessageError !== undefined) return { ok: false, error: ownMessageError } satisfies ToolResponse
+  yield* discord.deleteMessage(scope, messageId)
+  return { ok: true, result: { deleted: true } } satisfies ToolResponse
+})
+
+const postOtherChannel = Effect.fn("toolPostOtherChannel")(function* (
+  request: ToolRequest,
+  config: RuntimeConfig,
+  discord: DiscordService
+) {
+  const guildId = request.target.guildId
+  const channelId = request.target.channelId
+  const content = stringArg(request, "content")
+  if (guildId === undefined || channelId === undefined || content === undefined || content.trim() === "") {
+    return { ok: false, error: "guildId, channelId, and content are required" } satisfies ToolResponse
+  }
+  const result = yield* discord.postChannelMessage(guildId, channelId, sanitizeDiscordContent(content, config.guards))
+  return { ok: true, result } satisfies ToolResponse
+})
+
+const pin = Effect.fn("toolPin")(function* (
+  request: ToolRequest,
+  scope: DiscordScope,
+  discord: DiscordService,
+  operation: "pin" | "unpin"
+) {
+  const messageId = request.target.messageId
+  if (messageId === undefined) return { ok: false, error: "messageId is required" } satisfies ToolResponse
+  if (operation === "pin") {
+    yield* discord.pinMessage(scope, messageId)
+    return { ok: true, result: { pinned: true } } satisfies ToolResponse
+  }
+  yield* discord.unpinMessage(scope, messageId)
+  return { ok: true, result: { pinned: false } } satisfies ToolResponse
+})
+
+export const handleToolRequest = Effect.fn("handleToolRequest")(function* (
+  request: ToolRequest,
+  config: RuntimeConfig,
+  projectDir: string,
+  discord: DiscordService,
+  options: ToolRequestOptions = {}
+) {
+  if (!config.tools.enabled) return { ok: false, error: "Discord bridge tools are disabled" } satisfies ToolResponse
+  const flag = actionFlag(request.action)
+  if (flag === undefined) return { ok: false, error: `Unknown action ${request.action}` } satisfies ToolResponse
+  if (!config.tools[flag]) return disabled(request.action)
+
+  const scope = scopeFromRequest(request)
+  if (typeof scope === "string") return { ok: false, error: scope } satisfies ToolResponse
+  if (request.action !== "postOtherChannel" && !isAllowedScope(scope, options.allowedScopes)) {
+    return { ok: false, error: "Discord target is outside the active turn scope" } satisfies ToolResponse
+  }
+
+  switch (request.action) {
+    case "followUpMessage":
+      return yield* followUp(request, scope, config, discord)
+    case "addReaction":
+      return yield* reaction(request, scope, discord, "add")
+    case "removeReaction":
+      return yield* reaction(request, scope, discord, "remove")
+    case "fetchHistory":
+      return yield* fetchHistory(request, scope, config, discord)
+    case "attachFile":
+      return yield* attachFile(request, scope, config, projectDir, discord)
+    case "createThread":
+      return yield* createThread(request, scope, discord)
+    case "editOwnMessage":
+      return yield* editOwnMessage(request, scope, config, discord, options)
+    case "deleteOwnMessage":
+      return yield* deleteOwnMessage(request, scope, config, discord, options)
+    case "postOtherChannel":
+      return yield* postOtherChannel(request, config, discord)
+    case "pin":
+      return yield* pin(request, scope, discord, "pin")
+    case "unpin":
+      return yield* pin(request, scope, discord, "unpin")
+  }
+  return { ok: false, error: `Unknown action ${request.action}` } satisfies ToolResponse
+})

package/src/Bridge/ToolControlEdges.test.ts

@@ -0,0 +1,49 @@
+import { expect, test } from "bun:test"
+import { mkdtemp, rm } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Effect } from "effect"
+import { defaultConfig } from "../Config.ts"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { handleToolRequest } from "./ToolControl.ts"
+
+test("rejects missing attachment files inside the project", async () => {
+  const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tool-edge-"))
+  try {
+    const result = await Effect.runPromise(
+      handleToolRequest(
+        { action: "attachFile", target: { guildId: "g1", channelId: "c1" }, args: { path: "missing.txt" } },
+        defaultConfig,
+        projectDir,
+        makeMemoryDiscord()
+      )
+    )
+
+    expect(result).toEqual({ ok: false, error: "Attachment path must stay inside the project directory" })
+  } finally {
+    await rm(projectDir, { recursive: true, force: true })
+  }
+})
+
+test("rejects incomplete high-risk tool payloads before dispatch", async () => {
+  const config = {
+    ...defaultConfig,
+    tools: { ...defaultConfig.tools, editDeleteOwn: true, postOtherChannels: true }
+  }
+  const discord = makeMemoryDiscord()
+
+  const edit = await Effect.runPromise(
+    handleToolRequest(
+      { action: "editOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
+      config,
+      "/repo",
+      discord
+    )
+  )
+  const post = await Effect.runPromise(
+    handleToolRequest({ action: "postOtherChannel", target: { guildId: "g1", channelId: "c2" }, args: {} }, config, "/repo", discord)
+  )
+
+  expect(edit).toEqual({ ok: false, error: "messageId and content are required" })
+  expect(post).toEqual({ ok: false, error: "guildId, channelId, and content are required" })
+})

package/src/Bridge/ToolControlHighRisk.test.ts

@@ -0,0 +1,153 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import type { RuntimeConfig, ToolConfig } from "../Config.ts"
+import { defaultConfig } from "../Config.ts"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { handleToolRequest } from "./ToolControl.ts"
+
+const withTools = (tools: Partial<ToolConfig>): RuntimeConfig => ({
+  ...defaultConfig,
+  tools: { ...defaultConfig.tools, ...tools }
+})
+
+describe("handleToolRequest high-risk actions", () => {
+  test("dispatches opt-in high-risk actions through the Discord port", async () => {
+    const discord = makeMemoryDiscord({
+      context: [
+        {
+          id: "m1",
+          guildId: "g1",
+          channelId: "c1",
+          author: { id: "bot-1", displayName: "bot", isBot: true },
+          content: "old",
+          timestamp: "2026-06-05T14:03:00.000Z",
+          mentions: [],
+          roleMentions: [],
+          everyoneMention: false,
+          hereMention: false,
+          attachments: [],
+          reactions: [],
+          channelType: "guild"
+        }
+      ]
+    })
+    const config = withTools({ createThread: true, editDeleteOwn: true, postOtherChannels: true, pin: true })
+
+    const created = await Effect.runPromise(
+      handleToolRequest(
+        { action: "createThread", target: { guildId: "g1", channelId: "c1" }, args: { name: "work" } },
+        config,
+        "/repo",
+        discord,
+        { botId: "bot-1" }
+      )
+    )
+    const edited = await Effect.runPromise(
+      handleToolRequest(
+        { action: "editOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { content: "edited" } },
+        config,
+        "/repo",
+        discord,
+        { botId: "bot-1" }
+      )
+    )
+    const deleted = await Effect.runPromise(
+      handleToolRequest(
+        { action: "deleteOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
+        config,
+        "/repo",
+        discord,
+        { botId: "bot-1" }
+      )
+    )
+    const posted = await Effect.runPromise(
+      handleToolRequest(
+        { action: "postOtherChannel", target: { guildId: "g1", channelId: "c2" }, args: { content: "elsewhere" } },
+        config,
+        "/repo",
+        discord
+      )
+    )
+    const pinned = await Effect.runPromise(
+      handleToolRequest({ action: "pin", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} }, config, "/repo", discord)
+    )
+    const unpinned = await Effect.runPromise(
+      handleToolRequest(
+        { action: "unpin", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
+        config,
+        "/repo",
+        discord
+      )
+    )
+
+    expect(created).toEqual({ ok: true, result: { id: "thread-1" } })
+    expect(edited).toEqual({ ok: true, result: { edited: true } })
+    expect(deleted).toEqual({ ok: true, result: { deleted: true } })
+    expect(posted).toEqual({ ok: true, result: { id: "posted-2" } })
+    expect(pinned).toEqual({ ok: true, result: { pinned: true } })
+    expect(unpinned).toEqual({ ok: true, result: { pinned: false } })
+    expect(discord.threads).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, name: "work" }])
+    expect(discord.channelMessages).toEqual([{ guildId: "g1", channelId: "c2", content: "elsewhere" }])
+    expect(discord.pins.map((item) => item.op)).toEqual(["pin", "unpin"])
+  })
+
+  test("rejects edit/delete requests for messages not authored by the bot", async () => {
+    const discord = makeMemoryDiscord({
+      context: [
+        {
+          id: "m1",
+          guildId: "g1",
+          channelId: "c1",
+          author: { id: "user-1", displayName: "user", isBot: false },
+          content: "user text",
+          timestamp: "2026-06-05T14:03:00.000Z",
+          mentions: [],
+          roleMentions: [],
+          everyoneMention: false,
+          hereMention: false,
+          attachments: [],
+          reactions: [],
+          channelType: "guild"
+        }
+      ]
+    })
+    const config = withTools({ editDeleteOwn: true })
+
+    const edited = await Effect.runPromise(
+      handleToolRequest(
+        { action: "editOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { content: "edited" } },
+        config,
+        "/repo",
+        discord,
+        { botId: "bot-1" }
+      )
+    )
+    const deleted = await Effect.runPromise(
+      handleToolRequest(
+        { action: "deleteOwnMessage", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: {} },
+        config,
+        "/repo",
+        discord,
+        { botId: "bot-1" }
+      )
+    )
+
+    expect(edited).toEqual({ ok: false, error: "messageId must refer to a bot-authored message" })
+    expect(deleted).toEqual({ ok: false, error: "messageId must refer to a bot-authored message" })
+    expect(discord.edits).toEqual([])
+    expect(discord.deletes).toEqual([])
+  })
+
+  test("rejects DM-like targets even when cross-channel posting is enabled", async () => {
+    const response = await Effect.runPromise(
+      handleToolRequest(
+        { action: "postOtherChannel", target: { guildId: "@me", channelId: "dm" }, args: { content: "nope" } },
+        withTools({ postOtherChannels: true }),
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+
+    expect(response).toEqual({ ok: false, error: "Discord DMs are not supported" })
+  })
+})

package/src/Config.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, test } from "bun:test"
+import { mkdtemp, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Duration, Effect, Redacted } from "effect"
+import { defaultConfig, loadConfig, loadConfigFromSources } from "./Config.ts"
+
+describe("loadConfigFromSources", () => {
+  test("merges defaults, JSONC config, and environment with env precedence", async () => {
+    const config = await Effect.runPromise(
+      loadConfigFromSources({
+        cwd: "/repo/bot",
+        env: {
+          DISCORD_TOKEN: "discord-token",
+          OPENCODE_PORT: "5050",
+          DISCORD_BRIDGE_PORT: "9999",
+          OPENCODE_AGENT: "discord-agent"
+        },
+        configText: `{
+          // file values are lower precedence than env
+          "contextMessages": 12,
+          "contextMaxChars": 1234,
+          "streaming": { "updateIntervalMs": 250, "showToolStatus": false },
+          "threads": { "activeByRecentBotParticipation": false },
+          "concurrency": { "strategy": "burst", "globalMaxActiveTurns": 4 },
+          "guards": { "ignoreBots": false, "stripMassMentions": false, "redactSecretsInErrors": false, "maxTurnMs": 1000 },
+          "tools": { "createThread": true, "pin": true }
+        }`
+      })
+    )
+
+    expect(Redacted.value(config.discordToken)).toBe("discord-token")
+    expect(config.opencode.baseUrl).toBe("http://127.0.0.1:5050")
+    expect(config.opencode.projectDir).toBe("/repo/bot")
+    expect(config.opencode.agent).toBe("discord-agent")
+    expect(config.bridge.port).toBe(9999)
+    expect(config.context.messages).toBe(12)
+    expect(config.context.maxChars).toBe(1234)
+    expect(config.streaming.updateInterval).toEqual(Duration.millis(250))
+    expect(config.streaming.showToolStatus).toBe(false)
+    expect(config.threads.activeByRecentBotParticipation).toBe(false)
+    expect(config.concurrency.strategy).toBe("burst")
+    expect(config.concurrency.globalMaxActiveTurns).toBe(4)
+    expect(config.guards.ignoreBots).toBe(false)
+    expect(config.guards.stripMassMentions).toBe(false)
+    expect(config.guards.redactSecretsInErrors).toBe(false)
+    expect(config.guards.maxTurn).toEqual(Duration.millis(1000))
+    expect(config.tools.reactions).toBe(true)
+    expect(config.tools.createThread).toBe(true)
+    expect(config.tools.pin).toBe(true)
+  })
+
+  test("uses the normative localhost defaults", async () => {
+    const config = await Effect.runPromise(loadConfigFromSources({ cwd: "/work", env: { DISCORD_TOKEN: "token" } }))
+
+    expect(config.opencode.baseUrl).toBe("http://127.0.0.1:4096")
+    expect(config.opencode.projectDir).toBe("/work")
+    expect(config.bridge.host).toBe(defaultConfig.bridge.host)
+    expect(config.bridge.port).toBe(8787)
+    expect(config.context.messages).toBe(30)
+    expect(config.tools.autoInstall).toBe(true)
+    expect(config.tools.followUpMessages).toBe(true)
+    expect(config.tools.postOtherChannels).toBe(false)
+  })
+
+  test("fails fast when DISCORD_TOKEN is missing", async () => {
+    await expect(loadConfigFromSources({ cwd: "/work", env: {} }).pipe(Effect.runPromise)).rejects.toMatchObject({
+      _tag: "ConfigError"
+    })
+  })
+
+  test("fails fast when config text is invalid JSONC", async () => {
+    await expect(
+      loadConfigFromSources({ cwd: "/work", env: { DISCORD_TOKEN: "token" }, configText: "{" }).pipe(Effect.runPromise)
+    ).rejects.toMatchObject({
+      _tag: "ConfigError",
+      message: "Config file must be valid JSONC"
+    })
+  })
+
+  test("fails fast when JSONC config fails schema validation", async () => {
+    await expect(
+      loadConfigFromSources({ cwd: "/work", env: { DISCORD_TOKEN: "token" }, configText: `{ "contextMessages": "many" }` }).pipe(
+        Effect.runPromise
+      )
+    ).rejects.toMatchObject({
+      _tag: "ConfigError",
+      message: "Config file failed schema validation"
+    })
+
+    await expect(
+      loadConfigFromSources({
+        cwd: "/work",
+        env: { DISCORD_TOKEN: "token" },
+        configText: `{ "streaming": { "updateIntervalMs": -1 } }`
+      }).pipe(Effect.runPromise)
+    ).rejects.toMatchObject({
+      _tag: "ConfigError",
+      message: "Config file failed schema validation"
+    })
+  })
+
+  test("loads .opencode-discord.jsonc from the working directory when present", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "ocdb-config-"))
+
+    try {
+      await writeFile(join(cwd, ".opencode-discord.jsonc"), `{ "contextMessages": 7, "tools": { "pin": true } }`)
+      const config = await Effect.runPromise(loadConfig({ cwd, env: { DISCORD_TOKEN: "token" } }))
+
+      expect(config.context.messages).toBe(7)
+      expect(config.tools.pin).toBe(true)
+    } finally {
+      await rm(cwd, { recursive: true, force: true })
+    }
+  })
+
+  test("treats a missing .opencode-discord.jsonc as an empty config", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "ocdb-config-missing-"))
+
+    try {
+      const config = await Effect.runPromise(loadConfig({ cwd, env: { DISCORD_TOKEN: "token" } }))
+
+      expect(config.context.messages).toBe(defaultConfig.context.messages)
+      expect(config.opencode.projectDir).toBe(cwd)
+    } finally {
+      await rm(cwd, { recursive: true, force: true })
+    }
+  })
+
+  test("reports unreadable config files", async () => {
+    const cwd = await mkdtemp(join(tmpdir(), "ocdb-config-unreadable-"))
+
+    try {
+      await expect(loadConfig({ cwd, env: { DISCORD_TOKEN: "token" }, configPath: cwd }).pipe(Effect.runPromise)).rejects.toMatchObject({
+        _tag: "ConfigError",
+        message: "Unable to read config file"
+      })
+    } finally {
+      await rm(cwd, { recursive: true, force: true })
+    }
+  })
+})