@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/connection-controller-Dt62u6fI.mjs

@@ -0,0 +1,493 @@
+import { n as registerWhatsAppConnectionController, r as unregisterWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.mjs";
+import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.mjs";
+import { t as DEFAULT_WHATSAPP_SOCKET_TIMING } from "./socket-timing-DhbVFjah.mjs";
+import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError } from "./auth-store-BZKGa0tW.mjs";
+import { c as resolveComparableIdentity } from "./identity-CDB1bT-p.mjs";
+import { r as waitForWaConnection, t as createWaSocket } from "./session-vUI41Jel.mjs";
+import { computeBackoff, info, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { clamp } from "openclaw/plugin-sdk/text-utility-runtime";
+import { randomUUID } from "node:crypto";
+const DEFAULT_RECONNECT_POLICY = {
+	initialMs: 2e3,
+	maxMs: 3e4,
+	factor: 1.8,
+	jitter: .25,
+	maxAttempts: 12
+};
+function resolveHeartbeatSeconds(cfg, overrideSeconds) {
+	const candidate = overrideSeconds ?? cfg.web?.heartbeatSeconds;
+	if (typeof candidate === "number" && candidate > 0) return candidate;
+	return 60;
+}
+function resolveReconnectPolicy(cfg, overrides) {
+	const reconnectOverrides = cfg.web?.reconnect ?? {};
+	const overrideConfig = overrides ?? {};
+	const merged = {
+		...DEFAULT_RECONNECT_POLICY,
+		...reconnectOverrides,
+		...overrideConfig
+	};
+	merged.initialMs = Math.max(250, merged.initialMs);
+	merged.maxMs = Math.max(merged.initialMs, merged.maxMs);
+	merged.factor = clamp(merged.factor, 1.1, 10);
+	merged.jitter = clamp(merged.jitter, 0, 1);
+	merged.maxAttempts = Math.max(0, Math.floor(merged.maxAttempts));
+	return merged;
+}
+function newConnectionId() {
+	return randomUUID();
+}
+//#endregion
+//#region extensions/whatsapp/src/connection-controller.ts
+const LOGGED_OUT_STATUS = 401;
+const POST_PAIRING_RESTART_STATUS = 515;
+const TIMED_OUT_STATUS = 408;
+const WHATSAPP_LOGIN_RESTART_MESSAGE = "WhatsApp asked for a restart after pairing (code 515); waiting for creds to save…";
+const WHATSAPP_LOGIN_TIMEOUT_RESTART_MESSAGE = "WhatsApp connection timed out before login; retrying with a fresh socket…";
+const WHATSAPP_LOGGED_OUT_RELINK_MESSAGE = "WhatsApp reported the session is logged out. Cleared cached web session; please rerun openclaw channels login and scan the QR again.";
+const WHATSAPP_LOGIN_AUTH_UNSTABLE_MESSAGE = "WhatsApp connected, but saving the linked credentials has not settled on disk yet. Retry login in a moment.";
+const WHATSAPP_LOGIN_AUTH_NOT_PERSISTED_MESSAGE = "WhatsApp connected, but the linked credentials were not found on disk. Retry login in a moment.";
+const WHATSAPP_LOGIN_AUTH_NOT_CLEARED_MESSAGE = "existing auth could not be cleared. Remove or fix the configured WhatsApp auth directory, then retry login.";
+const WHATSAPP_LOGGED_OUT_QR_MESSAGE = "WhatsApp reported the session is logged out. Cleared cached web session; please scan a new QR.";
+const WHATSAPP_WATCHDOG_TIMEOUT_ERROR = "watchdog-timeout";
+function createNeverResolvePromise() {
+	return new Promise(() => {});
+}
+function getLoginSocketRestartKind(statusCode) {
+	if (statusCode === POST_PAIRING_RESTART_STATUS) return "post-pairing";
+	if (statusCode === TIMED_OUT_STATUS) return "timeout";
+	return null;
+}
+function getLoginSocketRestartMessage(kind) {
+	return kind === "timeout" ? WHATSAPP_LOGIN_TIMEOUT_RESTART_MESSAGE : WHATSAPP_LOGIN_RESTART_MESSAGE;
+}
+function createLiveConnection(params) {
+	let closeResolved = false;
+	let resolveClosePromise = (_reason) => {};
+	const closePromise = new Promise((resolve) => {
+		resolveClosePromise = (reason) => {
+			if (closeResolved) return;
+			closeResolved = true;
+			resolve(reason);
+		};
+	});
+	return {
+		connectionId: params.connectionId,
+		startedAt: Date.now(),
+		sock: params.sock,
+		listener: params.listener,
+		heartbeat: null,
+		watchdogTimer: null,
+		lastInboundAt: null,
+		lastTransportActivityAt: Date.now(),
+		handledMessages: 0,
+		unregisterUnhandled: null,
+		unregisterTransportActivity: null,
+		openedAfterRecentInbound: params.openedAfterRecentInbound,
+		backgroundTasks: /* @__PURE__ */ new Set(),
+		closePromise,
+		resolveClose: resolveClosePromise
+	};
+}
+function closeWaSocket(sock) {
+	try {
+		if (typeof sock?.end === "function") {
+			sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"));
+			return;
+		}
+		sock?.ws?.close?.();
+	} catch {}
+}
+function closeWaSocketSoon(sock, delayMs = 500) {
+	setTimeout(() => {
+		closeWaSocket(sock);
+	}, delayMs);
+}
+async function waitForWhatsAppLoginResult(params) {
+	const wait = params.waitForConnection ?? waitForWaConnection;
+	const createSocket = params.createSocket ?? createWaSocket;
+	let currentSock = params.sock;
+	let postPairingRestarted = false;
+	let timeoutRestarted = false;
+	let loggedOutRestarted = false;
+	const replaceLoginSocket = async (opts = {}) => {
+		if (opts.closeCurrent ?? true) closeWaSocket(currentSock);
+		try {
+			currentSock = await createSocket(false, params.verbose, {
+				authDir: params.authDir,
+				...params.socketTiming,
+				onQr: params.onQr,
+				beforeCredentialPersistence: params.beforeCredentialPersistence
+			});
+			params.onSocketReplaced?.(currentSock);
+			return null;
+		} catch (createErr) {
+			return {
+				outcome: "failed",
+				message: formatError(createErr),
+				statusCode: getStatusCode(createErr),
+				error: createErr
+			};
+		}
+	};
+	while (true) try {
+		await wait(currentSock, { timeout: "none" });
+		const persistedAuth = await readWebAuthExistsForDecision(params.authDir);
+		if (persistedAuth.outcome === "unstable") return {
+			outcome: "failed",
+			message: WHATSAPP_LOGIN_AUTH_UNSTABLE_MESSAGE,
+			error: new WhatsAppAuthUnstableError(WHATSAPP_LOGIN_AUTH_UNSTABLE_MESSAGE)
+		};
+		if (!persistedAuth.exists) return {
+			outcome: "failed",
+			message: WHATSAPP_LOGIN_AUTH_NOT_PERSISTED_MESSAGE,
+			error: new WhatsAppAuthUnstableError(WHATSAPP_LOGIN_AUTH_NOT_PERSISTED_MESSAGE)
+		};
+		return {
+			outcome: "connected",
+			restarted: postPairingRestarted || timeoutRestarted || loggedOutRestarted,
+			sock: currentSock
+		};
+	} catch (err) {
+		const statusCode = getStatusCode(err);
+		const restartKind = getLoginSocketRestartKind(statusCode);
+		if (restartKind && (restartKind === "post-pairing" && !postPairingRestarted || restartKind === "timeout" && !timeoutRestarted)) {
+			if (restartKind === "post-pairing") postPairingRestarted = true;
+			else timeoutRestarted = true;
+			params.runtime.log(info(getLoginSocketRestartMessage(restartKind)));
+			const replacementFailure = await replaceLoginSocket();
+			if (replacementFailure) return replacementFailure;
+			continue;
+		}
+		if (statusCode === LOGGED_OUT_STATUS) {
+			if (loggedOutRestarted) return {
+				outcome: "logged-out",
+				message: WHATSAPP_LOGGED_OUT_RELINK_MESSAGE,
+				statusCode: LOGGED_OUT_STATUS,
+				error: err
+			};
+			closeWaSocket(currentSock);
+			if (!await logoutWeb({
+				authDir: params.authDir,
+				isLegacyAuthDir: params.isLegacyAuthDir,
+				runtime: params.runtime,
+				beforeCredentialPersistence: params.beforeCredentialPersistence
+			})) {
+				const existingAuth = await readWebAuthExistsForDecision(params.authDir);
+				if (existingAuth.outcome === "unstable") return {
+					outcome: "failed",
+					message: WHATSAPP_LOGIN_AUTH_UNSTABLE_MESSAGE,
+					error: new WhatsAppAuthUnstableError(WHATSAPP_LOGIN_AUTH_UNSTABLE_MESSAGE)
+				};
+				if (existingAuth.exists) return {
+					outcome: "failed",
+					message: WHATSAPP_LOGIN_AUTH_NOT_CLEARED_MESSAGE,
+					error: err
+				};
+			}
+			loggedOutRestarted = true;
+			const replacementFailure = await replaceLoginSocket({ closeCurrent: false });
+			if (replacementFailure) return replacementFailure;
+			continue;
+		}
+		return {
+			outcome: "failed",
+			message: formatError(err),
+			statusCode,
+			error: err
+		};
+	}
+}
+var WhatsAppConnectionController = class {
+	constructor(params) {
+		this.disconnectRetryController = new AbortController();
+		this.current = null;
+		this.reconnectAttempts = 0;
+		this.lastHandledInboundAt = null;
+		this.accountId = params.accountId;
+		this.authDir = params.authDir;
+		this.verbose = params.verbose;
+		this.keepAlive = params.keepAlive;
+		this.heartbeatSeconds = params.heartbeatSeconds;
+		this.transportTimeoutMs = params.transportTimeoutMs;
+		this.messageTimeoutMs = params.messageTimeoutMs;
+		this.appSilenceTimeoutMs = params.messageTimeoutMs * 4;
+		this.watchdogCheckMs = params.watchdogCheckMs;
+		this.reconnectPolicy = params.reconnectPolicy;
+		this.abortSignal = params.abortSignal;
+		this.sleep = params.sleep ?? ((ms, signal) => sleepWithAbort(ms, signal));
+		this.isNonRetryableStatus = params.isNonRetryableStatus ?? (() => false);
+		this.socketTiming = {
+			...DEFAULT_WHATSAPP_SOCKET_TIMING,
+			...params.socketTiming
+		};
+		this.socketRef = { current: null };
+		this.abortPromise = params.abortSignal && new Promise((resolve) => {
+			params.abortSignal?.addEventListener("abort", () => resolve("aborted"), { once: true });
+		});
+		if (params.abortSignal?.aborted) this.stopDisconnectRetries();
+		else params.abortSignal?.addEventListener("abort", () => this.stopDisconnectRetries(), { once: true });
+	}
+	getActiveListener() {
+		return this.current?.listener ?? null;
+	}
+	getCurrentSock() {
+		return this.socketRef.current;
+	}
+	getSelfIdentity() {
+		const user = this.socketRef.current?.user;
+		if (!user) return null;
+		const jid = user.id ?? null;
+		const lid = user.lid ?? null;
+		if (!jid && !lid) return null;
+		const resolved = resolveComparableIdentity({
+			jid,
+			lid
+		}, this.authDir);
+		return {
+			jid: resolved.jid,
+			lid: resolved.lid,
+			e164: resolved.e164
+		};
+	}
+	getReconnectAttempts() {
+		return this.reconnectAttempts;
+	}
+	isStopRequested() {
+		return this.abortSignal?.aborted === true;
+	}
+	shouldRetryDisconnect() {
+		return this.keepAlive && !this.isStopRequested() && !this.disconnectRetryController.signal.aborted;
+	}
+	getDisconnectRetryAbortSignal() {
+		return this.disconnectRetryController.signal;
+	}
+	noteInbound(timestamp = Date.now()) {
+		if (!this.current) return;
+		this.current.handledMessages += 1;
+		this.current.lastInboundAt = timestamp;
+		this.current.lastTransportActivityAt = timestamp;
+		this.current.openedAfterRecentInbound = false;
+		this.lastHandledInboundAt = timestamp;
+	}
+	noteTransportActivity(timestamp = Date.now()) {
+		if (!this.current) return;
+		this.current.lastTransportActivityAt = timestamp;
+	}
+	getCurrentSnapshot(connection = this.current) {
+		if (!connection) return null;
+		return {
+			connectionId: connection.connectionId,
+			startedAt: connection.startedAt,
+			lastInboundAt: connection.lastInboundAt,
+			lastTransportActivityAt: connection.lastTransportActivityAt,
+			handledMessages: connection.handledMessages,
+			reconnectAttempts: this.reconnectAttempts,
+			uptimeMs: Date.now() - connection.startedAt
+		};
+	}
+	setUnhandledRejectionCleanup(unregister) {
+		if (!this.current) {
+			unregister?.();
+			return;
+		}
+		this.current.unregisterUnhandled?.();
+		this.current.unregisterUnhandled = unregister;
+	}
+	async openConnection(params) {
+		if (this.current) await this.closeCurrentConnection();
+		let sock = null;
+		let connection = null;
+		try {
+			sock = await createWaSocket(false, this.verbose, {
+				authDir: this.authDir,
+				...this.socketTiming,
+				...params.getMessage ? { getMessage: params.getMessage } : {},
+				...params.cachedGroupMetadata ? { cachedGroupMetadata: params.cachedGroupMetadata } : {}
+			});
+			await waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs });
+			this.socketRef.current = sock;
+			connection = createLiveConnection({
+				connectionId: params.connectionId,
+				sock,
+				listener: {},
+				openedAfterRecentInbound: this.isOpeningAfterRecentInbound()
+			});
+			const listener = await params.createListener({
+				sock,
+				connection
+			});
+			connection.listener = listener;
+			this.current = connection;
+			connection.unregisterTransportActivity = this.attachTransportActivityListener(sock);
+			registerWhatsAppConnectionController(this.accountId, this);
+			this.startTimers(connection, {
+				onHeartbeat: params.onHeartbeat,
+				onWatchdogTimeout: params.onWatchdogTimeout
+			});
+			return connection;
+		} catch (err) {
+			if (this.socketRef.current === sock) this.socketRef.current = null;
+			closeWaSocket(sock);
+			if (connection?.unregisterUnhandled) connection.unregisterUnhandled();
+			connection?.unregisterTransportActivity?.();
+			throw err;
+		}
+	}
+	async waitForClose() {
+		const connection = this.current;
+		if (!connection) return "aborted";
+		const listenerClose = connection.listener.onClose?.catch((err) => ({
+			status: 500,
+			isLoggedOut: false,
+			error: err
+		})) ?? createNeverResolvePromise();
+		return await Promise.race([
+			connection.closePromise,
+			listenerClose,
+			this.abortPromise ?? createNeverResolvePromise()
+		]);
+	}
+	normalizeCloseReason(reason) {
+		const statusCode = (typeof reason === "object" && reason && "status" in reason ? reason.status : void 0) ?? void 0;
+		return {
+			statusCode,
+			statusLabel: typeof statusCode === "number" ? statusCode : "unknown",
+			isLoggedOut: typeof reason === "object" && reason !== null && "isLoggedOut" in reason && reason.isLoggedOut === true,
+			error: reason?.error,
+			errorText: formatError(reason)
+		};
+	}
+	resolveCloseDecision(reason) {
+		if (reason === "aborted" || this.isStopRequested()) return "aborted";
+		const current = this.current;
+		if (current && Date.now() - current.startedAt > this.heartbeatSeconds * 1e3) this.reconnectAttempts = 0;
+		const normalized = this.normalizeCloseReason(reason);
+		if (normalized.isLoggedOut) return {
+			action: "stop",
+			reconnectAttempts: this.reconnectAttempts,
+			healthState: "logged-out",
+			normalized
+		};
+		if (this.isNonRetryableStatus(normalized.statusCode)) return {
+			action: "stop",
+			reconnectAttempts: this.reconnectAttempts,
+			healthState: "conflict",
+			normalized
+		};
+		const retryDecision = this.consumeReconnectAttempt();
+		if (retryDecision.action === "stop") return {
+			action: "stop",
+			reconnectAttempts: retryDecision.reconnectAttempts,
+			healthState: retryDecision.healthState,
+			normalized
+		};
+		return {
+			action: "retry",
+			delayMs: retryDecision.delayMs,
+			reconnectAttempts: retryDecision.reconnectAttempts,
+			healthState: retryDecision.healthState,
+			normalized
+		};
+	}
+	resolveSetupErrorDecision(error) {
+		const statusCode = getStatusCode(error);
+		if (typeof statusCode !== "number") return null;
+		return this.resolveCloseDecision({
+			status: statusCode,
+			isLoggedOut: statusCode === LOGGED_OUT_STATUS,
+			error
+		});
+	}
+	consumeReconnectAttempt() {
+		this.reconnectAttempts += 1;
+		if (this.reconnectPolicy.maxAttempts > 0 && this.reconnectAttempts >= this.reconnectPolicy.maxAttempts) return {
+			action: "stop",
+			reconnectAttempts: this.reconnectAttempts,
+			healthState: "stopped"
+		};
+		return {
+			action: "retry",
+			delayMs: computeBackoff(this.reconnectPolicy, this.reconnectAttempts),
+			reconnectAttempts: this.reconnectAttempts,
+			healthState: "reconnecting"
+		};
+	}
+	forceClose(reason) {
+		const connection = this.current;
+		if (!connection) return;
+		connection.resolveClose(reason);
+		connection.listener.signalClose?.(reason);
+	}
+	async closeCurrentConnection() {
+		const connection = this.current;
+		if (!connection) return;
+		this.current = null;
+		if (this.socketRef.current === connection.sock) this.socketRef.current = null;
+		connection.unregisterUnhandled?.();
+		connection.unregisterTransportActivity?.();
+		if (connection.heartbeat) clearInterval(connection.heartbeat);
+		if (connection.watchdogTimer) clearInterval(connection.watchdogTimer);
+		if (connection.backgroundTasks.size > 0) {
+			await Promise.allSettled(connection.backgroundTasks);
+			connection.backgroundTasks.clear();
+		}
+		try {
+			await connection.listener.close?.();
+		} catch {}
+		closeWaSocket(connection.sock);
+	}
+	async waitBeforeRetry(delayMs) {
+		await this.sleep(delayMs, this.abortSignal);
+	}
+	async shutdown() {
+		this.stopDisconnectRetries();
+		await this.closeCurrentConnection();
+		unregisterWhatsAppConnectionController(this.accountId, this);
+	}
+	startTimers(connection, hooks) {
+		if (!this.keepAlive) return;
+		connection.heartbeat = setInterval(() => {
+			const snapshot = this.getCurrentSnapshot(connection);
+			if (!snapshot) return;
+			hooks.onHeartbeat?.(snapshot);
+		}, this.heartbeatSeconds * 1e3);
+		connection.watchdogTimer = setInterval(() => {
+			const now = Date.now();
+			const transportStaleForMs = now - connection.lastTransportActivityAt;
+			const appSilentForMs = now - (connection.lastInboundAt ?? connection.startedAt);
+			const appSilenceTimeoutMs = connection.openedAfterRecentInbound ? this.messageTimeoutMs : this.appSilenceTimeoutMs;
+			if (transportStaleForMs <= this.transportTimeoutMs && appSilentForMs <= appSilenceTimeoutMs) return;
+			const snapshot = this.getCurrentSnapshot(connection);
+			if (!snapshot) return;
+			hooks.onWatchdogTimeout?.(snapshot);
+			this.forceClose({
+				status: 499,
+				isLoggedOut: false,
+				error: WHATSAPP_WATCHDOG_TIMEOUT_ERROR
+			});
+		}, this.watchdogCheckMs);
+	}
+	attachTransportActivityListener(sock) {
+		const ws = sock.ws;
+		if (!ws || typeof ws.on !== "function") return null;
+		const noteActivity = () => this.noteTransportActivity();
+		ws.on("frame", noteActivity);
+		return () => {
+			if (typeof ws.off === "function") {
+				ws.off("frame", noteActivity);
+				return;
+			}
+			ws.removeListener?.("frame", noteActivity);
+		};
+	}
+	isOpeningAfterRecentInbound() {
+		if (this.reconnectAttempts <= 0 || this.lastHandledInboundAt === null) return false;
+		return Date.now() - this.lastHandledInboundAt <= this.appSilenceTimeoutMs;
+	}
+	stopDisconnectRetries() {
+		if (!this.disconnectRetryController.signal.aborted) this.disconnectRetryController.abort();
+	}
+};
+//#endregion
+export { closeWaSocketSoon as a, computeBackoff as c, resolveReconnectPolicy as d, sleepWithAbort as f, closeWaSocket as i, newConnectionId as l, WHATSAPP_WATCHDOG_TIMEOUT_ERROR as n, waitForWhatsAppLoginResult as o, WhatsAppConnectionController as r, DEFAULT_RECONNECT_POLICY as s, WHATSAPP_LOGGED_OUT_QR_MESSAGE as t, resolveHeartbeatSeconds as u };

