@openclaw/whatsapp 2026.5.2 → 2026.5.3-beta.2

package/dist/setup-surface-ieFnIW4g.js

@@ -0,0 +1,344 @@
+import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-DG18xddX.js";
+import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-BDqgpFEB.js";
+import { i as formatWhatsAppWebAuthStatusState, m as readWebAuthState } from "./auth-store-BjCb50Ry.js";
+import { t as whatsappSetupAdapter } from "./setup-core-DZKvpzbH.js";
+import path from "node:path";
+import { DEFAULT_ACCOUNT_ID, normalizeAllowFromEntries, normalizeE164, pathExists, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup";
+import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+//#region extensions/whatsapp/src/setup-finalize.ts
+function trimPromptText(value) {
+	return value?.trim() ?? "";
+}
+function isDefaultWhatsAppAccountKey(accountId) {
+	return accountId.trim().toLowerCase() === DEFAULT_ACCOUNT_ID;
+}
+function shouldWriteDefaultWhatsAppAccountConfigAtAccountScope(cfg) {
+	const accounts = cfg.channels?.whatsapp?.accounts;
+	if (!accounts) return false;
+	if (accounts.default) return true;
+	return Object.keys(accounts).some((accountId) => !isDefaultWhatsAppAccountKey(accountId));
+}
+function resolveDefaultWhatsAppAccountWriteKey(cfg) {
+	const accounts = cfg.channels?.whatsapp?.accounts;
+	if (!accounts) return DEFAULT_ACCOUNT_ID;
+	return Object.keys(accounts).find((accountId) => isDefaultWhatsAppAccountKey(accountId)) ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveWhatsAppConfigPathPrefix(cfg, accountId) {
+	if (accountId === DEFAULT_ACCOUNT_ID && shouldWriteDefaultWhatsAppAccountConfigAtAccountScope(cfg)) return `channels.whatsapp.accounts.${resolveDefaultWhatsAppAccountWriteKey(cfg)}`;
+	return accountId === DEFAULT_ACCOUNT_ID ? "channels.whatsapp" : `channels.whatsapp.accounts.${accountId}`;
+}
+function mergeWhatsAppConfig(cfg, accountId, patch, options) {
+	const channelConfig = { ...cfg.channels?.whatsapp };
+	const mutableChannelConfig = channelConfig;
+	if (resolveWhatsAppConfigPathPrefix(cfg, accountId) === "channels.whatsapp") {
+		for (const [key, value] of Object.entries(patch)) {
+			if (value === void 0) {
+				if (options?.unsetOnUndefined?.includes(key)) delete mutableChannelConfig[key];
+				continue;
+			}
+			mutableChannelConfig[key] = value;
+		}
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				whatsapp: channelConfig
+			}
+		};
+	}
+	const accounts = { ...channelConfig.accounts };
+	const targetAccountId = accountId === DEFAULT_ACCOUNT_ID ? resolveDefaultWhatsAppAccountWriteKey(cfg) : accountId;
+	const lowerDefaultAccount = accountId === DEFAULT_ACCOUNT_ID && targetAccountId !== DEFAULT_ACCOUNT_ID ? accounts[DEFAULT_ACCOUNT_ID] : void 0;
+	const nextAccount = {
+		...accounts[targetAccountId],
+		...lowerDefaultAccount
+	};
+	const mutableNextAccount = nextAccount;
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === void 0) {
+			if (options?.unsetOnUndefined?.includes(key)) delete mutableNextAccount[key];
+			continue;
+		}
+		mutableNextAccount[key] = value;
+	}
+	accounts[targetAccountId] = nextAccount;
+	if (lowerDefaultAccount) delete accounts[DEFAULT_ACCOUNT_ID];
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			whatsapp: {
+				...channelConfig,
+				accounts
+			}
+		}
+	};
+}
+function setWhatsAppDmPolicy(cfg, accountId, dmPolicy) {
+	return mergeWhatsAppConfig(cfg, accountId, { dmPolicy });
+}
+function setWhatsAppAllowFrom(cfg, accountId, allowFrom) {
+	return mergeWhatsAppConfig(cfg, accountId, { allowFrom }, { unsetOnUndefined: ["allowFrom"] });
+}
+function setWhatsAppSelfChatMode(cfg, accountId, selfChatMode) {
+	return mergeWhatsAppConfig(cfg, accountId, { selfChatMode });
+}
+async function detectWhatsAppLinked(cfg, accountId) {
+	const { authDir } = resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	});
+	return await pathExists(path.join(authDir, "creds.json"));
+}
+async function promptWhatsAppOwnerAllowFrom(params) {
+	const { prompter, existingAllowFrom } = params;
+	await prompter.note("We need the sender/owner number so OpenClaw can allowlist you.", "WhatsApp number");
+	const normalized = normalizeE164(trimPromptText(await prompter.text({
+		message: "Your personal WhatsApp number (the phone you will message from)",
+		placeholder: "+15555550123",
+		initialValue: existingAllowFrom[0],
+		validate: (value) => {
+			const raw = trimPromptText(value);
+			if (!raw) return "Required";
+			if (!normalizeE164(raw)) return `Invalid number: ${raw}`;
+		}
+	})));
+	if (!normalized) throw new Error("Invalid WhatsApp owner number (expected E.164 after validation).");
+	return {
+		normalized,
+		allowFrom: normalizeAllowFromEntries([...existingAllowFrom.filter((item) => item !== "*"), normalized], normalizeE164)
+	};
+}
+async function applyWhatsAppOwnerAllowlist(params) {
+	const { normalized, allowFrom } = await promptWhatsAppOwnerAllowFrom({
+		prompter: params.prompter,
+		existingAllowFrom: params.existingAllowFrom
+	});
+	let next = setWhatsAppSelfChatMode(params.cfg, params.accountId, true);
+	next = setWhatsAppDmPolicy(next, params.accountId, "allowlist");
+	next = setWhatsAppAllowFrom(next, params.accountId, allowFrom);
+	await params.prompter.note([...params.messageLines, `- allowFrom includes ${normalized}`].join("\n"), params.title);
+	return next;
+}
+function parseWhatsAppAllowFromEntries(raw) {
+	const parts = splitSetupEntries(raw);
+	if (parts.length === 0) return { entries: [] };
+	const entries = [];
+	for (const part of parts) {
+		if (part === "*") {
+			entries.push("*");
+			continue;
+		}
+		const normalized = normalizeE164(part);
+		if (!normalized) return {
+			entries: [],
+			invalidEntry: part
+		};
+		entries.push(normalized);
+	}
+	return { entries: normalizeAllowFromEntries(entries, normalizeE164) };
+}
+async function promptWhatsAppDmAccess(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId
+	});
+	const existingPolicy = account.dmPolicy ?? "pairing";
+	const existingAllowFrom = account.allowFrom ?? [];
+	const existingLabel = existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : "unset";
+	const configPathPrefix = resolveWhatsAppConfigPathPrefix(params.cfg, accountId);
+	const policyKey = `${configPathPrefix}.dmPolicy`;
+	const allowFromKey = `${configPathPrefix}.allowFrom`;
+	if (params.forceAllowFrom) return await applyWhatsAppOwnerAllowlist({
+		cfg: params.cfg,
+		accountId,
+		prompter: params.prompter,
+		existingAllowFrom,
+		title: "WhatsApp allowlist",
+		messageLines: ["Allowlist mode enabled."]
+	});
+	await params.prompter.note([
+		`WhatsApp direct chats are gated by \`${policyKey}\` + \`${allowFromKey}\`.`,
+		"- pairing (default): unknown senders get a pairing code; owner approves",
+		"- allowlist: unknown senders are blocked",
+		"- open: public inbound DMs (requires allowFrom to include \"*\")",
+		"- disabled: ignore WhatsApp DMs",
+		"",
+		`Current: dmPolicy=${existingPolicy}, allowFrom=${existingLabel}`,
+		`Docs: ${formatDocsLink("/whatsapp", "whatsapp")}`
+	].join("\n"), "WhatsApp DM access");
+	if (await params.prompter.select({
+		message: "WhatsApp phone setup",
+		options: [{
+			value: "personal",
+			label: "This is my personal phone number"
+		}, {
+			value: "separate",
+			label: "Separate phone just for OpenClaw"
+		}]
+	}) === "personal") return await applyWhatsAppOwnerAllowlist({
+		cfg: params.cfg,
+		accountId,
+		prompter: params.prompter,
+		existingAllowFrom,
+		title: "WhatsApp personal phone",
+		messageLines: ["Personal phone mode enabled.", "- dmPolicy set to allowlist (pairing skipped)"]
+	});
+	const policy = await params.prompter.select({
+		message: "WhatsApp DM policy",
+		options: [
+			{
+				value: "pairing",
+				label: "Pairing (recommended)"
+			},
+			{
+				value: "allowlist",
+				label: "Allowlist only (block unknown senders)"
+			},
+			{
+				value: "open",
+				label: "Open (public inbound DMs)"
+			},
+			{
+				value: "disabled",
+				label: "Disabled (ignore WhatsApp DMs)"
+			}
+		]
+	});
+	let next = setWhatsAppSelfChatMode(params.cfg, accountId, false);
+	next = setWhatsAppDmPolicy(next, accountId, policy);
+	if (policy === "open") {
+		const allowFrom = normalizeAllowFromEntries(["*", ...existingAllowFrom], normalizeE164);
+		next = setWhatsAppAllowFrom(next, accountId, allowFrom.length > 0 ? allowFrom : ["*"]);
+		return next;
+	}
+	if (policy === "disabled") return next;
+	const allowOptions = existingAllowFrom.length > 0 ? [
+		{
+			value: "keep",
+			label: "Keep current allowFrom"
+		},
+		{
+			value: "unset",
+			label: "Unset allowFrom (use pairing approvals only)"
+		},
+		{
+			value: "list",
+			label: "Set allowFrom to specific numbers"
+		}
+	] : [{
+		value: "unset",
+		label: "Unset allowFrom (default)"
+	}, {
+		value: "list",
+		label: "Set allowFrom to specific numbers"
+	}];
+	const mode = await params.prompter.select({
+		message: "WhatsApp allowFrom (optional pre-allowlist)",
+		options: allowOptions.map((opt) => ({
+			value: opt.value,
+			label: opt.label
+		}))
+	});
+	if (mode === "keep") return next;
+	if (mode === "unset") return setWhatsAppAllowFrom(next, accountId, void 0);
+	const parsed = parseWhatsAppAllowFromEntries(trimPromptText(await params.prompter.text({
+		message: "Allowed sender numbers (comma-separated, E.164)",
+		placeholder: "+15555550123, +447700900123",
+		validate: (value) => {
+			const raw = trimPromptText(value);
+			if (!raw) return "Required";
+			const parsed = parseWhatsAppAllowFromEntries(raw);
+			if (parsed.entries.length === 0 && !parsed.invalidEntry) return "Required";
+			if (parsed.invalidEntry) return `Invalid number: ${parsed.invalidEntry}`;
+		}
+	})));
+	if (parsed.invalidEntry) throw new Error(`Invalid number: ${parsed.invalidEntry}`);
+	if (parsed.entries.length === 0) throw new Error("Invalid WhatsApp allowFrom list (expected at least one E.164 number).");
+	return setWhatsAppAllowFrom(next, accountId, parsed.entries);
+}
+async function finalizeWhatsAppSetup(params) {
+	const accountId = params.accountId.trim() || resolveDefaultWhatsAppAccountId(params.cfg);
+	let next = accountId === DEFAULT_ACCOUNT_ID ? params.cfg : whatsappSetupAdapter.applyAccountConfig({
+		cfg: params.cfg,
+		accountId,
+		input: {}
+	});
+	const linked = await detectWhatsAppLinked(next, accountId);
+	const { authDir } = resolveWhatsAppAuthDir({
+		cfg: next,
+		accountId
+	});
+	if (!linked) await params.prompter.note([
+		"Scan the QR with WhatsApp on your phone.",
+		`Credentials are stored under ${authDir}/ for future runs.`,
+		`Docs: ${formatDocsLink("/whatsapp", "whatsapp")}`
+	].join("\n"), "WhatsApp linking");
+	if (await params.prompter.confirm({
+		message: linked ? "WhatsApp already linked. Re-link now?" : "Link WhatsApp now (QR)?",
+		initialValue: !linked
+	})) try {
+		const { loginWeb } = await import("./login-DymdrKca.js").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(`Docs: ${formatDocsLink("/whatsapp", "whatsapp")}`, "WhatsApp help");
+	}
+	else if (!linked) await params.prompter.note(`Run \`${formatCliCommand("openclaw channels login")}\` later to link WhatsApp.`, "WhatsApp");
+	next = await promptWhatsAppDmAccess({
+		cfg: next,
+		accountId,
+		forceAllowFrom: params.forceAllowFrom,
+		prompter: params.prompter
+	});
+	return { cfg: next };
+}
+//#endregion
+//#region extensions/whatsapp/src/setup-surface.ts
+const channel = "whatsapp";
+async function readWhatsAppSetupLinkState(cfg, accountId) {
+	const { authDir } = resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	});
+	return await readWebAuthState(authDir);
+}
+const whatsappSetupWizard = {
+	channel,
+	status: {
+		configuredLabel: "linked",
+		unconfiguredLabel: "not linked",
+		configuredHint: "linked",
+		unconfiguredHint: "not linked",
+		configuredScore: 5,
+		unconfiguredScore: 4,
+		resolveConfigured: async ({ cfg, accountId }) => {
+			for (const resolvedAccountId of accountId ? [accountId] : listAccountIds(cfg)) if (await readWhatsAppSetupLinkState(cfg, resolvedAccountId) === "linked") return true;
+			return false;
+		},
+		resolveStatusLines: async ({ cfg, accountId, configured }) => {
+			const linkedAccountId = (await Promise.all((accountId ? [accountId] : listAccountIds(cfg)).map(async (resolvedAccountId) => ({
+				accountId: resolvedAccountId,
+				state: await readWhatsAppSetupLinkState(cfg, resolvedAccountId)
+			})))).find((entry) => entry.state === "linked" || entry.state === "unstable");
+			const labelAccountId = accountId ?? linkedAccountId?.accountId;
+			return [`${labelAccountId ? `WhatsApp (${labelAccountId === DEFAULT_ACCOUNT_ID ? "default" : labelAccountId})` : "WhatsApp"}: ${configured ? formatWhatsAppWebAuthStatusState("linked") : formatWhatsAppWebAuthStatusState(linkedAccountId?.state ?? "not-linked")}`];
+		}
+	},
+	resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
+	credentials: [],
+	finalize: async ({ cfg, accountId, forceAllowFrom, prompter, runtime }) => await finalizeWhatsAppSetup({
+		cfg,
+		accountId,
+		forceAllowFrom,
+		prompter,
+		runtime
+	}),
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
+	onAccountRecorded: (accountId, options) => {
+		options?.onAccountId?.(channel, accountId);
+	}
+};
+//#endregion
+export { whatsappSetupWizard };

