Optional Web Admin Panel

Author: Madriix

README.md

@@ -69,12 +69,35 @@ node bouncer.js somefile.conf &
 ```
 
 #### Keep it running forever (no downtime)
+### immortal
 To keep things running 24/7/365, there's a great app called [immortal](https://immortal.run/).
 
 The immortaldir files are located in this repo (jbnc.yml).
 
 Note: To use immortal on ubuntu, after following the steps on the page, please be sure to `systemctl enable immortaldir` as well as start.
 
+### pm2
+Alternatively, there's pm2. To install:
+```
+npm install pm2 -g
+```
+To prevent logs from becoming too large, simply install:
+```
+pm2 install pm2-logrotate
+```
+No configuration is needed. It works as soon as any application is launched.
+
+To start jbnc:
+```
+cd /home/folder/jbnc
+pm2 start bouncer.js
+or sudo pm2 start bouncer.js (if using SSL certificates from Let's Encrypt directories in /etc)
+```
+To stop:
+```
+Replace "start" with "stop"
+```
+
 ### IRC Client
 You just need to set your password in your jbnc config and then setup your IRC client:
 Just put this in your password:
@@ -142,6 +165,50 @@ SomePassword/buffername
 An example buffername could be 'desktop' and on the mobile phone could be 'mobile.'
 
 
+### Web Admin Panel
+
+A web panel for an administrator is now integrated with jbnc. It is optional.
+To use it, simply install `npm install express express-session` and add the following to the jbnc.conf file:
+```
+  "WebAdminPanel": true,
+  "WebAdminPanelPort": 8889,
+  "WebAdminPanelSecret":"<a_randomly_invented_key>",
+  "WebAdminPanelPassword":"<password>",
+```
+
+Then launch the web page in the browser at `http://127.0.0.1:8889`
+
+The web page is designed to be used with a proxy pass from nginx or httpd.
+
+For nginx, something like:
+
+```
+server {
+    ...
+    location /adminpanel {
+        proxy_pass http://127.0.0.1:8889;
+        ...
+    }
+    ...
+}
+```
+And for httpd:
+
+```
+<VirtualHost *:443>
+    ...
+    ProxyPass /adminpanel http://127.0.0.1:8889
+    ProxyPassReverse /adminpanel http://127.0.0.1:8889
+    ...
+</VirtualHost>
+```
+
+It is recommended to run the web page on an HTTPS-enabled site since both CDNs are HTTPS-enabled.
+
+
+###########
+
+
 ### Copyright
 
 (c) 2020 Andrew Lee <andrew@imperialfamily.com>

bouncer.js

@@ -1,4 +1,4 @@
-// jbnc v0.9.0
+// jbnc v0.9.1
 // Copyright (C) 2020 Andrew Lee <andrew@imperialfamily.com>
 // All Rights Reserved.
 const fs = require('fs');
@@ -39,10 +39,17 @@ global.DEBUG = config.debug ? config.debug : false;
 global.WEBIRCSPECIAL = config.webircSpecial ? config.webircSpecial : false;
 global.IRC_STANDARDS = config.ircStandards ? config.ircStandards : true;
 global.UNCAUGHTEXCEPTION = config.uncaughtException ? config.uncaughtException : true;
+global.WEBADMINPANEL = config.WebAdminPanel ? config.WebAdminPanel : false;
+global.WEBADMINPANEL_PORT = config.WebAdminPanelPort ? config.WebAdminPanelPort : 8889;
+global.WEBADMINPANEL_PASSWORD = config.WebAdminPanelPassword ? config.WebAdminPanelPassword : false;
+global.WEBADMINPANEL_SECRET = config.WebAdminPanelSecret ? config.WebAdminPanelSecret : 'keyboard cat';
 
 global.ircCommandList = new Set(["JOIN", "PART", "QUIT", "MODE", "PING", "NICK", "KICK"]);
 global.ircCommandRedistributeMessagesOnConnect = new Set(["AWAY", "NICK", "ACCOUNT", "PART", "QUIT", "MODE", "KICK", "TOPIC"]);
 
+global.LAST_LAUNCH = new Date().toLocaleString();
+global.LAST_BUG = 'none';
+
 
 // Reload passwords on sighup
 process.on('SIGHUP', function () {
@@ -59,6 +66,7 @@ if (global.UNCAUGHTEXCEPTION) {
   // Prevent BNC from crashing for all other users when an error is caused by a user (with log error and time)
   process.on('uncaughtException', (err, origin) => {
     console.error(`${parseInt(Number(new Date()) / 1000)} # Serious problem (${origin}) - this should not happen but the JBNC is still running. ${err.stack}`);
+    global.LAST_BUG = new Date().toLocaleString();
   });
 }
 

lib/Connections.js

@@ -19,6 +19,15 @@ class Connections {
         }
         return channels;
     }
+
+    userKill(hash) {
+        let disconnected = false;
+        if (this.connections[hash]) {
+            this.connections[hash].end();
+            disconnected=true;
+        }
+        return disconnected;
+    }
 }
 
 module.exports = Connections;

lib/Server.js

@@ -8,6 +8,10 @@ const ClientConnect = require('../lib/ClientConnect');
 const ClientReconnect = require('../lib/ClientReconnect');
 const Connections = require('../lib/Connections');
 
+var WebAdminPanel = null;
+if (global.WEBADMINPANEL)
+    WebAdminPanel = require('../lib/WebAdminPanel');
+
 class Server {
     constructor() {
         this.config = global.config;
@@ -747,6 +751,11 @@ class Server {
         if (global.DEBUG)
             console.log("The Bouncer Server is started. listen()");
 
+        // Web admin panel
+        if (global.WEBADMINPANEL) {
+            const webPanel = new WebAdminPanel(global.WEBADMINPANEL_PORT, this.connections, this.instanceConnections);
+            webPanel.start();
+        }
     }
 
 }

lib/WebAdminPanel.js

@@ -0,0 +1,127 @@
+const http = require('http');
+const express = require('express');
+const session = require('express-session');
+
+class WebAdminPanel {
+  constructor(port, connections, instanceConnections) {
+    this.port = port;
+    this.connections = connections;
+    this.instanceConnections = instanceConnections;
+    this.app = express();
+    this.app.use(express.urlencoded({ extended: true }));
+    this.app.use(express.json());
+    this.setupMiddleware();
+    this.setupRoutes();
+    this.setup404Error();
+  }
+
+  start() {
+    this.server = http.createServer(this.app);
+    this.server.listen(this.port, () => {
+      console.log(`Server WebPanel started and listening on port http://localhost:${this.port}`);
+    });
+  }
+
+  setupMiddleware() {
+    this.app.use(session({
+      secret: global.WEBADMINPANEL_SECRET,
+      resave: false,
+      saveUninitialized: true
+    }));
+  }
+
+  setupRoutes() {
+    this.app.get('/', (req, res) => {
+      res.sendFile(__dirname + '/webadminpanel/login.html');
+    });
+
+    this.app.post('/login', (req, res) => {
+      const { username, password } = req.body;
+      if (!!global.WEBADMINPANEL_SECRET && !!global.BOUNCER_ADMIN && !!global.WEBADMINPANEL_PASSWORD && username === global.BOUNCER_ADMIN && password === global.WEBADMINPANEL_PASSWORD) {
+        req.session.authenticated = true;
+        res.redirect('/dashboard');
+      } else {
+        res.status(401).send('Incorrect username or password');
+      }
+    });
+
+    this.app.get('/dashboard', (req, res) => {
+      if (req.session.authenticated) {
+        res.sendFile(__dirname + '/webadminpanel/dashboard.html');
+      } else {
+        res.redirect('/');
+      }
+    });
+
+    this.app.get('/connections.json', (req, res) => {
+      if (req.session.authenticated) {
+        let connectionsData = [];
+        for (const key in this.connections) {
+          if (Object.hasOwnProperty.call(this.connections, key)) {
+            let connection = {
+              key: key,
+              nick: this.connections[key].nick,
+              channelCount: this.instanceConnections.userChannelCount(key)
+            };
+            connectionsData.push(connection);
+          }
+        }
+        let responseData = {
+          connections: connectionsData,
+          count: connectionsData.length,
+          last_launch: global.LAST_LAUNCH,
+          last_bug: global.LAST_BUG
+        };
+  
+        res.json(responseData);
+      } else {
+        res.redirect('/');
+      }
+
+    });
+
+    this.app.get('/send', (req, res) => {
+      const command = req.query.command;
+      if (req.session.authenticated) {
+        if (command === 'kill') {
+          const key = req.query.key;
+          let disconnected = this.instanceConnections.userKill(key);
+          if(disconnected)
+            res.send("disconnected");
+          else
+            res.send("none disconnected");
+        } 
+        else {
+          res.send("none");
+        }
+      } else {
+        res.redirect('/');
+      }
+
+    });
+  }
+
+  setup404Error() {
+    this.app.use((req, res, next) => {
+      const errorMessage = "Sorry, the page you are looking for doesn't exist.";
+      res.status(404).send(`
+        <!DOCTYPE html>
+        <html lang="en">
+        <head>
+          <meta charset="UTF-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1.0">
+          <title>Error 404</title>
+        </head>
+        <body>
+          <h1>Error 404</h1>
+          <p>${errorMessage}</p>
+        </body>
+        </html>
+      `);
+    });
+  }
+}
+
+
+
+module.exports = WebAdminPanel;

lib/webadminpanel/dashboard.html

@@ -0,0 +1,105 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Jbnc's status</title>
+    <script src="https://cdn.jsdelivr.net/npm/vue@2"></script>
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css">
+    <style>
+        body {
+            padding: 0 20px;
+        }
+    </style>
+</head>
+
+<body>
+    <div id="app">
+        <h1>JBNC</h1>
+        <h4 class="mt-3">Last Launch: {{ last_launch }}</h4>
+        <h5>Last UncaughtException: {{ last_bug }}</h5>
+        <h2 class="mt-4">Connections (total: {{ count }}) :</h2>
+        <ul>
+            <li v-for="connection in connections" :key="connection.id">
+                Key: {{ connection.key }} - Nick: {{ connection.nick }} - Number of channels: {{ connection.channelCount }} - <button class="kill" :data-key="connection.key">Kill</button>
+            </li>
+        </ul>
+    </div>
+
+    <script>
+        const app = new Vue({
+            el: '#app',
+            data: {
+                connections: [],
+                count: 0,
+                last_launch: 'Pending',
+                last_bug: 'Pending'
+            },
+            methods: {
+                fetchData() {
+                    const url = '/connections.json';
+                    fetch(url)
+                        .then(response => {
+                            if (!response.ok) {
+                                throw new Error('The request failed.');
+                            }
+                            return response.json();
+                        })
+                        .then(data => {
+                            this.connections = data.connections;
+                            this.count = data.count;
+                            this.last_launch = data.last_launch;
+                            this.last_bug = data.last_bug;
+                        })
+                        .catch(error => {
+                            console.error('Error while retrieving data:', error);
+                        });
+                }
+            },
+            mounted() {
+                this.fetchData();
+                setInterval(() => {
+                    this.fetchData();
+                }, 5000);
+            }
+        });
+
+        document.addEventListener("DOMContentLoaded", function() {
+            document.addEventListener("click", function(event) {
+                if (event.target.classList.contains('kill')) {
+                    var data = {
+                        command: "kill",
+                        key: event.target.getAttribute('data-key')
+                    };
+
+                    var url = new URL("/send", window.location.origin);
+                    url.search = new URLSearchParams(data);
+
+                    fetch(url.href)
+                        .then(function(response) {
+                            if (response.ok) {
+                                return response.text();
+                            } else {
+                                throw new Error('Error fetching data');
+                            }
+                        })
+                        .then(function(data) {
+                            if (data == "disconnected") {
+                                event.target.innerText="disconnected !";
+                                event.target.disabled=true;
+                            }
+                            else 
+                                console.log("Error !");
+                        })
+                        .catch(function(error) {
+                            console.error("Error sending request:", error);
+                        });
+                }
+            });
+        });
+
+
+
+    </script>
+</body>
+</html>