@violetix/baileys 0.5.5 → 0.6.0

package/lib/Utils/connection-manager.js

@@ -1,258 +0,0 @@
-import { EventEmitter } from 'events';
-import { Agent } from 'https';
-import { DisconnectReason } from '../Types/index.js';
-/**
- * Supervises a fleet of sockets inside one process.
- *
- * The library builds and tears down one socket; it deliberately does not reconnect, because only
- * the host knows which auth state to reload. With hundreds of accounts that leaves three fleet-level
- * problems to whoever wires them up, and getting them wrong is what makes accounts drop:
- *
- *  - every socket reconnecting the moment the server closes it, all at once, which hammers the
- *    endpoint and gets throttled or banned (this is what `baseDelayMs` + jitter + stagger fix);
- *  - a permanently dead session (401/403/411/440) being reconnected forever, which is the
- *    documented path to a ban (this is what DEAD_REASONS stops);
- *  - unbounded parallel connects, which exhausts FDs and TLS handshakes on boot.
- *
- * Events are deliberately never named 'error': EventEmitter throws on an unhandled 'error', and one
- * dead session must not take the process down.
- *
- * ponytail: supervision only. Every socket still shares one event loop, so this bounds reconnect
- * storms and socket leaks but not CPU-bound crypto; past a few hundred accounts, shard by process.
- */
-const DEAD_REASONS = new Set([
-    DisconnectReason.loggedOut,
-    DisconnectReason.forbidden,
-    DisconnectReason.multideviceMismatch,
-    DisconnectReason.badSession,
-    DisconnectReason.connectionReplaced
-]);
-export class ConnectionManager extends EventEmitter {
-    #create;
-    #sessions = new Map();
-    #maxConcurrent;
-    #active = 0;
-    #waiters = [];
-    #reconnect;
-    #baseDelayMs;
-    #maxDelayMs;
-    #maxAttempts;
-    #staggerMs;
-    #logger;
-    #started = false;
-    constructor({ create, sessions = [], maxConcurrent = 8, reconnect = true, baseDelayMs = 2000, maxDelayMs = 60000, maxAttempts = Infinity, staggerMs = 250, logger = console }) {
-        super();
-        if (typeof create !== 'function') {
-            throw new TypeError('ConnectionManager needs a create(session) function');
-        }
-        for (const session of sessions) {
-            if (!session?.id) {
-                throw new TypeError('every session needs an id');
-            }
-            if (this.#sessions.has(session.id)) {
-                throw new TypeError(`duplicate session id: ${session.id}`);
-            }
-            this.#sessions.set(session.id, {
-                id: session.id,
-                session,
-                sock: null,
-                state: 'idle',
-                attempts: 0,
-                generation: 0,
-                timer: null,
-                stopped: false,
-                lastError: null
-            });
-        }
-        this.#create = create;
-        this.#maxConcurrent = Math.max(1, maxConcurrent);
-        this.#reconnect = reconnect;
-        this.#baseDelayMs = baseDelayMs;
-        this.#maxDelayMs = maxDelayMs;
-        this.#maxAttempts = maxAttempts;
-        this.#staggerMs = staggerMs;
-        this.#logger = logger;
-    }
-    /** Connect every session, staggered so boot does not fire them all in one tick. */
-    start() {
-        if (this.#started) {
-            return this.stats();
-        }
-        this.#started = true;
-        let index = 0;
-        for (const rec of this.#sessions.values()) {
-            const delayMs = this.#staggerMs * index++;
-            if (!delayMs) {
-                void this.#connect(rec);
-            }
-            else {
-                rec.timer = setTimeout(() => {
-                    rec.timer = null;
-                    void this.#connect(rec);
-                }, delayMs);
-            }
-        }
-        return this.stats();
-    }
-    get(id) {
-        return this.#sessions.get(id)?.sock ?? null;
-    }
-    /** Stop one session for good. A close event that arrives afterwards is ignored. */
-    stop(id) {
-        const rec = this.#sessions.get(id);
-        if (!rec) {
-            return false;
-        }
-        this.#stop(rec);
-        return true;
-    }
-    /** Stop everything and wait for each socket's teardown. */
-    async close() {
-        const pending = [];
-        for (const rec of this.#sessions.values()) {
-            const sock = this.#stop(rec);
-            if (sock) {
-                pending.push(Promise.resolve(sock.end?.(undefined)).catch(() => { }));
-            }
-        }
-        await Promise.all(pending);
-        this.#started = false;
-        this.removeAllListeners();
-    }
-    stats() {
-        const counts = { total: 0, idle: 0, connecting: 0, open: 0, reconnecting: 0, closed: 0, failed: 0 };
-        for (const rec of this.#sessions.values()) {
-            counts.total += 1;
-            counts[rec.state] += 1;
-        }
-        counts.activeConnects = this.#active;
-        counts.queuedConnects = this.#waiters.length;
-        return counts;
-    }
-    #stop(rec) {
-        rec.stopped = true;
-        rec.generation += 1;
-        if (rec.timer) {
-            clearTimeout(rec.timer);
-            rec.timer = null;
-        }
-        const sock = rec.sock;
-        rec.sock = null;
-        rec.state = 'closed';
-        return sock;
-    }
-    async #connect(rec) {
-        if (rec.stopped) {
-            return;
-        }
-        if (rec.timer) {
-            clearTimeout(rec.timer);
-            rec.timer = null;
-        }
-        const generation = ++rec.generation;
-        rec.state = 'connecting';
-        await this.#acquire();
-        let sock;
-        try {
-            sock = await this.#create(rec.session);
-        }
-        catch (err) {
-            this.#release();
-            rec.lastError = err;
-            this.emit('session-error', { id: rec.id, error: err });
-            this.#scheduleReconnect(rec, err);
-            return;
-        }
-        this.#release();
-        // stop() or a newer connect won the race while this one was being created
-        if (rec.stopped || generation !== rec.generation) {
-            void sock?.end?.(undefined);
-            return;
-        }
-        rec.sock = sock;
-        try {
-            sock.ev.on('connection.update', update => this.#onUpdate(rec, sock, update));
-        }
-        catch (err) {
-            rec.lastError = err;
-            this.emit('session-error', { id: rec.id, error: err });
-            this.#scheduleReconnect(rec, err);
-        }
-    }
-    #onUpdate(rec, sock, update) {
-        // a socket that was already replaced must not drive this session any more
-        if (rec.sock !== sock) {
-            return;
-        }
-        const { connection, lastDisconnect, qr } = update;
-        if (qr) {
-            this.emit('qr', { id: rec.id, qr });
-        }
-        if (connection === 'open') {
-            rec.state = 'open';
-            rec.attempts = 0;
-            rec.lastError = null;
-            this.emit('open', { id: rec.id, sock });
-        }
-        else if (connection === 'close') {
-            const error = lastDisconnect?.error;
-            rec.sock = null;
-            rec.lastError = error;
-            this.emit('close', { id: rec.id, error, statusCode: error?.output?.statusCode });
-            this.#scheduleReconnect(rec, error);
-        }
-    }
-    #scheduleReconnect(rec, error) {
-        if (!this.#reconnect || rec.stopped) {
-            rec.state = 'closed';
-            return;
-        }
-        const statusCode = error?.output?.statusCode;
-        if (DEAD_REASONS.has(statusCode) || rec.attempts >= this.#maxAttempts) {
-            rec.state = 'failed';
-            this.#logger?.warn?.({ id: rec.id, statusCode, attempts: rec.attempts }, 'session will not be reconnected');
-            this.emit('dead', { id: rec.id, error, statusCode });
-            return;
-        }
-        // the server asks for a restart on 515; backing off there only delays the reconnect
-        const immediate = statusCode === DisconnectReason.restartRequired;
-        const backoff = Math.min(this.#maxDelayMs, this.#baseDelayMs * 2 ** rec.attempts);
-        const delayMs = immediate ? 0 : Math.round(backoff * (0.75 + Math.random() * 0.5));
-        rec.attempts += 1;
-        rec.state = 'reconnecting';
-        this.emit('reconnect', { id: rec.id, attempt: rec.attempts, delayMs, statusCode });
-        rec.timer = setTimeout(() => {
-            rec.timer = null;
-            void this.#connect(rec);
-        }, delayMs);
-    }
-    #acquire() {
-        if (this.#active < this.#maxConcurrent) {
-            this.#active += 1;
-            return Promise.resolve();
-        }
-        return new Promise(resolve => this.#waiters.push(resolve));
-    }
-    #release() {
-        const next = this.#waiters.shift();
-        if (next) {
-            // hand the slot over without touching the counter
-            next();
-        }
-        else {
-            this.#active -= 1;
-        }
-    }
-}
-export const makeConnectionManager = (options) => new ConnectionManager(options);
-/**
- * One TLS agent shared by every socket in the fleet. `ws` opens one TCP connection per socket, so
- * this does not multiplex them, but it does keep the agent, its DNS cache and its free-socket pool
- * shared instead of one per account.
- */
-export const makeWssAgent = ({ maxSockets = 256, keepAlive = true, keepAliveMsecs = 30000 } = {}) => new Agent({
-    keepAlive,
-    keepAliveMsecs,
-    maxSockets,
-    maxFreeSockets: Math.min(32, maxSockets)
-});

