nodebb-plugin-admin-chats 1.0.2 → 2.0.0

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "kiroAgent.configureMCP": "Disabled"
+}

package/README.md

@@ -0,0 +1,56 @@
+# Super Admin Chat Control for NodeBB
+
+A professional administration plugin for NodeBB that allows administrators to monitor, manage, and interact with any chat room on the forum, regardless of membership.
+
+## Main Features
+
+* **Global Chat Access**: Administrators can view any private or group conversation.
+* **Management Privileges**: Grants admins the ability to edit or delete any message in any room.
+* **Admin Room Locking**: Administrators can lock any chat room so only admins can continue replying.
+* **Profile Integration**: Adds a "View Chats" button to the user profile menu for administrators to quickly audit a user's interactions.
+* **Non-Intrusive Monitoring**: Admins can load and view room history without being added as permanent members, maintaining a clean member list.
+* **UI Enhancements**: Replaces generic "no chats" messages with helpful instructions for admins and supports both English and Hebrew interfaces.
+
+## Technical Overview
+
+### Plugin Information
+* **Name**: Super Admin Chat Control
+* **ID**: `nodebb-plugin-admin-chats`
+* **Compatibility**: NodeBB versions `^3.0.0` or `^4.0.0`
+
+### Implemented Hooks
+The plugin utilizes several filters to elevate administrator permissions:
+
+| Hook | Method | Functionality |
+| :--- | :--- | :--- |
+| `filter:messaging.isRoomOwner` | `isRoomOwner` | Treats admins as owners for permission checks. |
+| `filter:messaging.canReply` | `canReply` | Allows admins to send messages in any room and blocks regular users in admin-locked rooms. |
+| `filter:messaging.canGetMessages` | `canGetMessages` | Allows admins to fetch chat history. |
+| `filter:messaging.loadRoom` | `onLoadRoom` | Manages room loading logic for non-member admins and injects lock state. |
+| `filter:user.accountMenu` | `addProfileLink` | Injects the admin link into the profile menu. |
+
+### Function Overrides
+The plugin overrides core messaging functions to ensure full administrative control:
+* **Edit/Delete**: `Messaging.canEdit` and `Messaging.canDelete` are bypassed for administrators.
+* **Visibility**: `Messaging.canViewMessage` is modified to always return `true` for admins.
+* **Room Locking**: `Messaging.canReply` is wrapped so non-admins cannot post in rooms locked by an admin.
+
+## Installation
+
+1. Install the plugin via terminal:
+   ```bash
+   npm install nodebb-plugin-admin-chats
+   ```
+2. Activate the plugin in the NodeBB Admin Control Panel (ACP).
+3. Restart NodeBB.
+
+## Client-Side Support
+The plugin includes a `client.js` script that:
+* Detects the system language (English or Hebrew).
+* Dynamically injects action buttons into the account sub-links menu.
+* Adds an admin lock/unlock control to the chat UI.
+* Disables the composer for non-admin users when a room is locked.
+* Cleans up the chat UI empty states for a better admin experience.
+
+---
+*Developed by [palmoni5](https://github.com/palmoni5/nodebb-plugin-admin-chats).*

package/client.js

@@ -1,62 +1,387 @@
-$(document).ready(function() {
-    
-    function isEnglishSystem() {
-        return $('html').attr('lang') && $('html').attr('lang').startsWith('en');
-    }
-
-    function replaceAdminEmptyStateText() {
-        if (!app.user.isAdmin) return;
-
-        $('span.text-muted.text-sm').each(function() {
-            const currentText = $(this).text().trim();
-            
-            if (currentText.includes("אין לכם צ'אטים פעילים") || currentText === "אין לכם צ'אטים פעילים.") {
-                $(this).text("אנא בחר צ'אט מסרגל הצד.");
-                $(this).removeClass('text-muted');
-            }
-
-            if (currentText.includes("You have no active chats") || currentText === "You have no active chats.") {
-                $(this).text("Please select a chat from the sidebar.");
-                $(this).removeClass('text-muted');
-            }
-        });
-    }
-
-    $(window).on('action:ajaxify.end', function(ev, data) {
-        
-        if (app.user.isAdmin && ajaxify.data.template.name.startsWith('account/')) {
-            const userSlug = ajaxify.data.userslug || (ajaxify.data.user && ajaxify.data.user.userslug);
-            
-            if (userSlug) {
-                const buttonText = isEnglishSystem() ? "View Chats" : "צפיה בצ'אטים";
-                
-                const relativePath = config.relative_path || ''; 
-
-                const btnHtml = `
-                    <li role="presentation">
-                        <a class="dropdown-item rounded-1 d-flex align-items-center gap-2" href="${relativePath}/user/${userSlug}/chats" role="menuitem">
-                            <i class="far fa-fw fa-comments"></i> 
-                            <span>${buttonText}</span>
-                        </a>
-                    </li>
-                    <li role="presentation" class="dropdown-divider"></li>
-                `;
-                const menu = $('.account-sub-links');
-                if (menu.length) {
-                    menu.find(`a[href*="/user/${userSlug}/chats"]`).parent().remove();
-                    menu.prepend(btnHtml);
-                }
-            }
-        }
-
-        if (data.url.match(/^user\/.+\/chats/) || data.url === 'chats') {
-            replaceAdminEmptyStateText();
-            setTimeout(replaceAdminEmptyStateText, 500);
-        }
-    });
-
-    $(window).on('action:chat.loaded', replaceAdminEmptyStateText);
-    $(window).on('action:chat.closed', function() {
-        setTimeout(replaceAdminEmptyStateText, 200);
-    });
-});
+$(document).ready(function() {
+    const LOCK_PREFIX = '[admin-chat-lock]';
+    const roomStateCache = new Map();
+    const TEXT = {
+        he: {
+            lockBanner: '🔒 חדר זה ננעל ע"י המנהלים.',
+            menuLock: 'נעל חדר',
+            menuRelease: 'שחרר נעילה',
+            updateError: 'לא ניתן לעדכן את נעילת החדר.',
+            viewChats: "צפיה בצ'אטים",
+            emptyState: "אנא בחר צ'אט מסרגל הצד.",
+            lockedAction: 'לא ניתן לבצע פעולה זו בחדר נעול',
+        },
+        en: {
+            lockBanner: '🔒 This room was locked by the administrators.',
+            menuLock: 'Lock Room',
+            menuRelease: 'Release Lock',
+            updateError: 'Unable to update room lock.',
+            viewChats: 'View Chats',
+            emptyState: 'Please select a chat from the sidebar.',
+            lockedAction: 'This action cannot be performed in a locked room.',
+        },
+    };
+
+    function isEnglishSystem() {
+        return $('html').attr('lang') && $('html').attr('lang').startsWith('en');
+    }
+
+    function t(key) {
+        const dict = isEnglishSystem() ? TEXT.en : TEXT.he;
+        return dict[key];
+    }
+
+    function replaceAdminEmptyStateText() {
+        if (!app.user.isAdmin) {
+            return;
+        }
+
+        $('span.text-muted.text-sm').each(function() {
+            const currentText = $(this).text().trim();
+            if (
+                currentText.includes("אין לכם צ'אטים פעילים") ||
+                currentText === "אין לכם צ'אטים פעילים." ||
+                currentText.includes('You have no active chats') ||
+                currentText === 'You have no active chats.'
+            ) {
+                $(this).text(t('emptyState'));
+                $(this).removeClass('text-muted');
+            }
+        });
+    }
+
+    function getChatWindows() {
+        return $('[component="chat/message/window"]');
+    }
+
+    function getWindowRoomId($window) {
+        const roomId = $window.find('[component="chat/messages"]').first().attr('data-roomid') ||
+            $window.closest('.chat-modal').attr('data-roomid') ||
+            (ajaxify && ajaxify.data && ajaxify.data.roomId);
+        return parseInt(roomId, 10) || 0;
+    }
+
+    function getCachedRoomData(roomId) {
+        const cached = roomStateCache.get(String(roomId));
+        if (!cached) {
+            return null;
+        }
+        if (Date.now() - cached.timestamp > 10000) {
+            roomStateCache.delete(String(roomId));
+            return null;
+        }
+        return cached.data;
+    }
+
+    function setCachedRoomData(roomId, data) {
+        roomStateCache.set(String(roomId), {
+            data,
+            timestamp: Date.now(),
+        });
+    }
+
+    async function fetchRoomData(roomId) {
+        if (!roomId) {
+            return null;
+        }
+
+        const currentRoom = ajaxify && ajaxify.data && (ajaxify.data.room || ajaxify.data);
+        if (currentRoom && parseInt(currentRoom.roomId, 10) === roomId && currentRoom.adminChatLock) {
+            setCachedRoomData(roomId, currentRoom);
+            return currentRoom;
+        }
+
+        const cached = getCachedRoomData(roomId);
+        if (cached) {
+            return cached;
+        }
+
+        const response = await fetch(`${config.relative_path || ''}/api/chats/${roomId}`, {
+            headers: {
+                'x-csrf-token': config.csrf_token,
+            },
+            credentials: 'same-origin',
+        });
+        if (!response.ok) {
+            return null;
+        }
+
+        const payload = await response.json();
+        const roomData = payload && payload.roomId ? payload : (payload && payload.room ? payload.room : null);
+        if (roomData) {
+            setCachedRoomData(roomId, roomData);
+        }
+        return roomData;
+    }
+
+    function isLockedForUser(roomData) {
+        return !!(roomData && roomData.adminChatLock && roomData.adminChatLock.isLocked && !(app.user && app.user.isAdmin));
+    }
+
+    function setComposerHidden($window, hidden) {
+        $window.find('[component="chat/composer"]').each(function() {
+            const $composer = $(this);
+            if (hidden) {
+                $composer.addClass('hidden').hide();
+            } else {
+                $composer.removeClass('hidden').show();
+            }
+        });
+
+        $window.find('[component="chat/input"], [component="chat/send"], button[data-action="send"], textarea.chat-input')
+            .prop('disabled', hidden)
+            .attr('disabled', hidden ? 'disabled' : null);
+    }
+
+    function renderLockBanner($window, hidden) {
+        $window.find('.admin-chat-lock-banner').remove();
+        if (!hidden) {
+            return;
+        }
+
+        const target = $window.find('[component="chat/messages"]').first();
+        if (!target.length) {
+            return;
+        }
+
+        const positionStyle = isEnglishSystem() ? 'float:right; clear:both;' : 'float:left; clear:both;';
+        target.prepend(`<div class="admin-chat-lock-banner alert alert-warning mb-2 text-start" style="${positionStyle} max-width: fit-content;">${t('lockBanner')}</div>`);
+    }
+
+    function updateLockedActionVisibility($window, hidden) {
+        [
+            '[data-action="reply"]',
+            '[data-action="edit"]',
+            '[data-action="delete"]',
+            '[data-action="restore"]',
+            '[data-action="kick"]',
+            '[data-action="toggleOwner"]'
+        ].forEach(function(selector) {
+            $window.find(selector).toggleClass('hidden', hidden).toggle(!hidden);
+        });
+
+        $window.find('[component="chat/controlsToggle"]').closest('.dropdown').toggleClass('hidden', hidden).toggle(!hidden);
+        $window.find('[component="chat/manage/user/add/search"], [component="chat/manage/user/list/search"], [component="chat/manage/save"]')
+            .toggleClass('hidden', hidden)
+            .toggle(!hidden)
+            .prop('disabled', hidden)
+            .attr('disabled', hidden ? 'disabled' : null);
+        $window.find('[component="chat/manage-modal"] .form-text, [component="chat/manage-modal"] .text-danger')
+            .toggleClass('hidden', hidden);
+    }
+
+    function normalizeLockMessages($window) {
+        $window.find('[component="chat/system-message"] > div').each(function() {
+            const $el = $(this);
+            const text = $el.text().trim();
+            if (!text.includes(LOCK_PREFIX.slice(1, -1)) && !text.includes('admin-chat-lock')) {
+                return;
+            }
+            $el.text(t('lockBanner'));
+        });
+    }
+
+    function getRoomMenuTargets($window) {
+        const scoped = $window.find('[component="chat/controls"]');
+        if (scoped.length) {
+            return scoped;
+        }
+        return $window.find('[component="chat/header"], .chat-header, .modal-header, [component="chat/nav"]').find('.dropdown-menu');
+    }
+
+    function renderAdminLockControl($window, roomData) {
+        $window.find('.admin-chat-lock-toggle-item, .admin-chat-lock-divider, .admin-chat-lock-item-wrap').remove();
+
+        if (!app.user.isAdmin || !roomData || !roomData.roomId) {
+            return;
+        }
+
+        const menus = getRoomMenuTargets($window);
+        if (!menus.length) {
+            return;
+        }
+
+        const lockData = roomData.adminChatLock || {};
+        const isLocked = !!lockData.isLocked;
+        const itemText = isLocked ? t('menuRelease') : t('menuLock');
+        const iconClass = isLocked ? 'fa-lock-open' : 'fa-lock';
+        const menuItemHtml = `
+            <li role="presentation" class="admin-chat-lock-item-wrap">
+                <a href="#" role="menuitem" class="dropdown-item rounded-1 d-flex align-items-center gap-2 admin-chat-lock-toggle-item" data-room-id="${roomData.roomId}" data-locked="${isLocked}">
+                    <i class="fa fa-fw ${iconClass}"></i>
+                    <span>${itemText}</span>
+                </a>
+            </li>
+            <li role="presentation" class="dropdown-divider admin-chat-lock-divider"></li>
+        `;
+
+        menus.each(function() {
+            const $menu = $(this);
+            if ($menu.find('.admin-chat-lock-toggle-item').length) {
+                return;
+            }
+            $menu.prepend(menuItemHtml);
+        });
+    }
+
+    async function applyUiToWindow($window) {
+        const roomId = getWindowRoomId($window);
+        if (!roomId) {
+            return;
+        }
+
+        const roomData = await fetchRoomData(roomId);
+        if (!roomData) {
+            return;
+        }
+
+        const hidden = isLockedForUser(roomData);
+        setComposerHidden($window, hidden);
+        updateLockedActionVisibility($window, hidden);
+        renderLockBanner($window, hidden);
+        renderAdminLockControl($window, roomData);
+        normalizeLockMessages($window);
+    }
+
+    async function refreshChatUi() {
+        replaceAdminEmptyStateText();
+        const windows = getChatWindows();
+        await Promise.all(windows.map(function() {
+            return applyUiToWindow($(this));
+        }).get());
+    }
+
+    async function toggleRoomLock(roomId, nextState) {
+        const response = await fetch(`${config.relative_path || ''}/api/admin-chats/${roomId}/lock`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-csrf-token': config.csrf_token,
+            },
+            body: JSON.stringify({ locked: nextState }),
+            credentials: 'same-origin',
+        });
+
+        if (!response.ok) {
+            throw new Error('Unable to update room lock');
+        }
+
+        return await response.json();
+    }
+
+    $(window).on('action:ajaxify.end', function(ev, data) {
+        const templateName = ajaxify && ajaxify.data && ajaxify.data.template ? ajaxify.data.template.name : '';
+
+        if (app.user.isAdmin && templateName.startsWith('account/')) {
+            const userSlug = ajaxify.data.userslug || (ajaxify.data.user && ajaxify.data.user.userslug);
+
+            if (userSlug) {
+                const relativePath = config.relative_path || '';
+                const btnHtml = `
+                    <li role="presentation">
+                        <a class="dropdown-item rounded-1 d-flex align-items-center gap-2" href="${relativePath}/user/${userSlug}/chats" role="menuitem">
+                            <i class="far fa-fw fa-comments"></i>
+                            <span>${t('viewChats')}</span>
+                        </a>
+                    </li>
+                    <li role="presentation" class="dropdown-divider"></li>
+                `;
+                const menu = $('.account-sub-links');
+                if (menu.length) {
+                    menu.find(`a[href*="/user/${userSlug}/chats"]`).parent().remove();
+                    menu.prepend(btnHtml);
+                }
+            }
+        }
+
+        const url = data && data.url ? data.url : '';
+        if (url.match(/^user\/.+\/chats/) || url === 'chats') {
+            refreshChatUi();
+            setTimeout(refreshChatUi, 500);
+            setTimeout(refreshChatUi, 1200);
+        }
+    });
+
+    $(window).on('action:chat.loaded', function() {
+        refreshChatUi();
+        setTimeout(refreshChatUi, 200);
+        setTimeout(refreshChatUi, 1000);
+    });
+
+    $(window).on('action:chat.closed', function() {
+        setTimeout(refreshChatUi, 200);
+    });
+
+    $(window).on('action:chat.onMessagesAddedToDom action:chat.edited action:chat.renamed', function() {
+        setTimeout(refreshChatUi, 0);
+    });
+
+    $(document).on('click', '.admin-chat-lock-toggle-item', async function(ev) {
+        ev.preventDefault();
+
+        const $button = $(this);
+        const roomId = parseInt($button.attr('data-room-id'), 10);
+        const isLocked = $button.attr('data-locked') === 'true';
+
+        if (!roomId) {
+            return;
+        }
+
+        $button.addClass('disabled').attr('aria-disabled', 'true');
+
+        try {
+            const result = await toggleRoomLock(roomId, !isLocked);
+            const currentRoom = ajaxify && ajaxify.data && (ajaxify.data.room || ajaxify.data);
+            if (currentRoom && parseInt(currentRoom.roomId, 10) === roomId) {
+                currentRoom.adminChatLock = result.lockData;
+                currentRoom.canReply = !result.lockData.isLocked || (app.user && app.user.isAdmin);
+                currentRoom.showUserInput = currentRoom.canReply;
+                if (ajaxify.data.room) {
+                    ajaxify.data.room.adminChatLock = result.lockData;
+                    ajaxify.data.room.canReply = currentRoom.canReply;
+                    ajaxify.data.room.showUserInput = currentRoom.showUserInput;
+                }
+            }
+
+            const cached = getCachedRoomData(roomId) || { roomId };
+            cached.adminChatLock = result.lockData;
+            cached.canReply = !result.lockData.isLocked || (app.user && app.user.isAdmin);
+            cached.showUserInput = cached.canReply;
+            setCachedRoomData(roomId, cached);
+            await refreshChatUi();
+        } catch (err) {
+            app.alertError(t('updateError'));
+            $button.removeClass('disabled').removeAttr('aria-disabled');
+        }
+    });
+
+    // Intercept error alerts to translate locked action errors
+    if (app && app.alertError) {
+        const originalAlertError = app.alertError;
+        app.alertError = function(error) {
+            let message = error;
+            if (typeof error === 'object' && error.message) {
+                message = error.message;
+            }
+            if (typeof message === 'string' && message.includes('admin-chats:errors.lockedAction')) {
+                message = t('lockedAction');
+            }
+            return originalAlertError.call(this, message);
+        };
+    }
+
+    // Intercept and translate error messages from API
+    if (app.alertError && !app.alertError._adminChatsWrapped) {
+        const originalAlertError = app.alertError;
+        app.alertError = function(message) {
+            if (typeof message === 'string') {
+                // Check if message contains translation key
+                if (message.includes('[[admin-chats:errors.lockedAction]]') || message.includes('errors.lockedAction')) {
+                    message = t('lockedAction');
+                }
+            }
+            return originalAlertError.call(this, message);
+        };
+        app.alertError._adminChatsWrapped = true;
+    }
+});

