djs-selfbot-v13 3.7.4 → 3.7.6

package/README.md

@@ -29,6 +29,7 @@
 ### Guild Management
 - `guild.mute(options?)` - Mute a guild completely (suppress all notifications)
 - `guild.unmute()` - Unmute a guild (restore all notifications)
+- `guild.markRead(readStates?)` - Mark all channels in a guild as read
 
 ### Developer Applications
 - `client.developers.get(withTeamApplications?)` - Fetch all developer applications owned by the user
@@ -79,6 +80,19 @@
 - `client.quests.getClaimable()` - Get claimable quests
 - `client.quests.filterQuestsValid()` - Filter valid quests
 
+### Message Search
+- `channel.search(options?)` - Search for messages in a channel with advanced filters
+  - `authorId` - Search by specific author
+  - `mentions` - Search for messages mentioning a user
+  - `has` - Search for messages containing: `image`, `video`, `link`, `embed`, `sound`, `poll`, `sticker`, `snapshot`
+  - `pinned` - Search only pinned messages
+  - `sortBy` - Sort by `timestamp` or `relevance`
+  - `sortOrder` - Sort order `desc` or `asc`
+  - `offset` - Pagination offset
+  - `limit` - Limit number of results
+  - `maxTime` - Search for messages before a specific date/time
+
+
 </details>
 
 > [!WARNING]
@@ -123,6 +137,50 @@ client.on('ready', async () => {
 client.login('token');
 ```
 
+### Advanced Examples
+
+#### Message Search
+```js
+// Search for messages with images in a channel
+const results = await channel.search({ has: ['image'] });
+
+// Search for messages by a specific author
+const userMessages = await channel.search({ 
+  authorId: '123456789012345678',
+  limit: 10 
+});
+
+// Search for pinned messages
+const pinnedMessages = await channel.search({ pinned: true });
+
+// Search for messages before a specific date
+const oldMessages = await channel.search({ 
+  maxTime: '2023-12-01',
+  limit: 50 
+});
+
+// Search for messages with multiple filters
+const complexSearch = await channel.search({
+  has: ['link', 'embed'],
+  sortBy: 'timestamp',
+  sortOrder: 'desc',
+  offset: 20,
+  maxTime: new Date('2023-12-31')
+});
+```
+
+#### Guild Read State Management
+```js
+// Mark all channels in a guild as read
+await guild.markRead();
+
+// Mark specific channels as read
+await guild.markRead([
+  { channel_id: '123456789012345678', message_id: '987654321098765432' },
+  { channel_id: '876543210987654321', message_id: '123456789012345678' }
+]);
+```
+
 ## Get Token ?
 
 - Based: [findByProps](https://discord.com/channels/603970300668805120/1085682686607249478/1085682686607249478)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.4",
+  "version": "3.7.6",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

package/src/managers/QuestManager.js

@@ -250,12 +250,9 @@ class QuestManager extends BaseManager {
   async doingQuest(quest) {
     const questName = quest.config.messages?.quest_name || 'Unknown Quest';
     
-    if (!quest.isEnrolledQuest()) {
-      console.log(`Enrolling in quest "${questName}"...`);
+    if (!quest.isEnrolledQuest()) 
       await this.acceptQuest(quest.id);
-    }
 
-    const applicationName = quest.config.application?.name || 'Unknown App';
     const taskConfig = quest.config.task_config;
     
     const taskName = [
@@ -266,10 +263,9 @@ class QuestManager extends BaseManager {
       'WATCH_VIDEO_ON_MOBILE'
     ].find(x => taskConfig.tasks?.[x] != null);
 
-    if (!taskName) {
-      console.log(`Unknown task type for quest "${questName}"`);
-      return;
-    }
+    if (!taskName)
+      return console.log(`Unknown task type for quest "${questName}"`);
+
 
     const secondsNeeded = taskConfig.tasks[taskName].target;
     let secondsDone = quest.userStatus?.progress?.[taskName]?.value ?? 0;
@@ -281,8 +277,6 @@ class QuestManager extends BaseManager {
       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;
@@ -305,8 +299,6 @@ class QuestManager extends BaseManager {
         await this.videoProgress(quest.id, secondsNeeded);
       }
 
-      console.log(`Quest "${questName}" completed!`);
-
     } else if (taskName === 'PLAY_ON_DESKTOP') {
       const interval = 60;
 
@@ -315,20 +307,11 @@ class QuestManager extends BaseManager {
         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!');
     }
   }
 

package/src/structures/Guild.js

@@ -1659,6 +1659,37 @@ class Guild extends AnonymousGuild {
     return data;
   }
 
+  /**
+   * Mark all channels in this guild as read
+   * @param {MarkReadOptions[]} [readStates] Array of read states to mark as read
+   * @returns {Promise<Object>} The response from Discord
+   * @example
+   * // Mark all channels as read
+   * guild.markRead();
+   * 
+   * // Mark specific channels as read
+   * guild.markRead([
+   *   { channel_id: '123456789012345678', message_id: '987654321098765432' }
+   * ]);
+   */
+  async markRead(readStates = []) {
+    // If no readStates provided, get all channels in guild
+    if (readStates.length === 0) {
+      const channels = this.channels.cache.filter(c => c.isTextBased());
+      readStates = channels.map(channel => ({
+        channel_id: channel.id,
+        message_id: channel.lastMessageId || '0',
+        read_state_type: 0
+      }));
+    }
+
+    const data = await this.client.api['read-states']['ack-bulk'].post({
+      data: readStates
+    });
+
+    return data;
+  }
+
   /**
    * Creates a collection of this guild's roles, sorted by their position and ids.
    * @returns {Collection<Snowflake, Role>}

package/src/structures/interfaces/TextBasedChannel.js

@@ -385,30 +385,67 @@ class TextBasedChannel {
     return Util.createPromiseInteraction(this.client, nonce, 5000);
   }
 
+
   /**
-   * Search messages in this channel by user
-   * @param {number} limit Number of messages to return
-   * @param {UserResolvable} user User whose messages to search for
-   * @returns {Promise<Object[]|false>} Array of messages or false if failed
+   * Search for messages in this channel
+   * @param {ChannelSearchOptions} [options] Search options
+   * @returns {Promise<Object>} The search results
    * @example
-   * // Search for messages from a user
-   * channel.search(10, user)
-   *   .then(messages => console.log(`Found ${messages.length} messages`))
-   *   .catch(console.error);
+   * // Search for messages by author
+   * channel.search({ authorId: '123456789012345678' });
+   * 
+   * // Search for messages with images
+   * channel.search({ has: ['image'] });
+   * 
+   * // Search for pinned messages
+   * channel.search({ pinned: true });
    */
-  async search(limit, user) {
-    const userId = this.client.users.resolveId(user);
-    if (!userId) throw new Error('INVALID_TYPE', 'user', 'UserResolvable');
+  async search(options = {}) {
+    const {
+      authorId,
+      mentions,
+      has = [],
+      pinned,
+      sortBy = 'timestamp',
+      sortOrder = 'desc',
+      offset = 0,
+      limit,
+      maxTime
+    } = options;
+
+    const query = {
+      sort_by: sortBy,
+      sort_order: sortOrder,
+      offset: offset
+    };
+
+    if (maxTime) {
+      const time = new Date(maxTime).getTime();
+      const maxId = (BigInt(time) - 1420070400000n) << 22n;
+      query.max_id = maxId.toString();
+    }
+
+    if (authorId) query.author_id = authorId;
+    if (mentions) query.mentions = mentions;
+    if (pinned) query.pinned = true;
     
-    const res = await fetch(`https://ptb.discord.com/api/v9/${this.guild ? `guilds/${this.guild.id}` : `channels/${this.id}`}/messages/search?author_id=${userId}&channel_id=${this.id}&sort_by=timestamp&sort_order=desc&offset=0`, {
-      method: 'GET',
-      headers: { authorization: this.client.token }
-    });
+    for (const hasType of has) {
+      if (!query.has) query.has = [];
+      query.has.push(hasType);
+    }
+
+    if (this.guild) query.channel_id = this.id;
+
+    const endpoint = this.guild 
+      ? this.client.api.guilds(this.guild.id).messages.search
+      : this.client.api.channels(this.id).messages.search;
+
+    const data = await endpoint.get({ query });
     
