@kodelyth/discord 2026.5.42 → 2026.6.1

package/src/monitor/route-resolution.ts

@@ -1,140 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import type { SessionBindingRecord } from "klaw/plugin-sdk/conversation-runtime";
-import {
-  deriveLastRoutePolicy,
-  isAcpSessionKey,
-  isSubagentSessionKey,
-  parseAgentSessionKey,
-  resolveAgentRoute,
-  type ResolvedAgentRoute,
-  type RoutePeer,
-} from "klaw/plugin-sdk/routing";
-import { resolveAgentIdFromSessionKey } from "klaw/plugin-sdk/routing";
-
-export function buildDiscordRoutePeer(params: {
-  isDirectMessage: boolean;
-  isGroupDm: boolean;
-  directUserId?: string | null;
-  conversationId: string;
-}): RoutePeer {
-  return {
-    kind: params.isDirectMessage ? "direct" : params.isGroupDm ? "group" : "channel",
-    id: params.isDirectMessage
-      ? params.directUserId?.trim() || params.conversationId
-      : params.conversationId,
-  };
-}
-
-export function resolveDiscordConversationRoute(params: {
-  cfg: KlawConfig;
-  accountId?: string | null;
-  guildId?: string | null;
-  memberRoleIds?: string[];
-  peer: RoutePeer;
-  parentConversationId?: string | null;
-}): ResolvedAgentRoute {
-  return resolveAgentRoute({
-    cfg: params.cfg,
-    channel: "discord",
-    accountId: params.accountId,
-    guildId: params.guildId ?? undefined,
-    memberRoleIds: params.memberRoleIds,
-    peer: params.peer,
-    parentPeer: params.parentConversationId
-      ? { kind: "channel", id: params.parentConversationId }
-      : undefined,
-  });
-}
-
-export function resolveDiscordBoundConversationRoute(params: {
-  cfg: KlawConfig;
-  accountId?: string | null;
-  guildId?: string | null;
-  memberRoleIds?: string[];
-  isDirectMessage: boolean;
-  isGroupDm: boolean;
-  directUserId?: string | null;
-  conversationId: string;
-  parentConversationId?: string | null;
-  boundSessionKey?: string | null;
-  configuredRoute?: { route: ResolvedAgentRoute } | null;
-  matchedBy?: ResolvedAgentRoute["matchedBy"];
-}): ResolvedAgentRoute {
-  const route = resolveDiscordConversationRoute({
-    cfg: params.cfg,
-    accountId: params.accountId,
-    guildId: params.guildId,
-    memberRoleIds: params.memberRoleIds,
-    peer: buildDiscordRoutePeer({
-      isDirectMessage: params.isDirectMessage,
-      isGroupDm: params.isGroupDm,
-      directUserId: params.directUserId,
-      conversationId: params.conversationId,
-    }),
-    parentConversationId: params.parentConversationId,
-  });
-  return resolveDiscordEffectiveRoute({
-    route,
-    boundSessionKey: params.boundSessionKey,
-    configuredRoute: params.configuredRoute,
-    matchedBy: params.matchedBy,
-  });
-}
-
-export function resolveDiscordEffectiveRoute(params: {
-  route: ResolvedAgentRoute;
-  boundSessionKey?: string | null;
-  configuredRoute?: { route: ResolvedAgentRoute } | null;
-  matchedBy?: ResolvedAgentRoute["matchedBy"];
-}): ResolvedAgentRoute {
-  const boundSessionKey = params.boundSessionKey?.trim();
-  if (!boundSessionKey) {
-    return params.configuredRoute?.route ?? params.route;
-  }
-  return {
-    ...params.route,
-    sessionKey: boundSessionKey,
-    agentId: resolveAgentIdFromSessionKey(boundSessionKey),
-    lastRoutePolicy: deriveLastRoutePolicy({
-      sessionKey: boundSessionKey,
-      mainSessionKey: params.route.mainSessionKey,
-    }),
-    ...(params.matchedBy ? { matchedBy: params.matchedBy } : {}),
-  };
-}
-
-function hasExplicitRuntimeBindingIntent(record: SessionBindingRecord): boolean {
-  if (record.targetKind === "subagent") {
-    return true;
-  }
-  if (isAcpSessionKey(record.targetSessionKey) || isSubagentSessionKey(record.targetSessionKey)) {
-    return true;
-  }
-  const metadata = record.metadata;
-  if (!metadata || typeof metadata !== "object") {
-    return false;
-  }
-  return (
-    typeof metadata.boundBy === "string" ||
-    typeof metadata.label === "string" ||
-    typeof metadata.threadName === "string" ||
-    metadata.pluginBindingOwner === "plugin"
-  );
-}
-
-export function shouldIgnoreStaleDiscordRouteBinding(params: {
-  bindingRecord?: SessionBindingRecord | null;
-  route: ResolvedAgentRoute;
-}): boolean {
-  const bindingRecord = params.bindingRecord;
-  const boundSessionKey = bindingRecord?.targetSessionKey?.trim();
-  if (!bindingRecord || !boundSessionKey || hasExplicitRuntimeBindingIntent(bindingRecord)) {
-    return false;
-  }
-  const bound = parseAgentSessionKey(boundSessionKey);
-  const routed = parseAgentSessionKey(params.route.sessionKey);
-  if (!bound || !routed || bound.rest !== routed.rest) {
-    return false;
-  }
-  return bound.agentId !== params.route.agentId;
-}

