@fer2809fl/baileys 7.0.4 → 7.0.5

package/lib/Utils/smart-reconnect.js

@@ -0,0 +1,207 @@
+import { DisconnectReason } from '../Types/index.js';
+
+const RECONNECT_CONFIG = {
+    MAX_RETRIES: 15,
+    INITIAL_DELAY: 1000,
+    MAX_DELAY: 300000,
+    BACKOFF_FACTOR: 1.5,
+    JITTER_FACTOR: 0.3,
+    STABLE_CONNECTION_TIME: 60000,
+    RECOVERABLE_REASONS: [
+        DisconnectReason.connectionClosed,
+        DisconnectReason.connectionLost,
+        DisconnectReason.connectionReplaced,
+        DisconnectReason.timedOut,
+        DisconnectReason.restartRequired
+    ],
+    FATAL_REASONS: [
+        DisconnectReason.loggedOut,
+        DisconnectReason.badSession,
+        DisconnectReason.multideviceMismatch
+    ]
+};
+
+class SmartReconnect {
+    constructor(logger, config = {}) {
+        this.logger = logger;
+        this.config = { ...RECONNECT_CONFIG, ...config };
+        this.retryCount = 0;
+        this.lastConnectTime = null;
+        this.lastDisconnectReason = null;
+        this.connectionStable = false;
+        this.reconnectTimer = null;
+        this.healthCheckInterval = null;
+        this.stats = {
+            totalReconnects: 0,
+            successfulReconnects: 0,
+            failedReconnects: 0,
+            lastSuccessfulConnect: null,
+            averageDowntime: 0
+        };
+    }
+
+    calculateDelay() {
+        const baseDelay = this.config.INITIAL_DELAY * Math.pow(this.config.BACKOFF_FACTOR, this.retryCount);
+        const cappedDelay = Math.min(baseDelay, this.config.MAX_DELAY);
+        const jitter = cappedDelay * this.config.JITTER_FACTOR * (Math.random() - 0.5);
+        return Math.floor(cappedDelay + jitter);
+    }
+
+    shouldReconnect(reason, statusCode) {
+        if (this.config.FATAL_REASONS.includes(statusCode)) {
+            this.logger?.warn({ reason, statusCode }, 'Fatal disconnect reason - not reconnecting');
+            return { shouldReconnect: false, reason: 'Fatal error - session invalidated' };
+        }
+        if (this.retryCount >= this.config.MAX_RETRIES) {
+            this.logger?.error({ retryCount: this.retryCount }, 'Max retries exceeded');
+            return { shouldReconnect: false, reason: 'Max retries exceeded' };
+        }
+        if (this.config.RECOVERABLE_REASONS.includes(statusCode)) {
+            return { shouldReconnect: true, delay: this.calculateDelay() };
+        }
+        return { shouldReconnect: true, delay: this.calculateDelay() * 2 };
+    }
+
+    async handleDisconnect(reason, statusCode, reconnectCallback) {
+        this.lastDisconnectReason = { reason, statusCode, time: Date.now() };
+        this.connectionStable = false;
+        const decision = this.shouldReconnect(reason, statusCode);
+        if (!decision.shouldReconnect) {
+            this.logger?.info({ reason: decision.reason }, 'Not attempting reconnection');
+            return { reconnecting: false, reason: decision.reason };
+        }
+        this.retryCount++;
+        this.stats.totalReconnects++;
+        const delay = decision.delay;
+        this.logger?.info({ attempt: this.retryCount, maxRetries: this.config.MAX_RETRIES, delay, reason }, 'Scheduling reconnection');
+        return new Promise((resolve) => {
+            this.reconnectTimer = setTimeout(async () => {
+                try {
+                    await reconnectCallback();
+                    this.onSuccessfulReconnect();
+                    resolve({ reconnecting: true, success: true });
+                } catch (error) {
+                    this.stats.failedReconnects++;
+                    this.logger?.error({ error }, 'Reconnection failed');
+                    resolve({ reconnecting: true, success: false, error });
+                }
+            }, delay);
+        });
+    }
+
+    onSuccessfulReconnect() {
+        const previousRetries = this.retryCount;
+        this.retryCount = 0;
+        this.lastConnectTime = Date.now();
+        this.stats.successfulReconnects++;
+        this.stats.lastSuccessfulConnect = new Date().toISOString();
+        this.logger?.info({ previousRetries }, 'Successfully reconnected');
+        setTimeout(() => {
+            if (this.lastConnectTime && Date.now() - this.lastConnectTime >= this.config.STABLE_CONNECTION_TIME) {
+                this.connectionStable = true;
+                this.logger?.debug('Connection marked as stable');
+            }
+        }, this.config.STABLE_CONNECTION_TIME);
+    }
+
+    cancelPendingReconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+    }
+
+    reset() {
+        this.retryCount = 0;
+        this.lastDisconnectReason = null;
+        this.cancelPendingReconnect();
+    }
+
+    getStats() {
+        return {
+            ...this.stats,
+            currentRetryCount: this.retryCount,
+            isStable: this.connectionStable,
+            lastDisconnect: this.lastDisconnectReason
+        };
+    }
+
+    startHealthCheck(pingCallback, interval = 30000) {
+        this.stopHealthCheck();
+        this.healthCheckInterval = setInterval(async () => {
+            try {
+                await pingCallback();
+                this.logger?.debug('Health check passed');
+            } catch (error) {
+                this.logger?.warn({ error }, 'Health check failed');
+            }
+        }, interval);
+    }
+
+    stopHealthCheck() {
+        if (this.healthCheckInterval) {
+            clearInterval(this.healthCheckInterval);
+            this.healthCheckInterval = null;
+        }
+    }
+
+    cleanup() {
+        this.cancelPendingReconnect();
+        this.stopHealthCheck();
+    }
+}
+
+function createConnectionHandler(sock, logger, options = {}) {
+    const reconnect = new SmartReconnect(logger, options);
+    return {
+        reconnect,
+        async handleConnectionUpdate(update, startSock) {
+            const { connection, lastDisconnect, qr } = update;
+            if (connection === 'close') {
+                const statusCode = lastDisconnect?.error?.output?.statusCode;
+                const reason = lastDisconnect?.error?.message || 'Unknown';
+                const result = await reconnect.handleDisconnect(reason, statusCode, startSock);
+                return result;
+            }
+            if (connection === 'open') {
+                reconnect.onSuccessfulReconnect();
+                return { connected: true };
+            }
+            if (qr) {
+                reconnect.reset();
+                return { qr };
+            }
+            return update;
+        },
+        getStatus() {
+            return {
+                stats: reconnect.getStats(),
+                isHealthy: reconnect.connectionStable && reconnect.retryCount === 0
+            };
+        }
+    };
+}
+
+async function withRetry(fn, options = {}) {
+    const { maxRetries = 3, delay = 1000, backoff = 2, onRetry = null } = options;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        } catch (error) {
+            lastError = error;
+            if (attempt === maxRetries) throw error;
+            const waitTime = delay * Math.pow(backoff, attempt);
+            if (onRetry) onRetry(error, attempt + 1, waitTime);
+            await new Promise(resolve => setTimeout(resolve, waitTime));
+        }
+    }
+    throw lastError;
+}
+
+export {
+    RECONNECT_CONFIG,
+    SmartReconnect,
+    createConnectionHandler,
+    withRetry
+};

