<<<<<<< HEAD

🚀 Wailey WhatsApp Library v4.4.1

Cea mai puternică și flexibilă bibliotecă WhatsApp pentru Node.js, cu suport dual pentru autentificare (cod QR și cod de asociere)

📋 Cuprins

• 🌟 Noutăți
• ✨ Caracteristici principale
• 🔧 Instalare
• 🚀 Utilizare rapidă
• 📱 Metode de autentificare
  • 🔄 Autentificare cu cod QR
  • 📲 Autentificare cu cod de asociere
• 💡 Exemple complete
• 🔌 Funcționalități avansate
• 🛠️ API Reference
• 📦 Gestionarea sesiunilor
• ⚠️ Soluționarea problemelor
• 📚 Referințe și resurse utile
• 🤝 Contribuții
• 📄 Licență

🌟 Noutăți

Versiunea 4.4.0 aduce îmbunătățiri semnificative:

• ✅ Suport pentru autentificare cu cod de asociere - Conectează-te fără a scana codul QR, direct cu numărul de telefon
• ✅ Fix pentru eroarea "waconnector is not a constructor" - Rezolvare pentru problema raportată frecvent
• ✅ Îmbunătățiri majore de stabilitate - Conexiuni mai robuste și mai puțin întreruperi
• ✅ Emulare browser îmbunătățită - Acum biblioteca se prezintă ca Chrome pe Linux pentru o compatibilitate maximă
• ✅ Mod demo/test - Testează funcționalitățile fără a necesita un număr real de telefon
• ✅ Validare avansată a numerelor de telefon - Suport pentru diverse formate internaționale

✨ Caracteristici principale

• 🔐 Metode duale de autentificare:

  • Scanare tradițională cod QR
  • Cod de asociere cu număr de telefon (nou!)

• 📊 Gestionare avansată a conexiunilor:

  • Reconectare automată
  • Management sesiuni persistente
  • Detecție stare conexiune

• 🔄 Compatibilitate maximizată:

  • WhatsApp Web versiuni noi
  • Multi-device 2.0 support
  • Funcționează pe servere, VPS-uri și Termux

• 📦 Design modular și flexibil:

  • API curat și intuitiv
  • Suport pentru middlewares
  • Gestionare avansată a evenimentelor

🔧 Instalare

Cerințe preliminare:

• Node.js (v14+)
• npm sau yarn

Cod de Asociere (Pairing Code)

Această versiune a bibliotecii suportă autentificarea prin cod de asociere numeric, fără a necesita scanarea codului QR.

Cum funcționează:

1. Inițializați clientul cu opțiunile dorite
2. Apelați metoda requestPairingCode cu numărul de telefon în format internațional
3. Primiți un cod de asociere format din 8 caractere
4. Introduceți acest cod în aplicația WhatsApp de pe telefon

Exemplu de cod:

const whatsapp = require('wailey-whatsapp-lib');

async function main() {
    // Creați și inițializați clientul
    const client = whatsapp.create({
        sessionPath: './session',
        printQRInTerminal: false
    });
    
    await client.initialize();
    
    // Solicitați codul de asociere (număr în format internațional)
    const pairingCode = await client.requestPairingCode('40712345678');
    
    console.log('Codul de asociere:', pairingCode);
    console.log('Introduceți acest cod în aplicația WhatsApp pe telefonul dvs.');
    
    // Așteptați autentificarea
    client.on('authenticated', (user) => {
        console.log('Autentificat ca:', user.name);
    });
}

main().catch(console.error);

Instrucțiuni pentru utilizator:

1. Deschideți WhatsApp pe telefonul mobil
2. Mergeți la Setări > Dispozitive conectate > Conectează un dispozitiv
3. La ecranul cu codul QR, apăsați pe "Conectează cu număr"
4. Introduceți codul afișat de script

Instalare via npm:

======= <<<<<<< HEAD

Wailey WhatsApp Library

O biblioteca WhatsApp Web API modificată care suportă atât autentificarea prin cod QR, cât și prin coduri de asociere pentru numere de telefon.

Caracteristici

