import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

import { afterEach, describe, expect, it, vi } from "vitest";

import { raceWithTimeout, withAbortTimeout } from "./timeouts.js";

afterEach(() => {

vi.useRealTimers();

vi.restoreAllMocks();

});

describe("discord monitor timeouts", () => {

it("caps raceWithTimeout timers before arming the watchdog", async () => {

const timeoutSpy = vi

.spyOn(globalThis, "setTimeout")

.mockReturnValue(1 as unknown as ReturnType<typeof setTimeout>);

vi.spyOn(globalThis, "clearTimeout").mockImplementation(() => undefined);

await expect(

raceWithTimeout({

promise: Promise.resolve("ok"),

timeoutMs: Number.MAX_SAFE_INTEGER,

onTimeout: () => "timeout",

}),

).resolves.toBe("ok");

expect(timeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

});

it("caps withAbortTimeout timers before arming the watchdog", async () => {

const timeoutSpy = vi

.spyOn(globalThis, "setTimeout")

.mockReturnValue(1 as unknown as ReturnType<typeof setTimeout>);

vi.spyOn(globalThis, "clearTimeout").mockImplementation(() => undefined);

await expect(

withAbortTimeout({

timeoutMs: Number.MAX_SAFE_INTEGER,

createTimeoutError: () => new Error("timed out"),

run: async () => "ok",

}),

).resolves.toBe("ok");

expect(timeoutSpy).toHaveBeenCalledWith(expect.any(Function), MAX_TIMER_TIMEOUT_MS);

});

});

import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";

// Compatibility constants for existing imports. Discord no longer enforces

// channel-owned listener or inbound run timeouts.

export const DISCORD_DEFAULT_LISTENER_TIMEOUT_MS = 120_000;

timeoutMs: number;

onTimeout: () => U;

}): Promise<T | U> {

const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);

let timeoutTimer: ReturnType<typeof setTimeout> | undefined;

const timeoutPromise = new Promise<U>((resolve) => {

timeoutTimer = setTimeout(() => resolve(params.onTimeout()), Math.max(1, params.timeoutMs));

timeoutTimer = setTimeout(() => resolve(params.onTimeout()), timeoutMs);

timeoutTimer.unref?.();

});

try {

createTimeoutError: () => Error;

run: (signal: AbortSignal) => Promise<T>;

}): Promise<T> {

const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);

const controller = new AbortController();

let timeoutTimer: ReturnType<typeof setTimeout> | undefined;

const timeoutPromise = new Promise<never>((_, reject) => {

timeoutTimer = setTimeout(

() => {

controller.abort();

reject(params.createTimeoutError());

},

Math.max(1, params.timeoutMs),

);

timeoutTimer = setTimeout(() => {

controller.abort();

reject(params.createTimeoutError());

}, timeoutMs);

timeoutTimer.unref?.();

});

try {