Partial update system

A system is partially added to allow live updating of the bot from the repository.

Author: EasyXploit

config.json

@@ -1,5 +1,6 @@
 {
     "locale": "en-US",
+    "betaEnabled": true,
     "errorTracking": {
         "enabled": false,
         "sentryDSN": "",

lib/menus/update.js

@@ -9,54 +9,319 @@ const menuName = new URL(import.meta.url).pathname.split('/').pop().replace('.js
 const locale = client.locale.lib.menus[menuName];
 
 // Exports a default function
-export default async (beforeError) => {
+export default async (beforeError, forceUpdate) => {
 
     try {
 
+        // Stores the local configuration from the configuration file
+        let localConfig = require('./config.json');
+
+        // Function to show the post-update menu
+        async function showPostUpdateMenu() {
+
+            // Shows the select menu
+            global.currentPrompt = select({
+                message: `${locale.promptMessage}:`,
+                choices: [
+                    {
+                        name: `🔎 ${locale.choices.checkAgain}`,
+                        value: 'checkAgain'
+                    },
+                    {
+                        name: `${ localConfig.betaEnabled ? `🏠 ${locale.choices.switchToStable}` : `🧪 ${locale.choices.switchToBeta}`}`,
+                        value: 'switchVersion'
+                    },
+                    {
+                        name: `↩️  ${locale.choices.return}`,
+                        value: 'return'
+                    }
+                ],
+            });
+        
+            // When the user selects an option
+            global.currentPrompt.then(async (result) => {
+        
+                // Switches between the options
+                switch (result) {
+        
+                    // If the user wants to check again for updates
+                    case 'checkAgain':
+                        
+                        // Shows this menu again
+                        await client.functions.menus.update();
+        
+                        // Breaks the switch
+                        break;
+        
+                    // If the user wants to change it's version
+                    case 'switchVersion':
+                        
+                        // Changes the betaEnabled value
+                        localConfig.betaEnabled = localConfig.betaEnabled ? false : true;
+
+                        // Saves the new configuration
+                        await fs.writeFileSync('./config.json', JSON.stringify(localConfig, null, 4));
+
+                        // Shows this menu again, passing the forceUpdate parameter based on the new value
+                        await client.functions.menus.update(null, localConfig.betaEnabled ? false : true);
+        
+                        // Breaks the switch
+                        break;
+        
+                    // If the user wants to go back to the main menu
+                    case 'return':
+                        
+                        // Shows the main menu
+                        await client.functions.menus.main();
+        
+                        // Breaks the switch
+                        break;
+                };
+
+            // When an error occurs
+            }).catch(async (error) => {
+
+                // Runs this menu again, passing the error
+                await client.functions.menus[menuName](error);
+            });
+        };
+
         // Cleans the console and shows the logo
         process.stdout.write('\u001b[2J\u001b[0;0H');
         await splashLogo(client.locale.lib.loaders.splashLogo);
-        
+
         // Shows an error message if one occurred
         if (beforeError) console.log(`❌ ${locale.errorMessage}.\n`);
         if (beforeError && process.env.NODE_ENV !== 'production') logger.error(`${beforeError.stack}\n`);
+
+        try {
+
+            // Shows a message indicating that the bot is checking for updates
+            console.log(`🔎 ${locale.checkingForUpdates} ...`);
 
-        // Shows a default text
-        console.log('🚧 This section is currently under development.\n');
+            // Loads the repository configuration
+            const packageConfig = require('./package.json');
 
-        // Shows the select menu
-        global.currentPrompt = select({
-            message: `${locale.promptMessage}:`,
-            choices: [
-                {
-                    name: `↩️  ${locale.choices.return}`,
-                    value: 'return'
-                }
-            ],
-        });
+            // Sets the latest local tag as the current version from the package
+            let latestLocalTag = packageConfig.version;
+
+            // Imports the necessary libraries
+            const simpleGit = require('simple-git');
 
-        // When the user selects an option
-        global.currentPrompt.then(async (result) => {
+            // Creates a new instance of simple-git
+            const git = simpleGit();
 
-            // When the user selects an option
-            switch (result) {
+            // Fetches the latest tags and prunes the old tags
+            await git.fetch(['--prune', '--tags']);
+            
+            // Gets the remote tags list
+            const remoteTagLines = (await git.listRemote(['--tags'])).split('\n');
+
+            // Maps the remote tags list to an array of tag names
+            let remoteTags = remoteTagLines.map(line => {
+
+                // Extracts the tag name from the line
+                const match = line.match(/refs\/tags\/(.+)$/);
+
+                // Returns the tag name or null if it doesn't exist
+                return match ? match[1] : null;
+            
+            // Filters out null values
+            }).filter(tag => tag !== null);
+        
+            // Gets the local tags list and filters out empty values
+            const localTags = (await git.tag(['--list'])).split('\n').filter(tag => tag.trim() !== '');
+        
+            // Filters out tags that exist locally but not remotely
+            const tagsToDelete = localTags.filter(tag => !remoteTags.includes(tag) && tag);
+        
+            // Deletes these non-existent tags
+            for (const tag of tagsToDelete) await git.tag(['-d', tag]);
+
+            // If the beta versions are disabled, removes them from the array
+            if (remoteTags && !localConfig.betaEnabled) remoteTags = remoteTags.filter(tag => !tag.includes('beta'));
+
+            // Obtains the latest remote tag
+            const latestRemoteTag = remoteTags[remoteTags.length - 1];
+
+            // Compares the local and remote tags
+            if (latestRemoteTag && latestRemoteTag.length > 0 && latestLocalTag !== latestRemoteTag) {
+
+                // Function to update the bot
+                async function updateBot() {
+
+                    // Cleans the console and shows the logo
+                    process.stdout.write('\u001b[2J\u001b[0;0H');
+                    await splashLogo(client.locale.lib.loaders.splashLogo);
+
+                    // Shows a message indicating that the bot is checking for updates
+                    console.log(`🔄 ${await client.functions.utils.parseLocale(locale.updatingFromTo, { originVersion: `v${latestLocalTag}`, targetVersion: `v${latestRemoteTag}` })} ...`);
+
+                    // Simulates a loading time
+                    await new Promise(resolve => setTimeout(resolve, 3000)); // Espera de 3 segundos
+
+                    // Makes a pull to update the bot
+                    //await git.pull();
+
+                    // Makes a checkout to the latest tag 
+                    //await git.checkout(latestTag);
+
+                    // Cleans the console and shows the logo
+                    process.stdout.write('\u001b[2J\u001b[0;0H');
+                    await splashLogo(client.locale.lib.loaders.splashLogo);
+
+                    // Shows a message indicating that the bot has been updated
+                    console.log(`✅ ${await client.functions.utils.parseLocale(locale.updatedCorrectly, { targetVersion: `v${latestRemoteTag}` })}\n`);
+                };
+
+                // Shows a message indicating that there are new updates
+                if (!forceUpdate) {
+
+                    // Function to obtain the release notes from the GitHub repository
+                    function getReleaseNotes(owner, repository, tagName) {
+
+                        // Imports the necessary libraries
+                        const https = require('https');
+
+                        // Returns a promise to obtain the release notes
+                        return new Promise((resolve, reject) => {
+                            const options = {
+                                hostname: 'api.github.com',
+                                path: `/repos/${owner}/${repository}/releases/tags/${tagName}`,
+                                method: 'GET',
+                                headers: {
+                                    'User-Agent': 'NodeJS'
+                                }
+                            };
+
+                            // Makes the request
+                            const request = https.request(options, (response) => {
+
+                                // Stores the data
+                                let data = '';
+
+                                // When a chunk of data is received
+                                response.on('data', (chunk) => {
+
+                                    // Stores the chunk
+                                    data += chunk;
+                                });
+
+                                // When the response ends
+                                response.on('end', () => {
+
+                                    // If the response was OK
+                                    if (response.statusCode === 200) {
+
+                                        // Parses the data
+                                        const jsonData = JSON.parse(data);
+
+                                        // Resolves the promise with the body of the response
+                                        resolve(jsonData.body);
+
+                                    } else {
+
+                                        // Rejects the promise with the error
+                                        if (response.statusCode !== 404) return reject(new Error(`Received status code ${response.statusCode}`));
+
+                                        // Resolves the promise with a default message
+                                        resolve(locale.noReleaseNotes);
+                                    };
+                                });
+                            });
+
+                            // When an error occurs
+                            request.on('error', (error) => {
+
+                                // Rejects the promise with the error
+                                reject(error);
+                            });
+
+                            // Ends the request
+                            request.end();
+                        });
+                    };
+
+                    // Cleans the console and shows the logo
+                    process.stdout.write('\u001b[2J\u001b[0;0H');
+                    await splashLogo(client.locale.lib.loaders.splashLogo);
+
+                    // Shows a message indicating that there are new updates
+                    console.log(`⬇️ ${await client.functions.utils.parseLocale(locale.newVersionAvailable, { targetVersion: latestRemoteTag })}\n`);
+
+                    // Uses a regular expression to obtain the owner and repository name from the URL
+                    const repositoryMetadata = packageConfig.repository.url.match(/github\.com\/([^\/]+)\/([^\/]+)\.git/);
+    
+                    // Stores the owner and repository name
+                    const repositoryOwner = repositoryMetadata[1];
+                    const repositoryName = repositoryMetadata[2];
+    
+                    // Obtains the release notes
+                    await getReleaseNotes(repositoryOwner, repositoryName, latestRemoteTag).then(releaseNotes => {
+
+                        // Shows the release notes
+                        console.log(`${locale.releaseNotes}:\n${releaseNotes}\n`);
+
+                    }).catch(error => {
+
+                        // Shows an error message if one occurred
+                        console.log(`❌ ${locale.releaseNotesError}\n`);
 
-                // If the user wants to go back to the main menu
-                case 'return':
-                    
-                    // Shows the main menu
-                    await client.functions.menus.main();
+                        // Logs an error message if one occurred
+                        logger.error(error);
+                    });
+
+                    // Shows the select menu to ask the user if wants to update the bot
+                    global.currentPrompt = select({
+                        message: `${locale.updateConfirmationPromptMessage}:`,
+                        choices: [
+                            {
+                                name: `✅ ${locale.updateConfirmationChoices.yes}`,
+                                value: 'yes'
+                            },
+                            {
+                                name: `❌ ${locale.updateConfirmationChoices.no}`,
+                                value: 'no'
+                            }
+                        ],
+                    });
+                
+                    // When the user selects an option
+                    await global.currentPrompt.then(async (result) => {
+
+                        // Cleans the console and shows the logo
+                        process.stdout.write('\u001b[2J\u001b[0;0H');
+                        await splashLogo(client.locale.lib.loaders.splashLogo);
+                
+                        // If the user wants to update the bot, updates it
+                        if (result === 'yes') await updateBot();
+
+                    // When an error occurs
+                    }).catch(async (error) => {
+
+                        // Runs this menu again, passing the error
+                        await client.functions.menus[menuName](error);
+                    });
+                };
 
-                    // Breaks the switch
-                    break;
+            } else {
+
+                // Cleans the console and shows the logo
+                process.stdout.write('\u001b[2J\u001b[0;0H');
+                await splashLogo(client.locale.lib.loaders.splashLogo);
+
+                // Shows a message indicating that the bot is updated to the latest version
+                console.log(`✅ ${locale.alreadyUpdated}: v${latestLocalTag}\n`);
             };
 
-        // When an error occurs
-        }).catch(async (error) => {
+            // Shows the post-update menu
+            await showPostUpdateMenu();
+
+        } catch (error) {
 
-            // Runs this menu again, passing the error
-            await client.functions.menus[menuName](error);
-        });
+            // Shows an error message if one occurred
+            console.error("❌ An error ocurred during the update process:", error.stack);
+        };
 
     } catch (error) {
 

locales/en-US.json

@@ -1349,9 +1349,25 @@
             "update": {
                 "promptMessage": "Select an option",
                 "choices": {
+                    "checkAgain": "Check again",
+                    "switchToBeta": "Switch to Beta",
+                    "switchToStable": "Switch to Stable",
                     "return": "Return"
                 },
-                "errorMessage": "An unexpected error ocurred. Check the logs for more details"
+                "errorMessage": "An unexpected error ocurred. Check the logs for more details",
+                "checkingForUpdates": "Checking if there are new updates",
+                "updatingFromTo": "Updating the bot from {{originVersion}} to {{targetVersion}}",
+                "updatedCorrectly": "The bot has been correctly updated to {{targetVersion}}",
+                "noReleaseNotes": "There are no release notes available for this version",
+                "newVersionAvailable": "Version {{targetVersion}} is available!",
+                "releaseNotes": "Release notes",
+                "releaseNotesError": "An error ocurred while obtaining the release notes",
+                "updateConfirmationPromptMessage": "Would you like to update the bot?",
+                "updateConfirmationChoices": {
+                    "yes": "Yes",
+                    "no": "No"
+                },
+                "alreadyUpdated": "The bot is already updated to the latest version"
             },
             "main": {
                 "promptMessage": "Select an option",