package/lib/Utils/ignore-key.d.ts

@@ -1,51 +0,0 @@
-import type { BinaryNode } from '../WABinary/index.js';
-export declare const IGNORE_KEY_KINDS: readonly ['message', 'receipt', 'notification', 'presence', 'chatstate', 'call'];
-export type WaIgnoreKeyKind = (typeof IGNORE_KEY_KINDS)[number];
-export type WaIgnoreKeyContext = {
-    /** Stanza tag. */
-    kind: WaIgnoreKeyKind;
-    /** Deviceless chat JID; userless `from` values are kept verbatim. */
-    remoteJid: string | null;
-    /** Resolved against the account's own PN and LID. */
-    fromMe: boolean;
-    /** Stanza id. */
-    id: string | undefined;
-    /** Author in groups / broadcasts; `null` otherwise. */
-    participant: string | null;
-};
-export type WaIgnoreKey = {
-    /** Chat JID; array entries OR. Alt `sender_pn` / `sender_lid` attrs are matched too. */
-    remoteJid?: string | readonly string[];
-    /** Whether the stanza was sent by this account. */
-    fromMe?: boolean;
-    /** Stanza id. */
-    id?: string;
-    /** Author in groups / broadcasts. Alt forms are matched too. */
-    participant?: string;
-    /** Restrict to specific tags. Default: all six. */
-    only?: readonly WaIgnoreKeyKind[];
-};
-export type WaIgnoreKeyPredicate = (ctx: WaIgnoreKeyContext) => boolean;
-export type WaIgnoreKeyInput = WaIgnoreKey | WaIgnoreKeyPredicate;
-export type WaIgnoreKeyEntry = {
-    remoteJid?: string[];
-    participant?: string;
-    fromMe?: boolean;
-    id?: string;
-    only?: readonly WaIgnoreKeyKind[];
-    predicate?: WaIgnoreKeyPredicate;
-};
-export declare const isIgnorableKind: (tag: string) => boolean;
-export declare const normalizeIgnoreKey: (input: WaIgnoreKeyInput) => WaIgnoreKeyEntry;
-export declare const buildIgnoreContext: (node: BinaryNode, meId?: string, meLid?: string) => WaIgnoreKeyContext;
-export declare const matchesIgnoreKey: (entry: WaIgnoreKeyEntry, ctx: WaIgnoreKeyContext, node: BinaryNode) => boolean;
-export declare const ignoredStanzaNeedsAck: (tag: string) => boolean;
-export declare const makeIgnoreKeyRegistry: (deps: {
-    getMeId: () => string | undefined;
-    getMeLid: () => string | undefined;
-    logger?: any;
-}) => {
-    register: (input: WaIgnoreKeyInput) => () => void;
-    shouldDrop: (node: BinaryNode) => boolean;
-    readonly size: number;
-};

