thelounge-plugin-ntfy 1.0.0

package/README.md

@@ -0,0 +1,44 @@
+# The Lounge ntfy Plugin
+
+A plugin for [The Lounge](https://thelounge.chat/) that sends a message to an [ntfy](https://ntfy.sh/) server whenever you are mentioned in a chat.
+
+## Installation
+
+Via the `thelounge` command line:
+
+```bash
+thelounge install thelounge-plugin-ntfy
+```
+
+Restart The Lounge after installation
+
+## Usage
+
+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 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 print`: Print the current configuration with warnings if any
+
+## Setup
+
+This plugin will **not** work out of the box, by default the plugin sends notifications to the official `ntfy.sh` server but no topic is set. To set a topic, enter this command:
+
+```
+/ntfy config set ntfy.topic <topic>
+```
+
+You may also set your account credentials or token as well if needed, see the config print command for all the possible settings.
+
+To start/stop sending push notifications in the desired network, enter:
+
+```
+/ntfy start/stop
+```
+
+## License
+
+This plugin is licensed under [MIT](https://opensource.org/license/mit)

package/docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  thelounge:
+    image: ghcr.io/thelounge/thelounge:latest
+    container_name: thelounge
+    network_mode: bridge
+    ports:
+      - 9000:9000
+    restart: unless-stopped
+    volumes:
+      - $PWD/tl:/var/opt/thelounge

package/index.js

@@ -0,0 +1,230 @@
+"use strict";
+
+const { PluginLogger } = require("./src/logger.js");
+const { createHandler } = require("./src/handler.js");
+const {
+  setRootDir,
+  loadUserConfig,
+  saveUserSetting,
+} = require("./src/config.js");
+
+// user -> Map<network.uuid -> handler and client>
+const globalActiveListeners = new Map();
+
+const ntfyCommand = {
+  input: (client, target, command, args) => {
+    const say = (message) => {
+      client.sendMessage(message, target.chan);
+    };
+
+    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} config set <setting_key> <setting_value> - Set a configuration setting`
+      );
+      say(
+        `/${command} config remove <setting_key> - Set configuration setting to null`
+      );
+      say(
+        `/${command} config print - Print the current configuration with warnings if any`
+      );
+    };
+
+    const subcommand = args;
+    const network = target.network;
+
+    if (subcommand.length === 0) {
+      helpMessage();
+      return;
+    }
+
+    if (typeof subcommand[0] !== "string") {
+      helpMessage();
+      return;
+    }
+
+    switch (subcommand[0].toLowerCase()) {
+      case "start": {
+        const [_, errors] = loadUserConfig(client.client.name);
+
+        if (errors.length > 0) {
+          say("Cannot start ntfy listener 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;
+        }
+
+        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");
+
+        break;
+      }
+
+      case "stop": {
+        const userListeners = globalActiveListeners.get(client.client.name);
+
+        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 "config": {
+        const subsubcommand = subcommand.slice(1);
+
+        if (subsubcommand.length === 0) {
+          helpMessage();
+          return;
+        }
+
+        if (typeof subsubcommand[0] !== "string") {
+          helpMessage();
+          return;
+        }
+
+        switch (subsubcommand[0].toLowerCase()) {
+          case "set": {
+            const subsubargs = subsubcommand.slice(1);
+
+            if (subsubargs.length < 2) {
+              helpMessage();
+              return;
+            }
+
+            const settingKey = subsubargs[0];
+            const settingValue = subsubargs.slice(1).join(" ");
+            const response = saveUserSetting(
+              client.client.name,
+              settingKey,
+              settingValue
+            );
+
+            say(response);
+
+            break;
+          }
+
+          case "remove": {
+            const subsubargs = subsubcommand.slice(1);
+
+            if (subsubargs.length < 1) {
+              helpMessage();
+              return;
+            }
+
+            const settingKey = subsubargs[0];
+            const response = saveUserSetting(
+              client.client.name,
+              settingKey,
+              null
+            );
+
+            say(response);
+
+            break;
+          }
+
+          case "print": {
+            const [userConfig, errors] = loadUserConfig(client.client.name);
+
+            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) {
+                  printConfig(value, fullKey);
+                } else {
+                  say(`${fullKey}=${value}`);
+                }
+              }
+            };
+
+            printConfig(userConfig);
+
+            if (errors.length > 0) {
+              say("");
+
+              for (const error of errors) {
+                say(`Warning: ${error.instancePath} ${error.message}`);
+              }
+            }
+
+            if (
+              userConfig.ntfy.token &&
+              userConfig.ntfy.username &&
+              userConfig.ntfy.password
+            ) {
+              say(
+                "Warning: Both ntfy.token and ntfy.username/password are set, ntfy.token will be used for authentication"
+              );
+            }
+
+            break;
+          }
+
+          default: {
+            helpMessage();
+            break;
+          }
+        }
+
+        break;
+      }
+
+      default: {
+        helpMessage();
+        break;
+      }
+    }
+  },
+  allowDisconnected: true,
+};
+
+module.exports = {
+  onServerStart(tl) {
+    PluginLogger.init(tl.Logger);
+
+    const configDir = tl.Config.getPersistentStorageDir();
+    setRootDir(configDir);
+    PluginLogger.info(`[ntfy] Using config directory: ${configDir}`);
+
+    tl.Commands.add("ntfy", ntfyCommand);
+  },
+};

