@gakr-gakr/discord 0.1.0

package/src/monitor/provider.allowlist.ts

@@ -0,0 +1,398 @@
+import {
+  addAllowlistUserEntriesFromConfigEntry,
+  buildAllowlistResolutionSummary,
+  canonicalizeAllowlistWithResolvedIds,
+  patchAllowlistUsersInConfigEntries,
+  summarizeMapping,
+} from "autobot/plugin-sdk/allow-from";
+import type { DiscordAccountConfig, DiscordGuildEntry } from "autobot/plugin-sdk/config-contracts";
+import { isDangerousNameMatchingEnabled } from "autobot/plugin-sdk/dangerous-name-runtime";
+import type { RuntimeEnv } from "autobot/plugin-sdk/runtime-env";
+import { formatErrorMessage } from "autobot/plugin-sdk/ssrf-runtime";
+import { normalizeStringEntries } from "autobot/plugin-sdk/string-coerce-runtime";
+import { resolveDiscordChannelAllowlist } from "../resolve-channels.js";
+import { resolveDiscordUserAllowlist } from "../resolve-users.js";
+
+type GuildEntries = Record<string, DiscordGuildEntry>;
+type ChannelResolutionInput = { input: string; guildKey: string; channelKey?: string };
+type DiscordChannelLogEntry = {
+  input: string;
+  guildId?: string;
+  guildName?: string;
+  channelId?: string;
+  channelName?: string;
+  note?: string;
+};
+type DiscordChannelResolvedGroup = {
+  target: string;
+  aliases: string[];
+  guildName?: string;
+  channelName?: string;
+  note?: string;
+};
+type DiscordUserLogEntry = {
+  input: string;
+  id?: string;
+  name?: string;
+  guildName?: string;
+  note?: string;
+};
+
+function formatResolutionLogDetails(base: string, details: Array<string | undefined>): string {
+  const nonEmpty = details
+    .map((value) => value?.trim())
+    .filter((value): value is string => Boolean(value));
+  return nonEmpty.length > 0 ? `${base} (${nonEmpty.join("; ")})` : base;
+}
+
+function formatResolvedBase(input: string, target: string | undefined): string {
+  if (!target) {
+    return input;
+  }
+  return input === target ? input : `${input}→${target}`;
+}
+
+function formatAliasSummary(aliases: string[]): string | undefined {
+  if (aliases.length === 0) {
+    return undefined;
+  }
+  const preview = aliases.slice(0, 3).join(", ");
+  if (aliases.length <= 3) {
+    return preview;
+  }
+  return `${preview}, +${aliases.length - 3} more`;
+}
+
+function formatDiscordChannelResolvedGroup(entry: DiscordChannelResolvedGroup): string {
+  const aliasSummary = formatAliasSummary(entry.aliases);
+  return formatResolutionLogDetails(entry.target, [
+    entry.guildName ? `guild:${entry.guildName}` : undefined,
+    entry.channelName ? `channel:${entry.channelName}` : undefined,
+    entry.note,
+    aliasSummary ? `aliases:${aliasSummary}` : undefined,
+  ]);
+}
+
+function formatDiscordChannelUnresolved(entry: DiscordChannelLogEntry): string {
+  return formatResolutionLogDetails(entry.input, [
+    entry.guildName
+      ? `guild:${entry.guildName}`
+      : entry.guildId
+        ? `guildId:${entry.guildId}`
+        : undefined,
+    entry.channelName
+      ? `channel:${entry.channelName}`
+      : entry.channelId
+        ? `channelId:${entry.channelId}`
+        : undefined,
+    entry.note,
+  ]);
+}
+
+function formatDiscordUserResolved(entry: DiscordUserLogEntry): string {
+  const displayName = entry.name?.trim();
+  const target = displayName || entry.id;
+  const base = formatResolvedBase(entry.input, target);
+  return formatResolutionLogDetails(base, [
+    displayName && entry.id ? `id:${entry.id}` : undefined,
+    entry.guildName ? `guild:${entry.guildName}` : undefined,
+    entry.note,
+  ]);
+}
+
+function formatDiscordUserUnresolved(entry: DiscordUserLogEntry): string {
+  return formatResolutionLogDetails(entry.input, [
+    entry.name ? `name:${entry.name}` : undefined,
+    entry.guildName ? `guild:${entry.guildName}` : undefined,
+    entry.note,
+  ]);
+}
+
+function toGuildEntries(value: unknown): GuildEntries {
+  if (!value || typeof value !== "object") {
+    return {};
+  }
+  const out: GuildEntries = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    out[key] = entry as DiscordGuildEntry;
+  }
+  return out;
+}
+
+function toAllowlistEntries(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  return normalizeStringEntries(value);
+}
+
+function hasGuildEntries(value: GuildEntries): boolean {
+  return Object.keys(value).length > 0;
+}
+
+function collectChannelResolutionInputs(guildEntries: GuildEntries): ChannelResolutionInput[] {
+  const entries: ChannelResolutionInput[] = [];
+  for (const [guildKey, guildCfg] of Object.entries(guildEntries)) {
+    if (guildKey === "*") {
+      continue;
+    }
+    const channels = guildCfg?.channels ?? {};
+    const channelKeys = Object.keys(channels).filter((key) => key !== "*");
+    if (channelKeys.length === 0) {
+      const input = /^\d+$/.test(guildKey) ? `guild:${guildKey}` : guildKey;
+      entries.push({ input, guildKey });
+      continue;
+    }
+    for (const channelKey of channelKeys) {
+      entries.push({
+        input: `${guildKey}/${channelKey}`,
+        guildKey,
+        channelKey,
+      });
+    }
+  }
+  return entries;
+}
+
+async function resolveGuildEntriesByChannelAllowlist(params: {
+  token: string;
+  guildEntries: GuildEntries;
+  fetcher: typeof fetch;
+  runtime: RuntimeEnv;
+}): Promise<GuildEntries> {
+  const entries = collectChannelResolutionInputs(params.guildEntries);
+  if (entries.length === 0) {
+    return params.guildEntries;
+  }
+  try {
+    const resolved = await resolveDiscordChannelAllowlist({
+      token: params.token,
+      entries: entries.map((entry) => entry.input),
+      fetcher: params.fetcher,
+    });
+    const sourceByInput = new Map(entries.map((entry) => [entry.input, entry]));
+    const nextGuilds = { ...params.guildEntries };
+    const mappingByTarget = new Map<string, DiscordChannelResolvedGroup>();
+    const unresolved: string[] = [];
+    for (const entry of resolved) {
+      const source = sourceByInput.get(entry.input);
+      if (!source) {
+        continue;
+      }
+      const sourceGuild = params.guildEntries[source.guildKey] ?? {};
+      if (!entry.resolved || !entry.guildId) {
+        unresolved.push(formatDiscordChannelUnresolved(entry));
+        continue;
+      }
+      const target = entry.channelId ? `${entry.guildId}/${entry.channelId}` : entry.guildId;
+      const existingGroup =
+        mappingByTarget.get(target) ??
+        ({
+          target,
+          aliases: [],
+          guildName: entry.guildName,
+          channelName: entry.channelName,
+          note: entry.note,
+        } satisfies DiscordChannelResolvedGroup);
+      if (entry.input !== target && !existingGroup.aliases.includes(entry.input)) {
+        existingGroup.aliases.push(entry.input);
+      }
+      if (!existingGroup.guildName && entry.guildName) {
+        existingGroup.guildName = entry.guildName;
+      }
+      if (!existingGroup.channelName && entry.channelName) {
+        existingGroup.channelName = entry.channelName;
+      }
+      if (!existingGroup.note && entry.note) {
+        existingGroup.note = entry.note;
+      }
+      mappingByTarget.set(target, existingGroup);
+      const existing = nextGuilds[entry.guildId] ?? {};
+      const mergedChannels = {
+        ...sourceGuild.channels,
+        ...existing.channels,
+      };
+      const mergedGuild: DiscordGuildEntry = {
+        ...sourceGuild,
+        ...existing,
+        channels: mergedChannels,
+      };
+      nextGuilds[entry.guildId] = mergedGuild;
+
+      if (source.channelKey && entry.channelId) {
+        const sourceChannel = sourceGuild.channels?.[source.channelKey];
+        if (sourceChannel) {
+          nextGuilds[entry.guildId] = {
+            ...mergedGuild,
+            channels: {
+              ...mergedChannels,
+              [entry.channelId]: {
+                ...sourceChannel,
+                ...mergedChannels[entry.channelId],
+              },
+            },
+          };
+        }
+      }
+    }
+    const mapping = [...mappingByTarget.values()].map((group) =>
+      formatDiscordChannelResolvedGroup(group),
+    );
+    summarizeMapping("discord channels", mapping, unresolved, params.runtime);
+    return nextGuilds;
+  } catch (err) {
+    params.runtime.log?.(
+      `discord channel resolve failed; using config entries. ${formatErrorMessage(err)}`,
+    );
+    return params.guildEntries;
+  }
+}
+
+async function resolveAllowFromByUserAllowlist(params: {
+  token: string;
+  allowFrom: string[] | undefined;
+  fetcher: typeof fetch;
+  runtime: RuntimeEnv;
+}): Promise<string[] | undefined> {
+  const allowEntries = normalizeStringEntries(params.allowFrom).filter((entry) => entry !== "*");
+  if (allowEntries.length === 0) {
+    return params.allowFrom;
+  }
+  try {
+    const resolvedUsers = await resolveDiscordUserAllowlist({
+      token: params.token,
+      entries: allowEntries,
+      fetcher: params.fetcher,
+    });
+    const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers, {
+      formatResolved: formatDiscordUserResolved,
+      formatUnresolved: formatDiscordUserUnresolved,
+    });
+    const allowFrom = canonicalizeAllowlistWithResolvedIds({
+      existing: params.allowFrom,
+      resolvedMap,
+    });
+    summarizeMapping("discord users", mapping, unresolved, params.runtime);
+    return allowFrom;
+  } catch (err) {
+    params.runtime.log?.(
+      `discord user resolve failed; using config entries. ${formatErrorMessage(err)}`,
+    );
+    return params.allowFrom;
+  }
+}
+
+function collectGuildUserEntries(guildEntries: GuildEntries): Set<string> {
+  const userEntries = new Set<string>();
+  for (const guild of Object.values(guildEntries)) {
+    if (!guild || typeof guild !== "object") {
+      continue;
+    }
+    addAllowlistUserEntriesFromConfigEntry(userEntries, guild);
+    const channels = (guild as { channels?: Record<string, unknown> }).channels ?? {};
+    for (const channel of Object.values(channels)) {
+      addAllowlistUserEntriesFromConfigEntry(userEntries, channel);
+    }
+  }
+  return userEntries;
+}
+
+async function resolveGuildEntriesByUserAllowlist(params: {
+  token: string;
+  guildEntries: GuildEntries;
+  fetcher: typeof fetch;
+  runtime: RuntimeEnv;
+}): Promise<GuildEntries> {
+  const userEntries = collectGuildUserEntries(params.guildEntries);
+  if (userEntries.size === 0) {
+    return params.guildEntries;
+  }
+  try {
+    const resolvedUsers = await resolveDiscordUserAllowlist({
+      token: params.token,
+      entries: Array.from(userEntries),
+      fetcher: params.fetcher,
+    });
+    const { resolvedMap, mapping, unresolved } = buildAllowlistResolutionSummary(resolvedUsers, {
+      formatResolved: formatDiscordUserResolved,
+      formatUnresolved: formatDiscordUserUnresolved,
+    });
+    const nextGuilds = { ...params.guildEntries };
+    for (const [guildKey, guildConfig] of Object.entries(params.guildEntries)) {
+      if (!guildConfig || typeof guildConfig !== "object") {
+        continue;
+      }
+      const nextGuild = { ...guildConfig } as Record<string, unknown>;
+      const users = (guildConfig as { users?: string[] }).users;
+      if (Array.isArray(users) && users.length > 0) {
+        nextGuild.users = canonicalizeAllowlistWithResolvedIds({
+          existing: users,
+          resolvedMap,
+        });
+      }
+      const channels = (guildConfig as { channels?: Record<string, unknown> }).channels ?? {};
+      if (channels && typeof channels === "object") {
+        nextGuild.channels = patchAllowlistUsersInConfigEntries({
+          entries: channels,
+          resolvedMap,
+          strategy: "canonicalize",
+        });
+      }
+      nextGuilds[guildKey] = nextGuild as DiscordGuildEntry;
+    }
+    summarizeMapping("discord channel users", mapping, unresolved, params.runtime);
+    return nextGuilds;
+  } catch (err) {
+    params.runtime.log?.(
+      `discord channel user resolve failed; using config entries. ${formatErrorMessage(err)}`,
+    );
+    return params.guildEntries;
+  }
+}
+
+export async function resolveDiscordAllowlistConfig(params: {
+  token: string;
+  guildEntries: unknown;
+  allowFrom: unknown;
+  discordConfig: DiscordAccountConfig;
+  fetcher: typeof fetch;
+  runtime: RuntimeEnv;
+}): Promise<{ guildEntries: GuildEntries | undefined; allowFrom: string[] | undefined }> {
+  let guildEntries = toGuildEntries(params.guildEntries);
+  let allowFrom = toAllowlistEntries(params.allowFrom);
+
+  if (hasGuildEntries(guildEntries)) {
+    guildEntries = await resolveGuildEntriesByChannelAllowlist({
+      token: params.token,
+      guildEntries,
+      fetcher: params.fetcher,
+      runtime: params.runtime,
+    });
+  }
+
+  if (isDangerousNameMatchingEnabled(params.discordConfig)) {
+    allowFrom = await resolveAllowFromByUserAllowlist({
+      token: params.token,
+      allowFrom,
+      fetcher: params.fetcher,
+      runtime: params.runtime,
+    });
+
+    if (hasGuildEntries(guildEntries)) {
+      guildEntries = await resolveGuildEntriesByUserAllowlist({
+        token: params.token,
+        guildEntries,
+        fetcher: params.fetcher,
+        runtime: params.runtime,
+      });
+    }
+  }
+
+  return {
+    guildEntries: hasGuildEntries(guildEntries) ? guildEntries : undefined,
+    allowFrom,
+  };
+}

