discord-self-lite 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-self-lite",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Lightweight Discord selfbot library",
   "keywords": [
     "discord",

package/src/classes/BitField.js

@@ -0,0 +1,110 @@
+/**
+ * A BitField is a data structure that makes it easy to interact with a bitfield.
+ */
+class BitField {
+  /**
+   * @param {BitFieldResolvable} [bits=BitField.defaultBit] Bit(s) to read from
+   */
+  constructor(bits = BitField.defaultBit) {
+    /**
+     * Bitfield of the packed bits
+     * @type {bigint}
+     */
+    this.bitfield = BitField.resolve(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or any of multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  any(bit) {
+    return (this.bitfield & BitField.resolve(bit)) !== BitField.defaultBit;
+  }
+
+  /**
+   * Checks whether the bitfield has a bit, or multiple bits.
+   * @param {BitFieldResolvable} bit Bit(s) to check for
+   * @returns {boolean}
+   */
+  has(bit) {
+    bit = BitField.resolve(bit);
+    return (this.bitfield & bit) === bit;
+  }
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   * @param {BitFieldResolvable} bits Bit(s) to check for
+   * @returns {string[]}
+   */
+  missing(bits) {
+    const res = [];
+    const bit = BitField.resolve(bits);
+
+    for (const [flag, value] of Object.entries(this.constructor.FLAGS)) {
+      if ((bit & value) !== value) continue;
+      if ((this.bitfield & value) === value) continue;
+      res.push(flag);
+    }
+
+    return res;
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the bits available.
+   * @param {boolean} [has=true] Whether to show bits that are set
+   * @returns {string[]}
+   */
+  toArray(has = true) {
+    const arr = [];
+
+    for (const [flag, value] of Object.entries(this.constructor.FLAGS)) {
+      if (has) {
+        if ((this.bitfield & value) === value) arr.push(flag);
+      } else {
+        if ((this.bitfield & value) !== value) arr.push(flag);
+      }
+    }
+
+    return arr;
+  }
+
+  /**
+   * Data that can be resolved to give a bitfield. This can be:
+   * * A string (see {@link BitField.FLAGS})
+   * * A bit number
+   * * An instance of BitField
+   * * An Array of BitFieldResolvable
+   * @typedef {string|bigint|BitField|BitFieldResolvable[]} BitFieldResolvable
+   */
+
+  /**
+   * Resolves bitfields to their numeric form.
+   * @param {BitFieldResolvable} [bit=BitField.defaultBit] bit(s) to resolve
+   * @returns {bigint}
+   */
+  static resolve(bit = BitField.defaultBit) {
+    if (typeof bit === "bigint" && bit >= BitField.defaultBit) return bit;
+    if (bit instanceof BitField) return bit.bitfield;
+    if (Array.isArray(bit))
+      return bit
+        .map((p) => this.resolve(p))
+        .reduce((prev, p) => prev | p, BitField.defaultBit);
+    if (typeof bit === "string") return this.FLAGS[bit];
+    throw new TypeError("BitField.resolve: Invalid bitfield");
+  }
+}
+
+/**
+ * Numeric bitfield flags.
+ * @type {Object<string, bigint>}
+ */
+BitField.FLAGS = {};
+
+/**
+ * The default bit to use if none are provided.
+ * @type {bigint}
+ */
+BitField.defaultBit = 0n;
+
+module.exports = BitField;

package/src/classes/Channel.js

@@ -1,6 +1,8 @@
 /**
  * Represents a Discord channel
  */
+const Permissions = require("./Permissions");
+
 class Channel {
   /**
    * Create a new Channel instance
@@ -161,6 +163,54 @@ class Channel {
     const guildId = this.data.guild_id;
     return `https://discord.com/channels/${guildId}/${this.id}`;
   }
+
+  /**
+   * Check permissions for a member in this channel
+   * @param {GuildMember} member - The guild member to check permissions for
+   * @returns {Permissions} Permissions bitfield for this member in this channel
+   */
+  permissionsFor(member) {
+    if (!member) return new Permissions(BigInt(0));
+
+    // Start with the member's base guild permissions
+    let permissions = member.permissions.bitfield;
+
+    // If member has administrator, they have all permissions
+    if (member.permissions.has(Permissions.FLAGS.ADMINISTRATOR)) {
+      return new Permissions(Permissions.ALL);
+    }
+
+    // Apply channel permission overwrites
+    if (this.data.permission_overwrites) {
+      const overwrites = this.data.permission_overwrites;
+
+      // Role overwrites (deny takes precedence over allow)
+      const memberRoles = member.roles || [];
+      for (const overwrite of overwrites) {
+        if (overwrite.type === 0) {
+          // Role overwrite
+          if (
+            memberRoles.includes(overwrite.id) ||
+            overwrite.id === this.data.guild_id
+          ) {
+            permissions &= ~BigInt(overwrite.deny || 0);
+            permissions |= BigInt(overwrite.allow || 0);
+          }
+        }
+      }
+
+      // Member-specific overwrites (takes precedence over role overwrites)
+      const memberOverwrite = overwrites.find(
+        (ow) => ow.type === 1 && ow.id === member.id,
+      );
+      if (memberOverwrite) {
+        permissions &= ~BigInt(memberOverwrite.deny || 0);
+        permissions |= BigInt(memberOverwrite.allow || 0);
+      }
+    }
+
+    return new Permissions(permissions);
+  }
 }
 
 module.exports = Channel;

package/src/classes/Client.js

@@ -128,6 +128,22 @@ class Client extends EventEmitter {
     const data = await this.rest.fetchGuild(id);
     const guild = new Guild(this, this.rest, data);
     this.guilds.set(id, guild); // Update cache with fresh data
+
+    // Also fetch and cache the client's member information for this guild
+    try {
+      const memberData = await this.rest.fetchGuildMember(id);
+      const GuildMember = require("./GuildMember");
+      const member = new GuildMember(this, memberData, guild);
+      guild._members.set(this.user.id, member);
+    } catch (error) {
+      // If fetching member fails, continue without it
+      // This might happen if the bot doesn't have permission or other issues
+      console.warn(
+        `Failed to fetch member data for guild ${id}:`,
+        error.message,
+      );
+    }
+
     return guild;
   }
 

package/src/classes/Guild.js

@@ -1,4 +1,6 @@
 const Channel = require("./Channel");
+const GuildMember = require("./GuildMember");
+const DiscordAPIError = require("./DiscordAPIError");
 
 /**
  * Represents a Discord guild (server)
@@ -31,6 +33,12 @@ class Guild {
       this.id = this.id || data.id;
       this.name = this.name || data.name;
     }
+
+    // Cache for guild members
+    this._members = new Map();
+
+    // Initialize roles from guild data
+    this.roles = this.data.roles || [];
   }
 
   /**
@@ -116,6 +124,69 @@ class Guild {
     const format = options.format || "png";
     return `https://cdn.discordapp.com/banners/${this.id}/${this.data.banner}.${format}?size=${size}`;
   }
+
+  /**
+   * Fetch members for this guild
+   * @param {object} [options={}] - Fetch options
+   * @param {number} [options.limit=1000] - Number of members to fetch
+   * @param {string} [options.after] - Member ID to fetch after
+   * @returns {Promise<Array<GuildMember>>} Array of guild member instances
+   */
+  async fetchMembers(options = {}) {
+    const { limit = 1000 } = options;
+
+    try {
+      const membersData = await this.client.rest.fetchGuildMembers(this.id, {
+        limit,
+      });
+
+      const members = [];
+      for (const memberData of membersData) {
+        const member = new GuildMember(this.client, memberData, this);
+        this._members.set(member.user.id, member);
+        members.push(member);
+      }
+
+      return members;
+    } catch (error) {
+      throw new DiscordAPIError(
+        `Failed to fetch guild members: ${error.message}`,
+      );
+    }
+  }
+
+  /**
+   * Get the members collection with a 'me' property
+   * @returns {object} Members collection with Map methods and 'me' property
+   */
+  get members() {
+    const membersMap = this._members;
+    const client = this.client;
+
+    return {
+      // Map methods
+      get: (key) => membersMap.get(key),
+      set: (key, value) => membersMap.set(key, value),
+      has: (key) => membersMap.has(key),
+      delete: (key) => membersMap.delete(key),
+      clear: () => membersMap.clear(),
+      size: membersMap.size,
+      [Symbol.iterator]: () => membersMap[Symbol.iterator](),
+
+      // Special 'me' property
+      get me() {
+        return membersMap.get(client.user?.id);
+      },
+    };
+  }
+
+  /**
+   * Set the members cache
+   * @param {Map} value - The members map
+   */
+  set members(value) {
+    this._members = value;
+  }
 }
 
 module.exports = Guild;

package/src/classes/GuildMember.js

@@ -0,0 +1,108 @@
+/**
+ * Represents a Discord guild member
+ */
+const Permissions = require("./Permissions");
+
+class GuildMember {
+  /**
+   * Create a new GuildMember instance
+   * @param {Client} client - The Discord client
+   * @param {object} data - Raw member data from Discord API
+   * @param {Guild} guild - The guild this member belongs to
+   */
+  constructor(client, data, guild) {
+    this.client = client;
+    this.guild = guild;
+    this.data = data;
+    this._permissions = null;
+
+    // Copy all member properties
+    for (const [key, value] of Object.entries(data)) {
+      const camelKey = key.replace(/_([a-z])/g, (_, letter) =>
+        letter.toUpperCase(),
+      );
+      this[camelKey] = value;
+    }
+
+    // Handle user data separately
+    if (data.user) {
+      this.user = data.user;
+      this.id = data.user.id;
+    }
+
+    this.roles = this.roles || [];
+    this.joinedAt = this.joinedAt || data.joined_at;
+  }
+
+  /**
+   * Check if this member is the client user
+   * @returns {boolean} True if this member represents the client
+   */
+  get isClient() {
+    return this.id === this.client.user?.id;
+  }
+
+  /**
+   * Get the member's display name (nickname or username)
+   * @returns {string} The display name
+   */
+  get displayName() {
+    return this.nick || this.user?.username || "Unknown";
+  }
+
+  /**
+   * Get the member's permissions in this guild
+   * @returns {Permissions} Permissions bitfield
+   */
+  get permissions() {
+    if (this._permissions) return this._permissions;
+
+    // Calculate permissions based on roles
+    let permissions = BigInt(0);
+
+    // If member is the guild owner, they have all permissions
+    if (this.id === this.guild.ownerId) {
+      permissions = Permissions.ALL;
+    } else {
+      // Start with @everyone role permissions
+      const everyoneRole = this.guild.roles?.find(
+        (role) => role.id === this.guild.id,
+      );
+      if (everyoneRole) {
+        permissions |= BigInt(everyoneRole.permissions || 0);
+      }
+
+      // Add permissions from member's roles
+      for (const roleId of this.roles || []) {
+        const role = this.guild.roles?.find((r) => r.id === roleId);
+        if (role) {
+          permissions |= BigInt(role.permissions || 0);
+        }
+      }
+    }
+
+    this._permissions = new Permissions(permissions);
+    return this._permissions;
+  }
+
+  set permissions(value) {
+    if (value instanceof Permissions) {
+      this._permissions = value;
+    } else {
+      this._permissions = new Permissions(value);
+    }
+  }
+
+  /**
+   * Check if the member has specific permissions
+   * @param {Array<string>} permissions - Permission flags to check
+   * @returns {boolean} True if member has all permissions
+   */
+  hasPermission() {
+    // TODO: Implement proper permission checking
+    // Simplified implementation - always return true for now
+    return true;
+  }
+}
+
+module.exports = GuildMember;

package/src/classes/Permissions.js

@@ -0,0 +1,212 @@
+"use strict";
+
+const BitField = require("./BitField");
+
+/**
+ * Data structure that makes it easy to interact with a permission bitfield. All {@link GuildMember}s have a set of
+ * permissions in their guild, and each channel in the guild may also have {@link PermissionOverwrites} for the member
+ * that override their default permissions.
+ * @extends {BitField}
+ */
+class Permissions extends BitField {
+  /**
+   * Bitfield of the packed bits
+   * @type {bigint}
+   * @name Permissions#bitfield
+   */
+
+  /**
+   * Data that can be resolved to give a permission number. This can be:
+   * * A string (see {@link Permissions.FLAGS})
+   * * A permission number
+   * * An instance of Permissions
+   * * An Array of PermissionResolvable
+   * @typedef {string|bigint|Permissions|PermissionResolvable[]} PermissionResolvable
+   */
+
+  /**
+   * Gets all given bits that are missing from the bitfield.
+   * @param {BitFieldResolvable} bits Bit(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {string[]}
+   */
+  missing(bits, checkAdmin = true) {
+    return checkAdmin && this.has(this.constructor.FLAGS.ADMINISTRATOR)
+      ? []
+      : super.missing(bits);
+  }
+
+  /**
+   * Checks whether the bitfield has a permission, or any of multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  any(permission, checkAdmin = true) {
+    return (
+      (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) ||
+      super.any(permission)
+    );
+  }
+
+  /**
+   * Checks whether the bitfield has a permission, or multiple permissions.
+   * @param {PermissionResolvable} permission Permission(s) to check for
+   * @param {boolean} [checkAdmin=true] Whether to allow the administrator permission to override
+   * @returns {boolean}
+   */
+  has(permission, checkAdmin = true) {
+    return (
+      (checkAdmin && super.has(this.constructor.FLAGS.ADMINISTRATOR)) ||
+      super.has(permission)
+    );
+  }
+
+  /**
+   * Gets an {@link Array} of bitfield names based on the permissions available.
+   * @returns {string[]}
+   */
+  toArray() {
+    return super.toArray(false);
+  }
+}
+
+/**
+ * Numeric permission flags. All available properties:
+ * * `CREATE_INSTANT_INVITE` (create invitations to the guild)
+ * * `KICK_MEMBERS`
+ * * `BAN_MEMBERS`
+ * * `ADMINISTRATOR` (implicitly has *all* permissions, and bypasses all channel overwrites)
+ * * `MANAGE_CHANNELS` (edit and reorder channels)
+ * * `MANAGE_GUILD` (edit the guild information, region, etc.)
+ * * `ADD_REACTIONS` (add new reactions to messages)
+ * * `VIEW_AUDIT_LOG`
+ * * `PRIORITY_SPEAKER`
+ * * `STREAM`
+ * * `VIEW_CHANNEL`
+ * * `SEND_MESSAGES`
+ * * `SEND_TTS_MESSAGES`
+ * * `MANAGE_MESSAGES` (delete messages and reactions)
+ * * `EMBED_LINKS` (links posted will have a preview embedded)
+ * * `ATTACH_FILES`
+ * * `READ_MESSAGE_HISTORY` (view messages that were posted prior to opening Discord)
+ * * `MENTION_EVERYONE`
+ * * `USE_EXTERNAL_EMOJIS` (use emojis from different guilds)
+ * * `VIEW_GUILD_INSIGHTS`
+ * * `CONNECT` (connect to a voice channel)
+ * * `SPEAK` (speak in a voice channel)
+ * * `MUTE_MEMBERS` (mute members across all voice channels)
+ * * `DEAFEN_MEMBERS` (deafen members across all voice channels)
+ * * `MOVE_MEMBERS` (move members between voice channels)
+ * * `USE_VAD` (use voice activity detection)
+ * * `CHANGE_NICKNAME`
+ * * `MANAGE_NICKNAMES` (change other members' nicknames)
+ * * `MANAGE_ROLES`
+ * * `MANAGE_WEBHOOKS`
+ * * `MANAGE_EMOJIS_AND_STICKERS`
+ * * `USE_APPLICATION_COMMANDS`
+ * * `REQUEST_TO_SPEAK`
+ * * `MANAGE_EVENTS`
+ * * `MANAGE_THREADS`
+ * * `USE_PUBLIC_THREADS` (deprecated)
+ * * `CREATE_PUBLIC_THREADS`
+ * * `USE_PRIVATE_THREADS` (deprecated)
+ * * `CREATE_PRIVATE_THREADS`
+ * * `USE_EXTERNAL_STICKERS` (use stickers from different guilds)
+ * * `SEND_MESSAGES_IN_THREADS`
+ * * `START_EMBEDDED_ACTIVITIES`
+ * * `MODERATE_MEMBERS`
+ * * `VIEW_CREATOR_MONETIZATION_ANALYTICS`
+ * * `USE_SOUNDBOARD`
+ * * `CREATE_GUILD_EXPRESSIONS`
+ * * `CREATE_EVENTS`
+ * * `USE_EXTERNAL_SOUNDS`
+ * * `SEND_VOICE_MESSAGES`
+ * * `USE_CLYDE_AI`
+ * * `SET_VOICE_CHANNEL_STATUS`
+ * * `SEND_POLLS`
+ * * `USE_EXTERNAL_APPS`
+ * @type {Object<string, bigint>}
+ * @see {@link https://discord.com/developers/docs/topics/permissions#permissions-bitwise-permission-flags}
+ */
+Permissions.FLAGS = {
+  CREATE_INSTANT_INVITE: 1n << 0n,
+  KICK_MEMBERS: 1n << 1n,
+  BAN_MEMBERS: 1n << 2n,
+  ADMINISTRATOR: 1n << 3n,
+  MANAGE_CHANNELS: 1n << 4n,
+  MANAGE_GUILD: 1n << 5n,
+  ADD_REACTIONS: 1n << 6n,
+  VIEW_AUDIT_LOG: 1n << 7n,
+  PRIORITY_SPEAKER: 1n << 8n,
+  STREAM: 1n << 9n,
+  VIEW_CHANNEL: 1n << 10n,
+  SEND_MESSAGES: 1n << 11n,
+  SEND_TTS_MESSAGES: 1n << 12n,
+  MANAGE_MESSAGES: 1n << 13n,
+  EMBED_LINKS: 1n << 14n,
+  ATTACH_FILES: 1n << 15n,
+  READ_MESSAGE_HISTORY: 1n << 16n,
+  MENTION_EVERYONE: 1n << 17n,
+  USE_EXTERNAL_EMOJIS: 1n << 18n,
+  VIEW_GUILD_INSIGHTS: 1n << 19n,
+  CONNECT: 1n << 20n,
+  SPEAK: 1n << 21n,
+  MUTE_MEMBERS: 1n << 22n,
+  DEAFEN_MEMBERS: 1n << 23n,
+  MOVE_MEMBERS: 1n << 24n,
+  USE_VAD: 1n << 25n,
+  CHANGE_NICKNAME: 1n << 26n,
+  MANAGE_NICKNAMES: 1n << 27n,
+  MANAGE_ROLES: 1n << 28n,
+  MANAGE_WEBHOOKS: 1n << 29n,
+  MANAGE_EMOJIS_AND_STICKERS: 1n << 30n,
+  USE_APPLICATION_COMMANDS: 1n << 31n,
+  REQUEST_TO_SPEAK: 1n << 32n,
+  MANAGE_EVENTS: 1n << 33n,
+  MANAGE_THREADS: 1n << 34n,
+  CREATE_PUBLIC_THREADS: 1n << 35n,
+  CREATE_PRIVATE_THREADS: 1n << 36n,
+  USE_EXTERNAL_STICKERS: 1n << 37n,
+  SEND_MESSAGES_IN_THREADS: 1n << 38n,
+  START_EMBEDDED_ACTIVITIES: 1n << 39n,
+  MODERATE_MEMBERS: 1n << 40n,
+  VIEW_CREATOR_MONETIZATION_ANALYTICS: 1n << 41n,
+  USE_SOUNDBOARD: 1n << 42n,
+  CREATE_GUILD_EXPRESSIONS: 1n << 43n,
+  CREATE_EVENTS: 1n << 44n,
+  USE_EXTERNAL_SOUNDS: 1n << 45n,
+  SEND_VOICE_MESSAGES: 1n << 46n,
+  USE_CLYDE_AI: 1n << 47n,
+  SET_VOICE_CHANNEL_STATUS: 1n << 48n,
+  SEND_POLLS: 1n << 49n,
+  USE_EXTERNAL_APPS: 1n << 50n,
+};
+
+/**
+ * Bitfield representing every permission combined
+ * @type {bigint}
+ */
+Permissions.ALL = Object.values(Permissions.FLAGS).reduce(
+  (all, p) => all | p,
+  0n,
+);
+
+/**
+ * Bitfield representing the default permissions for users
+ * @type {bigint}
+ */
+Permissions.DEFAULT = BigInt(104324673);
+
+/**
+ * Bitfield representing the permissions required for moderators of stage channels
+ * @type {bigint}
+ */
+Permissions.STAGE_MODERATOR =
+  Permissions.FLAGS.MANAGE_CHANNELS |
+  Permissions.FLAGS.MUTE_MEMBERS |
+  Permissions.FLAGS.MOVE_MEMBERS;
+
+Permissions.defaultBit = BigInt(0);
+
+module.exports = Permissions;

package/src/connection/rest/RestManager.js

@@ -1,6 +1,8 @@
 const sendMessage = require("./methods/sendMessage");
 const react = require("./methods/react");
 const clickButton = require("./methods/clickButton");
+const fetchGuildMembers = require("./methods/fetchGuildMembers");
+const fetchGuildMember = require("./methods/fetchGuildMember");
 const DiscordAPIError = require("../../classes/DiscordAPIError");
 
 /**
@@ -287,6 +289,27 @@ class RestManager {
     return await this.request(`/guilds/${guildId}/channels`);
   }
 
+  /**
+   * Fetch guild members
+   * @param {string} guildId - The guild ID
+   * @param {object} [options={}] - Fetch options
+   * @param {number} [options.limit=1000] - Number of members to fetch
+   * @param {string} [options.after] - Member ID to fetch after
+   * @returns {Promise<Array>} Array of member data
+   */
+  async fetchGuildMembers(guildId, options = {}) {
+    return await fetchGuildMembers(this, guildId, options);
+  }
+
+  /**
+   * Fetch the current user's member information for a guild
+   * @param {string} guildId - The guild ID
+   * @returns {Promise<object>} Member data
+   */
+  async fetchGuildMember(guildId) {
+    return await fetchGuildMember(this, guildId);
+  }
+
   /**
    * Fetch a specific message from a channel
    * @param {string} channelId - The channel ID

package/src/connection/rest/methods/fetchGuildMember.js

@@ -0,0 +1,11 @@
+/**
+ * Fetch the current user's member information for a guild
+ * @param {RestManager} rest - The REST manager instance
+ * @param {string} guildId - The guild ID
+ * @returns {Promise<object>} Member data
+ */
+async function fetchGuildMember(rest, guildId) {
+  return await rest.request(`/users/@me/guilds/${guildId}/member`);
+}
+
+module.exports = fetchGuildMember;

package/src/connection/rest/methods/fetchGuildMembers.js

@@ -0,0 +1,17 @@
+/**
+ * Fetch guild members
+ * @param {RestManager} rest - The REST manager instance
+ * @param {string} guildId - The guild ID
+ * @param {object} [options={}] - Fetch options
+ * @param {number} [options.limit=1000] - Number of members to fetch
+ * @param {string} [options.after] - Member ID to fetch after
+ * @returns {Promise<Array>} Array of member data
+ */
+async function fetchGuildMembers(rest, guildId, options = {}) {
+  const query = new URLSearchParams(options).toString();
+  return await rest.request(`/guilds/${guildId}/members?${query}`, {
+    method: "GET",
+  });
+}
+
+module.exports = fetchGuildMembers;

package/src/connection/ws/WebSocket.js

@@ -131,6 +131,14 @@ class DiscordWebSocket extends EventEmitter {
         this.sessionId = message.d.session_id;
         this.client.sessionId = message.d.session_id;
         this.client.user = new User(this.client, message.d.user);
+
+        // Process guilds from READY payload
+        if (message.d.guilds) {
+          for (const guildData of message.d.guilds) {
+            this.handleGuildCreate(guildData);
+          }
+        }
+
         this.ready = true;
         this.client.emit("ready", message.d);
         break;
@@ -140,9 +148,7 @@ class DiscordWebSocket extends EventEmitter {
         break;
       }
       case "GUILD_CREATE": {
-        const guild = new Guild(this.client, this.client.rest, message.d);
-        this.client.guilds.set(guild.id, guild);
-        this.client.emit("guildCreate", guild);
+        this.handleGuildCreate(message.d);
         break;
       }
       case "CHANNEL_CREATE": {
@@ -156,6 +162,40 @@ class DiscordWebSocket extends EventEmitter {
     }
   }
 
+  async handleGuildCreate(data) {
+    const guild = new Guild(this.client, this.client.rest, data);
+    this.client.guilds.set(guild.id, guild);
+
+    // Populate the client's member information for this guild
+    if (data.members) {
+      const clientMember = data.members.find(
+        (member) => member.user.id === this.client.user.id,
+      );
+      if (clientMember) {
+        const GuildMember = require("../../classes/GuildMember");
+        const member = new GuildMember(this.client, clientMember, guild);
+        guild._members.set(this.client.user.id, member);
+      }
+    }
+
+    // If no member data in GUILD_CREATE, fetch it from API
+    if (!guild._members.has(this.client.user.id)) {
+      try {
+        const memberData = await this.client.rest.fetchGuildMember(guild.id);
+        const GuildMember = require("../../classes/GuildMember");
+        const member = new GuildMember(this.client, memberData, guild);
+        guild._members.set(this.client.user.id, member);
+      } catch (err) {
+        console.warn(
+          `Failed to fetch member for guild ${guild.id}:`,
+          err.message,
+        );
+      }
+    }
+
+    this.client.emit("guildCreate", guild);
+  }
+
   reconnect() {
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       const err = new WebSocketError("Max reconnect attempts reached");

package/src/index.js

@@ -19,6 +19,8 @@
 
 const Client = require("./classes/Client");
 const WebhookClient = require("./connection/webhook/WebhookClient");
+const Permissions = require("./classes/Permissions");
+const BitField = require("./classes/BitField");
 
 /**
  * Main package exports
@@ -38,4 +40,18 @@ module.exports = {
    * @see {@link WebhookClient}
    */
   WebhookClient,
+
+  /**
+   * Discord permission flags and utilities
+   * @type {Permissions}
+   * @see {@link Permissions}
+   */
+  Permissions,
+
+  /**
+   * Base class for handling bitfields
+   * @type {BitField}
+   * @see {@link BitField}
+   */
+  BitField,
 };