@sasadevofc/baileys 1.0.0-beta.1

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@sasadevofc/baileys",
+  "version": "1.0.0-beta.1",
+  "description": "Ultra-modern WhatsApp Web automation library for bots and tools. Multi-device. Fast. Developer-first.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint src --ext .ts",
+    "test": "jest --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "whatsapp",
+    "whatsapp-web",
+    "whatsapp-bot",
+    "whatsapp-api",
+    "baileys",
+    "sasadev",
+    "multi-device",
+    "automation"
+  ],
+  "author": "SASA DEV <dev@sasadev.com>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sasadev/baileys.git"
+  },
+  "dependencies": {
+    "protobufjs": "^7.2.5",
+    "pino": "^8.16.0",
+    "ws": "^8.14.2",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.5.0",
+    "@types/ws": "^8.5.5",
+    "@types/uuid": "^9.0.2",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "@typescript-eslint/parser": "^6.4.0",
+    "eslint": "^8.47.0",
+    "jest": "^29.6.2",
+    "ts-jest": "^29.1.1",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  }
+}

package/src/auth/pairing.ts

@@ -0,0 +1,11 @@
+import { BaileysClient } from '../client';
+export class PairingHelper {
+  private client: BaileysClient;
+  constructor(client: BaileysClient) { this.client = client; }
+
+  async requestCode(phoneNumber: string): Promise<string> {
+    // Placeholder: would call WhatsApp pairing API
+    const code = '12345';
+    return code;
+  }
+}

package/src/auth/state.ts

@@ -0,0 +1,66 @@
+import { BaileysClient } from '../client';
+import { AuthState, Credentials } from '../types/auth';
+import { AuthStore } from './store';
+import { v4 as uuidv4 } from 'uuid';
+import { PairingHelper } from './pairing';
+
+export class AuthManager {
+  private client: BaileysClient;
+  private store: AuthStore;
+  private state: AuthState | null = null;
+
+  constructor(client: BaileysClient) {
+    this.client = client;
+    this.store = new AuthStore(); // can be replaced with custom store
+  }
+
+  async loadSession(sessionId?: string): Promise<AuthState | null> {
+    const id = sessionId || 'default';
+    const data = await this.store.load(id);
+    if (data) {
+      this.state = data;
+      return data;
+    }
+    return null;
+  }
+
+  async createSession(): Promise<AuthState> {
+    // Generate new keys (simplified)
+    const state: AuthState = {
+      creds: {
+        clientId: uuidv4(),
+        serverToken: '',
+        clientToken: '',
+        encKey: Buffer.alloc(32),
+        macKey: Buffer.alloc(32),
+      },
+      keys: {
+        registrationId: Math.floor(Math.random() * 16384),
+        identityKey: new Uint8Array(32),
+        signedPreKey: {
+          keyId: 1,
+          keyPair: { public: new Uint8Array(32), private: new Uint8Array(32) },
+          signature: new Uint8Array(64),
+        },
+        preKeys: [],
+      },
+    };
+    this.state = state;
+    await this.store.save('default', state);
+    return state;
+  }
+
+  async saveSession(sessionId?: string) {
+    if (!this.state) return;
+    await this.store.save(sessionId || 'default', this.state);
+  }
+
+  getCredentials(): Credentials | undefined {
+    return this.state?.creds;
+  }
+
+  // Pairing code helper
+  async startPairing(phoneNumber: string): Promise<string> {
+    return new PairingHelper(this.client).requestCode(phoneNumber);
+  }
+}

package/src/auth/store.ts

@@ -0,0 +1,26 @@
+import { AuthState } from '../types/auth';
+
+export interface IAuthStore {
+  load(sessionId: string): Promise<AuthState | null>;
+  save(sessionId: string, state: AuthState): Promise<void>;
+  delete(sessionId: string): Promise<void>;
+}
+
+/**
+ * Default in‑memory store. For production use a persistent store (JSON file, DB, etc.)
+ */
+export class AuthStore implements IAuthStore {
+  private cache = new Map<string, AuthState>();
+
+  async load(sessionId: string): Promise<AuthState | null> {
+    return this.cache.get(sessionId) || null;
+  }
+
+  async save(sessionId: string, state: AuthState): Promise<void> {
+    this.cache.set(sessionId, state);
+  }
+
+  async delete(sessionId: string): Promise<void> {
+    this.cache.delete(sessionId);
+  }
+}

