opensentinel 2.1.1

package/dist/chunk-HH2HBTQM.js

@@ -0,0 +1,806 @@
+import {
+  textToSpeech
+} from "./chunk-F6QUZQGI.js";
+import {
+  transcribeAudio
+} from "./chunk-GVJVEWHI.js";
+import {
+  scheduleReminder
+} from "./chunk-4LVWXUNC.js";
+import {
+  chatWithTools
+} from "./chunk-CI6Q63MM.js";
+
+// src/inputs/discord/index.ts
+import {
+  Client,
+  GatewayIntentBits,
+  Events,
+  REST,
+  Routes,
+  Collection,
+  ChannelType,
+  AttachmentBuilder,
+  EmbedBuilder
+} from "discord.js";
+import {
+  joinVoiceChannel,
+  createAudioPlayer,
+  createAudioResource,
+  AudioPlayerStatus,
+  VoiceConnectionStatus,
+  entersState
+} from "@discordjs/voice";
+import { Readable } from "stream";
+
+// src/inputs/discord/commands.ts
+import {
+  SlashCommandBuilder
+} from "discord.js";
+var sessions = /* @__PURE__ */ new Map();
+var MAX_HISTORY = 20;
+function getSession(userId) {
+  if (!sessions.has(userId)) {
+    sessions.set(userId, []);
+  }
+  return sessions.get(userId);
+}
+function addToSession(userId, message) {
+  const session = getSession(userId);
+  session.push(message);
+  if (session.length > MAX_HISTORY) {
+    sessions.set(userId, session.slice(-MAX_HISTORY));
+  }
+}
+function clearSession(userId) {
+  sessions.set(userId, []);
+}
+var askCommand = {
+  data: new SlashCommandBuilder().setName("ask").setDescription("Ask OpenSentinel a question").addStringOption(
+    (option) => option.setName("question").setDescription("Your question for OpenSentinel").setRequired(true)
+  ).toJSON(),
+  async execute(interaction) {
+    const question = interaction.options.getString("question", true);
+    const userId = interaction.user.id;
+    await interaction.deferReply();
+    try {
+      addToSession(userId, { role: "user", content: question });
+      const response = await chatWithTools(
+        getSession(userId),
+        `discord:${userId}`
+      );
+      addToSession(userId, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `*Used: ${toolList}*
+
+${response.content}`;
+      }
+      if (finalResponse.length > 2e3) {
+        const chunks = splitMessage(finalResponse, 2e3);
+        await interaction.editReply(chunks[0]);
+        for (let i = 1; i < chunks.length; i++) {
+          await interaction.followUp(chunks[i]);
+        }
+      } else {
+        await interaction.editReply(finalResponse);
+      }
+      console.log(
+        `[Discord] Processed /ask from ${interaction.user.tag}. Tokens: ${response.inputTokens}/${response.outputTokens}`
+      );
+    } catch (error) {
+      console.error("[Discord] Error processing /ask:", error);
+      await interaction.editReply(
+        "Sorry, I encountered an error processing your question. Please try again."
+      );
+    }
+  }
+};
+var chatCommand = {
+  data: new SlashCommandBuilder().setName("chat").setDescription("Have a conversation with OpenSentinel").addStringOption(
+    (option) => option.setName("message").setDescription("Your message").setRequired(true)
+  ).toJSON(),
+  async execute(interaction) {
+    const message = interaction.options.getString("message", true);
+    const userId = interaction.user.id;
+    await interaction.deferReply();
+    try {
+      addToSession(userId, { role: "user", content: message });
+      const response = await chatWithTools(
+        getSession(userId),
+        `discord:${userId}`
+      );
+      addToSession(userId, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `*Used: ${toolList}*
+
+${response.content}`;
+      }
+      if (finalResponse.length > 2e3) {
+        const chunks = splitMessage(finalResponse, 2e3);
+        await interaction.editReply(chunks[0]);
+        for (let i = 1; i < chunks.length; i++) {
+          await interaction.followUp(chunks[i]);
+        }
+      } else {
+        await interaction.editReply(finalResponse);
+      }
+      console.log(
+        `[Discord] Processed /chat from ${interaction.user.tag}. Tokens: ${response.inputTokens}/${response.outputTokens}`
+      );
+    } catch (error) {
+      console.error("[Discord] Error processing /chat:", error);
+      await interaction.editReply(
+        "Sorry, I encountered an error processing your message. Please try again."
+      );
+    }
+  }
+};
+var clearCommand = {
+  data: new SlashCommandBuilder().setName("clear").setDescription("Clear your conversation history with OpenSentinel").toJSON(),
+  async execute(interaction) {
+    clearSession(interaction.user.id);
+    await interaction.reply({
+      content: "Conversation history cleared.",
+      ephemeral: true
+    });
+    console.log(`[Discord] Cleared history for ${interaction.user.tag}`);
+  }
+};
+var remindCommand = {
+  data: new SlashCommandBuilder().setName("remind").setDescription("Set a reminder").addIntegerOption(
+    (option) => option.setName("time").setDescription("Time amount").setRequired(true).setMinValue(1)
+  ).addStringOption(
+    (option) => option.setName("unit").setDescription("Time unit").setRequired(true).addChoices(
+      { name: "seconds", value: "s" },
+      { name: "minutes", value: "m" },
+      { name: "hours", value: "h" }
+    )
+  ).addStringOption(
+    (option) => option.setName("message").setDescription("Reminder message").setRequired(true)
+  ).toJSON(),
+  async execute(interaction) {
+    const time = interaction.options.getInteger("time", true);
+    const unit = interaction.options.getString("unit", true);
+    const message = interaction.options.getString("message", true);
+    const multipliers = {
+      s: 1e3,
+      m: 60 * 1e3,
+      h: 60 * 60 * 1e3
+    };
+    const delayMs = time * multipliers[unit];
+    try {
+      await scheduleReminder(
+        message,
+        delayMs,
+        `discord:${interaction.channelId}:${interaction.user.id}`
+      );
+      const timeStr = unit === "s" ? "seconds" : unit === "m" ? "minutes" : "hours";
+      await interaction.reply({
+        content: `Reminder set for ${time} ${timeStr}: "${message}"`,
+        ephemeral: true
+      });
+      console.log(
+        `[Discord] Reminder set by ${interaction.user.tag}: ${time}${unit} - "${message}"`
+      );
+    } catch (error) {
+      console.error("[Discord] Error setting reminder:", error);
+      await interaction.reply({
+        content: "Sorry, I couldn't set the reminder. Please try again.",
+        ephemeral: true
+      });
+    }
+  }
+};
+var statusCommand = {
+  data: new SlashCommandBuilder().setName("status").setDescription("Check OpenSentinel status and capabilities").toJSON(),
+  async execute(interaction) {
+    const session = getSession(interaction.user.id);
+    const historyCount = session.length;
+    await interaction.reply({
+      content: `**OpenSentinel Status**
+
+Bot: Online
+Your conversation history: ${historyCount} messages
+
+**Capabilities:**
+- Chat and answer questions using Claude AI
+- Execute shell commands
+- Read and write files
+- Search the web
+- Remember important information
+- Set reminders
+- Voice channel support (join, speak)
+
+Use \`/help\` for available commands.`,
+      ephemeral: true
+    });
+  }
+};
+var helpCommand = {
+  data: new SlashCommandBuilder().setName("help").setDescription("Show available OpenSentinel commands").toJSON(),
+  async execute(interaction) {
+    await interaction.reply({
+      content: `**OpenSentinel Commands**
+
+\`/ask <question>\` - Ask a single question
+\`/chat <message>\` - Continue a conversation
+\`/clear\` - Clear your conversation history
+\`/remind <time> <unit> <message>\` - Set a reminder
+\`/status\` - Check bot status
+\`/voice join\` - Join your voice channel
+\`/voice leave\` - Leave the voice channel
+\`/voice speak <text>\` - Speak text in voice channel
+\`/help\` - Show this help message
+
+**Tips:**
+- Use \`/chat\` for multi-turn conversations with context
+- Use \`/ask\` for quick one-off questions
+- DM me directly to chat without slash commands`,
+      ephemeral: true
+    });
+  }
+};
+var voiceCommand = {
+  data: new SlashCommandBuilder().setName("voice").setDescription("Voice channel operations").addSubcommand(
+    (subcommand) => subcommand.setName("join").setDescription("Join your current voice channel")
+  ).addSubcommand(
+    (subcommand) => subcommand.setName("leave").setDescription("Leave the voice channel")
+  ).addSubcommand(
+    (subcommand) => subcommand.setName("speak").setDescription("Speak text in the voice channel").addStringOption(
+      (option) => option.setName("text").setDescription("Text to speak").setRequired(true)
+    )
+  ).toJSON(),
+  async execute(interaction) {
+    const subcommand = interaction.options.getSubcommand();
+    await interaction.reply({
+      content: `Voice command received: ${subcommand}. Voice handling is managed by the Discord bot.`,
+      ephemeral: true
+    });
+  }
+};
+var slashCommands = [
+  askCommand,
+  chatCommand,
+  clearCommand,
+  remindCommand,
+  statusCommand,
+  helpCommand,
+  voiceCommand
+];
+function getCommandData() {
+  return slashCommands.map((cmd) => cmd.data);
+}
+function getCommand(name) {
+  return slashCommands.find(
+    (cmd) => cmd.data.name === name
+  );
+}
+function splitMessage(text, maxLength) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+    let breakPoint = remaining.lastIndexOf("\n", maxLength);
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = remaining.lastIndexOf(" ", maxLength);
+    }
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = maxLength;
+    }
+    chunks.push(remaining.slice(0, breakPoint));
+    remaining = remaining.slice(breakPoint).trim();
+  }
+  return chunks;
+}
+
+// src/inputs/discord/index.ts
+var DiscordBot = class {
+  client;
+  config;
+  rest;
+  voiceConnections = /* @__PURE__ */ new Map();
+  commandCollection;
+  isReady = false;
+  constructor(config) {
+    this.config = config;
+    this.client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.DirectMessages,
+        GatewayIntentBits.GuildVoiceStates,
+        GatewayIntentBits.MessageContent
+        // Privileged - must be enabled in Developer Portal
+        // GatewayIntentBits.GuildMembers, // Optional - enable for role-based authorization
+      ]
+    });
+    this.rest = new REST({ version: "10" }).setToken(config.token);
+    this.commandCollection = new Collection();
+    for (const command of slashCommands) {
+      this.commandCollection.set(command.data.name, command);
+    }
+    this.setupEventHandlers();
+  }
+  /**
+   * Set up Discord event handlers
+   */
+  setupEventHandlers() {
+    this.client.once(Events.ClientReady, (readyClient) => {
+      this.isReady = true;
+      console.log(`[Discord] Bot ready as ${readyClient.user.tag}`);
+      console.log(
+        `[Discord] Connected to ${readyClient.guilds.cache.size} guild(s)`
+      );
+    });
+    this.client.on(Events.InteractionCreate, async (interaction) => {
+      await this.handleInteraction(interaction);
+    });
+    this.client.on(Events.MessageCreate, async (message) => {
+      await this.handleMessage(message);
+    });
+    this.client.on(Events.VoiceStateUpdate, async (oldState, newState) => {
+      await this.handleVoiceStateUpdate(oldState, newState);
+    });
+    this.client.on(Events.Error, (error) => {
+      console.error("[Discord] Client error:", error);
+    });
+    this.client.on(Events.Warn, (warning) => {
+      console.warn("[Discord] Warning:", warning);
+    });
+  }
+  /**
+   * Handle slash command interactions
+   */
+  async handleInteraction(interaction) {
+    if (!interaction.isChatInputCommand()) return;
+    if (!this.isUserAuthorized(interaction.user.id, interaction.member)) {
+      await interaction.reply({
+        content: "You are not authorized to use this bot.",
+        ephemeral: true
+      });
+      return;
+    }
+    const command = this.commandCollection.get(interaction.commandName);
+    if (!command) {
+      console.warn(`[Discord] Unknown command: ${interaction.commandName}`);
+      return;
+    }
+    if (interaction.commandName === "voice") {
+      await this.handleVoiceCommand(interaction);
+      return;
+    }
+    try {
+      await command.execute(interaction);
+    } catch (error) {
+      console.error(
+        `[Discord] Error executing command ${interaction.commandName}:`,
+        error
+      );
+      const errorMessage = "There was an error executing this command.";
+      if (interaction.replied || interaction.deferred) {
+        await interaction.followUp({ content: errorMessage, ephemeral: true });
+      } else {
+        await interaction.reply({ content: errorMessage, ephemeral: true });
+      }
+    }
+  }
+  /**
+   * Handle voice slash commands
+   */
+  async handleVoiceCommand(interaction) {
+    if (!interaction.isChatInputCommand()) return;
+    const subcommand = interaction.options.getSubcommand();
+    switch (subcommand) {
+      case "join":
+        await this.joinVoiceChannel(interaction);
+        break;
+      case "leave":
+        await this.leaveVoiceChannel(interaction);
+        break;
+      case "speak":
+        await this.speakInVoiceChannel(interaction);
+        break;
+      default:
+        await interaction.reply({
+          content: "Unknown voice subcommand.",
+          ephemeral: true
+        });
+    }
+  }
+  /**
+   * Join a voice channel
+   */
+  async joinVoiceChannel(interaction) {
+    if (!interaction.isChatInputCommand() || !interaction.guild) {
+      return;
+    }
+    const member = interaction.member;
+    const voiceChannel = member.voice.channel;
+    if (!voiceChannel) {
+      await interaction.reply({
+        content: "You need to be in a voice channel for me to join.",
+        ephemeral: true
+      });
+      return;
+    }
+    try {
+      const connection = joinVoiceChannel({
+        channelId: voiceChannel.id,
+        guildId: interaction.guild.id,
+        adapterCreator: interaction.guild.voiceAdapterCreator
+      });
+      const player = createAudioPlayer();
+      connection.subscribe(player);
+      await entersState(connection, VoiceConnectionStatus.Ready, 3e4);
+      this.voiceConnections.set(interaction.guild.id, {
+        connection,
+        player,
+        guildId: interaction.guild.id,
+        channelId: voiceChannel.id
+      });
+      await interaction.reply({
+        content: `Joined ${voiceChannel.name}!`,
+        ephemeral: true
+      });
+      console.log(
+        `[Discord] Joined voice channel: ${voiceChannel.name} in ${interaction.guild.name}`
+      );
+    } catch (error) {
+      console.error("[Discord] Error joining voice channel:", error);
+      await interaction.reply({
+        content: "Failed to join the voice channel. Please try again.",
+        ephemeral: true
+      });
+    }
+  }
+  /**
+   * Leave a voice channel
+   */
+  async leaveVoiceChannel(interaction) {
+    if (!interaction.isChatInputCommand() || !interaction.guild) {
+      return;
+    }
+    const voiceState = this.voiceConnections.get(interaction.guild.id);
+    if (!voiceState) {
+      await interaction.reply({
+        content: "I'm not in a voice channel.",
+        ephemeral: true
+      });
+      return;
+    }
+    try {
+      voiceState.player.stop();
+      voiceState.connection.destroy();
+      this.voiceConnections.delete(interaction.guild.id);
+      await interaction.reply({
+        content: "Left the voice channel.",
+        ephemeral: true
+      });
+      console.log(
+        `[Discord] Left voice channel in ${interaction.guild.name}`
+      );
+    } catch (error) {
+      console.error("[Discord] Error leaving voice channel:", error);
+      await interaction.reply({
+        content: "Failed to leave the voice channel.",
+        ephemeral: true
+      });
+    }
+  }
+  /**
+   * Speak text in a voice channel using TTS
+   */
+  async speakInVoiceChannel(interaction) {
+    if (!interaction.isChatInputCommand() || !interaction.guild) {
+      return;
+    }
+    const voiceState = this.voiceConnections.get(interaction.guild.id);
+    if (!voiceState) {
+      await interaction.reply({
+        content: "I need to be in a voice channel first. Use `/voice join`.",
+        ephemeral: true
+      });
+      return;
+    }
+    const text = interaction.options.getString("text", true);
+    await interaction.deferReply({ ephemeral: true });
+    try {
+      const audioBuffer = await textToSpeech(text);
+      if (!audioBuffer) {
+        await interaction.editReply("Failed to generate speech. TTS service may be unavailable.");
+        return;
+      }
+      const stream = Readable.from(audioBuffer);
+      const resource = createAudioResource(stream);
+      voiceState.player.play(resource);
+      await new Promise((resolve) => {
+        voiceState.player.once(AudioPlayerStatus.Idle, () => resolve());
+      });
+      await interaction.editReply(`Spoke: "${text}"`);
+      console.log(
+        `[Discord] Spoke in voice channel: "${text.substring(0, 50)}..."`
+      );
+    } catch (error) {
+      console.error("[Discord] Error speaking in voice channel:", error);
+      await interaction.editReply(
+        "Failed to speak in the voice channel. Please try again."
+      );
+    }
+  }
+  /**
+   * Handle incoming messages (DMs and @mentions)
+   */
+  async handleMessage(message) {
+    if (message.author.bot) return;
+    const isDM = message.channel.type === ChannelType.DM;
+    const isMentioned = message.mentions.has(this.client.user.id);
+    if (!isDM && !isMentioned) return;
+    if (isDM && !this.config.allowDMs) return;
+    if (!isDM && !this.config.allowChannels) return;
+    if (!this.isUserAuthorized(message.author.id, message.member)) return;
+    let content = message.content;
+    if (isMentioned) {
+      content = content.replace(/<@!?\d+>/g, "").trim();
+    }
+    if (!content && message.attachments.size === 0) return;
+    const userId = message.author.id;
+    try {
+      if ("sendTyping" in message.channel) {
+        await message.channel.sendTyping();
+      }
+      let processedContent = content;
+      if (message.attachments.size > 0) {
+        const attachmentDescriptions = await this.processAttachments(message);
+        if (attachmentDescriptions.length > 0) {
+          processedContent += "\n\n[Attachments:\n" + attachmentDescriptions.join("\n") + "]";
+        }
+      }
+      addToSession(userId, { role: "user", content: processedContent });
+      const response = await chatWithTools(
+        getSession(userId),
+        `discord:${userId}`,
+        async () => {
+          if ("sendTyping" in message.channel) {
+            await message.channel.sendTyping();
+          }
+        }
+      );
+      addToSession(userId, { role: "assistant", content: response.content });
+      let finalResponse = response.content;
+      if (response.toolsUsed && response.toolsUsed.length > 0) {
+        const toolList = [...new Set(response.toolsUsed)].join(", ");
+        finalResponse = `*Used: ${toolList}*
+
+${response.content}`;
+      }
+      if (finalResponse.length > 2e3) {
+        const chunks = splitMessage(finalResponse, 2e3);
+        for (const chunk of chunks) {
+          await message.reply(chunk);
+        }
+      } else {
+        await message.reply(finalResponse);
+      }
+      console.log(
+        `[Discord] Processed message from ${message.author.tag}. Tokens: ${response.inputTokens}/${response.outputTokens}` + (response.toolsUsed ? ` Tools: ${response.toolsUsed.join(", ")}` : "")
+      );
+    } catch (error) {
+      console.error("[Discord] Error processing message:", error);
+      await message.reply(
+        "Sorry, I encountered an error processing your message. Please try again."
+      );
+    }
+  }
+  /**
+   * Process message attachments
+   */
+  async processAttachments(message) {
+    const descriptions = [];
+    for (const [, attachment] of message.attachments) {
+      const contentType = attachment.contentType || "";
+      const fileName = attachment.name || "unknown";
+      if (contentType.startsWith("audio/")) {
+        try {
+          const response = await fetch(attachment.url);
+          const audioBuffer = await response.arrayBuffer();
+          const transcription = await transcribeAudio(Buffer.from(audioBuffer));
+          if (transcription) {
+            descriptions.push(`Audio transcription (${fileName}): "${transcription}"`);
+          } else {
+            descriptions.push(`Audio file: ${fileName} (could not transcribe)`);
+          }
+        } catch (error) {
+          console.error("[Discord] Error processing audio attachment:", error);
+          descriptions.push(`Audio file: ${fileName} (error processing)`);
+        }
+      } else if (contentType.startsWith("text/")) {
+        try {
+          const response = await fetch(attachment.url);
+          const text = await response.text();
+          const preview = text.length > 1e3 ? text.substring(0, 1e3) + "..." : text;
+          descriptions.push(`Text file (${fileName}):
+${preview}`);
+        } catch (error) {
+          descriptions.push(`Text file: ${fileName} (could not read)`);
+        }
+      } else {
+        descriptions.push(
+          `File: ${fileName} (${contentType || "unknown type"}, ${attachment.size} bytes)`
+        );
+      }
+    }
+    return descriptions;
+  }
+  /**
+   * Handle voice state updates
+   */
+  async handleVoiceStateUpdate(oldState, newState) {
+    if (oldState.member?.id === this.client.user?.id && !newState.channelId && oldState.channelId) {
+      const guildId = oldState.guild?.id || oldState.guildId;
+      const voiceState = this.voiceConnections.get(guildId);
+      if (voiceState) {
+        voiceState.player.stop();
+        this.voiceConnections.delete(guildId);
+        console.log(`[Discord] Bot disconnected from voice in ${oldState.guild?.name || guildId}`);
+      }
+    }
+  }
+  /**
+   * Check if a user is authorized to use the bot
+   */
+  isUserAuthorized(userId, member) {
+    if (!this.config.allowedUserIds?.length && !this.config.allowedRoleIds?.length) {
+      return true;
+    }
+    if (this.config.allowedUserIds?.includes(userId)) {
+      return true;
+    }
+    if (member && this.config.allowedRoleIds?.length) {
+      try {
+        for (const roleId of this.config.allowedRoleIds) {
+          if (member.roles?.cache?.has(roleId)) {
+            return true;
+          }
+        }
+      } catch {
+      }
+    }
+    return false;
+  }
+  /**
+   * Register slash commands with Discord
+   */
+  async registerCommands() {
+    const commands = getCommandData();
+    try {
+      console.log("[Discord] Registering slash commands...");
+      if (this.config.guildId) {
+        await this.rest.put(
+          Routes.applicationGuildCommands(
+            this.config.clientId,
+            this.config.guildId
+          ),
+          { body: commands }
+        );
+        console.log(
+          `[Discord] Registered ${commands.length} guild commands for guild ${this.config.guildId}`
+        );
+      } else {
+        await this.rest.put(Routes.applicationCommands(this.config.clientId), {
+          body: commands
+        });
+        console.log(
+          `[Discord] Registered ${commands.length} global commands`
+        );
+      }
+    } catch (error) {
+      console.error("[Discord] Error registering commands:", error);
+      throw error;
+    }
+  }
+  /**
+   * Start the Discord bot
+   */
+  async start() {
+    console.log("[Discord] Starting bot...");
+    await this.registerCommands();
+    await this.client.login(this.config.token);
+  }
+  /**
+   * Stop the Discord bot
+   */
+  async stop() {
+    console.log("[Discord] Stopping bot...");
+    for (const [guildId, voiceState] of this.voiceConnections) {
+      voiceState.player.stop();
+      voiceState.connection.destroy();
+      this.voiceConnections.delete(guildId);
+    }
+    this.client.destroy();
+    this.isReady = false;
+    console.log("[Discord] Bot stopped");
+  }
+  /**
+   * Get the Discord client
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Check if bot is ready
+   */
+  ready() {
+    return this.isReady;
+  }
+  /**
+   * Send a message to a channel
+   */
+  async sendMessage(channelId, content) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (channel?.isTextBased() && "send" in channel) {
+      await channel.send(content);
+    }
+  }
+  /**
+   * Send a message with an embed
+   */
+  async sendEmbed(channelId, title, description, color) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (channel?.isTextBased() && "send" in channel) {
+      const embed = new EmbedBuilder().setTitle(title).setDescription(description).setColor(color || 5793266).setTimestamp();
+      await channel.send({ embeds: [embed] });
+    }
+  }
+  /**
+   * Send a file to a channel
+   */
+  async sendFile(channelId, buffer, filename, content) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (channel?.isTextBased() && "send" in channel) {
+      const attachment = new AttachmentBuilder(buffer, { name: filename });
+      await channel.send({
+        content,
+        files: [attachment]
+      });
+    }
+  }
+};
+function createDiscordBot(config) {
+  return new DiscordBot(config);
+}
+var discord_default = {
+  createDiscordBot,
+  DiscordBot,
+  slashCommands,
+  getCommandData,
+  getCommand
+};
+
+export {
+  sessions,
+  getSession,
+  addToSession,
+  clearSession,
+  askCommand,
+  chatCommand,
+  clearCommand,
+  remindCommand,
+  statusCommand,
+  helpCommand,
+  voiceCommand,
+  slashCommands,
+  getCommandData,
+  getCommand,
+  splitMessage,
+  DiscordBot,
+  createDiscordBot,
+  discord_default
+};
+//# sourceMappingURL=chunk-HH2HBTQM.js.map