@kodelyth/discord 2026.5.39 → 2026.5.42

package/src/directory-contract.test.ts

@@ -0,0 +1,129 @@
+import type { BaseProbeResult, BaseTokenResolution } from "klaw/plugin-sdk/channel-contract";
+import { expectDirectoryIds } from "klaw/plugin-sdk/channel-test-helpers";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import {
+  listDiscordDirectoryGroupsFromConfig,
+  listDiscordDirectoryPeersFromConfig,
+} from "../directory-contract-api.js";
+import type { DiscordProbe } from "./probe.js";
+import type { DiscordTokenResolution } from "./token.js";
+
+describe("Discord directory contract", () => {
+  it("keeps public probe and token resolution aligned with base contracts", () => {
+    expectTypeOf<DiscordProbe>().toMatchTypeOf<BaseProbeResult>();
+    expectTypeOf<DiscordTokenResolution>().toMatchTypeOf<BaseTokenResolution>();
+  });
+
+  it("lists peers/groups from config (numeric ids only)", async () => {
+    const cfg = {
+      channels: {
+        discord: {
+          token: "discord-test",
+          dm: { allowFrom: ["<@111>", "<@!333>", "nope"] },
+          dms: { "222": {} },
+          guilds: {
+            "123": {
+              users: ["<@12345>", " discord:444 ", "not-an-id"],
+              channels: {
+                "555": {},
+                "<#777>": {},
+                "channel:666": {},
+                general: {},
+              },
+            },
+          },
+        },
+      },
+    } as unknown as KlawConfig;
+
+    await expectDirectoryIds(
+      listDiscordDirectoryPeersFromConfig,
+      cfg,
+      ["user:111", "user:12345", "user:222", "user:333", "user:444"],
+      { sorted: true },
+    );
+    await expectDirectoryIds(
+      listDiscordDirectoryGroupsFromConfig,
+      cfg,
+      ["channel:555", "channel:666", "channel:777"],
+      { sorted: true },
+    );
+  });
+
+  it("keeps directories readable when tokens are unresolved SecretRefs", async () => {
+    const envSecret = {
+      source: "env",
+      provider: "default",
+      id: "MISSING_TEST_SECRET",
+    } as const;
+    const cfg = {
+      channels: {
+        discord: {
+          token: envSecret,
+          dm: { allowFrom: ["<@111>"] },
+          guilds: {
+            "123": {
+              channels: {
+                "555": {},
+              },
+            },
+          },
+        },
+      },
+    } as unknown as KlawConfig;
+
+    await expectDirectoryIds(listDiscordDirectoryPeersFromConfig, cfg, ["user:111"]);
+    await expectDirectoryIds(listDiscordDirectoryGroupsFromConfig, cfg, ["channel:555"]);
+  });
+
+  it("uses account legacy dm.allowFrom before inherited root allowFrom", async () => {
+    const cfg = {
+      channels: {
+        discord: {
+          allowFrom: ["<@111>"],
+          accounts: {
+            work: {
+              dm: { allowFrom: ["<@222>"] },
+            },
+          },
+        },
+      },
+    } as unknown as KlawConfig;
+
+    const entries = await listDiscordDirectoryPeersFromConfig({
+      cfg,
+      accountId: "work",
+      query: null,
+      limit: null,
+    });
+    expect(entries.map((entry) => entry.id)).toEqual(["user:222"]);
+  });
+
+  it("applies query and limit filtering for config-backed directories", async () => {
+    const cfg = {
+      channels: {
+        discord: {
+          token: "discord-test",
+          guilds: {
+            "123": {
+              channels: {
+                "555": {},
+                "666": {},
+                "777": {},
+              },
+            },
+          },
+        },
+      },
+    } as unknown as KlawConfig;
+
+    const groups = await listDiscordDirectoryGroupsFromConfig({
+      cfg,
+      accountId: "default",
+      query: "666",
+      limit: 5,
+    });
+    expect(groups.map((entry) => entry.id)).toEqual(["channel:666"]);
+  });
+});

package/src/directory-live.test.ts

