@gakr-gakr/discord 0.1.0

package/src/security-audit.ts

@@ -0,0 +1,208 @@
+import { coerceNativeSetting, normalizeAllowFromList } from "autobot/plugin-sdk/channel-policy";
+import { readChannelAllowFromStore } from "autobot/plugin-sdk/conversation-runtime";
+import { isDangerousNameMatchingEnabled } from "autobot/plugin-sdk/dangerous-name-runtime";
+import {
+  resolveNativeCommandsEnabled,
+  resolveNativeSkillsEnabled,
+} from "autobot/plugin-sdk/native-command-config-runtime";
+import type { ResolvedDiscordAccount } from "./accounts.js";
+import type { AutoBotConfig } from "./runtime-api.js";
+import { isDiscordMutableAllowEntry } from "./security-doctor.js";
+
+function normalizeOptionalString(value: string | null | undefined): string | undefined {
+  const normalized = value?.trim();
+  return normalized ? normalized : undefined;
+}
+
+function addDiscordNameBasedEntries(params: {
+  target: Set<string>;
+  values: unknown;
+  source: string;
+}) {
+  if (!Array.isArray(params.values)) {
+    return;
+  }
+  for (const value of params.values) {
+    if (!isDiscordMutableAllowEntry(String(value))) {
+      continue;
+    }
+    const text = normalizeOptionalString(String(value)) ?? "";
+    if (!text) {
+      continue;
+    }
+    params.target.add(`${params.source}:${text}`);
+  }
+}
+
+export async function collectDiscordSecurityAuditFindings(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  account: ResolvedDiscordAccount;
+  orderedAccountIds: string[];
+  hasExplicitAccountPath: boolean;
+}) {
+  const findings: Array<{
+    checkId: string;
+    severity: "info" | "warn" | "critical";
+    title: string;
+    detail: string;
+    remediation?: string;
+  }> = [];
+  const discordCfg = params.account.config ?? {};
+  const accountId =
+    normalizeOptionalString(params.accountId) ?? params.account.accountId ?? "default";
+  const dangerousNameMatchingEnabled = isDangerousNameMatchingEnabled(discordCfg);
+  const storeAllowFrom = await readChannelAllowFromStore("discord", process.env, accountId).catch(
+    () => [],
+  );
+  const discordNameBasedAllowEntries = new Set<string>();
+  const discordPathPrefix =
+    params.orderedAccountIds.length > 1 || params.hasExplicitAccountPath
+      ? `channels.discord.accounts.${accountId}`
+      : "channels.discord";
+
+  addDiscordNameBasedEntries({
+    target: discordNameBasedAllowEntries,
+    values: discordCfg.allowFrom,
+    source: `${discordPathPrefix}.allowFrom`,
+  });
+  addDiscordNameBasedEntries({
+    target: discordNameBasedAllowEntries,
+    values: (discordCfg.dm as { allowFrom?: unknown } | undefined)?.allowFrom,
+    source: `${discordPathPrefix}.dm.allowFrom`,
+  });
+  addDiscordNameBasedEntries({
+    target: discordNameBasedAllowEntries,
+    values: storeAllowFrom,
+    source: "~/.autobot/credentials/discord-allowFrom.json",
+  });
+
+  const guildEntries = (discordCfg.guilds as Record<string, unknown> | undefined) ?? {};
+  for (const [guildKey, guildValue] of Object.entries(guildEntries)) {
+    if (!guildValue || typeof guildValue !== "object") {
+      continue;
+    }
+    const guild = guildValue as Record<string, unknown>;
+    addDiscordNameBasedEntries({
+      target: discordNameBasedAllowEntries,
+      values: guild.users,
+      source: `${discordPathPrefix}.guilds.${guildKey}.users`,
+    });
+    const channels = guild.channels;
+    if (!channels || typeof channels !== "object") {
+      continue;
+    }
+    for (const [channelKey, channelValue] of Object.entries(channels as Record<string, unknown>)) {
+      if (!channelValue || typeof channelValue !== "object") {
+        continue;
+      }
+      const channel = channelValue as Record<string, unknown>;
+      addDiscordNameBasedEntries({
+        target: discordNameBasedAllowEntries,
+        values: channel.users,
+        source: `${discordPathPrefix}.guilds.${guildKey}.channels.${channelKey}.users`,
+      });
+    }
+  }
+
+  if (discordNameBasedAllowEntries.size > 0) {
+    const examples = Array.from(discordNameBasedAllowEntries).slice(0, 5);
+    const more =
+      discordNameBasedAllowEntries.size > examples.length
+        ? ` (+${discordNameBasedAllowEntries.size - examples.length} more)`
+        : "";
+    findings.push({
+      checkId: "channels.discord.allowFrom.name_based_entries",
+      severity: dangerousNameMatchingEnabled ? "info" : "warn",
+      title: dangerousNameMatchingEnabled
+        ? "Discord allowlist uses break-glass name/tag matching"
+        : "Discord allowlist contains name or tag entries",
+      detail: dangerousNameMatchingEnabled
+        ? "Discord name/tag allowlist matching is explicitly enabled via dangerouslyAllowNameMatching. This mutable-identity mode is operator-selected break-glass behavior and out-of-scope for vulnerability reports by itself. " +
+          `Found: ${examples.join(", ")}${more}.`
+        : "Discord name/tag allowlist matching uses normalized slugs and can collide across users. " +
+          `Found: ${examples.join(", ")}${more}.`,
+      remediation: dangerousNameMatchingEnabled
+        ? "Prefer stable Discord IDs (or <@id>/user:<id>/pk:<id>), then disable dangerouslyAllowNameMatching."
+        : "Prefer stable Discord IDs (or <@id>/user:<id>/pk:<id>) in channels.discord.allowFrom and channels.discord.guilds.*.users, or explicitly opt in with dangerouslyAllowNameMatching=true if you accept the risk.",
+    });
+  }
+
+  const nativeEnabled = resolveNativeCommandsEnabled({
+    providerId: "discord",
+    providerSetting: coerceNativeSetting(
+      (discordCfg.commands as { native?: unknown } | undefined)?.native,
+    ),
+    globalSetting: params.cfg.commands?.native,
+  });
+  const nativeSkillsEnabled = resolveNativeSkillsEnabled({
+    providerId: "discord",
+    providerSetting: coerceNativeSetting(
+      (discordCfg.commands as { nativeSkills?: unknown } | undefined)?.nativeSkills,
+    ),
+    globalSetting: params.cfg.commands?.nativeSkills,
+  });
+  if (!nativeEnabled && !nativeSkillsEnabled) {
+    return findings;
+  }
+
+  const defaultGroupPolicy = params.cfg.channels?.defaults?.groupPolicy;
+  const groupPolicy =
+    (discordCfg.groupPolicy as string | undefined) ?? defaultGroupPolicy ?? "allowlist";
+  const guildsConfigured = Object.keys(guildEntries).length > 0;
+  const hasAnyUserAllowlist = Object.values(guildEntries).some((guild) => {
+    if (!guild || typeof guild !== "object") {
+      return false;
+    }
+    const record = guild as Record<string, unknown>;
+    if (Array.isArray(record.users) && record.users.length > 0) {
+      return true;
+    }
+    const channels = record.channels;
+    if (!channels || typeof channels !== "object") {
+      return false;
+    }
+    return Object.values(channels as Record<string, unknown>).some((channel) => {
+      if (!channel || typeof channel !== "object") {
+        return false;
+      }
+      const channelRecord = channel as Record<string, unknown>;
+      return Array.isArray(channelRecord.users) && channelRecord.users.length > 0;
+    });
+  });
+  const dmAllowFromRaw = (discordCfg.dm as { allowFrom?: unknown } | undefined)?.allowFrom;
+  const dmAllowFrom = Array.isArray(dmAllowFromRaw) ? dmAllowFromRaw : [];
+  const ownerAllowFromConfigured =
+    normalizeAllowFromList([...dmAllowFrom, ...storeAllowFrom]).length > 0;
+  const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
+
+  if (!useAccessGroups && groupPolicy !== "disabled" && guildsConfigured && !hasAnyUserAllowlist) {
+    findings.push({
+      checkId: "channels.discord.commands.native.unrestricted",
+      severity: "critical",
+      title: "Discord slash commands are unrestricted",
+      detail:
+        "commands.useAccessGroups=false disables sender allowlists for Discord slash commands unless a per-guild/channel users allowlist is configured; with no users allowlist, any user in allowed guild channels can invoke /… commands.",
+      remediation:
+        "Set commands.useAccessGroups=true (recommended), or configure channels.discord.guilds.<id>.users (or channels.discord.guilds.<id>.channels.<channel>.users).",
+    });
+  } else if (
+    useAccessGroups &&
+    groupPolicy !== "disabled" &&
+    guildsConfigured &&
+    !ownerAllowFromConfigured &&
+    !hasAnyUserAllowlist
+  ) {
+    findings.push({
+      checkId: "channels.discord.commands.native.no_allowlists",
+      severity: "warn",
+      title: "Discord slash commands have no allowlists",
+      detail:
+        "Discord slash commands are enabled, but neither an owner allowFrom list nor any per-guild/channel users allowlist is configured; /… commands will be rejected for everyone.",
+      remediation:
+        "Add your user id to channels.discord.allowFrom (or approve yourself via pairing), or configure channels.discord.guilds.<id>.users.",
+    });
+  }
+
+  return findings;
+}

