@openclaw/whatsapp 2026.7.2-beta.2 → 2026.7.2-beta.3

package/dist/question-reactions-C0qJ6wGA.js

@@ -0,0 +1,142 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+//#region extensions/whatsapp/src/question-reactions.ts
+var question_reactions_exports = /* @__PURE__ */ __exportAll({
+	clearWhatsAppQuestionReactionTargetsForTest: () => clearWhatsAppQuestionReactionTargetsForTest,
+	maybeResolveWhatsAppQuestionReaction: () => maybeResolveWhatsAppQuestionReaction,
+	registerWhatsAppQuestionReactionTargetForDeliveredPayload: () => registerWhatsAppQuestionReactionTargetForDeliveredPayload
+});
+const TARGET_TTL_MS = 1440 * 60 * 1e3;
+const targets = /* @__PURE__ */ new Map();
+function storeTarget(key, binding) {
+	const existing = targets.get(key);
+	if (existing) clearTimeout(existing.cleanupTimer);
+	const target = {
+		...binding,
+		terminal: false,
+		expiresAtMs: Date.now() + TARGET_TTL_MS,
+		cleanupTimer: setTimeout(() => {
+			if (targets.get(key) === target) targets.delete(key);
+		}, TARGET_TTL_MS)
+	};
+	target.cleanupTimer.unref?.();
+	targets.set(key, target);
+	questionGatewayRuntime.registerChannelDelivery({
+		questionId: binding.questionId,
+		deliveryId: `whatsapp-reaction:${key}`,
+		finalize: () => {
+			target.terminal = true;
+		}
+	});
+}
+function buildKey(accountId, remoteJid, messageId) {
+	const parts = [
+		accountId,
+		remoteJid,
+		messageId
+	].map((part) => part.trim());
+	return parts.every(Boolean) ? parts.join(":") : void 0;
+}
+function addCandidate(values, value) {
+	const normalized = value?.trim();
+	if (normalized && !values.includes(normalized)) values.push(normalized);
+}
+function listDeliveredIdentities(results) {
+	const identities = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (messageId, remoteJid) => {
+		const id = messageId?.trim() ?? "";
+		const jid = remoteJid?.trim() ?? "";
+		const key = `${jid}:${id}`;
+		if (id && id !== "unknown" && jid && !seen.has(key)) {
+			seen.add(key);
+			identities.push({
+				messageId: id,
+				remoteJid: jid
+			});
+		}
+	};
+	for (const result of results) {
+		if (result.channel !== "whatsapp") continue;
+		add(result.messageId, result.toJid);
+		for (const raw of result.receipt?.raw ?? []) add(raw.messageId, raw.toJid);
+		for (const part of result.receipt?.parts ?? []) add(part.raw?.messageId ?? part.platformMessageId, part.raw?.toJid);
+	}
+	return identities;
+}
+function registerWhatsAppQuestionReactionTargetForDeliveredPayload(params) {
+	const binding = questionGatewayRuntime.readReactionBinding(params.payload);
+	if (params.target.channel !== "whatsapp" || !binding) return false;
+	const accountId = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.target.accountId
+	}).accountId;
+	let registered = false;
+	for (const identity of listDeliveredIdentities(params.results)) {
+		const key = buildKey(accountId, identity.remoteJid, identity.messageId);
+		if (!key) continue;
+		storeTarget(key, binding);
+		registered = true;
+	}
+	return registered;
+}
+async function maybeResolveWhatsAppQuestionReaction(params) {
+	const reaction = params.msg.message?.reactionMessage;
+	const reactionKey = reaction?.text?.trim() ?? "";
+	const messageId = reaction?.key?.id?.trim() ?? "";
+	const optionIndex = questionGatewayRuntime.resolveReactionIndex(reactionKey);
+	if (optionIndex === void 0 || !messageId) return false;
+	const remoteJids = [];
+	addCandidate(remoteJids, reaction?.key?.remoteJid);
+	addCandidate(remoteJids, params.msg.key?.remoteJid);
+	const candidates = [];
+	for (const remoteJid of remoteJids) {
+		addCandidate(candidates, remoteJid);
+		for (const mapped of await params.resolveReactionTargetJids?.(remoteJid) ?? []) addCandidate(candidates, mapped);
+	}
+	let matched;
+	for (const remoteJid of candidates) {
+		const key = buildKey(params.accountId, remoteJid, messageId);
+		const target = key ? targets.get(key) : void 0;
+		if (key && target) {
+			matched = {
+				key,
+				target
+			};
+			break;
+		}
+	}
+	if (!matched) return false;
+	if (matched.target.expiresAtMs <= Date.now() || matched.target.terminal) {
+		matched.target.terminal = true;
+		params.logDebug?.(`whatsapp: stale question reaction ignored id=${matched.target.questionId}`);
+		return true;
+	}
+	const optionValue = matched.target.optionValues[optionIndex];
+	if (!optionValue) {
+		params.logDebug?.(`whatsapp: out-of-range question reaction ignored id=${matched.target.questionId}`);
+		return true;
+	}
+	try {
+		const result = await questionGatewayRuntime.resolveReaction({
+			cfg: params.cfg,
+			questionId: matched.target.questionId,
+			optionValue,
+			senderId: params.senderId,
+			gatewayUrl: params.gatewayUrl,
+			clientDisplayName: `WhatsApp question (${params.senderId})`
+		});
+		matched.target.terminal = result?.status === "answered" || result?.status === "already-terminal";
+		if (result?.status === "already-terminal") params.logDebug?.(`whatsapp: stale question reaction ignored id=${matched.target.questionId}`);
+	} catch (error) {
+		params.logDebug?.(`whatsapp: question reaction failed id=${matched.target.questionId}: ${String(error)}`);
+	}
+	return true;
+}
+function clearWhatsAppQuestionReactionTargetsForTest() {
+	for (const target of targets.values()) clearTimeout(target.cleanupTimer);
+	targets.clear();
+}
+//#endregion
+export { question_reactions_exports as n, maybeResolveWhatsAppQuestionReaction as t };

