f-baileys 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 f-baileys
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,248 @@
+# f-baileys 🚀
+
+> **Fast · Stable · Multi-Platform WhatsApp Bot Library**  
+> Pairing Code ✓ | QR Code ✓ | Auto-Install ✓ | Termux/VPS/Panel ✓
+
+[![npm version](https://img.shields.io/npm/v/f-baileys.svg?style=flat-square)](https://npmjs.com/package/f-baileys)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg?style=flat-square)](LICENSE)
+[![Node](https://img.shields.io/badge/Node-%3E%3D16-brightgreen?style=flat-square)](https://nodejs.org)
+
+---
+
+## ✨ Features
+
+| Feature | Status |
+|---------|--------|
+| Pairing Code login (100% masuk) | ✅ |
+| QR Code login | ✅ |
+| Auto-reconnect on disconnect | ✅ |
+| Multi-platform support | ✅ |
+| Auto-install missing dependencies | ✅ |
+| Serialized message objects | ✅ |
+| Send Text/Image/Video/Audio/Sticker/Document | ✅ |
+| TypeScript definitions | ✅ |
+| Pterodactyl Panel compatible | ✅ |
+| Termux (F-Droid) compatible | ✅ |
+
+---
+
+## 📦 Install
+
+```bash
+npm install f-baileys
+```
+
+> Saat install, f-baileys otomatis mendeteksi platform dan menginstall dependensi yang kurang.
+
+---
+
+## 🚀 Quick Start
+
+### Mode QR Code
+
+```js
+const FBaileys = require('f-baileys');
+
+const bot = new FBaileys({
+  sessionPath: './session',
+  usePairingCode: false,  // QR Code mode
+  printQR: true,
+  autoReconnect: true,
+});
+
+bot.on('open', () => console.log('✓ Connected!'));
+
+bot.on('message', async (msg) => {
+  if (msg.fromMe) return;
+  if (msg.text === 'ping') {
+    await msg.reply('Pong! 🏓');
+  }
+});
+
+bot.connect();
+```
+
+### Mode Pairing Code
+
+```js
+const FBaileys = require('f-baileys');
+
+const bot = new FBaileys({
+  sessionPath: './session',
+  usePairingCode: true,          // ← Pairing Code
+  phoneNumber: '628xxxxxxxxxx',  // Nomor HP (tanpa + atau spasi)
+  autoReconnect: true,
+});
+
+bot.on('open', () => console.log('✓ Connected via Pairing Code!'));
+bot.on('message', async (msg) => {
+  if (msg.text === 'halo') await msg.reply('Halo juga!');
+});
+
+bot.connect();
+```
+
+---
+
+## ⚙️ Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `sessionPath` | string | `'./f_session'` | Folder simpan session |
+| `usePairingCode` | boolean | `false` | `true` = pairing code, `false` = QR |
+| `phoneNumber` | string | `null` | Nomor HP untuk pairing code |
+| `printQR` | boolean | `true` | Auto print QR ke terminal |
+| `logLevel` | string | `'silent'` | `'silent'` / `'info'` / `'debug'` |
+| `autoReconnect` | boolean | `true` | Auto reconnect saat putus |
+| `reconnectDelay` | number | `3000` | Delay reconnect (ms) |
+| `baileysOptions` | object | `{}` | Extra config ke makeWASocket |
+
+---
+
+## 📨 Message Object
+
+Setiap pesan yang diterima sudah diserialisasi:
+
+```js
+bot.on('message', async (msg) => {
+  msg.id         // ID pesan
+  msg.from       // JID pengirim/grup
+  msg.sender     // JID pengirim (di dalam grup)
+  msg.senderNum  // Nomor pengirim (tanpa @s.whatsapp.net)
+  msg.fromMe     // true jika pesan dari bot sendiri
+  msg.isGroup    // true jika pesan dari grup
+  msg.text       // Isi teks pesan
+  msg.type       // Tipe pesan (imageMessage, videoMessage, dll)
+  msg.pushName   // Nama pengirim
+  msg.timestamp  // Unix timestamp
+
+  // Flags
+  msg.isText     // Pesan teks
+  msg.isImage    // Pesan gambar
+  msg.isVideo    // Pesan video
+  msg.isAudio    // Pesan audio
+  msg.isSticker  // Pesan stiker
+  msg.isDocument // Pesan dokumen
+
+  // Quoted message
+  msg.quoted?.body   // Teks quoted
+  msg.quoted?.type   // Tipe quoted
+
+  // Helpers
+  await msg.reply('Teks')          // Balas pesan
+  await msg.react('✅')            // Reaksi emoji
+});
+```
+
+---
+
+## 📤 Send Methods
+
+```js
+// Teks
+await bot.sendText(jid, 'Hello!');
+await bot.sendText(jid, 'Reply!', quotedMsg);
+
+// Gambar
+await bot.sendImage(jid, './gambar.jpg', 'Caption');
+await bot.sendImage(jid, 'https://..../img.jpg', 'Caption');
+
+// Video
+await bot.sendVideo(jid, './video.mp4', 'Caption');
+
+// Audio
+await bot.sendAudio(jid, './audio.mp3');
+await bot.sendAudio(jid, './voice.ogg', true); // ptt = voice note
+
+// Sticker
+await bot.sendSticker(jid, './sticker.webp');
+
+// Dokumen
+await bot.sendDocument(jid, './file.pdf', 'dokumen.pdf', 'application/pdf');
+
+// Reaksi
+await bot.sendReaction(jid, msg.key, '🔥');
+
+// Typing indicator
+await bot.sendTyping(jid, 2000); // Typing selama 2 detik
+
+// Download media dari pesan
+const buffer = await bot.downloadMedia(msg);
+```
+
+---
+
+## 🌍 Platform Support
+
+| Platform | Status |
+|----------|--------|
+| VPS Linux (Ubuntu/Debian/CentOS) | ✅ |
+| Termux (Google Play) | ✅ |
+| Termux (F-Droid) | ✅ |
+| Pterodactyl Panel | ✅ |
+| Docker | ✅ |
+| Windows | ✅ |
+| macOS | ✅ |
+
+---
+
+## 📦 Dependencies (Auto-Install)
+
+Saat `npm install f-baileys`, package berikut otomatis diinstall jika belum ada:
+
+| Package | Fungsi |
+|---------|--------|
+| `@whiskeysockets/baileys` | Core WhatsApp MD |
+| `sharp` | Image processing (WebP, resize, dll) |
+| `jimp` | Pure JS image processing |
+| `fluent-ffmpeg` | FFmpeg wrapper (convert audio/video) |
+| `ffmpeg-static` | Binary FFmpeg |
+| `ytdl-core` | YouTube downloader |
+| `webp-converter` | Konversi ke WebP (sticker) |
+| `color` | Manipulasi warna |
+| `chalk` | Warna terminal |
+| `qrcode-terminal` | Print QR di terminal |
+| `axios` | HTTP requests |
+| `pino` | Logger |
+
+> Untuk Termux: f-baileys otomatis menjalankan `pkg install ffmpeg nodejs` juga.
+
+---
+
+## 📱 Pairing Code Guide
+
+1. Jalankan bot dengan `usePairingCode: true`
+2. Kode 8 digit akan muncul di terminal (format: `XXXX-XXXX`)
+3. Buka WhatsApp di HP → **Perangkat Tertaut** → **Tautkan Perangkat**
+4. Pilih **Tautkan dengan Nomor Telepon**
+5. Masukkan kode yang tampil di terminal
+6. Selesai! ✓
+
+---
+
+## 🔧 Events
+
+```js
+bot.on('qr',           (qr) => { ... })          // QR string
+bot.on('open',         (sock) => { ... })         // Connected
+bot.on('close',        ({ reason, code }) => {})  // Disconnected
+bot.on('message',      (msg) => { ... })          // Pesan masuk
+bot.on('logout',       () => { ... })             // Session logout
+bot.on('group-update', (update) => { ... })       // Update grup
+```
+
+---
+
+## 🛠 Utility
+
+```js
+// Convert nomor ke JID
+FBaileys.toJid('628123456789')        // → 628123456789@s.whatsapp.net
+FBaileys.toGroupJid('120363xxxxxx')   // → 120363xxxxxx@g.us
+```
+
+---
+
+## 📄 License
+
+MIT © f-baileys

package/examples/pairing-login.js

@@ -0,0 +1,38 @@
+/**
+ * f-baileys — Example: Pairing Code Login
+ * =========================================
+ * npm install f-baileys
+ * node examples/pairing-login.js
+ */
+
+const FBaileys = require('f-baileys');
+
+// Ganti dengan nomor kamu (tanpa + atau spasi)
+const PHONE_NUMBER = '628xxxxxxxxxx';
+
+const bot = new FBaileys({
+  sessionPath:    './session_pair',
+  usePairingCode: true,           // ← Pairing Code Mode
+  phoneNumber:    PHONE_NUMBER,
+  logLevel:       'info',
+  autoReconnect:  true,
+  reconnectDelay: 3000,
+});
+
+bot.on('open', (sock) => {
+  console.log('✓ Connected via Pairing Code!');
+});
+
+bot.on('message', async (msg) => {
+  if (msg.fromMe) return;
+
+  if (msg.text?.toLowerCase() === 'ping') {
+    await msg.reply('🏓 Pong!');
+  }
+});
+
+bot.on('logout', () => {
+  console.log('Session logged out — re-run to pair again');
+});
+
+bot.connect();

package/examples/qr-login.js

@@ -0,0 +1,53 @@
+/**
+ * f-baileys — Example: QR Code Login
+ * ====================================
+ * npm install f-baileys
+ * node examples/qr-login.js
+ */
+
+const FBaileys = require('f-baileys');
+
+const bot = new FBaileys({
+  sessionPath:    './session',
+  usePairingCode: false,     // false = QR Code mode
+  printQR:        true,      // Print QR to terminal
+  logLevel:       'info',
+  autoReconnect:  true,
+  reconnectDelay: 3000,
+});
+
+// ── Event: QR Generated ──────────────────────
+bot.on('qr', (qr) => {
+  console.log('QR received — scan with WhatsApp!');
+});
+
+// ── Event: Connected ─────────────────────────
+bot.on('open', (sock) => {
+  console.log('✓ Bot connected!');
+});
+
+// ── Event: Message Received ──────────────────
+bot.on('message', async (msg) => {
+  if (msg.fromMe) return;   // Ignore own messages
+
+  console.log(`[${msg.senderNum}]: ${msg.text}`);
+
+  // Ping command
+  if (msg.text?.toLowerCase() === 'ping') {
+    await msg.reply('🏓 Pong! f-baileys is running.');
+    await msg.react('✅');
+  }
+
+  // Info command
+  if (msg.text?.toLowerCase() === '!info') {
+    await msg.reply(`*f-baileys Bot*\nPlatform: ${bot.platform.name}\nNode: ${process.version}`);
+  }
+});
+
+// ── Event: Disconnect ────────────────────────
+bot.on('close', ({ reason }) => {
+  console.log(`Disconnected: ${reason}`);
+});
+
+// ── Start ─────────────────────────────────────
+bot.connect();

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "f-baileys",
+  "version": "1.0.0",
+  "description": "🚀 Fast & Stable WhatsApp Bot Library — Pairing Code + QR Code Support, Multi-Platform (Termux/VPS/Panel), Full Dependency Auto-Installer",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "scripts": {
+    "start": "node src/index.js",
+    "example": "node examples/basic.js",
+    "postinstall": "node scripts/auto-install.js"
+  },
+  "keywords": [
+    "whatsapp",
+    "baileys",
+    "bot",
+    "pairing-code",
+    "qrcode",
+    "whatsapp-bot",
+    "termux",
+    "vps",
+    "multi-device",
+    "f-baileys"
+  ],
+  "author": "f-baileys",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/f-baileys/f-baileys"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "peerDependencies": {
+    "@whiskeysockets/baileys": "^6.7.0"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^6.7.0",
+    "pino": "^8.0.0",
+    "qrcode-terminal": "^0.12.0",
+    "chalk": "^4.1.2",
+    "node-fetch": "^2.7.0",
+    "axios": "^1.6.0",
+    "fs-extra": "^11.2.0",
+    "moment": "^2.30.1",
+    "ora": "^5.4.1",
+    "cli-table3": "^0.6.3"
+  },
+  "optionalDependencies": {
+    "sharp": "^0.33.0",
+    "jimp": "^0.22.12",
+    "fluent-ffmpeg": "^2.1.3",
+    "ffmpeg-static": "^5.2.0",
+    "ytdl-core": "^4.11.5",
+    "webp-converter": "^2.3.0",
+    "color": "^4.2.3",
+    "@ffmpeg/ffmpeg": "^0.12.10"
+  }
+}

package/scripts/auto-install.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+// f-baileys Auto Dependency Installer
+// Detects platform: Termux (fdroid), VPS Linux, Windows, Panel (Pterodactyl)
+
+const { execSync, spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ─────────────────────────────────────────────
+//  COLORS (tanpa chalk karena belum tentu ada)
+// ─────────────────────────────────────────────
+const c = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  red: '\x1b[31m',
+  bold: '\x1b[1m',
+  magenta: '\x1b[35m',
+};
+const log = {
+  info:    (m) => console.log(`${c.cyan}[f-baileys]${c.reset} ${m}`),
+  success: (m) => console.log(`${c.green}[f-baileys] ✓${c.reset} ${m}`),
+  warn:    (m) => console.log(`${c.yellow}[f-baileys] ⚠${c.reset} ${m}`),
+  error:   (m) => console.log(`${c.red}[f-baileys] ✗${c.reset} ${m}`),
+  banner:  ()  => console.log(`
+${c.magenta}${c.bold}
+ ███████╗      ██████╗  █████╗ ██╗██╗     ███████╗██╗   ██╗███████╗
+ ██╔════╝      ██╔══██╗██╔══██╗██║██║     ██╔════╝╚██╗ ██╔╝██╔════╝
+ █████╗  █████╗██████╔╝███████║██║██║     █████╗   ╚████╔╝ ███████╗
+ ██╔══╝  ╚════╝██╔══██╗██╔══██║██║██║     ██╔══╝    ╚██╔╝  ╚════██║
+ ██║           ██████╔╝██║  ██║██║███████╗███████╗   ██║   ███████║
+ ╚═╝           ╚═════╝ ╚═╝  ╚═╝╚═╝╚══════╝╚══════╝   ╚═╝   ╚══════╝
+${c.reset}${c.cyan} Fast & Stable WhatsApp Bot Library v1.0.0${c.reset}
+ ${c.yellow}Pairing Code ✓ | QR Code ✓ | Multi-Platform ✓ | Auto-Install ✓${c.reset}
+`),
+};
+
+// ─────────────────────────────────────────────
+//  PLATFORM DETECTION
+// ─────────────────────────────────────────────
+function detectPlatform() {
+  const platform = {
+    isTermux: false,
+    isVPS: false,
+    isPterodactyl: false,
+    isWindows: false,
+    isMac: false,
+    name: 'unknown',
+    pkgManager: 'npm',
+  };
+
+  // Windows
+  if (os.platform() === 'win32') {
+    platform.isWindows = true;
+    platform.name = 'Windows';
+    return platform;
+  }
+
+  // macOS
+  if (os.platform() === 'darwin') {
+    platform.isMac = true;
+    platform.name = 'macOS';
+    return platform;
+  }
+
+  // Termux detection
+  const termuxIndicators = [
+    process.env.TERMUX_VERSION,
+    process.env.PREFIX && process.env.PREFIX.includes('com.termux'),
+    fs.existsSync('/data/data/com.termux'),
+    fs.existsSync('/data/data/com.termux.fdroid'),
+    process.env.TERMUX_APP_PACKAGE_NAME,
+  ];
+  if (termuxIndicators.some(Boolean)) {
+    platform.isTermux = true;
+    platform.name = 'Termux';
+    platform.pkgManager = 'pkg';
+    return platform;
+  }
+
+  // Pterodactyl Panel detection
+  const pteroIndicators = [
+    process.env.P_SERVER_UUID,
+    process.env.P_SERVER_LOCATION,
+    fs.existsSync('/.dockerenv'),
+    process.env.PTERODACTYL,
+    process.env.SERVER_MEMORY,
+  ];
+  if (pteroIndicators.some(Boolean)) {
+    platform.isPterodactyl = true;
+    platform.name = 'Pterodactyl Panel';
+    return platform;
+  }
+
+  // VPS Linux
+  platform.isVPS = true;
+  platform.name = 'VPS/Linux';
+  return platform;
+}
+
+// ─────────────────────────────────────────────
+//  OPTIONAL DEPENDENCIES TO TRY INSTALL
+// ─────────────────────────────────────────────
+const OPTIONAL_DEPS = [
+  { name: 'sharp',            version: '^0.33.0',  desc: 'Image processing' },
+  { name: 'jimp',             version: '^0.22.12', desc: 'Pure JS image processing' },
+  { name: 'fluent-ffmpeg',    version: '^2.1.3',   desc: 'FFmpeg wrapper' },
+  { name: 'ffmpeg-static',    version: '^5.2.0',   desc: 'Static FFmpeg binary' },
+  { name: 'ytdl-core',        version: '^4.11.5',  desc: 'YouTube downloader' },
+  { name: 'webp-converter',   version: '^2.3.0',   desc: 'WebP conversion' },
+  { name: 'color',            version: '^4.2.3',   desc: 'Color manipulation' },
+];
+
+function isInstalled(pkg) {
+  try {
+    require.resolve(pkg);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installPkg(pkg, platform) {
+  const cmd = `npm install ${pkg} --no-save --legacy-peer-deps 2>&1`;
+  try {
+    execSync(cmd, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ─────────────────────────────────────────────
+//  TERMUX SYSTEM PACKAGES
+// ─────────────────────────────────────────────
+function installTermuxSystemDeps() {
+  const packages = ['ffmpeg', 'nodejs', 'python', 'libwebp'];
+  log.info('Installing Termux system packages...');
+  for (const pkg of packages) {
+    try {
+      execSync(`pkg install -y ${pkg} 2>&1`, { stdio: 'pipe' });
+      log.success(`Termux pkg installed: ${pkg}`);
+    } catch {
+      log.warn(`Skipped (already installed or unavailable): ${pkg}`);
+    }
+  }
+}
+
+// ─────────────────────────────────────────────
+//  MAIN
+// ─────────────────────────────────────────────
+async function main() {
+  log.banner();
+
+  const platform = detectPlatform();
+  log.info(`Platform detected: ${c.bold}${c.green}${platform.name}${c.reset}`);
+
+  // Termux: install system packages first
+  if (platform.isTermux) {
+    log.info('Termux detected — installing system dependencies first...');
+    installTermuxSystemDeps();
+  }
+
+  // Install optional deps
+  log.info('Checking optional dependencies...');
+  let installed = 0, skipped = 0, failed = 0;
+
+  for (const dep of OPTIONAL_DEPS) {
+    if (isInstalled(dep.name)) {
+      log.success(`Already installed: ${dep.name}`);
+      skipped++;
+      continue;
+    }
+    process.stdout.write(`${c.cyan}[f-baileys]${c.reset} Installing ${dep.name} (${dep.desc})... `);
+    const ok = installPkg(`${dep.name}@${dep.version}`, platform);
+    if (ok) {
+      console.log(`${c.green}✓${c.reset}`);
+      installed++;
+    } else {
+      console.log(`${c.yellow}skipped${c.reset}`);
+      failed++;
+    }
+  }
+
+  console.log('');
+  log.success(`Setup complete! ${installed} installed, ${skipped} already present, ${failed} skipped`);
+  log.info(`Use: ${c.bold}${c.cyan}require('f-baileys')${c.reset}`);
+  console.log('');
+}
+
+main().catch((e) => {
+  log.error('Auto-install failed (non-critical): ' + e.message);
+});

package/src/index.d.ts

@@ -0,0 +1,83 @@
+import { EventEmitter } from 'events';
+import { WASocket } from '@whiskeysockets/baileys';
+
+export interface FBaileysOptions {
+  sessionPath?:    string;
+  usePairingCode?: boolean;
+  phoneNumber?:    string;
+  printQR?:        boolean;
+  logLevel?:       'silent' | 'error' | 'warn' | 'info' | 'debug';
+  autoReconnect?:  boolean;
+  reconnectDelay?: number;
+  baileysOptions?: Record<string, any>;
+}
+
+export interface PlatformInfo {
+  isTermux:      boolean;
+  isVPS:         boolean;
+  isPterodactyl: boolean;
+  isWindows:     boolean;
+  isMac:         boolean;
+  isDocker:      boolean;
+  name:          string;
+  arch:          string;
+  nodeVersion:   string;
+}
+
+export interface SerializedMessage {
+  id:         string;
+  from:       string;
+  fromMe:     boolean;
+  pushName:   string;
+  isGroup:    boolean;
+  sender:     string;
+  senderNum:  string;
+  type:       string;
+  body:       string;
+  text:       string;
+  timestamp:  number;
+  isText:     boolean;
+  isImage:    boolean;
+  isVideo:    boolean;
+  isAudio:    boolean;
+  isSticker:  boolean;
+  isDocument: boolean;
+  isPoll:     boolean;
+  mentions:   string[];
+  quoted:     SerializedMessage | null;
+  reply:      (text: string) => Promise<any>;
+  react:      (emoji: string) => Promise<any>;
+}
+
+export declare class FBaileys extends EventEmitter {
+  constructor(options?: FBaileysOptions);
+
+  options:     Required<FBaileysOptions>;
+  sock:        WASocket | null;
+  isConnected: boolean;
+  platform:    PlatformInfo;
+
+  connect(): Promise<WASocket>;
+  sendText(jid: string, text: string, quoted?: any): Promise<any>;
+  sendImage(jid: string, source: string | Buffer, caption?: string, quoted?: any): Promise<any>;
+  sendVideo(jid: string, source: string | Buffer, caption?: string, quoted?: any): Promise<any>;
+  sendAudio(jid: string, source: string | Buffer, ptt?: boolean, quoted?: any): Promise<any>;
+  sendSticker(jid: string, source: string | Buffer, quoted?: any): Promise<any>;
+  sendDocument(jid: string, source: string | Buffer, filename: string, mimetype?: string, quoted?: any): Promise<any>;
+  sendReaction(jid: string, key: any, emoji: string): Promise<any>;
+  sendTyping(jid: string, duration?: number): Promise<void>;
+  downloadMedia(message: any): Promise<Buffer>;
+
+  static toJid(number: string): string;
+  static toGroupJid(id: string): string;
+
+  on(event: 'qr',      listener: (qr: string) => void): this;
+  on(event: 'open',    listener: (sock: WASocket) => void): this;
+  on(event: 'close',   listener: (info: { reason: string; code: number }) => void): this;
+  on(event: 'message', listener: (msg: SerializedMessage) => void): this;
+  on(event: 'logout',  listener: () => void): this;
+  on(event: 'group-update', listener: (update: any) => void): this;
+}
+
+export declare function detectPlatform(): PlatformInfo;
+export default FBaileys;

package/src/index.js

@@ -0,0 +1,264 @@
+'use strict';
+
+/**
+ * ╔═══════════════════════════════════════════════════════╗
+ * ║              f-baileys — Main Entry                   ║
+ * ║   Fast · Stable · Multi-Platform WhatsApp Library     ║
+ * ╚═══════════════════════════════════════════════════════╝
+ */
+
+const { makeWASocket, useMultiFileAuthState, makeCacheableSignalKeyStore,
+        DisconnectReason, fetchLatestBaileysVersion, proto,
+        downloadMediaMessage, getContentType } = require('@whiskeysockets/baileys');
+const pino = require('pino');
+const path = require('path');
+const fs = require('fs');
+const { EventEmitter } = require('events');
+
+const FLogger = require('./logger');
+const { detectPlatform } = require('./platform');
+const { FQR } = require('./qr');
+const { FPairing } = require('./pairing');
+const FSerializer = require('./serializer');
+
+// ─────────────────────────────────────────────
+class FBaileys extends EventEmitter {
+  /**
+   * @param {Object} options
+   * @param {string}  [options.sessionPath]    - Path to save session files
+   * @param {boolean} [options.usePairingCode] - true = pairing code, false = QR
+   * @param {string}  [options.phoneNumber]    - Phone number for pairing code (with country code, no +)
+   * @param {boolean} [options.printQR]        - Auto-print QR to terminal
+   * @param {string}  [options.logLevel]       - 'silent'|'error'|'warn'|'info'|'debug'
+   * @param {boolean} [options.autoReconnect]  - Auto reconnect on disconnect (default: true)
+   * @param {number}  [options.reconnectDelay] - Delay ms before reconnect (default: 3000)
+   * @param {Object}  [options.baileysOptions] - Extra options passed to makeWASocket
+   */
+  constructor(options = {}) {
+    super();
+    this.options = {
+      sessionPath:    options.sessionPath    ?? './f_session',
+      usePairingCode: options.usePairingCode ?? false,
+      phoneNumber:    options.phoneNumber    ?? null,
+      printQR:        options.printQR        ?? true,
+      logLevel:       options.logLevel       ?? 'silent',
+      autoReconnect:  options.autoReconnect  ?? true,
+      reconnectDelay: options.reconnectDelay ?? 3000,
+      baileysOptions: options.baileysOptions ?? {},
+    };
+
+    this.sock        = null;
+    this.isConnected = false;
+    this.platform    = detectPlatform();
+    this.logger      = new FLogger(this.options.logLevel);
+    this._reconnectTimer = null;
+  }
+
+  // ───────────────────────────────────────────
+  //  CONNECT
+  // ───────────────────────────────────────────
+  async connect() {
+    this.logger.banner();
+    this.logger.info(`Platform: ${this.platform.name}`);
+
+    // Ensure session dir exists
+    if (!fs.existsSync(this.options.sessionPath)) {
+      fs.mkdirSync(this.options.sessionPath, { recursive: true });
+    }
+
+    const { state, saveCreds } = await useMultiFileAuthState(this.options.sessionPath);
+    const { version, isLatest } = await fetchLatestBaileysVersion();
+    this.logger.info(`Baileys version: ${version.join('.')} ${isLatest ? '(latest)' : '(update available)'}`);
+
+    const pinoLogger = pino({ level: this.options.logLevel });
+
+    const socketConfig = {
+      version,
+      logger: pinoLogger,
+      printQRInTerminal: false, // We handle QR ourselves
+      auth: {
+        creds: state.creds,
+        keys: makeCacheableSignalKeyStore(state.keys, pinoLogger),
+      },
+      browser: ['f-baileys', 'Chrome', '120.0.0'],
+      connectTimeoutMs: 60_000,
+      defaultQueryTimeoutMs: 30_000,
+      keepAliveIntervalMs: 15_000,
+      retryRequestDelayMs: 500,
+      markOnlineOnConnect: true,
+      syncFullHistory: false,
+      ...this.options.baileysOptions,
+    };
+
+    this.sock = makeWASocket(socketConfig);
+
+    // ── Handle pairing code ──────────────────
+    if (this.options.usePairingCode && !state.creds.registered) {
+      await FPairing.request(this.sock, this.options.phoneNumber, this.logger);
+    }
+
+    // ── Connection updates ───────────────────
+    this.sock.ev.on('connection.update', async (update) => {
+      const { connection, lastDisconnect, qr, isNewLogin } = update;
+
+      if (qr && !this.options.usePairingCode) {
+        if (this.options.printQR) {
+          await FQR.print(qr, this.logger);
+        }
+        this.emit('qr', qr);
+      }
+
+      if (connection === 'open') {
+        this.isConnected = true;
+        clearTimeout(this._reconnectTimer);
+        this.logger.success('Connected to WhatsApp ✓');
+        this.emit('open', this.sock);
+      }
+
+      if (connection === 'close') {
+        this.isConnected = false;
+        const code = lastDisconnect?.error?.output?.statusCode;
+        const reason = Object.keys(DisconnectReason).find(
+          (k) => DisconnectReason[k] === code
+        ) ?? 'Unknown';
+
+        this.logger.warn(`Disconnected — reason: ${reason} (${code})`);
+        this.emit('close', { reason, code });
+
+        // Auto reconnect unless logged out
+        if (code !== DisconnectReason.loggedOut && this.options.autoReconnect) {
+          this.logger.info(`Reconnecting in ${this.options.reconnectDelay}ms...`);
+          this._reconnectTimer = setTimeout(() => this.connect(), this.options.reconnectDelay);
+        } else if (code === DisconnectReason.loggedOut) {
+          this.logger.error('Session logged out — deleting session files');
+          this._clearSession();
+          this.emit('logout');
+        }
+      }
+    });
+
+    // ── Save credentials ─────────────────────
+    this.sock.ev.on('creds.update', saveCreds);
+
+    // ── Messages ─────────────────────────────
+    this.sock.ev.on('messages.upsert', async ({ messages, type }) => {
+      if (type !== 'notify') return;
+      for (const raw of messages) {
+        const msg = FSerializer.serialize(raw, this.sock);
+        this.emit('message', msg);
+      }
+    });
+
+    // ── Group updates ────────────────────────
+    this.sock.ev.on('group-participants.update', (update) => {
+      this.emit('group-update', update);
+    });
+
+    return this.sock;
+  }
+
+  // ───────────────────────────────────────────
+  //  SEND HELPERS
+  // ───────────────────────────────────────────
+  /** Send a text message */
+  async sendText(jid, text, quoted = null) {
+    const content = { text };
+    const opts    = quoted ? { quoted } : {};
+    return this.sock.sendMessage(jid, content, opts);
+  }
+
+  /** Send an image */
+  async sendImage(jid, source, caption = '', quoted = null) {
+    const image = typeof source === 'string' && fs.existsSync(source)
+      ? { image: fs.readFileSync(source) }
+      : { image: { url: source } };
+    return this.sock.sendMessage(jid, { ...image, caption }, quoted ? { quoted } : {});
+  }
+
+  /** Send a video */
+  async sendVideo(jid, source, caption = '', quoted = null) {
+    const video = typeof source === 'string' && fs.existsSync(source)
+      ? { video: fs.readFileSync(source) }
+      : { video: { url: source } };
+    return this.sock.sendMessage(jid, { ...video, caption }, quoted ? { quoted } : {});
+  }
+
+  /** Send audio */
+  async sendAudio(jid, source, ptt = false, quoted = null) {
+    const audio = typeof source === 'string' && fs.existsSync(source)
+      ? { audio: fs.readFileSync(source) }
+      : { audio: { url: source } };
+    return this.sock.sendMessage(jid, { ...audio, ptt, mimetype: 'audio/mpeg' }, quoted ? { quoted } : {});
+  }
+
+  /** Send a sticker */
+  async sendSticker(jid, source, quoted = null) {
+    const sticker = typeof source === 'string' && fs.existsSync(source)
+      ? { sticker: fs.readFileSync(source) }
+      : { sticker: { url: source } };
+    return this.sock.sendMessage(jid, sticker, quoted ? { quoted } : {});
+  }
+
+  /** Send a document */
+  async sendDocument(jid, source, filename, mimetype = 'application/octet-stream', quoted = null) {
+    const document = typeof source === 'string' && fs.existsSync(source)
+      ? { document: fs.readFileSync(source) }
+      : { document: { url: source } };
+    return this.sock.sendMessage(jid, { ...document, fileName: filename, mimetype }, quoted ? { quoted } : {});
+  }
+
+  /** Send a reaction */
+  async sendReaction(jid, key, emoji) {
+    return this.sock.sendMessage(jid, { react: { text: emoji, key } });
+  }
+
+  /** Send typing status */
+  async sendTyping(jid, duration = 2000) {
+    await this.sock.sendPresenceUpdate('composing', jid);
+    await new Promise((r) => setTimeout(r, duration));
+    await this.sock.sendPresenceUpdate('paused', jid);
+  }
+
+  /** Download media from a message */
+  async downloadMedia(message) {
+    return downloadMediaMessage(message, 'buffer', {}, {
+      logger: pino({ level: 'silent' }),
+      reuploadRequest: this.sock.updateMediaMessage,
+    });
+  }
+
+  // ───────────────────────────────────────────
+  //  UTILITY
+  // ───────────────────────────────────────────
+  /** Format phone number to JID */
+  static toJid(number) {
+    return number.replace(/[^0-9]/g, '') + '@s.whatsapp.net';
+  }
+
+  /** Format group JID */
+  static toGroupJid(id) {
+    return id.includes('@g.us') ? id : id + '@g.us';
+  }
+
+  _clearSession() {
+    try {
+      fs.rmSync(this.options.sessionPath, { recursive: true, force: true });
+    } catch { /* ignore */ }
+  }
+}
+
+// ─────────────────────────────────────────────
+//  EXPORTS
+// ─────────────────────────────────────────────
+module.exports = FBaileys;
+module.exports.FBaileys   = FBaileys;
+module.exports.FLogger    = FLogger;
+module.exports.FQR        = FQR;
+module.exports.FPairing   = FPairing;
+module.exports.FSerializer = FSerializer;
+module.exports.detectPlatform = detectPlatform;
+
+// Re-export useful baileys helpers
+module.exports.proto             = proto;
+module.exports.getContentType    = getContentType;
+module.exports.DisconnectReason  = DisconnectReason;

package/src/logger.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const c = {
+  reset:   '\x1b[0m',
+  green:   '\x1b[32m',
+  yellow:  '\x1b[33m',
+  cyan:    '\x1b[36m',
+  red:     '\x1b[31m',
+  bold:    '\x1b[1m',
+  magenta: '\x1b[35m',
+  grey:    '\x1b[90m',
+};
+
+class FLogger {
+  constructor(level = 'info') {
+    this.level = level;
+  }
+
+  _ts() {
+    return c.grey + new Date().toLocaleTimeString() + c.reset;
+  }
+
+  banner() {
+    if (this.level === 'silent') return;
+    console.log(`
+${c.magenta}${c.bold} ███████╗      ██████╗  █████╗ ██╗██╗     ███████╗██╗   ██╗███████╗
+ ██╔════╝      ██╔══██╗██╔══██╗██║██║     ██╔════╝╚██╗ ██╔╝██╔════╝
+ █████╗  █████╗██████╔╝███████║██║██║     █████╗   ╚████╔╝ ███████╗
+ ██╔══╝  ╚════╝██╔══██╗██╔══██║██║██║     ██╔══╝    ╚██╔╝  ╚════██║
+ ██║           ██████╔╝██║  ██║██║███████╗███████╗   ██║   ███████║
+ ╚═╝           ╚═════╝ ╚═╝  ╚═╝╚═╝╚══════╝╚══════╝   ╚═╝   ╚══════╝${c.reset}
+${c.cyan} v1.0.0 — Fast & Stable WhatsApp Library${c.reset}
+`);
+  }
+
+  info(msg)    { if (this.level !== 'silent') console.log(`${this._ts()} ${c.cyan}[INFO]${c.reset}  ${msg}`); }
+  success(msg) { if (this.level !== 'silent') console.log(`${this._ts()} ${c.green}[OK]${c.reset}    ${msg}`); }
+  warn(msg)    { if (!['silent', 'error'].includes(this.level)) console.log(`${this._ts()} ${c.yellow}[WARN]${c.reset}  ${msg}`); }
+  error(msg)   { if (this.level !== 'silent') console.log(`${this._ts()} ${c.red}[ERROR]${c.reset} ${msg}`); }
+  debug(msg)   { if (this.level === 'debug') console.log(`${this._ts()} ${c.grey}[DEBUG]${c.reset} ${msg}`); }
+}
+
+module.exports = FLogger;

package/src/pairing.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * f-baileys — Pairing Code Handler
+ * 100% reliable pairing code delivery
+ */
+
+class FPairing {
+  /**
+   * Request a pairing code from WhatsApp
+   * @param {Object} sock - Baileys socket
+   * @param {string} phoneNumber - Phone number with country code (no + or spaces)
+   * @param {Object} logger - FLogger instance
+   */
+  static async request(sock, phoneNumber, logger) {
+    if (!phoneNumber) {
+      logger.error('Phone number required for pairing code!');
+      logger.info('Set option: { usePairingCode: true, phoneNumber: "628xxxxxxxxxx" }');
+      process.exit(1);
+    }
+
+    // Clean phone number
+    const cleaned = FPairing.cleanNumber(phoneNumber);
+
+    // Wait for socket to be ready
+    await FPairing._waitReady(sock);
+
+    try {
+      logger.info(`Requesting pairing code for: ${cleaned}`);
+
+      const code = await sock.requestPairingCode(cleaned);
+      const formatted = FPairing.formatCode(code);
+
+      FPairing._printCode(formatted, cleaned, logger);
+      return formatted;
+    } catch (err) {
+      logger.error(`Pairing code request failed: ${err.message}`);
+      logger.warn('Retrying in 3 seconds...');
+      await new Promise((r) => setTimeout(r, 3000));
+      return FPairing.request(sock, phoneNumber, logger);
+    }
+  }
+
+  /**
+   * Format raw pairing code into readable format (XXXX-XXXX)
+   */
+  static formatCode(code) {
+    const raw = code.replace(/[^A-Z0-9]/gi, '').toUpperCase();
+    if (raw.length === 8) {
+      return `${raw.slice(0, 4)}-${raw.slice(4, 8)}`;
+    }
+    return raw;
+  }
+
+  /**
+   * Clean phone number: remove spaces, dashes, +
+   */
+  static cleanNumber(number) {
+    return String(number).replace(/[^0-9]/g, '');
+  }
+
+  /**
+   * Wait for socket to initialize before requesting pairing
+   */
+  static _waitReady(sock, timeout = 10000) {
+    return new Promise((resolve) => {
+      // Give socket time to establish websocket connection
+      const t = setTimeout(resolve, 2000);
+      sock.ev.once('connection.update', () => {
+        clearTimeout(t);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Print pairing code to terminal in a styled box
+   */
+  static _printCode(code, phone, logger) {
+    const line = '─'.repeat(36);
+    console.log('');
+    console.log(`\x1b[36m┌${line}┐\x1b[0m`);
+    console.log(`\x1b[36m│\x1b[0m  \x1b[1m\x1b[33m📱 WhatsApp Pairing Code\x1b[0m              \x1b[36m│\x1b[0m`);
+    console.log(`\x1b[36m├${line}┤\x1b[0m`);
+    console.log(`\x1b[36m│\x1b[0m  Phone   : \x1b[32m+${phone}\x1b[0m${' '.repeat(Math.max(0, 22 - phone.length))}\x1b[36m│\x1b[0m`);
+    console.log(`\x1b[36m│\x1b[0m  Code    : \x1b[1m\x1b[35m${code}\x1b[0m${' '.repeat(Math.max(0, 25 - code.length))}\x1b[36m│\x1b[0m`);
+    console.log(`\x1b[36m├${line}┤\x1b[0m`);
+    console.log(`\x1b[36m│\x1b[0m  \x1b[90mSteps: WA → Linked Devices → Link Device\x1b[0m  \x1b[36m│\x1b[0m`);
+    console.log(`\x1b[36m│\x1b[0m  \x1b[90mEnter code above — expires in 60s\x1b[0m       \x1b[36m│\x1b[0m`);
+    console.log(`\x1b[36m└${line}┘\x1b[0m`);
+    console.log('');
+  }
+}
+
+module.exports = { FPairing };

package/src/platform.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const os = require('os');
+const fs = require('fs');
+
+function detectPlatform() {
+  const p = {
+    isTermux: false,
+    isVPS: false,
+    isPterodactyl: false,
+    isWindows: false,
+    isMac: false,
+    isDocker: false,
+    name: 'Unknown',
+    arch: os.arch(),
+    nodeVersion: process.version,
+  };
+
+  if (os.platform() === 'win32') {
+    p.isWindows = true;
+    p.name = 'Windows';
+    return p;
+  }
+
+  if (os.platform() === 'darwin') {
+    p.isMac = true;
+    p.name = 'macOS';
+    return p;
+  }
+
+  // Termux
+  if (
+    process.env.TERMUX_VERSION ||
+    (process.env.PREFIX && process.env.PREFIX.includes('com.termux')) ||
+    fs.existsSync('/data/data/com.termux') ||
+    fs.existsSync('/data/data/com.termux.fdroid') ||
+    process.env.TERMUX_APP_PACKAGE_NAME
+  ) {
+    p.isTermux = true;
+    p.name = process.env.PREFIX?.includes('fdroid')
+      ? 'Termux (F-Droid)'
+      : 'Termux';
+    return p;
+  }
+
+  // Docker / Pterodactyl
+  if (fs.existsSync('/.dockerenv')) {
+    p.isDocker = true;
+    if (
+      process.env.P_SERVER_UUID ||
+      process.env.P_SERVER_LOCATION ||
+      process.env.PTERODACTYL ||
+      process.env.SERVER_MEMORY
+    ) {
+      p.isPterodactyl = true;
+      p.name = 'Pterodactyl Panel';
+    } else {
+      p.name = 'Docker';
+    }
+    return p;
+  }
+
+  // Default: VPS/Linux
+  p.isVPS = true;
+  p.name = `VPS/Linux (${os.release()})`;
+  return p;
+}
+
+module.exports = { detectPlatform };

package/src/qr.js

@@ -0,0 +1,67 @@
+'use strict';
+
+/**
+ * f-baileys — QR Code Handler
+ * Prints QR to terminal and emits QR string
+ */
+
+class FQR {
+  /**
+   * Print QR to terminal
+   * @param {string} qr - QR string from baileys
+   * @param {Object} logger - FLogger instance
+   */
+  static async print(qr, logger) {
+    try {
+      const qrTerminal = require('qrcode-terminal');
+      console.log('');
+      logger.info('Scan QR Code below with WhatsApp:');
+      logger.info('WA → Linked Devices → Link a Device → Scan QR');
+      console.log('');
+      qrTerminal.generate(qr, { small: true });
+      console.log('');
+    } catch {
+      logger.warn('qrcode-terminal not available — QR string emitted as event only');
+      logger.info('Install: npm install qrcode-terminal');
+    }
+  }
+
+  /**
+   * Convert QR string to image buffer (requires 'qrcode' package)
+   * @param {string} qr
+   * @returns {Promise<Buffer>}
+   */
+  static async toBuffer(qr) {
+    try {
+      const QRCode = require('qrcode');
+      return await QRCode.toBuffer(qr, {
+        type: 'png',
+        width: 512,
+        margin: 2,
+        color: { dark: '#128C7E', light: '#FFFFFF' },
+      });
+    } catch {
+      throw new Error('Package "qrcode" required: npm install qrcode');
+    }
+  }
+
+  /**
+   * Convert QR string to base64 data URL
+   * @param {string} qr
+   * @returns {Promise<string>}
+   */
+  static async toDataURL(qr) {
+    try {
+      const QRCode = require('qrcode');
+      return await QRCode.toDataURL(qr, {
+        width: 512,
+        margin: 2,
+        color: { dark: '#128C7E', light: '#FFFFFF' },
+      });
+    } catch {
+      throw new Error('Package "qrcode" required: npm install qrcode');
+    }
+  }
+}
+
+module.exports = { FQR };

package/src/serializer.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * f-baileys — Message Serializer
+ * Makes msg.text, msg.from, msg.isGroup, etc. easy to access
+ */
+
+const { getContentType, proto } = require('@whiskeysockets/baileys');
+
+class FSerializer {
+  /**
+   * Serialize a raw Baileys message into an easy-to-use object
+   * @param {Object} raw - Raw message from Baileys
+   * @param {Object} sock - Baileys socket instance
+   * @returns {Object} Serialized message
+   */
+  static serialize(raw, sock) {
+    const msg = { ...raw };
+
+    // ── Basic info ──────────────────────────
+    msg.key       = raw.key;
+    msg.id        = raw.key.id;
+    msg.from      = raw.key.remoteJid;
+    msg.fromMe    = raw.key.fromMe;
+    msg.pushName  = raw.pushName || '';
+    msg.isGroup   = msg.from?.endsWith('@g.us') ?? false;
+    msg.sender    = msg.isGroup
+      ? (raw.key.participant || raw.participant || '')
+      : (msg.fromMe ? (sock.user?.id ?? '') : msg.from);
+    msg.senderNum = msg.sender.replace(/@.+/g, '');
+    msg.timestamp = raw.messageTimestamp
+      ? (typeof raw.messageTimestamp === 'number'
+          ? raw.messageTimestamp
+          : raw.messageTimestamp.low ?? raw.messageTimestamp)
+      : Date.now() / 1000;
+
+    // ── Content type ────────────────────────
+    const content    = raw.message;
+    msg.type         = getContentType(content) || 'unknown';
+    msg.body         = content?.conversation
+      || content?.extendedTextMessage?.text
+      || content?.imageMessage?.caption
+      || content?.videoMessage?.caption
+      || content?.documentMessage?.caption
+      || '';
+    msg.text         = msg.body;  // alias
+
+    // ── Media flags ─────────────────────────
+    msg.isText       = msg.type === 'conversation' || msg.type === 'extendedTextMessage';
+    msg.isImage      = msg.type === 'imageMessage';
+    msg.isVideo      = msg.type === 'videoMessage';
+    msg.isAudio      = msg.type === 'audioMessage';
+    msg.isSticker    = msg.type === 'stickerMessage';
+    msg.isDocument   = msg.type === 'documentMessage';
+    msg.isContact    = msg.type === 'contactMessage';
+    msg.isLocation   = msg.type === 'locationMessage';
+    msg.isPoll       = msg.type === 'pollCreationMessage';
+
+    // ── Quoted message ──────────────────────
+    const quoted = content?.extendedTextMessage?.contextInfo?.quotedMessage;
+    if (quoted) {
+      const qType  = getContentType(quoted) || 'unknown';
+      msg.quoted   = {
+        type:    qType,
+        message: quoted,
+        body:    quoted?.conversation
+          || quoted?.extendedTextMessage?.text
+          || quoted?.imageMessage?.caption
+          || quoted?.videoMessage?.caption
+          || '',
+        key: {
+          id:         content.extendedTextMessage.contextInfo.stanzaId,
+          remoteJid:  msg.from,
+          fromMe:     content.extendedTextMessage.contextInfo.participant === sock.user?.id,
+          participant: content.extendedTextMessage.contextInfo.participant,
+        },
+      };
+    } else {
+      msg.quoted = null;
+    }
+
+    // ── Mentions ────────────────────────────
+    msg.mentions = content?.extendedTextMessage?.contextInfo?.mentionedJid ?? [];
+
+    // ── Reply helper ─────────────────────────
+    msg.reply = (text) => sock.sendMessage(msg.from, { text }, { quoted: raw });
+
+    // ── React helper ─────────────────────────
+    msg.react = (emoji) => sock.sendMessage(msg.from, { react: { text: emoji, key: raw.key } });
+
+    return msg;
+  }
+}
+
+module.exports = FSerializer;