package/src/security-contract.ts

@@ -0,0 +1,47 @@
+import { isRecord } from "autobot/plugin-sdk/string-coerce-runtime";
+
+type UnsupportedSecretRefConfigCandidate = {
+  path: string;
+  value: unknown;
+};
+
+export const unsupportedSecretRefSurfacePatterns = [
+  "channels.discord.threadBindings.webhookToken",
+  "channels.discord.accounts.*.threadBindings.webhookToken",
+] as const;
+
+export function collectUnsupportedSecretRefConfigCandidates(
+  raw: unknown,
+): UnsupportedSecretRefConfigCandidate[] {
+  if (!isRecord(raw)) {
+    return [];
+  }
+  if (!isRecord(raw.channels) || !isRecord(raw.channels.discord)) {
+    return [];
+  }
+
+  const candidates: UnsupportedSecretRefConfigCandidate[] = [];
+  const discord = raw.channels.discord;
+  const threadBindings = isRecord(discord.threadBindings) ? discord.threadBindings : null;
+  if (threadBindings) {
+    candidates.push({
+      path: "channels.discord.threadBindings.webhookToken",
+      value: threadBindings.webhookToken,
+    });
+  }
+
+  const accounts = isRecord(discord.accounts) ? discord.accounts : null;
+  if (!accounts) {
+    return candidates;
+  }
+  for (const [accountId, account] of Object.entries(accounts)) {
+    if (!isRecord(account) || !isRecord(account.threadBindings)) {
+      continue;
+    }
+    candidates.push({
+      path: `channels.discord.accounts.${accountId}.threadBindings.webhookToken`,
+      value: account.threadBindings.webhookToken,
+    });
+  }
+  return candidates;
+}

