@patricktobias86/node-red-telegram-account 1.2.0 → 1.2.2

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+---
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  - package-ecosystem: npm
+    directory: "/"
+    schedule:
+      interval: "weekly"

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.2.1] - 2026-01-22
+### Added
+- Receiver node option to disable emitting edited message updates (useful to prevent duplicate outputs when counters/markup change on channel posts).
+
+## [1.2.2] - 2026-01-31
+### Fixed
+- Receiver node chat/sender filters now work (include/exclude chats and senders).
+
 ## [1.2.0] - 2026-01-12
 ### Changed
 - Switched underlying Telegram MTProto client dependency from `telegram` (GramJS) to `teleproto`.

package/README.md

@@ -18,7 +18,7 @@ See [docs/NODES.md](docs/NODES.md) for a detailed description of every node. Bel
 
 - **config** – stores your API credentials and caches sessions for reuse.
 - **auth** – interactive login that outputs a `stringSession` (also set on `msg.stringSession`).
-- **receiver** – emits messages for every incoming Telegram message using Raw MTProto updates (with optional ignore list, message type filter, and media size limit), including channel posts and service messages. Event listeners are cleaned up on node close so redeploys won't duplicate messages.
+- **receiver** – emits messages for every incoming Telegram message using Raw MTProto updates (with optional ignore list, message type filter, media size limit, and optional edit filtering), including channel posts and service messages. Event listeners are cleaned up on node close so redeploys won't duplicate messages.
 - **command** – triggers when an incoming message matches a command or regex. Event listeners are removed on redeploy to prevent duplicates.
 - **send-message** – sends text or media messages with rich options.
 - **send-files** – uploads one or more files with captions and buttons.

package/docs/NODES.md

@@ -8,7 +8,7 @@ Below is a short description of each node. For a full list of configuration opti
 |------|-------------|
 | **config** | Configuration node storing API credentials and connection options. Other nodes reference this to share a Telegram client and reuse the session. Connections are tracked in a Map with a reference count so multiple nodes can wait for the same connection. |
 | **auth** | Starts an interactive login flow. Produces a `stringSession` (available in both <code>msg.payload.stringSession</code> and <code>msg.stringSession</code>) that can be reused with the `config` node. |
-| **receiver** | Emits an output message for every incoming Telegram message using Raw MTProto updates (so channel posts, anonymous admins and service messages are not missed). Can ignore specific user IDs, skip selected message types (e.g. videos or documents), and optionally drop media above a configurable size. Output includes derived `peer`, `sender`, `senderType`, `senderId`, `chatId`, `isSilent`, and `messageTypes`. `chatId` is normalized to the MTProto dialog id (userId for private chats, chatId for legacy groups, channelId for supergroups/channels — not the Bot API `-100...` form). When Debug is enabled, a second output emits debug messages that can be wired to a Node-RED debug node. Event handlers are automatically removed when the node is closed. |
+| **receiver** | Emits an output message for every incoming Telegram message using Raw MTProto updates (so channel posts, anonymous admins and service messages are not missed). Can ignore specific user IDs, skip selected message types (e.g. videos or documents), optionally drop media above a configurable size, and optionally ignore edited message updates to prevent duplicate outputs when counters/markup change. Output includes derived `peer`, `sender`, `senderType`, `senderId`, `chatId`, `isSilent`, and `messageTypes`. `chatId` is normalized to the MTProto dialog id (userId for private chats, chatId for legacy groups, channelId for supergroups/channels — not the Bot API `-100...` form). When Debug is enabled, a second output emits debug messages that can be wired to a Node-RED debug node. Event handlers are automatically removed when the node is closed. |
 | **command** | Listens for new messages and triggers when a message matches a configured command or regular expression. The event listener is cleaned up on node close to avoid duplicates. |
 | **send-message** | Sends text messages or media files to a chat. Supports parse mode, buttons, scheduling, and more. |
 | **send-files** | Uploads one or more files to a chat with optional caption, thumbnails and other parameters. |

