miaw-core 1.7.0 → 1.9.0

package/dist/client/MiawClient.js

@@ -491,7 +491,13 @@ export class MiawClient extends EventEmitter {
         });
         // Messages
         this.socket.ev.on("messages.upsert", async (m) => {
-            if (m.type !== "notify")
+            // Baileys only ever emits type 'notify' (live) or 'append' (our own
+            // sends + offline/reconnect backlog). The type is a live-vs-backlog
+            // signal, NOT a direction signal, so we must process BOTH to capture
+            // outbound messages (sent by us or from the user's phone) and any
+            // messages that arrive in the offline backlog on reconnect. Direction is
+            // decided later via `fromMe`; storeMessage() dedups re-delivered messages.
+            if (m.type !== "notify" && m.type !== "append")
                 return;
             for (const msg of m.messages) {
                 // Debug: Log raw Baileys message structure
@@ -560,14 +566,16 @@ export class MiawClient extends EventEmitter {
                             }
                         }
                     }
-                    // Store message in messagesStore
-                    const chatJid = normalized.from;
-                    if (!this.messagesStore.has(chatJid)) {
-                        this.messagesStore.set(chatJid, []);
+                    // Store message in messagesStore (deduped by id). Outbound messages
+                    // (fromMe) — our own sends and messages sent from the user's phone —
+                    // are stored so getChatMessages / CLI `get messages` include them,
+                    // but are NOT emitted on "message" so existing bots don't reply to
+                    // their own sends. Emit only newly-stored INBOUND messages, so
+                    // reconnect re-delivery of already-stored messages never re-fires.
+                    const isNew = this.storeMessage(normalized);
+                    if (isNew && !normalized.fromMe) {
+                        this.emit("message", normalized);
                     }
-                    this.messagesStore.get(chatJid).push(normalized);
-                    this.saveMessagesToFile();
-                    this.emit("message", normalized);
                 }
             }
         });
