@openclaw/discord 2026.5.2 → 2026.5.3-beta.2

package/src/account-inspect.test.ts

@@ -1,126 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { describe, expect, it } from "vitest";
-import { inspectDiscordAccount } from "./account-inspect.js";
-
-function asConfig(value: unknown): OpenClawConfig {
-  return value as OpenClawConfig;
-}
-
-describe("inspectDiscordAccount", () => {
-  it("prefers account token over channel token and strips Bot prefix", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            token: "Bot channel-token",
-            accounts: {
-              work: {
-                token: "Bot account-token",
-              },
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("account-token");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("available");
-    expect(inspected.configured).toBe(true);
-  });
-
-  it("reports configured_unavailable for unresolved configured secret input", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            accounts: {
-              work: {
-                token: { source: "env", id: "DISCORD_TOKEN" },
-              },
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("configured_unavailable");
-    expect(inspected.configured).toBe(true);
-  });
-
-  it("does not fall back when account token key exists but is missing", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            token: "Bot channel-token",
-            accounts: {
-              work: {
-                token: "",
-              },
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("");
-    expect(inspected.tokenSource).toBe("none");
-    expect(inspected.tokenStatus).toBe("missing");
-    expect(inspected.configured).toBe(false);
-  });
-
-  it("falls back to channel token when account token is absent", () => {
-    const inspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            token: "Bot channel-token",
-            accounts: {
-              work: {},
-            },
-          },
-        },
-      }),
-      accountId: "work",
-    });
-
-    expect(inspected.token).toBe("channel-token");
-    expect(inspected.tokenSource).toBe("config");
-    expect(inspected.tokenStatus).toBe("available");
-    expect(inspected.configured).toBe(true);
-  });
-
-  it("allows env token only for default account", () => {
-    const defaultInspected = inspectDiscordAccount({
-      cfg: asConfig({}),
-      accountId: "default",
-      envToken: "Bot env-default",
-    });
-    const namedInspected = inspectDiscordAccount({
-      cfg: asConfig({
-        channels: {
-          discord: {
-            accounts: {
-              work: {},
-            },
-          },
-        },
-      }),
-      accountId: "work",
-      envToken: "Bot env-work",
-    });
-
-    expect(defaultInspected.token).toBe("env-default");
-    expect(defaultInspected.tokenSource).toBe("env");
-    expect(defaultInspected.configured).toBe(true);
-    expect(namedInspected.token).toBe("");
-    expect(namedInspected.tokenSource).toBe("none");
-    expect(namedInspected.configured).toBe(false);
-  });
-});

package/src/account-inspect.ts

@@ -1,132 +0,0 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import {
-  hasConfiguredSecretInput,
-  normalizeSecretInputString,
-} from "openclaw/plugin-sdk/secret-input";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import {
-  mergeDiscordAccountConfig,
-  resolveDefaultDiscordAccountId,
-  resolveDiscordAccountConfig,
-} from "./accounts.js";
-import type { DiscordAccountConfig, OpenClawConfig } from "./runtime-api.js";
-
-export type DiscordCredentialStatus = "available" | "configured_unavailable" | "missing";
-
-export type InspectedDiscordAccount = {
-  accountId: string;
-  enabled: boolean;
-  name?: string;
-  token: string;
-  tokenSource: "env" | "config" | "none";
-  tokenStatus: DiscordCredentialStatus;
-  configured: boolean;
-  config: DiscordAccountConfig;
-};
-
-function inspectDiscordTokenValue(value: unknown): {
-  token: string;
-  tokenSource: "config";
-  tokenStatus: Exclude<DiscordCredentialStatus, "missing">;
-} | 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 inspectDiscordAccount(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-  envToken?: string | null;
-}): InspectedDiscordAccount {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordAccountId(params.cfg),
-  );
-  const merged = mergeDiscordAccountConfig(params.cfg, accountId);
-  const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
-  const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
-  const hasAccountToken = Boolean(
-    accountConfig &&
-    Object.prototype.hasOwnProperty.call(accountConfig as Record<string, unknown>, "token"),
-  );
-  const accountToken = inspectDiscordTokenValue(accountConfig?.token);
-  if (accountToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: accountToken.token,
-      tokenSource: accountToken.tokenSource,
-      tokenStatus: accountToken.tokenStatus,
-      configured: true,
-      config: merged,
-    };
-  }
-  if (hasAccountToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: "",
-      tokenSource: "none",
-      tokenStatus: "missing",
-      configured: false,
-      config: merged,
-    };
-  }
-
-  const channelToken = inspectDiscordTokenValue(params.cfg.channels?.discord?.token);
-  if (channelToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: channelToken.token,
-      tokenSource: channelToken.tokenSource,
-      tokenStatus: channelToken.tokenStatus,
-      configured: true,
-      config: merged,
-    };
-  }
-
-  const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
-  const envToken = allowEnv
-    ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN)
-    : undefined;
-  if (envToken) {
-    return {
-      accountId,
-      enabled,
-      name: normalizeOptionalString(merged.name),
-      token: envToken.replace(/^Bot\s+/i, ""),
-      tokenSource: "env",
-      tokenStatus: "available",
-      configured: true,
-      config: merged,
-    };
-  }
-
-  return {
-    accountId,
-    enabled,
-    name: normalizeOptionalString(merged.name),
-    token: "",
-    tokenSource: "none",
-    tokenStatus: "missing",
-    configured: false,
-    config: merged,
-  };
-}