package/src/monitor/provider.cleanup.ts

@@ -0,0 +1,41 @@
+import { danger, type RuntimeEnv } from "autobot/plugin-sdk/runtime-env";
+import type { MutableDiscordGateway } from "./gateway-handle.js";
+import type { DiscordMonitorStatusSink } from "./status.js";
+import type { ThreadBindingManager } from "./thread-bindings.js";
+
+type EventEmitterLike = {
+  removeListener(event: string, listener: (...args: unknown[]) => void): unknown;
+};
+
+export function cleanupDiscordProviderStartup(params: {
+  deactivateMessageHandler?: () => void;
+  autoPresenceController?: { stop: () => void } | null;
+  setStatus?: DiscordMonitorStatusSink;
+  onEarlyGatewayDebug?: ((msg: unknown) => void) | undefined;
+  earlyGatewayEmitter?: EventEmitterLike | undefined;
+  lifecycleStarted: boolean;
+  lifecycleGateway?: MutableDiscordGateway;
+  gatewaySupervisor?: { dispose: () => void };
+  threadBindings: ThreadBindingManager;
+  runtime: RuntimeEnv;
+}) {
+  params.deactivateMessageHandler?.();
+  params.autoPresenceController?.stop();
+  params.setStatus?.({ connected: false });
+  if (params.onEarlyGatewayDebug) {
+    params.earlyGatewayEmitter?.removeListener("debug", params.onEarlyGatewayDebug);
+  }
+  if (!params.lifecycleStarted) {
+    try {
+      params.lifecycleGateway?.disconnect();
+    } catch (err) {
+      params.runtime.error?.(
+        danger(`discord: failed to disconnect gateway during startup cleanup: ${String(err)}`),
+      );
+    }
+  }
+  params.gatewaySupervisor?.dispose();
+  if (!params.lifecycleStarted) {
+    params.threadBindings.stop();
+  }
+}

