@kodelyth/discord 2026.5.42 → 2026.6.2

package/src/send.webhook.proxy.test.ts

@@ -1,210 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { DiscordError, RateLimitError } from "./internal/rest-errors.js";
-import { sendWebhookMessageDiscord } from "./send.webhook.js";
-
-const makeProxyFetchMock = vi.hoisted(() => vi.fn());
-
-vi.mock("klaw/plugin-sdk/fetch-runtime", async () => {
-  const actual = await vi.importActual<typeof import("klaw/plugin-sdk/fetch-runtime")>(
-    "klaw/plugin-sdk/fetch-runtime",
-  );
-  return {
-    ...actual,
-    makeProxyFetch: makeProxyFetchMock,
-  };
-});
-
-describe("sendWebhookMessageDiscord proxy support", () => {
-  beforeEach(() => {
-    makeProxyFetchMock.mockReset();
-    vi.restoreAllMocks();
-  });
-
-  it("falls back to global fetch when the Discord proxy URL is invalid", async () => {
-    makeProxyFetchMock.mockImplementation(() => {
-      throw new Error("bad proxy");
-    });
-    const globalFetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response(JSON.stringify({ id: "msg-0" }), { status: 200 }));
-
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "bad-proxy",
-        },
-      },
-    } as KlawConfig;
-
-    await sendWebhookMessageDiscord("hello", {
-      cfg,
-      accountId: "default",
-      webhookId: "123",
-      webhookToken: "abc",
-      wait: true,
-    });
-
-    expect(makeProxyFetchMock).not.toHaveBeenCalledWith("bad-proxy");
-    expect(globalFetchMock).toHaveBeenCalled();
-    globalFetchMock.mockRestore();
-  });
-
-  it("uses proxy fetch when a Discord proxy is configured", async () => {
-    const proxiedFetch = vi
-      .fn()
-      .mockResolvedValue(new Response(JSON.stringify({ id: "msg-1" }), { status: 200 }));
-    makeProxyFetchMock.mockReturnValue(proxiedFetch);
-
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "http://127.0.0.1:8080",
-        },
-      },
-    } as KlawConfig;
-
-    await sendWebhookMessageDiscord("hello", {
-      cfg,
-      accountId: "default",
-      webhookId: "123",
-      webhookToken: "abc",
-      wait: true,
-    });
-
-    expect(makeProxyFetchMock).toHaveBeenCalledWith("http://127.0.0.1:8080");
-    expect(proxiedFetch).toHaveBeenCalledOnce();
-  });
-
-  it("uses global fetch when the Discord proxy URL is remote", async () => {
-    const globalFetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response(JSON.stringify({ id: "msg-remote" }), { status: 200 }));
-
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-          proxy: "http://proxy.test:8080",
-        },
-      },
-    } as KlawConfig;
-
-    await sendWebhookMessageDiscord("hello", {
-      cfg,
-      accountId: "default",
-      webhookId: "123",
-      webhookToken: "abc",
-      wait: true,
-    });
-
-    expect(makeProxyFetchMock).not.toHaveBeenCalledWith("http://proxy.test:8080");
-    expect(globalFetchMock).toHaveBeenCalled();
-    globalFetchMock.mockRestore();
-  });
-
-  it("uses global fetch when no proxy is configured", async () => {
-    makeProxyFetchMock.mockReturnValue(undefined);
-    const globalFetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response(JSON.stringify({ id: "msg-2" }), { status: 200 }));
-
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-        },
-      },
-    } as KlawConfig;
-
-    await sendWebhookMessageDiscord("hello", {
-      cfg,
-      accountId: "default",
-      webhookId: "123",
-      webhookToken: "abc",
-      wait: true,
-    });
-
-    expect(globalFetchMock).toHaveBeenCalled();
-    globalFetchMock.mockRestore();
-  });
-
-  it("throws typed rate limit errors for webhook 429 responses", async () => {
-    const globalFetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
-      new Response(JSON.stringify({ message: "Slow down", retry_after: 0.25, global: false }), {
-        status: 429,
-      }),
-    );
-
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-        },
-      },
-    } as KlawConfig;
-
-    const thrown = await sendWebhookMessageDiscord("hello", {
-      cfg,
-      accountId: "default",
-      webhookId: "123",
-      webhookToken: "abc",
-      wait: true,
-    }).then(
-      () => undefined,
-      (error: unknown) => error,
-    );
-    expect(thrown).toBeInstanceOf(RateLimitError);
-    const error = thrown as RateLimitError;
-    expect(error.name).toBe("RateLimitError");
-    expect(error.status).toBe(429);
-    expect(error.statusCode).toBe(429);
-    expect(error.retryAfter).toBe(0.25);
-    expect(error.scope).toBeNull();
-    expect(error.bucket).toBeNull();
-    expect(error.message).toBe("Slow down");
-    expect(error.rawBody).toEqual({
-      message: "Slow down",
-      retry_after: 0.25,
-      code: undefined,
-      global: false,
-    });
-    globalFetchMock.mockRestore();
-  });
-
-  it("throws typed status errors for webhook server failures", async () => {
-    const globalFetchMock = vi
-      .spyOn(globalThis, "fetch")
-      .mockResolvedValue(new Response("upstream unavailable", { status: 503 }));
-
-    const cfg = {
-      channels: {
-        discord: {
-          token: "Bot test-token",
-        },
-      },
-    } as KlawConfig;
-
-    const thrown = await sendWebhookMessageDiscord("hello", {
-      cfg,
-      accountId: "default",
-      webhookId: "123",
-      webhookToken: "abc",
-      wait: true,
-    }).then(
-      () => undefined,
-      (error: unknown) => error,
-    );
-    expect(thrown).toBeInstanceOf(DiscordError);
-    expect(thrown).not.toBeInstanceOf(RateLimitError);
-    const error = thrown as DiscordError;
-    expect(error.name).toBe("DiscordError");
-    expect(error.status).toBe(503);
-    expect(error.statusCode).toBe(503);
-    expect(error.message).toBe("upstream unavailable");
-    expect(error.rawBody).toEqual({ message: "upstream unavailable" });
-    globalFetchMock.mockRestore();
-  });
-});