package/library.js

@@ -1,166 +1,450 @@
-'use strict';
-
-const User = require.main.require('./src/user');
-const Messaging = require.main.require('./src/messaging');
-const db = require.main.require('./src/database');
-const _ = require('lodash');
-
-const plugin = {};
-
-plugin.init = async function (params) {
-    
-    overrideMessagingFunctions();
-};
-
-
-plugin.addProfileLink = async function (data) {
-    try {
-        const userSlug = data.user ? data.user.userslug : (data.userData ? data.userData.userslug : null);
-        
-        if (userSlug) {
-            data.links.push({
-                id: 'admin-view-chats',
-                route: 'user/' + userSlug + '/chats',
-                icon: 'fa-comments',
-                name: 'צפה בצ\'אטים',
-                visibility: {
-                    self: false,
-                    other: true,
-                    moderator: false,
-                    globalMod: false,
-                    admin: true,
-                }
-            });
-        }
-    } catch (e) {
-        console.error('[Super Admin Chats] Error adding profile link:', e);
-    }
-    return data;
-};
-
-plugin.isRoomOwner = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.uid);
-    if (isAdmin) {
-        payload.isOwner = true;
-    }
-    return payload;
-};
-
-plugin.isUserInRoom = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.uid);
-    if (isAdmin) {
-        payload.inRoom = true;
-    }
-    return payload;
-};
-
-plugin.canReply = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.uid);
-    if (isAdmin) {
-        payload.canReply = true;
-    }
-    return payload;
-};
-
-plugin.canGetMessages = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.callerUid);
-    if (isAdmin) {
-        payload.canGet = true;
-    }
-    return payload;
-};
-
-plugin.canGetRecentChats = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.callerUid);
-    if (isAdmin) {
-        payload.canGet = true;
-    }
-    return payload;
-};
-
-plugin.canGetPublicChats = async function (payload) {
-    const isAdmin = await User.isAdministrator(payload.callerUid);
-    if (isAdmin) {
-        payload.canGet = true;
-    }
-    return payload;
-};
-
-plugin.onLoadRoom = async function (payload) {
-    const { uid, room } = payload;
-    const isAdmin = await User.isAdministrator(uid);
-    if (!isAdmin || !room) return payload;
-
-    const isOfficialMember = await db.isSortedSetMember(`chat:room:${room.roomId}:uids`, uid);
-
-    if (!isOfficialMember) {
-        await db.sortedSetRemove(`chat:room:${room.roomId}:uids:online`, uid);
-        
-        if (Array.isArray(room.users)) {
-            room.users = room.users.filter(user => user && parseInt(user.uid, 10) !== parseInt(uid, 10));
-        }
-        if (room.userCount > 0) {
-            room.userCount -= 1;
-        }
-        room.groupChat = room.userCount > 2;
-
-        const allMids = await db.getSortedSetRevRange(`chat:room:${room.roomId}:mids`, 0, 49);
-        
-        if (allMids.length > 0) {
-            const messages = await Messaging.getMessagesData(allMids, uid, room.roomId, false);
-            const messageCount = await db.getObjectField(`chat:room:${room.roomId}`, 'messageCount');
-            const count = parseInt(messageCount, 10) || 0;
-            
-            messages.forEach((msg, index) => {
-                msg.index = count - index - 1;
-            });
-            
-            room.messages = messages.reverse();
-
-            room.messages.forEach((msg, index) => {
-                if (index === 0) {
-                    msg.newSet = true;
-                } else {
-                    const prevMsg = room.messages[index - 1];
-                    msg.newSet = parseInt(msg.fromuid, 10) !== parseInt(prevMsg.fromuid, 10);
-                }
-            });
-        }
-        
-        room.isAdmin = true;
-        room.isOwner = true;
-    } else {
-        room.isAdmin = true;
-    }
-    return payload;
-};
-
-function overrideMessagingFunctions() {
-    
-    const originalCanEdit = Messaging.canEdit;
-    const originalCanDelete = Messaging.canDelete;
-    const originalCanViewMessage = Messaging.canViewMessage;
-
-    Messaging.canEdit = async function (messageId, uid) {
-        if (await User.isAdministrator(uid)) {
-            return true;
-        }
-        return await originalCanEdit(messageId, uid);
-    };
-
-    Messaging.canDelete = async function (messageId, uid) {
-        if (await User.isAdministrator(uid)) {
-            return true;
-        }
-        return await originalCanDelete(messageId, uid);
-    };
-
-    Messaging.canViewMessage = async function (mids, roomId, uid) {
-        if (await User.isAdministrator(uid)) {
-            return Array.isArray(mids) ? mids.map(() => true) : true;
-        }
-        return await originalCanViewMessage(mids, roomId, uid);
-    };
-}
-
-module.exports = plugin;
+'use strict';
+
+const User = require.main.require('./src/user');
+const Messaging = require.main.require('./src/messaging');
+const ChatsAPI = require.main.require('./src/api/chats');
+const db = require.main.require('./src/database');
+
+const plugin = {};
+const LOCK_PREFIX = '[admin-chat-lock]';
+const LOCKED_MESSAGE_TEXT = '🔒 חדר זה ננעל ע"י המנהלים.';
+
+plugin.init = async function (params) {
+    registerRoutes(params.router, params.middleware);
+    overrideMessagingFunctions();
+    overrideChatsApi();
+};
+
+plugin.addProfileLink = async function (data) {
+    try {
+        const userSlug = data.user ? data.user.userslug : (data.userData ? data.userData.userslug : null);
+
+        if (userSlug) {
+            data.links.push({
+                id: 'admin-view-chats',
+                route: 'user/' + userSlug + '/chats',
+                icon: 'fa-comments',
+                name: 'צפה בצ\'אטים',
+                visibility: {
+                    self: false,
+                    other: true,
+                    moderator: false,
+                    globalMod: false,
+                    admin: true,
+                }
+            });
+        }
+    } catch (e) {
+        console.error('[Super Admin Chats] Error adding profile link:', e);
+    }
+    return data;
+};
+
+plugin.isRoomOwner = async function (payload) {
+    const isAdmin = await User.isAdministrator(payload.uid);
+    if (isAdmin) {
+        payload.isOwner = true;
+    }
+    return payload;
+};
+
+plugin.isUserInRoom = async function (payload) {
+    const isAdmin = await User.isAdministrator(payload.uid);
+    if (isAdmin) {
+        payload.inRoom = true;
+    }
+    return payload;
+};
+
+plugin.canReply = async function (payload) {
+    const uid = getCallerUid(payload);
+    const roomId = getRoomId(payload);
+    const isAdmin = await User.isAdministrator(uid);
+
+    if (isAdmin) {
+        payload.canReply = true;
+        return payload;
+    }
+
+    if (roomId && await isRoomLocked(roomId)) {
+        payload.canReply = false;
+    }
+
+    return payload;
+};
+
+plugin.filterMessagingSend = async function (payload) {
+    const uid = getCallerUid(payload);
+    const roomId = getRoomId(payload);
+
+    if (!uid || !roomId) {
+        return payload;
+    }
+
+    if (await User.isAdministrator(uid)) {
+        return payload;
+    }
+
+    if (await isRoomLocked(roomId)) {
+        throw new Error('[[admin-chats:errors.lockedAction]]');
+    }
+
+    return payload;
+};
+plugin.filterAddUsersToRoom = async function (payload) {
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        throw new Error('[[admin-chats:errors.lockedAction]]');
+    }
+    return payload;
+};
+
+plugin.filterRemoveUsersFromRoom = async function (payload) {
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        throw new Error('[[admin-chats:errors.lockedAction]]');
+    }
+    return payload;
+};
+
+plugin.filterRenameRoom = async function (payload) {
+    if (await canNonAdminModifyLockedRoom(payload.uid, payload.roomId)) {
+        throw new Error('[[admin-chats:errors.lockedAction]]');
+    }
+    return payload;
+};
+
+plugin.canGetMessages = async function (payload) {
+    const isAdmin = await User.isAdministrator(payload.callerUid);
+    if (isAdmin) {
+        payload.canGet = true;
+    }
+    return payload;
+};
+
+plugin.canGetRecentChats = async function (payload) {
+    const isAdmin = await User.isAdministrator(payload.callerUid);
+    if (isAdmin) {
+        payload.canGet = true;
+    }
+    return payload;
+};
+
+plugin.canGetPublicChats = async function (payload) {
+    const isAdmin = await User.isAdministrator(payload.callerUid);
+    if (isAdmin) {
+        payload.canGet = true;
+    }
+    return payload;
+};
+
+plugin.onLoadRoom = async function (payload) {
+    const { uid, room } = payload;
+    if (!room) {
+        return payload;
+    }
+
+    const isAdmin = await User.isAdministrator(uid);
+    const lockData = await getRoomLockData(room.roomId);
+    const isLockedForUser = lockData.isLocked && !isAdmin;
+
+    room.adminChatLock = lockData;
+    room.messages = buildRoomMessagesWithLockNotice(room.messages, lockData);
+    room.canReply = room.canReply && !isLockedForUser;
+    room.showUserInput = room.showUserInput && !isLockedForUser;
+
+    if (!isAdmin) {
+        return payload;
+    }
+
+    const isOfficialMember = await db.isSortedSetMember(`chat:room:${room.roomId}:uids`, uid);
+
+    if (!isOfficialMember) {
+        await db.sortedSetRemove(`chat:room:${room.roomId}:uids:online`, uid);
+
+        if (Array.isArray(room.users)) {
+            room.users = room.users.filter(user => user && parseInt(user.uid, 10) !== parseInt(uid, 10));
+        }
+        if (room.userCount > 0) {
+            room.userCount -= 1;
+        }
+        room.groupChat = room.userCount > 2;
+
+        const allMids = await db.getSortedSetRevRange(`chat:room:${room.roomId}:mids`, 0, 49);
+
+        if (allMids.length > 0) {
+            const messages = await Messaging.getMessagesData(allMids, uid, room.roomId, false);
+            const messageCount = await db.getObjectField(`chat:room:${room.roomId}`, 'messageCount');
+            const count = parseInt(messageCount, 10) || 0;
+
+            messages.forEach((msg, index) => {
+                msg.index = count - index - 1;
+            });
+
+            room.messages = buildRoomMessagesWithLockNotice(messages.reverse(), lockData);
+
+            room.messages.forEach((msg, index) => {
+                if (index === 0) {
+                    msg.newSet = true;
+                } else {
+                    const prevMsg = room.messages[index - 1];
+                    msg.newSet = parseInt(msg.fromuid, 10) !== parseInt(prevMsg.fromuid, 10);
+                }
+            });
+        }
+
+        room.isAdmin = true;
+        room.isOwner = true;
+    } else {
+        room.isAdmin = true;
+    }
+    return payload;
+};
+
+function overrideChatsApi() {
+    if (!ChatsAPI || typeof ChatsAPI.kick !== 'function' || ChatsAPI.kick._adminChatLockWrapped) {
+        return;
+    }
+
+    const originalKick = ChatsAPI.kick;
+    const wrappedKick = async function (caller, data) {
+        if (caller && !await User.isAdministrator(caller.uid) && data && data.roomId && Array.isArray(data.uids) && data.uids.length === 1 && parseInt(data.uids[0], 10) === parseInt(caller.uid, 10) && await isRoomLocked(data.roomId)) {
+            throw new Error('[[admin-chats:errors.lockedAction]]');
+        }
+
+        return await originalKick.call(this, caller, data);
+    };
+
+    wrappedKick._adminChatLockWrapped = true;
+    ChatsAPI.kick = wrappedKick;
+}
+function overrideMessagingFunctions() {
+    const originalCanEdit = Messaging.canEdit;
+    const originalCanDelete = Messaging.canDelete;
+    const originalCanViewMessage = Messaging.canViewMessage;
+    const originalCanReply = Messaging.canReply;
+
+    Messaging.canEdit = async function (messageId, uid) {
+        if (await User.isAdministrator(uid)) {
+            return true;
+        }
+
+        const roomId = await getMessageRoomId(messageId);
+        if (roomId && await isRoomLocked(roomId)) {
+            throw new Error('[[admin-chats:errors.lockedAction]]');
+        }
+
+        return await originalCanEdit(messageId, uid);
+    };
+
+    Messaging.canDelete = async function (messageId, uid) {
+        if (await User.isAdministrator(uid)) {
+            return true;
+        }
+
+        const roomId = await getMessageRoomId(messageId);
+        if (roomId && await isRoomLocked(roomId)) {
+            throw new Error('[[admin-chats:errors.lockedAction]]');
+        }
+
+        return await originalCanDelete(messageId, uid);
+    };
+
+    Messaging.canViewMessage = async function (mids, roomId, uid) {
+        if (await User.isAdministrator(uid)) {
+            return Array.isArray(mids) ? mids.map(() => true) : true;
+        }
+        return await originalCanViewMessage(mids, roomId, uid);
+    };
+
+    if (typeof originalCanReply === 'function') {
+        Messaging.canReply = async function (...args) {
+            const guessed = guessRoomIdUidFromArgs(args);
+            if (await User.isAdministrator(guessed.uid)) {
+                return true;
+            }
+            if (guessed.roomId && await isRoomLocked(guessed.roomId)) {
+                return false;
+            }
+            return await originalCanReply.apply(this, args);
+        };
+    }
+}
+
+function registerRoutes(router, middleware) {
+    if (!router) {
+        return;
+    }
+
+    const routeMiddleware = [];
+    if (middleware && typeof middleware.ensureLoggedIn === 'function') {
+        routeMiddleware.push(middleware.ensureLoggedIn);
+    }
+
+    router.post('/api/admin-chats/:roomId/lock', ...routeMiddleware, async (req, res) => {
+        try {
+            const actingUid = req.uid;
+            const roomId = parseInt(req.params.roomId, 10);
+
+            if (!actingUid || Number.isNaN(roomId)) {
+                return res.status(400).json({ status: { code: 'bad-request', message: 'Invalid room id' } });
+            }
+
+            if (!await User.isAdministrator(actingUid)) {
+                return res.status(403).json({ status: { code: 'forbidden', message: 'Admin only' } });
+            }
+
+            if (!await roomExists(roomId)) {
+                return res.status(404).json({ status: { code: 'not-found', message: 'Room not found' } });
+            }
+
+            const shouldLock = req.body && typeof req.body.locked === 'boolean' ? req.body.locked : true;
+            const lockData = shouldLock ?
+                await lockRoom(roomId, actingUid) :
+                await unlockRoom(roomId, actingUid);
+
+            return res.json({
+                status: { code: 'ok', message: 'Room updated' },
+                roomId,
+                lockData,
+            });
+        } catch (err) {
+            console.error('[Super Admin Chats] Error updating room lock:', err);
+            return res.status(500).json({ status: { code: 'error', message: err.message } });
+        }
+    });
+}
+
+async function canNonAdminModifyLockedRoom(uid, roomId) {
+    if (!uid || !roomId) {
+        return false;
+    }
+
+    if (await User.isAdministrator(uid)) {
+        return false;
+    }
+
+    return await isRoomLocked(roomId);
+}
+async function roomExists(roomId) {
+    const roomData = await db.getObject(`chat:room:${roomId}`);
+    return !!roomData;
+}
+
+async function lockRoom(roomId, actingUid) {
+    const now = Date.now();
+    await db.setObject(`chat:room:${roomId}:adminLock`, {
+        isLocked: 1,
+        lockedBy: actingUid,
+        lockedAt: now,
+    });
+
+    return await getRoomLockData(roomId);
+}
+
+async function unlockRoom(roomId, actingUid) {
+    await db.setObject(`chat:room:${roomId}:adminLock`, {
+        isLocked: 0,
+        lockedBy: actingUid,
+        lockedAt: 0,
+    });
+
+    return await getRoomLockData(roomId);
+}
+
+async function isRoomLocked(roomId) {
+    const field = await db.getObjectField(`chat:room:${roomId}:adminLock`, 'isLocked');
+    return field === '1' || field === 1 || field === true;
+}
+
+async function getMessageRoomId(messageId) {
+    const roomId = await db.getObjectField(`message:${messageId}`, 'roomId');
+    return parseInt(roomId, 10) || 0;
+}
+
+async function getRoomLockData(roomId) {
+    const data = await db.getObject(`chat:room:${roomId}:adminLock`) || {};
+    const lockedBy = parseInt(data.lockedBy, 10) || 0;
+    const lockedAt = parseInt(data.lockedAt, 10) || 0;
+    const isLockedValue = data.isLocked === '1' || data.isLocked === 1 || data.isLocked === true;
+
+    return {
+        isLocked: isLockedValue,
+        lockedBy,
+        lockedAt,
+    };
+}
+
+function buildRoomMessagesWithLockNotice(messages, lockData) {
+    const cleanedMessages = stripAdminLockMessages(messages);
+    if (!lockData || !lockData.isLocked || !lockData.lockedAt) {
+        return cleanedMessages;
+    }
+
+    cleanedMessages.push({
+        content: `${LOCK_PREFIX} ${LOCKED_MESSAGE_TEXT}`,
+        fromuid: lockData.lockedBy,
+        uid: lockData.lockedBy,
+        timestamp: lockData.lockedAt,
+        datetime: lockData.lockedAt,
+        system: true,
+        newSet: true,
+    });
+
+    cleanedMessages.sort((left, right) => {
+        const leftTime = parseInt(left && (left.timestamp || left.datetime), 10) || 0;
+        const rightTime = parseInt(right && (right.timestamp || right.datetime), 10) || 0;
+        return leftTime - rightTime;
+    });
+
+    return cleanedMessages;
+}
+
+function stripAdminLockMessages(messages) {
+    const list = Array.isArray(messages) ? messages.slice() : [];
+    return list.filter(msg => !isAdminLockMessage(msg));
+}
+
+function isAdminLockMessage(msg) {
+    const content = String(msg && msg.content || '');
+    return content.includes('admin-chat-lock') ||
+        content.includes(LOCKED_MESSAGE_TEXT) ||
+        content.includes('נפתח מחדש ע"י המנהלים') ||
+        content.includes('modules:chat.system.[admin-chat-lock]');
+}
+
+function guessRoomIdUidFromArgs(args) {
+    if (!Array.isArray(args) || !args.length) {
+        return { roomId: null, uid: null };
+    }
+
+    if (args.length === 1 && args[0] && typeof args[0] === 'object') {
+        return {
+            roomId: getRoomId(args[0]),
+            uid: getCallerUid(args[0]),
+        };
+    }
+
+    return {
+        roomId: args[0],
+        uid: args[1],
+    };
+}
+
+function getCallerUid(payload) {
+    return payload && (
+        payload.uid ||
+        payload.callerUid ||
+        (payload.data && payload.data.uid) ||
+        (payload.message && payload.message.uid)
+    );
+}
+
+function getRoomId(payload) {
+    return payload && (
+        payload.roomId ||
+        (payload.data && payload.data.roomId) ||
+        (payload.message && payload.message.roomId)
+    );
+}
+
+module.exports = plugin;
+

