@openclaw/whatsapp 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{connection-controller-COkcq48K.mjs → connection-controller-CejM7bhn.mjs}

@@ -1,7 +1,7 @@
 import { r as getWhatsAppChannelRuntime } from "./runtime-BLlToOi6.mjs";
 import { n as WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY, t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-hgLJoRc8.mjs";
-import { O as resolveComparableIdentity, c as logoutWeb, d as readWebAuthExistsForDecision, j as waitForCredsSaveQueueWithTimeout, r as WhatsAppAuthUnstableError } from "./auth-store-D2rN-hP5.mjs";
-import { d as DEFAULT_WHATSAPP_SOCKET_TIMING, i as waitForWaConnection, o as computeBackoff, r as createWaSocket, t as closeWhatsAppSocketAndWait, u as sleepWithAbort$1, y as acquireWhatsAppGatewayConnectionOwner } from "./socket-close-DU7eerAa.mjs";
+import { O as resolveComparableIdentity, c as logoutWeb, d as readWebAuthExistsForDecision, j as waitForCredsSaveQueueWithTimeout, r as WhatsAppAuthUnstableError } from "./auth-store-DOBi5BPe.mjs";
+import { d as DEFAULT_WHATSAPP_SOCKET_TIMING, i as waitForWaConnection, o as computeBackoff, r as createWaSocket, t as closeWhatsAppSocketAndWait, u as sleepWithAbort$1, y as acquireWhatsAppGatewayConnectionOwner } from "./socket-close-C9OU9mVN.mjs";
 import { n as getStatusCode, t as formatError } from "./session-errors-B8UcAnZN.mjs";
 import { info } from "openclaw/plugin-sdk/runtime-env";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
@@ -22,35 +22,6 @@ 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) {
-	const close = createDeferred();
-	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: close.promise,
-		resolveClose: close.resolve,
-		socketClosed: false
-	};
-}
 async function closeWebSocketBestEffort(sock) {
 	try {
 		await sock.ws?.close?.();
@@ -94,11 +65,8 @@ 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);
+	const restartedStatuses = /* @__PURE__ */ new Set();
+	const replaceLoginSocket = async () => {
 		try {
 			currentSock = await createSocket(false, params.verbose, {
 				authDir: params.authDir,
@@ -140,22 +108,17 @@ async function waitForWhatsAppLoginResult(params) {
 		};
 		return {
 			outcome: "connected",
-			restarted: postPairingRestarted || timeoutRestarted || loggedOutRestarted,
+			restarted: restartedStatuses.size > 0,
 			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 {
+		if ((statusCode === POST_PAIRING_RESTART_STATUS || statusCode === TIMED_OUT_STATUS) && !restartedStatuses.has(statusCode)) {
+			restartedStatuses.add(statusCode);
+			params.runtime.log(info(statusCode === TIMED_OUT_STATUS ? WHATSAPP_LOGIN_TIMEOUT_RESTART_MESSAGE : WHATSAPP_LOGIN_RESTART_MESSAGE));
+			closeWaSocket(currentSock);
+		} else if (statusCode === LOGGED_OUT_STATUS) {
+			if (restartedStatuses.has(LOGGED_OUT_STATUS)) return {
 				outcome: "logged-out",
 				message: WHATSAPP_LOGGED_OUT_RELINK_MESSAGE,
 				statusCode: LOGGED_OUT_STATUS,
@@ -180,21 +143,20 @@ async function waitForWhatsAppLoginResult(params) {
 					error: err
 				};
 			}
-			loggedOutRestarted = true;
-			const replacementFailure = await replaceLoginSocket({ closeCurrent: false });
-			if (replacementFailure) return replacementFailure;
-			continue;
-		}
-		return {
+			restartedStatuses.add(LOGGED_OUT_STATUS);
+		} else return {
 			outcome: "failed",
 			message: formatError(err),
 			statusCode,
 			error: err
 		};
+		const replacementFailure = await replaceLoginSocket();
+		if (replacementFailure) return replacementFailure;
 	}
 }
 var WhatsAppConnectionController = class {
 	constructor(params) {
+		this.params = params;
 		this.disconnectRetryController = new AbortController();
 		this.current = null;
 		this.runtimeContextLease = null;
@@ -209,17 +171,10 @@ var WhatsAppConnectionController = class {
 		this.setupAbortController = new AbortController();
 		this.reconnectAttempts = 0;
 		this.lastHandledInboundAt = null;
+		this.params = { ...params };
 		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 ?? sleepWithAbort$1;
 		this.isNonRetryableStatus = params.isNonRetryableStatus ?? (() => false);
 		this.socketTiming = {
@@ -265,10 +220,10 @@ var WhatsAppConnectionController = class {
 		return this.reconnectAttempts;
 	}
 	isStopRequested() {
-		return this.abortSignal?.aborted === true;
+		return this.params.abortSignal?.aborted === true;
 	}
 	shouldRetryDisconnect() {
-		return this.keepAlive && !this.isStopRequested() && !this.disconnectRetryController.signal.aborted;
+		return this.params.keepAlive && !this.isStopRequested() && !this.disconnectRetryController.signal.aborted;
 	}
 	getDisconnectRetryAbortSignal() {
 		return this.disconnectRetryController.signal;
@@ -326,7 +281,7 @@ var WhatsAppConnectionController = class {
 		let sock = null;
 		let connection = null;
 		try {
-			sock = await createWaSocket(false, this.verbose, {
+			sock = await createWaSocket(false, this.params.verbose, {
 				authDir: this.authDir,
 				...this.socketTiming,
 				...params.getMessage ? { getMessage: params.getMessage } : {},
@@ -336,12 +291,27 @@ var WhatsAppConnectionController = class {
 			await this.waitForSetupStep(waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs }));
 			this.throwIfSetupStopped();
 			this.socketRef.current = sock;
-			connection = createLiveConnection({
+			const placeholderListener = {};
+			const openedAfterRecentInbound = this.reconnectAttempts > 0 && this.lastHandledInboundAt !== null && Date.now() - this.lastHandledInboundAt <= this.appSilenceTimeoutMs;
+			const close = createDeferred();
+			connection = {
 				connectionId: params.connectionId,
+				startedAt: Date.now(),
 				sock,
-				listener: {},
-				openedAfterRecentInbound: this.isOpeningAfterRecentInbound()
-			});
+				listener: placeholderListener,
+				heartbeat: null,
+				watchdogTimer: null,
+				lastInboundAt: null,
+				lastTransportActivityAt: Date.now(),
+				handledMessages: 0,
+				unregisterUnhandled: null,
+				unregisterTransportActivity: null,
+				openedAfterRecentInbound,
+				backgroundTasks: /* @__PURE__ */ new Set(),
+				closePromise: close.promise,
+				resolveClose: close.resolve,
+				socketClosed: false
+			};
 			const listenerTask = params.createListener({
 				sock,
 				connection
@@ -364,7 +334,7 @@ var WhatsAppConnectionController = class {
 				accountId: this.accountId,
 				capability: WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY,
 				context: this,
-				abortSignal: this.abortSignal
+				abortSignal: this.params.abortSignal
 			});
 			previousRuntimeContextLease?.dispose();
 			this.pendingOwnerContextLease?.dispose();
@@ -429,7 +399,7 @@ var WhatsAppConnectionController = class {
 	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;
+		if (current && Date.now() - current.startedAt > this.params.heartbeatSeconds * 1e3) this.reconnectAttempts = 0;
 		const normalized = this.normalizeCloseReason(reason);
 		if (normalized.isLoggedOut) return {
 			action: "stop",
@@ -459,14 +429,14 @@ var WhatsAppConnectionController = class {
 	}
 	consumeReconnectAttempt() {
 		this.reconnectAttempts += 1;
-		if (this.reconnectPolicy.maxAttempts > 0 && this.reconnectAttempts >= this.reconnectPolicy.maxAttempts) return {
+		if (this.params.reconnectPolicy.maxAttempts > 0 && this.reconnectAttempts >= this.params.reconnectPolicy.maxAttempts) return {
 			action: "stop",
 			reconnectAttempts: this.reconnectAttempts,
 			healthState: "stopped"
 		};
 		return {
 			action: "retry",
-			delayMs: computeBackoff(this.reconnectPolicy, this.reconnectAttempts),
+			delayMs: computeBackoff(this.params.reconnectPolicy, this.reconnectAttempts),
 			reconnectAttempts: this.reconnectAttempts,
 			healthState: "reconnecting"
 		};
@@ -498,7 +468,7 @@ var WhatsAppConnectionController = class {
 		if (this.pendingSocketCleanup === connection) this.pendingSocketCleanup = null;
 	}
 	async waitBeforeRetry(delayMs) {
-		await this.sleep(delayMs, this.abortSignal);
+		await this.sleep(delayMs, this.params.abortSignal);
 	}
 	async shutdown() {
 		this.shuttingDown = true;
@@ -565,7 +535,7 @@ var WhatsAppConnectionController = class {
 					accountId: this.accountId,
 					capability: WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY,
 					context: true,
-					abortSignal: this.abortSignal
+					abortSignal: this.params.abortSignal
 				});
 				this.connectionOwnerLease = ownerLease;
 			} catch (error) {
@@ -583,18 +553,18 @@ var WhatsAppConnectionController = class {
 		await this.connectionOwnerLeasePromise;
 	}
 	startTimers(connection, hooks) {
-		if (!this.keepAlive) return;
+		if (!this.params.keepAlive) return;
 		connection.heartbeat = setInterval(() => {
 			const snapshot = this.getCurrentSnapshot(connection);
 			if (!snapshot) return;
 			hooks.onHeartbeat?.(snapshot);
-		}, this.heartbeatSeconds * 1e3);
+		}, this.params.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 appSilenceTimeoutMs = connection.openedAfterRecentInbound ? this.params.messageTimeoutMs : this.appSilenceTimeoutMs;
+			if (transportStaleForMs <= this.params.transportTimeoutMs && appSilentForMs <= appSilenceTimeoutMs) return;
 			const snapshot = this.getCurrentSnapshot(connection);
 			if (!snapshot) return;
 			hooks.onWatchdogTimeout?.(snapshot);
@@ -603,7 +573,7 @@ var WhatsAppConnectionController = class {
 				isLoggedOut: false,
 				error: WHATSAPP_WATCHDOG_TIMEOUT_ERROR
 			});
-		}, this.watchdogCheckMs);
+		}, this.params.watchdogCheckMs);
 	}
 	attachTransportActivityListener(sock) {
 		const ws = sock.ws;
@@ -618,10 +588,6 @@ var WhatsAppConnectionController = class {
 			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();
 	}

package/dist/.setup/{directory-config-RYQomHyB.mjs → directory-config-DPLTUAqy.mjs}

@@ -1,10 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
 import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-F0vHuze2.mjs";
-import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BGra1ZnM.mjs";
+import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-D67Kc3g6.mjs";
 import { i as hasPendingWhatsAppConnectionOwner, r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-hgLJoRc8.mjs";
-import { d as readWebAuthExistsForDecision, j as waitForCredsSaveQueueWithTimeout } from "./auth-store-D2rN-hP5.mjs";
+import { d as readWebAuthExistsForDecision, j as waitForCredsSaveQueueWithTimeout } from "./auth-store-DOBi5BPe.mjs";
 import { n as resolveWebAccountId } from "./active-listener-CDjoX9QR.mjs";
-import { b as acquireWhatsAppStandaloneConnectionOwner, i as waitForWaConnection, n as createWaDirectorySocket, t as closeWhatsAppSocketAndWait, v as WhatsAppConnectionOwnerBusyError } from "./socket-close-DU7eerAa.mjs";
+import { b as acquireWhatsAppStandaloneConnectionOwner, i as waitForWaConnection, n as createWaDirectorySocket, t as closeWhatsAppSocketAndWait, v as WhatsAppConnectionOwnerBusyError } from "./socket-close-C9OU9mVN.mjs";
 import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
 //#region extensions/whatsapp/src/directory-config.ts
 var directory_config_exports = /* @__PURE__ */ __exportAll({
@@ -49,18 +49,22 @@ var WhatsAppDirectoryUnavailableError = class extends Error {
 	}
 };
 async function fetchLiveGroups(sock, params) {
-	const groups = await sock.groupFetchAllParticipating();
-	const query = params.query?.trim().toLowerCase() ?? "";
-	const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : void 0;
-	const entries = Object.entries(groups).map(([jid, metadata]) => ({
-		kind: "group",
-		id: jid,
-		name: metadata?.subject?.trim() || void 0
-	})).filter((entry) => {
-		if (!query) return true;
-		return entry.id.toLowerCase().includes(query) || entry.name?.toLowerCase().includes(query);
-	}).toSorted((left, right) => left.id.localeCompare(right.id));
-	return limit ? entries.slice(0, limit) : entries;
+	try {
+		const groups = await sock.groupFetchAllParticipating();
+		const query = params.query?.trim().toLowerCase() ?? "";
+		const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : void 0;
+		const entries = Object.entries(groups).map(([jid, metadata]) => ({
+			kind: "group",
+			id: jid,
+			name: metadata?.subject?.trim() || void 0
+		})).filter((entry) => {
+			if (!query) return true;
+			return entry.id.toLowerCase().includes(query) || entry.name?.toLowerCase().includes(query);
+		}).toSorted((left, right) => left.id.localeCompare(right.id));
+		return limit ? entries.slice(0, limit) : entries;
+	} catch (error) {
+		throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
+	}
 }
 function unavailable(reason, message, cause) {
 	return new WhatsAppDirectoryUnavailableError(reason, message, cause ? { cause } : void 0);
@@ -106,12 +110,9 @@ async function finishStandaloneCleanupOrThrow(cleanup, operationError) {
 	} catch (cleanupError) {
 		pendingStandaloneCleanups.set(cleanup.authDir, cleanup);
 		scheduleStandaloneCleanupRetry(cleanup);
-		throw cleanupUnavailable(operationError === void 0 ? cleanupError : new AggregateError([operationError, cleanupError], "WhatsApp live group lookup and cleanup failed", { cause: operationError }));
+		throw unavailable("cleanup_failed", "WhatsApp live group lookup could not safely close its standalone connection.", operationError === void 0 ? cleanupError : new AggregateError([operationError, cleanupError], "WhatsApp live group lookup and cleanup failed", { cause: operationError }));
 	}
 }
-function cleanupUnavailable(error) {
-	return unavailable("cleanup_failed", "WhatsApp live group lookup could not safely close its standalone connection.", error);
-}
 async function finishPriorStandaloneCleanup(authDir) {
 	const cleanup = pendingStandaloneCleanups.get(authDir);
 	if (!cleanup) return;
@@ -156,11 +157,7 @@ async function listGroupsThroughStandaloneOwner(params) {
 		} catch (error) {
 			throw unavailable("connection_failed", "WhatsApp live groups are unavailable because the standalone connection failed.", error);
 		}
-		try {
-			groups = await fetchLiveGroups(cleanup.sock, params);
-		} catch (error) {
-			throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
-		}
+		groups = await fetchLiveGroups(cleanup.sock, params);
 	} catch (error) {
 		await finishStandaloneCleanupOrThrow(cleanup, error);
 		throw error;
@@ -177,11 +174,7 @@ async function listWhatsAppDirectoryGroupsLive(params) {
 	if (!controller && !hasPendingWhatsAppConnectionOwner(accountId)) return await listGroupsThroughStandaloneOwner(params);
 	const sock = controller?.getCurrentSock();
 	if (!sock) throw unavailable("active_owner_unavailable", "WhatsApp live groups are unavailable while the gateway connection is offline.");
-	try {
-		return await fetchLiveGroups(sock, params);
-	} catch (error) {
-		throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
-	}
+	return await fetchLiveGroups(sock, params);
 }
 //#endregion
 export { listWhatsAppDirectoryGroupsFromConfig as n, listWhatsAppDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/.setup/{group-session-key-BV8Le9r8.mjs → group-session-key-BbTPosdy.mjs}

@@ -1,6 +1,6 @@
 import { a as resolveWhatsAppAccount } from "./accounts-F0vHuze2.mjs";
-import { c as normalizeWhatsAppTarget } from "./normalize-target-BGra1ZnM.mjs";
-import { r as jidToE164 } from "./targets-runtime-Dls-Xh4F.mjs";
+import { c as normalizeWhatsAppTarget } from "./normalize-target-D67Kc3g6.mjs";
+import { r as jidToE164 } from "./targets-runtime-D5ryyPxh.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";
@@ -45,7 +45,9 @@ function cacheInboundMessageMeta(accountId, remoteJid, messageId, meta) {
 	});
 }
 function lookupInboundMessageMeta(accountId, remoteJid, messageId) {
-	const cacheKey = makeCacheKey(accountId, remoteJid, messageId);
+	return readCachedMessageMeta(makeCacheKey(accountId, remoteJid, messageId));
+}
+function readCachedMessageMeta(cacheKey) {
 	const entry = cache.get(cacheKey);
 	if (!entry) return;
 	if (Date.now() - entry.ts > CACHE_TTL_MS) {
@@ -96,19 +98,14 @@ function lookupInboundMessageMetaForTarget(accountId, targetJid, messageId) {
 	const prefix = `${accountId}:`;
 	const suffix = `:${messageId}`;
 	let matched;
-	for (const [cacheKey, entry] of cache.entries()) {
+	for (const cacheKey of cache.keys()) {
 		if (!cacheKey.startsWith(prefix) || !cacheKey.endsWith(suffix)) continue;
-		if (Date.now() - entry.ts > CACHE_TTL_MS) {
-			cache.delete(cacheKey);
-			continue;
-		}
+		const remoteJid = cacheKey.slice(prefix.length, cacheKey.length - suffix.length);
+		const meta = readCachedMessageMeta(cacheKey);
+		if (!meta) continue;
 		const candidate = {
-			remoteJid: cacheKey.slice(prefix.length, cacheKey.length - suffix.length),
-			participant: entry.participant,
-			participantE164: entry.participantE164,
-			body: entry.body,
-			media: entry.media,
-			fromMe: entry.fromMe
+			remoteJid,
+			...meta
 		};
 		if (!matchesQuotedConversationTarget(targetJid, candidate)) continue;
 		if (matched) return;
@@ -150,15 +147,12 @@ function buildQuotedMessageOptions(params) {
 }
 //#endregion
 //#region extensions/whatsapp/src/group-session-key.ts
-function resolveWhatsAppGroupAccountThreadId(accountId) {
-	return `whatsapp-account-${normalizeAccountId(accountId)}`;
-}
 function resolveWhatsAppGroupSessionKey(params) {
 	const accountId = normalizeAccountId(params.accountId);
 	if (accountId === DEFAULT_ACCOUNT_ID || !params.sessionKey.includes(":group:")) return params.sessionKey;
 	return resolveThreadSessionKeys({
 		baseSessionKey: params.sessionKey,
-		threadId: resolveWhatsAppGroupAccountThreadId(accountId)
+		threadId: `whatsapp-account-${accountId}`
 	}).sessionKey;
 }
 function resolveWhatsAppGroupSessionRoute(route) {

package/dist/.setup/{login-CV_4V021.mjs → login-DUx5JYuW.mjs}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
 import { a as resolveWhatsAppAccount } from "./accounts-F0vHuze2.mjs";
-import { y as restoreCredsFromBackupIfNeeded } from "./auth-store-D2rN-hP5.mjs";
-import { _ as renderQrTerminal, h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-DU7eerAa.mjs";
-import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-COkcq48K.mjs";
+import { y as restoreCredsFromBackupIfNeeded } from "./auth-store-DOBi5BPe.mjs";
+import { _ as renderQrTerminal, h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-C9OU9mVN.mjs";
+import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-CejM7bhn.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";

package/dist/.setup/{login-qr-DFhGc5yH.mjs → login-qr-BAWbPonj.mjs}

@@ -1,9 +1,9 @@
 import { a as resolveWhatsAppAccount } from "./accounts-F0vHuze2.mjs";
-import { c as logoutWeb, d as readWebAuthExistsForDecision, h as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-D2rN-hP5.mjs";
+import { c as logoutWeb, d as readWebAuthExistsForDecision, h as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-DOBi5BPe.mjs";
 import { t as getActiveWebListener } from "./active-listener-CDjoX9QR.mjs";
-import { h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-DU7eerAa.mjs";
+import { h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-C9OU9mVN.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-COkcq48K.mjs";
+import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-CejM7bhn.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";
@@ -33,10 +33,16 @@ function notifyQrUpdate(login) {
 	login.qrUpdate = createDeferred();
 	previous.resolve();
 }
-function updateLoginQrState(login, qr) {
+function updateLoginQrState(accountId, login, qr, notify = false) {
 	login.qr = qr;
 	login.qrVersion += 1;
-	return login.qrVersion;
+	if (notify) notifyQrUpdate(login);
+	ensureQrDataUrl({
+		accountId,
+		loginId: login.id,
+		qr,
+		qrVersion: login.qrVersion
+	}).catch(() => {});
 }
 async function ensureQrDataUrl(params) {
 	const current = activeLogins.get(params.accountId);
@@ -70,9 +76,6 @@ async function ensureQrDataUrl(params) {
 		if (latest?.id === params.loginId && latest.qrRenderPromise === renderPromise) latest.qrRenderPromise = null;
 	}
 }
-function renderLatestQrDataUrlInBackground(params) {
-	ensureQrDataUrl(params).catch(() => {});
-}
 function attachLoginWaiter(accountId, login) {
 	login.waitPromise = waitForWhatsAppLoginResult({
 		sock: login.sock,
@@ -85,14 +88,7 @@ function attachLoginWaiter(accountId, login) {
 		onQr: (qr) => {
 			const current = activeLogins.get(accountId);
 			if (!current || current.id !== login.id) return;
-			const qrVersion = updateLoginQrState(current, qr);
-			notifyQrUpdate(current);
-			renderLatestQrDataUrlInBackground({
-				accountId,
-				loginId: login.id,
-				qr,
-				qrVersion
-			});
+			updateLoginQrState(accountId, current, qr, true);
 		},
 		onSocketReplaced: (sock) => {
 			const current = activeLogins.get(accountId);
@@ -121,13 +117,6 @@ function attachLoginWaiter(accountId, login) {
 	});
 }
 async function waitForQrOrRecoveredLogin(params) {
-	const qrResult = params.qrPromise.then((qr) => ({
-		outcome: "qr",
-		qr
-	}), (err) => ({
-		outcome: "failed",
-		message: `Failed to get QR: ${String(err)}`
-	}));
 	const readLoginResult = (fallbackMessage) => {
 		const current = activeLogins.get(params.accountId);
 		if (current?.id !== params.login.id) return {
@@ -150,7 +139,7 @@ async function waitForQrOrRecoveredLogin(params) {
 	});
 	const qrUpdateResult = params.login.qrUpdate.promise.then(() => readLoginResult("WhatsApp QR update ended without an active QR."));
 	return await Promise.race([
-		qrResult,
+		params.qrResult,
 		loginResult,
 		qrUpdateResult
 	]);
@@ -190,7 +179,10 @@ async function startWebLoginWithQr(opts = {}) {
 	await resetActiveLogin(account.accountId);
 	const qrReady = createDeferred();
 	const qrTimer = setTimeout(() => {
-		qrReady.reject(/* @__PURE__ */ new Error("Timed out waiting for WhatsApp QR"));
+		qrReady.resolve({
+			outcome: "failed",
+			message: "Failed to get QR: Error: Timed out waiting for WhatsApp QR"
+		});
 	}, resolveTimerTimeoutMs(opts.timeoutMs, 3e4, 5e3));
 	let sock;
 	let pendingQr = null;
@@ -212,17 +204,12 @@ async function startWebLoginWithQr(opts = {}) {
 			onQr: (qr) => {
 				pendingQr = qr;
 				const current = activeLogins.get(account.accountId);
-				if (current && current.id === loginId) {
-					const qrVersion = updateLoginQrState(current, qr);
-					renderLatestQrDataUrlInBackground({
-						accountId: account.accountId,
-						loginId,
-						qr,
-						qrVersion
-					});
-				}
+				if (current && current.id === loginId) updateLoginQrState(account.accountId, current, qr);
 				clearTimeout(qrTimer);
-				qrReady.resolve(qr);
+				qrReady.resolve({
+					outcome: "qr",
+					qr
+				});
 				runtime.log(info("WhatsApp QR received."));
 			}
 		});
@@ -256,20 +243,12 @@ async function startWebLoginWithQr(opts = {}) {
 	}
 	operationOwner.current = nextLogin;
 	activeLogins.set(account.accountId, nextLogin);
-	if (pendingQr) {
-		const qrVersion = updateLoginQrState(nextLogin, pendingQr);
-		renderLatestQrDataUrlInBackground({
-			accountId: account.accountId,
-			loginId: nextLogin.id,
-			qr: pendingQr,
-			qrVersion
-		});
-	}
+	if (pendingQr) updateLoginQrState(account.accountId, nextLogin, pendingQr);
 	attachLoginWaiter(account.accountId, nextLogin);
 	const loginStartResult = await waitForQrOrRecoveredLogin({
 		accountId: account.accountId,
 		login: nextLogin,
-		qrPromise: qrReady.promise
+		qrResult: qrReady.promise
 	});
 	clearTimeout(qrTimer);
 	if (loginStartResult.outcome === "connected") {