djs-selfbot-v13 3.7.1 → 3.7.3

package/src/managers/QuestManager.js

@@ -0,0 +1,376 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+
+/**
+ * Represents a single quest
+ */
+class Quest {
+  constructor(data) {
+    this.id = data.id;
+    this.config = data.config;
+    this.userStatus = data.user_status;
+  }
+
+  /**
+   * Check if quest is expired
+   * @param {Date} [date=new Date()] Date to check against
+   * @returns {boolean}
+   */
+  isExpired(date = new Date()) {
+    if (!this.config.expires_at) return false;
+    return new Date(this.config.expires_at) < date;
+  }
+
+  /**
+   * Check if quest is completed
+   * @returns {boolean}
+   */
+  isCompleted() {
+    return this.userStatus?.completed_at != null;
+  }
+
+  /**
+   * Check if quest rewards have been claimed
+   * @returns {boolean}
+   */
+  hasClaimedRewards() {
+    return this.userStatus?.claimed_at != null;
+  }
+
+  /**
+   * Check if user is enrolled in quest
+   * @returns {boolean}
+   */
+  isEnrolledQuest() {
+    return this.userStatus?.enrolled_at != null;
+  }
+
+  /**
+   * Update user status for this quest
+   * @param {Object} status New status data
+   */
+  updateUserStatus(status) {
+    this.userStatus = { ...this.userStatus, ...status };
+  }
+}
+
+/**
+ * Manages API methods for Discord quests
+ * @extends {BaseManager}
+ */
+class QuestManager extends BaseManager {
+  constructor(client) {
+    super(client);
+    
+    /**
+     * Collection of cached quests
+     * @type {Collection<string, Quest>}
+     */
+    this.cache = new Collection();
+  }
+
+  /**
+   * Get all available quests for the user
+   * @returns {Promise<Object>} Quest data
+   */
+  async get() {
+    const data = await this.client.api.users('@me').quests.get();
+    
+    // Cache quests
+    if (data.quests) {
+      this.cache.clear();
+      data.quests.forEach(questData => {
+        const quest = new Quest(questData);
+        this.cache.set(quest.id, quest);
+      });
+    }
+    
+    return data;
+  }
+
+  /**
+   * Get user's orb balance (virtual currency)
+   * @returns {Promise<Object>} Balance data
+   */
+  async orbs() {
+    const data = await this.client.api.users['@me']['virtual-currency'].balance.get();
+    return data;
+  }
+
+  /**
+   * Get quest by ID from cache
+   * @param {string} id Quest ID
+   * @returns {Quest|undefined}
+   */
+  getQuest(id) {
+    return this.cache.get(id);
+  }
+
+  /**
+   * Get all cached quests as array
+   * @returns {Quest[]}
+   */
+  list() {
+    return Array.from(this.cache.values());
+  }
+
+  /**
+   * Get expired quests
+   * @param {Date} [date=new Date()] Date to check against
+   * @returns {Quest[]}
+   */
+  getExpired(date = new Date()) {
+    return this.list().filter(quest => quest.isExpired(date));
+  }
+
+  /**
+   * Get completed quests
+   * @returns {Quest[]}
+   */
+  getCompleted() {
+    return this.list().filter(quest => quest.isCompleted());
+  }
+
+  /**
+   * Get claimable quests (completed but not claimed)
+   * @returns {Quest[]}
+   */
+  getClaimable() {
+    return this.list().filter(quest => quest.isCompleted() && !quest.hasClaimedRewards());
+  }
+
+  /**
+   * Get valid quests (not completed, not expired, not blacklisted)
+   * @returns {Quest[]}
+   */
+  filterQuestsValid() {
+    return this.list().filter(quest =>
+      quest.id !== '1412491570820812933' &&
+      !quest.isCompleted() &&
+      !quest.isExpired()
+    );
+  }
+
+  /**
+   * Check if quest exists in cache
+   * @param {string} id Quest ID
+   * @returns {boolean}
+   */
+  hasQuest(id) {
+    return this.cache.has(id);
+  }
+
+  /**
+   * Get application data for given IDs
+   * @param {string[]} ids Application IDs
+   * @returns {Promise<Object[]>}
+   */
+  async getApplicationData(ids) {
+    const query = new URLSearchParams();
+    ids.forEach(id => query.append('application_ids', id));
+    
+    return this.client.api.applications.public.get({ query: query.toString() });
+  }
+
+  /**
+   * Enroll in a specific quest
+   * @param {string} questId The quest ID to enroll in
+   * @param {Object} [options] Enrollment options
+   * @param {number} [options.location=11] Location parameter
+   * @param {boolean} [options.isTargeted=false] Whether the quest is targeted
+   * @param {*} [options.metadataRaw=null] Raw metadata
+   * @returns {Promise<Quest|undefined>} Updated quest or undefined
+   */
+  async acceptQuest(questId, options = {}) {
+    const { location = 11, isTargeted = false, metadataRaw = null } = options;
+    
+    const data = await this.client.api.quests(questId).enroll.post({
+      data: { 
+        location, 
+        is_targeted: isTargeted,
+        metadata_raw: metadataRaw
+      }
+    });
+    
+    const quest = this.getQuest(questId);
+    if (quest) {
+      quest.updateUserStatus(data);
+    }
+    
+    return quest;
+  }
+
+  /**
+   * Update progress for a video quest
+   * @param {string} questId The quest ID
+   * @param {number} timestamp Current progress timestamp
+   * @returns {Promise<Object>} Progress update result
+   */
+  async videoProgress(questId, timestamp) {
+    const data = await this.client.api.quests(questId)['video-progress'].post({
+      data: { timestamp }
+    });
+    return data;
+  }
+
+  /**
+   * Send heartbeat for desktop quests
+   * @param {string} questId The quest ID
+   * @param {string} applicationId Application ID
+   * @param {boolean} [terminal=false] Whether this is a terminal heartbeat
+   * @returns {Promise<Object>} Heartbeat result
+   */
+  async heartbeat(questId, applicationId, terminal = false) {
+    const data = await this.client.api.quests(questId).heartbeat.post({
+      data: {
+        application_id: applicationId,
+        terminal
+      }
+    });
+    return data;
+  }
+
+  /**
+   * Helper function for timeout
+   * @param {number} ms Milliseconds to wait
+   * @returns {Promise<void>}
+   * @private
+   */
+  async timeout(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Complete a quest automatically
+   * @param {Quest} quest Quest to complete
+   * @returns {Promise<void>}
+   */
+  async doingQuest(quest) {
+    const questName = quest.config.messages?.quest_name || 'Unknown Quest';
+    
+    if (!quest.isEnrolledQuest()) {
+      console.log(`Enrolling in quest "${questName}"...`);
+      await this.acceptQuest(quest.id);
+    }
+
+    const applicationName = quest.config.application?.name || 'Unknown App';
+    const taskConfig = quest.config.task_config;
+    
+    const taskName = [
+      'WATCH_VIDEO',
+      'PLAY_ON_DESKTOP', 
+      'STREAM_ON_DESKTOP',
+      'PLAY_ACTIVITY',
+      'WATCH_VIDEO_ON_MOBILE'
+    ].find(x => taskConfig.tasks?.[x] != null);
+
+    if (!taskName) {
+      console.log(`Unknown task type for quest "${questName}"`);
+      return;
+    }
+
+    const secondsNeeded = taskConfig.tasks[taskName].target;
+    let secondsDone = quest.userStatus?.progress?.[taskName]?.value ?? 0;
+
+    if (taskName === 'WATCH_VIDEO' || taskName === 'WATCH_VIDEO_ON_MOBILE') {
+      const maxFuture = 10;
+      const speed = 7;
+      const interval = 1;
+      const enrolledAt = new Date(quest.userStatus?.enrolled_at).getTime();
+      let completed = false;
+
+      console.log(`Spoofing video for ${questName}.`);
+
+      while (true) {
+        const maxAllowed = Math.floor((Date.now() - enrolledAt) / 1000) + maxFuture;
+        const diff = maxAllowed - secondsDone;
+        const timestamp = secondsDone + speed;
+
+        if (diff >= speed) {
+          const res = await this.videoProgress(quest.id, Math.min(secondsNeeded, timestamp + Math.random()));
+          completed = res.completed_at != null;
+          secondsDone = Math.min(secondsNeeded, timestamp);
+        }
+
+        if (timestamp >= secondsNeeded) {
+          break;
+        }
+
+        await this.timeout(interval * 1000);
+      }
+
+      if (!completed) {
+        await this.videoProgress(quest.id, secondsNeeded);
+      }
+
+      console.log(`Quest "${questName}" completed!`);
+
+    } else if (taskName === 'PLAY_ON_DESKTOP') {
+      const interval = 60;
+
+      while (!quest.isCompleted()) {
+        const secondsDone = quest.userStatus?.progress?.[taskName]?.value || 0;
+        const res = await this.heartbeat(quest.id, quest.config.application.id, false);
+        quest.updateUserStatus(res);
+
+        console.log(`Spoofed your game to ${applicationName}. Wait for ${Math.ceil((secondsNeeded - secondsDone) / 60)} more minutes.`);
+        await this.timeout(interval * 1000);
+      }
+
+      const res = await this.heartbeat(quest.id, quest.config.application.id, true);
+      quest.updateUserStatus(res);
+      console.log(`Quest "${questName}" completed!`);
+
+    } else if (taskName === 'STREAM_ON_DESKTOP') {
+      console.log('This no longer works in node for non-video quests. Use the discord desktop app to complete the', questName, 'quest!');
+    } else if (taskName === 'PLAY_ACTIVITY') {
+      console.log('This quest not supported. Use the discord desktop app to complete the', questName, 'quest!');
+    } else {
+      console.log('Unknown quest type. Use the discord desktop app to complete the', questName, 'quest!');
+    }
+  }
+
+  /**
+   * Auto-complete all valid quests
+   * @returns {Promise<void>}
+   */
+  async autoCompleteAll() {
+    await this.get(); // Refresh quest data
+    const validQuests = this.filterQuestsValid();
+    
+    for (const quest of validQuests) {
+      try {
+        await this.doingQuest(quest);
+      } catch (error) {
+        console.error(`Failed to complete quest ${quest.id}:`, error);
+      }
+    }
+  }
+
+  /**
+   * Get cache size
+   * @returns {number}
+   */
+  get size() {
+    return this.cache.size;
+  }
+
+  /**
+   * Clear quest cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+
+  /**
+   * Make QuestManager iterable
+   * @returns {IterableIterator<Quest>}
+   */
+  [Symbol.iterator]() {
+    return this.cache.values();
+  }
+}
+
+module.exports = QuestManager;

package/src/managers/ThreadManager.js

@@ -161,7 +161,7 @@ class ThreadManager extends CachedManager {
     // Discord sends the thread id as id in this object
     for (const rawMember of rawThreads.members) client.channels.cache.get(rawMember.id)?.members._add(rawMember);
     // Patch firstMessage
-    // According to https://github.com/aiko-chan-ai/discord.js-selfbot-v13/issues/1502, rawThreads.first_messages could be null.
+    // According to https://github.com/aiko-chan-ai/djs-selfbot-v13/issues/1502, rawThreads.first_messages could be null.
     for (const rawMessage of rawThreads?.first_messages || []) {
       client.channels.cache.get(rawMessage.id)?.messages._add(rawMessage);
     }

package/src/structures/ClientUser.js

@@ -203,7 +203,7 @@ class ClientUser extends User {
    * @example
    * // Set the client user's presence
    * client.user.setPresence({ activities: [{ name: 'with discord.js' }], status: 'idle' });
-   * @see {@link https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/RichPresence.md}
+   * @see {@link https://github.com/aiko-chan-ai/djs-selfbot-v13/blob/main/Document/RichPresence.md}
    */
   setPresence(data) {
     return this.client.presence.set(data);
@@ -248,7 +248,7 @@ class ClientUser extends User {
    * @example
    * // Set the client user's activity
    * client.user.setActivity('discord.js', { type: 'WATCHING' });
-   * @see {@link https://github.com/aiko-chan-ai/discord.js-selfbot-v13/blob/main/Document/RichPresence.md}
+   * @see {@link https://github.com/aiko-chan-ai/djs-selfbot-v13/blob/main/Document/RichPresence.md}
    */
   setActivity(name, options = {}) {
     if (!name) return this.setPresence({ activities: [], shardId: options.shardId });
@@ -447,12 +447,186 @@ class ClientUser extends User {
   }
 
   /**
-   * Set pronouns
-   * @param {?string} pronouns Your pronouns
+   * Add a widget to the user's profile
+   * @param {string} type Widget type (favorite_games, current_games, played_games, want_to_play_games)
+   * @param {string} gameId The game ID to add
+   * @param {string} [comment] Optional comment for the game
+   * @param {string[]} [tags] Optional tags for the game
+   * @returns {Promise<Object>}
+   */
+  async addWidget(type, gameId, comment = null, tags = []) {
+    if (!type || !gameId) {
+      throw new TypeError('Widget type and game ID are required');
+    }
+
+    const validTypes = ['favorite_games', 'current_games', 'played_games', 'want_to_play_games'];
+    if (!validTypes.includes(type)) {
+      throw new TypeError(`Invalid widget type. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // Get current widgets first
+    const currentWidgets = await this.widgetsList();
+    
+    // Find existing widget of this type or create new one
+    let targetWidget = currentWidgets.widgets.find(w => w.data.type === type);
+    
+    if (!targetWidget) {
+      // Create new widget if it doesn't exist
+      targetWidget = {
+        id: Date.now().toString(), // Generate temporary ID
+        data: {
+          type: type,
+          games: []
+        }
+      };
+      currentWidgets.widgets.push(targetWidget);
+    }
+
+    // Add the game if it doesn't already exist
+    const existingGame = targetWidget.data.games.find(g => g.game_id === gameId);
+    if (!existingGame) {
+      const gameData = { game_id: gameId };
+      if (comment !== null) gameData.comment = comment;
+      if (tags.length > 0) gameData.tags = tags;
+      
+      targetWidget.data.games.push(gameData);
+    }
+
+    // Update widgets via API
+    return this.client.api.users['@me'].profile.patch({
+      data: { widgets: currentWidgets.widgets }
+    });
+  }
+
+  /**
+   * Delete a widget or remove a game from a widget
+   * @param {string} type Widget type to modify
+   * @param {string} [gameId] Optional game ID to remove (if not provided, removes entire widget)
+   * @returns {Promise<Object>}
+   */
+  async delWidget(type, gameId = null) {
+    if (!type) {
+      throw new TypeError('Widget type is required');
+    }
+
+    const validTypes = ['favorite_games', 'current_games', 'played_games', 'want_to_play_games'];
+    if (!validTypes.includes(type)) {
+      throw new TypeError(`Invalid widget type. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // Get current widgets
+    const currentWidgets = await this.widgetsList();
+    
+    if (gameId) {
+      // Remove specific game from widget
+      const targetWidget = currentWidgets.widgets.find(w => w.data.type === type);
+      if (targetWidget) {
+        targetWidget.data.games = targetWidget.data.games.filter(g => g.game_id !== gameId);
+      }
+    } else {
+      // Remove entire widget
+      currentWidgets.widgets = currentWidgets.widgets.filter(w => w.data.type !== type);
+    }
+
+    // Update widgets via API
+    return this.client.api.users['@me'].profile.patch({
+      data: { widgets: currentWidgets.widgets }
+    });
+  }
+
+  /**
+   * Get the list of all widgets for the user
+   * @returns {Promise<Object>} Object containing widgets array
+   */
+  async widgetsList() {
+    try {
+      const data = await this.client.api.users['@me'].profile.get();
+      return data.widgets ? { widgets: data.widgets } : { widgets: [] };
+    } catch (error) {
+      // If profile endpoint doesn't exist or fails, return empty widgets
+      return { widgets: [] };
+    }
+  }
+
+  /**
+   * Set display name style with font, effect, and colors
+   * @param {string|number} fontName Font name or ID
+   * @param {string|number} effectName Effect name or ID  
+   * @param {number|string} color1 Primary color (hex or decimal)
+   * @param {number|string} [color2] Secondary color for gradient effects (hex or decimal)
    * @returns {Promise<ClientUser>}
+   * @example
+   * // Set Sans font with gradient effect
+   * client.user.setNameStyle('Sans', 'Gradient', 7183099, 6082490);
+   * // Set Tempo font with solid effect
+   * client.user.setNameStyle('Tempo', 'Solid', 7183099);
+   * // Using IDs directly
+   * client.user.setNameStyle(11, 2, 7183099, 6082490);
    */
-  setPronouns(pronouns = '') {
-    return this.edit({ pronouns });
+  async setNameStyle(fontName, effectName, color1, color2 = null) {
+    // Font name/ID mapping
+    const fontMap = {
+      'Sans': 11,
+      'Tempo': 12,
+      'Sakura': 3,
+      'JellyBean': 4,
+      'Modern': 6,
+      'Medieval': 7,
+      '8Bit': 8,
+      'Vampire': 10
+    };
+
+    // Effect name/ID mapping
+    const effectMap = {
+      'Solid': 1,
+      'Gradient': 2,
+      'Neon': 3,
+      'Toon': 4,
+      'Pop': 5
+    };
+
+    // Resolve font ID
+    let fontId = typeof fontName === 'string' ? fontMap[fontName] : fontName;
+    if (!fontId) {
+      throw new TypeError(`Invalid font name. Must be one of: ${Object.keys(fontMap).join(', ')} or a valid font ID`);
+    }
+
+    // Resolve effect ID
+    let effectId = typeof effectName === 'string' ? effectMap[effectName] : effectName;
+    if (!effectId) {
+      throw new TypeError(`Invalid effect name. Must be one of: ${Object.keys(effectMap).join(', ')} or a valid effect ID`);
+    }
+
+    // Resolve colors
+    const resolveColor = (color) => {
+      if (typeof color === 'string') {
+        // Handle hex colors
+        if (color.startsWith('#')) {
+          return parseInt(color.slice(1), 16);
+        }
+        return parseInt(color, 16);
+      }
+      return color;
+    };
+
+    const primaryColor = resolveColor(color1);
+    const colors = [primaryColor];
+    
+    if (color2 !== null) {
+      const secondaryColor = resolveColor(color2);
+      colors.push(secondaryColor);
+    }
+
+    // Build the data object
+    const data = {
+      display_name_font_id: fontId,
+      display_name_effect_id: effectId,
+      display_name_colors: colors
+    };
+
+    // Send PATCH request to Discord API
+    await this.client.api.users('@me').patch({ data });
+    return this;
   }
 
   /**

package/src/structures/Guild.js

@@ -1605,6 +1605,60 @@ class Guild extends AnonymousGuild {
     };
   }
 
+  /**
+   * Mute this guild
+   * @param {GuildMuteOptions} [options] Options for muting the guild
+   * @returns {Promise<Object>} The updated guild settings
+   * @example
+   * // Mute the guild with default settings
+   * guild.mute();
+   * @example
+   * // Mute the guild with custom options
+   * guild.mute({
+   *   muted: true,
+   *   suppressRoles: false,
+   *   suppressEveryone: true,
+   *   muteScheduledEvents: false
+   * });
+   */
+  async mute(options = {}) {
+    const {
+      muted = true,
+      suppressRoles = true,
+      suppressEveryone = true,
+      muteScheduledEvents = true
+    } = options;
+
+    const data = await this.client.api.users('@me').guilds(this.id).settings.patch({
+      data: {
+        muted,
+        suppress_roles: suppressRoles,
+        suppress_everyone: suppressEveryone,
+        mute_scheduled_events: muteScheduledEvents
+      }
+    });
+    return data;
+  }
+
+  /**
+   * Unmute this guild
+   * @returns {Promise<Object>} The updated guild settings
+   * @example
+   * // Unmute the guild
+   * guild.unmute();
+   */
+  async unmute() {
+    const data = await this.client.api.users('@me').guilds(this.id).settings.patch({
+      data: {
+        muted: false,
+        suppress_roles: false,
+        suppress_everyone: false,
+        mute_scheduled_events: false
+      }
+    });
+    return data;
+  }
+
   /**
    * Creates a collection of this guild's roles, sorted by their position and ids.
    * @returns {Collection<Snowflake, Role>}

package/src/structures/Presence.js

@@ -800,6 +800,22 @@ class RichPresence extends Activity {
     return this;
   }
 
+  /**
+   * Set the URL of the state of the activity
+   * @param {?string} url The url of the state
+   * @returns {RichPresence}
+   */
+  setStateURL(url){
+    if (!url)
+      throw new Error('Detail URL must be a url');
+
+    if (typeof url !== 'string') throw new Error('Detail URL must be a url');
+    if (!URL.canParse(url)) throw new Error('Detail URL must be a valid url');
+  
+    this.state_url  = url;
+    return this;
+  }
+
   /**
    * Set the details of the activity
    * @param {?string} details The details of the activity
@@ -810,6 +826,22 @@ class RichPresence extends Activity {
     return this;
   }
 
+  /**
+   * Set the URL of the details of the activity
+   * @param {?string} url The url of the details
+   * @returns {RichPresence}
+   */
+  setDetailsURL(url){
+    if (!url)
+      throw new Error('Detail URL must be a url');
+
+    if (typeof url !== 'string') throw new Error('Detail URL must be a url');
+    if (!URL.canParse(url)) throw new Error('Detail URL must be a valid url');
+  
+    this.details_url = url;
+    return this;
+  }
+
   /**
    * @typedef {Object} RichParty
    * @property {string} id The id of the party