Merge branch 'master' into issue/1138

# Conflicts:
#	server/server.js

server/auth.js

@@ -12,6 +12,10 @@ const { loginRateLimiter } = require("./rate-limiter");
  * @returns {Promise<Bean|null>}
  */
 exports.login = async function (username, password) {
+    if (typeof username !== "string" || typeof password !== "string") {
+        return null;
+    }
+
     let user = await R.findOne("user", " username = ? AND active = 1 ", [
         username,
     ]);
@@ -31,31 +35,34 @@ exports.login = async function (username, password) {
 };
 
 function myAuthorizer(username, password, callback) {
-    setting("disableAuth").then((result) => {
-        if (result) {
-            callback(null, true);
-        } else {
-            // Login Rate Limit
-            loginRateLimiter.pass(null, 0).then((pass) => {
-                if (pass) {
-                    exports.login(username, password).then((user) => {
-                        callback(null, user != null);
+    // Login Rate Limit
+    loginRateLimiter.pass(null, 0).then((pass) => {
+        if (pass) {
+            exports.login(username, password).then((user) => {
+                callback(null, user != null);
 
-                        if (user == null) {
-                            loginRateLimiter.removeTokens(1);
-                        }
-                    });
-                } else {
-                    callback(null, false);
+                if (user == null) {
+                    loginRateLimiter.removeTokens(1);
                 }
             });
-
+        } else {
+            callback(null, false);
         }
     });
 }
 
-exports.basicAuth = basicAuth({
-    authorizer: myAuthorizer,
-    authorizeAsync: true,
-    challenge: true,
-});
+exports.basicAuth = async function (req, res, next) {
+    const middleware = basicAuth({
+        authorizer: myAuthorizer,
+        authorizeAsync: true,
+        challenge: true,
+    });
+
+    const disabledAuth = await setting("disableAuth");
+
+    if (!disabledAuth) {
+        middleware(req, res, next);
+    } else {
+        next();
+    }
+};

server/check-version.js

@@ -1,5 +1,6 @@
-const { setSetting } = require("./util-server");
+const { setSetting, setting } = require("./util-server");
 const axios = require("axios");
+const compareVersions = require("compare-versions");
 
 exports.version = require("../package.json").version;
 exports.latestVersion = null;
@@ -16,6 +17,19 @@ exports.startInterval = () => {
                 res.data.slow = "1000.0.0";
             }
 
+            if (await setting("checkUpdate") === false) {
+                return;
+            }
+
+            let checkBeta = await setting("checkBeta");
+
+            if (checkBeta && res.data.beta) {
+                if (compareVersions.compare(res.data.beta, res.data.beta, ">")) {
+                    exports.latestVersion = res.data.beta;
+                    return;
+                }
+            }
+
             if (res.data.slow) {
                 exports.latestVersion = res.data.slow;
             }

server/client.js

@@ -83,6 +83,23 @@ async function sendImportantHeartbeatList(socket, monitorID, toUser = false, ove
 
 }
 
+/**
+ * Delivers proxy list
+ *
+ * @param socket
+ * @return {Promise<Bean[]>}
+ */
+async function sendProxyList(socket) {
+    const timeLogger = new TimeLogger();
+
+    const list = await R.find("proxy", " user_id = ? ", [socket.userID]);
+    io.to(socket.userID).emit("proxyList", list.map(bean => bean.export()));
+
+    timeLogger.print("Send Proxy List");
+
+    return list;
+}
+
 async function sendInfo(socket) {
     socket.emit("info", {
         version: checkVersion.version,
@@ -95,6 +112,6 @@ module.exports = {
     sendNotificationList,
     sendImportantHeartbeatList,
     sendHeartbeatList,
-    sendInfo
+    sendProxyList,
+    sendInfo,
 };
-

server/database.js

@@ -53,6 +53,9 @@ class Database {
         "patch-2fa-invalidate-used-token.sql": true,
         "patch-notification_sent_history.sql": true,
         "patch-monitor-basic-auth.sql": true,
+        "patch-status-page.sql": true,
+        "patch-proxy.sql": true,
+        "patch-monitor-expiry-notification.sql": true,
     }
 
     /**
@@ -80,7 +83,7 @@ class Database {
         console.log(`Data Dir: ${Database.dataDir}`);
     }
 
-    static async connect(testMode = false) {
+    static async connect(testMode = false, autoloadModels = true, noLog = false) {
         const acquireConnectionTimeout = 120 * 1000;
 
         const Dialect = require("knex/lib/dialects/sqlite3/index.js");
@@ -110,7 +113,10 @@ class Database {
 
         // Auto map the model to a bean object
         R.freeze(true);
-        await R.autoloadModels("./server/model");
+
+        if (autoloadModels) {
+            await R.autoloadModels("./server/model");
+        }
 
         await R.exec("PRAGMA foreign_keys = ON");
         if (testMode) {
@@ -123,10 +129,17 @@ class Database {
         await R.exec("PRAGMA cache_size = -12000");
         await R.exec("PRAGMA auto_vacuum = FULL");
 
-        console.log("SQLite config:");
-        console.log(await R.getAll("PRAGMA journal_mode"));
-        console.log(await R.getAll("PRAGMA cache_size"));
-        console.log("SQLite Version: " + await R.getCell("SELECT sqlite_version()"));
+        // This ensures that an operating system crash or power failure will not corrupt the database.
+        // FULL synchronous is very safe, but it is also slower.
+        // Read more: https://sqlite.org/pragma.html#pragma_synchronous
+        await R.exec("PRAGMA synchronous = FULL");
+
+        if (!noLog) {
+            console.log("SQLite config:");
+            console.log(await R.getAll("PRAGMA journal_mode"));
+            console.log(await R.getAll("PRAGMA cache_size"));
+            console.log("SQLite Version: " + await R.getCell("SELECT sqlite_version()"));
+        }
     }
 
     static async patch() {
@@ -170,6 +183,7 @@ class Database {
         }
 
         await this.patch2();
+        await this.migrateNewStatusPage();
     }
 
     /**
@@ -211,6 +225,74 @@ class Database {
         await setSetting("databasePatchedFiles", databasePatchedFiles);
     }
 
+    /**
+     * Migrate status page value in setting to "status_page" table
+     * @returns {Promise<void>}
+     */
+    static async migrateNewStatusPage() {
+
+        // Fix 1.13.0 empty slug bug
+        await R.exec("UPDATE status_page SET slug = 'empty-slug-recover' WHERE TRIM(slug) = ''");
+
+        let title = await setting("title");
+
+        if (title) {
+            console.log("Migrating Status Page");
+
+            let statusPageCheck = await R.findOne("status_page", " slug = 'default' ");
+
+            if (statusPageCheck !== null) {
+                console.log("Migrating Status Page - Skip, default slug record is already existing");
+                return;
+            }
+
+            let statusPage = R.dispense("status_page");
+            statusPage.slug = "default";
+            statusPage.title = title;
+            statusPage.description = await setting("description");
+            statusPage.icon = await setting("icon");
+            statusPage.theme = await setting("statusPageTheme");
+            statusPage.published = !!await setting("statusPagePublished");
+            statusPage.search_engine_index = !!await setting("searchEngineIndex");
+            statusPage.show_tags = !!await setting("statusPageTags");
+            statusPage.password = null;
+
+            if (!statusPage.title) {
+                statusPage.title = "My Status Page";
+            }
+
+            if (!statusPage.icon) {
+                statusPage.icon = "";
+            }
+
+            if (!statusPage.theme) {
+                statusPage.theme = "light";
+            }
+
+            let id = await R.store(statusPage);
+
+            await R.exec("UPDATE incident SET status_page_id = ? WHERE status_page_id IS NULL", [
+                id
+            ]);
+
+            await R.exec("UPDATE [group] SET status_page_id = ? WHERE status_page_id IS NULL", [
+                id
+            ]);
+
+            await R.exec("DELETE FROM setting WHERE type = 'statusPage'");
+
+            // Migrate Entry Page if it is status page
+            let entryPage = await setting("entryPage");
+
+            if (entryPage === "statusPage") {
+                await setSetting("entryPage", "statusPage-default", "general");
+            }
+
+            console.log("Migrating Status Page - Done");
+        }
+
+    }
+
     /**
      * Used it patch2() only
      * @param sqlFilename

server/jobs.js

@@ -1,7 +1,7 @@
 const path = require("path");
 const Bree = require("bree");
 const { SHARE_ENV } = require("worker_threads");
-
+let bree;
 const jobs = [
     {
         name: "clear-old-data",
@@ -10,7 +10,7 @@ const jobs = [
 ];
 
 const initBackgroundJobs = function (args) {
-    const bree = new Bree({
+    bree = new Bree({
         root: path.resolve("server", "jobs"),
         jobs,
         worker: {
@@ -26,6 +26,13 @@ const initBackgroundJobs = function (args) {
     return bree;
 };
 
-module.exports = {
-    initBackgroundJobs
+const stopBackgroundJobs = function () {
+    if (bree) {
+        bree.stop();
+    }
+};
+
+module.exports = {
+    initBackgroundJobs,
+    stopBackgroundJobs
 };

server/model/group.js

@@ -3,12 +3,12 @@ const { R } = require("redbean-node");
 
 class Group extends BeanModel {
 
-    async toPublicJSON() {
+    async toPublicJSON(showTags = false) {
         let monitorBeanList = await this.getMonitorList();
         let monitorList = [];
 
         for (let bean of monitorBeanList) {
-            monitorList.push(await bean.toPublicJSON());
+            monitorList.push(await bean.toPublicJSON(showTags));
         }
 
         return {

server/model/monitor.js

@@ -11,6 +11,7 @@ const { tcping, ping, dnsResolve, checkCertificate, checkStatusCode, getTotalCli
 const { R } = require("redbean-node");
 const { BeanModel } = require("redbean-node/dist/bean-model");
 const { Notification } = require("../notification");
+const { Proxy } = require("../proxy");
 const { demoMode } = require("../config");
 const version = require("../../package.json").version;
 const apicache = require("../modules/apicache");
@@ -24,18 +25,22 @@ const apicache = require("../modules/apicache");
 class Monitor extends BeanModel {
 
     /**
-     * Return a object that ready to parse to JSON for public
+     * Return an object that ready to parse to JSON for public
      * Only show necessary data to public
      */
-    async toPublicJSON() {
-        return {
+    async toPublicJSON(showTags = false) {
+        let obj = {
             id: this.id,
             name: this.name,
         };
+        if (showTags) {
+            obj.tags = await this.getTags();
+        }
+        return obj;
     }
 
     /**
-     * Return a object that ready to parse to JSON
+     * Return an object that ready to parse to JSON
      */
     async toJSON() {
 
@@ -49,7 +54,7 @@ class Monitor extends BeanModel {
             notificationIDList[bean.notification_id] = true;
         }
 
-        const tags = await R.getAll("SELECT mt.*, tag.name, tag.color FROM monitor_tag mt JOIN tag ON mt.tag_id = tag.id WHERE mt.monitor_id = ?", [this.id]);
+        const tags = await this.getTags();
 
         return {
             id: this.id,
@@ -69,6 +74,7 @@ class Monitor extends BeanModel {
             interval: this.interval,
             retryInterval: this.retryInterval,
             keyword: this.keyword,
+            expiryNotification: this.isEnabledExpiryNotification(),
             ignoreTls: this.getIgnoreTls(),
             upsideDown: this.isUpsideDown(),
             maxredirects: this.maxredirects,
@@ -77,11 +83,16 @@ class Monitor extends BeanModel {
             dns_resolve_server: this.dns_resolve_server,
             dns_last_result: this.dns_last_result,
             pushToken: this.pushToken,
+            proxyId: this.proxy_id,
             notificationIDList,
             tags: tags,
         };
     }
 
+    async getTags() {
+        return await R.getAll("SELECT mt.*, tag.name, tag.color FROM monitor_tag mt JOIN tag ON mt.tag_id = tag.id WHERE mt.monitor_id = ?", [this.id]);
+    }
+
     /**
      * Encode user and password to Base64 encoding
      * for HTTP "basic" auth, as per RFC-7617
@@ -91,6 +102,10 @@ class Monitor extends BeanModel {
         return Buffer.from(user + ":" + pass).toString("base64");
     }
 
+    isEnabledExpiryNotification() {
+        return Boolean(this.expiryNotification);
+    }
+
     /**
      * Parse to boolean
      * @returns {boolean}
@@ -119,6 +134,19 @@ class Monitor extends BeanModel {
 
         const beat = async () => {
 
+            let beatInterval = this.interval;
+
+            if (! beatInterval) {
+                beatInterval = 1;
+            }
+
+            if (demoMode) {
+                if (beatInterval < 20) {
+                    console.log("beat interval too low, reset to 20s");
+                    beatInterval = 20;
+                }
+            }
+
             // Expose here for prometheus update
             // undefined if not https
             let tlsInfo = undefined;
@@ -160,6 +188,11 @@ class Monitor extends BeanModel {
                         };
                     }
 
+                    const httpsAgentOptions = {
+                        maxCachedSessions: 0, // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
+                        rejectUnauthorized: !this.getIgnoreTls(),
+                    };
+
                     debug(`[${this.name}] Prepare Options for axios`);
 
                     const options = {
@@ -173,17 +206,33 @@ class Monitor extends BeanModel {
                             ...(this.headers ? JSON.parse(this.headers) : {}),
                             ...(basicAuthHeader),
                         },
-                        httpsAgent: new https.Agent({
-                            maxCachedSessions: 0,      // Use Custom agent to disable session reuse (https://github.com/nodejs/node/issues/3940)
-                            rejectUnauthorized: ! this.getIgnoreTls(),
-                        }),
                         maxRedirects: this.maxredirects,
                         validateStatus: (status) => {
                             return checkStatusCode(status, this.getAcceptedStatuscodes());
                         },
                     };
 
+                    if (this.proxy_id) {
+                        const proxy = await R.load("proxy", this.proxy_id);
+
+                        if (proxy && proxy.active) {
+                            const { httpAgent, httpsAgent } = Proxy.createAgents(proxy, {
+                                httpsAgentOptions: httpsAgentOptions,
+                            });
+
+                            options.proxy = false;
+                            options.httpAgent = httpAgent;
+                            options.httpsAgent = httpsAgent;
+                        }
+                    }
+
+                    if (!options.httpsAgent) {
+                        options.httpsAgent = new https.Agent(httpsAgentOptions);
+                    }
+
+                    debug(`[${this.name}] Axios Options: ${JSON.stringify(options)}`);
                     debug(`[${this.name}] Axios Request`);
+
                     let res = await axios.request(options);
                     bean.msg = `${res.status} - ${res.statusText}`;
                     bean.ping = dayjs().valueOf() - startTime;
@@ -196,7 +245,7 @@ class Monitor extends BeanModel {
                             let tlsInfoObject = checkCertificate(res);
                             tlsInfo = await this.updateTlsInfo(tlsInfoObject);
 
-                            if (!this.getIgnoreTls()) {
+                            if (!this.getIgnoreTls() && this.isEnabledExpiryNotification()) {
                                 debug(`[${this.name}] call sendCertNotification`);
                                 await this.sendCertNotification(tlsInfoObject);
                             }
@@ -303,7 +352,7 @@ class Monitor extends BeanModel {
                     } else {
                         // No need to insert successful heartbeat for push type, so end here
                         retries = 0;
-                        this.heartbeatInterval = setTimeout(beat, this.interval * 1000);
+                        this.heartbeatInterval = setTimeout(beat, beatInterval * 1000);
                         return;
                     }
 
@@ -377,8 +426,6 @@ class Monitor extends BeanModel {
                 }
             }
 
-            let beatInterval = this.interval;
-
             debug(`[${this.name}] Check isImportant`);
             let isImportant = Monitor.isImportantBeat(isFirstBeat, previousBeat?.status, bean.status);
 
@@ -422,14 +469,6 @@ class Monitor extends BeanModel {
             previousBeat = bean;
 
             if (! this.isStop) {
-
-                if (demoMode) {
-                    if (beatInterval < 20) {
-                        console.log("beat interval too low, reset to 20s");
-                        beatInterval = 20;
-                    }
-                }
-
                 debug(`[${this.name}] SetTimeout for next check.`);
                 this.heartbeatInterval = setTimeout(safeBeat, beatInterval * 1000);
             } else {
@@ -466,6 +505,12 @@ class Monitor extends BeanModel {
     stop() {
         clearTimeout(this.heartbeatInterval);
         this.isStop = true;
+
+        this.prometheus().remove();
+    }
+
+    prometheus() {
+        return new Prometheus(this);
     }
 
     /**

server/model/proxy.js

@@ -0,0 +1,21 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+
+class Proxy extends BeanModel {
+    toJSON() {
+        return {
+            id: this._id,
+            userId: this._user_id,
+            protocol: this._protocol,
+            host: this._host,
+            port: this._port,
+            auth: !!this._auth,
+            username: this._username,
+            password: this._password,
+            active: !!this._active,
+            default: !!this._default,
+            createdDate: this._created_date,
+        };
+    }
+}
+
+module.exports = Proxy;

server/model/status_page.js

@@ -0,0 +1,126 @@
+const { BeanModel } = require("redbean-node/dist/bean-model");
+const { R } = require("redbean-node");
+
+class StatusPage extends BeanModel {
+
+    static domainMappingList = { };
+
+    /**
+     * Return object like this: { "test-uptime.kuma.pet": "default" }
+     * @returns {Promise<void>}
+     */
+    static async loadDomainMappingList() {
+        StatusPage.domainMappingList = await R.getAssoc(`
+            SELECT domain, slug
+            FROM status_page, status_page_cname
+            WHERE status_page.id = status_page_cname.status_page_id
+        `);
+    }
+
+    static async sendStatusPageList(io, socket) {
+        let result = {};
+
+        let list = await R.findAll("status_page", " ORDER BY title ");
+
+        for (let item of list) {
+            result[item.id] = await item.toJSON();
+        }
+
+        io.to(socket.userID).emit("statusPageList", result);
+        return list;
+    }
+
+    async updateDomainNameList(domainNameList) {
+
+        if (!Array.isArray(domainNameList)) {
+            throw new Error("Invalid array");
+        }
+
+        let trx = await R.begin();
+
+        await trx.exec("DELETE FROM status_page_cname WHERE status_page_id = ?", [
+            this.id,
+        ]);
+
+        try {
+            for (let domain of domainNameList) {
+                if (typeof domain !== "string") {
+                    throw new Error("Invalid domain");
+                }
+
+                if (domain.trim() === "") {
+                    continue;
+                }
+
+                // If the domain name is used in another status page, delete it
+                await trx.exec("DELETE FROM status_page_cname WHERE domain = ?", [
+                    domain,
+                ]);
+
+                let mapping = trx.dispense("status_page_cname");
+                mapping.status_page_id = this.id;
+                mapping.domain = domain;
+                await trx.store(mapping);
+            }
+            await trx.commit();
+        } catch (error) {
+            await trx.rollback();
+            throw error;
+        }
+    }
+
+    getDomainNameList() {
+        let domainList = [];
+        for (let domain in StatusPage.domainMappingList) {
+            let s = StatusPage.domainMappingList[domain];
+
+            if (this.slug === s) {
+                domainList.push(domain);
+            }
+        }
+        return domainList;
+    }
+
+    async toJSON() {
+        return {
+            id: this.id,
+            slug: this.slug,
+            title: this.title,
+            description: this.description,
+            icon: this.getIcon(),
+            theme: this.theme,
+            published: !!this.published,
+            showTags: !!this.show_tags,
+            domainNameList: this.getDomainNameList(),
+        };
+    }
+
+    async toPublicJSON() {
+        return {
+            slug: this.slug,
+            title: this.title,
+            description: this.description,
+            icon: this.getIcon(),
+            theme: this.theme,
+            published: !!this.published,
+            showTags: !!this.show_tags,
+        };
+    }
+
+    static async slugToID(slug) {
+        return await R.getCell("SELECT id FROM status_page WHERE slug = ? ", [
+            slug
+        ]);
+    }
+
+    getIcon() {
+        if (!this.icon) {
+            return "/icon.svg";
+        } else {
+            return this.icon;
+        }
+    }
+
+}
+
+module.exports = StatusPage;

server/notification-providers/alerta.js

@@ -0,0 +1,67 @@
+const NotificationProvider = require("./notification-provider");
+const { DOWN, UP } = require("../../src/util");
+const axios = require("axios");
+
+class Alerta extends NotificationProvider {
+
+    name = "alerta";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            let alertaUrl = `${notification.alertaApiEndpoint}`;
+            let config = {
+                headers: {
+                    "Content-Type": "application/json;charset=UTF-8",
+                    "Authorization": "Key " + notification.alertaApiKey,
+                }
+            };
+            let data = {
+                environment: notification.alertaEnvironment,
+                severity: "critical",
+                correlate: [],
+                service: [ "UptimeKuma" ],
+                value: "Timeout",
+                tags: [ "uptimekuma" ],
+                attributes: {},
+                origin: "uptimekuma",
+                type: "exceptionAlert",
+            };
+
+            if (heartbeatJSON == null) {
+                let postData = Object.assign({
+                    event: "msg",
+                    text: msg,
+                    group: "uptimekuma-msg",
+                    resource: "Message",
+                }, data);
+
+                await axios.post(alertaUrl, postData, config);
+            } else {
+                let datadup = Object.assign( {
+                    correlate: ["service_up", "service_down"],
+                    event: monitorJSON["type"],
+                    group: "uptimekuma-" + monitorJSON["type"],
+                    resource: monitorJSON["name"],
+                }, data );
+
+                if (heartbeatJSON["status"] == DOWN) {
+                    datadup.severity = notification.alertaAlertState; // critical
+                    datadup.text = "Service " + monitorJSON["type"] + " is down.";
+                    await axios.post(alertaUrl, datadup, config);
+                } else if (heartbeatJSON["status"] == UP) {
+                    datadup.severity = notification.alertaRecoverState; // cleaned
+                    datadup.text = "Service " + monitorJSON["type"] + " is up.";
+                    await axios.post(alertaUrl, datadup, config);
+                }
+            }
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+
+    }
+}
+
+module.exports = Alerta;

server/notification-providers/gorush.js

@@ -0,0 +1,42 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class Gorush extends NotificationProvider {
+
+    name = "gorush";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        let platformMapping = {
+            "ios": 1,
+            "android": 2,
+            "huawei": 3,
+        };
+
+        try {
+            let data = {
+                "notifications": [
+                    {
+                        "tokens": [notification.gorushDeviceToken],
+                        "platform": platformMapping[notification.gorushPlatform],
+                        "message": msg,
+                        // Optional
+                        "title": notification.gorushTitle,
+                        "priority": notification.gorushPriority,
+                        "retry": parseInt(notification.gorushRetry) || 0,
+                        "topic": notification.gorushTopic,
+                    }
+                ]
+            };
+            let config = {};
+
+            await axios.post(`${notification.gorushServerURL}/api/push`, data, config);
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error);
+        }
+    }
+}
+
+module.exports = Gorush;

server/notification-providers/mattermost.js

@@ -15,12 +15,17 @@ class Mattermost extends NotificationProvider {
                 let mattermostTestData = {
                     username: mattermostUserName,
                     text: msg,
-                }
-                await axios.post(notification.mattermostWebhookUrl, mattermostTestData)
+                };
+                await axios.post(notification.mattermostWebhookUrl, mattermostTestData);
                 return okMsg;
             }
 
-            const mattermostChannel = notification.mattermostchannel;
+            let mattermostChannel;
+
+            if (typeof notification.mattermostchannel === "string") {
+                mattermostChannel = notification.mattermostchannel.toLowerCase();
+            }
+
             const mattermostIconEmoji = notification.mattermosticonemo;
             const mattermostIconUrl = notification.mattermosticonurl;
 

server/notification-providers/pushover.js

@@ -9,36 +9,31 @@ class Pushover extends NotificationProvider {
         let okMsg = "Sent Successfully.";
         let pushoverlink = "https://api.pushover.net/1/messages.json";
 
+        let data = {
+            "message": "<b>Uptime Kuma Alert</b>\n\n<b>Message</b>:" + msg,
+            "user": notification.pushoveruserkey,
+            "token": notification.pushoverapptoken,
+            "sound": notification.pushoversounds,
+            "priority": notification.pushoverpriority,
+            "title": notification.pushovertitle,
+            "retry": "30",
+            "expire": "3600",
+            "html": 1,
+        };
+
+        if (notification.pushoverdevice) {
+            data.device = notification.pushoverdevice;
+        }
+
         try {
             if (heartbeatJSON == null) {
-                let data = {
-                    "message": msg,
-                    "user": notification.pushoveruserkey,
-                    "token": notification.pushoverapptoken,
-                    "sound": notification.pushoversounds,
-                    "priority": notification.pushoverpriority,
-                    "title": notification.pushovertitle,
-                    "retry": "30",
-                    "expire": "3600",
-                    "html": 1,
-                };
+                await axios.post(pushoverlink, data);
+                return okMsg;
+            } else {
+                data.message += "\n<b>Time (UTC)</b>:" + heartbeatJSON["time"];
                 await axios.post(pushoverlink, data);
                 return okMsg;
             }
-
-            let data = {
-                "message": "<b>Uptime Kuma Alert</b>\n\n<b>Message</b>:" + msg + "\n<b>Time (UTC)</b>:" + heartbeatJSON["time"],
-                "user": notification.pushoveruserkey,
-                "token": notification.pushoverapptoken,
-                "sound": notification.pushoversounds,
-                "priority": notification.pushoverpriority,
-                "title": notification.pushovertitle,
-                "retry": "30",
-                "expire": "3600",
-                "html": 1,
-            };
-            await axios.post(pushoverlink, data);
-            return okMsg;
         } catch (error) {
             this.throwGeneralAxiosError(error);
         }

server/notification-providers/techulus-push.js

@@ -0,0 +1,23 @@
+const NotificationProvider = require("./notification-provider");
+const axios = require("axios");
+
+class TechulusPush extends NotificationProvider {
+
+    name = "PushByTechulus";
+
+    async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
+        let okMsg = "Sent Successfully.";
+
+        try {
+            await axios.post(`https://push.techulus.com/api/v1/notify/${notification.pushAPIKey}`, {
+                "title": "Uptime-Kuma",
+                "body": msg,
+            })
+            return okMsg;
+        } catch (error) {
+            this.throwGeneralAxiosError(error)
+        }
+    }
+}
+
+module.exports = TechulusPush;

server/notification.js

@@ -12,6 +12,7 @@ const ClickSendSMS = require("./notification-providers/clicksendsms");
 const Pushbullet = require("./notification-providers/pushbullet");
 const Pushover = require("./notification-providers/pushover");
 const Pushy = require("./notification-providers/pushy");
+const TechulusPush = require("./notification-providers/techulus-push");
 const RocketChat = require("./notification-providers/rocket-chat");
 const Signal = require("./notification-providers/signal");
 const Slack = require("./notification-providers/slack");
@@ -27,6 +28,8 @@ const SerwerSMS = require("./notification-providers/serwersms");
 const Stackfield = require("./notification-providers/stackfield");
 const WeCom = require("./notification-providers/wecom");
 const GoogleChat = require("./notification-providers/google-chat");
+const Gorush = require("./notification-providers/gorush");
+const Alerta = require("./notification-providers/alerta");
 
 class Notification {
 
@@ -55,6 +58,7 @@ class Notification {
             new Pushbullet(),
             new Pushover(),
             new Pushy(),
+            new TechulusPush(),
             new RocketChat(),
             new Signal(),
             new Slack(),
@@ -65,7 +69,9 @@ class Notification {
             new SerwerSMS(),
             new Stackfield(),
             new WeCom(),
-            new GoogleChat()
+            new GoogleChat(),
+            new Gorush(),
+            new Alerta(),
         ];
 
         for (let item of list) {

server/ping-lite.js

@@ -48,7 +48,7 @@ function Ping(host, options) {
         this._args = (options.args) ? options.args : [ "-n", "-t", timeout, "-c", "1", host ];
         this._regmatch = /=([0-9.]+?) ms/;
 
-    } else if (util.FBSD) {
+    } else if (util.BSD) {
         this._bin = "/sbin/ping";
 
         const defaultArgs = [ "-n", "-t", timeout, "-c", "1", host ];

server/prometheus.js

@@ -60,7 +60,9 @@ class Prometheus {
             }
 
             try {
-                monitor_cert_days_remaining.set(this.monitorLabelValues, tlsInfo.certInfo.daysRemaining);
+                if (tlsInfo.certInfo != null) {
+                    monitor_cert_days_remaining.set(this.monitorLabelValues, tlsInfo.certInfo.daysRemaining);
+                }
             } catch (e) {
                 console.error(e);
             }
@@ -84,6 +86,16 @@ class Prometheus {
         }
     }
 
+    remove() {
+        try {
+            monitor_cert_days_remaining.remove(this.monitorLabelValues);
+            monitor_cert_is_valid.remove(this.monitorLabelValues);
+            monitor_response_time.remove(this.monitorLabelValues);
+            monitor_status.remove(this.monitorLabelValues);
+        } catch (e) {
+            console.error(e);
+        }
+    }
 }
 
 module.exports = {

server/proxy.js

@@ -0,0 +1,187 @@
+const { R } = require("redbean-node");
+const HttpProxyAgent = require("http-proxy-agent");
+const HttpsProxyAgent = require("https-proxy-agent");
+const SocksProxyAgent = require("socks-proxy-agent");
+const { debug } = require("../src/util");
+const server = require("./server");
+
+class Proxy {
+
+    static SUPPORTED_PROXY_PROTOCOLS = ["http", "https", "socks", "socks5", "socks4"]
+
+    /**
+     * Saves and updates given proxy entity
+     *
+     * @param proxy
+     * @param proxyID
+     * @param userID
+     * @return {Promise<Bean>}
+     */
+    static async save(proxy, proxyID, userID) {
+        let bean;
+
+        if (proxyID) {
+            bean = await R.findOne("proxy", " id = ? AND user_id = ? ", [proxyID, userID]);
+
+            if (!bean) {
+                throw new Error("proxy not found");
+            }
+
+        } else {
+            bean = R.dispense("proxy");
+        }
+
+        // Make sure given proxy protocol is supported
+        if (!this.SUPPORTED_PROXY_PROTOCOLS.includes(proxy.protocol)) {
+            throw new Error(`
+                Unsupported proxy protocol "${proxy.protocol}.
+                Supported protocols are ${this.SUPPORTED_PROXY_PROTOCOLS.join(", ")}."`
+            );
+        }
+
+        // When proxy is default update deactivate old default proxy
+        if (proxy.default) {
+            await R.exec("UPDATE proxy SET `default` = 0 WHERE `default` = 1");
+        }
+
+        bean.user_id = userID;
+        bean.protocol = proxy.protocol;
+        bean.host = proxy.host;
+        bean.port = proxy.port;
+        bean.auth = proxy.auth;
+        bean.username = proxy.username;
+        bean.password = proxy.password;
+        bean.active = proxy.active || true;
+        bean.default = proxy.default || false;
+
+        await R.store(bean);
+
+        if (proxy.applyExisting) {
+            await applyProxyEveryMonitor(bean.id, userID);
+        }
+
+        return bean;
+    }
+
+    /**
+     * Deletes proxy with given id and removes it from monitors
+     *
+     * @param proxyID
+     * @param userID
+     * @return {Promise<void>}
+     */
+    static async delete(proxyID, userID) {
+        const bean = await R.findOne("proxy", " id = ? AND user_id = ? ", [proxyID, userID]);
+
+        if (!bean) {
+            throw new Error("proxy not found");
+        }
+
+        // Delete removed proxy from monitors if exists
+        await R.exec("UPDATE monitor SET proxy_id = null WHERE proxy_id = ?", [proxyID]);
+
+        // Delete proxy from list
+        await R.trash(bean);
+    }
+
+    /**
+     * Create HTTP and HTTPS agents related with given proxy bean object
+     *
+     * @param proxy proxy bean object
+     * @param options http and https agent options
+     * @return {{httpAgent: Agent, httpsAgent: Agent}}
+     */
+    static createAgents(proxy, options) {
+        const { httpAgentOptions, httpsAgentOptions } = options || {};
+        let agent;
+        let httpAgent;
+        let httpsAgent;
+
+        const proxyOptions = {
+            protocol: proxy.protocol,
+            host: proxy.host,
+            port: proxy.port,
+        };
+
+        if (proxy.auth) {
+            proxyOptions.auth = `${proxy.username}:${proxy.password}`;
+        }
+
+        debug(`Proxy Options: ${JSON.stringify(proxyOptions)}`);
+        debug(`HTTP Agent Options: ${JSON.stringify(httpAgentOptions)}`);
+        debug(`HTTPS Agent Options: ${JSON.stringify(httpsAgentOptions)}`);
+
+        switch (proxy.protocol) {
+            case "http":
+            case "https":
+                httpAgent = new HttpProxyAgent({
+                    ...httpAgentOptions || {},
+                    ...proxyOptions
+                });
+
+                httpsAgent = new HttpsProxyAgent({
+                    ...httpsAgentOptions || {},
+                    ...proxyOptions,
+                });
+                break;
+            case "socks":
+            case "socks5":
+            case "socks4":
+                agent = new SocksProxyAgent({
+                    ...httpAgentOptions,
+                    ...httpsAgentOptions,
+                    ...proxyOptions,
+                });
+
+                httpAgent = agent;
+                httpsAgent = agent;
+                break;
+
+            default: throw new Error(`Unsupported proxy protocol provided. ${proxy.protocol}`);
+        }
+
+        return {
+            httpAgent,
+            httpsAgent
+        };
+    }
+
+    /**
+     * Reload proxy settings for current monitors
+     * @returns {Promise<void>}
+     */
+    static async reloadProxy() {
+        let updatedList = await R.getAssoc("SELECT id, proxy_id FROM monitor");
+
+        for (let monitorID in server.monitorList) {
+            let monitor = server.monitorList[monitorID];
+
+            if (updatedList[monitorID]) {
+                monitor.proxy_id = updatedList[monitorID].proxy_id;
+            }
+        }
+    }
+}
+
+/**
+ * Applies given proxy id to monitors
+ *
+ * @param proxyID
+ * @param userID
+ * @return {Promise<void>}
+ */
+async function applyProxyEveryMonitor(proxyID, userID) {
+    // Find all monitors with id and proxy id
+    const monitors = await R.getAll("SELECT id, proxy_id FROM monitor WHERE user_id = ?", [userID]);
+
+    // Update proxy id not match with given proxy id
+    for (const monitor of monitors) {
+        if (monitor.proxy_id !== proxyID) {
+            await R.exec("UPDATE monitor SET proxy_id = ? WHERE id = ?", [proxyID, monitor.id]);
+        }
+    }
+}
+
+module.exports = {
+    Proxy,
+};

server/rate-limiter.js

@@ -34,6 +34,14 @@ const loginRateLimiter = new KumaRateLimiter({
     errorMessage: "Too frequently, try again later."
 });
 
+const twoFaRateLimiter = new KumaRateLimiter({
+    tokensPerInterval: 30,
+    interval: "minute",
+    fireImmediately: true,
+    errorMessage: "Too frequently, try again later."
+});
+
 module.exports = {
-    loginRateLimiter
+    loginRateLimiter,
+    twoFaRateLimiter,
 };

server/routers/api-router.js

@@ -6,14 +6,25 @@ const apicache = require("../modules/apicache");
 const Monitor = require("../model/monitor");
 const dayjs = require("dayjs");
 const { UP, flipStatus, debug } = require("../../src/util");
+const StatusPage = require("../model/status_page");
 let router = express.Router();
 
 let cache = apicache.middleware;
 let io = server.io;
 
-router.get("/api/entry-page", async (_, response) => {
+router.get("/api/entry-page", async (request, response) => {
     allowDevAllOrigin(response);
-    response.json(server.entryPage);
+
+    let result = { };
+
+    if (request.hostname in StatusPage.domainMappingList) {
+        result.type = "statusPageMatchedDomain";
+        result.statusPageSlug = StatusPage.domainMappingList[request.hostname];
+    } else {
+        result.type = "entryPage";
+        result.entryPage = server.entryPage;
+    }
+    response.json(result);
 });
 
 router.get("/api/push/:pushToken", async (request, response) => {
@@ -82,110 +93,80 @@ router.get("/api/push/:pushToken", async (request, response) => {
     }
 });
 
-// Status Page Config
-router.get("/api/status-page/config", async (_request, response) => {
+// Status page config, incident, monitor list
+router.get("/api/status-page/:slug", cache("5 minutes"), async (request, response) => {
     allowDevAllOrigin(response);
+    let slug = request.params.slug;
 
-    let config = await getSettings("statusPage");
+    // Get Status Page
+    let statusPage = await R.findOne("status_page", " slug = ? ", [
+        slug
+    ]);
 
-    if (! config.statusPageTheme) {
-        config.statusPageTheme = "light";
+    if (!statusPage) {
+        response.statusCode = 404;
+        response.json({
+            msg: "Not Found"
+        });
+        return;
     }
 
-    if (! config.statusPagePublished) {
-        config.statusPagePublished = true;
-    }
-
-    if (! config.statusPageTags) {
-        config.statusPageTags = false;
-    }
-
-    if (! config.title) {
-        config.title = "Uptime Kuma";
-    }
-
-    response.json(config);
-});
-
-// Status Page - Get the current Incident
-// Can fetch only if published
-router.get("/api/status-page/incident", async (_, response) => {
-    allowDevAllOrigin(response);
-
     try {
-        await checkPublished();
-
-        let incident = await R.findOne("incident", " pin = 1 AND active = 1");
+        // Incident
+        let incident = await R.findOne("incident", " pin = 1 AND active = 1 AND status_page_id = ? ", [
+            statusPage.id,
+        ]);
 
         if (incident) {
             incident = incident.toPublicJSON();
         }
 
+        // Public Group List
+        const publicGroupList = [];
+        const showTags = !!statusPage.show_tags;
+        debug("Show Tags???" + showTags);
+        const list = await R.find("group", " public = 1 AND status_page_id = ? ORDER BY weight ", [
+            statusPage.id
+        ]);
+
+        for (let groupBean of list) {
+            let monitorGroup = await groupBean.toPublicJSON(showTags);
+            publicGroupList.push(monitorGroup);
+        }
+
+        // Response
         response.json({
-            ok: true,
+            config: await statusPage.toPublicJSON(),
             incident,
+            publicGroupList
         });
 
     } catch (error) {
         send403(response, error.message);
     }
-});
 
-// Status Page - Monitor List
-// Can fetch only if published
-router.get("/api/status-page/monitor-list", cache("5 minutes"), async (_request, response) => {
-    allowDevAllOrigin(response);
-
-    try {
-        await checkPublished();
-        const publicGroupList = [];
-        const tagsVisible = (await getSettings("statusPage")).statusPageTags;
-        const list = await R.find("group", " public = 1 ORDER BY weight ");
-        for (let groupBean of list) {
-            let monitorGroup = await groupBean.toPublicJSON();
-            if (tagsVisible) {
-                monitorGroup.monitorList = await Promise.all(monitorGroup.monitorList.map(async (monitor) => {
-                    // Includes tags as an array in response, allows for tags to be displayed on public status page
-                    const tags = await R.getAll(
-                            `SELECT monitor_tag.monitor_id, monitor_tag.value, tag.name, tag.color
-                            FROM monitor_tag
-                            JOIN tag
-                            ON monitor_tag.tag_id = tag.id
-                            WHERE monitor_tag.monitor_id = ?`, [monitor.id]
-                    );
-                    return {
-                        ...monitor,
-                        tags: tags
-                    };
-                }));
-            }
-
-            publicGroupList.push(monitorGroup);
-        }
-
-        response.json(publicGroupList);
-
-    } catch (error) {
-        send403(response, error.message);
-    }
 });
 
 // Status Page Polling Data
 // Can fetch only if published
-router.get("/api/status-page/heartbeat", cache("5 minutes"), async (_request, response) => {
+router.get("/api/status-page/heartbeat/:slug", cache("1 minutes"), async (request, response) => {
     allowDevAllOrigin(response);
 
     try {
-        await checkPublished();
-
         let heartbeatList = {};
         let uptimeList = {};
 
+        let slug = request.params.slug;
+        let statusPageID = await StatusPage.slugToID(slug);
+
         let monitorIDList = await R.getCol(`
             SELECT monitor_group.monitor_id FROM monitor_group, \`group\`
             WHERE monitor_group.group_id = \`group\`.id
             AND public = 1
-        `);
+            AND \`group\`.status_page_id = ?
+        `, [
+            statusPageID
+        ]);
 
         for (let monitorID of monitorIDList) {
             let list = await R.getAll(`
@@ -214,22 +195,12 @@ router.get("/api/status-page/heartbeat", cache("5 minutes"), async (_request, re
     }
 });
 
-async function checkPublished() {
-    if (! await isPublished()) {
-        throw new Error("The status page is not published");
-    }
-}
-
 /**
  * Default is published
  * @returns {Promise<boolean>}
  */
 async function isPublished() {
-    const value = await setting("statusPagePublished");
-    if (value === null) {
-        return true;
-    }
-    return value;
+    return true;
 }
 
 function send403(res, msg = "") {

server/server.js

@@ -1,4 +1,15 @@
 console.log("Welcome to Uptime Kuma");
+
+// Check Node.js Version
+const nodeVersion = parseInt(process.versions.node.split(".")[0]);
+const requiredVersion = 14;
+console.log(`Your Node.js version: ${nodeVersion}`);
+
+if (nodeVersion < requiredVersion) {
+    console.error(`Error: Your Node.js version is not supported, please upgrade to Node.js >= ${requiredVersion}.`);
+    process.exit(-1);
+}
+
 const args = require("args-parser")(process.argv);
 const { sleep, debug, getRandomInt, genSecret } = require("../src/util");
 const config = require("./config");
@@ -37,22 +48,46 @@ debug("Importing 2FA Modules");
 const notp = require("notp");
 const base32 = require("thirty-two");
 
+/**
+ * `module.exports` (alias: `server`) should be inside this class, in order to avoid circular dependency issue.
+ * @type {UptimeKumaServer}
+ */
+class UptimeKumaServer {
+    /**
+     * Main monitor list
+     * @type {{}}
+     */
+    monitorList = {};
+    entryPage = "dashboard";
+
+    async sendMonitorList(socket) {
+        let list = await getMonitorJSONList(socket.userID);
+        io.to(socket.userID).emit("monitorList", list);
+        return list;
+    }
+}
+
+const server = module.exports = new UptimeKumaServer();
+
 console.log("Importing this project modules");
 debug("Importing Monitor");
 const Monitor = require("./model/monitor");
 debug("Importing Settings");
-const { getSettings, setSettings, setting, initJWTSecret, checkLogin, startUnitTest, FBSD, errorLog } = require("./util-server");
+const { getSettings, setSettings, setting, initJWTSecret, checkLogin, startUnitTest, FBSD, errorLog, doubleCheckPassword } = require("./util-server");
 
 debug("Importing Notification");
 const { Notification } = require("./notification");
 Notification.init();
 
+debug("Importing Proxy");
+const { Proxy } = require("./proxy");
+
 debug("Importing Database");
 const Database = require("./database");
 
 debug("Importing Background Jobs");
-const { initBackgroundJobs } = require("./jobs");
-const { loginRateLimiter } = require("./rate-limiter");
+const { initBackgroundJobs, stopBackgroundJobs } = require("./jobs");
+const { loginRateLimiter, twoFaRateLimiter } = require("./rate-limiter");
 
 const { basicAuth } = require("./auth");
 const { login } = require("./auth");
@@ -79,6 +114,7 @@ const port = [args.port, process.env.UPTIME_KUMA_PORT, process.env.PORT, 3001]
 const sslKey = args["ssl-key"] || process.env.UPTIME_KUMA_SSL_KEY || process.env.SSL_KEY || undefined;
 const sslCert = args["ssl-cert"] || process.env.UPTIME_KUMA_SSL_CERT || process.env.SSL_CERT || undefined;
 const disableFrameSameOrigin = args["disable-frame-sameorigin"] || !!process.env.UPTIME_KUMA_DISABLE_FRAME_SAMEORIGIN || false;
+const cloudflaredToken = args["cloudflared-token"] || process.env.UPTIME_KUMA_CLOUDFLARED_TOKEN || undefined;
 
 // 2FA / notp verification defaults
 const twofa_verification_opts = {
@@ -99,27 +135,30 @@ if (config.demoMode) {
 console.log("Creating express and socket.io instance");
 const app = express();
 
-let server;
+let httpServer;
 
 if (sslKey && sslCert) {
     console.log("Server Type: HTTPS");
-    server = https.createServer({
+    httpServer = https.createServer({
         key: fs.readFileSync(sslKey),
         cert: fs.readFileSync(sslCert)
     }, app);
 } else {
     console.log("Server Type: HTTP");
-    server = http.createServer(app);
+    httpServer = http.createServer(app);
 }
 
-const io = new Server(server);
+const io = new Server(httpServer);
 module.exports.io = io;
 
 // Must be after io instantiation
-const { sendNotificationList, sendHeartbeatList, sendImportantHeartbeatList, sendInfo } = require("./client");
+const { sendNotificationList, sendHeartbeatList, sendImportantHeartbeatList, sendInfo, sendProxyList } = require("./client");
 const { statusPageSocketHandler } = require("./socket-handlers/status-page-socket-handler");
 const databaseSocketHandler = require("./socket-handlers/database-socket-handler");
 const TwoFA = require("./2fa");
+const StatusPage = require("./model/status_page");
+const { cloudflaredSocketHandler, autoStart: cloudflaredAutoStart, stop: cloudflaredStop } = require("./socket-handlers/cloudflared-socket-handler");
+const { proxySocketHandler } = require("./socket-handlers/proxy-socket-handler");
 
 app.use(express.json());
 
@@ -144,12 +183,6 @@ let totalClient = 0;
  */
 let jwtSecret = null;
 
-/**
- * Main monitor list
- * @type {{}}
- */
-let monitorList = {};
-
 /**
  * Show Setup Page
  * @type {boolean}
@@ -172,13 +205,12 @@ try {
     }
 }
 
-exports.entryPage = "dashboard";
-
 (async () => {
     Database.init(args);
     await initDatabase(testMode);
 
     exports.entryPage = await setting("entryPage");
+    await StatusPage.loadDomainMappingList();
 
     console.log("Adding route");
 
@@ -187,9 +219,14 @@ exports.entryPage = "dashboard";
     // ***************************
 
     // Entry Page
-    app.get("/", async (_request, response) => {
-        if (exports.entryPage === "statusPage") {
-            response.redirect("/status");
+    app.get("/", async (request, response) => {
+        debug(`Request Domain: ${request.hostname}`);
+
+        if (request.hostname in StatusPage.domainMappingList) {
+            debug("This is a status page domain");
+            response.send(indexHTML);
+        } else if (exports.entryPage && exports.entryPage.startsWith("statusPage-")) {
+            response.redirect("/status/" + exports.entryPage.replace("statusPage-", ""));
         } else {
             response.redirect("/dashboard");
         }
@@ -292,6 +329,15 @@ exports.entryPage = "dashboard";
         socket.on("login", async (data, callback) => {
             console.log("Login");
 
+            // Checking
+            if (typeof callback !== "function") {
+                return;
+            }
+
+            if (!data) {
+                return;
+            }
+
             // Login Rate Limit
             if (! await loginRateLimiter.pass(callback)) {
                 return;
@@ -350,14 +396,27 @@ exports.entryPage = "dashboard";
         });
 
         socket.on("logout", async (callback) => {
+            // Rate Limit
+            if (! await loginRateLimiter.pass(callback)) {
+                return;
+            }
+
             socket.leave(socket.userID);
             socket.userID = null;
-            callback();
+
+            if (typeof callback === "function") {
+                callback();
+            }
         });
 
-        socket.on("prepare2FA", async (callback) => {
+        socket.on("prepare2FA", async (currentPassword, callback) => {
             try {
+                if (! await twoFaRateLimiter.pass(callback)) {
+                    return;
+                }
+
                 checkLogin(socket);
+                await doubleCheckPassword(socket, currentPassword);
 
                 let user = await R.findOne("user", " id = ? AND active = 1 ", [
                     socket.userID,
@@ -392,14 +451,19 @@ exports.entryPage = "dashboard";
             } catch (error) {
                 callback({
                     ok: false,
-                    msg: "Error while trying to prepare 2FA.",
+                    msg: error.message,
                 });
             }
         });
 
-        socket.on("save2FA", async (callback) => {
+        socket.on("save2FA", async (currentPassword, callback) => {
             try {
+                if (! await twoFaRateLimiter.pass(callback)) {
+                    return;
+                }
+
                 checkLogin(socket);
+                await doubleCheckPassword(socket, currentPassword);
 
                 await R.exec("UPDATE `user` SET twofa_status = 1 WHERE id = ? ", [
                     socket.userID,
@@ -412,14 +476,19 @@ exports.entryPage = "dashboard";
             } catch (error) {
                 callback({
                     ok: false,
-                    msg: "Error while trying to change 2FA.",
+                    msg: error.message,
                 });
             }
         });
 
-        socket.on("disable2FA", async (callback) => {
+        socket.on("disable2FA", async (currentPassword, callback) => {
             try {
+                if (! await twoFaRateLimiter.pass(callback)) {
+                    return;
+                }
+
                 checkLogin(socket);
+                await doubleCheckPassword(socket, currentPassword);
                 await TwoFA.disable2FA(socket.userID);
 
                 callback({
@@ -429,36 +498,47 @@ exports.entryPage = "dashboard";
             } catch (error) {
                 callback({
                     ok: false,
-                    msg: "Error while trying to change 2FA.",
+                    msg: error.message,
                 });
             }
         });
 
-        socket.on("verifyToken", async (token, callback) => {
-            let user = await R.findOne("user", " id = ? AND active = 1 ", [
-                socket.userID,
-            ]);
+        socket.on("verifyToken", async (token, currentPassword, callback) => {
+            try {
+                checkLogin(socket);
+                await doubleCheckPassword(socket, currentPassword);
 
-            let verify = notp.totp.verify(token, user.twofa_secret, twofa_verification_opts);
+                let user = await R.findOne("user", " id = ? AND active = 1 ", [
+                    socket.userID,
+                ]);
 
-            if (user.twofa_last_token !== token && verify) {
-                callback({
-                    ok: true,
-                    valid: true,
-                });
-            } else {
+                let verify = notp.totp.verify(token, user.twofa_secret, twofa_verification_opts);
+
+                if (user.twofa_last_token !== token && verify) {
+                    callback({
+                        ok: true,
+                        valid: true,
+                    });
+                } else {
+                    callback({
+                        ok: false,
+                        msg: "Invalid Token.",
+                        valid: false,
+                    });
+                }
+
+            } catch (error) {
                 callback({
                     ok: false,
-                    msg: "Invalid Token.",
-                    valid: false,
+                    msg: error.message,
                 });
             }
         });
 
         socket.on("twoFAStatus", async (callback) => {
-            checkLogin(socket);
-
             try {
+                checkLogin(socket);
+
                 let user = await R.findOne("user", " id = ? AND active = 1 ", [
                     socket.userID,
                 ]);
@@ -475,9 +555,10 @@ exports.entryPage = "dashboard";
                     });
                 }
             } catch (error) {
+                console.log(error);
                 callback({
                     ok: false,
-                    msg: "Error while trying to get 2FA status.",
+                    msg: error.message,
                 });
             }
         });
@@ -538,7 +619,7 @@ exports.entryPage = "dashboard";
 
                 await updateMonitorNotification(bean.id, notificationIDList);
 
-                await sendMonitorList(socket);
+                await server.sendMonitorList(socket);
                 await startMonitor(socket.userID, bean.id);
 
                 callback({
@@ -566,6 +647,9 @@ exports.entryPage = "dashboard";
                     throw new Error("Permission denied.");
                 }
 
+                // Reset Prometheus labels
+                server.monitorList[monitor.id]?.prometheus()?.remove();
+
                 bean.name = monitor.name;
                 bean.type = monitor.type;
                 bean.url = monitor.url;
@@ -581,12 +665,14 @@ exports.entryPage = "dashboard";
                 bean.port = monitor.port;
                 bean.keyword = monitor.keyword;
                 bean.ignoreTls = monitor.ignoreTls;
+                bean.expiryNotification = monitor.expiryNotification;
                 bean.upsideDown = monitor.upsideDown;
                 bean.maxredirects = monitor.maxredirects;
                 bean.accepted_statuscodes_json = JSON.stringify(monitor.accepted_statuscodes);
                 bean.dns_resolve_type = monitor.dns_resolve_type;
                 bean.dns_resolve_server = monitor.dns_resolve_server;
                 bean.pushToken = monitor.pushToken;
+                bean.proxyId = Number.isInteger(monitor.proxyId) ? monitor.proxyId : null;
 
                 await R.store(bean);
 
@@ -596,7 +682,7 @@ exports.entryPage = "dashboard";
                     await restartMonitor(socket.userID, bean.id);
                 }
 
-                await sendMonitorList(socket);
+                await server.sendMonitorList(socket);
 
                 callback({
                     ok: true,
@@ -616,7 +702,7 @@ exports.entryPage = "dashboard";
         socket.on("getMonitorList", async (callback) => {
             try {
                 checkLogin(socket);
-                await sendMonitorList(socket);
+                await server.sendMonitorList(socket);
                 callback({
                     ok: true,
                 });
@@ -690,7 +776,7 @@ exports.entryPage = "dashboard";
             try {
                 checkLogin(socket);
                 await startMonitor(socket.userID, monitorID);
-                await sendMonitorList(socket);
+                await server.sendMonitorList(socket);
 
                 callback({
                     ok: true,
@@ -709,7 +795,7 @@ exports.entryPage = "dashboard";
             try {
                 checkLogin(socket);
                 await pauseMonitor(socket.userID, monitorID);
-                await sendMonitorList(socket);
+                await server.sendMonitorList(socket);
 
                 callback({
                     ok: true,
@@ -730,9 +816,9 @@ exports.entryPage = "dashboard";
 
                 console.log(`Delete Monitor: ${monitorID} User ID: ${socket.userID}`);
 
-                if (monitorID in monitorList) {
-                    monitorList[monitorID].stop();
-                    delete monitorList[monitorID];
+                if (monitorID in server.monitorList) {
+                    server.monitorList[monitorID].stop();
+                    delete server.monitorList[monitorID];
                 }
 
                 await R.exec("DELETE FROM monitor WHERE id = ? AND user_id = ? ", [
@@ -745,7 +831,7 @@ exports.entryPage = "dashboard";
                     msg: "Deleted Successfully.",
                 });
 
-                await sendMonitorList(socket);
+                await server.sendMonitorList(socket);
                 // Clear heartbeat list on client
                 await sendImportantHeartbeatList(socket, monitorID, true, true);
 
@@ -923,21 +1009,13 @@ exports.entryPage = "dashboard";
                     throw new Error("Password is too weak. It should contain alphabetic and numeric characters. It must be at least 6 characters in length.");
                 }
 
-                let user = await R.findOne("user", " id = ? AND active = 1 ", [
-                    socket.userID,
-                ]);
+                let user = await doubleCheckPassword(socket, password.currentPassword);
+                await user.resetPassword(password.newPassword);
 
-                if (user && passwordHash.verify(password.currentPassword, user.password)) {
-
-                    user.resetPassword(password.newPassword);
-
-                    callback({
-                        ok: true,
-                        msg: "Password has been updated successfully.",
-                    });
-                } else {
-                    throw new Error("Incorrect current password");
-                }
+                callback({
+                    ok: true,
+                    msg: "Password has been updated successfully.",
+                });
 
             } catch (e) {
                 callback({
@@ -964,10 +1042,14 @@ exports.entryPage = "dashboard";
             }
         });
 
-        socket.on("setSettings", async (data, callback) => {
+        socket.on("setSettings", async (data, currentPassword, callback) => {
             try {
                 checkLogin(socket);
 
+                if (data.disableAuth) {
+                    await doubleCheckPassword(socket, currentPassword);
+                }
+
                 await setSettings("general", data);
                 exports.entryPage = data.entryPage;
 
@@ -1067,6 +1149,7 @@ exports.entryPage = "dashboard";
                 console.log(`Importing Backup, User ID: ${socket.userID}, Version: ${backupData.version}`);
 
                 let notificationListData = backupData.notificationList;
+                let proxyListData = backupData.proxyList;
                 let monitorListData = backupData.monitorList;
 
                 let version17x = compareVersions.compare(backupData.version, "1.7.0", ">=");
@@ -1074,8 +1157,8 @@ exports.entryPage = "dashboard";
                 // If the import option is "overwrite" it'll clear most of the tables, except "settings" and "user"
                 if (importHandle == "overwrite") {
                     // Stops every monitor first, so it doesn't execute any heartbeat while importing
-                    for (let id in monitorList) {
-                        let monitor = monitorList[id];
+                    for (let id in server.monitorList) {
+                        let monitor = server.monitorList[id];
                         await monitor.stop();
                     }
                     await R.exec("DELETE FROM heartbeat");
@@ -1085,6 +1168,7 @@ exports.entryPage = "dashboard";
                     await R.exec("DELETE FROM monitor_tag");
                     await R.exec("DELETE FROM tag");
                     await R.exec("DELETE FROM monitor");
+                    await R.exec("DELETE FROM proxy");
                 }
 
                 // Only starts importing if the backup file contains at least one notification
@@ -1104,6 +1188,24 @@ exports.entryPage = "dashboard";
                     }
                 }
 
+                // Only starts importing if the backup file contains at least one proxy
+                if (proxyListData.length >= 1) {
+                    const proxies = await R.findAll("proxy");
+
+                    // Loop over proxy list and save proxies
+                    for (const proxy of proxyListData) {
+                        const exists = proxies.find(item => item.id === proxy.id);
+
+                        // Do not process when proxy already exists in import handle is skip and keep
+                        if (["skip", "keep"].includes(importHandle) && !exists) {
+                            return;
+                        }
+
+                        // Save proxy as new entry if exists update exists one
+                        await Proxy.save(proxy, exists ? proxy.id : undefined, proxy.userId);
+                    }
+                }
+
                 // Only starts importing if the backup file contains at least one monitor
                 if (monitorListData.length >= 1) {
                     // Get every existing monitor name and puts them in one simple string
@@ -1153,6 +1255,7 @@ exports.entryPage = "dashboard";
                                 dns_resolve_type: monitorListData[i].dns_resolve_type,
                                 dns_resolve_server: monitorListData[i].dns_resolve_server,
                                 notificationIDList: {},
+                                proxy_id: monitorListData[i].proxy_id || null,
                             };
 
                             if (monitorListData[i].pushToken) {
@@ -1218,7 +1321,7 @@ exports.entryPage = "dashboard";
                     }
 
                     await sendNotificationList(socket);
-                    await sendMonitorList(socket);
+                    await server.sendMonitorList(socket);
                 }
 
                 callback({
@@ -1306,7 +1409,9 @@ exports.entryPage = "dashboard";
 
         // Status Page Socket Handler for admin only
         statusPageSocketHandler(socket);
+        cloudflaredSocketHandler(socket);
         databaseSocketHandler(socket);
+        proxySocketHandler(socket);
 
         debug("added all socket handlers");
 
@@ -1327,12 +1432,12 @@ exports.entryPage = "dashboard";
 
     console.log("Init the server");
 
-    server.once("error", async (err) => {
+    httpServer.once("error", async (err) => {
         console.error("Cannot listen: " + err.message);
-        await Database.close();
+        await shutdownFunction();
     });
 
-    server.listen(port, hostname, () => {
+    httpServer.listen(port, hostname, () => {
         if (hostname) {
             console.log(`Listening on ${hostname}:${port}`);
         } else {
@@ -1348,6 +1453,9 @@ exports.entryPage = "dashboard";
 
     initBackgroundJobs(args);
 
+    // Start cloudflared at the end if configured
+    await cloudflaredAutoStart(cloudflaredToken);
+
 })();
 
 async function updateMonitorNotification(monitorID, notificationIDList) {
@@ -1376,21 +1484,18 @@ async function checkOwner(userID, monitorID) {
     }
 }
 
-async function sendMonitorList(socket) {
-    let list = await getMonitorJSONList(socket.userID);
-    io.to(socket.userID).emit("monitorList", list);
-    return list;
-}
-
 async function afterLogin(socket, user) {
     socket.userID = user.id;
     socket.join(user.id);
 
-    let monitorList = await sendMonitorList(socket);
+    let monitorList = await server.sendMonitorList(socket);
     sendNotificationList(socket);
+    sendProxyList(socket);
 
     await sleep(500);
 
+    await StatusPage.sendStatusPageList(io, socket);
+
     for (let monitorID in monitorList) {
         await sendHeartbeatList(socket, monitorID);
     }
@@ -1466,11 +1571,11 @@ async function startMonitor(userID, monitorID) {
         monitorID,
     ]);
 
-    if (monitor.id in monitorList) {
-        monitorList[monitor.id].stop();
+    if (monitor.id in server.monitorList) {
+        server.monitorList[monitor.id].stop();
     }
 
-    monitorList[monitor.id] = monitor;
+    server.monitorList[monitor.id] = monitor;
     monitor.start(io);
 }
 
@@ -1488,8 +1593,8 @@ async function pauseMonitor(userID, monitorID) {
         userID,
     ]);
 
-    if (monitorID in monitorList) {
-        monitorList[monitorID].stop();
+    if (monitorID in server.monitorList) {
+        server.monitorList[monitorID].stop();
     }
 }
 
@@ -1500,7 +1605,7 @@ async function startMonitors() {
     let list = await R.find("monitor", " active = 1 ");
 
     for (let monitor of list) {
-        monitorList[monitor.id] = monitor;
+        server.monitorList[monitor.id] = monitor;
     }
 
     for (let monitor of list) {
@@ -1515,19 +1620,22 @@ async function shutdownFunction(signal) {
     console.log("Called signal: " + signal);
 
     console.log("Stopping all monitors");
-    for (let id in monitorList) {
-        let monitor = monitorList[id];
+    for (let id in server.monitorList) {
+        let monitor = server.monitorList[id];
         monitor.stop();
     }
     await sleep(2000);
     await Database.close();
+
+    stopBackgroundJobs();
+    await cloudflaredStop();
 }
 
 function finalFunction() {
     console.log("Graceful shutdown successful!");
 }
 
-gracefulShutdown(server, {
+gracefulShutdown(httpServer, {
     signals: "SIGINT SIGTERM",
     timeout: 30000,                   // timeout: 30 secs
     development: false,               // not in dev mode

server/socket-handlers/cloudflared-socket-handler.js

@@ -0,0 +1,90 @@
+const { checkLogin, setSetting, setting, doubleCheckPassword } = require("../util-server");
+const { CloudflaredTunnel } = require("node-cloudflared-tunnel");
+const { io } = require("../server");
+
+const prefix = "cloudflared_";
+const cloudflared = new CloudflaredTunnel();
+
+cloudflared.change = (running, message) => {
+    io.to("cloudflared").emit(prefix + "running", running);
+    io.to("cloudflared").emit(prefix + "message", message);
+};
+
+cloudflared.error = (errorMessage) => {
+    io.to("cloudflared").emit(prefix + "errorMessage", errorMessage);
+};
+
+module.exports.cloudflaredSocketHandler = (socket) => {
+
+    socket.on(prefix + "join", async () => {
+        try {
+            checkLogin(socket);
+            socket.join("cloudflared");
+            io.to(socket.userID).emit(prefix + "installed", cloudflared.checkInstalled());
+            io.to(socket.userID).emit(prefix + "running", cloudflared.running);
+            io.to(socket.userID).emit(prefix + "token", await setting("cloudflaredTunnelToken"));
+        } catch (error) { }
+    });
+
+    socket.on(prefix + "leave", async () => {
+        try {
+            checkLogin(socket);
+            socket.leave("cloudflared");
+        } catch (error) { }
+    });
+
+    socket.on(prefix + "start", async (token) => {
+        try {
+            checkLogin(socket);
+            if (token && typeof token === "string") {
+                await setSetting("cloudflaredTunnelToken", token);
+                cloudflared.token = token;
+            } else {
+                cloudflared.token = null;
+            }
+            cloudflared.start();
+        } catch (error) { }
+    });
+
+    socket.on(prefix + "stop", async (currentPassword, callback) => {
+        try {
+            checkLogin(socket);
+            await doubleCheckPassword(socket, currentPassword);
+            cloudflared.stop();
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    socket.on(prefix + "removeToken", async () => {
+        try {
+            checkLogin(socket);
+            await setSetting("cloudflaredTunnelToken", "");
+        } catch (error) { }
+    });
+
+};
+
+module.exports.autoStart = async (token) => {
+    if (!token) {
+        token = await setting("cloudflaredTunnelToken");
+    } else {
+        // Override the current token via args or env var
+        await setSetting("cloudflaredTunnelToken", token);
+        console.log("Use cloudflared token from args or env var");
+    }
+
+    if (token) {
+        console.log("Start cloudflared");
+        cloudflared.token = token;
+        cloudflared.start();
+    }
+};
+
+module.exports.stop = async () => {
+    console.log("Stop cloudflared");
+    cloudflared.stop();
+};

server/socket-handlers/proxy-socket-handler.js

@@ -0,0 +1,53 @@
+const { checkLogin } = require("../util-server");
+const { Proxy } = require("../proxy");
+const { sendProxyList } = require("../client");
+const server = require("../server");
+
+module.exports.proxySocketHandler = (socket) => {
+    socket.on("addProxy", async (proxy, proxyID, callback) => {
+        try {
+            checkLogin(socket);
+
+            const proxyBean = await Proxy.save(proxy, proxyID, socket.userID);
+            await sendProxyList(socket);
+
+            if (proxy.applyExisting) {
+                await Proxy.reloadProxy();
+                await server.sendMonitorList(socket);
+            }
+
+            callback({
+                ok: true,
+                msg: "Saved",
+                id: proxyBean.id,
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+
+    socket.on("deleteProxy", async (proxyID, callback) => {
+        try {
+            checkLogin(socket);
+
+            await Proxy.delete(proxyID, socket.userID);
+            await sendProxyList(socket);
+            await Proxy.reloadProxy();
+
+            callback({
+                ok: true,
+                msg: "Deleted",
+            });
+
+        } catch (e) {
+            callback({
+                ok: false,
+                msg: e.message,
+            });
+        }
+    });
+};

server/socket-handlers/status-page-socket-handler.js

@@ -1,25 +1,36 @@
 const { R } = require("redbean-node");
-const { checkLogin, setSettings } = require("../util-server");
+const { checkLogin, setSettings, setSetting } = require("../util-server");
 const dayjs = require("dayjs");
 const { debug } = require("../../src/util");
 const ImageDataURI = require("../image-data-uri");
 const Database = require("../database");
 const apicache = require("../modules/apicache");
+const StatusPage = require("../model/status_page");
+const server = require("../server");
 
 module.exports.statusPageSocketHandler = (socket) => {
 
     // Post or edit incident
-    socket.on("postIncident", async (incident, callback) => {
+    socket.on("postIncident", async (slug, incident, callback) => {
         try {
             checkLogin(socket);
 
-            await R.exec("UPDATE incident SET pin = 0 ");
+            let statusPageID = await StatusPage.slugToID(slug);
+
+            if (!statusPageID) {
+                throw new Error("slug is not found");
+            }
+
+            await R.exec("UPDATE incident SET pin = 0 WHERE status_page_id = ? ", [
+                statusPageID
+            ]);
 
             let incidentBean;
 
             if (incident.id) {
-                incidentBean = await R.findOne("incident", " id = ?", [
-                    incident.id
+                incidentBean = await R.findOne("incident", " id = ? AND status_page_id = ? ", [
+                    incident.id,
+                    statusPageID
                 ]);
             }
 
@@ -31,6 +42,7 @@ module.exports.statusPageSocketHandler = (socket) => {
             incidentBean.content = incident.content;
             incidentBean.style = incident.style;
             incidentBean.pin = true;
+            incidentBean.status_page_id = statusPageID;
 
             if (incident.id) {
                 incidentBean.lastUpdatedDate = R.isoDateTime(dayjs.utc());
@@ -52,11 +64,15 @@ module.exports.statusPageSocketHandler = (socket) => {
         }
     });
 
-    socket.on("unpinIncident", async (callback) => {
+    socket.on("unpinIncident", async (slug, callback) => {
         try {
             checkLogin(socket);
 
-            await R.exec("UPDATE incident SET pin = 0 WHERE pin = 1");
+            let statusPageID = await StatusPage.slugToID(slug);
+
+            await R.exec("UPDATE incident SET pin = 0 WHERE pin = 1 AND status_page_id = ? ", [
+                statusPageID
+            ]);
 
             callback({
                 ok: true,
@@ -69,14 +85,46 @@ module.exports.statusPageSocketHandler = (socket) => {
         }
     });
 
-    // Save Status Page
-    // imgDataUrl Only Accept PNG!
-    socket.on("saveStatusPage", async (config, imgDataUrl, publicGroupList, callback) => {
-
+    socket.on("getStatusPage", async (slug, callback) => {
         try {
             checkLogin(socket);
 
-            apicache.clear();
+            let statusPage = await R.findOne("status_page", " slug = ? ", [
+                slug
+            ]);
+
+            if (!statusPage) {
+                throw new Error("No slug?");
+            }
+
+            callback({
+                ok: true,
+                config: await statusPage.toJSON(),
+            });
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    // Save Status Page
+    // imgDataUrl Only Accept PNG!
+    socket.on("saveStatusPage", async (slug, config, imgDataUrl, publicGroupList, callback) => {
+        try {
+            checkLogin(socket);
+
+            // Save Config
+            let statusPage = await R.findOne("status_page", " slug = ? ", [
+                slug
+            ]);
+
+            if (!statusPage) {
+                throw new Error("No slug?");
+            }
+
+            checkSlug(config.slug);
 
             const header = "data:image/png;base64,";
 
@@ -88,16 +136,31 @@ module.exports.statusPageSocketHandler = (socket) => {
                     throw new Error("Only allowed PNG logo.");
                 }
 
+                const filename = `logo${statusPage.id}.png`;
+
                 // Convert to file
-                await ImageDataURI.outputFile(imgDataUrl, Database.uploadDir + "logo.png");
-                config.logo = "/upload/logo.png?t=" + Date.now();
+                await ImageDataURI.outputFile(imgDataUrl, Database.uploadDir + filename);
+                config.logo = `/upload/${filename}?t=` + Date.now();
 
             } else {
                 config.icon = imgDataUrl;
             }
 
-            // Save Config
-            await setSettings("statusPage", config);
+            statusPage.slug = config.slug;
+            statusPage.title = config.title;
+            statusPage.description = config.description;
+            statusPage.icon = config.logo;
+            statusPage.theme = config.theme;
+            //statusPage.published = ;
+            //statusPage.search_engine_index = ;
+            statusPage.show_tags = config.showTags;
+            //statusPage.password = null;
+            statusPage.modified_date = R.isoDateTime();
+
+            await R.store(statusPage);
+
+            await statusPage.updateDomainNameList(config.domainNameList);
+            await StatusPage.loadDomainMappingList();
 
             // Save Public Group List
             const groupIDList = [];
@@ -106,13 +169,15 @@ module.exports.statusPageSocketHandler = (socket) => {
             for (let group of publicGroupList) {
                 let groupBean;
                 if (group.id) {
-                    groupBean = await R.findOne("group", " id = ? AND public = 1 ", [
-                        group.id
+                    groupBean = await R.findOne("group", " id = ? AND public = 1 AND status_page_id = ? ", [
+                        group.id,
+                        statusPage.id
                     ]);
                 } else {
                     groupBean = R.dispense("group");
                 }
 
+                groupBean.status_page_id = statusPage.id;
                 groupBean.name = group.name;
                 groupBean.public = true;
                 groupBean.weight = groupOrder++;
@@ -124,7 +189,6 @@ module.exports.statusPageSocketHandler = (socket) => {
                 ]);
 
                 let monitorOrder = 1;
-                console.log(group.monitorList);
 
                 for (let monitor of group.monitorList) {
                     let relationBean = R.dispense("monitor_group");
@@ -141,7 +205,20 @@ module.exports.statusPageSocketHandler = (socket) => {
             // Delete groups that not in the list
             debug("Delete groups that not in the list");
             const slots = groupIDList.map(() => "?").join(",");
-            await R.exec(`DELETE FROM \`group\` WHERE id NOT IN (${slots})`, groupIDList);
+
+            const data = [
+                ...groupIDList,
+                statusPage.id
+            ];
+            await R.exec(`DELETE FROM \`group\` WHERE id NOT IN (${slots}) AND status_page_id = ?`, data);
+
+            // Also change entry page to new slug if it is the default one, and slug is changed.
+            if (server.entryPage === "statusPage-" + slug && statusPage.slug !== slug) {
+                server.entryPage = "statusPage-" + statusPage.slug;
+                await setSetting("entryPage", server.entryPage, "general");
+            }
+
+            apicache.clear();
 
             callback({
                 ok: true,
@@ -149,7 +226,7 @@ module.exports.statusPageSocketHandler = (socket) => {
             });
 
         } catch (error) {
-            console.log(error);
+            console.error(error);
 
             callback({
                 ok: false,
@@ -158,4 +235,115 @@ module.exports.statusPageSocketHandler = (socket) => {
         }
     });
 
+    // Add a new status page
+    socket.on("addStatusPage", async (title, slug, callback) => {
+        try {
+            checkLogin(socket);
+
+            title = title?.trim();
+            slug = slug?.trim();
+
+            // Check empty
+            if (!title || !slug) {
+                throw new Error("Please input all fields");
+            }
+
+            // Make sure slug is string
+            if (typeof slug !== "string") {
+                throw new Error("Slug -Accept string only");
+            }
+
+            // lower case only
+            slug = slug.toLowerCase();
+
+            checkSlug(slug);
+
+            let statusPage = R.dispense("status_page");
+            statusPage.slug = slug;
+            statusPage.title = title;
+            statusPage.theme = "light";
+            statusPage.icon = "";
+            await R.store(statusPage);
+
+            callback({
+                ok: true,
+                msg: "OK!"
+            });
+
+        } catch (error) {
+            console.error(error);
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
+
+    // Delete a status page
+    socket.on("deleteStatusPage", async (slug, callback) => {
+        try {
+            checkLogin(socket);
+
+            let statusPageID = await StatusPage.slugToID(slug);
+
+            if (statusPageID) {
+
+                // Reset entry page if it is the default one.
+                if (server.entryPage === "statusPage-" + slug) {
+                    server.entryPage = "dashboard";
+                    await setSetting("entryPage", server.entryPage, "general");
+                }
+
+                // No need to delete records from `status_page_cname`, because it has cascade foreign key.
+                // But for incident & group, it is hard to add cascade foreign key during migration, so they have to be deleted manually.
+
+                // Delete incident
+                await R.exec("DELETE FROM incident WHERE status_page_id = ? ", [
+                    statusPageID
+                ]);
+
+                // Delete group
+                await R.exec("DELETE FROM `group` WHERE status_page_id = ? ", [
+                    statusPageID
+                ]);
+
+                // Delete status_page
+                await R.exec("DELETE FROM status_page WHERE id = ? ", [
+                    statusPageID
+                ]);
+
+            } else {
+                throw new Error("Status Page is not found");
+            }
+
+            callback({
+                ok: true,
+            });
+        } catch (error) {
+            callback({
+                ok: false,
+                msg: error.message,
+            });
+        }
+    });
 };
+
+/**
+ * Check slug a-z, 0-9, - only
+ * Regex from: https://stackoverflow.com/questions/22454258/js-regex-string-validation-for-slug
+ */
+function checkSlug(slug) {
+    if (typeof slug !== "string") {
+        throw new Error("Slug must be string");
+    }
+
+    slug = slug.trim();
+
+    if (!slug) {
+        throw new Error("Slug cannot be empty");
+    }
+
+    if (!slug.match(/^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$/)) {
+        throw new Error("Invalid Slug");
+    }
+}

server/util-server.js

@@ -1,9 +1,8 @@
 const tcpp = require("tcp-ping");
 const Ping = require("./ping-lite");
 const { R } = require("redbean-node");
-const { debug } = require("../src/util");
+const { debug, genSecret } = require("../src/util");
 const passwordHash = require("./password-hash");
-const dayjs = require("dayjs");
 const { Resolver } = require("dns");
 const child_process = require("child_process");
 const iconv = require("iconv-lite");
@@ -16,6 +15,7 @@ exports.WIN = /^win/.test(process.platform);
 exports.LIN = /^linux/.test(process.platform);
 exports.MAC = /^darwin/.test(process.platform);
 exports.FBSD = /^freebsd/.test(process.platform);
+exports.BSD = /bsd$/.test(process.platform);
 
 /**
  * Init or reset JWT secret
@@ -31,7 +31,7 @@ exports.initJWTSecret = async () => {
         jwtSecretBean.key = "jwtSecret";
     }
 
-    jwtSecretBean.value = passwordHash.generate(dayjs() + "");
+    jwtSecretBean.value = passwordHash.generate(genSecret());
     await R.store(jwtSecretBean);
     return jwtSecretBean;
 };
@@ -320,6 +320,28 @@ exports.checkLogin = (socket) => {
     }
 };
 
+/**
+ * For logged-in users, double-check the password
+ * @param socket
+ * @param currentPassword
+ * @returns {Promise<Bean>}
+ */
+exports.doubleCheckPassword = async (socket, currentPassword) => {
+    if (typeof currentPassword !== "string") {
+        throw new Error("Wrong data type?");
+    }
+
+    let user = await R.findOne("user", " id = ? AND active = 1 ", [
+        socket.userID,
+    ]);
+
+    if (!user || !passwordHash.verify(currentPassword, user.password)) {
+        throw new Error("Incorrect current password");
+    }
+
+    return user;
+};
+
 exports.startUnitTest = async () => {
     console.log("Starting unit test...");
     const npm = /^win/.test(process.platform) ? "npm.cmd" : "npm";