Merge branch 'master' into 1.23.X-to-2

# Conflicts:
#	package-lock.json
#	package.json

server/monitor-types/dns.js

@@ -0,0 +1,85 @@
+const { MonitorType } = require("./monitor-type");
+const { UP, DOWN } = require("../../src/util");
+const dayjs = require("dayjs");
+const { dnsResolve } = require("../util-server");
+const { R } = require("redbean-node");
+const { ConditionVariable } = require("../monitor-conditions/variables");
+const { defaultStringOperators } = require("../monitor-conditions/operators");
+const { ConditionExpressionGroup } = require("../monitor-conditions/expression");
+const { evaluateExpressionGroup } = require("../monitor-conditions/evaluator");
+
+class DnsMonitorType extends MonitorType {
+    name = "dns";
+
+    supportsConditions = true;
+
+    conditionVariables = [
+        new ConditionVariable("record", defaultStringOperators ),
+    ];
+
+    /**
+     * @inheritdoc
+     */
+    async check(monitor, heartbeat, _server) {
+        let startTime = dayjs().valueOf();
+        let dnsMessage = "";
+
+        let dnsRes = await dnsResolve(monitor.hostname, monitor.dns_resolve_server, monitor.port, monitor.dns_resolve_type);
+        heartbeat.ping = dayjs().valueOf() - startTime;
+
+        const conditions = ConditionExpressionGroup.fromMonitor(monitor);
+        let conditionsResult = true;
+        const handleConditions = (data) => conditions ? evaluateExpressionGroup(conditions, data) : true;
+
+        switch (monitor.dns_resolve_type) {
+            case "A":
+            case "AAAA":
+            case "TXT":
+            case "PTR":
+                dnsMessage = `Records: ${dnsRes.join(" | ")}`;
+                conditionsResult = dnsRes.some(record => handleConditions({ record }));
+                break;
+
+            case "CNAME":
+                dnsMessage = dnsRes[0];
+                conditionsResult = handleConditions({ record: dnsRes[0] });
+                break;
+
+            case "CAA":
+                dnsMessage = dnsRes[0].issue;
+                conditionsResult = handleConditions({ record: dnsRes[0].issue });
+                break;
+
+            case "MX":
+                dnsMessage = dnsRes.map(record => `Hostname: ${record.exchange} - Priority: ${record.priority}`).join(" | ");
+                conditionsResult = dnsRes.some(record => handleConditions({ record: record.exchange }));
+                break;
+
+            case "NS":
+                dnsMessage = `Servers: ${dnsRes.join(" | ")}`;
+                conditionsResult = dnsRes.some(record => handleConditions({ record }));
+                break;
+
+            case "SOA":
+                dnsMessage = `NS-Name: ${dnsRes.nsname} | Hostmaster: ${dnsRes.hostmaster} | Serial: ${dnsRes.serial} | Refresh: ${dnsRes.refresh} | Retry: ${dnsRes.retry} | Expire: ${dnsRes.expire} | MinTTL: ${dnsRes.minttl}`;
+                conditionsResult = handleConditions({ record: dnsRes.nsname });
+                break;
+
+            case "SRV":
+                dnsMessage = dnsRes.map(record => `Name: ${record.name} | Port: ${record.port} | Priority: ${record.priority} | Weight: ${record.weight}`).join(" | ");
+                conditionsResult = dnsRes.some(record => handleConditions({ record: record.name }));
+                break;
+        }
+
+        if (monitor.dns_last_result !== dnsMessage && dnsMessage !== undefined) {
+            await R.exec("UPDATE `monitor` SET dns_last_result = ? WHERE id = ? ", [ dnsMessage, monitor.id ]);
+        }
+
+        heartbeat.msg = dnsMessage;
+        heartbeat.status = conditionsResult ? UP : DOWN;
+    }
+}
+
+module.exports = {
+    DnsMonitorType,
+};

server/monitor-types/mongodb.js