package/src/monitor/sender-identity.ts

@@ -1,81 +0,0 @@
-import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
-import type { User } from "../internal/discord.js";
-import type { PluralKitMessageInfo } from "../pluralkit.js";
-import { formatDiscordUserTag } from "./format.js";
-
-export type DiscordSenderIdentity = {
-  id: string;
-  name?: string;
-  tag?: string;
-  label: string;
-  isPluralKit: boolean;
-  pluralkit?: {
-    memberId: string;
-    memberName?: string;
-    systemId?: string;
-    systemName?: string;
-  };
-};
-
-type DiscordWebhookMessageLike = {
-  webhookId?: string | null;
-  webhook_id?: string | null;
-};
-
-type DiscordMemberLike = {
-  nickname?: string | null;
-  nick?: string | null;
-};
-
-export function resolveDiscordWebhookId(message: DiscordWebhookMessageLike): string | null {
-  const candidate = message.webhookId ?? message.webhook_id;
-  return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
-}
-
-export function resolveDiscordSenderIdentity(params: {
-  author: User;
-  member?: DiscordMemberLike | null;
-  pluralkitInfo?: PluralKitMessageInfo | null;
-}): DiscordSenderIdentity {
-  const pkInfo = params.pluralkitInfo ?? null;
-  const pkMember = pkInfo?.member ?? undefined;
-  const pkSystem = pkInfo?.system ?? undefined;
-  const memberId = pkMember?.id?.trim();
-  const memberNameRaw = pkMember?.display_name ?? pkMember?.name ?? "";
-  const memberName = memberNameRaw?.trim();
-  if (memberId && memberName) {
-    const systemName = pkSystem?.name?.trim();
-    const label = systemName ? `${memberName} (PK:${systemName})` : `${memberName} (PK)`;
-    return {
-      id: memberId,
-      name: memberName,
-      tag: normalizeOptionalString(pkMember?.name),
-      label,
-      isPluralKit: true,
-      pluralkit: {
-        memberId,
-        memberName,
-        systemId: normalizeOptionalString(pkSystem?.id),
-        systemName,
-      },
-    };
-  }
-
-  const senderTag = formatDiscordUserTag(params.author);
-  const senderDisplay =
-    params.member?.nickname ??
-    params.member?.nick ??
-    params.author.globalName ??
-    params.author.username;
-  const senderLabel =
-    senderDisplay && senderTag && senderDisplay !== senderTag
-      ? `${senderDisplay} (${senderTag})`
-      : (senderDisplay ?? senderTag ?? params.author.id);
-  return {
-    id: params.author.id,
-    name: params.author.username ?? undefined,
-    tag: senderTag,
-    label: senderLabel,
-    isPluralKit: false,
-  };
-}