package/misc/api.txt

@@ -0,0 +1,53 @@
+https://thelounge.chat/docs/api
+
+api
+    Commands
+        add(commandText: string, command: Command)
+    Config
+        getConfig()
+        getPersistentStorageDir()
+    Logger
+        error(...args)
+        warn(...args)
+        info(...args)
+        debug(...args)
+    Stylesheets
+        addFile(filename: String)
+
+command
+    input(client: Client, target: Target, command: String, args: String[])
+    allowDisconnected: bool
+
+target
+    network: String
+    chan: String
+
+client
+    runAsUser(command: String, targetId: String)
+    createChannel(attributes: Attributes)
+    sendToBrowser(event: String, data: Object)
+    getChannel(channelId: Number)
+    sendMessage(text: String, chan: Chan)
+
+attributes
+    id: Number
+    messages: Msg[]
+    name: string
+    key: String
+    topic: String
+    type: Chan.Type
+    state: Chan.State
+    firstUnread: Number
+    unread: Number
+    highlight: Number
+    users: String -> User Map
+
+Chan.Type
+    CHANNEL
+    LOBBY
+    QUERY
+    SPECIAL
+
+Chan.State
+    PARTED
+    JOINED

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "thelounge-plugin-ntfy",
+  "version": "1.0.0",
+  "description": "A plugin for The Lounge that sends push notifications via ntfy when highlighted",
+  "keywords": [
+    "thelounge",
+    "thelounge-plugin",
+    "ntfy",
+    "irc"
+  ],
+  "thelounge": {
+    "name": "ntfy",
+    "type": "plugin",
+    "supports": ">=4.0.0"
+  },
+  "homepage": "https://github.com/cy1der/thelounge-plugin-ntfy#readme",
+  "bugs": {
+    "url": "https://github.com/cy1der/thelounge-plugin-ntfy/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cy1der/thelounge-plugin-ntfy.git"
+  },
+  "license": "MIT",
+  "author": "cy1der",
+  "type": "commonjs",
+  "main": "index.js",
+  "dependencies": {
+    "ajv": "^8.17.1",
+    "ajv-errors": "^3.0.0",
+    "ajv-formats": "^3.0.1",
+    "ntfy": "^1.11.8",
+    "thelounge": "^4.4.3"
+  }
+}

package/src/config.js

