@neelegirly/baileys 2.2.30 → 2.2.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -15,7 +15,7 @@
15
15
  <img src="https://files.catbox.moe/5bqumy.jpeg" width="780" alt="@neelegirly/baileys Hero" />
16
16
  </p>
17
17
 
18
- <p align="center"><sub>2026 Glow-Up Edition · self-healing QR/Pairing · Companion-Stack auf <strong>2.2.30 / 1.8.13 / 1.0.33</strong></sub></p>
18
+ <p align="center"><sub>2026 Glow-Up Edition · self-healing QR/Pairing · Companion-Stack auf <strong>2.2.32 / 1.8.14 / 1.0.33</strong></sub></p>
19
19
 
20
20
  [**Installation**](#-installation) · [**Quickstart**](#-quickstart) · [**Was ist dieser Fork?**](#-was-ist-dieser-fork) · [**Versionsschema**](#-versionsschema) · [**Message-ID**](#-message-id-anpassung-neele) · [**Release Notes**](#-release-notes-2230)
21
21
 
@@ -79,7 +79,7 @@ Wichtig zu verstehen — hier laufen **zwei voneinander unabhängige** Versionsn
79
79
 
80
80
  | Nummer | Beispiel | Bedeutung |
81
81
  | --- | --- | --- |
82
- | **Fork-Version** | `2.2.30` | Die npm-Version *dieses Pakets*. Eigenes semver-Schema von Neelegirly – **nicht** identisch mit der Upstream-Baileys-Versionsnummer. |
82
+ | **Fork-Version** | `2.2.32` | Die npm-Version *dieses Pakets*. Eigenes semver-Schema von Neelegirly – **nicht** identisch mit der Upstream-Baileys-Versionsnummer. |
83
83
  | **WhatsApp-Web-Baseline** | `2.3000.1043857760` | Die Client-Version, die im Handshake an WhatsApp gemeldet wird. Wird zur Laufzeit aktuell gehalten (self-healing). |
84
84
 
85
85
  Die Fork-Version `2.2.x` ist also reines Paket-Versioning. Welche WhatsApp-Web-Version tatsächlich verbunden wird, zeigt der Boot-Banner und `fetchLatestBaileysVersion()`.
@@ -102,11 +102,11 @@ generateMessageID() // → z. B. "3AC18D8ANEELE3B14420"
102
102
  ## 🚀 Installation
103
103
 
104
104
  ```bash
105
- npm install @neelegirly/baileys@2.2.30 @neelegirly/libsignal@1.0.33 --save-exact
105
+ npm install @neelegirly/baileys@2.2.32 @neelegirly/libsignal@1.0.33 --save-exact
106
106
  ```
107
107
 
108
108
  ```bash
109
- yarn add @neelegirly/baileys@2.2.30 @neelegirly/libsignal@1.0.33 --exact
109
+ yarn add @neelegirly/baileys@2.2.32 @neelegirly/libsignal@1.0.33 --exact
110
110
  ```
111
111
 
112
112
  > Für den kompletten Stack passt dazu `@neelegirly/wa-api@1.8.13`.
@@ -164,7 +164,7 @@ start().catch(console.error)
164
164
 
165
165
  | Paket | Version | Rolle |
166
166
  |------|---------|-------|
167
- | `@neelegirly/baileys` | `2.2.30` | Socket, Events, Messaging |
167
+ | `@neelegirly/baileys` | `2.2.32` | Socket, Events, Messaging |
168
168
  | `@neelegirly/libsignal` | `1.0.33` | Signal-Protokoll-Komponente |
169
169
  | `@neelegirly/wa-api` | `1.8.13` | Lifecycle-, Session- und Update-Wrapper |
170
170
 
@@ -185,6 +185,38 @@ Beim QR-Scan werden Markenzeilen ober- und unterhalb des QR-Codes ausgegeben. Ve
185
185
 
186
186
  ---
187
187
 
188
+ ## 📝 Release Notes `2.2.32`
189
+
190
+ `prepareInteractiveMessageForMd(message)` ergänzt für eine interaktive Karte
191
+ genau einen Multi-Device-Umschlag mit `deviceListMetadataVersion: 2`. Ein
192
+ vorhandener View-once-Umschlag bleibt erhalten. GIF/Video im Header, Text,
193
+ Knöpfe und Zitat bleiben gemeinsam in einer Nachricht. Der Helper sendet
194
+ nichts selbst und verändert weder Socket-Verbindungen noch Konten.
195
+
196
+ ```js
197
+ const { prepareInteractiveMessageForMd, generateWAMessageFromContent } = require('@neelegirly/baileys')
198
+ // card: vorhandenes { interactiveMessage: { header, body, footer, nativeFlowMessage } }
199
+ const msg = generateWAMessageFromContent(jid, prepareInteractiveMessageForMd(card), {
200
+ userJid: sock.user.id
201
+ })
202
+ await sock.relayMessage(jid, msg.message, { messageId: msg.key.id })
203
+ ```
204
+
205
+ Für eine GIF-Karte mit direkten Auswahlknöpfen `quick_reply` verwenden.
206
+ `single_select` ist ein anderer Knopftyp; der Helper macht ihn nicht durch
207
+ einen Umschlag automatisch auf jedem iOS-/Android-Client sichtbar. Die
208
+ Darstellung muss auf den verwendeten WhatsApp-Clients geprüft werden.
209
+ Es gibt keine automatische Umstellung vorhandener Nachrichten.
210
+
211
+ ## 📝 Release Notes `2.2.31`
212
+
213
+ - 🔐 **„Warte auf diese Nachricht“: Gerät beim Entschlüsseln erhalten.** Sessions von Zweitgeräten (WhatsApp Web/Desktop) landeten im Datensatz des Handys, der Bot verschlüsselte ans Handy danach mit dem falschen Schlüssel.
214
+ - 🔁 **Retry repariert.** Neuzustellung an die echte Geräteadresse (vorher eine erfundene `<lid>@s.whatsapp.net`), beide Adressen (LID + Nummer) frisch, Schlüssel direkt aus der Retry-Anfrage (portiert aus WhiskeySockets 7.0.0-rc14, MIT), Logzeile `[ONIMAI retry]`.
215
+ - 🗝️ **Signal-Sessions:** kein Ersatz durch fremde Geräte, max. 40 Sessions je Datensatz, keine ~200 Lesezugriffe je Nachricht mehr.
216
+ - 🧩 **Multi-Buttons / Native Flow / Carousel** und **Umfrage-Stimmen** ohne patch-package.
217
+ - 🧷 NEELE-Message-IDs, QR/Pairing, Store, Auth-Helfer unverändert. Details: `CHANGELOG.md`.
218
+ - 🔗 Companion-Stack: `2.2.31 / 1.8.14 / 1.0.33`.
219
+
188
220
  ## 📝 Release Notes `2.2.30`
189
221
 
190
222
  - 🔧 **`fetchLatestWaWebVersion()` repariert.** Die Guard-Zeile las `match?.match[1]` statt `match?.[1]` und warf dadurch **bei jedem Aufruf** einen `TypeError`, der im `catch` verschwand. Die Funktion fiel deshalb *immer* still auf die eingebaute Baseline zurück und meldete `isLatest: false` — sie hat nie funktioniert. Jetzt liefert sie die echte Live-Version von `web.whatsapp.com/sw.js`.
@@ -145,15 +145,16 @@ function makeLibSignalRepository(auth, logger, pnFromLIDUSync) {
145
145
  if (!user) {
146
146
  return []
147
147
  }
148
+ // ONIMAI(retry-lid): nur DASSELBE Geraet unter seiner anderen Adresse (PN <-> LID).
149
+ // Frueher kam bei Geraet != 0 auch die Session von Geraet 0 als Ersatz in Frage.
150
+ // Das ist ein anderes Geraet mit anderen Schluesseln: damit verschluesselt, kann
151
+ // das Zielgeraet nichts lesen, und die kopierte Session spaltet die Kette auf.
148
152
  const resolved = []
149
153
  const mappedPn = await lidMapping.getPNForLID(`${user}@lid`)
150
154
  if (mappedPn) {
151
155
  const pnUser = jidUserPart(mappedPn)
152
156
  if (pnUser) {
153
157
  resolved.push(`${pnUser}.${device || '0'}`)
154
- if ((device || '0') !== '0') {
155
- resolved.push(`${pnUser}.0`)
156
- }
157
158
  }
158
159
  }
159
160
  const mappedLid = await lidMapping.getLIDForPN(`${user}@s.whatsapp.net`)
@@ -161,9 +162,6 @@ function makeLibSignalRepository(auth, logger, pnFromLIDUSync) {
161
162
  const lidUser = jidUserPart(mappedLid)
162
163
  if (lidUser) {
163
164
  resolved.push(`${lidUser}.${device || '0'}`)
164
- if ((device || '0') !== '0') {
165
- resolved.push(`${lidUser}.0`)
166
- }
167
165
  }
168
166
  }
169
167
  return unique(resolved.filter((candidate) => candidate !== id))
@@ -173,9 +171,20 @@ function makeLibSignalRepository(auth, logger, pnFromLIDUSync) {
173
171
  if (!normalized || !normalized.includes('@')) {
174
172
  return []
175
173
  }
176
- if (type !== 'msg' || hasExplicitDevice(jid)) {
177
- return [jidToSignalProtocolAddress(String(jid || '').trim()).toString()]
174
+ const exactId = jidToSignalProtocolAddress(String(jid || '').trim()).toString()
175
+ // pkmsg baut eine Session auf: genau unter der Adresse des Absendergeraets
176
+ if (type !== 'msg') {
177
+ return [exactId]
178
178
  }
179
+ // ONIMAI(retry-lid): eine JID ohne Geraeteteil IST Geraet 0. Frueher wurden hier
180
+ // die Sessions der Geraete 0..99 beider Adressen probiert — rund 200 Lesezugriffe
181
+ // je Nachricht (der Zwischenspeicher wird bei jedem Speichern geleert), und
182
+ // Sessions fremder Geraete koennen eine Nachricht ohnehin nie entschluesseln.
183
+ // Jetzt: dasselbe Geraet unter PN und LID; bei Geraet != 0 zusaetzlich der
184
+ // Datensatz von Geraet 0 — dort landeten bis 10/2026 die Sessions ALLER Geraete
185
+ // (decode-wa-message strich das Geraet weg). Ohne diesen Rueckgriff braeuchte
186
+ // jedes Zweitgeraet nach dem Update erst einen Retry.
187
+ const device = WABinary_1.jidDecode(String(jid || '').trim())?.device || 0
179
188
  const relatedJids = [normalized]
180
189
  if (/@lid$/i.test(normalized)) {
181
190
  const mappedPn = await lidMapping.getPNForLID(normalized)
@@ -191,26 +200,23 @@ function makeLibSignalRepository(auth, logger, pnFromLIDUSync) {
191
200
  }
192
201
  const sessionUsers = unique(relatedJids.map((value) => jidUserPart(value)).filter(Boolean))
193
202
  if (!sessionUsers.length) {
194
- return [jidToSignalProtocolAddress(normalized).toString()]
203
+ return [exactId]
195
204
  }
196
- const cacheKey = sessionUsers.slice().sort().join('|')
205
+ const cacheKey = `${sessionUsers.slice().sort().join('|')}#${device}`
197
206
  const cached = sessionAddressCache.get(cacheKey)
198
207
  if (cached?.length) {
199
208
  return [...cached]
200
209
  }
201
- const candidateIds = []
202
- for (const user of sessionUsers) {
203
- for (let device = 0; device <= 99; device += 1) {
204
- candidateIds.push(`${user}.${device}`)
205
- }
206
- }
207
- const existing = candidateIds.length
208
- ? await auth.keys.get('session', candidateIds)
209
- : {}
210
+ const candidateIds = unique([
211
+ exactId,
212
+ ...sessionUsers.map((user) => `${user}.${device}`),
213
+ ...(device !== 0 ? sessionUsers.map((user) => `${user}.0`) : [])
214
+ ])
215
+ const existing = await auth.keys.get('session', candidateIds)
210
216
  const orderedIds = candidateIds.filter((candidateId) => !!existing?.[candidateId])
211
217
  const finalIds = orderedIds.length
212
218
  ? orderedIds
213
- : [jidToSignalProtocolAddress(normalized).toString()]
219
+ : [exactId]
214
220
  sessionAddressCache.set(cacheKey, finalIds)
215
221
  return [...finalIds]
216
222
  }
@@ -376,6 +382,17 @@ function signalStorage({ creds, keys }, helpers = {}) {
376
382
  }
377
383
  },
378
384
  storeSession: async (id, session) => {
385
+ // ONIMAI(retry-lid): libsignal kappt alte Sessions nur beim Ver-/Entschluesseln,
386
+ // nicht beim Aufbau (initOutgoing). Jeder erzwungene Neuaufbau haengte deshalb
387
+ // eine Session an: 1207 Stueck / 1 MB fuer ein einziges Geraet. Hier wie in
388
+ // libsignal auf 40 geschlossene begrenzen; die offene Session bleibt immer.
389
+ try {
390
+ if (typeof session?.removeOldSessions === 'function') {
391
+ session.removeOldSessions()
392
+ }
393
+ } catch (_error) {
394
+ // "Corrupt sessions object" o. ae.: lieber unveraendert speichern als nichts
395
+ }
379
396
  await keys.set({ 'session': { [id]: session.serialize() } })
380
397
  if (typeof invalidateSessionAddressCache === 'function') {
381
398
  invalidateSessionAddressCache()
@@ -27,6 +27,82 @@ const ENFORCEMENT_TYPE_VALUES = new Set(
27
27
  const isValidEnforcementType = (value) =>
28
28
  typeof value === "string" && ENFORCEMENT_TYPE_VALUES.has(value);
29
29
 
30
+ // ONIMAI(retry-lid): Der Baileys-Logger steht in wa-api auf "silent". Ob eine
31
+ // Retry-Anfrage ("Warte auf diese Nachricht") beantwortet wurde, war deshalb nie
32
+ // sichtbar. Eine Zeile je Ereignis, hoechstens 30 pro Minute.
33
+ // Abschaltbar mit ONIMAI_LOG_RETRY_RESEND=0.
34
+ const onimaiRetryLogState = { windowStart: 0, lines: 0, dropped: 0 };
35
+ const onimaiRetryLog = (stage, info = {}) => {
36
+ if (process.env.ONIMAI_LOG_RETRY_RESEND === "0") return;
37
+ try {
38
+ const now = Date.now();
39
+ if (now - onimaiRetryLogState.windowStart > 60000) {
40
+ if (onimaiRetryLogState.dropped) {
41
+ console.warn(`[ONIMAI retry] ${onimaiRetryLogState.dropped} weitere Zeilen unterdrueckt`);
42
+ }
43
+ onimaiRetryLogState.windowStart = now;
44
+ onimaiRetryLogState.lines = 0;
45
+ onimaiRetryLogState.dropped = 0;
46
+ }
47
+ if (onimaiRetryLogState.lines >= 30) {
48
+ onimaiRetryLogState.dropped += 1;
49
+ return;
50
+ }
51
+ onimaiRetryLogState.lines += 1;
52
+ const parts = [`[ONIMAI retry] ${stage}`];
53
+ for (const [k, v] of Object.entries(info)) {
54
+ if (v !== undefined && v !== null && v !== "") parts.push(`${k}=${v}`);
55
+ }
56
+ console.warn(parts.join(" "));
57
+ } catch (_) {
58
+ /* Logging darf den Empfang nie stoeren */
59
+ }
60
+ };
61
+
62
+ // ONIMAI(retry-bundle): portiert aus WhiskeySockets/Baileys 7.0.0-rc14,
63
+ // Utils/signal.js `extractE2ESessionFromRetryReceipt` (MIT, (c) WhiskeySockets).
64
+ // Das anfragende Geraet schickt in der Retry-Anfrage seine EIGENEN aktuellen
65
+ // Schluessel mit (<keys>). Daraus gebaut passt die Session garantiert zu genau
66
+ // diesem Geraet — kein Umweg ueber den Server (spart auch eine Abfrage).
67
+ const onimaiIsValidUInt = (n) => typeof n === "number" && Number.isInteger(n);
68
+ const onimaiBundleFromRetryReceipt = (receipt) => {
69
+ try {
70
+ const keysNode = WABinary_1.getBinaryNodeChild(receipt, "keys");
71
+ if (!keysNode) return null;
72
+ const typeBuf = WABinary_1.getBinaryNodeChildBuffer(keysNode, "type");
73
+ if (!typeBuf || typeBuf.length !== 1 || typeBuf[0] !== Defaults_1.KEY_BUNDLE_TYPE[0]) return null;
74
+ const identity = WABinary_1.getBinaryNodeChildBuffer(keysNode, "identity");
75
+ const skey = WABinary_1.getBinaryNodeChild(keysNode, "skey");
76
+ if (!identity || identity.length !== 32 || !skey) return null;
77
+ const registrationId = WABinary_1.getBinaryNodeChildUInt(receipt, "registration", 4);
78
+ if (!onimaiIsValidUInt(registrationId)) return null;
79
+ const signedPubKey = WABinary_1.getBinaryNodeChildBuffer(skey, "value");
80
+ const signedSig = WABinary_1.getBinaryNodeChildBuffer(skey, "signature");
81
+ const signedKeyId = WABinary_1.getBinaryNodeChildUInt(skey, "id", 3);
82
+ if (!signedPubKey || signedPubKey.length !== 32 || !signedSig || !onimaiIsValidUInt(signedKeyId)) return null;
83
+ let preKey;
84
+ const preKeyNode = WABinary_1.getBinaryNodeChild(keysNode, "key");
85
+ if (preKeyNode) {
86
+ const preKeyPub = WABinary_1.getBinaryNodeChildBuffer(preKeyNode, "value");
87
+ const preKeyId = WABinary_1.getBinaryNodeChildUInt(preKeyNode, "id", 3);
88
+ if (!preKeyPub || preKeyPub.length !== 32 || !onimaiIsValidUInt(preKeyId)) return null;
89
+ preKey = { keyId: preKeyId, publicKey: Utils_1.generateSignalPubKey(preKeyPub) };
90
+ }
91
+ return {
92
+ registrationId,
93
+ identityKey: Utils_1.generateSignalPubKey(identity),
94
+ signedPreKey: {
95
+ keyId: signedKeyId,
96
+ publicKey: Utils_1.generateSignalPubKey(signedPubKey),
97
+ signature: signedSig,
98
+ },
99
+ preKey,
100
+ };
101
+ } catch (_error) {
102
+ return null;
103
+ }
104
+ };
105
+
30
106
  const makeMessagesRecvSocket = (config) => {
31
107
  const {
32
108
  logger,
@@ -1147,7 +1223,7 @@ const makeMessagesRecvSocket = (config) => {
1147
1223
  msgRetryCache.set(key, newValue);
1148
1224
  };
1149
1225
 
1150
- const sendMessagesAgain = async (key, ids, retryNode) => {
1226
+ const sendMessagesAgain = async (key, ids, retryNode, receiptNode) => {
1151
1227
  // ╭─ OniSelf fork fix (bug ≤2.2.26, shipped in 2.2.27) ───────────────────╮
1152
1228
  // │ BUG: this fork populates messageRetryManager's recent-message cache │
1153
1229
  // │ on every outgoing send (enableRecentMessageCache defaults to true, │
@@ -1175,8 +1251,51 @@ const makeMessagesRecvSocket = (config) => {
1175
1251
  // if it's the primary jid sending the request
1176
1252
  // just re-send the message to everyone
1177
1253
  // prevents the first message decryption failure
1254
+ // (wie WhiskeySockets: Hauptgeraet -> an alle, Zweitgeraet -> gezielt. Ein gezielter
1255
+ // Gruppen-Resend an "<nummer>@lid" ohne Geraeteteil kam im Live-Test nicht an.)
1178
1256
  const sendToAll = !WABinary_1.jidDecode(participant)?.device;
1179
- await assertSessions([participant], true);
1257
+ // ONIMAI(retry-lid): dasselbe Geraet hat zwei Adressen (LID + Telefonnummer). Der
1258
+ // Retry kommt meist ueber die LID, der normale Sendeweg (auch "an alle") nimmt in
1259
+ // diesem Fork aber die Nummer. Wurde nur die LID-Session erneuert, lief die Nachricht
1260
+ // wieder ueber die alte, fuer das Geraet unlesbare Nummern-Session. Beide frisch.
1261
+ const retrySessionJids = [participant];
1262
+ try {
1263
+ const decodedParticipant = WABinary_1.jidDecode(participant);
1264
+ const mapping = signalRepository?.lidMapping;
1265
+ if (decodedParticipant?.user && mapping) {
1266
+ let counterpart = null;
1267
+ if (WABinary_1.isLidUser(participant)) {
1268
+ counterpart = await mapping.getPNForLID?.(`${decodedParticipant.user}@lid`);
1269
+ } else if (WABinary_1.isJidUser(participant)) {
1270
+ counterpart = await mapping.getLIDForPN?.(`${decodedParticipant.user}@s.whatsapp.net`);
1271
+ }
1272
+ const decodedCounterpart = counterpart ? WABinary_1.jidDecode(counterpart) : null;
1273
+ if (decodedCounterpart?.user && decodedCounterpart.user !== decodedParticipant.user) {
1274
+ retrySessionJids.push(
1275
+ WABinary_1.jidEncode(decodedCounterpart.user, decodedCounterpart.server, decodedParticipant.device)
1276
+ );
1277
+ }
1278
+ }
1279
+ } catch (_error) {
1280
+ /* ohne Zuordnung bleibt es bei der Adresse aus dem Retry */
1281
+ }
1282
+ // ONIMAI(retry-bundle): Schluessel aus der Retry-Anfrage selbst (s. o.) fuer die
1283
+ // Adresse aus dem Retry; die zweite Adresse holt wie bisher frisch vom Server
1284
+ // (ein Einmal-Prekey darf nicht fuer zwei Sessions benutzt werden).
1285
+ let injectedFromBundle = false;
1286
+ const bundle = receiptNode ? onimaiBundleFromRetryReceipt(receiptNode) : null;
1287
+ if (bundle) {
1288
+ try {
1289
+ await signalRepository.injectE2ESession({ jid: participant, session: bundle });
1290
+ injectedFromBundle = true;
1291
+ } catch (error) {
1292
+ logger.warn({ error: error?.message, participant }, "failed to inject session from retry receipt");
1293
+ }
1294
+ }
1295
+ const sessionJidsToFetch = injectedFromBundle ? retrySessionJids.slice(1) : retrySessionJids;
1296
+ if (sessionJidsToFetch.length) {
1297
+ await assertSessions(sessionJidsToFetch, true);
1298
+ }
1180
1299
 
1181
1300
  if (WABinary_1.isJidGroup(remoteJid)) {
1182
1301
  await authState.keys.set({ "sender-key-memory": { [remoteJid]: null } });
@@ -1193,7 +1312,12 @@ const makeMessagesRecvSocket = (config) => {
1193
1312
  const msgRelayOpts = { messageId: ids[i] };
1194
1313
 
1195
1314
  if (sendToAll) {
1196
- msgRelayOpts.useUserDevicesCache = false;
1315
+ // Geraeteliste im Einzelchat frisch (wie Upstream). In Gruppen haette das die
1316
+ // Listen ALLER Mitglieder neu abgefragt — je Retry (rate-overlimit); die Liste
1317
+ // des Anfragenden haelt der devices-Hinweis (2.2.29) ohnehin aktuell.
1318
+ if (!WABinary_1.isJidGroup(remoteJid)) {
1319
+ msgRelayOpts.useUserDevicesCache = false;
1320
+ }
1197
1321
  } else {
1198
1322
  msgRelayOpts.participant = {
1199
1323
  jid: participant,
@@ -1202,11 +1326,20 @@ const makeMessagesRecvSocket = (config) => {
1202
1326
  }
1203
1327
 
1204
1328
  await relayMessage(key.remoteJid, msg, msgRelayOpts);
1329
+ onimaiRetryLog("resent", {
1330
+ jid: key.remoteJid,
1331
+ id: ids[i],
1332
+ participant,
1333
+ count: retryNode?.attrs?.count,
1334
+ to: sendToAll ? "all" : "device",
1335
+ keys: injectedFromBundle ? "receipt" : "server",
1336
+ });
1205
1337
  } else {
1206
1338
  logger.debug(
1207
1339
  { jid: key.remoteJid, id: ids[i] },
1208
1340
  "recv retry request, but message not available"
1209
1341
  );
1342
+ onimaiRetryLog("missing", { jid: key.remoteJid, id: ids[i], participant, count: retryNode?.attrs?.count });
1210
1343
  }
1211
1344
  }
1212
1345
  };
@@ -1297,12 +1430,18 @@ const makeMessagesRecvSocket = (config) => {
1297
1430
  if (key.fromMe) {
1298
1431
  try {
1299
1432
  logger.debug({ attrs, key }, "recv retry request");
1300
- await sendMessagesAgain(key, ids, retryNode);
1433
+ await sendMessagesAgain(key, ids, retryNode, node);
1301
1434
  } catch (error) {
1302
1435
  logger.error(
1303
1436
  { key, ids, trace: error.stack },
1304
1437
  "error in sending message again"
1305
1438
  );
1439
+ onimaiRetryLog("failed", {
1440
+ jid: key.remoteJid,
1441
+ id: ids[0],
1442
+ participant: key.participant,
1443
+ error: String(error?.message || error).slice(0, 120),
1444
+ });
1306
1445
  }
1307
1446
  } else {
1308
1447
  logger.info(
@@ -1315,6 +1454,7 @@ const makeMessagesRecvSocket = (config) => {
1315
1454
  { attrs, key },
1316
1455
  "will not send message again, as sent too many times"
1317
1456
  );
1457
+ onimaiRetryLog("limit", { jid: key.remoteJid, id: ids[0], participant: key.participant });
1318
1458
  }
1319
1459
  }
1320
1460
  }),
@@ -2015,4 +2155,6 @@ const makeMessagesRecvSocket = (config) => {
2015
2155
 
2016
2156
  module.exports = {
2017
2157
  makeMessagesRecvSocket,
2158
+ // fuer Tests (tests/wa_retry_lid_geraet.test.mjs in Onimai)
2159
+ onimaiBundleFromRetryReceipt,
2018
2160
  };
@@ -608,9 +608,13 @@ const makeMessagesSocket = (config) => {
608
608
  additionalAttributes = { ...additionalAttributes, 'device_fanout': 'false' }
609
609
  }
610
610
 
611
- const { user, device } = WABinary_1.jidDecode(participant.jid)
611
+ const { user, device, server } = WABinary_1.jidDecode(participant.jid)
612
612
 
613
- devices.push({ user, device })
613
+ // ONIMAI(retry-lid): Server + JID des anfragenden Geraets behalten.
614
+ // Vorher wurde im Gruppenzweig daraus "<lid-nummer>:<geraet>@s.whatsapp.net"
615
+ // gebaut — eine Telefonnummer, die es nicht gibt. Die Neuzustellung kam
616
+ // nie an, der Empfaenger blieb auf "Warte auf diese Nachricht".
617
+ devices.push({ user, device, server, jid: participant.jid })
614
618
  }
615
619
 
616
620
  await authState.keys.transaction(async () => {
@@ -640,7 +644,16 @@ const makeMessagesSocket = (config) => {
640
644
  }
641
645
 
642
646
  else if (!isStatus) {
643
- groupData = await groupMetadata(jid)
647
+ try {
648
+ groupData = await groupMetadata(jid)
649
+ } catch (error) {
650
+ // ONIMAI(retry-lid): Eine gezielte Neuzustellung an EIN Geraet braucht
651
+ // die Teilnehmerliste nicht. Drosselt WhatsApp die Gruppenabfrage
652
+ // (rate-overlimit), darf der Retry daran nicht scheitern.
653
+ if (!participant) throw error
654
+ logger.debug({ jid, error: error?.message }, 'group metadata unavailable for targeted resend')
655
+ groupData = undefined
656
+ }
644
657
  groupData = sanitizeGroupMetadataParticipants(groupData)
645
658
  }
646
659
 
@@ -692,7 +705,10 @@ const makeMessagesSocket = (config) => {
692
705
  throw new boom_1.Boom('Per-jid patching is not supported in groups')
693
706
  }
694
707
  const bytes = Utils_1.encodeWAMessage(patched)
695
- const groupAddressingMode = additionalAttributes?.['addressing_mode'] || groupData?.addressingMode || 'lid'
708
+ // ONIMAI(retry-lid): ohne Gruppendaten verraet die Adresse des anfragenden Geraets den Modus
709
+ const groupAddressingMode = additionalAttributes?.['addressing_mode']
710
+ || groupData?.addressingMode
711
+ || (participant && !WABinary_1.isLidUser(participant.jid) ? 'pn' : 'lid')
696
712
  const groupSenderIdentity = groupAddressingMode === 'lid' && meLid ? meLid : meId
697
713
 
698
714
  const { ciphertext, senderKeyDistributionMessage } = await signalRepository.encryptGroupMessage({
@@ -164,12 +164,28 @@ const decryptMessageNode = (stanza, meId, meLid, repository, logger) => {
164
164
  category: stanza.attrs.category,
165
165
  author,
166
166
  async decrypt() {
167
+ // ONIMAI(retry-lid): Geraet des Absenders. Die Signal-Adresse ist (Nummer, GERAET).
168
+ // Frueher strich jidNormalizedUser das Geraet weg: ein pkmsg von WhatsApp Web
169
+ // (z. B. Geraet 5) baute seine Session im Datensatz von Geraet 0 (Handy) auf und
170
+ // wurde dort die offene Session. Der Bot verschluesselte ans Handy danach mit dem
171
+ // Schluessel des anderen Geraets -> "Warte auf diese Nachricht" auf dem Handy.
172
+ // participant_pn traegt das Geraet nicht immer, darum aus der Original-Adresse.
173
+ const senderDevice = (() => {
174
+ const decoded = WABinary_1.jidDecode(String(stanza.attrs.participant || stanza.attrs.from || '').trim())
175
+ return typeof decoded?.device === 'number' ? decoded.device : undefined
176
+ })()
167
177
  const normalizeDecryptJid = (jid = '') => {
168
178
  const value = String(jid || '').trim()
169
179
  if (!value || !value.includes('@')) {
170
180
  return ''
171
181
  }
172
- return WABinary_1.jidNormalizedUser(value)
182
+ const decoded = WABinary_1.jidDecode(value)
183
+ if (!decoded?.user) {
184
+ return ''
185
+ }
186
+ const server = decoded.server === 'c.us' ? 's.whatsapp.net' : decoded.server
187
+ const device = typeof decoded.device === 'number' ? decoded.device : senderDevice
188
+ return WABinary_1.jidEncode(decoded.user, server, device)
173
189
  }
174
190
  let decryptables = 0
175
191
  if (Array.isArray(stanza.content)) {
@@ -1,6 +1,7 @@
1
1
  export * from './generics'
2
2
  export * from './decode-wa-message'
3
3
  export * from './messages'
4
+ export * from './interactive-envelope'
4
5
  export * from './messages-media'
5
6
  export * from './validate-connection'
6
7
  export * from './crypto'
@@ -21,6 +21,7 @@ Object.defineProperty(exports, "__esModule", { value: true })
21
21
  __exportStar(require("./generics"), exports)
22
22
  __exportStar(require("./decode-wa-message"), exports)
23
23
  __exportStar(require("./messages"), exports)
24
+ __exportStar(require("./interactive-envelope"), exports)
24
25
  __exportStar(require("./messages-media"), exports)
25
26
  __exportStar(require("./validate-connection"), exports)
26
27
  __exportStar(require("./crypto"), exports)
@@ -0,0 +1,4 @@
1
+ import { proto } from '../../WAProto';
2
+
3
+ /** Prepare one interactive/media card for MD delivery without sending or splitting it. */
4
+ export declare function prepareInteractiveMessageForMd<T extends proto.IMessage>(message: T): proto.IMessage;
@@ -0,0 +1,37 @@
1
+ "use strict";
2
+
3
+ const WRAPPERS = ['viewOnceMessage', 'viewOnceMessageV2', 'viewOnceMessageV2Extension'];
4
+
5
+ /**
6
+ * Prepare one interactive card for multi-device delivery. Media stays in its
7
+ * header; this helper never sends, uploads, splits messages or switches buttons.
8
+ * A matching WhatsApp client still decides which button types it can display.
9
+ */
10
+ function prepareInteractiveMessageForMd(message) {
11
+ if (!message || typeof message !== 'object') return message;
12
+ if (message.ephemeralMessage?.message) {
13
+ const inner = prepareInteractiveMessageForMd(message.ephemeralMessage.message);
14
+ return inner === message.ephemeralMessage.message ? message : {
15
+ ...message, ephemeralMessage: { ...message.ephemeralMessage, message: inner }
16
+ };
17
+ }
18
+ const existing = WRAPPERS.find(name => message[name]?.message);
19
+ const inner = existing ? message[existing].message : message;
20
+ if (!inner.interactiveMessage) return message;
21
+ const context = inner.messageContextInfo;
22
+ if (existing && context?.deviceListMetadataVersion === 2 && context.deviceListMetadata != null) return message;
23
+ const content = {
24
+ ...inner,
25
+ interactiveMessage: { ...inner.interactiveMessage },
26
+ messageContextInfo: {
27
+ ...(context || {}),
28
+ deviceListMetadataVersion: 2,
29
+ deviceListMetadata: context?.deviceListMetadata || {}
30
+ }
31
+ };
32
+ return existing ? {
33
+ ...message, [existing]: { ...message[existing], message: content }
34
+ } : { viewOnceMessageV2Extension: { message: content } };
35
+ }
36
+
37
+ module.exports = { prepareInteractiveMessageForMd };
@@ -748,6 +748,10 @@ const generateWAMessageContent = async (message, options) => {
748
748
  m.requestPhoneNumberMessage = {}
749
749
  }
750
750
 
751
+ else if ('interactiveMessage' in message || 'viewOnceMessage' in message || 'viewOnceMessageV2' in message || 'viewOnceMessageV2Extension' in message) {
752
+ m = message;
753
+ }
754
+
751
755
  else {
752
756
  const mess = await prepareWAMessageMedia(message, options)
753
757
  const [type] = Object.keys(mess)
@@ -406,7 +406,7 @@ const jid2 = message.key.participant;
406
406
  const creationMsgKey = content.pollUpdateMessage.pollCreationMessageKey
407
407
  // we need to fetch the poll creation message to get the poll enc key
408
408
  const pollMsg2 = await getMessage(creationMsgKey);
409
- const pollMsg = pollMsg.botInvokeMessage?.message || pollMsg2;
409
+ const pollMsg = pollMsg2?.botInvokeMessage?.message || pollMsg2;
410
410
  if (pollMsg) {
411
411
  const meIdNormalised = WABinary_1.jidNormalizedUser(meId)
412
412
  const pollCreatorJid = generics_1.getKeyAuthor(creationMsgKey, meIdNormalised)
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@neelegirly/baileys",
3
- "version": "2.2.30",
3
+ "version": "2.2.32",
4
4
  "description": "Eigenstaendiger Baileys-Fork von Neele Girl (NICHT WhiskeySockets/Baileys) — multi-device WhatsApp Web API fuer Node.js, mit Multi-Button-Support, QR-/Pairing-Stabilitaet und self-healing WA-Web-Version.",
5
5
  "keywords": [
6
6
  "whatsapp",
@@ -32,7 +32,8 @@
32
32
  "WAProto/**/*",
33
33
  "tsconfig.json",
34
34
  "README.md",
35
- "LICENSE"
35
+ "LICENSE",
36
+ "tests/interactive-envelope.test.cjs"
36
37
  ],
37
38
  "exports": {
38
39
  ".": {
@@ -54,6 +55,8 @@
54
55
  "cache-manager": "4.0.1",
55
56
  "futoin-hkdf": "^1.5.1",
56
57
  "libphonenumber-js": "^1.10.20",
58
+ "lodash": "^4.17.21",
59
+ "lru-cache": "^11.1.0",
57
60
  "music-metadata": "^7.12.3",
58
61
  "node-cache": "^5.1.2",
59
62
  "pino": "^7.0.0",
@@ -120,6 +123,6 @@
120
123
  "build:all": "tsc && typedoc",
121
124
  "build:docs": "typedoc",
122
125
  "build:tsc": "tsc",
123
- "test": "node --check lib/Socket/groups.js && node --check lib/Socket/messages-recv.js && node --check lib/Socket/messages-send.js && node --check lib/Socket/socket.js && node --check lib/Utils/auth-utils.js && node --check lib/Utils/decode-wa-message.js && node --check lib/Utils/process-message.js && node --check lib/Utils/link-preview.js && node -e \"const b=require('./'); if(typeof b.makeWASocket !== 'function' || b.NACK_REASONS.SenderReachoutTimelocked !== 463 || b.QueryIds.FOLLOW !== '24404358912487870') process.exit(1)\""
126
+ "test": "node --check lib/Socket/groups.js && node --check lib/Socket/messages-recv.js && node --check lib/Socket/messages-send.js && node --check lib/Socket/socket.js && node --check lib/Utils/auth-utils.js && node --check lib/Utils/decode-wa-message.js && node --check lib/Utils/process-message.js && node --check lib/Utils/link-preview.js && node -e \"const b=require('./'); if(typeof b.makeWASocket !== 'function' || b.NACK_REASONS.SenderReachoutTimelocked !== 463 || b.QueryIds.FOLLOW !== '24404358912487870') process.exit(1)\" && node --test tests/interactive-envelope.test.cjs"
124
127
  }
125
128
  }
@@ -0,0 +1,43 @@
1
+ const {test}=require('node:test');
2
+ const assert=require('node:assert/strict');
3
+ const {proto,generateWAMessageFromContent,prepareInteractiveMessageForMd}=require('../lib');
4
+
5
+ const card={interactiveMessage:{
6
+ header:{title:'Onimai',hasMediaAttachment:true,videoMessage:{gifPlayback:true,mimetype:'video/mp4',url:'https://example.invalid/menu.mp4'}},
7
+ body:{text:'Profil und Kategorien'},footer:{text:'Onimai'},
8
+ contextInfo:{stanzaId:'quoted',participant:'12345@s.whatsapp.net'},
9
+ nativeFlowMessage:{messageVersion:1,buttons:Array.from({length:10},(_,i)=>({name:'quick_reply',buttonParamsJson:JSON.stringify({display_text:'Kategorie '+i,id:'!menu kategorie '+i})}))}
10
+ }};
11
+
12
+ test('Eine MD-Hülle erhält GIF, alle Knöpfe, Text, IDs und Zitat im echten Protobuf',()=>{
13
+ const original=JSON.stringify(card),wrapped=prepareInteractiveMessageForMd(card);
14
+ assert.deepEqual(wrapped.viewOnceMessageV2Extension.message.interactiveMessage,card.interactiveMessage);
15
+ assert.equal(prepareInteractiveMessageForMd(wrapped),wrapped);
16
+ const generated=generateWAMessageFromContent('12345@s.whatsapp.net',wrapped,{userJid:'67890@s.whatsapp.net',messageId:'one-card'});
17
+ const decoded=proto.Message.decode(proto.Message.encode(generated.message).finish());
18
+ const inner=decoded.viewOnceMessageV2Extension.message;
19
+ assert.equal(inner.messageContextInfo.deviceListMetadataVersion,2);
20
+ assert.equal(inner.interactiveMessage.header.videoMessage.gifPlayback,true);
21
+ assert.equal(inner.interactiveMessage.nativeFlowMessage.buttons.length,10);
22
+ assert.equal(inner.interactiveMessage.contextInfo.stanzaId,'quoted');
23
+ assert.equal(generated.key.id,'one-card');assert.equal(JSON.stringify(card),original);
24
+ });
25
+
26
+ test('Vorhandene Hüllen werden ergänzt, nicht verdoppelt; Metadaten bleiben erhalten',()=>{
27
+ for(const name of ['viewOnceMessage','viewOnceMessageV2','viewOnceMessageV2Extension']){
28
+ const input={[name]:{message:{...card,messageContextInfo:{messageSecret:Buffer.from([1,2,3])}}}};
29
+ const output=prepareInteractiveMessageForMd(input),inner=output[name].message;
30
+ assert.deepEqual(inner.messageContextInfo.messageSecret,Buffer.from([1,2,3]));
31
+ assert.equal(inner.messageContextInfo.deviceListMetadataVersion,2);
32
+ for(const other of ['viewOnceMessage','viewOnceMessageV2','viewOnceMessageV2Extension'])assert.equal(inner[other],undefined);
33
+ assert.equal(input[name].message.messageContextInfo.deviceListMetadataVersion,undefined);
34
+ }
35
+ });
36
+
37
+ test('Ephemeral-Verpackung und Nicht-Karten bleiben erhalten',()=>{
38
+ const text={conversation:'Hallo'};assert.equal(prepareInteractiveMessageForMd(text),text);
39
+ assert.equal(prepareInteractiveMessageForMd(null),null);
40
+ const input={ephemeralMessage:{message:card}},output=prepareInteractiveMessageForMd(input);
41
+ assert.deepEqual(output.ephemeralMessage.message.viewOnceMessageV2Extension.message.interactiveMessage,card.interactiveMessage);
42
+ assert.equal(prepareInteractiveMessageForMd(output),output);
43
+ });