package/dist/runtime-api.js

@@ -1,16 +1,16 @@
 import { o as resolveWebCredsBackupPath, r as hasWebCredsSync, s as resolveWebCredsPath } from "./creds-files-B1kSWtBg.js";
-import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-Bf-12TIH.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-D9Ydnn4o.js";
+import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-p0V390gA.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-SB-4JrVZ.js";
 import { r as setWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
 import { t as createWhatsAppLoginTool } from "./agent-tools-login-DfyToBpG.js";
 import { C as waitForCredsSaveQueue, T as writeCredsJsonAtomically, _ as readWebSelfIdentity, a as formatWhatsAppWebAuthStatusState, b as restoreCredsFromBackupIfNeeded, c as logoutWeb, d as readWebAuthExistsBestEffort, f as readWebAuthExistsForDecision, g as readWebSelfId, h as readWebAuthState, l as pickWebChannel, m as readWebAuthSnapshotBestEffort, n as WHATSAPP_AUTH_UNSTABLE_CODE, o as getWebAuthAgeMs, p as readWebAuthSnapshot, r as WhatsAppAuthUnstableError, s as logWebSelfId, t as WA_WEB_AUTH_DIR, u as readCredsJsonRaw, v as readWebSelfIdentityForDecision, w as waitForCredsSaveQueueWithTimeout, x as webAuthExists, y as resolveDefaultWebAuthDir } from "./auth-store-BQi9pZqQ.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
-import { _ as extractLocationData, b as extractText, m as extractContactContext, v as extractMediaPlaceholder } from "./send-api-W33lI2nR.js";
-import { n as newConnectionId, r as waitForWaConnection, t as createWaSocket } from "./session-mxWFn0eS.js";
+import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-BbdlXooT.js";
+import { a as waitForWaConnection, i as newConnectionId, r as createWaSocket } from "./socket-close-jNGyZY4T.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
-import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-5kHap439.js";
-import { a as loadWebMediaRaw, c as monitorWebInbox, i as loadWebMedia, l as resetWebInboundDedupe, n as LocalMediaAccessError, o as optimizeImageToJpeg, r as getDefaultLocalRoots, s as optimizeImageToPng, t as monitorWebChannel } from "./monitor-BZ8QvCeV.js";
-import { t as loginWeb } from "./login-DGIoToX8.js";
+import { _ as extractLocationData, b as extractText, m as extractContactContext, v as extractMediaPlaceholder } from "./send-api-BG0MgoFI.js";
+import { a as loadWebMediaRaw, c as monitorWebInbox, i as loadWebMedia, l as resetWebInboundDedupe, n as LocalMediaAccessError, o as optimizeImageToJpeg, r as getDefaultLocalRoots, s as optimizeImageToPng, t as monitorWebChannel } from "./monitor-_jqDKBXj.js";
+import { t as loginWeb } from "./login-ifOXCBjo.js";
 import { HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN, stripHeartbeatToken } from "openclaw/plugin-sdk/reply-runtime";
 export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, LocalMediaAccessError, SILENT_REPLY_TOKEN, WA_WEB_AUTH_DIR, WHATSAPP_AUTH_UNSTABLE_CODE, WhatsAppAuthUnstableError, createWaSocket, createWhatsAppLoginTool, extractContactContext, extractLocationData, extractMediaPlaceholder, extractText, formatError, formatWhatsAppWebAuthStatusState, getActiveWebListener, getDefaultLocalRoots, getStatusCode, getWebAuthAgeMs, handleWhatsAppAction, hasWebCredsSync, loadWebMedia, loadWebMediaRaw, logWebSelfId, loginWeb, logoutWeb, monitorWebChannel, monitorWebInbox, newConnectionId, optimizeImageToJpeg, optimizeImageToPng, pickWebChannel, readCredsJsonRaw, readWebAuthExistsBestEffort, readWebAuthExistsForDecision, readWebAuthSnapshot, readWebAuthSnapshotBestEffort, readWebAuthState, readWebSelfId, readWebSelfIdentity, readWebSelfIdentityForDecision, resetWebInboundDedupe, resolveDefaultWebAuthDir, resolveWebAccountId, resolveWebCredsBackupPath, resolveWebCredsPath, restoreCredsFromBackupIfNeeded, sendMessageWhatsApp, sendPollWhatsApp, sendReactionWhatsApp, sendTypingWhatsApp, setWhatsAppRuntime, startWebLoginWithQr, stripHeartbeatToken, waitForCredsSaveQueue, waitForCredsSaveQueueWithTimeout, waitForWaConnection, waitForWebLogin, webAuthExists, whatsAppActionRuntime, writeCredsJsonAtomically };