@@ -0,0 +1,181 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const Ajv2019 = require("ajv/dist/2019").default;
+const addFormats = require("ajv-formats");
+const addErrors = require("ajv-errors");
+
+const DEFAULT_CONFIG = {
+  ntfy: {
+    server: "https://ntfy.sh",
+    topic: null, // Intentionally left null to force user configuration
+    username: null,
+    password: null,
+    token: null,
+  },
+};
+
+const ALLOWED_KEYS = new Set([
+  "ntfy.server",
+  "ntfy.topic",
+  "ntfy.username",
+  "ntfy.password",
+  "ntfy.token",
+]);
+
+const userConfigSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["ntfy"],
+  properties: {
+    ntfy: {
+      type: "object",
+      additionalProperties: false,
+      required: ["server", "topic"],
+      properties: {
+        server: {
+          type: "string",
+          format: "uri",
+          errorMessage: "Invalid server URL",
+        },
+        topic: {
+          type: "string",
+          minLength: 1,
+          errorMessage: "Topic cannot be empty",
+        },
+        username: { type: "string", nullable: true },
+        password: { type: "string", nullable: true },
+        token: {
+          type: "string",
+          format: "ntfy-token",
+          nullable: true,
+          errorMessage: "Invalid ntfy token, must start with 'tk_'",
+        },
+      },
+      allOf: [
+        {
+          if: {
+            properties: { username: { type: "string" } },
+            required: ["username"],
+          },
+          then: {
+            properties: { password: { type: "string" } },
+            required: ["password"],
+            errorMessage: {
+              properties: {
+                password: "Password is required when username is set",
+              },
+            },
+          },
+        },
+        {
+          if: {
+            properties: { password: { type: "string" } },
+            required: ["password"],
+          },
+          then: {
+            properties: { username: { type: "string" } },
+            required: ["username"],
+            errorMessage: {
+              properties: {
+                username: "Username is required when password is set",
+              },
+            },
+          },
+        },
+      ],
+      dependentRequired: {
+        username: ["password"],
+        password: ["username"],
+      },
+    },
+  },
+};
+
+const ajv = new Ajv2019({ allErrors: true });
+addFormats(ajv);
+addErrors(ajv);
+ajv.addFormat("ntfy-token", {
+  validate: (data) => typeof data === "string" && data.startsWith("tk_"),
+});
+
+let rootDir = null;
+
+function setRootDir(dir) {
+  rootDir = dir;
+}
+
+function loadUserConfig(username) {
+  if (!rootDir) {
+    throw new Error("Root directory is not set");
+  }
+
+  const userConfigPath = path.join(rootDir, "config", `${username}.json`);
+
+  if (!fs.existsSync(userConfigPath)) {
+    const validate = ajv.compile(userConfigSchema);
+    const valid = validate(DEFAULT_CONFIG);
+
+    return [DEFAULT_CONFIG, valid ? [] : validate.errors];
+  } else {
+    let userConfig;
+
+    try {
+      userConfig = JSON.parse(fs.readFileSync(userConfigPath, "utf-8"));
+    } catch (e) {
+      throw new Error(
+        `Invalid JSON in user config for ${username}: ${e.message}`
+      );
+    }
+
+    const validate = ajv.compile(userConfigSchema);
+    const valid = validate(userConfig);
+
+    return [userConfig, valid ? [] : validate.errors];
+  }
+}
+
+function saveUserSetting(username, settingKey, settingValue) {
+  if (!rootDir) {
+    throw new Error("Root directory is not set");
+  }
+
+  if (ALLOWED_KEYS.has(settingKey)) {
+    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];
+      }
+    }
+
+    curr[keys[keys.length - 1]] = settingValue;
+
+    const userConfigPath = path.join(rootDir, "config", `${username}.json`);
+
+    fs.mkdirSync(path.dirname(userConfigPath), { recursive: true });
+    fs.writeFileSync(
+      userConfigPath,
+      JSON.stringify(userConfig, null, 2),
+      "utf-8"
+    );
+
+    return "Success";
+  }
+
+  return `Invalid setting ${settingKey}, allowed settings are: ${Array.from(
+    ALLOWED_KEYS
+  ).join(", ")}`;
+}
+
+module.exports = {
+  setRootDir,
+  loadUserConfig,
+  saveUserSetting,
+};

package/src/handler.js

@@ -0,0 +1,49 @@
+"use strict";
+
+const { loadUserConfig } = require("./config.js");
+
+function createHandler(client, network) {
+  return async (data) => {
+    const highlightRegex = new RegExp(network.highlightRegex, "i");
+    const message = data.message || "";
+
+    if (highlightRegex.test(message)) {
+      // Load config after each message to get latest settings
+      const [userConfig, errors] = loadUserConfig(client.client.name);
+
+      if (errors.length > 0) {
+        return;
+      }
+
+      let ntfyAuth;
+
+      if (userConfig.ntfy.token) {
+        ntfyAuth = userConfig.ntfy.token;
+      } else if (userConfig.ntfy.username && userConfig.ntfy.password) {
+        ntfyAuth = {
+          username: userConfig.ntfy.username,
+          password: userConfig.ntfy.password,
+        };
+      }
+
+      const { NtfyClient, MessagePriority } = await import("ntfy");
+
+      const ntfyClient = new NtfyClient({
+        server: userConfig.ntfy.server,
+        topic: userConfig.ntfy.topic,
+        priority: MessagePriority.HIGH,
+        tags: ["speech_balloon"],
+        authorization: ntfyAuth,
+      });
+
+      ntfyClient.publish({
+        title: `${network.name} ${data.target}: ${data.nick}`,
+        message: message,
+      });
+    }
+  };
+}
+
+module.exports = {
+  createHandler,
+};

package/src/logger.js

@@ -0,0 +1,26 @@
+"use strict";
+
+let Logger;
+
+// Inspired by https://github.com/juanjocerero/thelounge-plugin-am/blob/main/src/logger.js
+const PluginLogger = {
+  init: (logger) => {
+    Logger = logger;
+  },
+  error: (...args) => {
+    if (Logger) Logger.error(...args);
+  },
+  warn: (...args) => {
+    if (Logger) Logger.warn(...args);
+  },
+  info: (...args) => {
+    if (Logger) Logger.info(...args);
+  },
+  debug: (...args) => {
+    if (Logger) Logger.debug(...args);
+  },
+};
+
+module.exports = {
+  PluginLogger,
+};