@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/resolve-users.test.ts

@@ -1,243 +0,0 @@
-import { withFetchPreconnect } from "klaw/plugin-sdk/test-env";
-import { describe, expect, it } from "vitest";
-import { resolveDiscordUserAllowlist } from "./resolve-users.js";
-import { jsonResponse, urlToString } from "./test-http-helpers.js";
-
-type DiscordAllowlistResult = Awaited<ReturnType<typeof resolveDiscordUserAllowlist>>[number];
-
-function expectResolvedUser(
-  result: DiscordAllowlistResult | undefined,
-  expected: { id: string; input?: string; name?: string },
-) {
-  if (!result) {
-    throw new Error("expected Discord allowlist result");
-  }
-  expect(result.resolved).toBe(true);
-  expect(result.id).toBe(expected.id);
-  if (expected.input !== undefined) {
-    expect(result.input).toBe(expected.input);
-  }
-  if (expected.name !== undefined) {
-    expect(result.name).toBe(expected.name);
-  }
-}
-
-function expectUnresolvedUser(result: DiscordAllowlistResult | undefined) {
-  if (!result) {
-    throw new Error("expected Discord allowlist result");
-  }
-  expect(result.resolved).toBe(false);
-}
-
-function createGuildListProbeFetcher() {
-  let guildsCalled = false;
-  const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
-    const url = urlToString(input);
-    if (url.endsWith("/users/@me/guilds")) {
-      guildsCalled = true;
-      return jsonResponse([]);
-    }
-    return new Response("not found", { status: 404 });
-  });
-  return {
-    fetcher,
-    wasGuildsCalled: () => guildsCalled,
-  };
-}
-
-function createGuildsForbiddenFetcher() {
-  return withFetchPreconnect(async (input: RequestInfo | URL) => {
-    const url = urlToString(input);
-    if (url.endsWith("/users/@me/guilds")) {
-      throw new Error("Forbidden: Missing Access");
-    }
-    return new Response("not found", { status: 404 });
-  });
-}
-
-describe("resolveDiscordUserAllowlist", () => {
-  it("resolves plain user ids without calling listGuilds", async () => {
-    const { fetcher, wasGuildsCalled } = createGuildListProbeFetcher();
-
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["123456789012345678"],
-      fetcher,
-    });
-
-    expect(results).toEqual([
-      {
-        input: "123456789012345678",
-        resolved: true,
-        id: "123456789012345678",
-      },
-    ]);
-    expect(wasGuildsCalled()).toBe(false);
-  });
-
-  it("resolves mention-format ids without calling listGuilds", async () => {
-    const { fetcher, wasGuildsCalled } = createGuildListProbeFetcher();
-
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["<@!123456789012345678>"],
-      fetcher,
-    });
-
-    expect(results).toEqual([
-      {
-        input: "<@!123456789012345678>",
-        resolved: true,
-        id: "123456789012345678",
-      },
-    ]);
-    expect(wasGuildsCalled()).toBe(false);
-  });
-
-  it("resolves prefixed ids (user:, discord:) without calling listGuilds", async () => {
-    const { fetcher, wasGuildsCalled } = createGuildListProbeFetcher();
-
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["user:111", "discord:222"],
-      fetcher,
-    });
-
-    expect(results).toHaveLength(2);
-    expectResolvedUser(results[0], { id: "111" });
-    expectResolvedUser(results[1], { id: "222" });
-    expect(wasGuildsCalled()).toBe(false);
-  });
-
-  it("resolves user ids even when listGuilds would fail", async () => {
-    const fetcher = createGuildsForbiddenFetcher();
-
-    // Before the fix, this would throw because listGuilds() was called eagerly
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["994979735488692324"],
-      fetcher,
-    });
-
-    expect(results).toEqual([
-      {
-        input: "994979735488692324",
-        resolved: true,
-        id: "994979735488692324",
-      },
-    ]);
-  });
-
-  it("calls listGuilds lazily when resolving usernames", async () => {
-    let guildsCalled = false;
-    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
-      const url = urlToString(input);
-      if (url.endsWith("/users/@me/guilds")) {
-        guildsCalled = true;
-        return jsonResponse([{ id: "g1", name: "Test Guild" }]);
-      }
-      if (url.includes("/guilds/g1/members/search")) {
-        return jsonResponse([
-          {
-            user: { id: "u1", username: "alice", bot: false },
-            nick: null,
-          },
-        ]);
-      }
-      return new Response("not found", { status: 404 });
-    });
-
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["alice"],
-      fetcher,
-    });
-
-    expect(guildsCalled).toBe(true);
-    expect(results).toHaveLength(1);
-    expectResolvedUser(results[0], { input: "alice", id: "u1", name: "alice" });
-  });
-
-  it("fetches guilds only once for multiple username entries", async () => {
-    let guildsCallCount = 0;
-    const fetcher = withFetchPreconnect(async (input: RequestInfo | URL) => {
-      const url = urlToString(input);
-      if (url.endsWith("/users/@me/guilds")) {
-        guildsCallCount++;
-        return jsonResponse([{ id: "g1", name: "Test Guild" }]);
-      }
-      if (url.includes("/guilds/g1/members/search")) {
-        const params = new URL(url).searchParams;
-        const query = params.get("query") ?? "";
-        return jsonResponse([
-          {
-            user: { id: `u-${query}`, username: query, bot: false },
-            nick: null,
-          },
-        ]);
-      }
-      return new Response("not found", { status: 404 });
-    });
-
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["alice", "bob"],
-      fetcher,
-    });
-
-    expect(guildsCallCount).toBe(1);
-    expect(results).toHaveLength(2);
-    expectResolvedUser(results[0], { id: "u-alice" });
-    expectResolvedUser(results[1], { id: "u-bob" });
-  });
-
-  it("handles mixed ids and usernames — ids resolve even if guilds fail", async () => {
-    const fetcher = createGuildsForbiddenFetcher();
-
-    // IDs should succeed, username should fail (listGuilds throws)
-    await expect(
-      resolveDiscordUserAllowlist({
-        token: "test",
-        entries: ["123456789012345678", "alice"],
-        fetcher,
-      }),
-    ).rejects.toThrow("Forbidden");
-
-    // But if we only pass IDs, it should work fine
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["123456789012345678", "<@999>"],
-      fetcher,
-    });
-
-    expect(results).toHaveLength(2);
-    expectResolvedUser(results[0], { id: "123456789012345678" });
-    expectResolvedUser(results[1], { id: "999" });
-  });
-
-  it("returns unresolved for empty/blank entries", async () => {
-    const fetcher = withFetchPreconnect(async () => {
-      return new Response("not found", { status: 404 });
-    });
-
-    const results = await resolveDiscordUserAllowlist({
-      token: "test",
-      entries: ["", "  "],
-      fetcher,
-    });
-
-    expect(results).toHaveLength(2);
-    expectUnresolvedUser(results[0]);
-    expectUnresolvedUser(results[1]);
-  });
-
-  it("returns all unresolved when token is empty", async () => {
-    const results = await resolveDiscordUserAllowlist({
-      token: "",
-      entries: ["123456789012345678", "alice"],
-    });
-
-    expect(results).toHaveLength(2);
-    expect(results.map((result) => result.resolved)).toEqual([false, false]);
-  });
-});

