@prototypevip/baileys 0.0.8 → 0.0.9

package/lib/AntiBan/observability.js

@@ -0,0 +1,145 @@
+/**
+ * Observability — Prometheus metrics export + pluggable structured logging
+ *
+ * Usage:
+ *   // Logging
+ *   import { createConsoleLogger } from 'baileys-antiban';
+ *   const logger = createConsoleLogger('[my-bot]');
+ *   logger.info('Message sent', { recipient: jid });
+ *
+ *   // Metrics export for Express
+ *   import { createMetricsHandler } from 'baileys-antiban';
+ *   const metricsHandler = createMetricsHandler(() => antiban.getStats());
+ *   app.get('/metrics', metricsHandler.handle);
+ *
+ *   // Periodic push to external system
+ *   import { createPeriodicExporter } from 'baileys-antiban';
+ *   const exporter = createPeriodicExporter(() => antiban.getStats(), {
+ *     intervalMs: 30_000,
+ *     onMetrics: (text) => pushToVictoriaMetrics(text),
+ *   });
+ */
+/**
+ * Create a simple console logger with timestamps and prefix
+ */
+export function createConsoleLogger(prefix = '[baileys-antiban]') {
+    const format = (level, msg, meta) => {
+        const timestamp = new Date().toISOString();
+        const metaStr = meta ? ' ' + JSON.stringify(meta) : '';
+        return `${timestamp} ${level} ${prefix} ${msg}${metaStr}`;
+    };
+    return {
+        debug: (msg, meta) => console.log(format('DEBUG', msg, meta)),
+        info: (msg, meta) => console.log(format('INFO', msg, meta)),
+        warn: (msg, meta) => console.warn(format('WARN', msg, meta)),
+        error: (msg, meta) => console.error(format('ERROR', msg, meta)),
+    };
+}
+/**
+ * Export AntiBan stats as Prometheus text format (exposition format v0.0.4)
+ */
+export function exportPrometheusMetrics(stats, labels) {
+    const labelMap = { instance: 'default', ...labels };
+    const labelStr = Object.entries(labelMap)
+        .map(([k, v]) => `${k}="${v}"`)
+        .join(',');
+    const lines = [];
+    const addMetric = (name, type, help, value) => {
+        lines.push(`# HELP ${name} ${help}`);
+        lines.push(`# TYPE ${name} ${type}`);
+        lines.push(`${name}{${labelStr}} ${value}`);
+    };
+    // Counters
+    addMetric('antiban_messages_allowed_total', 'counter', 'Total messages allowed by AntiBan', stats.messagesAllowed);
+    addMetric('antiban_messages_blocked_total', 'counter', 'Total messages blocked by AntiBan', stats.messagesBlocked);
+    addMetric('antiban_total_delay_ms_total', 'counter', 'Total delay imposed (milliseconds)', stats.totalDelayMs);
+    // Health gauges
+    const riskMap = { low: 0, medium: 1, high: 2, critical: 3 };
+    addMetric('antiban_health_score', 'gauge', 'Current health score (0=best, 100=worst)', stats.health.score);
+    addMetric('antiban_health_risk', 'gauge', 'Risk level encoded as number (0=low, 1=medium, 2=high, 3=critical)', riskMap[stats.health.risk] ?? 0);
+    addMetric('antiban_disconnects_last_hour', 'gauge', 'Disconnects in last hour', stats.health.stats.disconnectsLastHour);
+    addMetric('antiban_failed_messages_last_hour', 'gauge', 'Failed messages in last hour', stats.health.stats.failedMessagesLastHour);
+    addMetric('antiban_uptime_ms', 'gauge', 'Session uptime in milliseconds', stats.health.stats.uptimeMs);
+    // Warm-up gauges
+    addMetric('antiban_warmup_progress', 'gauge', 'Warm-up progress (0.0 to 1.0)', stats.warmUp.progress);
+    addMetric('antiban_warmup_day', 'gauge', 'Current warm-up day', stats.warmUp.day);
+    addMetric('antiban_warmup_today_sent', 'gauge', 'Messages sent today during warm-up', stats.warmUp.todaySent);
+    addMetric('antiban_warmup_today_limit', 'gauge', 'Message limit for today during warm-up', stats.warmUp.todayLimit);
+    // Rate limiter gauges
+    addMetric('antiban_rate_last_minute', 'gauge', 'Messages sent in last minute', stats.rateLimiter.lastMinute);
+    addMetric('antiban_rate_last_hour', 'gauge', 'Messages sent in last hour', stats.rateLimiter.lastHour);
+    addMetric('antiban_rate_last_day', 'gauge', 'Messages sent in last day', stats.rateLimiter.lastDay);
+    addMetric('antiban_rate_limit_per_minute', 'gauge', 'Rate limit per minute', stats.rateLimiter.limits.perMinute);
+    addMetric('antiban_rate_limit_per_hour', 'gauge', 'Rate limit per hour', stats.rateLimiter.limits.perHour);
+    addMetric('antiban_rate_limit_per_day', 'gauge', 'Rate limit per day', stats.rateLimiter.limits.perDay);
+    addMetric('antiban_known_chats', 'gauge', 'Number of known chats', stats.rateLimiter.knownChats);
+    // Reply ratio gauges (optional)
+    if (stats.replyRatio) {
+        addMetric('antiban_contacts_on_cooldown', 'gauge', 'Contacts currently on reply cooldown', stats.replyRatio.contactsOnCooldown);
+    }
+    else {
+        addMetric('antiban_contacts_on_cooldown', 'gauge', 'Contacts currently on reply cooldown', 0);
+    }
+    // Contact graph gauges (optional)
+    if (stats.contactGraph) {
+        addMetric('antiban_known_contacts', 'gauge', 'Number of known contacts', stats.contactGraph.knownContacts);
+        addMetric('antiban_pending_handshakes', 'gauge', 'Pending handshakes', stats.contactGraph.pendingHandshakes);
+    }
+    else {
+        addMetric('antiban_known_contacts', 'gauge', 'Number of known contacts', 0);
+        addMetric('antiban_pending_handshakes', 'gauge', 'Pending handshakes', 0);
+    }
+    // Retry tracker gauges (optional)
+    if (stats.retryTracker) {
+        addMetric('antiban_retry_spirals', 'gauge', 'Number of retry spirals detected', stats.retryTracker.spiralsDetected);
+        addMetric('antiban_active_retries', 'gauge', 'Currently active retries', stats.retryTracker.activeRetries);
+    }
+    else {
+        addMetric('antiban_retry_spirals', 'gauge', 'Number of retry spirals detected', 0);
+        addMetric('antiban_active_retries', 'gauge', 'Currently active retries', 0);
+    }
+    // Reconnect throttle gauges (optional)
+    if (stats.reconnectThrottle) {
+        addMetric('antiban_reconnect_throttled', 'gauge', 'Whether reconnect is currently throttled (0=no, 1=yes)', stats.reconnectThrottle.isThrottled ? 1 : 0);
+        addMetric('antiban_lifetime_reconnects', 'gauge', 'Total reconnects in session lifetime', stats.reconnectThrottle.lifetimeReconnects);
+    }
+    else {
+        addMetric('antiban_reconnect_throttled', 'gauge', 'Whether reconnect is currently throttled (0=no, 1=yes)', 0);
+        addMetric('antiban_lifetime_reconnects', 'gauge', 'Total reconnects in session lifetime', 0);
+    }
+    return lines.join('\n') + '\n';
+}
+/**
+ * Create an HTTP handler for Prometheus metrics (Express/Fastify compatible)
+ */
+export function createMetricsHandler(getStats, labels) {
+    return {
+        /**
+         * HTTP request handler (Express/Fastify compatible)
+         */
+        handle: (_req, res) => {
+            const metrics = exportPrometheusMetrics(getStats(), labels);
+            res.setHeader('Content-Type', 'text/plain; version=0.0.4; charset=utf-8');
+            res.end(metrics);
+        },
+        /**
+         * Get metrics as plain text (for non-HTTP usage)
+         */
+        text: () => {
+            return exportPrometheusMetrics(getStats(), labels);
+        },
+    };
+}
+/**
+ * Create a periodic metrics exporter that calls onMetrics on an interval
+ */
+export function createPeriodicExporter(getStats, config) {
+    const intervalMs = config.intervalMs ?? 30_000;
+    const intervalId = setInterval(() => {
+        const metrics = exportPrometheusMetrics(getStats(), config.labels);
+        config.onMetrics(metrics);
+    }, intervalMs);
+    return {
+        stop: () => clearInterval(intervalId),
+    };
+}