package/src/client.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from 'events';
+import { BaileysEventMap, ConnectionUpdate } from './types/events';
+import { AuthState } from './types/auth';
+import { SocketConfig, WALoginMethod } from './types/socket';
+import { AuthManager } from './auth/state';
+import { ConnectionManager } from './connection/socket';
+import { MessageHandler } from './message/handler';
+import { PluginManager } from './plugins/plugin-base';
+import { Logger } from './utils/logger';
+import { retry } from './utils/retry';
+import { throttle } from './utils/throttle';
+import { defaultConfig } from './config';
+
+export class BaileysClient extends EventEmitter {
+  public auth: AuthManager;
+  public connection: ConnectionManager;
+  public messages: MessageHandler;
+  public plugins: PluginManager;
+  public logger: Logger;
+  private config: SocketConfig;
+
+  constructor(config: Partial<SocketConfig> = {}) {
+    super();
+    this.config = { ...defaultConfig, ...config };
+    this.logger = new Logger({ level: 'info' });
+    this.auth = new AuthManager(this);
+    this.connection = new ConnectionManager(this);
+    this.messages = new MessageHandler(this);
+    this.plugins = new PluginManager(this);
+
+    // Wire up internal events
+    this.connection.on('update', (update: ConnectionUpdate) => {
+      this.emit('connection.update', update);
+    });
+
+    this.messages.on('message', (msg) => {
+      // Run middleware pipeline then emit
+      this.plugins.runMiddleware(msg, () => {
+        this.emit('message.new', msg);
+      });
+    });
+
+    this.messages.on('update', (update) => this.emit('message.update', update));
+    this.messages.on('receipt', (receipt) => this.emit('message.receipt', receipt));
+    this.messages.on('group.participants.update', (upd) => this.emit('group.participants.update', upd));
+    this.messages.on('presence', (upd) => this.emit('presence.update', upd));
+    this.messages.on('contacts', (contacts) => this.emit('contacts.update', contacts));
+    this.messages.on('reaction', (reaction) => this.emit('reaction', reaction));
+  }
+
+  /** Start the connection process */
+  async connect(): Promise<void> {
+    try {
+      await this.connection.connect();
+    } catch (err) {
+      this.logger.error('Failed to connect:', err);
+      this.emit('error', err as Error);
+    }
+  }
+
+  /** Disconnect gracefully */
+  async disconnect(): Promise<void> {
+    await this.connection.disconnect();
+  }
+
+  /** Request QR code for login (if loginMethod = 'qr') */
+  async requestQR(): Promise<string> {
+    return this.connection.requestQR();
+  }
+
+  /** Request pairing code (if loginMethod = 'pairing_code') */
+  async requestPairingCode(phoneNumber: string): Promise<string> {
+    return this.connection.requestPairingCode(phoneNumber);
+  }
+
+  /** Send a text message */
+  async sendMessage(jid: string, content: string, options?: { mentions?: string[]; quotedId?: string }) {
+    const msg = await this.messages.sendText(jid, content, options);
+    return msg;
+  }
+
+  /** Send media (buffer or URL) */
+  async sendMedia(jid: string, type: 'image'|'video'|'audio'|'document', media: Buffer | string, options?: any) {
+    return this.messages.sendMedia(jid, type, media, options);
+  }
+
+  /** ... other convenient methods delegate to feature modules */
+  async deleteMessage(jid: string, messageId: string) {
+    return this.messages.deleteMessage(jid, messageId);
+  }
+
+  async editMessage(jid: string, messageId: string, newContent: string) {
+    return this.messages.editMessage(jid, messageId, newContent);
+  }
+
+  async reactToMessage(jid: string, messageId: string, reaction: string) {
+    return this.messages.react(jid, messageId, reaction);
+  }
+
+  async downloadMedia(message: any): Promise<Buffer> {
+    return this.messages.downloadMedia(message);
+  }
+
+  // Event emitter overrides with typed signatures
+  on<K extends keyof BaileysEventMap>(event: K, listener: BaileysEventMap[K]): this;
+  on(event: string, listener: (...args: any[]) => void): this {
+    return super.on(event, listener);
+  }
+
+  emit<K extends keyof BaileysEventMap>(event: K, ...args: Parameters<BaileysEventMap[K]>): boolean;
+  emit(event: string, ...args: any[]): boolean {
+    return super.emit(event, ...args);
+  }
+
+  once<K extends keyof BaileysEventMap>(event: K, listener: BaileysEventMap[K]): this;
+  once(event: string, listener: (...args: any[]) => void): this {
+    return super.once(event, listener);
+  }
+}

