@gakr-gakr/discord 0.1.0

package/src/monitor/listeners.ts

@@ -0,0 +1,150 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { danger } from "autobot/plugin-sdk/runtime-env";
+import {
+  type Client,
+  InteractionCreateListener,
+  MessageCreateListener,
+  PresenceUpdateListener,
+  ThreadUpdateListener,
+} from "../internal/discord.js";
+import { discordEventQueueLog, runDiscordListenerWithSlowLog } from "./listeners.queue.js";
+export { DiscordReactionListener, DiscordReactionRemoveListener } from "./listeners.reactions.js";
+import { setPresence } from "./presence-cache.js";
+import { isThreadArchived } from "./thread-bindings.discord-api.js";
+import { closeDiscordThreadSessions } from "./thread-session-close.js";
+
+type Logger = ReturnType<typeof import("autobot/plugin-sdk/runtime-env").createSubsystemLogger>;
+
+export type DiscordMessageEvent = Parameters<MessageCreateListener["handle"]>[0];
+export type DiscordInteractionEvent = Parameters<InteractionCreateListener["handle"]>[0];
+
+export type DiscordMessageHandler = (
+  data: DiscordMessageEvent,
+  client: Client,
+  options?: { abortSignal?: AbortSignal },
+) => Promise<void>;
+
+export function registerDiscordListener(listeners: Array<object>, listener: object) {
+  if (listeners.some((existing) => existing.constructor === listener.constructor)) {
+    return false;
+  }
+  listeners.push(listener);
+  return true;
+}
+
+export class DiscordMessageListener extends MessageCreateListener {
+  constructor(
+    private handler: DiscordMessageHandler,
+    private logger?: Logger,
+    private onEvent?: () => void,
+  ) {
+    super();
+  }
+
+  async handle(data: DiscordMessageEvent, client: Client) {
+    this.onEvent?.();
+    // Fire-and-forget: hand off to the handler without blocking gateway dispatch.
+    // Per-session ordering is owned by the message run queue.
+    void Promise.resolve()
+      .then(() => this.handler(data, client))
+      .catch((err) => {
+        const logger = this.logger ?? discordEventQueueLog;
+        logger.error(danger(`discord handler failed: ${String(err)}`));
+      });
+  }
+}
+
+export class DiscordInteractionListener extends InteractionCreateListener {
+  constructor(
+    private logger?: Logger,
+    private onEvent?: () => void,
+  ) {
+    super();
+  }
+
+  async handle(data: DiscordInteractionEvent, client: Client) {
+    this.onEvent?.();
+    // Hand off immediately so slash/component handling can wait on session locks
+    // or compaction without blocking later gateway events.
+    void Promise.resolve()
+      .then(() => client.handleInteraction(data as Parameters<Client["handleInteraction"]>[0], {}))
+      .catch((err) => {
+        const logger = this.logger ?? discordEventQueueLog;
+        logger.error(danger(`discord interaction handler failed: ${String(err)}`));
+      });
+  }
+}
+
+type PresenceUpdateEvent = Parameters<PresenceUpdateListener["handle"]>[0];
+
+export class DiscordPresenceListener extends PresenceUpdateListener {
+  private logger?: Logger;
+  private accountId?: string;
+
+  constructor(params: { logger?: Logger; accountId?: string }) {
+    super();
+    this.logger = params.logger;
+    this.accountId = params.accountId;
+  }
+
+  async handle(data: PresenceUpdateEvent) {
+    try {
+      const userId =
+        "user" in data && data.user && typeof data.user === "object" && "id" in data.user
+          ? data.user.id
+          : undefined;
+      if (!userId) {
+        return;
+      }
+      setPresence(this.accountId, userId, data);
+    } catch (err) {
+      const logger = this.logger ?? discordEventQueueLog;
+      logger.error(danger(`discord presence handler failed: ${String(err)}`));
+    }
+  }
+}
+
+type ThreadUpdateEvent = Parameters<ThreadUpdateListener["handle"]>[0];
+
+export class DiscordThreadUpdateListener extends ThreadUpdateListener {
+  constructor(
+    private cfg: AutoBotConfig,
+    private accountId: string,
+    private logger?: Logger,
+  ) {
+    super();
+  }
+
+  async handle(data: ThreadUpdateEvent) {
+    await runDiscordListenerWithSlowLog({
+      logger: this.logger,
+      listener: this.constructor.name,
+      event: this.type,
+      run: async () => {
+        // Discord only fires THREAD_UPDATE when a field actually changes, so
+        // `thread_metadata.archived === true` in this payload means the thread
+        // just transitioned to the archived state.
+        if (!isThreadArchived(data)) {
+          return;
+        }
+        const threadId = "id" in data && typeof data.id === "string" ? data.id : undefined;
+        if (!threadId) {
+          return;
+        }
+        const logger = this.logger ?? discordEventQueueLog;
+        const count = await closeDiscordThreadSessions({
+          cfg: this.cfg,
+          accountId: this.accountId,
+          threadId,
+        });
+        if (count > 0) {
+          logger.info("Discord thread archived — reset sessions", { threadId, count });
+        }
+      },
+      onError: (err) => {
+        const logger = this.logger ?? discordEventQueueLog;
+        logger.error(danger(`discord thread-update handler failed: ${String(err)}`));
+      },
+    });
+  }
+}

