@gakr-gakr/discord 0.1.0

package/runtime-api.ts

@@ -0,0 +1,181 @@
+export {
+  discordMessageActions,
+  handleDiscordAction,
+  isDiscordModerationAction,
+  readDiscordChannelCreateParams,
+  readDiscordChannelEditParams,
+  readDiscordChannelMoveParams,
+  readDiscordModerationCommand,
+  readDiscordParentIdParam,
+  requiredGuildPermissionForModerationAction,
+  type DiscordModerationAction,
+  type DiscordModerationCommand,
+} from "./runtime-api.actions.js";
+export {
+  auditDiscordChannelPermissions,
+  collectDiscordAuditChannelIds,
+  fetchDiscordApplicationId,
+  fetchDiscordApplicationSummary,
+  listDiscordDirectoryGroupsLive,
+  listDiscordDirectoryPeersLive,
+  parseApplicationIdFromToken,
+  probeDiscord,
+  resolveDiscordChannelAllowlist,
+  resolveDiscordPrivilegedIntentsFromFlags,
+  resolveDiscordUserAllowlist,
+  setDiscordRuntime,
+  type DiscordApplicationSummary,
+  type DiscordChannelResolution,
+  type DiscordPrivilegedIntentsSummary,
+  type DiscordPrivilegedIntentStatus,
+  type DiscordProbe,
+  type DiscordUserResolution,
+} from "./runtime-api.lookup.js";
+export {
+  DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS,
+  DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS,
+  DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS,
+  DISCORD_DEFAULT_LISTENER_TIMEOUT_MS,
+  allowListMatches,
+  buildDiscordMediaPayload,
+  clearGateways,
+  clearPresences,
+  createDiscordGatewayPlugin,
+  createDiscordMessageHandler,
+  createDiscordNativeCommand,
+  getGateway,
+  getPresence,
+  isDiscordGroupAllowedByPolicy,
+  mergeAbortSignals,
+  monitorDiscordProvider,
+  normalizeDiscordAllowList,
+  normalizeDiscordSlug,
+  presenceCacheSize,
+  registerDiscordListener,
+  registerGateway,
+  resolveDiscordChannelConfig,
+  resolveDiscordChannelConfigWithFallback,
+  resolveDiscordCommandAuthorized,
+  resolveDiscordGatewayIntents,
+  resolveDiscordGuildEntry,
+  resolveDiscordReplyTarget,
+  resolveDiscordShouldRequireMention,
+  resolveGroupDmAllow,
+  sanitizeDiscordThreadName,
+  setPresence,
+  shouldEmitDiscordReactionNotification,
+  unregisterGateway,
+  waitForDiscordGatewayPluginRegistration,
+  type DiscordAllowList,
+  type DiscordChannelConfigResolved,
+  type DiscordGuildEntryResolved,
+  type DiscordMessageEvent,
+  type DiscordMessageHandler,
+  type MonitorDiscordOpts,
+} from "./runtime-api.monitor.js";
+export {
+  DiscordSendError,
+  addRoleDiscord,
+  banMemberDiscord,
+  createChannelDiscord,
+  createScheduledEventDiscord,
+  createThreadDiscord,
+  deleteChannelDiscord,
+  deleteMessageDiscord,
+  editChannelDiscord,
+  editDiscordComponentMessage,
+  editMessageDiscord,
+  fetchChannelInfoDiscord,
+  fetchChannelPermissionsDiscord,
+  fetchMemberGuildPermissionsDiscord,
+  fetchMemberInfoDiscord,
+  fetchMessageDiscord,
+  fetchReactionsDiscord,
+  fetchRoleInfoDiscord,
+  fetchVoiceStatusDiscord,
+  hasAllGuildPermissionsDiscord,
+  hasAnyGuildPermissionDiscord,
+  kickMemberDiscord,
+  listGuildChannelsDiscord,
+  listGuildEmojisDiscord,
+  listPinsDiscord,
+  listScheduledEventsDiscord,
+  listThreadsDiscord,
+  moveChannelDiscord,
+  pinMessageDiscord,
+  reactMessageDiscord,
+  readMessagesDiscord,
+  registerBuiltDiscordComponentMessage,
+  removeChannelPermissionDiscord,
+  removeOwnReactionsDiscord,
+  removeReactionDiscord,
+  removeRoleDiscord,
+  resolveDiscordOutboundSessionRoute,
+  resolveEventCoverImage,
+  searchMessagesDiscord,
+  sendDiscordComponentMessage,
+  sendMessageDiscord,
+  sendPollDiscord,
+  sendStickerDiscord,
+  sendTypingDiscord,
+  sendVoiceMessageDiscord,
+  sendWebhookMessageDiscord,
+  setChannelPermissionDiscord,
+  timeoutMemberDiscord,
+  unpinMessageDiscord,
+  uploadEmojiDiscord,
+  uploadStickerDiscord,
+  type DiscordChannelCreate,
+  type DiscordChannelEdit,
+  type DiscordChannelMove,
+  type DiscordChannelPermissionSet,
+  type DiscordEmojiUpload,
+  type DiscordMessageEdit,
+  type DiscordMessageQuery,
+  type DiscordModerationTarget,
+  type DiscordPermissionsSummary,
+  type DiscordReactionRuntimeContext,
+  type DiscordReactionSummary,
+  type DiscordReactionUser,
+  type DiscordReactOpts,
+  type DiscordRoleChange,
+  type DiscordRuntimeAccountContext,
+  type DiscordSearchQuery,
+  type DiscordSendResult,
+  type DiscordStickerUpload,
+  type DiscordThreadCreate,
+  type DiscordThreadList,
+  type DiscordTimeoutTarget,
+  type ResolveDiscordOutboundSessionRouteParams,
+} from "./runtime-api.send.js";
+export {
+  testing as __testing,
+  testing,
+  autoBindSpawnedDiscordSubagent,
+  createNoopThreadBindingManager,
+  createThreadBindingManager,
+  formatThreadBindingDurationLabel,
+  getThreadBindingManager,
+  isRecentlyUnboundThreadWebhookMessage,
+  listThreadBindingsBySessionKey,
+  listThreadBindingsForAccount,
+  reconcileAcpThreadBindingsOnStartup,
+  resolveDiscordThreadBindingIdleTimeoutMs,
+  resolveDiscordThreadBindingMaxAgeMs,
+  resolveThreadBindingIdleTimeoutMs,
+  resolveThreadBindingInactivityExpiresAt,
+  resolveThreadBindingIntroText,
+  resolveThreadBindingMaxAgeExpiresAt,
+  resolveThreadBindingMaxAgeMs,
+  resolveThreadBindingPersona,
+  resolveThreadBindingPersonaFromRecord,
+  resolveThreadBindingsEnabled,
+  resolveThreadBindingThreadName,
+  setThreadBindingIdleTimeoutBySessionKey,
+  setThreadBindingMaxAgeBySessionKey,
+  unbindThreadBindingsBySessionKey,
+  type AcpThreadBindingReconciliationResult,
+  type ThreadBindingManager,
+  type ThreadBindingRecord,
+  type ThreadBindingTargetKind,
+} from "./runtime-api.threads.js";

