opencode-discord-bot 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ysm-dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,13 @@
+# opencode-discord-bot
+
+Discord bot bridge for a self-hosted opencode instance.
+
+## Install
+
+```sh
+npm install opencode-discord-bot
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "opencode-discord-bot",
+  "version": "0.0.1",
+  "description": "Discord bot bridge for a self-hosted opencode instance",
+  "type": "module",
+  "main": "src/Main.ts",
+  "bin": {
+    "opencode-discord-bot": "./src/Main.ts"
+  },
+  "exports": {
+    ".": "./src/Main.ts"
+  },
+  "engines": {
+    "bun": ">=1.3.0"
+  },
+  "license": "MIT",
+  "author": "ysm-dev <i@ysm.dev>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ysm-dev/opencode-discord-bot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ysm-dev/opencode-discord-bot/issues"
+  },
+  "homepage": "https://github.com/ysm-dev/opencode-discord-bot#readme",
+  "keywords": [
+    "opencode",
+    "discord",
+    "discord-bot",
+    "bot",
+    "bridge"
+  ],
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "bun src/Main.ts",
+    "typecheck": "tsgo --noEmit",
+    "test": "bun test",
+    "test:unit": "bun test src",
+    "test:integration": "bun test test/integration",
+    "test:e2e": "bun test test/e2e",
+    "format": "biome format --write .",
+    "format:check": "biome format --check .",
+    "lint": "biome lint .",
+    "check": "biome check .",
+    "knip": "knip",
+    "coverage": "bun test --coverage --coverage-reporter=lcov && bun scripts/CheckCoverage.ts",
+    "ci": "bun run typecheck && bun run check && bun run knip && bun test && bun run coverage"
+  },
+  "dependencies": {
+    "@chat-adapter/discord": "4.29.0",
+    "@effect/platform-bun": "4.0.0-beta.74",
+    "@opencode-ai/sdk": "1.16.2",
+    "chat": "4.29.0",
+    "discord.js": "14.25.1",
+    "effect": "4.0.0-beta.74",
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.16",
+    "@changesets/cli": "^2.31.0",
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
+    "@effect/vitest": "4.0.0-beta.74",
+    "@types/bun": "1.3.13",
+    "@typescript/native-preview": "^7.0.0-dev.20260606.1",
+    "@vitest/coverage-v8": "^4.1.8",
+    "knip": "^6.16.1",
+    "lefthook": "^2.1.9",
+    "typescript": "5.8.2"
+  }
+}

package/src/Bridge/LoopbackServer.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import { defaultConfig } from "../Config.ts"
+import { makeMemoryDiscord } from "../Discord/MemoryDiscord.ts"
+import { startLoopbackServer } from "./LoopbackServer.ts"
+
+describe("startLoopbackServer", () => {
+  test("binds to loopback and serves POST /tool", async () => {
+    const discord = makeMemoryDiscord()
+
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const server = yield* startLoopbackServer({
+            port: 0,
+            config: defaultConfig,
+            projectDir: "/repo",
+            discord,
+            getAllowedScopes: () => [{ guildId: "g1", channelId: "c1" }]
+          })
+          const response = yield* Effect.tryPromise(() =>
+            fetch(`${server.url}/tool`, {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({
+                action: "followUpMessage",
+                target: { guildId: "g1", channelId: "c1" },
+                args: { content: "from http" }
+              })
+            })
+          )
+          const body = yield* Effect.tryPromise(() => response.json())
+
+          expect(server.url.startsWith("http://127.0.0.1:")).toBe(true)
+          expect(body).toEqual({ ok: true, result: { id: "posted-1" } })
+          expect(discord.messages).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, content: "from http" }])
+        })
+      )
+    )
+  })
+
+  test("returns 404 for non-tool routes and contract errors for bad bodies", async () => {
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const server = yield* startLoopbackServer({ port: 0, config: defaultConfig, projectDir: "/repo", discord: makeMemoryDiscord() })
+          const missing = yield* Effect.tryPromise(() => fetch(`${server.url}/missing`))
+          const badJson = yield* Effect.tryPromise(() =>
+            fetch(`${server.url}/tool`, { method: "POST", headers: { "content-type": "application/json" }, body: "not-json" })
+          )
+          const badContract = yield* Effect.tryPromise(() =>
+            fetch(`${server.url}/tool`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({}) })
+          )
+          const badJsonBody = yield* Effect.tryPromise(() => badJson.json())
+          const badContractBody = yield* Effect.tryPromise(() => badContract.json())
+
+          expect(missing.status).toBe(404)
+          expect(badJsonBody).toEqual({ ok: false, error: "Request body must be valid JSON" })
+          expect(badContractBody).toEqual({ ok: false, error: "Request body must match the tool contract" })
+        })
+      )
+    )
+  })
+
+  test("rejects tool targets outside the active turn scopes", async () => {
+    await Effect.runPromise(
+      Effect.scoped(
+        Effect.gen(function* () {
+          const server = yield* startLoopbackServer({
+            port: 0,
+            config: defaultConfig,
+            projectDir: "/repo",
+            discord: makeMemoryDiscord(),
+            getAllowedScopes: () => [{ guildId: "g1", channelId: "c1" }]
+          })
+          const response = yield* Effect.tryPromise(() =>
+            fetch(`${server.url}/tool`, {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({
+                action: "followUpMessage",
+                target: { guildId: "g1", channelId: "c2" },
+                args: { content: "outside" }
+              })
+            })
+          )
+          const body = yield* Effect.tryPromise(() => response.json())
+
+          expect(body).toEqual({ ok: false, error: "Discord target is outside the active turn scope" })
+        })
+      )
+    )
+  })
+})

package/src/Bridge/LoopbackServer.ts

@@ -0,0 +1,77 @@
+import { BunHttpServer } from "@effect/platform-bun"
+import { Context, Effect, Layer, Schema } from "effect"
+import { HttpRouter, HttpServer, type HttpServerRequest } from "effect/unstable/http"
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi"
+import type { RuntimeConfig } from "../Config.ts"
+import type { DiscordService } from "../Discord/DiscordPort.ts"
+import type { DiscordScope, ToolRequest, ToolResponse } from "../Schema.ts"
+import { ToolRequestSchema, ToolResponseSchema } from "../Schema.ts"
+import { handleToolRequest } from "./ToolControl.ts"
+
+export type LoopbackServerOptions = {
+  readonly port: number
+  readonly config: RuntimeConfig
+  readonly projectDir: string
+  readonly discord: DiscordService
+  readonly getAllowedScopes?: (() => ReadonlyArray<DiscordScope>) | undefined
+  readonly botId?: string | undefined
+}
+
+type LoopbackServer = {
+  readonly url: string
+  readonly port: number
+}
+
+const invalidRequest = (message: string): ToolResponse => ({ ok: false, error: message })
+
+const toolFailure = (error: ToolResponse | { readonly message?: unknown }): ToolResponse => {
+  if ("ok" in error) return error
+  return invalidRequest(typeof error.message === "string" ? error.message : "Discord bridge tool failed")
+}
+
+const parseBody = (request: HttpServerRequest.HttpServerRequest): Effect.Effect<ToolRequest, ToolResponse> =>
+  Effect.gen(function* () {
+    const body = yield* request.json.pipe(Effect.mapError(() => invalidRequest("Request body must be valid JSON")))
+    const decoded = yield* Schema.decodeUnknownEffect(ToolRequestSchema)(body).pipe(
+      Effect.mapError(() => invalidRequest("Request body must match the tool contract"))
+    )
+    return { action: decoded.action, target: decoded.target, args: decoded.args } satisfies ToolRequest
+  })
+
+class ToolApiGroup extends HttpApiGroup.make("tool").add(HttpApiEndpoint.post("handleTool", "/tool", { success: ToolResponseSchema })) {}
+
+class ToolApi extends HttpApi.make("opencode-discord-bot-tools").add(ToolApiGroup) {}
+
+const toolApiLayer = (options: LoopbackServerOptions) =>
+  HttpApiBuilder.group(ToolApi, "tool", (handlers) =>
+    handlers.handleRaw("handleTool", ({ request }) =>
+      Effect.gen(function* () {
+        const toolRequest = yield* parseBody(request)
+        return yield* handleToolRequest(toolRequest, options.config, options.projectDir, options.discord, {
+          allowedScopes: options.getAllowedScopes?.() ?? [],
+          botId: options.botId
+        })
+      }).pipe(Effect.catch((error) => Effect.succeed(toolFailure(error))))
+    )
+  )
+
+const httpLayer = (options: LoopbackServerOptions) =>
+  HttpRouter.serve(Layer.provide(HttpApiBuilder.layer(ToolApi), toolApiLayer(options)), {
+    disableListenLog: true,
+    disableLogger: true
+  }).pipe(
+    Layer.provideMerge(
+      BunHttpServer.layer({
+        hostname: "127.0.0.1",
+        port: options.port
+      })
+    )
+  )
+
+export const startLoopbackServer = Effect.fn("startLoopbackServer")(function* (options: LoopbackServerOptions) {
+  const context = yield* Layer.build(httpLayer(options))
+  const server = Context.get(context, HttpServer.HttpServer)
+
+  const port = server.address._tag === "TcpAddress" ? server.address.port : options.port
+  return { url: `http://127.0.0.1:${port}`, port } satisfies LoopbackServer
+})