@@ -1171,12 +1179,9 @@ export class MiawClient extends EventEmitter {
         if (normalized.participant) {
             normalized.participant = this.resolveLidToJid(normalized.participant);
         }
-        const chatJid = normalized.from;
-        if (!this.messagesStore.has(chatJid)) {
-            this.messagesStore.set(chatJid, []);
-        }
-        this.messagesStore.get(chatJid).push(normalized);
-        this.saveMessagesToFile();
+        // Store (deduped by id). The history-sync path never emits "message"; it
+        // only populates the store.
+        this.storeMessage(normalized);
     }
     /**
      * Clear session data for this instance.
@@ -1745,6 +1750,78 @@ export class MiawClient extends EventEmitter {
         }
         this.emit("poll_vote", vote);
     }
+    // ============================================
+    // Status / Stories (v1.8.0) — via status@broadcast
+    // ============================================
+    /**
+     * Resolve the audience (statusJidList) for a status post. When recipients are
+     * given they are used (formatted to JIDs); otherwise it defaults to every
+     * individual contact in the store (like the WhatsApp app's "all contacts").
+     */
+    getStatusAudience(recipients) {
+        if (recipients && recipients.length > 0) {
+            return recipients.map((r) => MessageHandler.formatPhoneToJid(r));
+        }
+        const jids = new Set();
+        for (const contact of this.contactsStore.values()) {
+            if (contact.jid?.endsWith("@s.whatsapp.net")) {
+                jids.add(contact.jid);
+            }
+        }
+        return [...jids];
+    }
+    /**
+     * Post a text status / story.
+     * @param text - The status text
+     * @param recipients - Audience (phone numbers or JIDs). Omit to send to all contacts.
+     * @param options - backgroundColor / font for the text status
+     */
+    async postTextStatus(text, recipients, options) {
+        return this.postStatus({ text }, recipients, options);
+    }
+    /**
+     * Post an image status / story.
+     * @param image - Image source (file path, URL, or Buffer)
+     * @param recipients - Audience (phone numbers or JIDs). Omit to send to all contacts.
+     * @param options - caption for the image
+     */
+    async postImageStatus(image, recipients, options) {
+        return this.postStatus({ image: Buffer.isBuffer(image) ? image : { url: image }, caption: options?.caption }, recipients, options);
+    }
+    /**
+     * Post a video status / story.
+     * @param video - Video source (file path, URL, or Buffer)
+     * @param recipients - Audience (phone numbers or JIDs). Omit to send to all contacts.
+     * @param options - caption for the video
+     */
+    async postVideoStatus(video, recipients, options) {
+        return this.postStatus({ video: Buffer.isBuffer(video) ? video : { url: video }, caption: options?.caption }, recipients, options);
+    }
+    /** Shared status sender: builds statusJidList and posts to status@broadcast. */
+    async postStatus(content, recipients, options) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot post status. Connection state: ${this.connectionState}`);
+            }
+            const statusJidList = this.getStatusAudience(recipients);
+            if (statusJidList.length === 0 && this.options.debug) {
+                this.logger.debug("[status] No audience (no recipients and empty contacts store); status will be visible only to you.");
+            }
+            const result = await this.socket.sendMessage("status@broadcast", content, {
+                statusJidList,
+                backgroundColor: options?.backgroundColor,
+                font: options?.font,
+            });
+            return { success: true, messageId: result?.key?.id || undefined };
+        }
+        catch (error) {
+            this.logger.error("Failed to post status:", error);
+            return { success: false, error: error.message };
+        }
+    }
     /**
      * Download media from a received message
      * @param message - The MiawMessage containing media (must have raw field with original Baileys message)
@@ -2000,6 +2077,145 @@ export class MiawClient extends EventEmitter {
             return null;
         }
     }
+    // ============================================
+    // Business extras (v1.8.0) — WhatsApp Business only
+    // ============================================
+    /**
+     * Update your own business profile (address, websites, email, description,
+     * hours). Category is read-only and cannot be changed here.
+     */
+    async updateBusinessProfile(updates) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot update business profile. Connection state: ${this.connectionState}`);
+            }
+            const socket = this.socket;
+            await socket.updateBussinesProfile(updates);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to update business profile:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Set the business cover photo.
+     * @param image - Image source (file path, URL, or Buffer)
+     * @returns The uploaded cover photo id (pass to removeCoverPhoto)
+     */
+    async updateCoverPhoto(image) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot update cover photo. Connection state: ${this.connectionState}`);
+            }
+            const photo = (Buffer.isBuffer(image) ? image : { url: image });
+            const id = await this.socket.updateCoverPhoto(photo);
+            return { success: true, coverPhotoId: id != null ? String(id) : undefined };
+        }
+        catch (error) {
+            this.logger.error("Failed to update cover photo:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Remove a business cover photo by its id. */
+    async removeCoverPhoto(coverPhotoId) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot remove cover photo. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.removeCoverPhoto(coverPhotoId);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to remove cover photo:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Fetch details for a business order. The `tokenBase64` comes from a received
+     * order message (`orderMessage.token`) — this is only usable after a customer
+     * sends an order.
+     */
+    async getOrderDetails(orderId, tokenBase64) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot get order details. Connection state: ${this.connectionState}`);
+            }
+            const details = await this.socket.getOrderDetails(orderId, tokenBase64);
+            if (!details) {
+                return null;
+            }
+            const price = (details.price ?? {});
+            return {
+                currency: price.currency,
+                total: price.total,
+                products: (details.products ?? []).map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    imageUrl: p.imageUrl,
+                    quantity: p.quantity,
+                    currency: p.currency,
+                    price: p.price,
+                })),
+            };
+        }
+        catch (error) {
+            this.logger.error("Failed to get order details:", error);
+            return null;
+        }
+    }
+    /** Add or edit a business quick reply. */
+    async addQuickReply(quickReply) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot add quick reply. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.addOrEditQuickReply({
+                shortcut: quickReply.shortcut,
+                message: quickReply.message,
+                keywords: quickReply.keywords ?? [],
+                count: 0,
+                deleted: false,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to add quick reply:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Remove a business quick reply by its timestamp. */
+    async removeQuickReply(timestamp) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot remove quick reply. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.removeQuickReply(timestamp);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to remove quick reply:", error);
+            return { success: false, error: error.message };
+        }
+    }
     /**
      * Get profile picture URL for a contact or group
      * @param jidOrPhone - Contact's JID, phone number, or group JID
@@ -2552,6 +2768,33 @@ export class MiawClient extends EventEmitter {
     getMessagesFilePath() {
         return path.join(this.options.sessionPath, this.options.instanceId, "messages.json");
     }
+    /**
+     * Store a normalized message in the in-memory store (and persist to disk),
+     * deduplicating by message id.
+     *
+     * Both the live `messages.upsert` handler and the history-sync path funnel
+     * through here, so a message re-delivered via multiple routes (our own send
+     * echo, offline/reconnect backlog, or history sync) is stored only once.
+     *
+     * @param normalized - Normalized message to store
+     * @returns true if the message was newly stored; false if it was a duplicate
+     */
+    storeMessage(normalized) {
+        const chatJid = normalized.from;
+        const bucket = this.messagesStore.get(chatJid);
+        if (bucket) {
+            // Dedup by id. An empty id (missing key.id) can't be deduped -> append.
+            if (normalized.id && bucket.some((m) => m.id === normalized.id)) {
+                return false;
+            }
+            bucket.push(normalized);
+        }
+        else {
+            this.messagesStore.set(chatJid, [normalized]);
+        }
+        this.saveMessagesToFile();
+        return true;
+    }
     /**
      * Save messages to disk for persistence across reconnections
      * Baileys v7 history sync doesn't always fire, so we persist messages locally
@@ -3681,6 +3924,368 @@ export class MiawClient extends EventEmitter {
         }
     }
     // ============================================
+    // Community Methods (v1.9.0)
+    // ============================================
+    /**
+     * Map Baileys GroupMetadata (communities share the shape) to CommunityInfo.
+     */
+    mapToCommunityInfo(metadata) {
+        const participants = (metadata.participants || []).map((p) => ({
+            jid: this.resolveLidToJid(p.id),
+            role: p.admin === "superadmin"
+                ? "superadmin"
+                : p.admin === "admin"
+                    ? "admin"
+                    : "member",
+        }));
+        return {
+            jid: metadata.id,
+            name: metadata.subject,
+            description: metadata.desc || undefined,
+            owner: metadata.owner ? this.resolveLidToJid(metadata.owner) : undefined,
+            createdAt: metadata.creation,
+            participantCount: (metadata.participants || []).length,
+            participants,
+            announce: metadata.announce,
+            restrict: metadata.restrict,
+        };
+    }
+    /**
+     * Create a new community.
+     * @param name - Community name/subject
+     * @param description - Optional community description
+     */
+    async createCommunity(name, description) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot create community. Connection state: ${this.connectionState}`);
+            }
+            const nameValidation = validateGroupName(name);
+            if (!nameValidation.valid) {
+                return { success: false, error: nameValidation.error };
+            }
+            const metadata = await this.socket.communityCreate(name, description || "");
+            if (!metadata) {
+                return { success: true };
+            }
+            const info = this.mapToCommunityInfo(metadata);
+            return { success: true, communityJid: info.jid, communityInfo: info };
+        }
+        catch (error) {
+            this.logger.error("Failed to create community:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Get community metadata/information. */
+    async getCommunityInfo(communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot get community info. Connection state: ${this.connectionState}`);
+            }
+            const metadata = await this.socket.communityMetadata(communityJid);
+            return metadata ? this.mapToCommunityInfo(metadata) : null;
+        }
+        catch (error) {
+            this.logger.error("Failed to get community info:", error);
+            return null;
+        }
+    }
+    /** Get a community's participants. */
+    async getCommunityParticipants(communityJid) {
+        const info = await this.getCommunityInfo(communityJid);
+        return info?.participants || null;
+    }
+    /** Fetch all communities the account participates in. */
+    async getAllCommunities() {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot fetch communities. Connection state: ${this.connectionState}`);
+            }
+            const all = await this.socket.communityFetchAllParticipating();
+            return Object.values(all || {}).map((m) => this.mapToCommunityInfo(m));
+        }
+        catch (error) {
+            this.logger.error("Failed to fetch communities:", error);
+            return [];
+        }
+    }
+    /** Update a community's name/subject. */
+    async updateCommunityName(communityJid, name) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot update community. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.communityUpdateSubject(communityJid, name);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to update community name:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Update a community's description. */
+    async updateCommunityDescription(communityJid, description) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot update community. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.communityUpdateDescription(communityJid, description);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to update community description:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Leave a community. */
+    async leaveCommunity(communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot leave community. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.communityLeave(communityJid);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to leave community:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Create a new group inside a community.
+     * @param communityJid - Parent community JID
+     * @param name - Group name/subject
+     * @param participants - Initial members (phone numbers or JIDs)
+     */
+    async createCommunityGroup(communityJid, name, participants = []) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot create community group. Connection state: ${this.connectionState}`);
+            }
+            const nameValidation = validateGroupName(name);
+            if (!nameValidation.valid) {
+                return { success: false, error: nameValidation.error };
+            }
+            const formatted = participants.map((p) => MessageHandler.formatPhoneToJid(p));
+            const metadata = await this.socket.communityCreateGroup(name, formatted, communityJid);
+            if (!metadata) {
+                return { success: true };
+            }
+            const info = this.mapToCommunityInfo(metadata);
+            return {
+                success: true,
+                groupJid: info.jid,
+                groupInfo: {
+                    jid: info.jid,
+                    name: info.name,
+                    description: info.description,
+                    owner: info.owner,
+                    createdAt: info.createdAt,
+                    participantCount: info.participantCount,
+                    participants: info.participants,
+                    announce: info.announce,
+                    restrict: info.restrict,
+                },
+            };
+        }
+        catch (error) {
+            this.logger.error("Failed to create community group:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Link an existing group to a community. */
+    async linkGroupToCommunity(groupJid, communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot link group. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.communityLinkGroup(groupJid, communityJid);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to link group to community:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** Unlink a group from a community. */
+    async unlinkGroupFromCommunity(groupJid, communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot unlink group. Connection state: ${this.connectionState}`);
+            }
+            await this.socket.communityUnlinkGroup(groupJid, communityJid);
+            return { success: true };
+        }
+        catch (error) {
+            this.logger.error("Failed to unlink group from community:", error);
+            return { success: false, error: error.message };
+        }
+    }
+    /** List the groups linked inside a community. */
+    async getLinkedGroups(communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot fetch linked groups. Connection state: ${this.connectionState}`);
+            }
+            const result = await this.socket.communityFetchLinkedGroups(communityJid);
+            return (result?.linkedGroups || []).map((g) => ({
+                id: g.id,
+                subject: g.subject,
+                creation: g.creation,
+                owner: g.owner ? this.resolveLidToJid(g.owner) : undefined,
+                size: g.size,
+            }));
+        }
+        catch (error) {
+            this.logger.error("Failed to fetch linked groups:", error);
+            return [];
+        }
+    }
+    /** Shared helper for community participant operations. */
+    async communityParticipantsOperation(communityJid, participants, action) {
+        if (!this.socket) {
+            throw new Error("Not connected. Call connect() first.");
+        }
+        if (this.connectionState !== "connected") {
+            throw new Error(`Cannot perform community operation. Connection state: ${this.connectionState}`);
+        }
+        const formatted = participants.map((p) => MessageHandler.formatPhoneToJid(p));
+        const results = await this.socket.communityParticipantsUpdate(communityJid, formatted, action);
+        return results.map((r) => ({
+            jid: r.jid || "",
+            status: r.status,
+            success: r.status === "200",
+        }));
+    }
+    /** Add members to a community. */
+    async addCommunityMembers(communityJid, participants) {
+        return this.communityParticipantsOperation(communityJid, participants, "add");
+    }
+    /** Remove members from a community. */
+    async removeCommunityMembers(communityJid, participants) {
+        return this.communityParticipantsOperation(communityJid, participants, "remove");
+    }
+    /** Promote members to community admin. */
+    async promoteCommunityMembers(communityJid, participants) {
+        return this.communityParticipantsOperation(communityJid, participants, "promote");
+    }
+    /** Demote community admins to members. */
+    async demoteCommunityMembers(communityJid, participants) {
+        return this.communityParticipantsOperation(communityJid, participants, "demote");
+    }
+    /** Get the community invite link. */
+    async getCommunityInviteLink(communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot get invite link. Connection state: ${this.connectionState}`);
+            }
+            const code = await this.socket.communityInviteCode(communityJid);
+            return code ? `https://chat.whatsapp.com/${code}` : null;
+        }
+        catch (error) {
+            this.logger.error("Failed to get community invite link:", error);
+            return null;
+        }
+    }
+    /** Revoke the community invite link and get a new one. */
+    async revokeCommunityInvite(communityJid) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot revoke invite. Connection state: ${this.connectionState}`);
+            }
+            const code = await this.socket.communityRevokeInvite(communityJid);
+            return code ? `https://chat.whatsapp.com/${code}` : null;
+        }
+        catch (error) {
+            this.logger.error("Failed to revoke community invite:", error);
+            return null;
+        }
+    }
+    /** Accept a community invite and join. */
+    async acceptCommunityInvite(inviteCode) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot accept invite. Connection state: ${this.connectionState}`);
+            }
+            let code = inviteCode;
+            if (inviteCode.includes("chat.whatsapp.com/")) {
+                code = inviteCode.split("chat.whatsapp.com/")[1];
+            }
+            const jid = await this.socket.communityAcceptInvite(code);
+            return jid || null;
+        }
+        catch (error) {
+            this.logger.error("Failed to accept community invite:", error);
+            return null;
+        }
+    }
+    /** Preview a community from an invite code without joining. */
+    async getCommunityInviteInfo(inviteCode) {
+        try {
+            if (!this.socket) {
+                throw new Error("Not connected. Call connect() first.");
+            }
+            if (this.connectionState !== "connected") {
+                throw new Error(`Cannot get invite info. Connection state: ${this.connectionState}`);
+            }
+            let code = inviteCode;
+            if (inviteCode.includes("chat.whatsapp.com/")) {
+                code = inviteCode.split("chat.whatsapp.com/")[1];
+            }
+            const metadata = await this.socket.communityGetInviteInfo(code);
+            return {
+                jid: metadata.id,
+                name: metadata.subject,
+                description: metadata.desc || undefined,
+                participantCount: metadata.size || metadata.participants?.length || 0,
+                createdAt: metadata.creation,
+            };
+        }
+        catch (error) {
+            this.logger.error("Failed to get community invite info:", error);
+            return null;
+        }
+    }
+    // ============================================
     // Profile Management Methods (v0.8.0)
     // ============================================
     /**