@@ -0,0 +1,141 @@
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import type { DirectoryConfigParams } from "klaw/plugin-sdk/directory-runtime";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { listDiscordDirectoryGroupsLive, listDiscordDirectoryPeersLive } from "./directory-live.js";
+
+function makeParams(overrides: Partial<DirectoryConfigParams> = {}): DirectoryConfigParams {
+  return {
+    cfg: {
+      channels: {
+        discord: {
+          token: "test-token",
+        },
+      },
+    } as KlawConfig,
+    accountId: "default",
+    ...overrides,
+  };
+}
+
+function jsonResponse(value: unknown): Response {
+  return new Response(JSON.stringify(value), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function resolveFetchUrl(input: string | URL | Request): string {
+  return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+}
+
+describe("discord directory live lookups", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.stubEnv("DISCORD_BOT_TOKEN", "");
+  });
+
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it("returns empty group directory when token is missing", async () => {
+    const rows = await listDiscordDirectoryGroupsLive({
+      ...makeParams(),
+      cfg: { channels: { discord: { token: "" } } } as KlawConfig,
+      query: "general",
+    });
+
+    expect(rows).toStrictEqual([]);
+  });
+
+  it("returns empty peer directory without query and skips guild listing", async () => {
+    const fetchSpy = vi.spyOn(globalThis, "fetch");
+
+    const rows = await listDiscordDirectoryPeersLive(makeParams({ query: "  " }));
+
+    expect(rows).toStrictEqual([]);
+    expect(fetchSpy).not.toHaveBeenCalled();
+  });
+
+  it("filters group channels by query and respects limit", async () => {
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input) => {
+      const url = resolveFetchUrl(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([
+          { id: "g1", name: "Guild 1" },
+          { id: "g2", name: "Guild 2" },
+        ]);
+      }
+      if (url.endsWith("/guilds/g1/channels")) {
+        return jsonResponse([
+          { id: "c1", name: "general" },
+          { id: "c2", name: "random" },
+        ]);
+      }
+      if (url.endsWith("/guilds/g2/channels")) {
+        return jsonResponse([{ id: "c3", name: "announcements" }]);
+      }
+      return jsonResponse([]);
+    });
+
+    const rows = await listDiscordDirectoryGroupsLive(makeParams({ query: "an", limit: 2 }));
+
+    expect(rows).toEqual([
+      {
+        kind: "group",
+        id: "channel:c2",
+        name: "random",
+        handle: "#random",
+        raw: { id: "c2", name: "random" },
+      },
+      {
+        kind: "group",
+        id: "channel:c3",
+        name: "announcements",
+        handle: "#announcements",
+        raw: { id: "c3", name: "announcements" },
+      },
+    ]);
+  });
+
+  it("returns ranked peer results and caps member search by limit", async () => {
+    vi.spyOn(globalThis, "fetch").mockImplementation(async (input) => {
+      const url = resolveFetchUrl(input);
+      if (url.endsWith("/users/@me/guilds")) {
+        return jsonResponse([{ id: "g1", name: "Guild 1" }]);
+      }
+      if (url.includes("/guilds/g1/members/search?")) {
+        const params = new URL(url).searchParams;
+        expect(params.get("query")).toBe("alice");
+        expect(params.get("limit")).toBe("2");
+        return jsonResponse([
+          { user: { id: "u1", username: "alice", bot: false }, nick: "Ali" },
+          { user: { id: "u2", username: "alice-bot", bot: true }, nick: null },
+          { user: { id: "u3", username: "ignored", bot: false }, nick: null },
+        ]);
+      }
+      return jsonResponse([]);
+    });
+
+    const rows = await listDiscordDirectoryPeersLive(makeParams({ query: "alice", limit: 2 }));
+
+    expect(rows).toEqual([
+      {
+        kind: "user",
+        id: "user:u1",
+        name: "Ali",
+        handle: "@alice",
+        rank: 1,
+        raw: { user: { id: "u1", username: "alice", bot: false }, nick: "Ali" },
+      },
+      {
+        kind: "user",
+        id: "user:u2",
+        name: "alice-bot",
+        handle: "@alice-bot",
+        rank: 0,
+        raw: { user: { id: "u2", username: "alice-bot", bot: true }, nick: null },
+      },
+    ]);
+  });
+});

package/src/directory-live.ts