package/src/Bridge/ToolControl.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, test } from "bun:test"
+import { mkdir, mkdtemp, realpath, rm, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+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", () => {
+  test("allows safe default actions through the Discord port", async () => {
+    const discord = makeMemoryDiscord()
+    const response = await Effect.runPromise(
+      handleToolRequest(
+        {
+          action: "followUpMessage",
+          target: { guildId: "g1", channelId: "c1" },
+          args: { content: "done" }
+        },
+        defaultConfig,
+        "/repo",
+        discord
+      )
+    )
+
+    expect(response.ok).toBe(true)
+    expect(discord.messages).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, content: "done" }])
+  })
+
+  test("neutralizes mass mentions in follow-up tool content", async () => {
+    const discord = makeMemoryDiscord()
+
+    const response = await Effect.runPromise(
+      handleToolRequest(
+        {
+          action: "followUpMessage",
+          target: { guildId: "g1", channelId: "c1" },
+          args: { content: "@everyone @here <@&123>" }
+        },
+        defaultConfig,
+        "/repo",
+        discord
+      )
+    )
+
+    expect(response.ok).toBe(true)
+    expect(discord.messages).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, content: "@ everyone @ here <@& 123>" }])
+  })
+
+  test("blocks higher-risk actions unless explicitly enabled", async () => {
+    const response = await Effect.runPromise(
+      handleToolRequest(
+        { action: "createThread", target: { guildId: "g1", channelId: "c1" }, args: { name: "new" } },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+
+    expect(response).toEqual({ ok: false, error: "Action createThread is disabled" })
+  })
+
+  test("rejects DMs and unsafe attachment paths", async () => {
+    const dm = await Effect.runPromise(
+      handleToolRequest(
+        { action: "followUpMessage", target: { channelId: "dm1" }, args: { content: "nope" } },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+    const unsafe = await Effect.runPromise(
+      handleToolRequest(
+        { action: "attachFile", target: { guildId: "g1", channelId: "c1" }, args: { path: "../secret.txt" } },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+
+    expect(dm.ok).toBe(false)
+    expect(unsafe).toEqual({ ok: false, error: "Attachment path must stay inside the project directory" })
+  })
+})
+
+describe("handleToolRequest action dispatch", () => {
+  test("dispatches reactions, history, and safe attachments", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tool-"))
+    await mkdir(join(projectDir, "out"), { recursive: true })
+    await writeFile(join(projectDir, "out", "report.txt"), "report")
+    const discord = makeMemoryDiscord({
+      context: [
+        {
+          id: "m1",
+          guildId: "g1",
+          channelId: "c1",
+          author: { id: "u1", displayName: "Alice", isBot: false },
+          content: "hi",
+          timestamp: "2026-06-05T14:03:00.000Z",
+          mentions: [],
+          roleMentions: [],
+          everyoneMention: false,
+          hereMention: false,
+          attachments: [],
+          reactions: [],
+          channelType: "guild"
+        }
+      ]
+    })
+
+    try {
+      const add = await Effect.runPromise(
+        handleToolRequest(
+          { action: "addReaction", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { emoji: "rocket" } },
+          defaultConfig,
+          projectDir,
+          discord
+        )
+      )
+      const remove = await Effect.runPromise(
+        handleToolRequest(
+          { action: "removeReaction", target: { guildId: "g1", channelId: "c1", messageId: "m1" }, args: { emoji: "rocket" } },
+          defaultConfig,
+          projectDir,
+          discord
+        )
+      )
+      const history = await Effect.runPromise(
+        handleToolRequest(
+          { action: "fetchHistory", target: { guildId: "g1", channelId: "c1" }, args: { limit: 1 } },
+          defaultConfig,
+          projectDir,
+          discord
+        )
+      )
+      const attach = await Effect.runPromise(
+        handleToolRequest(
+          { action: "attachFile", target: { guildId: "g1", channelId: "c1" }, args: { path: "out/report.txt" } },
+          defaultConfig,
+          projectDir,
+          discord
+        )
+      )
+      const attachmentRealpath = await realpath(join(projectDir, "out", "report.txt"))
+
+      expect(add).toEqual({ ok: true, result: { reacted: true } })
+      expect(remove).toEqual({ ok: true, result: { reacted: false } })
+      expect(history.ok).toBe(true)
+      expect(attach).toEqual({ ok: true, result: { path: attachmentRealpath } })
+      expect(discord.reactions.map((item) => item.op)).toEqual(["add", "remove"])
+      expect(discord.attachments).toEqual([{ scope: { guildId: "g1", channelId: "c1" }, path: attachmentRealpath }])
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+
+  test("rejects oversized attachments", async () => {
+    const projectDir = await mkdtemp(join(tmpdir(), "ocdb-tool-large-"))
+    await writeFile(join(projectDir, "large.txt"), "large")
+
+    try {
+      const response = await Effect.runPromise(
+        handleToolRequest(
+          { action: "attachFile", target: { guildId: "g1", channelId: "c1" }, args: { path: "large.txt" } },
+          { ...defaultConfig, context: { ...defaultConfig.context, attachmentMaxBytes: 1 } },
+          projectDir,
+          makeMemoryDiscord()
+        )
+      )
+
+      expect(response).toEqual({ ok: false, error: "Attachment exceeds the configured size limit" })
+    } finally {
+      await rm(projectDir, { recursive: true, force: true })
+    }
+  })
+
+  test("rejects default tool targets outside the active turn scope", async () => {
+    const response = await Effect.runPromise(
+      handleToolRequest(
+        { action: "followUpMessage", target: { guildId: "g1", channelId: "other" }, args: { content: "nope" } },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord(),
+        { allowedScopes: [{ guildId: "g1", channelId: "c1" }] }
+      )
+    )
+
+    expect(response).toEqual({ ok: false, error: "Discord target is outside the active turn scope" })
+  })
+
+  test("returns validation errors for malformed or unsupported requests", async () => {
+    const disabled = await Effect.runPromise(
+      handleToolRequest(
+        { action: "followUpMessage", target: { guildId: "g1", channelId: "c1" }, args: { content: "x" } },
+        withTools({ enabled: false }),
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+    const unknown = await Effect.runPromise(
+      handleToolRequest(
+        { action: "unknown", target: { guildId: "g1", channelId: "c1" }, args: {} },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+    const missingContent = await Effect.runPromise(
+      handleToolRequest(
+        { action: "followUpMessage", target: { guildId: "g1", channelId: "c1" }, args: {} },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+    const missingReactionFields = await Effect.runPromise(
+      handleToolRequest(
+        { action: "addReaction", target: { guildId: "g1", channelId: "c1" }, args: {} },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+    const missingPath = await Effect.runPromise(
+      handleToolRequest(
+        { action: "attachFile", target: { guildId: "g1", channelId: "c1" }, args: {} },
+        defaultConfig,
+        "/repo",
+        makeMemoryDiscord()
+      )
+    )
+
+    expect(disabled).toEqual({ ok: false, error: "Discord bridge tools are disabled" })
+    expect(unknown).toEqual({ ok: false, error: "Unknown action unknown" })
+    expect(missingContent).toEqual({ ok: false, error: "content is required" })
+    expect(missingReactionFields).toEqual({ ok: false, error: "messageId and emoji are required" })
+    expect(missingPath).toEqual({ ok: false, error: "path is required" })
+  })
+})