@open-mercato/channel-discord 0.6.8-develop.7090.1.4dbca7b350

package/dist/modules/channel_discord/lib/channel-state-store.js

@@ -0,0 +1,103 @@
+import { findOneWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { CommunicationChannel } from "@open-mercato/core/modules/communication_channels/data/entities";
+import { discordChannelStateSchema } from "./credentials.js";
+function mergeDiscordChannelState(currentRaw, patch, now) {
+  const current = discordChannelStateSchema.parse(currentRaw ?? {});
+  const sameSession = Boolean(patch.sessionId) && patch.sessionId === current.sessionId;
+  const rewindsSequence = sameSession && typeof patch.sequence === "number" && typeof current.sequence === "number" && patch.sequence < current.sequence;
+  if (rewindsSequence) return null;
+  return {
+    ...current,
+    ...patch,
+    lastConnectedAt: now.toISOString()
+  };
+}
+async function persistDiscordChannelState(params) {
+  const fork = params.em.fork();
+  const channel = await findOneWithDecryption(
+    fork,
+    CommunicationChannel,
+    {
+      id: params.channelId,
+      tenantId: params.scope.tenantId,
+      organizationId: params.scope.organizationId,
+      deletedAt: null
+    },
+    void 0,
+    {
+      tenantId: params.scope.tenantId,
+      organizationId: params.scope.organizationId ?? params.scope.tenantId
+    }
+  );
+  if (!channel) return "not_found";
+  const merged = mergeDiscordChannelState(channel.channelState, params.patch, params.now ?? /* @__PURE__ */ new Date());
+  if (!merged) return "skipped";
+  channel.channelState = merged;
+  await fork.flush();
+  return "written";
+}
+const AUTO_REPLY_ERROR_MAX_LENGTH = 500;
+async function recordDiscordAutoReplyOutcome(params) {
+  const fork = params.em.fork();
+  const channel = await findOneWithDecryption(
+    fork,
+    CommunicationChannel,
+    {
+      id: params.channelId,
+      tenantId: params.scope.tenantId,
+      organizationId: params.scope.organizationId,
+      deletedAt: null
+    },
+    void 0,
+    {
+      tenantId: params.scope.tenantId,
+      organizationId: params.scope.organizationId ?? params.scope.tenantId
+    }
+  );
+  if (!channel) return "not_found";
+  const current = discordChannelStateSchema.parse(channel.channelState ?? {});
+  const failure = params.failure?.slice(0, AUTO_REPLY_ERROR_MAX_LENGTH) ?? null;
+  if (failure === null && current.aiAutoReplyLastError === void 0) return "unchanged";
+  if (failure !== null && current.aiAutoReplyLastError === failure) return "unchanged";
+  const next = { ...current };
+  if (failure === null) {
+    delete next.aiAutoReplyLastError;
+    delete next.aiAutoReplyLastErrorAt;
+  } else {
+    next.aiAutoReplyLastError = failure;
+    next.aiAutoReplyLastErrorAt = (params.now ?? /* @__PURE__ */ new Date()).toISOString();
+  }
+  channel.channelState = next;
+  await fork.flush();
+  return "written";
+}
+async function quarantineDiscordChannel(params) {
+  const fork = params.em.fork();
+  const channel = await findOneWithDecryption(
+    fork,
+    CommunicationChannel,
+    {
+      id: params.channelId,
+      tenantId: params.scope.tenantId,
+      organizationId: params.scope.organizationId,
+      deletedAt: null
+    },
+    void 0,
+    {
+      tenantId: params.scope.tenantId,
+      organizationId: params.scope.organizationId ?? params.scope.tenantId
+    }
+  );
+  if (!channel) return "not_found";
+  channel.status = "requires_reauth";
+  channel.lastError = params.reason;
+  await fork.flush();
+  return "quarantined";
+}
+export {
+  mergeDiscordChannelState,
+  persistDiscordChannelState,
+  quarantineDiscordChannel,
+  recordDiscordAutoReplyOutcome
+};
+//# sourceMappingURL=channel-state-store.js.map

package/dist/modules/channel_discord/lib/channel-state-store.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/lib/channel-state-store.ts"],
+  "sourcesContent": ["import type { EntityManager } from '@mikro-orm/postgresql'\nimport { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'\nimport { CommunicationChannel } from '@open-mercato/core/modules/communication_channels/data/entities'\nimport { discordChannelStateSchema, type DiscordChannelState } from './credentials'\n\n/**\n * Tenant/organization scope every Discord channel-state write MUST carry.\n * The gateway worker persists resume state from a WebSocket callback that fires\n * long after the job handler returned, so the scope is captured up front from\n * the channel row the job loaded and replayed on every write.\n */\nexport type DiscordChannelScope = {\n  tenantId: string\n  organizationId: string | null\n}\n\n/** The gateway-owned subset of `channelState` this store is allowed to write. */\nexport type DiscordChannelStatePatch = {\n  sessionId?: string\n  sequence?: number | null\n  resumeGatewayUrl?: string\n  botUserId?: string\n}\n\nexport type PersistDiscordChannelStateResult = 'written' | 'skipped' | 'not_found'\n\n/**\n * Merge a gateway resume-state patch onto the state currently stored on the\n * channel row, or return `null` when the patch must not be written.\n *\n * Two rules make this safe against the socket callbacks racing each other:\n *\n * - Only the gateway-owned keys are touched; every other key (`aiAutoReplyEnabled`,\n *   `aiAgentId`, operator-set fields) is carried forward from the row that was\n *   just read, so a concurrent UI edit is never clobbered wholesale.\n * - A patch that would rewind the sequence of the session already stored is\n *   dropped. A late `READY` callback from a superseded socket must not overwrite\n *   fresher resume state with a stale cursor.\n */\nexport function mergeDiscordChannelState(\n  currentRaw: unknown,\n  patch: DiscordChannelStatePatch,\n  now: Date,\n): DiscordChannelState | null {\n  const current = discordChannelStateSchema.parse(currentRaw ?? {})\n  const sameSession = Boolean(patch.sessionId) && patch.sessionId === current.sessionId\n  const rewindsSequence =\n    sameSession &&\n    typeof patch.sequence === 'number' &&\n    typeof current.sequence === 'number' &&\n    patch.sequence < current.sequence\n  if (rewindsSequence) return null\n\n  return {\n    ...current,\n    ...patch,\n    lastConnectedAt: now.toISOString(),\n  }\n}\n\n/**\n * Scoped read-modify-write of a Discord channel's gateway resume state.\n *\n * The lookup filters by `tenant_id` / `organization_id` (never by id alone) so a\n * socket callback can only ever touch the row its own channel scope owns, and it\n * runs on its own `EntityManager` fork so the flush never rides on the request\n * context the worker job was started from.\n */\nexport async function persistDiscordChannelState(params: {\n  em: EntityManager\n  channelId: string\n  scope: DiscordChannelScope\n  patch: DiscordChannelStatePatch\n  now?: Date\n}): Promise<PersistDiscordChannelStateResult> {\n  const fork = params.em.fork()\n  const channel = await findOneWithDecryption(\n    fork,\n    CommunicationChannel,\n    {\n      id: params.channelId,\n      tenantId: params.scope.tenantId,\n      organizationId: params.scope.organizationId,\n      deletedAt: null,\n    },\n    undefined,\n    {\n      tenantId: params.scope.tenantId,\n      organizationId: params.scope.organizationId ?? params.scope.tenantId,\n    },\n  )\n  if (!channel) return 'not_found'\n\n  const merged = mergeDiscordChannelState(channel.channelState, params.patch, params.now ?? new Date())\n  if (!merged) return 'skipped'\n\n  channel.channelState = merged\n  await fork.flush()\n  return 'written'\n}\n\nexport type RecordAutoReplyOutcomeResult = 'written' | 'unchanged' | 'not_found'\n\n/** Truncated so a provider stack trace cannot grow the JSONB column without bound. */\nconst AUTO_REPLY_ERROR_MAX_LENGTH = 500\n\n/**\n * Record \u2014 or clear \u2014 why the last AI auto-reply attempt on this channel produced\n * nothing.\n *\n * The subscriber degrades every failure to a no-op on purpose: a broken model, a\n * denied policy check or a malformed object must never turn into a send. Being\n * *silent* about it is the part that hurts, because the operator's surface still\n * reads \"Auto-reply on\" while the channel answers nothing, and a `logger.warn` in\n * a background subscriber is not somewhere anyone looks. A save-time check cannot\n * close this on its own either \u2014 the settings route validates the agent against\n * the auto-reply principal, but a role edited afterwards makes that verdict stale.\n *\n * `failure: null` clears the marker, and the caller is expected to skip the write\n * when there is nothing to clear \u2014 a successful reply on a healthy channel must\n * not cost a row update per inbound message.\n *\n * The channel row's own `lastError` is deliberately left alone: the hub owns it\n * for delivery and polling failures, clears it on a successful poll, and keys the\n * reauth banner off `status`. Borrowing it here would let an AI failure mask a\n * delivery failure and let a successful poll erase an AI one.\n */\nexport async function recordDiscordAutoReplyOutcome(params: {\n  em: EntityManager\n  channelId: string\n  scope: DiscordChannelScope\n  failure: string | null\n  now?: Date\n}): Promise<RecordAutoReplyOutcomeResult> {\n  const fork = params.em.fork()\n  const channel = await findOneWithDecryption(\n    fork,\n    CommunicationChannel,\n    {\n      id: params.channelId,\n      tenantId: params.scope.tenantId,\n      organizationId: params.scope.organizationId,\n      deletedAt: null,\n    },\n    undefined,\n    {\n      tenantId: params.scope.tenantId,\n      organizationId: params.scope.organizationId ?? params.scope.tenantId,\n    },\n  )\n  if (!channel) return 'not_found'\n\n  const current = discordChannelStateSchema.parse(channel.channelState ?? {})\n  const failure = params.failure?.slice(0, AUTO_REPLY_ERROR_MAX_LENGTH) ?? null\n  if (failure === null && current.aiAutoReplyLastError === undefined) return 'unchanged'\n  if (failure !== null && current.aiAutoReplyLastError === failure) return 'unchanged'\n\n  const next: DiscordChannelState = { ...current }\n  if (failure === null) {\n    delete next.aiAutoReplyLastError\n    delete next.aiAutoReplyLastErrorAt\n  } else {\n    next.aiAutoReplyLastError = failure\n    next.aiAutoReplyLastErrorAt = (params.now ?? new Date()).toISOString()\n  }\n\n  channel.channelState = next\n  await fork.flush()\n  return 'written'\n}\n\nexport type QuarantineDiscordChannelResult = 'quarantined' | 'not_found'\n\n/**\n * Park a channel Discord has fatally rejected so the reconciler stops re-opening it.\n *\n * A `4004` (invalid token) or `4014` (disallowed intents) close is not\n * recoverable by retrying: the token or the Developer Portal toggle has to\n * change first. Without a persisted status the refresh job sees \"no live\n * session\" on the next tick and IDENTIFYs again \u2014 at the CLI's default 60s\n * refresh that is ~1440 session starts per day against Discord's ~1000/day\n * per-bot budget, while the row and the admin UI still read `connected`.\n *\n * Writing `requires_reauth` mirrors what the hub already does for a channel\n * whose credentials could not be persisted (`connect-channel.ts`), so the\n * existing reauth banner, the mutation guard that keys on `status`, and the\n * operator's reconnect flow all engage without any hub change.\n */\nexport async function quarantineDiscordChannel(params: {\n  em: EntityManager\n  channelId: string\n  scope: DiscordChannelScope\n  reason: string\n}): Promise<QuarantineDiscordChannelResult> {\n  const fork = params.em.fork()\n  const channel = await findOneWithDecryption(\n    fork,\n    CommunicationChannel,\n    {\n      id: params.channelId,\n      tenantId: params.scope.tenantId,\n      organizationId: params.scope.organizationId,\n      deletedAt: null,\n    },\n    undefined,\n    {\n      tenantId: params.scope.tenantId,\n      organizationId: params.scope.organizationId ?? params.scope.tenantId,\n    },\n  )\n  if (!channel) return 'not_found'\n\n  channel.status = 'requires_reauth'\n  channel.lastError = params.reason\n  await fork.flush()\n  return 'quarantined'\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/channel_discord/lib/convert-outbound.js

@@ -0,0 +1,38 @@
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { DISCORD_MAX_BODY_LENGTH } from "./capabilities.js";
+const logger = createLogger("channel_discord").child({ component: "convert-outbound" });
+function htmlToMarkdown(html) {
+  return html.replace(/<\s*br\s*\/?\s*>/gi, "\n").replace(/<\s*\/\s*p\s*>/gi, "\n\n").replace(/<\s*p[^>]*>/gi, "").replace(/<\s*(strong|b)\s*>(.*?)<\s*\/\s*\1\s*>/gis, "**$2**").replace(/<\s*(em|i)\s*>(.*?)<\s*\/\s*\1\s*>/gis, "*$2*").replace(/<\s*code\s*>(.*?)<\s*\/\s*code\s*>/gis, "`$1`").replace(/<\s*a[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\s*\/\s*a\s*>/gis, "[$2]($1)").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/\n{3,}/g, "\n\n").trim();
+}
+async function convertOutboundForDiscord(input) {
+  const droppedAttachmentCount = input.attachments?.length ?? 0;
+  if (droppedAttachmentCount > 0) {
+    logger.warn("discord outbound attachments are not supported \u2014 sending text only", {
+      droppedAttachmentCount
+    });
+  }
+  const raw = input.body ?? "";
+  const markdown = input.bodyFormat === "html" ? htmlToMarkdown(raw) : raw;
+  const TRUNCATE_MARKER = "\u2026";
+  const content = markdown.length > DISCORD_MAX_BODY_LENGTH ? markdown.slice(0, DISCORD_MAX_BODY_LENGTH - TRUNCATE_MARKER.length) + TRUNCATE_MARKER : markdown;
+  const allowedMentions = input.channelMetadata?.allowedMentions ?? { parse: [] };
+  return {
+    content: {
+      text: content,
+      bodyFormat: "markdown"
+    },
+    metadata: {
+      allowedMentions,
+      droppedAttachmentCount,
+      // Reply threading, dormant: no hub producer writes `replyToExternalId`
+      // into outbound metadata today, which is why `capabilities.threading` is
+      // declared `false`. Kept so that flag flips back with the hub-side
+      // producer and nothing else.
+      messageReferenceId: typeof input.channelMetadata?.replyToExternalId === "string" ? input.channelMetadata.replyToExternalId : void 0
+    }
+  };
+}
+export {
+  convertOutboundForDiscord
+};
+//# sourceMappingURL=convert-outbound.js.map

package/dist/modules/channel_discord/lib/convert-outbound.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/lib/convert-outbound.ts"],
+  "sourcesContent": ["import type {\n  ChannelNativeContent,\n  ConvertOutboundInput,\n} from '@open-mercato/core/modules/communication_channels/lib/adapter'\nimport { createLogger } from '@open-mercato/shared/lib/logger'\nimport { DISCORD_MAX_BODY_LENGTH } from './capabilities'\n\nconst logger = createLogger('channel_discord').child({ component: 'convert-outbound' })\n\n/**\n * Very small HTML \u2192 markdown down-converter for the common inline tags the hub's\n * `html` body format produces. Discord content is markdown-native, so we map the\n * handful of tags that have a markdown equivalent and strip the rest rather than\n * pulling in a full HTML parser dependency.\n */\nfunction htmlToMarkdown(html: string): string {\n  return html\n    .replace(/<\\s*br\\s*\\/?\\s*>/gi, '\\n')\n    .replace(/<\\s*\\/\\s*p\\s*>/gi, '\\n\\n')\n    .replace(/<\\s*p[^>]*>/gi, '')\n    .replace(/<\\s*(strong|b)\\s*>(.*?)<\\s*\\/\\s*\\1\\s*>/gis, '**$2**')\n    .replace(/<\\s*(em|i)\\s*>(.*?)<\\s*\\/\\s*\\1\\s*>/gis, '*$2*')\n    .replace(/<\\s*code\\s*>(.*?)<\\s*\\/\\s*code\\s*>/gis, '`$1`')\n    .replace(/<\\s*a[^>]*href=[\"']([^\"']+)[\"'][^>]*>(.*?)<\\s*\\/\\s*a\\s*>/gis, '[$2]($1)')\n    .replace(/<[^>]+>/g, '')\n    .replace(/&nbsp;/gi, ' ')\n    .replace(/&amp;/gi, '&')\n    .replace(/&lt;/gi, '<')\n    .replace(/&gt;/gi, '>')\n    .replace(/&quot;/gi, '\"')\n    .replace(/\\n{3,}/g, '\\n\\n')\n    .trim()\n}\n\n/**\n * Convert the hub's normalized outbound body into Discord native content.\n *\n * - `markdown` / `text` pass through unchanged (Discord is markdown-native).\n * - `html` is down-converted to markdown.\n * - Content is clamped to Discord's 2000-char hard limit (a longer body is\n *   truncated with an ellipsis marker rather than rejected by the API).\n * - `allowed_mentions` defaults to `{ parse: [] }` so an AI/automated reply can\n *   never accidentally @-ping everyone; callers can widen it via `channelMetadata`.\n * - Attachments are NOT uploaded: `discord-rest` has no multipart upload, so the\n *   capability profile declares `fileSharing: false` and the hub should never\n *   route an attachment here. If one arrives anyway we log it rather than drop\n *   it silently, and report the count in `metadata.droppedAttachmentCount` so the\n *   caller can surface the gap.\n */\nexport async function convertOutboundForDiscord(input: ConvertOutboundInput): Promise<ChannelNativeContent> {\n  const droppedAttachmentCount = input.attachments?.length ?? 0\n  if (droppedAttachmentCount > 0) {\n    logger.warn('discord outbound attachments are not supported \u2014 sending text only', {\n      droppedAttachmentCount,\n    })\n  }\n\n  const raw = input.body ?? ''\n  const markdown = input.bodyFormat === 'html' ? htmlToMarkdown(raw) : raw\n\n  const TRUNCATE_MARKER = '\u2026'\n  const content =\n    markdown.length > DISCORD_MAX_BODY_LENGTH\n      ? markdown.slice(0, DISCORD_MAX_BODY_LENGTH - TRUNCATE_MARKER.length) + TRUNCATE_MARKER\n      : markdown\n\n  const allowedMentions =\n    (input.channelMetadata?.allowedMentions as Record<string, unknown> | undefined) ?? { parse: [] }\n\n  return {\n    content: {\n      text: content,\n      bodyFormat: 'markdown',\n    },\n    metadata: {\n      allowedMentions,\n      droppedAttachmentCount,\n      // Reply threading, dormant: no hub producer writes `replyToExternalId`\n      // into outbound metadata today, which is why `capabilities.threading` is\n      // declared `false`. Kept so that flag flips back with the hub-side\n      // producer and nothing else.\n      messageReferenceId:\n        typeof input.channelMetadata?.replyToExternalId === 'string'\n          ? (input.channelMetadata.replyToExternalId as string)\n          : undefined,\n    },\n  }\n}\n"],
+  "mappings": "AAIA,SAAS,oBAAoB;AAC7B,SAAS,+BAA+B;AAExC,MAAM,SAAS,aAAa,iBAAiB,EAAE,MAAM,EAAE,WAAW,mBAAmB,CAAC;AAQtF,SAAS,eAAe,MAAsB;AAC5C,SAAO,KACJ,QAAQ,sBAAsB,IAAI,EAClC,QAAQ,oBAAoB,MAAM,EAClC,QAAQ,iBAAiB,EAAE,EAC3B,QAAQ,6CAA6C,QAAQ,EAC7D,QAAQ,yCAAyC,MAAM,EACvD,QAAQ,yCAAyC,MAAM,EACvD,QAAQ,+DAA+D,UAAU,EACjF,QAAQ,YAAY,EAAE,EACtB,QAAQ,YAAY,GAAG,EACvB,QAAQ,WAAW,GAAG,EACtB,QAAQ,UAAU,GAAG,EACrB,QAAQ,UAAU,GAAG,EACrB,QAAQ,YAAY,GAAG,EACvB,QAAQ,WAAW,MAAM,EACzB,KAAK;AACV;AAiBA,eAAsB,0BAA0B,OAA4D;AAC1G,QAAM,yBAAyB,MAAM,aAAa,UAAU;AAC5D,MAAI,yBAAyB,GAAG;AAC9B,WAAO,KAAK,2EAAsE;AAAA,MAChF;AAAA,IACF,CAAC;AAAA,EACH;AAEA,QAAM,MAAM,MAAM,QAAQ;AAC1B,QAAM,WAAW,MAAM,eAAe,SAAS,eAAe,GAAG,IAAI;AAErE,QAAM,kBAAkB;AACxB,QAAM,UACJ,SAAS,SAAS,0BACd,SAAS,MAAM,GAAG,0BAA0B,gBAAgB,MAAM,IAAI,kBACtE;AAEN,QAAM,kBACH,MAAM,iBAAiB,mBAA2D,EAAE,OAAO,CAAC,EAAE;AAEjG,SAAO;AAAA,IACL,SAAS;AAAA,MACP,MAAM;AAAA,MACN,YAAY;AAAA,IACd;AAAA,IACA,UAAU;AAAA,MACR;AAAA,MACA;AAAA;AAAA;AAAA;AAAA;AAAA,MAKA,oBACE,OAAO,MAAM,iBAAiB,sBAAsB,WAC/C,MAAM,gBAAgB,oBACvB;AAAA,IACR;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/modules/channel_discord/lib/credentials.js

@@ -0,0 +1,61 @@
+import { z } from "zod";
+const discordCredentialsSchema = z.object({
+  // "Bot <token>" — used as `Authorization: Bot <token>` on every REST call and
+  // for the gateway Identify handshake. Never logged.
+  botToken: z.string().min(1, "Bot token required"),
+  // Application (client) id — needed to register slash commands + build invites.
+  applicationId: z.string().min(1, "Application ID required"),
+  // Ed25519 public key (hex) from the application's General Information tab —
+  // verifies signed interaction requests. Never used as a secret; safe to store.
+  publicKey: z.string().min(1, "Public key required").regex(/^[0-9a-fA-F]+$/, "Public key must be hex").refine((value) => value.length === 64, "Public key must be a 32-byte (64 hex char) Ed25519 key"),
+  // Scope the bot to one guild (recommended). Optional.
+  guildId: z.string().optional(),
+  // Default outbound text channel id (used by the test-send smoke test).
+  defaultChannelId: z.string().optional()
+}).passthrough();
+const discordChannelStateSchema = z.object({
+  sessionId: z.string().optional(),
+  sequence: z.number().nullable().optional(),
+  resumeGatewayUrl: z.string().optional(),
+  // Bot's own user id — cached after the READY event so the worker can drop
+  // events it authored (feedback-loop guard) without an extra REST call.
+  botUserId: z.string().optional(),
+  lastConnectedAt: z.string().optional(),
+  // Per-channel AI auto-reply toggle (default OFF). When truthy, the AI
+  // auto-reply subscriber may answer "easy" inbound messages and proposes a
+  // reply for everything else. Written by the channel's AI auto-reply settings
+  // form via `PUT /api/channel_discord/channels/{id}/ai-auto-reply`.
+  aiAutoReplyEnabled: z.boolean().optional(),
+  // Object-mode agent id invoked when auto-reply is enabled. Defaults to the
+  // provider's own `channel_discord.auto_reply` agent; a tenant may point it at
+  // any object-mode agent whose `requiredFeatures` its channel-bot user holds.
+  aiAgentId: z.string().optional(),
+  // Why the last auto-reply attempt produced nothing, cleared by the next
+  // attempt that gets somewhere. The settings route validates a channel's agent
+  // against the auto-reply principal before arming it, but a role edit after the
+  // fact can still make the runtime start denying the call — and the subscriber
+  // degrades to a no-op by design, because a broken model must never become a
+  // send. Without a persisted marker that leaves an "Auto-reply on" channel
+  // answering nothing with nothing for an operator to look at. Written only by
+  // `lib/channel-state-store.ts`, never by the subscriber directly.
+  aiAutoReplyLastError: z.string().optional(),
+  // When the *current* failure was first observed. A channel that keeps failing
+  // for the same reason does not rewrite the row on every inbound message, so
+  // this is a first-seen stamp rather than a last-attempt one — the alternative
+  // is a row update per message on exactly the channels already misbehaving.
+  aiAutoReplyLastErrorAt: z.string().optional()
+}).partial().passthrough();
+function parseDiscordCredentialsOrThrow(value) {
+  const parsed = discordCredentialsSchema.safeParse(value);
+  if (!parsed.success) {
+    const first = parsed.error.issues[0];
+    throw new Error(`[internal] Invalid Discord credentials: ${first?.message ?? "unknown validation error"}`);
+  }
+  return parsed.data;
+}
+export {
+  discordChannelStateSchema,
+  discordCredentialsSchema,
+  parseDiscordCredentialsOrThrow
+};
+//# sourceMappingURL=credentials.js.map

package/dist/modules/channel_discord/lib/credentials.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/lib/credentials.ts"],
+  "sourcesContent": ["import { z } from 'zod'\n\n/**\n * Discord bot channel credentials (SPEC 2026-06-19 \u00A7 Data models).\n *\n * The hub persists this blob inside `IntegrationCredentials.credentials`\n * (encrypted at rest, scope `channel_discord`). Never log any value \u2014 the bot\n * token grants full control of the bot user.\n *\n * `.passthrough()` (not `.strict()`) so the connect-credential-channel command\n * can stash bookkeeping fields (e.g. `userId`) alongside the entered credentials,\n * mirroring the IMAP provider.\n */\nexport const discordCredentialsSchema = z\n  .object({\n    // \"Bot <token>\" \u2014 used as `Authorization: Bot <token>` on every REST call and\n    // for the gateway Identify handshake. Never logged.\n    botToken: z.string().min(1, 'Bot token required'),\n    // Application (client) id \u2014 needed to register slash commands + build invites.\n    applicationId: z.string().min(1, 'Application ID required'),\n    // Ed25519 public key (hex) from the application's General Information tab \u2014\n    // verifies signed interaction requests. Never used as a secret; safe to store.\n    publicKey: z\n      .string()\n      .min(1, 'Public key required')\n      .regex(/^[0-9a-fA-F]+$/, 'Public key must be hex')\n      .refine((value) => value.length === 64, 'Public key must be a 32-byte (64 hex char) Ed25519 key'),\n    // Scope the bot to one guild (recommended). Optional.\n    guildId: z.string().optional(),\n    // Default outbound text channel id (used by the test-send smoke test).\n    defaultChannelId: z.string().optional(),\n  })\n  .passthrough()\n\nexport type DiscordCredentials = z.infer<typeof discordCredentialsSchema>\n\n/**\n * Gateway resume state persisted on `CommunicationChannel.channelState` (JSONB,\n * additive) so the worker can `RESUME` instead of re-`IDENTIFY` after a\n * disconnect. Discord requires the stored `resumeGatewayUrl` + `sessionId` +\n * last `sequence` to resume a session.\n */\nexport const discordChannelStateSchema = z\n  .object({\n    sessionId: z.string().optional(),\n    sequence: z.number().nullable().optional(),\n    resumeGatewayUrl: z.string().optional(),\n    // Bot's own user id \u2014 cached after the READY event so the worker can drop\n    // events it authored (feedback-loop guard) without an extra REST call.\n    botUserId: z.string().optional(),\n    lastConnectedAt: z.string().optional(),\n    // Per-channel AI auto-reply toggle (default OFF). When truthy, the AI\n    // auto-reply subscriber may answer \"easy\" inbound messages and proposes a\n    // reply for everything else. Written by the channel's AI auto-reply settings\n    // form via `PUT /api/channel_discord/channels/{id}/ai-auto-reply`.\n    aiAutoReplyEnabled: z.boolean().optional(),\n    // Object-mode agent id invoked when auto-reply is enabled. Defaults to the\n    // provider's own `channel_discord.auto_reply` agent; a tenant may point it at\n    // any object-mode agent whose `requiredFeatures` its channel-bot user holds.\n    aiAgentId: z.string().optional(),\n    // Why the last auto-reply attempt produced nothing, cleared by the next\n    // attempt that gets somewhere. The settings route validates a channel's agent\n    // against the auto-reply principal before arming it, but a role edit after the\n    // fact can still make the runtime start denying the call \u2014 and the subscriber\n    // degrades to a no-op by design, because a broken model must never become a\n    // send. Without a persisted marker that leaves an \"Auto-reply on\" channel\n    // answering nothing with nothing for an operator to look at. Written only by\n    // `lib/channel-state-store.ts`, never by the subscriber directly.\n    aiAutoReplyLastError: z.string().optional(),\n    // When the *current* failure was first observed. A channel that keeps failing\n    // for the same reason does not rewrite the row on every inbound message, so\n    // this is a first-seen stamp rather than a last-attempt one \u2014 the alternative\n    // is a row update per message on exactly the channels already misbehaving.\n    aiAutoReplyLastErrorAt: z.string().optional(),\n  })\n  .partial()\n  .passthrough()\n\nexport type DiscordChannelState = z.infer<typeof discordChannelStateSchema>\n\nexport function parseDiscordCredentialsOrThrow(value: unknown): DiscordCredentials {\n  const parsed = discordCredentialsSchema.safeParse(value)\n  if (!parsed.success) {\n    const first = parsed.error.issues[0]\n    throw new Error(`[internal] Invalid Discord credentials: ${first?.message ?? 'unknown validation error'}`)\n  }\n  return parsed.data\n}\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAaX,MAAM,2BAA2B,EACrC,OAAO;AAAA;AAAA;AAAA,EAGN,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,oBAAoB;AAAA;AAAA,EAEhD,eAAe,EAAE,OAAO,EAAE,IAAI,GAAG,yBAAyB;AAAA;AAAA;AAAA,EAG1D,WAAW,EACR,OAAO,EACP,IAAI,GAAG,qBAAqB,EAC5B,MAAM,kBAAkB,wBAAwB,EAChD,OAAO,CAAC,UAAU,MAAM,WAAW,IAAI,wDAAwD;AAAA;AAAA,EAElG,SAAS,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA,EAE7B,kBAAkB,EAAE,OAAO,EAAE,SAAS;AACxC,CAAC,EACA,YAAY;AAUR,MAAM,4BAA4B,EACtC,OAAO;AAAA,EACN,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS;AAAA,EACzC,kBAAkB,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA;AAAA,EAGtC,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA,EAC/B,iBAAiB,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,EAKrC,oBAAoB,EAAE,QAAQ,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA,EAIzC,WAAW,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAS/B,sBAAsB,EAAE,OAAO,EAAE,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA,EAK1C,wBAAwB,EAAE,OAAO,EAAE,SAAS;AAC9C,CAAC,EACA,QAAQ,EACR,YAAY;AAIR,SAAS,+BAA+B,OAAoC;AACjF,QAAM,SAAS,yBAAyB,UAAU,KAAK;AACvD,MAAI,CAAC,OAAO,SAAS;AACnB,UAAM,QAAQ,OAAO,MAAM,OAAO,CAAC;AACnC,UAAM,IAAI,MAAM,2CAA2C,OAAO,WAAW,0BAA0B,EAAE;AAAA,EAC3G;AACA,SAAO,OAAO;AAChB;",
+  "names": []
+}

package/dist/modules/channel_discord/lib/discord-gateway-client.js

@@ -0,0 +1,289 @@
+const GatewayOpcode = {
+  DISPATCH: 0,
+  HEARTBEAT: 1,
+  IDENTIFY: 2,
+  RESUME: 6,
+  RECONNECT: 7,
+  INVALID_SESSION: 9,
+  HELLO: 10,
+  HEARTBEAT_ACK: 11
+};
+const INTENT_GUILDS = 1 << 0;
+const INTENT_GUILD_MESSAGES = 1 << 9;
+const INTENT_GUILD_MESSAGE_REACTIONS = 1 << 10;
+const INTENT_MESSAGE_CONTENT = 1 << 15;
+const DISCORD_GATEWAY_INTENTS = INTENT_GUILDS | INTENT_GUILD_MESSAGES | INTENT_GUILD_MESSAGE_REACTIONS | INTENT_MESSAGE_CONTENT;
+const DISCORD_GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+const FATAL_CLOSE_CODES = /* @__PURE__ */ new Set([4004, 4010, 4011, 4012, 4013, 4014]);
+function isFatalGatewayCloseCode(code) {
+  return typeof code === "number" && FATAL_CLOSE_CODES.has(code);
+}
+function shouldResumeAfterClose(code) {
+  if (code === void 0) return true;
+  if (isFatalGatewayCloseCode(code)) return false;
+  return code !== 4007 && code !== 4009 && code !== 1e3 && code !== 1001;
+}
+function createHeartbeatMonitor() {
+  let acked = true;
+  return {
+    onBeat() {
+      if (!acked) return "reconnect";
+      acked = false;
+      return "send";
+    },
+    onAck() {
+      acked = true;
+    },
+    reset() {
+      acked = true;
+    },
+    isAcked() {
+      return acked;
+    }
+  };
+}
+function computeReconnectDelayMs(attempt) {
+  const base = 1e3 * Math.pow(2, Math.min(attempt, 5));
+  const jitter = Math.floor(Math.random() * 500);
+  return Math.min(base + jitter, 3e4);
+}
+function buildIdentifyPayload(botToken, intents = DISCORD_GATEWAY_INTENTS) {
+  return {
+    op: GatewayOpcode.IDENTIFY,
+    d: {
+      token: botToken,
+      intents,
+      properties: { os: "linux", browser: "open-mercato", device: "open-mercato" }
+    }
+  };
+}
+function buildResumePayload(botToken, sessionId, seq) {
+  return {
+    op: GatewayOpcode.RESUME,
+    d: { token: botToken, session_id: sessionId, seq }
+  };
+}
+function buildHeartbeatPayload(seq) {
+  return { op: GatewayOpcode.HEARTBEAT, d: seq };
+}
+class NativeDiscordGatewayClient {
+  connect(options) {
+    const connection = new GatewaySession(options);
+    connection.open();
+    return {
+      close: () => connection.stop(),
+      isActive: () => connection.isRunning()
+    };
+  }
+}
+class GatewaySession {
+  constructor(options) {
+    this.options = options;
+    this.ws = null;
+    this.heartbeatTimer = null;
+    this.heartbeat = createHeartbeatMonitor();
+    this.sequence = null;
+    this.stopped = false;
+    this.attempt = 0;
+    this.sequence = options.resumeState?.sequence ?? null;
+    this.sessionId = options.resumeState?.sessionId;
+    this.resumeGatewayUrl = options.resumeState?.resumeGatewayUrl;
+  }
+  open() {
+    if (this.stopped) return;
+    const url = this.canResume() ? `${this.resumeGatewayUrl}?v=10&encoding=json` : DISCORD_GATEWAY_URL;
+    const factory = this.options.webSocketFactory ?? defaultWebSocketFactory;
+    const ws = factory(url);
+    this.ws = ws;
+    ws.addEventListener("message", (event) => this.onMessage(event));
+    ws.addEventListener("close", (event) => this.onClose(event));
+    ws.addEventListener("error", () => {
+    });
+  }
+  stop() {
+    this.stopped = true;
+    this.clearHeartbeat();
+    try {
+      this.ws?.close(1e3, "client stop");
+    } catch {
+    }
+    this.ws = null;
+  }
+  isRunning() {
+    return !this.stopped;
+  }
+  canResume() {
+    return Boolean(this.sessionId && this.resumeGatewayUrl);
+  }
+  /**
+   * Drop the resume state so the next connect performs a fresh `IDENTIFY`
+   * instead of a `RESUME` that Discord would reject again.
+   */
+  forgetSession() {
+    this.sessionId = void 0;
+    this.resumeGatewayUrl = void 0;
+    this.sequence = null;
+    this.options.onResumeStateChange?.({ sessionId: void 0, sequence: null, resumeGatewayUrl: void 0 });
+  }
+  onMessage(event) {
+    const data = event?.data;
+    if (typeof data !== "string") return;
+    let payload;
+    try {
+      payload = JSON.parse(data);
+    } catch {
+      return;
+    }
+    if (typeof payload.s === "number") {
+      this.sequence = payload.s;
+      this.options.onResumeStateChange?.({
+        sessionId: this.sessionId,
+        sequence: this.sequence,
+        resumeGatewayUrl: this.resumeGatewayUrl
+      });
+    }
+    switch (payload.op) {
+      case GatewayOpcode.HELLO: {
+        const interval = payload.d?.heartbeat_interval ?? 41250;
+        this.startHeartbeat(interval);
+        if (this.canResume()) {
+          this.sendJson(buildResumePayload(this.options.botToken, this.sessionId, this.sequence));
+        } else {
+          this.sendJson(buildIdentifyPayload(this.options.botToken, this.options.intents ?? DISCORD_GATEWAY_INTENTS));
+        }
+        break;
+      }
+      case GatewayOpcode.HEARTBEAT: {
+        this.sendJson(buildHeartbeatPayload(this.sequence));
+        break;
+      }
+      case GatewayOpcode.HEARTBEAT_ACK: {
+        this.heartbeat.onAck();
+        break;
+      }
+      case GatewayOpcode.INVALID_SESSION: {
+        if (payload.d !== true) this.forgetSession();
+        this.clearHeartbeat();
+        try {
+          this.ws?.close(4e3, "invalid session");
+        } catch {
+        }
+        break;
+      }
+      case GatewayOpcode.RECONNECT: {
+        try {
+          this.ws?.close(4e3, "server requested reconnect");
+        } catch {
+        }
+        break;
+      }
+      case GatewayOpcode.DISPATCH: {
+        this.attempt = 0;
+        void this.onDispatch(payload.t ?? "", payload.d);
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  async onDispatch(type, data) {
+    if (type === "READY") {
+      const ready = data;
+      this.sessionId = ready.session_id;
+      this.resumeGatewayUrl = ready.resume_gateway_url;
+      const resumeState = {
+        sessionId: this.sessionId,
+        sequence: this.sequence,
+        resumeGatewayUrl: this.resumeGatewayUrl
+      };
+      this.options.onResumeStateChange?.(resumeState);
+      await this.options.onReady({ botUserId: ready.user?.id ?? "", resumeState });
+      return;
+    }
+    if (type === "MESSAGE_CREATE") {
+      await this.options.onMessage(data);
+      return;
+    }
+    if (type === "MESSAGE_REACTION_ADD") {
+      await this.options.onReaction(data, "added");
+      return;
+    }
+    if (type === "MESSAGE_REACTION_REMOVE") {
+      await this.options.onReaction(data, "removed");
+      return;
+    }
+  }
+  onClose(event) {
+    this.clearHeartbeat();
+    const code = event?.code;
+    if (isFatalGatewayCloseCode(code)) {
+      void this.options.onRequiresReauth({ code });
+      this.stopped = true;
+      return;
+    }
+    if (!shouldResumeAfterClose(code)) {
+      this.forgetSession();
+    }
+    if (this.stopped) return;
+    const delay = computeReconnectDelayMs(this.attempt);
+    this.attempt += 1;
+    setTimeout(() => this.open(), delay);
+  }
+  startHeartbeat(intervalMs) {
+    this.clearHeartbeat();
+    this.heartbeat.reset();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.heartbeat.onBeat() === "reconnect") {
+        this.clearHeartbeat();
+        try {
+          this.ws?.close(4e3, "heartbeat ack timeout");
+        } catch {
+        }
+        return;
+      }
+      this.sendJson(buildHeartbeatPayload(this.sequence));
+    }, intervalMs);
+  }
+  clearHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  sendJson(payload) {
+    try {
+      this.ws?.send(JSON.stringify(payload));
+    } catch {
+    }
+  }
+}
+function defaultWebSocketFactory(url) {
+  const globalWebSocket = globalThis.WebSocket;
+  if (!globalWebSocket) {
+    throw new Error("[internal] global WebSocket is unavailable \u2014 Node >= 22 is required for the Discord gateway worker");
+  }
+  return new globalWebSocket(url);
+}
+let cachedClient = null;
+function getDiscordGatewayClient() {
+  if (!cachedClient) cachedClient = new NativeDiscordGatewayClient();
+  return cachedClient;
+}
+function setDiscordGatewayClient(client) {
+  cachedClient = client;
+}
+export {
+  DISCORD_GATEWAY_INTENTS,
+  DISCORD_GATEWAY_URL,
+  GatewayOpcode,
+  buildHeartbeatPayload,
+  buildIdentifyPayload,
+  buildResumePayload,
+  computeReconnectDelayMs,
+  createHeartbeatMonitor,
+  getDiscordGatewayClient,
+  isFatalGatewayCloseCode,
+  setDiscordGatewayClient,
+  shouldResumeAfterClose
+};
+//# sourceMappingURL=discord-gateway-client.js.map

package/dist/modules/channel_discord/lib/discord-gateway-client.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/lib/discord-gateway-client.ts"],
+  "sourcesContent": ["import type { DiscordMessageObject } from './discord-rest'\n\n/**\n * Discord Gateway (WebSocket) client. Uses the Node >= 22 built-in global\n * `WebSocket` \u2014 no `ws` dependency. The network-touching class only opens a\n * socket when `connect()` is called, so importing this module has no side\n * effects; the state-machine helpers below are pure and unit-tested.\n *\n * Swappable in tests / alternate transports via `setDiscordGatewayClient(...)`.\n */\n\n// \u2500\u2500 Gateway opcodes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nexport const GatewayOpcode = {\n  DISPATCH: 0,\n  HEARTBEAT: 1,\n  IDENTIFY: 2,\n  RESUME: 6,\n  RECONNECT: 7,\n  INVALID_SESSION: 9,\n  HELLO: 10,\n  HEARTBEAT_ACK: 11,\n} as const\n\n// \u2500\u2500 Gateway intents (bitfield) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\nconst INTENT_GUILDS = 1 << 0\nconst INTENT_GUILD_MESSAGES = 1 << 9\nconst INTENT_GUILD_MESSAGE_REACTIONS = 1 << 10\nconst INTENT_MESSAGE_CONTENT = 1 << 15\n\n/**\n * Default intents the bot identifies with: guild lifecycle, guild message\n * create/reactions, and (privileged) message content so inbound text is\n * readable. `DIRECT_MESSAGES` is intentionally omitted for the first release.\n */\nexport const DISCORD_GATEWAY_INTENTS =\n  INTENT_GUILDS | INTENT_GUILD_MESSAGES | INTENT_GUILD_MESSAGE_REACTIONS | INTENT_MESSAGE_CONTENT\n\nexport const DISCORD_GATEWAY_URL = 'wss://gateway.discord.gg/?v=10&encoding=json'\n\n/**\n * Fatal close codes: the bot token or intents are wrong and reconnecting will\n * not help. The worker surfaces these as `requires_reauth` instead of looping.\n * 4004 Authentication failed, 4014 Disallowed intents.\n */\nconst FATAL_CLOSE_CODES = new Set([4004, 4010, 4011, 4012, 4013, 4014])\n\nexport function isFatalGatewayCloseCode(code: number | undefined): boolean {\n  return typeof code === 'number' && FATAL_CLOSE_CODES.has(code)\n}\n\n/**\n * Whether a close code invalidates the current session so the next connect must\n * re-`IDENTIFY` (fresh session) rather than `RESUME`. 4007 (invalid seq) and\n * 4009 (session timed out) require a fresh identify.\n */\nexport function shouldResumeAfterClose(code: number | undefined): boolean {\n  if (code === undefined) return true\n  if (isFatalGatewayCloseCode(code)) return false\n  return code !== 4007 && code !== 4009 && code !== 1000 && code !== 1001\n}\n\n/**\n * Heartbeat/ACK zombie detector. Discord expects a Heartbeat ACK (opcode 11)\n * after every heartbeat we send; a missing ACK before the next heartbeat means\n * the connection is a zombie (TCP up, gateway dead) and MUST be torn down +\n * reconnected rather than left silently deaf. Pure + unit-testable.\n *\n * Contract: call `onBeat()` on each heartbeat-interval tick \u2014 it returns\n * `'reconnect'` when the previous beat was never acked, else `'send'` (and marks\n * the new beat pending). Call `onAck()` on opcode 11. `reset()` re-arms after a\n * fresh (re)connect.\n */\nexport function createHeartbeatMonitor() {\n  let acked = true\n  return {\n    onBeat(): 'send' | 'reconnect' {\n      if (!acked) return 'reconnect'\n      acked = false\n      return 'send'\n    },\n    onAck(): void {\n      acked = true\n    },\n    reset(): void {\n      acked = true\n    },\n    isAcked(): boolean {\n      return acked\n    },\n  }\n}\n\nexport type HeartbeatMonitor = ReturnType<typeof createHeartbeatMonitor>\n\n/** Exponential backoff with jitter, capped, for reconnect attempts. */\nexport function computeReconnectDelayMs(attempt: number): number {\n  const base = 1000 * Math.pow(2, Math.min(attempt, 5))\n  const jitter = Math.floor(Math.random() * 500)\n  return Math.min(base + jitter, 30_000)\n}\n\nexport interface IdentifyPayload {\n  op: number\n  d: {\n    token: string\n    intents: number\n    properties: { os: string; browser: string; device: string }\n  }\n}\n\nexport function buildIdentifyPayload(botToken: string, intents: number = DISCORD_GATEWAY_INTENTS): IdentifyPayload {\n  return {\n    op: GatewayOpcode.IDENTIFY,\n    d: {\n      token: botToken,\n      intents,\n      properties: { os: 'linux', browser: 'open-mercato', device: 'open-mercato' },\n    },\n  }\n}\n\nexport interface ResumePayload {\n  op: number\n  d: { token: string; session_id: string; seq: number | null }\n}\n\nexport function buildResumePayload(botToken: string, sessionId: string, seq: number | null): ResumePayload {\n  return {\n    op: GatewayOpcode.RESUME,\n    d: { token: botToken, session_id: sessionId, seq },\n  }\n}\n\nexport function buildHeartbeatPayload(seq: number | null): { op: number; d: number | null } {\n  return { op: GatewayOpcode.HEARTBEAT, d: seq }\n}\n\n// \u2500\u2500 Connection interface \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n\nexport interface GatewayResumeState {\n  sessionId?: string\n  sequence?: number | null\n  resumeGatewayUrl?: string\n}\n\nexport interface DiscordGatewayConnectOptions {\n  botToken: string\n  intents?: number\n  resumeState?: GatewayResumeState\n  /** Called for each `MESSAGE_CREATE` dispatch. */\n  onMessage: (message: DiscordMessageObject) => void | Promise<void>\n  /** Called for each `MESSAGE_REACTION_ADD` / `_REMOVE` dispatch. */\n  onReaction: (reaction: Record<string, unknown>, action: 'added' | 'removed') => void | Promise<void>\n  /** Called on READY with the bot's own user id + fresh resume state. */\n  onReady: (info: { botUserId: string; resumeState: GatewayResumeState }) => void | Promise<void>\n  /** Called on a fatal auth/intents close code (4004/4014). */\n  onRequiresReauth: (info: { code: number }) => void | Promise<void>\n  /** Optional persisted resume-state updates (session id + sequence). */\n  onResumeStateChange?: (resumeState: GatewayResumeState) => void\n  /** Injected WebSocket factory for tests; defaults to global `WebSocket`. */\n  webSocketFactory?: (url: string) => GatewayWebSocketLike\n}\n\nexport interface GatewayWebSocketLike {\n  send(data: string): void\n  close(code?: number, reason?: string): void\n  addEventListener(type: 'open' | 'message' | 'close' | 'error', listener: (event: unknown) => void): void\n}\n\nexport interface DiscordGatewayHandle {\n  /** Close the socket and stop reconnecting. */\n  close(): void\n  /**\n   * Whether this handle still owns a running session. A session that is merely\n   * between sockets (reconnect backoff after a resumable close) is still active \u2014\n   * it heals itself. It reports inactive only after `close()` or a fatal close\n   * code, which is exactly when the gateway worker must open a new one.\n   */\n  isActive(): boolean\n}\n\nexport interface DiscordGatewayClient {\n  connect(options: DiscordGatewayConnectOptions): DiscordGatewayHandle\n}\n\n/**\n * Native-WebSocket-backed gateway connection. Handles the HELLO\u2192IDENTIFY/RESUME\n * handshake, heartbeat with sequence tracking, dispatch fan-out, and\n * reconnect-with-backoff. One instance owns exactly one socket.\n */\nclass NativeDiscordGatewayClient implements DiscordGatewayClient {\n  connect(options: DiscordGatewayConnectOptions): DiscordGatewayHandle {\n    const connection = new GatewaySession(options)\n    connection.open()\n    return {\n      close: () => connection.stop(),\n      isActive: () => connection.isRunning(),\n    }\n  }\n}\n\nclass GatewaySession {\n  private ws: GatewayWebSocketLike | null = null\n  private heartbeatTimer: ReturnType<typeof setInterval> | null = null\n  private readonly heartbeat = createHeartbeatMonitor()\n  private sequence: number | null = null\n  private sessionId: string | undefined\n  private resumeGatewayUrl: string | undefined\n  private stopped = false\n  private attempt = 0\n\n  constructor(private readonly options: DiscordGatewayConnectOptions) {\n    this.sequence = options.resumeState?.sequence ?? null\n    this.sessionId = options.resumeState?.sessionId\n    this.resumeGatewayUrl = options.resumeState?.resumeGatewayUrl\n  }\n\n  open(): void {\n    if (this.stopped) return\n    const url = this.canResume() ? `${this.resumeGatewayUrl}?v=10&encoding=json` : DISCORD_GATEWAY_URL\n    const factory = this.options.webSocketFactory ?? defaultWebSocketFactory\n    const ws = factory(url)\n    this.ws = ws\n    ws.addEventListener('message', (event) => this.onMessage(event))\n    ws.addEventListener('close', (event) => this.onClose(event))\n    ws.addEventListener('error', () => {\n      /* the close handler drives reconnect; errors are logged by the worker */\n    })\n  }\n\n  stop(): void {\n    this.stopped = true\n    this.clearHeartbeat()\n    try {\n      this.ws?.close(1000, 'client stop')\n    } catch {\n      /* ignore */\n    }\n    this.ws = null\n  }\n\n  isRunning(): boolean {\n    return !this.stopped\n  }\n\n  private canResume(): boolean {\n    return Boolean(this.sessionId && this.resumeGatewayUrl)\n  }\n\n  /**\n   * Drop the resume state so the next connect performs a fresh `IDENTIFY`\n   * instead of a `RESUME` that Discord would reject again.\n   */\n  private forgetSession(): void {\n    this.sessionId = undefined\n    this.resumeGatewayUrl = undefined\n    this.sequence = null\n    this.options.onResumeStateChange?.({ sessionId: undefined, sequence: null, resumeGatewayUrl: undefined })\n  }\n\n  private onMessage(event: unknown): void {\n    const data = (event as { data?: unknown })?.data\n    if (typeof data !== 'string') return\n    let payload: { op: number; d?: unknown; s?: number | null; t?: string | null }\n    try {\n      payload = JSON.parse(data)\n    } catch {\n      return\n    }\n    if (typeof payload.s === 'number') {\n      this.sequence = payload.s\n      this.options.onResumeStateChange?.({\n        sessionId: this.sessionId,\n        sequence: this.sequence,\n        resumeGatewayUrl: this.resumeGatewayUrl,\n      })\n    }\n\n    switch (payload.op) {\n      case GatewayOpcode.HELLO: {\n        const interval = (payload.d as { heartbeat_interval?: number } | undefined)?.heartbeat_interval ?? 41250\n        this.startHeartbeat(interval)\n        if (this.canResume()) {\n          this.sendJson(buildResumePayload(this.options.botToken, this.sessionId as string, this.sequence))\n        } else {\n          this.sendJson(buildIdentifyPayload(this.options.botToken, this.options.intents ?? DISCORD_GATEWAY_INTENTS))\n        }\n        break\n      }\n      case GatewayOpcode.HEARTBEAT: {\n        // Server-requested immediate heartbeat.\n        this.sendJson(buildHeartbeatPayload(this.sequence))\n        break\n      }\n      case GatewayOpcode.HEARTBEAT_ACK: {\n        this.heartbeat.onAck()\n        break\n      }\n      case GatewayOpcode.INVALID_SESSION: {\n        // `d` is Discord's `resumable` flag. When it is `false` the session is\n        // dead and the next connect MUST re-`IDENTIFY`; when it is `true` the\n        // stored session survives and the next connect may `RESUME`.\n        //\n        // Either way Discord stops serving this socket, so we have to close it\n        // and let `onClose` run the shared backoff + handshake path. Only\n        // clearing the resume state (the previous behaviour) left the socket\n        // open but permanently deaf: no dispatches, no reconnect, no error.\n        if (payload.d !== true) this.forgetSession()\n        this.clearHeartbeat()\n        try {\n          this.ws?.close(4000, 'invalid session')\n        } catch {\n          /* the close handler reconnects */\n        }\n        break\n      }\n      case GatewayOpcode.RECONNECT: {\n        try {\n          this.ws?.close(4000, 'server requested reconnect')\n        } catch {\n          /* the close handler reconnects */\n        }\n        break\n      }\n      case GatewayOpcode.DISPATCH: {\n        this.attempt = 0\n        void this.onDispatch(payload.t ?? '', payload.d)\n        break\n      }\n      default:\n        break\n    }\n  }\n\n  private async onDispatch(type: string, data: unknown): Promise<void> {\n    if (type === 'READY') {\n      const ready = data as { session_id?: string; resume_gateway_url?: string; user?: { id?: string } }\n      this.sessionId = ready.session_id\n      this.resumeGatewayUrl = ready.resume_gateway_url\n      const resumeState: GatewayResumeState = {\n        sessionId: this.sessionId,\n        sequence: this.sequence,\n        resumeGatewayUrl: this.resumeGatewayUrl,\n      }\n      this.options.onResumeStateChange?.(resumeState)\n      await this.options.onReady({ botUserId: ready.user?.id ?? '', resumeState })\n      return\n    }\n    if (type === 'MESSAGE_CREATE') {\n      await this.options.onMessage(data as DiscordMessageObject)\n      return\n    }\n    if (type === 'MESSAGE_REACTION_ADD') {\n      await this.options.onReaction(data as Record<string, unknown>, 'added')\n      return\n    }\n    if (type === 'MESSAGE_REACTION_REMOVE') {\n      await this.options.onReaction(data as Record<string, unknown>, 'removed')\n      return\n    }\n  }\n\n  private onClose(event: unknown): void {\n    this.clearHeartbeat()\n    const code = (event as { code?: number })?.code\n    if (isFatalGatewayCloseCode(code)) {\n      void this.options.onRequiresReauth({ code: code as number })\n      this.stopped = true\n      return\n    }\n    if (!shouldResumeAfterClose(code)) {\n      this.forgetSession()\n    }\n    if (this.stopped) return\n    const delay = computeReconnectDelayMs(this.attempt)\n    this.attempt += 1\n    setTimeout(() => this.open(), delay)\n  }\n\n  private startHeartbeat(intervalMs: number): void {\n    this.clearHeartbeat()\n    this.heartbeat.reset()\n    this.heartbeatTimer = setInterval(() => {\n      if (this.heartbeat.onBeat() === 'reconnect') {\n        // Previous heartbeat was never ACKed \u2192 zombie connection. Force a close\n        // so the close handler reconnects (with resume) instead of staying deaf.\n        this.clearHeartbeat()\n        try {\n          this.ws?.close(4000, 'heartbeat ack timeout')\n        } catch {\n          /* the close handler reconnects */\n        }\n        return\n      }\n      this.sendJson(buildHeartbeatPayload(this.sequence))\n    }, intervalMs)\n  }\n\n  private clearHeartbeat(): void {\n    if (this.heartbeatTimer) {\n      clearInterval(this.heartbeatTimer)\n      this.heartbeatTimer = null\n    }\n  }\n\n  private sendJson(payload: unknown): void {\n    try {\n      this.ws?.send(JSON.stringify(payload))\n    } catch {\n      /* the close handler drives reconnect */\n    }\n  }\n}\n\nfunction defaultWebSocketFactory(url: string): GatewayWebSocketLike {\n  const globalWebSocket = (globalThis as { WebSocket?: new (url: string) => GatewayWebSocketLike }).WebSocket\n  if (!globalWebSocket) {\n    throw new Error('[internal] global WebSocket is unavailable \u2014 Node >= 22 is required for the Discord gateway worker')\n  }\n  return new globalWebSocket(url)\n}\n\nlet cachedClient: DiscordGatewayClient | null = null\n\nexport function getDiscordGatewayClient(): DiscordGatewayClient {\n  if (!cachedClient) cachedClient = new NativeDiscordGatewayClient()\n  return cachedClient\n}\n\nexport function setDiscordGatewayClient(client: DiscordGatewayClient | null): void {\n  cachedClient = client\n}\n"],
+  "mappings": "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",
+  "names": []
+}