package/src/monitor/startup-status.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatDiscordStartupStatusMessage } from "./startup-status.js";
-
-describe("formatDiscordStartupStatusMessage", () => {
-  it("reports logged-in status only after the gateway is ready", () => {
-    expect(
-      formatDiscordStartupStatusMessage({
-        gatewayReady: true,
-        botIdentity: "bot-1 (Molty)",
-      }),
-    ).toBe("logged in to discord as bot-1 (Molty)");
-  });
-
-  it("reports client initialization while gateway readiness is still pending", () => {
-    expect(
-      formatDiscordStartupStatusMessage({
-        gatewayReady: false,
-        botIdentity: "bot-1 (Molty)",
-      }),
-    ).toBe("discord client initialized as bot-1 (Molty); awaiting gateway readiness");
-  });
-
-  it("handles missing identity without awkward punctuation", () => {
-    expect(
-      formatDiscordStartupStatusMessage({
-        gatewayReady: false,
-      }),
-    ).toBe("discord client initialized; awaiting gateway readiness");
-  });
-});

package/src/monitor/startup-status.ts

@@ -1,10 +0,0 @@
-export function formatDiscordStartupStatusMessage(params: {
-  gatewayReady: boolean;
-  botIdentity?: string;
-}): string {
-  const identitySuffix = params.botIdentity ? ` as ${params.botIdentity}` : "";
-  if (params.gatewayReady) {
-    return `logged in to discord${identitySuffix}`;
-  }
-  return `discord client initialized${identitySuffix}; awaiting gateway readiness`;
-}

package/src/monitor/status.ts

@@ -1,22 +0,0 @@
-type DiscordMonitorStatusPatch = {
-  connected?: boolean;
-  lastEventAt?: number | null;
-  lastTransportActivityAt?: number | null;
-  lastConnectedAt?: number | null;
-  lastDisconnect?:
-    | string
-    | {
-        at: number;
-        status?: number;
-        error?: string;
-        loggedOut?: boolean;
-      }
-    | null;
-  lastInboundAt?: number | null;
-  lastError?: string | null;
-  busy?: boolean;
-  activeRuns?: number;
-  lastRunActivityAt?: number | null;
-};
-
-export type DiscordMonitorStatusSink = (patch: DiscordMonitorStatusPatch) => void;

package/src/monitor/system-events.ts