package/package.json

@@ -1,12 +1,12 @@
-{
-  "name": "nodebb-plugin-admin-chats",
-  "version": "1.0.2",
-  "description": "A plugin that allows the administrator to view and manage user chats.",
-  "main": "library.js",
-  "dependencies": {
-    "lodash": "^4.17.0"
-  },
-  "nbbpm": {
-    "compatibility": "^3.0.0 || ^4.0.0"
-  }
-}
+{
+  "name": "nodebb-plugin-admin-chats",
+  "version": "2.0.0",
+  "description": "A plugin that allows the administrator to view and manage user chats.",
+  "main": "library.js",
+  "dependencies": {
+    "lodash": "^4.17.0"
+  },
+  "nbbpm": {
+    "compatibility": "^3.0.0 || ^4.0.0"
+  }
+}

package/plugin.json

@@ -1,19 +1,64 @@
-{
-    "id": "nodebb-plugin-admin-chats",
-    "name": "Super Admin Chat Control",
-    "description": "A plugin that allows the administrator to view and manage user chats",
-    "url": "https://github.com/palmoni5/nodebb-plugin-admin-chats",
-    "library": "./library.js",
-    "scripts": [ "client.js" ],
-    "hooks": [
-        { "hook": "filter:user.accountMenu", "method": "addProfileLink" },
-        { "hook": "filter:messaging.isRoomOwner", "method": "isRoomOwner" },
-        { "hook": "filter:messaging.isUserInRoom", "method": "isUserInRoom" },
-        { "hook": "filter:messaging.canReply", "method": "canReply" },
-        { "hook": "filter:messaging.canGetMessages", "method": "canGetMessages" },
-        { "hook": "filter:messaging.canGetRecentChats", "method": "canGetRecentChats" },
-        { "hook": "filter:messaging.canGetPublicChats", "method": "canGetPublicChats" },
-        { "hook": "filter:messaging.loadRoom", "method": "onLoadRoom" },
-        { "hook": "static:app.load", "method": "init" }
-    ]
-}
+{
+  "id": "nodebb-plugin-admin-chats",
+  "name": "Super Admin Chat Control",
+  "description": "A plugin that allows the administrator to view and manage user chats",
+  "url": "https://github.com/palmoni5/nodebb-plugin-admin-chats",
+  "library": "./library.js",
+  "scripts": [
+    "client.js"
+  ],
+  "hooks": [
+    {
+      "hook": "filter:user.accountMenu",
+      "method": "addProfileLink"
+    },
+    {
+      "hook": "filter:messaging.isRoomOwner",
+      "method": "isRoomOwner"
+    },
+    {
+      "hook": "filter:messaging.isUserInRoom",
+      "method": "isUserInRoom"
+    },
+    {
+      "hook": "filter:messaging.canReply",
+      "method": "canReply"
+    },
+    {
+      "hook": "filter:messaging.canGetMessages",
+      "method": "canGetMessages"
+    },
+    {
+      "hook": "filter:messaging.canGetRecentChats",
+      "method": "canGetRecentChats"
+    },
+    {
+      "hook": "filter:messaging.canGetPublicChats",
+      "method": "canGetPublicChats"
+    },
+    {
+      "hook": "filter:messaging.loadRoom",
+      "method": "onLoadRoom"
+    },
+    {
+      "hook": "filter:messaging.send",
+      "method": "filterMessagingSend"
+    },
+    {
+      "hook": "static:app.load",
+      "method": "init"
+    },
+    {
+      "hook": "filter:messaging.addUsersToRoom",
+      "method": "filterAddUsersToRoom"
+    },
+    {
+      "hook": "filter:messaging.removeUsersFromRoom",
+      "method": "filterRemoveUsersFromRoom"
+    },
+    {
+      "hook": "filter:chat.renameRoom",
+      "method": "filterRenameRoom"
+    }
+  ]
+}

package/public/languages/en-GB/admin-chats.json

@@ -0,0 +1,9 @@
+{
+  "lock.banner": "🔒 This room was locked by the administrators.",
+  "menu.lock": "Lock Room",
+  "menu.release": "Release Lock",
+  "errors.update": "Unable to update room lock.",
+  "profile.viewChats": "View Chats",
+  "empty.selectChat": "Please select a chat from the sidebar.",
+  "errors.lockedAction": "This action cannot be performed in a locked room."
+}

package/public/languages/he/admin-chats.json

@@ -0,0 +1,9 @@
+{
+  "lock.banner": "🔒 חדר זה ננעל ע\"י המנהלים.",
+  "menu.lock": "נעילת חדר",
+  "menu.release": "שיחרור נעילה",
+  "errors.update": "לא ניתן לעדכן את נעילת החדר.",
+  "profile.viewChats": "צפיה בצ'אטים",
+  "empty.selectChat": "אנא בחר צ'אט מסרגל הצד.",
+  "errors.lockedAction": "לא ניתן לבצע פעולה זו בחדר נעול"
+}