@kodelyth/discord 2026.5.42 → 2026.6.1

package/src/directory-contract.test.ts

@@ -1,129 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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;
-}