package/src/accounts.test.ts

@@ -1,247 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import {
-  createDiscordActionGate,
-  isDiscordAccountEnabledForRuntime,
-  listEnabledDiscordAccounts,
-  resolveDiscordAccount,
-  resolveDiscordAccountDisabledReason,
-  resolveDiscordMaxLinesPerMessage,
-} from "./accounts.js";
-
-afterEach(() => {
-  vi.unstubAllEnvs();
-});
-
-describe("resolveDiscordAccount allowFrom precedence", () => {
-  it("uses configured defaultAccount when accountId is omitted", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            defaultAccount: "work",
-            accounts: {
-              work: { token: "token-work", name: "Work" },
-            },
-          },
-        },
-      },
-    });
-
-    expect(resolved.accountId).toBe("work");
-    expect(resolved.name).toBe("Work");
-    expect(resolved.token).toBe("token-work");
-  });
-
-  it("prefers accounts.default.allowFrom over top-level for default account", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            allowFrom: ["top"],
-            accounts: {
-              default: { allowFrom: ["default"], token: "token-default" },
-            },
-          },
-        },
-      },
-      accountId: "default",
-    });
-
-    expect(resolved.config.allowFrom).toEqual(["default"]);
-  });
-
-  it("falls back to top-level allowFrom for named account without override", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            allowFrom: ["top"],
-            accounts: {
-              work: { token: "token-work" },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(resolved.config.allowFrom).toEqual(["top"]);
-  });
-
-  it("does not inherit default account allowFrom for named account when top-level is absent", () => {
-    const resolved = resolveDiscordAccount({
-      cfg: {
-        channels: {
-          discord: {
-            accounts: {
-              default: { allowFrom: ["default"], token: "token-default" },
-              work: { token: "token-work" },
-            },
-          },
-        },
-      },
-      accountId: "work",
-    });
-
-    expect(resolved.config.allowFrom).toBeUndefined();
-  });
-});
-
-describe("createDiscordActionGate", () => {
-  it("uses configured defaultAccount when accountId is omitted", () => {
-    const gate = createDiscordActionGate({
-      cfg: {
-        channels: {
-          discord: {
-            actions: { reactions: false },
-            defaultAccount: "work",
-            accounts: {
-              work: {
-                token: "token-work",
-                actions: { reactions: true },
-              },
-            },
-          },
-        },
-      },
-    });
-
-    expect(gate("reactions")).toBe(true);
-  });
-});
-
-describe("resolveDiscordMaxLinesPerMessage", () => {
-  it("falls back to merged root discord maxLinesPerMessage when runtime config omits it", () => {
-    const resolved = resolveDiscordMaxLinesPerMessage({
-      cfg: {
-        channels: {
-          discord: {
-            maxLinesPerMessage: 120,
-            accounts: {
-              default: { token: "token-default" },
-            },
-          },
-        },
-      },
-      discordConfig: {},
-      accountId: "default",
-    });
-
-    expect(resolved).toBe(120);
-  });
-
-  it("prefers explicit runtime discord maxLinesPerMessage over merged config", () => {
-    const resolved = resolveDiscordMaxLinesPerMessage({
-      cfg: {
-        channels: {
-          discord: {
-            maxLinesPerMessage: 120,
-            accounts: {
-              default: { token: "token-default", maxLinesPerMessage: 80 },
-            },
-          },
-        },
-      },
-      discordConfig: { maxLinesPerMessage: 55 },
-      accountId: "default",
-    });
-
-    expect(resolved).toBe(55);
-  });
-
-  it("uses per-account discord maxLinesPerMessage over the root value when runtime config omits it", () => {
-    const resolved = resolveDiscordMaxLinesPerMessage({
-      cfg: {
-        channels: {
-          discord: {
-            maxLinesPerMessage: 120,
-            accounts: {
-              work: { token: "token-work", maxLinesPerMessage: 80 },
-            },
-          },
-        },
-      },
-      discordConfig: {},
-      accountId: "work",
-    });
-
-    expect(resolved).toBe(80);
-  });
-});
-
-describe("Discord duplicate-token account filtering", () => {
-  it("keeps the config-token account over default env fallback when tokens collide", () => {
-    vi.stubEnv("DISCORD_BOT_TOKEN", "same-token");
-    const cfg = {
-      channels: {
-        discord: {
-          accounts: {
-            work: {
-              token: "same-token",
-            },
-          },
-        },
-      },
-    };
-
-    const defaultAccount = resolveDiscordAccount({ cfg, accountId: "default" });
-    const workAccount = resolveDiscordAccount({ cfg, accountId: "work" });
-
-    expect(isDiscordAccountEnabledForRuntime(defaultAccount, cfg)).toBe(false);
-    expect(resolveDiscordAccountDisabledReason(defaultAccount, cfg)).toBe(
-      'duplicate bot token; using account "work"',
-    );
-    expect(isDiscordAccountEnabledForRuntime(workAccount, cfg)).toBe(true);
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["work"]);
-  });
-
-  it("keeps the first enabled account when duplicate tokens have the same source", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          accounts: {
-            first: {
-              token: "same-token",
-            },
-            second: {
-              token: "same-token",
-            },
-          },
-        },
-      },
-    };
-
-    const firstAccount = resolveDiscordAccount({ cfg, accountId: "first" });
-    const secondAccount = resolveDiscordAccount({ cfg, accountId: "second" });
-
-    expect(isDiscordAccountEnabledForRuntime(firstAccount, cfg)).toBe(true);
-    expect(isDiscordAccountEnabledForRuntime(secondAccount, cfg)).toBe(false);
-    expect(resolveDiscordAccountDisabledReason(secondAccount, cfg)).toBe(
-      'duplicate bot token; using account "first"',
-    );
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["first"]);
-  });
-
-  it("does not let disabled duplicate-token accounts suppress enabled accounts", () => {
-    const cfg = {
-      channels: {
-        discord: {
-          accounts: {
-            disabled: {
-              enabled: false,
-              token: "same-token",
-            },
-            active: {
-              token: "same-token",
-            },
-          },
-        },
-      },
-    };
-
-    const activeAccount = resolveDiscordAccount({ cfg, accountId: "active" });
-
-    expect(isDiscordAccountEnabledForRuntime(activeAccount, cfg)).toBe(true);
-    expect(listEnabledDiscordAccounts(cfg).map((account) => account.accountId)).toEqual(["active"]);
-  });
-});

