@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.34

package/dist/{shared-CAxd15bp.js → .setup/setup-core--FfzntMG.mjs}

@@ -1,76 +1,60 @@
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CSqLvCY5.js";
-import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-CugRyONv.js";
-import { t as WhatsAppChannelConfigSchema } from "./config-schema-BQP5YCeK.js";
-import { n as whatsappDoctor } from "./doctor-CwzVXKoE.js";
-import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.js";
-import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.js";
-import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-nAzD945y.js";
-import { n as deriveLegacySessionChatType, r as isLegacyGroupSessionKey, t as canonicalizeLegacySessionKey } from "./session-contract-DMTm6Q_L.js";
+import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.mjs";
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-Dw16pdNl.mjs";
+import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-bVWjgftN.mjs";
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-mBX2nmn1.mjs";
+import { n as whatsappDoctor } from "./doctor-By3SB4lm.mjs";
+import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.mjs";
+import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.mjs";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-nAzD945y.mjs";
+import { n as deriveLegacySessionChatType, r as isLegacyGroupSessionKey, t as canonicalizeLegacySessionKey } from "./session-contract-DMTm6Q_L.mjs";
 import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 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 { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { buildChannelGroupsScopeTree, collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
-import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
-import { createPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup";
+import { collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveChannelGroupRequireMention, resolveChannelGroupToolsPolicy } 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";
 import { readChannelAllowFromStore } from "openclaw/plugin-sdk/channel-pairing";
-//#region extensions/whatsapp/src/channel-runtime-loader.ts
-const loadWhatsAppAuthStore = createLazyRuntimeModule(() => import("./auth-store-DcEpIOmE.js").then((n) => n.i));
-async function readWhatsAppAccountLinkState(authDir) {
-	const state = await (await loadWhatsAppAuthStore()).readWebAuthState(authDir);
-	return state === "unstable" ? "unknown" : state;
-}
-const loadWhatsAppChannelRuntime = createLazyRuntimeModule(async () => {
-	await loadWhatsAppAuthStore();
-	return await import("./channel.runtime-BP0xNmLi.js");
-});
-//#endregion
+import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
 //#region extensions/whatsapp/src/config-accessors.ts
 function formatWhatsAppConfigAllowFromEntries(allowFrom) {
 	return normalizeWhatsAppAllowFromEntries(allowFrom);
 }
 //#endregion
-//#region extensions/whatsapp/src/group-policy.ts
-function resolveScopePath(params) {
-	return params.groupId ? [params.groupId] : [];
+//#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 resolveWhatsAppGroupRequireMention(params) {
-	return resolveScopeRequireMention({
-		tree: buildChannelGroupsScopeTree(params.cfg, "whatsapp", params.accountId),
-		path: resolveScopePath(params)
+	return resolveChannelGroupRequireMention({
+		cfg: params.cfg,
+		channel: "whatsapp",
+		groupId: params.groupId,
+		accountId: params.accountId
 	});
 }
 function resolveWhatsAppGroupToolPolicy(params) {
-	return resolveScopeToolsPolicy({
-		...params,
-		tree: buildChannelGroupsScopeTree(params.cfg, "whatsapp", params.accountId),
-		path: resolveScopePath(params),
-		messageProvider: "whatsapp"
+	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
 	});
 }
-const whatsappSetupAdapter = {
-	...createPatchedAccountSetupAdapter({
-		channelKey: "whatsapp",
-		alwaysUseAccounts: true,
-		buildPatch: (input) => input.authDir ? { authDir: input.authDir } : {}
-	}),
-	singleAccountKeysToMove: ["authDir"]
-};
-const whatsappSetupContract = defineChannelSetupContract({
-	fields: { authDir: {
-		kind: "string",
-		cli: {
-			flags: "--auth-dir <path>",
-			description: "WhatsApp auth directory override"
-		}
-	} },
-	legacyAdapter: whatsappSetupAdapter
-});
 //#endregion
 //#region extensions/whatsapp/src/security-fix.ts
 function applyGroupAllowFromFromStore(params) {
@@ -96,7 +80,8 @@ function applyGroupAllowFromFromStore(params) {
 	return changed ? next : params.cfg;
 }
 async function applyWhatsAppSecurityConfigFixes(params) {
-	const normalized = normalizeUniqueStringEntries(await readChannelAllowFromStore("whatsapp", params.env, DEFAULT_ACCOUNT_ID).catch(() => []));
+	const fromStore = await readChannelAllowFromStore("whatsapp", params.env, DEFAULT_ACCOUNT_ID).catch(() => []);
+	const normalized = normalizeUniqueStringEntries(fromStore);
 	if (normalized.length === 0) return {
 		config: params.cfg,
 		changes: []
@@ -114,8 +99,11 @@ async function applyWhatsAppSecurityConfigFixes(params) {
 //#endregion
 //#region extensions/whatsapp/src/shared.ts
 const WHATSAPP_CHANNEL = "whatsapp";
+async function loadWhatsAppChannelRuntime() {
+	return await import("./channel.runtime-DmmMgRJQ.mjs");
+}
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-BkVcd769.js");
+	return await import("./setup-surface-Zvj2cLzz.mjs");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({
@@ -219,7 +207,7 @@ function createWhatsAppPluginBase(params) {
 			docsLabel: "whatsapp",
 			blurb: "works with your own number; recommend a separate phone + eSIM.",
 			systemImage: "message",
-			exposure: { configured: false },
+			showConfigured: false,
 			quickstartAllowFrom: true,
 			forceAccountBinding: true,
 			preferSessionLookupForAnnounceTarget: true
@@ -241,7 +229,7 @@ function createWhatsAppPluginBase(params) {
 		},
 		reload: {
 			configPrefixes: [
-				"channels.whatsapp.enabled",
+				"web",
 				"channels.whatsapp.accounts",
 				"channels.whatsapp.selfChatMode"
 			],
@@ -251,17 +239,16 @@ function createWhatsAppPluginBase(params) {
 		configSchema: WhatsAppChannelConfigSchema,
 		config: {
 			...whatsappConfigAdapter,
-			isEnabled: (account) => account.enabled,
+			isEnabled: (account, cfg) => account.enabled && cfg.web?.enabled !== false,
 			disabledReason: () => "disabled",
 			isConfigured: params.isConfigured,
-			isLinked: params.isLinked,
 			hasPersistedAuthState: ({ cfg }) => hasAnyWhatsAppAuth(cfg),
-			unconfiguredReason: () => "not configured",
-			unlinkedReason: () => "not linked",
+			unconfiguredReason: () => "not linked",
 			describeAccount: (account) => describeAccountSnapshot({
 				account,
 				configured: Boolean(account.authDir),
 				extra: {
+					linked: Boolean(account.authDir),
 					dmPolicy: account.dmPolicy,
 					allowFrom: account.allowFrom
 				}
@@ -274,7 +261,6 @@ function createWhatsAppPluginBase(params) {
 		},
 		doctor: whatsappDoctor,
 		setup: params.setup,
-		...params.setupContract ? { setupContract: params.setupContract } : {},
 		groups: params.groups
 	});
 	return {
@@ -304,4 +290,49 @@ function createWhatsAppPluginBase(params) {
 	};
 }
 //#endregion
-export { resolveWhatsAppGroupRequireMention as a, loadWhatsAppChannelRuntime as c, whatsappSetupContract as i, readWhatsAppAccountLinkState as l, whatsappSetupWizardProxy as n, resolveWhatsAppGroupToolPolicy as o, whatsappSetupAdapter as r, formatWhatsAppConfigAllowFromEntries as s, createWhatsAppPluginBase as t };
+//#region extensions/whatsapp/src/setup-core.ts
+const channel = "whatsapp";
+const whatsappSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: channel,
+		accountId,
+		name,
+		alwaysUseAccounts: true
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const namedConfig = applyAccountNameToChannelSection({
+			cfg,
+			channelKey: channel,
+			accountId,
+			name: input.name,
+			alwaysUseAccounts: true
+		});
+		const next = migrateBaseNameToDefaultAccount({
+			cfg: namedConfig,
+			channelKey: channel,
+			alwaysUseAccounts: true
+		});
+		const entry = {
+			...next.channels?.whatsapp?.accounts?.[accountId],
+			...input.authDir ? { authDir: input.authDir } : {},
+			enabled: true
+		};
+		return {
+			...next,
+			channels: {
+				...next.channels,
+				whatsapp: {
+					...next.channels?.whatsapp,
+					accounts: {
+						...next.channels?.whatsapp?.accounts,
+						[accountId]: entry
+					}
+				}
+			}
+		};
+	}
+};
+//#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 };

package/dist/{setup-finalize-BZucx24W.js → .setup/setup-finalize-DCruIciL.mjs}

@@ -1,10 +1,10 @@
-import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-CSqLvCY5.js";
-import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import { r as hasWebCredsSync } from "./creds-files-B1kSWtBg.js";
-import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-CugRyONv.js";
-import { r as whatsappSetupAdapter } from "./shared-CAxd15bp.js";
-import { DEFAULT_ACCOUNT_ID, createSetupTranslator, splitSetupEntries } from "openclaw/plugin-sdk/setup";
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.mjs";
+import { r as hasWebCredsSync } from "./creds-files-B1kSWtBg.mjs";
+import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-Dw16pdNl.mjs";
+import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-bVWjgftN.mjs";
+import { t as whatsappSetupAdapter } from "./setup-core--FfzntMG.mjs";
 import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { DEFAULT_ACCOUNT_ID, createSetupTranslator, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 //#region extensions/whatsapp/src/setup-finalize.ts
 const t = createSetupTranslator();
 function trimPromptText(value) {
@@ -94,7 +94,7 @@ async function detectWhatsAppLinked(cfg, accountId) {
 async function promptWhatsAppOwnerAllowFrom(params) {
 	const { prompter, existingAllowFrom } = params;
 	await prompter.note(t("wizard.whatsapp.ownerNumberNote"), t("wizard.whatsapp.numberTitle"));
-	const normalized = normalizeWhatsAppAllowFromEntry(trimPromptText(await prompter.text({
+	const entry = await prompter.text({
 		message: t("wizard.whatsapp.personalNumberPrompt"),
 		placeholder: "+15555550123",
 		initialValue: existingAllowFrom[0],
@@ -103,7 +103,8 @@ async function promptWhatsAppOwnerAllowFrom(params) {
 			if (!raw) return t("common.required");
 			if (!normalizeWhatsAppAllowFromEntry(raw)) return `Invalid number: ${raw}`;
 		}
-	})));
+	});
+	const normalized = normalizeWhatsAppAllowFromEntry(trimPromptText(entry));
 	if (!normalized) throw new Error("Invalid WhatsApp owner number (expected E.164 after validation).");
 	return {
 		normalized,
@@ -271,15 +272,6 @@ 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 }),
@@ -288,35 +280,14 @@ async function finalizeWhatsAppSetup(params) {
 	if (await params.prompter.confirm({
 		message: linked ? t("wizard.whatsapp.relinkPrompt") : t("wizard.whatsapp.linkNowPrompt"),
 		initialValue: !linked
-	})) {
-		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-CvY2Dhch.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");
+	})) try {
+		const { loginWeb } = await import("./login-7b3M0iBp.mjs").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");
 	next = await promptWhatsAppDmAccess({
 		cfg: next,
 		accountId,

package/dist/.setup/setup-plugin-api-B6ck_20D.mjs

@@ -0,0 +1,3 @@
+import { t as whatsappSetupPlugin } from "./channel.setup-ByBYSeLd.mjs";
+import "../setup-plugin-api.js";
+export { whatsappSetupPlugin };

package/dist/{setup-surface-BkVcd769.js → .setup/setup-surface-Zvj2cLzz.mjs}

@@ -1,6 +1,6 @@
-import { o as resolveWhatsAppAuthDir } from "./accounts-CSqLvCY5.js";
-import { t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-DcEpIOmE.js";
+import { t as listAccountIds } from "./account-ids-CB5SOWjc.mjs";
+import { o as resolveWhatsAppAuthDir } from "./accounts-Dw16pdNl.mjs";
+import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-BZKGa0tW.mjs";
 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-BZucx24W.js")).finalizeWhatsAppSetup(params),
+	finalize: async (params) => await (await import("./setup-finalize-DCruIciL.mjs")).finalizeWhatsAppSetup(params),
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
 	onAccountRecorded: (accountId, options) => {
 		options?.onAccountId?.(channel, accountId);

package/dist/.setup/socket-timing-DhbVFjah.mjs

@@ -0,0 +1,77 @@
+import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-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 positiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function resolveWhatsAppSocketTiming(cfg, overrides) {
+	const configured = cfg.web?.whatsapp;
+	return {
+		keepAliveIntervalMs: positiveInteger(overrides?.keepAliveIntervalMs) ?? positiveInteger(configured?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
+		connectTimeoutMs: positiveInteger(overrides?.connectTimeoutMs) ?? positiveInteger(configured?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
+		defaultQueryTimeoutMs: positiveInteger(overrides?.defaultQueryTimeoutMs) ?? positiveInteger(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
+export { resolveWhatsAppSocketTiming as a, resolveWhatsAppSocketOperationTimeoutMs as i, createWhatsAppSocketOperationTimeoutAdapter as n, withWhatsAppSocketOperationTimeout as o, isWhatsAppSocketOperationTimeoutError as r, DEFAULT_WHATSAPP_SOCKET_TIMING as t };

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

@@ -1,8 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fileExists } from "openclaw/plugin-sdk/security-runtime";
+import { statRegularFileSync } 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/.setup/targets-runtime-C-GiVn6Y.mjs

@@ -0,0 +1,188 @@
+import fs from "node:fs";
+import path from "node:path";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { CONFIG_DIR, escapeRegExp, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
+//#region extensions/whatsapp/src/targets-runtime.ts
+const WHATSAPP_FENCE_PLACEHOLDER = "\0FENCE";
+const WHATSAPP_INLINE_CODE_PLACEHOLDER = "\0CODE";
+const WHATSAPP_PLACEHOLDER_TERMINATOR = "\0";
+function assertWebChannel(input) {
+	if (input !== "web") throw new Error("Web channel must be 'web'");
+}
+function isSelfChatMode(selfE164, allowFrom) {
+	if (!selfE164) return false;
+	if (!Array.isArray(allowFrom) || allowFrom.length === 0) return false;
+	const normalizedSelf = normalizeE164(selfE164);
+	return allowFrom.some((n) => {
+		if (n === "*") return false;
+		try {
+			return normalizeE164(String(n)) === normalizedSelf;
+		} catch {
+			return false;
+		}
+	});
+}
+function toWhatsappJid(number) {
+	const withoutPrefix = number.replace(/^whatsapp:/i, "").trim();
+	if (withoutPrefix.includes("@")) return withoutPrefix;
+	return `${normalizeE164(withoutPrefix).replace(/\D/g, "")}@s.whatsapp.net`;
+}
+function toWhatsappJidWithLid(number, opts) {
+	const stripped = number.replace(/^whatsapp:/i, "").trim();
+	if (stripped.includes("@")) return stripped;
+	const phoneDigits = normalizeE164(stripped).replace(/\D/g, "");
+	const lid = readLidForwardMapping({
+		phoneDigits,
+		opts
+	});
+	return lid ? `${lid}@lid` : `${phoneDigits}@s.whatsapp.net`;
+}
+function addUniqueString(target, value) {
+	const normalized = value?.trim();
+	if (normalized && !target.includes(normalized)) target.push(normalized);
+}
+async function tryLookupMappedJid(lookup) {
+	if (!lookup) return null;
+	try {
+		return await lookup() ?? null;
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`LID mapping lookup failed: ${String(err)}`);
+		return null;
+	}
+}
+const DIRECT_PN_JID_RE = /^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/i;
+const DIRECT_LID_JID_RE = /^(\d+)(?::\d+)?@(lid|hosted\.lid)$/i;
+function addEquivalentDirectChatCandidate(target, jid) {
+	addUniqueString(target, jid);
+	const pnMatch = jid?.match(DIRECT_PN_JID_RE);
+	if (pnMatch) {
+		addUniqueString(target, `${pnMatch[1]}@${pnMatch[2]}`);
+		return;
+	}
+	const lidMatch = jid?.match(DIRECT_LID_JID_RE);
+	if (lidMatch) addUniqueString(target, `${lidMatch[1]}@${lidMatch[2]}`);
+}
+async function resolveEquivalentWhatsAppDirectChatJids(jid, opts) {
+	const normalized = jid?.trim();
+	if (!normalized) return [];
+	const candidates = [];
+	addEquivalentDirectChatCandidate(candidates, normalized);
+	const pnMatch = normalized.match(DIRECT_PN_JID_RE);
+	if (pnMatch) {
+		addEquivalentDirectChatCandidate(candidates, await tryLookupMappedJid(() => opts?.lidLookup?.getLIDForPN?.(normalized)));
+		const mappedLocalLid = readLidForwardMapping({
+			phoneDigits: pnMatch[1],
+			opts
+		});
+		const localLidDomain = pnMatch[2].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 e164 = jidToE164(normalized, {
+			...opts,
+			logMissing: false
+		});
+		addUniqueString(candidates, e164 && lidMatch[2].toLowerCase() === "hosted.lid" ? `${e164.replace(/\D/g, "")}@hosted` : e164 ? toWhatsappJid(e164) : null);
+	}
+	return candidates;
+}
+function resolveLidMappingDirs(params) {
+	const dirs = /* @__PURE__ */ new Set();
+	const addDir = (dir) => {
+		if (!dir) return;
+		dirs.add(resolveUserPath$1(dir));
+	};
+	addDir(params.opts?.authDir);
+	for (const dir of params.opts?.lidMappingDirs ?? []) addDir(dir);
+	addDir(CONFIG_DIR);
+	addDir(path.join(CONFIG_DIR, "credentials"));
+	return [...dirs];
+}
+function readLidReverseMapping(params) {
+	const mappingFilename = `lid-mapping-${params.lid}_reverse.json`;
+	const mappingDirs = resolveLidMappingDirs({ opts: params.opts });
+	for (const dir of mappingDirs) {
+		const mappingPath = path.join(dir, mappingFilename);
+		try {
+			const data = fs.readFileSync(mappingPath, "utf8");
+			const phone = JSON.parse(data);
+			if (phone === null || phone === void 0) continue;
+			return normalizeE164(String(phone));
+		} catch {}
+	}
+	return null;
+}
+function readLidForwardMapping(params) {
+	const mappingFilename = `lid-mapping-${params.phoneDigits}.json`;
+	const mappingDirs = resolveLidMappingDirs({ opts: params.opts });
+	for (const dir of mappingDirs) {
+		const mappingPath = path.join(dir, mappingFilename);
+		try {
+			const data = fs.readFileSync(mappingPath, "utf8");
+			const lid = JSON.parse(data);
+			if (lid === null || lid === void 0) continue;
+			const digits = String(lid).replace(/\D/g, "");
+			if (digits) return digits;
+		} catch {}
+	}
+	return null;
+}
+function jidToE164(jid, opts) {
+	const match = jid.match(/^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted)$/);
+	if (match) return `+${match[1]}`;
+	const lidMatch = jid.match(/^(\d+)(?::\d+)?@(lid|hosted\.lid)$/);
+	if (!lidMatch) return null;
+	const phone = readLidReverseMapping({
+		lid: lidMatch[1],
+		opts
+	});
+	if (phone) return phone;
+	if (opts?.logMissing ?? shouldLogVerbose()) logVerbose(`LID mapping not found for ${lidMatch[1]}; skipping inbound message`);
+	return null;
+}
+async function resolveJidToE164(jid, opts) {
+	if (!jid) return null;
+	const direct = jidToE164(jid, opts);
+	if (direct) return direct;
+	if (!/(@lid|@hosted\.lid)$/.test(jid) || !opts?.lidLookup?.getPNForLID) return null;
+	try {
+		const pnJid = await opts.lidLookup.getPNForLID(jid);
+		if (!pnJid) return null;
+		return jidToE164(pnJid, opts);
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`LID mapping lookup failed for ${jid}: ${String(err)}`);
+		return null;
+	}
+}
+function markdownToWhatsApp(text) {
+	if (!text) return text;
+	const fences = [];
+	let result = text.replace(/```[\s\S]*?```/g, (match) => {
+		fences.push(match);
+		return `${WHATSAPP_FENCE_PLACEHOLDER}${fences.length - 1}${WHATSAPP_PLACEHOLDER_TERMINATOR}`;
+	});
+	const inlineCodes = [];
+	result = result.replace(/`[^`\n]+`/g, (match) => {
+		inlineCodes.push(match);
+		return `${WHATSAPP_INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}${WHATSAPP_PLACEHOLDER_TERMINATOR}`;
+	});
+	result = result.replace(/\*\*\*(.+?)\*\*\*/g, "*_$1_*");
+	result = result.replace(/___(.+?)___/g, "*_$1_*");
+	result = result.replace(/\*\*_(.+?)_\*\*/g, "*_$1_*");
+	result = result.replace(/__\*(.+?)\*__/g, "*_$1_*");
+	result = result.replace(/_\*\*(.+?)\*\*_/g, "*_$1_*");
+	result = result.replace(/\*__(.+?)__\*/g, "*_$1_*");
+	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
+	result = result.replace(/__(.+?)__/g, "*$1*");
+	result = result.replace(/~~(.+?)~~/g, "~$1~");
+	const terminator = escapeRegExp(WHATSAPP_PLACEHOLDER_TERMINATOR);
+	result = result.replace(new RegExp(`${escapeRegExp(WHATSAPP_INLINE_CODE_PLACEHOLDER)}(\\d+)${terminator}`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
+	result = result.replace(new RegExp(`${escapeRegExp(WHATSAPP_FENCE_PLACEHOLDER)}(\\d+)${terminator}`, "g"), (_, idx) => fences[Number(idx)] ?? "");
+	return result;
+}
+//#endregion
+export { resolveEquivalentWhatsAppDirectChatJids as a, toWhatsappJidWithLid as c, markdownToWhatsApp as i, isSelfChatMode as n, resolveJidToE164 as o, jidToE164 as r, toWhatsappJid as s, assertWebChannel as t };

package/dist/.setup/text-runtime-CUrq1mFq.mjs

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

package/dist/action-runtime-api.js

@@ -1,2 +1,2 @@
-import { t as handleWhatsAppAction } from "./action-runtime-BzfDFPbH.js";
+import { t as handleWhatsAppAction } from "./.setup/action-runtime-DLK_9v4r.mjs";
 export { handleWhatsAppAction };

package/dist/action-runtime.runtime.js

@@ -1,2 +1,2 @@
-import { t as handleWhatsAppAction } from "./action-runtime-BzfDFPbH.js";
+import { t as handleWhatsAppAction } from "./.setup/action-runtime-DLK_9v4r.mjs";
 export { handleWhatsAppAction };