abtars 0.1.0-alpha.2 → 0.1.0-alpha.21

package/bundle/discord-adapter-UYOCKRDF.js

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+ import { createRequire as __bundleCreateRequire } from 'node:module'; import { fileURLToPath as __bundleFileURLToPath } from 'node:url'; import { dirname as __bundleDirname } from 'node:path'; const require = __bundleCreateRequire(import.meta.url); const __chunk_filename = __bundleFileURLToPath(import.meta.url); const __chunk_dirname = __bundleDirname(__chunk_filename);
+import {
+  BOT_COMMANDS,
+  ResponseFormatter,
+  SecurityGate,
+  emojiToScore
+} from "./chunk-R36WIOYX.js";
+import {
+  require_src
+} from "./chunk-P6PN34XD.js";
+import {
+  formatReactionSignal,
+  handleInboundMessage
+} from "./chunk-DY3R7LDW.js";
+import "./chunk-NIRYBWUW.js";
+import "./chunk-3MO2MDXJ.js";
+import "./chunk-WX7GHGFX.js";
+import "./chunk-RWUINZUQ.js";
+import "./chunk-P56PLAIC.js";
+import {
+  loadUsers
+} from "./chunk-J5YIMCLT.js";
+import "./chunk-JAJ3DUQ2.js";
+import "./chunk-G6IXMYIO.js";
+import "./chunk-UDZIZB5F.js";
+import "./chunk-XLLSPBBT.js";
+import "./chunk-MZWMYN4O.js";
+import {
+  init_log_and_swallow,
+  logAndSwallow
+} from "./chunk-EX2SRTUE.js";
+import {
+  getEnv,
+  init_env_schema
+} from "./chunk-AQVOAQQI.js";
+import {
+  init_logger,
+  logDebug,
+  logError,
+  logInfo,
+  logWarn
+} from "./chunk-2BY6I4P5.js";
+import "./chunk-MJ6PHMOK.js";
+import {
+  __toESM
+} from "./chunk-7K2YZTLD.js";
+
+// src/platforms/discord/discord-api.ts
+init_log_and_swallow();
+var import_discord = __toESM(require_src(), 1);
+init_logger();
+var TAG = "DiscordApi";
+var DiscordApi = class {
+  client;
+  token;
+  ready = false;
+  constructor(botToken) {
+    this.token = botToken;
+    this.client = new import_discord.Client({
+      intents: [
+        import_discord.GatewayIntentBits.Guilds,
+        import_discord.GatewayIntentBits.GuildMessages,
+        import_discord.GatewayIntentBits.GuildMessageReactions,
+        import_discord.GatewayIntentBits.DirectMessages,
+        import_discord.GatewayIntentBits.MessageContent
+      ],
+      partials: [import_discord.Partials.Channel, import_discord.Partials.Message, import_discord.Partials.Reaction]
+    });
+    this.client.on("clientReady", () => {
+      this.ready = true;
+      logInfo(TAG, `Connected as ${this.client.user?.tag ?? "unknown"}`);
+    });
+    this.client.on("error", (err) => {
+      logError(TAG, "Client error", err);
+    });
+  }
+  /** Connect to the Discord Gateway. Resolves when the client is ready. */
+  async connect() {
+    logInfo(TAG, "Connecting to Discord Gateway\u2026");
+    return new Promise((resolve, reject) => {
+      const onReady = () => {
+        cleanup();
+        resolve();
+      };
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const cleanup = () => {
+        this.client.removeListener("clientReady", onReady);
+        this.client.removeListener("error", onError);
+      };
+      this.client.once("clientReady", onReady);
+      this.client.once("error", onError);
+      this.client.login(this.token).catch((err) => {
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+  }
+  /** Register a handler for MESSAGE_CREATE events. */
+  onMessage(handler) {
+    this.client.on("messageCreate", (message) => {
+      logDebug(TAG, `Message from ${message.author.tag} in #${message.channel.id}`);
+      try {
+        const result = handler(message);
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            logError(TAG, "Message handler error", err);
+          });
+        }
+      } catch (err) {
+        logError(TAG, "Message handler error", err);
+      }
+    });
+  }
+  /** Register a handler for MESSAGE_REACTION_ADD events. */
+  onReaction(handler) {
+    this.client.on("messageReactionAdd", async (reaction, user) => {
+      if (user.bot) return;
+      try {
+        if (reaction.partial) await reaction.fetch();
+        if (user.partial) await user.fetch();
+      } catch (err) {
+        logAndSwallow(TAG, "fetch reaction/user partial", err);
+        return;
+      }
+      try {
+        const result = handler(reaction, user);
+        if (result instanceof Promise) result.catch((err) => logError(TAG, "Reaction handler error", err));
+      } catch (err) {
+        logError(TAG, "Reaction handler error", err);
+      }
+    });
+  }
+  /** Register a handler for slash command interactions. */
+  onInteraction(handler) {
+    this.client.on("interactionCreate", async (interaction) => {
+      if (interaction.isChatInputCommand()) {
+        try {
+          const result = handler(interaction);
+          if (result instanceof Promise) result.catch((err) => logError(TAG, "Interaction handler error", err));
+        } catch (err) {
+          logError(TAG, "Interaction handler error", err);
+        }
+      }
+      if (interaction.isStringSelectMenu()) {
+        this.selectMenuHandlers.get(interaction.customId)?.(interaction);
+      }
+    });
+  }
+  selectMenuHandlers = /* @__PURE__ */ new Map();
+  onSelectMenu(customId, handler) {
+    this.selectMenuHandlers.set(customId, handler);
+  }
+  /** Register global application commands. Idempotent — Discord diffs and updates. */
+  async registerCommands(commands) {
+    if (!this.client.application) {
+      logWarn(TAG, "Cannot register commands \u2014 application not available");
+      return;
+    }
+    await this.client.application.commands.set(commands.map((c) => ({ name: c.name, description: c.description, type: 1 })));
+    logInfo(TAG, `Registered ${commands.length} slash commands`);
+  }
+  /** Send a text message to a channel. Returns the sent message ID. */
+  async sendMessage(channelId, text) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (!channel?.isTextBased()) {
+      throw new Error(`Channel ${channelId} is not a text channel`);
+    }
+    const sent = await channel.send(text);
+    logDebug(TAG, `Sent message ${sent.id} to channel ${channelId}`);
+    return sent.id;
+  }
+  /** Send typing indicator to a channel. */
+  async sendTyping(channelId) {
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (channel?.isTextBased()) await channel.sendTyping();
+    } catch (err) {
+      logAndSwallow("discord_api", "op", err);
+    }
+  }
+  /** Add or remove a reaction on a message. Empty emoji = remove bot's reactions. */
+  async setReaction(channelId, messageId, emoji) {
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (!channel?.isTextBased()) return;
+      const message = await channel.messages.fetch(messageId);
+      if (!emoji) {
+        const botId = this.client.user?.id;
+        if (botId) {
+          for (const reaction of message.reactions.cache.values()) {
+            await reaction.users.remove(botId).catch((err) => logAndSwallow(TAG, "remove bot reaction", err));
+          }
+        }
+      } else {
+        await message.react(emoji);
+      }
+    } catch (err) {
+      logAndSwallow("discord_api", "op", err);
+    }
+  }
+  /** Edit a previously sent message. */
+  async editMessage(channelId, messageId, text) {
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (!channel?.isTextBased()) return;
+      const message = await channel.messages.fetch(messageId);
+      await message.edit(text);
+    } catch (err) {
+      logAndSwallow("discord_api", "op", err);
+    }
+  }
+  /** Gracefully close the Gateway connection. */
+  async disconnect() {
+    logInfo(TAG, "Disconnecting from Discord Gateway\u2026");
+    this.ready = false;
+    this.client.destroy();
+  }
+  /** Whether the client is connected and ready. */
+  get isReady() {
+    return this.ready;
+  }
+  /** Get the bot's own user ID (for filtering self-messages). */
+  get botUserId() {
+    return this.client.user?.id ?? null;
+  }
+  /** Fetch a specific message by channel + message ID. Returns null on failure. (#388) */
+  async fetchMessage(channelId, messageId) {
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (!channel?.isTextBased()) return null;
+      const msg = await channel.messages.fetch(messageId);
+      return msg ? { authorId: msg.author.id } : null;
+    } catch (err) {
+      logAndSwallow(TAG, "fetchMessage", err);
+      return null;
+    }
+  }
+};
+
+// src/platforms/discord/discord-poller.ts
+init_logger();
+var TAG2 = "DiscordPoller";
+var DiscordPoller = class {
+  api;
+  appId;
+  onMessage;
+  started = false;
+  constructor(api, appId, onMessage) {
+    this.api = api;
+    this.appId = appId;
+    this.onMessage = onMessage;
+  }
+  /** Connect to Gateway and start listening. */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    await this.api.connect();
+    this.api.onMessage((raw) => {
+      const selfId = this.api.botUserId ?? this.appId;
+      if (raw.author.id === selfId) {
+        logDebug(TAG2, `Ignoring self-message ${raw.id}`);
+        return;
+      }
+      const inbound = toDiscordInboundMessage(raw, this.appId);
+      logDebug(TAG2, `Dispatching message ${inbound.id} from ${inbound.authorUsername}`);
+      try {
+        const result = this.onMessage(inbound);
+        if (result instanceof Promise) {
+          result.catch((err) => {
+            logWarn(TAG2, `Error in message callback: ${err instanceof Error ? err.message : String(err)}`);
+          });
+        }
+      } catch (err) {
+        logWarn(TAG2, `Error in message callback: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    });
+    logInfo(TAG2, "Started \u2014 listening for Discord messages");
+  }
+  /** Disconnect from Gateway cleanly. */
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.api.disconnect();
+    logInfo(TAG2, "Stopped");
+  }
+};
+function toDiscordInboundMessage(raw, botId) {
+  const parentId = "parentId" in raw.channel ? raw.channel.parentId ?? null : null;
+  const channelName = "name" in raw.channel ? raw.channel.name ?? null : null;
+  const mentionsBotId = botId ? raw.mentions.users.has(botId) || new RegExp(`<@!?${botId}>`).test(raw.content) : false;
+  const botMember = raw.guild?.members.me ?? null;
+  const botRoleIds = botMember ? /* @__PURE__ */ new Set([...botMember.roles.cache.keys()]) : /* @__PURE__ */ new Set();
+  const mentionsBotRole = botMember ? [...raw.mentions.roles.keys()].some((rid) => botRoleIds.has(rid)) : false;
+  logDebug(TAG2, `mentionsBotId=${mentionsBotId} mentionsBotRole=${mentionsBotRole} (appId=${botId}, mentions=${[...raw.mentions.users.keys()].join(",")}, content=${raw.content.slice(0, 60)})`);
+  return {
+    id: raw.id,
+    channelId: raw.channelId,
+    parentChannelId: parentId,
+    channelName,
+    isDM: !raw.guildId,
+    authorId: raw.author.id,
+    authorUsername: raw.author.username,
+    authorIsBot: raw.author.bot ?? false,
+    content: raw.content,
+    timestamp: raw.createdTimestamp,
+    mentionsBotId,
+    mentionsBotRole,
+    mentionsEveryone: raw.mentions.everyone,
+    hasUserMentions: raw.mentions.users.size > 0,
+    replyReferenceMessageId: raw.reference?.messageId ?? null,
+    attachments: raw.attachments.size > 0 ? [...raw.attachments.values()].map((a) => ({ url: a.url, filename: a.name ?? "file", contentType: a.contentType ?? void 0, size: a.size })) : void 0
+  };
+}
+
+// src/platforms/discord/discord-adapter.ts
+init_logger();
+init_log_and_swallow();
+init_env_schema();
+var DISCORD_CAPABILITIES = { voice: false, reactions: true, typing: true, threads: true };
+var TAG3 = "discord";
+var DiscordAdapter = class {
+  name = "discord";
+  capabilities = DISCORD_CAPABILITIES;
+  api;
+  securityGate;
+  formatter = new ResponseFormatter();
+  config;
+  deps;
+  poller = null;
+  constructor(config, deps) {
+    this.api = new DiscordApi(config.botToken);
+    this.securityGate = new SecurityGate(loadUsers());
+    this.config = config;
+    this.deps = deps;
+  }
+  async start() {
+    this.poller = new DiscordPoller(this.api, this.config.appId, (m) => this.handleMessage(m));
+    this.api.onReaction((reaction, user) => this.handleReaction(reaction, user));
+    this.api.onInteraction((interaction) => this.handleInteraction(interaction));
+    await this.poller.start();
+    await this.api.registerCommands([...BOT_COMMANDS]).catch(
+      (err) => logWarn(TAG3, `Slash command registration failed: ${err instanceof Error ? err.message : String(err)}`)
+    );
+  }
+  /** Handle Discord slash command interactions. */
+  async handleInteraction(interaction) {
+    if (interaction.commandName === "model" || interaction.commandName === "models") {
+      await this.handleModelPicker(interaction);
+      return;
+    }
+    await interaction.deferReply();
+    const registry = loadUsers();
+    const userEntry = registry.byPlatformId.get(`discord:${interaction.user.id}`);
+    if (!this.securityGate.authorizeById(interaction.user.id, interaction.channelId)) {
+      await interaction.editReply("\u26D4 Unauthorized.");
+      return;
+    }
+    const commandText = `/${interaction.commandName}`;
+    const userId = userEntry?.userId ?? "unknown";
+    const channelId = interaction.channelId;
+    let initialReplied = false;
+    const interactionAdapter = {
+      ...this,
+      sendMessage: async (_ch, text) => {
+        if (!text?.trim()) return void 0;
+        const chunks = text.length <= 2e3 ? [text] : text.match(/.{1,2000}/gs) ?? [text];
+        let lastId;
+        for (const chunk of chunks) {
+          if (!initialReplied) {
+            initialReplied = true;
+            const sent = await interaction.editReply(chunk);
+            lastId = sent.id;
+          } else {
+            const sent = await interaction.followUp(chunk);
+            lastId = sent.id;
+          }
+        }
+        return lastId;
+      },
+      editMessage: async (_ch, _messageId, text) => {
+        await interaction.editReply(text);
+      }
+    };
+    const msg = {
+      text: commandText,
+      channelId,
+      userId,
+      senderId: interaction.user.id,
+      senderName: interaction.user.username ?? "unknown",
+      platform: "discord",
+      timestamp: Date.now(),
+      isGroup: !!interaction.guildId,
+      isVoice: false
+    };
+    await handleInboundMessage(msg, interactionAdapter, this.deps.pipeline);
+  }
+  /** Interactive model picker — ephemeral select menus. */
+  async handleModelPicker(interaction) {
+    const { ActionRowBuilder, StringSelectMenuBuilder } = await import("./src-Z3WR7SRT.js");
+    const { loadTransport } = await import("./transport-config-ANPS2RYT.js");
+    const tc = loadTransport();
+    if (!tc) {
+      await interaction.reply({ content: "No transport config.", ephemeral: true });
+      return;
+    }
+    const providers = Object.entries(tc.providers).map(([id, p]) => ({ id, name: p.name ?? id }));
+    if (providers.length === 0) {
+      await interaction.reply({ content: "No providers configured.", ephemeral: true });
+      return;
+    }
+    const menu = new StringSelectMenuBuilder().setCustomId("model_picker_provider").setPlaceholder("Select provider").addOptions(providers.slice(0, 25).map((p) => ({ label: p.name, value: p.id })));
+    const row = new ActionRowBuilder().addComponents(menu);
+    await interaction.reply({ content: "\u{1F527} Select provider:", components: [row], ephemeral: true });
+    this.api.onSelectMenu("model_picker_provider", async (selectInteraction) => {
+      const providerId = selectInteraction.values[0];
+      const provider = tc.providers[providerId];
+      if (!provider) {
+        await selectInteraction.update({ content: "Provider not found.", components: [] });
+        return;
+      }
+      const { getModelsForProvider } = await import("./transport-config-ANPS2RYT.js");
+      const models = getModelsForProvider(providerId).filter((m) => m.entry.status === "alive" || !m.entry.status).slice(0, 25);
+      if (models.length === 0) {
+        await selectInteraction.update({ content: `No models for ${providerId}.`, components: [] });
+        return;
+      }
+      const modelMenu = new StringSelectMenuBuilder().setCustomId("model_picker_model").setPlaceholder("Select model").addOptions(models.map((m) => ({ label: m.id, value: m.id })));
+      const modelRow = new ActionRowBuilder().addComponents(modelMenu);
+      await selectInteraction.update({ content: `Provider: **${providerId}**
+Select model:`, components: [modelRow] });
+      this.api.onSelectMenu("model_picker_model", async (modelInteraction) => {
+        const modelId = modelInteraction.values[0];
+        await modelInteraction.update({ content: `\u2705 Switching to **${providerId}/${modelId}**...`, components: [] });
+        const msg = {
+          text: `/model ${providerId} ${modelId}`,
+          channelId: modelInteraction.channelId,
+          userId: interaction.user.id,
+          senderId: interaction.user.id,
+          senderName: interaction.user.username ?? "unknown",
+          platform: "discord",
+          timestamp: Date.now(),
+          isGroup: !!interaction.guildId,
+          isVoice: false
+        };
+        await handleInboundMessage(msg, this, this.deps.pipeline);
+      });
+    });
+  }
+  stop() {
+    this.poller?.stop();
+    this.poller = null;
+  }
+  authorize(msg) {
+    return this.securityGate.authorizeById(msg.senderId, msg.channelId);
+  }
+  async sendMessage(channelId, text, _opts) {
+    const id = await this.api.sendMessage(channelId, text);
+    return id || void 0;
+  }
+  async sendTyping(channelId) {
+    await this.api.sendTyping(channelId);
+  }
+  async setReaction(channelId, messageId, emoji) {
+    await this.api.setReaction(channelId, String(messageId), emoji);
+  }
+  async editMessage(channelId, messageId, text) {
+    await this.api.editMessage(channelId, String(messageId), text);
+  }
+  chunkResponse(text) {
+    return this.formatter.chunkForPlatform(text, "discord");
+  }
+  injectMessage(msg) {
+    handleInboundMessage(msg, this, this.deps.pipeline).catch((err) => {
+      logWarn(TAG3, `Failed to replay queued message: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
+  // --- Internal: Discord message handler ---
+  async handleMessage(message) {
+    logDebug(TAG3, `Message from ${message.authorUsername} in ${message.channelId}`);
+    const effectiveChannelId = message.parentChannelId ?? message.channelId;
+    if (!this.securityGate.authorizeById(message.authorId, effectiveChannelId)) {
+      logDebug(TAG3, `Unauthorized user=${message.authorId} channel=${effectiveChannelId}`);
+      return;
+    }
+    const rawText = message.content.trim();
+    if (!rawText && !message.attachments?.length) return;
+    let text = rawText.replace(new RegExp(`<@!?${this.config.appId}>`, "g"), "").replace(/\s{2,}/g, " ").trim();
+    let mediaPath;
+    if (message.attachments?.length) {
+      try {
+        const { saveInboundMedia } = await import("./media-utils-QBY5WBF3.js");
+        const att = message.attachments[0];
+        const res = await fetch(att.url);
+        if (res.ok) {
+          const buf = Buffer.from(await res.arrayBuffer());
+          const extHint = att.filename ? "." + (att.filename.split(".").pop() ?? "") : void 0;
+          const saved = await saveInboundMedia(buf, message.channelId, { extHint, claimedMime: att.contentType });
+          if (saved) {
+            mediaPath = saved.path;
+            if (!text) text = `User sent a ${saved.isImage ? "photo" : "file"}.`;
+          }
+        }
+      } catch (err) {
+        logWarn(TAG3, `Attachment download failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    if (!text) return;
+    const isDM = message.isDM;
+    if (!isDM) {
+      const mentionMode = getEnv().discordGroupMentions;
+      if (mentionMode === "optional") {
+        if (message.hasUserMentions && !message.mentionsBotId && !message.mentionsBotRole && !message.mentionsEveryone) {
+          logDebug(TAG3, `Skipped \u2014 mentions another user (optional mode, channel=${effectiveChannelId})`);
+          return;
+        }
+      } else {
+        let isReplyToBot = false;
+        if (message.replyReferenceMessageId && this.config.appId) {
+          try {
+            const referenced = await this.api.fetchMessage(message.channelId, message.replyReferenceMessageId);
+            isReplyToBot = referenced?.authorId === this.config.appId;
+          } catch (err) {
+            logAndSwallow(TAG3, "fetchMessage reply ref", err);
+          }
+        }
+        const addressed = message.mentionsBotId || message.mentionsBotRole || isReplyToBot;
+        if (!addressed) {
+          logDebug(TAG3, `Skipped \u2014 not addressed (channel=${effectiveChannelId})`);
+          return;
+        }
+      }
+    }
+    const channelLabel = message.parentChannelId ? message.channelName ?? "thread" : message.channelName ?? "DM";
+    const senderPrefix = isDM ? "" : `[${message.authorUsername}${message.authorIsBot ? " (bot)" : ""}] in #${channelLabel}: `;
+    const inbound = {
+      platform: "discord",
+      channelId: message.channelId,
+      userId: loadUsers().byPlatformId.get("discord:" + message.authorId)?.userId ?? "unknown",
+      senderId: message.authorId,
+      senderName: message.authorUsername,
+      text: senderPrefix + text,
+      timestamp: message.timestamp,
+      isGroup: !isDM,
+      isVoice: false,
+      mediaPath,
+      rawPlatformData: message
+    };
+    if (text.startsWith("/") && !text.startsWith("//")) {
+      handleInboundMessage(inbound, this, this.deps.pipeline).catch((err) => logAndSwallow(TAG3, "handleInboundMessage command", err));
+      return;
+    }
+    await handleInboundMessage(inbound, this, this.deps.pipeline);
+  }
+  async handleReaction(reaction, user) {
+    const channelId = reaction.message.channelId;
+    const messageId = Number(reaction.message.id);
+    const emoji = reaction.emoji.name ?? "";
+    if (!emoji) return;
+    const isAuthorized = this.securityGate.authorizeById(user.id, channelId);
+    const senderName = user.username || `id:${user.id}`;
+    logInfo(TAG3, `Reaction ${emoji} from ${senderName} on msg ${reaction.message.id}`);
+    if (isAuthorized && this.deps.memory) {
+      const score = emojiToScore(emoji);
+      const resolvedUserId = loadUsers().byPlatformId.get("discord:" + user.id)?.userId ?? "unknown";
+      const updated = this.deps.memory.updateEmotionByPlatformId(resolvedUserId, messageId, score);
+      if (updated) logDebug(TAG3, `Emotion score ${score} set on msg ${reaction.message.id}`);
+    }
+    if (!isAuthorized) {
+      logDebug(TAG3, `Unauthorized reaction from ${user.id}, discarding`);
+      return;
+    }
+    const signal = formatReactionSignal(senderName, [emoji]);
+    const bufKey = `discord:${channelId}`;
+    this.deps.conversationBuffer.push(bufKey, senderName, signal);
+    logDebug(TAG3, `Buffered reaction signal for channel ${channelId}`);
+  }
+};
+export {
+  DISCORD_CAPABILITIES,
+  DiscordAdapter
+};
+//# sourceMappingURL=discord-adapter-UYOCKRDF.js.map