• ✅ Autentificare prin Cod QR (scanare)
• ✅ Autentificare prin Cod de Asociere (pairing code)
• ✅ Mod Demo pentru testare fără numere reale
• ✅ Optimizat pentru conexiuni stabile

Cod de Asociere (Pairing Code)

Această versiune a bibliotecii suportă autentificarea prin cod de asociere numeric, fără a necesita scanarea codului QR.

Cum funcționează:

1. Inițializați clientul cu opțiunile dorite
2. Apelați metoda requestPairingCode cu numărul de telefon în format internațional
3. Primiți un cod de asociere format din 8 caractere
4. Introduceți acest cod în aplicația WhatsApp de pe telefon

Exemplu de cod:

const whatsapp = require('wailey-whatsapp-lib');

async function main() {
    // Creați și inițializați clientul
    const client = whatsapp.create({
        sessionPath: './session',
        printQRInTerminal: false
    });
    
    await client.initialize();
    
    // Solicitați codul de asociere (număr în format internațional)
    const pairingCode = await client.requestPairingCode('40712345678');
    
    console.log('Codul de asociere:', pairingCode);
    console.log('Introduceți acest cod în aplicația WhatsApp pe telefonul dvs.');
    
    // Așteptați autentificarea
    client.on('authenticated', (user) => {
        console.log('Autentificat ca:', user.name);
    });
}

main().catch(console.error);

Instrucțiuni pentru utilizator:

1. Deschideți WhatsApp pe telefonul mobil
2. Mergeți la Setări > Dispozitive conectate > Conectează un dispozitiv
3. La ecranul cu codul QR, apăsați pe "Conectează cu număr"
4. Introduceți codul afișat de script

Instalare

=======

Wailey WhatsApp Library v4.4.0

A robust WhatsApp library for Node.js with support for QR code and pairing code authentication

Overview

Wailey WhatsApp library is a reliable Node.js library for WhatsApp integration that allows you to connect to WhatsApp Web API. This library supports both QR code authentication and pairing code authentication methods.

Version 4.4.0 Important Updates:

• ✅ Fixed QR code generation and display
• ✅ Fixed pairing code authentication
• ✅ Improved AuthState management for stable sessions
• ✅ Enhanced connection stability with automatic reconnection
• ✅ Resolved module compatibility issues (ESM vs CommonJS)

Installation

a86b85ca9bd6630c8e744870cecbbfc908021c99 3a1140c (Rezolvat eroarea WAConnection is not a constructor și optimizat biblioteca)

npm install wailey-whatsapp-lib

<<<<<<< HEAD

Generare Cod de Asociere pentru WhatsApp

Biblioteca suportă generarea codurilor de asociere pentru autentificare prin număr de telefon, fără a necesita scanarea unui cod QR în prealabil.

const { create } = require('wailey-whatsapp-lib');

async function example() {
  const client = create({
    printQRInTerminal: false,
    sessionPath: './session'
  });
  
  client.on('pairing_code', (code) => {
    console.log(`Cod de asociere: ${code}`);
    console.log('Introdu acest cod în aplicația WhatsApp pe telefonul tău');
  });
  
  await client.initialize();
  
  // Solicită cod de asociere pentru numărul tău
  await client.requestPairingCode('40712345678');
}

example();

Vezi examples/pairing-code-example.js pentru un exemplu complet.

Cod de Asociere (Pairing Code)

Această versiune a bibliotecii suportă autentificarea prin cod de asociere numeric, fără a necesita scanarea codului QR.

Cum funcționează:

1. Inițializați clientul cu opțiunile dorite
2. Apelați metoda requestPairingCode cu numărul de telefon în format internațional
3. Primiți un cod de asociere format din 8 caractere
4. Introduceți acest cod în aplicația WhatsApp de pe telefon

Exemplu de cod:

const whatsapp = require('wailey-whatsapp-lib');

async function main() {
    // Creați și inițializați clientul
    const client = whatsapp.create({
        sessionPath: './session',
        printQRInTerminal: false
    });
    
    await client.initialize();
    
    // Solicitați codul de asociere (număr în format internațional)
    const pairingCode = await client.requestPairingCode('40712345678');
    
    console.log('Codul de asociere:', pairingCode);
    console.log('Introduceți acest cod în aplicația WhatsApp pe telefonul dvs.');
    
    // Așteptați autentificarea
    client.on('authenticated', (user) => {
        console.log('Autentificat ca:', user.name);
    });
}

