@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/monitor.ts

@@ -1,28 +0,0 @@
-export type {
-  DiscordAllowList,
-  DiscordChannelConfigResolved,
-  DiscordGuildEntryResolved,
-} from "./monitor/allow-list.js";
-export {
-  allowListMatches,
-  isDiscordGroupAllowedByPolicy,
-  normalizeDiscordAllowList,
-  normalizeDiscordSlug,
-  resolveDiscordChannelConfig,
-  resolveDiscordChannelConfigWithFallback,
-  resolveDiscordCommandAuthorized,
-  resolveDiscordGuildEntry,
-  resolveDiscordShouldRequireMention,
-  resolveGroupDmAllow,
-  shouldEmitDiscordReactionNotification,
-} from "./monitor/allow-list.js";
-export type { DiscordMessageEvent, DiscordMessageHandler } from "./monitor/listeners.js";
-export { registerDiscordListener } from "./monitor/listeners.js";
-
-export { createDiscordMessageHandler } from "./monitor/message-handler.js";
-export { buildDiscordMediaPayload } from "./monitor/message-utils.js";
-export { createDiscordNativeCommand } from "./monitor/native-command.js";
-export type { MonitorDiscordOpts } from "./monitor/provider.js";
-export { monitorDiscordProvider } from "./monitor/provider.js";
-
-export { resolveDiscordReplyTarget, sanitizeDiscordThreadName } from "./monitor/threading.js";

package/src/network-config.test.ts

@@ -1,92 +0,0 @@
-import type * as dns from "node:dns";
-import { afterEach, describe, expect, it, vi } from "vitest";
-
-const dnsMocks = vi.hoisted(() => ({
-  lookup: vi.fn(),
-}));
-
-vi.mock("node:dns", async () => {
-  const actual = await vi.importActual<typeof import("node:dns")>("node:dns");
-  return {
-    ...actual,
-    lookup: dnsMocks.lookup,
-  };
-});
-
-import { createDiscordDnsLookup } from "./network-config.js";
-
-describe("createDiscordDnsLookup", () => {
-  afterEach(() => {
-    dnsMocks.lookup.mockReset();
-  });
-
-  it("returns reordered address arrays when the caller requests all addresses", async () => {
-    dnsMocks.lookup.mockImplementation((_hostname: string, options: unknown, callback: unknown) => {
-      expect(options).toEqual({ all: true });
-      (callback as (err: NodeJS.ErrnoException | null, addresses: dns.LookupAddress[]) => void)(
-        null,
-        [
-          { address: "2606:4700::6810:1234", family: 6 },
-          { address: "162.159.135.232", family: 4 },
-        ],
-      );
-    });
-
-    const lookup = createDiscordDnsLookup();
-    const addresses = await new Promise<dns.LookupAddress[]>((resolve, reject) => {
-      lookup("discord.com", { all: true }, (err, result) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(result as dns.LookupAddress[]);
-      });
-    });
-
-    expect(addresses).toEqual([
-      { address: "162.159.135.232", family: 4 },
-      { address: "2606:4700::6810:1234", family: 6 },
-    ]);
-  });
-
-  it("returns the first reordered IPv4 address for scalar lookups", async () => {
-    dnsMocks.lookup.mockImplementation(
-      (_hostname: string, _options: unknown, callback: unknown) => {
-        (callback as (err: NodeJS.ErrnoException | null, addresses: dns.LookupAddress[]) => void)(
-          null,
-          [
-            { address: "2606:4700::6810:1234", family: 6 },
-            { address: "162.159.135.232", family: 4 },
-          ],
-        );
-      },
-    );
-
-    const lookup = createDiscordDnsLookup();
-    const result = await new Promise<{ address: string; family: number }>((resolve, reject) => {
-      lookup("gateway.discord.gg", {}, (err, address, family) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        if (typeof address !== "string" || typeof family !== "number") {
-          reject(new Error("Expected scalar lookup result"));
-          return;
-        }
-        resolve({ address, family });
-      });
-    });
-
-    expect(result).toEqual({ address: "162.159.135.232", family: 4 });
-  });
-
-  it("delegates non-Discord hostnames unchanged", () => {
-    const callback = vi.fn();
-    const options = { all: true };
-    const lookup = createDiscordDnsLookup();
-
-    lookup("example.com", options, callback);
-
-    expect(dnsMocks.lookup).toHaveBeenCalledWith("example.com", options, callback);
-  });
-});

