@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/monitor/provider.allowlist.test.ts

@@ -1,217 +0,0 @@
-import type { DiscordAccountConfig } from "klaw/plugin-sdk/config-contracts";
-import { createNonExitingRuntimeEnv } from "klaw/plugin-sdk/plugin-test-runtime";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import * as resolveChannelsModule from "../resolve-channels.js";
-import * as resolveUsersModule from "../resolve-users.js";
-import { resolveDiscordAllowlistConfig } from "./provider.allowlist.js";
-
-describe("resolveDiscordAllowlistConfig", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    vi.spyOn(resolveChannelsModule, "resolveDiscordChannelAllowlist").mockResolvedValue([]);
-    vi.spyOn(resolveUsersModule, "resolveDiscordUserAllowlist").mockImplementation(
-      async (params: { entries: string[] }) =>
-        params.entries.map((entry) => {
-          switch (entry) {
-            case "Alice":
-              return { input: entry, resolved: true, id: "111" };
-            case "Bob":
-              return { input: entry, resolved: true, id: "222" };
-            case "Carol":
-              return { input: entry, resolved: false };
-            case "387":
-              return { input: entry, resolved: true, id: "387", name: "Peter" };
-            default:
-              return { input: entry, resolved: true, id: entry };
-          }
-        }),
-    );
-  });
-
-  it("canonicalizes resolved user names to ids in runtime config", async () => {
-    const runtime = createNonExitingRuntimeEnv();
-    const result = await resolveDiscordAllowlistConfig({
-      token: "token",
-      allowFrom: ["Alice", "111", "*"],
-      guildEntries: {
-        "*": {
-          users: ["Bob", "999"],
-          channels: {
-            "*": {
-              users: ["Carol", "888"],
-            },
-          },
-        },
-      },
-      fetcher: vi.fn() as unknown as typeof fetch,
-      runtime,
-      discordConfig: { dangerouslyAllowNameMatching: true } as DiscordAccountConfig,
-    });
-
-    expect(result.allowFrom).toEqual(["111", "*"]);
-    expect(result.guildEntries?.["*"]?.users).toEqual(["222", "999"]);
-    expect(result.guildEntries?.["*"]?.channels?.["*"]?.users).toEqual(["Carol", "888"]);
-    expect(resolveUsersModule.resolveDiscordUserAllowlist).toHaveBeenCalledTimes(2);
-  });
-
-  it("logs discord name metadata for resolved and unresolved allowlist entries", async () => {
-    vi.spyOn(resolveChannelsModule, "resolveDiscordChannelAllowlist").mockResolvedValueOnce([
-      {
-        input: "145/c404",
-        resolved: false,
-        guildId: "145",
-        guildName: "Ops",
-        channelName: "missing-room",
-      },
-    ]);
-    const runtime = createNonExitingRuntimeEnv();
-
-    await resolveDiscordAllowlistConfig({
-      token: "token",
-      allowFrom: ["387"],
-      guildEntries: {
-        "145": {
-          channels: {
-            c404: {},
-          },
-        },
-      },
-      fetcher: vi.fn() as unknown as typeof fetch,
-      runtime,
-      discordConfig: { dangerouslyAllowNameMatching: true } as DiscordAccountConfig,
-    });
-
-    const logs = (runtime.log as ReturnType<typeof vi.fn>).mock.calls
-      .map(([line]) => String(line))
-      .join("\n");
-    expect(logs).toContain(
-      "discord channels unresolved: 145/c404 (guild:Ops; channel:missing-room)",
-    );
-    expect(logs).toContain("discord users resolved: 387→Peter (id:387)");
-  });
-
-  it("groups resolved discord channel aliases under one target line", async () => {
-    vi.spyOn(resolveChannelsModule, "resolveDiscordChannelAllowlist").mockResolvedValueOnce([
-      {
-        input: "1456350064065904867/1464953333713473657",
-        resolved: true,
-        guildId: "1456350064065904867",
-        guildName: "Friends of the Crustacean 🦞🤝",
-        channelId: "1464953333713473657",
-        channelName: "dev",
-      },
-      {
-        input: "1456350064065904867/1456744319972282449",
-        resolved: true,
-        guildId: "1456350064065904867",
-        guildName: "Friends of the Crustacean 🦞🤝",
-        channelId: "1456744319972282449",
-        channelName: "maintainers",
-      },
-      {
-        input: "friends-of-the-crustacean/1464953333713473657",
-        resolved: true,
-        guildId: "1456350064065904867",
-        guildName: "Friends of the Crustacean 🦞🤝",
-        channelId: "1464953333713473657",
-        channelName: "dev",
-      },
-    ]);
-
-    const runtime = createNonExitingRuntimeEnv();
-
-    await resolveDiscordAllowlistConfig({
-      token: "token",
-      allowFrom: [],
-      guildEntries: {
-        "1456350064065904867": {
-          channels: {
-            "1464953333713473657": {},
-            "1456744319972282449": {},
-          },
-        },
-        "friends-of-the-crustacean": {
-          channels: {
-            "1464953333713473657": {},
-          },
-        },
-      },
-      fetcher: vi.fn() as unknown as typeof fetch,
-      runtime,
-      discordConfig: {} as DiscordAccountConfig,
-    });
-
-    const logs = (runtime.log as ReturnType<typeof vi.fn>).mock.calls
-      .map(([line]) => String(line))
-      .join("\n");
-    expect(logs.match(/1456350064065904867\/1464953333713473657/g)?.length).toBe(1);
-    expect(logs).toContain("aliases:friends-of-the-crustacean/1464953333713473657");
-    expect(logs).toContain(
-      "1456350064065904867/1456744319972282449 (guild:Friends of the Crustacean 🦞🤝; channel:maintainers)",
-    );
-  });
-
-  it("keeps user allowlist names unresolved unless name matching is enabled", async () => {
-    const runtime = createNonExitingRuntimeEnv();
-    const result = await resolveDiscordAllowlistConfig({
-      token: "token",
-      allowFrom: ["Alice", "111", "*"],
-      guildEntries: {
-        "*": {
-          users: ["Bob", "999"],
-          channels: {
-            "*": {
-              users: ["Carol", "888"],
-            },
-          },
-        },
-      },
-      fetcher: vi.fn() as unknown as typeof fetch,
-      runtime,
-      discordConfig: {} as DiscordAccountConfig,
-    });
-
-    expect(result.allowFrom).toEqual(["Alice", "111", "*"]);
-    expect(result.guildEntries?.["*"]?.users).toEqual(["Bob", "999"]);
-    expect(result.guildEntries?.["*"]?.channels?.["*"]?.users).toEqual(["Carol", "888"]);
-    expect(resolveUsersModule.resolveDiscordUserAllowlist).not.toHaveBeenCalled();
-  });
-
-  it("still resolves guild and channel ids when name matching is disabled", async () => {
-    vi.spyOn(resolveChannelsModule, "resolveDiscordChannelAllowlist").mockResolvedValueOnce([
-      {
-        input: "ops/general",
-        resolved: true,
-        guildId: "145",
-        guildName: "Ops",
-        channelId: "246",
-        channelName: "general",
-      },
-    ]);
-    const runtime = createNonExitingRuntimeEnv();
-
-    const result = await resolveDiscordAllowlistConfig({
-      token: "token",
-      allowFrom: ["Alice"],
-      guildEntries: {
-        ops: {
-          users: ["Bob"],
-          channels: {
-            general: {
-              users: ["Carol"],
-            },
-          },
-        },
-      },
-      fetcher: vi.fn() as unknown as typeof fetch,
-      runtime,
-      discordConfig: {} as DiscordAccountConfig,
-    });
-
-    expect(result.allowFrom).toEqual(["Alice"]);
-    expect(result.guildEntries?.["145"]?.channels?.["246"]?.users).toEqual(["Carol"]);
-    expect(result.guildEntries?.ops?.users).toEqual(["Bob"]);
-    expect(resolveChannelsModule.resolveDiscordChannelAllowlist).toHaveBeenCalledTimes(1);
-    expect(resolveUsersModule.resolveDiscordUserAllowlist).not.toHaveBeenCalled();
-  });
-});

