opencode-discord-bot 0.0.1

package/src/Discord/DiscordJsDiscord.test.ts

@@ -0,0 +1,208 @@
+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 { Effect } from "effect"
+import type { DiscordScope } from "../Schema.ts"
+import { type DiscordJsChannelLike, fromDiscordJsMessage, makeDiscordJsDiscord } from "./DiscordJsDiscord.ts"
+
+const collection = <A>(items: ReadonlyArray<A>) => ({ values: () => items[Symbol.iterator]() })
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+const baseMessage = (
+  overrides: { readonly guildId?: string | null; readonly channelId?: string; readonly channel?: DiscordJsChannelLike } = {}
+) => ({
+  id: "m1",
+  guildId: overrides.guildId ?? "g1",
+  channelId: overrides.channelId ?? "c1",
+  channel: overrides.channel ?? { id: "c1", isDMBased: () => false, isThread: () => false },
+  author: { id: "u1", username: "alice", globalName: null, displayName: "Alice", bot: false },
+  member: { nickname: null },
+  content: "hello @here",
+  createdAt: new Date("2026-06-05T14:03:00.000Z"),
+  mentions: { users: collection([{ id: "u2" }]), roles: collection([{ id: "r1" }]), everyone: true },
+  attachments: collection([{ id: "a1", name: "a.txt", contentType: null, size: 4, url: "https://example.test/a.txt" }]),
+  reactions: { cache: collection([{ emoji: { name: null }, count: 1 }]) },
+  system: false,
+  inGuild: () => overrides.guildId !== null
+})
+
+describe("fromDiscordJsMessage", () => {
+  test("maps guild and thread messages and ignores non-guild messages", () => {
+    expect(fromDiscordJsMessage(baseMessage())).toEqual({
+      id: "m1",
+      guildId: "g1",
+      channelId: "c1",
+      author: { id: "u1", displayName: "Alice", isBot: false },
+      content: "hello @here",
+      timestamp: "2026-06-05T14:03:00.000Z",
+      mentions: ["u2"],
+      roleMentions: ["r1"],
+      everyoneMention: true,
+      hereMention: true,
+      attachments: [{ id: "a1", filename: "a.txt", size: 4, url: "https://example.test/a.txt" }],
+      reactions: [{ emoji: "unknown", count: 1 }],
+      channelType: "guild",
+      isSystem: false
+    })
+    expect(
+      fromDiscordJsMessage(baseMessage({ channelId: "t1", channel: { id: "t1", parentId: "c1", isThread: () => true } }))
+    ).toMatchObject({
+      channelId: "c1",
+      threadId: "t1"
+    })
+    expect(fromDiscordJsMessage(baseMessage({ guildId: null, channel: { id: "dm1", isDMBased: () => true } }))).toBeUndefined()
+  })
+})
+
+describe("makeDiscordJsDiscord", () => {
+  test("routes port operations through a discord.js-like client", async () => {
+    const calls: Array<readonly [string, unknown]> = []
+    const fetchedMessage = {
+      ...baseMessage(),
+      edit: (content: string) => {
+        calls.push(["edit", content])
+        return Promise.resolve({})
+      },
+      delete: () => {
+        calls.push(["delete", {}])
+        return Promise.resolve({})
+      },
+      pin: () => {
+        calls.push(["pin", {}])
+        return Promise.resolve({})
+      },
+      unpin: () => {
+        calls.push(["unpin", {}])
+        return Promise.resolve({})
+      },
+      react: (emoji: string) => {
+        calls.push(["react", emoji])
+        return Promise.resolve({})
+      },
+      reactions: {
+        cache: collection([{ emoji: { name: "rocket" }, count: 2 }]),
+        resolve: (emoji: string) => ({
+          users: { remove: (userId: string) => Promise.resolve(calls.push(["removeReaction", { emoji, userId }])) }
+        })
+      }
+    }
+    const channel = {
+      send: (content: unknown) => {
+        calls.push(["send", content])
+        return Promise.resolve({ id: "posted-1" })
+      },
+      sendTyping: () => {
+        calls.push(["typing", {}])
+        return Promise.resolve()
+      },
+      messages: {
+        fetch: (query: string | { readonly limit: number }) => {
+          calls.push(["fetchMessages", query])
+          return Promise.resolve(typeof query === "string" ? fetchedMessage : collection([baseMessage()]))
+        }
+      },
+      threads: {
+        create: (options: { readonly name: string }) => {
+          calls.push(["createThread", options])
+          return Promise.resolve({ id: "thread-1" })
+        }
+      }
+    }
+    const client = {
+      user: { id: "bot-1" },
+      channels: {
+        fetch: (id: string) => {
+          calls.push(["fetchChannel", id])
+          return Promise.resolve(channel)
+        }
+      }
+    }
+    const discord = makeDiscordJsDiscord(client)
+    const directory = await mkdtemp(join(tmpdir(), "ocdb-discordjs-"))
+
+    try {
+      const file = join(directory, "upload.txt")
+      await writeFile(file, "upload")
+      const context = await Effect.runPromise(discord.fetchContext(scope, 1))
+      const history = await Effect.runPromise(discord.fetchHistory(scope, 1))
+      await Effect.runPromise(discord.sendTyping(scope))
+      const posted = await Effect.runPromise(discord.postMessage(scope, "hello"))
+      await Effect.runPromise(discord.editMessage(scope, "m1", "edited"))
+      await Effect.runPromise(discord.deleteMessage(scope, "m1"))
+      await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
+      await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
+      const attached = await Effect.runPromise(discord.attachFile(scope, file))
+      expect(await Effect.runPromise(discord.createThread(scope, "work"))).toEqual({ id: "thread-1" })
+      expect(await Effect.runPromise(discord.postChannelMessage("g1", "c2", "hello"))).toEqual({ id: "posted-1" })
+      await Effect.runPromise(discord.pinMessage(scope, "m1"))
+      await Effect.runPromise(discord.unpinMessage(scope, "m1"))
+
+      expect(context).toHaveLength(1)
+      expect(history).toHaveLength(1)
+      expect(posted).toEqual({ id: "posted-1" })
+      expect(attached).toEqual({ path: "posted-1" })
+      expect(calls.map((call) => call[0])).toContain("removeReaction")
+      expect(calls.map((call) => call[0])).toContain("delete")
+      expect(calls.map((call) => call[0])).toContain("createThread")
+      expect(calls.map((call) => call[0])).toContain("pin")
+      expect(calls.map((call) => call[0])).toContain("unpin")
+    } finally {
+      await rm(directory, { recursive: true, force: true })
+    }
+  })
+
+  test("fails when a fetched channel is not text-capable", async () => {
+    const discord = makeDiscordJsDiscord({ user: { id: "bot-1" }, channels: { fetch: () => Promise.resolve({}) } })
+
+    await expect(Effect.runPromise(discord.postMessage(scope, "hello"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord channel is not text-capable"
+    })
+  })
+
+  test("rejects DM-based output targets", async () => {
+    const channel = {
+      isDMBased: () => true,
+      send: () => Promise.resolve({ id: "posted-1" }),
+      messages: { fetch: () => Promise.resolve(collection([])) }
+    }
+    const discord = makeDiscordJsDiscord({ user: { id: "bot-1" }, channels: { fetch: () => Promise.resolve(channel) } })
+
+    await expect(Effect.runPromise(discord.postMessage(scope, "hello"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord DMs are not supported"
+    })
+  })
+
+  test("fails high-risk operations on unsupported channels and messages", async () => {
+    const fetchedMessage = {
+      ...baseMessage(),
+      edit: () => Promise.resolve({}),
+      react: () => Promise.resolve({}),
+      reactions: { resolve: () => null }
+    }
+    const channel = {
+      send: () => Promise.resolve({ id: "posted-1" }),
+      messages: { fetch: () => Promise.resolve(fetchedMessage) }
+    }
+    const discord = makeDiscordJsDiscord({ user: { id: "bot-1" }, channels: { fetch: () => Promise.resolve(channel) } })
+
+    await expect(Effect.runPromise(discord.createThread(scope, "work"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord channel cannot create threads"
+    })
+    await expect(Effect.runPromise(discord.pinMessage(scope, "m1"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord message is not pinnable"
+    })
+    await expect(Effect.runPromise(discord.unpinMessage(scope, "m1"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord message is not unpinnable"
+    })
+    await expect(Effect.runPromise(discord.deleteMessage(scope, "m1"))).rejects.toMatchObject({
+      _tag: "DiscordError",
+      message: "Discord message is not deletable"
+    })
+  })
+})

package/src/Discord/DiscordJsDiscord.ts

@@ -0,0 +1,267 @@
+import { readFile } from "node:fs/promises"
+import { basename } from "node:path"
+import { Effect } from "effect"
+import type { DiscordAttachment, DiscordMessage, DiscordReaction, DiscordScope } from "../Schema.ts"
+import { DiscordError, type DiscordService } from "./DiscordPort.ts"
+
+type CollectionLike<A> = {
+  readonly values: () => IterableIterator<A>
+}
+
+type AttachmentLike = {
+  readonly id: string
+  readonly name: string
+  readonly contentType: string | null
+  readonly size: number
+  readonly url: string
+}
+
+type ReactionLike = {
+  readonly emoji: { readonly name: string | null; readonly identifier?: string }
+  readonly count: number
+}
+
+type AuthorLike = {
+  readonly id: string
+  readonly displayName?: string
+  readonly globalName?: string | null
+  readonly username: string
+  readonly bot: boolean
+}
+
+export type DiscordJsMessageLike = {
+  readonly id: string
+  readonly guildId: string | null
+  readonly channelId: string
+  readonly channel: DiscordJsChannelLike
+  readonly author: AuthorLike
+  readonly member?: { readonly nickname: string | null } | null
+  readonly content: string
+  readonly createdAt: Date
+  readonly mentions: {
+    readonly users: CollectionLike<{ readonly id: string }>
+    readonly roles: CollectionLike<{ readonly id: string }>
+    readonly everyone: boolean
+  }
+  readonly attachments: CollectionLike<AttachmentLike>
+  readonly reactions: { readonly cache: CollectionLike<ReactionLike> }
+  readonly system: boolean
+  readonly inGuild?: () => boolean
+}
+
+type DiscordPostedLike = {
+  readonly id: string
+}
+
+type DiscordFetchedMessageLike = DiscordJsMessageLike & {
+  readonly edit: (content: string) => Promise<unknown>
+  readonly react: (emoji: string) => Promise<unknown>
+  readonly delete?: () => Promise<unknown>
+  readonly pin?: () => Promise<unknown>
+  readonly unpin?: () => Promise<unknown>
+  readonly reactions: DiscordJsMessageLike["reactions"] & {
+    readonly resolve: (emoji: string) => { readonly users: { readonly remove: (userId: string) => Promise<unknown> } } | null
+  }
+}
+
+export type DiscordJsChannelLike = {
+  readonly id: string
+  readonly parentId?: string | null
+  readonly isDMBased?: () => boolean
+  readonly isThread?: () => boolean
+  readonly send?: (
+    content: string | { readonly files: ReadonlyArray<{ readonly attachment: Uint8Array; readonly name: string }> }
+  ) => Promise<DiscordPostedLike>
+  readonly sendTyping?: () => Promise<void>
+  readonly threads?: {
+    readonly create: (input: { readonly name: string }) => Promise<{ readonly id: string }>
+  }
+  readonly messages?: {
+    readonly fetch: (
+      query: string | { readonly limit: number }
+    ) => Promise<DiscordFetchedMessageLike | CollectionLike<DiscordJsMessageLike>>
+  }
+}
+
+export type DiscordJsClientLike = {
+  readonly user: { readonly id: string } | null
+  readonly channels: {
+    readonly fetch: (id: string) => Promise<unknown>
+  }
+}
+
+const isObject = (value: unknown): value is object => typeof value === "object" && value !== null
+
+const hasMethod = (value: object, key: string): boolean => typeof Reflect.get(value, key) === "function"
+
+const isTextChannel = (value: unknown): value is Required<Pick<DiscordJsChannelLike, "send" | "messages">> & DiscordJsChannelLike =>
+  isObject(value) &&
+  hasMethod(value, "send") &&
+  isObject(Reflect.get(value, "messages")) &&
+  hasMethod(Reflect.get(value, "messages"), "fetch")
+
+const isCollectionLike = <A>(value: unknown): value is CollectionLike<A> => isObject(value) && hasMethod(value, "values")
+
+const isFetchedMessage = (value: unknown): value is DiscordFetchedMessageLike =>
+  isObject(value) && hasMethod(value, "edit") && hasMethod(value, "react")
+
+const fromCollection = <A>(collection: CollectionLike<A>): ReadonlyArray<A> => [...collection.values()]
+
+const channelTargetId = (scope: DiscordScope): string => scope.threadId ?? scope.channelId
+
+const channelScope = (message: DiscordJsMessageLike): DiscordScope | undefined => {
+  if (message.guildId === null) return undefined
+  const channel = message.channel
+  if (channel.isDMBased?.() === true) return undefined
+  if (channel.isThread?.() === true) {
+    return { guildId: message.guildId, channelId: channel.parentId ?? message.channelId, threadId: message.channelId }
+  }
+  return { guildId: message.guildId, channelId: message.channelId }
+}
+
+const attachment = (item: AttachmentLike): DiscordAttachment => ({
+  id: item.id,
+  filename: item.name,
+  ...(item.contentType === null ? {} : { contentType: item.contentType }),
+  size: item.size,
+  url: item.url
+})
+
+const reaction = (item: ReactionLike): DiscordReaction => ({
+  emoji: item.emoji.identifier ?? item.emoji.name ?? "unknown",
+  count: item.count
+})
+
+export const fromDiscordJsMessage = (message: DiscordJsMessageLike): DiscordMessage | undefined => {
+  if (message.inGuild?.() === false) return undefined
+  const scope = channelScope(message)
+  if (scope === undefined) return undefined
+
+  return {
+    id: message.id,
+    ...scope,
+    author: {
+      id: message.author.id,
+      displayName: message.author.displayName ?? message.author.globalName ?? message.author.username,
+      ...(message.member?.nickname === undefined || message.member.nickname === null ? {} : { nickname: message.member.nickname }),
+      isBot: message.author.bot
+    },
+    content: message.content,
+    timestamp: message.createdAt.toISOString(),
+    mentions: fromCollection(message.mentions.users).map((user) => user.id),
+    roleMentions: fromCollection(message.mentions.roles).map((role) => role.id),
+    everyoneMention: message.mentions.everyone,
+    hereMention: message.content.includes("@here"),
+    attachments: fromCollection(message.attachments).map(attachment),
+    reactions: fromCollection(message.reactions.cache).map(reaction),
+    channelType: "guild",
+    isSystem: message.system
+  }
+}
+
+const tryDiscord = <A>(operation: () => Promise<A>): Effect.Effect<A, DiscordError> =>
+  Effect.tryPromise({
+    try: operation,
+    catch: (cause) => new DiscordError({ message: cause instanceof Error ? cause.message : "Discord operation failed" })
+  })
+
+const fetchTextChannel = (
+  client: DiscordJsClientLike,
+  scope: DiscordScope
+): Effect.Effect<Required<Pick<DiscordJsChannelLike, "send" | "messages">> & DiscordJsChannelLike, DiscordError> =>
+  tryDiscord(async () => {
+    const channel = await client.channels.fetch(channelTargetId(scope))
+    if (!isTextChannel(channel)) throw new Error("Discord channel is not text-capable")
+    if (channel.isDMBased?.() === true) throw new Error("Discord DMs are not supported")
+    return channel
+  })
+
+const fetchMessage = (
+  client: DiscordJsClientLike,
+  scope: DiscordScope,
+  messageId: string
+): Effect.Effect<DiscordFetchedMessageLike, DiscordError> =>
+  Effect.gen(function* () {
+    const channel = yield* fetchTextChannel(client, scope)
+    const message = yield* tryDiscord(() => channel.messages.fetch(messageId))
+    if (!isFetchedMessage(message)) return yield* Effect.fail(new DiscordError({ message: "Discord message is not editable/reactable" }))
+    return message
+  })
+
+export const makeDiscordJsDiscord = (client: DiscordJsClientLike): DiscordService => ({
+  fetchContext: (scope, limit) =>
+    Effect.gen(function* () {
+      const channel = yield* fetchTextChannel(client, scope)
+      const result = yield* tryDiscord(() => channel.messages.fetch({ limit }))
+      if (!isCollectionLike<DiscordJsMessageLike>(result)) return []
+      return fromCollection(result).flatMap((message) => {
+        const mapped = fromDiscordJsMessage(message)
+        return mapped === undefined ? [] : [mapped]
+      })
+    }),
+  fetchHistory: (scope, limit) => makeDiscordJsDiscord(client).fetchContext(scope, limit),
+  sendTyping: (scope) =>
+    Effect.gen(function* () {
+      const channel = yield* fetchTextChannel(client, scope)
+      if (channel.sendTyping !== undefined) yield* tryDiscord(() => channel.sendTyping?.() ?? Promise.resolve())
+    }),
+  postMessage: (scope, content) =>
+    Effect.gen(function* () {
+      const channel = yield* fetchTextChannel(client, scope)
+      const result = yield* tryDiscord(() => channel.send(content))
+      return { id: result.id }
+    }),
+  editMessage: (scope, messageId, content) =>
+    Effect.gen(function* () {
+      const message = yield* fetchMessage(client, scope, messageId)
+      yield* tryDiscord(() => message.edit(content))
+    }),
+  deleteMessage: (scope, messageId) =>
+    Effect.gen(function* () {
+      const message = yield* fetchMessage(client, scope, messageId)
+      if (message.delete === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord message is not deletable" }))
+      yield* tryDiscord(() => message.delete?.() ?? Promise.resolve())
+    }),
+  addReaction: (scope, messageId, emoji) =>
+    Effect.gen(function* () {
+      const message = yield* fetchMessage(client, scope, messageId)
+      yield* tryDiscord(() => message.react(emoji))
+    }),
+  removeReaction: (scope, messageId, emoji) =>
+    Effect.gen(function* () {
+      const message = yield* fetchMessage(client, scope, messageId)
+      const reaction = message.reactions.resolve(emoji)
+      if (reaction !== null && client.user !== null) yield* tryDiscord(() => reaction.users.remove(client.user?.id ?? ""))
+    }),
+  attachFile: (scope, path) =>
+    Effect.gen(function* () {
+      const channel = yield* fetchTextChannel(client, scope)
+      const data = yield* tryDiscord(() => readFile(path))
+      const result = yield* tryDiscord(() => channel.send({ files: [{ attachment: data, name: basename(path) }] }))
+      return { path: result.id }
+    }),
+  createThread: (scope, name) =>
+    Effect.gen(function* () {
+      const channel = yield* fetchTextChannel(client, scope)
+      if (channel.threads === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord channel cannot create threads" }))
+      return yield* tryDiscord(() => channel.threads?.create({ name }) ?? Promise.resolve({ id: "" }))
+    }),
+  postChannelMessage: (_guildId, channelId, content) =>
+    Effect.gen(function* () {
+      const channel = yield* fetchTextChannel(client, { guildId: _guildId, channelId })
+      const result = yield* tryDiscord(() => channel.send(content))
+      return { id: result.id }
+    }),
+  pinMessage: (scope, messageId) =>
+    Effect.gen(function* () {
+      const message = yield* fetchMessage(client, scope, messageId)
+      if (message.pin === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord message is not pinnable" }))
+      yield* tryDiscord(() => message.pin?.() ?? Promise.resolve())
+    }),
+  unpinMessage: (scope, messageId) =>
+    Effect.gen(function* () {
+      const message = yield* fetchMessage(client, scope, messageId)
+      if (message.unpin === undefined) return yield* Effect.fail(new DiscordError({ message: "Discord message is not unpinnable" }))
+      yield* tryDiscord(() => message.unpin?.() ?? Promise.resolve())
+    })
+})

package/src/Discord/DiscordPort.ts

@@ -0,0 +1,30 @@
+import { Context, Data, type Duration, type Effect } from "effect"
+import type { DiscordMessage, DiscordScope } from "../Schema.ts"
+
+export class DiscordError extends Data.TaggedError("DiscordError")<{
+  readonly message: string
+  readonly retryAfter?: Duration.Duration | undefined
+}> {}
+
+export type DiscordPostedMessage = {
+  readonly scope: DiscordScope
+  readonly content: string
+}
+
+export type DiscordService = {
+  readonly fetchContext: (scope: DiscordScope, limit: number) => Effect.Effect<ReadonlyArray<DiscordMessage>, DiscordError>
+  readonly sendTyping: (scope: DiscordScope) => Effect.Effect<void, DiscordError>
+  readonly postMessage: (scope: DiscordScope, content: string) => Effect.Effect<{ readonly id: string }, DiscordError>
+  readonly editMessage: (scope: DiscordScope, messageId: string, content: string) => Effect.Effect<void, DiscordError>
+  readonly addReaction: (scope: DiscordScope, messageId: string, emoji: string) => Effect.Effect<void, DiscordError>
+  readonly removeReaction: (scope: DiscordScope, messageId: string, emoji: string) => Effect.Effect<void, DiscordError>
+  readonly fetchHistory: (scope: DiscordScope, limit: number) => Effect.Effect<ReadonlyArray<DiscordMessage>, DiscordError>
+  readonly attachFile: (scope: DiscordScope, path: string) => Effect.Effect<{ readonly path: string }, DiscordError>
+  readonly createThread: (scope: DiscordScope, name: string) => Effect.Effect<{ readonly id: string }, DiscordError>
+  readonly deleteMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
+  readonly postChannelMessage: (guildId: string, channelId: string, content: string) => Effect.Effect<{ readonly id: string }, DiscordError>
+  readonly pinMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
+  readonly unpinMessage: (scope: DiscordScope, messageId: string) => Effect.Effect<void, DiscordError>
+}
+
+export const Discord = Context.Service<DiscordService>("opencode-discord-bot/Discord")

package/src/Discord/MemoryDiscord.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import type { DiscordMessage, DiscordScope } from "../Schema.ts"
+import { makeMemoryDiscord } from "./MemoryDiscord.ts"
+
+const scope: DiscordScope = { guildId: "g1", channelId: "c1" }
+
+const message = (id: string): DiscordMessage => ({
+  id,
+  guildId: "g1",
+  channelId: "c1",
+  author: { id: "u1", displayName: "Alice", isBot: false },
+  content: id,
+  timestamp: "2026-06-05T14:03:00.000Z",
+  mentions: [],
+  roleMentions: [],
+  everyoneMention: false,
+  hereMention: false,
+  attachments: [],
+  reactions: [],
+  channelType: "guild"
+})
+
+describe("makeMemoryDiscord", () => {
+  test("records every Discord port operation", async () => {
+    const discord = makeMemoryDiscord({ context: [message("1"), message("2")] })
+
+    const context = await Effect.runPromise(discord.fetchContext(scope, 1))
+    const history = await Effect.runPromise(discord.fetchHistory(scope, 2))
+    const posted = await Effect.runPromise(discord.postMessage(scope, "hello"))
+    await Effect.runPromise(discord.editMessage(scope, posted.id, "updated"))
+    await Effect.runPromise(discord.addReaction(scope, "m1", "rocket"))
+    await Effect.runPromise(discord.removeReaction(scope, "m1", "rocket"))
+    const attached = await Effect.runPromise(discord.attachFile(scope, "/repo/out.txt"))
+
+    expect(context.map((item) => item.id)).toEqual(["2"])
+    expect(history.map((item) => item.id)).toEqual(["1", "2"])
+    expect(posted).toEqual({ id: "posted-1" })
+    expect(discord.messages).toEqual([{ scope, content: "hello" }])
+    expect(discord.edits).toEqual([{ scope, messageId: "posted-1", content: "updated" }])
+    expect(discord.reactions.map((item) => item.op)).toEqual(["add", "remove"])
+    expect(attached).toEqual({ path: "/repo/out.txt" })
+  })
+})

package/src/Discord/MemoryDiscord.ts

@@ -0,0 +1,85 @@
+import { Effect } from "effect"
+import type { DiscordMessage, DiscordScope } from "../Schema.ts"
+import type { DiscordPostedMessage, DiscordService } from "./DiscordPort.ts"
+
+type MemoryOptions = {
+  readonly context?: ReadonlyArray<DiscordMessage>
+}
+
+export type MemoryDiscord = DiscordService & {
+  readonly context: Array<DiscordMessage>
+  readonly typingScopes: Array<DiscordScope>
+  readonly messages: Array<DiscordPostedMessage>
+  readonly edits: Array<{ readonly scope: DiscordScope; readonly messageId: string; readonly content: string }>
+  readonly reactions: Array<{
+    readonly scope: DiscordScope
+    readonly messageId: string
+    readonly emoji: string
+    readonly op: "add" | "remove"
+  }>
+  readonly attachments: Array<{ readonly scope: DiscordScope; readonly path: string }>
+  readonly threads: Array<{ readonly scope: DiscordScope; readonly name: string }>
+  readonly deletes: Array<{ readonly scope: DiscordScope; readonly messageId: string }>
+  readonly channelMessages: Array<{ readonly guildId: string; readonly channelId: string; readonly content: string }>
+  readonly pins: Array<{ readonly scope: DiscordScope; readonly messageId: string; readonly op: "pin" | "unpin" }>
+}
+
+export const makeMemoryDiscord = (options: MemoryOptions = {}): MemoryDiscord => {
+  let nextId = 0
+  const context = [...(options.context ?? [])]
+  const typingScopes: Array<DiscordScope> = []
+  const messages: Array<DiscordPostedMessage> = []
+  const edits: MemoryDiscord["edits"] = []
+  const reactions: MemoryDiscord["reactions"] = []
+  const attachments: MemoryDiscord["attachments"] = []
+  const threads: MemoryDiscord["threads"] = []
+  const deletes: MemoryDiscord["deletes"] = []
+  const channelMessages: MemoryDiscord["channelMessages"] = []
+  const pins: MemoryDiscord["pins"] = []
+
+  return {
+    context,
+    typingScopes,
+    messages,
+    edits,
+    reactions,
+    attachments,
+    threads,
+    deletes,
+    channelMessages,
+    pins,
+    fetchContext: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
+    sendTyping: (scope) => Effect.sync(() => typingScopes.push(scope)).pipe(Effect.asVoid),
+    postMessage: (scope, content) =>
+      Effect.sync(() => {
+        nextId += 1
+        messages.push({ scope, content })
+        return { id: `posted-${nextId}` }
+      }),
+    editMessage: (scope, messageId, content) => Effect.sync(() => edits.push({ scope, messageId, content })).pipe(Effect.asVoid),
+    addReaction: (scope, messageId, emoji) => Effect.sync(() => reactions.push({ scope, messageId, emoji, op: "add" })).pipe(Effect.asVoid),
+    removeReaction: (scope, messageId, emoji) =>
+      Effect.sync(() => reactions.push({ scope, messageId, emoji, op: "remove" })).pipe(Effect.asVoid),
+    fetchHistory: (_scope, limit) => Effect.succeed(context.slice(Math.max(0, context.length - limit))),
+    attachFile: (scope, path) =>
+      Effect.sync(() => {
+        attachments.push({ scope, path })
+        return { path }
+      }),
+    createThread: (scope, name) =>
+      Effect.sync(() => {
+        nextId += 1
+        threads.push({ scope, name })
+        return { id: `thread-${nextId}` }
+      }),
+    deleteMessage: (scope, messageId) => Effect.sync(() => deletes.push({ scope, messageId })).pipe(Effect.asVoid),
+    postChannelMessage: (guildId, channelId, content) =>
+      Effect.sync(() => {
+        nextId += 1
+        channelMessages.push({ guildId, channelId, content })
+        return { id: `posted-${nextId}` }
+      }),
+    pinMessage: (scope, messageId) => Effect.sync(() => pins.push({ scope, messageId, op: "pin" })).pipe(Effect.asVoid),
+    unpinMessage: (scope, messageId) => Effect.sync(() => pins.push({ scope, messageId, op: "unpin" })).pipe(Effect.asVoid)
+  }
+}

package/src/Discord/Safety.ts

@@ -0,0 +1,11 @@
+export type DiscordOutputGuards = {
+  readonly stripMassMentions: boolean
+}
+
+export const sanitizeDiscordContent = (content: string, guards: DiscordOutputGuards): string => {
+  if (!guards.stripMassMentions) return content
+  return content
+    .replaceAll("@everyone", "@ everyone")
+    .replaceAll("@here", "@ here")
+    .replace(/<@&(\d+)>/g, "<@& $1>")
+}