@vanzxy/baileys 1.6.2 → 1.6.4

package/lib/Utils/message-search.js

@@ -0,0 +1,174 @@
+// Vanz@Add --- ported from Bail-master addons/message-search.ts (type-only
+// annotations dropped; behavior unchanged).
+export const extractMessageText = (message) => {
+    const c = message.message;
+    if (!c)
+        return '';
+    if (c.conversation)
+        return c.conversation;
+    if (c.extendedTextMessage?.text)
+        return c.extendedTextMessage.text;
+    if (c.imageMessage?.caption)
+        return c.imageMessage.caption;
+    if (c.videoMessage?.caption)
+        return c.videoMessage.caption;
+    if (c.documentMessage?.caption)
+        return c.documentMessage.caption;
+    if (c.documentMessage?.fileName)
+        return c.documentMessage.fileName;
+    if (c.locationMessage?.name)
+        return c.locationMessage.name;
+    if (c.locationMessage?.address)
+        return c.locationMessage.address;
+    if (c.contactMessage?.displayName)
+        return c.contactMessage.displayName;
+    if (c.pollCreationMessage?.name)
+        return c.pollCreationMessage.name;
+    return '';
+};
+const getMessageType = (message) => {
+    const c = message.message;
+    if (!c)
+        return 'other';
+    if (c.conversation || c.extendedTextMessage)
+        return 'text';
+    if (c.imageMessage)
+        return 'image';
+    if (c.videoMessage)
+        return 'video';
+    if (c.documentMessage)
+        return 'document';
+    if (c.audioMessage)
+        return 'audio';
+    if (c.stickerMessage)
+        return 'sticker';
+    if (c.locationMessage || c.liveLocationMessage)
+        return 'location';
+    if (c.contactMessage || c.contactsArrayMessage)
+        return 'contact';
+    return 'other';
+};
+export const calculateRelevance = (query, text, position) => {
+    let score = 100;
+    if (text.toLowerCase() === query.toLowerCase())
+        score += 50;
+    score -= Math.min(position / 10, 20);
+    const lt = text.toLowerCase(), lq = query.toLowerCase();
+    if (position === 0 ||
+        lt[position - 1] === ' ' ||
+        lt[position + lq.length] === ' ' ||
+        position + lq.length === text.length)
+        score += 20;
+    return Math.max(score, 0);
+};
+/** Plain-text substring search with relevance-sorted results. */
+export const searchMessages = (messages, query, options = {}) => {
+    const results = [];
+    const sq = options.caseSensitive ? query : query.toLowerCase();
+    for (const message of messages) {
+        if (options.jid && message.key.remoteJid !== options.jid)
+            continue;
+        const ts = message.messageTimestamp;
+        const mt = ts ? new Date((typeof ts === 'number' ? ts : Number(ts)) * 1000) : null;
+        if (options.fromDate && mt && mt < options.fromDate)
+            continue;
+        if (options.toDate && mt && mt > options.toDate)
+            continue;
+        if (options.fromSender && message.key.participant !== options.fromSender)
+            continue;
+        if (options.fromMe !== undefined && message.key.fromMe !== options.fromMe)
+            continue;
+        if (options.messageTypes?.length) {
+            if (!options.messageTypes.includes(getMessageType(message)))
+                continue;
+        }
+        const text = extractMessageText(message);
+        if (!text)
+            continue;
+        const st = options.caseSensitive ? text : text.toLowerCase();
+        const pos = st.indexOf(sq);
+        if (pos !== -1) {
+            results.push({
+                message,
+                matchedText: text.substring(Math.max(0, pos - 20), Math.min(text.length, pos + query.length + 20)),
+                matchPosition: pos,
+                relevanceScore: calculateRelevance(query, text, pos)
+            });
+        }
+        if (options.limit && results.length >= options.limit)
+            break;
+    }
+    return results.sort((a, b) => b.relevanceScore - a.relevanceScore);
+};
+/** Regex-based search (e.g. for commands/patterns), unordered by relevance. */
+export const searchMessagesRegex = (messages, pattern, options = {}) => {
+    const results = [];
+    for (const message of messages) {
+        if (options.jid && message.key.remoteJid !== options.jid)
+            continue;
+        if (options.fromSender && message.key.participant !== options.fromSender)
+            continue;
+        if (options.fromMe !== undefined && message.key.fromMe !== options.fromMe)
+            continue;
+        if (options.messageTypes?.length) {
+            if (!options.messageTypes.includes(getMessageType(message)))
+                continue;
+        }
+        const text = extractMessageText(message);
+        if (!text)
+            continue;
+        const match = text.match(pattern);
+        if (match)
+            results.push({ message, matchedText: match[0], matchPosition: match.index ?? 0, relevanceScore: 100 });
+        if (options.limit && results.length >= options.limit)
+            break;
+    }
+    return results;
+};
+/** Standalone searchable index — feed it messages independently of the main Store. */
+export class MessageSearchManager {
+    messages = [];
+    messageIndex = new Map();
+    addMessages(messages) {
+        for (const msg of messages) {
+            const id = msg.key.id;
+            if (id && !this.messageIndex.has(id)) {
+                this.messages.push(msg);
+                this.messageIndex.set(id, msg);
+            }
+        }
+    }
+    removeMessages(messageIds) {
+        const idSet = new Set(messageIds);
+        this.messages = this.messages.filter((m) => !idSet.has(m.key.id || ''));
+        for (const id of messageIds)
+            this.messageIndex.delete(id);
+    }
+    clear() {
+        this.messages = [];
+        this.messageIndex.clear();
+    }
+    get count() {
+        return this.messages.length;
+    }
+    search(query, options) {
+        return searchMessages(this.messages, query, options);
+    }
+    searchRegex(pattern, options) {
+        return searchMessagesRegex(this.messages, pattern, options);
+    }
+    getByJid(jid) {
+        return this.messages.filter((m) => m.key.remoteJid === jid);
+    }
+    getBySender(sender) {
+        return this.messages.filter((m) => m.key.participant === sender || m.key.remoteJid === sender);
+    }
+    getByType(type) {
+        return this.messages.filter((m) => getMessageType(m) === type);
+    }
+    getById(id) {
+        return this.messageIndex.get(id);
+    }
+}
+export const createMessageSearch = () => new MessageSearchManager();
+//# sourceMappingURL=message-search.js.map

