innovators-bot2 1.2.5 → 1.2.6

package/README.md

@@ -146,7 +146,16 @@ client.on('message-deleted', async (data) => {
 const groups = await client.getAllGroups()
 
 // Add participant to group
-await client.changeGroupParticipants(groupId, ['1234567890@s.whatsapp.net'], 'add')
+// Note: If adding fails due to user's privacy settings (403), 
+// an invitation link is automatically sent to the user instead.
+const result = await client.changeGroupParticipants(groupId, ['1234567890@s.whatsapp.net'], 'add')
+
+if (result[0].status === 403 && result[0].invitationSent) {
+    console.log('User has privacy settings enabled. Invitation link sent!')
+}
+
+// Send a manual group invitation link
+await client.sendGroupInvitation(groupId, '1234567890@s.whatsapp.net', 'Join my group!')
 
 // Remove participant
 await client.changeGroupParticipants(groupId, ['1234567890@s.whatsapp.net'], 'remove')

package/example.js

@@ -398,6 +398,7 @@ async function start() {
                     `*👥 Group Management*\n` +
                     `• !groups - List all your groups\n` +
                     `• !add <number> - Add participant\n` +
+                    `• !invite <number> - Send group invite link\n` +
                     `• !remove <number> - Remove participant\n` +
                     `• !promote <number> - Make admin\n` +
                     `• !demote <number> - Remove admin\n\n` +
@@ -588,12 +589,32 @@ async function start() {
                         break
                     }
 
-                    const number = args.replace(/[^0-9]/g, '') + '@s.whatsapp.net'
-                    if (!number) {
-                        await client.sendMessage(msg.from, 'Please provide a valid phone number')
+                    const rawNumber = args.replace(/[^0-9]/g, '')
+
+                    // Validate phone number format
+                    if (!rawNumber || rawNumber.length < 10) {
+                        await client.sendMessage(msg.from,
+                            `❌ Invalid phone number format.\n\n` +
+                            `✅ Correct format: !${command.slice(1)} 923001234567\n` +
+                            `(Include country code without + or spaces)`
+                        )
+                        break
+                    }
+
+                    // Ensure country code is present (check if starts with common codes)
+                    if (rawNumber.startsWith('0')) {
+                        await client.sendMessage(msg.from,
+                            `❌ Phone number must include country code.\n\n` +
+                            `Example:\n` +
+                            `• Pakistan: 923001234567 (not 03001234567)\n` +
+                            `• India: 919876543210 (not 09876543210)\n` +
+                            `• USA: 14155551234 (not 4155551234)`
+                        )
                         break
                     }
 
+                    const number = rawNumber + '@s.whatsapp.net'
+
                     let action
                     switch (command) {
                         case '!add': action = 'add'; break
@@ -610,14 +631,66 @@ async function start() {
                         demote: 'demoted in'
                     }
 
-                    if (result[0].status === 200) {
+                    if (result[0].status == 200) {
                         await client.sendMessage(msg.from, `Successfully ${actionMap[action]} the group`)
+                    } else if (result[0].status == 403 && result[0].invitationSent) {
+                        await client.sendMessage(msg.from, `⚠️ Could not add directly due to privacy settings.\n✅ Group invitation link has been sent to the user instead!`)
                     } else {
-                        await client.sendMessage(msg.from, `Failed to ${action} participant: ${result[0].content}`)
+                        await client.sendMessage(msg.from, `Failed to ${action} participant: ${result[0].message || result[0].content || result[0].error || 'Unknown error'}`)
                     }
                 } catch (error) {
                     console.error(`Error ${command} participant:`, error)
-                    await client.sendMessage(msg.from, `Failed to ${command.slice(1)} participant`)
+                    if (error.output?.statusCode === 408) {
+                        await client.sendMessage(msg.from, `⏱️ Request timed out. The number might be invalid or not on WhatsApp.`)
+                    } else {
+                        await client.sendMessage(msg.from, `Failed to ${command.slice(1)} participant: ${error.message || 'Unknown error'}`)
+                    }
+                }
+                break
+
+
+            case '!invite':
+                try {
+                    if (!msg.raw.key.remoteJid.endsWith('@g.us')) {
+                        await client.sendMessage(msg.from, 'This command can only be used in groups')
+                        break
+                    }
+
+                    const rawInviteNumber = args.replace(/[^0-9]/g, '')
+
+                    // Validate phone number format
+                    if (!rawInviteNumber || rawInviteNumber.length < 10) {
+                        await client.sendMessage(msg.from,
+                            `❌ Invalid phone number format.\n\n` +
+                            `✅ Correct format: !invite 923001234567\n` +
+                            `(Include country code without + or spaces)`
+                        )
+                        break
+                    }
+
+                    // Ensure country code is present
+                    if (rawInviteNumber.startsWith('0')) {
+                        await client.sendMessage(msg.from,
+                            `❌ Phone number must include country code.\n\n` +
+                            `Example:\n` +
+                            `• Pakistan: 923001234567 (not 03001234567)\n` +
+                            `• India: 919876543210 (not 09876543210)\n` +
+                            `• USA: 14155551234 (not 4155551234)`
+                        )
+                        break
+                    }
+
+                    const inviteNumber = rawInviteNumber + '@s.whatsapp.net'
+
+                    await client.sendGroupInvitation(msg.raw.key.remoteJid, inviteNumber)
+                    await client.sendMessage(msg.from, `✅ Group invitation sent to ${rawInviteNumber}`)
+                } catch (error) {
+                    console.error('Error sending invitation:', error)
+                    if (error.output?.statusCode === 408) {
+                        await client.sendMessage(msg.from, `⏱️ Request timed out. The number might be invalid or not on WhatsApp.`)
+                    } else {
+                        await client.sendMessage(msg.from, `Failed to send group invitation: ${error.message || 'Unknown error'}`)
+                    }
                 }
                 break
         }

package/index.js

@@ -864,12 +864,75 @@ class WhatsAppClient extends EventEmitter {
 
         try {
             for (const participantId of participantIds) {
-                const result = await this.sock.groupParticipantsUpdate(
-                    groupId,
-                    [participantId],
-                    action
-                );
-                results.push(result);
+                try {
+                    let updateResult = await this.sock.groupParticipantsUpdate(
+                        groupId,
+                        [participantId],
+                        action
+                    );
+
+                    // Baileys may return an array or a single object. 
+                    // We want to handle the first result for this participant.
+                    let participantResult = Array.isArray(updateResult) ? updateResult[0] : updateResult;
+
+                    // If it's the { [jid]: { code: ... } } format, extract it
+                    if (participantResult && participantResult[participantId]) {
+                        participantResult = {
+                            status: participantResult[participantId].code,
+                            jid: participantId,
+                            ...participantResult[participantId]
+                        };
+                    }
+
+                    // Normalize status to number
+                    const status = participantResult?.status || participantResult?.code;
+
+                    if (action === 'add' && (status === 403 || status === '403')) {
+                        console.log(`Privacy settings prevent adding ${participantId}. Sending invitation link...`);
+
+                        try {
+                            await this.sendGroupInvitation(groupId, participantId, 'You have been invited to join this group');
+                            participantResult.invitationSent = true;
+                            participantResult.message = 'Invitation link sent due to privacy settings';
+                            participantResult.status = 403;
+                        } catch (invError) {
+                            console.error('Failed to send auto-invitation:', invError);
+                            participantResult.invitationSent = false;
+                            participantResult.error = 'Privacy restricted, and failed to send invitation link';
+                            participantResult.status = 403;
+                        }
+                    } else if (participantResult) {
+                        participantResult.status = status ? parseInt(status) : 500;
+                    }
+
+                    results.push(participantResult || { status: 500, jid: participantId, error: 'Empty result' });
+                } catch (participantError) {
+                    // Handle cases where Baileys might throw instead of returning 403
+                    const statusCode = participantError.output?.statusCode || participantError.data?.status;
+
+                    if (action === 'add' && (statusCode === 403 || statusCode === '403')) {
+                        console.log(`Privacy error caught in throw: Sending invitation link...`);
+                        try {
+                            await this.sendGroupInvitation(groupId, participantId, 'You have been invited to join this group');
+                            results.push({
+                                status: 403,
+                                jid: participantId,
+                                invitationSent: true,
+                                message: 'Invitation link sent due to privacy settings'
+                            });
+                            continue;
+                        } catch (invError) {
+                            console.error('Failed to send fallback invitation:', invError);
+                        }
+                    }
+
+                    console.error(`Error updating participant ${participantId}:`, participantError);
+                    results.push({
+                        status: statusCode || 500,
+                        jid: participantId,
+                        error: participantError.message || 'Unknown error'
+                    });
+                }
             }
             return results;
         } catch (error) {
@@ -877,6 +940,62 @@ class WhatsAppClient extends EventEmitter {
             throw error;
         }
     }
+
+    /**
+     * Get group name from metadata
+     * @param {string} groupId - The group JID
+     * @returns {Promise<string>} The group name
+     * @private
+     */
+    async _getGroupName(groupId) {
+        try {
+            const metadata = await this.getGroupMetadata(groupId);
+            return metadata.subject || 'Group';
+        } catch (error) {
+            console.error('Error getting group name:', error);
+            return 'Group';
+        }
+    }
+
+    /**
+     * Send a group invitation link to a user
+     * @param {string} groupId - The group JID
+     * @param {string} participantId - The participant JID to send invitation to
+     * @param {string} [customMessage] - Optional custom invitation message
+     * @returns {Promise<object>} The sent message info
+     * @throws {Error} If client is not connected or an error occurs
+     */
+    async sendGroupInvitation(groupId, participantId, customMessage) {
+        if (!this.isConnected) {
+            throw new Error('Client is not connected');
+        }
+
+        try {
+            // Get group invite code
+            const inviteCode = await this.sock.groupInviteCode(groupId);
+            const groupName = await this._getGroupName(groupId);
+
+            // Create the invitation link
+            const inviteLink = `https://chat.whatsapp.com/${inviteCode}`;
+
+            // Create the invitation message
+            const message = customMessage
+                ? `${customMessage}\n\n${inviteLink}`
+                : `📨 *Group Invitation*\n\n` +
+                `You have been invited to join:\n` +
+                `*${groupName}*\n\n` +
+                `Click the link below to join:\n${inviteLink}`;
+
+            // Send as text message
+            return await this.sock.sendMessage(participantId, {
+                text: message
+            }, { ai: true });
+        } catch (error) {
+            console.error('Error sending group invitation:', error);
+            throw error;
+        }
+    }
+
     /**
      * Mark a message as read
      * @param {object|string} messageKey - The message key object or message ID

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "innovators-bot2",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "",
   "main": "index.js",
   "scripts": {