botforje 0.0.1

package/dist/whatsapp/client.js

@@ -0,0 +1,293 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppInitializer = exports.WhatsAppChannel = void 0;
+exports.getWwebCacheDir = getWwebCacheDir;
+exports.setGlobalConfig = setGlobalConfig;
+exports.getPuppeteerOptions = getPuppeteerOptions;
+exports.getClientOptions = getClientOptions;
+const whatsapp_web_js_1 = require("whatsapp-web.js");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const whatsapp_1 = require("./whatsapp");
+const logger_1 = require("../helpers/logger");
+function getWwebCacheDir() {
+    const cacheHome = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+    return path.join(cacheHome, 'botforje');
+}
+let globalConfig;
+function setGlobalConfig(config) {
+    globalConfig = config;
+}
+function getPuppeteerOptions() {
+    const chromiumPath = globalConfig?.chromium_path || '/usr/bin/chromium';
+    return {
+        executablePath: chromiumPath,
+        headless: true,
+        args: [
+            '--no-sandbox',
+            '--disable-setuid-sandbox',
+            '--disable-dev-shm-usage',
+            '--disable-accelerated-2d-canvas',
+            '--no-first-run',
+            '--no-zygote',
+            '--disable-gpu',
+            '--disable-software-rasterizer',
+            '--disable-extensions',
+            '--disable-background-networking',
+            '--disable-default-apps',
+            '--disable-sync',
+            '--metrics-recording-only',
+            '--mute-audio',
+        ],
+    };
+}
+function getClientOptions(clientId) {
+    return {
+        authStrategy: new whatsapp_web_js_1.LocalAuth({
+            clientId: clientId,
+            dataPath: path.join(getWwebCacheDir(), '.wwebjs_auth'),
+        }),
+        puppeteer: getPuppeteerOptions(),
+        webVersionCache: {
+            type: 'local',
+            path: path.join(getWwebCacheDir(), '.wwebjs_cache'),
+        },
+    };
+}
+class WhatsAppChannel {
+    constructor(clientId) {
+        this.messageHandlers = [];
+        this.readyHandlers = [];
+        this.disconnectedHandlers = [];
+        this.authFailureHandlers = [];
+        this.connectionErrorHandlers = [];
+        this.stateChangeHandlers = [];
+        this.authRequiredHandlers = [];
+        this.isConnected = false;
+        this.channelId = clientId;
+        this.client = new whatsapp_web_js_1.Client(getClientOptions(clientId));
+        this.setupEventListeners();
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    setupEventListeners() {
+        this.client.on('ready', () => {
+            this.isConnected = true;
+            if (this.client.info?.wid) {
+                this.phoneNumber = (0, whatsapp_1.widToPhoneNumber)(this.client.info.wid._serialized);
+            }
+            this.readyHandlers.forEach(handler => handler());
+        });
+        this.client.on('message', async (msg) => {
+            const domainMessage = (0, whatsapp_1.toDomainMessage)(msg);
+            if (msg.from.includes('@lid')) {
+                try {
+                    const contact = await msg.getContact();
+                    const result = await this.client.getContactLidAndPhone([contact.id._serialized]);
+                    if (result && result[0]?.pn) {
+                        domainMessage.from = (0, whatsapp_1.normalizePhoneNumber)(result[0].pn);
+                    }
+                    domainMessage.senderName = contact.pushname || contact.name || contact.shortName;
+                }
+                catch (err) {
+                    this.logger.debug(`LID resolution failed: ${err.message}`);
+                }
+            }
+            else {
+                try {
+                    const contact = await msg.getContact();
+                    domainMessage.senderName = contact.pushname || contact.name || contact.shortName;
+                }
+                catch (err) {
+                    this.logger.debug(`Contact resolution failed: ${err.message}`);
+                }
+            }
+            this.messageHandlers.forEach(handler => handler(domainMessage));
+        });
+        this.client.on('disconnected', reason => {
+            this.isConnected = false;
+            this.disconnectedHandlers.forEach(handler => handler(reason));
+        });
+        this.client.on('qr', (qr) => {
+            this.logger.info(`qr auth required for channel ${this.channelId}`);
+            const info = {
+                channelId: this.channelId,
+                method: 'qr',
+                data: qr,
+            };
+            this.authRequiredHandlers.forEach(handler => handler(info));
+        });
+        this.client.on('auth_failure', (msg) => {
+            const error = new Error(typeof msg === 'string' ? msg : 'Authentication failed');
+            this.authFailureHandlers.forEach(handler => handler(error));
+        });
+        this.client.on('connection_error', (error) => {
+            this.connectionErrorHandlers.forEach(handler => handler(error));
+        });
+        this.client.on('change_state', state => {
+            const domainState = this.mapWhatsAppState(state);
+            this.stateChangeHandlers.forEach(handler => handler(domainState));
+        });
+    }
+    mapWhatsAppState(state) {
+        switch (state) {
+            case whatsapp_1.WhatsAppConnectionState.CONNECTED:
+                return 'connected';
+            case whatsapp_1.WhatsAppConnectionState.CONNECTING:
+                return 'connecting';
+            case whatsapp_1.WhatsAppConnectionState.DISCONNECTED:
+                return 'disconnected';
+            case whatsapp_1.WhatsAppConnectionState.AUTHENTICATING:
+                return 'authenticating';
+            default:
+                return 'unknown';
+        }
+    }
+    async connect() {
+        if (this.isConnected) {
+            throw new Error('Channel is already connected');
+        }
+        await this.client.initialize();
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.destroy();
+            this.isConnected = false;
+        }
+    }
+    async send(message) {
+        if (!this.isConnected) {
+            throw new Error('Channel is not connected');
+        }
+        const whatsappMsg = (0, whatsapp_1.toWhatsAppFormat)(message);
+        this.logger.debug(`WhatsApp send options: ${JSON.stringify(whatsappMsg.options, null, 2)}`);
+        if (whatsappMsg.options?.type === 'location') {
+            const { latitude, longitude, name, address, url, description } = whatsappMsg.options;
+            const locationInstance = new whatsapp_web_js_1.Location(latitude, longitude, { name, address, url, description });
+            const { type: _t, latitude: _la, longitude: _lo, name: _n, address: _a, url: _u, description: _d, ...rest } = whatsappMsg.options;
+            const result = await this.client.sendMessage(whatsappMsg.to, locationInstance, rest);
+            return result.id._serialized;
+        }
+        const result = await this.client.sendMessage(whatsappMsg.to, whatsappMsg.content, whatsappMsg.options);
+        return result.id._serialized;
+    }
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    onReady(handler) {
+        if (this.isConnected) {
+            handler();
+        }
+        else {
+            this.readyHandlers.push(handler);
+        }
+    }
+    onDisconnected(handler) {
+        this.disconnectedHandlers.push(handler);
+    }
+    onAuthFailure(handler) {
+        this.authFailureHandlers.push(handler);
+    }
+    onConnectionError(handler) {
+        this.connectionErrorHandlers.push(handler);
+    }
+    onStateChange(handler) {
+        this.stateChangeHandlers.push(handler);
+    }
+    onAuthRequired(handler) {
+        this.authRequiredHandlers.push(handler);
+    }
+    getPhone() {
+        return this.phoneNumber;
+    }
+}
+exports.WhatsAppChannel = WhatsAppChannel;
+class WhatsAppInitializer {
+    constructor(clientId) {
+        this.authSuccessFired = false;
+        this.client = new whatsapp_web_js_1.Client(getClientOptions(clientId));
+        this.setupEventListeners();
+    }
+    setupEventListeners() {
+        this.client.on('qr', (qr) => {
+            if (this.qrHandler) {
+                this.qrHandler(qr);
+            }
+        });
+        this.client.on('ready', async () => {
+            if (this.authSuccessFired)
+                return;
+            this.authSuccessFired = true;
+            try {
+                const info = this.client.info;
+                const phoneNumber = (0, whatsapp_1.widToPhoneNumber)(info.wid._serialized);
+                if (this.successHandler) {
+                    this.successHandler(phoneNumber);
+                }
+            }
+            catch (error) {
+                if (this.failureHandler) {
+                    this.failureHandler(new Error('Failed to get phone number after authentication'));
+                }
+            }
+        });
+        this.client.on('auth_failure', (error) => {
+            if (this.failureHandler) {
+                const errorObj = error instanceof Error ? error : new Error(String(error));
+                this.failureHandler(errorObj);
+            }
+        });
+    }
+    async initialize() {
+        await this.client.initialize();
+    }
+    async destroy() {
+        if (this.client) {
+            await this.client.destroy();
+        }
+    }
+    onQRCode(handler) {
+        this.qrHandler = handler;
+    }
+    onAuthSuccess(handler) {
+        this.successHandler = handler;
+    }
+    onAuthFailure(handler) {
+        this.failureHandler = handler;
+    }
+}
+exports.WhatsAppInitializer = WhatsAppInitializer;