package/lib/AntiBan/patch.js

@@ -0,0 +1,302 @@
+/**
+ * baileys-antiban patch command
+ *
+ * Patches an installed Baileys package to wrap makeWASocket with antiban middleware.
+ * Designed for frameworks (OpenClaw, etc.) that create the socket internally and
+ * don't expose a socket:ready hook.
+ *
+ * Idempotent: safe to re-run after plugin updates. Keeps a .antiban-backup file.
+ *
+ * Usage:
+ *   npx baileys-antiban patch [--path <baileys-dir>] [--dry-run] [--preset conservative|moderate|aggressive]
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const PATCH_MARKER_START = '// [BAILEYS-ANTIBAN-PATCH-START]';
+const PATCH_MARKER_END = '// [BAILEYS-ANTIBAN-PATCH-END]';
+function findBaileysDir(candidates) {
+    for (const candidate of candidates) {
+        if (!candidate)
+            continue;
+        const pkgPath = path.join(candidate, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'baileys' || pkg.name === '@whiskeysockets/baileys' || pkg.name === '@oxidezap/baileyrs') {
+                    return path.resolve(candidate);
+                }
+            }
+            catch {
+                // not a valid package.json, skip
+            }
+        }
+    }
+    return null;
+}
+function findMakeWASocketFile(baileyDir) {
+    // Ordered by likelihood of containing the actual makeWASocket definition
+    const candidates = [
+        'lib/socket/index.js',
+        'lib/index.js',
+        'lib/socket.js',
+        'src/socket/index.js',
+        'dist/socket/index.js',
+        'dist/index.js',
+    ];
+    for (const rel of candidates) {
+        const full = path.join(baileyDir, rel);
+        if (!fs.existsSync(full))
+            continue;
+        const source = fs.readFileSync(full, 'utf-8');
+        // Look for makeWASocket being defined (not just re-exported via export *)
+        if (source.includes('function makeWASocket') ||
+            source.includes('const makeWASocket') ||
+            source.includes('exports.makeWASocket') ||
+            source.includes('makeWASocket =')) {
+            const isEsm = source.includes('export function makeWASocket') ||
+                source.includes('export const makeWASocket') ||
+                source.includes('export {') ||
+                source.includes('export default');
+            return { file: full, format: isEsm ? 'esm' : 'cjs' };
+        }
+    }
+    // Fallback: search lib/ directory for the defining file
+    const libDir = path.join(baileyDir, 'lib');
+    if (fs.existsSync(libDir)) {
+        const jsFiles = fs
+            .readdirSync(libDir, { recursive: true })
+            .filter((f) => typeof f === 'string' && f.endsWith('.js'))
+            .map((f) => path.join(libDir, f));
+        for (const full of jsFiles) {
+            try {
+                const source = fs.readFileSync(full, 'utf-8');
+                if (source.includes('function makeWASocket') && source.includes('makeWASocket')) {
+                    const isEsm = source.includes('export');
+                    return { file: full, format: isEsm ? 'esm' : 'cjs' };
+                }
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+    }
+    return null;
+}
+function buildCjsPatch(opts) {
+    return `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+(function() {
+  try {
+    const { wrapSocket } = require('baileys-antiban');
+    const _orig = module.exports.makeWASocket;
+    if (typeof _orig === 'function') {
+      module.exports.makeWASocket = function(...args) {
+        return wrapSocket(_orig.apply(this, args), {
+          preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+          delayBetweenMessages: {
+            min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+            max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+          },
+          typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+        });
+      };
+    }
+  } catch(e) {
+    console.warn('[baileys-antiban] patch inactive:', e.message);
+  }
+})();
+${PATCH_MARKER_END}
+`;
+}
+function buildEsmPatch(source, opts) {
+    // Strategy A: function declaration — rename and re-export wrapped version
+    if (source.includes('export function makeWASocket')) {
+        const patched = source.replace(/export function makeWASocket\b/, 'function _antiban_makeWASocket_orig');
+        return (patched +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+export const makeWASocket = (...args) => _antibanWrap(_antiban_makeWASocket_orig(...args), {
+  preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+  delayBetweenMessages: {
+    min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+    max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+  },
+  typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+});
+${PATCH_MARKER_END}
+`);
+    }
+    // Strategy B: const/let declaration — rename and re-export
+    if (source.match(/export\s+(const|let)\s+makeWASocket\s*=/)) {
+        const patched = source.replace(/export\s+(const|let)\s+makeWASocket\s*=/, 'const _antiban_makeWASocket_orig =');
+        return (patched +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+export const makeWASocket = (...args) => _antibanWrap(_antiban_makeWASocket_orig(...args), {
+  preset: process.env.ANTIBAN_PRESET || '${opts.preset}',
+  delayBetweenMessages: {
+    min: parseInt(process.env.ANTIBAN_MIN_DELAY || '${opts.minDelay}'),
+    max: parseInt(process.env.ANTIBAN_MAX_DELAY || '${opts.maxDelay}'),
+  },
+  typingIndicator: (process.env.ANTIBAN_TYPING || '${opts.typing}') !== 'false',
+});
+${PATCH_MARKER_END}
+`);
+    }
+    // Strategy C: named re-export — intercept at this boundary
+    if (source.includes('makeWASocket')) {
+        // Append import + re-export override at end of file
+        return (source +
+            `
+${PATCH_MARKER_START}
+// Auto-generated by baileys-antiban patch. Re-run after Baileys/plugin updates.
+// NOTE: Strategy C (named export intercept) — less precise than A/B.
+// If this breaks, use --path to target the file where makeWASocket is defined.
+import { wrapSocket as _antibanWrap } from 'baileys-antiban';
+const _antiban_raw = makeWASocket;
+export { makeWASocket };  // shadowed below if engine supports block-level export rebind
+// Fallback: log advisory if strategy C can't reassign
+if (typeof makeWASocket === 'function') {
+  // eslint-disable-next-line no-global-assign
+  try { makeWASocket = (...a) => _antibanWrap(_antiban_raw(...a), { preset: '${opts.preset}', delayBetweenMessages: { min: ${opts.minDelay}, max: ${opts.maxDelay} }, typingIndicator: ${opts.typing} }); } catch {}
+}
+${PATCH_MARKER_END}
+`);
+    }
+    throw new Error('Could not locate makeWASocket in this file. Try --path to a different Baileys file.');
+}
+export function applyPatch(opts) {
+    const { preset = 'conservative', minDelay = 1500, maxDelay = 4000, typingIndicator = true, dryRun = false, } = opts;
+    // 1. Locate Baileys
+    const defaultSearchPaths = [
+        // OC-style nested location
+        './node_modules/@openclaw/whatsapp/node_modules/baileys',
+        './node_modules/@openclaw/whatsapp/node_modules/@whiskeysockets/baileys',
+        // Standard locations
+        './node_modules/baileys',
+        './node_modules/@whiskeysockets/baileys',
+        // Walk up
+        '../node_modules/baileys',
+        '../../node_modules/baileys',
+    ];
+    const searchPaths = opts.baileysPaths?.length ? opts.baileysPaths : defaultSearchPaths;
+    const baileyDir = findBaileysDir(searchPaths);
+    if (!baileyDir) {
+        return {
+            success: false,
+            baileyDir: '(not found)',
+            targetFile: '(not found)',
+            alreadyPatched: false,
+            format: 'cjs',
+            message: 'Could not find Baileys package. Use --path <dir> to specify its location.\n' +
+                'Example: npx baileys-antiban patch --path ./node_modules/@openclaw/whatsapp/node_modules/baileys',
+        };
+    }
+    // 2. Find file containing makeWASocket
+    const found = findMakeWASocketFile(baileyDir);
+    if (!found) {
+        return {
+            success: false,
+            baileyDir,
+            targetFile: '(not found)',
+            alreadyPatched: false,
+            format: 'cjs',
+            message: `Found Baileys at ${baileyDir} but could not locate makeWASocket definition.\n` +
+                'The package structure may have changed. Please open an issue.',
+        };
+    }
+    const { file: targetFile, format } = found;
+    const source = fs.readFileSync(targetFile, 'utf-8');
+    // 3. Check idempotency
+    if (source.includes(PATCH_MARKER_START)) {
+        return {
+            success: true,
+            baileyDir,
+            targetFile,
+            alreadyPatched: true,
+            format,
+            message: `Already patched: ${targetFile}\nRe-run with --force to re-apply.`,
+        };
+    }
+    if (dryRun) {
+        return {
+            success: true,
+            baileyDir,
+            targetFile,
+            alreadyPatched: false,
+            format,
+            message: `[dry-run] Would patch ${targetFile} (format: ${format})`,
+        };
+    }
+    // 4. Backup
+    const backupPath = targetFile + '.antiban-backup';
+    if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(targetFile, backupPath);
+    }
+    // 5. Build and apply patch
+    const patchOpts = { preset, minDelay, maxDelay, typing: typingIndicator };
+    let patched;
+    try {
+        if (format === 'cjs') {
+            patched = source + buildCjsPatch(patchOpts);
+        }
+        else {
+            patched = buildEsmPatch(source, patchOpts);
+        }
+    }
+    catch (e) {
+        return {
+            success: false,
+            baileyDir,
+            targetFile,
+            alreadyPatched: false,
+            format,
+            message: `Patch generation failed: ${e.message}`,
+        };
+    }
+    fs.writeFileSync(targetFile, patched, 'utf-8');
+    return {
+        success: true,
+        baileyDir,
+        targetFile,
+        alreadyPatched: false,
+        format,
+        backupPath,
+        message: `✅ Patched: ${targetFile}\n` +
+            `   Format:  ${format}\n` +
+            `   Backup:  ${backupPath}\n` +
+            `   Preset:  ${preset} (${minDelay}–${maxDelay}ms delays, typing=${typingIndicator})\n` +
+            `\nTo auto-re-patch after plugin updates, add to your package.json:\n` +
+            `  "scripts": { "postinstall": "npx baileys-antiban patch" }\n\n` +
+            `Env overrides: ANTIBAN_PRESET, ANTIBAN_MIN_DELAY, ANTIBAN_MAX_DELAY, ANTIBAN_TYPING`,
+    };
+}
+export function unpatchFile(targetFile) {
+    if (!fs.existsSync(targetFile)) {
+        return { success: false, message: `File not found: ${targetFile}` };
+    }
+    const backupPath = targetFile + '.antiban-backup';
+    if (!fs.existsSync(backupPath)) {
+        // Try removing the patch block from source
+        const source = fs.readFileSync(targetFile, 'utf-8');
+        if (!source.includes(PATCH_MARKER_START)) {
+            return { success: true, message: 'File is not patched.' };
+        }
+        const startIdx = source.indexOf(PATCH_MARKER_START);
+        const endIdx = source.indexOf(PATCH_MARKER_END);
+        if (startIdx === -1 || endIdx === -1) {
+            return { success: false, message: 'Patch markers found but malformed. Restore manually from backup.' };
+        }
+        const cleaned = source.slice(0, startIdx) + source.slice(endIdx + PATCH_MARKER_END.length);
+        fs.writeFileSync(targetFile, cleaned, 'utf-8');
+        return { success: true, message: `Patch removed from ${targetFile}` };
+    }
+    fs.copyFileSync(backupPath, targetFile);
+    fs.unlinkSync(backupPath);
+    return { success: true, message: `Restored from backup: ${backupPath}` };
+}

package/lib/AntiBan/persist.js

@@ -0,0 +1,87 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const KNOWN_CHATS_MAX = 1000;
+const DEBOUNCE_MS = 5000;
+/**
+ * Manages persisted state for a single baileys-antiban instance.
+ *
+ * **Single-writer assumption:** No file lock is used. Two processes sharing
+ * the same state file will race on concurrent writes. Use separate state
+ * files per process to avoid data corruption.
+ */
+export class StateManager {
+    path;
+    debounceTimer = null;
+    constructor(filePath) {
+        // Resolve to absolute path and reject null bytes to prevent path injection
+        if (filePath.includes('\0'))
+            throw new Error('[baileys-antiban] Invalid state file path: null byte');
+        this.path = path.resolve(filePath);
+    }
+    load() {
+        try {
+            const raw = fs.readFileSync(this.path, 'utf-8');
+            const parsed = JSON.parse(raw);
+            // Strict shape validation before trusting file content
+            if (typeof parsed !== 'object' || parsed === null ||
+                parsed.version !== 3 ||
+                typeof parsed.savedAt !== 'number' ||
+                !Array.isArray(parsed.knownChats)) {
+                console.warn('[baileys-antiban] WARN: corrupt state file or version mismatch, starting fresh');
+                return null;
+            }
+            return parsed;
+        }
+        catch {
+            // Missing file = silent null. Corrupt JSON = warn.
+            if (fs.existsSync(this.path)) {
+                console.warn('[baileys-antiban] WARN: corrupt state file, starting fresh');
+            }
+            return null;
+        }
+    }
+    /** Debounced save — called after every send (5s delay) */
+    saveDebounced(state) {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+        this.debounceTimer = setTimeout(() => {
+            this.writeFile(state);
+            this.debounceTimer = null;
+        }, DEBOUNCE_MS);
+    }
+    /** Immediate save — called after health events (ban/restriction) */
+    saveImmediate(state) {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.writeFile(state);
+    }
+    /** Flush/cancel pending debounced write (for tests and process exit) */
+    flush() {
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+    }
+    destroy() {
+        this.flush();
+    }
+    writeFile(state) {
+        const toSave = {
+            ...state,
+            savedAt: Date.now(),
+            // LRU eviction: keep last KNOWN_CHATS_MAX entries
+            knownChats: state.knownChats.length > KNOWN_CHATS_MAX
+                ? state.knownChats.slice(-KNOWN_CHATS_MAX)
+                : state.knownChats,
+        };
+        try {
+            fs.writeFileSync(this.path, JSON.stringify(toSave, null, 2), 'utf-8');
+        }
+        catch (err) {
+            console.warn(`[baileys-antiban] WARN: failed to write state to ${this.path}:`, err);
+        }
+    }
+}