package/src/send.webhook.ts

@@ -1,137 +0,0 @@
-import { recordChannelActivity } from "klaw/plugin-sdk/channel-activity-runtime";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import { resolveDiscordClientAccountContext } from "./client.js";
-import {
-  DiscordError,
-  RateLimitError,
-  readDiscordCode,
-  readDiscordMessage,
-  readRetryAfter,
-} from "./internal/rest-errors.js";
-import { rewriteDiscordKnownMentions } from "./mentions.js";
-import { createDiscordSendResult } from "./send.receipt.js";
-import type { DiscordSendResult } from "./send.types.js";
-
-type DiscordWebhookSendOpts = {
-  cfg: KlawConfig;
-  webhookId: string;
-  webhookToken: string;
-  accountId?: string;
-  threadId?: string | number;
-  replyTo?: string;
-  username?: string;
-  avatarUrl?: string;
-  wait?: boolean;
-};
-
-function resolveWebhookExecutionUrl(params: {
-  webhookId: string;
-  webhookToken: string;
-  threadId?: string | number;
-  wait?: boolean;
-}) {
-  const baseUrl = new URL(
-    `https://discord.com/api/v10/webhooks/${encodeURIComponent(params.webhookId)}/${encodeURIComponent(params.webhookToken)}`,
-  );
-  baseUrl.searchParams.set("wait", params.wait === false ? "false" : "true");
-  if (params.threadId !== undefined && params.threadId !== null && params.threadId !== "") {
-    baseUrl.searchParams.set("thread_id", String(params.threadId));
-  }
-  return baseUrl.toString();
-}
-
-function coerceWebhookErrorBody(raw: string): unknown {
-  if (!raw) {
-    return undefined;
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { message: raw.slice(0, 200) };
-  }
-}
-
-async function throwWebhookResponseError(response: Response): Promise<never> {
-  const raw = await response.text().catch(() => "");
-  const parsed = coerceWebhookErrorBody(raw);
-  if (response.status === 429) {
-    throw new RateLimitError(response, {
-      message: readDiscordMessage(parsed, "Rate limited"),
-      retry_after: readRetryAfter(parsed, response, 1),
-      code: readDiscordCode(parsed),
-      global:
-        parsed && typeof parsed === "object" && "global" in parsed
-          ? Boolean((parsed as { global?: unknown }).global)
-          : false,
-    });
-  }
-  throw new DiscordError(response, parsed);
-}
-
-export async function sendWebhookMessageDiscord(
-  text: string,
-  opts: DiscordWebhookSendOpts,
-): Promise<DiscordSendResult> {
-  const webhookId = normalizeOptionalString(opts.webhookId) ?? "";
-  const webhookToken = normalizeOptionalString(opts.webhookToken) ?? "";
-  if (!webhookId || !webhookToken) {
-    throw new Error("Discord webhook id/token are required");
-  }
-
-  const replyTo = normalizeOptionalString(opts.replyTo) ?? "";
-  const messageReference = replyTo ? { message_id: replyTo, fail_if_not_exists: false } : undefined;
-  const { account, proxyFetch } = resolveDiscordClientAccountContext({
-    cfg: opts.cfg,
-    accountId: opts.accountId,
-  });
-  const rewrittenText = rewriteDiscordKnownMentions(text, {
-    accountId: account.accountId,
-    mentionAliases: account.config.mentionAliases,
-  });
-
-  const response = await (proxyFetch ?? fetch)(
-    resolveWebhookExecutionUrl({
-      webhookId,
-      webhookToken,
-      threadId: opts.threadId,
-      wait: opts.wait,
-    }),
-    {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-      },
-      body: JSON.stringify({
-        content: rewrittenText,
-        username: normalizeOptionalString(opts.username),
-        avatar_url: normalizeOptionalString(opts.avatarUrl),
-        ...(messageReference ? { message_reference: messageReference } : {}),
-      }),
-    },
-  );
-  if (!response.ok) {
-    await throwWebhookResponseError(response);
-  }
-
-  const payload = (await response.json().catch(() => ({}))) as {
-    id?: string;
-    channel_id?: string;
-  };
-  try {
-    recordChannelActivity({
-      channel: "discord",
-      accountId: account.accountId,
-      direction: "outbound",
-    });
-  } catch {
-    // Best-effort telemetry only.
-  }
-  return createDiscordSendResult({
-    result: payload,
-    fallbackChannelId: opts.threadId ? String(opts.threadId) : "",
-    kind: "text",
-    ...(opts.threadId != null ? { threadId: opts.threadId } : {}),
-    ...(replyTo ? { replyToId: replyTo } : {}),
-  });
-}

