jsdecryptor 4.0.3

package/index.js

@@ -0,0 +1,994 @@
+const config = require('./config');
+require('dotenv').config();
+
+const fs = require('fs')
+const chalk = require('chalk').default || require('chalk')
+const path = require('path')
+const axios = require('axios')
+const os = require('os')
+const PhoneNumber = require('awesome-phonenumber')
+const express = require('express')
+
+const app = express()
+const PORT = process.env.PORT || 3000
+app.get('/', (req, res) => {
+    res.sendFile(path.join(__dirname, 'davelib', 'server.html'))
+})
+app.listen(PORT, '0.0.0.0', () => {
+    console.log(`[ DAVE-X ] Web server running on port ${PORT}`)
+})
+const {
+    default: makeWASocket,
+    useMultiFileAuthState,
+    DisconnectReason,
+    fetchLatestBaileysVersion,
+    jidNormalizedUser,
+    makeCacheableSignalKeyStore,
+    delay 
+} = require("@whiskeysockets/baileys")
+
+const NodeCache = require("node-cache")
+const pino = require("pino")
+const readline = require("readline")
+const { rmSync } = require('fs')
+
+// --- Readline setup (JUNE X style) - NO DELAYS ---
+const rl = process.stdin.isTTY ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null
+const question = (text) => rl ? new Promise(resolve => rl.question(text, resolve)) : Promise.resolve(global.phoneNumber)
+
+// --- OPTIMIZATION: For 308MB RAM panel ---
+const MSG_CACHE_SIZE = 10;
+const MSG_AGE_HOURS = 2;
+const MEMORY_THRESHOLD = 260;     // Cleanup at 260MB (bot idles at ~227MB)
+const CRITICAL_MEMORY = 285;       // Critical at 285MB
+const EMERGENCY_MEMORY = 300;       // Emergency at 300MB
+const SESSION_CLEANUP_HOURS = 12;
+
+// --- GLITCH TEXT ---
+const glitchText = (text) => {
+    return chalk.hex('#00ffff').bold(text) + chalk.hex('#ff00ff')('_');
+};
+
+// --- LOGGING (YOUR STYLE) ---
+function log(message, color = 'white', isError = false) {
+    const logFunc = isError ? _origConsoleError : _origConsoleLog;
+
+    if (message.includes('LIVE') || message.includes('Connected') || message.includes('FATAL')) {
+        logFunc(chalk.bgHex('#0a0a0a').hex('#00ff00')('┌───────────────── DAVE-X ─────────────────┐'));
+        logFunc(chalk.bgHex('#0a0a0a').hex('#ff00ff')(`   ⚡ ${glitchText(isError ? 'ERROR' : 'SYSTEM')}`));
+        logFunc(chalk.bgHex('#0a0a0a').hex('#00ffff')('├─────────────────────────────────────────────┤'));
+        logFunc(
+            chalk.bgHex('#0a0a0a').hex('#ffff00')('   📡 ') +
+            chalk.bgHex('#0a0a0a').hex('#00ff00')('STATUS:') +
+            chalk.bgHex('#0a0a0a').hex('#ffffff')(` ${message}`)
+        );
+        logFunc(chalk.bgHex('#0a0a0a').hex('#00ff00')('└─────────────────────────────────────────────┘\n'));
+    } else {
+        logFunc(
+            chalk.bgHex('#0a0a0a').hex('#ff00ff')('[ DAVE-X ]') +
+            chalk.bgHex('#0a0a0a').hex(isError ? '#ff0000' : '#00ff00')(message)
+        );
+    }
+}
+
+// --- NOISE FILTERING ---
+const noisyPatterns = new Set([
+    'Failed to decrypt', 'Bad MAC', 'decryptWithSessions',
+    'doDecryptWhisperMessage', 'session_cipher',
+    'Closing stale open', 'Decryption failed', 'SignalProtocolStore',
+    'PreKeyWhisperMessage', 'closing session',
+    'Closing session: SessionEntry', 'SessionEntry {',
+    'recv ', 'handling frame', 'query:', 'prekey',
+    'session record', 'identity key', 'sender key', 'ciphertext',
+    'got notification', 'msg:ack', 'writing data', 'got ack',
+    'processing message', 'updating prekeys', 'next pre key',
+    'ws open', 'opened ws', 'frame buffered',
+    'pairing configured', 'handshake',
+    'unreadCount', 'presence'
+]);
+
+function isNoisyLog(...args) {
+    const str = args.map(a => {
+        if (a instanceof Error) return a.message;
+        return typeof a === 'string' ? a : '';
+    }).join('');
+    for (const pattern of noisyPatterns) {
+        if (str.includes(pattern)) return true;
+    }
+    return false;
+}
+
+// --- CONSOLE OVERRIDES ---
+const _origConsoleLog = console.log;
+const _origConsoleError = console.error;
+const _origConsoleWarn = console.warn;
+
+console.log = function(...args) {
+    if (isNoisyLog(...args)) return;
+    _origConsoleLog.apply(console, args);
+};
+
+console.error = function(...args) {
+    if (isNoisyLog(...args)) return;
+    _origConsoleError.apply(console, args);
+};
+
+console.warn = function(...args) {
+    if (isNoisyLog(...args)) return;
+    _origConsoleWarn.apply(console, args);
+};
+
+// --- STDOUT/STDERR FILTER ---
+const _origStdoutWrite = process.stdout.write.bind(process.stdout);
+const _origStderrWrite = process.stderr.write.bind(process.stderr);
+
+const stdoutNoisePatterns = [
+    'Closing session: SessionEntry',
+    'SessionEntry {',
+    '_chains:',
+    'chainKey:',
+    'registrationId:',
+    'currentRatchet:',
+    'ephemeralKeyPair:',
+    'lastRemoteEphemeralKey:',
+    'previousCounter:',
+    'rootKey:',
+    'indexInfo:',
+    'baseKey:',
+    'baseKeyType:',
+    'remoteIdentityKey:',
+    'pendingPreKey:',
+    'signedKeyId:',
+    'preKeyId:',
+    '<Buffer',
+    'closed: -1',
+    'chainType:',
+    'messageKeys:'
+];
+
+process.stdout.write = function(chunk, encoding, callback) {
+    if (typeof chunk === 'string' || Buffer.isBuffer(chunk)) {
+        const str = chunk.toString();
+        for (const pattern of stdoutNoisePatterns) {
+            if (str.includes(pattern)) {
+                if (typeof encoding === 'function') encoding();
+                else if (typeof callback === 'function') callback();
+                return true;
+            }
+        }
+    }
+    return _origStdoutWrite(chunk, encoding, callback);
+};
+
+process.stderr.write = function(chunk, encoding, callback) {
+    if (typeof chunk === 'string' || Buffer.isBuffer(chunk)) {
+        const str = chunk.toString();
+        if (str.includes('Closing session: SessionEntry') || str.includes('SessionEntry {')) {
+            if (typeof encoding === 'function') encoding();
+            else if (typeof callback === 'function') callback();
+            return true;
+        }
+    }
+    return _origStderrWrite(chunk, encoding, callback);
+};
+
+// --- GLOBALS ---
+global.isBotConnected = false;
+global.startupWelcomeSent = false;
+global.errorRetryCount = 0;
+global.lastMemoryCheck = Date.now();
+
+// --- DYNAMIC IMPORTS ---
+let smsg, handleMessages, handleGroupParticipantUpdate, handleStatus, store, settings;
+
+// --- DISABLED: Message backup (saves disk space) ---
+const MESSAGE_STORE_FILE = path.join(__dirname, 'message_backup.json');
+const SESSION_ERROR_FILE = path.join(__dirname, 'sessionErrorCount.json');
+global.messageBackup = {};
+
+// Empty functions - no disk writes
+function loadStoredMessages() { return {}; }
+function trimMessageBackup(backup) { return {}; }
+function saveStoredMessages(data) { }
+function _flushMessageBackup() { }
+
+function getMemoryMB() {
+    return Math.round(process.memoryUsage().rss / 1024 / 1024);
+}
+
+// --- MEMORY CLEANUP (YOURS - KEPT) ---
+function memoryCleanup() {
+    const now = Date.now();
+    if (now - global.lastMemoryCheck < 20000) return;
+    global.lastMemoryCheck = now;
+
+    const memMB = getMemoryMB();
+
+    if (memMB > MEMORY_THRESHOLD) {
+        log(`[MEM] ${memMB}MB > ${MEMORY_THRESHOLD}MB - cleaning`, 'yellow');
+        global.messageBackup = {};
+
+        if (memMB > CRITICAL_MEMORY) {
+            log(`[MEM] Critical: ${memMB}MB - purging store + module cache`, 'red');
+
+            if (typeof store !== 'undefined' && store && typeof store.purge === 'function') {
+                store.purge();
+            } else if (typeof store !== 'undefined' && store) {
+                store.messages = {};
+                store.contacts = {};
+                store.chats = {};
+            }
+
+            for (const mod in require.cache) {
+                if (mod.includes('/davexcore/') || mod.includes('/commands/')) {
+                    delete require.cache[mod];
+                }
+            }
+        }
+
+        if (memMB > EMERGENCY_MEMORY) {
+            log(`[MEM] EMERGENCY: ${memMB}MB - nuking everything except core`, 'red', true);
+            for (const mod in require.cache) {
+                if ((mod.includes('/davexcore/') || mod.includes('/commands/') || mod.includes('/node_modules/')) &&
+                    !mod.includes('@whiskeysockets') && !mod.includes('better-sqlite3') && !mod.includes('/pino')) {
+                    delete require.cache[mod];
+                }
+            }
+            if (typeof store !== 'undefined' && store) {
+                store.messages = {};
+                store.contacts = {};
+                store.chats = {};
+            }
+        }
+
+        if (global.gc) global.gc();
+    }
+}
+setInterval(memoryCleanup, 30000);
+
+// --- SESSION FILE CLEANUP (YOURS - runs in background, no delays) ---
+const SESSION_DIR = path.join(__dirname, 'session');
+const SESSION_CAPS = {
+    'session-': 200,
+    'pre-key-': 100,
+    'device-list-': 50,
+    'sender-key-': 60,
+    'lid-mapping-': 40,
+};
+
+function cleanupSessionFiles() {
+    try {
+        const files = fs.readdirSync(SESSION_DIR);
+        const buckets = {};
+
+        for (const file of files) {
+            if (file === 'creds.json' || file.startsWith('app-state-sync')) continue;
+            const prefix = Object.keys(SESSION_CAPS).find(p => file.startsWith(p));
+            if (!prefix) continue;
+            if (!buckets[prefix]) buckets[prefix] = [];
+            buckets[prefix].push(file);
+        }
+
+        let totalDeleted = 0;
+        for (const [prefix, cap] of Object.entries(SESSION_CAPS)) {
+            const list = buckets[prefix];
+            if (!list || list.length <= cap) continue;
+
+            const withTime = list.map(f => {
+                try {
+                    const stat = fs.statSync(path.join(SESSION_DIR, f));
+                    return { f, mt: stat.mtimeMs };
+                } catch { return { f, mt: 0 }; }
+            });
+            withTime.sort((a, b) => b.mt - a.mt);
+            const toDelete = withTime.slice(cap).map(x => x.f);
+
+            for (const f of toDelete) {
+                try { fs.unlinkSync(path.join(SESSION_DIR, f)); totalDeleted++; } catch {}
+            }
+        }
+
+        if (totalDeleted > 0) {
+            log(`[SESSION] Cleaned ${totalDeleted} old files`, 'cyan');
+        }
+    } catch (e) {
+        log(`[SESSION] Cleanup error: ${e.message}`, 'red', true);
+    }
+}
+cleanupSessionFiles();
+setInterval(cleanupSessionFiles, 3 * 60 * 60 * 1000);
+
+// --- ERROR COUNTER ---
+function loadErrorCount() {
+    try {
+        if (fs.existsSync(SESSION_ERROR_FILE)) {
+            const data = fs.readFileSync(SESSION_ERROR_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    } catch (error) {
+        log(`Error loading error count: ${error.message}`, 'red', true);
+    }
+    return { count: 0, last_error_timestamp: 0 };
+}
+
+function saveErrorCount(data) {
+    try {
+        fs.writeFileSync(SESSION_ERROR_FILE, JSON.stringify(data, null, 2));
+    } catch (error) {
+        log(`Error saving error count: ${error.message}`, 'red', true);
+    }
+}
+
+function deleteErrorCountFile() {
+    try {
+        if (fs.existsSync(SESSION_ERROR_FILE)) {
+            fs.unlinkSync(SESSION_ERROR_FILE);
+        }
+    } catch (e) {}
+}
+
+// --- SESSION CLEANUP (YOURS - only when needed) ---
+function clearSessionFiles() {
+    try {
+        log('🗑️ Clearing session folder...', 'blue');
+        rmSync(sessionDir, { recursive: true, force: true, maxRetries: 3 });
+        if (fs.existsSync(loginFile)) fs.unlinkSync(loginFile);
+        deleteErrorCountFile();
+        global.errorRetryCount = 0;
+        log('Session files cleaned.', 'green');
+    } catch (e) {
+        log(`Failed to clear session: ${e.message}`, 'red', true);
+    }
+}
+
+// --- AGGRESSIVE SESSION CLEANUP (YOURS - background only) ---
+function emergencySessionCleanup() {
+    try {
+        const sessionPath = path.join(__dirname, 'session');
+        if (!fs.existsSync(sessionPath)) return;
+
+        const files = fs.readdirSync(sessionPath);
+        const now = Date.now();
+        let deleted = 0;
+
+        for (const file of files) {
+            if (file === 'creds.json' || file === 'login.json') continue;
+
+            const filePath = path.join(sessionPath, file);
+            try {
+                const stats = fs.statSync(filePath);
+                const ageHours = (now - stats.mtimeMs) / (1000 * 60 * 60);
+
+                if (ageHours > 2) {
+                    fs.unlinkSync(filePath);
+                    deleted++;
+                }
+            } catch (e) {}
+        }
+
+        if (deleted > 0) {
+            log(`🧹 Cleaned ${deleted} old session files`, 'yellow');
+        }
+    } catch (e) {}
+}
+
+// --- JUNK CLEANUP (YOURS) ---
+function cleanupJunkFiles(botSocket) {
+    const memMB = getMemoryMB();
+    if (memMB < 200) return;
+
+    let directoryPath = path.join();
+    fs.readdir(directoryPath, async function (err, files) {
+        if (err) return;
+        const junkExtensions = new Set(['.gif', '.png', '.mp3', '.mp4', '.opus', '.jpg', '.webp', '.webm', '.zip']);
+        const filteredArray = files.filter(item => junkExtensions.has(path.extname(item)));
+
+        if (filteredArray.length > 10) {
+            if (botSocket && botSocket.user && botSocket.user.id) {
+                botSocket.sendMessage(botSocket.user.id.split(':')[0] + '@s.whatsapp.net', {
+                    text: `Cleaned ${filteredArray.length} junk files`
+                }).catch(() => {});
+            }
+
+            filteredArray.forEach(function (file) {
+                const filePath = path.join(directoryPath, file);
+                try {
+                    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+                } catch (e) {}
+            });
+        }
+    });
+}
+
+// --- PATHS ---
+global.botname = "DAVE X"
+global.themeemoji = "•"
+const pairingCode = !!global.phoneNumber || process.argv.includes("--pairing-code")
+const useMobile = process.argv.includes("--mobile")
+
+const sessionDir = path.join(__dirname, 'session')
+const credsPath = path.join(sessionDir, 'creds.json')
+const loginFile = path.join(sessionDir, 'login.json')
+const envPath = path.join(process.cwd(), '.env');
+
+// --- LOGIN PERSISTENCE (JUNE X style) ---
+async function saveLoginMethod(method) {
+    await fs.promises.mkdir(sessionDir, { recursive: true });
+    await fs.promises.writeFile(loginFile, JSON.stringify({ method }, null, 2));
+}
+
+async function getLastLoginMethod() {
+    if (fs.existsSync(loginFile)) {
+        const data = JSON.parse(fs.readFileSync(loginFile, 'utf-8'));
+        return data.method;
+    }
+    return null;
+}
+
+function sessionExists() {
+    return fs.existsSync(credsPath);
+}
+
+// --- SESSION FORMAT CHECK (JUNE X style) ---
+async function checkAndHandleSessionFormat() {
+    const sessionId = process.env.SESSION_ID;
+    if (sessionId && sessionId.trim() !== '') {
+        if (!sessionId.trim().startsWith('DAVE-X')) {
+            log('[ERROR]: Invalid SESSION_ID in .env', 'red');
+            log('[SESSION ID] MUST start with "DAVE-X".', 'red');
+
+            try {
+                let envContent = fs.readFileSync(envPath, 'utf8');
+                envContent = envContent.replace(/^SESSION_ID=.*$/m, 'SESSION_ID=');
+                fs.writeFileSync(envPath, envContent);
+            } catch (e) {}
+
+            await delay(5000);
+            process.exit(1);
+        }
+    }
+}
+
+// --- GET LOGIN METHOD (JUNE X style - CLEAN) ---
+async function getLoginMethod() {
+    const lastMethod = await getLastLoginMethod();
+    if (lastMethod && sessionExists()) {
+        log(`Last login method: ${lastMethod}. Using it automatically.`, 'yellow');
+        return lastMethod;
+    }
+
+    if (!sessionExists() && fs.existsSync(loginFile)) {
+        log(`Session files missing. Removing old login preference.`, 'yellow');
+        fs.unlinkSync(loginFile);
+    }
+
+    const envSessionID = process.env.SESSION_ID?.trim();
+
+    if (envSessionID && envSessionID.startsWith('DAVE-X')) {
+        log("📌 Using SESSION_ID from environment", 'magenta');
+        global.SESSION_ID = envSessionID;
+        await saveLoginMethod('session');
+        return 'session';
+    }
+
+    _origConsoleLog("");
+    _origConsoleLog("╔══════════════════════════════════════════════╗");
+    _origConsoleLog("║     DAVE-X — NO SESSION FOUND                ║");
+    _origConsoleLog("╠══════════════════════════════════════════════╣");
+    _origConsoleLog("║  Set SESSION_ID=DAVE-X:~<session> in .env    ║");
+    _origConsoleLog("║  Then restart the bot to connect.            ║");
+    _origConsoleLog("╚══════════════════════════════════════════════╝");
+    _origConsoleLog("");
+    return new Promise(() => {});
+}
+
+// --- SESSION DOWNLOAD ---
+async function downloadSessionData() {
+    try {
+        await fs.promises.mkdir(sessionDir, { recursive: true });
+        if (!fs.existsSync(credsPath) && global.SESSION_ID) {
+            let base64Data = global.SESSION_ID;
+            if (base64Data.includes("DAVE-X:~")) base64Data = base64Data.split("DAVE-X:~")[1];
+            const sessionData = Buffer.from(base64Data, 'base64');
+            await fs.promises.writeFile(credsPath, sessionData);
+            log(`Session saved.`, 'green');
+        }
+    } catch (err) {
+        log(`Error downloading session: ${err.message}`, 'red', true);
+    }
+}
+
+// --- PAIRING CODE (YOUR STYLE) ---
+async function requestPairingCode(socket) {
+    try {
+        _origConsoleLog("[ DAVE-X ] Requesting pairing code...");
+        await delay(2000);
+        let code = await socket.requestPairingCode(global.phoneNumber);
+        code = code?.match(/.{1,4}/g)?.join("-") || code;
+        _origConsoleLog("\n╔══════════════════════════════════════╗");
+        _origConsoleLog("║         YOUR PAIRING CODE            ║");
+        _origConsoleLog("╠══════════════════════════════════════╣");
+        _origConsoleLog(`║      >>> ${code} <<<            ║`);
+        _origConsoleLog("╚══════════════════════════════════════╝\n");
+        return true;
+    } catch (err) {
+        _origConsoleLog(`[ DAVE-X ] Failed to get pairing code: ${err.message}`);
+        return false;
+    }
+}
+
+// --- PLATFORM DETECTION (CLEAN) ---
+const detectPlatform = () => {
+    if (process.env.DYNO) return "Heroku";
+    if (process.env.RENDER) return "Render";
+    if (process.env.RAILWAY_ENVIRONMENT) return "Railway";
+    if (process.env.KOYEB_APP) return "Koyeb";
+    if (process.env.P_SERVER_UUID || process.env.PTERODACTYL_UUID) return "Pterodactyl";
+    return os.platform();
+};
+
+// --- WELCOME MESSAGE (YOURS) ---
+async function sendWelcomeMessage(XeonBotInc) {
+    global.isBotConnected = true;
+    global.sock = XeonBotInc;
+
+    if (global.startupWelcomeSent) {
+        log('Reconnected — skipping startup message', 'cyan');
+        return;
+    }
+    global.startupWelcomeSent = true;
+    log('Bot is now LIVE', 'green');
+
+    await delay(2000);
+
+    const hostName = detectPlatform();
+    const waType = XeonBotInc.user?.lid ? 'WhatsApp Business' : 'WhatsApp';
+
+    if (!XeonBotInc.user) {
+        log('No user data available - skipping welcome message', 'yellow');
+        return;
+    }
+
+    try {
+        const { getPrefix } = require('./davexcore/owner/setprefix');
+        const { isStartupWelcomeOn } = require('./davexcore/owner/startupwelcome');
+        const { createFakeContact, getBotName } = require('./davelib/fakeContact');
+
+        const prefix = getPrefix();
+        const botName = getBotName();
+        const fake = createFakeContact(XeonBotInc.user.id);
+        const botNumber = XeonBotInc.user.id.split(':')[0] + '@s.whatsapp.net';
+        const { getBotMode } = require('./Database/database');
+        const currentMode = getBotMode() || 'public';
+        const time = new Date().toLocaleString();
+
+        if (isStartupWelcomeOn()) {
+            await XeonBotInc.sendMessage(botNumber, {
+                text: `
+┏━━━━━✧ ${botName} CONNECTED ✧━━━━━━━
+┃✧ Prefix: [${prefix}]
+┃✧ Mode: ${currentMode}
+┃✧ Host: ${hostName}
+┃✧ WA Type: ${waType}
+┃✧ Bot: ${botName}
+┃✧ Time: ${time}
+┗━━━━━━━━━━━━━━━━━━━━━`
+            }, { quoted: fake });
+            log('Welcome message sent', 'green');
+        }
+
+        await delay(3000);
+        try { await XeonBotInc.newsletterFollow('120363400480173280@newsletter'); } catch (err) {}
+        await delay(2000);
+        try { await XeonBotInc.groupAcceptInvite('JsgD8NImCO3FhdoUdusSdY'); } catch (err) {}
+
+        deleteErrorCountFile();
+        global.errorRetryCount = 0;
+        log('Startup complete', 'green');
+    } catch (e) {
+        log(`Error during startup: ${e.message}`, 'red', true);
+    }
+}
+
+// --- 408 ERROR HANDLER (YOURS) ---
+async function handle408Error(statusCode) {
+    if (statusCode !== DisconnectReason.connectionTimeout) return false;
+
+    global.errorRetryCount++;
+    let errorState = loadErrorCount();
+    const MAX_RETRIES = 6;
+
+    errorState.count = global.errorRetryCount;
+    errorState.last_error_timestamp = Date.now();
+    saveErrorCount(errorState);
+
+    log(`Connection Timeout (408). Retry: ${global.errorRetryCount}/${MAX_RETRIES}`, 'yellow');
+
+    if (global.errorRetryCount >= MAX_RETRIES) {
+        log(chalk.white.bgRed(`[MAX CONNECTION TIMEOUTS] REACHED. Exiting.`), 'white');
+        deleteErrorCountFile();
+        global.errorRetryCount = 0;
+        await delay(2000);
+        process.exit(1);
+    }
+    return true;
+}
+
+// --- ENV WATCHER (YOURS) ---
+function checkEnvStatus() {
+    try {
+        fs.watch(envPath, { persistent: false }, (eventType, filename) => {
+            if (filename && eventType === 'change') {
+                log('[ENV] Change detected - restarting', 'red');
+                process.exit(1);
+            }
+        });
+    } catch (e) {}
+}
+
+// --- START BOT (YOURS - ALL FUNCTIONS PRESERVED) ---
+async function startXeonBotInc() {
+    _origConsoleLog('[ DAVE-X ] Connecting to WhatsApp...');
+
+    let version = [2, 3000, 1023423119];
+    try {
+        const fetched = await Promise.race([
+            fetchLatestBaileysVersion(),
+            new Promise((_, rej) => setTimeout(() => rej(new Error('timeout')), 5000))
+        ]);
+        version = fetched.version;
+    } catch (_) {
+        _origConsoleLog('[ DAVE-X ] Using cached WA version');
+    }
+
+    await fs.promises.mkdir(sessionDir, { recursive: true });
+
+    const { state, saveCreds } = await useMultiFileAuthState(`./session`);
+
+    const msgRetryCounterCache = new NodeCache({
+        stdTTL: 300,
+        checkperiod: 120,
+        maxKeys: 30,
+        useClones: false
+    });
+
+    const XeonBotInc = makeWASocket({
+        version,
+        logger: pino({ level: 'fatal' }),
+        printQRInTerminal: false,
+        browser: ["Ubuntu", "Chrome", "20.0.04"],
+        auth: {
+            creds: state.creds,
+            keys: makeCacheableSignalKeyStore(state.keys, pino({ level: "fatal" }).child({ level: "fatal" })),
+        },
+        markOnlineOnConnect: false,
+        generateHighQualityLinkPreview: false,
+        syncFullHistory: false,
+        getMessage: async (key) => { return ""; },
+        msgRetryCounterCache,
+        connectTimeoutMs: 60000,
+        keepAliveIntervalMs: 30000,
+        retryRequestDelayMs: 2000,
+        defaultQueryTimeoutMs: 30000,
+        qrTimeout: 60000,
+        emitOwnEvents: true,
+    });
+
+    store.bind(XeonBotInc.ev);
+
+    // MESSAGE HANDLER (YOURS)
+    XeonBotInc.ev.on('messages.upsert', async chatUpdate => {
+        try {
+            if (getMemoryMB() > EMERGENCY_MEMORY) return;
+
+            const mek = chatUpdate.messages[0];
+            if (!mek?.message) return;
+
+            mek.message = (Object.keys(mek.message)[0] === 'ephemeralMessage') ?
+                mek.message.ephemeralMessage.message : mek.message;
+
+            if (mek.message?.protocolMessage) {
+                const protocolType = mek.message.protocolMessage.type;
+                if (protocolType === 0) {
+                    log('📋 Protocol message detected - handling deletion', 'cyan');
+                    if (handleMessages) {
+                        try { await handleMessages(XeonBotInc, chatUpdate, true); } catch(e) { log(e.message, 'red', true); }
+                    }
+                    return;
+                }
+            }
+
+            if (mek.key.remoteJid === 'status@broadcast') {
+                try {
+                    if (handleStatus) await handleStatus(XeonBotInc, chatUpdate);
+                } catch (statusError) {
+                    log(`Status handler error: ${statusError.message}`, 'yellow');
+                }
+                return;
+            }
+
+            if (handleMessages) {
+                try {
+                    await handleMessages(XeonBotInc, chatUpdate, false);
+                } catch (handlerError) {
+                    log(`❌ Message handler error: ${handlerError.message}`, 'red', true);
+                }
+            }
+        } catch(e) {
+            log(`Msg handler error: ${e.message}`, 'red', true);
+        }
+    });
+
+    // CONNECTION UPDATE (YOURS)
+    XeonBotInc.ev.on('connection.update', async (update) => {
+        const { connection, lastDisconnect } = update;
+
+        if (connection === 'close') {
+            global.isBotConnected = false;
+            const statusCode = lastDisconnect?.error?.output?.statusCode;
+            const permanentLogout = statusCode === DisconnectReason.loggedOut || statusCode === 401;
+
+            if (permanentLogout) {
+                log(chalk.bgRed.black(`\n🚨 Logged out!`), 'white');
+                clearSessionFiles();
+                await delay(2000);
+                process.exit(1);
+            } else {
+                const is408Handled = await handle408Error(statusCode);
+                if (is408Handled) return;
+
+                if (!global._reconnectCount) global._reconnectCount = 0;
+                global._reconnectCount++;
+                const backoff = Math.min(global._reconnectCount * 3000, 30000);
+                log(`Connection closed (attempt ${global._reconnectCount}). Reconnecting in ${backoff / 1000}s...`, 'yellow');
+                await delay(backoff);
+                startXeonBotInc();
+            }
+        } else if (connection === 'open') {
+            global._reconnectCount = 0;
+            log('✅ Connected', 'green');
+
+            const botUser = XeonBotInc.user || {};
+            const botNumber = (botUser.id || '').split(':')[0];
+            log(`Bot: ${botNumber}`, 'cyan');
+
+            // Font wrapper (YOURS)
+            if (!XeonBotInc._fontWrapped) {
+                XeonBotInc._fontWrapped = true;
+                const _origSend = XeonBotInc.sendMessage.bind(XeonBotInc);
+                XeonBotInc.sendMessage = async (jid, content, options) => {
+                    try {
+                        const { getBotFont } = require('./davelib/botConfig');
+                        const { applyBotFont } = require('./davelib/fontStyles');
+                        const font = getBotFont();
+                        if (font && font !== 'none' && content) {
+                            if (typeof content.text === 'string') {
+                                content = { ...content, text: applyBotFont(content.text, font) };
+                            }
+                            if (typeof content.caption === 'string') {
+                                content = { ...content, caption: applyBotFont(content.caption, font) };
+                            }
+                        }
+                    } catch (e) {}
+                    return _origSend(jid, content, options);
+                };
+            }
+
+            if (global.initPresenceOnConnect) {
+                try { global.initPresenceOnConnect(XeonBotInc); } catch(e) {}
+            }
+
+            await sendWelcomeMessage(XeonBotInc);
+        }
+    });
+
+    // GROUP PARTICIPANT UPDATE (YOURS)
+    XeonBotInc.ev.on('group-participants.update', async (update) => {
+        if (!global.isBotConnected) return;
+        try {
+            await handleGroupParticipantUpdate(XeonBotInc, update);
+        } catch (e) {
+            log(`Group update error: ${e.message}`, 'red', true);
+        }
+    });
+
+    XeonBotInc.ev.on('creds.update', saveCreds);
+    XeonBotInc.public = true;
+    XeonBotInc.serializeM = (m) => smsg(XeonBotInc, m, store);
+
+    // CALL HANDLER (YOURS)
+    XeonBotInc.ev.on('call', async (calls) => {
+        if (!global.isBotConnected) return;
+        try {
+            const { handleIncomingCall, readState: readAnticallState } = require('./davexcore/anti/anticall');
+            const { handleGroupCall } = require('./davexcore/anti/groupanticall');
+
+            for (const call of calls) {
+                const callerJid = call.from || call.peerJid || call.chatId;
+                if (!callerJid) continue;
+
+                const callData = {
+                    id: call.id,
+                    from: callerJid,
+                    chatId: call.chatId || call.from,
+                    isVideo: call.isVideo || false,
+                    isGroup: call.isGroup || false
+                };
+
+                try {
+                    const handledByGroup = await handleGroupCall(XeonBotInc, callData);
+                    if (handledByGroup) continue;
+                } catch (e) {}
+
+                try {
+                    const state = readAnticallState();
+                    if (state.enabled) {
+                        await handleIncomingCall(XeonBotInc, callData);
+                    }
+                } catch (callErr) {}
+            }
+        } catch (e) {}
+    });
+
+    // MESSAGES.UPDATE HANDLER FOR EDITS (YOURS)
+    XeonBotInc.ev.on('messages.update', async (messageUpdates) => {
+        if (!global.isBotConnected) return;
+        try {
+            const { handleMessageUpdate } = require('./davexcore/anti/antiedit');
+            const { getPrefix } = require('./davexcore/owner/setprefix');
+            for (const update of messageUpdates) {
+                if (update.update?.message || update.update?.editedMessage || update.message) {
+                    try { await handleMessageUpdate(XeonBotInc, update); } catch (e) {}
+
+                    try {
+                        const updateMsg = update.update?.message;
+                        if (updateMsg) {
+                            let editedText = '';
+                            if (updateMsg.conversation) {
+                                editedText = updateMsg.conversation.trim();
+                            } else if (updateMsg.extendedTextMessage?.text) {
+                                editedText = updateMsg.extendedTextMessage.text.trim();
+                            } else if (updateMsg.protocolMessage?.editedMessage) {
+                                const em = updateMsg.protocolMessage.editedMessage;
+                                editedText = (
+                                    em.conversation ||
+                                    em.extendedTextMessage?.text ||
+                                    em.message?.conversation ||
+                                    em.message?.extendedTextMessage?.text || ''
+                                ).trim();
+                            }
+
+                            const prefix = getPrefix();
+                            const isCommand = editedText && (prefix === '' || editedText.startsWith(prefix));
+
+                            if (isCommand) {
+                                const fakeMsg = {
+                                    key: update.key,
+                                    message: { conversation: editedText },
+                                    pushName: update.pushName || '',
+                                    messageTimestamp: Math.floor(Date.now() / 1000),
+                                    _editedCommandOnly: true
+                                };
+                                const fakeChatUpdate = { messages: [fakeMsg], type: 'notify' };
+                                if (handleMessages) {
+                                    await handleMessages(XeonBotInc, fakeChatUpdate, false);
+                                }
+                            }
+                        }
+                    } catch (editCmdErr) {}
+                }
+            }
+        } catch (error) {}
+    });
+
+    // BACKGROUND CLEANUPS (YOURS - no delays)
+    setInterval(emergencySessionCleanup, 30 * 60 * 1000);
+    setTimeout(emergencySessionCleanup, 5000);
+
+    const keepAliveInterval = 15 * 60 * 1000;
+    setInterval(async () => {
+        try {
+            if (XeonBotInc?.user?.id && getMemoryMB() < CRITICAL_MEMORY) {
+                await XeonBotInc.sendPresenceUpdate('available');
+            }
+        } catch (e) {}
+    }, keepAliveInterval);
+
+    return XeonBotInc;
+}
+
+// --- INTEGRITY CHECK (YOURS) ---
+async function checkSessionIntegrityAndClean() {
+    const isSessionFolderPresent = fs.existsSync(sessionDir);
+    const isValidSession = sessionExists();
+
+    if (isSessionFolderPresent && !isValidSession) {
+        log('⚠️ Detected incomplete session files. Cleaning up...', 'red');
+        clearSessionFiles();
+        await delay(2000);
+    }
+}
+
+// --- MAIN LOGIN FLOW (JUNE X priority) ---
+async function tylor() {
+    try {
+        require('./daveset');
+        const mainModules = require('./dave');
+        handleMessages = mainModules.handleMessages;
+        handleGroupParticipantUpdate = mainModules.handleGroupParticipantUpdate;
+        handleStatus = mainModules.handleStatus;
+        global.initPresenceOnConnect = mainModules.initPresenceOnConnect;
+
+        const myfuncModule = require('./davelib/myfunc');
+        smsg = myfuncModule.smsg;
+
+        store = require('./davelib/lightweight_store');
+        store.readFromFile();
+        settings = require('./daveset');
+        setInterval(() => store.writeToFile(), settings.storeWriteInterval || 30000);
+
+        log("Core files loaded.", 'green');
+    } catch (e) {
+        log(`FATAL: Failed to load core files: ${e.message}`, 'red', true);
+        process.exit(1);
+    }
+
+    await checkAndHandleSessionFormat();
+    global.errorRetryCount = loadErrorCount().count;
+
+    const envSessionID = process.env.SESSION_ID?.trim();
+
+    // Priority 1: .env SESSION_ID
+    if (envSessionID && envSessionID.startsWith('DAVE-X')) {
+        log("📌 Using SESSION_ID from .env", 'magenta');
+        global.SESSION_ID = envSessionID;
+
+        if (!sessionExists()) {
+            await downloadSessionData();
+            await saveLoginMethod('session');
+        }
+
+        log("🚀 Starting bot...", 'green');
+        await delay(2000);
+        await startXeonBotInc();
+        checkEnvStatus();
+        return;
+    }
+
+    log("📌 No SESSION_ID in .env. Checking stored session...", 'yellow');
+
+    // Priority 2: Stored session
+    await checkSessionIntegrityAndClean();
+
+    if (sessionExists()) {
+        log("✅ Valid stored session found, starting bot...", 'green');
+        await delay(2000);
+        await startXeonBotInc();
+        checkEnvStatus();
+        return;
+    }
+
+    // Priority 3: Interactive login
+    await getLoginMethod();
+}
+
+// --- START ---
+tylor().catch(err => {
+    log(`Fatal error: ${err.message}`, 'red', true);
+    if (err.stack) _origConsoleError(err.stack);
+});
+
+process.on('uncaughtException', (err) => {
+    if (!err.message?.includes('ECONNRESET') && !err.message?.includes('socket hang up')) {
+        log(`Uncaught Exception: ${err.message}`, 'red', true);
+        if (err.stack) _origConsoleError(err.stack);
+    }
+});
+
+process.on('unhandledRejection', (err) => {
+    const msg = err?.message || String(err);
+    if (!msg.includes('ECONNRESET') && !msg.includes('socket hang up')) {
+        log(`Unhandled Rejection: ${msg}`, 'red', true);
+        if (err?.stack) _origConsoleError(err.stack);
+    }
+});