package/lib/Utils/scheduling.d.ts

@@ -0,0 +1,42 @@
+import type { WAMessage, AnyMessageContent } from '../Types/index.js';
+export interface SchedulerOptions {
+    maxQueue?: number;
+    checkInterval?: number;
+    onSent?: (scheduled: ScheduledMessage, message?: WAMessage) => void;
+    onFailed?: (scheduled: ScheduledMessage, error: Error) => void;
+}
+export type ScheduledMessageStatus = 'pending' | 'sent' | 'failed' | 'cancelled';
+export interface RepeatOptions {
+    repeatIntervalMs?: number;
+    maxRepeats?: number;
+}
+export interface ScheduledMessage {
+    id: string;
+    jid: string;
+    content: AnyMessageContent;
+    scheduledTime: Date;
+    createdAt: Date;
+    status: ScheduledMessageStatus;
+    messageId?: string;
+    error?: string;
+    repeatIntervalMs?: number;
+    maxRepeats?: number;
+    repeatCount?: number;
+}
+export declare class MessageScheduler {
+    private queue;
+    private timer;
+    private sendMessage;
+    private options;
+    constructor(sendMessage: (jid: string, content: AnyMessageContent) => Promise<WAMessage | undefined>, options?: SchedulerOptions);
+    schedule(jid: string, content: AnyMessageContent, scheduledTime: Date, repeatOptions?: RepeatOptions): ScheduledMessage;
+    scheduleDelay(jid: string, content: AnyMessageContent, delayMs: number, repeatOptions?: RepeatOptions): ScheduledMessage;
+    cancel(id: string): boolean;
+    cancelForJid(jid: string): number;
+    getPending(): ScheduledMessage[];
+    get(id: string): ScheduledMessage | undefined;
+    clearAll(): number;
+    stop(): void;
+    start(): void;
+}
+export declare const createMessageScheduler: (sendMessage: (jid: string, content: AnyMessageContent) => Promise<WAMessage | undefined>, options?: SchedulerOptions) => MessageScheduler;

package/lib/Utils/scheduling.js