package/lib/Utils/use-sqlite-auth-state.d.ts

@@ -0,0 +1,11 @@
+import type { AuthenticationState } from "../Types/index.js";
+
+export declare function useSqliteAuthState(opts: {
+    dbPath?: string;
+    database?: any;
+}): Promise<{
+    state: AuthenticationState;
+    saveCreds: () => Promise<void>;
+    clearKeys: () => Promise<void>;
+    close: () => void;
+}>;

package/lib/Utils/use-sqlite-auth-state.js

@@ -0,0 +1,95 @@
+import { proto } from '../../WAProto/index.js';
+import { initAuthCreds } from './auth-utils.js';
+import { BufferJSON } from './generics.js';
+
+const CREDS_ROW_KEY = '__creds__';
+
+const CREATE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS creds (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+CREATE TABLE IF NOT EXISTS signal_keys (
+  type TEXT NOT NULL,
+  id TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (type, id)
+);
+CREATE INDEX IF NOT EXISTS signal_keys_type_idx ON signal_keys(type);
+`;
+
+async function useSqliteAuthState(opts) {
+    let Database;
+    try {
+        Database = (await import('better-sqlite3')).default;
+    } catch (err) {
+        throw new Error('`better-sqlite3` is required for `useSqliteAuthState`. Install with: npm install better-sqlite3');
+    }
+
+    const db = opts.database || new Database(opts.dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('synchronous = NORMAL');
+    db.exec(CREATE_SCHEMA_SQL);
+
+    const stmts = {
+        credsSelect: db.prepare('SELECT value FROM creds WHERE key = ?'),
+        credsUpsert: db.prepare('INSERT INTO creds (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value'),
+        keySelect: db.prepare('SELECT value FROM signal_keys WHERE type = ? AND id = ?'),
+        keyUpsert: db.prepare('INSERT INTO signal_keys (type, id, value) VALUES (?, ?, ?) ON CONFLICT(type, id) DO UPDATE SET value = excluded.value'),
+        keyDelete: db.prepare('DELETE FROM signal_keys WHERE type = ? AND id = ?'),
+        keyListIds: db.prepare('SELECT id FROM signal_keys WHERE type = ?'),
+        keyList: db.prepare('SELECT id, value FROM signal_keys WHERE type = ?'),
+        clearKeys: db.prepare('DELETE FROM signal_keys')
+    };
+
+    const loadCreds = () => {
+        const row = stmts.credsSelect.get(CREDS_ROW_KEY);
+        if (!row) return initAuthCreds();
+        return JSON.parse(row.value, BufferJSON.reviver);
+    };
+
+    const persistCreds = creds => {
+        stmts.credsUpsert.run(CREDS_ROW_KEY, JSON.stringify(creds, BufferJSON.replacer));
+    };
+
+    const creds = loadCreds();
+
+    return {
+        state: {
+            creds,
+            keys: {
+                get: async (type, ids) => {
+                    const data = {};
+                    for (const id of ids) {
+                        const row = stmts.keySelect.get(type, id);
+                        if (row) {
+                            let value = JSON.parse(row.value, BufferJSON.reviver);
+                            if (type === 'app-state-sync-key' && value) {
+                                value = proto.Message.AppStateSyncKeyData.fromObject(value);
+                            }
+                            data[id] = value;
+                        }
+                    }
+                    return data;
+                },
+                set: async data => {
+                    const writeTx = db.transaction(() => {
+                        for (const category in data) {
+                            for (const id in data[category]) {
+                                const value = data[category][id];
+                                if (value) stmts.keyUpsert.run(category, id, JSON.stringify(value, BufferJSON.replacer));
+                                else stmts.keyDelete.run(category, id);
+                            }
+                        }
+                    });
+                    writeTx();
+                }
+            }
+        },
+        saveCreds: async () => { persistCreds(creds); },
+        clearKeys: async () => { stmts.clearKeys.run(); },
+        close: () => { db.close(); }
+    };
+}
+
+export { useSqliteAuthState };

package/lib/VoIP/audio-feeder.d.ts

@@ -0,0 +1,15 @@
+export declare class AudioFeeder {
+    #private;
+    private readonly sampleRate;
+    private readonly channels;
+    private readonly framesPerChunk;
+    private readonly onChunk;
+    private readonly source;
+    droppedChunks: number;
+    underflowChunks: number;
+    bytesProduced: number;
+    chunksEmitted: number;
+    constructor(sampleRate: number, channels: number, framesPerChunk: number, onChunk: (chunk: Float32Array) => void, source?: string);
+    start: () => void;
+    stop: () => void;
+}

package/lib/VoIP/audio-feeder.js

@@ -0,0 +1,132 @@
+/**
+ * Audio feeder.
+ *
+ * Spawns ffmpeg to decode `source` into f32le PCM at the requested rate, then
+ * meters frames out at chunk-cadence to the WASM uplink.
+ *
+ * @author ShellTear
+ */
+import { spawn } from "node:child_process";
+const LOW_WATERMARK_CHUNKS = 16;
+const MAX_QUEUED_CHUNKS = 1024;
+const DEFAULT_WARMUP_MS = 500;
+export class AudioFeeder {
+    sampleRate;
+    channels;
+    framesPerChunk;
+    onChunk;
+    source;
+    #proc = null;
+    #pending = Buffer.alloc(0);
+    #queue = [];
+    #emitTimer = null;
+    #nextEmitAtMs = 0;
+    #warmupUntilMs = 0;
+    droppedChunks = 0;
+    underflowChunks = 0;
+    bytesProduced = 0;
+    chunksEmitted = 0;
+    constructor(sampleRate, channels, framesPerChunk, onChunk, source = "silence") {
+        this.sampleRate = sampleRate;
+        this.channels = channels;
+        this.framesPerChunk = framesPerChunk;
+        this.onChunk = onChunk;
+        this.source = source;
+    }
+    start = () => {
+        if (this.#proc)
+            return;
+        const chunkSamples = this.framesPerChunk * this.channels;
+        const chunkBytes = chunkSamples * Float32Array.BYTES_PER_ELEMENT;
+        const chunkIntervalMs = (this.framesPerChunk / this.sampleRate) * 1000;
+        const inputArgs = this.#resolveInputArgs();
+        this.#proc = spawn("ffmpeg", [
+            "-hide_banner",
+            "-loglevel", "error",
+            "-thread_queue_size", "512",
+            ...inputArgs,
+            "-f", "f32le",
+            "-ac", String(this.channels),
+            "-ar", String(this.sampleRate),
+            "pipe:1",
+        ]);
+        this.#proc.stdout.on("data", (chunk) => {
+            this.#pending = Buffer.concat([this.#pending, chunk]);
+            while (this.#pending.length >= chunkBytes) {
+                if (this.#queue.length >= MAX_QUEUED_CHUNKS) {
+                    this.#proc?.stdout.pause();
+                    break;
+                }
+                const frame = this.#pending.subarray(0, chunkBytes);
+                this.#pending = this.#pending.subarray(chunkBytes);
+                const out = new Float32Array(chunkSamples);
+                out.set(new Float32Array(frame.buffer, frame.byteOffset, chunkSamples));
+                this.bytesProduced += chunkBytes;
+                this.#queue.push(out);
+            }
+        });
+        this.#proc.stderr.on("data", (chunk) => {
+            process.stderr.write(`[AudioFeeder] ${chunk.toString().trim()}\n`);
+        });
+        this.#proc.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                process.stderr.write(`[AudioFeeder] ffmpeg exited with code=${code}\n`);
+            }
+            this.#proc = null;
+        });
+        this.#nextEmitAtMs = 0;
+        this.#warmupUntilMs = Date.now() + DEFAULT_WARMUP_MS;
+        this.#scheduleNext(chunkSamples, chunkIntervalMs);
+    };
+    stop = () => {
+        if (this.#emitTimer) {
+            clearTimeout(this.#emitTimer);
+            this.#emitTimer = null;
+        }
+        this.#proc?.kill("SIGTERM");
+        this.#proc = null;
+        this.#pending = Buffer.alloc(0);
+        this.#queue = [];
+        this.#warmupUntilMs = 0;
+    };
+    #resolveInputArgs = () => {
+        if (!this.source || this.source === "silence") {
+            return ["-f", "lavfi", "-i", `aevalsrc=0:d=3600:s=${this.sampleRate}`];
+        }
+        if (this.source.startsWith("lavfi:")) {
+            return ["-f", "lavfi", "-i", this.source.slice("lavfi:".length)];
+        }
+        return ["-i", this.source];
+    };
+    #scheduleNext = (chunkSamples, chunkIntervalMs) => {
+        if (!this.#proc)
+            return;
+        const now = Date.now();
+        if (this.#nextEmitAtMs === 0)
+            this.#nextEmitAtMs = now;
+        const delayMs = Math.max(0, this.#nextEmitAtMs - now);
+        this.#emitTimer = setTimeout(() => {
+            this.#emitTimer = null;
+            if (this.#queue.length < LOW_WATERMARK_CHUNKS && Date.now() < this.#warmupUntilMs) {
+                this.#nextEmitAtMs = Date.now() + 10;
+                this.#scheduleNext(chunkSamples, chunkIntervalMs);
+                return;
+            }
+            this.#flushOne(chunkSamples);
+            this.#nextEmitAtMs += chunkIntervalMs;
+            this.#scheduleNext(chunkSamples, chunkIntervalMs);
+        }, delayMs);
+    };
+    #flushOne = (chunkSamples) => {
+        let nextChunk = this.#queue.shift();
+        if (!nextChunk) {
+            nextChunk = new Float32Array(chunkSamples);
+            this.underflowChunks += 1;
+        }
+        this.chunksEmitted += 1;
+        this.onChunk(nextChunk);
+        if (this.#proc?.stdout.isPaused() && this.#queue.length <= MAX_QUEUED_CHUNKS / 4) {
+            this.#proc.stdout.resume();
+        }
+    };
+}