package/src/security-doctor.ts

@@ -0,0 +1,20 @@
+export function isDiscordMutableAllowEntry(raw: string): boolean {
+  const text = raw.trim();
+  if (!text || text === "*") {
+    return false;
+  }
+
+  const maybeMentionId = text.replace(/^<@!?/, "").replace(/>$/, "");
+  if (/^\d+$/.test(maybeMentionId)) {
+    return false;
+  }
+
+  for (const prefix of ["discord:", "user:", "pk:"]) {
+    if (!text.startsWith(prefix)) {
+      continue;
+    }
+    return text.slice(prefix.length).trim().length === 0;
+  }
+
+  return true;
+}

package/src/security.ts

@@ -0,0 +1,60 @@
+import { createScopedDmSecurityResolver } from "autobot/plugin-sdk/channel-config-helpers";
+import { createOpenProviderConfiguredRouteWarningCollector } from "autobot/plugin-sdk/channel-policy";
+import {
+  resolveDiscordAccountAllowFrom,
+  resolveDiscordAccountDmPolicy,
+  type ResolvedDiscordAccount,
+} from "./accounts.js";
+import type { ChannelPlugin } from "./channel-api.js";
+
+const resolveDiscordDmPolicy = createScopedDmSecurityResolver<ResolvedDiscordAccount>({
+  channelKey: "discord",
+  resolvePolicy: (account) => account.config.dmPolicy,
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  resolveAccess: ({ cfg, account }) => ({
+    dmPolicy: resolveDiscordAccountDmPolicy({ cfg, accountId: account.accountId }),
+    allowFrom: resolveDiscordAccountAllowFrom({ cfg, accountId: account.accountId }),
+  }),
+  policyPathSuffix: "dmPolicy",
+  normalizeEntry: (raw) =>
+    raw
+      .trim()
+      .replace(/^(discord|user):/i, "")
+      .replace(/^<@!?(\d+)>$/, "$1"),
+});
+
+const collectDiscordSecurityWarnings =
+  createOpenProviderConfiguredRouteWarningCollector<ResolvedDiscordAccount>({
+    providerConfigPresent: (cfg) => cfg.channels?.discord !== undefined,
+    resolveGroupPolicy: (account) => account.config.groupPolicy,
+    resolveRouteAllowlistConfigured: (account) =>
+      Object.keys(account.config.guilds ?? {}).length > 0,
+    configureRouteAllowlist: {
+      surface: "Discord guilds",
+      openScope: "any channel not explicitly denied",
+      groupPolicyPath: "channels.discord.groupPolicy",
+      routeAllowlistPath: "channels.discord.guilds.<id>.channels",
+    },
+    missingRouteAllowlist: {
+      surface: "Discord guilds",
+      openBehavior: "with no guild/channel allowlist; any channel can trigger (mention-gated)",
+      remediation:
+        'Set channels.discord.groupPolicy="allowlist" and configure channels.discord.guilds.<id>.channels',
+    },
+  });
+
+let discordSecurityAuditModulePromise:
+  | Promise<typeof import("./security-audit.runtime.js")>
+  | undefined;
+
+async function loadDiscordSecurityAuditModule() {
+  discordSecurityAuditModulePromise ??= import("./security-audit.runtime.js");
+  return await discordSecurityAuditModulePromise;
+}
+
+export const discordSecurityAdapter = {
+  resolveDmPolicy: resolveDiscordDmPolicy,
+  collectWarnings: collectDiscordSecurityWarnings,
+  collectAuditFindings: async (params) =>
+    (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params),
+} satisfies NonNullable<ChannelPlugin<ResolvedDiscordAccount>["security"]>;