main().catch(console.error);

Instrucțiuni pentru utilizator:

1. Deschideți WhatsApp pe telefonul mobil
2. Mergeți la Setări > Dispozitive conectate > Conectează un dispozitiv
3. La ecranul cu codul QR, apăsați pe "Conectează cu număr"
4. Introduceți codul afișat de script

Instalare via yarn:

yarn add wailey-whatsapp-lib

Cod de Asociere (Pairing Code)

Această versiune a bibliotecii suportă autentificarea prin cod de asociere numeric, fără a necesita scanarea codului QR.

Cum funcționează:

1. Inițializați clientul cu opțiunile dorite
2. Apelați metoda requestPairingCode cu numărul de telefon în format internațional
3. Primiți un cod de asociere format din 8 caractere
4. Introduceți acest cod în aplicația WhatsApp de pe telefon

Exemplu de cod:

const whatsapp = require('wailey-whatsapp-lib');

async function main() {
    // Creați și inițializați clientul
    const client = whatsapp.create({
        sessionPath: './session',
        printQRInTerminal: false
    });
    
    await client.initialize();
    
    // Solicitați codul de asociere (număr în format internațional)
    const pairingCode = await client.requestPairingCode('40712345678');
    
    console.log('Codul de asociere:', pairingCode);
    console.log('Introduceți acest cod în aplicația WhatsApp pe telefonul dvs.');
    
    // Așteptați autentificarea
    client.on('authenticated', (user) => {
        console.log('Autentificat ca:', user.name);
    });
}

main().catch(console.error);

Instrucțiuni pentru utilizator:

1. Deschideți WhatsApp pe telefonul mobil
2. Mergeți la Setări > Dispozitive conectate > Conectează un dispozitiv
3. La ecranul cu codul QR, apăsați pe "Conectează cu număr"
4. Introduceți codul afișat de script

Instalare directă din GitHub:

npm install git+https://github.com/gyovannyvpn123/wailey-whatsapp-lib.git

🚀 Utilizare rapidă

Iată un exemplu simplu pentru a porni rapid:

<<<<<<< HEAD

Utilizare

Inițializare

3a1140c (Rezolvat eroarea WAConnection is not a constructor și optimizat biblioteca)

const whatsapp = require('wailey-whatsapp-lib');

<<<<<<< HEAD
// Creare instanță client
const client = whatsapp.create({
  puppeteer: {
    headless: 'new', // Recomandat pentru servere
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  }
});

// Gestionare evenimente
client.on(whatsapp.Events.QR_CODE, (qr) => {
  console.log('Scanează acest cod QR în WhatsApp: ', qr);
});

client.on(whatsapp.Events.PAIRING_CODE, (code) => {
  console.log('Cod de asociere primit: ' + code);
  console.log('Folosește acest cod pentru a conecta telefonul tău!');
});

client.on(whatsapp.Events.AUTHENTICATED, () => {
  console.log('Autentificat cu succes!');
});

client.on(whatsapp.Events.READY, () => {
  console.log('Client pregătit pentru utilizare!');
});

// Inițializare client
client.initialize();

// Opțional: solicită un cod de asociere pentru autentificare
// cu număr de telefon (fără + la început, doar cifre)
setTimeout(async () => {
  try {
    await client.requestPairingCode('4075646XXXX'); // Înlocuiește cu numărul tău real
  } catch (err) {
    console.error('Eroare la solicitarea codului de asociere:', err.message);
  }
}, 2000);

📱 Metode de autentificare

🔄 Autentificare cu cod QR

Metoda tradițională de autentificare utilizând un cod QR:

const whatsapp = require('wailey-whatsapp-lib');
const qrcode = require('qrcode-terminal'); // Optional pentru afișarea în terminal

const client = whatsapp.create();

client.on(whatsapp.Events.QR_CODE, (qr) => {
  // Afișează codul QR în terminal (opțional)
  qrcode.generate(qr, {small: true});
  console.log('Scanează acest cod QR cu aplicația WhatsApp de pe telefon');
});

