plogme 1.0.0

package/lib/Utils/view-once-utils.js

@@ -0,0 +1,206 @@
+/**
+ * View-Once Message Utilities
+ * 
+ * Provides auto-detection, decryption, and handling of view-once messages.
+ * - autoVV: Automatically decrypt view-once messages and re-emit as regular messages
+ * - antiVV: Automatically detect and delete/view view-once messages
+ */
+
+import { downloadContentFromMessage } from './messages-media.js';
+import { extractMessageContent, getContentType } from './messages.js';
+
+/**
+ * Detect if a message is a view-once message
+ * @param {object} message - The message object
+ * @returns {boolean}
+ */
+export const isViewOnceMessage = (message) => {
+    if (!message) return false;
+    const content = message.message || message;
+    return !!(
+        content.viewOnceMessage ||
+        content.viewOnceMessageV2 ||
+        content.viewOnceMessageV2Extension
+    );
+};
+
+/**
+ * Extract the inner content from a view-once message wrapper
+ * @param {object} message - The message object with viewOnce wrapper
+ * @returns {object|null} The inner message content or null
+ */
+export const extractViewOnceContent = (message) => {
+    const content = message.message || message;
+    const viewOnceWrapper = 
+        content.viewOnceMessage ||
+        content.viewOnceMessageV2 ||
+        content.viewOnceMessageV2Extension;
+    
+    if (!viewOnceWrapper) return null;
+    return viewOnceWrapper.message || viewOnceWrapper;
+};
+
+/**
+ * Get the media type from a view-once message
+ * @param {object} message - The message object
+ * @returns {string|null} The media type (image, video, audio, document) or null
+ */
+export const getViewOnceMediaType = (message) => {
+    const innerContent = extractViewOnceContent(message);
+    if (!innerContent) return null;
+    
+    if (innerContent.imageMessage) return 'image';
+    if (innerContent.videoMessage) return 'video';
+    if (innerContent.audioMessage) return 'audio';
+    if (innerContent.documentMessage) return 'document';
+    if (innerContent.stickerMessage) return 'sticker';
+    
+    return null;
+};
+
+/**
+ * Get the media content from a view-once message
+ * @param {object} message - The message object
+ * @returns {object|null} The media content object with url, mediaKey, etc.
+ */
+export const getViewOnceMediaContent = (message) => {
+    const innerContent = extractViewOnceContent(message);
+    if (!innerContent) return null;
+    
+    return innerContent.imageMessage ||
+           innerContent.videoMessage ||
+           innerContent.audioMessage ||
+           innerContent.documentMessage ||
+           innerContent.stickerMessage ||
+           null;
+};
+
+/**
+ * Download and decrypt a view-once message's media content
+ * @param {object} message - The full message object
+ * @param {object} options - Options for download
+ * @returns {Promise<Buffer>} The decrypted media buffer
+ */
+export const downloadViewOnceMedia = async (message, options = {}) => {
+    const mediaContent = getViewOnceMediaContent(message);
+    if (!mediaContent) {
+        throw new Error('No media content found in view-once message');
+    }
+    
+    const mediaType = getViewOnceMediaType(message);
+    if (!mediaType) {
+        throw new Error('Could not determine media type');
+    }
+    
+    const stream = await downloadContentFromMessage(mediaContent, mediaType, options);
+    const chunks = [];
+    for await (const chunk of stream) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+};
+
+/**
+ * Create a regular message from a decrypted view-once message
+ * @param {object} originalMessage - The original view-once message
+ * @param {Buffer} mediaBuffer - The decrypted media buffer
+ * @returns {object} A regular message object with the media
+ */
+export const createRegularMessageFromViewOnce = (originalMessage, mediaBuffer) => {
+    const innerContent = extractViewOnceContent(originalMessage);
+    if (!innerContent) return null;
+    
+    const mediaType = getViewOnceMediaType(originalMessage);
+    const mediaContent = getViewOnceMediaContent(originalMessage);
+    
+    // Create a new message with the decrypted content
+    const newMessage = {
+        key: originalMessage.key,
+        messageTimestamp: originalMessage.messageTimestamp,
+        pushName: originalMessage.pushName,
+        participant: originalMessage.participant,
+        // Store the decrypted media
+        decryptedMedia: {
+            type: mediaType,
+            buffer: mediaBuffer,
+            mimeType: mediaContent?.mimetype,
+            fileName: mediaContent?.fileName,
+            caption: mediaContent?.caption,
+            fileLength: mediaContent?.fileLength,
+        },
+        // Keep original message for reference
+        originalViewOnceMessage: originalMessage.message,
+    };
+    
+    return newMessage;
+};
+
+/**
+ * Check if a message should be auto-decrypted based on configuration
+ * @param {object} message - The message object
+ * @param {object} config - Configuration object
+ * @returns {boolean}
+ */
+export const shouldAutoDecryptViewOnce = (message, config = {}) => {
+    if (!isViewOnceMessage(message)) return false;
+    
+    // Check if auto-decryption is enabled
+    if (config.autoVV === false) return false;
+    
+    // Check if it's from self (don't decrypt own messages)
+    if (message.key?.fromMe) return false;
+    
+    return true;
+};
+
+/**
+ * Check if a message should be deleted based on anti-VV configuration
+ * @param {object} message - The message object
+ * @param {object} config - Configuration object
+ * @returns {boolean}
+ */
+export const shouldDeleteViewOnce = (message, config = {}) => {
+    if (!isViewOnceMessage(message)) return false;
+    
+    // Check if anti-VV is enabled
+    if (config.antiVV === false) return false;
+    
+    // Check if it's from self (don't delete own messages)
+    if (message.key?.fromMe) return false;
+    
+    return true;
+};
+
+/**
+ * Parse view-once message info for logging/display
+ * @param {object} message - The message object
+ * @returns {object} Parsed view-once info
+ */
+export const parseViewOnceInfo = (message) => {
+    const mediaType = getViewOnceMediaType(message);
+    const mediaContent = getViewOnceMediaContent(message);
+    
+    return {
+        isViewOnce: isViewOnceMessage(message),
+        mediaType,
+        mimeType: mediaContent?.mimetype,
+        fileName: mediaContent?.fileName,
+        caption: mediaContent?.caption,
+        fileLength: mediaContent?.fileLength,
+        hasUrl: !!mediaContent?.url,
+        hasDirectPath: !!mediaContent?.directPath,
+        hasMediaKey: !!mediaContent?.mediaKey,
+    };
+};
+
+export default {
+    isViewOnceMessage,
+    extractViewOnceContent,
+    getViewOnceMediaType,
+    getViewOnceMediaContent,
+    downloadViewOnceMedia,
+    createRegularMessageFromViewOnce,
+    shouldAutoDecryptViewOnce,
+    shouldDeleteViewOnce,
+    parseViewOnceInfo,
+};