package/src/session-contract.ts

@@ -1,3 +0,0 @@
-export function deriveLegacySessionChatType(sessionKey: string): "channel" | undefined {
-  return /^discord:(?:[^:]+:)?guild-[^:]+:channel-[^:]+$/.test(sessionKey) ? "channel" : undefined;
-}

package/src/session-key-normalization.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { normalizeExplicitDiscordSessionKey } from "./session-key-normalization.js";
-
-describe("normalizeExplicitDiscordSessionKey", () => {
-  it("rewrites bare discord:dm keys for direct chats", () => {
-    expect(
-      normalizeExplicitDiscordSessionKey("discord:dm:123456", {
-        ChatType: "direct",
-        From: "discord:123456",
-        SenderId: "123456",
-      }),
-    ).toBe("discord:direct:123456");
-  });
-
-  it("rewrites legacy discord:dm keys for direct chats", () => {
-    expect(
-      normalizeExplicitDiscordSessionKey("agent:fina:discord:dm:123456", {
-        ChatType: "direct",
-        From: "discord:123456",
-        SenderId: "123456",
-      }),
-    ).toBe("agent:fina:discord:direct:123456");
-  });
-
-  it("rewrites phantom discord:channel keys when sender matches", () => {
-    expect(
-      normalizeExplicitDiscordSessionKey("discord:channel:123456", {
-        ChatType: "direct",
-        From: "discord:123456",
-        SenderId: "123456",
-      }),
-    ).toBe("discord:direct:123456");
-  });
-
-  it("leaves non-direct channel keys unchanged", () => {
-    expect(
-      normalizeExplicitDiscordSessionKey("agent:fina:discord:channel:123456", {
-        ChatType: "channel",
-        From: "discord:channel:123456",
-        SenderId: "789",
-      }),
-    ).toBe("agent:fina:discord:channel:123456");
-  });
-});

package/src/session-key-normalization.ts

