@neelegirl/baileys 1.5.2 → 1.5.3

package/lib/Signal/lid-mapping.js

@@ -0,0 +1,184 @@
+"use strict"
+
+Object.defineProperty(exports, "__esModule", { value: true })
+
+const lru_cache_1 = require("lru-cache")
+const WABinary_1 = require("../WABinary")
+
+class LIDMappingStore {
+	constructor(keys, onWhatsAppFunc, logger) {
+		this.mappingCache = new lru_cache_1.LRUCache({
+            ttl: 7 * 24 * 60 * 60 * 1000, // 7 days
+            ttlAutopurge: true,
+            updateAgeOnGet: true
+        })
+		this.keys = keys
+		this.logger = logger
+		this.onWhatsAppFunc = onWhatsAppFunc // needed to get LID from PN if not found
+	}
+	/**
+     * Store LID-PN mapping - USER LEVEL
+     */
+    async storeLIDPNMappings(pairs) {
+        // Validate inputs
+        const pairMap = {}
+        const logger = this.logger
+        
+        for (const { lid, pn } of pairs) {
+            if (!((WABinary_1.isLidUser(lid) && WABinary_1.isJidUser(pn)) || (WABinary_1.isJidUser(lid) && WABinary_1.isLidUser(pn)))) {
+                logger.warn(`Invalid LID-PN mapping: ${lid}, ${pn}`)
+                continue
+            }
+            
+            const [lidJid, pnJid] = WABinary_1.isLidUser(lid) ? [lid, pn] : [pn, lid]
+            const lidDecoded = WABinary_1.jidDecode(lidJid)
+            const pnDecoded = WABinary_1.jidDecode(pnJid)
+            
+            if (!lidDecoded || !pnDecoded) return
+            
+            const pnUser = pnDecoded.user
+            const lidUser = lidDecoded.user
+            
+            // Check if mapping already exists (cache first, then database)
+            let existingLidUser = this.mappingCache.get(`pn:${pnUser}`)
+            
+            if (!existingLidUser) {
+                // Cache miss - check database
+                const stored = await this.keys.get('lid-mapping', [pnUser])
+                
+                existingLidUser = stored[pnUser]
+                
+                if (existingLidUser) {
+                    // Update cache with database value
+                    this.mappingCache.set(`pn:${pnUser}`, existingLidUser)
+                    this.mappingCache.set(`lid:${existingLidUser}`, pnUser)
+                }
+            }
+            
+            if (existingLidUser === lidUser) {
+                logger.debug({ pnUser, lidUser }, 'LID mapping already exists, skipping')
+                continue
+            }
+            
+            pairMap[pnUser] = lidUser
+        }
+        
+        logger.trace({ pairMap }, `Storing ${Object.keys(pairMap).length} pn mappings`)
+        
+        await this.keys.transaction(async () => {
+            for (const [pnUser, lidUser] of Object.entries(pairMap)) {
+                await this.keys.set({
+                    'lid-mapping': {
+                        [pnUser]: lidUser, // "554396160286" -> "102765716062358"
+                        [`${lidUser}_reverse`]: pnUser // "102765716062358_reverse" -> "554396160286"
+                    }
+                })
+                
+                // Update cache with both directions
+                this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                this.mappingCache.set(`lid:${lidUser}`, pnUser)
+            }
+        }, 'lid-mapping')
+    }
+    /**
+     * Get LID for PN - Returns device-specific LID based on user mapping
+     */
+    async getLIDForPN(pn) {
+        if (!WABinary_1.isJidUser(pn)) return null
+        
+        const logger = this.logger
+        const decoded = WABinary_1.jidDecode(pn)
+        
+        if (!decoded) return null
+        
+        // Check cache first for PN → LID mapping
+        const pnUser = decoded.user
+        
+        let lidUser = this.mappingCache.get(`pn:${pnUser}`)
+        
+        if (!lidUser) {
+            // Cache miss - check database
+            const stored = await this.keys.get('lid-mapping', [pnUser])
+            
+            lidUser = stored[pnUser]
+            
+            if (lidUser) {
+                // Cache the database result
+                this.mappingCache.set(`pn:${pnUser}`, lidUser)
+            }
+            
+            else {
+                // Not in database - try USync
+                logger.trace(`No LID mapping found for PN user ${pnUser}; getting from USync`)
+                
+                const { exists, lid } = (await this.onWhatsAppFunc?.(pn))?.[0] // this function already adds LIDs to mapping
+                
+                if (exists && lid) {
+                    lidUser = WABinary_1.jidDecode(lid)?.user
+                    
+                    if (lidUser) {
+                        // Cache the USync result
+                        this.mappingCache.set(`pn:${pnUser}`, lidUser)
+                    }
+                }
+                
+                else {
+                    return null
+                }
+            }
+        }
+        
+        if (typeof lidUser !== 'string' || !lidUser) {
+            logger.warn(`Invalid or empty LID user for PN ${pn}: lidUser = "${lidUser}"`)
+            return null
+        }
+        
+        // Push the PN device ID to the LID to maintain device separation
+        const pnDevice = decoded.device !== undefined ? decoded.device : 0
+        const deviceSpecificLid = `${lidUser}:${pnDevice}@lid`
+        
+        logger.trace(`getLIDForPN: ${pn} → ${deviceSpecificLid} (user mapping with device ${pnDevice})`)
+        
+        return deviceSpecificLid
+    }
+    /**
+     * Get PN for LID - USER LEVEL with device construction
+     */
+     async getPNForLID(lid) {
+        if (!WABinary_1.isLidUser(lid)) return null
+        
+        const logger = this.logger
+        const decoded = WABinary_1.jidDecode(lid)
+        
+        if (!decoded) return null
+        
+        // Check cache first for LID → PN mapping
+        const lidUser = decoded.user
+        
+        let pnUser = this.mappingCache.get(`lid:${lidUser}`)
+        
+        if (!pnUser || typeof pnUser !== 'string') {
+            // Cache miss - check database
+            const stored = await this.keys.get('lid-mapping', [`${lidUser}_reverse`]);
+            pnUser = stored[`${lidUser}_reverse`]
+            
+            if (!pnUser || typeof pnUser !== 'string') {
+                logger.trace(`No reverse mapping found for LID user: ${lidUser}`)
+                return null
+            }
+            
+            this.mappingCache.set(`lid:${lidUser}`, pnUser)
+        }
+        
+        // Construct device-specific PN JID
+        const lidDevice = decoded.device !== undefined ? decoded.device : 0
+        const pnJid = `${pnUser}:${lidDevice}@s.whatsapp.net`
+        logger.trace(`Found reverse mapping: ${lid} → ${pnJid}`)
+        
+        return pnJid
+    }
+}
+
+module.exports = {
+  LIDMappingStore
+}