package/src/monitor/message-channel-info.ts

@@ -0,0 +1,96 @@
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { normalizeOptionalStringifiedId } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { ChannelType, Message } from "../internal/discord.js";
+import { resolveDiscordChannelInfoSafe } from "./channel-access.js";
+
+export type DiscordChannelInfo = {
+  type: ChannelType;
+  name?: string;
+  topic?: string;
+  parentId?: string;
+  ownerId?: string;
+};
+export type DiscordChannelInfoClient = {
+  fetchChannel(channelId: string): Promise<unknown>;
+};
+
+type DiscordMessageWithChannelId = Message & {
+  channel_id?: unknown;
+  rawData?: { channel_id?: unknown };
+};
+
+const DISCORD_CHANNEL_INFO_CACHE_TTL_MS = 5 * 60 * 1000;
+const DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS = 30 * 1000;
+const DISCORD_CHANNEL_INFO_CACHE = new Map<
+  string,
+  { value: DiscordChannelInfo | null; expiresAt: number }
+>();
+
+export function resetDiscordChannelInfoCacheForTest() {
+  DISCORD_CHANNEL_INFO_CACHE.clear();
+}
+
+function normalizeDiscordChannelId(value: unknown): string {
+  return normalizeOptionalStringifiedId(value) ?? "";
+}
+
+export function resolveDiscordMessageChannelId(params: {
+  message: Message;
+  eventChannelId?: string | number | null;
+}): string {
+  const message = params.message as DiscordMessageWithChannelId;
+  return (
+    normalizeDiscordChannelId(message.channelId) ||
+    normalizeDiscordChannelId(message.channel_id) ||
+    normalizeDiscordChannelId(message.rawData?.channel_id) ||
+    normalizeDiscordChannelId(params.eventChannelId)
+  );
+}
+
+export async function resolveDiscordChannelInfo(
+  client: DiscordChannelInfoClient,
+  channelId: string,
+): Promise<DiscordChannelInfo | null> {
+  const cached = DISCORD_CHANNEL_INFO_CACHE.get(channelId);
+  if (cached) {
+    if (cached.expiresAt > Date.now()) {
+      return cached.value;
+    }
+    DISCORD_CHANNEL_INFO_CACHE.delete(channelId);
+  }
+  try {
+    const channel = await client.fetchChannel(channelId);
+    if (!channel) {
+      DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
+        value: null,
+        expiresAt: Date.now() + DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS,
+      });
+      return null;
+    }
+    const channelInfo = resolveDiscordChannelInfoSafe(channel);
+    const rawChannel = channel as { type?: ChannelType };
+    const type = (channelInfo.type as ChannelType | undefined) ?? rawChannel.type;
+    if (type === undefined) {
+      return null;
+    }
+    const payload: DiscordChannelInfo = {
+      type,
+      name: channelInfo.name,
+      topic: channelInfo.topic,
+      parentId: channelInfo.parentId,
+      ownerId: channelInfo.ownerId,
+    };
+    DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
+      value: payload,
+      expiresAt: Date.now() + DISCORD_CHANNEL_INFO_CACHE_TTL_MS,
+    });
+    return payload;
+  } catch (err) {
+    logVerbose(`discord: failed to fetch channel ${channelId}: ${String(err)}`);
+    DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
+      value: null,
+      expiresAt: Date.now() + DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS,
+    });
+    return null;
+  }
+}

package/src/monitor/message-forwarded.ts

