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

import { MAX_TIMER_TIMEOUT_MS } from "../../shared/number-coercion.js";

import { createTypingController } from "./typing.js";

describe("typing persistence bug fix", () => {

expect(inert.isActive()).toBe(false);

expect(vi.getTimerCount()).toBe(0);

});

it("clamps oversized typing interval and TTL timers", async () => {

const setIntervalSpy = vi.spyOn(globalThis, "setInterval");

const setTimeoutSpy = vi.spyOn(globalThis, "setTimeout");

const boundedController = createTypingController({

onReplyStart: onReplyStartSpy,

onCleanup: onCleanupSpy,

typingIntervalSeconds: Number.MAX_SAFE_INTEGER,

typingTtlMs: Number.MAX_SAFE_INTEGER,

log: vi.fn(),

});

await boundedController.startTypingLoop();

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

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

boundedController.cleanup();

});

});

import {

finiteSecondsToTimerSafeMilliseconds,

resolveTimerTimeoutMs,

} from "@openclaw/normalization-core/number-coercion";

import { normalizeOptionalString } from "@openclaw/normalization-core/string-coerce";

import { createTypingKeepaliveLoop } from "../../channels/typing-lifecycle.js";

import { createTypingStartGuard } from "../../channels/typing-start-guard.js";

import { isSilentReplyPrefixText, isSilentReplyText, SILENT_REPLY_TOKEN } from "../tokens.js";

const DEFAULT_TYPING_INTERVAL_SECONDS = 6;

const DEFAULT_TYPING_TTL_MS = 2 * 60_000;

function resolveTypingIntervalMs(seconds: number | undefined): number {

if (Number.isFinite(seconds) && (seconds ?? 0) <= 0) {

return 0;

}

return (

finiteSecondsToTimerSafeMilliseconds(seconds ?? DEFAULT_TYPING_INTERVAL_SECONDS) ??

DEFAULT_TYPING_INTERVAL_SECONDS * 1000

);

}

export type TypingController = {

onReplyStart: () => Promise<void>;

startTypingLoop: () => Promise<void>;

silentToken?: string;

log?: (message: string) => void;

}): TypingController {

const {

onReplyStart,

onCleanup,

typingIntervalSeconds = 6,

typingTtlMs = 2 * 60_000,

silentToken = SILENT_REPLY_TOKEN,

log,

} = params;

const { onReplyStart, onCleanup, silentToken = SILENT_REPLY_TOKEN, log } = params;

if (!onReplyStart && !onCleanup) {

return {

onReplyStart: async () => {},

// Once we stop typing, we "seal" the controller so late events can't restart typing forever.

let sealed = false;

let typingTtlTimer: NodeJS.Timeout | undefined;

const typingIntervalMs = typingIntervalSeconds * 1000;

const typingIntervalMs = resolveTypingIntervalMs(params.typingIntervalSeconds);

const typingTtlMs = resolveTimerTimeoutMs(params.typingTtlMs, DEFAULT_TYPING_TTL_MS, 0);

const formatTypingTtl = (ms: number) => {

if (ms % 60_000 === 0) {