@gakr-gakr/discord 0.1.0

package/src/monitor/startup-status.ts

@@ -0,0 +1,10 @@
+export function formatDiscordStartupStatusMessage(params: {
+  gatewayReady: boolean;
+  botIdentity?: string;
+}): string {
+  const identitySuffix = params.botIdentity ? ` as ${params.botIdentity}` : "";
+  if (params.gatewayReady) {
+    return `logged in to discord${identitySuffix}`;
+  }
+  return `discord client initialized${identitySuffix}; awaiting gateway readiness`;
+}

package/src/monitor/status.ts

@@ -0,0 +1,22 @@
+type DiscordMonitorStatusPatch = {
+  connected?: boolean;
+  lastEventAt?: number | null;
+  lastTransportActivityAt?: number | null;
+  lastConnectedAt?: number | null;
+  lastDisconnect?:
+    | string
+    | {
+        at: number;
+        status?: number;
+        error?: string;
+        loggedOut?: boolean;
+      }
+    | null;
+  lastInboundAt?: number | null;
+  lastError?: string | null;
+  busy?: boolean;
+  activeRuns?: number;
+  lastRunActivityAt?: number | null;
+};
+
+export type DiscordMonitorStatusSink = (patch: DiscordMonitorStatusPatch) => void;

package/src/monitor/system-events.ts

@@ -0,0 +1,55 @@
+import { type Message, MessageType } from "../internal/discord.js";
+import { formatDiscordUserTag } from "./format.js";
+
+export function resolveDiscordSystemEvent(message: Message, location: string): string | null {
+  switch (message.type) {
+    case MessageType.ChannelPinnedMessage:
+      return buildDiscordSystemEvent(message, location, "pinned a message");
+    case MessageType.RecipientAdd:
+      return buildDiscordSystemEvent(message, location, "added a recipient");
+    case MessageType.RecipientRemove:
+      return buildDiscordSystemEvent(message, location, "removed a recipient");
+    case MessageType.UserJoin:
+      return buildDiscordSystemEvent(message, location, "user joined");
+    case MessageType.GuildBoost:
+      return buildDiscordSystemEvent(message, location, "boosted the server");
+    case MessageType.GuildBoostTier1:
+      return buildDiscordSystemEvent(message, location, "boosted the server (Tier 1 reached)");
+    case MessageType.GuildBoostTier2:
+      return buildDiscordSystemEvent(message, location, "boosted the server (Tier 2 reached)");
+    case MessageType.GuildBoostTier3:
+      return buildDiscordSystemEvent(message, location, "boosted the server (Tier 3 reached)");
+    case MessageType.ThreadCreated:
+      return buildDiscordSystemEvent(message, location, "created a thread");
+    case MessageType.AutoModerationAction:
+      return buildDiscordSystemEvent(message, location, "auto moderation action");
+    case MessageType.GuildIncidentAlertModeEnabled:
+      return buildDiscordSystemEvent(message, location, "raid protection enabled");
+    case MessageType.GuildIncidentAlertModeDisabled:
+      return buildDiscordSystemEvent(message, location, "raid protection disabled");
+    case MessageType.GuildIncidentReportRaid:
+      return buildDiscordSystemEvent(message, location, "raid reported");
+    case MessageType.GuildIncidentReportFalseAlarm:
+      return buildDiscordSystemEvent(message, location, "raid report marked false alarm");
+    case MessageType.StageStart:
+      return buildDiscordSystemEvent(message, location, "stage started");
+    case MessageType.StageEnd:
+      return buildDiscordSystemEvent(message, location, "stage ended");
+    case MessageType.StageSpeaker:
+      return buildDiscordSystemEvent(message, location, "stage speaker updated");
+    case MessageType.StageTopic:
+      return buildDiscordSystemEvent(message, location, "stage topic updated");
+    case MessageType.PollResult:
+      return buildDiscordSystemEvent(message, location, "poll results posted");
+    case MessageType.PurchaseNotification:
+      return buildDiscordSystemEvent(message, location, "purchase notification");
+    default:
+      return null;
+  }
+}
+
+function buildDiscordSystemEvent(message: Message, location: string, action: string) {
+  const authorLabel = message.author ? formatDiscordUserTag(message.author) : "";
+  const actor = authorLabel ? `${authorLabel} ` : "";
+  return `Discord system: ${actor}${action} in ${location}`;
+}

