@patricktobias86/node-red-telegram-account 1.1.18 → 1.1.20

package/CHANGELOG.md

@@ -2,12 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
-## [1.1.18] - 2026-01-05
+## [1.1.20] - 2026-01-05
+### Added
+- Receiver node now emits debug events on a second output when Debug is enabled, so you can see internal logs in the Node-RED debug sidebar.
 ### Fixed
+- Receiver node now also supports GramJS `Integer { value: ... }` wrappers when deriving `payload.chatId` / `payload.senderId`.
 - Receiver node now populates `payload.chatId` / `payload.senderId` when Telegram IDs arrive as numeric strings (common in debug/output), so downstream filters work reliably.
-
-## [1.1.17] - 2026-01-05
-### Fixed
 - Receiver node now listens to Raw MTProto updates and derives sender/chat identity safely so valid messages (channel posts, anonymous admins, service messages, missing fromId) are no longer dropped.
 
 ## [1.1.16] - 2025-09-22

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). 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), 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. |
 | **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/receiver.html

@@ -12,7 +12,7 @@
             maxFileSizeMb: { value: "" }
         },
         inputs: 1,
-        outputs: 1,
+        outputs: 2,
         paletteLabel: 'receiver',
         label: function() {
             return this.name||'receiver';
@@ -95,6 +95,14 @@
 
     <h3>Outputs</h3>
     <dl class="message-properties">
+        <dt>output 1
+            <span class="property-type">message</span>
+        </dt>
+        <dd>The parsed incoming Telegram message.</dd>
+        <dt>output 2
+            <span class="property-type">message</span>
+        </dt>
+        <dd>Debug messages emitted when <b>Debug</b> is enabled (suitable for wiring to a Node-RED debug node).</dd>
         <dt>payload.update
             <span class="property-type">object</span>
         </dt>

package/nodes/receiver.js

@@ -185,6 +185,13 @@ const toPeerInfo = (peer) => {
 };
 
 const toSafeNumber = (value) => {
+    if (value && typeof value === 'object') {
+        // GramJS can represent large integers using custom Integer wrappers.
+        // Those often serialize/log as `Integer { value: 123n }`.
+        if ('value' in value) {
+            return toSafeNumber(value.value);
+        }
+    }
     if (typeof value === 'number') {
         return Number.isFinite(value) ? value : null;
     }
@@ -424,11 +431,19 @@ module.exports = function (RED) {
         }
     };
 
+    const debugSend = (payload) => {
+        if (!node.debugEnabled) {
+            return;
+        }
+        node.send([null, { payload }]);
+    };
+
     const event = new Raw({});
     const handler = (rawUpdate) => {
         const debug = node.debugEnabled;
         if (debug) {
             node.log('receiver raw update: ' + util.inspect(rawUpdate, { depth: null }));
+            debugSend({ event: 'rawUpdate', rawUpdate });
         }
 
         const extracted = extractMessageEvents(rawUpdate);
@@ -436,12 +451,14 @@ module.exports = function (RED) {
             // Raw emits *all* MTProto updates; many are not message-bearing updates (typing, reads, etc.).
             // We do not output those by default, but we also do not silently hide that they occurred.
             debugLog(`receiver ignoring non-message MTProto update: ${getClassName(rawUpdate) || 'unknown'}`);
+            debugSend({ event: 'ignored', reason: 'non-message', rawUpdateClassName: getClassName(rawUpdate) || 'unknown' });
             return;
         }
 
         for (const { update, message } of extracted) {
             if (!message) {
                 debugLog(`receiver ignoring message update without message payload: ${getClassName(update) || 'unknown'}`);
+                debugSend({ event: 'ignored', reason: 'missing-message', updateClassName: getClassName(update) || 'unknown' });
                 continue;
             }
 
@@ -472,6 +489,7 @@ module.exports = function (RED) {
                 const shouldIgnoreType = Array.from(messageTypes).some((type) => ignoredMessageTypes.has(type));
                 if (shouldIgnoreType) {
                     debugLog(`receiver ignoring message due to ignoreMessageTypes; types=${Array.from(messageTypes).join(', ')}`);
+                    debugSend({ event: 'ignored', reason: 'ignoreMessageTypes', messageTypes: Array.from(messageTypes) });
                     continue;
                 }
             }
@@ -480,6 +498,7 @@ module.exports = function (RED) {
                 const mediaSize = extractMediaSize(message.media);
                 if (mediaSize != null && mediaSize > maxFileSizeBytes) {
                     debugLog(`receiver ignoring message due to maxFileSizeMb; mediaSize=${mediaSize} limitBytes=${maxFileSizeBytes}`);
+                    debugSend({ event: 'ignored', reason: 'maxFileSizeMb', mediaSize, limitBytes: maxFileSizeBytes });
                     continue;
                 }
             }
@@ -489,6 +508,7 @@ module.exports = function (RED) {
             // Now we only apply the ignore list when we can confidently identify a user sender.
             if (senderType === 'user' && senderId != null && ignore.includes(String(senderId))) {
                 debugLog(`receiver ignoring message due to ignore list; userId=${senderId}`);
+                debugSend({ event: 'ignored', reason: 'ignore', userId: senderId });
                 continue;
             }
 
@@ -506,7 +526,11 @@ module.exports = function (RED) {
                 }
             };
 
-            node.send(out);
+            if (debug) {
+                node.send([out, { payload: { event: 'output', out } }]);
+            } else {
+                node.send(out);
+            }
             if (debug) {
                 node.log('receiver output: ' + util.inspect(out, { depth: null }));
             }

package/package.json

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

package/test/receiver-debug.test.js

@@ -4,6 +4,7 @@ const proxyquire = require('proxyquire').noPreserveCache();
 function load() {
   const addCalls = [];
   const logs = [];
+  const sends = [];
   class TelegramClientStub {
     addEventHandler(fn, event) { addCalls.push({fn, event}); }
     removeEventHandler() {}
@@ -18,7 +19,7 @@ function load() {
         node._events = {};
         node.on = (e, fn) => { node._events[e] = fn; };
         node.log = (msg) => logs.push(msg);
-        node.send = () => {};
+        node.send = (msg) => sends.push(msg);
       },
       registerType(name, ctor) { NodeCtor = ctor; },
       getNode() { return configNode; }
@@ -29,12 +30,12 @@ function load() {
     'telegram/events': { Raw: RawStub }
   })(RED);
 
-  return { NodeCtor, addCalls, logs };
+  return { NodeCtor, addCalls, logs, sends };
 }
 
 describe('Receiver node debug with BigInt', function() {
   it('logs update and output without throwing', function() {
-    const { NodeCtor, addCalls, logs } = load();
+    const { NodeCtor, addCalls, logs, sends } = load();
     const node = new NodeCtor({config:'c', ignore:'', debug:true});
     const handler = addCalls[0].fn;
     assert.doesNotThrow(() => handler({
@@ -43,5 +44,8 @@ describe('Receiver node debug with BigInt', function() {
     }));
     assert(logs.some(l => l.includes('receiver raw update')));
     assert(logs.some(l => l.includes('receiver output')));
+    assert(sends.some((msg) => Array.isArray(msg) && msg.length === 2));
+    assert(sends.some((msg) => Array.isArray(msg) && msg[1] && msg[1].payload && msg[1].payload.event === 'rawUpdate'));
+    assert(sends.some((msg) => Array.isArray(msg) && msg[1] && msg[1].payload && msg[1].payload.event === 'output'));
   });
 });

package/test/receiver.test.js

@@ -100,4 +100,46 @@ describe('Receiver node', function() {
 
     assert.strictEqual(sent.length, 1);
   });
+
+  it('populates chatId and senderId for string ids', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:''});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateNewChannelMessage',
+      message: {
+        fromId: { userId: '6304354944', className: 'PeerUser' },
+        peerId: { channelId: '2877134366', className: 'PeerChannel' },
+        message: 'hello'
+      }
+    });
+
+    assert.strictEqual(sent.length, 1);
+    assert.strictEqual(sent[0].payload.chatId, 2877134366);
+    assert.strictEqual(sent[0].payload.senderId, 6304354944);
+  });
+
+  it('populates chatId and senderId for Integer wrappers', function() {
+    const { NodeCtor, addCalls } = load();
+    const sent = [];
+    const node = new NodeCtor({config:'c', ignore:'', ignoreMessageTypes:'', maxFileSizeMb:''});
+    node.send = (msg) => sent.push(msg);
+    const handler = addCalls[0].fn;
+
+    handler({
+      className: 'UpdateNewChannelMessage',
+      message: {
+        fromId: { userId: { value: 6304354944n }, className: 'PeerUser' },
+        peerId: { channelId: { value: 2877134366n }, className: 'PeerChannel' },
+        message: 'hello'
+      }
+    });
+
+    assert.strictEqual(sent.length, 1);
+    assert.strictEqual(sent[0].payload.chatId, 2877134366);
+    assert.strictEqual(sent[0].payload.senderId, 6304354944);
+  });
 });