package/dist/{send-D9Ydnn4o.js → send-SB-4JrVZ.js}

@@ -1,8 +1,7 @@
-import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-LiT9wWH9.js";
+import { a as resolveWhatsAppAccount, c as resolveMergedWhatsAppAccountConfig, s as resolveWhatsAppMediaMaxBytes } from "./accounts-ejK8sXPU.js";
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CKOFMPf-.js";
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-DSZnHkKF.js";
-import { n as getWhatsAppConnectionController } from "./connection-controller-runtime-context-CbTsqmPT.js";
+import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-9mEeAvu1.js";
 import "./normalize-C-Z16y7Q.js";
 import { i as markdownToWhatsApp, s as toWhatsappJid } from "./targets-runtime-Bsh0HR9y.js";
 import { a as sanitizeAssistantVisibleTextWithProfile, i as sanitizeAssistantVisibleText, o as stripToolCallXmlTags } from "./text-runtime-BTGkMN0o.js";

package/dist/{send-api-W33lI2nR.js → send-api-BG0MgoFI.js}

@@ -1,16 +1,16 @@
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-DSZnHkKF.js";
-import { l as resolveWhatsAppDocumentFileName } from "./send-D9Ydnn4o.js";
+import { l as resolveWhatsAppDocumentFileName } from "./send-SB-4JrVZ.js";
 import "./normalize-C-Z16y7Q.js";
 import { c as toWhatsappJidWithLid, r as jidToE164, s as toWhatsappJid } from "./targets-runtime-Bsh0HR9y.js";
 import "./text-runtime-BTGkMN0o.js";
