@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/channel-react-action-mvIbAFhn.mjs

@@ -0,0 +1,127 @@
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-Dw16pdNl.mjs";
+import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.mjs";
+import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-DLK_9v4r.mjs";
+import { t as sendMessageWhatsApp } from "./send-BQjMC41n.mjs";
+import "./normalize-eddWWsNV.mjs";
+import { jsonResult, readStringOrNumberParam, readStringParam as readStringParam$1, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
+import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
+//#region extensions/whatsapp/src/channel-react-action.ts
+const WHATSAPP_CHANNEL = "whatsapp";
+function readUploadFileMediaSource(args) {
+	return readStringParam$1(args, "media", { trim: false }) ?? readStringParam$1(args, "mediaUrl", { trim: false }) ?? readStringParam$1(args, "filePath", { trim: false }) ?? readStringParam$1(args, "path", { trim: false }) ?? readStringParam$1(args, "fileUrl", { trim: false });
+}
+function readUploadFileCaptionText(args) {
+	return readStringParam$1(args, "message", { allowEmpty: true }) ?? readStringParam$1(args, "content", { allowEmpty: true }) ?? readStringParam$1(args, "caption", { allowEmpty: true }) ?? "";
+}
+function hasUploadFileBufferPayload(args) {
+	return readStringParam$1(args, "buffer", { trim: false }) !== void 0;
+}
+function readWhatsAppActionChatJid(params) {
+	const explicit = readStringParam$1(params.params, "chatJid") ?? readStringParam$1(params.params, "to");
+	if (explicit) return explicit;
+	if (params.toolContext?.currentChannelProvider !== WHATSAPP_CHANNEL || !params.toolContext.currentChannelId) return;
+	return normalizeWhatsAppTarget(params.toolContext.currentChannelId) ?? void 0;
+}
+function extractBase64Payload(encoded) {
+	const match = /^data:[^;]+;base64,(.*)$/i.exec(encoded.trim());
+	return match ? match[1] : encoded;
+}
+function estimateBase64DecodedBytes(encoded) {
+	const compact = extractBase64Payload(encoded).replace(/\s/g, "");
+	if (!compact) return 0;
+	const padding = compact.endsWith("==") ? 2 : compact.endsWith("=") ? 1 : 0;
+	return Math.max(0, Math.floor(compact.length * 3 / 4) - padding);
+}
+function decodeUploadFileMediaPayload(params) {
+	if (params.maxBytes !== void 0) {
+		const estimatedBytes = estimateBase64DecodedBytes(params.encoded);
+		if (estimatedBytes > params.maxBytes) throw new Error(`WhatsApp upload-file buffer exceeds configured media limit (${estimatedBytes} bytes > ${params.maxBytes} bytes).`);
+	}
+	const contentType = readStringParam$1(params.args, "contentType") ?? readStringParam$1(params.args, "mimeType");
+	const fileName = readStringParam$1(params.args, "filename") ?? readStringParam$1(params.args, "fileName");
+	const buffer = Buffer.from(extractBase64Payload(params.encoded), "base64");
+	if (params.maxBytes !== void 0 && buffer.byteLength > params.maxBytes) throw new Error(`WhatsApp upload-file buffer exceeds configured media limit (${buffer.byteLength} bytes > ${params.maxBytes} bytes).`);
+	return {
+		buffer,
+		...contentType ? { contentType } : {},
+		...fileName ? { fileName } : {}
+	};
+}
+async function handleWhatsAppUploadFileAction(params) {
+	const mediaUrl = readUploadFileMediaSource(params.params);
+	const encodedPayload = readStringParam$1(params.params, "buffer", { trim: false });
+	if (!mediaUrl && !hasUploadFileBufferPayload(params.params)) throw new Error("WhatsApp upload-file requires media, mediaUrl, filePath, path, fileUrl, or buffer.");
+	const to = readWhatsAppActionChatJid(params) ?? readStringParam$1(params.params, "to", { required: true });
+	const resolved = resolveAuthorizedWhatsAppOutboundTarget({
+		cfg: params.cfg,
+		chatJid: to,
+		accountId: params.accountId ?? void 0,
+		actionLabel: "upload-file"
+	});
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: resolved.accountId
+	});
+	const mediaPayload = encodedPayload ? decodeUploadFileMediaPayload({
+		args: params.params,
+		encoded: encodedPayload,
+		maxBytes: resolveWhatsAppMediaMaxBytes(account)
+	}) : void 0;
+	const result = await sendMessageWhatsApp(resolved.to, readUploadFileCaptionText(params.params), {
+		verbose: false,
+		cfg: params.cfg,
+		...mediaUrl && !mediaPayload ? { mediaUrl } : {},
+		...mediaPayload ? { mediaPayload } : {},
+		mediaAccess: params.mediaAccess,
+		mediaLocalRoots: params.mediaLocalRoots,
+		mediaReadFile: params.mediaReadFile,
+		gifPlayback: readBooleanParam(params.params, "gifPlayback") ?? void 0,
+		audioAsVoice: readBooleanParam(params.params, "asVoice") ?? readBooleanParam(params.params, "audioAsVoice") ?? void 0,
+		forceDocument: readBooleanParam(params.params, "forceDocument") ?? readBooleanParam(params.params, "asDocument") ?? void 0,
+		accountId: resolved.accountId
+	});
+	return jsonResult({
+		ok: true,
+		channel: WHATSAPP_CHANNEL,
+		action: "upload-file",
+		messageId: result.messageId,
+		toJid: result.toJid
+	});
+}
+async function handleWhatsAppMessageAction(params) {
+	if (params.action === "upload-file") return await handleWhatsAppUploadFileAction(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 = readWhatsAppActionChatJid(params);
+	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: readWhatsAppActionChatJid(params) ?? 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 { handleWhatsAppMessageAction };

package/dist/.setup/channel.runtime-DmmMgRJQ.mjs

@@ -0,0 +1,55 @@
+import { startWebLoginWithQr as startWebLoginWithQr$1, waitForWebLogin as waitForWebLogin$1 } from "../login-qr-runtime.js";
+import { c as logoutWeb$1, d as readWebAuthExistsBestEffort$1, f as readWebAuthExistsForDecision$1, g as readWebSelfId$1, h as readWebAuthState$1, m as readWebAuthSnapshotBestEffort$1, o as getWebAuthAgeMs$1, p as readWebAuthSnapshot$1, s as logWebSelfId$1, x as webAuthExists$1 } from "./auth-store-BZKGa0tW.mjs";
+import { t as getActiveWebListener$1 } from "./active-listener-CloPBx0S.mjs";
+import { t as monitorWebChannel$1 } from "./monitor-Dh6Di_YO.mjs";
+import { t as loginWeb$1 } from "./login-7b3M0iBp.mjs";
+import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-Zvj2cLzz.mjs";
+//#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/.setup/channel.setup-ByBYSeLd.mjs

@@ -0,0 +1,22 @@
+import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, s as resolveWhatsAppGroupIntroHint, t as whatsappSetupAdapter } from "./setup-core--FfzntMG.mjs";
+import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-D_BmQUR9.mjs";
+//#region extensions/whatsapp/src/channel.setup.ts
+async function isWhatsAppAuthConfigured(account) {
+	const { readWebAuthState } = await import("./auth-store-BZKGa0tW.mjs").then((n) => n.i);
+	return await readWebAuthState(account.authDir) === "linked";
+}
+const whatsappSetupPlugin = {
+	...createWhatsAppPluginBase({
+		groups: {
+			resolveRequireMention: resolveWhatsAppGroupRequireMention,
+			resolveToolPolicy: resolveWhatsAppGroupToolPolicy,
+			resolveGroupIntroHint: resolveWhatsAppGroupIntroHint
+		},
+		setupWizard: whatsappSetupWizardProxy,
+		setup: whatsappSetupAdapter,
+		isConfigured: isWhatsAppAuthConfigured
+	}),
+	lifecycle: { detectLegacyStateMigrations: ({ oauthDir }) => detectWhatsAppLegacyStateMigrations({ oauthDir }) }
+};
+//#endregion
+export { whatsappSetupPlugin as t };

package/dist/.setup/config-schema-mBX2nmn1.mjs

@@ -0,0 +1,47 @@
+import { WhatsAppConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
+//#endregion
+//#region extensions/whatsapp/src/config-schema.ts
+const WhatsAppChannelConfigSchema = buildChannelConfigSchema(WhatsAppConfigSchema, { uiHints: {
+	"": {
+		label: "WhatsApp",
+		help: "WhatsApp channel provider configuration for access policy and message batching behavior. Use this section to tune responsiveness and direct-message routing safety for WhatsApp chats."
+	},
+	dmPolicy: {
+		label: "WhatsApp DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.whatsapp.allowFrom=[\"*\"]."
+	},
+	selfChatMode: {
+		label: "WhatsApp Self-Phone Mode",
+		help: "Same-phone setup (bot uses your personal WhatsApp number)."
+	},
+	debounceMs: {
+		label: "WhatsApp Message Debounce (ms)",
+		help: "Debounce window (ms) for batching rapid consecutive messages from the same sender (0 to disable)."
+	},
+	configWrites: {
+		label: "WhatsApp Config Writes",
+		help: "Allow WhatsApp to write config in response to channel events/commands (default: true)."
+	},
+	"actions.calls": {
+		label: "WhatsApp Voice Calls",
+		help: "Expose the experimental requester-bound WhatsApp voice-call tool. Default: false. Requires a separately paired MeowCaller CLI."
+	},
+	mentionPatterns: {
+		label: "WhatsApp Mention Pattern Policy",
+		help: "Scopes configured groupChat mentionPatterns to selected WhatsApp conversation IDs such as 123@g.us."
+	},
+	"mentionPatterns.mode": {
+		label: "WhatsApp Mention Pattern Mode",
+		help: "\"allow\" enables configured regex mention patterns unless denyIn matches; \"deny\" disables them unless allowIn matches."
+	},
+	"mentionPatterns.allowIn": {
+		label: "WhatsApp Mention Pattern Allowlist",
+		help: "WhatsApp conversation IDs where configured regex mention patterns are enabled when mode is deny."
+	},
+	"mentionPatterns.denyIn": {
+		label: "WhatsApp Mention Pattern Denylist",
+		help: "WhatsApp conversation IDs where configured regex mention patterns are disabled."
+	}
+} });
+//#endregion
+export { WhatsAppChannelConfigSchema as t };