package/src/monitor/provider.commands.ts

@@ -0,0 +1,129 @@
+import {
+  listNativeCommandSpecsForConfig,
+  listSkillCommandsForAgents,
+  type NativeCommandSpec,
+} from "autobot/plugin-sdk/command-auth-native";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { danger, warn, type RuntimeEnv } from "autobot/plugin-sdk/runtime-env";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+export type GetPluginCommandSpecs =
+  typeof import("autobot/plugin-sdk/plugin-runtime").getPluginCommandSpecs;
+
+let pluginRuntimePromise: Promise<typeof import("autobot/plugin-sdk/plugin-runtime")> | undefined;
+
+async function loadPluginRuntime() {
+  const promise = pluginRuntimePromise ?? import("autobot/plugin-sdk/plugin-runtime");
+  pluginRuntimePromise = promise;
+  try {
+    return await promise;
+  } catch (error) {
+    if (pluginRuntimePromise === promise) {
+      pluginRuntimePromise = undefined;
+    }
+    throw error;
+  }
+}
+
+async function appendPluginCommandSpecs(params: {
+  commandSpecs: NativeCommandSpec[];
+  runtime: RuntimeEnv;
+  cfg: AutoBotConfig;
+  getPluginCommandSpecs?: GetPluginCommandSpecs;
+}): Promise<NativeCommandSpec[]> {
+  const merged = [...params.commandSpecs];
+  const existingNames = new Set(
+    merged.map((spec) => normalizeLowercaseStringOrEmpty(spec.name)).filter(Boolean),
+  );
+  const getPluginCommandSpecs =
+    params.getPluginCommandSpecs ?? (await loadPluginRuntime()).getPluginCommandSpecs;
+  for (const pluginCommand of getPluginCommandSpecs("discord", { config: params.cfg })) {
+    const normalizedName = normalizeLowercaseStringOrEmpty(pluginCommand.name);
+    if (!normalizedName) {
+      continue;
+    }
+    if (existingNames.has(normalizedName)) {
+      params.runtime.error?.(
+        danger(
+          `discord: plugin command "/${normalizedName}" duplicates an existing native command. Skipping.`,
+        ),
+      );
+      continue;
+    }
+    existingNames.add(normalizedName);
+    merged.push({
+      name: pluginCommand.name,
+      description: pluginCommand.description,
+      acceptsArgs: pluginCommand.acceptsArgs,
+    });
+  }
+  return merged;
+}
+
+export async function resolveDiscordProviderCommandSpecs(params: {
+  cfg: AutoBotConfig;
+  runtime: RuntimeEnv;
+  nativeEnabled: boolean;
+  nativeSkillsEnabled: boolean;
+  maxDiscordCommands?: number;
+  listSkillCommandsForAgents?: typeof listSkillCommandsForAgents;
+  listNativeCommandSpecsForConfig?: typeof listNativeCommandSpecsForConfig;
+  getPluginCommandSpecs?: GetPluginCommandSpecs;
+}): Promise<{
+  skillCommands: ReturnType<typeof listSkillCommandsForAgents>;
+  commandSpecs: NativeCommandSpec[];
+}> {
+  const listSkillCommands = params.listSkillCommandsForAgents ?? listSkillCommandsForAgents;
+  const listNativeCommandSpecs =
+    params.listNativeCommandSpecsForConfig ?? listNativeCommandSpecsForConfig;
+  const maxDiscordCommands = params.maxDiscordCommands ?? 100;
+  let skillCommands =
+    params.nativeEnabled && params.nativeSkillsEnabled
+      ? listSkillCommands({ cfg: params.cfg })
+      : [];
+  let commandSpecs = params.nativeEnabled
+    ? listNativeCommandSpecs(params.cfg, {
+        skillCommands,
+        provider: "discord",
+      })
+    : [];
+  if (params.nativeEnabled) {
+    commandSpecs = await appendPluginCommandSpecs({
+      commandSpecs,
+      runtime: params.runtime,
+      cfg: params.cfg,
+      getPluginCommandSpecs: params.getPluginCommandSpecs,
+    });
+  }
+  const initialCommandCount = commandSpecs.length;
+  if (
+    params.nativeEnabled &&
+    params.nativeSkillsEnabled &&
+    commandSpecs.length > maxDiscordCommands
+  ) {
+    skillCommands = [];
+    commandSpecs = listNativeCommandSpecs(params.cfg, {
+      skillCommands: [],
+      provider: "discord",
+    });
+    commandSpecs = await appendPluginCommandSpecs({
+      commandSpecs,
+      runtime: params.runtime,
+      cfg: params.cfg,
+      getPluginCommandSpecs: params.getPluginCommandSpecs,
+    });
+    params.runtime.log?.(
+      warn(
+        `discord: ${initialCommandCount} commands exceeds limit; removing per-skill commands and keeping /skill.`,
+      ),
+    );
+  }
+  if (params.nativeEnabled && commandSpecs.length > maxDiscordCommands) {
+    params.runtime.log?.(
+      warn(
+        `discord: ${commandSpecs.length} commands exceeds limit; some commands may fail to deploy.`,
+      ),
+    );
+  }
+  return { skillCommands, commandSpecs };
+}