@@ -1,47 +0,0 @@
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
-
-type DiscordSessionKeyContext = {
-  ChatType?: string;
-  From?: string;
-  SenderId?: string;
-};
-
-function normalizeDiscordChatType(raw?: string): "direct" | "group" | "channel" | undefined {
-  const normalized = normalizeLowercaseStringOrEmpty(raw);
-  if (!normalized) {
-    return undefined;
-  }
-  if (normalized === "dm") {
-    return "direct";
-  }
-  if (normalized === "group" || normalized === "channel" || normalized === "direct") {
-    return normalized;
-  }
-  return undefined;
-}
-
-export function normalizeExplicitDiscordSessionKey(
-  sessionKey: string,
-  ctx: DiscordSessionKeyContext,
-): string {
-  let normalized = normalizeLowercaseStringOrEmpty(sessionKey);
-  if (normalizeDiscordChatType(ctx.ChatType) !== "direct") {
-    return normalized;
-  }
-
-  normalized = normalized.replace(/^(discord:)dm:/, "$1direct:");
-  normalized = normalized.replace(/^(agent:[^:]+:discord:)dm:/, "$1direct:");
-  const match = normalized.match(/^((?:agent:[^:]+:)?)discord:channel:([^:]+)$/);
-  if (!match) {
-    return normalized;
-  }
-
-  const from = normalizeLowercaseStringOrEmpty(ctx.From);
-  const senderId = normalizeLowercaseStringOrEmpty(ctx.SenderId);
-  const fromDiscordId =
-    from.startsWith("discord:") && !from.includes(":channel:") && !from.includes(":group:")
-      ? from.slice("discord:".length)
-      : "";
-  const directId = senderId || fromDiscordId;
-  return directId && directId === match[2] ? `${match[1]}discord:direct:${match[2]}` : normalized;
-}

