@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.33

package/README.md

@@ -5,7 +5,7 @@ Official OpenClaw channel plugin for WhatsApp Web chats.
 Install from OpenClaw:
 
 ```bash
-openclaw plugins install @openclaw/whatsapp
+openclaw plugin add @openclaw/whatsapp
 ```
 
 Link a WhatsApp account through the plugin's setup flow, then configure which chats OpenClaw agents should monitor and reply to.

package/dist/.setup/access-control-C0jumQuO.mjs

@@ -0,0 +1,364 @@
+import { a as resolveWhatsAppAccount } from "./accounts-Dw16pdNl.mjs";
+import { n as isSelfChatMode } from "./targets-runtime-C-GiVn6Y.mjs";
+import { n as normalizeE164 } from "./text-runtime-CUrq1mFq.mjs";
+import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-CDB1bT-p.mjs";
+import { defaultRuntime } from "openclaw/plugin-sdk/runtime-env";
+import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
+import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
+import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveDefaultGroupPolicy, resolveOpenProviderRuntimeGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { resolveGroupSessionKey } from "openclaw/plugin-sdk/session-store-runtime";
+//#region extensions/whatsapp/src/inbound/group-conversation.ts
+function resolveWhatsAppGroupConversationId(conversationId) {
+	return resolveGroupSessionKey({
+		From: conversationId,
+		ChatType: "group",
+		Provider: "whatsapp"
+	})?.id ?? conversationId;
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/admission.ts
+function copyAccount(account) {
+	const copied = {
+		accountId: account.accountId,
+		enabled: account.enabled,
+		sendReadReceipts: account.sendReadReceipts
+	};
+	if (account.name) copied.name = account.name;
+	if (typeof account.selfChatMode === "boolean") copied.selfChatMode = account.selfChatMode;
+	if (account.replyToMode) copied.replyToMode = account.replyToMode;
+	return copied;
+}
+function buildWhatsAppInboundAdmission(params) {
+	return {
+		accountId: params.policy.account.accountId,
+		isSelfChat: params.policy.isSelfChat,
+		account: copyAccount(params.policy.account),
+		conversation: {
+			kind: params.isGroup ? "group" : "direct",
+			id: params.conversationId,
+			groupSessionId: resolveWhatsAppGroupConversationId(params.conversationId)
+		},
+		sender: {
+			id: params.senderId,
+			isSamePhone: params.policy.isSamePhone(params.senderId)
+		},
+		ingress: {
+			admission: params.access.ingress.admission,
+			decision: params.access.ingress.decision,
+			decisiveGateId: params.access.ingress.decisiveGateId,
+			reasonCode: params.access.ingress.reasonCode
+		},
+		senderAccess: {
+			allowed: params.access.senderAccess.allowed,
+			decision: params.access.senderAccess.decision,
+			reasonCode: params.access.senderAccess.reasonCode,
+			providerMissingFallbackApplied: params.access.senderAccess.providerMissingFallbackApplied
+		},
+		commandAccess: {
+			requested: params.access.commandAccess.requested,
+			authorized: params.access.commandAccess.authorized,
+			shouldBlockControlCommand: params.access.commandAccess.shouldBlockControlCommand,
+			reasonCode: params.access.commandAccess.reasonCode
+		},
+		activationAccess: {
+			ran: params.access.activationAccess.ran,
+			allowed: params.access.activationAccess.allowed,
+			shouldSkip: params.access.activationAccess.shouldSkip,
+			reasonCode: params.access.activationAccess.reasonCode
+		}
+	};
+}
+function buildDeprecatedFlatWhatsAppInboundAdmission(msg) {
+	const conversationId = msg.conversationId || msg.from;
+	if (!conversationId || !msg.accountId || !msg.chatType) throw new Error("WhatsApp legacy flat inbound messages must include deprecated top-level admission fields.");
+	const accountId = msg.accountId;
+	const admitted = msg.accessControlPassed !== false;
+	const platformSender = msg.platform?.sender;
+	const senderE164 = platformSender?.e164 ?? msg.platform?.senderE164 ?? msg.senderE164;
+	const senderJid = platformSender?.jid ?? msg.platform?.senderJid ?? msg.senderJid;
+	const senderName = platformSender?.name ?? msg.platform?.senderName ?? msg.senderName;
+	const senderId = msg.chatType === "group" ? senderE164 ?? senderJid ?? senderName ?? conversationId : senderE164 ?? conversationId;
+	const reasonCode = admitted ? msg.chatType === "group" ? "group_policy_allowed" : "dm_policy_allowlisted" : "no_policy_match";
+	return buildWhatsAppInboundAdmission({
+		policy: {
+			account: {
+				accountId,
+				enabled: true,
+				sendReadReceipts: true
+			},
+			isSelfChat: false,
+			isSamePhone: () => false
+		},
+		access: {
+			ingress: {
+				admission: admitted ? "dispatch" : "drop",
+				decision: admitted ? "allow" : "block",
+				decisiveGateId: "legacy-flat-compat",
+				reasonCode
+			},
+			senderAccess: {
+				allowed: admitted,
+				decision: admitted ? "allow" : "block",
+				reasonCode,
+				providerMissingFallbackApplied: false
+			},
+			commandAccess: {
+				requested: false,
+				authorized: false,
+				shouldBlockControlCommand: false,
+				reasonCode: "command_authorized"
+			},
+			activationAccess: {
+				ran: false,
+				allowed: admitted,
+				shouldSkip: !admitted,
+				reasonCode: admitted ? "activation_allowed" : "activation_skipped"
+			}
+		},
+		isGroup: msg.chatType === "group",
+		conversationId,
+		senderId
+	});
+}
+function requireWhatsAppInboundAdmission(params) {
+	if (!params.admission) throw new Error("WhatsApp inbound message is missing admission facts");
+	return params.admission;
+}
+function requireAdmittedWhatsAppInboundMessage(msg) {
+	requireWhatsAppInboundAdmission(msg);
+	return msg;
+}
+//#endregion
+//#region extensions/whatsapp/src/runtime-group-policy.ts
+function resolveWhatsAppRuntimeGroupPolicy(params) {
+	return resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound-policy.ts
+function normalizeWhatsAppIngressPhone(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	return normalizeE164(trimmed);
+}
+function maybeSamePhoneDmAllowFrom(params) {
+	if (params.isGroup || !params.dmSenderId || !params.policy.isSamePhone(params.dmSenderId)) return [];
+	return [params.dmSenderId];
+}
+function buildResolvedWhatsAppGroupConfig(params) {
+	return { channels: { whatsapp: {
+		groupPolicy: params.groupPolicy,
+		groups: params.groups
+	} } };
+}
+function resolveWhatsAppInboundPolicy(params) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const configuredAllowFrom = account.allowFrom ?? [];
+	const dmPolicy = account.dmPolicy ?? "pairing";
+	const dmAllowFrom = configuredAllowFrom.length > 0 ? configuredAllowFrom : params.selfE164 ? [params.selfE164] : [];
+	const groupAllowFrom = (Array.isArray(account.groupAllowFrom) && account.groupAllowFrom.length > 0 ? account.groupAllowFrom : void 0) ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0) ?? [];
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveWhatsAppRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.whatsapp !== void 0,
+		groupPolicy: account.groupPolicy,
+		defaultGroupPolicy
+	});
+	const resolvedGroupCfg = buildResolvedWhatsAppGroupConfig({
+		groupPolicy,
+		groups: account.groups
+	});
+	const isSamePhone = (value) => typeof value === "string" && typeof params.selfE164 === "string" && value === params.selfE164;
+	return {
+		account,
+		dmPolicy,
+		groupPolicy,
+		configuredAllowFrom,
+		dmAllowFrom,
+		groupAllowFrom,
+		isSelfChat: account.selfChatMode ?? isSelfChatMode(params.selfE164, configuredAllowFrom),
+		providerMissingFallbackApplied,
+		isSamePhone,
+		resolveConversationGroupPolicy: (conversationId) => resolveChannelGroupPolicy({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveWhatsAppGroupConversationId(conversationId),
+			hasGroupAllowFrom: groupAllowFrom.length > 0
+		}),
+		resolveConversationRequireMention: (conversationId) => resolveChannelGroupRequireMention({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveWhatsAppGroupConversationId(conversationId)
+		})
+	};
+}
+async function resolveWhatsAppIngressAccess(params) {
+	const samePhoneDmAllowFrom = maybeSamePhoneDmAllowFrom({
+		isGroup: params.isGroup,
+		policy: params.policy,
+		dmSenderId: params.dmSenderId
+	});
+	const dmAllowFrom = [...params.policy.dmAllowFrom, ...samePhoneDmAllowFrom];
+	return await resolveStableChannelMessageIngress({
+		channelId: "whatsapp",
+		accountId: params.policy.account.accountId,
+		identity: {
+			key: "whatsapp-sender-phone",
+			kind: "phone",
+			normalize: normalizeWhatsAppIngressPhone,
+			sensitivity: "pii",
+			entryIdPrefix: "whatsapp-entry"
+		},
+		cfg: params.cfg,
+		useDefaultPairingStore: true,
+		subject: { stableId: params.senderId ?? "" },
+		conversation: {
+			kind: params.isGroup ? "group" : "direct",
+			id: params.conversationId
+		},
+		dmPolicy: params.policy.dmPolicy,
+		groupPolicy: params.policy.groupPolicy,
+		policy: { groupAllowFromFallbackToAllowFrom: false },
+		providerMissingFallbackApplied: params.policy.providerMissingFallbackApplied,
+		allowFrom: dmAllowFrom,
+		groupAllowFrom: params.policy.groupAllowFrom,
+		command: params.includeCommand === true ? {} : void 0
+	});
+}
+async function resolveWhatsAppCommandAuthorized(params) {
+	if (!(params.cfg.commands?.useAccessGroups !== false)) return true;
+	const self = getSelfIdentity(params.msg, params.authDir);
+	const admission = requireWhatsAppInboundAdmission(params.msg);
+	const policy = params.policy ?? resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: admission.accountId,
+		selfE164: self.e164 ?? null
+	});
+	const isGroup = admission.conversation.kind === "group";
+	const sender = getSenderIdentity(params.msg, params.authDir);
+	const dmSender = sender.e164 ?? admission.conversation.id;
+	const groupSender = sender.e164 ?? "";
+	if (!normalizeE164(isGroup ? groupSender : dmSender)) return false;
+	return (await resolveWhatsAppIngressAccess({
+		cfg: params.cfg,
+		policy,
+		isGroup,
+		conversationId: admission.conversation.id,
+		senderId: isGroup ? groupSender : dmSender,
+		dmSenderId: dmSender,
+		includeCommand: true
+	})).commandAccess.authorized;
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/access-control.ts
+const PAIRING_REPLY_HISTORY_GRACE_MS = 3e4;
+function logWhatsAppVerbose(enabled, message) {
+	if (!enabled) return;
+	defaultRuntime.log(message);
+}
+function blockedInboundAccess(policy) {
+	return {
+		allowed: false,
+		shouldMarkRead: false,
+		isSelfChat: policy.isSelfChat,
+		resolvedAccountId: policy.account.accountId
+	};
+}
+async function checkInboundAccessControl(params) {
+	const policy = resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		selfE164: params.selfE164
+	});
+	const pairingGraceMs = typeof params.pairingGraceMs === "number" && params.pairingGraceMs > 0 ? params.pairingGraceMs : PAIRING_REPLY_HISTORY_GRACE_MS;
+	const suppressPairingReply = typeof params.connectedAtMs === "number" && typeof params.messageTimestampMs === "number" && params.messageTimestampMs < params.connectedAtMs - pairingGraceMs;
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied: policy.providerMissingFallbackApplied,
+		providerKey: "whatsapp",
+		accountId: policy.account.accountId,
+		log: (message) => logWhatsAppVerbose(params.verbose, message)
+	});
+	const conversationId = params.group ? params.remoteJid : params.from;
+	const accessSenderId = params.group ? params.senderE164 : params.from;
+	const admissionSenderId = params.group ? params.senderE164 ?? params.senderJid ?? params.from : params.from;
+	const access = await resolveWhatsAppIngressAccess({
+		cfg: params.cfg,
+		policy,
+		isGroup: params.group,
+		conversationId,
+		senderId: accessSenderId,
+		dmSenderId: params.from
+	});
+	const { senderAccess } = access;
+	if (params.group && senderAccess.decision !== "allow") {
+		if (senderAccess.reasonCode === "group_policy_disabled") logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: disabled)");
+		else if (senderAccess.reasonCode === "group_policy_empty_allowlist") logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: allowlist, no groupAllowFrom)");
+		else logWhatsAppVerbose(params.verbose, `Blocked group message from ${params.senderE164 ?? "unknown sender"} (groupPolicy: allowlist)`);
+		return blockedInboundAccess(policy);
+	}
+	if (!params.group) {
+		if (params.isFromMe && !policy.isSamePhone(params.from)) {
+			logWhatsAppVerbose(params.verbose, "Skipping outbound DM (fromMe); no pairing reply needed.");
+			return blockedInboundAccess(policy);
+		}
+		if (senderAccess.decision === "block" && senderAccess.reasonCode === "dm_policy_disabled") {
+			logWhatsAppVerbose(params.verbose, "Blocked dm (dmPolicy: disabled)");
+			return blockedInboundAccess(policy);
+		}
+		if (senderAccess.decision === "pairing" && !policy.isSamePhone(params.from)) {
+			const candidate = params.from;
+			if (suppressPairingReply) logWhatsAppVerbose(params.verbose, `Skipping pairing reply for historical DM from ${candidate}.`);
+			else await createChannelPairingChallengeIssuer({
+				channel: "whatsapp",
+				accountId: policy.account.accountId,
+				upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+					channel: "whatsapp",
+					id,
+					accountId: policy.account.accountId,
+					meta
+				})
+			})({
+				senderId: candidate,
+				senderIdLine: `Your WhatsApp phone number: ${candidate}`,
+				meta: { name: (params.pushName ?? "").trim() || void 0 },
+				onCreated: () => {
+					logWhatsAppVerbose(params.verbose, `whatsapp pairing request sender=${candidate} name=${params.pushName ?? "unknown"}`);
+				},
+				sendPairingReply: async (text) => {
+					await params.sock.sendMessage(params.remoteJid, { text });
+				},
+				onReplyError: (err) => {
+					logWhatsAppVerbose(params.verbose, `whatsapp pairing reply failed for ${candidate}: ${String(err)}`);
+				}
+			});
+			return blockedInboundAccess(policy);
+		}
+		if (senderAccess.decision !== "allow") {
+			logWhatsAppVerbose(params.verbose, `Blocked unauthorized sender ${params.from} (dmPolicy=${policy.dmPolicy})`);
+			return blockedInboundAccess(policy);
+		}
+	}
+	return {
+		allowed: true,
+		shouldMarkRead: true,
+		isSelfChat: policy.isSelfChat,
+		resolvedAccountId: policy.account.accountId,
+		admission: buildWhatsAppInboundAdmission({
+			policy,
+			access,
+			isGroup: params.group,
+			conversationId,
+			senderId: admissionSenderId
+		})
+	};
+}
+const testing = { resolveWhatsAppInboundPolicy };
+//#endregion
+export { resolveWhatsAppRuntimeGroupPolicy as a, requireWhatsAppInboundAdmission as c, resolveWhatsAppInboundPolicy as i, resolveWhatsAppGroupConversationId as l, testing as n, buildDeprecatedFlatWhatsAppInboundAdmission as o, resolveWhatsAppCommandAuthorized as r, requireAdmittedWhatsAppInboundMessage as s, checkInboundAccessControl as t };