package/runtime-setter-api.ts

@@ -0,0 +1,3 @@
+// Keep bundled registration fast: runtime wiring only needs the store setter,
+// while runtime-api.js remains the broad runtime surface.
+export { setDiscordRuntime } from "./src/runtime.js";

package/secret-contract-api.ts

@@ -0,0 +1,4 @@
+export {
+  collectRuntimeConfigAssignments,
+  secretTargetRegistryEntries,
+} from "./src/secret-config-contract.js";

package/security-audit-contract-api.ts

@@ -0,0 +1 @@
+export { collectDiscordSecurityAuditFindings } from "./src/security-audit.js";

package/security-contract-api.ts

@@ -0,0 +1,4 @@
+export {
+  collectUnsupportedSecretRefConfigCandidates,
+  unsupportedSecretRefSurfacePatterns,
+} from "./src/security-contract.js";

package/session-key-api.ts

@@ -0,0 +1 @@
+export { normalizeExplicitDiscordSessionKey } from "./src/session-key-normalization.js";

package/setup-entry.ts

@@ -0,0 +1,9 @@
+import { defineBundledChannelSetupEntry } from "autobot/plugin-sdk/channel-entry-contract";
+
+export default defineBundledChannelSetupEntry({
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./setup-plugin-api.js",
+    exportName: "discordSetupPlugin",
+  },
+});

package/setup-plugin-api.ts

@@ -0,0 +1,3 @@
+// Keep bundled setup entry imports narrow so setup loads do not pull the
+// broader Discord channel plugin surface.
+export { discordSetupPlugin } from "./src/channel.setup.js";

package/src/account-inspect.ts

