@gakr-gakr/discord 0.1.0

package/src/proxy-fetch.ts

@@ -0,0 +1,92 @@
+import { isIP } from "node:net";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { makeProxyFetch } from "autobot/plugin-sdk/fetch-runtime";
+import { danger } from "autobot/plugin-sdk/runtime-env";
+import type { RuntimeEnv } from "autobot/plugin-sdk/runtime-env";
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { ResolvedDiscordAccount } from "./accounts.js";
+
+function resolveDiscordProxyUrl(
+  account: Pick<ResolvedDiscordAccount, "config">,
+  cfg: AutoBotConfig,
+): string | undefined {
+  const accountProxy = account.config.proxy?.trim();
+  if (accountProxy) {
+    return accountProxy;
+  }
+  const channelProxy = cfg?.channels?.discord?.proxy;
+  if (typeof channelProxy !== "string") {
+    return undefined;
+  }
+  const trimmed = channelProxy.trim();
+  return trimmed || undefined;
+}
+
+function resolveDiscordProxyFetchByUrl(
+  proxyUrl: string | undefined,
+  runtime?: Pick<RuntimeEnv, "error">,
+): typeof fetch | undefined {
+  return withValidatedDiscordProxy(proxyUrl, runtime, (proxy) => makeProxyFetch(proxy));
+}
+
+export function resolveDiscordProxyFetchForAccount(
+  account: Pick<ResolvedDiscordAccount, "config">,
+  cfg: AutoBotConfig,
+  runtime?: Pick<RuntimeEnv, "error">,
+): typeof fetch | undefined {
+  return resolveDiscordProxyFetchByUrl(resolveDiscordProxyUrl(account, cfg), runtime);
+}
+
+export function withValidatedDiscordProxy<T>(
+  proxyUrl: string | undefined,
+  runtime: Pick<RuntimeEnv, "error"> | undefined,
+  createValue: (proxyUrl: string) => T,
+): T | undefined {
+  const proxy = proxyUrl?.trim();
+  if (!proxy) {
+    return undefined;
+  }
+  try {
+    validateDiscordProxyUrl(proxy);
+    return createValue(proxy);
+  } catch (err) {
+    runtime?.error?.(danger(`discord: invalid rest proxy: ${String(err)}`));
+    return undefined;
+  }
+}
+
+export function validateDiscordProxyUrl(proxyUrl: string): string {
+  let parsed: URL;
+  try {
+    parsed = new URL(proxyUrl);
+  } catch {
+    throw new Error("Proxy URL must be a valid http or https URL");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new Error("Proxy URL must use http or https");
+  }
+  if (!isLoopbackProxyHostname(parsed.hostname)) {
+    throw new Error("Proxy URL must target a loopback host");
+  }
+  return proxyUrl;
+}
+
+function isLoopbackProxyHostname(hostname: string): boolean {
+  const normalized = normalizeLowercaseStringOrEmpty(hostname);
+  if (!normalized) {
+    return false;
+  }
+  const bracketless =
+    normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
+  if (bracketless === "localhost") {
+    return true;
+  }
+  const ipFamily = isIP(bracketless);
+  if (ipFamily === 4) {
+    return bracketless.startsWith("127.");
+  }
+  if (ipFamily === 6) {
+    return bracketless === "::1" || bracketless === "0:0:0:0:0:0:0:1";
+  }
+  return false;
+}

package/src/proxy-request-client.ts

@@ -0,0 +1,21 @@
+import { RequestClient, type RequestClientOptions } from "./internal/discord.js";
+
+type ProxyRequestClientOptions = RequestClientOptions;
+
+export const DISCORD_REST_TIMEOUT_MS = 15_000;
+
+export function createDiscordRequestClient(
+  token: string,
+  options?: ProxyRequestClientOptions,
+): RequestClient {
+  if (!options?.fetch) {
+    return new RequestClient(token, options);
+  }
+  return new RequestClient(token, {
+    runtimeProfile: "persistent",
+    maxQueueSize: 1000,
+    timeout: DISCORD_REST_TIMEOUT_MS,
+    ...options,
+    fetch: options.fetch,
+  });
+}

package/src/recipient-resolution.ts

