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

package/dist/security-contract-api.js

@@ -0,0 +1,2 @@
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DqH8JDX6.js";
+export { collectUnsupportedSecretRefConfigCandidates, unsupportedSecretRefSurfacePatterns };

package/dist/send-CIyLFxdZ.js

@@ -0,0 +1,234 @@
+import { t as __exportAll } from "./rolldown-runtime-RkAeH_Qm.js";
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-DG18xddX.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BDqgpFEB.js";
+import { n as isWhatsAppNewsletterJid } from "./normalize-target-BPVHNsM5.js";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-D_iIGz5m.js";
+import "./normalize-CWYiGkXw.js";
+import { a as markdownToWhatsApp, s as toWhatsappJid } from "./text-runtime-C1zNiZeO.js";
+import { a as resolveWhatsAppOutboundMediaUrls, i as prepareWhatsAppOutboundMedia, n as normalizeWhatsAppPayloadText } from "./outbound-media-contract-CGss_QHy.js";
+import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
+import { generateSecureUuid } from "openclaw/plugin-sdk/core";
+import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
+import { convertMarkdownTables, resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
+import { createSubsystemLogger, getChildLogger } from "openclaw/plugin-sdk/runtime-env";
+import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
+//#region extensions/whatsapp/src/outbound-media.runtime.ts
+async function loadOutboundMediaFromUrl(mediaUrl, options = {}) {
+	const readFile = options.mediaAccess?.readFile ?? options.mediaReadFile;
+	const localRoots = options.mediaAccess?.localRoots?.length && options.mediaAccess.localRoots.length > 0 ? options.mediaAccess.localRoots : options.mediaLocalRoots && options.mediaLocalRoots.length > 0 ? options.mediaLocalRoots : void 0;
+	return await loadWebMedia(mediaUrl, readFile ? {
+		...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {},
+		localRoots: "any",
+		readFile,
+		hostReadCapability: true
+	} : {
+		...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {},
+		...localRoots ? { localRoots } : {}
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/send.ts
+var send_exports = /* @__PURE__ */ __exportAll({
+	sendMessageWhatsApp: () => sendMessageWhatsApp,
+	sendPollWhatsApp: () => sendPollWhatsApp,
+	sendReactionWhatsApp: () => sendReactionWhatsApp,
+	sendTypingWhatsApp: () => sendTypingWhatsApp
+});
+const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+function resolveOutboundWhatsAppAccountId(params) {
+	const explicitAccountId = params.accountId?.trim();
+	if (explicitAccountId) return explicitAccountId;
+	return resolveDefaultWhatsAppAccountId(params.cfg);
+}
+function requireOutboundActiveWebListener(params) {
+	const resolvedAccountId = resolveOutboundWhatsAppAccountId(params) ?? resolveDefaultWhatsAppAccountId(params.cfg);
+	const listener = getRegisteredWhatsAppConnectionController(resolvedAccountId)?.getActiveListener() ?? null;
+	if (!listener) throw new Error(`No active WhatsApp Web listener (account: ${resolvedAccountId}). Start the gateway, then link WhatsApp with: ${formatCliCommand(`openclaw channels login --channel whatsapp --account ${resolvedAccountId}`)}.`);
+	return {
+		accountId: resolvedAccountId,
+		listener
+	};
+}
+async function sendMessageWhatsApp(to, body, options) {
+	let text = options.preserveLeadingWhitespace ? body : normalizeWhatsAppPayloadText(body);
+	const jid = toWhatsappJid(to);
+	const primaryMediaUrl = resolveWhatsAppOutboundMediaUrls(options)[0];
+	if (!text && !primaryMediaUrl) return {
+		messageId: "",
+		toJid: jid
+	};
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const cfg = requireRuntimeConfig(options.cfg, "WhatsApp send");
+	const { listener: active, accountId: resolvedAccountId } = requireOutboundActiveWebListener({
+		cfg,
+		accountId: options.accountId
+	});
+	const account = resolveWhatsAppAccount({
+		cfg,
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "whatsapp",
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	text = convertMarkdownTables(text ?? "", tableMode);
+	text = markdownToWhatsApp(text);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const redactedJid = redactIdentifier(jid);
+		let mediaBuffer;
+		let mediaType;
+		let documentFileName;
+		let visibleTextAfterVoice;
+		if (primaryMediaUrl) {
+			const media = await prepareWhatsAppOutboundMedia(await loadOutboundMediaFromUrl(primaryMediaUrl, {
+				maxBytes: resolveWhatsAppMediaMaxBytes(account),
+				mediaAccess: options.mediaAccess,
+				mediaLocalRoots: options.mediaLocalRoots,
+				mediaReadFile: options.mediaReadFile
+			}), primaryMediaUrl);
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.mimetype;
+			if (media.kind === "audio" && caption) {
+				visibleTextAfterVoice = caption;
+				text = "";
+			} else if (media.kind === "document") {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			} else text = caption ?? "";
+		}
+		outboundLog.info(`Sending message -> ${redactedJid}${primaryMediaUrl ? " (media)" : ""}`);
+		logger.info({
+			jid: redactedJid,
+			hasMedia: Boolean(primaryMediaUrl)
+		}, "sending message");
+		if (!isWhatsAppNewsletterJid(jid)) await active.sendComposingTo(to);
+		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
+		const sendOptions = options.gifPlayback || accountId || documentFileName || options.quotedMessageKey ? {
+			...options.gifPlayback ? { gifPlayback: true } : {},
+			...documentFileName ? { fileName: documentFileName } : {},
+			...options.quotedMessageKey ? { quotedMessageKey: options.quotedMessageKey } : {},
+			accountId
+		} : void 0;
+		const result = sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType);
+		if (visibleTextAfterVoice) if (sendOptions) await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0, sendOptions);
+		else await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0);
+		const messageId = result?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent message ${messageId} -> ${redactedJid}${primaryMediaUrl ? " (media)" : ""} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent message");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo,
+			hasMedia: Boolean(primaryMediaUrl)
+		}, "failed to send via web session");
+		throw err;
+	}
+}
+async function sendTypingWhatsApp(to, options) {
+	const { listener: active } = requireOutboundActiveWebListener({
+		cfg: requireRuntimeConfig(options.cfg, "WhatsApp typing send"),
+		accountId: options.accountId
+	});
+	if (!isWhatsAppNewsletterJid(toWhatsappJid(to))) await active.sendComposingTo(to);
+}
+async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
+	const correlationId = generateSecureUuid();
+	const { listener: active } = requireOutboundActiveWebListener({
+		cfg: requireRuntimeConfig(options.cfg, "WhatsApp reaction"),
+		accountId: options.accountId
+	});
+	const redactedChatJid = redactIdentifier(chatJid);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		chatJid: redactedChatJid,
+		messageId
+	});
+	try {
+		const redactedJid = redactIdentifier(toWhatsappJid(chatJid));
+		outboundLog.info(`Sending reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: redactedJid,
+			messageId,
+			emoji
+		}, "sending reaction");
+		await active.sendReaction(chatJid, messageId, emoji, options.fromMe ?? false, options.participant);
+		outboundLog.info(`Sent reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: redactedJid,
+			messageId,
+			emoji
+		}, "sent reaction");
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			chatJid: redactedChatJid,
+			messageId,
+			emoji
+		}, "failed to send reaction via web session");
+		throw err;
+	}
+}
+async function sendPollWhatsApp(to, poll, options) {
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const { listener: active } = requireOutboundActiveWebListener({
+		cfg: requireRuntimeConfig(options.cfg, "WhatsApp poll"),
+		accountId: options.accountId
+	});
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		const redactedJid = redactIdentifier(jid);
+		const normalized = normalizePollInput(poll, { maxOptions: 12 });
+		outboundLog.info(`Sending poll -> ${redactedJid}`);
+		logger.info({
+			jid: redactedJid,
+			optionCount: normalized.options.length,
+			maxSelections: normalized.maxSelections
+		}, "sending poll");
+		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent poll ${messageId} -> ${redactedJid} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent poll");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo
+		}, "failed to send poll via web session");
+		throw err;
+	}
+}
+//#endregion
+export { send_exports as a, sendTypingWhatsApp as i, sendPollWhatsApp as n, sendReactionWhatsApp as r, sendMessageWhatsApp as t };