package/src/network-config.ts

@@ -1,79 +0,0 @@
-import * as dns from "node:dns";
-import type { LookupFunction } from "node:net";
-
-const DISCORD_DNS_HOSTS = ["discord.com", "discord.gg", "gateway.discord.gg"];
-
-function normalizeHostname(hostname: string): string {
-  return hostname.trim().toLowerCase();
-}
-
-function isDiscordTransportHostname(hostname: string): boolean {
-  const normalized = normalizeHostname(hostname);
-  if (!normalized) {
-    return false;
-  }
-  return DISCORD_DNS_HOSTS.some(
-    (target) => normalized === target || normalized.endsWith(`.${target}`),
-  );
-}
-
-function reorderLookupAddresses(addresses: dns.LookupAddress[]): dns.LookupAddress[] {
-  if (!Array.isArray(addresses) || addresses.length < 2) {
-    return addresses;
-  }
-  const ipv4 = addresses.filter((entry) => entry.family === 4);
-  const ipv6 = addresses.filter((entry) => entry.family === 6);
-  if (ipv4.length === 0) {
-    return ipv6;
-  }
-  if (ipv6.length === 0) {
-    return ipv4;
-  }
-  return [...ipv4, ...ipv6];
-}
-
-export function createDiscordDnsLookup(): LookupFunction {
-  return (hostname, options, callback) => {
-    if (!isDiscordTransportHostname(hostname)) {
-      return dns.lookup(hostname, options, callback);
-    }
-
-    const lookupOptions: dns.LookupOptions =
-      typeof options === "number"
-        ? { family: options }
-        : options === undefined
-          ? {}
-          : ({ ...options } as dns.LookupOptions);
-
-    if (lookupOptions.family === 4 || lookupOptions.family === 6) {
-      return dns.lookup(hostname, lookupOptions, callback as never);
-    }
-
-    dns.lookup(hostname, { ...lookupOptions, all: true }, (err, addresses) => {
-      if (err) {
-        callback(err, "", 4);
-        return;
-      }
-      if (!Array.isArray(addresses)) {
-        callback(new Error("Expected all lookup addresses to be an array"), "", 4);
-        return;
-      }
-
-      const reordered = reorderLookupAddresses(addresses);
-      if (lookupOptions.all === true) {
-        (callback as (err: NodeJS.ErrnoException | null, addresses: dns.LookupAddress[]) => void)(
-          null,
-          reordered,
-        );
-        return;
-      }
-
-      const first = reordered[0];
-      if (!first) {
-        callback(new Error("No Discord DNS addresses resolved"), "", 4);
-        return;
-      }
-      callback(null, first.address, first.family);
-    });
-  };
-}