package/lib/Utils/voip-rekey.js

@@ -0,0 +1,20 @@
+import { proto } from '../../WAProto/index.js';
+
+const REKEY_TYPE_NAMES = {
+    [proto.RekeyKeyType.REKEY_KEY_AUDIO]: 'REKEY_KEY_AUDIO',
+    [proto.RekeyKeyType.REKEY_KEY_VIDEO]: 'REKEY_KEY_VIDEO',
+    [proto.RekeyKeyType.REKEY_KEY_APPDATA]: 'REKEY_KEY_APPDATA'
+};
+
+export const decodeE2eRekeyPayload = (buffer) => {
+    if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+        throw new TypeError('decodeE2eRekeyPayload: buffer must be Buffer or Uint8Array');
+    }
+    const decoded = proto.E2eRekeyPayload.decode(buffer);
+    return {
+        keys: (decoded.keys || []).map(entry => ({
+            type: REKEY_TYPE_NAMES[entry.type] ?? entry.type,
+            key: entry.key ? Buffer.from(entry.key) : Buffer.alloc(0)
+        }))
+    };
+};

package/lib/Utils/welcome-flow.js

@@ -0,0 +1,220 @@
+/**
+ * Lia@Changes [WIP]
+ * Welcome Flow — Meta Business-style startup template.
+ *
+ * Fires automatically on first message from any new contact.
+ * Sends a fully configurable greeting with interactive FAQ buttons,
+ * exactly like Meta Business account welcome templates.
+ *
+ * Tracks seen JIDs in memory + optional persistent JSON file so the
+ * greeting fires ONCE per contact — never on repeat messages.
+ *
+ * Usage:
+ *   const welcome = createWelcomeFlow(sock, config)
+ *   welcome.listen()       // start listening
+ *   welcome.stop()         // stop listening
+ *   welcome.reset(jid)     // force re-greet a contact
+ *   welcome.resetAll()     // clear all seen contacts
+ *
+ * If you use or copy this code, please credit @crysnovax/bailey.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { isJidGroup, isJidNewsletter, isJidBroadcast, jidNormalizedUser } from '../WABinary/index.js';
+import { premiumEnabled } from './integrity.js';
+import { delay } from './generics.js';
+
+// ─── Defaults ────────────────────────────────────────────────────────────────
+
+const DEFAULT_CONFIG = {
+    greeting: '👋 Welcome! How can I help you today?',
+    footer: 'Powered by @crysnovax/bailey',
+    buttonText: '📋 Choose an option',
+    faqs: [
+        { id: 'faq_1', title: '📦 Track my order',       description: 'Check order status' },
+        { id: 'faq_2', title: '💳 Billing & payments',   description: 'Payment issues & invoices' },
+        { id: 'faq_3', title: '🛠️ Technical support',    description: 'Get help with a problem' },
+        { id: 'faq_4', title: '📞 Talk to a human',      description: 'Connect with support staff' },
+    ],
+    sectionTitle: 'How can we help?',
+    typingDelayMs: 1200,        // simulate typing before greeting appears
+    persistPath: null,          // set to a file path to persist seen JIDs across restarts
+    ignoreGroups: true,         // don't fire in group chats
+    ignoreNewsletter: true,     // don't fire for newsletter messages
+    ignoreBroadcast: true,      // don't fire for broadcast messages
+    onGreet: null,              // async (jid, message) => {} — called after greeting sent
+    onFaqReply: null,           // async (jid, faqId, message) => {} — called when user picks a FAQ
+};
+
+// ─── Persistent seen-JID store ───────────────────────────────────────────────
+
+const createSeenStore = (persistPath) => {
+    const seen = new Set();
+
+    // Load from file if path given and file exists
+    if (persistPath && existsSync(persistPath)) {
+        try {
+            const data = JSON.parse(readFileSync(persistPath, 'utf8'));
+            if (Array.isArray(data)) data.forEach(jid => seen.add(jid));
+        } catch (_) {}
+    }
+
+    const save = () => {
+        if (!persistPath) return;
+        try {
+            writeFileSync(persistPath, JSON.stringify([...seen]), 'utf8');
+        } catch (_) {}
+    };
+
+    return {
+        has: (jid) => seen.has(jid),
+        add: (jid) => { seen.add(jid); save(); },
+        delete: (jid) => { seen.delete(jid); save(); },
+        clear: () => { seen.clear(); save(); }
+    };
+};
+
+// ─── Build the welcome interactive list message ───────────────────────────────
+
+const buildWelcomeMessage = (config, quotedMsg = null) => {
+    const { greeting, footer, buttonText, faqs, sectionTitle } = config;
+
+    const content = {
+        text: greeting,
+        footer,
+        buttonText,
+        sections: [
+            {
+                title: sectionTitle,
+                rows: faqs.map(faq => ({
+                    title: faq.title,
+                    description: faq.description || '',
+                    rowId: faq.id
+                }))
+            }
+        ]
+    };
+
+    if (quotedMsg) {
+        content.quoted = quotedMsg;
+    }
+
+    return content;
+};
+
+// ─── Main factory ─────────────────────────────────────────────────────────────
+
+/**
+ * createWelcomeFlow — attach a Meta Business-style welcome template to a socket.
+ *
+ * @param {object} sock    - Baileys socket
+ * @param {object} config  - Partial config — merges with DEFAULT_CONFIG
+ * @returns {{ listen, stop, reset, resetAll }}
+ */
+export const createWelcomeFlow = (sock, config = {}) => {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const seen = createSeenStore(cfg.persistPath);
+
+    // ── FAQ reply handler — called when user selects a list option ────────────
+    const handleFaqReply = async (msg) => {
+        if (typeof cfg.onFaqReply !== 'function') return;
+        const reply = msg.message?.listResponseMessage;
+        if (!reply) return;
+        const faqId = reply.singleSelectReply?.selectedRowId;
+        const jid = jidNormalizedUser(msg.key.remoteJid);
+        if (faqId) {
+            await cfg.onFaqReply(jid, faqId, msg);
+        }
+    };
+
+    // ── First-message handler ─────────────────────────────────────────────────
+    const handleMessage = async ({ messages, type }) => {
+        if (type !== 'notify') return;
+
+        for (const msg of messages) {
+            try {
+                const jid = msg.key?.remoteJid;
+                if (!jid || msg.key?.fromMe) continue;
+
+                // Skip ignored JID types
+                if (cfg.ignoreGroups && isJidGroup(jid)) continue;
+                if (cfg.ignoreNewsletter && isJidNewsletter(jid)) continue;
+                if (cfg.ignoreBroadcast && isJidBroadcast(jid)) continue;
+
+                const normalizedJid = jidNormalizedUser(jid);
+
+                // Check if it's a FAQ reply first
+                if (msg.message?.listResponseMessage) {
+                    await handleFaqReply(msg);
+                    continue;
+                }
+
+                // Already greeted this contact — skip
+                if (seen.has(normalizedJid)) continue;
+
+                // Mark as seen immediately to prevent race conditions
+                seen.add(normalizedJid);
+
+                // Simulate typing before the greeting
+                if (cfg.typingDelayMs > 0) {
+                    await sock.sendPresenceUpdate('composing', jid);
+                    await delay(cfg.typingDelayMs);
+                    await sock.sendPresenceUpdate('paused', jid);
+                }
+
+                // Send the welcome message (plain text greeting on unlicensed copies)
+                const welcomeContent = premiumEnabled(sock.config?.logger)
+                    ? buildWelcomeMessage(cfg, msg)
+                    : { text: cfg.greeting };
+                await sock.sendMessage(jid, welcomeContent);
+
+                // Fire onGreet callback if provided
+                if (typeof cfg.onGreet === 'function') {
+                    await cfg.onGreet(normalizedJid, msg).catch(() => {});
+                }
+            } catch (_) {}
+        }
+    };
+
+    // ── Public API ────────────────────────────────────────────────────────────
+    return {
+        /**
+         * Start listening for new contacts.
+         */
+        listen() {
+            sock.ev.on('messages.upsert', handleMessage);
+        },
+
+        /**
+         * Stop listening.
+         */
+        stop() {
+            sock.ev.off('messages.upsert', handleMessage);
+        },
+
+        /**
+         * Force re-greet a specific contact next time they message.
+         * @param {string} jid
+         */
+        reset(jid) {
+            seen.delete(jidNormalizedUser(jid));
+        },
+
+        /**
+         * Clear all seen contacts — everyone gets re-greeted.
+         */
+        resetAll() {
+            seen.clear();
+        },
+
+        /**
+         * Check if a contact has already been greeted.
+         * @param {string} jid
+         * @returns {boolean}
+         */
+        hasGreeted(jid) {
+            return seen.has(jidNormalizedUser(jid));
+        }
+    };
+};
+