@@ -0,0 +1,114 @@
+import type { APIAttachment, APIStickerItem } from "discord-api-types/v10";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { Message } from "../internal/discord.js";
+
+export type DiscordSnapshotAuthor = {
+  id?: string | null;
+  username?: string | null;
+  discriminator?: string | null;
+  global_name?: string | null;
+  name?: string | null;
+};
+
+export type DiscordSnapshotMessage = {
+  content?: string | null;
+  components?: unknown;
+  embeds?: Array<{ description?: string | null; title?: string | null }> | null;
+  attachments?: APIAttachment[] | null;
+  stickers?: APIStickerItem[] | null;
+  sticker_items?: APIStickerItem[] | null;
+  author?: DiscordSnapshotAuthor | null;
+};
+
+export type DiscordMessageSnapshot = {
+  message?: DiscordSnapshotMessage | null;
+};
+
+const FORWARD_MESSAGE_REFERENCE_TYPE = 1;
+
+export function normalizeDiscordStickerItems(value: unknown): APIStickerItem[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(
+    (entry): entry is APIStickerItem =>
+      Boolean(entry) &&
+      typeof entry === "object" &&
+      typeof (entry as { id?: unknown }).id === "string" &&
+      typeof (entry as { name?: unknown }).name === "string",
+  );
+}
+
+export function resolveDiscordMessageStickers(message: Message): APIStickerItem[] {
+  const stickers = (message as { stickers?: unknown }).stickers;
+  const normalized = normalizeDiscordStickerItems(stickers);
+  if (normalized.length > 0) {
+    return normalized;
+  }
+  const rawData = (message as { rawData?: { sticker_items?: unknown; stickers?: unknown } })
+    .rawData;
+  return normalizeDiscordStickerItems(rawData?.sticker_items ?? rawData?.stickers);
+}
+
+export function resolveDiscordSnapshotStickers(snapshot: DiscordSnapshotMessage): APIStickerItem[] {
+  return normalizeDiscordStickerItems(snapshot.stickers ?? snapshot.sticker_items);
+}
+
+export function hasDiscordMessageStickers(message: Message): boolean {
+  return resolveDiscordMessageStickers(message).length > 0;
+}
+
+export function resolveDiscordMessageSnapshots(message: Message): DiscordMessageSnapshot[] {
+  const rawData = (message as { rawData?: { message_snapshots?: unknown } }).rawData;
+  return normalizeDiscordMessageSnapshots(
+    rawData?.message_snapshots ??
+      (message as { message_snapshots?: unknown }).message_snapshots ??
+      (message as { messageSnapshots?: unknown }).messageSnapshots,
+  );
+}
+
+export function normalizeDiscordMessageSnapshots(snapshots: unknown): DiscordMessageSnapshot[] {
+  if (!Array.isArray(snapshots)) {
+    return [];
+  }
+  return snapshots.filter(
+    (entry): entry is DiscordMessageSnapshot => Boolean(entry) && typeof entry === "object",
+  );
+}
+
+export function resolveDiscordReferencedForwardMessage(message: Message): Message | null {
+  const referenceType = message.messageReference?.type;
+  return Number(referenceType) === FORWARD_MESSAGE_REFERENCE_TYPE
+    ? message.referencedMessage
+    : null;
+}
+
+export function resolveDiscordReferencedReplyMessage(message: Message): Message | null {
+  const referenceType = message.messageReference?.type;
+  return Number(referenceType) === FORWARD_MESSAGE_REFERENCE_TYPE
+    ? null
+    : (message.referencedMessage ?? null);
+}
+
+export function formatDiscordSnapshotAuthor(
+  author: DiscordSnapshotAuthor | null | undefined,
+): string | undefined {
+  if (!author) {
+    return undefined;
+  }
+  const globalName = normalizeOptionalString(author.global_name) ?? undefined;
+  const username = normalizeOptionalString(author.username) ?? undefined;
+  const name = normalizeOptionalString(author.name) ?? undefined;
+  const discriminator = normalizeOptionalString(author.discriminator) ?? undefined;
+  const base = globalName || username || name;
+  if (username && discriminator && discriminator !== "0") {
+    return `@${username}#${discriminator}`;
+  }
+  if (base) {
+    return `@${base}`;
+  }
+  if (author.id) {
+    return `@${author.id}`;
+  }
+  return undefined;
+}

package/src/monitor/message-handler.batch-gate.ts

@@ -0,0 +1,19 @@
+import type { ReplyToMode } from "autobot/plugin-sdk/config-contracts";
+import type { ReplyThreadingPolicy } from "autobot/plugin-sdk/reply-reference";
+import { resolveBatchedReplyThreadingPolicy } from "autobot/plugin-sdk/reply-reference";
+
+type ReplyThreadingContext = {
+  ReplyThreading?: ReplyThreadingPolicy;
+};
+
+export function applyImplicitReplyBatchGate(
+  ctx: object,
+  replyToMode: ReplyToMode,
+  isBatched: boolean,
+) {
+  const replyThreading = resolveBatchedReplyThreadingPolicy(replyToMode, isBatched);
+  if (!replyThreading) {
+    return;
+  }
+  (ctx as ReplyThreadingContext).ReplyThreading = replyThreading;
+}