package/dist/.setup/account-config-6PTOSfaI.mjs

@@ -0,0 +1,47 @@
+import { DEFAULT_ACCOUNT_ID, mergeAccountConfig, resolveAccountEntry, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
+import { resolveChannelStreamingBlockEnabled, resolveChannelStreamingChunkMode } from "openclaw/plugin-sdk/channel-outbound";
+//#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"]
+	});
+	const merged = accountId === DEFAULT_ACCOUNT_ID ? base : resolveMergedNamedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		...merged,
+		chunkMode: resolveChannelStreamingChunkMode(merged) ?? merged.chunkMode,
+		blockStreaming: resolveChannelStreamingBlockEnabled(merged) ?? merged.blockStreaming
+	};
+}
+//#endregion
+export { resolveMergedWhatsAppAccountConfig as t };

package/dist/.setup/accounts-Dw16pdNl.mjs

@@ -0,0 +1,114 @@
+import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-6PTOSfaI.mjs";
+import { n as listConfiguredAccountIds, r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.mjs";
+import { n as hasWebCredsRegularFileSync, r as hasWebCredsSync } from "./creds-files-B1kSWtBg.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, resolveUserPath } from "openclaw/plugin-sdk/account-core";
+import { resolveOAuthDir } from "openclaw/plugin-sdk/state-paths";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/whatsapp/src/accounts.ts
+const DEFAULT_WHATSAPP_MEDIA_MAX_MB = 50;
+function listWhatsAppAuthDirs(cfg) {
+	const oauthDir = resolveOAuthDir();
+	const whatsappDir = path.join(oauthDir, "whatsapp");
+	const authDirs = /* @__PURE__ */ new Set([oauthDir, path.join(whatsappDir, DEFAULT_ACCOUNT_ID)]);
+	const accountIds = listConfiguredAccountIds(cfg);
+	for (const accountId of accountIds) authDirs.add(resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	}).authDir);
+	try {
+		const entries = fs.readdirSync(whatsappDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			authDirs.add(path.join(whatsappDir, entry.name));
+		}
+	} catch {}
+	return Array.from(authDirs);
+}
+function hasAnyWhatsAppAuth(cfg) {
+	return listWhatsAppAuthDirs(cfg).some((authDir) => hasWebCredsSync(authDir));
+}
+function resolveDefaultAuthDir(accountId) {
+	return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
+}
+function resolveLegacyAuthDir() {
+	return resolveOAuthDir();
+}
+function legacyAuthExists(authDir) {
+	return hasWebCredsRegularFileSync(authDir);
+}
+function resolveWhatsAppAuthDir(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	const configured = resolveMergedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId
+	})?.authDir?.trim();
+	if (configured) return {
+		authDir: resolveUserPath(configured),
+		isLegacy: false
+	};
+	const defaultDir = resolveDefaultAuthDir(accountId);
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const legacyDir = resolveLegacyAuthDir();
+		if (legacyAuthExists(legacyDir) && !legacyAuthExists(defaultDir)) return {
+			authDir: legacyDir,
+			isLegacy: true
+		};
+	}
+	return {
+		authDir: defaultDir,
+		isLegacy: false
+	};
+}
+function resolveWhatsAppAccount(params) {
+	const merged = resolveMergedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId?.trim() || resolveDefaultWhatsAppAccountId(params.cfg)
+	});
+	const accountId = merged.accountId;
+	const enabled = merged.enabled !== false;
+	const { authDir, isLegacy } = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		name: normalizeOptionalString(merged.name),
+		enabled,
+		sendReadReceipts: merged.sendReadReceipts ?? true,
+		messagePrefix: merged.messagePrefix ?? params.cfg.messages?.messagePrefix,
+		defaultTo: merged.defaultTo,
+		authDir,
+		isLegacyAuthDir: isLegacy,
+		selfChatMode: merged.selfChatMode,
+		dmPolicy: merged.dmPolicy,
+		allowFrom: merged.allowFrom,
+		groupAllowFrom: merged.groupAllowFrom,
+		groupPolicy: merged.groupPolicy,
+		mentionPatterns: merged.mentionPatterns,
+		historyLimit: merged.historyLimit,
+		textChunkLimit: merged.textChunkLimit,
+		chunkMode: merged.chunkMode,
+		mediaMaxMb: merged.mediaMaxMb,
+		blockStreaming: merged.blockStreaming,
+		ackReaction: merged.ackReaction,
+		reactionLevel: merged.reactionLevel,
+		groups: merged.groups,
+		direct: merged.direct,
+		debounceMs: merged.debounceMs,
+		replyToMode: merged.replyToMode
+	};
+}
+function resolveWhatsAppMediaMaxBytes(account) {
+	const mediaMaxMb = typeof account.mediaMaxMb === "number" && account.mediaMaxMb > 0 ? account.mediaMaxMb : 50;
+	return Math.floor(mediaMaxMb * 1024 * 1024);
+}
+function listEnabledWhatsAppAccounts(cfg) {
+	return listAccountIds(cfg).map((accountId) => resolveWhatsAppAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resolveWhatsAppAccount as a, listWhatsAppAuthDirs as i, hasAnyWhatsAppAuth as n, resolveWhatsAppAuthDir as o, listEnabledWhatsAppAccounts as r, resolveWhatsAppMediaMaxBytes as s, DEFAULT_WHATSAPP_MEDIA_MAX_MB as t };

package/dist/.setup/action-runtime-DLK_9v4r.mjs

@@ -0,0 +1,73 @@
+import { a as resolveWhatsAppAccount } from "./accounts-Dw16pdNl.mjs";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-oI7VpU4w.mjs";
+import { g as resolveWhatsAppReactionLevel, r as sendReactionWhatsApp } from "./send-BQjMC41n.mjs";
+import { ToolAuthorizationError, createActionGate, jsonResult, readReactionParams, readStringParam } from "openclaw/plugin-sdk/channel-actions";
+//#region extensions/whatsapp/src/action-runtime-target-auth.ts
+function resolveAuthorizedWhatsAppOutboundTarget(params) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const resolution = resolveWhatsAppOutboundTarget({
+		to: params.chatJid,
+		allowFrom: account.allowFrom ?? [],
+		mode: "implicit"
+	});
+	if (!resolution.ok) throw new ToolAuthorizationError(`WhatsApp ${params.actionLabel} blocked: chatJid "${params.chatJid}" is not in the configured allowFrom list for account "${account.accountId}".`);
+	return {
+		to: resolution.to,
+		accountId: account.accountId
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/action-runtime.ts
+const whatsAppActionRuntime = {
+	resolveAuthorizedWhatsAppOutboundTarget,
+	sendReactionWhatsApp
+};
+async function handleWhatsAppAction(params, cfg) {
+	const action = readStringParam(params, "action", { required: true });
+	const whatsAppConfig = cfg.channels?.whatsapp;
+	const isActionEnabled = createActionGate(whatsAppConfig?.actions);
+	if (action === "react") {
+		const accountId = readStringParam(params, "accountId");
+		if (!whatsAppConfig) throw new Error("WhatsApp reactions are disabled.");
+		if (!isActionEnabled("reactions")) throw new Error("WhatsApp reactions are disabled.");
+		const reactionLevelInfo = resolveWhatsAppReactionLevel({
+			cfg,
+			accountId: accountId ?? void 0
+		});
+		if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`WhatsApp agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.whatsapp.reactionLevel to "minimal" or "extensive" to enable.`);
+		const chatJid = readStringParam(params, "chatJid", { required: true });
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a WhatsApp reaction." });
+		const participant = readStringParam(params, "participant");
+		const fromMeRaw = params.fromMe;
+		const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : void 0;
+		const resolved = whatsAppActionRuntime.resolveAuthorizedWhatsAppOutboundTarget({
+			cfg,
+			chatJid,
+			accountId,
+			actionLabel: "reaction"
+		});
+		const resolvedEmoji = remove ? "" : emoji;
+		await whatsAppActionRuntime.sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
+			verbose: false,
+			fromMe,
+			participant: participant ?? void 0,
+			accountId: resolved.accountId,
+			cfg
+		});
+		if (!remove && !isEmpty) return jsonResult({
+			ok: true,
+			added: emoji
+		});
+		return jsonResult({
+			ok: true,
+			removed: true
+		});
+	}
+	throw new Error(`Unsupported WhatsApp action: ${action}`);
+}
+//#endregion
+export { whatsAppActionRuntime as n, resolveAuthorizedWhatsAppOutboundTarget as r, handleWhatsAppAction as t };

package/dist/.setup/active-listener-CloPBx0S.mjs

@@ -0,0 +1,11 @@
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.mjs";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.mjs";
+//#region extensions/whatsapp/src/active-listener.ts
+function resolveWebAccountId(params) {
+	return (params.accountId ?? "").trim() || resolveDefaultWhatsAppAccountId(params.cfg);
+}
+function getActiveWebListener(accountId) {
+	return getRegisteredWhatsAppConnectionController(accountId)?.getActiveListener() ?? null;
+}
+//#endregion
+export { resolveWebAccountId as n, getActiveWebListener as t };