@kangwifi-pro/waliwa 1.0.0

package/dist/features/index.js

@@ -0,0 +1,755 @@
+"use strict";
+/**
+ * Waliwa - New Features Module
+ *
+ * Module yang berisi fitur-fitur baru yang gak ada di Baileys:
+ *
+ * 1. Health Monitor - real-time health tracking dengan auto-recovery
+ * 2. Multi-account Manager - manage multiple WhatsApp accounts
+ * 3. Webhook System - reliable webhooks dengan retry + HMAC signature
+ * 4. Circuit Breaker - prevent retry storms untuk failed sends
+ * 5. Rate Limit Tracker - per-recipient rate limit tracking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagePersistence = exports.RateLimitTracker = exports.CircuitBreaker = exports.WebhookManager = exports.MultiAccountManager = exports.HealthMonitor = void 0;
+const events_1 = require("events");
+const logger_js_1 = require("../utils/logger.js");
+const crypto_1 = require("crypto");
+class HealthMonitor extends events_1.EventEmitter {
+    logger;
+    startTime;
+    lastPingTime = 0;
+    reconnectCount = 0;
+    messagesSent = 0;
+    messagesReceived = 0;
+    sendFailures = 0;
+    latencies = [];
+    maxLatencySamples = 100;
+    checkInterval = null;
+    autoRecoveryEnabled;
+    constructor(opts = {}) {
+        super();
+        this.logger = opts.logger ?? new logger_js_1.SilentLogger();
+        this.startTime = Date.now();
+        this.autoRecoveryEnabled = opts.autoRecovery ?? true;
+    }
+    /**
+     * Start monitoring - periodic health checks
+     */
+    start(intervalMs = 60000) {
+        if (this.checkInterval)
+            return;
+        this.checkInterval = setInterval(() => {
+            const status = this.getHealth();
+            this.emit('health:check', status);
+            if (status.status === 'unhealthy' && this.autoRecoveryEnabled) {
+                this.logger.warn('Health degraded, triggering recovery actions');
+                this.emit('health:recovery', status);
+            }
+        }, intervalMs);
+    }
+    stop() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+    }
+    recordPing() {
+        this.lastPingTime = Date.now();
+    }
+    recordReconnect() {
+        this.reconnectCount++;
+    }
+    recordSend(latencyMs, success = true) {
+        if (success) {
+            this.messagesSent++;
+            this.latencies.push(latencyMs);
+            if (this.latencies.length > this.maxLatencySamples) {
+                this.latencies.shift();
+            }
+        }
+        else {
+            this.sendFailures++;
+        }
+    }
+    recordReceive() {
+        this.messagesReceived++;
+    }
+    getHealth() {
+        const memUsage = process.memoryUsage();
+        const avgLatency = this.latencies.length > 0
+            ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length
+            : 0;
+        const issues = [];
+        let score = 100;
+        // Check connection
+        const connected = this.lastPingTime > 0 && (Date.now() - this.lastPingTime) < 60000;
+        if (!connected) {
+            issues.push('Connection appears down (no recent ping)');
+            score -= 40;
+        }
+        // Check reconnect frequency
+        if (this.reconnectCount > 10) {
+            issues.push(`High reconnect count: ${this.reconnectCount}`);
+            score -= 20;
+        }
+        // Check send failure rate
+        const totalSends = this.messagesSent + this.sendFailures;
+        const failureRate = totalSends > 0 ? this.sendFailures / totalSends : 0;
+        if (failureRate > 0.1) {
+            issues.push(`High send failure rate: ${(failureRate * 100).toFixed(1)}%`);
+            score -= 25;
+        }
+        // Check latency
+        if (avgLatency > 5000) {
+            issues.push(`High average latency: ${avgLatency.toFixed(0)}ms`);
+            score -= 15;
+        }
+        // Check memory
+        const memMb = memUsage.rss / 1024 / 1024;
+        if (memMb > 500) {
+            issues.push(`High memory usage: ${memMb.toFixed(1)}MB`);
+            score -= 10;
+        }
+        let status;
+        if (score >= 80)
+            status = 'healthy';
+        else if (score >= 50)
+            status = 'degraded';
+        else
+            status = 'unhealthy';
+        return {
+            status,
+            score: Math.max(0, score),
+            connection: {
+                connected,
+                uptime: Date.now() - this.startTime,
+                lastPingTime: this.lastPingTime,
+                reconnectCount: this.reconnectCount
+            },
+            metrics: {
+                messagesSent: this.messagesSent,
+                messagesReceived: this.messagesReceived,
+                sendFailures: this.sendFailures,
+                avgLatencyMs: avgLatency
+            },
+            resources: {
+                memoryUsageMb: memMb,
+                pendingSends: 0,
+                queueSize: 0
+            },
+            issues,
+            timestamp: Date.now()
+        };
+    }
+    reset() {
+        this.startTime = Date.now();
+        this.lastPingTime = 0;
+        this.reconnectCount = 0;
+        this.messagesSent = 0;
+        this.messagesReceived = 0;
+        this.sendFailures = 0;
+        this.latencies = [];
+    }
+}
+exports.HealthMonitor = HealthMonitor;
+/**
+ * MultiAccountManager - manage multiple WhatsApp accounts dari satu process.
+ * Berguna untuk: customer service bots, multiple business accounts, dll.
+ *
+ * RAM optimization: lazy-load accounts, only active ones consume resources.
+ */
+class MultiAccountManager extends events_1.EventEmitter {
+    accounts = new Map();
+    logger;
+    maxAccounts;
+    constructor(opts = {}) {
+        super();
+        this.logger = opts.logger ?? new logger_js_1.SilentLogger();
+        this.maxAccounts = opts.maxAccounts ?? 10;
+    }
+    /**
+     * Register new account
+     */
+    registerAccount(config) {
+        if (this.accounts.size >= this.maxAccounts) {
+            throw new Error(`Max accounts (${this.maxAccounts}) reached`);
+        }
+        if (this.accounts.has(config.id)) {
+            throw new Error(`Account with id ${config.id} already exists`);
+        }
+        this.accounts.set(config.id, {
+            config,
+            socket: null,
+            status: {
+                id: config.id,
+                name: config.name,
+                connected: false,
+                lastActive: Date.now(),
+                messagesSent: 0,
+                messagesReceived: 0
+            }
+        });
+        this.logger.info(`Account registered: ${config.id} (${config.name})`);
+    }
+    /**
+     * Connect account by ID
+     */
+    async connectAccount(accountId) {
+        const entry = this.accounts.get(accountId);
+        if (!entry)
+            throw new Error(`Account ${accountId} not found`);
+        if (entry.socket) {
+            this.logger.warn(`Account ${accountId} already connected`);
+            return;
+        }
+        // Lazy load makeWASocket untuk hemat RAM
+        const { makeWASocket } = await import('../socket/wa-socket.js');
+        const { useFileAuthState } = await import('../auth/auth-state.js');
+        const state = await useFileAuthState(entry.config.authFolder, accountId);
+        const socket = makeWASocket({
+            ...entry.config.config,
+            authState: state
+        });
+        // Track connection
+        socket.ev.on('connection.update', (update) => {
+            if (update.connection === 'open') {
+                entry.status.connected = true;
+                entry.status.user = socket.user;
+                entry.status.lastActive = Date.now();
+                this.emit('account:connected', accountId);
+            }
+            else if (update.connection === 'close') {
+                entry.status.connected = false;
+                this.emit('account:disconnected', accountId);
+            }
+        });
+        socket.ev.on('message.upsert', ({ messages }) => {
+            entry.status.messagesReceived += messages.length;
+            entry.status.lastActive = Date.now();
+            this.emit('account:message', accountId, messages);
+        });
+        entry.socket = socket;
+        this.logger.info(`Account ${accountId} connected`);
+    }
+    /**
+     * Disconnect account
+     */
+    async disconnectAccount(accountId) {
+        const entry = this.accounts.get(accountId);
+        if (!entry || !entry.socket)
+            return;
+        await entry.socket.end();
+        entry.socket = null;
+        entry.status.connected = false;
+        this.logger.info(`Account ${accountId} disconnected`);
+    }
+    /**
+     * Get account socket (untuk send messages)
+     */
+    getSocket(accountId) {
+        const entry = this.accounts.get(accountId);
+        return entry?.socket;
+    }
+    /**
+     * List all accounts dengan status
+     */
+    listAccounts() {
+        return Array.from(this.accounts.values()).map(e => e.status);
+    }
+    /**
+     * Send message from specific account
+     */
+    async sendMessageFrom(accountId, jid, content) {
+        const entry = this.accounts.get(accountId);
+        if (!entry?.socket) {
+            throw new Error(`Account ${accountId} not connected`);
+        }
+        const result = await entry.socket.sendMessage(jid, content);
+        entry.status.messagesSent++;
+        entry.status.lastActive = Date.now();
+        return result;
+    }
+    /**
+     * Broadcast message dari multiple accounts
+     */
+    async broadcast(jid, content, accountIds) {
+        const ids = accountIds ?? Array.from(this.accounts.keys());
+        const promises = ids.map(async (id) => {
+            try {
+                await this.sendMessageFrom(id, jid, content);
+                return { id, success: true };
+            }
+            catch (err) {
+                this.logger.error(`Broadcast from ${id} failed: ${err.message}`);
+                return { id, success: false, error: err.message };
+            }
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * Disconnect all accounts
+     */
+    async disconnectAll() {
+        const promises = Array.from(this.accounts.keys()).map(id => this.disconnectAccount(id));
+        await Promise.all(promises);
+    }
+}
+exports.MultiAccountManager = MultiAccountManager;
+/**
+ * WebhookManager - reliable webhook delivery dengan retry + HMAC signature.
+ * Fix common Baileys issue: webhooks tidak reliable.
+ *
+ * Strategy:
+ * - HMAC-SHA256 signature untuk verify authenticity
+ * - Exponential backoff retry
+ * - Queue pending webhooks jika network issue
+ * - Dead letter queue untuk permanent failures
+ */
+class WebhookManager {
+    webhooks = new Map();
+    pendingQueue = [];
+    deadLetterQueue = [];
+    logger;
+    processingTimer = null;
+    isProcessing = false;
+    stats = { sent: 0, failed: 0, retried: 0 };
+    constructor(opts = {}) {
+        this.logger = opts.logger ?? new logger_js_1.SilentLogger();
+        // Process queue every 5 seconds
+        this.processingTimer = setInterval(() => this.processQueue(), 5000);
+    }
+    /**
+     * Register webhook
+     */
+    register(config) {
+        this.webhooks.set(config.url, config);
+        this.logger.info(`Webhook registered: ${config.url} for events: ${config.events.join(', ')}`);
+    }
+    /**
+     * Unregister webhook
+     */
+    unregister(url) {
+        this.webhooks.delete(url);
+    }
+    /**
+     * Trigger webhook delivery
+     */
+    trigger(event, payload) {
+        for (const config of this.webhooks.values()) {
+            if (!config.enabled)
+                continue;
+            if (config.events.includes('*') || config.events.includes(event)) {
+                const id = `wh-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                this.pendingQueue.push({
+                    id,
+                    url: config.url,
+                    payload: { event, timestamp: Date.now(), data: payload },
+                    secret: config.secret,
+                    attempts: 0,
+                    nextRetryAt: Date.now()
+                });
+            }
+        }
+    }
+    async processQueue() {
+        if (this.isProcessing)
+            return;
+        this.isProcessing = true;
+        const now = Date.now();
+        const toProcess = this.pendingQueue.filter(w => w.nextRetryAt <= now);
+        this.pendingQueue = this.pendingQueue.filter(w => w.nextRetryAt > now);
+        for (const webhook of toProcess) {
+            await this.deliver(webhook);
+        }
+        this.isProcessing = false;
+    }
+    async deliver(webhook) {
+        const config = this.webhooks.get(webhook.url);
+        if (!config) {
+            // Webhook was unregistered, drop
+            return;
+        }
+        webhook.attempts++;
+        const body = JSON.stringify(webhook.payload);
+        // Sign with HMAC jika secret provided
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (webhook.secret) {
+            const signature = (0, crypto_1.createHmac)('sha256', webhook.secret)
+                .update(body)
+                .digest('hex');
+            headers['X-Waliwa-Signature'] = `sha256=${signature}`;
+            headers['X-Waliwa-Event'] = webhook.payload.event;
+        }
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), config.timeoutMs);
+            const response = await fetch(webhook.url, {
+                method: 'POST',
+                headers,
+                body,
+                signal: controller.signal
+            });
+            clearTimeout(timeout);
+            if (response.status >= 200 && response.status < 300) {
+                this.stats.sent++;
+                this.logger.debug(`Webhook ${webhook.id} delivered successfully`);
+            }
+            else if (response.status >= 400 && response.status < 500) {
+                // Client error - don't retry (4xx = permanent failure)
+                this.stats.failed++;
+                this.deadLetterQueue.push(webhook);
+                this.logger.warn(`Webhook ${webhook.id} rejected with ${response.status}, moved to DLQ`);
+            }
+            else {
+                // Server error - retry
+                throw new Error(`HTTP ${response.status}`);
+            }
+        }
+        catch (err) {
+            this.logger.warn(`Webhook ${webhook.id} delivery failed (attempt ${webhook.attempts}): ${err.message}`);
+            if (webhook.attempts >= config.retryCount) {
+                // Move to dead letter queue
+                this.deadLetterQueue.push(webhook);
+                this.stats.failed++;
+                this.logger.error(`Webhook ${webhook.id} permanently failed, moved to DLQ`);
+            }
+            else {
+                // Schedule retry dengan exponential backoff
+                const delay = config.retryDelayMs * Math.pow(2, webhook.attempts - 1);
+                webhook.nextRetryAt = Date.now() + delay;
+                this.pendingQueue.push(webhook);
+                this.stats.retried++;
+            }
+        }
+    }
+    getStats() {
+        return {
+            ...this.stats,
+            pending: this.pendingQueue.length,
+            deadLettered: this.deadLetterQueue.length
+        };
+    }
+    /**
+     * Get dead letter queue (untuk manual retry)
+     */
+    getDeadLetterQueue() {
+        return this.deadLetterQueue;
+    }
+    /**
+     * Retry dari DLQ
+     */
+    retryDeadLetter(id) {
+        if (id) {
+            const idx = this.deadLetterQueue.findIndex(w => w.id === id);
+            if (idx !== -1) {
+                const webhook = this.deadLetterQueue.splice(idx, 1)[0];
+                webhook.attempts = 0;
+                webhook.nextRetryAt = Date.now();
+                this.pendingQueue.push(webhook);
+            }
+        }
+        else {
+            // Retry all
+            for (const webhook of this.deadLetterQueue) {
+                webhook.attempts = 0;
+                webhook.nextRetryAt = Date.now();
+                this.pendingQueue.push(webhook);
+            }
+            this.deadLetterQueue = [];
+        }
+    }
+    destroy() {
+        if (this.processingTimer) {
+            clearInterval(this.processingTimer);
+            this.processingTimer = null;
+        }
+        this.pendingQueue = [];
+        this.deadLetterQueue = [];
+    }
+}
+exports.WebhookManager = WebhookManager;
+// ============================================================
+// FEATURE 4: Circuit Breaker untuk failed sends
+// ============================================================
+/**
+ * CircuitBreaker - prevent retry storms untuk failed recipients.
+ * Fix Baileys issue: failed sends terus retry, flood server, get banned.
+ *
+ * Strategy:
+ * - Track failure count per recipient
+ * - When threshold reached, open circuit (stop sending)
+ * - After cooldown, try again (half-open state)
+ * - If success, close circuit; if fail, re-open
+ */
+class CircuitBreaker {
+    states = new Map();
+    failureThreshold;
+    cooldownMs;
+    logger;
+    constructor(opts = {}) {
+        this.failureThreshold = opts.failureThreshold ?? 5;
+        this.cooldownMs = opts.cooldownMs ?? 60 * 1000; // 1 minute default
+        this.logger = opts.logger ?? new logger_js_1.SilentLogger();
+    }
+    /**
+     * Check if can send to recipient
+     */
+    canSend(recipientJid) {
+        const state = this.states.get(recipientJid);
+        if (!state)
+            return true; // No state = closed
+        if (state.state === 'closed')
+            return true;
+        if (state.state === 'open') {
+            // Check if cooldown elapsed
+            if (Date.now() - state.lastFailureTime > this.cooldownMs) {
+                // Half-open: allow one attempt
+                state.state = 'half-open';
+                this.logger.info(`Circuit half-open for ${recipientJid}`);
+                return true;
+            }
+            return false;
+        }
+        // half-open: only allow one concurrent request
+        return true;
+    }
+    /**
+     * Record successful send
+     */
+    recordSuccess(recipientJid) {
+        const state = this.states.get(recipientJid);
+        if (state) {
+            state.failureCount = 0;
+            state.state = 'closed';
+        }
+    }
+    /**
+     * Record failed send
+     */
+    recordFailure(recipientJid) {
+        let state = this.states.get(recipientJid);
+        if (!state) {
+            state = {
+                failureCount: 0,
+                lastFailureTime: Date.now(),
+                state: 'closed'
+            };
+            this.states.set(recipientJid, state);
+        }
+        state.failureCount++;
+        state.lastFailureTime = Date.now();
+        if (state.failureCount >= this.failureThreshold) {
+            state.state = 'open';
+            this.logger.warn(`Circuit opened for ${recipientJid} after ${state.failureCount} failures`);
+        }
+    }
+    /**
+     * Manually reset circuit untuk recipient
+     */
+    reset(recipientJid) {
+        this.states.delete(recipientJid);
+    }
+    /**
+     * Get circuit state untuk recipient
+     */
+    getState(recipientJid) {
+        return this.states.get(recipientJid)?.state ?? 'closed';
+    }
+    /**
+     * Get all open circuits (untuk monitoring)
+     */
+    getOpenCircuits() {
+        const result = [];
+        for (const [jid, state] of this.states.entries()) {
+            if (state.state === 'open') {
+                result.push({
+                    jid,
+                    failureCount: state.failureCount,
+                    lastFailureTime: state.lastFailureTime
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Cleanup expired circuits (cooldown elapsed and still open)
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [jid, state] of this.states.entries()) {
+            if (state.state === 'open' && (now - state.lastFailureTime) > this.cooldownMs * 2) {
+                this.states.delete(jid);
+            }
+        }
+    }
+}
+exports.CircuitBreaker = CircuitBreaker;
+// ============================================================
+// FEATURE 5: Rate Limit Tracker per recipient
+// ============================================================
+/**
+ * RateLimitTracker - per-recipient rate limiting.
+ * Berguna untuk: prevent spam, comply dengan WA server limits.
+ *
+ * WhatsApp server limits (approximate):
+ * - 5 messages/sec per recipient
+ * - 60 messages/min per recipient
+ * - 1000 messages/hour per recipient
+ */
+class RateLimitTracker {
+    counts = new Map();
+    limits;
+    logger;
+    constructor(opts = {}) {
+        this.limits = {
+            perSecond: opts.perSecond ?? 5,
+            perMinute: opts.perMinute ?? 60,
+            perHour: opts.perHour ?? 1000
+        };
+        this.logger = opts.logger ?? new logger_js_1.SilentLogger();
+    }
+    /**
+     * Check if can send to recipient (and increment counter)
+     */
+    canSend(recipientJid) {
+        const now = Date.now();
+        let entry = this.counts.get(recipientJid);
+        if (!entry) {
+            entry = {
+                second: 0,
+                minute: 0,
+                hour: 0,
+                lastReset: { second: now, minute: now, hour: now }
+            };
+            this.counts.set(recipientJid, entry);
+        }
+        // Reset counters jika time window elapsed
+        if (now - entry.lastReset.second > 1000) {
+            entry.second = 0;
+            entry.lastReset.second = now;
+        }
+        if (now - entry.lastReset.minute > 60000) {
+            entry.minute = 0;
+            entry.lastReset.minute = now;
+        }
+        if (now - entry.lastReset.hour > 3600000) {
+            entry.hour = 0;
+            entry.lastReset.hour = now;
+        }
+        // Check limits
+        if (entry.second >= this.limits.perSecond)
+            return false;
+        if (entry.minute >= this.limits.perMinute)
+            return false;
+        if (entry.hour >= this.limits.perHour)
+            return false;
+        // Increment
+        entry.second++;
+        entry.minute++;
+        entry.hour++;
+        return true;
+    }
+    /**
+     * Get remaining quota untuk recipient
+     */
+    getRemainingQuota(recipientJid) {
+        const entry = this.counts.get(recipientJid);
+        if (!entry) {
+            return { second: this.limits.perSecond, minute: this.limits.perMinute, hour: this.limits.perHour };
+        }
+        const now = Date.now();
+        return {
+            second: Math.max(0, this.limits.perSecond - (now - entry.lastReset.second > 1000 ? 0 : entry.second)),
+            minute: Math.max(0, this.limits.perMinute - (now - entry.lastReset.minute > 60000 ? 0 : entry.minute)),
+            hour: Math.max(0, this.limits.perHour - (now - entry.lastReset.hour > 3600000 ? 0 : entry.hour))
+        };
+    }
+    /**
+     * Reset counter untuk recipient (e.g., on successful interaction)
+     */
+    reset(recipientJid) {
+        this.counts.delete(recipientJid);
+    }
+    /**
+     * Cleanup inactive recipients (no sends in last hour)
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [jid, entry] of this.counts.entries()) {
+            if (now - entry.lastReset.hour > 3600000) {
+                this.counts.delete(jid);
+            }
+        }
+    }
+    getStats() {
+        return {
+            trackedRecipients: this.counts.size,
+            limits: { perSecond: this.limits.perSecond, perMinute: this.limits.perMinute, perHour: this.limits.perHour }
+        };
+    }
+}
+exports.RateLimitTracker = RateLimitTracker;
+class MessagePersistence {
+    messages = new Map();
+    maxRetention;
+    logger;
+    constructor(opts = {}) {
+        this.maxRetention = opts.maxRetention ?? 10000; // Keep last 10k messages
+        this.logger = opts.logger ?? new logger_js_1.SilentLogger();
+    }
+    save(message) {
+        this.messages.set(message.id, message);
+        // Trim if over max
+        if (this.messages.size > this.maxRetention) {
+            const firstKey = this.messages.keys().next().value;
+            if (firstKey)
+                this.messages.delete(firstKey);
+        }
+    }
+    get(id) {
+        return this.messages.get(id);
+    }
+    update(id, update) {
+        const existing = this.messages.get(id);
+        if (existing) {
+            this.messages.set(id, { ...existing, ...update, updatedAt: Date.now() });
+        }
+    }
+    /**
+     * Get all pending messages (untuk retry on restart)
+     */
+    getPending() {
+        return Array.from(this.messages.values()).filter(m => m.status === 'pending');
+    }
+    /**
+     * Get all failed messages (untuk manual retry)
+     */
+    getFailed() {
+        return Array.from(this.messages.values()).filter(m => m.status === 'failed');
+    }
+    delete(id) {
+        this.messages.delete(id);
+    }
+    /**
+     * Cleanup old messages (older than X ms)
+     */
+    cleanup(maxAgeMs = 24 * 60 * 60 * 1000) {
+        const cutoff = Date.now() - maxAgeMs;
+        let cleaned = 0;
+        for (const [id, msg] of this.messages.entries()) {
+            if (msg.updatedAt < cutoff) {
+                this.messages.delete(id);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
+    size() {
+        return this.messages.size;
+    }
+}
+exports.MessagePersistence = MessagePersistence;
+//# sourceMappingURL=index.js.map