package/dist/whatsapp/session.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const client_1 = require("./client");
+const logger_1 = require("../helpers/logger");
+class SessionManager {
+    constructor() {
+        this.channels = new Map();
+        this.states = new Map();
+        this.qrData = new Map();
+        this.phoneNumbers = new Map();
+        this.errors = new Map();
+        this.eventListeners = new Map();
+        this.readyCallbacks = new Map();
+    }
+    get logger() {
+        return (0, logger_1.getLogger)();
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new SessionManager();
+        }
+        return this.instance;
+    }
+    createChannel(id) {
+        if (this.channels.has(id)) {
+            throw new Error(`Channel already exists for ID ${id}`);
+        }
+        const channel = new client_1.WhatsAppChannel(id);
+        this.channels.set(id, channel);
+        this.states.set(id, 'pending');
+        return channel;
+    }
+    getChannel(id) {
+        return this.channels.get(id);
+    }
+    getAllChannels() {
+        return new Map(this.channels);
+    }
+    async removeChannel(id) {
+        const channel = this.channels.get(id);
+        if (channel) {
+            await channel.disconnect();
+            this.channels.delete(id);
+            this.states.delete(id);
+            this.qrData.delete(id);
+            this.phoneNumbers.delete(id);
+            this.errors.delete(id);
+            this.eventListeners.delete(id);
+            this.readyCallbacks.delete(id);
+        }
+    }
+    async removeAllChannels() {
+        const ids = Array.from(this.channels.keys());
+        await Promise.all(ids.map(id => this.removeChannel(id)));
+    }
+    getChannelCount() {
+        return this.channels.size;
+    }
+    hasChannel(id) {
+        return this.channels.has(id);
+    }
+    getSessionInfo(id) {
+        if (!this.channels.has(id))
+            return undefined;
+        return {
+            state: this.states.get(id) || 'pending',
+            phone: this.phoneNumbers.get(id),
+            lastQR: this.qrData.get(id),
+            error: this.errors.get(id),
+        };
+    }
+    getAllSessions() {
+        const result = new Map();
+        for (const id of this.channels.keys()) {
+            const info = this.getSessionInfo(id);
+            if (info)
+                result.set(id, info);
+        }
+        return result;
+    }
+    async registerSession(id) {
+        if (this.channels.has(id)) {
+            const state = this.states.get(id);
+            if (state === 'connected') {
+                throw new Error(`Session "${id}" is already authenticated`);
+            }
+            await this.removeChannel(id);
+        }
+        this.logger.info(`Registering session: ${id}`);
+        const channel = new client_1.WhatsAppChannel(id);
+        this.channels.set(id, channel);
+        this.states.set(id, 'pending');
+        channel.onAuthRequired((info) => {
+            this.states.set(id, 'qr_received');
+            if (info.data)
+                this.qrData.set(id, info.data);
+            this.logger.info(`qr auth required for session ${id}`);
+            this.emitEvent(id, { type: 'qr', data: info.data });
+        });
+        channel.onReady(() => {
+            this.states.set(id, 'connected');
+            const phone = channel.getPhone();
+            if (phone)
+                this.phoneNumbers.set(id, phone);
+            this.logger.info(`Session "${id}" connected`);
+            this.emitEvent(id, { type: 'ready' });
+            this.readyCallbacks.get(id)?.forEach(cb => cb(channel));
+        });
+        channel.onDisconnected((reason) => {
+            this.states.set(id, 'disconnected');
+            this.errors.set(id, reason);
+            this.emitEvent(id, { type: 'disconnected', data: reason });
+        });
+        channel.onAuthFailure((error) => {
+            this.states.set(id, 'auth_failure');
+            this.errors.set(id, error.message);
+            this.emitEvent(id, { type: 'auth_failure', data: error.message });
+        });
+        await channel.connect();
+    }
+    onSessionEvent(id, handler) {
+        if (!this.eventListeners.has(id)) {
+            this.eventListeners.set(id, new Set());
+        }
+        this.eventListeners.get(id).add(handler);
+    }
+    removeSessionEventListener(id, handler) {
+        this.eventListeners.get(id)?.delete(handler);
+    }
+    onSessionReady(id, callback) {
+        if (!this.readyCallbacks.has(id)) {
+            this.readyCallbacks.set(id, new Set());
+        }
+        this.readyCallbacks.get(id).add(callback);
+        const state = this.states.get(id);
+        if (state === 'connected') {
+            const channel = this.channels.get(id);
+            if (channel)
+                callback(channel);
+        }
+    }
+    removeSessionReadyCallback(id, callback) {
+        this.readyCallbacks.get(id)?.delete(callback);
+    }
+    emitEvent(id, event) {
+        this.eventListeners.get(id)?.forEach(handler => {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.logger.error(`Session event handler error for ${id}: ${msg}`);
+            }
+        });
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/whatsapp/types.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppConnectionState = exports.WhatsAppMessageType = void 0;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+exports.extractPhoneNumberFromWid = extractPhoneNumberFromWid;
+exports.widToPhoneNumber = widToPhoneNumber;
+exports.phoneNumberToWid = phoneNumberToWid;
+exports.isMediaMessage = isMediaMessage;
+exports.isInteractiveMessage = isInteractiveMessage;
+exports.getFileExtension = getFileExtension;
+exports.generateMessageId = generateMessageId;
+exports.toDomainMessage = toDomainMessage;
+exports.toWhatsAppFormat = toWhatsAppFormat;
+var WhatsAppMessageType;
+(function (WhatsAppMessageType) {
+    WhatsAppMessageType["TEXT"] = "chat";
+    WhatsAppMessageType["IMAGE"] = "image";
+    WhatsAppMessageType["VIDEO"] = "video";
+    WhatsAppMessageType["AUDIO"] = "audio";
+    WhatsAppMessageType["DOCUMENT"] = "document";
+    WhatsAppMessageType["STICKER"] = "sticker";
+    WhatsAppMessageType["LOCATION"] = "location";
+    WhatsAppMessageType["CONTACT"] = "contact";
+    WhatsAppMessageType["BUTTONS_RESPONSE"] = "buttons_response";
+    WhatsAppMessageType["LIST_RESPONSE"] = "list_response";
+    WhatsAppMessageType["TEMPLATE_BUTTON_REPLY"] = "template_button_reply";
+})(WhatsAppMessageType || (exports.WhatsAppMessageType = WhatsAppMessageType = {}));
+var WhatsAppConnectionState;
+(function (WhatsAppConnectionState) {
+    WhatsAppConnectionState["CONNECTING"] = "CONNECTING";
+    WhatsAppConnectionState["AUTHENTICATING"] = "AUTHENTICATING";
+    WhatsAppConnectionState["CONNECTED"] = "CONNECTED";
+    WhatsAppConnectionState["DISCONNECTED"] = "DISCONNECTED";
+    WhatsAppConnectionState["FAILED"] = "FAILED";
+})(WhatsAppConnectionState || (exports.WhatsAppConnectionState = WhatsAppConnectionState = {}));
+function normalizePhoneNumber(phoneNumber) {
+    return phoneNumber.replace(/\D/g, '');
+}
+function extractPhoneNumberFromWid(wid) {
+    const match = wid.match(/^(\d+)@/);
+    return match ? match[1] : wid;
+}
+function widToPhoneNumber(wid) {
+    const phone = extractPhoneNumberFromWid(wid);
+    return normalizePhoneNumber(phone);
+}
+function phoneNumberToWid(phoneNumber) {
+    const normalized = normalizePhoneNumber(phoneNumber);
+    return `${normalized}@c.us`;
+}
+function isMediaMessage(messageType) {
+    return [
+        WhatsAppMessageType.IMAGE,
+        WhatsAppMessageType.VIDEO,
+        WhatsAppMessageType.AUDIO,
+        WhatsAppMessageType.DOCUMENT,
+        WhatsAppMessageType.STICKER,
+    ].includes(messageType);
+}
+function isInteractiveMessage(messageType) {
+    return [
+        WhatsAppMessageType.BUTTONS_RESPONSE,
+        WhatsAppMessageType.LIST_RESPONSE,
+        WhatsAppMessageType.TEMPLATE_BUTTON_REPLY,
+    ].includes(messageType);
+}
+function getFileExtension(mimetype) {
+    const extensions = {
+        'image/jpeg': 'jpg',
+        'image/png': 'png',
+        'image/gif': 'gif',
+        'image/webp': 'webp',
+        'video/mp4': 'mp4',
+        'video/3gpp': '3gp',
+        'audio/ogg': 'ogg',
+        'audio/mpeg': 'mp3',
+        'application/pdf': 'pdf',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+        'application/msword': 'doc',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+        'application/vnd.ms-excel': 'xls',
+    };
+    return extensions[mimetype] || 'bin';
+}
+function generateMessageId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function toDomainMessage(message) {
+    return {
+        id: message.id._serialized,
+        from: widToPhoneNumber(message.from),
+        to: widToPhoneNumber(message.to),
+        content: message.body,
+        timestamp: new Date(message.timestamp * 1000),
+        metadata: {
+            hasMedia: message.hasMedia,
+            type: message.type,
+            fromMe: message.fromMe,
+            isGroup: message.isGroupMsg || false,
+        },
+    };
+}
+function toWhatsAppFormat(message) {
+    return {
+        to: phoneNumberToWid(message.to),
+        content: message.content,
+        options: message.metadata,
+    };
+}

