@gakr-gakr/discord 0.1.0

package/src/approval-native.ts

@@ -0,0 +1,219 @@
+import { createLazyChannelApprovalNativeRuntimeAdapter } from "autobot/plugin-sdk/approval-handler-adapter-runtime";
+import type { ChannelApprovalNativeRuntimeAdapter } from "autobot/plugin-sdk/approval-handler-runtime";
+import { resolveApprovalRequestSessionConversation } from "autobot/plugin-sdk/approval-native-runtime";
+import type { ChannelApprovalCapability } from "autobot/plugin-sdk/channel-contract";
+import type { DiscordExecApprovalConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  normalizeLowercaseStringOrEmpty,
+  normalizeOptionalString,
+} from "autobot/plugin-sdk/string-coerce-runtime";
+export { shouldHandleDiscordApprovalRequest } from "./approval-shared.js";
+import { listDiscordAccountIds, resolveDiscordAccount } from "./accounts.js";
+import {
+  createChannelApproverDmTargetResolver,
+  createChannelNativeOriginTargetResolver,
+  createApproverRestrictedNativeApprovalCapability,
+  splitChannelApprovalCapability,
+} from "./approval-runtime.js";
+import { shouldHandleDiscordApprovalRequest } from "./approval-shared.js";
+import {
+  getDiscordExecApprovalApprovers,
+  isDiscordExecApprovalApprover,
+  isDiscordExecApprovalClientEnabled,
+} from "./exec-approvals.js";
+
+// Legacy export kept for monitor test/support surfaces; native routing now uses
+// the shared session-conversation fallback helper instead.
+export function extractDiscordChannelId(sessionKey?: string | null): string | null {
+  if (!sessionKey) {
+    return null;
+  }
+  const match = sessionKey.match(/discord:(?:channel|group):(\d+)/);
+  return match ? match[1] : null;
+}
+
+function extractDiscordSessionKind(sessionKey?: string | null): "channel" | "group" | "dm" | null {
+  if (!sessionKey) {
+    return null;
+  }
+  const match = sessionKey.match(/discord:(channel|group|dm):/);
+  if (!match) {
+    return null;
+  }
+  return match[1] as "channel" | "group" | "dm";
+}
+
+function normalizeDiscordOriginChannelId(value?: string | null): string | null {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const prefixed = trimmed.match(/^(?:channel|group):(\d+)$/i);
+  if (prefixed) {
+    return prefixed[1];
+  }
+  return /^\d+$/.test(trimmed) ? trimmed : null;
+}
+
+function normalizeDiscordThreadId(value?: string | number | null): string | undefined {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : undefined;
+  }
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const normalized = value.trim();
+  return /^\d+$/.test(normalized) ? normalized : undefined;
+}
+
+function createDiscordOriginTargetResolver(configOverride?: DiscordExecApprovalConfig | null) {
+  return createChannelNativeOriginTargetResolver({
+    channel: "discord",
+    shouldHandleRequest: ({ cfg, accountId, request }) =>
+      shouldHandleDiscordApprovalRequest({
+        cfg,
+        accountId,
+        request,
+        configOverride,
+      }),
+    resolveTurnSourceTarget: (request) => {
+      const sessionConversation = resolveApprovalRequestSessionConversation({
+        request,
+        channel: "discord",
+        bundledFallback: false,
+      });
+      const sessionKind = extractDiscordSessionKind(
+        normalizeOptionalString(request.request.sessionKey) ?? null,
+      );
+      const turnSourceChannel = normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel);
+      const rawTurnSourceTo = normalizeOptionalString(request.request.turnSourceTo) ?? "";
+      const turnSourceTo = normalizeDiscordOriginChannelId(rawTurnSourceTo);
+      const threadId =
+        normalizeDiscordThreadId(request.request.turnSourceThreadId) ??
+        normalizeDiscordThreadId(sessionConversation?.threadId) ??
+        undefined;
+      const hasExplicitOriginTarget = /^(?:channel|group):/i.test(rawTurnSourceTo);
+      if (turnSourceChannel !== "discord" || !turnSourceTo || sessionKind === "dm") {
+        return null;
+      }
+      return hasExplicitOriginTarget || sessionKind === "channel" || sessionKind === "group"
+        ? { to: turnSourceTo, threadId }
+        : null;
+    },
+    resolveSessionTarget: (sessionTarget, request) => {
+      const sessionConversation = resolveApprovalRequestSessionConversation({
+        request,
+        channel: "discord",
+        bundledFallback: false,
+      });
+      const sessionKind = extractDiscordSessionKind(request.request.sessionKey?.trim() || null);
+      if (sessionKind === "dm") {
+        return null;
+      }
+      const targetTo = normalizeDiscordOriginChannelId(sessionTarget.to);
+      return targetTo
+        ? {
+            to: targetTo,
+            threadId:
+              normalizeDiscordThreadId(sessionTarget.threadId) ??
+              normalizeDiscordThreadId(sessionConversation?.threadId) ??
+              undefined,
+          }
+        : null;
+    },
+    resolveFallbackTarget: (request) => {
+      const sessionConversation = resolveApprovalRequestSessionConversation({
+        request,
+        channel: "discord",
+        bundledFallback: false,
+      });
+      const sessionKind = extractDiscordSessionKind(request.request.sessionKey?.trim() || null);
+      if (sessionKind === "dm") {
+        return null;
+      }
+      const fallbackChannelId = normalizeDiscordOriginChannelId(sessionConversation?.id);
+      return fallbackChannelId
+        ? {
+            to: fallbackChannelId,
+            threadId: normalizeDiscordThreadId(sessionConversation?.threadId) ?? undefined,
+          }
+        : null;
+    },
+  });
+}
+
+function createDiscordApproverDmTargetResolver(configOverride?: DiscordExecApprovalConfig | null) {
+  return createChannelApproverDmTargetResolver({
+    shouldHandleRequest: ({ cfg, accountId, request }) =>
+      shouldHandleDiscordApprovalRequest({
+        cfg,
+        accountId,
+        request,
+        configOverride,
+      }),
+    resolveApprovers: ({ cfg, accountId }) =>
+      getDiscordExecApprovalApprovers({ cfg, accountId, configOverride }),
+    mapApprover: (approver) => ({ to: approver }),
+  });
+}
+
+function createDiscordApprovalCapability(configOverride?: DiscordExecApprovalConfig | null) {
+  return createApproverRestrictedNativeApprovalCapability({
+    channel: "discord",
+    channelLabel: "Discord",
+    describeExecApprovalSetup: ({
+      accountId,
+    }: Parameters<NonNullable<ChannelApprovalCapability["describeExecApprovalSetup"]>>[0]) => {
+      const prefix =
+        accountId && accountId !== "default"
+          ? `channels.discord.accounts.${accountId}`
+          : "channels.discord";
+      return `Approve it from the Web UI or terminal UI for now. Discord supports native exec approvals for this account. Configure \`${prefix}.execApprovals.approvers\` or \`commands.ownerAllowFrom\`; set \`${prefix}.execApprovals.enabled\` to \`auto\` or \`true\`.`;
+    },
+    listAccountIds: listDiscordAccountIds,
+    hasApprovers: ({ cfg, accountId }) =>
+      getDiscordExecApprovalApprovers({ cfg, accountId, configOverride }).length > 0,
+    isExecAuthorizedSender: ({ cfg, accountId, senderId }) =>
+      isDiscordExecApprovalApprover({ cfg, accountId, senderId, configOverride }),
+    isNativeDeliveryEnabled: ({ cfg, accountId }) =>
+      isDiscordExecApprovalClientEnabled({ cfg, accountId, configOverride }),
+    resolveNativeDeliveryMode: ({ cfg, accountId }) =>
+      configOverride?.target ??
+      resolveDiscordAccount({ cfg, accountId }).config.execApprovals?.target ??
+      "dm",
+    resolveOriginTarget: createDiscordOriginTargetResolver(configOverride),
+    resolveApproverDmTargets: createDiscordApproverDmTargetResolver(configOverride),
+    notifyOriginWhenDmOnly: true,
+    nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
+      eventKinds: ["exec", "plugin"],
+      isConfigured: ({ cfg, accountId }) =>
+        isDiscordExecApprovalClientEnabled({ cfg, accountId, configOverride }),
+      shouldHandle: ({ cfg, accountId, request }) =>
+        shouldHandleDiscordApprovalRequest({
+          cfg,
+          accountId,
+          request,
+          configOverride,
+        }),
+      load: async () =>
+        (await import("./approval-handler.runtime.js"))
+          .discordApprovalNativeRuntime as unknown as ChannelApprovalNativeRuntimeAdapter,
+    }),
+  });
+}
+
+export function createDiscordNativeApprovalAdapter(
+  configOverride?: DiscordExecApprovalConfig | null,
+) {
+  return splitChannelApprovalCapability(createDiscordApprovalCapability(configOverride));
+}
+
+let cachedDiscordApprovalCapability: ReturnType<typeof createDiscordApprovalCapability> | undefined;
+
+export function getDiscordApprovalCapability() {
+  cachedDiscordApprovalCapability ??= createDiscordApprovalCapability();
+  return cachedDiscordApprovalCapability;
+}