package/src/resolve-users.ts

@@ -1,184 +0,0 @@
-import {
-  normalizeLowercaseStringOrEmpty,
-  normalizeOptionalString,
-} from "klaw/plugin-sdk/string-coerce-runtime";
-import { fetchDiscord } from "./api.js";
-import { listGuilds, type DiscordGuildSummary } from "./guilds.js";
-import {
-  buildDiscordUnresolvedResults,
-  filterDiscordGuilds,
-  resolveDiscordAllowlistToken,
-} from "./resolve-allowlist-common.js";
-
-type DiscordUser = {
-  id: string;
-  username: string;
-  discriminator?: string;
-  global_name?: string;
-  bot?: boolean;
-};
-
-type DiscordMember = {
-  user: DiscordUser;
-  nick?: string | null;
-};
-
-export type DiscordUserResolution = {
-  input: string;
-  resolved: boolean;
-  id?: string;
-  name?: string;
-  guildId?: string;
-  guildName?: string;
-  note?: string;
-};
-
-function parseDiscordUserInput(raw: string): {
-  userId?: string;
-  guildId?: string;
-  guildName?: string;
-  userName?: string;
-} {
-  const trimmed = raw.trim();
-  if (!trimmed) {
-    return {};
-  }
-  const mention = trimmed.match(/^<@!?(\d+)>$/);
-  if (mention) {
-    return { userId: mention[1] };
-  }
-  const prefixed = trimmed.match(/^(?:user:|discord:)?(\d+)$/i);
-  if (prefixed) {
-    return { userId: prefixed[1] };
-  }
-  const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
-  if (split.length >= 2) {
-    const guild = split[0]?.trim();
-    const user = split.slice(1).join("#").trim();
-    if (guild && /^\d+$/.test(guild)) {
-      return { guildId: guild, userName: user };
-    }
-    return { guildName: guild, userName: user };
-  }
-  return { userName: trimmed.replace(/^@/, "") };
-}
-
-function scoreDiscordMember(member: DiscordMember, query: string): number {
-  const q = normalizeLowercaseStringOrEmpty(query);
-  const user = member.user;
-  const candidates = [user.username, user.global_name, member.nick ?? undefined]
-    .map((value) => {
-      const normalized = normalizeOptionalString(value);
-      return normalized ? normalizeLowercaseStringOrEmpty(normalized) : undefined;
-    })
-    .filter(Boolean) as string[];
-  let score = 0;
-  if (candidates.some((value) => value === q)) {
-    score += 3;
-  }
-  if (candidates.some((value) => value?.includes(q))) {
-    score += 1;
-  }
-  if (!user.bot) {
-    score += 1;
-  }
-  return score;
-}
-
-export async function resolveDiscordUserAllowlist(params: {
-  token: string;
-  entries: string[];
-  fetcher?: typeof fetch;
-}): Promise<DiscordUserResolution[]> {
-  const token = resolveDiscordAllowlistToken(params.token);
-  if (!token) {
-    return buildDiscordUnresolvedResults(params.entries, (input) => ({
-      input,
-      resolved: false,
-    }));
-  }
-  const fetcher = params.fetcher ?? fetch;
-
-  // Lazy-load guilds: only fetch when an entry actually needs username search.
-  // This prevents listGuilds() failures (permissions, network) from blocking
-  // resolution of plain user-id entries that don't need guild data at all.
-  let guilds: DiscordGuildSummary[] | null = null;
-  const getGuilds = async (): Promise<DiscordGuildSummary[]> => {
-    if (!guilds) {
-      guilds = await listGuilds(token, fetcher);
-    }
-    return guilds;
-  };
-
-  const results: DiscordUserResolution[] = [];
-
-  for (const input of params.entries) {
-    const parsed = parseDiscordUserInput(input);
-    if (parsed.userId) {
-      results.push({
-        input,
-        resolved: true,
-        id: parsed.userId,
-      });
-      continue;
-    }
-
-    const query = parsed.userName?.trim();
-    if (!query) {
-      results.push({ input, resolved: false });
-      continue;
-    }
-
-    const allGuilds = await getGuilds();
-    const guildList = filterDiscordGuilds(allGuilds, {
-      guildId: parsed.guildId,
-      guildName: parsed.guildName?.trim(),
-    });
-
-    let best: { member: DiscordMember; guild: DiscordGuildSummary; score: number } | null = null;
-    let matches = 0;
-
-    for (const guild of guildList) {
-      const paramsObj = new URLSearchParams({
-        query,
-        limit: "25",
-      });
-      const members = await fetchDiscord<DiscordMember[]>(
-        `/guilds/${guild.id}/members/search?${paramsObj.toString()}`,
-        token,
-        fetcher,
-      );
-      for (const member of members) {
-        const score = scoreDiscordMember(member, query);
-        if (score === 0) {
-          continue;
-        }
-        matches += 1;
-        if (!best || score > best.score) {
-          best = { member, guild, score };
-        }
-      }
-    }
-
-    if (best) {
-      const user = best.member.user;
-      const name =
-        normalizeOptionalString(best.member.nick) ??
-        normalizeOptionalString(user.global_name) ??
-        normalizeOptionalString(user.username);
-      results.push({
-        input,
-        resolved: true,
-        id: user.id,
-        name,
-        guildId: best.guild.id,
-        guildName: best.guild.name,
-        note: matches > 1 ? "multiple matches; chose best" : undefined,
-      });
-    } else {
-      results.push({ input, resolved: false });
-    }
-  }
-
-  return results;
-}

