talon-agent 3.33.4 → 3.34.1

package/src/frontend/discord/callbacks/components/settings.ts

@@ -0,0 +1,243 @@
+/**
+ * `settings:*` — the /settings panel. Every callback updates the original
+ * message in place (Discord supports update() on the interaction).
+ *
+ *   settings:done
+ *   settings:model              (select menu, value=modelId)
+ *   settings:effort:select      (select menu)
+ *   settings:proactive:on|off
+ */
+
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  StringSelectMenuBuilder,
+  MessageFlags,
+} from "discord.js";
+import type { TalonConfig } from "../../../../util/config.js";
+import type { Gateway } from "../../../../core/engine/gateway.js";
+import {
+  getChatSettings,
+  setChatModelForBackend,
+  setChatBackend,
+  setChatEffort,
+  type EffortLevel,
+} from "../../../../storage/chat-settings.js";
+import { resolveModelId as resolveModelName } from "../../../../core/models/catalog.js";
+import {
+  registerChat,
+  disablePulse,
+  enablePulse,
+  isPulseEnabled,
+} from "../../../../core/background/pulse.js";
+import { renderSettingsText, EFFORT_DESCRIPTIONS } from "../../helpers.js";
+import {
+  getBackendIdForChat,
+  resolveChatBackend,
+} from "../../../../core/engine/backend-controller/index.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import {
+  displayReasoningEffort,
+  getActiveReasoningLevels,
+  supportsReasoningLevel,
+} from "../../../shared/reasoning-levels.js";
+import { logError } from "../../../../util/log.js";
+import { safeSlice } from "../../formatting.js";
+import type { ComponentContext, ComponentInteraction } from "./types.js";
+
+export async function handleSettingsComponent(
+  interaction: ComponentInteraction,
+  { config, gateway, chatId }: ComponentContext,
+): Promise<boolean> {
+  const parts = interaction.customId.split(":");
+  const category = parts[1];
+
+  if (category === "done") {
+    try {
+      await interaction.update({ components: [], content: "Done." });
+    } catch {
+      /* ignore */
+    }
+    return true;
+  }
+
+  if (category === "model" && interaction.isStringSelectMenu()) {
+    const value = interaction.values[0];
+    const settingsBe = resolveChatBackend(chatId, gateway?.backend);
+    const settingsBeId = getBackendIdForChat(chatId);
+    if (value === "reset") {
+      // Clear THIS backend's slot only — other backends' picks stay.
+      setChatModelForBackend(chatId, settingsBeId, undefined);
+    } else if (settingsBe?.models?.resolveModelInfo) {
+      const resolution = await settingsBe.models?.resolveModelInfo(value);
+      if (resolution.kind !== "exact" || !resolution.model.selectable) {
+        await interaction.reply({
+          content: `Model unavailable.`,
+          flags: MessageFlags.Ephemeral,
+        });
+        return true;
+      }
+      setChatModelForBackend(chatId, settingsBeId, resolution.storedValue);
+      setChatBackend(chatId, settingsBeId);
+    } else {
+      setChatModelForBackend(chatId, settingsBeId, resolveModelName(value));
+      setChatBackend(chatId, settingsBeId);
+    }
+    await refreshSettingsPanel(interaction, config, gateway, chatId);
+    return true;
+  }
+
+  if (category === "effort" && interaction.isStringSelectMenu()) {
+    // settings:effort:select — current shape (emitted by handleSettings +
+    // refreshSettingsPanel).
+    const level = interaction.values[0];
+    const settingsBe = resolveChatBackend(chatId, gateway?.backend);
+    const settingsBeId = getBackendIdForChat(chatId);
+    const reasoning = await getActiveReasoningLevels({
+      chatId,
+      backend: settingsBe,
+      backendId: settingsBeId,
+      config,
+    });
+    if (level === "adaptive") {
+      setChatEffort(chatId, undefined);
+    } else if (supportsReasoningLevel(level, reasoning.levels)) {
+      setChatEffort(chatId, level as EffortLevel);
+    } else {
+      await interaction.reply({
+        content: "No valid reasoning level for this model.",
+        flags: MessageFlags.Ephemeral,
+      });
+      return true;
+    }
+    await refreshSettingsPanel(interaction, config, gateway, chatId);
+    return true;
+  }
+
+  if (category === "proactive") {
+    const value = parts[2] ?? "";
+    if (value === "on") {
+      enablePulse(chatId);
+      registerChat(chatId);
+    } else {
+      disablePulse(chatId);
+    }
+    await refreshSettingsPanel(interaction, config, gateway, chatId);
+    return true;
+  }
+
+  return false;
+}
+
+async function refreshSettingsPanel(
+  interaction: ComponentInteraction,
+  config: TalonConfig,
+  gateway: Gateway,
+  chatId: string,
+): Promise<void> {
+  const chatSets = getChatSettings(chatId);
+  const settingsBe = resolveChatBackend(chatId, gateway?.backend);
+  const settingsBeId = getBackendIdForChat(chatId);
+  // Match the Telegram path — resolve via the 5-step chain so the
+  // panel's "Model:" line stays coherent on backend-overridden
+  // chats and surfaces "No model selected" when applicable.
+  const { model: resolvedActive } = await resolveActiveModelForChat(
+    chatId,
+    settingsBe,
+    settingsBeId,
+    config,
+  );
+  const activeModel = resolvedActive ?? "No model selected";
+  const pulseOn = isPulseEnabled(chatId);
+  const reasoning = await getActiveReasoningLevels({
+    chatId,
+    backend: settingsBe,
+    backendId: settingsBeId,
+    config,
+  });
+  const effortName = displayReasoningEffort(chatSets.effort, reasoning.levels);
+
+  let modelDetails: Array<string> | undefined;
+  let modelButtons: Array<{ text: string; callback_data: string }> | undefined;
+  // `settingsBe` already resolved above for the activeModel lookup —
+  // reuse it instead of re-resolving (it points at the per-chat
+  // backend, override-aware).
+  if (settingsBe?.models?.getSettingsPresentation) {
+    const presModelId = resolvedActive ?? "";
+    const pres = await settingsBe.models?.getSettingsPresentation(presModelId);
+    modelDetails = pres.modelDetails;
+    modelButtons = pres.modelButtons;
+  }
+
+  const components: ActionRowBuilder<
+    StringSelectMenuBuilder | ButtonBuilder
+  >[] = [];
+
+  if (modelButtons?.length) {
+    const menu = new StringSelectMenuBuilder()
+      .setCustomId("settings:model")
+      .setPlaceholder("Select a model")
+      .addOptions(
+        modelButtons.slice(0, 25).map((b) => ({
+          label: safeSlice(b.text.replace(/^✓ /, ""), 100),
+          value: safeSlice(
+            b.callback_data.replace(/^settings:model:/, ""),
+            100,
+          ),
+          default: b.text.startsWith("✓"),
+        })),
+      );
+    components.push(
+      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(menu),
+    );
+  }
+
+  if (reasoning.levels.length > 0) {
+    const effortMenu = new StringSelectMenuBuilder()
+      .setCustomId("settings:effort:select")
+      .setPlaceholder(`Effort: ${effortName}`)
+      .addOptions(
+        [...reasoning.levels, "adaptive"].map((v) => ({
+          label: v,
+          value: v,
+          description: EFFORT_DESCRIPTIONS[v],
+          default: effortName === v,
+        })),
+      );
+    components.push(
+      new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(effortMenu),
+    );
+  }
+
+  components.push(
+    new ActionRowBuilder<ButtonBuilder>().addComponents(
+      new ButtonBuilder()
+        .setCustomId(`settings:proactive:${pulseOn ? "off" : "on"}`)
+        .setLabel(pulseOn ? "Pulse: ON" : "Pulse: OFF")
+        .setStyle(pulseOn ? ButtonStyle.Success : ButtonStyle.Secondary),
+      new ButtonBuilder()
+        .setCustomId("settings:done")
+        .setLabel("Done")
+        .setStyle(ButtonStyle.Secondary),
+    ),
+  );
+
+  try {
+    await interaction.update({
+      content: renderSettingsText(
+        activeModel,
+        effortName,
+        pulseOn,
+        chatSets.pulseIntervalMs,
+        modelDetails,
+      ),
+      components,
+    });
+  } catch (err) {
+    logError(
+      "discord",
+      `Failed to refresh settings panel: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}

package/src/frontend/discord/callbacks/components/types.ts

@@ -0,0 +1,34 @@
+/**
+ * Component-handler types.
+ *
+ * The router (index.ts) keys `ComponentHandlers` by the custom-id prefix —
+ * the first `:`-terminated segment (`settings:`, `pulse:`, `model:`, …).
+ * A handler owns everything under its prefix and returns `false` for an id
+ * it doesn't recognise, so the router can ack it the way it acks an id with
+ * no handler at all (stale buttons from older panels).
+ */
+
+import type {
+  ButtonInteraction,
+  StringSelectMenuInteraction,
+} from "discord.js";
+import type { TalonConfig } from "../../../../util/config.js";
+import type { Gateway } from "../../../../core/engine/gateway.js";
+
+export type ComponentInteraction =
+  ButtonInteraction | StringSelectMenuInteraction;
+
+export interface ComponentContext {
+  config: TalonConfig;
+  gateway: Gateway;
+  /** Talon chat id (`discord_guild_…` / `discord_dm_…`), already registered. */
+  chatId: string;
+  numericChatId: number;
+}
+
+type ComponentHandler = (
+  interaction: ComponentInteraction,
+  context: ComponentContext,
+) => Promise<boolean>;
+
+export type ComponentHandlers = Record<string, ComponentHandler>;

package/src/frontend/discord/callbacks/index.ts

@@ -2,13 +2,13 @@
  * Discord interaction callbacks — components, modals, and autocomplete.
  *
  * Mirrors src/frontend/telegram/callbacks. Split by interaction kind:
- *   - shared       — ComponentInteraction type + chatIdFromInteraction
- *   - components   — button + select-menu handler (settings/pulse/effort/model
- *                    + ai: forwarding), refreshSettingsPanel, forwardToAgent
+ *   - components/  — button + select-menu router, a dispatch table keyed by
+ *                    custom-id prefix with one handler module per prefix
+ *                    (settings/pulse/effort/model/metrics + ai: forwarding)
  *   - modals       — modal submissions (pulse interval)
  *   - autocomplete — /model name autocomplete with a cached model list
  */
 
-export { handleComponentInteraction } from "./components.js";
+export { handleComponentInteraction } from "./components/index.js";
 export { handleModalSubmit } from "./modals.js";
 export { handleAutocomplete } from "./autocomplete.js";

package/src/frontend/discord/connection.ts

@@ -0,0 +1,36 @@
+/**
+ * Client connection lifecycle — login (blocking until READY) and the
+ * shutdown sequence that takes the gateway down with the client.
+ */
+
+import { Events } from "discord.js";
+import { once } from "node:events";
+import { log, logError } from "../../util/log.js";
+import type { DiscordRuntime } from "./runtime.js";
+
+export async function connect(runtime: DiscordRuntime): Promise<void> {
+  const { client, discord: dc } = runtime;
+  await client.login(dc.botToken);
+  // Wait for the WebSocket READY event before returning — login() resolves
+  // after HTTP IDENTIFY but client.user / client.guilds.cache are empty
+  // until READY fires. Anything called after start() can then safely read
+  // gateway state.
+  if (!client.isReady()) {
+    await once(client, Events.ClientReady);
+  }
+}
+
+export async function disconnect(runtime: DiscordRuntime): Promise<void> {
+  try {
+    await runtime.client.destroy();
+    log("shutdown", "Discord client disconnected");
+  } catch (err) {
+    logError("shutdown", "Discord stop error", err);
+  }
+  try {
+    await runtime.gateway.stop();
+    log("shutdown", "Gateway stopped");
+  } catch (err) {
+    logError("shutdown", "Gateway stop error", err);
+  }
+}

package/src/frontend/discord/diagnostics.ts

@@ -0,0 +1,62 @@
+/**
+ * Client diagnostics — the error/warn/disconnect/rate-limit listeners that
+ * only log. discord.js handles reconnects and retries itself; these exist
+ * so a silent failure mode (a fatal close code, an approaching IP ban) is
+ * visible in the daemon log.
+ */
+
+import { type Client, Events } from "discord.js";
+import { logError, logWarn } from "../../util/log.js";
+
+function shardDisconnectLabel(code: number | undefined): string {
+  return code === 4004
+    ? "AUTHENTICATION_FAILED — bot token invalid/revoked"
+    : code === 4013
+      ? "INVALID_INTENTS — declared intent doesn't exist"
+      : code === 4014
+        ? "DISALLOWED_INTENTS — privileged intent (GuildMembers/MessageContent/Presence) not enabled in Developer Portal"
+        : `code=${code}`;
+}
+
+export function bindClientDiagnostics(client: Client): void {
+  client.on("error", (err) => {
+    logError("discord", "Client error", err);
+  });
+  client.on("warn", (msg) => {
+    logWarn("discord", msg);
+  });
+
+  // Surface gateway close codes — discord.js auto-reconnects on most, but
+  // 4004 (auth failed), 4013 (invalid intents), 4014 (disallowed intents)
+  // are terminal: the bot will hang silent in IDENTIFY without an alert.
+  client.on(Events.ShardDisconnect, (event, shardId) => {
+    const code = event?.code;
+    const reason = event?.reason || "(no reason)";
+    const fatal = code === 4004 || code === 4013 || code === 4014;
+    const label = shardDisconnectLabel(code);
+    if (fatal) {
+      logError(
+        "discord",
+        `Shard ${shardId} disconnected fatally: ${label} (${reason})`,
+      );
+    } else {
+      logWarn("discord", `Shard ${shardId} disconnected: ${label} (${reason})`);
+    }
+  });
+
+  // Rate-limit / invalid-request observability. discord.js handles retries
+  // automatically; we just want logs so we know when we're flirting with
+  // the Cloudflare 10k-invalid-requests/10min cap.
+  client.rest.on("rateLimited", (info) => {
+    logWarn(
+      "discord",
+      `Rate-limited ${info.method} ${info.route} — wait ${info.timeToReset}ms (global=${info.global})`,
+    );
+  });
+  client.rest.on("invalidRequestWarning", (info) => {
+    logError(
+      "discord",
+      `Invalid-request warning: ${info.count} bad requests in last ${info.remainingTime}ms — approaching IP ban threshold`,
+    );
+  });
+}

package/src/frontend/discord/guild-policy.ts

@@ -0,0 +1,89 @@
+/**
+ * Guild whitelist enforcement — the bot only operates in `allowedGuilds`.
+ *
+ * Two entry points: the sweep run once at ready (defense in depth against
+ * guilds joined while the bot was offline) and the `guildCreate` handler
+ * that reacts the moment the bot is added somewhere. Both tell the admins
+ * and, when `leaveUnauthorizedGuilds` is set, leave.
+ */
+
+import type { Client, Guild } from "discord.js";
+import { log, logError, logWarn } from "../../util/log.js";
+import { registerCommandsForGuilds } from "./commands/index.js";
+import type { DiscordRuntime } from "./runtime.js";
+
+async function notifyAdmins(
+  client: Client,
+  adminUserIds: readonly string[],
+  content: string,
+): Promise<void> {
+  for (const adminId of adminUserIds) {
+    try {
+      const admin = await client.users.fetch(adminId);
+      await admin.send({ content, allowedMentions: { parse: [] } });
+    } catch {
+      /* ignore */
+    }
+  }
+}
+
+async function leaveGuild(guild: Guild): Promise<void> {
+  try {
+    await guild.leave();
+  } catch (err) {
+    logWarn(
+      "discord",
+      `Failed to leave guild ${guild.id}: ${err instanceof Error ? err.message : err}`,
+    );
+  }
+}
+
+/** Ready-time sweep: leave every guild the bot is in that isn't whitelisted. */
+export async function leaveNonWhitelistedGuilds(
+  runtime: DiscordRuntime,
+  client: Client<true>,
+): Promise<void> {
+  const dc = runtime.discord;
+  for (const guild of client.guilds.cache.values()) {
+    if (dc.allowedGuilds.includes(guild.id)) continue;
+    log(
+      "discord",
+      `Leaving non-whitelisted guild "${guild.name}" (${guild.id})`,
+    );
+    await notifyAdmins(
+      client,
+      dc.adminUserIds,
+      `🚪 Leaving non-whitelisted guild "${guild.name}" (${guild.id}).`,
+    );
+    await leaveGuild(guild);
+  }
+}
+
+/** guildCreate: bot was added to a new guild → enforce whitelist immediately. */
+export async function onGuildCreate(
+  runtime: DiscordRuntime,
+  guild: Guild,
+): Promise<void> {
+  const { client, config, discord: dc } = runtime;
+  if (dc.allowedGuilds.includes(guild.id)) {
+    log("discord", `Joined whitelisted guild "${guild.name}" (${guild.id})`);
+    // Re-register commands for this guild
+    try {
+      await registerCommandsForGuilds(client, config);
+    } catch (err) {
+      logError("discord", `Re-register commands after guildCreate failed`, err);
+    }
+    return;
+  }
+  log("discord", `Joined non-whitelisted guild "${guild.name}" (${guild.id})`);
+  await notifyAdmins(
+    client,
+    dc.adminUserIds,
+    dc.leaveUnauthorizedGuilds
+      ? `🚨 Bot was added to non-whitelisted guild "${guild.name}" (${guild.id}). Leaving.`
+      : `⚠️ Bot was added to non-whitelisted guild "${guild.name}" (${guild.id}). Commands will not be registered.`,
+  );
+  if (dc.leaveUnauthorizedGuilds) {
+    await leaveGuild(guild);
+  }
+}