fix(commands): inherit the chat disappearing timer when replying

Author: zeative

docs/content/message-payload.mdx

@@ -300,8 +300,9 @@ A few values come from your `Client` config rather than the raw message:
 - **`isSpam` is reserved** and always `false` today. Use `forwardCount >= 5` for chain-message detection.
 - **Answer only live messages.** After a reconnect WhatsApp replays everything you missed. Guard with
   `if (ctx.isOld) return` unless you deliberately want to process the backlog.
-- **Mirror the disappearing timer on replies.** `ctx.reply()` does not inherit it — pass
-  `ctx.ephemeralDuration` to `.disappearing()` yourself, or your answer outlives the thread it belongs to.
+- **`ctx.reply()` inherits the disappearing timer automatically.** An answer in a disappearing chat
+  disappears with it. Only `client.send(...)` needs `.disappearing(ctx.ephemeralDuration)` passed by
+  hand — without it WhatsApp marks the message *"this message won't disappear"*.
 - **`senderUsername` is usually `null` — WhatsApp sends the phone number _or_ the username, never
   both.** A username is the fallback handle for a sender whose number you cannot see, so it stays
   `null` for anyone whose phone number your account already knows (which is most people). It arrives

src/client/client.ts

@@ -73,6 +73,7 @@ import {
 } from '../automation/index.js'
 import type { CitationConfig, MessageContext } from '../events/context.js'
 import { createDownloadFn } from '../events/decoders/_media-download.js'
+import { ephemeralExpirationOf } from '../events/decoders/messages.js'
 import type { CallPayload, MediaDownloadResult, MediaKind } from '../events/types.js'
 import {
   formatConnectionStatus,
@@ -614,7 +615,7 @@ export class Client extends TypedEventEmitter<ClientEventMap> {
       resolveQuoted: (id, remoteJid) => this.lookupQuoted(id, remoteJid),
       resolveLidToPn: () => Promise.resolve(null),
       sendReply: async (target, content, opts, quoted) =>
-        await this.send(target).text(content, opts).reply(quoted),
+        await this.replyWithSameLifetime(target, content, opts, quoted),
       react: (key, emoji) => this.react(key, emoji),
       ignoreMe: this.ignoreMe,
     })
@@ -805,6 +806,19 @@ export class Client extends TypedEventEmitter<ClientEventMap> {
     })
   }
 
+  /** Replies inherit the quoted message's disappearing timer, so an answer never outlives its thread. */
+  private async replyWithSameLifetime(
+    target: string,
+    content: string,
+    opts: TextOptions | undefined,
+    quoted: WAMessage,
+  ): Promise<WAMessageKey> {
+    const builder = this.send(target).text(content, opts)
+    const expiration = ephemeralExpirationOf(quoted)
+    const withLifetime = expiration !== undefined ? builder.disappearing(expiration) : builder
+    return withLifetime.reply(quoted)
+  }
+
   /** Admin lookup for the `admin` guard. Never throws — an unreachable group means "not an admin". */
   private async isGroupAdmin(groupJid: string, senderJid: string): Promise<boolean> {
     try {
@@ -835,7 +849,7 @@ export class Client extends TypedEventEmitter<ClientEventMap> {
       json: resolved.json,
       reply: async (content: string, opts?: TextOptions): Promise<WAMessageKey> => {
         const target = msg.message().key.remoteJid ?? msg.roomId ?? msg.senderId
-        const key = await this.send(target).text(content, opts).reply(msg.message())
+        const key = await this.replyWithSameLifetime(target, content, opts, msg.message())
         lastSentKey = key
         return key
       },
@@ -1141,7 +1155,7 @@ export class Client extends TypedEventEmitter<ClientEventMap> {
         resolveQuoted: (id, remoteJid) => this.lookupQuoted(id, remoteJid),
         resolveLidToPn: (lid) => this.lidToPn(lid),
         sendReply: async (target, content, opts, quoted) =>
-          await this.send(target).text(content, opts).reply(quoted),
+          await this.replyWithSameLifetime(target, content, opts, quoted),
         react: (key, emoji) => this.react(key, emoji),
         ignoreMe: this.ignoreMe,
       })

src/events/decoders/messages.ts

@@ -516,6 +516,13 @@ const isEphemeralOf = (msg: WAMessage, contextInfo: WAContextInfo | null): boole
   return typeof contextInfo?.expiration === 'number' && contextInfo.expiration > 0
 }
 
+/**
+ * The disappearing timer a reply must copy. Without it WhatsApp flags the answer as one that will
+ * not disappear, leaving it behind in a chat whose other messages are gone.
+ */
+export const ephemeralExpirationOf = (msg: WAMessage): number | undefined =>
+  ephemeralDurationOf(msg, contextInfoOf(msg)) ?? undefined
+
 const numOr = (value: unknown, fallback: number): number =>
   typeof value === 'number' && Number.isFinite(value) ? value : fallback
 

tests/client/reply-lifetime.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { MiscMessageGenerationOptions, WAMessage } from 'baileys'
+import { Client } from '../../src/client/client.js'
+import { MemoryAuthStore } from '../../src/auth/adapters/memory.js'
+import type { MessageContext } from '../../src/events/context.js'
+
+const SENDER = '628111@s.whatsapp.net'
+
+/** A quoted message from a chat whose disappearing timer is `expiration` seconds. */
+const quoted = (expiration?: number): WAMessage =>
+  ({
+    key: { remoteJid: SENDER, id: 'M1', fromMe: false },
+    message: {
+      extendedTextMessage: {
+        text: 'halo',
+        ...(expiration === undefined ? {} : { contextInfo: { expiration } }),
+      },
+    },
+  }) as unknown as WAMessage
+
+const msg = (expiration?: number): MessageContext =>
+  ({
+    text: '!ping',
+    senderId: SENDER,
+    roomId: SENDER,
+    isGroup: false,
+    message: () => quoted(expiration),
+  }) as unknown as MessageContext
+
+const connected = () => {
+  const sendMessage = vi.fn(async () => ({ key: { remoteJid: SENDER, id: 'OUT', fromMe: true } }))
+  const client = new Client({
+    auth: new MemoryAuthStore(),
+    qrTerminal: false,
+    autoConnect: false,
+    commandPrefix: '!',
+  })
+  ;(client as unknown as { _socket: unknown })._socket = {
+    user: { id: 'me@s.whatsapp.net' },
+    sendMessage,
+  }
+  return { client, sendMessage }
+}
+
+const optionsOf = (
+  sendMessage: ReturnType<typeof connected>['sendMessage'],
+): MiscMessageGenerationOptions =>
+  (sendMessage.mock.calls[0] as unknown as [string, unknown, MiscMessageGenerationOptions])[2]
+
+describe('replies inherit the disappearing timer', () => {
+  it('copies the expiration of the message it answers', async () => {
+    const { client, sendMessage } = connected()
+    client.command('ping', async (ctx) => {
+      await ctx.reply('pong')
+    })
+    client.emit('text', msg(604800))
+    await new Promise((r) => setTimeout(r, 20))
+    expect(optionsOf(sendMessage).ephemeralExpiration).toBe(604800)
+  })
+
+  it('sends no expiration when the chat keeps its messages', async () => {
+    const { client, sendMessage } = connected()
+    client.command('ping', async (ctx) => {
+      await ctx.reply('pong')
+    })
+    client.emit('text', msg())
+    await new Promise((r) => setTimeout(r, 20))
+    expect(optionsOf(sendMessage).ephemeralExpiration).toBeUndefined()
+  })
+})