package/src/accounts.ts

@@ -1,196 +0,0 @@
-import {
-  createAccountActionGate,
-  createAccountListHelpers,
-  resolveMergedAccountConfig,
-} from "openclaw/plugin-sdk/account-helpers";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import {
-  mapAllowFromEntries,
-  normalizeChannelDmPolicy,
-  resolveChannelDmAllowFrom,
-  resolveChannelDmPolicy,
-  type ChannelDmPolicy,
-} from "openclaw/plugin-sdk/channel-config-helpers";
-import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
-import type { DiscordAccountConfig, DiscordActionConfig, OpenClawConfig } from "./runtime-api.js";
-import { resolveDiscordToken } from "./token.js";
-
-export type ResolvedDiscordAccount = {
-  accountId: string;
-  enabled: boolean;
-  name?: string;
-  token: string;
-  tokenSource: "env" | "config" | "none";
-  config: DiscordAccountConfig;
-};
-
-const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord");
-export const listDiscordAccountIds = listAccountIds;
-export const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
-
-export function resolveDiscordAccountConfig(
-  cfg: OpenClawConfig,
-  accountId: string,
-): DiscordAccountConfig | undefined {
-  return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
-}
-
-export function mergeDiscordAccountConfig(
-  cfg: OpenClawConfig,
-  accountId: string,
-): DiscordAccountConfig {
-  return resolveMergedAccountConfig<DiscordAccountConfig>({
-    channelConfig: cfg.channels?.discord as DiscordAccountConfig | undefined,
-    accounts: cfg.channels?.discord?.accounts as
-      | Record<string, Partial<DiscordAccountConfig>>
-      | undefined,
-    accountId,
-  });
-}
-
-export function resolveDiscordAccountAllowFrom(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): string[] | undefined {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordAccountId(params.cfg),
-  );
-  const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
-  const rootConfig = params.cfg.channels?.discord as DiscordAccountConfig | undefined;
-
-  const allowFrom = resolveChannelDmAllowFrom({
-    account: accountConfig as Record<string, unknown> | undefined,
-    parent: rootConfig as Record<string, unknown> | undefined,
-  });
-  return allowFrom ? mapAllowFromEntries(allowFrom) : undefined;
-}
-
-export function resolveDiscordAccountDmPolicy(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): ChannelDmPolicy | undefined {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordAccountId(params.cfg),
-  );
-  const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
-  const rootConfig = params.cfg.channels?.discord as DiscordAccountConfig | undefined;
-  const policy = resolveChannelDmPolicy({
-    account: accountConfig as Record<string, unknown> | undefined,
-    parent: rootConfig as Record<string, unknown> | undefined,
-    defaultPolicy: "pairing",
-  });
-  return normalizeChannelDmPolicy(policy);
-}
-
-export function createDiscordActionGate(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): (key: keyof DiscordActionConfig, defaultValue?: boolean) => boolean {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordAccountId(params.cfg),
-  );
-  return createAccountActionGate({
-    baseActions: params.cfg.channels?.discord?.actions,
-    accountActions: resolveDiscordAccountConfig(params.cfg, accountId)?.actions,
-  });
-}
-
-export function resolveDiscordAccount(params: {
-  cfg: OpenClawConfig;
-  accountId?: string | null;
-}): ResolvedDiscordAccount {
-  const accountId = normalizeAccountId(
-    params.accountId ?? resolveDefaultDiscordAccountId(params.cfg),
-  );
-  const baseEnabled = params.cfg.channels?.discord?.enabled !== false;
-  const merged = mergeDiscordAccountConfig(params.cfg, accountId);
-  const accountEnabled = merged.enabled !== false;
-  const enabled = baseEnabled && accountEnabled;
-  const tokenResolution = resolveDiscordToken(params.cfg, { accountId });
-  return {
-    accountId,
-    enabled,
-    name: normalizeOptionalString(merged.name),
-    token: tokenResolution.token,
-    tokenSource: tokenResolution.source,
-    config: merged,
-  };
-}
-
-export function resolveDiscordMaxLinesPerMessage(params: {
-  cfg: OpenClawConfig;
-  discordConfig?: DiscordAccountConfig | null;
-  accountId?: string | null;
-}): number | undefined {
-  if (typeof params.discordConfig?.maxLinesPerMessage === "number") {
-    return params.discordConfig.maxLinesPerMessage;
-  }
-  return resolveDiscordAccount({
-    cfg: params.cfg,
-    accountId: params.accountId,
-  }).config.maxLinesPerMessage;
-}
-
-function resolveDiscordAccountTokenOwner(params: {
-  cfg: OpenClawConfig;
-  token: string;
-}): string | undefined {
-  const token = params.token.trim();
-  if (!token) {
-    return undefined;
-  }
-  let owner: { accountId: string; priority: number; index: number } | undefined;
-  const accountIds = listDiscordAccountIds(params.cfg);
-  for (const [index, accountId] of accountIds.entries()) {
-    const account = resolveDiscordAccount({ cfg: params.cfg, accountId });
-    const accountToken = account.token.trim();
-    if (!account.enabled || accountToken !== token) {
-      continue;
-    }
-    const priority = account.tokenSource === "config" ? 2 : account.tokenSource === "env" ? 1 : 0;
-    if (!owner || priority > owner.priority) {
-      owner = { accountId: account.accountId, priority, index };
-      continue;
-    }
-    if (priority === owner.priority && index < owner.index) {
-      owner = { accountId: account.accountId, priority, index };
-    }
-  }
-  return owner?.accountId;
-}
-
-function resolveDiscordDuplicateTokenOwner(params: {
-  cfg: OpenClawConfig;
-  account: ResolvedDiscordAccount;
-}): string | undefined {
-  const owner = resolveDiscordAccountTokenOwner({
-    cfg: params.cfg,
-    token: params.account.token,
-  });
-  return owner && owner !== params.account.accountId ? owner : undefined;
-}
-
-export function isDiscordAccountEnabledForRuntime(
-  account: ResolvedDiscordAccount,
-  cfg: OpenClawConfig,
-): boolean {
-  return account.enabled && !resolveDiscordDuplicateTokenOwner({ cfg, account });
-}
-
-export function resolveDiscordAccountDisabledReason(
-  account: ResolvedDiscordAccount,
-  cfg: OpenClawConfig,
-): string {
-  if (!account.enabled) {
-    return "disabled";
-  }
-  const owner = resolveDiscordDuplicateTokenOwner({ cfg, account });
-  return owner ? `duplicate bot token; using account "${owner}"` : "disabled";
-}
-
-export function listEnabledDiscordAccounts(cfg: OpenClawConfig): ResolvedDiscordAccount[] {
-  return listDiscordAccountIds(cfg)
-    .map((accountId) => resolveDiscordAccount({ cfg, accountId }))
-    .filter((account) => isDiscordAccountEnabledForRuntime(account, cfg));
-}