package/dist/whatsapp/whatsapp.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppConnectionState = exports.WhatsAppMessageType = void 0;
+exports.normalizePhoneNumber = normalizePhoneNumber;
+exports.extractPhoneNumberFromWid = extractPhoneNumberFromWid;
+exports.widToPhoneNumber = widToPhoneNumber;
+exports.phoneNumberToWid = phoneNumberToWid;
+exports.isMediaMessage = isMediaMessage;
+exports.isInteractiveMessage = isInteractiveMessage;
+exports.getFileExtension = getFileExtension;
+exports.generateMessageId = generateMessageId;
+exports.toDomainMessage = toDomainMessage;
+exports.toWhatsAppFormat = toWhatsAppFormat;
+var WhatsAppMessageType;
+(function (WhatsAppMessageType) {
+    WhatsAppMessageType["TEXT"] = "chat";
+    WhatsAppMessageType["IMAGE"] = "image";
+    WhatsAppMessageType["VIDEO"] = "video";
+    WhatsAppMessageType["AUDIO"] = "audio";
+    WhatsAppMessageType["DOCUMENT"] = "document";
+    WhatsAppMessageType["STICKER"] = "sticker";
+    WhatsAppMessageType["LOCATION"] = "location";
+    WhatsAppMessageType["CONTACT"] = "contact";
+    WhatsAppMessageType["BUTTONS_RESPONSE"] = "buttons_response";
+    WhatsAppMessageType["LIST_RESPONSE"] = "list_response";
+    WhatsAppMessageType["TEMPLATE_BUTTON_REPLY"] = "template_button_reply";
+})(WhatsAppMessageType || (exports.WhatsAppMessageType = WhatsAppMessageType = {}));
+var WhatsAppConnectionState;
+(function (WhatsAppConnectionState) {
+    WhatsAppConnectionState["CONNECTING"] = "CONNECTING";
+    WhatsAppConnectionState["AUTHENTICATING"] = "AUTHENTICATING";
+    WhatsAppConnectionState["CONNECTED"] = "CONNECTED";
+    WhatsAppConnectionState["DISCONNECTED"] = "DISCONNECTED";
+    WhatsAppConnectionState["FAILED"] = "FAILED";
+})(WhatsAppConnectionState || (exports.WhatsAppConnectionState = WhatsAppConnectionState = {}));
+function normalizePhoneNumber(phoneNumber) {
+    return phoneNumber.replace(/\D/g, '');
+}
+function extractPhoneNumberFromWid(wid) {
+    const match = wid.match(/^(\d+)@/);
+    return match ? match[1] : wid;
+}
+function widToPhoneNumber(wid) {
+    const phone = extractPhoneNumberFromWid(wid);
+    return normalizePhoneNumber(phone);
+}
+function phoneNumberToWid(phoneNumber) {
+    const normalized = normalizePhoneNumber(phoneNumber);
+    return `${normalized}@c.us`;
+}
+function isMediaMessage(messageType) {
+    return [
+        WhatsAppMessageType.IMAGE,
+        WhatsAppMessageType.VIDEO,
+        WhatsAppMessageType.AUDIO,
+        WhatsAppMessageType.DOCUMENT,
+        WhatsAppMessageType.STICKER,
+    ].includes(messageType);
+}
+function isInteractiveMessage(messageType) {
+    return [
+        WhatsAppMessageType.BUTTONS_RESPONSE,
+        WhatsAppMessageType.LIST_RESPONSE,
+        WhatsAppMessageType.TEMPLATE_BUTTON_REPLY,
+    ].includes(messageType);
+}
+function getFileExtension(mimetype) {
+    const extensions = {
+        'image/jpeg': 'jpg',
+        'image/png': 'png',
+        'image/gif': 'gif',
+        'image/webp': 'webp',
+        'video/mp4': 'mp4',
+        'video/3gpp': '3gp',
+        'audio/ogg': 'ogg',
+        'audio/mpeg': 'mp3',
+        'application/pdf': 'pdf',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+        'application/msword': 'doc',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+        'application/vnd.ms-excel': 'xls',
+    };
+    return extensions[mimetype] || 'bin';
+}
+function generateMessageId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function toDomainMessage(message) {
+    return {
+        id: message.id._serialized,
+        from: widToPhoneNumber(message.from),
+        to: widToPhoneNumber(message.to),
+        content: message.body,
+        timestamp: new Date(message.timestamp * 1000),
+        metadata: {
+            hasMedia: message.hasMedia,
+            type: message.type,
+            fromMe: message.fromMe,
+            isGroup: message.isGroupMsg || false,
+        },
+    };
+}
+function toWhatsAppFormat(message) {
+    return {
+        to: phoneNumberToWid(message.to),
+        content: message.content,
+        options: message.metadata,
+    };
+}