package/lib/Utils/ignore-key.js

@@ -1,176 +0,0 @@
-import { areJidsSameUser, jidDecode, jidEncode } from '../WABinary/index.js';
-/**
- * Stanza tags a filter may drop. Stream control, `iq` replies and the auth-critical
- * `success` / `failure` tags are deliberately absent so the connection flow stays intact.
- */
-export const IGNORE_KEY_KINDS = ['message', 'receipt', 'notification', 'presence', 'chatstate', 'call'];
-const IGNORE_KEY_KIND_SET = new Set(IGNORE_KEY_KINDS);
-/**
- * Kinds the server re-delivers until acked. Dropping one without an ack makes the server
- * retry it forever, so the filter acks on the handler's behalf. Presence and chat-state are
- * fire-and-forget and must not be acked.
- */
-const ACKED_KINDS = new Set(['message', 'receipt', 'notification', 'call']);
-/**
- * A JID arrives in whichever namespace the sender used, and the alt attributes carry the other
- * form. Matching every one of these lets a filter written with a phone number also catch the
- * LID-addressed copy of the same stanza (and vice versa).
- */
-const REMOTE_JID_ATTRS = ['from', 'sender_pn', 'sender_lid'];
-const PARTICIPANT_ATTRS = ['participant', 'participant_pn', 'participant_lid'];
-const DESCRIPTOR_FIELDS = ['remoteJid', 'fromMe', 'id', 'participant'];
-/** Deviceless user-form JID. Userless values (e.g. `s.whatsapp.net`) are kept verbatim. */
-const stripDevice = (jid) => {
-    if (!jid) {
-        return null;
-    }
-    const decoded = jidDecode(jid);
-    if (!decoded?.user) {
-        return jid;
-    }
-    return jidEncode(decoded.user, decoded.server);
-};
-/**
- * Compares deviceless JIDs as whole strings rather than by user part. `areJidsSameUser` ignores
- * the server, so it reports `5551234@s.whatsapp.net` and `5551234@lid` as the same user — two
- * unrelated accounts that would then share a filter. Server equality is required here; the
- * PN/LID crossover is handled by the alt attributes instead.
- */
-const sameJid = (a, b) => {
-    if (!a || !b) {
-        return false;
-    }
-    return stripDevice(a) === stripDevice(b);
-};
-export const isIgnorableKind = (tag) => IGNORE_KEY_KIND_SET.has(tag);
-/** Validates a descriptor or predicate and freezes it into an internal entry. */
-export const normalizeIgnoreKey = (input) => {
-    if (typeof input === 'function') {
-        return { predicate: input };
-    }
-    if (!input || typeof input !== 'object' || Array.isArray(input)) {
-        throw new Error('ignoreKey expects a descriptor object or a predicate function');
-    }
-    if (!DESCRIPTOR_FIELDS.some(field => input[field] !== undefined)) {
-        throw new Error('ignoreKey descriptor needs at least one of remoteJid, fromMe, id, participant');
-    }
-    const entry = {};
-    if (input.remoteJid !== undefined) {
-        const jids = (Array.isArray(input.remoteJid) ? input.remoteJid : [input.remoteJid]).filter(Boolean);
-        if (!jids.length) {
-            throw new Error('ignoreKey remoteJid cannot be empty');
-        }
-        entry.remoteJid = jids;
-    }
-    if (input.participant !== undefined) {
-        if (typeof input.participant !== 'string' || !input.participant) {
-            throw new Error('ignoreKey participant must be a non-empty jid');
-        }
-        entry.participant = input.participant;
-    }
-    if (input.fromMe !== undefined) {
-        entry.fromMe = !!input.fromMe;
-    }
-    if (input.id !== undefined) {
-        if (typeof input.id !== 'string' || !input.id) {
-            throw new Error('ignoreKey id must be a non-empty string');
-        }
-        entry.id = input.id;
-    }
-    if (input.only !== undefined) {
-        const only = Array.isArray(input.only) ? input.only : [input.only];
-        if (!only.length) {
-            throw new Error('ignoreKey only cannot be empty');
-        }
-        const unknown = only.filter(kind => !IGNORE_KEY_KIND_SET.has(kind));
-        if (unknown.length) {
-            throw new Error(`ignoreKey only has unknown kinds: ${unknown.join(', ')}`);
-        }
-        entry.only = only;
-    }
-    return entry;
-};
-/**
- * Parses the wire node into the shape filters match on, so a predicate never has to walk a
- * BinaryNode. `remoteJid` and `participant` are device-stripped to line up with the
- * `event.key.remoteJid` a handler would see.
- */
-export const buildIgnoreContext = (node, meId, meLid) => {
-    const attrs = node.attrs || {};
-    const author = attrs.participant || attrs.participant_pn || attrs.participant_lid || attrs.from;
-    const fromMe = !!author && ((!!meId && areJidsSameUser(author, meId)) || (!!meLid && areJidsSameUser(author, meLid)));
-    return {
-        kind: node.tag,
-        // a 1:1 message sent from another of our devices arrives from us, with the chat in `recipient`
-        remoteJid: stripDevice(fromMe && attrs.recipient ? attrs.recipient : attrs.from),
-        fromMe,
-        id: attrs.id,
-        participant: stripDevice(attrs.participant || attrs.participant_pn || attrs.participant_lid)
-    };
-};
-export const matchesIgnoreKey = (entry, ctx, node) => {
-    if (entry.predicate) {
-        return !!entry.predicate(ctx);
-    }
-    if (entry.only && !entry.only.includes(ctx.kind)) {
-        return false;
-    }
-    if (entry.id !== undefined && entry.id !== ctx.id) {
-        return false;
-    }
-    if (entry.fromMe !== undefined && entry.fromMe !== ctx.fromMe) {
-        return false;
-    }
-    const attrs = node.attrs || {};
-    const remoteAttrs = ctx.fromMe && attrs.recipient ? ['recipient', ...REMOTE_JID_ATTRS] : REMOTE_JID_ATTRS;
-    if (entry.remoteJid && !entry.remoteJid.some(wanted => remoteAttrs.some(attr => sameJid(attrs[attr], wanted)))) {
-        return false;
-    }
-    if (entry.participant && !PARTICIPANT_ATTRS.some(attr => sameJid(attrs[attr], entry.participant))) {
-        return false;
-    }
-    return true;
-};
-export const ignoredStanzaNeedsAck = (tag) => ACKED_KINDS.has(tag);
-/**
- * Holds the registered filters and answers the one question the socket asks per stanza.
- *
- * `category='peer'` traffic from this account's own devices is never dropped: those stanzas
- * carry app-state key shares, history sync and PDO responses between the account's devices, so
- * the common `{ fromMe: true }` filter would otherwise swallow the app-state key share and leave
- * the collections blocked on a key they re-request on every sync. The exemption only applies
- * when the sender really is this account — resolved against both `meJid` and `meLid` — so a
- * foreign stanza cannot dodge a filter by stamping the attribute.
- */
-export const makeIgnoreKeyRegistry = ({ getMeId, getMeLid, logger }) => {
-    const entries = new Set();
-    const register = (input) => {
-        const entry = normalizeIgnoreKey(input);
-        entries.add(entry);
-        return () => {
-            entries.delete(entry);
-        };
-    };
-    const shouldDrop = (node) => {
-        if (!entries.size || !isIgnorableKind(node.tag)) {
-            return false;
-        }
-        const ctx = buildIgnoreContext(node, getMeId(), getMeLid());
-        if (ctx.fromMe && node.attrs?.category === 'peer') {
-            return false;
-        }
-        for (const entry of entries) {
-            try {
-                if (matchesIgnoreKey(entry, ctx, node)) {
-                    return true;
-                }
-            }
-            catch (err) {
-                // A throwing predicate must not take the stanza with it; the stanza stays.
-                logger?.error({ err, kind: ctx.kind, id: ctx.id }, 'ignoreKey filter threw, keeping stanza');
-            }
-        }
-        return false;
-    };
-    return { register, shouldDrop, get size() { return entries.size; } };
-};