@@ -1,55 +0,0 @@
-import { type Message, MessageType } from "../internal/discord.js";
-import { formatDiscordUserTag } from "./format.js";
-
-export function resolveDiscordSystemEvent(message: Message, location: string): string | null {
-  switch (message.type) {
-    case MessageType.ChannelPinnedMessage:
-      return buildDiscordSystemEvent(message, location, "pinned a message");
-    case MessageType.RecipientAdd:
-      return buildDiscordSystemEvent(message, location, "added a recipient");
-    case MessageType.RecipientRemove:
-      return buildDiscordSystemEvent(message, location, "removed a recipient");
-    case MessageType.UserJoin:
-      return buildDiscordSystemEvent(message, location, "user joined");
-    case MessageType.GuildBoost:
-      return buildDiscordSystemEvent(message, location, "boosted the server");
-    case MessageType.GuildBoostTier1:
-      return buildDiscordSystemEvent(message, location, "boosted the server (Tier 1 reached)");
-    case MessageType.GuildBoostTier2:
-      return buildDiscordSystemEvent(message, location, "boosted the server (Tier 2 reached)");
-    case MessageType.GuildBoostTier3:
-      return buildDiscordSystemEvent(message, location, "boosted the server (Tier 3 reached)");
-    case MessageType.ThreadCreated:
-      return buildDiscordSystemEvent(message, location, "created a thread");
-    case MessageType.AutoModerationAction:
-      return buildDiscordSystemEvent(message, location, "auto moderation action");
-    case MessageType.GuildIncidentAlertModeEnabled:
-      return buildDiscordSystemEvent(message, location, "raid protection enabled");
-    case MessageType.GuildIncidentAlertModeDisabled:
-      return buildDiscordSystemEvent(message, location, "raid protection disabled");
-    case MessageType.GuildIncidentReportRaid:
-      return buildDiscordSystemEvent(message, location, "raid reported");
-    case MessageType.GuildIncidentReportFalseAlarm:
-      return buildDiscordSystemEvent(message, location, "raid report marked false alarm");
-    case MessageType.StageStart:
-      return buildDiscordSystemEvent(message, location, "stage started");
-    case MessageType.StageEnd:
-      return buildDiscordSystemEvent(message, location, "stage ended");
-    case MessageType.StageSpeaker:
-      return buildDiscordSystemEvent(message, location, "stage speaker updated");
-    case MessageType.StageTopic:
-      return buildDiscordSystemEvent(message, location, "stage topic updated");
-    case MessageType.PollResult:
-      return buildDiscordSystemEvent(message, location, "poll results posted");
-    case MessageType.PurchaseNotification:
-      return buildDiscordSystemEvent(message, location, "purchase notification");
-    default:
-      return null;
-  }
-}
-
-function buildDiscordSystemEvent(message: Message, location: string, action: string) {
-  const authorLabel = message.author ? formatDiscordUserTag(message.author) : "";
-  const actor = authorLabel ? `${authorLabel} ` : "";
-  return `Discord system: ${actor}${action} in ${location}`;
-}

package/src/monitor/thread-bindings.config.ts

@@ -1,35 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import {
-  resolveThreadBindingIdleTimeoutMs,
-  resolveThreadBindingMaxAgeMs,
-  resolveThreadBindingsEnabled,
-} from "klaw/plugin-sdk/conversation-runtime";
-import { normalizeAccountId } from "klaw/plugin-sdk/routing";
-
-export { resolveThreadBindingsEnabled };
-
-export function resolveDiscordThreadBindingIdleTimeoutMs(params: {
-  cfg: KlawConfig;
-  accountId?: string;
-}): number {
-  const accountId = normalizeAccountId(params.accountId);
-  const root = params.cfg.channels?.discord?.threadBindings;
-  const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
-  return resolveThreadBindingIdleTimeoutMs({
-    channelIdleHoursRaw: account?.idleHours ?? root?.idleHours,
-    sessionIdleHoursRaw: params.cfg.session?.threadBindings?.idleHours,
-  });
-}
-
-export function resolveDiscordThreadBindingMaxAgeMs(params: {
-  cfg: KlawConfig;
-  accountId?: string;
-}): number {
-  const accountId = normalizeAccountId(params.accountId);
-  const root = params.cfg.channels?.discord?.threadBindings;
-  const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
-  return resolveThreadBindingMaxAgeMs({
-    channelMaxAgeHoursRaw: account?.maxAgeHours ?? root?.maxAgeHours,
-    sessionMaxAgeHoursRaw: params.cfg.session?.threadBindings?.maxAgeHours,
-  });
-}

package/src/monitor/thread-bindings.discord-api.test.ts