package/src/normalize.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  looksLikeDiscordTargetId,
-  normalizeDiscordMessagingTarget,
-  normalizeDiscordOutboundTarget,
-} from "./normalize.js";
-
-describe("discord target normalization", () => {
-  it("normalizes bare messaging target ids to channel targets", () => {
-    expect(normalizeDiscordMessagingTarget("1234567890")).toBe("channel:1234567890");
-  });
-
-  it("keeps explicit outbound targets and rejects missing recipients", () => {
-    expect(normalizeDiscordOutboundTarget("1234567890")).toEqual({
-      ok: true,
-      to: "channel:1234567890",
-    });
-    expect(normalizeDiscordOutboundTarget("user:42")).toEqual({
-      ok: true,
-      to: "user:42",
-    });
-
-    const result = normalizeDiscordOutboundTarget("   ");
-    expect(result.ok).toBe(false);
-    if (!result.ok) {
-      expect(result.error.message).toContain("Discord recipient is required");
-    }
-  });
-
-  it("treats bare outbound IDs listed in allowFrom as DM targets", () => {
-    expect(normalizeDiscordOutboundTarget("1234567890", ["1234567890"])).toEqual({
-      ok: true,
-      to: "user:1234567890",
-    });
-    expect(normalizeDiscordOutboundTarget("2345678901", ["user:2345678901"])).toEqual({
-      ok: true,
-      to: "user:2345678901",
-    });
-    expect(normalizeDiscordOutboundTarget("3456789012", ["<@3456789012>"])).toEqual({
-      ok: true,
-      to: "user:3456789012",
-    });
-    expect(normalizeDiscordOutboundTarget("4567890123", ["*"])).toEqual({
-      ok: true,
-      to: "channel:4567890123",
-    });
-  });
-
-  it("detects Discord-style target identifiers", () => {
-    expect(looksLikeDiscordTargetId("<@!123456>")).toBe(true);
-    expect(looksLikeDiscordTargetId("user:123456")).toBe(true);
-    expect(looksLikeDiscordTargetId("discord:123456")).toBe(true);
-    expect(looksLikeDiscordTargetId("123456")).toBe(true);
-    expect(looksLikeDiscordTargetId("hello world")).toBe(false);
-  });
-});

package/src/normalize.ts

@@ -1,86 +0,0 @@
-import { parseDiscordTarget } from "./target-parsing.js";
-
-export function normalizeDiscordMessagingTarget(raw: string): string | undefined {
-  // Default bare IDs to channels so routing is stable across tool actions.
-  const target = parseDiscordTarget(raw, { defaultKind: "channel" });
-  return target?.normalized;
-}
-
-/**
- * Normalize a Discord outbound target for delivery. Bare numeric IDs are
- * prefixed with "channel:" to avoid the ambiguous-target error in
- * parseDiscordTarget, unless the ID is explicitly configured as an allowed DM
- * sender. All other formats pass through unchanged.
- */
-export function normalizeDiscordOutboundTarget(
-  to?: string,
-  allowFrom?: readonly string[],
-): { ok: true; to: string } | { ok: false; error: Error } {
-  const trimmed = to?.trim();
-  if (!trimmed) {
-    return {
-      ok: false,
-      error: new Error(
-        'Discord recipient is required. Use "channel:<id>" for channels or "user:<id>" for DMs.',
-      ),
-    };
-  }
-  if (/^\d+$/.test(trimmed)) {
-    if (allowFromContainsDiscordUserId(allowFrom, trimmed)) {
-      return { ok: true, to: `user:${trimmed}` };
-    }
-    return { ok: true, to: `channel:${trimmed}` };
-  }
-  return { ok: true, to: trimmed };
-}
-
-export function allowFromContainsDiscordUserId(
-  allowFrom: readonly string[] | undefined,
-  userId: string,
-): boolean {
-  const normalizedUserId = userId.trim();
-  if (!normalizedUserId) {
-    return false;
-  }
-  return (allowFrom ?? []).some(
-    (entry) => normalizeAllowFromDiscordUserId(entry) === normalizedUserId,
-  );
-}
-
-function normalizeAllowFromDiscordUserId(entry: string): string | undefined {
-  const trimmed = entry.trim().toLowerCase();
-  if (!trimmed || trimmed === "*") {
-    return undefined;
-  }
-  const mentionMatch = /^<@!?(\d+)>$/.exec(trimmed);
-  if (mentionMatch) {
-    return mentionMatch[1];
-  }
-  // Accept both current and legacy allowFrom forms for Discord user IDs.
-  const prefixedMatch = /^(?:discord:)?user:(\d+)$/.exec(trimmed);
-  if (prefixedMatch) {
-    return prefixedMatch[1];
-  }
-  const discordMatch = /^discord:(\d+)$/.exec(trimmed);
-  if (discordMatch) {
-    return discordMatch[1];
-  }
-  return /^\d+$/.test(trimmed) ? trimmed : undefined;
-}
-
-export function looksLikeDiscordTargetId(raw: string): boolean {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return false;
-  }
-  if (/^<@!?\d+>$/.test(trimmed)) {
-    return true;
-  }
-  if (/^(user|channel|discord):/i.test(trimmed)) {
-    return true;
-  }
-  if (/^\d{6,}$/.test(trimmed)) {
-    return true;
-  }
-  return false;
-}

