shadowx-fca 8.0.0

package/logger.js

@@ -0,0 +1,500 @@
+"use strict";
+
+const fs = require('fs');
+const path = require('path');
+
+const C = {
+    reset:    '\x1b[0m',
+    bold:     '\x1b[1m',
+    dim:      '\x1b[2m',
+    italic:   '\x1b[3m',
+    underline:'\x1b[4m',
+    blink:    '\x1b[5m',
+    reverse:  '\x1b[7m',
+    hidden:   '\x1b[8m',
+    strike:   '\x1b[9m',
+    black:    '\x1b[30m',
+    red:      '\x1b[31m',
+    green:    '\x1b[32m',
+    yellow:   '\x1b[33m',
+    blue:     '\x1b[34m',
+    magenta:  '\x1b[35m',
+    cyan:     '\x1b[36m',
+    white:    '\x1b[37m',
+    bBlack:   '\x1b[90m',
+    bRed:     '\x1b[91m',
+    bGreen:   '\x1b[92m',
+    bYellow:  '\x1b[93m',
+    bBlue:    '\x1b[94m',
+    bMagenta: '\x1b[95m',
+    bCyan:    '\x1b[96m',
+    bWhite:   '\x1b[97m',
+    bgRed:    '\x1b[41m',
+    bgGreen:  '\x1b[42m',
+    bgYellow: '\x1b[43m',
+    bgBlue:   '\x1b[44m',
+    bgMagenta:'\x1b[45m',
+    bgCyan:   '\x1b[46m',
+    bgWhite:  '\x1b[47m',
+    bgBlack:  '\x1b[40m',
+};
+
+// Emoji constants for different log types
+const EMOJI = {
+    info: 'ℹ️ ',
+    success: '✅',
+    warn: '⚠️ ',
+    error: '❌',
+    debug: '🔍',
+    trace: '📍',
+    event: '🎯',
+    progress: '📊',
+    box: '📦',
+    group: '📂',
+    mqtt: '🔌',
+    bot: '🤖',
+    region: '🌍',
+    e2ee: '🔐',
+    transport: '📡',
+    shield: '🛡️',
+    key: '🔑',
+    lock: '🔒',
+    unlock: '🔓',
+    gear: '⚙️ ',
+    rocket: '🚀',
+    star: '⭐',
+    spark: '✨',
+    fire: '🔥',
+    zap: '⚡',
+    check: '✔️ ',
+    cross: '✖️ ',
+    dot: '◈',
+    arrow: '➜',
+    pointer: '👉',
+    clock: '🕐',
+    bell: '🔔',
+    mute: '🔕',
+    mail: '📧',
+    chat: '💬',
+    users: '👥',
+    user: '👤',
+    globe: '🌐',
+    cloud: '☁️ ',
+    server: '🖥️ ',
+    database: '🗄️ ',
+    file: '📄',
+    folder: '📁',
+    pin: '📌',
+    link: '🔗',
+    heart: '❤️ ',
+    thumbsUp: '👍',
+    thumbsDown: '👎',
+    wave: '👋',
+    eyes: '👀',
+    bulb: '💡',
+    target: '🎯',
+    megaphone: '📣',
+    speaker: '🔊',
+    microphone: '🎤',
+    camera: '📷',
+    image: '🖼️ ',
+    video: '🎬',
+    music: '🎵',
+    gift: '🎁',
+    package: '📦',
+    wrench: '🔧',
+    hammer: '🔨',
+    magnet: '🧲',
+    battery: '🔋',
+    plug: '🔌',
+    cable: '🔗',
+    signal: '📶',
+    wifi: '📶',
+    antenna: '📡',
+    satellite: '🛰️ ',
+};
+
+// Log levels with numeric priority
+const LEVELS = {
+    SILENT: 0,
+    ERROR: 1,
+    WARN: 2,
+    INFO: 3,
+    SUCCESS: 4,
+    EVENT: 5,
+    DEBUG: 6,
+    TRACE: 7,
+};
+
+// Default configuration
+const config = {
+    level: 'INFO',
+    fileLogging: false,
+    logDir: path.join(process.cwd(), 'logs'),
+    maxFileSize: 10 * 1024 * 1024, // 10MB
+    maxFiles: 5,
+    showTimestamp: true,
+    showLevel: true,
+    showEmoji: true,
+    colorize: true,
+    json: false,
+    callerInfo: false,
+};
+
+let currentLogFile = null;
+let currentFileSize = 0;
+
+function setConfig(newConfig) {
+    Object.assign(config, newConfig);
+    if (config.fileLogging && !fs.existsSync(config.logDir)) {
+        fs.mkdirSync(config.logDir, { recursive: true });
+    }
+}
+
+function getCallerInfo() {
+    if (!config.callerInfo) return '';
+    const err = new Error();
+    const stack = err.stack.split('\n');
+    const caller = stack[4] || stack[3] || '';
+    const match = caller.match(/at\s+(.+?)\s+\((.+?):(\d+):(\d+)\)/) || 
+                  caller.match(/at\s+(.+?):(\d+):(\d+)/);
+    if (match) {
+        const [_, func, file, line] = match;
+        const fileName = file ? path.basename(file) : 'unknown';
+        return `${C.dim}(${fileName}:${line})${C.reset} `;
+    }
+    return '';
+}
+
+function ts() {
+    if (!config.showTimestamp) return '';
+    const d = new Date();
+    const hh = String(d.getHours()).padStart(2, '0');
+    const mm = String(d.getMinutes()).padStart(2, '0');
+    const ss = String(d.getSeconds()).padStart(2, '0');
+    const ms = String(d.getMilliseconds()).padStart(3, '0');
+    return `${C.dim}${hh}:${mm}:${ss}.${ms}${C.reset}`;
+}
+
+function tag(label, color, emoji = '') {
+    if (!config.showLevel) return '';
+    const emojiStr = config.showEmoji && emoji ? `${emoji} ` : '';
+    return `${color}${C.bold}${emojiStr}[ ${label.padEnd(5)} ]${C.reset}`;
+}
+
+function fmt(msg) {
+    if (msg instanceof Error) {
+        return msg.stack || msg.message;
+    }
+    if (typeof msg === 'object' && msg !== null) {
+        try {
+            return JSON.stringify(msg, null, 2);
+        } catch (_) {
+            return String(msg);
+        }
+    }
+    return String(msg);
+}
+
+function rotateLogFile() {
+    if (!config.fileLogging) return;
+    
+    const logFile = path.join(config.logDir, 'shadowx-fca.log');
+    
+    if (fs.existsSync(logFile)) {
+        const stats = fs.statSync(logFile);
+        if (stats.size >= config.maxFileSize) {
+            for (let i = config.maxFiles - 1; i >= 0; i--) {
+                const oldFile = i === 0 ? logFile : `${logFile}.${i}`;
+                const newFile = `${logFile}.${i + 1}`;
+                if (fs.existsSync(oldFile)) {
+                    if (i === config.maxFiles - 1) {
+                        fs.unlinkSync(oldFile);
+                    } else {
+                        fs.renameSync(oldFile, newFile);
+                    }
+                }
+            }
+        }
+    }
+    
+    currentLogFile = logFile;
+    currentFileSize = fs.existsSync(logFile) ? fs.statSync(logFile).size : 0;
+}
+
+function writeToFile(level, label, msg) {
+    if (!config.fileLogging) return;
+    if (!currentLogFile) rotateLogFile();
+    
+    const d = new Date();
+    const timestamp = d.toISOString();
+    const logEntry = `[${timestamp}] [${level}] [${label}] ${msg}\n`;
+    
+    try {
+        fs.appendFileSync(currentLogFile, logEntry);
+        currentFileSize += Buffer.byteLength(logEntry);
+        
+        if (currentFileSize >= config.maxFileSize) {
+            rotateLogFile();
+        }
+    } catch (err) {
+        console.error(`Failed to write to log file: ${err.message}`);
+    }
+}
+
+function shouldLog(level) {
+    const currentLevel = LEVELS[config.level] || LEVELS.INFO;
+    const messageLevel = LEVELS[level] || LEVELS.INFO;
+    return messageLevel <= currentLevel;
+}
+
+const logger = {
+    LEVELS,
+    EMOJI,
+    config,
+    setConfig,
+
+    info(label, msg) {
+        if (!shouldLog('INFO')) return;
+        if (msg === undefined) { msg = label; label = 'INFO'; }
+        const caller = getCallerInfo();
+        const output = `${ts()} ${tag(label, C.bCyan, EMOJI.info)} ${caller}${C.white}${fmt(msg)}${C.reset}`;
+        console.log(output);
+        writeToFile('INFO', label, fmt(msg));
+    },
+
+    success(label, msg) {
+        if (!shouldLog('SUCCESS')) return;
+        if (msg === undefined) { msg = label; label = 'OK'; }
+        const caller = getCallerInfo();
+        const output = `${ts()} ${tag(label, C.bGreen, EMOJI.success)} ${caller}${C.bWhite}${fmt(msg)}${C.reset}`;
+        console.log(output);
+        writeToFile('SUCCESS', label, fmt(msg));
+    },
+
+    warn(label, msg) {
+        if (!shouldLog('WARN')) return;
+        if (msg === undefined) { msg = label; label = 'WARN'; }
+        const caller = getCallerInfo();
+        const output = `${ts()} ${tag(label, C.bYellow, EMOJI.warn)} ${caller}${C.yellow}${fmt(msg)}${C.reset}`;
+        console.warn(output);
+        writeToFile('WARN', label, fmt(msg));
+    },
+
+    error(label, msg) {
+        if (!shouldLog('ERROR')) return;
+        if (msg === undefined) { msg = label; label = 'ERROR'; }
+        const caller = getCallerInfo();
+        const body = msg instanceof Error ? msg.stack || msg.message : fmt(msg);
+        const output = `${ts()} ${tag(label, C.bRed, EMOJI.error)} ${caller}${C.red}${body}${C.reset}`;
+        console.error(output);
+        writeToFile('ERROR', label, body);
+    },
+
+    debug(label, msg) {
+        if (!shouldLog('DEBUG')) return;
+        if (msg === undefined) { msg = label; label = 'DEBUG'; }
+        const caller = getCallerInfo();
+        const output = `${ts()} ${tag(label, C.bBlack, EMOJI.debug)} ${caller}${C.dim}${fmt(msg)}${C.reset}`;
+        console.log(output);
+        writeToFile('DEBUG', label, fmt(msg));
+    },
+
+    trace(label, msg) {
+        if (!shouldLog('TRACE')) return;
+        if (msg === undefined) { msg = label; label = 'TRACE'; }
+        const caller = getCallerInfo();
+        const output = `${ts()} ${tag(label, C.bBlue, EMOJI.trace)} ${caller}${C.dim}${C.italic}${fmt(msg)}${C.reset}`;
+        console.log(output);
+        writeToFile('TRACE', label, fmt(msg));
+    },
+
+    event(label, msg) {
+        if (!shouldLog('EVENT')) return;
+        if (msg === undefined) { msg = label; label = 'EVENT'; }
+        const caller = getCallerInfo();
+        const output = `${ts()} ${tag(label, C.bMagenta, EMOJI.event)} ${caller}${C.magenta}${fmt(msg)}${C.reset}`;
+        console.log(output);
+        writeToFile('EVENT', label, fmt(msg));
+    },
+
+    // Progress bar
+    progress(current, total, label = '') {
+        if (!shouldLog('INFO')) return;
+        const percentage = Math.round((current / total) * 100);
+        const barWidth = 30;
+        const filled = Math.round((barWidth * current) / total);
+        const empty = barWidth - filled;
+        const bar = '█'.repeat(filled) + '░'.repeat(empty);
+        const percentStr = `${percentage}%`.padStart(4);
+        
+        const emoji = percentage === 100 ? EMOJI.success : EMOJI.progress;
+        
+        process.stdout.write(
+            `\r${ts()} ${tag(label || 'PROG', C.bCyan, emoji)} ${C.bold}${bar}${C.reset} ${C.bWhite}${percentStr}${C.reset} ${C.dim}${current}/${total}${C.reset}`
+        );
+        
+        if (current === total) {
+            process.stdout.write('\n');
+        }
+    },
+
+    // Table logging
+    table(data, columns = null) {
+        if (!shouldLog('INFO')) return;
+        if (!Array.isArray(data) || data.length === 0) return;
+        
+        const keys = columns || Object.keys(data[0]);
+        const colWidths = keys.map(key => {
+            const maxDataWidth = Math.max(...data.map(row => String(row[key] || '').length));
+            return Math.max(key.length, maxDataWidth) + 2;
+        });
+        
+        // Header
+        const header = keys.map((key, i) => 
+            `${C.bold}${C.bCyan}${String(key).padEnd(colWidths[i])}${C.reset}`
+        ).join('');
+        console.log(`\n${EMOJI.table} ${header}`);
+        
+        // Separator
+        const separator = colWidths.map(w => '─'.repeat(w)).join('');
+        console.log(`${C.dim}${separator}${C.reset}`);
+        
+        // Rows
+        data.forEach(row => {
+            const line = keys.map((key, i) => 
+                `${C.white}${String(row[key] || '').padEnd(colWidths[i])}${C.reset}`
+            ).join('');
+            console.log(line);
+        });
+        console.log('');
+    },
+
+    // Boxed message
+    box(msg, type = 'info') {
+        if (!shouldLog('INFO')) return;
+        const colors = {
+            info: C.bCyan,
+            success: C.bGreen,
+            warn: C.bYellow,
+            error: C.bRed,
+        };
+        const emojis = {
+            info: EMOJI.info,
+            success: EMOJI.success,
+            warn: EMOJI.warn,
+            error: EMOJI.error,
+        };
+        const color = colors[type] || C.bCyan;
+        const emoji = emojis[type] || EMOJI.box;
+        const lines = msg.split('\n');
+        const maxLen = Math.max(...lines.map(l => l.length));
+        const top = `┌${'─'.repeat(maxLen + 2)}┐`;
+        const bottom = `└${'─'.repeat(maxLen + 2)}┘`;
+        
+        console.log(`${color}${emoji} ${top}${C.reset}`);
+        lines.forEach(line => {
+            const padding = ' '.repeat(maxLen - line.length);
+            console.log(`${color}│ ${C.white}${line}${padding} ${color}│${C.reset}`);
+        });
+        console.log(`${color}${bottom}${C.reset}`);
+    },
+
+    // Group related logs
+    group(label, fn) {
+        if (!shouldLog('INFO')) return;
+        console.log(`\n${C.bold}${C.bCyan}${EMOJI.group} ${label}${C.reset}`);
+        console.log(`${C.dim}${'─'.repeat(50)}${C.reset}`);
+        if (typeof fn === 'function') {
+            fn();
+        }
+        console.log(`${C.dim}${'─'.repeat(50)}${C.reset}\n`);
+    },
+
+    // Clear console
+    clear() {
+        process.stdout.write('\x1b[2J\x1b[H');
+    },
+
+    banner(name, version, userID, botName, region, e2ee) {
+        const SEP = `${C.bBlack}${'━'.repeat(54)}${C.reset}`;
+        const dot = `${C.bBlack}${EMOJI.dot}${C.reset}`;
+        const label = (s) => `${C.bold}${C.white}${s.padEnd(10)}${C.reset}`;
+
+        const displayName = botName
+            ? `${C.bWhite}${botName}${C.reset} ${C.bBlack}(${userID})${C.reset}`
+            : `${C.bYellow}${userID}${C.reset}`;
+
+        const e2eeStr = e2ee 
+            ? `${C.bGreen}${EMOJI.lock}  Active${C.reset}`
+            : `${C.bBlack}${EMOJI.unlock}  Inactive${C.reset}`;
+
+        const rows = [
+            '',
+            `  ${C.bold}${C.bCyan}${EMOJI.zap}  ${name}${C.reset} ${C.bBlack}v${version}${C.reset}`,
+            `  ${SEP}`,
+            `  ${dot}  ${label('Bot      ')}  ${EMOJI.bot} ${displayName}`,
+            `  ${dot}  ${label('Region   ')}  ${EMOJI.globe} ${C.bGreen}${(region || 'AUTO').toUpperCase()}${C.reset}`,
+            `  ${dot}  ${label('E2EE     ')}  ${EMOJI.shield} ${e2eeStr}`,
+            `  ${dot}  ${label('Transport')}  ${EMOJI.transport} ${C.bCyan}MQTT / WebSocket${C.reset}`,
+            `  ${SEP}`,
+            `  ${C.dim}  Developed by ${C.bMagenta}Mueid Mursalin Rifat${C.reset}`,
+            `  ${C.dim}  ${EMOJI.heart}  ${C.bRed}Made with love for the community${C.reset}`,
+            '',
+        ];
+        rows.forEach(r => console.log(r));
+    },
+
+    mqttSpinner: null,
+
+    startSpinner(region) {
+        const frames = ['⠋','⠙','⠹','⠸','⠴','⠦','⠧','⠇','⠏'];
+        let fi = 0;
+        const regionStr = region ? ` ${C.dim}${C.bCyan}[${region.toUpperCase()}]${C.reset}` : '';
+        process.stdout.write('\n');
+        logger.mqttSpinner = setInterval(() => {
+            const f = frames[fi++ % frames.length];
+            process.stdout.write(
+                `\r  ${C.bold}${C.bCyan}${f}${C.reset}  ${C.cyan}SHADOWX${C.reset} ` +
+                `${C.dim}${EMOJI.mqtt} connecting to MQTT${C.reset}${regionStr}${C.dim} ...${C.reset}   `
+            );
+        }, 80);
+    },
+
+    stopSpinner(success = true) {
+        if (logger.mqttSpinner) {
+            clearInterval(logger.mqttSpinner);
+            logger.mqttSpinner = null;
+        }
+        process.stdout.write('\r\x1b[2K');
+        const icon = success ? `${C.bGreen}${EMOJI.check}${C.reset}` : `${C.bRed}${EMOJI.cross}${C.reset}`;
+        const statusMsg = success ? 'established' : 'failed';
+        const statusIcon = success ? EMOJI.success : EMOJI.error;
+        process.stdout.write(`\r  ${icon}  ${C.cyan}SHADOWX${C.reset} ${C.dim}${EMOJI.mqtt} MQTT connection ${statusMsg}${C.reset} ${statusIcon}\n`);
+    },
+
+    // Additional utility methods with emojis
+    connected(msg) {
+        this.success('CONNECT', `${EMOJI.plug} ${msg || 'Connected successfully'}`);
+    },
+
+    disconnected(msg) {
+        this.warn('DISCON', `${EMOJI.cable} ${msg || 'Disconnected'}`);
+    },
+
+    message(msg) {
+        this.info('MSG', `${EMOJI.chat} ${msg}`);
+    },
+
+    userAction(msg) {
+        this.event('USER', `${EMOJI.user} ${msg}`);
+    },
+
+    system(msg) {
+        this.info('SYS', `${EMOJI.gear} ${msg}`);
+    },
+};
+
+module.exports = logger;
+module.exports.C = C;
+module.exports.EMOJI = EMOJI;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "shadowx-fca",
+  "version": "8.0.0",
+  "description": "SHADOWX-FCA - Ultimate Facebook Chat API for Node.js. Dev by Dev by Mueid Mursalin Rifat",
+  "main": "index.js",
+  "files": [
+    "src/",
+    "build/",
+    "lib/",
+    "assets/",
+    "index.js",
+    "utils.js",
+    "checkUpdate.js",
+    "logger.js",
+    "e2ee.js",
+    "e2eetest.js",
+    "config.json"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "start": "node index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mueidmursalinrifat/shadowx-fca.git"
+  },
+  "keywords": [
+    "facebook", "chat", "api", "bot", "messenger", "unofficial",
+    "signal-protocol", "mqtt", "facebook-chat-api"
+  ],
+  "author": "Mueid Mursalin Rifat",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mueidmursalinrifat/shadowx-fca/issues"
+  },
+  "homepage": "https://github.com/mueidmursalinrifat/shadowx-fca#readme",
+  "dependencies": {
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
+    "@signalapp/libsignal-client": "0.70.0",
+    "axios": "^1.8.4",
+    "bluebird": "^3.7.2",
+    "chalk": "^4.1.2",
+    "cheerio": "^1.0.0-rc.10",
+    "duplexify": "^4.1.3",
+    "form-data": "^4.0.0",
+    "gradient-string": "^2.0.2",
+    "https-proxy-agent": "^7.0.6",
+    "koffi": "^3.0.2",
+    "mime": "^3.0.0",
+    "mqtt": "^5.10.1",
+    "npmlog": "^1.2.0",
+    "protobufjs": "^8.4.0",
+    "request": "^2.88.2",
+    "sequelize": "^6.37.6",
+    "sqlite3": "^5.1.7",
+    "totp-generator": "^1.0.0",
+    "undici": "^8.4.0",
+    "ws": "^8.18.1",
+    "yumi-json-bigint": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/GetBotInfo.js

@@ -0,0 +1,66 @@
+"use strict";
+// shadowx-fca — GetBotInfo
+// Author: Modified for shadowx-fca
+
+const utils = require('../utils');
+
+module.exports = (defaultFuncs, api, ctx) => {
+  /**
+   * Returns bot's current login info, tokens, and context accessor functions.
+   * @param {Array<object>} netData - JSON blobs extracted from Facebook HTML
+   * @returns {object|null}
+   */
+  return function GetBotInfo(netData) {
+    if (!netData || !Array.isArray(netData)) {
+      utils.log("GetBotInfo", "netData is not a valid array.");
+      return null;
+    }
+
+    const findConfig = (key) => {
+      for (const scriptData of netData) {
+        if (!scriptData.require) continue;
+        for (const req of scriptData.require) {
+          if (Array.isArray(req) && req[0] === key && req[2]) {
+            return req[2];
+          }
+          if (Array.isArray(req) && req[3] && req[3][0] && req[3][0].__bbox && req[3][0].__bbox.define) {
+            for (const def of req[3][0].__bbox.define) {
+              if (Array.isArray(def) && def[0] && def[0].endsWith(key) && def[2]) {
+                return def[2];
+              }
+            }
+          }
+        }
+      }
+      return null;
+    };
+
+    const currentUserData = findConfig("CurrentUserInitialData");
+    const dtsgInitialData = findConfig("DTSGInitialData");
+    const dtsgInitData = findConfig("DTSGInitData");
+    const lsdData = findConfig("LSD");
+
+    if (!currentUserData || !dtsgInitialData) {
+      utils.log("GetBotInfo", "Could not find required data (CurrentUserInitialData or DTSGInitialData).");
+      return null;
+    }
+
+    return {
+      name: currentUserData.NAME || null,
+      firstName: currentUserData.SHORT_NAME || null,
+      uid: currentUserData.USER_ID || null,
+      appID: currentUserData.APP_ID || null,
+      dtsgToken: dtsgInitialData.token || null,
+      lsdToken: lsdData?.token || null,
+      dtsgInit: dtsgInitData ? { 
+        token: dtsgInitData.token, 
+        async_get_token: dtsgInitData.async_get_token 
+      } : undefined,
+      getCtx: (key) => ctx ? ctx[key] : null,
+      getOptions: (key) => ctx && ctx.globalOptions ? ctx.globalOptions[key] : null,
+      getRegion: () => ctx?.region || null,
+      getUserID: () => ctx?.userID || currentUserData?.USER_ID || null,
+      getJar: () => ctx?.jar || null
+    };
+  };
+};