@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/doctor.ts

@@ -1,340 +0,0 @@
-import { type ChannelDoctorAdapter } from "openclaw/plugin-sdk/channel-contract";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { collectProviderDangerousNameMatchingScopes } from "openclaw/plugin-sdk/runtime-doctor";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import { inspectDiscordAccount } from "./account-inspect.js";
-import { resolveDefaultDiscordAccountId } from "./accounts.js";
-import { normalizeCompatibilityConfig as normalizeDiscordCompatibilityConfig } from "./doctor-contract.js";
-import { DISCORD_LEGACY_CONFIG_RULES } from "./doctor-shared.js";
-import { isDiscordMutableAllowEntry } from "./security-doctor.js";
-
-type DiscordNumericIdHit = { path: string; entry: number; safe: boolean };
-
-type DiscordIdListRef = {
-  pathLabel: string;
-  holder: Record<string, unknown>;
-  key: string;
-};
-
-function asObjectRecord(value: unknown): Record<string, unknown> | null {
-  return value && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function sanitizeForLog(value: string): string {
-  return value.replace(/\p{Cc}+/gu, " ").trim();
-}
-
-function collectDiscordAccountScopes(
-  cfg: OpenClawConfig,
-): Array<{ prefix: string; account: Record<string, unknown> }> {
-  const scopes: Array<{ prefix: string; account: Record<string, unknown> }> = [];
-  const discord = asObjectRecord(cfg.channels?.discord);
-  if (!discord) {
-    return scopes;
-  }
-
-  scopes.push({ prefix: "channels.discord", account: discord });
-  const accounts = asObjectRecord(discord.accounts);
-  if (!accounts) {
-    return scopes;
-  }
-  for (const key of Object.keys(accounts)) {
-    const account = asObjectRecord(accounts[key]);
-    if (account) {
-      scopes.push({ prefix: `channels.discord.accounts.${key}`, account });
-    }
-  }
-  return scopes;
-}
-
-function collectDiscordIdLists(
-  prefix: string,
-  account: Record<string, unknown>,
-): DiscordIdListRef[] {
-  const refs: DiscordIdListRef[] = [
-    { pathLabel: `${prefix}.allowFrom`, holder: account, key: "allowFrom" },
-  ];
-  const dm = asObjectRecord(account.dm);
-  if (dm) {
-    refs.push({ pathLabel: `${prefix}.dm.allowFrom`, holder: dm, key: "allowFrom" });
-    refs.push({ pathLabel: `${prefix}.dm.groupChannels`, holder: dm, key: "groupChannels" });
-  }
-  const execApprovals = asObjectRecord(account.execApprovals);
-  if (execApprovals) {
-    refs.push({
-      pathLabel: `${prefix}.execApprovals.approvers`,
-      holder: execApprovals,
-      key: "approvers",
-    });
-  }
-  const guilds = asObjectRecord(account.guilds);
-  if (!guilds) {
-    return refs;
-  }
-  for (const guildId of Object.keys(guilds)) {
-    const guild = asObjectRecord(guilds[guildId]);
-    if (!guild) {
-      continue;
-    }
-    refs.push({ pathLabel: `${prefix}.guilds.${guildId}.users`, holder: guild, key: "users" });
-    refs.push({ pathLabel: `${prefix}.guilds.${guildId}.roles`, holder: guild, key: "roles" });
-    const channels = asObjectRecord(guild.channels);
-    if (!channels) {
-      continue;
-    }
-    for (const channelId of Object.keys(channels)) {
-      const channel = asObjectRecord(channels[channelId]);
-      if (!channel) {
-        continue;
-      }
-      refs.push({
-        pathLabel: `${prefix}.guilds.${guildId}.channels.${channelId}.users`,
-        holder: channel,
-        key: "users",
-      });
-      refs.push({
-        pathLabel: `${prefix}.guilds.${guildId}.channels.${channelId}.roles`,
-        holder: channel,
-        key: "roles",
-      });
-    }
-  }
-  return refs;
-}
-
-export function scanDiscordNumericIdEntries(cfg: OpenClawConfig): DiscordNumericIdHit[] {
-  const hits: DiscordNumericIdHit[] = [];
-  const scanList = (pathLabel: string, list: unknown) => {
-    if (!Array.isArray(list)) {
-      return;
-    }
-    for (const [index, entry] of list.entries()) {
-      if (typeof entry !== "number") {
-        continue;
-      }
-      hits.push({
-        path: `${pathLabel}[${index}]`,
-        entry,
-        safe: Number.isSafeInteger(entry) && entry >= 0,
-      });
-    }
-  };
-
-  for (const scope of collectDiscordAccountScopes(cfg)) {
-    for (const ref of collectDiscordIdLists(scope.prefix, scope.account)) {
-      scanList(ref.pathLabel, ref.holder[ref.key]);
-    }
-  }
-  return hits;
-}
-
-export function collectDiscordNumericIdWarnings(params: {
-  hits: DiscordNumericIdHit[];
-  doctorFixCommand: string;
-}): string[] {
-  if (params.hits.length === 0) {
-    return [];
-  }
-  const hitsByListPath = new Map<string, DiscordNumericIdHit[]>();
-  for (const hit of params.hits) {
-    const listPath = hit.path.replace(/\[\d+\]$/, "");
-    const existing = hitsByListPath.get(listPath);
-    if (existing) {
-      existing.push(hit);
-    } else {
-      hitsByListPath.set(listPath, [hit]);
-    }
-  }
-
-  const repairableHits: DiscordNumericIdHit[] = [];
-  const blockedHits: DiscordNumericIdHit[] = [];
-  for (const hits of hitsByListPath.values()) {
-    if (hits.some((hit) => !hit.safe)) {
-      blockedHits.push(...hits);
-    } else {
-      repairableHits.push(...hits);
-    }
-  }
-
-  const lines: string[] = [];
-  if (repairableHits.length > 0) {
-    const sample = repairableHits[0];
-    lines.push(
-      `- Discord allowlists contain ${repairableHits.length} numeric ${repairableHits.length === 1 ? "entry" : "entries"} (e.g. ${sanitizeForLog(sample.path)}=${sanitizeForLog(String(sample.entry))}).`,
-      `- Discord IDs must be strings; run "${params.doctorFixCommand}" to convert numeric IDs to quoted strings.`,
-    );
-  }
-  if (blockedHits.length > 0) {
-    const sample = blockedHits[0];
-    lines.push(
-      `- Discord allowlists contain ${blockedHits.length} numeric ${blockedHits.length === 1 ? "entry" : "entries"} in lists that cannot be auto-repaired (e.g. ${sanitizeForLog(sample.path)}).`,
-      `- These lists include invalid or precision-losing numeric IDs; manually quote the original values in your config file, then rerun "${params.doctorFixCommand}".`,
-    );
-  }
-  return lines;
-}
-
-export function maybeRepairDiscordNumericIds(
-  cfg: OpenClawConfig,
-  doctorFixCommand: string,
-): { config: OpenClawConfig; changes: string[]; warnings?: string[] } {
-  const hits = scanDiscordNumericIdEntries(cfg);
-  if (hits.length === 0) {
-    return { config: cfg, changes: [] };
-  }
-
-  const next = structuredClone(cfg);
-  const changes: string[] = [];
-
-  const repairList = (pathLabel: string, holder: Record<string, unknown>, key: string) => {
-    const raw = holder[key];
-    if (!Array.isArray(raw)) {
-      return;
-    }
-    const hasUnsafe = raw.some(
-      (entry) => typeof entry === "number" && (!Number.isSafeInteger(entry) || entry < 0),
-    );
-    if (hasUnsafe) {
-      return;
-    }
-    let converted = 0;
-    holder[key] = raw.map((entry) => {
-      if (typeof entry === "number") {
-        converted += 1;
-        return String(entry);
-      }
-      return entry;
-    });
-    if (converted > 0) {
-      changes.push(
-        `- ${sanitizeForLog(pathLabel)}: converted ${converted} numeric ${converted === 1 ? "ID" : "IDs"} to strings`,
-      );
-    }
-  };
-
-  for (const scope of collectDiscordAccountScopes(next)) {
-    for (const ref of collectDiscordIdLists(scope.prefix, scope.account)) {
-      repairList(ref.pathLabel, ref.holder, ref.key);
-    }
-  }
-
-  if (changes.length === 0) {
-    return {
-      config: cfg,
-      changes: [],
-      warnings: collectDiscordNumericIdWarnings({ hits, doctorFixCommand }),
-    };
-  }
-  return {
-    config: next,
-    changes,
-    warnings: collectDiscordNumericIdWarnings({
-      hits: hits.filter((hit) => !hit.safe),
-      doctorFixCommand,
-    }),
-  };
-}
-
-export function collectDiscordMissingEnvTokenWarnings(params: {
-  cfg: OpenClawConfig;
-  env?: NodeJS.ProcessEnv;
-}): string[] {
-  if (resolveDefaultDiscordAccountId(params.cfg) !== "default") {
-    return [];
-  }
-  const account = inspectDiscordAccount({
-    cfg: params.cfg,
-    accountId: "default",
-    envToken: params.env?.DISCORD_BOT_TOKEN ?? "",
-  });
-  if (!account.enabled || account.tokenStatus !== "missing" || account.tokenSource !== "none") {
-    return [];
-  }
-  return [
-    "- channels.discord: default account has no available bot token, and DISCORD_BOT_TOKEN is absent in this doctor environment. After migration, verify DISCORD_BOT_TOKEN is present in the state-dir .env or configure channels.discord.token / channels.discord.accounts.default.token as a SecretRef.",
-  ];
-}
-
-function collectDiscordMutableAllowlistWarnings(cfg: OpenClawConfig): string[] {
-  const hits: Array<{ path: string; entry: string }> = [];
-  const addHits = (pathLabel: string, list: unknown) => {
-    if (!Array.isArray(list)) {
-      return;
-    }
-    for (const entry of list) {
-      const text = normalizeOptionalString(String(entry)) ?? "";
-      if (!text || text === "*" || !isDiscordMutableAllowEntry(text)) {
-        continue;
-      }
-      hits.push({ path: pathLabel, entry: text });
-    }
-  };
-
-  for (const scope of collectProviderDangerousNameMatchingScopes(cfg, "discord")) {
-    if (scope.dangerousNameMatchingEnabled) {
-      continue;
-    }
-    addHits(`${scope.prefix}.allowFrom`, scope.account.allowFrom);
-    const dm = asObjectRecord(scope.account.dm);
-    if (dm) {
-      addHits(`${scope.prefix}.dm.allowFrom`, dm.allowFrom);
-    }
-    const guilds = asObjectRecord(scope.account.guilds);
-    if (!guilds) {
-      continue;
-    }
-    for (const [guildId, guildRaw] of Object.entries(guilds)) {
-      const guild = asObjectRecord(guildRaw);
-      if (!guild) {
-        continue;
-      }
-      addHits(`${scope.prefix}.guilds.${guildId}.users`, guild.users);
-      const channels = asObjectRecord(guild.channels);
-      if (!channels) {
-        continue;
-      }
-      for (const [channelId, channelRaw] of Object.entries(channels)) {
-        const channel = asObjectRecord(channelRaw);
-        if (channel) {
-          addHits(`${scope.prefix}.guilds.${guildId}.channels.${channelId}.users`, channel.users);
-        }
-      }
-    }
-  }
-
-  if (hits.length === 0) {
-    return [];
-  }
-  const exampleLines = hits
-    .slice(0, 8)
-    .map((hit) => `- ${sanitizeForLog(hit.path)}: ${sanitizeForLog(hit.entry)}`);
-  const remaining =
-    hits.length > 8 ? `- +${hits.length - 8} more mutable allowlist entries.` : null;
-  return [
-    `- Found ${hits.length} mutable allowlist ${hits.length === 1 ? "entry" : "entries"} across discord while name matching is disabled by default.`,
-    ...exampleLines,
-    ...(remaining ? [remaining] : []),
-    `- Option A (break-glass): enable channels.discord.dangerousNameMatching=true for the affected scope.`,
-    `- Option B (recommended): resolve names to stable Discord IDs and rewrite the allowlist entries.`,
-  ];
-}
-
-export const discordDoctor: ChannelDoctorAdapter = {
-  dmAllowFromMode: "topOnly",
-  groupModel: "route",
-  groupAllowFromFallbackToAllowFrom: false,
-  warnOnEmptyGroupSenderAllowlist: false,
-  legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
-  normalizeCompatibilityConfig: normalizeDiscordCompatibilityConfig,
-  collectPreviewWarnings: ({ cfg, doctorFixCommand, env }) => [
-    ...collectDiscordMissingEnvTokenWarnings({ cfg, env }),
-    ...collectDiscordNumericIdWarnings({
-      hits: scanDiscordNumericIdEntries(cfg),
-      doctorFixCommand,
-    }),
-  ],
-  collectMutableAllowlistWarnings: ({ cfg }) => collectDiscordMutableAllowlistWarnings(cfg),
-  repairConfig: ({ cfg, doctorFixCommand }) => maybeRepairDiscordNumericIds(cfg, doctorFixCommand),
-};

package/src/draft-chunking.test.ts

@@ -1,64 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { describe, expect, it } from "vitest";
-import { resolveDiscordDraftStreamingChunking } from "./draft-chunking.js";
-import { EMPTY_DISCORD_TEST_CONFIG } from "./test-support/config.js";
-
-describe("resolveDiscordDraftStreamingChunking", () => {
-  it("returns sane defaults when discord draft chunking is unset", () => {
-    expect(resolveDiscordDraftStreamingChunking(EMPTY_DISCORD_TEST_CONFIG)).toEqual({
-      minChars: 200,
-      maxChars: 800,
-      breakPreference: "paragraph",
-    });
-  });
-
-  it("clamps requested draft chunk sizes to the resolved text limit", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          textChunkLimit: 500,
-          draftChunk: {
-            minChars: 900,
-            maxChars: 1200,
-            breakPreference: "sentence",
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    expect(resolveDiscordDraftStreamingChunking(cfg)).toEqual({
-      minChars: 500,
-      maxChars: 500,
-      breakPreference: "sentence",
-    });
-  });
-
-  it("prefers account draft chunking over channel defaults", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          draftChunk: {
-            minChars: 200,
-            maxChars: 800,
-            breakPreference: "paragraph",
-          },
-          accounts: {
-            ops: {
-              draftChunk: {
-                minChars: 25,
-                maxChars: 75,
-                breakPreference: "newline",
-              },
-            },
-          },
-        },
-      },
-    } as OpenClawConfig;
-
-    expect(resolveDiscordDraftStreamingChunking(cfg, "ops")).toEqual({
-      minChars: 25,
-      maxChars: 75,
-      breakPreference: "newline",
-    });
-  });
-});