package/src/approval-runtime.ts

@@ -0,0 +1,14 @@
+export {
+  isChannelExecApprovalClientEnabledFromConfig,
+  matchesApprovalRequestFilters,
+  getExecApprovalReplyMetadata,
+} from "autobot/plugin-sdk/approval-client-runtime";
+export { resolveApprovalApprovers } from "autobot/plugin-sdk/approval-auth-runtime";
+export {
+  createApproverRestrictedNativeApprovalCapability,
+  splitChannelApprovalCapability,
+} from "autobot/plugin-sdk/approval-delivery-runtime";
+export {
+  createChannelApproverDmTargetResolver,
+  createChannelNativeOriginTargetResolver,
+} from "autobot/plugin-sdk/approval-native-runtime";

package/src/approval-shared.ts

@@ -0,0 +1,56 @@
+import { doesApprovalRequestMatchChannelAccount } from "autobot/plugin-sdk/approval-native-runtime";
+import type {
+  ExecApprovalRequest,
+  PluginApprovalRequest,
+} from "autobot/plugin-sdk/approval-runtime";
+import type {
+  DiscordExecApprovalConfig,
+  AutoBotConfig,
+} from "autobot/plugin-sdk/config-contracts";
+import { resolveDiscordAccount } from "./accounts.js";
+import {
+  isChannelExecApprovalClientEnabledFromConfig,
+  matchesApprovalRequestFilters,
+} from "./approval-runtime.js";
+import { getDiscordExecApprovalApprovers } from "./exec-approvals.js";
+
+type ApprovalRequest = ExecApprovalRequest | PluginApprovalRequest;
+
+export function shouldHandleDiscordApprovalRequest(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  request: ApprovalRequest;
+  configOverride?: DiscordExecApprovalConfig | null;
+}): boolean {
+  const config =
+    params.configOverride ??
+    resolveDiscordAccount({ cfg: params.cfg, accountId: params.accountId }).config.execApprovals;
+  const approvers = getDiscordExecApprovalApprovers({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    configOverride: params.configOverride,
+  });
+  if (
+    !doesApprovalRequestMatchChannelAccount({
+      cfg: params.cfg,
+      request: params.request,
+      channel: "discord",
+      accountId: params.accountId,
+    })
+  ) {
+    return false;
+  }
+  if (
+    !isChannelExecApprovalClientEnabledFromConfig({
+      enabled: config?.enabled,
+      approverCount: approvers.length,
+    })
+  ) {
+    return false;
+  }
+  return matchesApprovalRequestFilters({
+    request: params.request.request,
+    agentFilter: config?.agentFilter,
+    sessionFilter: config?.sessionFilter,
+  });
+}

