discord-self-lite 0.1.3 → 0.1.4

package/package.json

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

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,9 @@ class Guild {
       this.id = this.id || data.id;
       this.name = this.name || data.name;
     }
+
+    // Cache for guild members
+    this._members = new Map();
   }
 
   /**
@@ -116,6 +121,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,77 @@
+/**
+ * Represents a Discord guild member
+ */
+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 {Array<string>} Array of permission strings
+   */
+  get permissions() {
+    // This is a simplified implementation
+    // In a full implementation, you'd calculate permissions based on roles
+    return this._permissions;
+  }
+
+  set permissions(value) {
+    this._permissions = value ?? null;
+  }
+
+  /**
+   * 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/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");