package/dist/shared-D_wzSVar.js

@@ -0,0 +1,307 @@
+import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-DG18xddX.js";
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-BDqgpFEB.js";
+import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-BPVHNsM5.js";
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-Dmo66Ubb.js";
+import { n as whatsappDoctor } from "./doctor-A9tXm9Om.js";
+import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-B8QBn0I2.js";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DqH8JDX6.js";
+import { n as deriveLegacySessionChatType, r as isLegacyGroupSessionKey, t as canonicalizeLegacySessionKey } from "./session-contract-B0efQf9P.js";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-core";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+import { createChannelPluginBase, getChatChannelMeta } from "openclaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
+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/config-accessors.ts
+function formatWhatsAppConfigAllowFromEntries(allowFrom) {
+	return normalizeWhatsAppAllowFromEntries(allowFrom);
+}
+//#endregion
+//#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 resolveChannelGroupRequireMention({
+		cfg: params.cfg,
+		channel: "whatsapp",
+		groupId: params.groupId,
+		accountId: params.accountId
+	});
+}
+function resolveWhatsAppGroupToolPolicy(params) {
+	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
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/security-fix.ts
+function applyGroupAllowFromFromStore(params) {
+	const next = structuredClone(params.cfg ?? {});
+	const section = next.channels?.whatsapp;
+	if (!section || typeof section !== "object" || params.storeAllowFrom.length === 0) return params.cfg;
+	let changed = false;
+	const maybeApply = (prefix, holder) => {
+		if (holder.groupPolicy !== "allowlist") return;
+		const allowFrom = Array.isArray(holder.allowFrom) ? holder.allowFrom : [];
+		const groupAllowFrom = Array.isArray(holder.groupAllowFrom) ? holder.groupAllowFrom : [];
+		if (allowFrom.length > 0 || groupAllowFrom.length > 0) return;
+		holder.groupAllowFrom = params.storeAllowFrom;
+		params.changes.push(`${prefix}groupAllowFrom=pairing-store`);
+		changed = true;
+	};
+	maybeApply("channels.whatsapp.", section);
+	const accounts = section.accounts;
+	if (accounts && typeof accounts === "object") for (const [accountId, accountValue] of Object.entries(accounts)) {
+		if (!accountValue || typeof accountValue !== "object") continue;
+		maybeApply(`channels.whatsapp.accounts.${accountId}.`, accountValue);
+	}
+	return changed ? next : params.cfg;
+}
+async function applyWhatsAppSecurityConfigFixes(params) {
+	const fromStore = await readChannelAllowFromStore("whatsapp", params.env, DEFAULT_ACCOUNT_ID$1).catch(() => []);
+	const normalized = Array.from(new Set(fromStore.map((entry) => entry.trim()))).filter(Boolean);
+	if (normalized.length === 0) return {
+		config: params.cfg,
+		changes: []
+	};
+	const changes = [];
+	return {
+		config: applyGroupAllowFromFromStore({
+			cfg: params.cfg,
+			storeAllowFrom: normalized,
+			changes
+		}),
+		changes
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/shared.ts
+const WHATSAPP_CHANNEL = "whatsapp";
+const WHATSAPP_GROUP_SCOPE_FIELDS = [
+	"groupPolicy",
+	"groupAllowFrom",
+	"groups"
+];
+function resolveWhatsAppAccountKey(accounts, accountId) {
+	if (!accounts) return;
+	if (Object.hasOwn(accounts, accountId)) return accountId;
+	const normalizedAccountId = accountId.trim().toLowerCase();
+	return Object.keys(accounts).find((key) => key.trim().toLowerCase() === normalizedAccountId);
+}
+function resolveWhatsAppGroupScopeBasePath(params) {
+	const accountId = typeof params.accountId === "string" ? params.accountId.trim() || DEFAULT_ACCOUNT_ID : DEFAULT_ACCOUNT_ID;
+	const accounts = params.cfg.channels?.whatsapp?.accounts;
+	const accountKey = resolveWhatsAppAccountKey(accounts, accountId);
+	const defaultAccountKey = resolveWhatsAppAccountKey(accounts, DEFAULT_ACCOUNT_ID);
+	const accountConfig = accountKey ? accounts?.[accountKey] : void 0;
+	const defaultAccountConfig = defaultAccountKey ? accounts?.[defaultAccountKey] : void 0;
+	const matchesAnyGroupScopeField = (config) => WHATSAPP_GROUP_SCOPE_FIELDS.some((field) => config?.[field] !== void 0);
+	if (matchesAnyGroupScopeField(accountConfig)) return `channels.whatsapp.accounts.${accountKey}`;
+	if (accountId !== DEFAULT_ACCOUNT_ID && matchesAnyGroupScopeField(defaultAccountConfig)) return `channels.whatsapp.accounts.${defaultAccountKey}`;
+	return "channels.whatsapp";
+}
+function resolveWhatsAppConfigPath(params) {
+	return `${resolveWhatsAppGroupScopeBasePath(params)}.${params.field}`;
+}
+async function loadWhatsAppChannelRuntime() {
+	return await import("./channel.runtime-DKXRnA8x.js");
+}
+async function loadWhatsAppSetupSurface() {
+	return await import("./setup-surface-ieFnIW4g.js");
+}
+const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
+const whatsappConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: WHATSAPP_CHANNEL,
+	listAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveWhatsAppAccount),
+	defaultAccountId: resolveDefaultWhatsAppAccountId,
+	clearBaseFields: [],
+	allowTopLevel: false,
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatWhatsAppConfigAllowFromEntries(allowFrom),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+const whatsappResolveDmPolicy = createScopedDmSecurityResolver({
+	channelKey: WHATSAPP_CHANNEL,
+	resolvePolicy: (account) => account.dmPolicy,
+	resolveAllowFrom: (account) => account.allowFrom,
+	policyPathSuffix: "dmPolicy",
+	normalizeEntry: (raw) => normalizeE164(raw),
+	inheritSharedDefaultsFromDefaultAccount: true
+});
+function createWhatsAppSetupWizardProxy(loadWizard) {
+	return createDelegatedSetupWizardProxy({
+		channel: WHATSAPP_CHANNEL,
+		loadWizard,
+		status: {
+			configuredLabel: "linked",
+			unconfiguredLabel: "not linked",
+			configuredHint: "linked",
+			unconfiguredHint: "not linked",
+			configuredScore: 5,
+			unconfiguredScore: 4
+		},
+		resolveShouldPromptAccountIds: (params) => params.shouldPromptAccountIds,
+		credentials: [],
+		delegateFinalize: true,
+		disable: (cfg) => ({
+			...cfg,
+			channels: {
+				...cfg.channels,
+				whatsapp: {
+					...cfg.channels?.whatsapp,
+					enabled: false
+				}
+			}
+		}),
+		onAccountRecorded: (accountId, options) => {
+			options?.onAccountId?.(WHATSAPP_CHANNEL, accountId);
+		}
+	});
+}
+function createWhatsAppPluginBase(params) {
+	const collectWhatsAppSecurityWarnings = createAllowlistProviderGroupPolicyWarningCollector({
+		providerConfigPresent: (cfg) => cfg.channels?.whatsapp !== void 0,
+		resolveGroupPolicy: ({ account }) => account.groupPolicy,
+		collect: ({ account, accountId, cfg, groupPolicy }) => collectOpenGroupPolicyRouteAllowlistWarnings({
+			groupPolicy,
+			routeAllowlistConfigured: Boolean(account.groups) && Object.keys(account.groups ?? {}).length > 0,
+			restrictSenders: {
+				surface: "WhatsApp groups",
+				openScope: "any member in allowed groups",
+				groupPolicyPath: resolveWhatsAppConfigPath({
+					cfg,
+					accountId,
+					field: "groupPolicy"
+				}),
+				groupAllowFromPath: resolveWhatsAppConfigPath({
+					cfg,
+					accountId,
+					field: "groupAllowFrom"
+				})
+			},
+			noRouteAllowlist: {
+				surface: "WhatsApp groups",
+				routeAllowlistPath: resolveWhatsAppConfigPath({
+					cfg,
+					accountId,
+					field: "groups"
+				}),
+				routeScope: "group",
+				groupPolicyPath: resolveWhatsAppConfigPath({
+					cfg,
+					accountId,
+					field: "groupPolicy"
+				}),
+				groupAllowFromPath: resolveWhatsAppConfigPath({
+					cfg,
+					accountId,
+					field: "groupAllowFrom"
+				})
+			}
+		})
+	});
+	const base = createChannelPluginBase({
+		id: WHATSAPP_CHANNEL,
+		meta: {
+			...getChatChannelMeta(WHATSAPP_CHANNEL),
+			showConfigured: false,
+			quickstartAllowFrom: true,
+			forceAccountBinding: true,
+			preferSessionLookupForAnnounceTarget: true
+		},
+		setupWizard: params.setupWizard,
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"group",
+				"channel"
+			],
+			polls: true,
+			reactions: true,
+			media: true,
+			tts: { voice: {
+				synthesisTarget: "voice-note",
+				transcodesAudio: true
+			} }
+		},
+		reload: {
+			configPrefixes: ["web"],
+			noopPrefixes: ["channels.whatsapp"]
+		},
+		gatewayMethods: ["web.login.start", "web.login.wait"],
+		configSchema: WhatsAppChannelConfigSchema,
+		config: {
+			...whatsappConfigAdapter,
+			isEnabled: (account, cfg) => account.enabled && cfg.web?.enabled !== false,
+			disabledReason: () => "disabled",
+			isConfigured: params.isConfigured,
+			hasPersistedAuthState: ({ cfg }) => hasAnyWhatsAppAuth(cfg),
+			unconfiguredReason: () => "not linked",
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: Boolean(account.authDir),
+				extra: {
+					linked: Boolean(account.authDir),
+					dmPolicy: account.dmPolicy,
+					allowFrom: account.allowFrom
+				}
+			})
+		},
+		security: {
+			applyConfigFixes: applyWhatsAppSecurityConfigFixes,
+			resolveDmPolicy: whatsappResolveDmPolicy,
+			collectWarnings: collectWhatsAppSecurityWarnings
+		},
+		doctor: whatsappDoctor,
+		setup: params.setup,
+		groups: params.groups
+	});
+	return {
+		...base,
+		setupWizard: base.setupWizard,
+		capabilities: base.capabilities,
+		reload: base.reload,
+		gatewayMethods: base.gatewayMethods,
+		configSchema: base.configSchema,
+		config: base.config,
+		messaging: {
+			defaultMarkdownTableMode: "bullets",
+			deriveLegacySessionChatType,
+			resolveLegacyGroupSessionKey,
+			isLegacyGroupSessionKey,
+			canonicalizeLegacySessionKey: (params) => canonicalizeLegacySessionKey({
+				key: params.key,
+				agentId: params.agentId
+			})
+		},
+		secrets: {
+			unsupportedSecretRefSurfacePatterns,
+			collectUnsupportedSecretRefConfigCandidates
+		},
+		security: base.security,
+		groups: base.groups
+	};
+}
+//#endregion
+export { resolveWhatsAppGroupToolPolicy as a, formatWhatsAppConfigAllowFromEntries as c, resolveWhatsAppGroupRequireMention as i, loadWhatsAppChannelRuntime as n, resolveWhatsAppGroupIntroHint as o, whatsappSetupWizardProxy as r, resolveWhatsAppMentionStripRegexes as s, createWhatsAppPluginBase as t };