package/src/config.ts

@@ -0,0 +1,10 @@
+import { SocketConfig } from './types/socket';
+
+export const defaultConfig: SocketConfig = {
+  wsUrl: 'wss://web.whatsapp.com/ws/md',
+  autoReconnect: true,
+  maxReconnectAttempts: -1,
+  reconnectDelay: 3000,
+  keepAliveInterval: 10000,
+  loginMethod: 'qr',
+};

package/src/connection/handshake.ts

@@ -0,0 +1,10 @@
+import { BaileysClient } from '../client';
+import WebSocket from 'ws';
+export class Handshake {
+  private client: BaileysClient;
+  constructor(client: BaileysClient) { this.client = client; }
+  async perform(ws: WebSocket): Promise<void> {
+    // Noise handshake placeholder; would exchange keys, etc.
+    return;
+  }
+}

package/src/connection/socket.ts

@@ -0,0 +1,109 @@
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import { BaileysClient } from '../client';
+import { ConnectionUpdate } from '../types/events';
+import { Transport } from './transport';
+import { Handshake } from './handshake';
+
+export class ConnectionManager extends EventEmitter {
+  private client: BaileysClient;
+  private ws: WebSocket | null = null;
+  private transport: Transport;
+  private handshake: Handshake;
+  private reconnectAttempts = 0;
+  private keepAliveTimer?: NodeJS.Timeout;
+
+  constructor(client: BaileysClient) {
+    super();
+    this.client = client;
+    this.transport = new Transport(client);
+    this.handshake = new Handshake(client);
+  }
+
+  async connect(): Promise<void> {
+    if (this.ws?.readyState === WebSocket.OPEN) return;
+    const { wsUrl, autoReconnect, reconnectDelay } = this.client['config'];
+
+    const doConnect = async () => {
+      this.emit('update', { status: 'connecting' });
+      const ws = new WebSocket(wsUrl);
+      this.ws = ws;
+      ws.binaryType = 'arraybuffer';
+
+      return new Promise<void>((resolve, reject) => {
+        ws.on('open', async () => {
+          this.emit('update', { status: 'open' });
+          this.reconnectAttempts = 0;
+          this.startKeepAlive();
+          // Perform noise handshake (stub)
+          await this.handshake.perform(ws);
+          resolve();
+        });
+
+        ws.on('message', (data: ArrayBuffer) => {
+          const decoded = this.transport.decode(data);
+          // route to MessageHandler
+          this.client.messages.processIncoming(decoded);
+        });
+
+        ws.on('close', (code) => {
+          this.stopKeepAlive();
+          this.emit('update', { status: 'close', error: new Error(`Closed with code ${code}`) });
+          if (autoReconnect && (!this.client['config'].maxReconnectAttempts || this.reconnectAttempts < this.client['config'].maxReconnectAttempts)) {
+            setTimeout(() => {
+              this.reconnectAttempts++;
+              this.connect().catch(() => {});
+            }, reconnectDelay * Math.min(this.reconnectAttempts, 10));
+          }
+        });
+
+        ws.on('error', (err) => {
+          reject(err);
+          this.emit('update', { status: 'error', error: err });
+        });
+      });
+    };
+
+    return doConnect();
+  }
+
+  async disconnect(): Promise<void> {
+    this.stopKeepAlive();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  async requestQR(): Promise<string> {
+    // Simulated QR generation (real implementation would ask WhatsApp servers)
+    const qr = 'data:image/png;base64,iVBORw0KGgo...'; // placeholder
+    this.emit('update', { status: 'qr', qr });
+    return qr;
+  }
+
+  async requestPairingCode(phoneNumber: string): Promise<string> {
+    const code = '12345'; // placeholder
+    this.emit('update', { status: 'pairing', pairingCode: code });
+    return code;
+  }
+
+  private startKeepAlive() {
+    this.keepAliveTimer = setInterval(() => {
+      this.ws?.ping();
+    }, this.client['config'].keepAliveInterval);
+  }
+
+  private stopKeepAlive() {
+    if (this.keepAliveTimer) clearInterval(this.keepAliveTimer);
+  }
+
+  // Outgoing message send raw
+  sendRaw(data: Uint8Array) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(data);
+    } else {
+      throw new Error('WebSocket not connected');
+    }
+  }
+      }

