@kangwifi-pro/waliwa 1.0.0

package/src/features/index.ts

@@ -0,0 +1,921 @@
+/**
+ * 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
+ */
+
+import { EventEmitter } from 'events';
+import type { WALogger, JIDLike, WAMessage } from '../types/index.js';
+import { SilentLogger } from '../utils/logger.js';
+import { jidToString } from '../utils/jid.js';
+import { LRUCache } from '../skdm/index.js';
+import { createHmac } from 'crypto';
+
+// ============================================================
+// FEATURE 1: Health Monitor dengan auto-recovery
+// ============================================================
+
+export interface HealthStatus {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  score: number; // 0-100
+  connection: {
+    connected: boolean;
+    uptime: number;
+    lastPingTime: number;
+    reconnectCount: number;
+  };
+  metrics: {
+    messagesSent: number;
+    messagesReceived: number;
+    sendFailures: number;
+    avgLatencyMs: number;
+  };
+  resources: {
+    memoryUsageMb: number;
+    pendingSends: number;
+    queueSize: number;
+  };
+  issues: string[];
+  timestamp: number;
+}
+
+export class HealthMonitor extends EventEmitter {
+  private logger: WALogger;
+  private startTime: number;
+  private lastPingTime: number = 0;
+  private reconnectCount: number = 0;
+  private messagesSent: number = 0;
+  private messagesReceived: number = 0;
+  private sendFailures: number = 0;
+  private latencies: number[] = [];
+  private maxLatencySamples: number = 100;
+  private checkInterval: NodeJS.Timeout | null = null;
+  private autoRecoveryEnabled: boolean;
+
+  constructor(opts: { logger?: WALogger; autoRecovery?: boolean } = {}) {
+    super();
+    this.logger = opts.logger ?? new SilentLogger();
+    this.startTime = Date.now();
+    this.autoRecoveryEnabled = opts.autoRecovery ?? true;
+  }
+
+  /**
+   * Start monitoring - periodic health checks
+   */
+  start(intervalMs: number = 60000): void {
+    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(): void {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+
+  recordPing(): void {
+    this.lastPingTime = Date.now();
+  }
+
+  recordReconnect(): void {
+    this.reconnectCount++;
+  }
+
+  recordSend(latencyMs: number, success: boolean = true): void {
+    if (success) {
+      this.messagesSent++;
+      this.latencies.push(latencyMs);
+      if (this.latencies.length > this.maxLatencySamples) {
+        this.latencies.shift();
+      }
+    } else {
+      this.sendFailures++;
+    }
+  }
+
+  recordReceive(): void {
+    this.messagesReceived++;
+  }
+
+  getHealth(): HealthStatus {
+    const memUsage = process.memoryUsage();
+    const avgLatency = this.latencies.length > 0
+      ? this.latencies.reduce((a, b) => a + b, 0) / this.latencies.length
+      : 0;
+
+    const issues: string[] = [];
+    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: 'healthy' | 'degraded' | 'unhealthy';
+    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(): void {
+    this.startTime = Date.now();
+    this.lastPingTime = 0;
+    this.reconnectCount = 0;
+    this.messagesSent = 0;
+    this.messagesReceived = 0;
+    this.sendFailures = 0;
+    this.latencies = [];
+  }
+}
+
+// ============================================================
+// FEATURE 2: Multi-account Manager
+// ============================================================
+
+export interface AccountConfig {
+  id: string;
+  name: string;
+  authFolder: string;
+  enabled: boolean;
+  config: any; // WaliwaConfig
+}
+
+export interface AccountStatus {
+  id: string;
+  name: string;
+  connected: boolean;
+  user?: { id: string; name?: string };
+  lastActive: number;
+  messagesSent: number;
+  messagesReceived: number;
+}
+
+/**
+ * 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.
+ */
+export class MultiAccountManager extends EventEmitter {
+  private accounts: Map<string, { config: AccountConfig; socket: any; status: AccountStatus }> = new Map();
+  private logger: WALogger;
+  private maxAccounts: number;
+
+  constructor(opts: { maxAccounts?: number; logger?: WALogger } = {}) {
+    super();
+    this.logger = opts.logger ?? new SilentLogger();
+    this.maxAccounts = opts.maxAccounts ?? 10;
+  }
+
+  /**
+   * Register new account
+   */
+  registerAccount(config: AccountConfig): void {
+    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: string): Promise<void> {
+    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: any) => {
+      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 }: any) => {
+      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: string): Promise<void> {
+    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: string): any {
+    const entry = this.accounts.get(accountId);
+    return entry?.socket;
+  }
+
+  /**
+   * List all accounts dengan status
+   */
+  listAccounts(): AccountStatus[] {
+    return Array.from(this.accounts.values()).map(e => e.status);
+  }
+
+  /**
+   * Send message from specific account
+   */
+  async sendMessageFrom(accountId: string, jid: JIDLike, content: any): Promise<any> {
+    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: JIDLike, content: any, accountIds?: string[]): Promise<void> {
+    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: any) {
+        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(): Promise<void> {
+    const promises = Array.from(this.accounts.keys()).map(id => this.disconnectAccount(id));
+    await Promise.all(promises);
+  }
+}
+
+// ============================================================
+// FEATURE 3: Webhook System dengan HMAC signature + retry
+// ============================================================
+
+export interface WebhookConfig {
+  url: string;
+  events: string[]; // '*' untuk all events
+  secret?: string; // HMAC signing secret
+  enabled: boolean;
+  retryCount: number;
+  retryDelayMs: number;
+  timeoutMs: number;
+}
+
+interface PendingWebhook {
+  id: string;
+  url: string;
+  payload: any;
+  secret?: string;
+  attempts: number;
+  nextRetryAt: number;
+}
+
+/**
+ * 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
+ */
+export class WebhookManager {
+  private webhooks: Map<string, WebhookConfig> = new Map();
+  private pendingQueue: PendingWebhook[] = [];
+  private deadLetterQueue: PendingWebhook[] = [];
+  private logger: WALogger;
+  private processingTimer: NodeJS.Timeout | null = null;
+  private isProcessing: boolean = false;
+  private stats: { sent: number; failed: number; retried: number } = { sent: 0, failed: 0, retried: 0 };
+
+  constructor(opts: { logger?: WALogger } = {}) {
+    this.logger = opts.logger ?? new SilentLogger();
+    // Process queue every 5 seconds
+    this.processingTimer = setInterval(() => this.processQueue(), 5000);
+  }
+
+  /**
+   * Register webhook
+   */
+  register(config: WebhookConfig): void {
+    this.webhooks.set(config.url, config);
+    this.logger.info(`Webhook registered: ${config.url} for events: ${config.events.join(', ')}`);
+  }
+
+  /**
+   * Unregister webhook
+   */
+  unregister(url: string): void {
+    this.webhooks.delete(url);
+  }
+
+  /**
+   * Trigger webhook delivery
+   */
+  trigger(event: string, payload: any): void {
+    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()
+        });
+      }
+    }
+  }
+
+  private async processQueue(): Promise<void> {
+    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;
+  }
+
+  private async deliver(webhook: PendingWebhook): Promise<void> {
+    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: Record<string, string> = {
+      'Content-Type': 'application/json'
+    };
+    if (webhook.secret) {
+      const signature = 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: any) {
+      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(): { sent: number; failed: number; retried: number; pending: number; deadLettered: number } {
+    return {
+      ...this.stats,
+      pending: this.pendingQueue.length,
+      deadLettered: this.deadLetterQueue.length
+    };
+  }
+
+  /**
+   * Get dead letter queue (untuk manual retry)
+   */
+  getDeadLetterQueue(): PendingWebhook[] {
+    return this.deadLetterQueue;
+  }
+
+  /**
+   * Retry dari DLQ
+   */
+  retryDeadLetter(id?: string): void {
+    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(): void {
+    if (this.processingTimer) {
+      clearInterval(this.processingTimer);
+      this.processingTimer = null;
+    }
+    this.pendingQueue = [];
+    this.deadLetterQueue = [];
+  }
+}
+
+// ============================================================
+// 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
+ */
+export class CircuitBreaker {
+  private states: Map<string, {
+    failureCount: number;
+    lastFailureTime: number;
+    state: 'closed' | 'open' | 'half-open';
+  }> = new Map();
+  private failureThreshold: number;
+  private cooldownMs: number;
+  private logger: WALogger;
+
+  constructor(opts: { failureThreshold?: number; cooldownMs?: number; logger?: WALogger } = {}) {
+    this.failureThreshold = opts.failureThreshold ?? 5;
+    this.cooldownMs = opts.cooldownMs ?? 60 * 1000; // 1 minute default
+    this.logger = opts.logger ?? new SilentLogger();
+  }
+
+  /**
+   * Check if can send to recipient
+   */
+  canSend(recipientJid: string): boolean {
+    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: string): void {
+    const state = this.states.get(recipientJid);
+    if (state) {
+      state.failureCount = 0;
+      state.state = 'closed';
+    }
+  }
+
+  /**
+   * Record failed send
+   */
+  recordFailure(recipientJid: string): void {
+    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: string): void {
+    this.states.delete(recipientJid);
+  }
+
+  /**
+   * Get circuit state untuk recipient
+   */
+  getState(recipientJid: string): 'closed' | 'open' | 'half-open' {
+    return this.states.get(recipientJid)?.state ?? 'closed';
+  }
+
+  /**
+   * Get all open circuits (untuk monitoring)
+   */
+  getOpenCircuits(): Array<{ jid: string; failureCount: number; lastFailureTime: number }> {
+    const result: Array<{ jid: string; failureCount: number; lastFailureTime: number }> = [];
+    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(): void {
+    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);
+      }
+    }
+  }
+}
+
+// ============================================================
+// 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
+ */
+export class RateLimitTracker {
+  private counts: Map<string, { second: number; minute: number; hour: number; lastReset: { second: number; minute: number; hour: number } }> = new Map();
+  private limits: { perSecond: number; perMinute: number; perHour: number };
+  private logger: WALogger;
+
+  constructor(opts: { perSecond?: number; perMinute?: number; perHour?: number; logger?: WALogger } = {}) {
+    this.limits = {
+      perSecond: opts.perSecond ?? 5,
+      perMinute: opts.perMinute ?? 60,
+      perHour: opts.perHour ?? 1000
+    };
+    this.logger = opts.logger ?? new SilentLogger();
+  }
+
+  /**
+   * Check if can send to recipient (and increment counter)
+   */
+  canSend(recipientJid: string): boolean {
+    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: string): { second: number; minute: number; hour: number } {
+    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: string): void {
+    this.counts.delete(recipientJid);
+  }
+
+  /**
+   * Cleanup inactive recipients (no sends in last hour)
+   */
+  cleanup(): void {
+    const now = Date.now();
+    for (const [jid, entry] of this.counts.entries()) {
+      if (now - entry.lastReset.hour > 3600000) {
+        this.counts.delete(jid);
+      }
+    }
+  }
+
+  getStats(): {
+    trackedRecipients: number;
+    limits: { perSecond: number; perMinute: number; perHour: number };
+  } {
+    return {
+      trackedRecipients: this.counts.size,
+      limits: { perSecond: this.limits.perSecond, perMinute: this.limits.perMinute, perHour: this.limits.perHour }
+    };
+  }
+}
+
+// ============================================================
+// FEATURE: Message Persistence (survive restarts)
+// ============================================================
+
+/**
+ * MessagePersistence - persist outgoing messages untuk survive restarts.
+ * Fix Baileys issue: pending messages lost on restart.
+ */
+export interface PersistedMessage {
+  id: string;
+  recipientJid: string;
+  content: any;
+  status: 'pending' | 'sent' | 'failed';
+  attempts: number;
+  createdAt: number;
+  updatedAt: number;
+  lastError?: string;
+}
+
+export class MessagePersistence {
+  private messages: Map<string, PersistedMessage> = new Map();
+  private maxRetention: number;
+  private logger: WALogger;
+
+  constructor(opts: { maxRetention?: number; logger?: WALogger } = {}) {
+    this.maxRetention = opts.maxRetention ?? 10000; // Keep last 10k messages
+    this.logger = opts.logger ?? new SilentLogger();
+  }
+
+  save(message: PersistedMessage): void {
+    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: string): PersistedMessage | undefined {
+    return this.messages.get(id);
+  }
+
+  update(id: string, update: Partial<PersistedMessage>): void {
+    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(): PersistedMessage[] {
+    return Array.from(this.messages.values()).filter(m => m.status === 'pending');
+  }
+
+  /**
+   * Get all failed messages (untuk manual retry)
+   */
+  getFailed(): PersistedMessage[] {
+    return Array.from(this.messages.values()).filter(m => m.status === 'failed');
+  }
+
+  delete(id: string): void {
+    this.messages.delete(id);
+  }
+
+  /**
+   * Cleanup old messages (older than X ms)
+   */
+  cleanup(maxAgeMs: number = 24 * 60 * 60 * 1000): number {
+    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(): number {
+    return this.messages.size;
+  }
+}