package/nodes/get-entity.js

@@ -17,11 +17,25 @@ module.exports = function (RED) {
             try {
                 let entity;
 
-                // Check if the input is a URL
-                if (input.includes('https://t.me/')) {
-                    const username = input.split('/').pop();
-                    entity = await client.getEntity(username);
-                } else {
+                // Check if the input is a Telegram URL and extract the username safely
+                try {
+                    const url = new URL(input);
+                    const hostname = url.hostname.toLowerCase();
+
+                    if (hostname === 't.me') {
+                        const segments = url.pathname.split('/').filter(Boolean);
+                        const username = segments[segments.length - 1];
+
+                        if (username) {
+                            entity = await client.getEntity(username);
+                        } else {
+                            entity = await client.getEntity(input);
+                        }
+                    } else {
+                        entity = await client.getEntity(input);
+                    }
+                } catch (e) {
+                    // Not a valid URL, treat input as a plain identifier
                     entity = await client.getEntity(input);
                 }
 

package/nodes/receiver.html

@@ -9,6 +9,7 @@
             ignore: { value:""},
             ignoreMessageTypes: { value: "" },
             debug: { value: false },
+            emitEdits: { value: true },
             maxFileSizeMb: { value: "" },
             includeChats: { value: "" },
             excludeChats: { value: "" },
@@ -53,6 +54,13 @@
       </label>
       <input type="checkbox" id="node-input-debug">
     </div>
+    <div class="form-row">
+      <label for="node-input-emitEdits">
+        <i class="fa fa-pencil"></i> Emit edits
+      </label>
+      <input type="checkbox" id="node-input-emitEdits">
+      <p class="form-tips">When disabled, edited message updates (e.g. like/view counters changing on channel posts) are ignored.</p>
+    </div>
     <div class="form-row">
       <label for="node-input-ignore">
         <i class="fa fa-user-times"></i> Ignore list
@@ -178,6 +186,11 @@
         </dt>
         <dd>List of message or media types to skip (for example <code>video</code>, <code>document</code>, or <code>sticker</code>). Separate multiple entries with commas or new lines.</dd>
 
+        <dt>Emit edits
+            <span class="property-type">boolean</span>
+        </dt>
+        <dd>When disabled, the receiver ignores edited message updates (such as <code>UpdateEditChannelMessage</code>) to avoid duplicate outputs for the same post.</dd>
+
         <dt>Max media size (MB)
             <span class="property-type">number</span>
         </dt>
@@ -205,7 +218,7 @@
     </dl>
 
     <h3>Details</h3>
-    <p>The <b>receiver</b> node uses the Telegram client to listen for all new messages in real-time. It emits a message to the next connected Node-RED node whenever a new Telegram message is received, provided the sender's user ID is not in the ignore list.</p>
+    <p>The <b>receiver</b> node uses the Telegram client to listen for all new messages in real-time. It emits a message to the next connected Node-RED node whenever a new Telegram message is received, provided it passes the configured filters.</p>
 
     <h3>Example</h3>
     <pre>
@@ -243,7 +256,9 @@
     <h3>Notes</h3>
     <ul>
         <li>Ensure the Telegram bot has sufficient permissions to receive messages in the configured chat or channel.</li>
-        <li>The <b>Ignore List</b> only filters messages based on the sender's user ID.</li>
+        <li>The <b>Ignore List</b> only filters messages where the sender can be identified as a user.</li>
+        <li><b>Include/Exclude chats</b> match against <code>payload.chatId</code>.</li>
+        <li><b>Include/Exclude senders</b> match against <code>payload.senderId</code> (user/chat/channel IDs depending on the update).</li>
         <li>Use <b>Ignore message types</b> to drop updates that contain media you don't want to process, such as large videos or documents.</li>
         <li>For advanced filtering based on message content, consider chaining this node with additional processing nodes in Node-RED.</li>
     </ul>

package/nodes/receiver.js

@@ -366,6 +366,7 @@ module.exports = function (RED) {
     const client =  this.config.client;
     const ignore = splitList(config.ignore || "");
     const ignoredMessageTypes = toLowerCaseSet(splitList(config.ignoreMessageTypes || ""));
+    const emitEdits = config.emitEdits !== false;
     const maxFileSizeMb = Number(config.maxFileSizeMb);
     const maxFileSizeBytes = Number.isFinite(maxFileSizeMb) && maxFileSizeMb > 0
         ? maxFileSizeMb * 1024 * 1024
@@ -376,6 +377,26 @@ module.exports = function (RED) {
     const includeSenders = splitList(config.includeSenders || "");
     const excludeSenders = splitList(config.excludeSenders || "");
 
+    const toNormalizedIdSet = (values) => {
+        const result = new Set();
+        for (const value of values) {
+            if (value == null) {
+                continue;
+            }
+            const normalized = String(value).trim();
+            if (!normalized) {
+                continue;
+            }
+            result.add(normalized);
+        }
+        return result;
+    };
+
+    const includeChatSet = toNormalizedIdSet(includeChats);
+    const excludeChatSet = toNormalizedIdSet(excludeChats);
+    const includeSenderSet = toNormalizedIdSet(includeSenders);
+    const excludeSenderSet = toNormalizedIdSet(excludeSenders);
+
     const extractPhotoSize = (photo) => {
         if (!photo || !Array.isArray(photo.sizes)) {
             return null;
@@ -456,13 +477,9 @@ module.exports = function (RED) {
         node.send([null, { payload }]);
     };
 
-    let rawOptions = {};
-    if (includeChats.length > 0) rawOptions.chats = includeChats;
-    if (excludeChats.length > 0) rawOptions.blacklistChats = excludeChats;
-    if (includeSenders.length > 0) rawOptions.senders = includeSenders;
-    if (excludeSenders.length > 0) rawOptions.blacklistSenders = excludeSenders;
-
-    const event = new Raw(rawOptions);
+    // teleproto's Raw event builder only supports `types` and `func` options.
+    // Chat/sender filtering is implemented below after we normalize the message metadata.
+    const event = new Raw({});
     const handler = (rawUpdate) => {
         const debug = node.debugEnabled;
         if (debug) {
@@ -480,9 +497,23 @@ module.exports = function (RED) {
         }
 
         for (const { update, message } of extracted) {
+            const updateClassName = getClassName(update) || 'unknown';
+
+            if (!emitEdits) {
+                const isEditUpdate =
+                    updateClassName === 'UpdateEditMessage' ||
+                    updateClassName === 'UpdateEditChannelMessage' ||
+                    updateClassName === 'UpdateBotEditBusinessMessage';
+                if (isEditUpdate) {
+                    debugLog(`receiver ignoring edit update due to emitEdits=false; updateClassName=${updateClassName}`);
+                    debugSend({ event: 'ignored', reason: 'emitEdits', updateClassName });
+                    continue;
+                }
+            }
+
             if (!message) {
-                debugLog(`receiver ignoring message update without message payload: ${getClassName(update) || 'unknown'}`);
-                debugSend({ event: 'ignored', reason: 'missing-message', updateClassName: getClassName(update) || 'unknown' });
+                debugLog(`receiver ignoring message update without message payload: ${updateClassName}`);
+                debugSend({ event: 'ignored', reason: 'missing-message', updateClassName });
                 continue;
             }
 
@@ -508,6 +539,44 @@ module.exports = function (RED) {
                 null;
 
             const chatId = peerChatId(peer);
+            const chatIdString = chatId != null ? String(chatId) : null;
+            const senderIdString = senderId != null ? String(senderId) : null;
+
+            if (includeChatSet.size > 0) {
+                const allowed = chatIdString != null && includeChatSet.has(chatIdString);
+                if (!allowed) {
+                    debugLog(`receiver ignoring message due to includeChats; chatId=${chatIdString ?? 'unknown'}`);
+                    debugSend({ event: 'ignored', reason: 'includeChats', chatId });
+                    continue;
+                }
+            }
+
+            if (excludeChatSet.size > 0) {
+                const blocked = chatIdString != null && excludeChatSet.has(chatIdString);
+                if (blocked) {
+                    debugLog(`receiver ignoring message due to excludeChats; chatId=${chatIdString}`);
+                    debugSend({ event: 'ignored', reason: 'excludeChats', chatId });
+                    continue;
+                }
+            }
+
+            if (includeSenderSet.size > 0) {
+                const allowed = senderIdString != null && includeSenderSet.has(senderIdString);
+                if (!allowed) {
+                    debugLog(`receiver ignoring message due to includeSenders; senderId=${senderIdString ?? 'unknown'} senderType=${senderType}`);
+                    debugSend({ event: 'ignored', reason: 'includeSenders', senderId, senderType });
+                    continue;
+                }
+            }
+
+            if (excludeSenderSet.size > 0) {
+                const blocked = senderIdString != null && excludeSenderSet.has(senderIdString);
+                if (blocked) {
+                    debugLog(`receiver ignoring message due to excludeSenders; senderId=${senderIdString} senderType=${senderType}`);
+                    debugSend({ event: 'ignored', reason: 'excludeSenders', senderId, senderType });
+                    continue;
+                }
+            }
 
             if (ignoredMessageTypes.size > 0) {
                 const shouldIgnoreType = Array.from(messageTypes).some((type) => ignoredMessageTypes.has(type));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patricktobias86/node-red-telegram-account",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Node-RED nodes to communicate with TeleProto.",
   "main": "nodes/config.js",
   "keywords": [

package/test/receiver.test.js

@@ -101,6 +101,87 @@ describe('Receiver node', function() {
     assert.strictEqual(sent.length, 1);
   });
 
+  it('filters by includeChats', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'', includeChats:'111'});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 111 }, message: 'allowed' }
+    });
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 222 }, message: 'blocked' }
+    });
+
+    assert.strictEqual(sent.length, 1);
+    assert.strictEqual(sent[0].payload.chatId, 111);
+    assert.strictEqual(sent[0].payload.message.message, 'allowed');
+  });
+
+  it('filters by excludeChats', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'', excludeChats:'222'});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 111 }, message: 'allowed' }
+    });
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 222 }, message: 'blocked' }
+    });
+
+    assert.strictEqual(sent.length, 1);
+    assert.strictEqual(sent[0].payload.chatId, 111);
+  });
+
+  it('filters by includeSenders', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'', includeSenders:'123'});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 111 }, message: 'allowed' }
+    });
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 456 }, peerId:{ userId: 111 }, message: 'blocked' }
+    });
+
+    assert.strictEqual(sent.length, 1);
+    assert.strictEqual(sent[0].payload.senderId, 123);
+  });
+
+  it('filters by excludeSenders', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'', excludeSenders:'456'});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 123 }, peerId:{ userId: 111 }, message: 'allowed' }
+    });
+    handler({
+      className: 'UpdateNewMessage',
+      message: { fromId: { userId: 456 }, peerId:{ userId: 111 }, message: 'blocked' }
+    });
+
+    assert.strictEqual(sent.length, 1);
+    assert.strictEqual(sent[0].payload.senderId, 123);
+  });
+
   it('populates chatId and senderId for string ids', function() {
     const { NodeCtor, addCalls } = load();
     const sent = [];
@@ -207,6 +288,25 @@ describe('Receiver node', function() {
     assert.strictEqual(sent[0].payload.message.message, 'edited business message');
   });
 
+  it('can ignore edited message updates when emitEdits is disabled', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:'', emitEdits:false});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateEditChannelMessage',
+      message: {
+        id: 171429,
+        peerId: { channelId: '1050289360', className: 'PeerChannel' },
+        message: 'same content'
+      }
+    });
+
+    assert.strictEqual(sent.length, 0);
+  });
+
   it('handles UpdateQuickReplyMessage updates', function() {
     const { NodeCtor, addCalls } = load();
     const sent = [];