client.on(whatsapp.Events.AUTHENTICATED, () => {
  console.log('Autentificat cu succes!');
});

client.initialize();

📲 Autentificare cu cod de asociere

Metoda nouă de autentificare utilizând un cod de asociere și număr de telefon:

const whatsapp = require('wailey-whatsapp-lib');

const client = whatsapp.create();

client.on(whatsapp.Events.PAIRING_CODE, (code) => {
  console.log('=============COD DE ASOCIERE=============');
  console.log('Utilizează acest cod pentru a asocia telefonul: ' + code);
  console.log('Deschide WhatsApp > Setări > Dispozitive conectate > Conectează un dispozitiv');
  console.log('=========================================');
});

client.on(whatsapp.Events.AUTHENTICATED, () => {
  console.log('Autentificat cu succes!');
});

client.initialize();

// Solicită un cod de asociere pentru autentificare
// Notă: așteaptă puțin timp după initialize() înainte de a solicita codul
setTimeout(async () => {
  try {
    // Numărul în format internațional fără "+" (exemplu: 4075646XXXX)
    await client.requestPairingCode('4075646XXXX'); 
  } catch (err) {
    console.error('Eroare la solicitarea codului de asociere:', err.message);
  }
}, 2000);

💡 Exemple complete

Script demo complet pentru testare rapidă:

const whatsapp = require('wailey-whatsapp-lib');

// Funcție pentru afișare ASCII art
function printBanner() {
  console.log('');
  console.log('╭──────────────────────────────────────────────────╮');
  console.log('│ 🚀 WAILEY WHATSAPP LIBRARY v4.4.0                │');
  console.log('│ ✨ Demo pentru autentificare QR și cod asociere  │');
  console.log('╰──────────────────────────────────────────────────╯');
  console.log('');
}

// Afișare banner
printBanner();

// Creare client WhatsApp
const client = whatsapp.create({
  puppeteer: {
    headless: 'new',
    args: ['--no-sandbox', '--disable-setuid-sandbox']
  }
});

// Gestionare evenimente
console.log('🔄 Inițializare client WhatsApp...');

client.on(whatsapp.Events.QR_CODE, (qr) => {
  console.log('╭─────────────────────────────────────────────╮');
  console.log('│ 📱 COD QR PRIMIT                            │');
  console.log('│ Scanează acest cod în WhatsApp pentru login │');
  console.log('╰─────────────────────────────────────────────╯');
});

client.on(whatsapp.Events.PAIRING_CODE, (code) => {
  console.log('╭─────────────────────────────────────────────╮');
  console.log('│ 🔐 COD DE ASOCIERE PRIMIT                   │');
  console.log(`│ Cod: ${code}                                │`);
  console.log('│ Instrucțiuni:                               │');
  console.log('│ 1. Deschide WhatsApp pe telefonul tău       │');
  console.log('│ 2. Accesează Setări > Dispozitive conectate │');
  console.log('│ 3. Selectează "Conectează un dispozitiv"    │');
  console.log('│ 4. Introdu codul afișat mai sus             │');
  console.log('╰─────────────────────────────────────────────╯');
});

client.on(whatsapp.Events.AUTHENTICATED, () => {
  console.log('✅ AUTENTIFICAT CU SUCCES!');
});

client.on(whatsapp.Events.READY, () => {
  console.log('🚀 Client pregătit pentru utilizare!');
});

client.on(whatsapp.Events.ERROR, (err) => {
  console.error('❌ EROARE:', err);
});

// Inițializare client
console.log('🔄 Inițializare...');
client.initialize().then(() => {
  console.log('✅ Inițializare completă');
  
  // Solicită un cod de asociere după 2 secunde
  setTimeout(async () => {
    try {
      console.log('🔄 Solicitare cod de asociere...');
      await client.requestPairingCode('4075646XXXX'); // Folosește un număr de test
    } catch (err) {
      console.error('❌ Eroare la solicitarea codului de asociere:', err.message);
    }
  }, 2000);
});

// Oprește clientul după 30 secunde (doar pentru demo)
setTimeout(async () => {
  console.log('⏱️ Demo finalizat, închidere client...');
  await client.destroy();
  process.exit(0);
}, 30000);