package/src/connection/transport.ts

@@ -0,0 +1,20 @@
+import { BaileysClient } from '../client';
+// Simplified protobuf encode/decode using protobufjs/minimal
+// Real implementation would use fully defined .proto files.
+export class Transport {
+  private client: BaileysClient;
+  constructor(client: BaileysClient) {
+    this.client = client;
+  }
+
+  decode(buffer: ArrayBuffer): any {
+    // Placeholder: parse binary into WAMessage format
+    // In a real lib this would use protobuf definitions
+    return JSON.parse(Buffer.from(buffer).toString('utf8'));
+  }
+
+  encode(message: any): Uint8Array {
+    // Placeholder
+    return Buffer.from(JSON.stringify(message));
+  }
+}

package/src/message/decoder.ts

@@ -0,0 +1,13 @@
+import { BaileysClient } from '../client';
+
+export class Decoder {
+  constructor(private client: BaileysClient) {}
+  decode(raw: any): any {
+    // Placeholder – real implementation would deserialize protobuf
+    try {
+      return JSON.parse(Buffer.from(raw).toString('utf8'));
+    } catch {
+      return {};
+    }
+  }
+}

package/src/message/encoder.ts

@@ -0,0 +1,9 @@
+import { BaileysClient } from '../client';
+
+export class Encoder {
+  constructor(private client: BaileysClient) {}
+  encode(message: any): Uint8Array {
+    // Placeholder – real implementation would serialize to protobuf
+    return Buffer.from(JSON.stringify(message));
+  }
+}

package/src/message/handler.ts

@@ -0,0 +1,91 @@
+import { EventEmitter } from 'events';
+import { BaileysClient } from '../client';
+import { TextMessage, MediaMessage, WAMessage, WAMessageUpdate } from '../types/messages';
+import { Encoder } from './encoder';
+import { Decoder } from './decoder';
+
+export class MessageHandler extends EventEmitter {
+  private client: BaileysClient;
+  private encoder: Encoder;
+  private decoder: Decoder;
+
+  constructor(client: BaileysClient) {
+    super();
+    this.client = client;
+    this.encoder = new Encoder(client);
+    this.decoder = new Decoder(client);
+  }
+
+  processIncoming(raw: any) {
+    const msg = this.decoder.decode(raw);
+    // Emit appropriate events based on msg type
+    if (msg.type === 'message') {
+      this.emit('message', msg.content);
+    } else if (msg.type === 'receipt') {
+      this.emit('receipt', msg.content);
+    } else if (msg.type === 'presence') {
+      this.emit('presence', msg.content);
+    } else if (msg.type === 'groupParticipants') {
+      this.emit('group.participants.update', msg.content);
+    } else if (msg.type === 'contacts') {
+      this.emit('contacts', msg.content);
+    } else if (msg.type === 'reaction') {
+      this.emit('reaction', msg.content);
+    } else if (msg.type === 'messageUpdate') {
+      this.emit('update', msg.content);
+    }
+  }
+
+  async sendText(jid: string, body: string, opts?: any): Promise<TextMessage> {
+    const msg: TextMessage = {
+      id: this.generateId(),
+      from: this.client.auth.getCredentials()?.clientId || 'me',
+      to: jid,
+      timestamp: Date.now(),
+      messageType: 'text',
+      body,
+      mentionedJids: opts?.mentions,
+      quotedMessage: opts?.quotedId ? { id: opts.quotedId } : undefined,
+    };
+    const encoded = this.encoder.encode(msg);
+    this.client.connection.sendRaw(encoded);
+    return msg;
+  }
+
+  async sendMedia(jid: string, type: string, media: Buffer | string, opts?: any): Promise<MediaMessage> {
+    // similar but with media upload
+    const msg: MediaMessage = {
+      id: this.generateId(),
+      from: 'me',
+      to: jid,
+      timestamp: Date.now(),
+      messageType: type as any,
+      mimeType: opts?.mimeType || 'application/octet-stream',
+      mediaUrl: typeof media === 'string' ? media : undefined,
+    };
+    const encoded = this.encoder.encode(msg);
+    this.client.connection.sendRaw(encoded);
+    return msg;
+  }
+
+  async deleteMessage(jid: string, messageId: string): Promise<void> {
+    // ... encode delete
+  }
+
+  async editMessage(jid: string, messageId: string, newBody: string): Promise<void> {
+    // ... encode edit
+  }
+
+  async react(jid: string, messageId: string, reaction: string): Promise<void> {
+    // ...
+  }
+
+  async downloadMedia(message: WAMessage): Promise<Buffer> {
+    // ...
+    return Buffer.alloc(0);
+  }
+
+  private generateId(): string {
+    return 'msg_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
+  }
+      }

