jsdecryptor 4.0.3

package/Database/migration.js

@@ -0,0 +1,327 @@
+const fs = require('fs');
+const path = require('path');
+const db = require('./database');
+const { setGroupConfig, setOwnerConfig, clearAllCache } = require('./settingsStore');
+
+const DATA_DIR = path.join(__dirname, '../data');
+const MIGRATION_STATUS_FILE = path.join(__dirname, '.migration_status.json');
+
+function getMigrationStatus() {
+    try {
+        if (fs.existsSync(MIGRATION_STATUS_FILE)) {
+            return JSON.parse(fs.readFileSync(MIGRATION_STATUS_FILE, 'utf8'));
+        }
+    } catch {}
+    return {};
+}
+
+function saveMigrationStatus(status) {
+    try {
+        fs.writeFileSync(MIGRATION_STATUS_FILE, JSON.stringify(status, null, 2));
+    } catch {}
+}
+
+function isFileMigrated(filename) {
+    const status = getMigrationStatus();
+    return status[filename] === true;
+}
+
+function markFileMigrated(filename) {
+    const status = getMigrationStatus();
+    status[filename] = true;
+    saveMigrationStatus(status);
+}
+
+function migrateFromJson() {
+    console.log('[ DAVE-X ] Checking for pending JSON migrations...');
+    let hasPendingMigrations = false;
+    let migrated = 0;
+
+    try {
+        const userGroupPath = path.join(DATA_DIR, 'userGroupData.json');
+        if (fs.existsSync(userGroupPath) && !isFileMigrated('userGroupData.json')) {
+            hasPendingMigrations = true;
+            const data = JSON.parse(fs.readFileSync(userGroupPath, 'utf8'));
+            
+            const features = [
+                'antibadword', 'antilink', 'antitag', 'antimention', 'antigroupmention',
+                'antidemote', 'antisticker', 'antiimage', 'antiaudio', 'antidocument',
+                'antifiles', 'antipromote', 'antivideo', 'antibug', 'antichart',
+                'welcome', 'goodbye', 'chatbot'
+            ];
+            
+            for (const feature of features) {
+                if (data[feature]) {
+                    for (const [groupId, config] of Object.entries(data[feature])) {
+                        setGroupConfig(groupId, feature, config);
+                        migrated++;
+                    }
+                }
+            }
+            
+            if (data.warnings) {
+                for (const [groupId, users] of Object.entries(data.warnings)) {
+                    for (const [userId, count] of Object.entries(users)) {
+                        const database = db.getDb();
+                        const stmt = database.prepare(`
+                            INSERT OR REPLACE INTO warnings (group_jid, user_jid, count, updated_at)
+                            VALUES (?, ?, ?, strftime('%s', 'now'))
+                        `);
+                        stmt.run(groupId, userId, count);
+                        migrated++;
+                    }
+                }
+            }
+            
+            if (Array.isArray(data.sudo)) {
+                for (const userId of data.sudo) {
+                    db.addSudoUser(userId);
+                    migrated++;
+                }
+            }
+            
+            markFileMigrated('userGroupData.json');
+            console.log(`[ DAVE-X ] Migrated ${migrated} settings from userGroupData.json`);
+        }
+
+        const antideleteConfig = path.join(DATA_DIR, 'antidelete.json');
+        if (fs.existsSync(antideleteConfig) && !isFileMigrated('antidelete.json')) {
+            hasPendingMigrations = true;
+            try {
+                const config = JSON.parse(fs.readFileSync(antideleteConfig, 'utf8'));
+                setOwnerConfig('antidelete', config);
+                markFileMigrated('antidelete.json');
+                console.log('[ DAVE-X ] Migrated antidelete config');
+            } catch {}
+        }
+
+        const anticallConfig = path.join(DATA_DIR, 'anticall.json');
+        if (fs.existsSync(anticallConfig) && !isFileMigrated('anticall.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(anticallConfig, 'utf8'));
+                setOwnerConfig('anticall', { enabled: config.enabled || false, mode: 'block', message: 'Calls not allowed!' });
+                markFileMigrated('anticall.json');
+                console.log('[ DAVE-X ] Migrated anticall config');
+            } catch {}
+        }
+
+        const antieditConfig = path.join(DATA_DIR, 'antiedit.json');
+        if (fs.existsSync(antieditConfig) && !isFileMigrated('antiedit.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(antieditConfig, 'utf8'));
+                setOwnerConfig('antiedit', config);
+                markFileMigrated('antiedit.json');
+                console.log('[ DAVE-X ] Migrated antiedit config');
+            } catch {}
+        }
+
+        const autoreadConfig = path.join(DATA_DIR, 'autoread.json');
+        if (fs.existsSync(autoreadConfig) && !isFileMigrated('autoread.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(autoreadConfig, 'utf8'));
+                setOwnerConfig('autoread', config.enabled || false);
+                markFileMigrated('autoread.json');
+                console.log('[ DAVE-X ] Migrated autoread config');
+            } catch {}
+        }
+
+        const autotypingConfig = path.join(DATA_DIR, 'autotyping.json');
+        if (fs.existsSync(autotypingConfig) && !isFileMigrated('autotyping.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(autotypingConfig, 'utf8'));
+                setOwnerConfig('autotyping', config.enabled || false);
+                markFileMigrated('autotyping.json');
+                console.log('[ DAVE-X ] Migrated autotyping config');
+            } catch {}
+        }
+
+        const autorecordingConfig = path.join(DATA_DIR, 'autorecording.json');
+        if (fs.existsSync(autorecordingConfig) && !isFileMigrated('autorecording.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(autorecordingConfig, 'utf8'));
+                setOwnerConfig('autorecording', config.enabled || false);
+                markFileMigrated('autorecording.json');
+                console.log('[ DAVE-X ] Migrated autorecording config');
+            } catch {}
+        }
+
+        const ownerConfig = path.join(DATA_DIR, 'owner.json');
+        if (fs.existsSync(ownerConfig) && !isFileMigrated('owner.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(ownerConfig, 'utf8'));
+                if (Array.isArray(config)) {
+                    for (const owner of config) {
+                        if (typeof owner === 'string') {
+                            db.addSudoUser(owner.includes('@') ? owner : owner + '@s.whatsapp.net');
+                        }
+                    }
+                }
+                markFileMigrated('owner.json');
+                console.log('[ DAVE-X ] Migrated owner config');
+            } catch {}
+        }
+
+        const bannedConfig = path.join(DATA_DIR, 'banned.json');
+        if (fs.existsSync(bannedConfig) && !isFileMigrated('banned.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(bannedConfig, 'utf8'));
+                if (Array.isArray(config)) {
+                    for (const user of config) {
+                        if (typeof user === 'string') {
+                            db.addBannedUser(user);
+                        }
+                    }
+                } else if (typeof config === 'object') {
+                    for (const [userId, reason] of Object.entries(config)) {
+                        db.addBannedUser(userId, reason || '');
+                    }
+                }
+                markFileMigrated('banned.json');
+                console.log('[ DAVE-X ] Migrated banned users');
+            } catch {}
+        }
+
+        const premiumConfig = path.join(DATA_DIR, 'premium.json');
+        if (fs.existsSync(premiumConfig) && !isFileMigrated('premium.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(premiumConfig, 'utf8'));
+                if (Array.isArray(config)) {
+                    for (const user of config) {
+                        if (typeof user === 'string') {
+                            const database = db.getDb();
+                            const stmt = database.prepare(`
+                                INSERT OR IGNORE INTO premium_users (user_jid, added_at)
+                                VALUES (?, strftime('%s', 'now'))
+                            `);
+                            stmt.run(user);
+                        }
+                    }
+                }
+                markFileMigrated('premium.json');
+                console.log('[ DAVE-X ] Migrated premium users');
+            } catch {}
+        }
+
+        const warningsConfig = path.join(DATA_DIR, 'warnings.json');
+        if (fs.existsSync(warningsConfig) && !isFileMigrated('warnings.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(warningsConfig, 'utf8'));
+                if (typeof config === 'object' && config !== null) {
+                    for (const [groupId, users] of Object.entries(config)) {
+                        if (typeof users === 'object' && users !== null) {
+                            for (const [userId, count] of Object.entries(users)) {
+                                const database = db.getDb();
+                                const stmt = database.prepare(`
+                                    INSERT OR REPLACE INTO warnings (group_jid, user_jid, count, updated_at)
+                                    VALUES (?, ?, ?, strftime('%s', 'now'))
+                                `);
+                                stmt.run(groupId, userId, typeof count === 'number' ? count : 0);
+                            }
+                        }
+                    }
+                }
+                markFileMigrated('warnings.json');
+                console.log('[ DAVE-X ] Migrated warnings');
+            } catch {}
+        }
+
+        const pmblockerConfig = path.join(DATA_DIR, 'pmblocker.json');
+        if (fs.existsSync(pmblockerConfig) && !isFileMigrated('pmblocker.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(pmblockerConfig, 'utf8'));
+                setOwnerConfig('pmblocker', { enabled: config.enabled || false, message: config.message || '' });
+                markFileMigrated('pmblocker.json');
+                console.log('[ DAVE-X ] Migrated pmblocker config');
+            } catch {}
+        }
+
+        const autoStatusConfig = path.join(DATA_DIR, 'autoStatus.json');
+        if (fs.existsSync(autoStatusConfig) && !isFileMigrated('autoStatus.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(autoStatusConfig, 'utf8'));
+                setOwnerConfig('autostatus', config);
+                setOwnerConfig('autoviewstatus', config.enabled || config.autoView || false);
+                markFileMigrated('autoStatus.json');
+                console.log('[ DAVE-X ] Migrated autoStatus config');
+            } catch {}
+        }
+
+        const prefixConfig = path.join(DATA_DIR, 'prefix.json');
+        if (fs.existsSync(prefixConfig) && !isFileMigrated('prefix.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(prefixConfig, 'utf8'));
+                setOwnerConfig('prefix', config.prefix || '.');
+                markFileMigrated('prefix.json');
+                console.log('[ DAVE-X ] Migrated prefix config');
+            } catch {}
+        }
+
+        const botconfigPath = path.join(DATA_DIR, 'botconfig.json');
+        if (fs.existsSync(botconfigPath) && !isFileMigrated('botconfig.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(botconfigPath, 'utf8'));
+                setOwnerConfig('botconfig', config);
+                markFileMigrated('botconfig.json');
+                console.log('[ DAVE-X ] Migrated botconfig');
+            } catch {}
+        }
+
+        const menuSettingsPath = path.join(DATA_DIR, 'menuSettings.json');
+        if (fs.existsSync(menuSettingsPath) && !isFileMigrated('menuSettings.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(menuSettingsPath, 'utf8'));
+                setOwnerConfig('menuSettings', config);
+                markFileMigrated('menuSettings.json');
+                console.log('[ DAVE-X ] Migrated menuSettings');
+            } catch {}
+        }
+
+        const statusAntideleteConfig = path.join(DATA_DIR, 'status_antidelete.json');
+        if (fs.existsSync(statusAntideleteConfig) && !isFileMigrated('status_antidelete.json')) {
+            try {
+                const config = JSON.parse(fs.readFileSync(statusAntideleteConfig, 'utf8'));
+                setOwnerConfig('status_antidelete', config);
+                markFileMigrated('status_antidelete.json');
+                console.log('[ DAVE-X ] Migrated status_antidelete config');
+            } catch {}
+        }
+
+        if (hasPendingMigrations) {
+            clearAllCache();
+            console.log('[ DAVE-X ] Migration completed successfully!');
+        } else {
+            console.log('[ DAVE-X ] No pending migrations.');
+        }
+        
+    } catch (error) {
+        console.error('[ DAVE-X ] Migration error:', error.message);
+        console.error('[ DAVE-X ] Migration incomplete - will retry on next startup');
+    }
+}
+
+function cleanupLegacyFiles() {
+    const filesToKeep = ['botConfig.js', 'fakeContact.js', 'greetings.js', 'messageHandler.js'];
+    
+    try {
+        if (!fs.existsSync(DATA_DIR)) return;
+        
+        const files = fs.readdirSync(DATA_DIR);
+        let cleaned = 0;
+        
+        for (const file of files) {
+            if (file.endsWith('.json') && !filesToKeep.includes(file)) {
+                console.log(`[ DAVE-X ] Note: Legacy file ${file} can be removed after verifying migration`);
+                cleaned++;
+            }
+        }
+        
+        if (cleaned > 0) {
+            console.log(`[ DAVE-X ] ${cleaned} legacy JSON files identified for cleanup`);
+        }
+    } catch {}
+}
+
+module.exports = {
+    migrateFromJson,
+    cleanupLegacyFiles
+};