@@ -0,0 +1,131 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "autobot/plugin-sdk/account-id";
+import {
+  hasConfiguredSecretInput,
+  normalizeSecretInputString,
+} from "autobot/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import {
+  mergeDiscordAccountConfig,
+  resolveDefaultDiscordAccountId,
+  resolveDiscordAccountConfig,
+} from "./accounts.js";
+import type { DiscordAccountConfig, AutoBotConfig } from "./runtime-api.js";
+import type { DiscordCredentialStatus } from "./token.js";
+
+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: AutoBotConfig;
+  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.ts

@@ -0,0 +1,205 @@
+import {
+  createAccountActionGate,
+  createAccountListHelpers,
+  resolveMergedAccountConfig,
+} from "autobot/plugin-sdk/account-helpers";
+import { normalizeAccountId } from "autobot/plugin-sdk/account-id";
+import {
+  mapAllowFromEntries,
+  normalizeChannelDmPolicy,
+  resolveChannelDmAllowFrom,
+  resolveChannelDmPolicy,
+  type ChannelDmPolicy,
+} from "autobot/plugin-sdk/channel-config-helpers";
+import { resolveAccountEntry } from "autobot/plugin-sdk/routing";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import type { DiscordAccountConfig, DiscordActionConfig, AutoBotConfig } from "./runtime-api.js";
+import { selectDiscordRuntimeConfig } from "./runtime-config.js";
+import { resolveDiscordToken, type DiscordCredentialStatus } from "./token.js";
+
+export type ResolvedDiscordAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "config" | "none";
+  tokenStatus: DiscordCredentialStatus;
+  config: DiscordAccountConfig;
+};
+
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("discord", {
+  implicitDefaultAccount: {
+    channelKeys: ["token"],
+    envVars: ["DISCORD_BOT_TOKEN"],
+  },
+});
+export const listDiscordAccountIds = listAccountIds;
+export const resolveDefaultDiscordAccountId = resolveDefaultAccountId;
+
+export function resolveDiscordAccountConfig(
+  cfg: AutoBotConfig,
+  accountId: string,
+): DiscordAccountConfig | undefined {
+  return resolveAccountEntry(cfg.channels?.discord?.accounts, accountId);
+}
+
+export function mergeDiscordAccountConfig(
+  cfg: AutoBotConfig,
+  accountId: string,
+): DiscordAccountConfig {
+  const merged = resolveMergedAccountConfig<DiscordAccountConfig>({
+    channelConfig: cfg.channels?.discord as DiscordAccountConfig | undefined,
+    accounts: cfg.channels?.discord?.accounts as
+      | Record<string, Partial<DiscordAccountConfig>>
+      | undefined,
+    accountId,
+    nestedObjectKeys: ["botLoopProtection"],
+  });
+  return merged;
+}
+
+export function resolveDiscordAccountAllowFrom(params: {
+  cfg: AutoBotConfig;
+  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: AutoBotConfig;
+  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: AutoBotConfig;
+  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: AutoBotConfig;
+  accountId?: string | null;
+}): ResolvedDiscordAccount {
+  const cfg = selectDiscordRuntimeConfig(params.cfg);
+  const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(cfg));
+  const baseEnabled = cfg.channels?.discord?.enabled !== false;
+  const merged = mergeDiscordAccountConfig(cfg, accountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const tokenResolution = resolveDiscordToken(cfg, { accountId });
+  return {
+    accountId,
+    enabled,
+    name: normalizeOptionalString(merged.name),
+    token: tokenResolution.token,
+    tokenSource: tokenResolution.source,
+    tokenStatus: tokenResolution.tokenStatus,
+    config: merged,
+  };
+}
+
+export function resolveDiscordMaxLinesPerMessage(params: {
+  cfg: AutoBotConfig;
+  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: AutoBotConfig;
+  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: AutoBotConfig;
+  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: AutoBotConfig,
+): boolean {
+  return account.enabled && !resolveDiscordDuplicateTokenOwner({ cfg, account });
+}
+
+export function resolveDiscordAccountDisabledReason(
+  account: ResolvedDiscordAccount,
+  cfg: AutoBotConfig,
+): string {
+  if (!account.enabled) {
+    return "disabled";
+  }
+  const owner = resolveDiscordDuplicateTokenOwner({ cfg, account });
+  return owner ? `duplicate bot token; using account "${owner}"` : "disabled";
+}
+
+export function listEnabledDiscordAccounts(cfg: AutoBotConfig): ResolvedDiscordAccount[] {
+  return listDiscordAccountIds(cfg)
+    .map((accountId) => resolveDiscordAccount({ cfg, accountId }))
+    .filter((account) => isDiscordAccountEnabledForRuntime(account, cfg));
+}