package/lib/Socket/Client/abstract-socket-client.d.ts

@@ -1,15 +1,15 @@
-import { EventEmitter } from 'events';
-import { URL } from 'url';
-import { SocketConfig } from '../../Types';
-export declare abstract class AbstractSocketClient extends EventEmitter {
-    url: URL;
-    config: SocketConfig;
-    abstract get isOpen(): boolean;
-    abstract get isClosed(): boolean;
-    abstract get isClosing(): boolean;
-    abstract get isConnecting(): boolean;
-    constructor(url: URL, config: SocketConfig);
-    abstract connect(): Promise<void>;
-    abstract close(): Promise<void>;
-    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
-}
+import { EventEmitter } from 'events';
+import { URL } from 'url';
+import { SocketConfig } from '../../Types';
+export declare abstract class AbstractSocketClient extends EventEmitter {
+    url: URL;
+    config: SocketConfig;
+    abstract get isOpen(): boolean;
+    abstract get isClosed(): boolean;
+    abstract get isClosing(): boolean;
+    abstract get isConnecting(): boolean;
+    constructor(url: URL, config: SocketConfig);
+    abstract connect(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract send(str: Uint8Array | string, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/abstract-socket-client.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractSocketClient = void 0;
-const events_1 = require("events");
-class AbstractSocketClient extends events_1.EventEmitter {
-    constructor(url, config) {
-        super();
-        this.url = url;
-        this.config = config;
-        this.setMaxListeners(0);
-    }
-}
-exports.AbstractSocketClient = AbstractSocketClient;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSocketClient = void 0;
+const events_1 = require("events");
+class AbstractSocketClient extends events_1.EventEmitter {
+    constructor(url, config) {
+        super();
+        this.url = url;
+        this.config = config;
+        this.setMaxListeners(0);
+    }
+}
+exports.AbstractSocketClient = AbstractSocketClient;

package/lib/Socket/Client/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types'
-export * from './websocket'
+export * from '@neelegirl/baileys/lib/Socket/Client/types'
+export * from '@neelegirl/baileys/lib/Socket/Client/websocket'

package/lib/Socket/Client/mobile-socket-client.d.ts

@@ -1,12 +1,12 @@
-import { Socket } from 'net';
-import { AbstractSocketClient } from './abstract-socket-client';
-export declare class MobileSocketClient extends AbstractSocketClient {
-    protected socket: Socket | null;
-    get isOpen(): boolean;
-    get isClosed(): boolean;
-    get isClosing(): boolean;
-    get isConnecting(): boolean;
-    connect(): Promise<void>;
-    close(): Promise<void>;
-    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
-}
+import { Socket } from 'net';
+import { AbstractSocketClient } from './abstract-socket-client';
+export declare class MobileSocketClient extends AbstractSocketClient {
+    protected socket: Socket | null;
+    get isOpen(): boolean;
+    get isClosed(): boolean;
+    get isClosing(): boolean;
+    get isConnecting(): boolean;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    send(str: string | Uint8Array, cb?: (err?: Error) => void): boolean;
+}

package/lib/Socket/Client/mobile-socket-client.js

@@ -1,65 +1,65 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MobileSocketClient = void 0;
-const net_1 = require("net");
-const abstract_socket_client_1 = require("./abstract-socket-client");
-class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
-    constructor() {
-        super(...arguments);
-        this.socket = null;
-    }
-    get isOpen() {
-        var _a;
-        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open';
-    }
-    get isClosed() {
-        var _a;
-        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
-    }
-    get isClosing() {
-        var _a;
-        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
-    }
-    get isConnecting() {
-        var _a;
-        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening';
-    }
-    async connect() {
-        var _a;
-        if (this.socket) {
-            return;
-        }
-        if (this.config.agent) {
-            throw new Error('There are not support for proxy agent for mobile connection');
-        }
-        else {
-            this.socket = (0, net_1.connect)({
-                host: this.url.hostname,
-                port: Number(this.url.port) || 443
-            });
-        }
-        this.socket.setMaxListeners(0);
-        const events = ['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'ready', 'timeout'];
-        for (const event of events) {
-            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, (...args) => this.emit(event, ...args));
-        }
-        this.socket.on('data', (...args) => this.emit('message', ...args));
-        this.socket.on('ready', (...args) => this.emit('open', ...args));
-    }
-    async close() {
-        if (!this.socket) {
-            return;
-        }
-        return new Promise(resolve => {
-            this.socket.end(resolve);
-            this.socket = null;
-        });
-    }
-    send(str, cb) {
-        if (this.socket === null) {
-            return false;
-        }
-        return this.socket.write(str, undefined, cb);
-    }
-}
-exports.MobileSocketClient = MobileSocketClient;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileSocketClient = void 0;
+const net_1 = require("net");
+const abstract_socket_client_1 = require("./abstract-socket-client");
+class MobileSocketClient extends abstract_socket_client_1.AbstractSocketClient {
+    constructor() {
+        super(...arguments);
+        this.socket = null;
+    }
+    get isOpen() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'open';
+    }
+    get isClosed() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isClosing() {
+        var _a;
+        return this.socket === null || ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'closed';
+    }
+    get isConnecting() {
+        var _a;
+        return ((_a = this.socket) === null || _a === void 0 ? void 0 : _a.readyState) === 'opening';
+    }
+    async connect() {
+        var _a;
+        if (this.socket) {
+            return;
+        }
+        if (this.config.agent) {
+            throw new Error('There are not support for proxy agent for mobile connection');
+        }
+        else {
+            this.socket = (0, net_1.connect)({
+                host: this.url.hostname,
+                port: Number(this.url.port) || 443
+            });
+        }
+        this.socket.setMaxListeners(0);
+        const events = ['close', 'connect', 'data', 'drain', 'end', 'error', 'lookup', 'ready', 'timeout'];
+        for (const event of events) {
+            (_a = this.socket) === null || _a === void 0 ? void 0 : _a.on(event, (...args) => this.emit(event, ...args));
+        }
+        this.socket.on('data', (...args) => this.emit('message', ...args));
+        this.socket.on('ready', (...args) => this.emit('open', ...args));
+    }
+    async close() {
+        if (!this.socket) {
+            return;
+        }
+        return new Promise(resolve => {
+            this.socket.end(resolve);
+            this.socket = null;
+        });
+    }
+    send(str, cb) {
+        if (this.socket === null) {
+            return false;
+        }
+        return this.socket.write(str, undefined, cb);
+    }
+}
+exports.MobileSocketClient = MobileSocketClient;

package/lib/Socket/Client/types.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from 'events'
 import { URL } from 'url'
-import { SocketConfig } from '../../Types'
+import { SocketConfig } from '@neelegirl/baileys/lib/Types'
 
 export declare abstract class AbstractSocketClient extends EventEmitter {
     url: URL

package/lib/Socket/Client/websocket.d.ts

@@ -1,5 +1,5 @@
 import WebSocket from 'ws'
-import { AbstractSocketClient } from './types'
+import { AbstractSocketClient } from '@neelegirl/baileys/lib/Socket/Client/types'
 
 export declare class WebSocketClient extends AbstractSocketClient {
     protected socket: WebSocket | null

package/lib/Socket/business.d.ts

@@ -1,4 +1,4 @@
-import { GetCatalogOptions, ProductCreate, ProductUpdate, SocketConfig } from '../Types'
+import { GetCatalogOptions, ProductCreate, ProductUpdate, SocketConfig, UpdateBussinesProfileProps } from '../Types'
 import { BinaryNode } from '../WABinary'
 
 export declare const makeBusinessSocket: (config: SocketConfig) => {
@@ -16,13 +16,15 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         deleted: number
     }>
     productUpdate: (productId: string, update: ProductUpdate) => Promise<import("../Types").Product>
+    updateBussinesProfile: (args: UpdateBussinesProfileProps) => Promise<any>
+    updateCoverPhoto: (photo: import("../Types").WAMediaUpload) => Promise<number>
+    removeCoverPhoto: (id: string) => Promise<any>
     sendMessageAck: ({ tag, attrs, content }: BinaryNode, errorCode?: number | undefined) => Promise<void>
     sendRetryRequest: (node: BinaryNode, forceIncludeKeys?: boolean) => Promise<void>
     offerCall: (toJid: string, isVideo?: boolean) => Promise<{
         id: any
         to: string
     }>
-    nodelogger: (node: BinaryNode) => Promise<void>
     rejectCall: (callId: string, callFrom: string) => Promise<void>
     fetchMessageHistory: (count: number, oldestMsgKey: import("../Types").WAProto.IMessageKey, oldestMsgTimestamp: number | import("long").Long) => Promise<string>
     requestPlaceholderResend: (messageKey: import("../Types").WAProto.IMessageKey) => Promise<string | undefined>
@@ -119,10 +121,6 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
     	lid: string
         id: string
     }[] | undefined>
-    onWhatsApp: (...jids: string[]) => Promise<{
-        jid: string
-        exists: unknown
-    }[] | undefined>
     fetchBlocklist: () => Promise<string[]>
     fetchStatus: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>
     fetchDisappearingDuration: (...jids: string[]) => Promise<import("..").USyncQueryResultList[] | undefined>
@@ -154,6 +152,8 @@ export declare const makeBusinessSocket: (config: SocketConfig) => {
         id: string
         fromMe?: boolean | undefined
     }[], star: boolean) => Promise<void>
+    addOrEditQuickReply: (quickReply: import("../Types/Bussines").QuickReplyAction) => Promise<void>
+    removeQuickReply: (timestamp: string) => Promise<void>
     executeUSyncQuery: (usyncQuery: import("..").USyncQuery) => Promise<import("..").USyncQueryResult | undefined>
     type: "md"
     ws: import("./Client").WebSocketClient