thelounge-plugin-ntfy 1.3.0 → 1.5.0

package/README.md

@@ -19,13 +19,15 @@ Restart The Lounge after installation
 
 This plugin introduces the `/ntfy` command, subcommands are:
 
-- `/ntfy start`: Start the ntfy listener for the network
-- `/ntfy stop`: Stop the ntfy listener for the network
-- `/ntfy status`: Show the ntfy listener status for this network
+- `/ntfy start [all]`: Start the ntfy listener for the network or all networks if 'all' is specified
+- `/ntfy stop [all]`: Stop the ntfy listener for the network or all networks if 'all' is specified
+- `/ntfy status [all]`: Show the ntfy listener status for this network or all networks if 'all' is specified
 - `/ntfy test`: Send a test notification
 - `/ntfy config`: Config commands
-  - `/ntfy config set <setting_key> <setting_value>`: Set a configuration setting
-  - `/ntfy config remove <setting_key>`: Set a configuration setting to null
+  - `/ntfy config set <setting_key> <setting_value>`: Set a global configuration setting
+  - `/ntfy config remove <setting_key>`: Set a global configuration setting to null
+  - `/ntfy config network set <setting_key> <setting_value>`: Set a per-network setting for this network
+  - `/ntfy config network remove <setting_key>`: Remove per-network setting for this network
   - `/ntfy config print`: Print the current configuration with warnings if any
 
 ## Setup
@@ -46,12 +48,14 @@ To start/stop sending push notifications in the desired network, enter:
 
 ## Private Messages
 
-By default, you will only be notified when you are mentioned, **this includes messages sent privately to you**. If you want to be notified of all private messages, enter this command and start the notifier like usual:
+By default, you will only be notified when you are mentioned, **this includes messages sent privately to you**. If you want to be notified of all private messages on a specific network, enter this command while connected to that network and start the notifier like usual:
 
 ```
-/ntfy config set config.notify_on_private_messages true
+/ntfy config network set config.notify_on_private_messages true
 ```
 