@@ -0,0 +1,135 @@
+import type {
+  ChannelDirectoryEntry,
+  DirectoryConfigParams,
+} from "klaw/plugin-sdk/directory-runtime";
+import { normalizeOptionalLowercaseString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { resolveDiscordAccount } from "./accounts.js";
+import { fetchDiscord } from "./api.js";
+import { rememberDiscordDirectoryUser } from "./directory-cache.js";
+import { normalizeDiscordSlug } from "./monitor/allow-list.js";
+import { normalizeDiscordToken } from "./token.js";
+
+type DiscordGuild = { id: string; name: string };
+type DiscordUser = { id: string; username: string; global_name?: string; bot?: boolean };
+type DiscordMember = { user: DiscordUser; nick?: string | null };
+type DiscordChannel = { id: string; name?: string | null };
+type DiscordDirectoryAccess = { token: string; query: string; accountId: string };
+
+function normalizeQuery(value?: string | null): string {
+  return normalizeOptionalLowercaseString(value) ?? "";
+}
+
+function buildUserRank(user: DiscordUser): number {
+  return user.bot ? 0 : 1;
+}
+
+function resolveDiscordDirectoryAccess(
+  params: DirectoryConfigParams,
+): DiscordDirectoryAccess | null {
+  const account = resolveDiscordAccount({ cfg: params.cfg, accountId: params.accountId });
+  const token = normalizeDiscordToken(account.token, "channels.discord.token");
+  if (!token) {
+    return null;
+  }
+  return { token, query: normalizeQuery(params.query), accountId: account.accountId };
+}
+
+async function listDiscordGuilds(token: string): Promise<DiscordGuild[]> {
+  const rawGuilds = await fetchDiscord<DiscordGuild[]>("/users/@me/guilds", token);
+  return rawGuilds.filter((guild) => guild.id && guild.name);
+}
+
+export async function listDiscordDirectoryGroupsLive(
+  params: DirectoryConfigParams,
+): Promise<ChannelDirectoryEntry[]> {
+  const access = resolveDiscordDirectoryAccess(params);
+  if (!access) {
+    return [];
+  }
+  const { token, query } = access;
+  const guilds = await listDiscordGuilds(token);
+  const rows: ChannelDirectoryEntry[] = [];
+
+  for (const guild of guilds) {
+    const channels = await fetchDiscord<DiscordChannel[]>(`/guilds/${guild.id}/channels`, token);
+    for (const channel of channels) {
+      const name = channel.name?.trim();
+      if (!name) {
+        continue;
+      }
+      if (query && !normalizeDiscordSlug(name).includes(normalizeDiscordSlug(query))) {
+        continue;
+      }
+      rows.push({
+        kind: "group",
+        id: `channel:${channel.id}`,
+        name,
+        handle: `#${name}`,
+        raw: channel,
+      });
+      if (typeof params.limit === "number" && params.limit > 0 && rows.length >= params.limit) {
+        return rows;
+      }
+    }
+  }
+
+  return rows;
+}
+
+export async function listDiscordDirectoryPeersLive(
+  params: DirectoryConfigParams,
+): Promise<ChannelDirectoryEntry[]> {
+  const access = resolveDiscordDirectoryAccess(params);
+  if (!access) {
+    return [];
+  }
+  const { token, query, accountId } = access;
+  if (!query) {
+    return [];
+  }
+
+  const guilds = await listDiscordGuilds(token);
+  const rows: ChannelDirectoryEntry[] = [];
+  const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : 25;
+
+  for (const guild of guilds) {
+    const paramsObj = new URLSearchParams({
+      query,
+      limit: String(Math.min(limit, 100)),
+    });
+    const members = await fetchDiscord<DiscordMember[]>(
+      `/guilds/${guild.id}/members/search?${paramsObj.toString()}`,
+      token,
+    );
+    for (const member of members) {
+      const user = member.user;
+      if (!user?.id) {
+        continue;
+      }
+      rememberDiscordDirectoryUser({
+        accountId,
+        userId: user.id,
+        handles: [
+          user.username,
+          user.global_name,
+          member.nick,
+          user.username ? `@${user.username}` : null,
+        ],
+      });
+      const name = member.nick?.trim() || user.global_name?.trim() || user.username?.trim();
+      rows.push({
+        kind: "user",
+        id: `user:${user.id}`,
+        name: name || undefined,
+        handle: user.username ? `@${user.username}` : undefined,
+        rank: buildUserRank(user),
+        raw: member,
+      });
+      if (rows.length >= limit) {
+        return rows;
+      }
+    }
+  }
+
+  return rows;
+}