@openclaw/whatsapp 2026.5.2-beta.2 → 2026.5.3-beta.1

package/dist/channel-DQ-5Xoj9.js

@@ -0,0 +1,542 @@
+import { t as listAccountIds } from "./account-ids-DG18xddX.js";
+import { a as resolveWhatsAppAccount } from "./accounts-BDqgpFEB.js";
+import { i as looksLikeWhatsAppTargetId, n as isWhatsAppNewsletterJid, o as normalizeWhatsAppMessagingTarget, s as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BPVHNsM5.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CN-Wo6IY.js";
+import { t as resolveWhatsAppReactionLevel } from "./reaction-level-CRVEVAfi.js";
+import "./normalize-CWYiGkXw.js";
+import { r as normalizeWhatsAppPayloadTextPreservingIndentation } from "./outbound-media-contract-CGss_QHy.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, t as sendMessageWhatsApp } from "./send-CIyLFxdZ.js";
+import { t as createWhatsAppLoginTool } from "./agent-tools-login-DpRxLNRB.js";
+import { t as createWhatsAppOutboundBase } from "./outbound-base-Bq1UYEK5.js";
+import { t as getWhatsAppRuntime } from "./runtime-6fZ67abR.js";
+import { t as whatsappCommandPolicy } from "./command-policy-O8sRnqUV.js";
+import { a as resolveWhatsAppGroupToolPolicy, c as formatWhatsAppConfigAllowFromEntries, i as resolveWhatsAppGroupRequireMention, n as loadWhatsAppChannelRuntime, o as resolveWhatsAppGroupIntroHint, r as whatsappSetupWizardProxy, s as resolveWhatsAppMentionStripRegexes, t as createWhatsAppPluginBase } from "./shared-D_wzSVar.js";
+import { d as readWebAuthExistsForDecision, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-BjCb50Ry.js";
+import { t as whatsappSetupAdapter } from "./setup-core-DZKvpzbH.js";
+import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-DnCdvoYD.js";
+import { createActionGate as createActionGate$1 } from "openclaw/plugin-sdk/channel-actions";
+import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
+import { buildChannelOutboundSessionRoute } from "openclaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { asString, collectIssuesForEnabledAccounts, createAsyncComputedAccountStatusAdapter, createDefaultChannelRuntimeState, isRecord } from "openclaw/plugin-sdk/status-helpers";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { chunkText } from "openclaw/plugin-sdk/reply-chunking";
+//#region extensions/whatsapp/src/approval-auth.ts
+function normalizeWhatsAppApproverId(value) {
+	const normalized = normalizeWhatsAppTarget(String(value));
+	if (!normalized || normalized.endsWith("@g.us")) return;
+	return normalized;
+}
+const whatsappApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "WhatsApp",
+	resolveApprovers: ({ cfg, accountId }) => {
+		const account = resolveWhatsAppAccount({
+			cfg,
+			accountId
+		});
+		return resolveApprovalApprovers({
+			allowFrom: account.allowFrom,
+			defaultTo: account.defaultTo,
+			normalizeApprover: normalizeWhatsAppApproverId
+		});
+	},
+	normalizeSenderId: (value) => normalizeWhatsAppApproverId(value)
+});
+//#endregion
+//#region extensions/whatsapp/src/channel-actions.ts
+function areWhatsAppAgentReactionsEnabled(params) {
+	if (!params.cfg.channels?.whatsapp) return false;
+	if (!createActionGate$1(params.cfg.channels.whatsapp.actions)("reactions")) return false;
+	return resolveWhatsAppReactionLevel({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).agentReactionsEnabled;
+}
+function hasAnyWhatsAppAccountWithAgentReactionsEnabled(cfg) {
+	if (!cfg.channels?.whatsapp) return false;
+	return listAccountIds(cfg).some((accountId) => {
+		if (!resolveWhatsAppAccount({
+			cfg,
+			accountId
+		}).enabled) return false;
+		return areWhatsAppAgentReactionsEnabled({
+			cfg,
+			accountId
+		});
+	});
+}
+function resolveWhatsAppAgentReactionGuidance(params) {
+	if (!params.cfg.channels?.whatsapp) return;
+	if (!createActionGate$1(params.cfg.channels.whatsapp.actions)("reactions")) return;
+	const resolved = resolveWhatsAppReactionLevel({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!resolved.agentReactionsEnabled) return;
+	return resolved.agentReactionGuidance;
+}
+function describeWhatsAppMessageActions(params) {
+	if (!params.cfg.channels?.whatsapp) return null;
+	const gate = createActionGate$1(params.cfg.channels.whatsapp.actions);
+	const actions = /* @__PURE__ */ new Set();
+	if (params.accountId != null ? areWhatsAppAgentReactionsEnabled({
+		cfg: params.cfg,
+		accountId: params.accountId ?? void 0
+	}) : hasAnyWhatsAppAccountWithAgentReactionsEnabled(params.cfg)) actions.add("react");
+	if (gate("polls")) actions.add("poll");
+	return { actions: Array.from(actions) };
+}
+//#endregion
+//#region extensions/whatsapp/src/channel-outbound.ts
+function normalizeWhatsAppChannelPayloadText(text) {
+	return normalizeWhatsAppPayloadTextPreservingIndentation(text);
+}
+function normalizeWhatsAppChannelSendText(text) {
+	const normalized = normalizeWhatsAppChannelPayloadText(text);
+	return normalized.trim() ? normalized : "";
+}
+const whatsappChannelOutbound = {
+	...createWhatsAppOutboundBase({
+		chunker: chunkText,
+		sendMessageWhatsApp: async (to, text, options) => await sendMessageWhatsApp(to, text, {
+			...options,
+			preserveLeadingWhitespace: true
+		}),
+		sendPollWhatsApp,
+		shouldLogVerbose: () => getWhatsAppRuntime().logging.shouldLogVerbose(),
+		resolveTarget: ({ to, allowFrom, mode }) => resolveWhatsAppOutboundTarget({
+			to,
+			allowFrom,
+			mode
+		}),
+		normalizeText: normalizeWhatsAppChannelSendText
+	}),
+	sendTextOnlyErrorPayloads: true,
+	normalizePayload: ({ payload }) => ({
+		...payload,
+		text: normalizeWhatsAppChannelPayloadText(payload.text)
+	})
+};
+//#endregion
+//#region extensions/whatsapp/src/heartbeat.ts
+async function checkWhatsAppHeartbeatReady(params) {
+	if (params.cfg.web?.enabled === false) return {
+		ok: false,
+		reason: "whatsapp-disabled"
+	};
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const authState = await (params.deps?.readWebAuthExistsForDecision ?? readWebAuthExistsForDecision)(account.authDir);
+	if (authState.outcome === "unstable") return {
+		ok: false,
+		reason: WHATSAPP_AUTH_UNSTABLE_CODE
+	};
+	if (!authState.exists) return {
+		ok: false,
+		reason: "whatsapp-not-linked"
+	};
+	if (!(params.deps?.hasActiveWebListener ? params.deps.hasActiveWebListener(account.accountId) : Boolean((await loadWhatsAppChannelRuntime()).getActiveWebListener(account.accountId)))) return {
+		ok: false,
+		reason: "whatsapp-not-running"
+	};
+	return {
+		ok: true,
+		reason: "ok"
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/session-route.ts
+function resolveWhatsAppOutboundSessionRoute(params) {
+	const normalized = normalizeWhatsAppTarget(params.target);
+	if (!normalized) return null;
+	const isGroup = isWhatsAppGroupJid(normalized);
+	const isNewsletter = isWhatsAppNewsletterJid(normalized);
+	const chatType = isGroup ? "group" : isNewsletter ? "channel" : "direct";
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "whatsapp",
+		accountId: params.accountId,
+		peer: {
+			kind: chatType,
+			id: normalized
+		},
+		chatType,
+		from: normalized,
+		to: normalized
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/status-issues.ts
+const RECENT_DISCONNECT_WARNING_WINDOW_MS = 900 * 1e3;
+function readWhatsAppAccountStatus(value) {
+	if (!isRecord(value)) return null;
+	return {
+		accountId: value.accountId,
+		statusState: value.statusState,
+		enabled: value.enabled,
+		linked: value.linked,
+		connected: value.connected,
+		running: value.running,
+		reconnectAttempts: value.reconnectAttempts,
+		lastDisconnect: value.lastDisconnect,
+		lastInboundAt: value.lastInboundAt,
+		lastError: value.lastError,
+		healthState: value.healthState
+	};
+}
+function readLastDisconnect(value) {
+	if (typeof value === "string") {
+		const error = asString(value);
+		return error ? {
+			at: null,
+			error
+		} : null;
+	}
+	if (!isRecord(value)) return null;
+	return {
+		at: typeof value.at === "number" ? value.at : null,
+		error: asString(value.error)
+	};
+}
+function isRecentDisconnect(disconnect, now = Date.now()) {
+	if (disconnect?.at == null) return false;
+	return now - disconnect.at <= RECENT_DISCONNECT_WARNING_WINDOW_MS;
+}
+function collectWhatsAppStatusIssues(accounts) {
+	return collectIssuesForEnabledAccounts({
+		accounts,
+		readAccount: readWhatsAppAccountStatus,
+		collectIssues: ({ account, accountId, issues }) => {
+			const linked = account.linked === true;
+			const statusState = asString(account.statusState);
+			const running = account.running === true;
+			const connected = account.connected === true;
+			const reconnectAttempts = typeof account.reconnectAttempts === "number" ? account.reconnectAttempts : null;
+			const lastInboundAt = typeof account.lastInboundAt === "number" ? account.lastInboundAt : null;
+			const lastDisconnect = readLastDisconnect(account.lastDisconnect);
+			const lastError = asString(account.lastError) ?? lastDisconnect?.error;
+			const healthState = asString(account.healthState);
+			if (statusState === "unstable") {
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "auth",
+					message: "Auth state is still stabilizing.",
+					fix: "Wait a moment for queued credential writes to finish, then retry the command or rerun health."
+				});
+				return;
+			}
+			if (!linked) {
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "auth",
+					message: "Not linked (no WhatsApp Web session).",
+					fix: `Run: ${formatCliCommand("openclaw channels login")} (scan QR on the gateway host).`
+				});
+				return;
+			}
+			if (healthState === "stale") {
+				const staleSuffix = lastInboundAt != null ? ` (last inbound ${Math.max(0, Math.floor((Date.now() - lastInboundAt) / 6e4))}m ago)` : "";
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "runtime",
+					message: `Linked but stale${staleSuffix}${lastError ? `: ${lastError}` : "."}`,
+					fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
+				});
+				return;
+			}
+			if (healthState === "reconnecting" || healthState === "conflict" || healthState === "stopped") {
+				const stateLabel = healthState === "conflict" ? "session conflict" : healthState === "reconnecting" ? "reconnecting" : "stopped";
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "runtime",
+					message: `Linked but ${stateLabel}${reconnectAttempts != null ? ` (reconnectAttempts=${reconnectAttempts})` : ""}${lastError ? `: ${lastError}` : "."}`,
+					fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
+				});
+				return;
+			}
+			if (healthState === "logged-out") {
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "auth",
+					message: `Linked session logged out${lastError ? `: ${lastError}` : "."}`,
+					fix: `Run: ${formatCliCommand("openclaw channels login")} (scan QR on the gateway host).`
+				});
+				return;
+			}
+			if (linked && running && connected && reconnectAttempts != null && reconnectAttempts > 0 && isRecentDisconnect(lastDisconnect)) {
+				issues.push({
+					channel: "whatsapp",
+					accountId,
+					kind: "runtime",
+					message: `Linked but recently reconnected (reconnectAttempts=${reconnectAttempts})${lastError ? `: ${lastError}` : "."}`,
+					fix: `Watch: ${formatCliCommand("openclaw logs --follow")} and run ${formatCliCommand("openclaw channels status --probe")} if disconnects continue. If it keeps flapping, restart the gateway or relink via channels login.`
+				});
+				return;
+			}
+			if (running && !connected) issues.push({
+				channel: "whatsapp",
+				accountId,
+				kind: "runtime",
+				message: `Linked but disconnected${reconnectAttempts != null ? ` (reconnectAttempts=${reconnectAttempts})` : ""}${lastError ? `: ${lastError}` : "."}`,
+				fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
+			});
+		}
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/channel.ts
+const loadWhatsAppDirectoryConfig = createLazyRuntimeModule(() => import("./directory-config-DVs4ffXu.js").then((n) => n.t));
+const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-Df20qAy9.js"));
+function parseWhatsAppExplicitTarget(raw) {
+	const normalized = normalizeWhatsAppTarget(raw);
+	if (!normalized) return null;
+	return {
+		to: normalized,
+		chatType: isWhatsAppGroupJid(normalized) ? "group" : isWhatsAppNewsletterJid(normalized) ? "channel" : "direct"
+	};
+}
+const whatsappPlugin = createChatChannelPlugin({
+	pairing: { idLabel: "whatsappSenderId" },
+	outbound: whatsappChannelOutbound,
+	threading: { scopedAccountReplyToMode: {
+		resolveAccount: (cfg, accountId) => resolveWhatsAppAccount({
+			cfg,
+			accountId
+		}),
+		resolveReplyToMode: (account) => account.replyToMode
+	} },
+	base: {
+		...createWhatsAppPluginBase({
+			groups: {
+				resolveRequireMention: resolveWhatsAppGroupRequireMention,
+				resolveToolPolicy: resolveWhatsAppGroupToolPolicy,
+				resolveGroupIntroHint: resolveWhatsAppGroupIntroHint
+			},
+			setupWizard: whatsappSetupWizardProxy,
+			setup: whatsappSetupAdapter,
+			isConfigured: async (account) => {
+				return await (await loadWhatsAppChannelRuntime()).readWebAuthState(account.authDir) === "linked";
+			}
+		}),
+		agentTools: () => [createWhatsAppLoginTool()],
+		allowlist: buildDmGroupAccountAllowlistAdapter({
+			channelId: "whatsapp",
+			resolveAccount: resolveWhatsAppAccount,
+			normalize: ({ values }) => formatWhatsAppConfigAllowFromEntries(values),
+			resolveDmAllowFrom: (account) => account.allowFrom,
+			resolveGroupAllowFrom: (account) => account.groupAllowFrom,
+			resolveDmPolicy: (account) => account.dmPolicy,
+			resolveGroupPolicy: (account) => account.groupPolicy
+		}),
+		mentions: { stripRegexes: ({ ctx }) => resolveWhatsAppMentionStripRegexes(ctx) },
+		commands: whatsappCommandPolicy,
+		agentPrompt: { reactionGuidance: ({ cfg, accountId }) => {
+			const level = resolveWhatsAppAgentReactionGuidance({
+				cfg,
+				accountId: accountId ?? void 0
+			});
+			return level ? {
+				level,
+				channelLabel: "WhatsApp"
+			} : void 0;
+		} },
+		messaging: {
+			targetPrefixes: ["whatsapp"],
+			normalizeTarget: normalizeWhatsAppMessagingTarget,
+			resolveOutboundSessionRoute: (params) => resolveWhatsAppOutboundSessionRoute(params),
+			parseExplicitTarget: ({ raw }) => parseWhatsAppExplicitTarget(raw),
+			inferTargetChatType: ({ to }) => parseWhatsAppExplicitTarget(to)?.chatType,
+			targetResolver: {
+				looksLikeId: looksLikeWhatsAppTargetId,
+				hint: "<E.164|group JID|newsletter JID>"
+			}
+		},
+		directory: {
+			self: async ({ cfg, accountId }) => {
+				const account = resolveWhatsAppAccount({
+					cfg,
+					accountId
+				});
+				const { e164, jid } = (await loadWhatsAppChannelRuntime()).readWebSelfId(account.authDir);
+				const id = e164 ?? jid;
+				if (!id) return null;
+				return {
+					kind: "user",
+					id,
+					name: account.name,
+					raw: {
+						e164,
+						jid
+					}
+				};
+			},
+			listPeers: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryPeersFromConfig(params),
+			listGroups: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryGroupsFromConfig(params)
+		},
+		actions: {
+			describeMessageTool: ({ cfg, accountId }) => describeWhatsAppMessageActions({
+				cfg,
+				accountId
+			}),
+			supportsAction: ({ action }) => action === "react",
+			resolveExecutionMode: ({ action }) => action === "react" ? "gateway" : "local",
+			handleAction: async ({ action, params, cfg, accountId, requesterSenderId, toolContext }) => await (await loadWhatsAppChannelReactAction()).handleWhatsAppReactAction({
+				action,
+				params,
+				cfg,
+				accountId,
+				requesterSenderId,
+				toolContext
+			})
+		},
+		approvalCapability: whatsappApprovalAuth,
+		auth: { login: async ({ cfg, accountId, runtime, verbose }) => {
+			const resolvedAccountId = accountId?.trim() || whatsappPlugin.config.defaultAccountId?.(cfg) || DEFAULT_ACCOUNT_ID;
+			await (await loadWhatsAppChannelRuntime()).loginWeb(Boolean(verbose), void 0, runtime, resolvedAccountId);
+		} },
+		lifecycle: { detectLegacyStateMigrations: ({ oauthDir }) => detectWhatsAppLegacyStateMigrations({ oauthDir }) },
+		heartbeat: {
+			checkReady: async ({ cfg, accountId, deps }) => await checkWhatsAppHeartbeatReady({
+				cfg,
+				accountId: accountId ?? void 0,
+				deps
+			}),
+			sendTyping: async ({ cfg, to, accountId }) => {
+				await sendTypingWhatsApp(to, {
+					cfg,
+					...accountId ? { accountId } : {}
+				});
+			}
+		},
+		status: createAsyncComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+				connected: false,
+				reconnectAttempts: 0,
+				lastConnectedAt: null,
+				lastDisconnect: null,
+				lastInboundAt: null,
+				lastMessageAt: null,
+				lastEventAt: null,
+				healthState: "stopped"
+			}),
+			collectStatusIssues: collectWhatsAppStatusIssues,
+			buildChannelSummary: async ({ account, snapshot }) => {
+				const channelRuntime = await loadWhatsAppChannelRuntime();
+				const authDir = account.authDir;
+				const auth = authDir ? await channelRuntime.readWebAuthSnapshot(authDir) : {
+					state: "not-linked",
+					authAgeMs: null,
+					selfId: {
+						e164: null,
+						jid: null,
+						lid: null
+					}
+				};
+				const linked = typeof snapshot.linked === "boolean" ? snapshot.linked : auth.state === "unstable" ? void 0 : auth.state === "linked";
+				const summaryAuthState = auth.state === "unstable" ? auth.state : linked === true ? "linked" : linked === false ? "not-linked" : void 0;
+				const statusState = summaryAuthState === void 0 ? void 0 : summaryAuthState;
+				const configured = auth.state === "unstable" ? typeof snapshot.configured === "boolean" ? snapshot.configured : true : typeof linked === "boolean" ? linked : auth.state === "linked";
+				const authAgeMs = typeof linked === "boolean" && linked ? auth.authAgeMs : null;
+				const self = typeof linked === "boolean" && linked ? auth.selfId : {
+					e164: null,
+					jid: null,
+					lid: null
+				};
+				return {
+					configured,
+					...statusState ? { statusState } : {},
+					...typeof linked === "boolean" ? { linked } : {},
+					authAgeMs,
+					self,
+					running: snapshot.running ?? false,
+					connected: snapshot.connected ?? false,
+					lastConnectedAt: snapshot.lastConnectedAt ?? null,
+					lastDisconnect: snapshot.lastDisconnect ?? null,
+					reconnectAttempts: snapshot.reconnectAttempts,
+					lastInboundAt: snapshot.lastInboundAt ?? snapshot.lastMessageAt ?? null,
+					lastMessageAt: snapshot.lastMessageAt ?? null,
+					lastEventAt: snapshot.lastEventAt ?? null,
+					lastError: snapshot.lastError ?? null,
+					healthState: snapshot.healthState ?? void 0
+				};
+			},
+			resolveAccountSnapshot: async ({ account, runtime }) => {
+				const authState = await (await loadWhatsAppChannelRuntime()).readWebAuthState(account.authDir);
+				return {
+					accountId: account.accountId,
+					name: account.name,
+					enabled: account.enabled,
+					configured: true,
+					extra: {
+						statusState: authState,
+						...authState === "linked" ? { linked: true } : authState === "not-linked" ? { linked: false } : {},
+						connected: runtime?.connected ?? false,
+						reconnectAttempts: runtime?.reconnectAttempts,
+						lastConnectedAt: runtime?.lastConnectedAt ?? null,
+						lastDisconnect: runtime?.lastDisconnect ?? null,
+						lastInboundAt: runtime?.lastInboundAt ?? runtime?.lastMessageAt ?? null,
+						lastMessageAt: runtime?.lastMessageAt ?? null,
+						lastEventAt: runtime?.lastEventAt ?? null,
+						healthState: runtime?.healthState ?? void 0,
+						dmPolicy: account.dmPolicy,
+						allowFrom: account.allowFrom
+					}
+				};
+			},
+			resolveAccountState: ({ configured }) => configured ? "linked" : "not linked",
+			logSelfId: ({ account, runtime, includeChannelPrefix }) => {
+				loadWhatsAppChannelRuntime().then((runtimeExports) => runtimeExports.logWebSelfId(account.authDir, runtime, includeChannelPrefix));
+			}
+		}),
+		gateway: {
+			startAccount: async (ctx) => {
+				const account = ctx.account;
+				const { e164, jid } = (await loadWhatsAppChannelRuntime()).readWebSelfId(account.authDir);
+				const identity = e164 ? e164 : jid ? `jid ${jid}` : "unknown";
+				ctx.log?.info(`[${account.accountId}] starting provider (${identity})`);
+				return (await loadWhatsAppChannelRuntime()).monitorWebChannel(getWhatsAppRuntime().logging.shouldLogVerbose(), void 0, true, void 0, ctx.runtime, ctx.abortSignal, {
+					statusSink: (next) => ctx.setStatus({
+						accountId: ctx.accountId,
+						...next
+					}),
+					accountId: account.accountId
+				});
+			},
+			loginWithQrStart: async ({ accountId, force, timeoutMs, verbose }) => await (await loadWhatsAppChannelRuntime()).startWebLoginWithQr({
+				accountId,
+				force,
+				timeoutMs,
+				verbose
+			}),
+			loginWithQrWait: async ({ accountId, timeoutMs, currentQrDataUrl }) => await (await loadWhatsAppChannelRuntime()).waitForWebLogin({
+				accountId,
+				timeoutMs,
+				currentQrDataUrl
+			}),
+			logoutAccount: async ({ account, runtime }) => {
+				const cleared = await (await loadWhatsAppChannelRuntime()).logoutWeb({
+					authDir: account.authDir,
+					isLegacyAuthDir: account.isLegacyAuthDir,
+					runtime
+				});
+				return {
+					cleared,
+					loggedOut: cleared
+				};
+			}
+		}
+	}
+});
+//#endregion
+export { whatsappPlugin as t };