package/src/setup-account-state.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  inspectDiscordSetupAccount,
-  listDiscordSetupAccountIds,
-  resolveDefaultDiscordSetupAccountId,
-  resolveDiscordSetupAccountConfig,
-} from "./setup-account-state.js";
-
-describe("discord setup account state", () => {
-  it("lists normalized setup account ids plus the implicit default account", () => {
-    expect(
-      listDiscordSetupAccountIds({
-        channels: {
-          discord: {
-            accounts: {
-              Work: { token: "work-token" },
-              alerts: { token: "alerts-token" },
-            },
-          },
-        },
-      }),
-    ).toEqual(["alerts", "default", "work"]);
-  });
-
-  it("resolves setup account config when account key casing differs from normalized id", () => {
-    const resolved = resolveDiscordSetupAccountConfig({
-      cfg: {
-        channels: {
-          discord: {
-            allowFrom: ["top"],
-            accounts: {
-              Work: { name: "Work", allowFrom: ["acct"] },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(resolved.accountId).toBe("work");
-    expect(resolved.config.name).toBe("Work");
-    expect(resolved.config.allowFrom).toEqual(["acct"]);
-  });
-
-  it("uses configured defaultAccount for omitted setup account resolution", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          defaultAccount: "work",
-          allowFrom: ["top"],
-          accounts: {
-            alerts: { allowFrom: ["alerts-only"] },
-            work: { name: "Work", allowFrom: ["work-only"] },
-          },
-        },
-      },
-    };
-
-    expect(resolveDefaultDiscordSetupAccountId(cfg)).toBe("work");
-
-    const resolved = resolveDiscordSetupAccountConfig({
-      cfg,
-    });
-
-    expect(resolved.accountId).toBe("work");
-    expect(resolved.config.name).toBe("Work");
-    expect(resolved.config.allowFrom).toEqual(["work-only"]);
-  });
-
-  it("treats explicit blank account tokens as missing without falling back", () => {
-    const inspected = inspectDiscordSetupAccount({
-      cfg: {
-        channels: {
-          discord: {
-            token: "top-level-token",
-            accounts: {
-              work: { token: "" },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(inspected.accountId).toBe("work");
-    expect(inspected.token).toBe("");
-    expect(inspected.tokenSource).toBe("none");
-    expect(inspected.tokenStatus).toBe("missing");
-    expect(inspected.configured).toBe(false);
-  });
-
-  it("reports unresolved SecretRef account tokens as configured but unavailable", () => {
-    const inspected = inspectDiscordSetupAccount({
-      cfg: {
-        channels: {
-          discord: {
-            accounts: {
-              work: {
-                token: { source: "exec", provider: "vault", id: "discord/work" },
-              },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("configured_unavailable");
-    expect(inspected.configured).toBe(true);
-  });
-});

package/src/setup-account-state.ts

@@ -1,141 +0,0 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
-import { listCombinedAccountIds } from "klaw/plugin-sdk/account-resolution";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { hasConfiguredSecretInput, normalizeSecretInputString } from "klaw/plugin-sdk/secret-input";
-import { resolveDefaultDiscordAccountId } from "./accounts.js";
-import { mergeDiscordAccountConfig, resolveDiscordAccountConfig } from "./accounts.js";
-import type { DiscordAccountConfig } from "./runtime-api.js";
-import { resolveDiscordToken } from "./token.js";
-
-type InspectedDiscordSetupAccount = {
-  accountId: string;
-  enabled: boolean;
-  token: string;
-  tokenSource: "env" | "config" | "none";
-  tokenStatus: "available" | "configured_unavailable" | "missing";
-  configured: boolean;
-  config: DiscordAccountConfig;
-};
-
-function inspectConfiguredToken(value: unknown): {
-  token: string;
-  tokenSource: "config";
-  tokenStatus: "available" | "configured_unavailable";
-} | null {
-  const normalized = normalizeSecretInputString(value);
-  if (normalized) {
-    return {
-      token: normalized.replace(/^Bot\s+/i, ""),
-      tokenSource: "config",
-      tokenStatus: "available",
-    };
-  }
-  if (hasConfiguredSecretInput(value)) {
-    return {
-      token: "",
-      tokenSource: "config",
-      tokenStatus: "configured_unavailable",
-    };
-  }
-  return null;
-}
-
-export function listDiscordSetupAccountIds(cfg: KlawConfig): string[] {
-  const accounts = cfg.channels?.discord?.accounts;
-  return listCombinedAccountIds({
-    configuredAccountIds:
-      accounts && typeof accounts === "object" && !Array.isArray(accounts)
-        ? Object.keys(accounts).map((accountId) => normalizeAccountId(accountId))
-        : [],
-    implicitAccountId: DEFAULT_ACCOUNT_ID,
-  });
-}
-
-export function resolveDefaultDiscordSetupAccountId(cfg: KlawConfig): string {
-  return resolveDefaultDiscordAccountId(cfg);
-}
-
-export function resolveDiscordSetupAccountConfig(params: {
-  cfg: KlawConfig;
-  accountId?: string | null;
-}): { accountId: string; config: DiscordAccountConfig } {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordSetupAccountId(params.cfg),
-  );
-  return {
-    accountId,
-    config: mergeDiscordAccountConfig(params.cfg, accountId),
-  };
-}
-
-export function inspectDiscordSetupAccount(params: {
-  cfg: KlawConfig;
-  accountId?: string | null;
-}): InspectedDiscordSetupAccount {
-  const { accountId, config } = resolveDiscordSetupAccountConfig(params);
-  const enabled = params.cfg.channels?.discord?.enabled !== false && config.enabled !== false;
-  const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
-  const hasAccountToken = Boolean(
-    accountConfig &&
-    Object.prototype.hasOwnProperty.call(accountConfig as Record<string, unknown>, "token"),
-  );
-  const accountToken = inspectConfiguredToken(accountConfig?.token);
-  if (accountToken) {
-    return {
-      accountId,
-      enabled,
-      token: accountToken.token,
-      tokenSource: accountToken.tokenSource,
-      tokenStatus: accountToken.tokenStatus,
-      configured: true,
-      config,
-    };
-  }
-  if (hasAccountToken) {
-    return {
-      accountId,
-      enabled,
-      token: "",
-      tokenSource: "none",
-      tokenStatus: "missing",
-      configured: false,
-      config,
-    };
-  }
-
-  const channelToken = inspectConfiguredToken(params.cfg.channels?.discord?.token);
-  if (channelToken) {
-    return {
-      accountId,
-      enabled,
-      token: channelToken.token,
-      tokenSource: channelToken.tokenSource,
-      tokenStatus: channelToken.tokenStatus,
-      configured: true,
-      config,
-    };
-  }
-
-  const tokenResolution = resolveDiscordToken(params.cfg, { accountId });
-  if (tokenResolution.token) {
-    return {
-      accountId,
-      enabled,
-      token: tokenResolution.token,
-      tokenSource: tokenResolution.source,
-      tokenStatus: "available",
-      configured: true,
-      config,
-    };
-  }
-
-  return {
-    accountId,
-    enabled,
-    token: "",
-    tokenSource: "none",
-    tokenStatus: "missing",
-    configured: false,
-    config,
-  };
-}