@openclaw/whatsapp 2026.7.1 → 2026.7.2-beta.2

package/dist/{session-DriaHt7V.js → session-mxWFn0eS.js}

@@ -1,14 +1,86 @@
 import { o as resolveWebCredsBackupPath, s as resolveWebCredsPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-B1kSWtBg.js";
-import { n as getStatusCode } from "./session-errors-BAj9D2La.js";
-import { t as DEFAULT_WHATSAPP_SOCKET_TIMING } from "./socket-timing-DhbVFjah.js";
-import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-Db-wfApd.js";
-import { i as makeWASocket, n as fetchLatestBaileysVersion, o as useMultiFileAuthState, r as makeCacheableSignalKeyStore } from "./session.runtime-CyooSQvj.js";
+import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-BQi9pZqQ.js";
+import { n as getStatusCode } from "./session-errors-JuazczrA.js";
+import { a as makeWASocket, i as makeCacheableSignalKeyStore, n as createBaileysSignalRepository, r as fetchLatestBaileysVersion, s as useMultiFileAuthState } from "./session.runtime-Nsqaehbd.js";
 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 { parseStrictPositiveInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { randomUUID } from "node:crypto";
 import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
+//#region extensions/whatsapp/src/socket-timing.ts
+const socketSendMessageQueueTails = /* @__PURE__ */ new WeakMap();
+const DEFAULT_WHATSAPP_SOCKET_TIMING = {
+	keepAliveIntervalMs: 25e3,
+	connectTimeoutMs: 6e4,
+	defaultQueryTimeoutMs: 6e4
+};
+var WhatsAppSocketOperationTimeoutError = class extends Error {
+	constructor(operation, timeoutMs) {
+		super(`WhatsApp socket ${operation} timed out after ${timeoutMs}ms; delivery state is unknown`);
+		this.operation = operation;
+		this.timeoutMs = timeoutMs;
+		this.deliveryState = "unknown";
+		this.name = "WhatsAppSocketOperationTimeoutError";
+	}
+};
+function resolveWhatsAppSocketTiming(cfg, overrides) {
+	const configured = cfg.web?.whatsapp;
+	return {
+		keepAliveIntervalMs: parseStrictPositiveInteger(overrides?.keepAliveIntervalMs) ?? parseStrictPositiveInteger(configured?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
+		connectTimeoutMs: parseStrictPositiveInteger(overrides?.connectTimeoutMs) ?? parseStrictPositiveInteger(configured?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
+		defaultQueryTimeoutMs: parseStrictPositiveInteger(overrides?.defaultQueryTimeoutMs) ?? parseStrictPositiveInteger(configured?.defaultQueryTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
+	};
+}
+function isWhatsAppSocketOperationTimeoutError(error) {
+	return error instanceof WhatsAppSocketOperationTimeoutError;
+}
+function resolveWhatsAppSocketOperationTimeoutMs(timeoutMs) {
+	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs);
+}
+async function runSerializedSocketSendMessage(sock, run) {
+	const result = (socketSendMessageQueueTails.get(sock) ?? Promise.resolve()).then(run);
+	const tail = result.then(() => void 0, () => void 0);
+	socketSendMessageQueueTails.set(sock, tail);
+	tail.then(() => {
+		if (socketSendMessageQueueTails.get(sock) === tail) socketSendMessageQueueTails.delete(sock);
+	});
+	return await result;
+}
+async function withWhatsAppSocketOperationTimeout(operation, promise, timeoutMs, onTimeout) {
+	const resolvedTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(timeoutMs);
+	let timeout = null;
+	try {
+		return await Promise.race([promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => {
+				onTimeout?.();
+				reject(new WhatsAppSocketOperationTimeoutError(operation, resolvedTimeoutMs));
+			}, resolvedTimeoutMs);
+			timeout.unref?.();
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function createWhatsAppSocketOperationTimeoutAdapter(sock, timeoutMs, hooks) {
+	const operationTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(timeoutMs);
+	return {
+		sendMessage: (jid, content, options) => {
+			return runSerializedSocketSendMessage(sock, () => {
+				const send = options ? sock.sendMessage(jid, content, options) : sock.sendMessage(jid, content);
+				return withWhatsAppSocketOperationTimeout("sendMessage", send, operationTimeoutMs, hooks?.onSendMessageTimeout ? () => hooks.onSendMessageTimeout?.({
+					jid,
+					promise: send
+				}) : void 0);
+			});
+		},
+		sendPresenceUpdate: (presence, jid) => {
+			return withWhatsAppSocketOperationTimeout("sendPresenceUpdate", jid === void 0 ? sock.sendPresenceUpdate(presence) : sock.sendPresenceUpdate(presence, jid), operationTimeoutMs);
+		}
+	};
+}
+//#endregion
 //#region extensions/whatsapp/src/session.ts
 const LOGGED_OUT_STATUS = 401;
 const WHATSAPP_WEBSOCKET_PROXY_TARGET = "https://mmg.whatsapp.net/";
@@ -17,29 +89,60 @@ const OPENCLAW_WHATSAPP_WEB_SOCKET_URL_ENV = "OPENCLAW_WHATSAPP_WEB_SOCKET_URL";
 async function rejectUnsafeWebCredsPath(authDir) {
 	await assertWebCredsPathRegularFileOrMissing(resolveWebCredsPath(authDir));
 }
-function enqueueSaveCreds(authDir, saveCreds, logger) {
-	enqueueCredsSave(authDir, () => safeSaveCreds(authDir, saveCreds, logger), (err) => {
+function enqueueSaveCreds(authDir, saveCreds, logger, options) {
+	enqueueCredsSave(authDir, () => safeSaveCreds({
+		authDir,
+		saveCreds,
+		logger,
+		beforeCredentialPersistence: options?.beforeCredentialPersistence
+	}), (err) => {
 		logger.warn({ error: String(err) }, "WhatsApp creds save queue error");
+		options?.onError?.(err);
 	});
 }
-async function safeSaveCreds(authDir, saveCreds, logger) {
+async function safeSaveCreds(params) {
+	let backup;
 	try {
-		const credsPath = resolveWebCredsPath(authDir);
-		const backupPath = resolveWebCredsBackupPath(authDir);
+		const credsPath = resolveWebCredsPath(params.authDir);
+		const backupPath = resolveWebCredsBackupPath(params.authDir);
 		const raw = readCredsJsonRaw(credsPath);
 		if (raw) try {
 			JSON.parse(raw);
-			await writeWebCredsRawAtomically({
-				filePath: backupPath,
+			backup = {
 				content: raw,
+				filePath: backupPath
+			};
+		} catch {}
+	} catch {}
+	if (backup) {
+		await params.beforeCredentialPersistence?.();
+		try {
+			await writeWebCredsRawAtomically({
+				filePath: backup.filePath,
+				content: backup.content,
 				tempPrefix: ".creds.backup"
 			});
 		} catch {}
-	} catch {}
+	}
+	await params.beforeCredentialPersistence?.();
 	try {
-		await Promise.resolve(saveCreds());
+		await Promise.resolve(params.saveCreds());
 	} catch (err) {
-		logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+		params.logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+		if (params.beforeCredentialPersistence) throw err;
+	}
+}
+function abortSocketAfterCredentialPersistenceFailure(sock, error) {
+	const failure = error instanceof Error ? error : /* @__PURE__ */ new Error("WhatsApp credential persistence rejected");
+	const closeWebSocket = () => {
+		try {
+			sock.ws?.close?.();
+		} catch {}
+	};
+	try {
+		sock.end(failure).catch(closeWebSocket);
+	} catch {
+		closeWebSocket();
 	}
 }
 async function printTerminalQr(qr) {
@@ -70,12 +173,13 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 	const logger = toPinoLikeLogger(getChildLogger({ module: "baileys" }, { level: verbose ? "info" : "silent" }), verbose ? "info" : "silent");
 	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
 	await rejectUnsafeWebCredsPath(authDir);
+	await opts.beforeCredentialPersistence?.();
 	await ensureDir(authDir);
 	const sessionLogger = getChildLogger({ module: "web-session" });
 	if (await waitForCredsSaveQueueWithTimeout(authDir) === "timed_out") sessionLogger.warn({ authDir }, CREDS_FLUSH_TIMEOUT_MESSAGE);
 	else {
 		await rejectUnsafeWebCredsPath(authDir);
-		await restoreCredsFromBackupIfNeeded(authDir);
+		await restoreCredsFromBackupIfNeeded(authDir, { beforeCredentialPersistence: opts.beforeCredentialPersistence });
 	}
 	await rejectUnsafeWebCredsPath(authDir);
 	const { state } = await useMultiFileAuthState(authDir);
@@ -91,10 +195,62 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 		connectTimeoutMs: opts.connectTimeoutMs ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
 		defaultQueryTimeoutMs: opts.defaultQueryTimeoutMs ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
 	};
+	const socketRef = {};
+	let pendingSocketAbort;
+	const reportCredentialPersistenceError = (error) => {
+		if (socketRef.current) abortSocketAfterCredentialPersistenceFailure(socketRef.current, error);
+		else pendingSocketAbort = { error };
+		opts.onCredentialPersistenceError?.(error);
+	};
+	const cachedSignalKeys = makeCacheableSignalKeyStore(opts.beforeCredentialPersistence ? {
+		...state.keys,
+		async set(data) {
+			await opts.beforeCredentialPersistence?.();
+			await state.keys.set(data);
+		}
+	} : state.keys, logger);
+	const signalKeys = opts.beforeCredentialPersistence ? {
+		...cachedSignalKeys,
+		get(type, ids) {
+			const task = Promise.resolve(cachedSignalKeys.get(type, ids));
+			opts.onCredentialPersistenceTask?.(task);
+			return task;
+		},
+		set(data) {
+			const task = (async () => {
+				try {
+					await cachedSignalKeys.set(data);
+				} catch (error) {
+					reportCredentialPersistenceError(error);
+					throw error;
+				}
+			})();
+			opts.onCredentialPersistenceTask?.(task);
+			return task;
+		}
+	} : cachedSignalKeys;
+	const makeSignalRepository = opts.onCredentialPersistenceTask ? (...args) => {
+		const repository = createBaileysSignalRepository(...args);
+		const storeLidPnMappings = repository.lidMapping.storeLIDPNMappings.bind(repository.lidMapping);
+		repository.lidMapping.storeLIDPNMappings = (...storeArgs) => {
+			const task = storeLidPnMappings(...storeArgs);
+			opts.onCredentialPersistenceTask?.(task);
+			task.then(void 0, reportCredentialPersistenceError);
+			return task;
+		};
+		const migrateSession = repository.migrateSession.bind(repository);
+		repository.migrateSession = (...migrateArgs) => {
+			const task = migrateSession(...migrateArgs);
+			opts.onCredentialPersistenceTask?.(task);
+			task.then(void 0, reportCredentialPersistenceError);
+			return task;
+		};
+		return repository;
+	} : void 0;
 	const sock = makeWASocket({
 		auth: {
 			creds: state.creds,
-			keys: makeCacheableSignalKeyStore(state.keys, logger)
+			keys: signalKeys
 		},
 		version,
 		logger,
@@ -109,11 +265,17 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 		...socketTiming,
 		agent,
 		fetchAgent,
+		...makeSignalRepository ? { makeSignalRepository } : {},
 		...waWebSocketUrl ? { waWebSocketUrl } : {},
 		...opts.getMessage ? { getMessage: opts.getMessage } : {},
 		...opts.cachedGroupMetadata ? { cachedGroupMetadata: opts.cachedGroupMetadata } : {}
 	});
-	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger));
+	socketRef.current = sock;
+	if (pendingSocketAbort) abortSocketAfterCredentialPersistenceFailure(sock, pendingSocketAbort.error);
+	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger, {
+		beforeCredentialPersistence: opts.beforeCredentialPersistence,
+		onError: reportCredentialPersistenceError
+	}));
 	sock.ev.on("connection.update", (update) => {
 		(async () => {
 			try {
@@ -208,7 +370,7 @@ async function waitForWaConnection(sock, options = { timeout: "none" }) {
 			}
 			if (update.connection === "close") {
 				cleanup();
-				reject(toLintErrorObject(update.lastDisconnect ?? /* @__PURE__ */ new Error("Connection closed"), "Non-Error rejection"));
+				reject(toLintErrorObject(update.lastDisconnect?.error ?? update.lastDisconnect ?? /* @__PURE__ */ new Error("Connection closed"), "Non-Error rejection"));
 			}
 		};
 		sock.ev.on("connection.update", handler);
@@ -238,4 +400,4 @@ function createConnectionTimeoutError(timeoutMs) {
 	return error;
 }
 //#endregion
-export { renderQrTerminal as i, newConnectionId as n, waitForWaConnection as r, createWaSocket as t };
+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 };

package/dist/session.runtime-Nsqaehbd.js

@@ -0,0 +1,16 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { BufferJSON, DEFAULT_CONNECTION_CONFIG, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState } from "baileys";
+//#region extensions/whatsapp/src/session.runtime.ts
+var session_runtime_exports = /* @__PURE__ */ __exportAll({
+	BufferJSON: () => BufferJSON,
+	createBaileysSignalRepository: () => createBaileysSignalRepository,
+	fetchLatestBaileysVersion: () => fetchLatestBaileysVersion,
+	makeCacheableSignalKeyStore: () => makeCacheableSignalKeyStore,
+	makeWASocket: () => makeWASocket,
+	useMultiFileAuthState: () => useMultiFileAuthState
+});
+function createBaileysSignalRepository(...args) {
+	return DEFAULT_CONNECTION_CONFIG.makeSignalRepository(...args);
+}
+//#endregion
+export { makeWASocket as a, makeCacheableSignalKeyStore as i, createBaileysSignalRepository as n, session_runtime_exports as o, fetchLatestBaileysVersion as r, useMultiFileAuthState as s, BufferJSON as t };

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

@@ -1,7 +1,7 @@
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-4YgwroRU.js";
-import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-bVWjgftN.js";
-import { t as WhatsAppChannelConfigSchema } from "./config-schema-mBX2nmn1.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";
 import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.js";
 import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.js";
@@ -11,7 +11,7 @@ import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-
 import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
 import { createChannelPluginBase } from "openclaw/plugin-sdk/core";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
-import { collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveChannelGroupRequireMention, resolveChannelGroupToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
+import { buildChannelGroupsScopeTree, collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
 import { createDelegatedSetupWizardProxy } from "openclaw/plugin-sdk/setup-runtime";
@@ -22,37 +22,22 @@ function formatWhatsAppConfigAllowFromEntries(allowFrom) {
 	return normalizeWhatsAppAllowFromEntries(allowFrom);
 }
 //#endregion
-//#region extensions/whatsapp/src/group-intro.ts
-const WHATSAPP_GROUP_INTRO_HINT = "WhatsApp IDs: SenderId is the participant JID (group participant id).";
-function resolveWhatsAppGroupIntroHint() {
-	return WHATSAPP_GROUP_INTRO_HINT;
-}
-function resolveWhatsAppMentionStripRegexes(ctx) {
-	const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/i, "");
-	if (!selfE164) return [];
-	const escaped = selfE164.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	return [new RegExp(escaped, "g"), new RegExp(`@${escaped}`, "g")];
-}
-//#endregion
 //#region extensions/whatsapp/src/group-policy.ts
+function resolveScopePath(params) {
+	return params.groupId ? [params.groupId] : [];
+}
 function resolveWhatsAppGroupRequireMention(params) {
-	return resolveChannelGroupRequireMention({
-		cfg: params.cfg,
-		channel: "whatsapp",
-		groupId: params.groupId,
-		accountId: params.accountId
+	return resolveScopeRequireMention({
+		tree: buildChannelGroupsScopeTree(params.cfg, "whatsapp", params.accountId),
+		path: resolveScopePath(params)
 	});
 }
 function resolveWhatsAppGroupToolPolicy(params) {
-	return resolveChannelGroupToolsPolicy({
-		cfg: params.cfg,
-		channel: "whatsapp",
-		groupId: params.groupId,
-		accountId: params.accountId,
-		senderId: params.senderId,
-		senderName: params.senderName,
-		senderUsername: params.senderUsername,
-		senderE164: params.senderE164
+	return resolveScopeToolsPolicy({
+		...params,
+		tree: buildChannelGroupsScopeTree(params.cfg, "whatsapp", params.accountId),
+		path: resolveScopePath(params),
+		messageProvider: "whatsapp"
 	});
 }
 //#endregion
@@ -99,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-CAssfx9p.js");
+	return await import("./channel.runtime-BDDy4Lhz.js");
 }
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-DlWb0Z09.js");
+	return await import("./setup-surface-CiKGdNJv.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({
@@ -333,4 +318,4 @@ const whatsappSetupAdapter = {
 	}
 };
 //#endregion
-export { resolveWhatsAppGroupRequireMention as a, resolveWhatsAppMentionStripRegexes as c, whatsappSetupWizardProxy as i, formatWhatsAppConfigAllowFromEntries as l, createWhatsAppPluginBase as n, resolveWhatsAppGroupToolPolicy as o, loadWhatsAppChannelRuntime as r, resolveWhatsAppGroupIntroHint as s, whatsappSetupAdapter as t };
+export { resolveWhatsAppGroupRequireMention as a, whatsappSetupWizardProxy as i, createWhatsAppPluginBase as n, resolveWhatsAppGroupToolPolicy as o, loadWhatsAppChannelRuntime as r, formatWhatsAppConfigAllowFromEntries as s, whatsappSetupAdapter as t };

package/dist/{setup-finalize-c8dl34sO.js → setup-finalize-DBf1jjBj.js}

@@ -1,8 +1,8 @@
 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-4YgwroRU.js";
-import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-bVWjgftN.js";
-import { t as whatsappSetupAdapter } from "./setup-core-DH-DFPLY.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 { 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
@@ -271,6 +271,15 @@ async function finalizeWhatsAppSetup(params) {
 		cfg: next,
 		accountId
 	});
+	if (params.options?.deferDeviceLinkToClient) {
+		next = await promptWhatsAppDmAccess({
+			cfg: next,
+			accountId,
+			forceAllowFrom: params.forceAllowFrom,
+			prompter: params.prompter
+		});
+		return { cfg: next };
+	}
 	if (!linked) await params.prompter.note([
 		t("wizard.whatsapp.scanQr"),
 		t("wizard.whatsapp.credentialsStored", { authDir }),
@@ -279,14 +288,35 @@ async function finalizeWhatsAppSetup(params) {
 	if (await params.prompter.confirm({
 		message: linked ? t("wizard.whatsapp.relinkPrompt") : t("wizard.whatsapp.linkNowPrompt"),
 		initialValue: !linked
-	})) try {
-		const { loginWeb } = await import("./login-C48y0jlx.js").then((n) => n.n);
-		await loginWeb(false, void 0, params.runtime, accountId);
-	} catch (error) {
-		params.runtime.error(`WhatsApp login failed: ${String(error)}`);
-		await params.prompter.note(t("wizard.channels.docs", { link: formatDocsLink("/whatsapp", "whatsapp") }), t("wizard.whatsapp.helpTitle"));
-	}
-	else if (!linked) await params.prompter.note(t("wizard.whatsapp.linkLater", { command: formatCliCommand("openclaw channels login") }), "WhatsApp");
+	})) {
+		const reportLoginFailure = async (error) => {
+			params.runtime.error(`WhatsApp login failed: ${String(error)}`);
+			await params.prompter.note(t("wizard.channels.docs", { link: formatDocsLink("/whatsapp", "whatsapp") }), t("wizard.whatsapp.helpTitle"));
+		};
+		let loginWeb;
+		try {
+			({loginWeb} = await import("./login-DGIoToX8.js").then((n) => n.n));
+		} catch (error) {
+			await reportLoginFailure(error);
+		}
+		if (loginWeb) {
+			let persistenceGuardFailure;
+			const beforeCredentialPersistence = params.options?.beforePersistentEffect ? async () => {
+				try {
+					await params.options?.beforePersistentEffect?.();
+				} catch (error) {
+					persistenceGuardFailure = { error };
+					throw error;
+				}
+			} : void 0;
+			try {
+				await loginWeb(false, void 0, params.runtime, accountId, { beforeCredentialPersistence });
+			} catch (error) {
+				if (persistenceGuardFailure) throw persistenceGuardFailure.error;
+				await reportLoginFailure(error);
+			}
+		}
+	} else if (!linked) await params.prompter.note(t("wizard.whatsapp.linkLater", { command: formatCliCommand("openclaw channels login") }), "WhatsApp");
 	next = await promptWhatsAppDmAccess({
 		cfg: next,
 		accountId,

package/dist/setup-plugin-api.js

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

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

@@ -1,6 +1,6 @@
 import { t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { o as resolveWhatsAppAuthDir } from "./accounts-4YgwroRU.js";
-import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-Db-wfApd.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
 const t = createSetupTranslator();
@@ -36,7 +36,7 @@ const whatsappSetupWizard = {
 	},
 	resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
 	credentials: [],
-	finalize: async (params) => await (await import("./setup-finalize-c8dl34sO.js")).finalizeWhatsAppSetup(params),
+	finalize: async (params) => await (await import("./setup-finalize-DBf1jjBj.js")).finalizeWhatsAppSetup(params),
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
 	onAccountRecorded: (accountId, options) => {
 		options?.onAccountId?.(channel, accountId);

package/dist/{state-migrations-D_BmQUR9.js → state-migrations-CAMTrs2U.js}

@@ -1,15 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { statRegularFileSync } from "openclaw/plugin-sdk/security-runtime";
+import { fileExists } from "openclaw/plugin-sdk/security-runtime";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 //#region extensions/whatsapp/src/state-migrations.ts
-function fileExists(pathValue) {
-	try {
-		return !statRegularFileSync(pathValue).missing;
-	} catch {
-		return false;
-	}
-}
 function isLegacyWhatsAppAuthFile(name) {
 	if (name === "creds.json" || name === "creds.json.bak") return true;
 	if (!name.endsWith(".json")) return false;

package/dist/{targets-runtime-C-GiVn6Y.js → targets-runtime-Bsh0HR9y.js}

@@ -71,22 +71,27 @@ async function resolveEquivalentWhatsAppDirectChatJids(jid, opts) {
 	const pnMatch = normalized.match(DIRECT_PN_JID_RE);
 	if (pnMatch) {
 		addEquivalentDirectChatCandidate(candidates, await tryLookupMappedJid(() => opts?.lidLookup?.getLIDForPN?.(normalized)));
+		const phoneDigits = pnMatch[1];
+		const pnDomain = pnMatch[2];
+		if (!phoneDigits || !pnDomain) return candidates;
 		const mappedLocalLid = readLidForwardMapping({
-			phoneDigits: pnMatch[1],
+			phoneDigits,
 			opts
 		});
-		const localLidDomain = pnMatch[2].toLowerCase() === "hosted" ? "hosted.lid" : "lid";
+		const localLidDomain = pnDomain.toLowerCase() === "hosted" ? "hosted.lid" : "lid";
 		addUniqueString(candidates, mappedLocalLid ? `${mappedLocalLid}@${localLidDomain}` : null);
 		return candidates;
 	}
 	const lidMatch = normalized.match(DIRECT_LID_JID_RE);
 	if (lidMatch) {
 		addEquivalentDirectChatCandidate(candidates, await tryLookupMappedJid(() => opts?.lidLookup?.getPNForLID?.(normalized)));
+		const lidDomain = lidMatch[2];
+		if (!lidMatch[1] || !lidDomain) return candidates;
 		const e164 = jidToE164(normalized, {
 			...opts,
 			logMissing: false
 		});
-		addUniqueString(candidates, e164 && lidMatch[2].toLowerCase() === "hosted.lid" ? `${e164.replace(/\D/g, "")}@hosted` : e164 ? toWhatsappJid(e164) : null);
+		addUniqueString(candidates, e164 && lidDomain.toLowerCase() === "hosted.lid" ? `${e164.replace(/\D/g, "")}@hosted` : e164 ? toWhatsappJid(e164) : null);
 	}
 	return candidates;
 }
@@ -132,12 +137,14 @@ function readLidForwardMapping(params) {
 	return null;
 }
 function jidToE164(jid, opts) {
-	const match = jid.match(/^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/);
-	if (match) return `+${match[1]}`;
+	const phoneDigits = jid.match(/^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/)?.[1];
+	if (phoneDigits) return `+${phoneDigits}`;
 	const lidMatch = jid.match(/^(\d+)(?::\d+)?@(lid|hosted\.lid)$/);
 	if (!lidMatch) return null;
+	const lid = lidMatch[1];
+	if (!lid) return null;
 	const phone = readLidReverseMapping({
-		lid: lidMatch[1],
+		lid,
 		opts
 	});
 	if (phone) return phone;

package/dist/text-runtime-BTGkMN0o.js

@@ -0,0 +1,4 @@
+import "./targets-runtime-Bsh0HR9y.js";
+import { convertMarkdownTables, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile, stripToolCallXmlTags } from "openclaw/plugin-sdk/text-chunking";
+import { normalizeE164, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
+export { sanitizeAssistantVisibleTextWithProfile as a, sanitizeAssistantVisibleText as i, normalizeE164 as n, stripToolCallXmlTags as o, resolveUserPath$1 as r, convertMarkdownTables as t };

package/npm-shrinkwrap.json

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