package/Database/pgSync.js

@@ -0,0 +1,229 @@
+const { Pool } = require('pg');
+
+let pool = null;
+let pgAvailable = false;
+
+const PG_TABLES_SQL = `
+    CREATE TABLE IF NOT EXISTS owner_settings (
+        setting_key TEXT PRIMARY KEY,
+        setting_value TEXT NOT NULL,
+        updated_at BIGINT DEFAULT (EXTRACT(EPOCH FROM NOW()))
+    );
+    CREATE TABLE IF NOT EXISTS group_settings (
+        group_jid TEXT NOT NULL,
+        setting_key TEXT NOT NULL,
+        setting_value TEXT NOT NULL,
+        updated_at BIGINT DEFAULT (EXTRACT(EPOCH FROM NOW())),
+        PRIMARY KEY (group_jid, setting_key)
+    );
+    CREATE TABLE IF NOT EXISTS warnings (
+        group_jid TEXT NOT NULL,
+        user_jid TEXT NOT NULL,
+        count INTEGER DEFAULT 0,
+        updated_at BIGINT DEFAULT (EXTRACT(EPOCH FROM NOW())),
+        PRIMARY KEY (group_jid, user_jid)
+    );
+    CREATE TABLE IF NOT EXISTS banned_users (
+        user_jid TEXT PRIMARY KEY,
+        reason TEXT,
+        banned_at BIGINT DEFAULT (EXTRACT(EPOCH FROM NOW()))
+    );
+    CREATE TABLE IF NOT EXISTS sudo_users (
+        user_jid TEXT PRIMARY KEY,
+        added_at BIGINT DEFAULT (EXTRACT(EPOCH FROM NOW()))
+    );
+    CREATE TABLE IF NOT EXISTS premium_users (
+        user_jid TEXT PRIMARY KEY,
+        expires_at BIGINT,
+        added_at BIGINT DEFAULT (EXTRACT(EPOCH FROM NOW()))
+    );
+    CREATE TABLE IF NOT EXISTS message_counts (
+        group_jid TEXT NOT NULL,
+        user_jid TEXT NOT NULL,
+        count INTEGER DEFAULT 0,
+        PRIMARY KEY (group_jid, user_jid)
+    );
+`;
+
+function getPgUrl() {
+    return process.env.DATABASE_URL || process.env.HEROKU_DATABASE_URL || null;
+}
+
+async function initPg() {
+    const url = getPgUrl();
+    if (!url) return false;
+
+    try {
+        pool = new Pool({
+            connectionString: url,
+            ssl: { rejectUnauthorized: false },
+            max: 3,
+            idleTimeoutMillis: 30000,
+            connectionTimeoutMillis: 10000
+        });
+
+        await pool.query('SELECT 1');
+        await pool.query(PG_TABLES_SQL);
+        pgAvailable = true;
+        console.log('[ DAVE-X ][PG] PostgreSQL connected');
+        return true;
+    } catch (err) {
+        console.error('[ DAVE-X ][PG] PostgreSQL init failed:', err.message);
+        pgAvailable = false;
+        return false;
+    }
+}
+
+async function loadFromPg(sqliteDb) {
+    if (!pgAvailable || !pool) return 0;
+
+    let loaded = 0;
+    try {
+        const ownerRows = await pool.query('SELECT setting_key, setting_value FROM owner_settings');
+        for (const row of ownerRows.rows) {
+            sqliteDb.prepare('INSERT OR REPLACE INTO owner_settings (setting_key, setting_value, updated_at) VALUES (?, ?, strftime(\'%s\', \'now\'))').run(row.setting_key, row.setting_value);
+            loaded++;
+        }
+
+        const groupRows = await pool.query('SELECT group_jid, setting_key, setting_value FROM group_settings');
+        for (const row of groupRows.rows) {
+            sqliteDb.prepare('INSERT OR REPLACE INTO group_settings (group_jid, setting_key, setting_value, updated_at) VALUES (?, ?, ?, strftime(\'%s\', \'now\'))').run(row.group_jid, row.setting_key, row.setting_value);
+            loaded++;
+        }
+
+        const warnRows = await pool.query('SELECT group_jid, user_jid, count FROM warnings');
+        for (const row of warnRows.rows) {
+            sqliteDb.prepare('INSERT OR REPLACE INTO warnings (group_jid, user_jid, count, updated_at) VALUES (?, ?, ?, strftime(\'%s\', \'now\'))').run(row.group_jid, row.user_jid, row.count);
+            loaded++;
+        }
+
+        const banRows = await pool.query('SELECT user_jid, reason FROM banned_users');
+        for (const row of banRows.rows) {
+            sqliteDb.prepare('INSERT OR REPLACE INTO banned_users (user_jid, reason, banned_at) VALUES (?, ?, strftime(\'%s\', \'now\'))').run(row.user_jid, row.reason);
+            loaded++;
+        }
+
+        const sudoRows = await pool.query('SELECT user_jid FROM sudo_users');
+        for (const row of sudoRows.rows) {
+            sqliteDb.prepare('INSERT OR IGNORE INTO sudo_users (user_jid, added_at) VALUES (?, strftime(\'%s\', \'now\'))').run(row.user_jid);
+            loaded++;
+        }
+
+        const premRows = await pool.query('SELECT user_jid, expires_at FROM premium_users');
+        for (const row of premRows.rows) {
+            sqliteDb.prepare('INSERT OR REPLACE INTO premium_users (user_jid, expires_at, added_at) VALUES (?, ?, strftime(\'%s\', \'now\'))').run(row.user_jid, row.expires_at);
+            loaded++;
+        }
+
+        const countRows = await pool.query('SELECT group_jid, user_jid, count FROM message_counts');
+        for (const row of countRows.rows) {
+            sqliteDb.prepare('INSERT OR REPLACE INTO message_counts (group_jid, user_jid, count) VALUES (?, ?, ?)').run(row.group_jid, row.user_jid, row.count);
+            loaded++;
+        }
+
+        if (loaded > 0) {
+            console.log(`[ DAVE-X ][PG] Loaded ${loaded} records from PostgreSQL`);
+        }
+    } catch (err) {
+        console.error('[ DAVE-X ][PG] Load from PG failed:', err.message);
+    }
+    return loaded;
+}
+
+function pgWrite(query, params = []) {
+    if (!pgAvailable || !pool) return;
+    pool.query(query, params).catch(err => {
+        console.error('[ DAVE-X ][PG] Write error:', err.message);
+    });
+}
+
+function pgSetOwnerSetting(key, value) {
+    pgWrite(
+        'INSERT INTO owner_settings (setting_key, setting_value, updated_at) VALUES ($1, $2, EXTRACT(EPOCH FROM NOW())) ON CONFLICT (setting_key) DO UPDATE SET setting_value = $2, updated_at = EXTRACT(EPOCH FROM NOW())',
+        [key, JSON.stringify(value)]
+    );
+}
+
+function pgSetGroupSetting(groupJid, key, value) {
+    pgWrite(
+        'INSERT INTO group_settings (group_jid, setting_key, setting_value, updated_at) VALUES ($1, $2, $3, EXTRACT(EPOCH FROM NOW())) ON CONFLICT (group_jid, setting_key) DO UPDATE SET setting_value = $3, updated_at = EXTRACT(EPOCH FROM NOW())',
+        [groupJid, key, JSON.stringify(value)]
+    );
+}
+
+function pgDeleteGroupSetting(groupJid, key) {
+    pgWrite('DELETE FROM group_settings WHERE group_jid = $1 AND setting_key = $2', [groupJid, key]);
+}
+
+function pgSetWarning(groupJid, userJid, count) {
+    if (count <= 0) {
+        pgWrite('DELETE FROM warnings WHERE group_jid = $1 AND user_jid = $2', [groupJid, userJid]);
+    } else {
+        pgWrite(
+            'INSERT INTO warnings (group_jid, user_jid, count, updated_at) VALUES ($1, $2, $3, EXTRACT(EPOCH FROM NOW())) ON CONFLICT (group_jid, user_jid) DO UPDATE SET count = $3, updated_at = EXTRACT(EPOCH FROM NOW())',
+            [groupJid, userJid, count]
+        );
+    }
+}
+
+function pgResetWarning(groupJid, userJid) {
+    pgWrite('DELETE FROM warnings WHERE group_jid = $1 AND user_jid = $2', [groupJid, userJid]);
+}
+
+function pgAddBannedUser(userJid, reason) {
+    pgWrite(
+        'INSERT INTO banned_users (user_jid, reason, banned_at) VALUES ($1, $2, EXTRACT(EPOCH FROM NOW())) ON CONFLICT (user_jid) DO UPDATE SET reason = $2, banned_at = EXTRACT(EPOCH FROM NOW())',
+        [userJid, reason]
+    );
+}
+
+function pgRemoveBannedUser(userJid) {
+    pgWrite('DELETE FROM banned_users WHERE user_jid = $1', [userJid]);
+}
+
+function pgAddSudoUser(userJid) {
+    pgWrite(
+        'INSERT INTO sudo_users (user_jid, added_at) VALUES ($1, EXTRACT(EPOCH FROM NOW())) ON CONFLICT (user_jid) DO NOTHING',
+        [userJid]
+    );
+}
+
+function pgRemoveSudoUser(userJid) {
+    pgWrite('DELETE FROM sudo_users WHERE user_jid = $1', [userJid]);
+}
+
+function pgIncrementMsgCount(groupJid, userJid) {
+    pgWrite(
+        'INSERT INTO message_counts (group_jid, user_jid, count) VALUES ($1, $2, 1) ON CONFLICT (group_jid, user_jid) DO UPDATE SET count = message_counts.count + 1',
+        [groupJid, userJid]
+    );
+}
+
+function pgResetGroupMsgCounts(groupJid) {
+    pgWrite('DELETE FROM message_counts WHERE group_jid = $1', [groupJid]);
+}
+
+async function closePg() {
+    if (pool) {
+        try { await pool.end(); } catch {}
+        pool = null;
+        pgAvailable = false;
+    }
+}
+
+module.exports = {
+    initPg,
+    loadFromPg,
+    closePg,
+    pgSetOwnerSetting,
+    pgSetGroupSetting,
+    pgDeleteGroupSetting,
+    pgSetWarning,
+    pgResetWarning,
+    pgAddBannedUser,
+    pgRemoveBannedUser,
+    pgAddSudoUser,
+    pgRemoveSudoUser,
+    pgIncrementMsgCount,
+    pgResetGroupMsgCounts
+};