whatsapp_notifier 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 130b5676184b753e6329f98ead313255db4a16be9393597f4b34f38741ae9c63
-  data.tar.gz: 7c7fe4a7eb0464676d4257443fa3003e80035e938e41d690aee7282787fd962a
+  metadata.gz: f08dab8359fed7382e1003222467857c0b073bafced5dc0945683624f91a193b
+  data.tar.gz: e4b9aba0c7ae8e1ff5c3782d5b5981626afbbedef781302fbb852ab56bd808e1
 SHA512:
-  metadata.gz: 18e39291eabaa4a61e33a7a9f62a840b233320724147dc24614f740dafaa14151363a2e606943027098b42bed3dbea80db81459d1c73a38d1ad6989d0a1d2104
-  data.tar.gz: 35170c14888aa976a0eb211757e617a2237ab8e442ee75b9e319391d1737bbb75ce81d3a69802b71b9f712ab8d8731e4fd1d243123017cac05c5c686cac9830c
+  metadata.gz: 2ce8dabade33198c6561e2790227ad0592d1008c776aac0a06e86dd469028ea836219260ea953e81fab43a0fe03c4c290501540ca2d00710d5dfa121c7064ea3
+  data.tar.gz: 924c1f01a29ae6d71c85104c4ac8781458114f73a7c18f703bade137b29553c3db601e2545411cc0eecb8ec3ab4404932e9a22bcd69e0458cd1035a1c1302c36

data/lib/whatsapp_notifier/services/web_automation/history.test.ts

@@ -20,7 +20,14 @@ import {
     type HistoryDeps,
     type RefetchDeps
 } from './history';
-import { configureInbound, loadTargets, resetInboundState, type ChatLike } from './inbound';
+import {
+    configureInbound,
+    loadTargets,
+    resetInboundState,
+    rememberLidAlias,
+    resolveLidAlias,
+    type ChatLike
+} from './inbound';
 import {
     configureMedia,
     resetMediaState,
@@ -231,6 +238,44 @@ test('replayHistory returns oldest-first even when the chat yields newest-first'
     expect(history.map((m) => m.messageId)).toEqual(['m1', 'm2', 'm3']);
 });
 
