shadowx-fca 1.2.0 → 2.0.0

package/checkUpdate.js

@@ -0,0 +1,112 @@
+const axios = require('axios');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+async function checkForFCAUpdate() {
+    try {
+        console.log('\x1b[33m%s\x1b[0m', '🔍 Checking for shadowx-fca updates...');
+        
+        // Get latest version from npm registry
+        const { data: npmData } = await axios.get(
+            'https://registry.npmjs.org/shadowx-fca/latest'
+        );
+        
+        const latestVersion = npmData.version;
+        
+        // Check current installed version in node_modules
+        let currentVersion = '1.0.8';
+        const nodeModulesPackagePath = path.join(process.cwd(), 'node_modules', 'shadowx-fca', 'package.json');
+        if (fs.existsSync(nodeModulesPackagePath)) {
+            const installedPackage = JSON.parse(fs.readFileSync(nodeModulesPackagePath, 'utf-8'));
+            currentVersion = installedPackage.version;
+        }
+        
+        if (latestVersion !== currentVersion) {
+            console.log('\x1b[32m%s\x1b[0m', `✨ New shadowx-fca version available: ${latestVersion} (current: ${currentVersion})`);
+            console.log('\x1b[33m%s\x1b[0m', '📦 Updating shadowx-fca package...');
+            
+            // Show changelog
+            try {
+                const { data: changesData } = await axios.get(
+                    'https://raw.githubusercontent.com/mueidmursalinrifat/shadowx-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 (err) {
+                // Silently ignore changelog fetch errors
+            }
+            
+            // Update npm package
+            await updateNpmPackage(latestVersion);
+            
+            // Update version in user's package.json
+            await updateUserPackageJson(latestVersion);
+            
+            console.log('\x1b[32m%s\x1b[0m', '✅ shadowx-fca updated successfully!');
+            console.log('\x1b[33m%s\x1b[0m', '🔄 Restarting to apply changes...');
+            
+            // Restart the process
+            setTimeout(() => {
+                process.exit(2);
+            }, 1000);
+            
+            return true;
+        } else {
+            console.log('\x1b[32m%s\x1b[0m', `✅ shadowx-fca is up to date (v${currentVersion})`);
+            return false;
+        }
+    } catch (error) {
+        console.log('\x1b[31m%s\x1b[0m', '❌ Failed to check for shadowx-fca updates:', error.message);
+        return false;
+    }
+}
+
+async function updateNpmPackage(version) {
+    try {
+        console.log('\x1b[36m%s\x1b[0m', `📦 Running npm install shadowx-fca@${version}...`);
+        
+        // Execute npm install command
+        execSync(`npm install shadowx-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)) {
+            console.log('\x1b[33m%s\x1b[0m', '⚠️  No package.json found in user project');
+            return;
+        }
+
+        const packageJson = JSON.parse(fs.readFileSync(userPackageJsonPath, 'utf-8'));
+
+        // Update stfca version in dependencies
+        if (packageJson.dependencies && packageJson.dependencies.stfca) {
+            packageJson.dependencies.stfca = `^${version}`;
+            fs.writeFileSync(userPackageJsonPath, JSON.stringify(packageJson, null, 2));
+            console.log('\x1b[32m%s\x1b[0m', `✅ Updated package.json to shadowx-fca@${version}`);
+        }
+
+        return true;
+    } catch (error) {
+        console.log('\x1b[31m%s\x1b[0m', '⚠️  Failed to update user package.json:', error.message);
+        // Don't throw - this is not critical
+        return false;
+    }
+}
+
+module.exports = { checkForFCAUpdate, updateNpmPackage, updateUserPackageJson };

package/index.js

@@ -3,11 +3,28 @@
 var utils = require("./utils");
 var cheerio = require("cheerio");
 var log = require("npmlog");
-
+var { checkForFCAUpdate } = require("./checkUpdate");
+const fs = require('fs');
+const path = require('path');
+/*var { getThemeColors } = require("../../func/utils/log.js");
+var logger = require("../../func/utils/log.js");
+var { cra, cv, cb, co } = getThemeColors();*/
 log.maxRecordSize = 100;
 var checkVerified = null;
 const Boolean_Option = ['online', 'selfListen', 'listenEvents', 'updatePresence', 'forceLogin', 'autoMarkDelivery', 'autoMarkRead', 'listenTyping', 'autoReconnect', 'emitReady'];
 global.ditconmemay = false;
+global.stfcaUpdateChecked = false;
+
+// Auto-check for updates on package load (non-blocking)
+if (!global.stfcaUpdateChecked) {
+    global.stfcaUpdateChecked = 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) {
@@ -173,6 +190,86 @@ function buildAPI(globalOptions, html, jar) {
         reqCallbacks: {},
         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'));
+            if (rootConfig && typeof rootConfig === 'object') {
+                if (typeof rootConfig.enableTypingIndicator !== 'undefined') config.enableTypingIndicator = rootConfig.enableTypingIndicator;
+                if (typeof rootConfig.typingDuration !== 'undefined') config.typingDuration = rootConfig.typingDuration;
+            }
+        }
+
+        const fcaConfigPath = path.join(__dirname, 'config.json');
+        if (fs.existsSync(fcaConfigPath)) {
+            const fcaConfig = JSON.parse(fs.readFileSync(fcaConfigPath, 'utf8'));
+            if (fcaConfig && typeof fcaConfig === 'object') {
+                if (typeof fcaConfig.enableTypingIndicator !== 'undefined') config.enableTypingIndicator = fcaConfig.enableTypingIndicator;
+                if (typeof fcaConfig.typingDuration !== 'undefined') config.typingDuration = fcaConfig.typingDuration;
+            }
+        }
+
+        if (global.GoatBot && global.GoatBot.config) {
+            if (typeof global.GoatBot.config.enableTypingIndicator !== 'undefined') config.enableTypingIndicator = global.GoatBot.config.enableTypingIndicator;
+            if (typeof global.GoatBot.config.typingDuration !== 'undefined') config.typingDuration = global.GoatBot.config.typingDuration;
+        }
+    } catch (e) {
+        console.log('Error loading config.json:', e);
+    }
+
+    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') {
+                    if (typeof rootConfig.enableTypingIndicator !== 'undefined') updatedConfig.enableTypingIndicator = rootConfig.enableTypingIndicator;
+                    if (typeof rootConfig.typingDuration !== 'undefined') updatedConfig.typingDuration = rootConfig.typingDuration;
+                }
+            }
+
+            if (fs.existsSync(path.join(__dirname, 'config.json'))) {
+                const fcaConfig = JSON.parse(fs.readFileSync(path.join(__dirname, 'config.json'), 'utf8'));
+                if (fcaConfig && typeof fcaConfig === 'object') {
+                    if (typeof fcaConfig.enableTypingIndicator !== 'undefined') updatedConfig.enableTypingIndicator = fcaConfig.enableTypingIndicator;
+                    if (typeof fcaConfig.typingDuration !== 'undefined') updatedConfig.typingDuration = fcaConfig.typingDuration;
+                }
+            }
+
+            if (global.GoatBot && global.GoatBot.config) {
+                if (typeof global.GoatBot.config.enableTypingIndicator !== 'undefined') updatedConfig.enableTypingIndicator = global.GoatBot.config.enableTypingIndicator;
+                if (typeof global.GoatBot.config.typingDuration !== 'undefined') updatedConfig.typingDuration = global.GoatBot.config.typingDuration;
+            }
+
+            ctx.config = updatedConfig;
+            config = updatedConfig;
+            if (global.GoatBot) global.GoatBot.config = global.GoatBot.config || {};
+            if (global.GoatBot && typeof global.GoatBot.config.enableTypingIndicator !== 'undefined') {
+                global.GoatBot.config.enableTypingIndicator = updatedConfig.enableTypingIndicator;
+            }
+            if (global.GoatBot && typeof global.GoatBot.config.typingDuration !== 'undefined') {
+                global.GoatBot.config.typingDuration = updatedConfig.typingDuration;
+            }
+        } catch (e) {
+            console.log('Failed to refresh fca config:', e);
+        }
+    };
+
+    // Initial config load
+    refreshFcaConfig();
+
+    // Accessible runtime API for config reload
+    ctx.refreshFcaConfig = refreshFcaConfig;
+    if (global.GoatBot) {
+        global.GoatBot.refreshFcaConfig = refreshFcaConfig;
+    }
+
+    ctx.config = config;
     var api = {
         setOptions: setOptions.bind(null, globalOptions),
         getAppState: () => utils.getAppState(jar),
@@ -426,6 +523,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.stfcaUpdateChecked) {
+        global.stfcaUpdateChecked = 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 = {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadowx-fca",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "Unofficial Facebook Chat API for Node.js with Auto-Update System -  modify by Mueid Mursalin Rifat",
   "main": "index.js",
   "files": [
@@ -15,7 +15,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/mueidmursalinrifat/pussy-fca.git"
+    "url": "git+https://github.com/mueidmursalinrifat/shadowx-fca.git"
   },
   "keywords": [
     "facebook",