package/dist/session-contract-B0efQf9P.js

@@ -0,0 +1,27 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/whatsapp/src/session-contract.ts
+function extractLegacyWhatsAppGroupId(key) {
+	const trimmed = key.trim();
+	if (!trimmed) return null;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	if (trimmed.startsWith("group:")) {
+		const id = trimmed.slice(6).trim();
+		return normalizeLowercaseStringOrEmpty(id).includes("@g.us") ? id : null;
+	}
+	if (!lower.includes("@g.us")) return null;
+	if (!trimmed.includes(":")) return trimmed;
+	if (lower.startsWith("whatsapp:") && !trimmed.includes(":group:")) return trimmed.slice(9).trim().replace(/^group:/i, "").trim() || null;
+	return null;
+}
+function isLegacyGroupSessionKey(key) {
+	return extractLegacyWhatsAppGroupId(key) !== null;
+}
+function deriveLegacySessionChatType(key) {
+	return isLegacyGroupSessionKey(key) ? "group" : void 0;
+}
+function canonicalizeLegacySessionKey(params) {
+	const legacyGroupId = extractLegacyWhatsAppGroupId(params.key);
+	return legacyGroupId ? `agent:${normalizeLowercaseStringOrEmpty(params.agentId)}:whatsapp:group:${normalizeLowercaseStringOrEmpty(legacyGroupId)}` : null;
+}
+//#endregion
+export { deriveLegacySessionChatType as n, isLegacyGroupSessionKey as r, canonicalizeLegacySessionKey as t };

package/dist/session-errors-CSuKZPub.js