package/src/monitor/provider.allowlist.ts

@@ -1,398 +0,0 @@
-import {
-  addAllowlistUserEntriesFromConfigEntry,
-  buildAllowlistResolutionSummary,
-  canonicalizeAllowlistWithResolvedIds,
-  patchAllowlistUsersInConfigEntries,
-  summarizeMapping,
-} from "klaw/plugin-sdk/allow-from";
-import type { DiscordAccountConfig, DiscordGuildEntry } from "klaw/plugin-sdk/config-contracts";
-import { isDangerousNameMatchingEnabled } from "klaw/plugin-sdk/dangerous-name-runtime";
-import type { RuntimeEnv } from "klaw/plugin-sdk/runtime-env";
-import { formatErrorMessage } from "klaw/plugin-sdk/ssrf-runtime";
-import { normalizeStringEntries } from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveDiscordChannelAllowlist } from "../resolve-channels.js";
-import { resolveDiscordUserAllowlist } from "../resolve-users.js";
-
-type GuildEntries = Record<string, DiscordGuildEntry>;
-type ChannelResolutionInput = { input: string; guildKey: string; channelKey?: string };
-type DiscordChannelLogEntry = {
-  input: string;
-  guildId?: string;
-  guildName?: string;
-  channelId?: string;
-  channelName?: string;
-  note?: string;
-};
-type DiscordChannelResolvedGroup = {
-  target: string;
-  aliases: string[];
-  guildName?: string;
-  channelName?: string;
-  note?: string;
-};
-type DiscordUserLogEntry = {
-  input: string;
-  id?: string;
-  name?: string;
-  guildName?: string;
-  note?: string;
-};
-
-function formatResolutionLogDetails(base: string, details: Array<string | undefined>): string {
-  const nonEmpty = details
-    .map((value) => value?.trim())
-    .filter((value): value is string => Boolean(value));
-  return nonEmpty.length > 0 ? `${base} (${nonEmpty.join("; ")})` : base;
-}
-
-function formatResolvedBase(input: string, target: string | undefined): string {
-  if (!target) {
-    return input;
-  }
-  return input === target ? input : `${input}→${target}`;
-}
-
-function formatAliasSummary(aliases: string[]): string | undefined {
-  if (aliases.length === 0) {
-    return undefined;
-  }
-  const preview = aliases.slice(0, 3).join(", ");
-  if (aliases.length <= 3) {
-    return preview;
-  }
-  return `${preview}, +${aliases.length - 3} more`;
-}
-
-function formatDiscordChannelResolvedGroup(entry: DiscordChannelResolvedGroup): string {
-  const aliasSummary = formatAliasSummary(entry.aliases);
-  return formatResolutionLogDetails(entry.target, [
-    entry.guildName ? `guild:${entry.guildName}` : undefined,
-    entry.channelName ? `channel:${entry.channelName}` : undefined,
-    entry.note,
-    aliasSummary ? `aliases:${aliasSummary}` : undefined,
-  ]);
-}
-
-function formatDiscordChannelUnresolved(entry: DiscordChannelLogEntry): string {
-  return formatResolutionLogDetails(entry.input, [
-    entry.guildName
-      ? `guild:${entry.guildName}`
-      : entry.guildId
-        ? `guildId:${entry.guildId}`
-        : undefined,
-    entry.channelName
-      ? `channel:${entry.channelName}`
-      : entry.channelId
-        ? `channelId:${entry.channelId}`
-        : undefined,
-    entry.note,
-  ]);
-}
-
-function formatDiscordUserResolved(entry: DiscordUserLogEntry): string {
-  const displayName = entry.name?.trim();
-  const target = displayName || entry.id;
-  const base = formatResolvedBase(entry.input, target);
-  return formatResolutionLogDetails(base, [
-    displayName && entry.id ? `id:${entry.id}` : undefined,
-    entry.guildName ? `guild:${entry.guildName}` : undefined,
-    entry.note,
-  ]);
-}
-
-function formatDiscordUserUnresolved(entry: DiscordUserLogEntry): string {
-  return formatResolutionLogDetails(entry.input, [
-    entry.name ? `name:${entry.name}` : undefined,
-    entry.guildName ? `guild:${entry.guildName}` : undefined,
-    entry.note,
-  ]);
-}
-
-function toGuildEntries(value: unknown): GuildEntries {
-  if (!value || typeof value !== "object") {
-    return {};
-  }
-  const out: GuildEntries = {};
-  for (const [key, entry] of Object.entries(value)) {
-    if (!entry || typeof entry !== "object") {
-      continue;
-    }
-    out[key] = entry as DiscordGuildEntry;
-  }
-  return out;
-}
-
-function toAllowlistEntries(value: unknown): string[] | undefined {
-  if (!Array.isArray(value)) {
-    return undefined;
-  }
-  return normalizeStringEntries(value);
-}
-
-function hasGuildEntries(value: GuildEntries): boolean {
-  return Object.keys(value).length > 0;
-}
-
-function collectChannelResolutionInputs(guildEntries: GuildEntries): ChannelResolutionInput[] {
-  const entries: ChannelResolutionInput[] = [];
-  for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
-    if (guildKey === "*") {
-      continue;
-    }
-    const channels = guildCfg?.channels ?? {};
-    const channelKeys = Object.keys(channels).filter((key) => key !== "*");
-    if (channelKeys.length === 0) {
-      const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
-      entries.push({ input, guildKey });
-      continue;
-    }
-    for (const channelKey of channelKeys) {
-      entries.push({
-        input: `${guildKey}/${channelKey}`,
-        guildKey,
-        channelKey,
-      });
-    }
-  }
-  return entries;
-}
-
-async function resolveGuildEntriesByChannelAllowlist(params: {
-  token: string;
-  guildEntries: GuildEntries;
-  fetcher: typeof fetch;
-  runtime: RuntimeEnv;
-}): Promise<GuildEntries> {
-  const entries = collectChannelResolutionInputs(params.guildEntries);
-  if (entries.length === 0) {
-    return params.guildEntries;
-  }
-  try {
-    const resolved = await resolveDiscordChannelAllowlist({
-      token: params.token,
-      entries: entries.map((entry) => entry.input),
-      fetcher: params.fetcher,
-    });
-    const sourceByInput = new Map(entries.map((entry) => [entry.input, entry]));
-    const nextGuilds = { ...params.guildEntries };
-    const mappingByTarget = new Map<string, DiscordChannelResolvedGroup>();
-    const unresolved: string[] = [];
-    for (const entry of resolved) {
-      const source = sourceByInput.get(entry.input);
-      if (!source) {
-        continue;
-      }
-      const sourceGuild = params.guildEntries[source.guildKey] ?? {};
-      if (!entry.resolved || !entry.guildId) {
-        unresolved.push(formatDiscordChannelUnresolved(entry));
-        continue;
-      }
-      const target = entry.channelId ? `${entry.guildId}/${entry.channelId}` : entry.guildId;
-      const existingGroup =
-        mappingByTarget.get(target) ??
-        ({
-          target,
-          aliases: [],
-          guildName: entry.guildName,
-          channelName: entry.channelName,
-          note: entry.note,
-        } satisfies DiscordChannelResolvedGroup);
-      if (entry.input !== target && !existingGroup.aliases.includes(entry.input)) {
-        existingGroup.aliases.push(entry.input);
-      }
-      if (!existingGroup.guildName && entry.guildName) {
-        existingGroup.guildName = entry.guildName;
-      }
-      if (!existingGroup.channelName && entry.channelName) {
-        existingGroup.channelName = entry.channelName;
-      }
-      if (!existingGroup.note && entry.note) {
-        existingGroup.note = entry.note;
-      }
-      mappingByTarget.set(target, existingGroup);
-      const existing = nextGuilds[entry.guildId] ?? {};
-      const mergedChannels = {
-        ...sourceGuild.channels,
-        ...existing.channels,
-      };
-      const mergedGuild: DiscordGuildEntry = {
-        ...sourceGuild,
-        ...existing,
-        channels: mergedChannels,
-      };
-      nextGuilds[entry.guildId] = mergedGuild;
-
-      if (source.channelKey && entry.channelId) {
-        const sourceChannel = sourceGuild.channels?.[source.channelKey];
-        if (sourceChannel) {
-          nextGuilds[entry.guildId] = {
-            ...mergedGuild,
-            channels: {
-              ...mergedChannels,
-              [entry.channelId]: {
-                ...sourceChannel,
-                ...mergedChannels[entry.channelId],
-              },
-            },
-          };
-        }
-      }
-    }
-    const mapping = [...mappingByTarget.values()].map((group) =>
-      formatDiscordChannelResolvedGroup(group),
-    );
-    summarizeMapping("discord channels", mapping, unresolved, params.runtime);
-    return nextGuilds;
-  } catch (err) {
-    params.runtime.log?.(
-      `discord channel resolve failed; using config entries. ${formatErrorMessage(err)}`,
-    );
-    return params.guildEntries;
-  }
-}
-
-async function resolveAllowFromByUserAllowlist(params: {
-  token: string;
-  allowFrom: string[] | undefined;
-  fetcher: typeof fetch;
-  runtime: RuntimeEnv;
-}): Promise<string[] | undefined> {
-  const allowEntries = normalizeStringEntries(params.allowFrom).filter((entry) => entry !== "*");
-  if (allowEntries.length === 0) {
-    return params.allowFrom;
-  }
-  try {
-    const resolvedUsers = await resolveDiscordUserAllowlist({
-      token: params.token,
-      entries: allowEntries,
-      fetcher: params.fetcher,
-    });
-    const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers, {
-      formatResolved: formatDiscordUserResolved,
-      formatUnresolved: formatDiscordUserUnresolved,
-    });
-    const allowFrom = canonicalizeAllowlistWithResolvedIds({
-      existing: params.allowFrom,
-      resolvedMap,
-    });
-    summarizeMapping("discord users", mapping, unresolved, params.runtime);
-    return allowFrom;
-  } catch (err) {
-    params.runtime.log?.(
-      `discord user resolve failed; using config entries. ${formatErrorMessage(err)}`,
-    );
-    return params.allowFrom;
-  }
-}
-
-function collectGuildUserEntries(guildEntries: GuildEntries): Set<string> {
-  const userEntries = new Set<string>();
-  for (const guild of Object.values(guildEntries)) {
-    if (!guild || typeof guild !== "object") {
-      continue;
-    }
-    addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
-    const channels = (guild as { channels?: Record<string, unknown> }).channels ?? {};
-    for (const channel of Object.values(channels)) {
-      addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
-    }
-  }
-  return userEntries;
-}
-
-async function resolveGuildEntriesByUserAllowlist(params: {
-  token: string;
-  guildEntries: GuildEntries;
-  fetcher: typeof fetch;
-  runtime: RuntimeEnv;
-}): Promise<GuildEntries> {
-  const userEntries = collectGuildUserEntries(params.guildEntries);
-  if (userEntries.size === 0) {
-    return params.guildEntries;
-  }
-  try {
-    const resolvedUsers = await resolveDiscordUserAllowlist({
-      token: params.token,
-      entries: Array.from(userEntries),
-      fetcher: params.fetcher,
-    });
-    const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers, {
-      formatResolved: formatDiscordUserResolved,
-      formatUnresolved: formatDiscordUserUnresolved,
-    });
-    const nextGuilds = { ...params.guildEntries };
-    for (const [guildKey, guildConfig] of Object.entries(params.guildEntries)) {
-      if (!guildConfig || typeof guildConfig !== "object") {
-        continue;
-      }
-      const nextGuild = { ...guildConfig } as Record<string, unknown>;
-      const users = (guildConfig as { users?: string[] }).users;
-      if (Array.isArray(users) && users.length > 0) {
-        nextGuild.users = canonicalizeAllowlistWithResolvedIds({
-          existing: users,
-          resolvedMap,
-        });
-      }
-      const channels = (guildConfig as { channels?: Record<string, unknown> }).channels ?? {};
-      if (channels && typeof channels === "object") {
-        nextGuild.channels = patchAllowlistUsersInConfigEntries({
-          entries: channels,
-          resolvedMap,
-          strategy: "canonicalize",
-        });
-      }
-      nextGuilds[guildKey] = nextGuild as DiscordGuildEntry;
-    }
-    summarizeMapping("discord channel users", mapping, unresolved, params.runtime);
-    return nextGuilds;
-  } catch (err) {
-    params.runtime.log?.(
-      `discord channel user resolve failed; using config entries. ${formatErrorMessage(err)}`,
-    );
-    return params.guildEntries;
-  }
-}
-
-export async function resolveDiscordAllowlistConfig(params: {
-  token: string;
-  guildEntries: unknown;
-  allowFrom: unknown;
-  discordConfig: DiscordAccountConfig;
-  fetcher: typeof fetch;
-  runtime: RuntimeEnv;
-}): Promise<{ guildEntries: GuildEntries | undefined; allowFrom: string[] | undefined }> {
-  let guildEntries = toGuildEntries(params.guildEntries);
-  let allowFrom = toAllowlistEntries(params.allowFrom);
-
-  if (hasGuildEntries(guildEntries)) {
-    guildEntries = await resolveGuildEntriesByChannelAllowlist({
-      token: params.token,
-      guildEntries,
-      fetcher: params.fetcher,
-      runtime: params.runtime,
-    });
-  }
-
-  if (isDangerousNameMatchingEnabled(params.discordConfig)) {
-    allowFrom = await resolveAllowFromByUserAllowlist({
-      token: params.token,
-      allowFrom,
-      fetcher: params.fetcher,
-      runtime: params.runtime,
-    });
-
-    if (hasGuildEntries(guildEntries)) {
-      guildEntries = await resolveGuildEntriesByUserAllowlist({
-        token: params.token,
-        guildEntries,
-        fetcher: params.fetcher,
-        runtime: params.runtime,
-      });
-    }
-  }
-
-  return {
-    guildEntries: hasGuildEntries(guildEntries) ? guildEntries : undefined,
-    allowFrom,
-  };
-}