Exemplu pentru aplicație web (Express):

const express = require('express');
const whatsapp = require('wailey-whatsapp-lib');
const qrcode = require('qrcode');

const app = express();
const port = 3000;

// Setare middleware și configurări Express
app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static('public'));
app.set('view engine', 'ejs');

// Variabile globale
let whatsappClient;
let currentQR = '';
let currentPairingCode = '';
let connectionStatus = 'Deconectat';

// Creare client WhatsApp
function initializeWhatsAppClient() {
  whatsappClient = whatsapp.create({
    puppeteer: {
      headless: 'new',
      args: ['--no-sandbox', '--disable-setuid-sandbox']
    }
  });

  whatsappClient.on(whatsapp.Events.QR_CODE, (qr) => {
    currentQR = qr;
    connectionStatus = 'Așteptare scanare cod QR';
    console.log('Cod QR nou generat');
  });

  whatsappClient.on(whatsapp.Events.PAIRING_CODE, (code) => {
    currentPairingCode = code;
    connectionStatus = 'Așteptare introducere cod de asociere';
    console.log(`Cod de asociere generat: ${code}`);
  });

  whatsappClient.on(whatsapp.Events.AUTHENTICATED, () => {
    connectionStatus = 'Autentificat';
    console.log('Autentificat cu succes!');
  });

  whatsappClient.on(whatsapp.Events.READY, () => {
    connectionStatus = 'Pregătit';
    console.log('Client WhatsApp pregătit');
  });

  whatsappClient.on(whatsapp.Events.ERROR, (err) => {
    connectionStatus = `Eroare: ${err.message}`;
    console.error('Eroare client WhatsApp:', err);
  });

  // Inițializare client
  whatsappClient.initialize().catch(error => {
    console.error('Eroare la inițializarea clientului WhatsApp:', error);
    connectionStatus = `Eroare la inițializare: ${error.message}`;
  });
}

// Rute
app.get('/', (req, res) => {
  res.render('index', { 
    status: connectionStatus,
    hasPairingCode: currentPairingCode !== ''
  });
});

app.get('/qr', async (req, res) => {
  if (!currentQR) {
    return res.status(404).send('Niciun cod QR disponibil');
  }
  
  try {
    const qrImage = await qrcode.toDataURL(currentQR);
    res.send(`<img src="${qrImage}" alt="WhatsApp QR Code">`);
  } catch (err) {
    res.status(500).send('Eroare la generarea imaginii QR');
  }
});

app.get('/status', (req, res) => {
  res.json({
    status: connectionStatus,
    hasPairingCode: currentPairingCode !== '',
    pairingCode: currentPairingCode
  });
});

app.post('/request-pairing-code', async (req, res) => {
  const { phoneNumber } = req.body;
  
  if (!phoneNumber) {
    return res.status(400).json({ success: false, message: 'Numărul de telefon este obligatoriu' });
  }
  
  try {
    await whatsappClient.requestPairingCode(phoneNumber);
    res.json({ success: true, message: 'Cod de asociere solicitat cu succes' });
  } catch (err) {
    res.status(500).json({ success: false, message: err.message });
  }
});

app.post('/logout', async (req, res) => {
  if (whatsappClient) {
    try {
      await whatsappClient.logout();
      await whatsappClient.destroy();
      
      // Resetare variabile
      currentQR = '';
      currentPairingCode = '';
      connectionStatus = 'Deconectat';
      
      // Reinițializare client
      initializeWhatsAppClient();
      
      res.json({ success: true, message: 'Deconectat cu succes' });
    } catch (err) {
      res.status(500).json({ success: false, message: err.message });
    }
  } else {
    res.json({ success: true, message: 'Niciun client activ' });
  }
});

// Inițializare client WhatsApp și pornire server
initializeWhatsAppClient();

app.listen(port, () => {
  console.log(`Server pornit la adresa http://localhost:${port}`);
});

🔌 Funcționalități avansate

Gestionarea evenimentelor:

// Evenimentele disponibile
const events = {
  QR_CODE: 'qrCode',           // Cod QR generat
  PAIRING_CODE: 'pairingCode', // Cod de asociere generat
  AUTHENTICATED: 'authenticated', // Autentificare reușită
  READY: 'ready',              // Client pregătit
  DISCONNECTED: 'disconnected', // Deconectat
  ERROR: 'error'               // Eroare
};

// Exemplu de gestionare a evenimentelor
client.on(events.QR_CODE, (qr) => {
  // Manipulare cod QR
});

client.on(events.PAIRING_CODE, (code) => {
  // Manipulare cod de asociere
});

client.on(events.AUTHENTICATED, () => {
  // Manipulare autentificare reușită
});

client.on(events.READY, () => {
  // Client pregătit pentru utilizare
});

client.on(events.DISCONNECTED, () => {
  // Manipulare deconectare
});

client.on(events.ERROR, (error) => {
  // Manipulare eroare
});

Configurații avansate:

const client = whatsapp.create({
  // Opțiuni Puppeteer
  puppeteer: {
    headless: 'new',           // 'new' pentru modul headless
    args: [
      '--no-sandbox',
      '--disable-setuid-sandbox',
      '--disable-gpu',
      '--disable-dev-shm-usage'
    ],
    defaultViewport: null,
    executablePath: '/path/to/chrome' // Opțional: cale către executabil Chrome
  },
  
  // Opțiuni conexiune
  connectionOptions: {
    maxRetries: 5,             // Număr maxim de încercări de reconectare
    retryDelay: 3000,          // Întârziere între încercări (ms)
    maxQrAttempts: 3           // Număr maxim de încercări de generare QR
  },
  
  // Gestionare sesiune
  session: {
    storePath: './whatsapp-session', // Director pentru stocarea sesiunii
    saveCredentials: true,     // Salvare automată credențiale
    restoreSessions: true      // Restaurare automată sesiuni
  },
  
  // Opțiuni utilizator
  userAgent: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36', // User agent custom
  browserName: 'Chrome',       // Nume browser
  browserVersion: '123.0.0.0', // Versiune browser
  platformName: 'Linux'        // Platformă
});

🛠️ API Reference

Metode principale:

| Metodă | Descriere | Parametri | Răspuns | |--------|-----------|-----------|---------| | create(options) | Crează o nouă instanță client | options: Obiect configurare | Client | | initialize() | Inițializează clientul și conexiunea | - | Promise<void> | | requestPairingCode(phoneNumber) | Solicită un cod de asociere | phoneNumber: String | Promise<string> | | getQrCode() | Obține codul QR curent | - | Promise<string> | | isAuthenticated() | Verifică dacă clientul este autentificat | - | boolean | | logout() | Deconectare de la WhatsApp Web | - | Promise<boolean> | | destroy() | Închide conexiunea și browser-ul | - | Promise<void> |

Evenimente importante:

| Eveniment | Descriere | Callback Parametri | |-----------|-----------|-------------------| | QR_CODE | Emis când se generează un cod QR | (qrString) | | PAIRING_CODE | Emis când se generează un cod de asociere | (pairingCode) | | AUTHENTICATED | Emis la autentificare reușită | - | | READY | Emis când clientul e pregătit pentru utilizare | - | | DISCONNECTED | Emis la deconectare | - | | ERROR | Emis când apare o eroare | (errorObject) |

📦 Gestionarea sesiunilor

Biblioteca suportă gestionarea sesiunilor pentru a evita re-autentificarea constantă:

const whatsapp = require('wailey-whatsapp-lib');

// Configurare client cu gestionare de sesiune
const client = whatsapp.create({
  session: {
    storePath: './whatsapp-session', // Directorul unde va fi stocată sesiunea
    saveCredentials: true,           // Salvează automat credențialele
    restoreSessions: true            // Încearcă automat restaurarea sesiunilor salvate
  }
});

// Restul codului...
client.initialize();

⚠️ Soluționarea problemelor

Problema: Eroarea "waconnector is not a constructor"

Soluție: Utilizează corect metoda create() pentru instanțierea clientului:

const whatsapp = require('wailey-whatsapp-lib');

// Corect:
const client = whatsapp.create();

// Incorect:
// const client = new whatsapp.waconnector();

Problema: Conexiune închisă după solicitarea codului de asociere