@@ -0,0 +1,63 @@
+//#region extensions/whatsapp/src/session-errors.ts
+function safeStringify(value, limit = 800) {
+	try {
+		const seen = /* @__PURE__ */ new WeakSet();
+		const raw = JSON.stringify(value, (_key, v) => {
+			if (typeof v === "bigint") return v.toString();
+			if (typeof v === "function") {
+				const maybeName = v.name;
+				return `[Function ${typeof maybeName === "string" && maybeName.length > 0 ? maybeName : "anonymous"}]`;
+			}
+			if (typeof v === "object" && v) {
+				if (seen.has(v)) return "[Circular]";
+				seen.add(v);
+			}
+			return v;
+		}, 2);
+		if (!raw) return String(value);
+		return raw.length > limit ? `${raw.slice(0, limit)}…` : raw;
+	} catch {
+		return String(value);
+	}
+}
+function extractBoomDetails(err) {
+	if (!err || typeof err !== "object") return null;
+	const output = err?.output;
+	if (!output || typeof output !== "object") return null;
+	const payload = output.payload;
+	const statusCode = typeof output.statusCode === "number" ? output.statusCode : typeof payload?.statusCode === "number" ? payload.statusCode : void 0;
+	const error = typeof payload?.error === "string" ? payload.error : void 0;
+	const message = typeof payload?.message === "string" ? payload.message : void 0;
+	if (!statusCode && !error && !message) return null;
+	return {
+		statusCode,
+		error,
+		message
+	};
+}
+function getStatusCode(err) {
+	return err?.output?.statusCode ?? err?.status ?? err?.error?.output?.statusCode;
+}
+function formatError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (!err || typeof err !== "object") return String(err);
+	const boom = extractBoomDetails(err) ?? extractBoomDetails(err?.error) ?? extractBoomDetails(err?.lastDisconnect?.error);
+	const status = boom?.statusCode ?? getStatusCode(err);
+	const code = err?.code;
+	const codeText = typeof code === "string" || typeof code === "number" ? String(code) : void 0;
+	const message = [
+		boom?.message,
+		typeof err?.message === "string" ? err.message : void 0,
+		typeof err?.error?.message === "string" ? err.error?.message : void 0
+	].find((value) => Boolean(value && value.trim().length > 0));
+	const pieces = [];
+	if (typeof status === "number") pieces.push(`status=${status}`);
+	if (boom?.error) pieces.push(boom.error);
+	if (message) pieces.push(message);
+	if (codeText) pieces.push(`code=${codeText}`);
+	if (pieces.length > 0) return pieces.join(" ");
+	return safeStringify(err);
+}
+//#endregion
+export { getStatusCode as n, formatError as t };

package/dist/session.runtime-C1eSE_KK.js

@@ -0,0 +1,13 @@
+import { t as __exportAll } from "./rolldown-runtime-RkAeH_Qm.js";
+import { BufferJSON, DisconnectReason as DisconnectReason$1, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState } from "@whiskeysockets/baileys";
+//#region extensions/whatsapp/src/session.runtime.ts
+var session_runtime_exports = /* @__PURE__ */ __exportAll({
+	BufferJSON: () => BufferJSON,
+	DisconnectReason: () => DisconnectReason$1,
+	fetchLatestBaileysVersion: () => fetchLatestBaileysVersion,
+	makeCacheableSignalKeyStore: () => makeCacheableSignalKeyStore,
+	makeWASocket: () => makeWASocket,
+	useMultiFileAuthState: () => useMultiFileAuthState
+});
+//#endregion
+export { session_runtime_exports as a, makeWASocket as i, fetchLatestBaileysVersion as n, useMultiFileAuthState as o, makeCacheableSignalKeyStore as r, DisconnectReason$1 as t };

package/dist/setup-core-DZKvpzbH.js

@@ -0,0 +1,46 @@
+import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId } from "openclaw/plugin-sdk/setup";
+//#region extensions/whatsapp/src/setup-core.ts
+const channel = "whatsapp";
+const whatsappSetupAdapter = {
+	resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: channel,
+		accountId,
+		name,
+		alwaysUseAccounts: true
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const next = migrateBaseNameToDefaultAccount({
+			cfg: applyAccountNameToChannelSection({
+				cfg,
+				channelKey: channel,
+				accountId,
+				name: input.name,
+				alwaysUseAccounts: true
+			}),
+			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 { whatsappSetupAdapter as t };

package/dist/setup-entry.js

@@ -0,0 +1,23 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/whatsapp/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	features: {
+		legacyStateMigrations: true,
+		legacySessionSurfaces: true
+	},
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "whatsappSetupPlugin"
+	},
+	legacyStateMigrations: {
+		specifier: "./legacy-state-migrations-api.js",
+		exportName: "detectWhatsAppLegacyStateMigrations"
+	},
+	legacySessionSurface: {
+		specifier: "./legacy-session-surface-api.js",
+		exportName: "whatsappLegacySessionSurface"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

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