@@ -0,0 +1,63 @@
+const { MonitorType } = require("./monitor-type");
+const { UP } = require("../../src/util");
+const { MongoClient } = require("mongodb");
+const jsonata = require("jsonata");
+
+class MongodbMonitorType extends MonitorType {
+    name = "mongodb";
+
+    /**
+     * @inheritdoc
+     */
+    async check(monitor, heartbeat, _server) {
+        let command = { "ping": 1 };
+        if (monitor.databaseQuery) {
+            command = JSON.parse(monitor.databaseQuery);
+        }
+
+        let result = await this.runMongodbCommand(monitor.databaseConnectionString, command);
+
+        if (result["ok"] !== 1) {
+            throw new Error("MongoDB command failed");
+        } else {
+            heartbeat.msg = "Command executed successfully";
+        }
+
+        if (monitor.jsonPath) {
+            let expression = jsonata(monitor.jsonPath);
+            result = await expression.evaluate(result);
+            if (result) {
+                heartbeat.msg = "Command executed successfully and the jsonata expression produces a result.";
+            } else {
+                throw new Error("Queried value not found.");
+            }
+        }
+
+        if (monitor.expectedValue) {
+            if (result.toString() === monitor.expectedValue) {
+                heartbeat.msg = "Command executed successfully and expected value was found";
+            } else {
+                throw new Error("Query executed, but value is not equal to expected value, value was: [" + JSON.stringify(result) + "]");
+            }
+        }
+
+        heartbeat.status = UP;
+    }
+
+    /**
+     * Connect to and run MongoDB command on a MongoDB database
+     * @param {string} connectionString The database connection string
+     * @param {object} command MongoDB command to run on the database
+     * @returns {Promise<(string[] | object[] | object)>} Response from server
+     */
+    async runMongodbCommand(connectionString, command) {
+        let client = await MongoClient.connect(connectionString);
+        let result = await client.db().command(command);
+        await client.close();
+        return result;
+    }
+}
+
+module.exports = {
+    MongodbMonitorType,
+};

server/monitor-types/monitor-type.js