@@ -0,0 +1,39 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { requireRuntimeConfig } from "autobot/plugin-sdk/plugin-config-runtime";
+import { resolveDiscordAccount } from "./accounts.js";
+import { parseAndResolveDiscordTarget } from "./target-resolver.js";
+import type { DiscordTargetParseOptions } from "./targets.js";
+
+type DiscordRecipient =
+  | {
+      kind: "user";
+      id: string;
+    }
+  | {
+      kind: "channel";
+      id: string;
+    };
+
+export async function parseAndResolveRecipient(
+  raw: string,
+  cfg: AutoBotConfig,
+  accountId?: string,
+  parseOptions: DiscordTargetParseOptions = {},
+): Promise<DiscordRecipient> {
+  if (!cfg) {
+    throw new Error(
+      "Discord recipient resolution requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.",
+    );
+  }
+  const resolvedCfg = requireRuntimeConfig(cfg, "Discord recipient resolution");
+  const accountInfo = resolveDiscordAccount({ cfg: resolvedCfg, accountId });
+  const resolved = await parseAndResolveDiscordTarget(
+    raw,
+    {
+      cfg: resolvedCfg,
+      accountId: accountInfo.accountId,
+    },
+    parseOptions,
+  );
+  return { kind: resolved.kind, id: resolved.id };
+}

package/src/resolve-allowlist-common.ts

@@ -0,0 +1,39 @@
+import type { DiscordGuildSummary } from "./guilds.js";
+import { normalizeDiscordSlug } from "./monitor/allow-list.js";
+import { normalizeDiscordToken } from "./token.js";
+
+export function resolveDiscordAllowlistToken(token: string): string | undefined {
+  return normalizeDiscordToken(token, "channels.discord.token");
+}
+
+export function buildDiscordUnresolvedResults<T extends { input: string; resolved: boolean }>(
+  entries: string[],
+  buildResult: (input: string) => T,
+): T[] {
+  return entries.map((input) => buildResult(input));
+}
+
+export function findDiscordGuildByName(
+  guilds: DiscordGuildSummary[],
+  input: string,
+): DiscordGuildSummary | undefined {
+  const slug = normalizeDiscordSlug(input);
+  if (!slug) {
+    return undefined;
+  }
+  return guilds.find((guild) => guild.slug === slug);
+}
+
+export function filterDiscordGuilds(
+  guilds: DiscordGuildSummary[],
+  params: { guildId?: string; guildName?: string },
+): DiscordGuildSummary[] {
+  if (params.guildId) {
+    return guilds.filter((guild) => guild.id === params.guildId);
+  }
+  if (params.guildName) {
+    const match = findDiscordGuildByName(guilds, params.guildName);
+    return match ? [match] : [];
+  }
+  return guilds;
+}

package/src/resolve-channels.ts