Soluție: Asigură-te că folosești un număr de telefon valid și formatul corect:

// Format corect: fără "+" sau alte caractere, doar cifrele
await client.requestPairingCode('4075646XXXX');

// Format incorect:
// await client.requestPairingCode('+4075646XXXX');
// await client.requestPairingCode('0075646XXXX');

Problema: Erori de browser/Puppeteer

Soluție: Asigură-te că folosești configurațiile corecte pentru environment-ul tău:

const client = whatsapp.create({
  puppeteer: {
    headless: 'new',
    args: [
      '--no-sandbox',
      '--disable-setuid-sandbox',
      '--disable-dev-shm-usage',
      '--disable-accelerated-2d-canvas',
      '--no-first-run',
      '--no-zygote',
      '--single-process',
      '--disable-gpu'
    ]
  }
});

Problema: Probleme pe Termux/Android

Soluție: Folosește scriptul de instalare specific pentru Termux:

bash -c "$(curl -fsSL https://raw.githubusercontent.com/gyovannyvpn123/wailey-whatsapp-lib/main/fix-termux.sh)"

📚 Referințe și resurse utile

• Documentație oficială WhatsApp Business API
• Ghid multidevice WhatsApp
• Puppeteer API

🤝 Contribuții

Contribuțiile sunt întotdeauna binevenite! Dacă ai îmbunătățiri sau corecții:

1. Fork la repository
2. Creează branch-ul tău (git checkout -b feature/amazing-feature)
3. Commit schimbările (git commit -m 'Add some amazing feature')
4. Push la branch (git push origin feature/amazing-feature)
5. Deschide un Pull Request

📄 Licență

Acest proiect este licențiat sub Licența MIT.

Autor

🧑‍💻 gyovannyvpn123

🙏 Dezvoltat pe baza proiectului original wailey-whatsapp-lib, cu modificări și îmbunătățiri semnificative.

⭐ Nu uita să apreciezi acest proiect cu un star pe GitHub! ⭐

