Fix false WhatsApp stale-socket restarts on idle sessions

OpenClaw Assistant · OpenClaw Assistant · commit 5709858e3c29 · 2026-03-15T17:13:40.000Z
diff --git a/extensions/whatsapp/src/auto-reply.web-auto-reply.connection-and-logging.e2e.test.ts b/extensions/whatsapp/src/auto-reply.web-auto-reply.connection-and-logging.e2e.test.ts
@@ -278,6 +278,78 @@ describe("web auto-reply connection", () => {
     }
   });
 
+  it("does not reconnect solely because the inbox stays quiet by default", async () => {
+    vi.useFakeTimers();
+    try {
+      const sleep = vi.fn(async () => {});
+      const closeResolvers: Array<(reason: unknown) => void> = [];
+      let capturedOnMessage:
+        | ((msg: import("./inbound.js").WebInboundMessage) => Promise<void>)
+        | undefined;
+      const listenerFactory = vi.fn(
+        async (opts: {
+          onMessage: (msg: import("./inbound.js").WebInboundMessage) => Promise<void>;
+        }) => {
+          capturedOnMessage = opts.onMessage;
+          let resolveClose: (reason: unknown) => void = () => {};
+          const onClose = new Promise<unknown>((res) => {
+            resolveClose = res;
+            closeResolvers.push(res);
+          });
+          return {
+            close: vi.fn(),
+            onClose,
+            signalClose: (reason?: unknown) => resolveClose(reason),
+          };
+        },
+      );
+      const { controller, run } = startMonitorWebChannel({
+        monitorWebChannelFn: monitorWebChannel as never,
+        listenerFactory,
+        sleep,
+        heartbeatSeconds: 60,
+        watchdogCheckMs: 5,
+      });
+
+      await Promise.resolve();
+      expect(listenerFactory).toHaveBeenCalledTimes(1);
+      await vi.waitFor(
+        () => {
+          expect(capturedOnMessage).toBeTypeOf("function");
+        },
+        { timeout: 250, interval: 2 },
+      );
+
+      const reply = vi.fn().mockResolvedValue(undefined);
+      const sendComposing = vi.fn();
+      const sendMedia = vi.fn();
+
+      await capturedOnMessage?.(
+        makeInboundMessage({
+          body: "hi",
+          from: "+1",
+          to: "+2",
+          id: "m1",
+          sendComposing,
+          reply,
+          sendMedia,
+        }),
+      );
+
+      await vi.advanceTimersByTimeAsync(5 * 60 * 1_000);
+      await Promise.resolve();
+      expect(listenerFactory).toHaveBeenCalledTimes(1);
+      expect(sleep).not.toHaveBeenCalled();
+
+      controller.abort();
+      closeResolvers[0]?.({ status: 499, isLoggedOut: false });
+      await Promise.resolve();
+      await run;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("processes inbound messages without batching and preserves timestamps", async () => {
     await withEnvAsync({ TZ: "Europe/Vienna" }, async () => {
       const originalMax = process.getMaxListeners();
diff --git a/extensions/whatsapp/src/auto-reply/monitor.ts b/extensions/whatsapp/src/auto-reply/monitor.ts
@@ -156,9 +156,10 @@ export async function monitorWebChannel(
     let _lastInboundMsg: WebInboundMsg | null = null;
     let unregisterUnhandled: (() => void) | null = null;
 
-    // Watchdog to detect stuck message processing (e.g., event emitter died).
-    // Tuning overrides are test-oriented; production defaults remain unchanged.
-    const MESSAGE_TIMEOUT_MS = tuning.messageTimeoutMs ?? 30 * 60 * 1000; // 30m default
+    // The WhatsApp inbox can legitimately stay quiet for long stretches, so the
+    // absence of inbound messages is not reliable evidence that the socket died.
+    // Keep the watchdog opt-in via tuning for tests and targeted diagnostics.
+    const MESSAGE_TIMEOUT_MS = tuning.messageTimeoutMs ?? Number.POSITIVE_INFINITY;
     const WATCHDOG_CHECK_MS = tuning.watchdogCheckMs ?? 60 * 1000; // 1m default
 
     const backgroundTasks = new Set<Promise<unknown>>();
@@ -286,11 +287,7 @@ export async function monitorWebChannel(
             : {}),
         };
 
-        if (minutesSinceLastMessage && minutesSinceLastMessage > 30) {
-          heartbeatLogger.warn(logData, "⚠️ web gateway heartbeat - no messages in 30+ minutes");
-        } else {
-          heartbeatLogger.info(logData, "web gateway heartbeat");
-        }
+        heartbeatLogger.info(logData, "web gateway heartbeat");
       }, heartbeatSeconds * 1000);
 
       watchdogTimer = setInterval(() => {
diff --git a/src/gateway/channel-health-monitor.test.ts b/src/gateway/channel-health-monitor.test.ts
@@ -557,6 +557,23 @@ describe("channel-health-monitor", () => {
       await expectNoRestart(manager);
     });
 
+    it("skips WhatsApp idle channels even when lastEventAt is old", async () => {
+      const now = Date.now();
+      const manager = createSnapshotManager({
+        whatsapp: {
+          default: {
+            running: true,
+            connected: true,
+            enabled: true,
+            configured: true,
+            lastStartAt: now - STALE_THRESHOLD - 60_000,
+            lastEventAt: now - STALE_THRESHOLD - 30_000,
+          },
+        },
+      });
+      await expectNoRestart(manager);
+    });
+
     it("respects custom staleEventThresholdMs", async () => {
       const customThreshold = 10 * 60_000;
       const now = Date.now();
diff --git a/src/gateway/channel-health-policy.test.ts b/src/gateway/channel-health-policy.test.ts
@@ -156,6 +156,26 @@ describe("evaluateChannelHealth", () => {
     expect(evaluation).toEqual({ healthy: true, reason: "healthy" });
   });
 
+  it("skips stale-socket detection for WhatsApp idle periods", () => {
+    const evaluation = evaluateChannelHealth(
+      {
+        running: true,
+        connected: true,
+        enabled: true,
+        configured: true,
+        lastStartAt: 0,
+        lastEventAt: 0,
+      },
+      {
+        channelId: "whatsapp",
+        now: 100_000,
+        channelConnectGraceMs: 10_000,
+        staleEventThresholdMs: 30_000,
+      },
+    );
+    expect(evaluation).toEqual({ healthy: true, reason: "healthy" });
+  });
+
   it("skips stale-socket detection for channels in webhook mode", () => {
     const evaluation = evaluateDiscordHealth({
       running: true,
diff --git a/src/gateway/channel-health-policy.ts b/src/gateway/channel-health-policy.ts
@@ -106,12 +106,14 @@ export function evaluateChannelHealth(
   if (snapshot.connected === false) {
     return { healthy: false, reason: "disconnected" };
   }
-  // Skip stale-socket check for Telegram (long-polling mode) and any channel
-  // explicitly operating in webhook mode. In these cases, there is no persistent
-  // outgoing socket that can go half-dead, so the lack of incoming events
-  // does not necessarily indicate a connection failure.
+  // Skip stale-socket check for Telegram (long-polling mode), WhatsApp Web
+  // (its lastEventAt currently tracks inbound message flow rather than socket
+  // liveness), and any channel explicitly operating in webhook mode. In these
+  // cases, the lack of incoming events does not necessarily indicate a broken
+  // connection.
   if (
     policy.channelId !== "telegram" &&
+    policy.channelId !== "whatsapp" &&
     snapshot.mode !== "webhook" &&
     snapshot.connected === true &&
     snapshot.lastEventAt != null