package/dist/.setup/connection-controller-registry-TSX_udJp.mjs

@@ -0,0 +1,22 @@
+//#region extensions/whatsapp/src/connection-controller-registry.ts
+const CONNECTION_REGISTRY_KEY = Symbol.for("openclaw.whatsapp.connectionControllerRegistry");
+function getConnectionRegistryState() {
+	const globalState = globalThis;
+	const existing = globalState[CONNECTION_REGISTRY_KEY];
+	if (existing) return existing;
+	const created = { controllers: /* @__PURE__ */ new Map() };
+	globalState[CONNECTION_REGISTRY_KEY] = created;
+	return created;
+}
+function getRegisteredWhatsAppConnectionController(accountId) {
+	return getConnectionRegistryState().controllers.get(accountId) ?? null;
+}
+function registerWhatsAppConnectionController(accountId, controller) {
+	getConnectionRegistryState().controllers.set(accountId, controller);
+}
+function unregisterWhatsAppConnectionController(accountId, controller) {
+	const controllers = getConnectionRegistryState().controllers;
+	if (controllers.get(accountId) === controller) controllers.delete(accountId);
+}
+//#endregion
+export { registerWhatsAppConnectionController as n, unregisterWhatsAppConnectionController as r, getRegisteredWhatsAppConnectionController as t };