package/src/retry.test.ts

@@ -1,83 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { isRetryableDiscordDeliveryError } from "./delivery-retry.js";
-import { DiscordError, RateLimitError } from "./internal/discord.js";
-import { createDiscordRetryRunner, isRetryableDiscordTransientError } from "./retry.js";
-
-const ZERO_DELAY_RETRY = { attempts: 2, minDelayMs: 0, maxDelayMs: 0, jitter: 0 };
-
-function createRateLimitError(retryAfter = 0): RateLimitError {
-  const response = new Response(null, {
-    status: 429,
-    headers: {
-      "X-RateLimit-Scope": "user",
-      "X-RateLimit-Bucket": "bucket-1",
-    },
-  });
-  const RateLimitErrorCtor = RateLimitError as unknown as new (
-    response: Response,
-    body: { message: string; retry_after: number; global: boolean },
-  ) => RateLimitError;
-  return new RateLimitErrorCtor(response, {
-    message: "rate limited",
-    retry_after: retryAfter,
-    global: false,
-  });
-}
-
-describe("isRetryableDiscordTransientError", () => {
-  it.each([
-    ["rate limit", createRateLimitError()],
-    ["408 status", Object.assign(new Error("request timeout"), { status: 408 })],
-    ["502 status", Object.assign(new Error("bad gateway"), { status: 502 })],
-    ["503 statusCode", Object.assign(new Error("service unavailable"), { statusCode: 503 })],
-    ["fetch failed", new TypeError("fetch failed")],
-    ["ECONNRESET", Object.assign(new Error("socket hang up"), { code: "ECONNRESET" })],
-    ["ETIMEDOUT cause", new Error("request failed", { cause: { code: "ETIMEDOUT" } })],
-    ["abort", Object.assign(new Error("aborted"), { name: "AbortError" })],
-  ])("retries %s", (_name, err) => {
-    expect(isRetryableDiscordTransientError(err)).toBe(true);
-  });
-
-  it.each([
-    ["400 status", Object.assign(new Error("bad request"), { status: 400 })],
-    ["403 status", Object.assign(new Error("missing permissions"), { statusCode: 403 })],
-    ["unknown channel", new Error("Unknown Channel")],
-    ["plain string", "fetch failed"],
-  ])("does not retry %s", (_name, err) => {
-    expect(isRetryableDiscordTransientError(err)).toBe(false);
-  });
-});
-
-describe("createDiscordRetryRunner", () => {
-  it("retries transient transport errors", async () => {
-    const fn = vi.fn().mockRejectedValueOnce(new TypeError("fetch failed")).mockResolvedValue("ok");
-    const runner = createDiscordRetryRunner({ retry: ZERO_DELAY_RETRY });
-
-    await expect(runner(fn, "send")).resolves.toBe("ok");
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-
-  it("stops after configured transient retry attempts", async () => {
-    const fn = vi.fn().mockRejectedValue(new TypeError("fetch failed"));
-    const runner = createDiscordRetryRunner({ retry: ZERO_DELAY_RETRY });
-
-    await expect(runner(fn, "send")).rejects.toThrow("fetch failed");
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-});
-
-describe("isRetryableDiscordDeliveryError", () => {
-  it("retries status-coded errors from injected delivery dependencies", () => {
-    expect(
-      isRetryableDiscordDeliveryError(Object.assign(new Error("bad gateway"), { status: 502 })),
-    ).toBe(true);
-  });
-
-  it("does not retry Discord client errors after the request runner handled them", () => {
-    const err = new DiscordError(new Response("upstream", { status: 502 }), {
-      message: "Bad Gateway",
-    });
-
-    expect(isRetryableDiscordDeliveryError(err)).toBe(false);
-  });
-});

package/src/retry.ts

@@ -1,98 +0,0 @@
-import {
-  collectErrorGraphCandidates,
-  extractErrorCode,
-  formatErrorMessage,
-  readErrorName,
-} from "klaw/plugin-sdk/error-runtime";
-import {
-  createRateLimitRetryRunner,
-  type RetryConfig,
-  type RetryRunner,
-} from "klaw/plugin-sdk/retry-runtime";
-import { RateLimitError } from "./internal/discord.js";
-
-const DISCORD_RETRY_DEFAULTS = {
-  attempts: 3,
-  minDelayMs: 500,
-  maxDelayMs: 30_000,
-  jitter: 0.1,
-} satisfies RetryConfig;
-
-const DISCORD_RETRYABLE_STATUS_CODES = new Set([408, 429]);
-const DISCORD_RETRYABLE_ERROR_CODES = new Set([
-  "EAI_AGAIN",
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENETUNREACH",
-  "ENOTFOUND",
-  "EPIPE",
-  "ETIMEDOUT",
-  "UND_ERR_BODY_TIMEOUT",
-  "UND_ERR_CONNECT_TIMEOUT",
-  "UND_ERR_HEADERS_TIMEOUT",
-  "UND_ERR_SOCKET",
-]);
-const DISCORD_TRANSIENT_MESSAGE_RE =
-  /\b(?:bad gateway|fetch failed|network error|networkerror|service unavailable|socket hang up|temporarily unavailable|timed out|timeout)\b|connection (?:closed|reset|refused)/i;
-
-function readDiscordErrorStatus(err: unknown): number | undefined {
-  if (!err || typeof err !== "object") {
-    return undefined;
-  }
-  const raw =
-    "status" in err && err.status !== undefined
-      ? err.status
-      : "statusCode" in err && err.statusCode !== undefined
-        ? err.statusCode
-        : undefined;
-  if (typeof raw === "number" && Number.isFinite(raw)) {
-    return raw;
-  }
-  if (typeof raw === "string" && /^\d+$/.test(raw)) {
-    return Number(raw);
-  }
-  return undefined;
-}
-
-export function isRetryableDiscordTransientError(err: unknown): boolean {
-  if (err instanceof RateLimitError) {
-    return true;
-  }
-  for (const candidate of collectErrorGraphCandidates(err, (current) => [
-    current.cause,
-    current.error,
-  ])) {
-    const status = readDiscordErrorStatus(candidate);
-    if (status !== undefined && (DISCORD_RETRYABLE_STATUS_CODES.has(status) || status >= 500)) {
-      return true;
-    }
-    const code = extractErrorCode(candidate);
-    if (code && DISCORD_RETRYABLE_ERROR_CODES.has(code.toUpperCase())) {
-      return true;
-    }
-    if (readErrorName(candidate) === "AbortError") {
-      return true;
-    }
-    if (
-      (candidate instanceof Error || (candidate !== null && typeof candidate === "object")) &&
-      DISCORD_TRANSIENT_MESSAGE_RE.test(formatErrorMessage(candidate))
-    ) {
-      return true;
-    }
-  }
-  return false;
-}
-
-export function createDiscordRetryRunner(params: {
-  retry?: RetryConfig;
-  configRetry?: RetryConfig;
-  verbose?: boolean;
-}): RetryRunner {
-  return createRateLimitRetryRunner({
-    ...params,
-    defaults: DISCORD_RETRY_DEFAULTS,
-    logLabel: "discord",
-    shouldRetry: isRetryableDiscordTransientError,
-    retryAfterMs: (err) => (err instanceof RateLimitError ? err.retryAfter * 1000 : undefined),
-  });
-}

package/src/runtime-api.ts

@@ -1,61 +0,0 @@
-export {
-  buildComputedAccountStatusSnapshot,
-  buildTokenChannelStatusSummary,
-  PAIRING_APPROVED_MESSAGE,
-  projectCredentialSnapshotFields,
-  resolveConfiguredFromCredentialStatuses,
-} from "klaw/plugin-sdk/channel-status";
-export { buildChannelConfigSchema, DiscordConfigSchema } from "../config-api.js";
-export type {
-  ChannelMessageActionAdapter,
-  ChannelMessageActionContext,
-  ChannelMessageActionName,
-} from "klaw/plugin-sdk/channel-contract";
-export type {
-  ChannelPlugin,
-  KlawPluginApi,
-  PluginRuntime,
-} from "klaw/plugin-sdk/channel-plugin-common";
-export type {
-  DiscordAccountConfig,
-  DiscordActionConfig,
-  DiscordConfig,
-  KlawConfig,
-} from "klaw/plugin-sdk/config-contracts";
-export {
-  jsonResult,
-  readNumberParam,
-  readStringArrayParam,
-  readStringParam,
-  resolvePollMaxSelections,
-} from "klaw/plugin-sdk/channel-actions";
-export type { ActionGate } from "klaw/plugin-sdk/channel-actions";
-export { readBooleanParam } from "klaw/plugin-sdk/boolean-param";
-export {
-  assertMediaNotDataUrl,
-  parseAvailableTags,
-  readReactionParams,
-  withNormalizedTimestamp,
-} from "klaw/plugin-sdk/channel-actions";
-export {
-  createHybridChannelConfigAdapter,
-  createScopedChannelConfigAdapter,
-  createScopedAccountConfigAccessors,
-  createScopedChannelConfigBase,
-  createTopLevelChannelConfigAdapter,
-} from "klaw/plugin-sdk/channel-config-helpers";
-export { createAccountActionGate, createAccountListHelpers } from "klaw/plugin-sdk/account-helpers";
-export { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
-export {
-  emptyPluginConfigSchema,
-  formatPairingApproveHint,
-} from "klaw/plugin-sdk/channel-plugin-common";
-export { loadOutboundMediaFromUrl } from "klaw/plugin-sdk/outbound-media";
-export { resolveAccountEntry } from "klaw/plugin-sdk/routing";
-export {
-  hasConfiguredSecretInput,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-} from "klaw/plugin-sdk/secret-input";
-export { getChatChannelMeta } from "./channel-api.js";
-export { resolveDiscordOutboundSessionRoute } from "./outbound-session-route.js";

package/src/runtime-config.ts

@@ -1,16 +0,0 @@
-import {
-  getRuntimeConfigSnapshot,
-  getRuntimeConfigSourceSnapshot,
-  selectApplicableRuntimeConfig,
-} from "klaw/plugin-sdk/runtime-config-snapshot";
-import type { KlawConfig } from "./runtime-api.js";
-
-export function selectDiscordRuntimeConfig(inputConfig: KlawConfig): KlawConfig {
-  return (
-    selectApplicableRuntimeConfig({
-      inputConfig,
-      runtimeConfig: getRuntimeConfigSnapshot(),
-      runtimeSourceConfig: getRuntimeConfigSourceSnapshot(),
-    }) ?? inputConfig
-  );
-}