package/src/plugins/command.ts

@@ -0,0 +1,40 @@
+import { BaileysClient } from '../client';
+import { CommandHandler, CommandContext } from '../types/plugin';
+import { TextMessage } from '../types/messages';
+
+export class CommandFramework {
+  private client: BaileysClient;
+  private commands: Map<string, CommandHandler> = new Map();
+  private prefix: string;
+
+  constructor(client: BaileysClient, prefix = '/') {
+    this.client = client;
+    this.prefix = prefix;
+
+    // Register middleware to intercept text messages
+    client.plugins.use(async (ctx, next) => {
+      if (ctx.message.messageType === 'text') {
+        const textMsg = ctx.message as TextMessage;
+        if (textMsg.body.startsWith(this.prefix)) {
+          const [commandName, ...args] = textMsg.body.slice(this.prefix.length).trim().split(/\s+/);
+          const handler = this.commands.get(commandName.toLowerCase());
+          if (handler) {
+            const cmdCtx: CommandContext = {
+              client: this.client,
+              message: textMsg,
+              args,
+              commandName: commandName.toLowerCase(),
+            };
+            await handler(cmdCtx);
+            return; // prevent further processing
+          }
+        }
+      }
+      await next();
+    });
+  }
+
+  register(command: string, handler: CommandHandler) {
+    this.commands.set(command.toLowerCase(), handler);
+  }
+}

package/src/plugins/plugin-base.ts

@@ -0,0 +1,36 @@
+import { BaileysClient } from '../client';
+import { Middleware, NextFunction } from '../types/plugin';
+import { WAMessage } from '../types/messages';
+
+export class PluginManager {
+  private client: BaileysClient;
+  private middlewares: Middleware[] = [];
+
+  constructor(client: BaileysClient) {
+    this.client = client;
+  }
+
+  use(fn: Middleware) {
+    this.middlewares.push(fn);
+  }
+
+  async runMiddleware(msg: WAMessage, done: NextFunction) {
+    const ctx = { client: this.client, message: msg };
+    const stack = [...this.middlewares];
+
+    const next: NextFunction = async (err?: Error) => {
+      if (err) return done(err);
+      const fn = stack.shift();
+      if (fn) {
+        try {
+          await fn(ctx, next);
+        } catch (e) {
+          done(e as Error);
+        }
+      } else {
+        done();
+      }
+    };
+    await next();
+  }
+}

package/src/types/auth.ts

@@ -0,0 +1,30 @@
+export interface Credentials {
+  clientId: string;
+  serverToken: string;
+  clientToken: string;
+  encKey: Buffer;
+  macKey: Buffer;
+}
+
+export interface AuthState {
+  creds: Credentials;
+  /** Multi‑device pre‑keys */
+  keys: {
+    registrationId: number;
+    identityKey: Uint8Array;
+    signedPreKey: {
+      keyId: number;
+      keyPair: KeyPair;
+      signature: Uint8Array;
+    };
+    preKeys: Array<{
+      keyId: number;
+      keyPair: KeyPair;
+    }>;
+  };
+}
+
+export interface KeyPair {
+  public: Uint8Array;
+  private: Uint8Array;
+}