@@ -1,250 +0,0 @@
-import { ChannelType } from "discord-api-types/v10";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import * as discordClientModule from "../client.js";
-import * as discordSendModule from "../send.js";
-import { createDiscordSendReceipt } from "../send.receipt.js";
-import { EMPTY_DISCORD_TEST_CONFIG } from "../test-support/config.js";
-import type { ThreadBindingRecord } from "./thread-bindings.types.js";
-
-const DEFAULT_SEND_RESULT = {
-  messageId: "msg-1",
-  channelId: "thread-1",
-  receipt: createDiscordSendReceipt({
-    platformMessageIds: ["msg-1"],
-    channelId: "thread-1",
-    kind: "text",
-  }),
-};
-
-const restGet = vi.fn<(...args: unknown[]) => Promise<unknown>>();
-const sendMessageDiscord = vi.fn<typeof discordSendModule.sendMessageDiscord>();
-const sendWebhookMessageDiscord = vi.fn<typeof discordSendModule.sendWebhookMessageDiscord>();
-const createDiscordRestClient = vi.fn<typeof discordClientModule.createDiscordRestClient>(
-  () =>
-    ({
-      rest: {
-        get: restGet,
-      },
-    }) as unknown as ReturnType<typeof discordClientModule.createDiscordRestClient>,
-);
-
-let maybeSendBindingMessage: typeof import("./thread-bindings.discord-api.js").maybeSendBindingMessage;
-let resolveChannelIdForBinding: typeof import("./thread-bindings.discord-api.js").resolveChannelIdForBinding;
-
-beforeAll(async () => {
-  ({ maybeSendBindingMessage, resolveChannelIdForBinding } =
-    await import("./thread-bindings.discord-api.js"));
-});
-
-function resolveTestChannelIdForBinding(
-  params: Omit<Parameters<typeof resolveChannelIdForBinding>[0], "cfg"> & {
-    cfg?: KlawConfig;
-  },
-) {
-  return resolveChannelIdForBinding({
-    cfg: EMPTY_DISCORD_TEST_CONFIG,
-    ...params,
-  });
-}
-
-function firstMockCall(mock: { mock: { calls: unknown[][] } }, label: string): unknown[] {
-  const call = mock.mock.calls.at(0);
-  if (!call) {
-    throw new Error(`expected ${label} call`);
-  }
-  return call;
-}
-
-describe("resolveChannelIdForBinding", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    restGet.mockReset();
-    sendMessageDiscord.mockReset().mockResolvedValue(DEFAULT_SEND_RESULT);
-    sendWebhookMessageDiscord.mockReset().mockResolvedValue(DEFAULT_SEND_RESULT);
-    createDiscordRestClient.mockReset().mockImplementation(
-      () =>
-        ({
-          rest: {
-            get: restGet,
-          },
-        }) as unknown as ReturnType<typeof discordClientModule.createDiscordRestClient>,
-    );
-    vi.spyOn(discordClientModule, "createDiscordRestClient").mockImplementation(
-      (...args) =>
-        createDiscordRestClient(...args) as unknown as ReturnType<
-          typeof discordClientModule.createDiscordRestClient
-        >,
-    );
-    vi.spyOn(discordSendModule, "sendMessageDiscord").mockImplementation((...args) =>
-      sendMessageDiscord(...args),
-    );
-    vi.spyOn(discordSendModule, "sendWebhookMessageDiscord").mockImplementation((...args) =>
-      sendWebhookMessageDiscord(...args),
-    );
-  });
-
-  it("returns explicit channelId without resolving route", async () => {
-    const resolved = await resolveTestChannelIdForBinding({
-      accountId: "default",
-      threadId: "thread-1",
-      channelId: "channel-explicit",
-    });
-
-    expect(resolved).toBe("channel-explicit");
-    expect(createDiscordRestClient).not.toHaveBeenCalled();
-    expect(restGet).not.toHaveBeenCalled();
-  });
-
-  it("normalizes prefixed explicit channelId without resolving route", async () => {
-    const resolved = await resolveTestChannelIdForBinding({
-      accountId: "default",
-      threadId: "thread-1",
-      channelId: "channel:123456789012345678",
-    });
-
-    expect(resolved).toBe("123456789012345678");
-    expect(createDiscordRestClient).not.toHaveBeenCalled();
-    expect(restGet).not.toHaveBeenCalled();
-  });
-
-  it("strips channel prefix before resolving route", async () => {
-    restGet.mockResolvedValueOnce({
-      id: "123456789012345678",
-      type: ChannelType.GuildText,
-    });
-
-    const resolved = await resolveTestChannelIdForBinding({
-      accountId: "default",
-      threadId: "channel:123456789012345678",
-    });
-
-    expect(resolved).toBe("123456789012345678");
-    const route = JSON.stringify(firstMockCall(restGet, "REST get")[0] ?? null);
-    expect(route).toContain("123456789012345678");
-    expect(route).not.toContain("channel:");
-  });
-
-  it("returns parent channel for thread channels", async () => {
-    restGet.mockResolvedValueOnce({
-      id: "thread-1",
-      type: ChannelType.PublicThread,
-      parent_id: "channel-parent",
-    });
-
-    const resolved = await resolveTestChannelIdForBinding({
-      accountId: "default",
-      threadId: "thread-1",
-    });
-
-    expect(resolved).toBe("channel-parent");
-  });
-
-  it("forwards cfg when resolving channel id through Discord client", async () => {
-    const cfg = {
-      channels: { discord: { token: "tok" } },
-    } as KlawConfig;
-    restGet.mockResolvedValueOnce({
-      id: "thread-1",
-      type: ChannelType.PublicThread,
-      parent_id: "channel-parent",
-    });
-
-    await resolveTestChannelIdForBinding({
-      cfg,
-      accountId: "default",
-      threadId: "thread-1",
-    });
-
-    expect(
-      (
-        firstMockCall(createDiscordRestClient, "createDiscordRestClient")[0] as
-          | { cfg?: KlawConfig }
-          | undefined
-      )?.cfg,
-    ).toBe(cfg);
-  });
-
-  it("keeps non-thread channel id even when parent_id exists", async () => {
-    restGet.mockResolvedValueOnce({
-      id: "channel-text",
-      type: ChannelType.GuildText,
-      parent_id: "category-1",
-    });
-
-    const resolved = await resolveTestChannelIdForBinding({
-      accountId: "default",
-      threadId: "channel-text",
-    });
-
-    expect(resolved).toBe("channel-text");
-  });
-
-  it("keeps forum channel id instead of parent category", async () => {
-    restGet.mockResolvedValueOnce({
-      id: "forum-1",
-      type: ChannelType.GuildForum,
-      parent_id: "category-1",
-    });
-
-    const resolved = await resolveTestChannelIdForBinding({
-      accountId: "default",
-      threadId: "forum-1",
-    });
-
-    expect(resolved).toBe("forum-1");
-  });
-});
-
-describe("maybeSendBindingMessage", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-    sendMessageDiscord.mockReset().mockResolvedValue(DEFAULT_SEND_RESULT);
-    sendWebhookMessageDiscord.mockReset().mockResolvedValue(DEFAULT_SEND_RESULT);
-    vi.spyOn(discordSendModule, "sendMessageDiscord").mockImplementation((...args) =>
-      sendMessageDiscord(...args),
-    );
-    vi.spyOn(discordSendModule, "sendWebhookMessageDiscord").mockImplementation((...args) =>
-      sendWebhookMessageDiscord(...args),
-    );
-  });
-
-  it("forwards cfg to webhook send path", async () => {
-    const cfg = {
-      channels: { discord: { token: "tok" } },
-    } as KlawConfig;
-    const record = {
-      accountId: "default",
-      channelId: "parent-1",
-      threadId: "thread-1",
-      targetKind: "subagent",
-      targetSessionKey: "agent:main:subagent:test",
-      agentId: "main",
-      boundBy: "test",
-      boundAt: Date.now(),
-      lastActivityAt: Date.now(),
-      webhookId: "wh_1",
-      webhookToken: "tok_1",
-    } satisfies ThreadBindingRecord;
-
-    await maybeSendBindingMessage({
-      cfg,
-      record,
-      text: "hello webhook",
-    });
-
-    expect(sendWebhookMessageDiscord).toHaveBeenCalledTimes(1);
-    expect(firstMockCall(sendWebhookMessageDiscord, "sendWebhookMessageDiscord")).toEqual([
-      "hello webhook",
-      {
-        cfg,
-        webhookId: "wh_1",
-        webhookToken: "tok_1",
-        accountId: "default",
-        threadId: "thread-1",
-        username: "⚙️ main",
-      },
-    ]);
-    expect(sendMessageDiscord).not.toHaveBeenCalled();
-  });
-});