package/src/draft-chunking.ts

@@ -1,43 +0,0 @@
-import { resolveChannelStreamingPreviewChunk } from "openclaw/plugin-sdk/channel-streaming";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
-import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-import { DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter.js";
-
-const DEFAULT_DISCORD_DRAFT_STREAM_MIN = 200;
-const DEFAULT_DISCORD_DRAFT_STREAM_MAX = 800;
-
-export function resolveDiscordDraftStreamingChunking(
-  cfg: OpenClawConfig,
-  accountId?: string | null,
-): {
-  minChars: number;
-  maxChars: number;
-  breakPreference: "paragraph" | "newline" | "sentence";
-} {
-  const textLimit = resolveTextChunkLimit(cfg, "discord", accountId, {
-    fallbackLimit: DISCORD_TEXT_CHUNK_LIMIT,
-  });
-  const normalizedAccountId = normalizeAccountId(accountId);
-  const accountCfg = resolveAccountEntry(cfg?.channels?.discord?.accounts, normalizedAccountId);
-  const draftCfg =
-    resolveChannelStreamingPreviewChunk(accountCfg) ??
-    resolveChannelStreamingPreviewChunk(cfg?.channels?.discord);
-
-  const maxRequested = Math.max(
-    1,
-    Math.floor(draftCfg?.maxChars ?? DEFAULT_DISCORD_DRAFT_STREAM_MAX),
-  );
-  const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
-  const minRequested = Math.max(
-    1,
-    Math.floor(draftCfg?.minChars ?? DEFAULT_DISCORD_DRAFT_STREAM_MIN),
-  );
-  const minChars = Math.min(minRequested, maxChars);
-  const breakPreference =
-    draftCfg?.breakPreference === "newline" || draftCfg?.breakPreference === "sentence"
-      ? draftCfg.breakPreference
-      : "paragraph";
-  return { minChars, maxChars, breakPreference };
-}

package/src/draft-stream.test.ts

@@ -1,159 +0,0 @@
-import { Routes } from "discord-api-types/v10";
-import { describe, expect, it, vi } from "vitest";
-import { createDiscordDraftStream } from "./draft-stream.js";
-
-describe("createDiscordDraftStream", () => {
-  it("holds the first preview until minInitialChars is reached", async () => {
-    const rest = {
-      post: vi.fn(async () => ({ id: "m1" })),
-      patch: vi.fn(async () => undefined),
-      delete: vi.fn(async () => undefined),
-    };
-    const stream = createDiscordDraftStream({
-      rest: rest as never,
-      channelId: "c1",
-      throttleMs: 250,
-      minInitialChars: 5,
-    });
-
-    stream.update("hey");
-    await stream.flush();
-
-    expect(rest.post).not.toHaveBeenCalled();
-    expect(stream.messageId()).toBeUndefined();
-  });
-
-  it("sends a reply preview, then edits the same message on later flushes", async () => {
-    const rest = {
-      post: vi.fn(async () => ({ id: "m1" })),
-      patch: vi.fn(async () => undefined),
-      delete: vi.fn(async () => undefined),
-    };
-    const stream = createDiscordDraftStream({
-      rest: rest as never,
-      channelId: "c1",
-      throttleMs: 250,
-      replyToMessageId: () => "  parent-1  ",
-    });
-
-    stream.update("first draft");
-    await stream.flush();
-    stream.update("second draft");
-    await stream.flush();
-
-    expect(rest.post).toHaveBeenCalledWith(Routes.channelMessages("c1"), {
-      body: {
-        content: "first draft",
-        allowed_mentions: { parse: [] },
-        message_reference: {
-          message_id: "parent-1",
-          fail_if_not_exists: false,
-        },
-      },
-    });
-    expect(rest.patch).toHaveBeenCalledWith(Routes.channelMessage("c1", "m1"), {
-      body: { content: "second draft", allowed_mentions: { parse: [] } },
-    });
-    expect(stream.messageId()).toBe("m1");
-  });
-
-  it("suppresses mentions in preview creates and edits", async () => {
-    const rest = {
-      post: vi.fn(async () => ({ id: "m1" })),
-      patch: vi.fn(async () => undefined),
-      delete: vi.fn(async () => undefined),
-    };
-    const stream = createDiscordDraftStream({
-      rest: rest as never,
-      channelId: "c1",
-      throttleMs: 250,
-    });
-
-    stream.update("working @everyone <@123>");
-    await stream.flush();
-    stream.update("still working @here");
-    await stream.flush();
-
-    expect(rest.post).toHaveBeenCalledWith(Routes.channelMessages("c1"), {
-      body: {
-        content: "working @everyone <@123>",
-        allowed_mentions: { parse: [] },
-      },
-    });
-    expect(rest.patch).toHaveBeenCalledWith(Routes.channelMessage("c1", "m1"), {
-      body: {
-        content: "still working @here",
-        allowed_mentions: { parse: [] },
-      },
-    });
-  });
-
-  it("stops previewing and warns once text exceeds the configured limit", async () => {
-    const rest = {
-      post: vi.fn(async () => ({ id: "m1" })),
-      patch: vi.fn(async () => undefined),
-      delete: vi.fn(async () => undefined),
-    };
-    const warn = vi.fn();
-    const stream = createDiscordDraftStream({
-      rest: rest as never,
-      channelId: "c1",
-      maxChars: 5,
-      throttleMs: 250,
-      warn,
-    });
-
-    stream.update("123456");
-    await stream.flush();
-
-    expect(rest.post).not.toHaveBeenCalled();
-    expect(warn).toHaveBeenCalledWith(expect.stringContaining("discord stream preview stopped"));
-    expect(stream.messageId()).toBeUndefined();
-  });
-
-  it("discardPending keeps an existing preview but ignores later updates", async () => {
-    const rest = {
-      post: vi.fn(async () => ({ id: "m1" })),
-      patch: vi.fn(async () => undefined),
-      delete: vi.fn(async () => undefined),
-    };
-    const stream = createDiscordDraftStream({
-      rest: rest as never,
-      channelId: "c1",
-      throttleMs: 250,
-    });
-
-    stream.update("first draft");
-    await stream.flush();
-    await stream.discardPending();
-    stream.update("late draft");
-    await stream.flush();
-
-    expect(rest.post).toHaveBeenCalledTimes(1);
-    expect(rest.patch).not.toHaveBeenCalled();
-    expect(rest.delete).not.toHaveBeenCalled();
-    expect(stream.messageId()).toBe("m1");
-  });
-
-  it("seal keeps an existing preview and cancels pending final overwrites", async () => {
-    const rest = {
-      post: vi.fn(async () => ({ id: "m1" })),
-      patch: vi.fn(async () => undefined),
-      delete: vi.fn(async () => undefined),
-    };
-    const stream = createDiscordDraftStream({
-      rest: rest as never,
-      channelId: "c1",
-      throttleMs: 250,
-    });
-
-    stream.update("first draft");
-    await stream.flush();
-    stream.update("stale final draft");
-    await stream.seal();
-
-    expect(rest.post).toHaveBeenCalledTimes(1);
-    expect(rest.patch).not.toHaveBeenCalled();
-    expect(stream.messageId()).toBe("m1");
-  });
-});