@@ -0,0 +1,140 @@
+/**
+ * Vanz@Add --- ported from Bail-master addons/scheduling.ts + message-scheduler.ts.
+ * Bail-master shipped these as two separate, overlapping schedulers (one class-based
+ * with polling, one function-based with setTimeout + repeat support). Merged here into
+ * a single class-based scheduler so multiple independent instances can be bound to
+ * different sendMessage functions (e.g. multi-session bots), while keeping the
+ * repeat-interval/maxRepeats feature from the function-based version.
+ */
+export class MessageScheduler {
+    queue = new Map();
+    timer = null;
+    sendMessage;
+    options;
+    constructor(sendMessage, options = {}) {
+        this.sendMessage = sendMessage;
+        this.options = {
+            maxQueue: options.maxQueue ?? 1000,
+            checkInterval: options.checkInterval ?? 1000,
+            onSent: options.onSent ?? (() => { }),
+            onFailed: options.onFailed ?? (() => { })
+        };
+    }
+    generateId() {
+        return `sched_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    }
+    /**
+     * Schedule a message for a specific Date. Pass `repeatIntervalMs` to
+     * re-queue the job that many ms after each send (optionally capped by
+     * `maxRepeats`).
+     */
+    schedule(jid, content, scheduledTime, repeatOptions) {
+        if (this.queue.size >= this.options.maxQueue)
+            throw new Error(`Maximum queue size (${this.options.maxQueue}) reached`);
+        if (scheduledTime.getTime() <= Date.now())
+            throw new Error('Scheduled time must be in the future');
+        const scheduled = {
+            id: this.generateId(),
+            jid,
+            content,
+            scheduledTime,
+            createdAt: new Date(),
+            status: 'pending',
+            repeatIntervalMs: repeatOptions?.repeatIntervalMs,
+            maxRepeats: repeatOptions?.maxRepeats,
+            repeatCount: 0
+        };
+        this.queue.set(scheduled.id, scheduled);
+        this.ensureTimerRunning();
+        return scheduled;
+    }
+    scheduleDelay(jid, content, delayMs, repeatOptions) {
+        return this.schedule(jid, content, new Date(Date.now() + delayMs), repeatOptions);
+    }
+    cancel(id) {
+        const s = this.queue.get(id);
+        if (s?.status === 'pending') {
+            s.status = 'cancelled';
+            this.queue.delete(id);
+            return true;
+        }
+        return false;
+    }
+    cancelForJid(jid) {
+        let cancelled = 0;
+        for (const [id, s] of this.queue) {
+            if (s.jid === jid && s.status === 'pending') {
+                s.status = 'cancelled';
+                this.queue.delete(id);
+                cancelled++;
+            }
+        }
+        return cancelled;
+    }
+    getPending() {
+        return Array.from(this.queue.values()).filter((s) => s.status === 'pending');
+    }
+    get(id) {
+        return this.queue.get(id);
+    }
+    clearAll() {
+        const count = this.queue.size;
+        this.queue.clear();
+        this.stopTimer();
+        return count;
+    }
+    async processQueue() {
+        const now = Date.now();
+        for (const [id, s] of this.queue) {
+            if (s.status !== 'pending')
+                continue;
+            if (s.scheduledTime.getTime() > now)
+                continue;
+            try {
+                const message = await this.sendMessage(s.jid, s.content);
+                s.messageId = message?.key?.id ?? undefined;
+                this.options.onSent(s, message);
+                // Handle repeating jobs — re-arm instead of removing from the queue.
+                if (s.repeatIntervalMs && s.repeatIntervalMs > 0) {
+                    const nextCount = (s.repeatCount ?? 0) + 1;
+                    if (s.maxRepeats === undefined || nextCount < s.maxRepeats) {
+                        s.repeatCount = nextCount;
+                        s.scheduledTime = new Date(Date.now() + s.repeatIntervalMs);
+                        s.status = 'pending';
+                        continue;
+                    }
+                }
+                s.status = 'sent';
+            }
+            catch (error) {
+                s.status = 'failed';
+                s.error = error?.message || String(error);
+                this.options.onFailed(s, error);
+            }
+            this.queue.delete(id);
+        }
+        if (this.queue.size === 0)
+            this.stopTimer();
+    }
+    ensureTimerRunning() {
+        if (!this.timer) {
+            this.timer = setInterval(() => this.processQueue(), this.options.checkInterval);
+            this.timer?.unref?.();
+        }
+    }
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    stop() {
+        this.stopTimer();
+    }
+    start() {
+        if (this.queue.size > 0)
+            this.ensureTimerRunning();
+    }
+}
+export const createMessageScheduler = (sendMessage, options) => new MessageScheduler(sendMessage, options);
+//# sourceMappingURL=scheduling.js.map

package/lib/Utils/status.d.ts

@@ -0,0 +1,50 @@
+import type { AnyMessageContent } from '../Types/index.js';
+import type makeWASocket from '../Socket/index.js';
+type WASocket = ReturnType<typeof makeWASocket>;
+export declare const STATUS_BROADCAST_JID = "status@broadcast";
+export declare const STATUS_BACKGROUNDS: {
+    solid: Record<string, string>;
+    gradient: Record<string, string[]>;
+};
+export declare const STATUS_FONTS: {
+    readonly SANS_SERIF: 0;
+    readonly SERIF: 1;
+    readonly NORICAN: 2;
+    readonly BRYNDAN: 3;
+    readonly BEBASNEUE: 4;
+    readonly OSWALD: 5;
+    readonly DAMION: 6;
+    readonly DANCING: 7;
+    readonly COMFORTAA: 8;
+    readonly EXOTWO: 9;
+};
+export type StatusFont = (typeof STATUS_FONTS)[keyof typeof STATUS_FONTS];
+export declare const generateStatusMessageId: () => string;
+export type TextStatusOptions = {
+    text: string;
+    backgroundColor?: string;
+    font?: StatusFont;
+    textColor?: string;
+    mentions?: string[];
+};
+export type MediaStatusOptions = {
+    caption?: string;
+    gifPlayback?: boolean;
+    waveform?: Uint8Array;
+};
+export declare const createTextStatus: (options: TextStatusOptions) => AnyMessageContent;
+export declare const createImageStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const createVideoStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const createAudioStatus: (media: Buffer | string, options?: MediaStatusOptions) => AnyMessageContent;
+export declare const getStatusJid: () => string;
+export declare const StatusHelper: {
+    text: (text: string, backgroundColor?: string, font?: StatusFont) => AnyMessageContent;
+    image: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    imageUrl: (url: string, caption?: string) => AnyMessageContent;
+    video: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    videoUrl: (url: string, caption?: string) => AnyMessageContent;
+    gif: (buffer: Buffer, caption?: string) => AnyMessageContent;
+    voiceNote: (buffer: Buffer) => AnyMessageContent;
+    send: (sock: WASocket, content: AnyMessageContent, jidList?: string[]) => Promise<any>;
+};
+export {};

package/lib/Utils/status.js

@@ -0,0 +1,108 @@
+// Vanz@Add --- ported from Bail-master addons/status-helpers.ts (type-only
+// annotations dropped; behavior unchanged). status-posting.ts (the other
+// addon shipping identical STATUS_BACKGROUNDS/STATUS_FONTS/createXStatus/
+// StatusHelper) additionally exposed `makeStatusMentionsAddon`, a
+// socket-factory-style addon requiring deep internal wiring (authState,
+// waUploadToServer, groupMetadata, generateWAMessageContent) matching
+// Baileys' own makeXSocket pattern — left out of this port as too tightly
+// coupled to socket internals to safely merge without live testing.
+// Basic status mentions are still supported via createTextStatus's own
+// `mentions` option (contextInfo.mentionedJid).
+import { randomBytes } from 'crypto';
+export const STATUS_BROADCAST_JID = 'status@broadcast';
+export const STATUS_BACKGROUNDS = {
+    solid: {
+        green: '#25D366',
+        blue: '#34B7F1',
+        purple: '#8B5CF6',
+        red: '#EF4444',
+        orange: '#F97316',
+        yellow: '#EAB308',
+        pink: '#EC4899',
+        teal: '#14B8A6',
+        gray: '#6B7280',
+        black: '#000000',
+        white: '#FFFFFF'
+    },
+    gradient: {
+        sunset: ['#F97316', '#EF4444'],
+        ocean: ['#3B82F6', '#06B6D4'],
+        forest: ['#22C55E', '#10B981'],
+        purple: ['#8B5CF6', '#EC4899'],
+        midnight: ['#1E3A8A', '#4C1D95'],
+        aurora: ['#06B6D4', '#8B5CF6', '#EC4899']
+    }
+};
+export const STATUS_FONTS = {
+    SANS_SERIF: 0,
+    SERIF: 1,
+    NORICAN: 2,
+    BRYNDAN: 3,
+    BEBASNEUE: 4,
+    OSWALD: 5,
+    DAMION: 6,
+    DANCING: 7,
+    COMFORTAA: 8,
+    EXOTWO: 9
+};
+/** Generate a status message ID with a 4NY4W3B prefix. */
+export const generateStatusMessageId = () => `4NY4W3B${randomBytes(16).toString('hex').toUpperCase()}`;
+export const createTextStatus = (options) => ({
+    text: options.text,
+    backgroundColor: options.backgroundColor || STATUS_BACKGROUNDS.solid.green,
+    font: options.font ?? STATUS_FONTS.SANS_SERIF,
+    textColor: options.textColor || '#FFFFFF',
+    contextInfo: { mentionedJid: options.mentions || [], isForwarded: false }
+});
+export const createImageStatus = (media, options) => ({
+    image: typeof media === 'string' ? { url: media } : media,
+    caption: options?.caption || ''
+});
+export const createVideoStatus = (media, options) => ({
+    video: typeof media === 'string' ? { url: media } : media,
+    caption: options?.caption || '',
+    gifPlayback: options?.gifPlayback || false
+});
+export const createAudioStatus = (media, options) => ({
+    audio: typeof media === 'string' ? { url: media } : media,
+    ptt: true,
+    mimetype: 'audio/ogg; codecs=opus',
+    waveform: options?.waveform
+});
+export const getStatusJid = () => STATUS_BROADCAST_JID;
+/** Convenience wrappers + a `send()` that routes group vs. individual/broadcast status delivery. */
+export const StatusHelper = {
+    text: (text, backgroundColor, font) => createTextStatus({ text, backgroundColor, font }),
+    image: (buffer, caption) => createImageStatus(buffer, { caption }),
+    imageUrl: (url, caption) => createImageStatus(url, { caption }),
+    video: (buffer, caption) => createVideoStatus(buffer, { caption }),
+    videoUrl: (url, caption) => createVideoStatus(url, { caption }),
+    gif: (buffer, caption) => createVideoStatus(buffer, { caption, gifPlayback: true }),
+    voiceNote: (buffer) => createAudioStatus(buffer),
+    /**
+     * Send a status to specific JIDs (groups and/or individuals).
+     * Handles group status (groupStatus:true) and broadcast (status@broadcast) separately.
+     * Pass an empty jidList (or omit it) to broadcast to everyone.
+     */
+    send: async (sock, content, jidList = []) => {
+        const groups = jidList.filter((j) => j?.endsWith('@g.us'));
+        const individuals = jidList.filter((j) => j?.endsWith('@s.whatsapp.net') || j?.endsWith('@lid'));
+        let lastResult;
+        if (groups.length > 0) {
+            const groupContent = { ...content, groupStatus: true };
+            for (const groupJid of groups) {
+                lastResult = await sock.sendMessage(groupJid, groupContent, { messageId: generateStatusMessageId() });
+            }
+        }
+        if (individuals.length > 0 || jidList.length === 0) {
+            const result = await sock.sendMessage(STATUS_BROADCAST_JID, content, {
+                statusJidList: individuals.length > 0 ? individuals : undefined,
+                messageId: generateStatusMessageId()
+            });
+            if (!lastResult)
+                lastResult = result;
+        }
+        return lastResult;
+    }
+};
+//# sourceMappingURL=status.js.map

package/lib/Utils/stickerpack.d.ts

@@ -0,0 +1,51 @@
+import type { ILogger } from './logger.js';
+import type { WAMediaUpload } from '../Types/index.js';
+import { proto } from '../../WAProto/index.js';
+export declare const isWebPBuffer: (buffer: Buffer) => boolean;
+export declare const isAnimatedWebP: (buffer: Buffer) => boolean;
+export declare const convertToWebP: (input: WAMediaUpload) => Promise<{
+    buffer: Buffer;
+    isAnimated: boolean;
+}>;
+export declare const generateStickerPackId: () => string;
+export declare const buildStickerPackProto: (pack: {
+    name: string;
+    publisher: string;
+    packId?: string;
+    description?: string;
+}) => {
+    name: string;
+    publisher: string;
+    packId: string;
+    description: string;
+};
+export declare const STICKER_PACK_MESSAGE_TYPE: 'sticker_pack';
+export type ItsliaaaStickerInput = {
+    data: WAMediaUpload;
+    emojis?: string[];
+    accessibilityLabel?: string;
+};
+export type ItsliaaaStickerPackInput = {
+    cover: WAMediaUpload;
+    stickers: ItsliaaaStickerInput[];
+    name?: string;
+    publisher?: string;
+    description?: string;
+};
+export type ItsliaaaStickerPackOptions = {
+    logger?: ILogger;
+    upload: (filePath: string, opts: {
+        fileEncSha256B64: string;
+        mediaType: string;
+        timeoutMs?: number;
+    }) => Promise<{
+        directPath: string;
+    }>;
+    options?: RequestInit;
+    mediaUploadTimeoutMs?: number;
+    mediaCache?: {
+        get: (key: string) => Promise<Buffer | undefined>;
+        set: (key: string, value: Buffer) => void;
+    };
+};
+export declare const prepareStickerPackMessageItsliaaa: (message: ItsliaaaStickerPackInput, options: ItsliaaaStickerPackOptions) => Promise<proto.Message.IStickerPackMessage>;