package/src/monitor/thread-bindings.config.ts

@@ -0,0 +1,35 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  resolveThreadBindingIdleTimeoutMs,
+  resolveThreadBindingMaxAgeMs,
+  resolveThreadBindingsEnabled,
+} from "autobot/plugin-sdk/conversation-runtime";
+import { normalizeAccountId } from "autobot/plugin-sdk/routing";
+
+export { resolveThreadBindingsEnabled };
+
+export function resolveDiscordThreadBindingIdleTimeoutMs(params: {
+  cfg: AutoBotConfig;
+  accountId?: string;
+}): number {
+  const accountId = normalizeAccountId(params.accountId);
+  const root = params.cfg.channels?.discord?.threadBindings;
+  const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
+  return resolveThreadBindingIdleTimeoutMs({
+    channelIdleHoursRaw: account?.idleHours ?? root?.idleHours,
+    sessionIdleHoursRaw: params.cfg.session?.threadBindings?.idleHours,
+  });
+}
+
+export function resolveDiscordThreadBindingMaxAgeMs(params: {
+  cfg: AutoBotConfig;
+  accountId?: string;
+}): number {
+  const accountId = normalizeAccountId(params.accountId);
+  const root = params.cfg.channels?.discord?.threadBindings;
+  const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
+  return resolveThreadBindingMaxAgeMs({
+    channelMaxAgeHoursRaw: account?.maxAgeHours ?? root?.maxAgeHours,
+    sessionMaxAgeHoursRaw: params.cfg.session?.threadBindings?.maxAgeHours,
+  });
+}

package/src/monitor/thread-bindings.discord-api.ts