package/src/monitor/provider.cleanup.ts

@@ -1,41 +0,0 @@
-import { danger, type RuntimeEnv } from "klaw/plugin-sdk/runtime-env";
-import type { MutableDiscordGateway } from "./gateway-handle.js";
-import type { DiscordMonitorStatusSink } from "./status.js";
-import type { ThreadBindingManager } from "./thread-bindings.js";
-
-type EventEmitterLike = {
-  removeListener(event: string, listener: (...args: unknown[]) => void): unknown;
-};
-
-export function cleanupDiscordProviderStartup(params: {
-  deactivateMessageHandler?: () => void;
-  autoPresenceController?: { stop: () => void } | null;
-  setStatus?: DiscordMonitorStatusSink;
-  onEarlyGatewayDebug?: ((msg: unknown) => void) | undefined;
-  earlyGatewayEmitter?: EventEmitterLike | undefined;
-  lifecycleStarted: boolean;
-  lifecycleGateway?: MutableDiscordGateway;
-  gatewaySupervisor?: { dispose: () => void };
-  threadBindings: ThreadBindingManager;
-  runtime: RuntimeEnv;
-}) {
-  params.deactivateMessageHandler?.();
-  params.autoPresenceController?.stop();
-  params.setStatus?.({ connected: false });
-  if (params.onEarlyGatewayDebug) {
-    params.earlyGatewayEmitter?.removeListener("debug", params.onEarlyGatewayDebug);
-  }
-  if (!params.lifecycleStarted) {
-    try {
-      params.lifecycleGateway?.disconnect();
-    } catch (err) {
-      params.runtime.error?.(
-        danger(`discord: failed to disconnect gateway during startup cleanup: ${String(err)}`),
-      );
-    }
-  }
-  params.gatewaySupervisor?.dispose();
-  if (!params.lifecycleStarted) {
-    params.threadBindings.stop();
-  }
-}