discord-self-lite 0.1.12 → 0.1.14

package/package.json

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

package/src/classes/Message.js

@@ -53,6 +53,8 @@ class Message {
     this.mentions = this.mentions || [];
     this.mentionRoles = this.mentionRoles || [];
     this.reactions = this.reactions || [];
+    this.guildId =
+      this.guildId || this.client.getChannel(this.channelId)?.guildId || null;
     this.url = `https://discord.com/channels/${this.guildId ? this.guildId : "@me"}/${this.channelId}/${this.id}`;
   }
 

package/src/classes/MessageAttachment.js

@@ -0,0 +1,18 @@
+/**
+ * Represents an attachment in a message
+ */
+class MessageAttachment {
+  /**
+   * Create a new MessageAttachment instance
+   * @param {Buffer|string|ArrayBuffer} data - File data buffer or string
+   * @param {string} name - Filename
+   * @param {string|null} [description=null] - Description of the attachment
+   */
+  constructor(data, name, description = null) {
+    this.data = data;
+    this.name = name;
+    this.description = description;
+  }
+}
+
+module.exports = MessageAttachment;

package/src/connection/rest/RestManager.js

@@ -231,13 +231,18 @@ class RestManager {
 
     while (attempt < maxRetries) {
       try {
+        const headers = {
+          Authorization: this.token,
+          ...options.headers,
+        };
+
+        if (!(options.body instanceof FormData)) {
+          headers["Content-Type"] = "application/json";
+        }
+
         const response = await fetch(url, {
           ...options,
-          headers: {
-            Authorization: this.token,
-            "Content-Type": "application/json",
-            ...options.headers,
-          },
+          headers,
         });
 
         // Update rate limit info from headers

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

@@ -8,7 +8,75 @@
 async function sendMessage(rest, channelId, payload) {
   // If payload is a string, treat it as content
   const messagePayload =
-    typeof payload === "string" ? { content: payload } : payload;
+    typeof payload === "string" ? { content: payload } : { ...payload };
+
+  const filesToUpload = [];
+  const keepAttachments = [];
+
+  const rawAttachments = messagePayload.attachments || [];
+  if (Array.isArray(rawAttachments)) {
+    for (const att of rawAttachments) {
+      if (
+        att &&
+        typeof att === "object" &&
+        (att.data !== undefined || att.attachment !== undefined)
+      ) {
+        filesToUpload.push(att);
+      } else {
+        keepAttachments.push(att);
+      }
+    }
+  }
+
+  const rawFiles = messagePayload.files || [];
+  if (Array.isArray(rawFiles)) {
+    for (const file of rawFiles) {
+      if (
+        file &&
+        typeof file === "object" &&
+        (file.data !== undefined || file.attachment !== undefined)
+      ) {
+        filesToUpload.push(file);
+      } else if (file) {
+        filesToUpload.push({ data: file });
+      }
+    }
+  }
+
+  if (filesToUpload.length > 0) {
+    const formData = new FormData();
+
+    const uploadedAttachmentsMetadata = filesToUpload.map((file, index) => {
+      const filename = file.name || `file_${index}`;
+      const description = file.description || null;
+      return {
+        id: index,
+        filename,
+        description,
+      };
+    });
+
+    messagePayload.attachments = [
+      ...keepAttachments,
+      ...uploadedAttachmentsMetadata,
+    ];
+
+    delete messagePayload.files;
+
+    formData.append("payload_json", JSON.stringify(messagePayload));
+
+    filesToUpload.forEach((file, index) => {
+      const fileData = file.data || file.attachment;
+      const filename = file.name || `file_${index}`;
+      const blob = new Blob([fileData]);
+      formData.append(`files[${index}]`, blob, filename);
+    });
+
+    return await rest.request(`/channels/${channelId}/messages`, {
+      method: "POST",
+      body: formData,
+    });
+  }
 
   return await rest.request(`/channels/${channelId}/messages`, {
     method: "POST",

package/src/connection/webhook/WebhookClient.js

@@ -22,18 +22,79 @@ function resolveColor(color) {
 class WebhookClient {
   /**
    * Create a new WebhookClient
-   * @param {string} url - The webhook URL
-   * @param {object} [options={}] - Default options for the webhook
-   * @param {string} [options.username] - Default username for the webhook
-   * @param {string} [options.avatarURL] - Default avatar URL for the webhook
+   * @param {string|object} urlOrId - The webhook URL, an object containing `id` and `token` (or `url`), or just the webhook ID
+   * @param {string|object} [tokenOrOptions={}] - The webhook token (if first arg is ID) or default options
+   * @param {object} [options={}] - Default options for the webhook (if first two args are ID and token)
    */
-  constructor(url, options = {}) {
-    this.url = url;
-    this.options = {
-      username: options.username || null,
-      avatarURL: options.avatarURL || null,
-      ...options,
-    };
+  constructor(urlOrId, tokenOrOptions = {}, options = {}) {
+    if (typeof urlOrId === "object" && urlOrId !== null) {
+      // constructor({ id, token, url, ...options }, options)
+      const data = urlOrId;
+      const opts = tokenOrOptions || {};
+
+      if (data.url) {
+        this.url = data.url;
+        try {
+          const parsed = WebhookClient.parseURL(data.url);
+          this.id = parsed.id;
+          this.token = parsed.token;
+        } catch {
+          // Ignore parse errors for custom/mock URLs
+        }
+      } else if (data.id && data.token) {
+        this.id = data.id.toString();
+        this.token = data.token;
+        this.url = `https://discord.com/api/webhooks/${this.id}/${this.token}`;
+      } else {
+        throw new Error(
+          "WebhookClient requires either a URL or an ID and Token",
+        );
+      }
+
+      this.options = {
+        username: data.username || opts.username || null,
+        avatarURL: data.avatarURL || opts.avatarURL || null,
+        ...data,
+        ...opts,
+      };
+
+      // Clean up internal keys from options
+      delete this.options.id;
+      delete this.options.token;
+      delete this.options.url;
+    } else if (
+      typeof urlOrId === "string" &&
+      typeof tokenOrOptions === "string"
+    ) {
+      // constructor(id, token, options)
+      this.id = urlOrId;
+      this.token = tokenOrOptions;
+      this.url = `https://discord.com/api/webhooks/${this.id}/${this.token}`;
+      this.options = {
+        username: options.username || null,
+        avatarURL: options.avatarURL || null,
+        ...options,
+      };
+    } else if (typeof urlOrId === "string") {
+      // constructor(url, options)
+      this.url = urlOrId;
+      try {
+        const parsed = WebhookClient.parseURL(urlOrId);
+        this.id = parsed.id;
+        this.token = parsed.token;
+      } catch {
+        // Ignore parse errors for custom/mock URLs
+      }
+      this.options = {
+        username: tokenOrOptions.username || null,
+        avatarURL: tokenOrOptions.avatarURL || null,
+        ...tokenOrOptions,
+      };
+    } else {
+      throw new Error(
+        "Invalid parameters provided to WebhookClient constructor",
+      );
+    }
   }
 
   /**
@@ -69,12 +130,81 @@ class WebhookClient {
       payload = this._buildPayload("", options);
     }
 
+    const filesToUpload = [];
+    const keepAttachments = [];
+
+    const rawAttachments = payload.attachments || [];
+    if (Array.isArray(rawAttachments)) {
+      for (const att of rawAttachments) {
+        if (
+          att &&
+          typeof att === "object" &&
+          (att.data !== undefined || att.attachment !== undefined)
+        ) {
+          filesToUpload.push(att);
+        } else {
+          keepAttachments.push(att);
+        }
+      }
+    }
+
+    const rawFiles = payload.files || [];
+    if (Array.isArray(rawFiles)) {
+      for (const file of rawFiles) {
+        if (
+          file &&
+          typeof file === "object" &&
+          (file.data !== undefined || file.attachment !== undefined)
+        ) {
+          filesToUpload.push(file);
+        } else if (file) {
+          filesToUpload.push({ data: file });
+        }
+      }
+    }
+
+    let requestBody;
+    const headers = {};
+
+    if (filesToUpload.length > 0) {
+      const formData = new FormData();
+
+      const uploadedAttachmentsMetadata = filesToUpload.map((file, index) => {
+        const filename = file.name || `file_${index}`;
+        const description = file.description || null;
+        return {
+          id: index,
+          filename,
+          description,
+        };
+      });
+
+      payload.attachments = [
+        ...keepAttachments,
+        ...uploadedAttachmentsMetadata,
+      ];
+
+      delete payload.files;
+
+      formData.append("payload_json", JSON.stringify(payload));
+
+      filesToUpload.forEach((file, index) => {
+        const fileData = file.data || file.attachment;
+        const filename = file.name || `file_${index}`;
+        const blob = new Blob([fileData]);
+        formData.append(`files[${index}]`, blob, filename);
+      });
+
+      requestBody = formData;
+    } else {
+      headers["Content-Type"] = "application/json";
+      requestBody = JSON.stringify(payload);
+    }
+
     const response = await fetch(this.url, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(payload),
+      headers,
+      body: requestBody,
     });
 
     if (!response.ok) {

package/src/index.js

@@ -21,6 +21,7 @@ const Client = require("./classes/Client");
 const WebhookClient = require("./connection/webhook/WebhookClient");
 const Permissions = require("./classes/Permissions");
 const BitField = require("./classes/BitField");
+const MessageAttachment = require("./classes/MessageAttachment");
 
 /**
  * Main package exports
@@ -54,4 +55,11 @@ module.exports = {
    * @see {@link BitField}
    */
   BitField,
+
+  /**
+   * Represents an attachment to be sent in a message
+   * @type {MessageAttachment}
+   * @see {@link MessageAttachment}
+   */
+  MessageAttachment,
 };