package/src/outbound-adapter.interactive-order.test.ts

@@ -1,82 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import {
-  createDiscordOutboundHoisted,
-  installDiscordOutboundModuleSpies,
-  resetDiscordOutboundMocks,
-} from "./outbound-adapter.test-harness.js";
-
-const hoisted = createDiscordOutboundHoisted();
-await installDiscordOutboundModuleSpies(hoisted);
-
-const { discordOutbound } = await import("./outbound-adapter.js");
-
-type DiscordSendPayload = NonNullable<typeof discordOutbound.sendPayload>;
-
-function requireDiscordSendPayload(): DiscordSendPayload {
-  const sendPayload = discordOutbound.sendPayload;
-  if (!sendPayload) {
-    throw new Error("Expected Discord outbound sendPayload");
-  }
-  return sendPayload;
-}
-
-describe("discordOutbound shared interactive ordering", () => {
-  beforeEach(() => {
-    resetDiscordOutboundMocks(hoisted);
-    hoisted.sendDiscordComponentMessageMock.mockResolvedValue({
-      messageId: "msg-1",
-      channelId: "123456",
-    });
-  });
-
-  it("keeps shared text blocks in authored order without hoisting fallback text", async () => {
-    const sendPayload = requireDiscordSendPayload();
-    const result = await sendPayload({
-      cfg: {},
-      to: "channel:123456",
-      text: "",
-      payload: {
-        interactive: {
-          blocks: [
-            { type: "text", text: "First" },
-            {
-              type: "buttons",
-              buttons: [{ label: "Approve", value: "approve" }],
-            },
-            { type: "text", text: "Last" },
-          ],
-        },
-      },
-    });
-
-    expect(hoisted.sendDiscordComponentMessageMock).toHaveBeenCalledWith(
-      "channel:123456",
-      {
-        blocks: [
-          { type: "text", text: "First" },
-          {
-            type: "actions",
-            buttons: [{ label: "Approve", style: "secondary", callbackData: "approve" }],
-          },
-          { type: "text", text: "Last" },
-        ],
-      },
-      {
-        accountId: undefined,
-        chunkMode: undefined,
-        cfg: {},
-        maxLinesPerMessage: undefined,
-        replyTo: undefined,
-        silent: undefined,
-        tableMode: undefined,
-        textLimit: undefined,
-      },
-    );
-    expect(hoisted.sendMessageDiscordMock).not.toHaveBeenCalled();
-    expect(result).toEqual({
-      channel: "discord",
-      messageId: "msg-1",
-      channelId: "123456",
-    });
-  });
-});

package/src/outbound-adapter.test-harness.ts