@@ -0,0 +1,310 @@
+import { ChannelType } from "discord-api-types/v10";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { logVerbose } from "autobot/plugin-sdk/runtime-env";
+import { normalizeOptionalString } from "autobot/plugin-sdk/string-coerce-runtime";
+import { createDiscordRestClient } from "../client.js";
+import { createChannelWebhook, getChannel } from "../internal/discord.js";
+import { sendMessageDiscord, sendWebhookMessageDiscord } from "../send.js";
+import { createThreadDiscord } from "../send.messages.js";
+import { resolveDiscordChannelId } from "../target-parsing.js";
+import { resolveDiscordChannelIdSafe, resolveDiscordChannelInfoSafe } from "./channel-access.js";
+import { resolveThreadBindingPersonaFromRecord } from "./thread-bindings.persona.js";
+import {
+  BINDINGS_BY_THREAD_ID,
+  REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL,
+  rememberReusableWebhook,
+  toReusableWebhookKey,
+} from "./thread-bindings.state.js";
+import {
+  DISCORD_UNKNOWN_CHANNEL_ERROR_CODE,
+  type ThreadBindingRecord,
+} from "./thread-bindings.types.js";
+
+function buildThreadTarget(threadId: string): string {
+  return /^(channel:|user:)/i.test(threadId) ? threadId : `channel:${threadId}`;
+}
+
+export function isThreadArchived(raw: unknown): boolean {
+  if (!raw || typeof raw !== "object") {
+    return false;
+  }
+  const asRecord = raw as {
+    archived?: unknown;
+    thread_metadata?: { archived?: unknown };
+    threadMetadata?: { archived?: unknown };
+  };
+  if (asRecord.archived === true) {
+    return true;
+  }
+  if (asRecord.thread_metadata?.archived === true) {
+    return true;
+  }
+  if (asRecord.threadMetadata?.archived === true) {
+    return true;
+  }
+  return false;
+}
+
+function isThreadChannelType(type: unknown): boolean {
+  return (
+    type === ChannelType.PublicThread ||
+    type === ChannelType.PrivateThread ||
+    type === ChannelType.AnnouncementThread
+  );
+}
+
+function normalizeDiscordBindingChannelId(raw?: string | null): string | null {
+  const trimmed = normalizeOptionalString(raw) ?? "";
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return resolveDiscordChannelId(trimmed);
+  } catch {
+    return null;
+  }
+}
+
+export function summarizeDiscordError(err: unknown): string {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  if (typeof err === "string") {
+    return err;
+  }
+  if (
+    typeof err === "number" ||
+    typeof err === "boolean" ||
+    typeof err === "bigint" ||
+    typeof err === "symbol"
+  ) {
+    return String(err);
+  }
+  return "error";
+}
+
+function extractNumericDiscordErrorValue(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return Math.trunc(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return Number(value);
+  }
+  return undefined;
+}
+
+function extractDiscordErrorStatus(err: unknown): number | undefined {
+  if (!err || typeof err !== "object") {
+    return undefined;
+  }
+  const candidate = err as {
+    status?: unknown;
+    statusCode?: unknown;
+    response?: { status?: unknown };
+  };
+  return (
+    extractNumericDiscordErrorValue(candidate.status) ??
+    extractNumericDiscordErrorValue(candidate.statusCode) ??
+    extractNumericDiscordErrorValue(candidate.response?.status)
+  );
+}
+
+function extractDiscordErrorCode(err: unknown): number | undefined {
+  if (!err || typeof err !== "object") {
+    return undefined;
+  }
+  const candidate = err as {
+    code?: unknown;
+    rawError?: { code?: unknown };
+    body?: { code?: unknown };
+    response?: { body?: { code?: unknown }; data?: { code?: unknown } };
+  };
+  return (
+    extractNumericDiscordErrorValue(candidate.code) ??
+    extractNumericDiscordErrorValue(candidate.rawError?.code) ??
+    extractNumericDiscordErrorValue(candidate.body?.code) ??
+    extractNumericDiscordErrorValue(candidate.response?.body?.code) ??
+    extractNumericDiscordErrorValue(candidate.response?.data?.code)
+  );
+}
+
+export function isDiscordThreadGoneError(err: unknown): boolean {
+  const code = extractDiscordErrorCode(err);
+  if (code === DISCORD_UNKNOWN_CHANNEL_ERROR_CODE) {
+    return true;
+  }
+  const status = extractDiscordErrorStatus(err);
+  // 404: deleted/unknown channel. 403: bot no longer has access.
+  return status === 404 || status === 403;
+}
+
+export async function maybeSendBindingMessage(params: {
+  cfg: AutoBotConfig;
+  record: ThreadBindingRecord;
+  text: string;
+  preferWebhook?: boolean;
+}) {
+  const text = params.text.trim();
+  if (!text) {
+    return;
+  }
+  const record = params.record;
+  if (params.preferWebhook !== false && record.webhookId && record.webhookToken) {
+    try {
+      await sendWebhookMessageDiscord(text, {
+        cfg: params.cfg,
+        webhookId: record.webhookId,
+        webhookToken: record.webhookToken,
+        accountId: record.accountId,
+        threadId: record.threadId,
+        username: resolveThreadBindingPersonaFromRecord(record),
+      });
+      return;
+    } catch (err) {
+      logVerbose(`discord thread binding webhook send failed: ${summarizeDiscordError(err)}`);
+    }
+  }
+  try {
+    await sendMessageDiscord(buildThreadTarget(record.threadId), text, {
+      cfg: params.cfg,
+      accountId: record.accountId,
+    });
+  } catch (err) {
+    logVerbose(`discord thread binding fallback send failed: ${summarizeDiscordError(err)}`);
+  }
+}
+
+export async function createWebhookForChannel(params: {
+  cfg: AutoBotConfig;
+  accountId: string;
+  token?: string;
+  channelId: string;
+}): Promise<{ webhookId?: string; webhookToken?: string }> {
+  try {
+    const rest = createDiscordRestClient({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      token: params.token,
+    }).rest;
+    const created = await createChannelWebhook(rest, params.channelId, {
+      body: {
+        name: "AutoBot Agents",
+      },
+    });
+    const webhookId = normalizeOptionalString(created?.id) ?? "";
+    const webhookToken = normalizeOptionalString(created?.token) ?? "";
+    if (!webhookId || !webhookToken) {
+      return {};
+    }
+    return { webhookId, webhookToken };
+  } catch (err) {
+    logVerbose(
+      `discord thread binding webhook create failed for ${params.channelId}: ${summarizeDiscordError(err)}`,
+    );
+    return {};
+  }
+}
+
+export function findReusableWebhook(params: { accountId: string; channelId: string }): {
+  webhookId?: string;
+  webhookToken?: string;
+} {
+  const reusableKey = toReusableWebhookKey({
+    accountId: params.accountId,
+    channelId: params.channelId,
+  });
+  const cached = REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.get(reusableKey);
+  if (cached) {
+    return {
+      webhookId: cached.webhookId,
+      webhookToken: cached.webhookToken,
+    };
+  }
+  for (const record of BINDINGS_BY_THREAD_ID.values()) {
+    if (record.accountId !== params.accountId) {
+      continue;
+    }
+    if (record.channelId !== params.channelId) {
+      continue;
+    }
+    if (!record.webhookId || !record.webhookToken) {
+      continue;
+    }
+    rememberReusableWebhook(record);
+    return {
+      webhookId: record.webhookId,
+      webhookToken: record.webhookToken,
+    };
+  }
+  return {};
+}
+
+export async function resolveChannelIdForBinding(params: {
+  cfg: AutoBotConfig;
+  accountId: string;
+  token?: string;
+  threadId: string;
+  channelId?: string;
+}): Promise<string | null> {
+  const explicit = normalizeDiscordBindingChannelId(params.channelId);
+  if (explicit) {
+    return explicit;
+  }
+  const lookupThreadId = normalizeDiscordBindingChannelId(params.threadId);
+  if (!lookupThreadId) {
+    return null;
+  }
+  try {
+    const rest = createDiscordRestClient({
+      cfg: params.cfg,
+      accountId: params.accountId,
+      token: params.token,
+    }).rest;
+    const channel = await getChannel(rest, lookupThreadId);
+    const channelInfo = resolveDiscordChannelInfoSafe(channel);
+    const channelId = normalizeOptionalString(resolveDiscordChannelIdSafe(channel)) ?? "";
+    const type = channelInfo.type;
+    const parentId = normalizeOptionalString(channelInfo.parentId) ?? "";
+    // Only thread channels should resolve to their parent channel.
+    // Non-thread channels (text/forum/media) must keep their own ID.
+    if (parentId && isThreadChannelType(type)) {
+      return parentId;
+    }
+    return channelId || null;
+  } catch (err) {
+    logVerbose(
+      `discord thread binding channel resolve failed for ${lookupThreadId}: ${summarizeDiscordError(err)}`,
+    );
+    return null;
+  }
+}
+
+export async function createThreadForBinding(params: {
+  cfg: AutoBotConfig;
+  accountId: string;
+  token?: string;
+  channelId: string;
+  threadName: string;
+}): Promise<string | null> {
+  try {
+    const created = await createThreadDiscord(
+      params.channelId,
+      {
+        name: params.threadName,
+        autoArchiveMinutes: 60,
+      },
+      {
+        cfg: params.cfg,
+        accountId: params.accountId,
+        token: params.token,
+      },
+    );
+    const createdId = normalizeOptionalString(created?.id) ?? "";
+    return createdId || null;
+  } catch (err) {
+    logVerbose(
+      `discord thread binding auto-thread create failed for ${params.channelId}: ${summarizeDiscordError(err)}`,
+    );
+    return null;
+  }
+}