-    if (!res.ok) return false;
+    if (limit && data.messages) 
+      data.messages = data.messages.flat().slice(0, limit);
     
-    const data = await res.json();
-    return data.messages.splice(0, limit);
+    return data;
   }
 
   /**

package/typings/index.d.ts

@@ -945,6 +945,24 @@ export interface AcceptInviteOptions {
   bypassVerify: boolean;
 }
 
+export interface ChannelSearchOptions {
+  authorId?: Snowflake;
+  mentions?: Snowflake;
+  has?: ('image' | 'video' | 'link' | 'embed' | 'sound' | 'poll' | 'sticker' | 'snapshot')[];
+  pinned?: boolean;
+  sortBy?: 'timestamp' | 'relevance';
+  sortOrder?: 'desc' | 'asc';
+  offset?: number;
+  limit?: number;
+  maxTime?: string | Date;
+}
+
+export interface MarkReadOptions {
+  channel_id: Snowflake;
+  message_id: Snowflake;
+  read_state_type?: number;
+}
+
 export type OAuth2AuthorizeOptions = {
   guild_id?: Snowflake;
   permissions?: string;
@@ -1684,6 +1702,7 @@ export class Guild extends AnonymousGuild {
   public setVanityCode(code?: string): Promise<this>;
   public mute(options?: GuildMuteOptions): Promise<any>;
   public unmute(): Promise<any>;
+  public markRead(readStates?: MarkReadOptions[]): Promise<any>;
 }
 
 export class GuildAuditLogs<T extends GuildAuditLogsResolvable = 'ALL'> {
@@ -5225,6 +5244,7 @@ export interface TextBasedChannelFields extends PartialTextBasedChannelFields {
   fetchWebhooks(): Promise<Collection<Snowflake, Webhook>>;
   sendTyping(): Promise<{ message_send_cooldown_ms: number; thread_create_cooldown_ms: number } | undefined>;
   sendSlash(target: UserResolvable, commandName: string, ...args: any[]): Promise<Message | Modal>;
+  search(options?: ChannelSearchOptions): Promise<any>;
 }
 
 export function PartialWebhookMixin<T>(Base?: Constructable<T>): Constructable<T & PartialWebhookFields>;