const client = whatsapp.create({ // Opțional: Folder pentru stocarea sesiunii sessionPath: './whatsapp-session' });

// Ascultă evenimente client.on(whatsapp.Events.QR_CODE, (qr) => { console.log('Cod QR primit:', qr); });

client.on(whatsapp.Events.PAIRING_CODE, (code) => { console.log('Cod de asociere primit:', code); });

client.on(whatsapp.Events.AUTHENTICATED, () => { console.log('Autentificat cu succes!'); });

client.on(whatsapp.Events.READY, () => { console.log('Client pregătit!'); });

// Inițializare client.initialize();

### Autentificare prin Cod QR

Codul QR va fi generat automat la inițializare și emis prin evenimentul `QR_CODE`. Poți afișa acest cod pentru ca utilizatorul să-l scaneze.

```javascript
const qrcode = require('qrcode-terminal');

client.on(whatsapp.Events.QR_CODE, (qr) => {
    // Afișează codul QR în terminal
    qrcode.generate(qr, { small: true });
    console.log('Scanează acest cod QR în aplicația WhatsApp');
});

Autentificare prin Cod de Asociere

// Solicită un cod de asociere pentru un număr de telefon
async function requestPairingCode(phoneNumber) {
    try {
        await client.requestPairingCode(phoneNumber);
        // Codul de asociere va fi emis prin evenimentul PAIRING_CODE
    } catch (error) {
        console.error('Eroare:', error.message);
    }
}

// Procesează codul de asociere primit
client.on(whatsapp.Events.PAIRING_CODE, (code) => {
    console.log('Folosește acest cod în aplicația WhatsApp:', code);
    console.log('1. Deschide WhatsApp pe telefon');
    console.log('2. Mergi la Setări > Dispozitive conectate');
    console.log('3. Apasă pe "Conectează un dispozitiv"');
    console.log('4. Când apare scanarea codului QR, apasă "CONECTARE CU NUMĂR DE TELEFON"');
    console.log('5. Introdu numărul de telefon și codul de 8 cifre de mai sus');
});

Note Importante

1. Autentificarea cu cod de asociere în mediul real:

   • WhatsApp necesită o sesiune activă pentru a genera coduri de asociere reale.
   • În unele cazuri, este necesar să scanezi întâi un cod QR pentru a stabili conexiunea inițială.
   • După autentificarea inițială, codul de asociere va funcționa corect.

2. Mod Demo:

   • Pentru a testa biblioteca fără un număr real, folosește un număr cu "XXXX" în el (ex: "+4075646XXXX").
   • Biblioteca va detecta automat modul demo și va genera un cod de asociere de test.

3. Format Numere de Telefon:

   • Folosește formatul internațional cu prefix "+" (exemplu: "+40748123456").

Exemple

Vezi fișierul demo.js pentru un exemplu complet care arată ambele metode de autentificare.

Licență

=======

Features

• Multiple authentication methods:
  • QR Code authentication (scan with your phone)
  • Pairing Code authentication (enter a code on your phone)
• Persistent session management
• Message handling (sending/receiving text and media)
• Event-based architecture
• Automatic reconnection
• Comprehensive error handling

Quick Start

Authentication with QR Code

const { WAConnection } = require('wailey-whatsapp-lib');

// Create a new instance
const client = new WAConnection({
  authStateDir: './auth_info',
  debug: true,
  printQRInTerminal: true,
  session: 'my-session'
});

// Connect with QR code
async function start() {
  try {
    await client.connectWithQR();
    
    // Register event handlers
    client.on('message', (message) => {
      console.log('New message:', message);
    });
    
    // Send a message after connected
    client.on('ready', async () => {
      console.log('Client is ready!');
      
      // Send a message
      await client.sendTextMessage('[email protected]', 'Hello from Wailey WhatsApp Library!');
    });
    
  } catch (error) {
    console.error('Connection error:', error);
  }
}

start();

Authentication with Pairing Code

const { WAConnection } = require('wailey-whatsapp-lib');

// Create a new instance
const client = new WAConnection({
  authStateDir: './auth_info',
  debug: true,
  session: 'my-session'
});

// Connect with pairing code
async function start() {
  try {
    // The phone number should be without any formatting (no +, spaces, etc.)
    const phoneNumber = '1234567890'; // Replace with your phone number
    
    const result = await client.connectWithPairingCode(phoneNumber);
    console.log('Pairing code:', result.code);
    
    // Register event handlers
    client.on('ready', () => {
      console.log('Client is ready!');
    });
    
  } catch (error) {
    console.error('Connection error:', error);
  }
}

start();

API Reference

WAConnection Class

The main class for WhatsApp connection.

Constructor Options

const client = new WAConnection({
  // Required options
  authStateDir: './auth_info',  // Directory to store auth data
  session: 'my-session',        // Session name
  
  // Optional options
  debug: true,                  // Enable debugging
  printQRInTerminal: true,      // Print QR code in terminal
  reconnect: true,              // Auto reconnect on disconnect
  maxReconnectAttempts: 5,      // Maximum reconnection attempts
  connectTimeout: 60000,        // Connection timeout in ms
  qrTimeout: 60000,             // QR code timeout in ms
  logLevel: 'info'              // Log level: debug, info, warn, error
});

Methods

• connectWithQR(): Connect to WhatsApp using QR code authentication
• connectWithPairingCode(phoneNumber): Connect to WhatsApp using pairing code authentication
• sendTextMessage(to, text, options): Send a text message
• sendMediaMessage(to, media, options): Send a media message (image, video, document)
• getStatus(): Get connection status
• logout(): Logout and clear session data
• disconnect(): Disconnect from WhatsApp
• on(event, listener): Register event listener
• off(event, listener): Remove event listener
• once(event, listener): Register one-time event listener

Events

• qr: Emitted when QR code is received
• pairing_code: Emitted when pairing code is received
• ready: Emitted when connection is ready
• message: Emitted when new message is received
• message.new: Emitted when a new message is received
• message.update: Emitted when a message is updated
• disconnected: Emitted when disconnected
• connecting: Emitted when connecting
• connection.update: Emitted when connection status changes
• error: Emitted when an error occurs

License

a86b85ca9bd6630c8e744870cecbbfc908021c99

MIT

3a1140c (Rezolvat eroarea WAConnection is not a constructor și optimizat biblioteca)