@furlow/discord 0.1.0

package/dist/index.js

@@ -0,0 +1,1089 @@
+// src/client/index.ts
+import {
+  Client,
+  GatewayIntentBits,
+  Partials
+} from "discord.js";
+var INTENT_MAP = {
+  guilds: GatewayIntentBits.Guilds,
+  guild_members: GatewayIntentBits.GuildMembers,
+  guild_moderation: GatewayIntentBits.GuildModeration,
+  guild_emojis_and_stickers: GatewayIntentBits.GuildEmojisAndStickers,
+  guild_integrations: GatewayIntentBits.GuildIntegrations,
+  guild_webhooks: GatewayIntentBits.GuildWebhooks,
+  guild_invites: GatewayIntentBits.GuildInvites,
+  guild_voice_states: GatewayIntentBits.GuildVoiceStates,
+  guild_presences: GatewayIntentBits.GuildPresences,
+  guild_messages: GatewayIntentBits.GuildMessages,
+  guild_message_reactions: GatewayIntentBits.GuildMessageReactions,
+  guild_message_typing: GatewayIntentBits.GuildMessageTyping,
+  direct_messages: GatewayIntentBits.DirectMessages,
+  direct_message_reactions: GatewayIntentBits.DirectMessageReactions,
+  direct_message_typing: GatewayIntentBits.DirectMessageTyping,
+  message_content: GatewayIntentBits.MessageContent,
+  guild_scheduled_events: GatewayIntentBits.GuildScheduledEvents,
+  auto_moderation_configuration: GatewayIntentBits.AutoModerationConfiguration,
+  auto_moderation_execution: GatewayIntentBits.AutoModerationExecution
+};
+var FurlowClient = class {
+  client;
+  token;
+  spec;
+  constructor(options) {
+    this.token = options.token;
+    this.spec = options.spec;
+    const intents = this.resolveIntents(options.spec.intents);
+    const clientOptions = {
+      intents,
+      partials: [
+        Partials.Message,
+        Partials.Channel,
+        Partials.Reaction,
+        Partials.User,
+        Partials.GuildMember
+      ]
+    };
+    this.client = new Client(clientOptions);
+  }
+  /**
+   * Resolve intents from spec
+   */
+  resolveIntents(config) {
+    if (!config) {
+      return [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.GuildMembers,
+        GatewayIntentBits.MessageContent
+      ];
+    }
+    if (config.auto) {
+      return this.autoDetectIntents();
+    }
+    if (config.explicit) {
+      return config.explicit.map((intent) => INTENT_MAP[intent]).filter((i) => i !== void 0);
+    }
+    return [GatewayIntentBits.Guilds];
+  }
+  /**
+   * Auto-detect required intents from spec
+   */
+  autoDetectIntents() {
+    const intents = /* @__PURE__ */ new Set();
+    intents.add(GatewayIntentBits.Guilds);
+    if (this.spec.events) {
+      for (const handler of this.spec.events) {
+        switch (handler.event) {
+          case "message_create":
+          case "message":
+          case "message_update":
+          case "message_delete":
+            intents.add(GatewayIntentBits.GuildMessages);
+            intents.add(GatewayIntentBits.MessageContent);
+            break;
+          case "guild_member_add":
+          case "guild_member_remove":
+          case "guild_member_update":
+          case "member_join":
+          case "member_leave":
+            intents.add(GatewayIntentBits.GuildMembers);
+            break;
+          case "voice_state_update":
+          case "voice_join":
+          case "voice_leave":
+            intents.add(GatewayIntentBits.GuildVoiceStates);
+            break;
+          case "message_reaction_add":
+          case "message_reaction_remove":
+            intents.add(GatewayIntentBits.GuildMessageReactions);
+            break;
+          case "presence_update":
+            intents.add(GatewayIntentBits.GuildPresences);
+            break;
+        }
+      }
+    }
+    if (this.spec.commands?.length) {
+      intents.add(GatewayIntentBits.GuildMessages);
+    }
+    if (this.spec.voice) {
+      intents.add(GatewayIntentBits.GuildVoiceStates);
+    }
+    return [...intents];
+  }
+  /**
+   * Start the client
+   */
+  async start() {
+    await this.client.login(this.token);
+    if (!this.client.isReady()) {
+      await new Promise((resolve) => {
+        this.client.once("ready", () => resolve());
+      });
+    }
+    await this.applyIdentity();
+    await this.applyPresence();
+  }
+  /**
+   * Stop the client
+   */
+  async stop() {
+    await this.client.destroy();
+  }
+  /**
+   * Apply bot identity
+   */
+  async applyIdentity() {
+    if (!this.spec.identity) return;
+    const identity = this.spec.identity;
+    if (identity.name && this.client.user?.username !== identity.name) {
+      try {
+        await this.client.user?.setUsername(identity.name);
+      } catch {
+      }
+    }
+    if (identity.avatar) {
+      try {
+        await this.client.user?.setAvatar(identity.avatar);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Apply presence
+   */
+  async applyPresence() {
+    if (!this.spec.presence) return;
+    const presence = this.spec.presence;
+    this.client.user?.setPresence({
+      status: presence.status ?? "online",
+      activities: presence.activity ? [
+        {
+          type: this.getActivityType(presence.activity.type),
+          name: presence.activity.text,
+          url: presence.activity.url,
+          state: presence.activity.state
+        }
+      ] : void 0
+    });
+  }
+  /**
+   * Get Discord.js activity type
+   */
+  getActivityType(type) {
+    const types = {
+      playing: 0,
+      streaming: 1,
+      listening: 2,
+      watching: 3,
+      custom: 4,
+      competing: 5
+    };
+    return types[type] ?? 0;
+  }
+  /**
+   * Register event listener
+   */
+  on(event, listener) {
+    this.client.on(event, listener);
+    return this;
+  }
+  /**
+   * Register one-time event listener
+   */
+  once(event, listener) {
+    this.client.once(event, listener);
+    return this;
+  }
+  /**
+   * Get the underlying Discord.js client
+   */
+  getClient() {
+    return this.client;
+  }
+  /**
+   * Get the spec
+   */
+  getSpec() {
+    return this.spec;
+  }
+  /**
+   * Check if client is ready
+   */
+  isReady() {
+    return this.client.isReady();
+  }
+  /**
+   * Get guild count
+   */
+  get guildCount() {
+    return this.client.guilds.cache.size;
+  }
+  /**
+   * Get user count (approximate)
+   */
+  get userCount() {
+    return this.client.guilds.cache.reduce((acc, guild) => acc + guild.memberCount, 0);
+  }
+};
+function createClient(options) {
+  return new FurlowClient(options);
+}
+
+// src/gateway/index.ts
+var GatewayManager = class {
+  client;
+  config;
+  reconnectAttempts = 0;
+  maxReconnectAttempts;
+  baseDelay;
+  maxDelay;
+  backoffStrategy;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.config = options.config ?? {};
+    const reconnect = this.config.reconnect ?? {};
+    this.maxReconnectAttempts = reconnect.max_retries ?? 10;
+    const baseDelay = reconnect.base_delay ?? "1s";
+    const maxDelay = reconnect.max_delay ?? "60s";
+    this.baseDelay = typeof baseDelay === "number" ? baseDelay : this.parseDuration(baseDelay);
+    this.maxDelay = typeof maxDelay === "number" ? maxDelay : this.parseDuration(maxDelay);
+    this.backoffStrategy = reconnect.backoff ?? "exponential";
+    this.setupListeners(options);
+  }
+  setupListeners(options) {
+    this.client.on("shardReady", (shardId) => {
+      console.log(`Shard ${shardId} ready`);
+      this.reconnectAttempts = 0;
+    });
+    this.client.on("shardDisconnect", (event, shardId) => {
+      console.log(`Shard ${shardId} disconnected: ${event.code}`);
+      options.onDisconnect?.();
+    });
+    this.client.on("shardReconnecting", (shardId) => {
+      console.log(`Shard ${shardId} reconnecting...`);
+      this.reconnectAttempts++;
+      options.onReconnect?.();
+    });
+    this.client.on("shardError", (error, shardId) => {
+      console.error(`Shard ${shardId} error:`, error);
+      options.onError?.(error);
+    });
+    this.client.on("shardResume", (shardId, replayedEvents) => {
+      console.log(`Shard ${shardId} resumed, replayed ${replayedEvents} events`);
+      this.reconnectAttempts = 0;
+    });
+  }
+  /**
+   * Get the delay for the next reconnection attempt
+   */
+  getReconnectDelay() {
+    switch (this.backoffStrategy) {
+      case "exponential":
+        return Math.min(
+          this.baseDelay * Math.pow(2, this.reconnectAttempts),
+          this.maxDelay
+        );
+      case "linear":
+        return Math.min(
+          this.baseDelay * (this.reconnectAttempts + 1),
+          this.maxDelay
+        );
+      case "fixed":
+      default:
+        return this.baseDelay;
+    }
+  }
+  /**
+   * Check if we should attempt reconnection
+   */
+  shouldReconnect() {
+    return this.reconnectAttempts < this.maxReconnectAttempts;
+  }
+  /**
+   * Get current reconnect attempt count
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Reset reconnect counter
+   */
+  resetReconnectAttempts() {
+    this.reconnectAttempts = 0;
+  }
+  /**
+   * Get gateway latency (ping)
+   */
+  getPing() {
+    return this.client.ws.ping;
+  }
+  /**
+   * Get shard info
+   */
+  getShardInfo() {
+    return [...this.client.ws.shards.values()].map((shard) => ({
+      id: shard.id,
+      status: shard.status.toString(),
+      ping: shard.ping
+    }));
+  }
+  /**
+   * Parse duration string to milliseconds
+   */
+  parseDuration(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m|h)?$/);
+    if (!match) return 1e3;
+    const value = parseInt(match[1], 10);
+    const unit = match[2] ?? "s";
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 60 * 1e3;
+      case "h":
+        return value * 60 * 60 * 1e3;
+      default:
+        return value * 1e3;
+    }
+  }
+};
+function createGatewayManager(client, options) {
+  return new GatewayManager(client, options);
+}
+
+// src/interactions/index.ts
+import {
+  REST,
+  Routes,
+  SlashCommandBuilder,
+  ContextMenuCommandBuilder,
+  ApplicationCommandType
+} from "discord.js";
+var InteractionHandler = class {
+  client;
+  rest;
+  clientId;
+  guildId;
+  commandHandlers = /* @__PURE__ */ new Map();
+  buttonHandlers = /* @__PURE__ */ new Map();
+  selectHandlers = /* @__PURE__ */ new Map();
+  modalHandlers = /* @__PURE__ */ new Map();
+  userContextHandlers = /* @__PURE__ */ new Map();
+  messageContextHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.client = options.client;
+    this.clientId = options.clientId;
+    this.guildId = options.guildId;
+    this.rest = new REST({ version: "10" }).setToken(options.token);
+    this.setupListener();
+  }
+  /**
+   * Set up the interaction listener
+   */
+  setupListener() {
+    this.client.on("interactionCreate", async (interaction) => {
+      try {
+        await this.handleInteraction(interaction);
+      } catch (error) {
+        console.error("Interaction error:", error);
+        if (interaction.isRepliable() && !interaction.replied && !interaction.deferred) {
+          await interaction.reply({
+            content: "An error occurred while processing this interaction.",
+            ephemeral: true
+          }).catch(() => {
+          });
+        }
+      }
+    });
+  }
+  /**
+   * Handle an interaction
+   */
+  async handleInteraction(interaction) {
+    if (interaction.isChatInputCommand()) {
+      const handler = this.commandHandlers.get(interaction.commandName);
+      if (handler) {
+        await handler(interaction);
+      }
+    } else if (interaction.isButton()) {
+      const handler = this.buttonHandlers.get(interaction.customId) ?? this.findPrefixHandler(this.buttonHandlers, interaction.customId);
+      if (handler) {
+        await handler(interaction);
+      }
+    } else if (interaction.isStringSelectMenu()) {
+      const handler = this.selectHandlers.get(interaction.customId) ?? this.findPrefixHandler(this.selectHandlers, interaction.customId);
+      if (handler) {
+        await handler(interaction);
+      }
+    } else if (interaction.isModalSubmit()) {
+      const handler = this.modalHandlers.get(interaction.customId) ?? this.findPrefixHandler(this.modalHandlers, interaction.customId);
+      if (handler) {
+        await handler(interaction);
+      }
+    } else if (interaction.isUserContextMenuCommand()) {
+      const handler = this.userContextHandlers.get(interaction.commandName);
+      if (handler) {
+        await handler(interaction);
+      }
+    } else if (interaction.isMessageContextMenuCommand()) {
+      const handler = this.messageContextHandlers.get(interaction.commandName);
+      if (handler) {
+        await handler(interaction);
+      }
+    }
+  }
+  /**
+   * Find a handler by prefix (for dynamic IDs like "button_123")
+   */
+  findPrefixHandler(handlers, customId) {
+    for (const [key, handler] of handlers) {
+      if (key.endsWith("*") && customId.startsWith(key.slice(0, -1))) {
+        return handler;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Register a command handler
+   */
+  onCommand(name, handler) {
+    this.commandHandlers.set(name, handler);
+  }
+  /**
+   * Register a button handler
+   */
+  onButton(customId, handler) {
+    this.buttonHandlers.set(customId, handler);
+  }
+  /**
+   * Register a select menu handler
+   */
+  onSelect(customId, handler) {
+    this.selectHandlers.set(customId, handler);
+  }
+  /**
+   * Register a modal handler
+   */
+  onModal(customId, handler) {
+    this.modalHandlers.set(customId, handler);
+  }
+  /**
+   * Register a user context menu handler
+   */
+  onUserContext(name, handler) {
+    this.userContextHandlers.set(name, handler);
+  }
+  /**
+   * Register a message context menu handler
+   */
+  onMessageContext(name, handler) {
+    this.messageContextHandlers.set(name, handler);
+  }
+  /**
+   * Register slash commands with Discord
+   */
+  async registerCommands(commands, contextMenus) {
+    const slashCommands = commands.map((cmd) => this.buildSlashCommand(cmd));
+    const contextCommands = (contextMenus ?? []).map((cmd) => this.buildContextMenu(cmd));
+    const allCommands = [...slashCommands, ...contextCommands];
+    if (this.guildId) {
+      await this.rest.put(
+        Routes.applicationGuildCommands(this.clientId, this.guildId),
+        { body: allCommands }
+      );
+    } else {
+      await this.rest.put(Routes.applicationCommands(this.clientId), {
+        body: allCommands
+      });
+    }
+  }
+  /**
+   * Build a slash command from definition
+   */
+  buildSlashCommand(cmd) {
+    const builder = new SlashCommandBuilder().setName(cmd.name).setDescription(cmd.description);
+    if (cmd.dm_permission !== void 0) {
+      builder.setDMPermission(cmd.dm_permission);
+    }
+    if (cmd.nsfw) {
+      builder.setNSFW(true);
+    }
+    if (cmd.options) {
+      for (const opt of cmd.options) {
+        this.addOption(builder, opt);
+      }
+    }
+    if (cmd.subcommands) {
+      for (const sub of cmd.subcommands) {
+        builder.addSubcommand((subBuilder) => {
+          subBuilder.setName(sub.name).setDescription(sub.description);
+          if (sub.options) {
+            for (const opt of sub.options) {
+              this.addOption(subBuilder, opt);
+            }
+          }
+          return subBuilder;
+        });
+      }
+    }
+    if (cmd.subcommand_groups) {
+      for (const group of cmd.subcommand_groups) {
+        builder.addSubcommandGroup((groupBuilder) => {
+          groupBuilder.setName(group.name).setDescription(group.description);
+          for (const sub of group.subcommands) {
+            groupBuilder.addSubcommand((subBuilder) => {
+              subBuilder.setName(sub.name).setDescription(sub.description);
+              if (sub.options) {
+                for (const opt of sub.options) {
+                  this.addOption(subBuilder, opt);
+                }
+              }
+              return subBuilder;
+            });
+          }
+          return groupBuilder;
+        });
+      }
+    }
+    return builder.toJSON();
+  }
+  /**
+   * Add an option to a command builder
+   */
+  addOption(builder, opt) {
+    const addMethod = `add${this.getOptionMethodName(opt.type)}Option`;
+    if (typeof builder[addMethod] !== "function") {
+      console.warn(`Unknown option type: ${opt.type}`);
+      return;
+    }
+    builder[addMethod]((optBuilder) => {
+      optBuilder.setName(opt.name).setDescription(opt.description);
+      if (opt.required) {
+        optBuilder.setRequired(true);
+      }
+      if (opt.choices && optBuilder.addChoices) {
+        optBuilder.addChoices(...opt.choices);
+      }
+      if (opt.min_value !== void 0 && optBuilder.setMinValue) {
+        optBuilder.setMinValue(opt.min_value);
+      }
+      if (opt.max_value !== void 0 && optBuilder.setMaxValue) {
+        optBuilder.setMaxValue(opt.max_value);
+      }
+      if (opt.min_length !== void 0 && optBuilder.setMinLength) {
+        optBuilder.setMinLength(opt.min_length);
+      }
+      if (opt.max_length !== void 0 && optBuilder.setMaxLength) {
+        optBuilder.setMaxLength(opt.max_length);
+      }
+      if (opt.autocomplete && optBuilder.setAutocomplete) {
+        optBuilder.setAutocomplete(true);
+      }
+      return optBuilder;
+    });
+  }
+  /**
+   * Get the method name for an option type
+   */
+  getOptionMethodName(type) {
+    const map = {
+      string: "String",
+      integer: "Integer",
+      number: "Number",
+      boolean: "Boolean",
+      user: "User",
+      channel: "Channel",
+      role: "Role",
+      mentionable: "Mentionable",
+      attachment: "Attachment"
+    };
+    return map[type] ?? "String";
+  }
+  /**
+   * Build a context menu command
+   */
+  buildContextMenu(cmd) {
+    const builder = new ContextMenuCommandBuilder().setName(cmd.name).setType(
+      cmd.type === "user" ? ApplicationCommandType.User : ApplicationCommandType.Message
+    );
+    return builder.toJSON();
+  }
+};
+function createInteractionHandler(options) {
+  return new InteractionHandler(options);
+}
+
+// src/voice/index.ts
+import {
+  joinVoiceChannel,
+  createAudioPlayer,
+  createAudioResource,
+  AudioPlayerStatus,
+  VoiceConnectionStatus,
+  entersState,
+  getVoiceConnection
+} from "@discordjs/voice";
+var VoiceManager = class {
+  guildStates = /* @__PURE__ */ new Map();
+  config = {};
+  /**
+   * Configure the voice manager
+   */
+  configure(config) {
+    this.config = config;
+  }
+  /**
+   * Join a voice channel
+   */
+  async join(channel, options = {}) {
+    const guildId = channel.guild.id;
+    const existing = getVoiceConnection(guildId);
+    if (existing) {
+      existing.destroy();
+    }
+    const connection = joinVoiceChannel({
+      channelId: channel.id,
+      guildId,
+      adapterCreator: channel.guild.voiceAdapterCreator,
+      selfDeaf: options.selfDeaf ?? this.config.connection?.self_deaf ?? true,
+      selfMute: options.selfMute ?? this.config.connection?.self_mute ?? false
+    });
+    await entersState(connection, VoiceConnectionStatus.Ready, 3e4);
+    const player = createAudioPlayer();
+    player.on(AudioPlayerStatus.Idle, () => {
+      this.handleTrackEnd(guildId);
+    });
+    player.on("error", (error) => {
+      console.error(`Audio player error in ${guildId}:`, error);
+      this.handleTrackEnd(guildId);
+    });
+    connection.subscribe(player);
+    this.guildStates.set(guildId, {
+      connection,
+      player,
+      queue: [],
+      currentTrack: null,
+      volume: this.config.default_volume ?? 100,
+      loopMode: this.config.default_loop ?? "off",
+      filters: /* @__PURE__ */ new Set(),
+      paused: false
+    });
+    return connection;
+  }
+  /**
+   * Leave a voice channel
+   */
+  leave(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return false;
+    state.player.stop();
+    state.connection.destroy();
+    this.guildStates.delete(guildId);
+    return true;
+  }
+  /**
+   * Play audio from a URL or file
+   */
+  async play(guildId, source, options = {}) {
+    const state = this.guildStates.get(guildId);
+    if (!state) {
+      throw new Error("Not connected to voice in this guild");
+    }
+    const resource = createAudioResource(source, {
+      inlineVolume: true
+    });
+    const volume = options.volume ?? state.volume;
+    resource.volume?.setVolume(volume / 100);
+    state.player.play(resource);
+    state.paused = false;
+  }
+  /**
+   * Add a track to the queue
+   */
+  addToQueue(guildId, item, position) {
+    const state = this.guildStates.get(guildId);
+    if (!state) {
+      throw new Error("Not connected to voice in this guild");
+    }
+    const maxSize = this.config.max_queue_size ?? 1e3;
+    if (state.queue.length >= maxSize) {
+      throw new Error(`Queue is full (max ${maxSize} tracks)`);
+    }
+    if (position === "next" || position === 0) {
+      state.queue.unshift(item);
+      return 0;
+    } else if (position === "last" || position === void 0) {
+      state.queue.push(item);
+      return state.queue.length - 1;
+    } else if (typeof position === "number") {
+      state.queue.splice(position, 0, item);
+      return position;
+    }
+    state.queue.push(item);
+    return state.queue.length - 1;
+  }
+  /**
+   * Remove a track from the queue
+   */
+  removeFromQueue(guildId, position) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return null;
+    const [removed] = state.queue.splice(position, 1);
+    return removed ?? null;
+  }
+  /**
+   * Clear the queue
+   */
+  clearQueue(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return 0;
+    const count = state.queue.length;
+    state.queue = [];
+    return count;
+  }
+  /**
+   * Shuffle the queue
+   */
+  shuffleQueue(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return;
+    for (let i = state.queue.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [state.queue[i], state.queue[j]] = [state.queue[j], state.queue[i]];
+    }
+  }
+  /**
+   * Skip the current track
+   */
+  skip(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return false;
+    state.player.stop();
+    return true;
+  }
+  /**
+   * Pause playback
+   */
+  pause(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return false;
+    state.player.pause();
+    state.paused = true;
+    return true;
+  }
+  /**
+   * Resume playback
+   */
+  resume(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return false;
+    state.player.unpause();
+    state.paused = false;
+    return true;
+  }
+  /**
+   * Stop playback
+   */
+  stop(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return false;
+    state.player.stop();
+    state.queue = [];
+    state.currentTrack = null;
+    return true;
+  }
+  /**
+   * Set volume
+   */
+  setVolume(guildId, volume) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return false;
+    state.volume = Math.max(0, Math.min(200, volume));
+    return true;
+  }
+  /**
+   * Set loop mode
+   */
+  setLoopMode(guildId, mode) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return;
+    state.loopMode = mode;
+  }
+  /**
+   * Get the current state for a guild
+   */
+  getState(guildId) {
+    return this.guildStates.get(guildId);
+  }
+  /**
+   * Check if connected to a guild
+   */
+  isConnected(guildId) {
+    return this.guildStates.has(guildId);
+  }
+  /**
+   * Get the queue for a guild
+   */
+  getQueue(guildId) {
+    return this.guildStates.get(guildId)?.queue ?? [];
+  }
+  /**
+   * Get the current track for a guild
+   */
+  getCurrentTrack(guildId) {
+    return this.guildStates.get(guildId)?.currentTrack ?? null;
+  }
+  /**
+   * Handle track end (play next or loop)
+   */
+  async handleTrackEnd(guildId) {
+    const state = this.guildStates.get(guildId);
+    if (!state) return;
+    if (state.loopMode === "track" && state.currentTrack) {
+      await this.play(guildId, state.currentTrack.url);
+      return;
+    }
+    if (state.loopMode === "queue" && state.currentTrack) {
+      state.queue.push(state.currentTrack);
+    }
+    const next = state.queue.shift();
+    if (next) {
+      state.currentTrack = next;
+      await this.play(guildId, next.url);
+    } else {
+      state.currentTrack = null;
+    }
+  }
+  /**
+   * Disconnect from all voice channels
+   */
+  disconnectAll() {
+    for (const [guildId] of this.guildStates) {
+      this.leave(guildId);
+    }
+  }
+};
+function createVoiceManager() {
+  return new VoiceManager();
+}
+
+// src/video/index.ts
+var VideoManager = class {
+  client;
+  config = {};
+  streamingMembers = /* @__PURE__ */ new Map();
+  // guildId -> Map<memberId, StreamInfo>
+  listeners = [];
+  initialized = false;
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Configure and initialize the video manager
+   */
+  configure(config) {
+    this.config = config;
+    if (config.stream_detection && !this.initialized) {
+      this.setupListener();
+      this.initialized = true;
+    }
+  }
+  /**
+   * Set up voice state update listener for stream detection
+   */
+  setupListener() {
+    this.client.on("voiceStateUpdate", (oldState, newState) => {
+      this.handleVoiceStateUpdate(oldState, newState);
+    });
+  }
+  /**
+   * Handle voice state update for stream detection
+   */
+  async handleVoiceStateUpdate(oldState, newState) {
+    const guildId = newState.guild.id;
+    const memberId = newState.member?.id;
+    if (!memberId || !newState.member) return;
+    if (!this.streamingMembers.has(guildId)) {
+      this.streamingMembers.set(guildId, /* @__PURE__ */ new Map());
+    }
+    const streaming = this.streamingMembers.get(guildId);
+    const wasStreaming = oldState.streaming;
+    const isStreaming = newState.streaming;
+    if (!wasStreaming && isStreaming && newState.channelId) {
+      const streamInfo = {
+        memberId,
+        username: newState.member.user.username,
+        channelId: newState.channelId,
+        startedAt: /* @__PURE__ */ new Date()
+      };
+      streaming.set(memberId, streamInfo);
+      const event = {
+        type: "start",
+        member: newState.member,
+        channelId: newState.channelId,
+        guildId,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await this.emit(event);
+      await this.sendNotification(event);
+    }
+    if (wasStreaming && !isStreaming) {
+      streaming.delete(memberId);
+      const event = {
+        type: "stop",
+        member: newState.member,
+        channelId: oldState.channelId ?? "",
+        guildId,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await this.emit(event);
+    }
+    if (wasStreaming && !newState.channelId) {
+      streaming.delete(memberId);
+      const event = {
+        type: "stop",
+        member: newState.member,
+        channelId: oldState.channelId ?? "",
+        guildId,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      await this.emit(event);
+    }
+  }
+  /**
+   * Emit a stream event to all listeners
+   */
+  async emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        await listener(event);
+      } catch (error) {
+        console.error("Stream event listener error:", error);
+      }
+    }
+  }
+  /**
+   * Send notification when a stream starts
+   */
+  async sendNotification(event) {
+    if (event.type !== "start" || !this.config.notify_channel) {
+      return;
+    }
+    try {
+      const guild = this.client.guilds.cache.get(event.guildId);
+      if (!guild) return;
+      const channelId = typeof this.config.notify_channel === "string" ? this.config.notify_channel.replace(/[<#>]/g, "") : String(this.config.notify_channel);
+      const channel = guild.channels.cache.get(channelId);
+      if (!channel || !channel.isTextBased()) return;
+      const voiceChannel = guild.channels.cache.get(event.channelId);
+      const voiceChannelName = voiceChannel?.name ?? "Unknown Channel";
+      let content = `**${event.member.displayName}** started streaming in **${voiceChannelName}**!`;
+      if (this.config.notify_role) {
+        const roleId = typeof this.config.notify_role === "string" ? this.config.notify_role.replace(/[<@&>]/g, "") : String(this.config.notify_role);
+        const role = guild.roles.cache.get(roleId);
+        if (role) {
+          content = `${role.toString()} ${content}`;
+        }
+      }
+      await channel.send({
+        content,
+        allowedMentions: {
+          roles: this.config.notify_role ? [String(this.config.notify_role).replace(/[<@&>]/g, "")] : []
+        }
+      });
+    } catch (error) {
+      console.error("Failed to send stream notification:", error);
+    }
+  }
+  /**
+   * Register a stream event listener
+   */
+  onStreamEvent(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index !== -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  /**
+   * Get all members currently streaming in a guild
+   */
+  getStreamingMembers(guildId) {
+    const streaming = this.streamingMembers.get(guildId);
+    if (!streaming) return [];
+    return [...streaming.values()];
+  }
+  /**
+   * Get streaming info for a specific member
+   */
+  getStreamInfo(guildId, memberId) {
+    return this.streamingMembers.get(guildId)?.get(memberId) ?? null;
+  }
+  /**
+   * Check if a member is streaming
+   */
+  isStreaming(guildId, memberId) {
+    return this.streamingMembers.get(guildId)?.has(memberId) ?? false;
+  }
+  /**
+   * Get stream count in a guild
+   */
+  getStreamCount(guildId) {
+    return this.streamingMembers.get(guildId)?.size ?? 0;
+  }
+  /**
+   * Get total active streams across all guilds
+   */
+  getTotalStreamCount() {
+    let count = 0;
+    for (const streaming of this.streamingMembers.values()) {
+      count += streaming.size;
+    }
+    return count;
+  }
+  /**
+   * Get all active streams across all guilds
+   */
+  getAllActiveStreams() {
+    const result = [];
+    for (const [guildId, streaming] of this.streamingMembers) {
+      if (streaming.size > 0) {
+        result.push({ guildId, streams: [...streaming.values()] });
+      }
+    }
+    return result;
+  }
+  /**
+   * Check if stream detection is enabled
+   */
+  isEnabled() {
+    return this.config.stream_detection ?? false;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+function createVideoManager(client) {
+  return new VideoManager(client);
+}
+export {
+  FurlowClient,
+  GatewayManager,
+  InteractionHandler,
+  VideoManager,
+  VoiceManager,
+  createClient,
+  createGatewayManager,
+  createInteractionHandler,
+  createVideoManager,
+  createVoiceManager
+};
+//# sourceMappingURL=index.js.map