@openclaw/whatsapp 2026.9.5 → 2026.9.7

package/dist/.setup/{directory-config-BHPoBklt.mjs → directory-config-DUiJ5d8I.mjs}

@@ -1,11 +1,10 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-D_NGDjCx.mjs";
+import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-CtRPAQCL.mjs";
 import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BGra1ZnM.mjs";
 import { i as hasPendingWhatsAppConnectionOwner, r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-hgLJoRc8.mjs";
-import "./normalize-DdsROMMa.mjs";
-import { M as waitForCredsSaveQueueWithTimeout, f as readWebAuthExistsForDecision } from "./auth-store-Dh8a3cba.mjs";
+import { M as waitForCredsSaveQueueWithTimeout, f as readWebAuthExistsForDecision } from "./auth-store-BBonwKks.mjs";
 import { n as resolveWebAccountId } from "./active-listener-CDjoX9QR.mjs";
-import { a as waitForWaConnection, h as acquireWhatsAppStandaloneConnectionOwner, n as createWaDirectorySocket, p as WhatsAppConnectionOwnerBusyError, t as closeWhatsAppSocketAndWait } from "./socket-close-CCVSFufF.mjs";
+import { b as acquireWhatsAppStandaloneConnectionOwner, i as waitForWaConnection, n as createWaDirectorySocket, t as closeWhatsAppSocketAndWait, v as WhatsAppConnectionOwnerBusyError } from "./socket-close-CT__V2fz.mjs";
 import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
 //#region extensions/whatsapp/src/directory-config.ts
 var directory_config_exports = /* @__PURE__ */ __exportAll({
@@ -15,16 +14,13 @@ var directory_config_exports = /* @__PURE__ */ __exportAll({
 	listWhatsAppDirectoryGroupsLive: () => listWhatsAppDirectoryGroupsLive,
 	listWhatsAppDirectoryPeersFromConfig: () => listWhatsAppDirectoryPeersFromConfig
 });
-function resolveWhatsAppDirectoryAccount(cfg, accountId) {
-	return resolveMergedWhatsAppAccountConfig({
-		cfg,
-		accountId
-	});
-}
 async function listWhatsAppDirectoryPeersFromConfig(params) {
 	return listResolvedDirectoryUserEntriesFromAllowFrom({
 		...params,
-		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAccount: (cfg, accountId) => resolveMergedWhatsAppAccountConfig({
+			cfg,
+			accountId
+		}),
 		resolveAllowFrom: (account) => account.allowFrom,
 		normalizeId: (entry) => {
 			const normalized = normalizeWhatsAppTarget(entry);
@@ -36,7 +32,10 @@ async function listWhatsAppDirectoryPeersFromConfig(params) {
 async function listWhatsAppDirectoryGroupsFromConfig(params) {
 	return listResolvedDirectoryGroupEntriesFromMapKeys({
 		...params,
-		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAccount: (cfg, accountId) => resolveMergedWhatsAppAccountConfig({
+			cfg,
+			accountId
+		}),
 		resolveGroups: (account) => account.groups
 	});
 }
@@ -127,7 +126,7 @@ async function finishPriorStandaloneCleanup(authDir) {
 	}
 }
 async function listGroupsThroughStandaloneOwner(params) {
-	const account = resolveWhatsAppDirectoryAccount(params.cfg, params.accountId);
+	const account = resolveMergedWhatsAppAccountConfig(params);
 	const authDir = resolveWhatsAppAuthDir({
 		cfg: params.cfg,
 		accountId: account.accountId

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

@@ -0,0 +1,222 @@
+import { n as __reExport, t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord(asNullableRecord(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord(root?.legacyWebhook);
+			return normalizeChannelConfigEntries({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
+//#region extensions/whatsapp/src/doctor.ts
+function resolveLegacyAckScope(ack) {
+	const direct = ack.direct !== false;
+	const group = ack.group ?? "mentions";
+	if (direct) return group === "always" ? "all" : group === "never" ? "direct" : void 0;
+	return group === "always" ? "group-all" : group === "mentions" ? "group-mentions" : group === "never" ? "off" : void 0;
+}
+function resolveDefaultAgentEmoji(cfg) {
+	const entries = (0, runtime_doctor_migrations_exports.asObjectRecord)((0, runtime_doctor_migrations_exports.asObjectRecord)(cfg.agents)?.entries);
+	const agents = entries ? Object.values(entries).flatMap((value) => {
+		const entry = (0, runtime_doctor_migrations_exports.asObjectRecord)(value);
+		return entry ? [entry] : [];
+	}) : [];
+	const agent = agents.find((entry) => entry.default === true) ?? agents[0];
+	const emoji = (0, runtime_doctor_migrations_exports.asObjectRecord)(agent?.identity)?.emoji;
+	return typeof emoji === "string" ? emoji : void 0;
+}
+function normalizeCompatibilityConfig({ cfg }) {
+	const changes = [];
+	const sources = [];
+	for (const scope of (0, runtime_doctor_migrations_exports.collectChannelAccountScopes)({
+		cfg,
+		channelId: "whatsapp"
+	})) {
+		const ack = (0, runtime_doctor_migrations_exports.asObjectRecord)(scope.account.ackReaction);
+		if (!ack) continue;
+		sources.push({
+			path: `${scope.prefix}.ackReaction`,
+			account: scope.account,
+			...typeof ack.emoji === "string" ? { emoji: ack.emoji } : {},
+			scope: resolveLegacyAckScope(ack),
+			unrepresentableScope: ack.direct !== false && (ack.group ?? "mentions") === "mentions"
+		});
+	}
+	if (sources.length === 0) return {
+		config: cfg,
+		changes
+	};
+	const messages = cfg.messages ??= {};
+	const identityEmoji = resolveDefaultAgentEmoji(cfg) ?? "👀";
+	for (const source of sources) {
+		messages.ackReaction ??= source.emoji ?? identityEmoji;
+		messages.ackReactionScope ??= source.scope;
+		delete source.account.ackReaction;
+		changes.push(`Moved translatable ${source.path} settings to messages ack settings.`);
+	}
+	const finalEmoji = messages.ackReaction.trim();
+	const finalScope = messages.ackReactionScope ?? "group-mentions";
+	const comparableFinalScope = finalScope === "none" ? "off" : finalScope;
+	for (const source of sources) {
+		const sourceEmoji = source.emoji?.trim();
+		if (source.emoji === void 0) changes.push(`${source.path} used a route-dependent agent identity acknowledgement emoji before migration; the final messages.ackReaction is ${JSON.stringify(finalEmoji)}. Review messages.ackReaction.`);
+		else if (sourceEmoji !== finalEmoji) changes.push(`${source.path} requested acknowledgement emoji ${JSON.stringify(sourceEmoji)}, but the final messages.ackReaction is ${JSON.stringify(finalEmoji)}. Review messages.ackReaction.`);
+		if (source.unrepresentableScope) changes.push(`${source.path} migration cannot preserve both direct-message and mentioned-group acknowledgements; the final messages.ackReactionScope is ${JSON.stringify(finalScope)}. Review messages.ackReactionScope.`);
+		else if (source.scope && source.scope !== comparableFinalScope) changes.push(`${source.path} requested acknowledgement scope ${JSON.stringify(source.scope)}, but the final messages.ackReactionScope is ${JSON.stringify(finalScope)}. Review messages.ackReactionScope.`);
+	}
+	return {
+		config: cfg,
+		changes
+	};
+}
+const whatsappDoctor = { normalizeCompatibilityConfig };
+//#endregion
+export { whatsappDoctor as n, runtime_doctor_migrations_exports as r, normalizeCompatibilityConfig as t };

package/dist/.setup/group-config-path-DZr3ucUO.mjs

@@ -0,0 +1,40 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-core";
+//#region extensions/whatsapp/src/group-config-path.ts
+const WHATSAPP_GROUP_SCOPE_FIELDS = [
+	"groupPolicy",
+	"groupAllowFrom",
+	"groups"
+];
+function resolveWhatsAppAccountKey(accounts, accountId) {
+	if (!accounts) return;
+	if (Object.hasOwn(accounts, accountId)) return accountId;
+	const normalizedAccountId = accountId.trim().toLowerCase();
+	return Object.keys(accounts).find((key) => key.trim().toLowerCase() === normalizedAccountId);
+}
+function normalizePathAccountId(accountId) {
+	return typeof accountId === "string" ? accountId.trim() || DEFAULT_ACCOUNT_ID : DEFAULT_ACCOUNT_ID;
+}
+function hasConfiguredField(config, field) {
+	return Boolean(config && typeof config === "object" && Object.hasOwn(config, field) && config[field] !== void 0);
+}
+function resolveWhatsAppGroupScopeBasePath(params, fields = WHATSAPP_GROUP_SCOPE_FIELDS) {
+	const accountId = normalizePathAccountId(params.accountId);
+	const whatsapp = params.cfg.channels?.whatsapp;
+	const accounts = whatsapp?.accounts;
+	const accountKey = resolveWhatsAppAccountKey(accounts, accountId);
+	const defaultAccountKey = resolveWhatsAppAccountKey(accounts, DEFAULT_ACCOUNT_ID);
+	const accountConfig = accountKey ? accounts?.[accountKey] : void 0;
+	const defaultAccountConfig = defaultAccountKey ? accounts?.[defaultAccountKey] : void 0;
+	const hasField = (config) => fields.some((field) => hasConfiguredField(config, field));
+	if (hasField(accountConfig)) return `channels.whatsapp.accounts.${accountKey}`;
+	if (accountId !== DEFAULT_ACCOUNT_ID && hasField(defaultAccountConfig)) return `channels.whatsapp.accounts.${defaultAccountKey}`;
+	if (hasField(whatsapp)) return "channels.whatsapp";
+}
+function resolveWhatsAppConfigPath(params) {
+	return `${resolveWhatsAppGroupScopeBasePath(params) ?? "channels.whatsapp"}.${params.field}`;
+}
+function resolveWhatsAppGroupsConfigPath(params) {
+	return `${resolveWhatsAppGroupScopeBasePath(params, ["groups"]) ?? resolveWhatsAppGroupScopeBasePath(params) ?? "channels.whatsapp"}.groups`;
+}
+//#endregion
+export { resolveWhatsAppGroupsConfigPath as n, resolveWhatsAppConfigPath as t };

package/dist/.setup/{group-session-key-D22hYMdE.mjs → group-session-key-2-mja4OF.mjs}

@@ -1,8 +1,6 @@
-import { a as resolveWhatsAppAccount } from "./accounts-D_NGDjCx.mjs";
+import { a as resolveWhatsAppAccount } from "./accounts-CtRPAQCL.mjs";
 import { c as normalizeWhatsAppTarget } from "./normalize-target-BGra1ZnM.mjs";
-import "./normalize-DdsROMMa.mjs";
-import { r as jidToE164 } from "./targets-runtime-RBjx3pg_.mjs";
-import "./text-runtime-CHl0iPYe.mjs";
+import { r as jidToE164 } from "./targets-runtime-DmiqXIXO.mjs";
 import { formatMediaPlaceholderText } from "openclaw/plugin-sdk/channel-inbound";
 import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from "baileys";
@@ -96,11 +94,7 @@ function lookupInboundMessageMetaForTarget(accountId, targetJid, messageId) {
 	const exact = lookupInboundMessageMeta(accountId, targetJid, messageId);
 	if (exact) return {
 		remoteJid: targetJid,
-		participant: exact.participant,
-		participantE164: exact.participantE164,
-		body: exact.body,
-		media: exact.media,
-		fromMe: exact.fromMe
+		...exact
 	};
 	const prefix = `${accountId}:`;
 	const suffix = `:${messageId}`;

package/dist/.setup/{login-2dmd1TfE.mjs → login-BFlvSh9h.mjs}

@@ -1,11 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as resolveWhatsAppAccount } from "./accounts-D_NGDjCx.mjs";
-import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-Dh8a3cba.mjs";
-import { f as renderQrTerminal, r as createWaSocket, u as resolveWhatsAppSocketTiming } from "./socket-close-CCVSFufF.mjs";
-import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-C60mU7j7.mjs";
+import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { a as resolveWhatsAppAccount } from "./accounts-CtRPAQCL.mjs";
+import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-BBonwKks.mjs";
+import { _ as renderQrTerminal, h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-CT__V2fz.mjs";
+import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-CHo1oRJA.mjs";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { logInfo } from "openclaw/plugin-sdk/logging-core";
 import { danger, defaultRuntime, success } from "openclaw/plugin-sdk/runtime-env";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 //#region extensions/whatsapp/src/login.ts
 var login_exports = /* @__PURE__ */ __exportAll({ loginWeb: () => loginWeb });
@@ -20,14 +21,11 @@ async function loginWeb(verbose, waitForConnection, runtime = defaultRuntime, ac
 	const socketTiming = resolveWhatsAppSocketTiming();
 	const restoredFromBackup = await restoreCredsFromBackupIfNeeded(account.authDir, { beforeCredentialPersistence: options?.beforeCredentialPersistence });
 	const credentialPersistenceState = { failure: null };
-	let resolveCredentialPersistenceFailure = (_failure) => {};
-	const credentialPersistenceFailurePromise = new Promise((resolve) => {
-		resolveCredentialPersistenceFailure = resolve;
-	});
+	const credentialPersistenceFailure = createDeferred();
 	const onCredentialPersistenceError = (error) => {
 		if (credentialPersistenceState.failure) return;
 		credentialPersistenceState.failure = { error };
-		resolveCredentialPersistenceFailure(credentialPersistenceState.failure);
+		credentialPersistenceFailure.resolve(credentialPersistenceState.failure);
 	};
 	const credentialPersistenceTasks = /* @__PURE__ */ new Set();
 	const onCredentialPersistenceTask = (task) => {
@@ -84,7 +82,7 @@ async function loginWeb(verbose, waitForConnection, runtime = defaultRuntime, ac
 			onQr,
 			...credentialPersistenceOptions,
 			...options?.beforeCredentialPersistence ? {
-				credentialPersistenceFailure: credentialPersistenceFailurePromise,
+				credentialPersistenceFailure: credentialPersistenceFailure.promise,
 				getCredentialPersistenceFailure: () => credentialPersistenceState.failure,
 				waitForCredentialPersistence
 			} : {},

package/dist/.setup/{login-qr-CgKtO_ef.mjs → login-qr-Ayb8i25J.mjs}

@@ -1,50 +1,36 @@
-import { a as resolveWhatsAppAccount } from "./accounts-D_NGDjCx.mjs";
-import { c as logoutWeb, f as readWebAuthExistsForDecision, g as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-Dh8a3cba.mjs";
+import { a as resolveWhatsAppAccount } from "./accounts-CtRPAQCL.mjs";
+import { c as logoutWeb, f as readWebAuthExistsForDecision, g as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-BBonwKks.mjs";
 import { t as getActiveWebListener } from "./active-listener-CDjoX9QR.mjs";
-import { r as createWaSocket, u as resolveWhatsAppSocketTiming } from "./socket-close-CCVSFufF.mjs";
-import { t as formatError } from "./session-errors-JuazczrA.mjs";
-import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-C60mU7j7.mjs";
+import { h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-CT__V2fz.mjs";
+import { t as formatError } from "./session-errors-B8UcAnZN.mjs";
+import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-CHo1oRJA.mjs";
 import { logInfo } from "openclaw/plugin-sdk/logging-core";
 import { danger, defaultRuntime, info, success } from "openclaw/plugin-sdk/runtime-env";
 import { renderQrPngDataUrl } from "openclaw/plugin-sdk/media-runtime";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { randomUUID } from "node:crypto";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { setImmediate } from "node:timers/promises";
 //#region extensions/whatsapp/src/login-qr.ts
-function waitForNextTask() {
-	return new Promise((resolve) => {
-		setImmediate(resolve);
-	});
-}
 const ACTIVE_LOGIN_TTL_MS = 18e4;
 const MAX_QR_RENDER_CHASES = 10;
 const activeLogins = /* @__PURE__ */ new Map();
-function resolveWhatsAppLoginTimeoutMs(value, fallbackMs, minMs) {
-	return resolveTimerTimeoutMs(value, fallbackMs, minMs);
-}
-function closeSocket(sock) {
-	closeWaSocket(sock);
-}
 async function resetActiveLogin(accountId, reason) {
 	const login = activeLogins.get(accountId);
 	if (login) {
 		activeLogins.delete(accountId);
-		closeSocket(login.sock);
+		closeWaSocket(login.sock);
 	}
 	if (reason) logInfo(reason);
 }
 function isLoginFresh(login) {
 	return Date.now() - login.startedAt < ACTIVE_LOGIN_TTL_MS;
 }
-function resetQrUpdateSignal(login) {
-	login.qrUpdatePromise = new Promise((resolve) => {
-		login.resolveQrUpdate = resolve;
-	});
-}
 function notifyQrUpdate(login) {
-	const resolve = login.resolveQrUpdate;
-	resetQrUpdateSignal(login);
-	resolve?.();
+	const previous = login.qrUpdate;
+	login.qrUpdate = createDeferred();
+	previous.resolve();
 }
 function updateLoginQrState(login, qr) {
 	login.qr = qr;
@@ -141,28 +127,7 @@ async function waitForQrOrRecoveredLogin(params) {
 		outcome: "failed",
 		message: `Failed to get QR: ${String(err)}`
 	}));
-	const loginResult = params.login.waitPromise.then(async () => {
-		if (activeLogins.get(params.accountId)?.id !== params.login.id) return {
-			outcome: "failed",
-			message: "WhatsApp login was replaced by a newer request."
-		};
-		await waitForNextTask();
-		const latest = activeLogins.get(params.accountId);
-		if (latest?.id !== params.login.id) return {
-			outcome: "failed",
-			message: "WhatsApp login was replaced by a newer request."
-		};
-		if (latest.qr) return {
-			outcome: "qr",
-			qr: latest.qr
-		};
-		if (latest.connected) return { outcome: "connected" };
-		return {
-			outcome: "failed",
-			message: latest.error ? `WhatsApp login failed: ${latest.error}` : "WhatsApp login failed."
-		};
-	});
-	const qrUpdateResult = params.login.qrUpdatePromise.then(() => {
+	const readLoginResult = (fallbackMessage) => {
 		const current = activeLogins.get(params.accountId);
 		if (current?.id !== params.login.id) return {
 			outcome: "failed",
@@ -175,9 +140,14 @@ async function waitForQrOrRecoveredLogin(params) {
 		if (current.connected) return { outcome: "connected" };
 		return {
 			outcome: "failed",
-			message: current.error ? `WhatsApp login failed: ${current.error}` : "WhatsApp QR update ended without an active QR."
+			message: current.error ? `WhatsApp login failed: ${current.error}` : fallbackMessage
 		};
+	};
+	const loginResult = params.login.waitPromise.then(async () => {
+		if (activeLogins.get(params.accountId)?.id === params.login.id) await setImmediate();
+		return readLoginResult("WhatsApp login failed.");
 	});
+	const qrUpdateResult = params.login.qrUpdate.promise.then(() => readLoginResult("WhatsApp QR update ended without an active QR."));
 	return await Promise.race([
 		qrResult,
 		loginResult,
@@ -212,7 +182,7 @@ async function startWebLoginWithQr(opts = {}) {
 		return { message: `WhatsApp login failed: ${formatError(err)}` };
 	}
 	const existing = activeLogins.get(account.accountId);
-	if (existing && isLoginFresh(existing) && existing.qrDataUrl) return {
+	if (!opts.force && existing && isLoginFresh(existing) && !existing.connected && existing.error === void 0 && existing.qrDataUrl) return {
 		qrDataUrl: existing.qrDataUrl,
 		message: "QR already active. Scan it in WhatsApp → Linked Devices."
 	};
@@ -225,7 +195,7 @@ async function startWebLoginWithQr(opts = {}) {
 	});
 	const qrTimer = setTimeout(() => {
 		rejectQr?.(/* @__PURE__ */ new Error("Timed out waiting for WhatsApp QR"));
-	}, resolveWhatsAppLoginTimeoutMs(opts.timeoutMs, 3e4, 5e3));
+	}, resolveTimerTimeoutMs(opts.timeoutMs, 3e4, 5e3));
 	let sock;
 	let pendingQr = null;
 	const loginId = randomUUID();
@@ -270,7 +240,6 @@ async function startWebLoginWithQr(opts = {}) {
 		return { message: `Failed to start WhatsApp login: ${String(err)}` };
 	}
 	const nextLogin = {
-		accountId: account.accountId,
 		authDir: account.authDir,
 		isLegacyAuthDir: account.isLegacyAuthDir,
 		id: loginId,
@@ -279,8 +248,7 @@ async function startWebLoginWithQr(opts = {}) {
 		connected: false,
 		waitPromise: Promise.resolve(),
 		qrVersion: 0,
-		qrUpdatePromise: Promise.resolve(),
-		resolveQrUpdate: null,
+		qrUpdate: createDeferred(),
 		qrRenderPromise: null,
 		verbose: Boolean(opts.verbose),
 		runtime,
@@ -291,11 +259,10 @@ async function startWebLoginWithQr(opts = {}) {
 		await opts.beforeCredentialPersistence?.();
 	} catch (err) {
 		clearTimeout(qrTimer);
-		closeSocket(sock);
+		closeWaSocket(sock);
 		return { message: `Failed to start WhatsApp login: ${String(err)}` };
 	}
 	operationOwner.current = nextLogin;
-	resetQrUpdateSignal(nextLogin);
 	activeLogins.set(account.accountId, nextLogin);
 	if (pendingQr) {
 		const qrVersion = updateLoginQrState(nextLogin, pendingQr);
@@ -370,21 +337,12 @@ async function waitForWebLogin(opts = {}) {
 			message: "The login QR expired. Ask me to generate a new one."
 		};
 	}
-	const timeoutMs = resolveWhatsAppLoginTimeoutMs(opts.timeoutMs, 12e4, 1e3);
+	const timeoutMs = resolveTimerTimeoutMs(opts.timeoutMs, 12e4, 1e3);
 	const deadline = Date.now() + timeoutMs;
 	const currentQrDataUrl = opts.currentQrDataUrl;
 	while (true) {
 		if (login.error) {
-			if (login.errorStatus === 401) {
-				const message = WHATSAPP_LOGGED_OUT_QR_MESSAGE;
-				await resetActiveLogin(account.accountId, message);
-				runtime.log(danger(message));
-				return {
-					connected: false,
-					message
-				};
-			}
-			const message = `WhatsApp login failed: ${login.error}`;
+			const message = login.errorStatus === 401 ? WHATSAPP_LOGGED_OUT_QR_MESSAGE : `WhatsApp login failed: ${login.error}`;
 			await resetActiveLogin(account.accountId, message);
 			runtime.log(danger(message));
 			return {
@@ -411,26 +369,20 @@ async function waitForWebLogin(opts = {}) {
 			connected: false,
 			message: "Still waiting for the QR scan. Let me know when you’ve scanned it."
 		};
+		let timer;
 		const timeout = new Promise((resolve) => {
-			setTimeout(() => resolve("timeout"), remaining);
+			timer = setTimeout(() => resolve("timeout"), remaining);
 		});
 		const result = await Promise.race([
 			login.waitPromise.then(() => "done"),
-			login.qrUpdatePromise.then(() => "qr-update"),
+			login.qrUpdate.promise.then(() => "qr-update"),
 			timeout
-		]);
+		]).finally(() => clearTimeout(timer));
 		if (result === "timeout") return {
 			connected: false,
 			message: "Still waiting for the QR scan. Let me know when you’ve scanned it."
 		};
-		if (result === "qr-update") continue;
-		if (result === "done") {
-			if (login.connected || login.error) continue;
-			return {
-				connected: false,
-				message: "Login ended without a connection."
-			};
-		}
+		if (result === "qr-update" || login.connected || login.error) continue;
 		return {
 			connected: false,
 			message: "Login ended without a connection."