+This setting is per-network, so you can enable it for some networks and disable it for others.
+
 ## License
 
 This plugin is licensed under [MIT](https://opensource.org/license/mit)

package/index.js

@@ -6,6 +6,8 @@ const {
   setRootDir,
   loadUserConfig,
   saveUserSetting,
+  saveNetworkSetting,
+  PER_NETWORK_KEYS,
 } = require("./src/config.js");
 
 // user -> Map<network.uuid -> handler and client>
@@ -19,17 +21,27 @@ const ntfyCommand = {
 
     const helpMessage = () => {
       say(`${command} command help:`);
-      say(`/${command} start - Start the ntfy listener for this network`);
-      say(`/${command} stop - Stop the ntfy listener for this network`);
       say(
-        `/${command} status - Show the ntfy listener status for this network`,
+        `/${command} start [all] - Start the ntfy listener for this network or all networks if 'all' is specified`,
+      );
+      say(
+        `/${command} stop [all] - Stop the ntfy listener for this network or all networks if 'all' is specified`,
+      );
+      say(
+        `/${command} status [all] - Show the ntfy listener status for this network or all networks if 'all' is specified`,
       );
       say(`/${command} test - Send a test notification`);
       say(
-        `/${command} config set <setting_key> <setting_value> - Set a configuration setting`,
+        `/${command} config set <setting_key> <setting_value> - Set a global configuration setting`,
       );
       say(
-        `/${command} config remove <setting_key> - Set configuration setting to null`,
+        `/${command} config remove <setting_key> - Set global configuration setting to null`,
+      );
+      say(
+        `/${command} config network set <setting_key> <setting_value> - Set a per-network setting for this network`,
+      );
+      say(
+        `/${command} config network remove <setting_key> - Remove per-network setting for this network`,
       );
       say(
         `/${command} config print - Print the current configuration with warnings if any`,
@@ -51,82 +63,221 @@ const ntfyCommand = {
 
     switch (subcommand[0].toLowerCase()) {
       case "start": {
+        let all = false;
         const [_, errors] = loadUserConfig(client.client.name);
+        const subsubcommand = subcommand.slice(1);
+
+        if (
+          typeof subsubcommand[0] === "string" &&
+          subsubcommand.length > 0 &&
+          subsubcommand[0].toLowerCase() === "all"
+        ) {
+          all = true;
+        }
 
         if (errors.length > 0) {
-          say("Cannot start ntfy listener due to invalid configuration:");
+          say(
+            `Cannot start ntfy listener${all ? "s" : ""} due to invalid configuration:`,
+          );
+
           for (const error of errors) {
             say(`- ${error.instancePath} ${error.message}`);
           }
+
           return;
         }
 
         const userListeners = globalActiveListeners.get(client.client.name);
 
-        if (
-          userListeners &&
-          typeof userListeners.has === "function" &&
-          userListeners.has(network.uuid)
-        ) {
-          say("ntfy listener is already running for this network");
-          return;
-        }
+        if (all) {
+          const networks = client.client.networks;
+          let started = 0;
+          let skipped = 0;
 
-        const handler = createHandler(client, network);
-        network.irc.on("privmsg", handler);
+          for (const net of networks) {
+            if (
+              userListeners &&
+              typeof userListeners.has === "function" &&
+              userListeners.has(net.uuid)
+            ) {
+              skipped++;
+              continue;
+            }
 
-        if (!userListeners) {
-          const map = new Map();
-          map.set(network.uuid, { handler: handler, client: client });
-          globalActiveListeners.set(client.client.name, map);
+            const handler = createHandler(client, net);
+            net.irc.on("privmsg", handler);
+
+            if (!userListeners) {
+              const map = new Map();
+              map.set(net.uuid, { handler: handler, client: client });
+              globalActiveListeners.set(client.client.name, map);
+            } else {
+              userListeners.set(net.uuid, {
+                handler: handler,
+                client: client,
+              });
+            }
+
+            started++;
+          }
+
+          if (started === 0 && skipped === 0) {
+            say("No networks available to start ntfy listeners");
+            return;
+          }
+          if (started > 0) {
+            say(
+              `Started ntfy listener${started !== 1 ? "s" : ""} for ${started} network${started !== 1 ? "s" : ""}`,
+            );
+          }
+          if (skipped > 0) {
+            say(
+              `Skipped ${skipped} network${skipped !== 1 ? "s" : ""} because ntfy listener is already running`,
+            );
+          }
         } else {
-          userListeners.set(network.uuid, { handler: handler, client: client });
-        }
+          if (
+            userListeners &&
+            typeof userListeners.has === "function" &&
+            userListeners.has(network.uuid)
+          ) {
+            say("ntfy listener is already running for this network");
+            return;
+          }
+
+          const handler = createHandler(client, network);
+          network.irc.on("privmsg", handler);
+
+          if (!userListeners) {
+            const map = new Map();
+            map.set(network.uuid, { handler: handler, client: client });
+            globalActiveListeners.set(client.client.name, map);
+          } else {
+            userListeners.set(network.uuid, {
+              handler: handler,
+              client: client,
+            });
+          }
 
-        say("ntfy listener started for this network");
+          say("ntfy listener started for this network");
+        }
 
         break;
       }
 
       case "stop": {
-        const userListeners = globalActiveListeners.get(client.client.name);
+        let all = false;
+        const subsubcommand = subcommand.slice(1);
 
         if (
-          !userListeners ||
-          typeof userListeners.has !== "function" ||
-          !userListeners.has(network.uuid)
+          typeof subsubcommand[0] === "string" &&
+          subsubcommand.length > 0 &&
+          subsubcommand[0].toLowerCase() === "all"
         ) {
-          say("ntfy listener is not running for this network");
-          return;
+          all = true;
         }
 
-        const { handler } = userListeners.get(network.uuid);
-        network.irc.removeListener("privmsg", handler);
-        userListeners.delete(network.uuid);
+        const userListeners = globalActiveListeners.get(client.client.name);
+
+        if (all) {
+          const networks = client.client.networks;
+          let stopped = 0;
+          let skipped = 0;
+
+          for (const net of networks) {
+            if (
+              !userListeners ||
+              typeof userListeners.has !== "function" ||
+              !userListeners.has(net.uuid)
+            ) {
+              skipped++;
+              continue;
+            }
 
-        say("ntfy listener stopped for this network");
+            const { handler } = userListeners.get(net.uuid);
+            net.irc.removeListener("privmsg", handler);
+            userListeners.delete(net.uuid);
+            stopped++;
+          }
+
+          if (stopped === 0 && skipped === 0) {
+            say("No networks available to stop ntfy listeners");
+            return;
+          }
+          if (stopped > 0) {
+            say(
+              `Stopped ntfy listener${stopped !== 1 ? "s" : ""} for ${stopped} network${stopped !== 1 ? "s" : ""}`,
+            );
+          }
+          if (skipped > 0) {
+            say(
+              `Skipped ${skipped} network${skipped !== 1 ? "s" : ""} because ntfy listener was not running`,
+            );
+          }
+        } else {
+          if (
+            !userListeners ||
+            typeof userListeners.has !== "function" ||
+            !userListeners.has(network.uuid)
+          ) {
+            say("ntfy listener is not running for this network");
+            return;
+          }
+
+          const { handler } = userListeners.get(network.uuid);
+          network.irc.removeListener("privmsg", handler);
+          userListeners.delete(network.uuid);
+
+          say("ntfy listener stopped for this network");
+        }
 
         break;
       }
 
       case "status": {
-        const userListeners = globalActiveListeners.get(client.client.name);
+        let all = false;
+        const subsubcommand = subcommand.slice(1);
 
         if (
-          userListeners &&
-          typeof userListeners.has === "function" &&
-          userListeners.has(network.uuid)
+          typeof subsubcommand[0] === "string" &&
+          subsubcommand.length > 0 &&
+          subsubcommand[0].toLowerCase() === "all"
         ) {
-          say("ntfy listener is running for this network");
+          all = true;
+        }
+
+        const userListeners = globalActiveListeners.get(client.client.name);
+
+        if (all) {
+          const networks = client.client.networks;
+          for (const net of networks) {
+            if (
+              userListeners &&
+              typeof userListeners.has === "function" &&
+              userListeners.has(net.uuid)
+            ) {
+              say(`${net.name}: running`);
+            } else {
+              say(`${net.name}: not running`);
+            }
+          }
         } else {
-          say("ntfy listener is not running for this network");
+          if (
+            userListeners &&
+            typeof userListeners.has === "function" &&
+            userListeners.has(network.uuid)
+          ) {
+            say("ntfy listener is running for this network");
+          } else {
+            say("ntfy listener is not running for this network");
+          }
         }
 
         break;
       }
 
       case "test": {
-        const { NtfyClient, MessagePriority } = await import("ntfy");
+        const { NtfyClient } = await import("ntfy");
 
         const [userConfig, errors] = loadUserConfig(client.client.name);
 
@@ -152,7 +303,7 @@ const ntfyCommand = {
         const ntfyClient = new NtfyClient({
           server: userConfig.ntfy.server,
           topic: userConfig.ntfy.topic,
-          priority: MessagePriority.HIGH,
+          priority: userConfig.ntfy.priority,
           tags: ["speech_balloon"],
           authorization: ntfyAuth,
         });
@@ -229,13 +380,26 @@ const ntfyCommand = {
             const [userConfig, errors] = loadUserConfig(client.client.name);
 
             const sensitiveKeys = new Set(["ntfy.password", "ntfy.token"]);
+            const perNetworkKeys = new Set([
+              "config.notify_on_private_messages",
+            ]);
 
             const printConfig = (obj, parentKey = "") => {
               for (const key in obj) {
                 const value = obj[key];
                 const fullKey = parentKey ? `${parentKey}.${key}` : key;
 
-                if (typeof value === "object" && value !== null) {
+                if (perNetworkKeys.has(fullKey)) {
+                  // Special handling for per-network settings
+                  if (typeof value === "object" && value !== null) {
+                    const networkValue = value[network.uuid];
+                    say(
+                      `${fullKey}=${networkValue !== undefined ? networkValue : "(not set for this network)"}`,
+                    );
+                  } else {
+                    say(`${fullKey}=(not set for this network)`);
+                  }
+                } else if (typeof value === "object" && value !== null) {
                   printConfig(value, fullKey);
                 } else if (sensitiveKeys.has(fullKey) && value) {
                   say(`${fullKey}=********`);
@@ -268,6 +432,78 @@ const ntfyCommand = {
             break;
           }
 
+          case "network": {
+            const networkArgs = subsubcommand.slice(1);
+
+            if (networkArgs.length === 0) {
+              helpMessage();
+              return;
+            }
+
+            if (typeof networkArgs[0] !== "string") {
+              helpMessage();
+              return;
+            }
+
+            switch (networkArgs[0].toLowerCase()) {
+              case "set": {
+                const setArgs = networkArgs.slice(1);
+
+                if (setArgs.length < 2) {
+                  say("Usage: /ntfy config network set <setting_key> <value>");
+                  say(
+                    `Available per-network settings: ${Array.from(PER_NETWORK_KEYS).join(", ")}`,
+                  );
+                  return;
+                }
+
+                const settingKey = setArgs[0];
+                const settingValue = setArgs.slice(1).join(" ");
+                const response = saveNetworkSetting(
+                  client.client.name,
+                  settingKey,
+                  network.uuid,
+                  settingValue,
+                );
+
+                say(response);
+
+                break;
+              }
+
+              case "remove": {
+                const removeArgs = networkArgs.slice(1);
+
+                if (removeArgs.length < 1) {
+                  say("Usage: /ntfy config network remove <setting_key>");
+                  say(
+                    `Available per-network settings: ${Array.from(PER_NETWORK_KEYS).join(", ")}`,
+                  );
+                  return;
+                }
+
+                const settingKey = removeArgs[0];
+                const response = saveNetworkSetting(
+                  client.client.name,
+                  settingKey,
+                  network.uuid,
+                  null,
+                );
+
+                say(response);
+
+                break;
+              }
+
+              default: {
+                helpMessage();
+                break;
+              }
+            }
+
+            break;
+          }
+
           default: {
             helpMessage();
             break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thelounge-plugin-ntfy",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "A plugin for The Lounge that sends push notifications via ntfy when highlighted",
   "keywords": [
     "thelounge",

package/src/config.js

@@ -19,22 +19,26 @@ const DEFAULT_CONFIG = {
     username: null,
     password: null,
     token: null,
+    priority: 3,
   },
   config: {
-    notify_on_private_messages: false,
+    notify_on_private_messages: {}, // Per-network: { "network-uuid": true/false }
   },
 };
 
-const ALLOWED_KEYS = new Set([
+const GLOBAL_KEYS = new Set([
   "ntfy.server",
   "ntfy.topic",
   "ntfy.username",
   "ntfy.password",
   "ntfy.token",
-  "config.notify_on_private_messages",
+  "ntfy.priority",
 ]);
+const GLOBAL_BOOLEAN_KEYS = new Set([]);
+const GLOBAL_NUMERIC_KEYS = new Set(["ntfy.priority"]);
 
-const BOOLEAN_KEYS = new Set(["config.notify_on_private_messages"]);
+const PER_NETWORK_KEYS = new Set(["config.notify_on_private_messages"]);
+const PER_NETWORK_BOOLEAN_KEYS = new Set(["config.notify_on_private_messages"]);
 
 const SENSITIVE_KEYS = new Set(["ntfy.password", "ntfy.token"]);
 
@@ -66,6 +70,13 @@ const userConfigSchema = {
           nullable: true,
           errorMessage: "Invalid ntfy token, must start with 'tk_'",
         },
+        priority: {
+          type: "integer",
+          minimum: 1,
+          maximum: 5,
+          default: 3,
+          errorMessage: "Priority must be an integer between 1 and 5",
+        },
       },
       allOf: [
         {
@@ -110,8 +121,9 @@ const userConfigSchema = {
       required: ["notify_on_private_messages"],
       properties: {
         notify_on_private_messages: {
-          type: "boolean",
-          default: false,
+          type: "object",
+          additionalProperties: { type: ["boolean", "string"] },
+          default: {},
         },
       },
     },
@@ -227,7 +239,7 @@ function saveUserSetting(username, settingKey, settingValue) {
     throw new Error("Root directory is not set");
   }
 
-  if (ALLOWED_KEYS.has(settingKey)) {
+  if (GLOBAL_KEYS.has(settingKey)) {
     let userConfig = loadUserConfig(username)[0];
 
     const keys = settingKey.split(".");
@@ -245,7 +257,7 @@ function saveUserSetting(username, settingKey, settingValue) {
       return `Error: expected value to be a string`;
     }
 
-    if (BOOLEAN_KEYS.has(settingKey)) {
+    if (GLOBAL_BOOLEAN_KEYS.has(settingKey)) {
       try {
         settingValue = settingValue
           ? JSON.parse(settingValue.toLowerCase())
@@ -259,6 +271,18 @@ function saveUserSetting(username, settingKey, settingValue) {
       }
     }
 
+    if (GLOBAL_NUMERIC_KEYS.has(settingKey)) {
+      try {
+        settingValue = settingValue ? Number(settingValue) : NaN;
+
+        if (isNaN(settingValue) || typeof settingValue !== "number") {
+          return `Invalid value for ${settingKey}, expected a number`;
+        }
+      } catch {
+        return `Invalid value for ${settingKey}, expected a number`;
+      }
+    }
+
     curr[keys[keys.length - 1]] = settingValue;
 
     const configToSave = encryptSensitiveFields(userConfig);
@@ -276,12 +300,103 @@ function saveUserSetting(username, settingKey, settingValue) {
   }
 
   return `Invalid setting ${settingKey}, allowed settings are: ${Array.from(
-    ALLOWED_KEYS,
+    GLOBAL_KEYS,
   ).join(", ")}`;
 }
 
+function saveNetworkSetting(username, settingKey, networkUuid, settingValue) {
+  if (!rootDir) {
+    throw new Error("Root directory is not set");
+  }
+
+  if (!PER_NETWORK_KEYS.has(settingKey)) {
+    return `Invalid per-network setting ${settingKey}, allowed settings are: ${Array.from(
+      PER_NETWORK_KEYS,
+    ).join(", ")}`;
+  }
+
+  let userConfig = loadUserConfig(username)[0];
+
+  const keys = settingKey.split(".");
+
+  let curr = userConfig;
+
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (key in curr) {
+      curr = curr[key];
+    }
+  }
+
+  const finalKey = keys[keys.length - 1];
+
+  if (!curr[finalKey] || typeof curr[finalKey] !== "object") {
+    curr[finalKey] = {};
+  }
+
+  if (settingValue === null) {
+    delete curr[finalKey][networkUuid];
+  } else if (PER_NETWORK_BOOLEAN_KEYS.has(settingKey)) {
+    try {
+      const boolValue = JSON.parse(settingValue.toLowerCase());
+
+      if (typeof boolValue !== "boolean") {
+        return `Invalid value for ${settingKey}, expected a boolean`;
+      }
+
+      curr[finalKey][networkUuid] = boolValue;
+    } catch {
+      return `Invalid value for ${settingKey}, expected a boolean (true/false)`;
+    }
+  } else {
+    curr[finalKey][networkUuid] = settingValue;
+  }
+
+  const configToSave = encryptSensitiveFields(userConfig);
+
+  const userConfigPath = path.join(rootDir, "config", `${username}.json`);
+
+  fs.mkdirSync(path.dirname(userConfigPath), { recursive: true });
+  fs.writeFileSync(
+    userConfigPath,
+    JSON.stringify(configToSave, null, 2),
+    "utf-8",
+  );
+
+  return "Success";
+}
+
+function getNetworkSetting(
+  userConfig,
+  settingKey,
+  networkUuid,
+  defaultValue = false,
+) {
+  const keys = settingKey.split(".");
+
+  let curr = userConfig;
+
+  for (const key of keys) {
+    if (curr && typeof curr === "object" && key in curr) {
+      curr = curr[key];
+    } else {
+      return defaultValue;
+    }
+  }
+
+  if (curr && typeof curr === "object" && networkUuid in curr) {
+    return curr[networkUuid];
+  }
+
+  return defaultValue;
+}
+
 module.exports = {
   setRootDir,
   loadUserConfig,
   saveUserSetting,
+  saveNetworkSetting,
+  getNetworkSetting,
+  PER_NETWORK_KEYS,
+  PER_NETWORK_BOOLEAN_KEYS,
 };

package/src/handler.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const { loadUserConfig } = require("./config.js");
+const { loadUserConfig, getNetworkSetting } = require("./config.js");
 const { PluginLogger } = require("./logger.js");
 
 function createHandler(client, network) {
@@ -19,11 +19,11 @@ function createHandler(client, network) {
     let notify = false;
     let userConfig;
 
-    if (mentioned) {
-      // Mentions always notify
+    if (mentioned && !isPM) {
+      // Mentions always notify in channels
       notify = true;
     } else if (isPM) {
-      // PMs notify only if enabled in config
+      // PMs notify only if enabled in config for this network
       const [uc, errors] = loadUserConfig(client.client.name);
 
       if (errors.length > 0) {
@@ -32,7 +32,14 @@ function createHandler(client, network) {
 
       userConfig = uc;
 
-      if (userConfig.config.notify_on_private_messages) {
+      const notifyOnPMs = getNetworkSetting(
+        userConfig,
+        "config.notify_on_private_messages",
+        network.uuid,
+        false,
+      );
+
+      if (notifyOnPMs) {
         notify = true;
       }
     }
@@ -64,12 +71,12 @@ function createHandler(client, network) {
           };
         }
 
-        const { NtfyClient, MessagePriority } = await import("ntfy");
+        const { NtfyClient } = await import("ntfy");
 
         const ntfyClient = new NtfyClient({
           server: userConfig.ntfy.server,
           topic: userConfig.ntfy.topic,
-          priority: MessagePriority.HIGH,
+          priority: userConfig.ntfy.priority,
           tags: ["speech_balloon"],
           authorization: ntfyAuth,
         });