package/src/send-target-parsing.ts

@@ -0,0 +1,14 @@
+import {
+  parseDiscordTarget,
+  type DiscordTarget,
+  type DiscordTargetParseOptions,
+} from "./target-parsing.js";
+
+export type SendDiscordTarget = DiscordTarget;
+
+type SendDiscordTargetParseOptions = DiscordTargetParseOptions;
+
+export const parseDiscordSendTarget = (
+  raw: string,
+  options: SendDiscordTargetParseOptions = {},
+): SendDiscordTarget | undefined => parseDiscordTarget(raw, options);

package/src/send.channels.ts

@@ -0,0 +1,139 @@
+import type { APIChannel } from "discord-api-types/v10";
+import {
+  createGuildChannel,
+  deleteChannel,
+  deleteChannelPermission,
+  editChannel,
+  moveGuildChannels,
+  putChannelPermission,
+} from "./internal/discord.js";
+import { resolveDiscordRest } from "./send.shared.js";
+import type {
+  DiscordChannelCreate,
+  DiscordChannelEdit,
+  DiscordChannelMove,
+  DiscordChannelPermissionSet,
+  DiscordReactOpts,
+} from "./send.types.js";
+
+export async function createChannelDiscord(
+  payload: DiscordChannelCreate,
+  opts: DiscordReactOpts,
+): Promise<APIChannel> {
+  const rest = resolveDiscordRest(opts);
+  const body: Record<string, unknown> = {
+    name: payload.name,
+  };
+  if (payload.type !== undefined) {
+    body.type = payload.type;
+  }
+  if (payload.parentId) {
+    body.parent_id = payload.parentId;
+  }
+  if (payload.topic) {
+    body.topic = payload.topic;
+  }
+  if (payload.position !== undefined) {
+    body.position = payload.position;
+  }
+  if (payload.nsfw !== undefined) {
+    body.nsfw = payload.nsfw;
+  }
+  return await createGuildChannel(rest, payload.guildId, {
+    body,
+  });
+}
+
+export async function editChannelDiscord(
+  payload: DiscordChannelEdit,
+  opts: DiscordReactOpts,
+): Promise<APIChannel> {
+  const rest = resolveDiscordRest(opts);
+  const body: Record<string, unknown> = {};
+  if (payload.name !== undefined) {
+    body.name = payload.name;
+  }
+  if (payload.topic !== undefined) {
+    body.topic = payload.topic;
+  }
+  if (payload.position !== undefined) {
+    body.position = payload.position;
+  }
+  if (payload.parentId !== undefined) {
+    body.parent_id = payload.parentId;
+  }
+  if (payload.nsfw !== undefined) {
+    body.nsfw = payload.nsfw;
+  }
+  if (payload.rateLimitPerUser !== undefined) {
+    body.rate_limit_per_user = payload.rateLimitPerUser;
+  }
+  if (payload.archived !== undefined) {
+    body.archived = payload.archived;
+  }
+  if (payload.locked !== undefined) {
+    body.locked = payload.locked;
+  }
+  if (payload.autoArchiveDuration !== undefined) {
+    body.auto_archive_duration = payload.autoArchiveDuration;
+  }
+  if (payload.availableTags !== undefined) {
+    body.available_tags = payload.availableTags.map((t) => ({
+      ...(t.id !== undefined && { id: t.id }),
+      name: t.name,
+      ...(t.moderated !== undefined && { moderated: t.moderated }),
+      ...(t.emoji_id !== undefined && { emoji_id: t.emoji_id }),
+      ...(t.emoji_name !== undefined && { emoji_name: t.emoji_name }),
+    }));
+  }
+  return await editChannel(rest, payload.channelId, {
+    body,
+  });
+}
+
+export async function deleteChannelDiscord(channelId: string, opts: DiscordReactOpts) {
+  const rest = resolveDiscordRest(opts);
+  await deleteChannel(rest, channelId);
+  return { ok: true, channelId };
+}
+
+export async function moveChannelDiscord(payload: DiscordChannelMove, opts: DiscordReactOpts) {
+  const rest = resolveDiscordRest(opts);
+  const body: Array<Record<string, unknown>> = [
+    {
+      id: payload.channelId,
+      ...(payload.parentId !== undefined && { parent_id: payload.parentId }),
+      ...(payload.position !== undefined && { position: payload.position }),
+    },
+  ];
+  await moveGuildChannels(rest, payload.guildId, { body });
+  return { ok: true };
+}
+
+export async function setChannelPermissionDiscord(
+  payload: DiscordChannelPermissionSet,
+  opts: DiscordReactOpts,
+) {
+  const rest = resolveDiscordRest(opts);
+  const body: Record<string, unknown> = {
+    type: payload.targetType,
+  };
+  if (payload.allow !== undefined) {
+    body.allow = payload.allow;
+  }
+  if (payload.deny !== undefined) {
+    body.deny = payload.deny;
+  }
+  await putChannelPermission(rest, payload.channelId, payload.targetId, { body });
+  return { ok: true };
+}
+
+export async function removeChannelPermissionDiscord(
+  channelId: string,
+  targetId: string,
+  opts: DiscordReactOpts,
+) {
+  const rest = resolveDiscordRest(opts);
+  await deleteChannelPermission(rest, channelId, targetId);
+  return { ok: true };
+}