@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/probe.ts

@@ -1,237 +0,0 @@
-import type { BaseProbeResult } from "klaw/plugin-sdk/channel-contract";
-import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
-import { resolveFetch } from "klaw/plugin-sdk/fetch-runtime";
-import { fetchWithTimeout } from "klaw/plugin-sdk/text-utility-runtime";
-import { DiscordApiError, fetchDiscord } from "./api.js";
-import { normalizeDiscordToken } from "./token.js";
-
-const DISCORD_API_BASE = "https://discord.com/api/v10";
-
-export type DiscordProbe = BaseProbeResult & {
-  status?: number | null;
-  elapsedMs: number;
-  bot?: { id?: string | null; username?: string | null };
-  application?: DiscordApplicationSummary;
-};
-
-export type DiscordPrivilegedIntentStatus = "enabled" | "limited" | "disabled";
-
-export type DiscordPrivilegedIntentsSummary = {
-  messageContent: DiscordPrivilegedIntentStatus;
-  guildMembers: DiscordPrivilegedIntentStatus;
-  presence: DiscordPrivilegedIntentStatus;
-};
-
-export type DiscordApplicationSummary = {
-  id?: string | null;
-  flags?: number | null;
-  intents?: DiscordPrivilegedIntentsSummary;
-};
-
-const DISCORD_APP_FLAG_GATEWAY_PRESENCE = 1 << 12;
-const DISCORD_APP_FLAG_GATEWAY_PRESENCE_LIMITED = 1 << 13;
-const DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS = 1 << 14;
-const DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS_LIMITED = 1 << 15;
-const DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT = 1 << 18;
-const DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT_LIMITED = 1 << 19;
-
-async function fetchDiscordApplicationMe(
-  token: string,
-  timeoutMs: number,
-  fetcher: typeof fetch,
-): Promise<{ id?: string; flags?: number } | undefined> {
-  try {
-    const normalized = normalizeDiscordToken(token, "channels.discord.token");
-    if (!normalized) {
-      return undefined;
-    }
-    return await fetchDiscord<{ id?: string; flags?: number }>(
-      "/oauth2/applications/@me",
-      normalized,
-      createDiscordTimeoutFetch(fetcher, timeoutMs),
-      { retry: { attempts: 1 } },
-    );
-  } catch {
-    return undefined;
-  }
-}
-
-function createDiscordTimeoutFetch(fetcher: typeof fetch, timeoutMs: number): typeof fetch {
-  const fetchImpl = getResolvedFetch(fetcher);
-  return ((input: RequestInfo | URL, init?: RequestInit) =>
-    fetchWithTimeout(
-      typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url,
-      init ?? {},
-      timeoutMs,
-      fetchImpl,
-    )) as typeof fetch;
-}
-
-export function resolveDiscordPrivilegedIntentsFromFlags(
-  flags: number,
-): DiscordPrivilegedIntentsSummary {
-  const resolve = (enabledBit: number, limitedBit: number) => {
-    if ((flags & enabledBit) !== 0) {
-      return "enabled";
-    }
-    if ((flags & limitedBit) !== 0) {
-      return "limited";
-    }
-    return "disabled";
-  };
-  return {
-    presence: resolve(DISCORD_APP_FLAG_GATEWAY_PRESENCE, DISCORD_APP_FLAG_GATEWAY_PRESENCE_LIMITED),
-    guildMembers: resolve(
-      DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS,
-      DISCORD_APP_FLAG_GATEWAY_GUILD_MEMBERS_LIMITED,
-    ),
-    messageContent: resolve(
-      DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT,
-      DISCORD_APP_FLAG_GATEWAY_MESSAGE_CONTENT_LIMITED,
-    ),
-  };
-}
-
-export async function fetchDiscordApplicationSummary(
-  token: string,
-  timeoutMs: number,
-  fetcher: typeof fetch = fetch,
-): Promise<DiscordApplicationSummary | undefined> {
-  const json = await fetchDiscordApplicationMe(token, timeoutMs, fetcher);
-  if (!json) {
-    return undefined;
-  }
-  const flags =
-    typeof json.flags === "number" && Number.isFinite(json.flags) ? json.flags : undefined;
-  return {
-    id: json.id ?? null,
-    flags: flags ?? null,
-    intents:
-      typeof flags === "number" ? resolveDiscordPrivilegedIntentsFromFlags(flags) : undefined,
-  };
-}
-
-function getResolvedFetch(fetcher: typeof fetch): typeof fetch {
-  const fetchImpl = resolveFetch(fetcher);
-  if (!fetchImpl) {
-    throw new Error("fetch is not available");
-  }
-  return fetchImpl;
-}
-
-export async function probeDiscord(
-  token: string,
-  timeoutMs: number,
-  opts?: { fetcher?: typeof fetch; includeApplication?: boolean },
-): Promise<DiscordProbe> {
-  const started = Date.now();
-  const fetcher = opts?.fetcher ?? fetch;
-  const includeApplication = opts?.includeApplication === true;
-  const normalized = normalizeDiscordToken(token, "channels.discord.token");
-  const result: DiscordProbe = {
-    ok: false,
-    status: null,
-    error: null,
-    elapsedMs: 0,
-  };
-  if (!normalized) {
-    return {
-      ...result,
-      error: "missing token",
-      elapsedMs: Date.now() - started,
-    };
-  }
-  try {
-    const res = await fetchWithTimeout(
-      `${DISCORD_API_BASE}/users/@me`,
-      { headers: { Authorization: `Bot ${normalized}` } },
-      timeoutMs,
-      getResolvedFetch(fetcher),
-    );
-    if (!res.ok) {
-      result.status = res.status;
-      result.error = `getMe failed (${res.status})`;
-      return { ...result, elapsedMs: Date.now() - started };
-    }
-    const json = (await res.json()) as { id?: string; username?: string };
-    result.ok = true;
-    result.bot = {
-      id: json.id ?? null,
-      username: json.username ?? null,
-    };
-    if (includeApplication) {
-      result.application =
-        (await fetchDiscordApplicationSummary(normalized, timeoutMs, fetcher)) ?? undefined;
-    }
-    return { ...result, elapsedMs: Date.now() - started };
-  } catch (err) {
-    return {
-      ...result,
-      status: err instanceof Response ? err.status : result.status,
-      error: formatErrorMessage(err),
-      elapsedMs: Date.now() - started,
-    };
-  }
-}
-
-/**
- * Extract the application (bot user) ID from a Discord bot token by
- * base64-decoding the first segment.  Discord tokens have the format:
- *   base64(user_id) . timestamp . hmac
- * The decoded first segment is the numeric snowflake ID as a plain string,
- * so we keep it as a string to avoid precision loss for IDs that exceed
- * Number.MAX_SAFE_INTEGER.
- */
-export function parseApplicationIdFromToken(token: string): string | undefined {
-  const normalized = normalizeDiscordToken(token, "channels.discord.token");
-  if (!normalized) {
-    return undefined;
-  }
-  const firstDot = normalized.indexOf(".");
-  if (firstDot <= 0) {
-    return undefined;
-  }
-  try {
-    const decoded = Buffer.from(normalized.slice(0, firstDot), "base64").toString("utf-8");
-    if (/^\d+$/.test(decoded)) {
-      return decoded;
-    }
-    return undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-export async function fetchDiscordApplicationId(
-  token: string,
-  timeoutMs: number,
-  fetcher: typeof fetch = fetch,
-): Promise<string | undefined> {
-  const normalized = normalizeDiscordToken(token, "channels.discord.token");
-  if (!normalized) {
-    return undefined;
-  }
-  const parsedApplicationId = parseApplicationIdFromToken(token);
-  if (parsedApplicationId) {
-    return parsedApplicationId;
-  }
-  try {
-    const json = await fetchDiscord<{ id?: string }>(
-      "/oauth2/applications/@me",
-      normalized,
-      createDiscordTimeoutFetch(fetcher, timeoutMs),
-    );
-    if (json?.id) {
-      return json.id;
-    }
-    return undefined;
-  } catch (error) {
-    if (error instanceof DiscordApiError) {
-      if (error.status === 429) {
-        throw error;
-      }
-      return undefined;
-    }
-    return undefined;
-  }
-}

package/src/proxy-fetch.ts

@@ -1,92 +0,0 @@
-import { isIP } from "node:net";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { makeProxyFetch } from "klaw/plugin-sdk/fetch-runtime";
-import { danger } from "klaw/plugin-sdk/runtime-env";
-import type { RuntimeEnv } from "klaw/plugin-sdk/runtime-env";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-import type { ResolvedDiscordAccount } from "./accounts.js";
-
-function resolveDiscordProxyUrl(
-  account: Pick<ResolvedDiscordAccount, "config">,
-  cfg: KlawConfig,
-): string | undefined {
-  const accountProxy = account.config.proxy?.trim();
-  if (accountProxy) {
-    return accountProxy;
-  }
-  const channelProxy = cfg?.channels?.discord?.proxy;
-  if (typeof channelProxy !== "string") {
-    return undefined;
-  }
-  const trimmed = channelProxy.trim();
-  return trimmed || undefined;
-}
-
-function resolveDiscordProxyFetchByUrl(
-  proxyUrl: string | undefined,
-  runtime?: Pick<RuntimeEnv, "error">,
-): typeof fetch | undefined {
-  return withValidatedDiscordProxy(proxyUrl, runtime, (proxy) => makeProxyFetch(proxy));
-}
-
-export function resolveDiscordProxyFetchForAccount(
-  account: Pick<ResolvedDiscordAccount, "config">,
-  cfg: KlawConfig,
-  runtime?: Pick<RuntimeEnv, "error">,
-): typeof fetch | undefined {
-  return resolveDiscordProxyFetchByUrl(resolveDiscordProxyUrl(account, cfg), runtime);
-}
-
-export function withValidatedDiscordProxy<T>(
-  proxyUrl: string | undefined,
-  runtime: Pick<RuntimeEnv, "error"> | undefined,
-  createValue: (proxyUrl: string) => T,
-): T | undefined {
-  const proxy = proxyUrl?.trim();
-  if (!proxy) {
-    return undefined;
-  }
-  try {
-    validateDiscordProxyUrl(proxy);
-    return createValue(proxy);
-  } catch (err) {
-    runtime?.error?.(danger(`discord: invalid rest proxy: ${String(err)}`));
-    return undefined;
-  }
-}
-
-export function validateDiscordProxyUrl(proxyUrl: string): string {
-  let parsed: URL;
-  try {
-    parsed = new URL(proxyUrl);
-  } catch {
-    throw new Error("Proxy URL must be a valid http or https URL");
-  }
-  if (!["http:", "https:"].includes(parsed.protocol)) {
-    throw new Error("Proxy URL must use http or https");
-  }
-  if (!isLoopbackProxyHostname(parsed.hostname)) {
-    throw new Error("Proxy URL must target a loopback host");
-  }
-  return proxyUrl;
-}
-
-function isLoopbackProxyHostname(hostname: string): boolean {
-  const normalized = normalizeLowercaseStringOrEmpty(hostname);
-  if (!normalized) {
-    return false;
-  }
-  const bracketless =
-    normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
-  if (bracketless === "localhost") {
-    return true;
-  }
-  const ipFamily = isIP(bracketless);
-  if (ipFamily === 4) {
-    return bracketless.startsWith("127.");
-  }
-  if (ipFamily === 6) {
-    return bracketless === "::1" || bracketless === "0:0:0:0:0:0:0:1";
-  }
-  return false;
-}

package/src/proxy-request-client.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import {
-  createAbortableFetchMock,
-  createJsonResponse,
-} from "./internal/test-builders.test-support.js";
-import { createDiscordRequestClient, DISCORD_REST_TIMEOUT_MS } from "./proxy-request-client.js";
-
-async function expectAbortError(promise: Promise<unknown>) {
-  let abortError: unknown;
-  try {
-    await promise;
-  } catch (error) {
-    abortError = error;
-  }
-  expect(abortError).toBeInstanceOf(DOMException);
-  if (!(abortError instanceof DOMException)) {
-    throw new Error("expected Discord request abort error");
-  }
-  expect(abortError.name).toBe("AbortError");
-  expect(abortError.message).toBe("The operation was aborted.");
-}
-
-describe("createDiscordRequestClient", () => {
-  it("preserves the REST client's abort signal for proxied fetch calls", async () => {
-    const fetchSpy = vi.fn(async (_input: string | URL | Request, init?: RequestInit) => {
-      if (!(init?.signal instanceof AbortSignal)) {
-        throw new Error("Expected proxied fetch init to include an AbortSignal");
-      }
-      expect(init.signal.aborted).toBe(false);
-      return createJsonResponse([]);
-    });
-
-    const client = createDiscordRequestClient("Bot test-token", {
-      fetch: fetchSpy as never,
-      queueRequests: false,
-    });
-
-    await client.get("/channels/123/messages");
-    expect(fetchSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it("lets the REST client abort hanging proxied requests after its timeout", async () => {
-    const { fetch: fetchSpy } = createAbortableFetchMock();
-
-    const client = createDiscordRequestClient("Bot test-token", {
-      fetch: fetchSpy as never,
-      queueRequests: false,
-      timeout: 20,
-    });
-
-    await expectAbortError(client.get("/channels/123/messages"));
-  }, 1_000);
-
-  it("lets abortAllRequests cancel active proxied fetches", async () => {
-    const abortable = createAbortableFetchMock();
-
-    const client = createDiscordRequestClient("Bot test-token", {
-      fetch: abortable.fetch as never,
-      queueRequests: false,
-      timeout: 5_000,
-    });
-
-    const request = client.get("/channels/123/messages");
-    await vi.waitFor(() => expect(abortable.fetch).toHaveBeenCalledTimes(1));
-
-    client.abortAllRequests();
-
-    await expectAbortError(request);
-    if (!abortable.receivedSignal) {
-      throw new Error("Expected proxied fetch abort signal");
-    }
-    expect(abortable.receivedSignal.aborted).toBe(true);
-  });
-
-  it("provides the REST client's timeout signal even without a caller signal", async () => {
-    let receivedSignal: AbortSignal | undefined;
-
-    const fetchSpy = vi.fn(async (_input: string | URL | Request, init?: RequestInit) => {
-      receivedSignal = init?.signal ?? undefined;
-      return createJsonResponse({});
-    });
-
-    const client = createDiscordRequestClient("Bot test-token", {
-      fetch: fetchSpy as never,
-      queueRequests: false,
-    });
-
-    await client.get("/channels/123/messages");
-
-    if (!receivedSignal) {
-      throw new Error("Expected proxied fetch to receive the REST timeout signal");
-    }
-    expect(receivedSignal.aborted).toBe(false);
-  });
-
-  it("exports a reasonable timeout constant", () => {
-    expect(DISCORD_REST_TIMEOUT_MS).toBeGreaterThanOrEqual(5_000);
-    expect(DISCORD_REST_TIMEOUT_MS).toBeLessThanOrEqual(30_000);
-  });
-});

package/src/proxy-request-client.ts

@@ -1,21 +0,0 @@
-import { RequestClient, type RequestClientOptions } from "./internal/discord.js";
-
-type ProxyRequestClientOptions = RequestClientOptions;
-
-export const DISCORD_REST_TIMEOUT_MS = 15_000;
-
-export function createDiscordRequestClient(
-  token: string,
-  options?: ProxyRequestClientOptions,
-): RequestClient {
-  if (!options?.fetch) {
-    return new RequestClient(token, options);
-  }
-  return new RequestClient(token, {
-    runtimeProfile: "persistent",
-    maxQueueSize: 1000,
-    timeout: DISCORD_REST_TIMEOUT_MS,
-    ...options,
-    fetch: options.fetch,
-  });
-}

package/src/recipient-resolution.ts

@@ -1,39 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { requireRuntimeConfig } from "klaw/plugin-sdk/plugin-config-runtime";
-import { resolveDiscordAccount } from "./accounts.js";
-import { parseAndResolveDiscordTarget } from "./target-resolver.js";
-import type { DiscordTargetParseOptions } from "./targets.js";
-
-type DiscordRecipient =
-  | {
-      kind: "user";
-      id: string;
-    }
-  | {
-      kind: "channel";
-      id: string;
-    };
-
-export async function parseAndResolveRecipient(
-  raw: string,
-  cfg: KlawConfig,
-  accountId?: string,
-  parseOptions: DiscordTargetParseOptions = {},
-): Promise<DiscordRecipient> {
-  if (!cfg) {
-    throw new Error(
-      "Discord recipient resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.",
-    );
-  }
-  const resolvedCfg = requireRuntimeConfig(cfg, "Discord recipient resolution");
-  const accountInfo = resolveDiscordAccount({ cfg: resolvedCfg, accountId });
-  const resolved = await parseAndResolveDiscordTarget(
-    raw,
-    {
-      cfg: resolvedCfg,
-      accountId: accountInfo.accountId,
-    },
-    parseOptions,
-  );
-  return { kind: resolved.kind, id: resolved.id };
-}

package/src/resolve-allowlist-common.test.ts

@@ -1,40 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildDiscordUnresolvedResults,
-  filterDiscordGuilds,
-  findDiscordGuildByName,
-  resolveDiscordAllowlistToken,
-} from "./resolve-allowlist-common.js";
-
-describe("resolve-allowlist-common", () => {
-  const guilds = [
-    { id: "1", name: "Main Guild", slug: "main-guild" },
-    { id: "2", name: "Ops Guild", slug: "ops-guild" },
-  ];
-
-  it("resolves and filters guilds by id or name", () => {
-    const mainGuild = findDiscordGuildByName(guilds, "Main Guild");
-    if (!mainGuild) {
-      throw new Error("expected Main Guild lookup result");
-    }
-    expect(mainGuild.id).toBe("1");
-    expect(filterDiscordGuilds(guilds, { guildId: "2" })).toEqual([guilds[1]]);
-    expect(filterDiscordGuilds(guilds, { guildName: "main-guild" })).toEqual([guilds[0]]);
-  });
-
-  it("builds unresolved result rows in input order", () => {
-    const unresolved = buildDiscordUnresolvedResults(["a", "b"], (input) => ({
-      input,
-      resolved: false,
-    }));
-    expect(unresolved).toEqual([
-      { input: "a", resolved: false },
-      { input: "b", resolved: false },
-    ]);
-  });
-
-  it("normalizes allowlist token values", () => {
-    expect(resolveDiscordAllowlistToken(" discord-token ")).toBe("discord-token");
-    expect(resolveDiscordAllowlistToken("")).toBeUndefined();
-  });
-});

package/src/resolve-allowlist-common.ts

@@ -1,39 +0,0 @@
-import type { DiscordGuildSummary } from "./guilds.js";
-import { normalizeDiscordSlug } from "./monitor/allow-list.js";
-import { normalizeDiscordToken } from "./token.js";
-
-export function resolveDiscordAllowlistToken(token: string): string | undefined {
-  return normalizeDiscordToken(token, "channels.discord.token");
-}
-
-export function buildDiscordUnresolvedResults<T extends { input: string; resolved: boolean }>(
-  entries: string[],
-  buildResult: (input: string) => T,
-): T[] {
-  return entries.map((input) => buildResult(input));
-}
-
-export function findDiscordGuildByName(
-  guilds: DiscordGuildSummary[],
-  input: string,
-): DiscordGuildSummary | undefined {
-  const slug = normalizeDiscordSlug(input);
-  if (!slug) {
-    return undefined;
-  }
-  return guilds.find((guild) => guild.slug === slug);
-}
-
-export function filterDiscordGuilds(
-  guilds: DiscordGuildSummary[],
-  params: { guildId?: string; guildName?: string },
-): DiscordGuildSummary[] {
-  if (params.guildId) {
-    return guilds.filter((guild) => guild.id === params.guildId);
-  }
-  if (params.guildName) {
-    const match = findDiscordGuildByName(guilds, params.guildName);
-    return match ? [match] : [];
-  }
-  return guilds;
-}