+// fromMe items in an @lid-keyed chat: the host requested this history by the
+// phone @c.us, and fetchMessages only returns THIS chat's messages — so the
+// requested id IS the @lid's phone. Same prod chat shape as the live-capture
+// bug (125417440686124@lid): without resolution these were unmatchable.
+test('replayHistory resolves fromMe @lid counterparties to the requested chat id and learns the alias', async () => {
+    const LID = '125417440686124@lid';
+    const history = await replayHistory('h1', chatWith([
+        msg({ body: 'customer says hi', timestamp: 1 }),
+        msg({
+            fromMe: true, from: OPERATOR, to: LID, body: 'Yes cool',
+            id: { _serialized: 'op1' }, timestamp: 2
+        })
+    ]), 50, CUST);
+
+    expect(history.length).toBe(2);
+    expect(history[0].from).toBe(CUST);                              // inbound leg untouched
+    expect(history[1]).toMatchObject({ fromMe: true, to: CUST, body: 'Yes cool' });
+    expect(resolveLidAlias('h1', LID)).toBe(CUST); // learned → live fromMe capture resolves too
+});
+
+test('replayHistory falls back to the learned alias map and skips unresolvable fromMe @lid items', async () => {
+    const LID = '125417440686124@lid';
+
+    // No requested chat id (test seam) but a learned alias → resolved.
+    rememberLidAlias('h2', LID, CUST);
+    const withAlias = await replayHistory('h2', chatWith([
+        msg({ fromMe: true, from: OPERATOR, to: LID, id: { _serialized: 'op1' } })
+    ]), 50);
+    expect(withAlias.length).toBe(1);
+    expect(withAlias[0].to).toBe(CUST);
+
+    // Neither → skipped: never forward an unmatchable counterparty.
+    const unresolved = await replayHistory('h3', chatWith([
+        msg({ fromMe: true, from: OPERATOR, to: LID, id: { _serialized: 'op2' } })
+    ]), 50);
+    expect(unresolved).toEqual([]);
+});
+
 test('replayHistory passes the limit through and tolerates a non-array result', async () => {
     let seenLimit = 0;
     await replayHistory('1', chatWith([], ({ limit }) => { seenLimit = limit; }), 37);
@@ -398,6 +443,28 @@ test('historyResponse replays the chat, clamps the limit and allowlists the chat
     expect(data.lastUsed).toBeGreaterThan(0);
 });
 
+// End-to-end shape of the prod incident: the host asks for a phone whose chat
+// is @lid-keyed (getChatById fails → index.ts's contact fallback resolves it),
+// and the replayed fromMe items must come back threaded on that phone.
+test('historyResponse resolves fromMe @lid items in an @lid-keyed chat to the requested phone', async () => {
+    const LID = '125417440686124@lid';
+    const deps = depsWith(readyClient(), {
+        resolveChat: async () => chatWith([
+            msg({ fromMe: true, from: OPERATOR, to: LID, body: 'No still not', id: { _serialized: 'op1' } })
+        ])
+    });
+
+    const res = await historyResponse('h9', { chatId: CUST }, undefined, undefined, deps);
+
+    expect(res.status).toBe(200);
+    const payload = await res.json();
+    expect(payload.messages).toEqual([{
+        from: OPERATOR, to: CUST, fromMe: true, body: 'No still not',
+        messageId: 'op1', timestamp: 1717000000, type: 'chat'
+    }]);
+    expect(resolveLidAlias('h9', LID)).toBe(CUST);
+});
+
 test('historyResponse defaults the limit to 50 when the body omits it', async () => {
     let seenLimit = 0;
     const data = readyClient({

data/lib/whatsapp_notifier/services/web_automation/history.ts

@@ -13,7 +13,9 @@ import {
     InboundMediaInfo,
     ChatLike,
     shouldCapture,
-    normalizeInbound
+    normalizeInbound,
+    resolveLidAlias,
+    rememberLidAlias
 } from './inbound';
 import { verifyMediaToken, MediaResolution, sanitizeId } from './media';
 
@@ -96,12 +98,37 @@ export function historyMediaInfo(): InboundMediaInfo {
 // host threads whole conversations. Messages failing shouldCapture (system
 // events, status, group posts) are skipped. Returned oldest-first so the
 // host can ingest in thread order.
-export async function replayHistory(userId: string, chat: ChatLike, limit: number): Promise<InboundMsg[]> {
+//
+// fromMe items in an @lid-keyed chat carry the @lid at `to` — unmatchable
+// host-side, exactly the live-capture bug. requestedChatId is the @c.us id
+// the host asked POST /history for (normalizeHistoryChatId enforces the
+// suffix), and fetchMessages only ever returns THIS chat's messages, so that
+// id IS the @lid's phone: resolve with it and learn the alias — which is also
+// how a restarted service can relearn mappings (and backfill previously
+// dropped operator messages) without waiting for the customer to write.
+// Without it (test seam) the learned map is the fallback; what neither
+// resolves is skipped — the same never-forward-an-unmatchable-counterparty
+// rule as the live fromMe leg.
+export async function replayHistory(
+    userId: string,
+    chat: ChatLike,
+    limit: number,
+    requestedChatId?: string
+): Promise<InboundMsg[]> {
     const msgs = await chat.fetchMessages({ limit });
-    return (Array.isArray(msgs) ? msgs : [])
-        .filter((m) => shouldCapture(userId, m))
-        .map((m) => normalizeInbound(m, m.hasMedia ? historyMediaInfo() : undefined))
-        .sort((a, b) => a.timestamp - b.timestamp);
+    const out: InboundMsg[] = [];
+    for (const m of (Array.isArray(msgs) ? msgs : [])) {
+        if (!shouldCapture(userId, m)) continue;
+        const inbound = normalizeInbound(m, m.hasMedia ? historyMediaInfo() : undefined);
+        if (inbound.fromMe && inbound.to && inbound.to.endsWith('@lid')) {
+            const resolved = requestedChatId || resolveLidAlias(userId, inbound.to);
+            if (!resolved) continue;
+            if (requestedChatId) rememberLidAlias(userId, inbound.to, requestedChatId);
+            inbound.to = resolved;
+        }
+        out.push(inbound);
+    }
+    return out.sort((a, b) => a.timestamp - b.timestamp);
 }
 
 // ── Route responses ──
@@ -193,7 +220,7 @@ export async function historyResponse(
         const chat = await deps.resolveChat(gate.client, chatId);
         if (!chat) return deny(404, 'chat not found');
 
-        const messages = await replayHistory(userId, chat, clampHistoryLimit(body && body.limit));
+        const messages = await replayHistory(userId, chat, clampHistoryLimit(body && body.limit), chatId);
 
         // A synced chat is a conversation of record: allowlist it like a /send
         // recipient so disconnect-window replies to it backfill on reconnect.

data/lib/whatsapp_notifier/services/web_automation/inbound.test.ts

@@ -10,6 +10,7 @@ import {
     loadTargets,
     rememberTarget,
     rememberLidAlias,
+    resolveLidAlias,
     rememberSelfSend,
     isSelfSend,
     resolveChat,
@@ -158,13 +159,17 @@ test('rememberLidAlias stores the @lid chat id for a known target', () => {
     expect(loadTargets('la1').has(CUST)).toBe(true);
 });
 
-test('rememberLidAlias ignores unknown senders and non-@lid raw ids', () => {
+test('rememberLidAlias keeps unknown senders off the allowlist and skips non-@lid raw ids', () => {
     rememberTarget('la2', CUST);
 
     rememberLidAlias('la2', '999@lid', '918888000000@c.us'); // resolved not a target
     rememberLidAlias('la2', CUST, CUST);                     // raw is already @c.us
 
     expect(loadTargets('la2')).toEqual(new Set([CUST]));
+    // The mapping itself IS learned for the unknown sender (the fromMe leg
+    // needs it regardless of the allowlist), but never for a non-@lid raw id.
+    expect(resolveLidAlias('la2', '999@lid')).toBe('918888000000@c.us');
+    expect(resolveLidAlias('la2', CUST)).toBeUndefined();
 });
 
 // backfill resolves chats directly, then via contact, and skips dead targets
@@ -414,11 +419,11 @@ test('processInbound resolves media for operator-sent media messages', async ()
     expect(drained[0].mediaSize).toBe(10);
 });
 
-// An @lid counterparty on fromMe has no phone the host can thread on and no
-// contact handle to resolve it through (getContact resolves the sender — the
-// operator). Dropped with a log, before any download — same disk-hygiene rule
-// as the inbound @lid drop.
-test('processInbound drops a fromMe message to an @lid chat before any download', async () => {
+// An @lid counterparty on fromMe that resolves through NEITHER the learned
+// alias map NOR the live contact lookup (here: a message with no client
+// handle at all) stays dropped with a log, before any download — same
+// disk-hygiene rule as the inbound @lid drop.
+test('processInbound drops a fromMe message to an unresolvable @lid chat before any download', async () => {
     let resolveCalls = 0;
     const m = mediaMsg({ fromMe: true, from: OPERATOR, to: LID_FROM });
 
@@ -431,6 +436,115 @@ test('processInbound drops a fromMe message to an @lid chat before any download'
     expect(loadTargets('fm4').size).toBe(0); // an unmatchable chat earns no allowlist slot
 });
 
+// ── fromMe @lid resolution (the two-way rollout blocker) ──
+//
+// Prod evidence 2026-07-10, chat 125417440686124@lid: customer messages in
+// the chat resolved to the phone and flowed, while EVERY operator-phone
+// message hit the unconditional drop. Resolution order: learned alias map →
+// one live getContactById(<@lid>) lookup (the same call the inbound leg is
+// proven on) → logged drop.
+
+test('processInbound resolves a fromMe @lid counterparty from the learned alias map', async () => {
+    // The customer wrote earlier — the inbound leg learned the alias.
+    rememberLidAlias('fl1', LID_FROM, CUST);
+
+    let contactLookups = 0;
+    const m = msg({
+        fromMe: true, from: OPERATOR, to: LID_FROM, body: 'Yes cool',
+        client: { getContactById: async () => { contactLookups += 1; return { number: '919999000001' }; } }
+    });
+
+    const pushed: InboundMsg[] = [];
+    await processInbound('fl1', m, {
+        resolveMedia: async () => ({ mediaStatus: 'available' as const }),
+        push: (_u, inbound) => pushed.push(inbound)
+    });
+
+    const drained = drainInbound('fl1');
+    expect(drained.length).toBe(1);
+    expect(drained[0].fromMe).toBe(true);
+    expect(drained[0].to).toBe(CUST);                    // resolved phone, not the @lid
+    expect(drained[0].body).toBe('Yes cool');
+    expect(pushed).toEqual(drained);                     // webhook saw the same payload
+    expect(contactLookups).toBe(0);                      // map hit → no puppeteer roundtrip
+    expect(loadTargets('fl1').has(CUST)).toBe(true);     // allowlisted like any fromMe counterparty
+    expect(loadTargets('fl1').has(LID_FROM)).toBe(true); // the chat's REAL key joins the allowlist too
+});
+
+test('processInbound live-resolves a fromMe @lid chat and learns the alias for next time', async () => {
+    const seenIds: string[] = [];
+    const m = msg({
+        fromMe: true, from: OPERATOR, to: LID_FROM, body: 'No still not',
+        client: { getContactById: async (id: string) => { seenIds.push(id); return { number: '919999000001' }; } }
+    });
+
+    await processInbound('fl2', m, { resolveMedia: async () => ({ mediaStatus: 'available' as const }) });
+
+    const drained = drainInbound('fl2');
+    expect(drained.length).toBe(1);
+    expect(drained[0].to).toBe(CUST);
+    expect(seenIds).toEqual([LID_FROM]);                   // the inbound leg's exact lookup, by the @lid
+    expect(resolveLidAlias('fl2', LID_FROM)).toBe(CUST);   // learned → the next message is a map hit
+});
+
+test('live resolution trusts contact.id.user only when the contact id is phone-keyed', async () => {
+    // No `number`, but a @c.us-keyed contact id carries the phone at id.user.
+    const good = msg({
+        fromMe: true, from: OPERATOR, to: LID_FROM,
+        client: { getContactById: async () => ({ id: { user: '919999000001', _serialized: CUST } }) }
+    });
+    await processInbound('fl3', good, { resolveMedia: async () => ({ mediaStatus: 'available' as const }) });
+    expect(drainInbound('fl3')[0].to).toBe(CUST);
+
+    // An @lid-keyed contact id must NOT mint a bogus "phone" out of the
+    // privacy id's own digits — that message is unresolvable and dropped.
+    const bogus = msg({
+        fromMe: true, from: OPERATOR, to: LID_FROM, id: { _serialized: 'b1' },
+        client: { getContactById: async () => ({ id: { user: '125417440686124', _serialized: LID_FROM } }) }
+    });
+    await processInbound('fl4', bogus, { resolveMedia: async () => ({ mediaStatus: 'available' as const }) });
+    expect(drainInbound('fl4')).toEqual([]);
+    expect(resolveLidAlias('fl4', LID_FROM)).toBeUndefined();
+});
+
+test('processInbound still drops a fromMe @lid message when the live lookup throws', async () => {
+    let resolveCalls = 0;
+    const m = mediaMsg({
+        fromMe: true, from: OPERATOR, to: LID_FROM,
+        client: { getContactById: async () => { throw new Error('contact store not hydrated'); } }
+    });
+
+    await processInbound('fl5', m, {
+        resolveMedia: async () => { resolveCalls += 1; return { mediaStatus: 'available' as const }; }
+    });
+
+    expect(resolveCalls).toBe(0);                // dropped BEFORE any download
+    expect(drainInbound('fl5')).toEqual([]);
+    expect(loadTargets('fl5').size).toBe(0);
+});
+
+test('rememberLidAlias persists the @lid → phone mapping across a restart', () => {
+    rememberLidAlias('al1', LID_FROM, CUST);
+    expect(resolveLidAlias('al1', LID_FROM)).toBe(CUST);
+
+    const file = join(dirFor('al1'), 'lid_aliases.json');
+    expect(existsSync(file)).toBe(true);
+    expect(JSON.parse(readFileSync(file, 'utf8'))).toEqual({ [LID_FROM]: CUST });
+
+    resetInboundState(); // the restart: drop in-memory cache → must reload from disk
+    configureInbound(dirFor);
+    expect(resolveLidAlias('al1', LID_FROM)).toBe(CUST);
+});
+
+test('clearInbound drops the cached alias map so a re-pair cannot inherit old mappings', () => {
+    rememberLidAlias('al2', LID_FROM, CUST);
+    // Logout wipes the session dir (incl. lid_aliases.json) from disk...
+    rmSync(dirFor('al2'), { recursive: true, force: true });
+    // ...but without clearInbound the in-memory cache would still resolve.
+    clearInbound('al2');
+    expect(resolveLidAlias('al2', LID_FROM)).toBeUndefined();
+});
+
 // ── Self-send echo suppression ──
 //
 // Every /send fires its own fromMe message_create echo. A registry hit must

data/lib/whatsapp_notifier/services/web_automation/inbound.ts

@@ -54,6 +54,13 @@ export const INBOUND_QUEUE_CAP = 1000;
 
 const inboundQueues = new Map<string, InboundMsg[]>();
 const outboundTargets = new Map<string, Set<string>>();
+// userId → (@lid privacy id → resolved phone @c.us). Learned whenever an @lid
+// is resolved to a phone (inbound contact lookup, fromMe live lookup, history
+// replay) and consulted by the fromMe leg, where msg.getContact() is no help
+// (it resolves the SENDER — the operator). Persisted per user next to
+// outbound_targets.json so a restart doesn't resume dropping operator
+// messages until the customer happens to write again.
+const lidAliases = new Map<string, Map<string, string>>();
 
 // How to resolve a user's on-disk session dir. index.ts wires this to
 // sessionDirForUser; tests point it at a tmp dir.
@@ -66,6 +73,34 @@ function targetsFilePath(userId: string) {
     return join(baseDirResolver(userId), 'outbound_targets.json');
 }
 
+function aliasesFilePath(userId: string) {
+    return join(baseDirResolver(userId), 'lid_aliases.json');
+}
+
+export function loadLidAliases(userId: string): Map<string, string> {
+    const cached = lidAliases.get(userId);
+    if (cached) return cached;
+
+    const map = new Map<string, string>();
+    try {
+        const p = aliasesFilePath(userId);
+        if (existsSync(p)) {
+            const obj = JSON.parse(readFileSync(p, 'utf8'));
+            if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+                for (const [lid, phone] of Object.entries(obj)) {
+                    if (typeof phone === 'string') map.set(lid, phone);
+                }
+            }
+        }
+    } catch (_) { /* corrupt/missing file → start empty */ }
+    lidAliases.set(userId, map);
+    return map;
+}
+
+export function resolveLidAlias(userId: string, lid: string): string | undefined {
+    return loadLidAliases(userId).get(lid);
+}
+
 export function loadTargets(userId: string): Set<string> {
     const cached = outboundTargets.get(userId);
     if (cached) return cached;
@@ -82,15 +117,31 @@ export function loadTargets(userId: string): Set<string> {
     return set;
 }
 
-// After an @lid sender is resolved to a phone @c.us: if the resolved phone is
-// one of our outbound targets, remember the @lid alias too. rememberTarget at
-// send time only ever stores @c.us ids, but for privacy-number accounts the
-// *chat* is keyed by the @lid — so a reconnect backfill that replays targets
-// via chat-id lookup could never re-open that chat, permanently losing any
-// disconnect-window replies. Duplicate captures across the @c.us/@lid pair are
-// fine: the contract is at-least-once and the host dedupes on messageId.
+// After an @lid is resolved to a phone @c.us, two things are remembered:
+//
+// 1. The @lid → phone mapping itself (persisted, see lidAliases): the fromMe
+//    leg has no contact handle of its own, so without this map every operator
+//    message in an @lid-keyed chat would depend on a live lookup succeeding.
+// 2. If the resolved phone is one of our outbound targets, the @lid joins the
+//    allowlist too. rememberTarget at send time only ever stores @c.us ids,
+//    but for privacy-number accounts the *chat* is keyed by the @lid — so a
+//    reconnect backfill that replays targets via chat-id lookup could never
+//    re-open that chat, permanently losing any disconnect-window replies.
+//    Duplicate captures across the @c.us/@lid pair are fine: the contract is
+//    at-least-once and the host dedupes on messageId.
 export function rememberLidAlias(userId: string, rawFrom: string, resolvedFrom: string) {
     if (!rawFrom.endsWith('@lid')) return;
+    const aliases = loadLidAliases(userId);
+    if (aliases.get(rawFrom) !== resolvedFrom) {
+        aliases.set(rawFrom, resolvedFrom);
+        try {
+            const dir = baseDirResolver(userId);
+            if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+            writeFileSync(aliasesFilePath(userId), JSON.stringify(Object.fromEntries(aliases)));
+        } catch (e) {
+            console.error(`Failed to persist @lid alias for ${userId}`, e);
+        }
+    }
     if (loadTargets(userId).has(resolvedFrom)) rememberTarget(userId, rawFrom);
 }
 
@@ -300,15 +351,23 @@ async function processOwnMessage(userId: string, msg: any, deps: CaptureDeps) {
     const messageId = msg.id && msg.id._serialized;
     if (messageId && isSelfSend(userId, messageId)) return;
 
-    const to: string = msg.to || '';
+    const rawTo: string = msg.to || '';
+    let to = rawTo;
     // An @lid counterparty carries no phone number the host can thread on,
-    // and unlike inbound there is no contact handle to resolve it through
-    // (msg.getContact() resolves the SENDER — here, the operator). Rare in
-    // practice: operator-initiated chats are keyed by the phone @c.us. Drop
-    // with a log rather than forward an unmatchable body.
-    if (to.endsWith('@lid')) {
-        console.log(`Dropping fromMe message to unresolved @lid chat for ${userId}`);
-        return;
+    // and msg.getContact() is no help here (it resolves the SENDER — the
+    // operator). Newer WhatsApp keys some 1:1 chats by the @lid, so EVERY
+    // operator-phone message in such a chat used to hit an unconditional
+    // drop while the customer's side flowed — half the conversation lost.
+    // Resolve it instead, BEFORE any media download (a dropped message must
+    // not have cost one): the alias map the inbound leg learns first, then
+    // one guarded live lookup. Only when both fail is the message dropped —
+    // now the rare case, not every @lid-keyed chat.
+    if (rawTo.endsWith('@lid')) {
+        to = resolveLidAlias(userId, rawTo) || await resolveOwnLidCounterparty(userId, rawTo, msg) || '';
+        if (!to) {
+            console.log(`Dropping fromMe message to unresolved @lid chat for ${userId}`);
+            return;
+        }
     }
 
     // Same kept-message-earns-the-download rule as inbound: every resolver
@@ -319,17 +378,52 @@ async function processOwnMessage(userId: string, msg: any, deps: CaptureDeps) {
     }
 
     const inbound = normalizeInbound(msg, media);
+    // Thread on the resolved phone: the host matches `to` against its own
+    // recipient records, and a raw @lid would never match. The @lid is still
+    // fine as normalizeInbound's fallback-id key — any stable counterparty
+    // string dedupes correctly.
+    inbound.to = to;
 
     // A fromMe message to a brand-new number means the operator opened the
     // conversation in the WhatsApp app — allowlist the chat exactly like
     // /send does for its recipients, so the reconnect backfill can replay
-    // this conversation after a disconnect window too.
+    // this conversation after a disconnect window too. For an @lid-keyed
+    // chat the alias call ALSO allowlists the @lid id itself — the id the
+    // chat is actually reachable by (see rememberLidAlias).
     rememberTarget(userId, to);
+    if (rawTo.endsWith('@lid')) rememberLidAlias(userId, rawTo, to);
 
     enqueueInbound(userId, inbound);
     if (deps.push) deps.push(userId, inbound);
 }
 
+// Live fallback for a fromMe @lid counterparty with no learned alias yet
+// (e.g. right after a restart, before the customer writes again). Every wwebjs
+// Message carries its Client, and client.getContactById(<@lid>) is the exact
+// call the inbound leg's msg.getContact() makes for @lid senders — the one
+// path proven to yield the real phone in production. One roundtrip, guarded;
+// a hit is fed into rememberLidAlias so the next fromMe message resolves from
+// the map. contact.id.user is trusted only when the contact id itself is
+// phone-keyed — an @lid contact id would otherwise mint a bogus "phone" out
+// of the privacy id's own digits.
+async function resolveOwnLidCounterparty(userId: string, rawTo: string, msg: any): Promise<string | null> {
+    try {
+        const client = msg.client;
+        if (!client || typeof client.getContactById !== 'function') return null;
+        const contact = await client.getContactById(rawTo);
+        const num = contact && (contact.number ||
+            (contact.id && String(contact.id._serialized || '').endsWith('@c.us') && contact.id.user));
+        const digits = num ? String(num).replace(/\D/g, '') : '';
+        if (!digits) return null;
+        const resolved = `${digits}@c.us`;
+        rememberLidAlias(userId, rawTo, resolved);
+        return resolved;
+    } catch (e) {
+        console.error(`fromMe @lid contact lookup failed for ${userId}`, e);
+        return null;
+    }
+}
+
 // Minimal slice of whatsapp-web.js Client that backfill needs — a seam so the
 // replay loop can be tested without booting a real client.
 export interface ChatLike {
@@ -385,6 +479,10 @@ export async function backfillTargets(
 export function clearInbound(userId: string) {
     inboundQueues.delete(userId);
     outboundTargets.delete(userId);
+    // Same resurrection hazard as the allowlist: the on-disk lid_aliases.json
+    // was just wiped with the session dir, and a re-pair (possibly a DIFFERENT
+    // WhatsApp number) must not inherit the old pairing's @lid mappings.
+    lidAliases.delete(userId);
     // Self-send echo ids belong to the old pairing too — and suppression must
     // never leak across a re-pair (however unlikely an id collision is).
     selfSendIds.delete(userId);
@@ -394,5 +492,6 @@ export function clearInbound(userId: string) {
 export function resetInboundState() {
     inboundQueues.clear();
     outboundTargets.clear();
+    lidAliases.clear();
     selfSendIds.clear();
 }

data/lib/whatsapp_notifier/version.rb

@@ -1,4 +1,4 @@
 module WhatsAppNotifier
-  VERSION = "0.8.1"
+  VERSION = "0.8.2"
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whatsapp_notifier
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.2
 platform: ruby
 authors:
 - Kshitiz Sinha