package/dist/.setup/constants-C7m81BNe.mjs

@@ -0,0 +1,4 @@
+//#region extensions/whatsapp/src/auto-reply/constants.ts
+const DEFAULT_WEB_MEDIA_BYTES = 5242880;
+//#endregion
+export { DEFAULT_WEB_MEDIA_BYTES as t };

package/dist/.setup/directory-config-B7Obxrq2.mjs

@@ -0,0 +1,37 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-6PTOSfaI.mjs";
+import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.mjs";
+import "./normalize-eddWWsNV.mjs";
+import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
+//#region extensions/whatsapp/src/directory-config.ts
+var directory_config_exports = /* @__PURE__ */ __exportAll({
+	listWhatsAppDirectoryGroupsFromConfig: () => listWhatsAppDirectoryGroupsFromConfig,
+	listWhatsAppDirectoryPeersFromConfig: () => listWhatsAppDirectoryPeersFromConfig
+});
+function resolveWhatsAppDirectoryAccount(cfg, accountId) {
+	return resolveMergedWhatsAppAccountConfig({
+		cfg,
+		accountId
+	});
+}
+async function listWhatsAppDirectoryPeersFromConfig(params) {
+	return listResolvedDirectoryUserEntriesFromAllowFrom({
+		...params,
+		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAllowFrom: (account) => account.allowFrom,
+		normalizeId: (entry) => {
+			const normalized = normalizeWhatsAppTarget(entry);
+			if (!normalized || isWhatsAppGroupJid(normalized)) return null;
+			return normalized;
+		}
+	});
+}
+async function listWhatsAppDirectoryGroupsFromConfig(params) {
+	return listResolvedDirectoryGroupEntriesFromMapKeys({
+		...params,
+		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveGroups: (account) => account.groups
+	});
+}
+//#endregion
+export { listWhatsAppDirectoryGroupsFromConfig as n, listWhatsAppDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/.setup/doctor-By3SB4lm.mjs

@@ -0,0 +1,48 @@
+//#region extensions/whatsapp/src/doctor.ts
+function normalizeCompatibilityConfig({ cfg }) {
+	const legacyAckReaction = cfg.messages?.ackReaction?.trim();
+	if (!legacyAckReaction || cfg.channels?.whatsapp === void 0) return {
+		config: cfg,
+		changes: []
+	};
+	if (cfg.channels.whatsapp?.ackReaction !== void 0) return {
+		config: cfg,
+		changes: []
+	};
+	const legacyScope = cfg.messages?.ackReactionScope ?? "group-mentions";
+	let direct = true;
+	let group = "mentions";
+	if (legacyScope === "all") {
+		direct = true;
+		group = "always";
+	} else if (legacyScope === "direct") {
+		direct = true;
+		group = "never";
+	} else if (legacyScope === "group-all") {
+		direct = false;
+		group = "always";
+	} else if (legacyScope === "group-mentions") {
+		direct = false;
+		group = "mentions";
+	}
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				whatsapp: {
+					...cfg.channels?.whatsapp,
+					ackReaction: {
+						emoji: legacyAckReaction,
+						direct,
+						group
+					}
+				}
+			}
+		},
+		changes: [`Copied messages.ackReaction → channels.whatsapp.ackReaction (scope: ${legacyScope}).`]
+	};
+}
+const whatsappDoctor = { normalizeCompatibilityConfig };
+//#endregion
+export { whatsappDoctor as n, normalizeCompatibilityConfig as t };