package/src/audit-core.ts

@@ -0,0 +1,178 @@
+import { ChannelType } from "discord-api-types/v10";
+import type {
+  DiscordGuildChannelConfig,
+  DiscordGuildEntry,
+  AutoBotConfig,
+} from "autobot/plugin-sdk/config-contracts";
+import { formatErrorMessage } from "autobot/plugin-sdk/error-runtime";
+import { isRecord, normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+
+type DiscordChannelPermissionsAuditEntry = {
+  channelId: string;
+  ok: boolean;
+  missing?: string[];
+  error?: string | null;
+  matchKey?: string;
+  matchSource?: "id";
+};
+
+export type DiscordChannelPermissionsAudit = {
+  ok: boolean;
+  checkedChannels: number;
+  unresolvedChannels: number;
+  channels: DiscordChannelPermissionsAuditEntry[];
+  elapsedMs: number;
+};
+
+const REQUIRED_TEXT_CHANNEL_PERMISSIONS = ["ViewChannel", "SendMessages"] as const;
+const REQUIRED_VOICE_CHANNEL_PERMISSIONS = [
+  "ViewChannel",
+  "Connect",
+  "Speak",
+  "SendMessages",
+  "ReadMessageHistory",
+] as const;
+
+export function resolveRequiredDiscordChannelPermissions(channelType?: number): string[] {
+  if (channelType === ChannelType.GuildVoice || channelType === ChannelType.GuildStageVoice) {
+    return [...REQUIRED_VOICE_CHANNEL_PERMISSIONS];
+  }
+  return [...REQUIRED_TEXT_CHANNEL_PERMISSIONS];
+}
+
+function shouldAuditChannelConfig(config: DiscordGuildChannelConfig | undefined) {
+  if (!config) {
+    return true;
+  }
+  if (config.enabled === false) {
+    return false;
+  }
+  return true;
+}
+
+function listConfiguredGuildChannelKeys(
+  guilds: Record<string, DiscordGuildEntry> | undefined,
+): string[] {
+  if (!guilds) {
+    return [];
+  }
+  const ids = new Set<string>();
+  for (const entry of Object.values(guilds)) {
+    if (!entry || typeof entry !== "object") {
+      continue;
+    }
+    const channelsRaw = (entry as { channels?: unknown }).channels;
+    if (!isRecord(channelsRaw)) {
+      continue;
+    }
+    for (const [key, value] of Object.entries(channelsRaw)) {
+      const channelId = normalizeOptionalString(key) ?? "";
+      if (!channelId) {
+        continue;
+      }
+      if (channelId === "*") {
+        continue;
+      }
+      if (!shouldAuditChannelConfig(value as DiscordGuildChannelConfig | undefined)) {
+        continue;
+      }
+      ids.add(channelId);
+    }
+  }
+  return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+
+export function collectDiscordAuditChannelIdsForGuilds(
+  guilds: Record<string, DiscordGuildEntry> | undefined,
+) {
+  const keys = listConfiguredGuildChannelKeys(guilds);
+  const channelIds = keys.filter((key) => /^\d+$/.test(key));
+  const unresolvedChannels = keys.length - channelIds.length;
+  return { channelIds, unresolvedChannels };
+}
+
+export function collectDiscordAuditChannelIdsForAccount(config: {
+  guilds?: Record<string, DiscordGuildEntry>;
+  voice?: { autoJoin?: Array<{ guildId?: string; channelId?: string }> };
+}) {
+  const collected = collectDiscordAuditChannelIdsForGuilds(config.guilds);
+  const channelIds = new Set(collected.channelIds);
+  let unresolvedVoiceChannels = 0;
+  for (const entry of config.voice?.autoJoin ?? []) {
+    const channelId = normalizeOptionalString(entry?.channelId) ?? "";
+    if (/^\d+$/.test(channelId)) {
+      channelIds.add(channelId);
+    } else if (channelId) {
+      unresolvedVoiceChannels++;
+    }
+  }
+  return {
+    channelIds: [...channelIds].toSorted((a, b) => a.localeCompare(b)),
+    unresolvedChannels: collected.unresolvedChannels + unresolvedVoiceChannels,
+  };
+}
+
+export async function auditDiscordChannelPermissionsWithFetcher(params: {
+  cfg: AutoBotConfig;
+  token: string;
+  accountId?: string | null;
+  channelIds: string[];
+  timeoutMs: number;
+  fetchChannelPermissions: (
+    channelId: string,
+    params: { cfg: AutoBotConfig; token: string; accountId?: string },
+  ) => Promise<{
+    permissions: string[];
+    channelType?: number;
+  }>;
+}): Promise<DiscordChannelPermissionsAudit> {
+  const started = Date.now();
+  const token = normalizeOptionalString(params.token) ?? "";
+  if (!token || params.channelIds.length === 0) {
+    return {
+      ok: true,
+      checkedChannels: 0,
+      unresolvedChannels: 0,
+      channels: [],
+      elapsedMs: Date.now() - started,
+    };
+  }
+
+  const channels: DiscordChannelPermissionsAuditEntry[] = [];
+
+  for (const channelId of params.channelIds) {
+    try {
+      const perms = await params.fetchChannelPermissions(channelId, {
+        cfg: params.cfg,
+        token,
+        accountId: params.accountId ?? undefined,
+      });
+      const required = resolveRequiredDiscordChannelPermissions(perms.channelType);
+      const missing = required.filter((p) => !perms.permissions.includes(p));
+      channels.push({
+        channelId,
+        ok: missing.length === 0,
+        missing: missing.length ? missing : undefined,
+        error: null,
+        matchKey: channelId,
+        matchSource: "id",
+      });
+    } catch (err) {
+      channels.push({
+        channelId,
+        ok: false,
+        error: formatErrorMessage(err),
+        matchKey: channelId,
+        matchSource: "id",
+      });
+    }
+  }
+
+  return {
+    ok: channels.every((c) => c.ok),
+    checkedChannels: channels.length,
+    unresolvedChannels: 0,
+    channels,
+    elapsedMs: Date.now() - started,
+  };
+}

package/src/audit.ts

@@ -0,0 +1,32 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { inspectDiscordAccount } from "./account-inspect.js";
+import {
+  auditDiscordChannelPermissionsWithFetcher,
+  collectDiscordAuditChannelIdsForAccount,
+  type DiscordChannelPermissionsAudit,
+} from "./audit-core.js";
+import { fetchChannelPermissionsDiscord } from "./send.js";
+
+export function collectDiscordAuditChannelIds(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+}) {
+  const account = inspectDiscordAccount({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  return collectDiscordAuditChannelIdsForAccount(account.config);
+}
+
+export async function auditDiscordChannelPermissions(params: {
+  cfg: AutoBotConfig;
+  token: string;
+  accountId?: string | null;
+  channelIds: string[];
+  timeoutMs: number;
+}): Promise<DiscordChannelPermissionsAudit> {
+  return await auditDiscordChannelPermissionsWithFetcher({
+    ...params,
+    fetchChannelPermissions: fetchChannelPermissionsDiscord,
+  });
+}

package/src/channel-actions.runtime.ts

@@ -0,0 +1 @@
+export { handleDiscordMessageAction } from "./actions/handle-action.js";