type UnknownMock = Mock<(...args: unknown[]) => unknown>;

type AsyncUnknownMock = Mock<(...args: unknown[]) => Promise<unknown>>;

const loadedMonitorModules = new Set<MonitorModule>();

const cachedMonitorModules = new Map<string, Promise<MonitorModule>>();

let cachedWebhookModule: Promise<WebhookModule> | undefined;

type ZaloLifecycleMocks = {

setWebhookMock: AsyncUnknownMock;

)) as SecretInputModule;

}

async function importWebhookModule(cacheBust: string): Promise<WebhookModule> {

return (await import(`${webhookModuleUrl}?t=${cacheBust}-${Date.now()}`)) as WebhookModule;

async function importCachedWebhookModule(): Promise<WebhookModule> {

cachedWebhookModule ??= import(webhookModuleUrl) as Promise<WebhookModule>;

return await cachedWebhookModule;

}

export async function resetLifecycleTestState() {

vi.clearAllMocks();

(await importWebhookModule("reset-webhook")).clearZaloWebhookSecurityStateForTest();

(await importCachedWebhookModule()).clearZaloWebhookSecurityStateForTest();

for (const module of loadedMonitorModules) {

module.__testing.clearHostedMediaRouteRefsForTest();

}

loadedMonitorModules.clear();

setActivePluginRegistry(createEmptyPluginRegistry());

}

return await importMonitorModule({ cacheBust: "monitor", mocked: true });

}

export async function loadCachedLifecycleMonitorModule(cacheKey: string): Promise<MonitorModule> {

const key = cacheKey.trim();

if (!key) {

throw new Error("cacheKey is required");

}

const cached =

cachedMonitorModules.get(key) ??

(async () => {

installLifecycleModuleMocks();

const module = (await import(`${monitorModuleUrl}?t=${key}`)) as MonitorModule;

loadedMonitorModules.add(module);

return module;

})();

cachedMonitorModules.set(key, cached);

return await cached;

}

export async function startWebhookLifecycleMonitor(params: {

account: ResolvedZaloAccount;

config: OpenClawConfig;

token?: string;

webhookUrl?: string;

webhookSecret?: string;

cacheKey?: string;

}) {

const registry = createEmptyPluginRegistry();

setActivePluginRegistry(registry);

const { normalizeSecretInputString } = await importSecretInputModule("secret-input");

const webhookSecret =

params.webhookSecret ?? normalizeSecretInputString(params.account.config?.webhookSecret);

const { monitorZaloProvider } = await loadLifecycleMonitorModule();

const { monitorZaloProvider } = params.cacheKey

? await loadCachedLifecycleMonitorModule(params.cacheKey)

: await loadLifecycleMonitorModule();

const run = monitorZaloProvider({

token: params.token ?? "zalo-token",

account: params.account,