-import { i as buildQuotedMessageOptions } from "./group-session-key-CLTZeH_F.js";
+import { i as buildQuotedMessageOptions } from "./group-session-key-Dh8WZun_.js";
 import { c as resolveComparableIdentity } from "./identity-D7L8LCuH.js";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds } from "openclaw/plugin-sdk/channel-outbound";
 import { getImageMetadata, resizeToJpeg } from "openclaw/plugin-sdk/media-runtime";
-import { formatLocationText } from "openclaw/plugin-sdk/channel-inbound";
 import { DisconnectReason, downloadMediaMessage, extractMessageContent, getContentType, isJidGroup, normalizeMessageContent, normalizeMessageContent as normalizeMessageContent$1 } from "baileys";
+import { formatLocationText } from "openclaw/plugin-sdk/channel-inbound";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
 //#region extensions/whatsapp/src/vcard.ts
 const ALLOWED_VCARD_KEYS = /* @__PURE__ */ new Set([

package/dist/{setup-core-3aSOoK2T.js → setup-core-BbIgEl2M.js}

@@ -1,5 +1,5 @@
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-ejK8sXPU.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CKOFMPf-.js";
 import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-DSZnHkKF.js";
 import { t as WhatsAppChannelConfigSchema } from "./config-schema-BZ8h1hWA.js";
 import { n as whatsappDoctor } from "./doctor-By3SB4lm.js";
@@ -84,10 +84,10 @@ async function applyWhatsAppSecurityConfigFixes(params) {
 //#region extensions/whatsapp/src/shared.ts
 const WHATSAPP_CHANNEL = "whatsapp";
 async function loadWhatsAppChannelRuntime() {
-	return await import("./channel.runtime-BDDy4Lhz.js");
+	return await import("./channel.runtime-CjkhQzk8.js");
 }
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-CiKGdNJv.js");
+	return await import("./setup-surface-DhnXEZir.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({

package/dist/{setup-finalize-DBf1jjBj.js → setup-finalize-Cc-4iWGj.js}

@@ -1,8 +1,8 @@
+import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-ejK8sXPU.js";
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
 import { r as hasWebCredsSync } from "./creds-files-B1kSWtBg.js";
-import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-CKOFMPf-.js";
 import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-DSZnHkKF.js";
-import { t as whatsappSetupAdapter } from "./setup-core-3aSOoK2T.js";
+import { t as whatsappSetupAdapter } from "./setup-core-BbIgEl2M.js";
 import { DEFAULT_ACCOUNT_ID, createSetupTranslator, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 //#region extensions/whatsapp/src/setup-finalize.ts
@@ -295,7 +295,7 @@ async function finalizeWhatsAppSetup(params) {
 		};
 		let loginWeb;
 		try {
-			({loginWeb} = await import("./login-DGIoToX8.js").then((n) => n.n));
+			({loginWeb} = await import("./login-ifOXCBjo.js").then((n) => n.n));
 		} catch (error) {
 			await reportLoginFailure(error);
 		}

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as whatsappSetupPlugin } from "./channel.setup-BZ-po8fg.js";
+import { t as whatsappSetupPlugin } from "./channel.setup-BMWE9LmN.js";
 export { whatsappSetupPlugin };

package/dist/{setup-surface-CiKGdNJv.js → setup-surface-DhnXEZir.js}

@@ -1,5 +1,5 @@
+import { o as resolveWhatsAppAuthDir } from "./accounts-ejK8sXPU.js";
 import { t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { o as resolveWhatsAppAuthDir } from "./accounts-CKOFMPf-.js";
 import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-BQi9pZqQ.js";
 import { DEFAULT_ACCOUNT_ID, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
 //#region extensions/whatsapp/src/setup-surface.ts
@@ -36,7 +36,7 @@ const whatsappSetupWizard = {
 	},
 	resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
 	credentials: [],
-	finalize: async (params) => await (await import("./setup-finalize-DBf1jjBj.js")).finalizeWhatsAppSetup(params),
+	finalize: async (params) => await (await import("./setup-finalize-Cc-4iWGj.js")).finalizeWhatsAppSetup(params),
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
 	onAccountRecorded: (accountId, options) => {
 		options?.onAccountId?.(channel, accountId);

package/dist/{session-mxWFn0eS.js → socket-close-jNGyZY4T.js}

@@ -6,9 +6,161 @@ import { VERSION, formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { danger, getChildLogger, success, toPinoLikeLogger } from "openclaw/plugin-sdk/runtime-env";
 import { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";
 import { ensureDir, resolveUserPath } from "openclaw/plugin-sdk/text-utility-runtime";
+import fs from "node:fs/promises";
 import { parseStrictPositiveInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { FILE_LOCK_STALE_ERROR_CODE, FILE_LOCK_TIMEOUT_ERROR_CODE, acquireFileLock } from "openclaw/plugin-sdk/file-lock";
 import { randomUUID } from "node:crypto";
 import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
+//#region extensions/whatsapp/src/connection-owner.ts
+const WHATSAPP_CONNECTION_OWNER_BUSY_CODE = "whatsapp_connection_owner_busy";
+var WhatsAppConnectionOwnerBusyError = class extends Error {
+	constructor(authDir, options) {
+		super("Another process owns this WhatsApp connection.", options);
+		this.authDir = authDir;
+		this.code = WHATSAPP_CONNECTION_OWNER_BUSY_CODE;
+		this.name = "WhatsAppConnectionOwnerBusyError";
+	}
+};
+const OWNER_LOCK_STALE_MS = 5 * 6e4;
+const GATEWAY_LOCAL_OWNER_WAIT_MS = 15e4;
+const processOwners = /* @__PURE__ */ new Map();
+function ownershipCancelledError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error ? reason : new Error("WhatsApp connection ownership cancelled", reason === void 0 ? {} : { cause: reason });
+}
+async function waitForAbortableDelay(delayMs, signal) {
+	if (signal?.aborted) throw ownershipCancelledError(signal);
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(ownershipCancelledError(signal));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delayMs);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function reserveProcessOwner(params) {
+	while (true) {
+		if (params.signal?.aborted) throw ownershipCancelledError(params.signal);
+		const current = processOwners.get(params.ownerPath);
+		if (!current) {
+			let resolveReleased = () => {};
+			const owner = {
+				released: new Promise((resolve) => {
+					resolveReleased = resolve;
+				}),
+				resolveReleased,
+				token: Symbol(params.ownerPath)
+			};
+			processOwners.set(params.ownerPath, owner);
+			return owner;
+		}
+		if (!params.waitForLocalOwner) throw new WhatsAppConnectionOwnerBusyError(params.authDir);
+		let timer;
+		let onAbort;
+		const outcome = await Promise.race([
+			current.released.then(() => "released"),
+			new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timed_out"), GATEWAY_LOCAL_OWNER_WAIT_MS);
+				timer.unref?.();
+			}),
+			new Promise((resolve) => {
+				onAbort = () => resolve("aborted");
+				params.signal?.addEventListener("abort", onAbort, { once: true });
+			})
+		]).finally(() => {
+			if (timer) clearTimeout(timer);
+			if (onAbort) params.signal?.removeEventListener("abort", onAbort);
+		});
+		if (outcome === "aborted") throw ownershipCancelledError(params.signal);
+		if (outcome === "timed_out") throw new WhatsAppConnectionOwnerBusyError(params.authDir);
+	}
+}
+function abandonProcessOwner(ownerPath, owner) {
+	if (processOwners.get(ownerPath)?.token !== owner.token) return;
+	processOwners.delete(ownerPath);
+	owner.resolveReleased();
+}
+async function acquireOwnerLease(params) {
+	const resolvedOwnerPath = resolveUserPath(params.authDir);
+	await fs.mkdir(resolvedOwnerPath, { recursive: true });
+	const ownerPath = await fs.realpath(resolvedOwnerPath);
+	const processOwner = await reserveProcessOwner({
+		authDir: params.authDir,
+		ownerPath,
+		signal: params.signal,
+		waitForLocalOwner: params.waitForLocalOwner
+	});
+	let fileLock;
+	let attempt = 0;
+	while (true) {
+		if (params.signal?.aborted) {
+			abandonProcessOwner(ownerPath, processOwner);
+			throw ownershipCancelledError(params.signal);
+		}
+		try {
+			fileLock = await acquireFileLock(ownerPath, {
+				retries: {
+					retries: 0,
+					factor: 1,
+					minTimeout: 1,
+					maxTimeout: 1
+				},
+				stale: OWNER_LOCK_STALE_MS,
+				staleRecovery: "remove-if-unchanged"
+			});
+			break;
+		} catch (error) {
+			const code = error.code;
+			if (code === FILE_LOCK_STALE_ERROR_CODE) {
+				abandonProcessOwner(ownerPath, processOwner);
+				throw new WhatsAppConnectionOwnerBusyError(params.authDir, { cause: error });
+			}
+			if (code !== FILE_LOCK_TIMEOUT_ERROR_CODE || attempt >= params.retries) {
+				abandonProcessOwner(ownerPath, processOwner);
+				if (code === FILE_LOCK_TIMEOUT_ERROR_CODE) throw new WhatsAppConnectionOwnerBusyError(params.authDir, { cause: error });
+				throw error;
+			}
+			const delayMs = Math.min(100 * 1.5 ** attempt, 1e3);
+			attempt += 1;
+			await waitForAbortableDelay(delayMs, params.signal).catch((delayError) => {
+				abandonProcessOwner(ownerPath, processOwner);
+				throw delayError;
+			});
+		}
+	}
+	let releasePromise = null;
+	return { release: async () => {
+		if (!releasePromise) releasePromise = fileLock.release().then(() => {
+			abandonProcessOwner(ownerPath, processOwner);
+		}).catch((releaseError) => {
+			releasePromise = null;
+			throw releaseError;
+		});
+		await releasePromise;
+	} };
+}
+/** Gateway owner waits for a bounded standalone lookup to finish before startup. */
+async function acquireWhatsAppGatewayConnectionOwner(authDir, signal) {
+	return await acquireOwnerLease({
+		authDir,
+		retries: 150,
+		signal,
+		waitForLocalOwner: true
+	});
+}
+/** Standalone lookup fails quickly when a gateway already owns the account. */
+async function acquireWhatsAppStandaloneConnectionOwner(authDir) {
+	return await acquireOwnerLease({
+		authDir,
+		retries: 3,
+		waitForLocalOwner: false
+	});
+}
+//#endregion
 //#region extensions/whatsapp/src/socket-timing.ts
 const socketSendMessageQueueTails = /* @__PURE__ */ new WeakMap();
 const DEFAULT_WHATSAPP_SOCKET_TIMING = {
@@ -170,6 +322,9 @@ function resolveEnvWaWebSocketUrl() {
 * Consumers can opt into QR printing for interactive login flows.
 */
 async function createWaSocket(printQr, verbose, opts = {}) {
+	return await createWaSocketInternal(printQr, verbose, opts, "normal");
+}
+async function createWaSocketInternal(printQr, verbose, opts, receiveMode) {
 	const logger = toPinoLikeLogger(getChildLogger({ module: "baileys" }, { level: verbose ? "info" : "silent" }), verbose ? "info" : "silent");
 	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
 	await rejectUnsafeWebCredsPath(authDir);
@@ -261,6 +416,7 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 			VERSION
 		],
 		syncFullHistory: false,
+		fireInitQueries: receiveMode !== "directory",
 		markOnlineOnConnect: false,
 		...socketTiming,
 		agent,
@@ -270,6 +426,19 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 		...opts.getMessage ? { getMessage: opts.getMessage } : {},
 		...opts.cachedGroupMetadata ? { cachedGroupMetadata: opts.cachedGroupMetadata } : {}
 	});
+	if (receiveMode === "directory") for (const event of [
+		"CB:message",
+		"CB:call",
+		"CB:receipt",
+		"CB:notification",
+		"CB:ack,class:message",
+		"CB:presence",
+		"CB:chatstate",
+		"CB:ib,,dirty",
+		"CB:ib,,offline_preview",
+		"CB:ib,,offline",
+		"CB:ib,,edge_routing"
+	]) sock.ws.removeAllListeners(event);
 	socketRef.current = sock;
 	if (pendingSocketAbort) abortSocketAfterCredentialPersistenceFailure(sock, pendingSocketAbort.error);
 	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger, {
@@ -303,6 +472,9 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 	});
 	return sock;
 }
+async function createWaDirectorySocket(authDir) {
+	return await createWaSocketInternal(false, false, { authDir }, "directory");
+}
 async function resolveEnvProxyAgent(logger) {
 	try {
 		const agent = createNodeProxyAgent({
@@ -400,4 +572,52 @@ function createConnectionTimeoutError(timeoutMs) {
 	return error;
 }
 //#endregion
-export { createWhatsAppSocketOperationTimeoutAdapter as a, resolveWhatsAppSocketTiming as c, DEFAULT_WHATSAPP_SOCKET_TIMING as i, withWhatsAppSocketOperationTimeout as l, newConnectionId as n, isWhatsAppSocketOperationTimeoutError as o, waitForWaConnection as r, resolveWhatsAppSocketOperationTimeoutMs as s, createWaSocket as t, renderQrTerminal as u };
+//#region extensions/whatsapp/src/socket-close.ts
+const SOCKET_CLOSE_TIMEOUT_MS = 15e3;
+async function withCloseTimeout(task, operationName) {
+	let timer;
+	await Promise.race([task, new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`WhatsApp ${operationName} timed out`)), SOCKET_CLOSE_TIMEOUT_MS);
+	})]).finally(() => {
+		if (timer) clearTimeout(timer);
+	});
+}
+async function waitForTransportClose(ws, operation, operationName) {
+	let onClose;
+	const closed = ws.isClosed ? Promise.resolve() : new Promise((resolve) => {
+		onClose = resolve;
+		ws.once("close", onClose);
+		if (ws.isClosed) onClose();
+	});
+	try {
+		await withCloseTimeout(Promise.all([Promise.resolve(operation), closed]), operationName);
+	} finally {
+		if (onClose) ws.removeListener("close", onClose);
+	}
+}
+/** Close Baileys and verify the transport state before connection ownership moves. */
+async function closeWhatsAppSocketAndWait(sock, reason) {
+	const errors = [];
+	try {
+		const endResult = sock.end(new Error(reason));
+		if (sock.ws.isClosed) {
+			await waitForTransportClose(sock.ws, endResult, "socket end");
+			return;
+		}
+		if (sock.ws.isClosing) await waitForTransportClose(sock.ws, endResult, "socket end");
+		else await withCloseTimeout(Promise.resolve(endResult), "socket end");
+	} catch (error) {
+		errors.push(error);
+	}
+	if (sock.ws.isClosed) return;
+	try {
+		const closeResult = sock.ws.close();
+		await waitForTransportClose(sock.ws, closeResult, "WebSocket close");
+	} catch (error) {
+		errors.push(error);
+	}
+	if (sock.ws.isClosed) return;
+	throw new AggregateError(errors, "WhatsApp socket close could not be confirmed");
+}
+//#endregion
+export { waitForWaConnection as a, isWhatsAppSocketOperationTimeoutError as c, withWhatsAppSocketOperationTimeout as d, renderQrTerminal as f, acquireWhatsAppStandaloneConnectionOwner as h, newConnectionId as i, resolveWhatsAppSocketOperationTimeoutMs as l, acquireWhatsAppGatewayConnectionOwner as m, createWaDirectorySocket as n, DEFAULT_WHATSAPP_SOCKET_TIMING as o, WhatsAppConnectionOwnerBusyError as p, createWaSocket as r, createWhatsAppSocketOperationTimeoutAdapter as s, closeWhatsAppSocketAndWait as t, resolveWhatsAppSocketTiming as u };

package/npm-shrinkwrap.json

@@ -1,19 +1,19 @@
 {
   "name": "@openclaw/whatsapp",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/whatsapp",
-      "version": "2026.7.2-beta.2",
+      "version": "2026.7.2-beta.3",
       "dependencies": {
         "audio-decode": "2.2.3",
         "baileys": "7.0.0-rc13",
         "typebox": "1.3.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.2-beta.2"
+        "openclaw": ">=2026.7.2-beta.3"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/whatsapp",
-  "version": "2026.7.2-beta.2",
+  "version": "2026.7.2-beta.3",
   "description": "OpenClaw WhatsApp channel plugin for WhatsApp Web chats.",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
     "typebox": "1.3.3"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.2"
+    "openclaw": ">=2026.7.2-beta.3"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -56,10 +56,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.2"
+      "pluginApi": ">=2026.7.2-beta.3"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.2"
+      "openclawVersion": "2026.7.2-beta.3"
     },
     "release": {
       "publishToClawHub": true,

package/dist/account-config-LiT9wWH9.js

@@ -1,43 +0,0 @@
-import { DEFAULT_ACCOUNT_ID, mergeAccountConfig, resolveAccountEntry, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
-//#region extensions/whatsapp/src/account-config.ts
-function resolveWhatsAppDefaultAccountSharedConfig(cfg) {
-	const defaultAccount = resolveAccountEntry(cfg.channels?.whatsapp?.accounts, DEFAULT_ACCOUNT_ID);
-	if (!defaultAccount) return;
-	const { enabled: _ignoredEnabled, name: _ignoredName, authDir: _ignoredAuthDir, selfChatMode: _ignoredSelfChatMode, ...sharedDefaults } = defaultAccount;
-	return sharedDefaults;
-}
-function resolveWhatsAppAccountConfigForTest(cfg, accountId) {
-	return resolveAccountEntry(cfg.channels?.whatsapp?.accounts, accountId);
-}
-function resolveMergedNamedWhatsAppAccountConfig(params) {
-	const rootCfg = params.cfg.channels?.whatsapp;
-	const accountConfig = resolveWhatsAppAccountConfigForTest(params.cfg, params.accountId);
-	return {
-		...mergeAccountConfig({
-			channelConfig: rootCfg,
-			accountConfig: void 0,
-			omitKeys: ["defaultAccount"]
-		}),
-		...resolveWhatsAppDefaultAccountSharedConfig(params.cfg),
-		...accountConfig
-	};
-}
-function resolveMergedWhatsAppAccountConfig(params) {
-	const rootCfg = params.cfg.channels?.whatsapp;
-	const accountId = params.accountId?.trim() || rootCfg?.defaultAccount || DEFAULT_ACCOUNT_ID;
-	const base = resolveMergedAccountConfig({
-		channelConfig: rootCfg,
-		accounts: rootCfg?.accounts,
-		accountId,
-		omitKeys: ["defaultAccount"]
-	});
-	return {
-		accountId,
-		...accountId === DEFAULT_ACCOUNT_ID ? base : resolveMergedNamedWhatsAppAccountConfig({
-			cfg: params.cfg,
-			accountId
-		})
-	};
-}
-//#endregion
-export { resolveMergedWhatsAppAccountConfig as t };

package/dist/directory-config-CLBQrjtC.js

@@ -1,37 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-LiT9wWH9.js";
-import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
-import "./normalize-C-Z16y7Q.js";
-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 };