package/src/monitor/provider.config-log.ts

@@ -0,0 +1,45 @@
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { summarizeStringEntries } from "autobot/plugin-sdk/string-coerce-runtime";
+import { formatThreadBindingDurationLabel } from "./thread-bindings.messages.js";
+
+function formatThreadBindingDurationForConfigLabel(durationMs: number): string {
+  const label = formatThreadBindingDurationLabel(durationMs);
+  return label === "disabled" ? "off" : label;
+}
+
+export function logDiscordResolvedConfig(params: {
+  dmEnabled: boolean;
+  dmPolicy: string;
+  allowFrom?: string[];
+  groupDmEnabled: boolean;
+  groupDmChannels?: string[];
+  groupPolicy: string;
+  guildEntries?: Record<string, unknown>;
+  historyLimit: number;
+  mediaMaxBytes: number;
+  nativeEnabled: boolean;
+  nativeSkillsEnabled: boolean;
+  useAccessGroups: boolean;
+  threadBindingsEnabled: boolean;
+  threadBindingIdleTimeoutMs: number;
+  threadBindingMaxAgeMs: number;
+}): void {
+  const allowFromSummary = summarizeStringEntries({
+    entries: params.allowFrom ?? [],
+    limit: 4,
+    emptyText: "any",
+  });
+  const groupDmChannelSummary = summarizeStringEntries({
+    entries: params.groupDmChannels ?? [],
+    limit: 4,
+    emptyText: "any",
+  });
+  const guildSummary = summarizeStringEntries({
+    entries: Object.keys(params.guildEntries ?? {}),
+    limit: 4,
+    emptyText: "any",
+  });
+  logVerbose(
+    `discord: config dm=${params.dmEnabled ? "on" : "off"} dmPolicy=${params.dmPolicy} allowFrom=${allowFromSummary} groupDm=${params.groupDmEnabled ? "on" : "off"} groupDmChannels=${groupDmChannelSummary} groupPolicy=${params.groupPolicy} guilds=${guildSummary} historyLimit=${params.historyLimit} mediaMaxMb=${Math.round(params.mediaMaxBytes / (1024 * 1024))} native=${params.nativeEnabled ? "on" : "off"} nativeSkills=${params.nativeSkillsEnabled ? "on" : "off"} accessGroups=${params.useAccessGroups ? "on" : "off"} threadBindings=${params.threadBindingsEnabled ? "on" : "off"} threadIdleTimeout=${formatThreadBindingDurationForConfigLabel(params.threadBindingIdleTimeoutMs)} threadMaxAge=${formatThreadBindingDurationForConfigLabel(params.threadBindingMaxAgeMs)}`,
+  );
+}