fix(slack): bound app mention retry clocks

steipete · steipete · commit 8539e0283a55 · 2026-05-30T11:04:24.000-04:00
diff --git a/extensions/slack/src/monitor/message-handler.app-mention-race.test.ts b/extensions/slack/src/monitor/message-handler.app-mention-race.test.ts
@@ -1,4 +1,4 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
 
 const prepareSlackMessageMock =
   vi.fn<
@@ -151,6 +151,10 @@ describe("createSlackMessageHandler app_mention race handling", () => {
     clearSlackRuntime();
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   it("allows a single app_mention retry when message event was dropped before dispatch", async () => {
     prepareSlackMessageMock.mockImplementation(async ({ opts }) => {
       if (opts.source === "message") {
@@ -169,6 +173,43 @@ describe("createSlackMessageHandler app_mention race handling", () => {
     expect(dispatchPreparedSlackMessageMock).toHaveBeenCalledTimes(1);
   });
 
+  it("does not retain app_mention retry allowance when the current clock is not a valid date timestamp", async () => {
+    const nowSpy = vi.spyOn(Date, "now").mockReturnValue(Number.NaN);
+    prepareSlackMessageMock.mockImplementation(async ({ opts }) => {
+      if (opts.source === "message") {
+        return null;
+      }
+      return { ctxPayload: {} };
+    });
+
+    const handler = createTestHandler();
+
+    await sendMessageEvent(handler, "1700000000.000125");
+    nowSpy.mockReturnValue(1_700_000_000_000);
+    await sendMentionEvent(handler, "1700000000.000125");
+
+    expect(prepareSlackMessageMock).toHaveBeenCalledTimes(1);
+    expect(dispatchPreparedSlackMessageMock).not.toHaveBeenCalled();
+  });
+
+  it("does not retain app_mention retry allowance when the expiry timestamp would exceed the valid date range", async () => {
+    vi.spyOn(Date, "now").mockReturnValue(8_640_000_000_000_000);
+    prepareSlackMessageMock.mockImplementation(async ({ opts }) => {
+      if (opts.source === "message") {
+        return null;
+      }
+      return { ctxPayload: {} };
+    });
+
+    const handler = createTestHandler();
+
+    await sendMessageEvent(handler, "1700000000.000126");
+    await sendMentionEvent(handler, "1700000000.000126");
+
+    expect(prepareSlackMessageMock).toHaveBeenCalledTimes(1);
+    expect(dispatchPreparedSlackMessageMock).not.toHaveBeenCalled();
+  });
+
   it("allows app_mention while message handling is still in-flight, then keeps later duplicates deduped", async () => {
     const { handler, messagePending, resolveMessagePrepare } =
       await createInFlightMessageScenario("1700000000.000150");
diff --git a/extensions/slack/src/monitor/message-handler.ts b/extensions/slack/src/monitor/message-handler.ts
@@ -3,6 +3,10 @@ import {
   shouldDebounceTextInbound,
 } from "openclaw/plugin-sdk/channel-inbound";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import {
+  asDateTimestampMs,
+  resolveExpiresAtMsFromDurationMs,
+} from "openclaw/plugin-sdk/number-runtime";
 import type { ResolvedSlackAccount } from "../accounts.js";
 import type { SlackMessageEvent } from "../types.js";
 import { stripSlackMentionsForCommandDetection } from "./commands.js";
@@ -123,7 +127,7 @@ export function createSlackMessageHandler(params: {
           pruneAppMentionRetryKeys(Date.now());
           if (last.opts.source === "app_mention") {
             // If app_mention wins the race and dispatches first, drop the later message dispatch.
-            appMentionDispatchedKeys.set(seenMessageKey, Date.now() + APP_MENTION_RETRY_TTL_MS);
+            rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
           } else if (
             last.opts.source === "message" &&
             appMentionDispatchedKeys.has(seenMessageKey)
@@ -176,28 +180,46 @@ export function createSlackMessageHandler(params: {
   const appMentionRetryKeys = new Map<string, number>();
   const appMentionDispatchedKeys = new Map<string, number>();
 
-  const pruneAppMentionRetryKeys = (now: number) => {
+  const pruneAppMentionRetryKeys = (rawNow: number): boolean => {
+    const now = asDateTimestampMs(rawNow);
+    if (now === undefined) {
+      appMentionRetryKeys.clear();
+      appMentionDispatchedKeys.clear();
+      return false;
+    }
     for (const [key, expiresAt] of appMentionRetryKeys) {
-      if (expiresAt <= now) {
+      if (asDateTimestampMs(expiresAt) === undefined || expiresAt <= now) {
         appMentionRetryKeys.delete(key);
       }
     }
     for (const [key, expiresAt] of appMentionDispatchedKeys) {
-      if (expiresAt <= now) {
+      if (asDateTimestampMs(expiresAt) === undefined || expiresAt <= now) {
         appMentionDispatchedKeys.delete(key);
       }
     }
+    return true;
   };
 
-  const rememberAppMentionRetryKey = (key: string) => {
+  const rememberExpiringAppMentionKey = (map: Map<string, number>, key: string): void => {
     const now = Date.now();
-    pruneAppMentionRetryKeys(now);
-    appMentionRetryKeys.set(key, now + APP_MENTION_RETRY_TTL_MS);
+    if (!pruneAppMentionRetryKeys(now)) {
+      return;
+    }
+    const expiresAt = resolveExpiresAtMsFromDurationMs(APP_MENTION_RETRY_TTL_MS, { nowMs: now });
+    if (expiresAt !== undefined) {
+      map.set(key, expiresAt);
+    }
+  };
+
+  const rememberAppMentionRetryKey = (key: string) => {
+    rememberExpiringAppMentionKey(appMentionRetryKeys, key);
   };
 
   const consumeAppMentionRetryKey = (key: string) => {
     const now = Date.now();
-    pruneAppMentionRetryKeys(now);
+    if (!pruneAppMentionRetryKeys(now)) {
+      return false;
+    }
     if (!appMentionRetryKeys.has(key)) {
       return false;
     }
