shadowx-fca 8.0.0

package/checkUpdate.js

@@ -0,0 +1,393 @@
+"use strict";
+
+const axios = require('axios');
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const logger = require('./logger');
+
+/**
+ * Check for updates to shadowx-fca package
+ * @returns {Promise<boolean>} True if update was performed, false otherwise
+ */
+async function checkForFCAUpdate() {
+    try {
+        logger.info('UPDATE', 'Checking for shadowx-fca updates...');
+        
+        // Get latest version from npm registry
+        const { data: npmData } = await axios.get(
+            'https://registry.npmjs.org/shadowx-fca/latest',
+            { timeout: 10000 }
+        );
+        
+        const latestVersion = npmData.version;
+        
+        // Check current installed version in multiple locations
+        let currentVersion = '0.0.0';
+        const searchPaths = [
+            path.join(process.cwd(), 'node_modules', 'shadowx-fca', 'package.json'),
+            path.join(__dirname, '..', 'package.json'), // Parent directory
+            path.join(process.cwd(), 'package.json'), // Check if running from source
+        ];
+        
+        for (const pkgPath of searchPaths) {
+            if (fs.existsSync(pkgPath)) {
+                try {
+                    const installedPackage = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+                    if (installedPackage.name === 'shadowx-fca') {
+                        currentVersion = installedPackage.version;
+                        break;
+                    }
+                } catch (err) {
+                    // Continue to next path
+                }
+            }
+        }
+        
+        logger.debug('UPDATE', `Current version: ${currentVersion}, Latest version: ${latestVersion}`);
+        
+        if (compareVersions(latestVersion, currentVersion) > 0) {
+            logger.box(
+                `✨ New update available!\n` +
+                `Current: v${currentVersion}\n` +
+                `Latest:  v${latestVersion}`,
+                'warn'
+            );
+            
+            // Show changelog if available
+            await showChangelog(latestVersion);
+            
+            // Confirm update
+            const shouldUpdate = await confirmUpdate();
+            
+            if (shouldUpdate) {
+                logger.group('📦 Updating shadowx-fca', async () => {
+                    // Backup current version
+                    await backupCurrentVersion(currentVersion);
+                    
+                    // Update npm package
+                    await updateNpmPackage(latestVersion);
+                    
+                    // Update version in user's package.json
+                    await updateUserPackageJson(latestVersion);
+                    
+                    logger.success('UPDATE', `Successfully updated to v${latestVersion}`);
+                    logger.warn('UPDATE', 'Restarting to apply changes...');
+                    
+                    // Graceful restart
+                    setTimeout(() => {
+                        process.exit(2);
+                    }, 2000);
+                    
+                    return true;
+                });
+            } else {
+                logger.info('UPDATE', 'Update skipped by user');
+                return false;
+            }
+        } else if (compareVersions(latestVersion, currentVersion) < 0) {
+            logger.info('UPDATE', `Running development version v${currentVersion} (latest: v${latestVersion})`);
+            return false;
+        } else {
+            logger.success('UPDATE', `shadowx-fca is up to date (v${currentVersion})`);
+            return false;
+        }
+    } catch (error) {
+        if (error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT') {
+            logger.warn('UPDATE', 'Could not reach npm registry. Skipping update check.');
+        } else {
+            logger.error('UPDATE', `Failed to check for updates: ${error.message}`);
+        }
+        return false;
+    }
+}
+
+/**
+ * Show changelog for the new version
+ * @param {string} version - Latest version number
+ */
+async function showChangelog(version) {
+    try {
+        const changelogUrls = [
+            `https://raw.githubusercontent.com/mueidmursalinrifat/shadowx-fca/main/CHANGELOG.md`,
+            `https://raw.githubusercontent.com/mueidmursalinrifat/shadowx-fca/master/CHANGELOG.md`,
+        ];
+        
+        for (const url of changelogUrls) {
+            try {
+                const { data: changesData } = await axios.get(url, { timeout: 5000 });
+                
+                logger.info('UPDATE', '📋 Recent Changes:');
+                
+                // Parse changelog sections
+                const sections = changesData.split(/(?=##\s)/);
+                let latestChanges = '';
+                
+                // Find the section for this version or the latest version
+                for (const section of sections) {
+                    if (section.includes(version) || sections.indexOf(section) === 1) {
+                        const lines = section.split('\n').filter(line => line.trim());
+                        // Skip the header line
+                        latestChanges = lines.slice(1, 6).join('\n');
+                        break;
+                    }
+                }
+                
+                if (latestChanges) {
+                    console.log(logger.C.dim + latestChanges + logger.C.reset);
+                } else {
+                    // Show first few lines if no version-specific section
+                    const lines = changesData.split('\n').slice(0, 10);
+                    console.log(logger.C.dim + lines.join('\n') + logger.C.reset);
+                }
+                return;
+            } catch (err) {
+                // Try next URL
+            }
+        }
+    } catch (err) {
+        logger.debug('UPDATE', 'Could not fetch changelog');
+    }
+}
+
+/**
+ * Confirm with user before updating
+ * @returns {Promise<boolean>}
+ */
+async function confirmUpdate() {
+    return new Promise((resolve) => {
+        // Auto-update in production, ask in development
+        if (process.env.NODE_ENV === 'production' || process.env.AUTO_UPDATE === 'true') {
+            logger.info('UPDATE', 'Auto-update enabled, proceeding...');
+            resolve(true);
+            return;
+        }
+        
+        // If no TTY, auto-accept
+        if (!process.stdin.isTTY) {
+            logger.info('UPDATE', 'Non-interactive mode, proceeding with update...');
+            resolve(true);
+            return;
+        }
+        
+        // Default to yes after timeout
+        const timeout = setTimeout(() => {
+            logger.info('UPDATE', 'No response, proceeding with update...');
+            resolve(true);
+        }, 10000);
+        
+        process.stdout.write(
+            `${logger.C.bYellow}Do you want to update? (Y/n): ${logger.C.reset}`
+        );
+        
+        const handler = (data) => {
+            clearTimeout(timeout);
+            const input = data.toString().trim().toLowerCase();
+            process.stdin.removeListener('data', handler);
+            
+            if (input === 'n' || input === 'no') {
+                resolve(false);
+            } else {
+                resolve(true);
+            }
+        };
+        
+        process.stdin.once('data', handler);
+        process.stdin.resume();
+    });
+}
+
+/**
+ * Backup current version before updating
+ * @param {string} currentVersion - Current version number
+ */
+async function backupCurrentVersion(currentVersion) {
+    try {
+        const backupDir = path.join(process.cwd(), 'node_modules', '.shadowx-fca-backup');
+        const sourceDir = path.join(process.cwd(), 'node_modules', 'shadowx-fca');
+        
+        if (fs.existsSync(sourceDir)) {
+            if (!fs.existsSync(backupDir)) {
+                fs.mkdirSync(backupDir, { recursive: true });
+            }
+            
+            const backupPath = path.join(backupDir, `v${currentVersion}-${Date.now()}`);
+            
+            // Copy package.json for reference
+            const pkgPath = path.join(sourceDir, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                fs.copyFileSync(pkgPath, path.join(backupDir, `package-v${currentVersion}.json`));
+            }
+            
+            logger.debug('UPDATE', `Backed up current version v${currentVersion}`);
+        }
+    } catch (error) {
+        logger.warn('UPDATE', `Could not create backup: ${error.message}`);
+    }
+}
+
+/**
+ * Compare two semantic versions
+ * @param {string} v1 - First version
+ * @param {string} v2 - Second version
+ * @returns {number} 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+    
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const part1 = parts1[i] || 0;
+        const part2 = parts2[i] || 0;
+        
+        if (part1 > part2) return 1;
+        if (part1 < part2) return -1;
+    }
+    
+    return 0;
+}
+
+/**
+ * Update npm package to latest version
+ * @param {string} version - Version to install
+ * @returns {Promise<boolean>}
+ */
+async function updateNpmPackage(version) {
+    return new Promise((resolve, reject) => {
+        try {
+            logger.info('UPDATE', `📦 Installing shadowx-fca@${version}...`);
+            
+            // Try multiple package managers
+            const packageManagers = ['npm', 'yarn', 'pnpm'];
+            let installed = false;
+            
+            for (const pm of packageManagers) {
+                try {
+                    const command = pm === 'yarn' 
+                        ? `yarn add shadowx-fca@${version}`
+                        : pm === 'pnpm'
+                            ? `pnpm add shadowx-fca@${version}`
+                            : `npm install shadowx-fca@${version} --save`;
+                    
+                    logger.debug('UPDATE', `Trying ${pm}...`);
+                    
+                    execSync(command, {
+                        cwd: process.cwd(),
+                        stdio: 'pipe',
+                        timeout: 60000
+                    });
+                    
+                    installed = true;
+                    logger.success('UPDATE', `Package installed successfully using ${pm}`);
+                    break;
+                } catch (err) {
+                    logger.debug('UPDATE', `${pm} failed: ${err.message}`);
+                }
+            }
+            
+            if (installed) {
+                resolve(true);
+            } else {
+                reject(new Error('All package managers failed'));
+            }
+        } catch (error) {
+            logger.error('UPDATE', `Failed to install package: ${error.message}`);
+            reject(error);
+        }
+    });
+}
+
+/**
+ * Update user's package.json with new version
+ * @param {string} version - New version number
+ * @returns {Promise<boolean>}
+ */
+async function updateUserPackageJson(version) {
+    try {
+        const userPackageJsonPath = path.join(process.cwd(), 'package.json');
+
+        if (!fs.existsSync(userPackageJsonPath)) {
+            logger.warn('UPDATE', 'No package.json found in project root');
+            return false;
+        }
+
+        const packageJson = JSON.parse(fs.readFileSync(userPackageJsonPath, 'utf-8'));
+        let updated = false;
+
+        // Update in dependencies
+        if (packageJson.dependencies && packageJson.dependencies['shadowx-fca']) {
+            packageJson.dependencies['shadowx-fca'] = `^${version}`;
+            updated = true;
+        }
+        
+        // Update in devDependencies
+        if (packageJson.devDependencies && packageJson.devDependencies['shadowx-fca']) {
+            packageJson.devDependencies['shadowx-fca'] = `^${version}`;
+            updated = true;
+        }
+        
+        // Update in peerDependencies
+        if (packageJson.peerDependencies && packageJson.peerDependencies['shadowx-fca']) {
+            packageJson.peerDependencies['shadowx-fca'] = `^${version}`;
+            updated = true;
+        }
+
+        if (updated) {
+            fs.writeFileSync(userPackageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+            logger.success('UPDATE', `Updated package.json to shadowx-fca@^${version}`);
+        } else {
+            logger.debug('UPDATE', 'shadowx-fca not found in package.json dependencies');
+        }
+
+        return true;
+    } catch (error) {
+        logger.warn('UPDATE', `Failed to update user package.json: ${error.message}`);
+        return false;
+    }
+}
+
+/**
+ * Check for updates with retry mechanism
+ * @param {number} retries - Number of retry attempts
+ * @param {number} delay - Delay between retries in ms
+ * @returns {Promise<boolean>}
+ */
+async function checkForUpdatesWithRetry(retries = 3, delay = 5000) {
+    for (let i = 0; i < retries; i++) {
+        try {
+            const result = await checkForFCAUpdate();
+            return result;
+        } catch (error) {
+            if (i < retries - 1) {
+                logger.warn('UPDATE', `Retry ${i + 1}/${retries} in ${delay/1000}s...`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+    }
+    logger.error('UPDATE', 'All update attempts failed');
+    return false;
+}
+
+// Initialize update check if not disabled
+function initAutoUpdate() {
+    const disableUpdate = process.env.DISABLE_UPDATE === 'true' || 
+                          process.argv.includes('--no-update');
+    
+    if (!disableUpdate) {
+        // Check for updates after a delay to not block startup
+        setTimeout(() => {
+            checkForUpdatesWithRetry().catch(() => {
+                // Silently fail - updates are non-critical
+            });
+        }, 3000);
+    }
+}
+
+module.exports = {
+    checkForFCAUpdate,
+    updateNpmPackage,
+    updateUserPackageJson,
+    checkForUpdatesWithRetry,
+    initAutoUpdate,
+    compareVersions
+};

package/config.json

@@ -0,0 +1,17 @@
+{
+  "e2ee": {
+    "enable": true,
+    "memoryOnly": true,
+    "autoReconnect": true,
+    "logLevel": "none",
+    "devicePath": null
+  },
+  "enableTypingIndicator": true,
+  "typingDuration": 2000,
+  "listenEvents": true,
+  "autoMarkRead": true,
+  "autoMarkDelivery": false,
+  "selfListen": false,
+  "online": true,
+  "logLevel": "silent"
+}