package/dist/state-migrations-DnCdvoYD.js

@@ -0,0 +1,39 @@
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+//#region extensions/whatsapp/src/state-migrations.ts
+function fileExists(pathValue) {
+	try {
+		return fs.existsSync(pathValue) && fs.statSync(pathValue).isFile();
+	} catch {
+		return false;
+	}
+}
+function isLegacyWhatsAppAuthFile(name) {
+	if (name === "creds.json" || name === "creds.json.bak") return true;
+	if (!name.endsWith(".json")) return false;
+	return /^(app-state-sync|session|sender-key|pre-key)-/.test(name);
+}
+function detectWhatsAppLegacyStateMigrations(params) {
+	const targetDir = path.join(params.oauthDir, "whatsapp", DEFAULT_ACCOUNT_ID);
+	return (() => {
+		try {
+			return fs.readdirSync(params.oauthDir, { withFileTypes: true });
+		} catch {
+			return [];
+		}
+	})().flatMap((entry) => {
+		if (!entry.isFile() || entry.name === "oauth.json" || !isLegacyWhatsAppAuthFile(entry.name)) return [];
+		const sourcePath = path.join(params.oauthDir, entry.name);
+		const targetPath = path.join(targetDir, entry.name);
+		if (fileExists(targetPath)) return [];
+		return [{
+			kind: "move",
+			label: `WhatsApp auth ${entry.name}`,
+			sourcePath,
+			targetPath
+		}];
+	});
+}
+//#endregion
+export { detectWhatsAppLegacyStateMigrations as t };

package/dist/targets.js

@@ -0,0 +1,2 @@
+import { r as isWhatsAppUserTarget, s as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BPVHNsM5.js";
+export { isWhatsAppGroupJid, isWhatsAppUserTarget, normalizeWhatsAppTarget };

package/dist/test-api.js

@@ -0,0 +1,3 @@
+import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-Gp1lQ0at.js";
+import { t as whatsappOutbound } from "./outbound-adapter-BssVnZdz.js";
+export { resolveWhatsAppRuntimeGroupPolicy, whatsappOutbound };