@@ -1,18 +1,29 @@
 class MonitorType {
-
     name = undefined;
 
     /**
-     *
-     * @param {Monitor} monitor
-     * @param {Heartbeat} heartbeat
-     * @param {UptimeKumaServer} server
+     * Whether or not this type supports monitor conditions. Controls UI visibility in monitor form.
+     * @type {boolean}
+     */
+    supportsConditions = false;
+
+    /**
+     * Variables supported by this type. e.g. an HTTP type could have a "response_code" variable to test against.
+     * This property controls the choices displayed in the monitor edit form.
+     * @type {import("../monitor-conditions/variables").ConditionVariable[]}
+     */
+    conditionVariables = [];
+
+    /**
+     * Run the monitoring check on the given monitor
+     * @param {Monitor} monitor Monitor to check
+     * @param {Heartbeat} heartbeat Monitor heartbeat to update
+     * @param {UptimeKumaServer} server Uptime Kuma server
      * @returns {Promise<void>}
      */
     async check(monitor, heartbeat, server) {
         throw new Error("You need to override check()");
     }
-
 }
 
 module.exports = {

server/monitor-types/mqtt.js

@@ -0,0 +1,117 @@
+const { MonitorType } = require("./monitor-type");
+const { log, UP } = require("../../src/util");
+const mqtt = require("mqtt");
+const jsonata = require("jsonata");
+
+class MqttMonitorType extends MonitorType {
+    name = "mqtt";
+
+    /**
+     * @inheritdoc
+     */
+    async check(monitor, heartbeat, server) {
+        const receivedMessage = await this.mqttAsync(monitor.hostname, monitor.mqttTopic, {
+            port: monitor.port,
+            username: monitor.mqttUsername,
+            password: monitor.mqttPassword,
+            interval: monitor.interval,
+        });
+
+        if (monitor.mqttCheckType == null || monitor.mqttCheckType === "") {
+            // use old default
+            monitor.mqttCheckType = "keyword";
+        }
+
+        if (monitor.mqttCheckType === "keyword") {
+            if (receivedMessage != null && receivedMessage.includes(monitor.mqttSuccessMessage)) {
+                heartbeat.msg = `Topic: ${monitor.mqttTopic}; Message: ${receivedMessage}`;
+                heartbeat.status = UP;
+            } else {
+                throw Error(`Message Mismatch - Topic: ${monitor.mqttTopic}; Message: ${receivedMessage}`);
+            }
+        } else if (monitor.mqttCheckType === "json-query") {
+            const parsedMessage = JSON.parse(receivedMessage);
+
+            let expression = jsonata(monitor.jsonPath);
+
+            let result = await expression.evaluate(parsedMessage);
+
+            if (result?.toString() === monitor.expectedValue) {
+                heartbeat.msg = "Message received, expected value is found";
+                heartbeat.status = UP;
+            } else {
+                throw new Error("Message received but value is not equal to expected value, value was: [" + result + "]");
+            }
+        } else {
+            throw Error("Unknown MQTT Check Type");
+        }
+    }
+
+    /**
+     * Connect to MQTT Broker, subscribe to topic and receive message as String
+     * @param {string} hostname Hostname / address of machine to test
+     * @param {string} topic MQTT topic
+     * @param {object} options MQTT options. Contains port, username,
+     * password and interval (interval defaults to 20)
+     * @returns {Promise<string>} Received MQTT message
+     */
+    mqttAsync(hostname, topic, options = {}) {
+        return new Promise((resolve, reject) => {
+            const { port, username, password, interval = 20 } = options;
+
+            // Adds MQTT protocol to the hostname if not already present
+            if (!/^(?:http|mqtt|ws)s?:\/\//.test(hostname)) {
+                hostname = "mqtt://" + hostname;
+            }
+
+            const timeoutID = setTimeout(() => {
+                log.debug("mqtt", "MQTT timeout triggered");
+                client.end();
+                reject(new Error("Timeout, Message not received"));
+            }, interval * 1000 * 0.8);
+
+            const mqttUrl = `${hostname}:${port}`;
+
+            log.debug("mqtt", `MQTT connecting to ${mqttUrl}`);
+
+            let client = mqtt.connect(mqttUrl, {
+                username,
+                password,
+                clientId: "uptime-kuma_" + Math.random().toString(16).substr(2, 8)
+            });
+
+            client.on("connect", () => {
+                log.debug("mqtt", "MQTT connected");
+
+                try {
+                    client.subscribe(topic, () => {
+                        log.debug("mqtt", "MQTT subscribed to topic");
+                    });
+                } catch (e) {
+                    client.end();
+                    clearTimeout(timeoutID);
+                    reject(new Error("Cannot subscribe topic"));
+                }
+            });
+
+            client.on("error", (error) => {
+                client.end();
+                clearTimeout(timeoutID);
+                reject(error);
+            });
+
+            client.on("message", (messageTopic, message) => {
+                if (messageTopic === topic) {
+                    client.end();
+                    clearTimeout(timeoutID);
+                    resolve(message.toString("utf8"));
+                }
+            });
+
+        });
+    }
+}
+
+module.exports = {
+    MqttMonitorType,
+};

server/monitor-types/rabbitmq.js

@@ -0,0 +1,67 @@
+const { MonitorType } = require("./monitor-type");
+const { log, UP, DOWN } = require("../../src/util");
+const { axiosAbortSignal } = require("../util-server");
+const axios = require("axios");
+
+class RabbitMqMonitorType extends MonitorType {
+    name = "rabbitmq";
+
+    /**
+     * @inheritdoc
+     */
+    async check(monitor, heartbeat, server) {
+        let baseUrls = [];
+        try {
+            baseUrls = JSON.parse(monitor.rabbitmqNodes);
+        } catch (error) {
+            throw new Error("Invalid RabbitMQ Nodes");
+        }
+
+        heartbeat.status = DOWN;
+        for (let baseUrl of baseUrls) {
+            try {
+                // Without a trailing slash, path in baseUrl will be removed. https://example.com/api -> https://example.com
+                if ( !baseUrl.endsWith("/") ) {
+                    baseUrl += "/";
+                }
+                const options = {
+                    // Do not start with slash, it will strip the trailing slash from baseUrl
+                    url: new URL("api/health/checks/alarms/", baseUrl).href,
+                    method: "get",
+                    timeout: monitor.timeout * 1000,
+                    headers: {
+                        "Accept": "application/json",
+                        "Authorization": "Basic " + Buffer.from(`${monitor.rabbitmqUsername || ""}:${monitor.rabbitmqPassword || ""}`).toString("base64"),
+                    },
+                    signal: axiosAbortSignal((monitor.timeout + 10) * 1000),
+                    // Capture reason for 503 status
+                    validateStatus: (status) => status === 200 || status === 503,
+                };
+                log.debug("monitor", `[${monitor.name}] Axios Request: ${JSON.stringify(options)}`);
+                const res = await axios.request(options);
+                log.debug("monitor", `[${monitor.name}] Axios Response: status=${res.status} body=${JSON.stringify(res.data)}`);
+                if (res.status === 200) {
+                    heartbeat.status = UP;
+                    heartbeat.msg = "OK";
+                    break;
+                } else if (res.status === 503) {
+                    heartbeat.msg = res.data.reason;
+                } else {
+                    heartbeat.msg = `${res.status} - ${res.statusText}`;
+                }
+            } catch (error) {
+                if (axios.isCancel(error)) {
+                    heartbeat.msg = "Request timed out";
+                    log.debug("monitor", `[${monitor.name}] Request timed out`);
+                } else {
+                    log.debug("monitor", `[${monitor.name}] Axios Error: ${JSON.stringify(error.message)}`);
+                    heartbeat.msg = error.message;
+                }
+            }
+        }
+    }
+}
+
+module.exports = {
+    RabbitMqMonitorType,
+};

server/monitor-types/real-browser-monitor-type.js

@@ -8,6 +8,7 @@ const path = require("path");
 const Database = require("../database");
 const jwt = require("jsonwebtoken");
 const config = require("../config");
+const { RemoteBrowser } = require("../remote-browser");
 
 /**
  * Cached instance of a browser
@@ -28,6 +29,9 @@ if (process.platform === "win32") {
     allowedList.push(process.env.PROGRAMFILES + "\\Chromium\\Application\\chrome.exe");
     allowedList.push(process.env["ProgramFiles(x86)"] + "\\Chromium\\Application\\chrome.exe");
 
+    // Allow MS Edge
+    allowedList.push(process.env["ProgramFiles(x86)"] + "\\Microsoft\\Edge\\Application\\msedge.exe");
+
     // For Loop A to Z
     for (let i = 65; i <= 90; i++) {
         let drive = String.fromCharCode(i);
@@ -47,15 +51,17 @@ if (process.platform === "win32") {
         "/snap/bin/chromium",           // Ubuntu
     ];
 } else if (process.platform === "darwin") {
-    // TODO: Generated by GitHub Copilot, but not sure if it's correct
     allowedList = [
         "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
         "/Applications/Chromium.app/Contents/MacOS/Chromium",
     ];
 }
 
-log.debug("chrome", allowedList);
-
+/**
+ * Is the executable path allowed?
+ * @param {string} executablePath Path to executable
+ * @returns {Promise<boolean>} The executable is allowed?
+ */
 async function isAllowedChromeExecutable(executablePath) {
     console.log(config.args);
     if (config.args["allow-all-chrome-exec"] || process.env.UPTIME_KUMA_ALLOW_ALL_CHROME_EXEC === "1") {
@@ -88,6 +94,24 @@ async function getBrowser() {
     }
 }
 
+/**
+ * Get the current instance of the browser. If there isn't one, create it
+ * @param {integer} remoteBrowserID Path to executable
+ * @param {integer} userId User ID
+ * @returns {Promise<Browser>} The browser
+ */
+async function getRemoteBrowser(remoteBrowserID, userId) {
+    let remoteBrowser = await RemoteBrowser.get(remoteBrowserID, userId);
+    log.debug("MONITOR", `Using remote browser: ${remoteBrowser.name} (${remoteBrowser.id})`);
+    browser = await chromium.connect(remoteBrowser.url);
+    return browser;
+}
+
+/**
+ * Prepare the chrome executable path
+ * @param {string} executablePath Path to chrome executable
+ * @returns {Promise<string>} Executable path
+ */
 async function prepareChromeExecutable(executablePath) {
     // Special code for using the playwright_chromium
     if (typeof executablePath === "string" && executablePath.toLocaleLowerCase() === "#playwright_chromium") {
@@ -134,6 +158,12 @@ async function prepareChromeExecutable(executablePath) {
     return executablePath;
 }
 
+/**
+ * Find the chrome executable
+ * @param {any[]} executables Executables to search through
+ * @returns {any} Executable
+ * @throws Could not find executable
+ */
 function findChrome(executables) {
     // Use the last working executable, so we don't have to search for it again
     if (lastAutoDetectChromeExecutable) {
@@ -151,6 +181,10 @@ function findChrome(executables) {
     throw new Error("Chromium not found, please specify Chromium executable path in the settings page.");
 }
 
+/**
+ * Reset chrome
+ * @returns {Promise<void>}
+ */
 async function resetChrome() {
     if (browser) {
         await browser.close();
@@ -160,8 +194,8 @@ async function resetChrome() {
 
 /**
  * Test if the chrome executable is valid and return the version
- * @param executablePath
- * @returns {Promise<string>}
+ * @param {string} executablePath Path to executable
+ * @returns {Promise<string>} Chrome version
  */
 async function testChrome(executablePath) {
     try {
@@ -179,17 +213,30 @@ async function testChrome(executablePath) {
         throw new Error(e.message);
     }
 }
-
+// test remote browser
 /**
- * TODO: connect remote browser? https://playwright.dev/docs/api/class-browsertype#browser-type-connect
- *
+ * @param {string} remoteBrowserURL Remote Browser URL
+ * @returns {Promise<boolean>} Returns if connection worked
  */
+async function testRemoteBrowser(remoteBrowserURL) {
+    try {
+        const browser = await chromium.connect(remoteBrowserURL);
+        browser.version();
+        await browser.close();
+        return true;
+    } catch (e) {
+        throw new Error(e.message);
+    }
+}
 class RealBrowserMonitorType extends MonitorType {
 
     name = "real-browser";
 
+    /**
+     * @inheritdoc
+     */
     async check(monitor, heartbeat, server) {
-        const browser = await getBrowser();
+        const browser = monitor.remote_browser ? await getRemoteBrowser(monitor.remote_browser, monitor.user_id) : await getBrowser();
         const context = await browser.newContext();
         const page = await context.newPage();
 
@@ -230,4 +277,5 @@ module.exports = {
     RealBrowserMonitorType,
     testChrome,
     resetChrome,
+    testRemoteBrowser,
 };

server/monitor-types/snmp.js

@@ -0,0 +1,63 @@
+const { MonitorType } = require("./monitor-type");
+const { UP, log, evaluateJsonQuery } = require("../../src/util");
+const snmp = require("net-snmp");
+
+class SNMPMonitorType extends MonitorType {
+    name = "snmp";
+
+    /**
+     * @inheritdoc
+     */
+    async check(monitor, heartbeat, _server) {
+        let session;
+        try {
+            const sessionOptions = {
+                port: monitor.port || "161",
+                retries: monitor.maxretries,
+                timeout: monitor.timeout * 1000,
+                version: snmp.Version[monitor.snmpVersion],
+            };
+            session = snmp.createSession(monitor.hostname, monitor.radiusPassword, sessionOptions);
+
+            // Handle errors during session creation
+            session.on("error", (error) => {
+                throw new Error(`Error creating SNMP session: ${error.message}`);
+            });
+
+            const varbinds = await new Promise((resolve, reject) => {
+                session.get([ monitor.snmpOid ], (error, varbinds) => {
+                    error ? reject(error) : resolve(varbinds);
+                });
+            });
+            log.debug("monitor", `SNMP: Received varbinds (Type: ${snmp.ObjectType[varbinds[0].type]} Value: ${varbinds[0].value})`);
+
+            if (varbinds.length === 0) {
+                throw new Error(`No varbinds returned from SNMP session (OID: ${monitor.snmpOid})`);
+            }
+
+            if (varbinds[0].type === snmp.ObjectType.NoSuchInstance) {
+                throw new Error(`The SNMP query returned that no instance exists for OID ${monitor.snmpOid}`);
+            }
+
+            // We restrict querying to one OID per monitor, therefore `varbinds[0]` will always contain the value we're interested in.
+            const value = varbinds[0].value;
+
+            const { status, response } = await evaluateJsonQuery(value, monitor.jsonPath, monitor.jsonPathOperator, monitor.expectedValue);
+
+            if (status) {
+                heartbeat.status = UP;
+                heartbeat.msg = `JSON query passes (comparing ${response} ${monitor.jsonPathOperator} ${monitor.expectedValue})`;
+            } else {
+                throw new Error(`JSON query does not pass (comparing ${response} ${monitor.jsonPathOperator} ${monitor.expectedValue})`);
+            }
+        } finally {
+            if (session) {
+                session.close();
+            }
+        }
+    }
+}
+
+module.exports = {
+    SNMPMonitorType,
+};

server/monitor-types/tailscale-ping.js

@@ -2,23 +2,13 @@ const { MonitorType } = require("./monitor-type");
 const { UP } = require("../../src/util");
 const childProcessAsync = require("promisify-child-process");
 
-/**
- * A TailscalePing class extends the MonitorType.
- * It runs Tailscale ping to monitor the status of a specific node.
- */
 class TailscalePing extends MonitorType {
-
     name = "tailscale-ping";
 
     /**
-     * Checks the ping status of the URL associated with the monitor.
-     * It then parses the Tailscale ping command output to update the heatrbeat.
-     *
-     * @param {Object} monitor - The monitor object associated with the check.
-     * @param {Object} heartbeat - The heartbeat object to update.
-     * @throws Will throw an error if checking Tailscale ping encounters any error
+     * @inheritdoc
      */
-    async check(monitor, heartbeat) {
+    async check(monitor, heartbeat, _server) {
         try {
             let tailscaleOutput = await this.runTailscalePing(monitor.hostname, monitor.interval);
             this.parseTailscaleOutput(tailscaleOutput, heartbeat);
@@ -30,10 +20,9 @@ class TailscalePing extends MonitorType {
 
     /**
      * Runs the Tailscale ping command to the given URL.
-     *
-     * @param {string} hostname - The hostname to ping.
-     * @param {number} interval
-     * @returns {Promise<string>} - A Promise that resolves to the output of the Tailscale ping command
+     * @param {string} hostname The hostname to ping.
+     * @param {number} interval Interval to send ping
+     * @returns {Promise<string>} A Promise that resolves to the output of the Tailscale ping command
      * @throws Will throw an error if the command execution encounters any error.
      */
     async runTailscalePing(hostname, interval) {
@@ -54,9 +43,9 @@ class TailscalePing extends MonitorType {
 
     /**
      * Parses the output of the Tailscale ping command to update the heartbeat.
-     *
-     * @param {string} tailscaleOutput - The output of the Tailscale ping command.
-     * @param {Object} heartbeat - The heartbeat object to update.
+     * @param {string} tailscaleOutput The output of the Tailscale ping command.
+     * @param {object} heartbeat The heartbeat object to update.
+     * @returns {void}
      * @throws Will throw an eror if the output contains any unexpected string.
      */
     parseTailscaleOutput(tailscaleOutput, heartbeat) {