@lordbex/thelounge 4.4.4-blowfish → 4.5.1-blowfish

package/dist/server/plugins/irc-events/part.js

@@ -1,13 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-exports.default = (function (irc, network) {
-    const client = this;
-    irc.on("part", function (data) {
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+export default (function (irc, network) {
+    irc.on("part", (data) => {
         if (!data.channel) {
             return;
         }
@@ -16,20 +10,30 @@ exports.default = (function (irc, network) {
             return;
         }
         const user = chan.getUser(data.nick);
-        const msg = new msg_1.default({
-            type: msg_2.MessageType.PART,
+        const msg = new Msg({
+            type: MessageType.PART,
             time: data.time,
             text: data.message || "",
             hostmask: data.ident + "@" + data.hostname,
             from: user,
             self: data.nick === irc.user.nick,
         });
-        chan.pushMessage(client, msg);
+        // Self parts should not be buffered and need special handling
         if (data.nick === irc.user.nick) {
-            client.part(network, chan);
+            chan.pushMessage(this, msg);
+            this.part(network, chan);
+            return;
         }
-        else {
+        // User list update callback - executed regardless of buffering
+        const updateUserList = () => {
             chan.removeUser(user);
+        };
+        // Try to process through mass event aggregator
+        const wasBuffered = this.massEventAggregator.processMessage(network, chan, msg, updateUserList);
+        if (!wasBuffered) {
+            // Not in mass event mode - process normally
+            chan.pushMessage(this, msg);
+            updateUserList();
         }
     });
 });

package/dist/server/plugins/irc-events/quit.js

@@ -1,27 +1,30 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-exports.default = (function (irc, network) {
-    const client = this;
-    irc.on("quit", function (data) {
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+export default (function (irc, network) {
+    irc.on("quit", (data) => {
         network.channels.forEach((chan) => {
             const user = chan.findUser(data.nick);
             if (typeof user === "undefined") {
                 return;
             }
-            const msg = new msg_1.default({
+            const msg = new Msg({
                 time: data.time,
-                type: msg_2.MessageType.QUIT,
+                type: MessageType.QUIT,
                 text: data.message || "",
                 hostmask: data.ident + "@" + data.hostname,
                 from: user,
             });
-            chan.pushMessage(client, msg);
-            chan.removeUser(user);
+            // User list update callback - executed regardless of buffering
+            const updateUserList = () => {
+                chan.removeUser(user);
+            };
+            // Try to process through mass event aggregator
+            const wasBuffered = this.massEventAggregator.processMessage(network, chan, msg, updateUserList);
+            if (!wasBuffered) {
+                // Not in mass event mode - process normally
+                chan.pushMessage(this, msg);
+                updateUserList();
+            }
         });
         // If user with the nick we are trying to keep has quit, try to get this nick
         if (network.keepNick === data.nick) {

package/dist/server/plugins/irc-events/sasl.js

@@ -1,26 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-exports.default = (function (irc, network) {
-    const client = this;
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+export default (function (irc, network) {
     irc.on("loggedin", (data) => {
         const lobby = network.getLobby();
-        const msg = new msg_1.default({
-            type: msg_2.MessageType.LOGIN,
+        const msg = new Msg({
+            type: MessageType.LOGIN,
             text: "Logged in as: " + data.account,
         });
-        lobby.pushMessage(client, msg, true);
+        lobby.pushMessage(this, msg, true);
     });
     irc.on("loggedout", () => {
         const lobby = network.getLobby();
-        const msg = new msg_1.default({
-            type: msg_2.MessageType.LOGOUT,
+        const msg = new Msg({
+            type: MessageType.LOGOUT,
             text: "Logged out",
         });
-        lobby.pushMessage(client, msg, true);
+        lobby.pushMessage(this, msg, true);
     });
 });

package/dist/server/plugins/irc-events/spgroups.js

@@ -0,0 +1,38 @@
+import log from "../../log.js";
+export default (function (irc, network) {
+    // Handle SPGROUPS command from seedpool/enhanced capable servers
+    // Format: :SeedServ SPGROUPS #channel :{"groups":[{"name":"Sysop","users":["admin1"]}, ...]}
+    irc.on("unknown command", (command) => {
+        if (command.command !== "SPGROUPS") {
+            return;
+        }
+        const channelName = command.params[0];
+        const jsonPayload = command.params[1];
+        if (!channelName || !jsonPayload) {
+            log.warn("SPGROUPS: Missing channel or payload");
+            return;
+        }
+        const chan = network.getChannel(channelName);
+        if (!chan) {
+            log.warn(`SPGROUPS: Channel ${channelName} not found`);
+            return;
+        }
+        try {
+            const data = JSON.parse(jsonPayload);
+            if (!data.groups || !Array.isArray(data.groups)) {
+                log.warn("SPGROUPS: Invalid payload format, expected {groups: [...]}");
+                return;
+            }
+            // Store groups on the channel, sorted by position (highest first)
+            chan.groups = data.groups.sort((a, b) => b.position - a.position);
+            // Emit to client
+            this.emit("channel:groups", {
+                chan: chan.id,
+                groups: chan.groups,
+            });
+        }
+        catch (err) {
+            log.error(`SPGROUPS: Failed to parse JSON payload: ${String(err)}`);
+        }
+    });
+});

package/dist/server/plugins/irc-events/spjoin.js

@@ -0,0 +1,52 @@
+import log from "../../log.js";
+export default (function (irc, network) {
+    // Handle SPJOIN command from seedpool/enhanced capable servers
+    // Format: :SeedServ SPJOIN #channel nickname :GroupName
+    irc.on("unknown command", (command) => {
+        if (command.command !== "SPJOIN") {
+            return;
+        }
+        const channelName = command.params[0];
+        const nickname = command.params[1];
+        const groupName = command.params[2];
+        if (!channelName || !nickname || !groupName) {
+            log.warn("SPJOIN: Missing channel, nickname, or group");
+            return;
+        }
+        const chan = network.getChannel(channelName);
+        if (!chan) {
+            log.warn(`SPJOIN: Channel ${channelName} not found`);
+            return;
+        }
+        if (!chan.groups) {
+            chan.groups = [];
+        }
+        // Remove user from any existing group (in case of group change)
+        for (const group of chan.groups) {
+            const lowerUsers = group.users.map((u) => u.toLowerCase());
+            const userIndex = lowerUsers.indexOf(nickname.toLowerCase());
+            if (userIndex !== -1) {
+                group.users.splice(userIndex, 1);
+            }
+        }
+        // Find the target group or create it
+        let targetGroup = chan.groups.find((g) => g.name === groupName);
+        if (!targetGroup) {
+            // Find the lowest existing position and go below it
+            const lowestPosition = chan.groups.length > 0 ? Math.min(...chan.groups.map((g) => g.position)) - 1 : 0;
+            targetGroup = { name: groupName, position: lowestPosition, users: [] };
+            chan.groups.push(targetGroup);
+        }
+        // Add user to the group
+        if (!targetGroup.users.map((u) => u.toLowerCase()).includes(nickname.toLowerCase())) {
+            targetGroup.users.push(nickname);
+        }
+        // Sort groups by position (highest first) before emitting
+        chan.groups.sort((a, b) => b.position - a.position);
+        // Emit updated groups to client
+        this.emit("channel:groups", {
+            chan: chan.id,
+            groups: chan.groups,
+        });
+    });
+});

package/dist/server/plugins/irc-events/topic.js

@@ -1,42 +1,36 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-exports.default = (function (irc, network) {
-    const client = this;
-    irc.on("topic", function (data) {
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+export default (function (irc, network) {
+    irc.on("topic", (data) => {
         const chan = network.getChannel(data.channel);
         if (typeof chan === "undefined") {
             return;
         }
-        const msg = new msg_1.default({
+        const msg = new Msg({
             time: data.time,
-            type: msg_2.MessageType.TOPIC,
+            type: MessageType.TOPIC,
             from: data.nick && chan.getUser(data.nick),
             text: data.topic,
             self: data.nick === irc.user.nick,
         });
-        chan.pushMessage(client, msg);
+        chan.pushMessage(this, msg);
         chan.topic = data.topic;
-        client.emit("topic", {
+        this.emit("topic", {
             chan: chan.id,
             topic: chan.topic,
         });
     });
-    irc.on("topicsetby", function (data) {
+    irc.on("topicsetby", (data) => {
         const chan = network.getChannel(data.channel);
         if (typeof chan === "undefined") {
             return;
         }
-        const msg = new msg_1.default({
-            type: msg_2.MessageType.TOPIC_SET_BY,
+        const msg = new Msg({
+            type: MessageType.TOPIC_SET_BY,
             from: chan.getUser(data.nick),
             when: new Date(data.when * 1000),
             self: data.nick === irc.user.nick,
         });
-        chan.pushMessage(client, msg);
+        chan.pushMessage(this, msg);
     });
 });

package/dist/server/plugins/irc-events/unhandled.js

@@ -1,13 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-exports.default = (function (irc, network) {
-    const client = this;
-    irc.on("unknown command", function (command) {
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+// Commands handled by other plugins - don't display as unhandled
+const handledCommands = new Set(["SPGROUPS", "SPJOIN"]);
+export default (function (irc, network) {
+    irc.on("unknown command", (command) => {
+        // Skip commands that are handled by other plugins
+        if (handledCommands.has(command.command)) {
+            return;
+        }
         let target = network.getLobby();
         // Do not display users own name
         if (command.params.length > 0 && command.params[0] === network.irc.user.nick) {
@@ -22,8 +22,8 @@ exports.default = (function (irc, network) {
                 target = channel;
             }
         }
-        target.pushMessage(client, new msg_1.default({
-            type: msg_2.MessageType.UNHANDLED,
+        target.pushMessage(this, new Msg({
+            type: MessageType.UNHANDLED,
             command: command.command,
             params: command.params,
         }), true);

package/dist/server/plugins/irc-events/welcome.js

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-exports.default = (function (irc, network) {
-    const client = this;
-    irc.on("registered", function (data) {
+import Msg from "../../models/msg.js";
+export default (function (irc, network) {
+    irc.on("registered", (data) => {
         network.setNick(data.nick);
         const lobby = network.getLobby();
-        const msg = new msg_1.default({
+        const msg = new Msg({
             text: "You're now known as " + data.nick,
         });
-        lobby.pushMessage(client, msg);
-        client.save();
-        client.emit("nick", {
+        lobby.pushMessage(this, msg);
+        this.save();
+        this.emit("nick", {
             network: network.uuid,
             nick: data.nick,
         });

package/dist/server/plugins/irc-events/whois.js

@@ -1,17 +1,13 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const msg_1 = __importDefault(require("../../models/msg"));
-const msg_2 = require("../../../shared/types/msg");
-const chan_1 = require("../../../shared/types/chan");
-exports.default = (function (irc, network) {
-    const client = this;
-    irc.on("whois", handleWhois);
+import Msg from "../../models/msg.js";
+import { MessageType } from "../../../shared/types/msg.js";
+import { ChanType } from "../../../shared/types/chan.js";
+export default (function (irc, network) {
+    irc.on("whois", (data) => {
+        handleWhois.call(this, data);
+    });
     irc.on("whowas", (data) => {
         data.whowas = true;
-        handleWhois(data);
+        handleWhois.call(this, data);
     });
     function handleWhois(data) {
         let chan = network.getChannel(data.nick);
@@ -21,37 +17,37 @@ exports.default = (function (irc, network) {
                 chan = network.getLobby();
             }
             else {
-                chan = client.createChannel({
-                    type: chan_1.ChanType.QUERY,
+                chan = this.createChannel({
+                    type: ChanType.QUERY,
                     name: data.nick,
                 });
-                client.emit("join", {
+                this.emit("join", {
                     network: network.uuid,
                     chan: chan.getFilteredClone(true),
                     shouldOpen: true,
                     index: network.addChannel(chan),
                 });
-                chan.loadMessages(client, network);
-                client.save();
+                chan.loadMessages(this, network);
+                this.save();
             }
         }
         let msg;
         if (data.error) {
-            msg = new msg_1.default({
-                type: msg_2.MessageType.ERROR,
+            msg = new Msg({
+                type: MessageType.ERROR,
                 text: "No such nick: " + data.nick,
             });
         }
         else {
             // Absolute datetime in milliseconds since nick is idle
-            data.idleTime = Date.now() - data.idle * 1000;
+            data.idleTime = Date.now() - (data.idle ?? 0) * 1000;
             // Absolute datetime in milliseconds when nick logged on.
-            data.logonTime = data.logon * 1000;
-            msg = new msg_1.default({
-                type: msg_2.MessageType.WHOIS,
+            data.logonTime = (data.logon ?? 0) * 1000;
+            msg = new Msg({
+                type: MessageType.WHOIS,
                 whois: data,
             });
         }
-        chan.pushMessage(client, msg);
+        chan.pushMessage(this, msg);
     }
 });

package/dist/server/plugins/massEventAggregator.js

@@ -0,0 +1,214 @@
+import Msg from "../models/msg.js";
+import Config from "../config.js";
+import log from "../log.js";
+import { MessageType } from "../../shared/types/msg.js";
+import { condensedTypes } from "../../shared/irc.js";
+class MassEventAggregator {
+    channelStates = new Map();
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    getOrCreateState(chanId) {
+        if (!this.channelStates.has(chanId)) {
+            this.channelStates.set(chanId, {
+                isActive: false,
+                buffer: [],
+                preBuffer: [],
+                startTime: null,
+                cooldownTimer: null,
+                maxDurationTimer: null,
+                recentTimestamps: [],
+            });
+        }
+        return this.channelStates.get(chanId);
+    }
+    /**
+     * Process an incoming status message.
+     * Returns true if the message was buffered (mass event active).
+     * Returns false if the message should be sent normally.
+     */
+    processMessage(network, chan, msg, userUpdateCallback) {
+        // Check if mass event detection is enabled
+        if (!Config.values.massEventDetection?.enable) {
+            return false;
+        }
+        // Only process condensable message types
+        if (!condensedTypes.has(msg.type)) {
+            return false;
+        }
+        // Never buffer self messages or highlights
+        if (msg.self || msg.highlight) {
+            return false;
+        }
+        const config = Config.values.massEventDetection;
+        const state = this.getOrCreateState(chan.id);
+        const now = Date.now();
+        // Update recent timestamps (sliding window)
+        state.recentTimestamps.push(now);
+        const windowStart = now - config.windowMs;
+        state.recentTimestamps = state.recentTimestamps.filter((t) => t > windowStart);
+        // Check if we should activate mass event mode
+        if (!state.isActive) {
+            // Track message in preBuffer for accurate counting when activation happens
+            state.preBuffer.push({ msg, timestamp: now });
+            // Clean old messages from preBuffer (keep only within window)
+            state.preBuffer = state.preBuffer.filter((m) => m.timestamp > windowStart);
+            if (state.recentTimestamps.length >= config.threshold) {
+                log.debug(`MassEvent: ACTIVATING for ${chan.name} (${state.recentTimestamps.length} msgs, ${state.preBuffer.length} in preBuffer)`);
+                // Move preBuffer to main buffer when activating
+                state.buffer = [...state.preBuffer];
+                state.preBuffer = [];
+                this.activateMassEvent(state, chan, network, now);
+                // Execute user update callback
+                if (userUpdateCallback) {
+                    userUpdateCallback();
+                }
+                // Reset cooldown timer
+                this.resetCooldownTimer(state, chan, network);
+                return true; // Message was captured in preBuffer, now in main buffer
+            }
+            return false; // Not in mass event mode, process normally
+        }
+        // We're in mass event mode - buffer the message
+        state.buffer.push({ msg, timestamp: now });
+        // Execute user update callback (for real-time user list updates)
+        if (userUpdateCallback) {
+            userUpdateCallback();
+        }
+        // Reset cooldown timer
+        this.resetCooldownTimer(state, chan, network);
+        return true;
+    }
+    activateMassEvent(state, chan, network, now) {
+        state.isActive = true;
+        state.startTime = now;
+        const config = Config.values.massEventDetection;
+        // Set maximum duration timer
+        state.maxDurationTimer = setTimeout(() => {
+            this.endMassEvent(state, chan, network);
+        }, config.maxDurationMs);
+    }
+    resetCooldownTimer(state, chan, network) {
+        if (state.cooldownTimer) {
+            clearTimeout(state.cooldownTimer);
+        }
+        const config = Config.values.massEventDetection;
+        state.cooldownTimer = setTimeout(() => {
+            this.endMassEvent(state, chan, network);
+        }, config.cooldownMs);
+    }
+    endMassEvent(state, chan, network) {
+        if (!state.isActive) {
+            return;
+        }
+        log.debug(`MassEvent: ENDING for ${chan.name} (${state.buffer.length} buffered msgs)`);
+        // Clear timers
+        if (state.cooldownTimer) {
+            clearTimeout(state.cooldownTimer);
+            state.cooldownTimer = null;
+        }
+        if (state.maxDurationTimer) {
+            clearTimeout(state.maxDurationTimer);
+            state.maxDurationTimer = null;
+        }
+        // Generate summary
+        const summary = this.generateSummary(state);
+        log.debug(`MassEvent: Summary - joins=${summary.joins} parts=${summary.parts} quits=${summary.quits}`);
+        // Create summary message
+        const summaryMsg = new Msg({
+            type: MessageType.MASS_EVENT,
+            time: new Date(),
+            massEventSummary: summary,
+        });
+        // Push summary message through normal channel
+        chan.pushMessage(this.client, summaryMsg);
+        // Reset state
+        state.isActive = false;
+        state.buffer = [];
+        state.preBuffer = [];
+        state.startTime = null;
+        state.recentTimestamps = [];
+        // Refresh user list if configured
+        if (Config.values.massEventDetection.refreshNamesAfter && network.irc) {
+            network.irc.raw("NAMES", chan.name);
+        }
+    }
+    generateSummary(state) {
+        const now = Date.now();
+        const summary = {
+            joins: 0,
+            parts: 0,
+            quits: 0,
+            modes: 0,
+            nicks: 0,
+            kicks: 0,
+            chghosts: 0,
+            away: 0,
+            back: 0,
+            duration: now - (state.startTime || now),
+            startTime: new Date(state.startTime || now),
+            endTime: new Date(),
+        };
+        for (const { msg } of state.buffer) {
+            switch (msg.type) {
+                case MessageType.JOIN:
+                    summary.joins++;
+                    break;
+                case MessageType.PART:
+                    summary.parts++;
+                    break;
+                case MessageType.QUIT:
+                    summary.quits++;
+                    break;
+                case MessageType.MODE:
+                    // Count individual mode changes
+                    const modeText = msg.text || "";
+                    const modeChanges = modeText
+                        .split(" ")[0]
+                        .split("")
+                        .filter((c) => c !== "+" && c !== "-").length;
+                    summary.modes += modeChanges || 1;
+                    break;
+                case MessageType.NICK:
+                    summary.nicks++;
+                    break;
+                case MessageType.KICK:
+                    summary.kicks++;
+                    break;
+                case MessageType.CHGHOST:
+                    summary.chghosts++;
+                    break;
+                case MessageType.AWAY:
+                    summary.away++;
+                    break;
+                case MessageType.BACK:
+                    summary.back++;
+                    break;
+            }
+        }
+        return summary;
+    }
+    /**
+     * Clean up state for a channel (e.g., when leaving)
+     */
+    cleanup(chanId) {
+        const state = this.channelStates.get(chanId);
+        if (state) {
+            if (state.cooldownTimer) {
+                clearTimeout(state.cooldownTimer);
+            }
+            if (state.maxDurationTimer) {
+                clearTimeout(state.maxDurationTimer);
+            }
+            this.channelStates.delete(chanId);
+        }
+    }
+    /**
+     * Check if mass event is active for a channel
+     */
+    isActive(chanId) {
+        return this.channelStates.get(chanId)?.isActive || false;
+    }
+}
+export default MassEventAggregator;