@@ -1,207 +0,0 @@
-import { expect, vi, type Mock } from "vitest";
-
-type UnknownMock = Mock<(...args: unknown[]) => unknown>;
-type AsyncUnknownMock = Mock<(...args: unknown[]) => Promise<unknown>>;
-
-type DiscordOutboundHoisted = {
-  sendMessageDiscordMock: AsyncUnknownMock;
-  sendDiscordComponentMessageMock: AsyncUnknownMock;
-  sendPollDiscordMock: AsyncUnknownMock;
-  sendWebhookMessageDiscordMock: AsyncUnknownMock;
-  sendVoiceMessageDiscordMock: AsyncUnknownMock;
-  getThreadBindingManagerMock: UnknownMock;
-};
-
-type DiscordSendModule = typeof import("./send.js");
-type DiscordSendComponentsModule = typeof import("./send.components.js");
-type DiscordThreadBindingsModule = typeof import("./monitor/thread-bindings.js");
-
-// oxlint-disable-next-line typescript/no-unnecessary-type-parameters -- Test helper preserves mock call and result types.
-function invokeMock<TArgs extends unknown[], TResult>(
-  mock: (...args: unknown[]) => unknown,
-  ...args: TArgs
-): TResult {
-  return mock(...args) as TResult;
-}
-
-export function createDiscordOutboundHoisted(): DiscordOutboundHoisted {
-  const sendMessageDiscordMock = vi.fn();
-  const sendDiscordComponentMessageMock = vi.fn();
-  const sendPollDiscordMock = vi.fn();
-  const sendWebhookMessageDiscordMock = vi.fn();
-  const sendVoiceMessageDiscordMock = vi.fn();
-  const getThreadBindingManagerMock = vi.fn();
-  return {
-    sendMessageDiscordMock,
-    sendDiscordComponentMessageMock,
-    sendPollDiscordMock,
-    sendWebhookMessageDiscordMock,
-    sendVoiceMessageDiscordMock,
-    getThreadBindingManagerMock,
-  };
-}
-
-const DEFAULT_DISCORD_SEND_RESULT = {
-  channel: "discord",
-  messageId: "msg-1",
-  channelId: "ch-1",
-} as const;
-
-async function createDiscordSendModuleMock(
-  hoisted: DiscordOutboundHoisted,
-  loadActual: () => Promise<DiscordSendModule>,
-): Promise<DiscordSendModule> {
-  const actual = await loadActual();
-  return {
-    ...actual,
-    sendMessageDiscord: (...args: Parameters<DiscordSendModule["sendMessageDiscord"]>) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendMessageDiscord"]>,
-        ReturnType<DiscordSendModule["sendMessageDiscord"]>
-      >(hoisted.sendMessageDiscordMock, ...args),
-    sendPollDiscord: (...args: Parameters<DiscordSendModule["sendPollDiscord"]>) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendPollDiscord"]>,
-        ReturnType<DiscordSendModule["sendPollDiscord"]>
-      >(hoisted.sendPollDiscordMock, ...args),
-    sendWebhookMessageDiscord: (
-      ...args: Parameters<DiscordSendModule["sendWebhookMessageDiscord"]>
-    ) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendWebhookMessageDiscord"]>,
-        ReturnType<DiscordSendModule["sendWebhookMessageDiscord"]>
-      >(hoisted.sendWebhookMessageDiscordMock, ...args),
-    sendVoiceMessageDiscord: (...args: Parameters<DiscordSendModule["sendVoiceMessageDiscord"]>) =>
-      invokeMock<
-        Parameters<DiscordSendModule["sendVoiceMessageDiscord"]>,
-        ReturnType<DiscordSendModule["sendVoiceMessageDiscord"]>
-      >(hoisted.sendVoiceMessageDiscordMock, ...args),
-  };
-}
-
-async function createDiscordSendComponentsModuleMock(
-  hoisted: DiscordOutboundHoisted,
-  loadActual: () => Promise<DiscordSendComponentsModule>,
-): Promise<DiscordSendComponentsModule> {
-  const actual = await loadActual();
-  return {
-    ...actual,
-    sendDiscordComponentMessage: (
-      ...args: Parameters<DiscordSendComponentsModule["sendDiscordComponentMessage"]>
-    ) =>
-      invokeMock<
-        Parameters<DiscordSendComponentsModule["sendDiscordComponentMessage"]>,
-        ReturnType<DiscordSendComponentsModule["sendDiscordComponentMessage"]>
-      >(hoisted.sendDiscordComponentMessageMock, ...args),
-  };
-}
-
-async function createDiscordThreadBindingsModuleMock(
-  hoisted: DiscordOutboundHoisted,
-  loadActual: () => Promise<DiscordThreadBindingsModule>,
-): Promise<DiscordThreadBindingsModule> {
-  const actual = await loadActual();
-  return {
-    ...actual,
-    getThreadBindingManager: (
-      ...args: Parameters<DiscordThreadBindingsModule["getThreadBindingManager"]>
-    ) =>
-      invokeMock<
-        Parameters<DiscordThreadBindingsModule["getThreadBindingManager"]>,
-        ReturnType<DiscordThreadBindingsModule["getThreadBindingManager"]>
-      >(hoisted.getThreadBindingManagerMock, ...args),
-  };
-}
-
-export async function installDiscordOutboundModuleSpies(hoisted: DiscordOutboundHoisted) {
-  const sendModule = await import("./send.js");
-  const mockedSendModule = await createDiscordSendModuleMock(hoisted, async () => sendModule);
-  vi.spyOn(sendModule, "sendMessageDiscord").mockImplementation(
-    mockedSendModule.sendMessageDiscord,
-  );
-  vi.spyOn(sendModule, "sendPollDiscord").mockImplementation(mockedSendModule.sendPollDiscord);
-  vi.spyOn(sendModule, "sendWebhookMessageDiscord").mockImplementation(
-    mockedSendModule.sendWebhookMessageDiscord,
-  );
-  vi.spyOn(sendModule, "sendVoiceMessageDiscord").mockImplementation(
-    mockedSendModule.sendVoiceMessageDiscord,
-  );
-
-  const sendComponentsModule = await import("./send.components.js");
-  const mockedSendComponentsModule = await createDiscordSendComponentsModuleMock(
-    hoisted,
-    async () => sendComponentsModule,
-  );
-  vi.spyOn(sendComponentsModule, "sendDiscordComponentMessage").mockImplementation(
-    mockedSendComponentsModule.sendDiscordComponentMessage,
-  );
-
-  const threadBindingsModule = await import("./monitor/thread-bindings.js");
-  const mockedThreadBindingsModule = await createDiscordThreadBindingsModuleMock(
-    hoisted,
-    async () => threadBindingsModule,
-  );
-  vi.spyOn(threadBindingsModule, "getThreadBindingManager").mockImplementation(
-    mockedThreadBindingsModule.getThreadBindingManager,
-  );
-}
-
-export function resetDiscordOutboundMocks(hoisted: DiscordOutboundHoisted) {
-  hoisted.sendMessageDiscordMock.mockReset().mockResolvedValue({
-    messageId: "msg-1",
-    channelId: "ch-1",
-  });
-  hoisted.sendDiscordComponentMessageMock.mockReset().mockResolvedValue({
-    messageId: "component-1",
-    channelId: "ch-1",
-  });
-  hoisted.sendPollDiscordMock.mockReset().mockResolvedValue({
-    messageId: "poll-1",
-    channelId: "ch-1",
-  });
-  hoisted.sendWebhookMessageDiscordMock.mockReset().mockResolvedValue({
-    messageId: "msg-webhook-1",
-    channelId: "thread-1",
-  });
-  hoisted.sendVoiceMessageDiscordMock.mockReset().mockResolvedValue({
-    messageId: "voice-1",
-    channelId: "ch-1",
-  });
-  hoisted.getThreadBindingManagerMock.mockReset().mockReturnValue(null);
-}
-
-export function expectDiscordThreadBotSend(params: {
-  hoisted: DiscordOutboundHoisted;
-  text: string;
-  result: unknown;
-  options?: Record<string, unknown>;
-}) {
-  expect(params.hoisted.sendMessageDiscordMock).toHaveBeenCalledWith(
-    "channel:thread-1",
-    params.text,
-    expect.objectContaining({
-      accountId: "default",
-      ...params.options,
-    }),
-  );
-  expect(params.result).toEqual(DEFAULT_DISCORD_SEND_RESULT);
-}
-
-export function mockDiscordBoundThreadManager(hoisted: DiscordOutboundHoisted) {
-  hoisted.getThreadBindingManagerMock.mockReturnValue({
-    getByThreadId: () => ({
-      accountId: "default",
-      channelId: "parent-1",
-      threadId: "thread-1",
-      targetKind: "subagent",
-      targetSessionKey: "agent:main:subagent:child",
-      agentId: "main",
-      label: "codex-thread",
-      webhookId: "wh-1",
-      webhookToken: "tok-1",
-      boundBy: "system",
-      boundAt: Date.now(),
-    }),
-    touchThread: vi.fn(),
-  });
-}