@@ -0,0 +1,369 @@
+import { DiscordApiError, fetchDiscord } from "./api.js";
+import { listGuilds } from "./guilds.js";
+import { normalizeDiscordSlug } from "./monitor/allow-list.js";
+import {
+  buildDiscordUnresolvedResults,
+  filterDiscordGuilds,
+  resolveDiscordAllowlistToken,
+} from "./resolve-allowlist-common.js";
+
+type DiscordChannelSummary = {
+  id: string;
+  name: string;
+  guildId: string;
+  type?: number;
+  archived?: boolean;
+};
+
+type DiscordChannelPayload = {
+  id?: string;
+  name?: string;
+  type?: number;
+  guild_id?: string;
+  thread_metadata?: { archived?: boolean };
+};
+
+export type DiscordChannelResolution = {
+  input: string;
+  resolved: boolean;
+  guildId?: string;
+  guildName?: string;
+  channelId?: string;
+  channelName?: string;
+  archived?: boolean;
+  note?: string;
+};
+
+function parseDiscordChannelInput(raw: string): {
+  guild?: string;
+  channel?: string;
+  channelId?: string;
+  guildId?: string;
+  guildOnly?: boolean;
+} {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const mention = trimmed.match(/^<#(\d+)>$/);
+  if (mention) {
+    return { channelId: mention[1] };
+  }
+  const channelPrefix = trimmed.match(/^(?:channel:|discord:)?(\d+)$/i);
+  if (channelPrefix) {
+    return { channelId: channelPrefix[1] };
+  }
+  const guildPrefix = trimmed.match(/^(?:guild:|server:)?(\d+)$/i);
+  if (guildPrefix && !trimmed.includes("/") && !trimmed.includes("#")) {
+    return { guildId: guildPrefix[1], guildOnly: true };
+  }
+  const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
+  if (split.length >= 2) {
+    const guild = split[0]?.trim();
+    const channel = split.slice(1).join("#").trim();
+    if (!channel) {
+      return guild ? { guild: guild.trim(), guildOnly: true } : {};
+    }
+    if (guild && /^\d+$/.test(guild)) {
+      if (/^\d+$/.test(channel)) {
+        return { guildId: guild, channelId: channel };
+      }
+      return { guildId: guild, channel };
+    }
+    return { guild, channel };
+  }
+  return { guild: trimmed, guildOnly: true };
+}
+
+async function listGuildChannels(
+  token: string,
+  fetcher: typeof fetch,
+  guildId: string,
+): Promise<DiscordChannelSummary[]> {
+  const raw = await fetchDiscord<DiscordChannelPayload[]>(
+    `/guilds/${guildId}/channels`,
+    token,
+    fetcher,
+  );
+  return raw
+    .map((channel) => {
+      const archived = channel.thread_metadata?.archived;
+      return {
+        id: typeof channel.id === "string" ? channel.id : "",
+        name: typeof channel.name === "string" ? channel.name : "",
+        guildId,
+        type: channel.type,
+        archived,
+      };
+    })
+    .filter((channel) => Boolean(channel.id) && Boolean(channel.name));
+}
+
+type FetchChannelResult =
+  | { status: "found"; channel: DiscordChannelSummary }
+  | { status: "not-found" }
+  | { status: "forbidden" }
+  | { status: "invalid" };
+
+async function fetchChannel(
+  token: string,
+  fetcher: typeof fetch,
+  channelId: string,
+): Promise<FetchChannelResult> {
+  let raw: DiscordChannelPayload;
+  try {
+    raw = await fetchDiscord<DiscordChannelPayload>(`/channels/${channelId}`, token, fetcher);
+  } catch (err) {
+    if (err instanceof DiscordApiError && err.status === 403) {
+      return { status: "forbidden" };
+    }
+    if (err instanceof DiscordApiError && err.status === 404) {
+      return { status: "not-found" };
+    }
+    throw err;
+  }
+  if (!raw || typeof raw.guild_id !== "string" || typeof raw.id !== "string") {
+    return { status: "invalid" };
+  }
+  return {
+    status: "found",
+    channel: {
+      id: raw.id,
+      name: typeof raw.name === "string" ? raw.name : "",
+      guildId: raw.guild_id,
+      type: raw.type,
+    },
+  };
+}
+
+function preferActiveMatch(candidates: DiscordChannelSummary[]): DiscordChannelSummary | undefined {
+  if (candidates.length === 0) {
+    return undefined;
+  }
+  const scored = candidates.map((channel) => {
+    const isThread = channel.type === 11 || channel.type === 12;
+    const archived = Boolean(channel.archived);
+    const score = (archived ? 0 : 2) + (isThread ? 0 : 1);
+    return { channel, score };
+  });
+  scored.sort((a, b) => b.score - a.score);
+  return scored[0]?.channel ?? candidates[0];
+}
+
+export async function resolveDiscordChannelAllowlist(params: {
+  token: string;
+  entries: string[];
+  fetcher?: typeof fetch;
+}): Promise<DiscordChannelResolution[]> {
+  const token = resolveDiscordAllowlistToken(params.token);
+  if (!token) {
+    return buildDiscordUnresolvedResults(params.entries, (input) => ({
+      input,
+      resolved: false,
+    }));
+  }
+  const fetcher = params.fetcher ?? fetch;
+  const guilds = await listGuilds(token, fetcher);
+  const channelsByGuild = new Map<string, Promise<DiscordChannelSummary[]>>();
+  const getChannels = (guildId: string) => {
+    const existing = channelsByGuild.get(guildId);
+    if (existing) {
+      return existing;
+    }
+    const promise = listGuildChannels(token, fetcher, guildId);
+    channelsByGuild.set(guildId, promise);
+    return promise;
+  };
+
+  const results: DiscordChannelResolution[] = [];
+
+  for (const input of params.entries) {
+    const parsed = parseDiscordChannelInput(input);
+    if (parsed.guildOnly) {
+      const guild = filterDiscordGuilds(guilds, {
+        guildId: parsed.guildId,
+        guildName: parsed.guild,
+      })[0];
+      if (guild) {
+        results.push({
+          input,
+          resolved: true,
+          guildId: guild.id,
+          guildName: guild.name,
+        });
+      } else {
+        results.push({
+          input,
+          resolved: false,
+          guildId: parsed.guildId,
+          guildName: parsed.guild,
+        });
+      }
+      continue;
+    }
+
+    if (parsed.channelId) {
+      const channelId = parsed.channelId;
+      const result = await fetchChannel(token, fetcher, channelId);
+      if (result.status === "found") {
+        const channel = result.channel;
+        if (parsed.guildId && parsed.guildId !== channel.guildId) {
+          const expectedGuild = guilds.find((entry) => entry.id === parsed.guildId);
+          const actualGuild = guilds.find((entry) => entry.id === channel.guildId);
+          results.push({
+            input,
+            resolved: false,
+            guildId: parsed.guildId,
+            guildName: expectedGuild?.name,
+            channelId,
+            channelName: channel.name,
+            note: actualGuild?.name
+              ? `channel belongs to guild ${actualGuild.name}`
+              : "channel belongs to a different guild",
+          });
+          continue;
+        }
+        const guild = guilds.find((entry) => entry.id === channel.guildId);
+        results.push({
+          input,
+          resolved: true,
+          guildId: channel.guildId,
+          guildName: guild?.name,
+          channelId: channel.id,
+          channelName: channel.name,
+          archived: channel.archived,
+        });
+        continue;
+      }
+
+      if (result.status === "not-found" && parsed.guildId) {
+        const guild = guilds.find((entry) => entry.id === parsed.guildId);
+        if (guild) {
+          const channels = await getChannels(guild.id);
+          const matches = channels.filter(
+            (channel) => normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelId),
+          );
+          const match = preferActiveMatch(matches);
+          if (match) {
+            results.push({
+              input,
+              resolved: true,
+              guildId: guild.id,
+              guildName: guild.name,
+              channelId: match.id,
+              channelName: match.name,
+              archived: match.archived,
+            });
+            continue;
+          }
+        }
+      }
+
+      results.push({
+        input,
+        resolved: false,
+        guildId: parsed.guildId,
+        channelId,
+      });
+      continue;
+    }
+
+    if (parsed.guildId || parsed.guild) {
+      const guild = filterDiscordGuilds(guilds, {
+        guildId: parsed.guildId,
+        guildName: parsed.guild,
+      })[0];
+      const channelQuery = parsed.channel?.trim();
+      if (!guild || !channelQuery) {
+        results.push({
+          input,
+          resolved: false,
+          guildId: parsed.guildId,
+          guildName: parsed.guild,
+          channelName: channelQuery ?? parsed.channel,
+        });
+        continue;
+      }
+      const channels = await getChannels(guild.id);
+      const normalizedChannelQuery = normalizeDiscordSlug(channelQuery);
+      const isNumericId = /^\d+$/.test(channelQuery);
+      let matches = channels.filter((channel) =>
+        isNumericId
+          ? channel.id === channelQuery
+          : normalizeDiscordSlug(channel.name) === normalizedChannelQuery,
+      );
+      if (isNumericId && matches.length === 0) {
+        matches = channels.filter(
+          (channel) => normalizeDiscordSlug(channel.name) === normalizedChannelQuery,
+        );
+      }
+      const match = preferActiveMatch(matches);
+      if (match) {
+        results.push({
+          input,
+          resolved: true,
+          guildId: guild.id,
+          guildName: guild.name,
+          channelId: match.id,
+          channelName: match.name,
+          archived: match.archived,
+        });
+      } else {
+        results.push({
+          input,
+          resolved: false,
+          guildId: guild.id,
+          guildName: guild.name,
+          channelName: parsed.channel,
+          note: `channel not found in guild ${guild.name}`,
+        });
+      }
+      continue;
+    }
+
+    const channelName = input.trim().replace(/^#/, "");
+    if (!channelName) {
+      results.push({
+        input,
+        resolved: false,
+        channelName: channelName,
+      });
+      continue;
+    }
+    const candidates: DiscordChannelSummary[] = [];
+    for (const guild of guilds) {
+      const channels = await getChannels(guild.id);
+      for (const channel of channels) {
+        if (normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelName)) {
+          candidates.push(channel);
+        }
+      }
+    }
+    const match = preferActiveMatch(candidates);
+    if (match) {
+      const guild = guilds.find((entry) => entry.id === match.guildId);
+      results.push({
+        input,
+        resolved: true,
+        guildId: match.guildId,
+        guildName: guild?.name,
+        channelId: match.id,
+        channelName: match.name,
+        archived: match.archived,
+        note:
+          candidates.length > 1 && guild?.name
+            ? `matched multiple; chose ${guild.name}`
+            : undefined,
+      });
+      continue;
+    }
+
+    results.push({
+      input,
+      resolved: false,
+      channelName: channelName,
+    });
+  }
+
+  return results;
+}