package/dist/channel-config-api.js

@@ -0,0 +1,2 @@
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-Dmo66Ubb.js";
+export { WhatsAppChannelConfigSchema };

package/dist/channel-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as whatsappPlugin } from "./channel-DQ-5Xoj9.js";
+export { whatsappPlugin };

package/dist/channel-react-action-Df20qAy9.js

@@ -0,0 +1,42 @@
+import { s as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BPVHNsM5.js";
+import { t as handleWhatsAppAction } from "./action-runtime-DTGNgG-i.js";
+import "./normalize-CWYiGkXw.js";
+import { readStringOrNumberParam, readStringParam as readStringParam$1, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
+//#region extensions/whatsapp/src/channel-react-action.ts
+const WHATSAPP_CHANNEL = "whatsapp";
+async function handleWhatsAppReactAction(params) {
+	if (params.action !== "react") throw new Error(`Action ${params.action} is not supported for provider ${WHATSAPP_CHANNEL}.`);
+	const isWhatsAppSource = params.toolContext?.currentChannelProvider === WHATSAPP_CHANNEL;
+	const explicitTarget = readStringParam$1(params.params, "chatJid") ?? readStringParam$1(params.params, "to");
+	const normalizedTarget = explicitTarget ? normalizeWhatsAppTarget(explicitTarget) : null;
+	const normalizedCurrent = isWhatsAppSource && params.toolContext?.currentChannelId ? normalizeWhatsAppTarget(params.toolContext.currentChannelId) : null;
+	const isCrossChat = normalizedTarget != null && (normalizedCurrent == null || normalizedTarget !== normalizedCurrent);
+	const scopedContext = !isWhatsAppSource || isCrossChat || !params.toolContext ? void 0 : {
+		currentChannelId: params.toolContext.currentChannelId ?? void 0,
+		currentChannelProvider: params.toolContext.currentChannelProvider ?? void 0,
+		currentMessageId: params.toolContext.currentMessageId ?? void 0
+	};
+	const messageIdRaw = resolveReactionMessageId({
+		args: params.params,
+		toolContext: scopedContext
+	});
+	if (messageIdRaw == null) readStringParam$1(params.params, "messageId", { required: true });
+	const messageId = String(messageIdRaw);
+	const explicitMessageId = readStringOrNumberParam(params.params, "messageId");
+	const emoji = readStringParam$1(params.params, "emoji", { allowEmpty: true });
+	const remove = typeof params.params.remove === "boolean" ? params.params.remove : void 0;
+	const explicitParticipant = readStringParam$1(params.params, "participant");
+	const inferredParticipant = explicitParticipant || explicitMessageId != null || !isWhatsAppSource || isCrossChat || !isWhatsAppGroupJid(explicitTarget ?? params.toolContext?.currentChannelId ?? "") ? void 0 : typeof params.requesterSenderId === "string" && params.requesterSenderId.trim().length > 0 ? params.requesterSenderId.trim() : void 0;
+	return await handleWhatsAppAction({
+		action: "react",
+		chatJid: readStringParam$1(params.params, "chatJid") ?? readStringParam$1(params.params, "to", { required: true }),
+		messageId,
+		emoji,
+		remove,
+		participant: explicitParticipant ?? inferredParticipant,
+		accountId: params.accountId ?? void 0,
+		fromMe: typeof params.params.fromMe === "boolean" ? params.params.fromMe : void 0
+	}, params.cfg);
+}
+//#endregion
+export { handleWhatsAppReactAction };

package/dist/channel.runtime-DKXRnA8x.js

@@ -0,0 +1,55 @@
+import { startWebLoginWithQr as startWebLoginWithQr$1, waitForWebLogin as waitForWebLogin$1 } from "./login-qr-runtime.js";
+import { a as getWebAuthAgeMs$1, b as webAuthExists$1, d as readWebAuthExistsForDecision$1, f as readWebAuthSnapshot$1, h as readWebSelfId$1, m as readWebAuthState$1, o as logWebSelfId$1, p as readWebAuthSnapshotBestEffort$1, s as logoutWeb$1, u as readWebAuthExistsBestEffort$1 } from "./auth-store-BjCb50Ry.js";
+import { t as getActiveWebListener$1 } from "./active-listener-N7GFKsuN.js";
+import { t as monitorWebChannel$1 } from "./monitor-C4Fhg_lD.js";
+import { t as loginWeb$1 } from "./login-DymdrKca.js";
+import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-ieFnIW4g.js";
+//#region extensions/whatsapp/src/channel.runtime.ts
+function getActiveWebListener(...args) {
+	return getActiveWebListener$1(...args);
+}
+function getWebAuthAgeMs(...args) {
+	return getWebAuthAgeMs$1(...args);
+}
+function logWebSelfId(...args) {
+	return logWebSelfId$1(...args);
+}
+function logoutWeb(...args) {
+	return logoutWeb$1(...args);
+}
+function readWebAuthSnapshot(...args) {
+	return readWebAuthSnapshot$1(...args);
+}
+function readWebAuthState(...args) {
+	return readWebAuthState$1(...args);
+}
+function readWebAuthExistsBestEffort(...args) {
+	return readWebAuthExistsBestEffort$1(...args);
+}
+function readWebAuthExistsForDecision(...args) {
+	return readWebAuthExistsForDecision$1(...args);
+}
+function readWebAuthSnapshotBestEffort(...args) {
+	return readWebAuthSnapshotBestEffort$1(...args);
+}
+function readWebSelfId(...args) {
+	return readWebSelfId$1(...args);
+}
+function webAuthExists(...args) {
+	return webAuthExists$1(...args);
+}
+function loginWeb(...args) {
+	return loginWeb$1(...args);
+}
+async function startWebLoginWithQr(...args) {
+	return await startWebLoginWithQr$1(...args);
+}
+async function waitForWebLogin(...args) {
+	return await waitForWebLogin$1(...args);
+}
+const whatsappSetupWizard = { ...whatsappSetupWizard$1 };
+function monitorWebChannel(...args) {
+	return monitorWebChannel$1(...args);
+}
+//#endregion
+export { getActiveWebListener, getWebAuthAgeMs, logWebSelfId, loginWeb, logoutWeb, monitorWebChannel, readWebAuthExistsBestEffort, readWebAuthExistsForDecision, readWebAuthSnapshot, readWebAuthSnapshotBestEffort, readWebAuthState, readWebSelfId, startWebLoginWithQr, waitForWebLogin, webAuthExists, whatsappSetupWizard };

package/dist/channel.setup-DOHR2BGp.js

@@ -0,0 +1,20 @@
+import { a as resolveWhatsAppGroupToolPolicy, i as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupIntroHint, r as whatsappSetupWizardProxy, t as createWhatsAppPluginBase } from "./shared-D_wzSVar.js";
+import { m as readWebAuthState } from "./auth-store-BjCb50Ry.js";
+import { t as whatsappSetupAdapter } from "./setup-core-DZKvpzbH.js";
+import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-DnCdvoYD.js";
+//#region extensions/whatsapp/src/channel.setup.ts
+const whatsappSetupPlugin = {
+	...createWhatsAppPluginBase({
+		groups: {
+			resolveRequireMention: resolveWhatsAppGroupRequireMention,
+			resolveToolPolicy: resolveWhatsAppGroupToolPolicy,
+			resolveGroupIntroHint: resolveWhatsAppGroupIntroHint
+		},
+		setupWizard: whatsappSetupWizardProxy,
+		setup: whatsappSetupAdapter,
+		isConfigured: async (account) => await readWebAuthState(account.authDir) === "linked"
+	}),
+	lifecycle: { detectLegacyStateMigrations: ({ oauthDir }) => detectWhatsAppLegacyStateMigrations({ oauthDir }) }
+};
+//#endregion
+export { whatsappSetupPlugin as t };

package/dist/command-policy-O8sRnqUV.js

@@ -0,0 +1,8 @@
+//#region extensions/whatsapp/src/command-policy.ts
+const whatsappCommandPolicy = {
+	enforceOwnerForCommands: true,
+	preferSenderE164ForCommands: true,
+	skipWhenConfigEmpty: true
+};
+//#endregion
+export { whatsappCommandPolicy as t };