@openclaw/whatsapp 2026.9.6 → 2026.9.8

package/dist/.setup/{channel-react-action-1iBiEnq7.mjs → channel-react-action-2r_hjLZV.mjs}

@@ -1,8 +1,7 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-D_NGDjCx.mjs";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CtRPAQCL.mjs";
 import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BGra1ZnM.mjs";
-import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-DZZFamfl.mjs";
-import { a as sendWhatsAppUploadFile } from "./send-C6jDmcL9.mjs";
-import "./normalize-DdsROMMa.mjs";
+import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-DeVk5V7r.mjs";
+import { a as sendWhatsAppUploadFile } from "./send-BGdvf5cC.mjs";
 import { jsonResult, readStringOrNumberParam, readStringParam as readStringParam$1, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 import { canonicalizeBase64, estimateBase64DecodedBytes } from "openclaw/plugin-sdk/media-runtime";
 import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
@@ -14,9 +13,6 @@ function readUploadFileMediaSource(args) {
 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;
@@ -46,7 +42,7 @@ async function handleWhatsAppUploadFileAction(params) {
 	const encodedPayload = readStringParam$1(params.params, "buffer", { trim: false });
 	const contentType = readStringParam$1(params.params, "contentType") ?? readStringParam$1(params.params, "mimeType");
 	const fileName = readStringParam$1(params.params, "filename") ?? readStringParam$1(params.params, "fileName");
-	if (!mediaUrl && !hasUploadFileBufferPayload(params.params)) throw new Error("WhatsApp upload-file requires media, mediaUrl, filePath, path, fileUrl, or buffer.");
+	if (!mediaUrl && encodedPayload === void 0) 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,

package/dist/.setup/{channel.runtime-rurG-kbr.mjs → channel.runtime-C94goLw9.mjs}

@@ -1,9 +1,9 @@
 import { startWebLoginWithQr as startWebLoginWithQr$1, waitForWebLogin as waitForWebLogin$1 } from "../login-qr-runtime.js";
-import { c as logoutWeb, d as readWebAuthExistsBestEffort, f as readWebAuthExistsForDecision, g as readWebSelfId, h as readWebAuthState, m as readWebAuthSnapshotBestEffort, o as getWebAuthAgeMs, p as readWebAuthSnapshot, s as logWebSelfId, x as webAuthExists } from "./auth-store-Dh8a3cba.mjs";
+import { c as logoutWeb, d as readWebAuthExistsBestEffort, f as readWebAuthExistsForDecision, g as readWebSelfId, h as readWebAuthState, m as readWebAuthSnapshotBestEffort, o as getWebAuthAgeMs, p as readWebAuthSnapshot, s as logWebSelfId, x as webAuthExists } from "./auth-store-BBonwKks.mjs";
 import { t as getActiveWebListener } from "./active-listener-CDjoX9QR.mjs";
-import { t as monitorWebChannel } from "./monitor-By82ehLA.mjs";
-import { t as loginWeb } from "./login-2dmd1TfE.mjs";
-import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-B9CYwDPZ.mjs";
+import { t as monitorWebChannel } from "./monitor-CGpV2VNN.mjs";
+import { t as loginWeb } from "./login-BFlvSh9h.mjs";
+import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-43fj197P.mjs";
 //#region extensions/whatsapp/src/channel.runtime.ts
 async function startWebLoginWithQr(...args) {
 	return await startWebLoginWithQr$1(...args);

package/dist/.setup/{channel.setup-C8P5q8uD.mjs → channel.setup-CfN1UfdY.mjs}

@@ -1,4 +1,4 @@
-import { t as createWhatsAppPluginBase } from "./shared-DVgQ8kRG.mjs";
+import { t as createWhatsAppPluginBase } from "./shared-DgOG5Iqr.mjs";
 //#region extensions/whatsapp/src/channel.setup.ts
 const whatsappSetupPlugin = { ...createWhatsAppPluginBase() };
 //#endregion

package/dist/.setup/{connection-controller-C60mU7j7.mjs → connection-controller-CHo1oRJA.mjs}

@@ -1,43 +1,11 @@
 import { r as getWhatsAppChannelRuntime } from "./runtime-BLlToOi6.mjs";
 import { n as WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY, t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-hgLJoRc8.mjs";
-import { M as waitForCredsSaveQueueWithTimeout, c as logoutWeb, f as readWebAuthExistsForDecision, k as resolveComparableIdentity, r as WhatsAppAuthUnstableError } from "./auth-store-Dh8a3cba.mjs";
-import { a as waitForWaConnection, m as acquireWhatsAppGatewayConnectionOwner, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, t as closeWhatsAppSocketAndWait } from "./socket-close-CCVSFufF.mjs";
-import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.mjs";
-import { computeBackoff, info, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { M as waitForCredsSaveQueueWithTimeout, c as logoutWeb, f as readWebAuthExistsForDecision, k as resolveComparableIdentity, r as WhatsAppAuthUnstableError } from "./auth-store-BBonwKks.mjs";
+import { d as DEFAULT_WHATSAPP_SOCKET_TIMING, i as waitForWaConnection, o as computeBackoff, r as createWaSocket, t as closeWhatsAppSocketAndWait, u as sleepWithAbort, y as acquireWhatsAppGatewayConnectionOwner } from "./socket-close-CT__V2fz.mjs";
+import { n as getStatusCode, t as formatError } from "./session-errors-B8UcAnZN.mjs";
+import { info } from "openclaw/plugin-sdk/runtime-env";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
-import { clamp } from "openclaw/plugin-sdk/text-utility-runtime";
-import { randomUUID } from "node:crypto";
-//#region extensions/whatsapp/src/reconnect.ts
-const DEFAULT_HEARTBEAT_SECONDS = 60;
-const DEFAULT_RECONNECT_POLICY = {
-	initialMs: 2e3,
-	maxMs: 3e4,
-	factor: 1.8,
-	jitter: .25,
-	maxAttempts: 12
-};
-function resolveHeartbeatSeconds(cfg, overrideSeconds) {
-	const candidate = overrideSeconds;
-	if (typeof candidate === "number" && candidate > 0) return candidate;
-	return DEFAULT_HEARTBEAT_SECONDS;
-}
-function resolveReconnectPolicy(cfg, overrides) {
-	const overrideConfig = overrides ?? {};
-	const merged = {
-		...DEFAULT_RECONNECT_POLICY,
-		...overrideConfig
-	};
-	merged.initialMs = Math.max(250, merged.initialMs);
-	merged.maxMs = Math.max(merged.initialMs, merged.maxMs);
-	merged.factor = clamp(merged.factor, 1.1, 10);
-	merged.jitter = clamp(merged.jitter, 0, 1);
-	merged.maxAttempts = Math.max(0, Math.floor(merged.maxAttempts));
-	return merged;
-}
-function newConnectionId() {
-	return randomUUID();
-}
-//#endregion
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 //#region extensions/whatsapp/src/connection-controller.ts
 const LOGGED_OUT_STATUS = 401;
 const POST_PAIRING_RESTART_STATUS = 515;
@@ -62,15 +30,7 @@ function getLoginSocketRestartMessage(kind) {
 	return kind === "timeout" ? WHATSAPP_LOGIN_TIMEOUT_RESTART_MESSAGE : WHATSAPP_LOGIN_RESTART_MESSAGE;
 }
 function createLiveConnection(params) {
-	let closeResolved = false;
-	let resolveClosePromise = (_reason) => {};
-	const closePromise = new Promise((resolve) => {
-		resolveClosePromise = (reason) => {
-			if (closeResolved) return;
-			closeResolved = true;
-			resolve(reason);
-		};
-	});
+	const close = createDeferred();
 	return {
 		connectionId: params.connectionId,
 		startedAt: Date.now(),
@@ -85,8 +45,8 @@ function createLiveConnection(params) {
 		unregisterTransportActivity: null,
 		openedAfterRecentInbound: params.openedAfterRecentInbound,
 		backgroundTasks: /* @__PURE__ */ new Set(),
-		closePromise,
-		resolveClose: resolveClosePromise,
+		closePromise: close.promise,
+		resolveClose: close.resolve,
 		socketClosed: false
 	};
 }
@@ -259,7 +219,7 @@ var WhatsAppConnectionController = class {
 		this.watchdogCheckMs = params.watchdogCheckMs;
 		this.reconnectPolicy = params.reconnectPolicy;
 		this.abortSignal = params.abortSignal;
-		this.sleep = params.sleep ?? ((ms, signal) => sleepWithAbort(ms, signal));
+		this.sleep = params.sleep ?? sleepWithAbort;
 		this.isNonRetryableStatus = params.isNonRetryableStatus ?? (() => false);
 		this.socketTiming = {
 			...DEFAULT_WHATSAPP_SOCKET_TIMING,
@@ -456,11 +416,11 @@ var WhatsAppConnectionController = class {
 		]);
 	}
 	normalizeCloseReason(reason) {
-		const statusCode = (typeof reason === "object" && reason && "status" in reason ? reason.status : void 0) ?? void 0;
+		const statusCode = reason?.status ?? void 0;
 		return {
 			statusCode,
 			statusLabel: typeof statusCode === "number" ? statusCode : "unknown",
-			isLoggedOut: typeof reason === "object" && reason !== null && "isLoggedOut" in reason && reason.isLoggedOut === true,
+			isLoggedOut: reason.isLoggedOut,
 			error: reason?.error,
 			errorText: formatError(reason)
 		};
@@ -482,18 +442,8 @@ var WhatsAppConnectionController = class {
 			healthState: "conflict",
 			normalized
 		};
-		const retryDecision = this.consumeReconnectAttempt();
-		if (retryDecision.action === "stop") return {
-			action: "stop",
-			reconnectAttempts: retryDecision.reconnectAttempts,
-			healthState: retryDecision.healthState,
-			normalized
-		};
 		return {
-			action: "retry",
-			delayMs: retryDecision.delayMs,
-			reconnectAttempts: retryDecision.reconnectAttempts,
-			healthState: retryDecision.healthState,
+			...this.consumeReconnectAttempt(),
 			normalized
 		};
 	}
@@ -686,4 +636,4 @@ var WhatsAppConnectionController = class {
 	}
 };
 //#endregion
-export { closeWaSocketSoon as a, computeBackoff as c, resolveReconnectPolicy as d, sleepWithAbort as f, closeWaSocket as i, newConnectionId as l, WHATSAPP_WATCHDOG_TIMEOUT_ERROR as n, waitForWhatsAppLoginResult as o, WhatsAppConnectionController as r, DEFAULT_RECONNECT_POLICY as s, WHATSAPP_LOGGED_OUT_QR_MESSAGE as t, resolveHeartbeatSeconds as u };
+export { closeWaSocketSoon as a, closeWaSocket as i, WHATSAPP_WATCHDOG_TIMEOUT_ERROR as n, waitForWhatsAppLoginResult as o, WhatsAppConnectionController as r, WHATSAPP_LOGGED_OUT_QR_MESSAGE as t };

package/dist/.setup/{creds-files-Drg3usj1.mjs → creds-files-CDATZWWM.mjs}

@@ -34,15 +34,9 @@ function resolveWebCredsParentCheck(filePath) {
 		messagePrefix: "WhatsApp credential file path"
 	};
 }
-async function assertWebCredsParentPathSafe(filePath) {
-	await assertNoSymlinkParents(resolveWebCredsParentCheck(filePath));
-}
-function assertWebCredsParentPathSafeSync(filePath) {
-	assertNoSymlinkParentsSync(resolveWebCredsParentCheck(filePath));
-}
 async function assertWebCredsPathRegularFileOrMissing(filePath) {
 	try {
-		await assertWebCredsParentPathSafe(filePath);
+		await assertNoSymlinkParents(resolveWebCredsParentCheck(filePath));
 		await statRegularFile(filePath);
 	} catch (error) {
 		throw new Error(`WhatsApp credential file path is unsafe; creds.json must be a regular file or missing: ${filePath}`, { cause: error });
@@ -50,7 +44,7 @@ async function assertWebCredsPathRegularFileOrMissing(filePath) {
 }
 function readWebCredsJsonRawSync(filePath) {
 	try {
-		assertWebCredsParentPathSafeSync(filePath);
+		assertNoSymlinkParentsSync(resolveWebCredsParentCheck(filePath));
 		const { buffer, stat } = readRegularFileSync({ filePath });
 		return stat.size > 1 ? buffer.toString("utf-8") : null;
 	} catch {
@@ -59,7 +53,7 @@ function readWebCredsJsonRawSync(filePath) {
 }
 async function readWebCredsJsonRaw(filePath) {
 	try {
-		await assertWebCredsParentPathSafe(filePath);
+		await assertNoSymlinkParents(resolveWebCredsParentCheck(filePath));
 		const { buffer, stat } = await readRegularFile({ filePath });
 		return stat.size > 1 ? buffer.toString("utf-8") : null;
 	} catch {
@@ -68,7 +62,7 @@ async function readWebCredsJsonRaw(filePath) {
 }
 function statWebCredsFileSync(filePath) {
 	try {
-		assertWebCredsParentPathSafeSync(filePath);
+		assertNoSymlinkParentsSync(resolveWebCredsParentCheck(filePath));
 		const result = statRegularFileSync(filePath);
 		if (result.missing || result.stat.size <= 1) return null;
 		return {
@@ -82,7 +76,7 @@ function statWebCredsFileSync(filePath) {
 function hasWebCredsRegularFileSync(authDir) {
 	try {
 		const credsPath = resolveWebCredsPath(authDir);
-		assertWebCredsParentPathSafeSync(credsPath);
+		assertNoSymlinkParentsSync(resolveWebCredsParentCheck(credsPath));
 		return !statRegularFileSync(credsPath).missing;
 	} catch {
 		return false;

package/dist/.setup/{directory-config-BHPoBklt.mjs → directory-config-DUiJ5d8I.mjs}

@@ -1,11 +1,10 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-D_NGDjCx.mjs";
+import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-CtRPAQCL.mjs";
 import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BGra1ZnM.mjs";
 import { i as hasPendingWhatsAppConnectionOwner, r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-hgLJoRc8.mjs";
-import "./normalize-DdsROMMa.mjs";
-import { M as waitForCredsSaveQueueWithTimeout, f as readWebAuthExistsForDecision } from "./auth-store-Dh8a3cba.mjs";
+import { M as waitForCredsSaveQueueWithTimeout, f as readWebAuthExistsForDecision } from "./auth-store-BBonwKks.mjs";
 import { n as resolveWebAccountId } from "./active-listener-CDjoX9QR.mjs";
-import { a as waitForWaConnection, h as acquireWhatsAppStandaloneConnectionOwner, n as createWaDirectorySocket, p as WhatsAppConnectionOwnerBusyError, t as closeWhatsAppSocketAndWait } from "./socket-close-CCVSFufF.mjs";
+import { b as acquireWhatsAppStandaloneConnectionOwner, i as waitForWaConnection, n as createWaDirectorySocket, t as closeWhatsAppSocketAndWait, v as WhatsAppConnectionOwnerBusyError } from "./socket-close-CT__V2fz.mjs";
 import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
 //#region extensions/whatsapp/src/directory-config.ts
 var directory_config_exports = /* @__PURE__ */ __exportAll({
@@ -15,16 +14,13 @@ var directory_config_exports = /* @__PURE__ */ __exportAll({
 	listWhatsAppDirectoryGroupsLive: () => listWhatsAppDirectoryGroupsLive,
 	listWhatsAppDirectoryPeersFromConfig: () => listWhatsAppDirectoryPeersFromConfig
 });
-function resolveWhatsAppDirectoryAccount(cfg, accountId) {
-	return resolveMergedWhatsAppAccountConfig({
-		cfg,
-		accountId
-	});
-}
 async function listWhatsAppDirectoryPeersFromConfig(params) {
 	return listResolvedDirectoryUserEntriesFromAllowFrom({
 		...params,
-		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAccount: (cfg, accountId) => resolveMergedWhatsAppAccountConfig({
+			cfg,
+			accountId
+		}),
 		resolveAllowFrom: (account) => account.allowFrom,
 		normalizeId: (entry) => {
 			const normalized = normalizeWhatsAppTarget(entry);
@@ -36,7 +32,10 @@ async function listWhatsAppDirectoryPeersFromConfig(params) {
 async function listWhatsAppDirectoryGroupsFromConfig(params) {
 	return listResolvedDirectoryGroupEntriesFromMapKeys({
 		...params,
-		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAccount: (cfg, accountId) => resolveMergedWhatsAppAccountConfig({
+			cfg,
+			accountId
+		}),
 		resolveGroups: (account) => account.groups
 	});
 }
@@ -127,7 +126,7 @@ async function finishPriorStandaloneCleanup(authDir) {
 	}
 }
 async function listGroupsThroughStandaloneOwner(params) {
-	const account = resolveWhatsAppDirectoryAccount(params.cfg, params.accountId);
+	const account = resolveMergedWhatsAppAccountConfig(params);
 	const authDir = resolveWhatsAppAuthDir({
 		cfg: params.cfg,
 		accountId: account.accountId

package/dist/.setup/doctor-iMwg0Vhr.mjs

@@ -0,0 +1,222 @@
+import { n as __reExport, t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+//#region packages/normalization-core/src/record-coerce.ts
+/** Type guard for non-array object records at browser-safe boundaries. */
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Returns a non-array record or null. */
+function asNullableRecord(value) {
+	return isRecord(value) ? value : null;
+}
+//#endregion
+//#region src/config/channel-config-normalization.ts
+/** Applies one channel-specific doctor migration to every object-shaped account. */
+function normalizeChannelAccounts(params) {
+	const rawAccounts = asNullableRecord(params.entry.accounts);
+	if (!rawAccounts) return {
+		entry: params.entry,
+		changed: false
+	};
+	let changed = false;
+	const accounts = { ...rawAccounts };
+	for (const [accountId, value] of Object.entries(rawAccounts)) {
+		const account = asNullableRecord(value);
+		if (!account) continue;
+		const normalized = params.normalizeAccount({
+			account,
+			accountId,
+			pathPrefix: `${params.pathPrefix}.accounts.${accountId}`,
+			changes: params.changes
+		});
+		if (normalized.changed) {
+			accounts[accountId] = normalized.entry;
+			changed = true;
+		}
+	}
+	return changed ? {
+		entry: {
+			...params.entry,
+			accounts
+		},
+		changed: true
+	} : {
+		entry: params.entry,
+		changed: false
+	};
+}
+/** Applies the same channel-specific doctor migration at root and account scope. */
+function normalizeChannelConfigEntries(params) {
+	const changes = params.changes ?? [];
+	const channels = params.cfg.channels;
+	const entry = asNullableRecord(channels?.[params.channelId]);
+	if (!entry) return {
+		config: params.cfg,
+		changes
+	};
+	const channelPath = `channels.${params.channelId}`;
+	const root = params.normalizeEntry({
+		entry,
+		pathPrefix: channelPath,
+		changes
+	});
+	const accounts = normalizeChannelAccounts({
+		entry: root.entry,
+		pathPrefix: channelPath,
+		changes,
+		normalizeAccount: (accountParams) => params.normalizeEntry({
+			entry: accountParams.account,
+			accountId: accountParams.accountId,
+			pathPrefix: accountParams.pathPrefix,
+			changes: accountParams.changes
+		})
+	});
+	if (!root.changed && !accounts.changed) return {
+		config: params.cfg,
+		changes
+	};
+	return {
+		config: {
+			...params.cfg,
+			channels: {
+				...channels,
+				[params.channelId]: accounts.entry
+			}
+		},
+		changes
+	};
+}
+//#endregion
+//#region src/plugin-sdk/legacy-webhook-listener-migration.ts
+/** Preserve explicitly configured webhook listeners while moving ingress onto Gateway routes. */
+function createLegacyWebhookListenerDoctorContract(params) {
+	const portKey = params.portKey ?? "webhookPort";
+	const hostKey = params.hostKey === void 0 ? "webhookHost" : params.hostKey;
+	const source = (entry) => params.webhookKey ? asNullableRecord(entry[params.webhookKey]) : entry;
+	const hasLegacy = (value) => {
+		const entry = asNullableRecord(value);
+		const listener = entry && source(entry);
+		return Boolean(listener && (Object.hasOwn(listener, portKey) || hostKey && Object.hasOwn(listener, hostKey)));
+	};
+	const prefix = `channels.${params.channelKey}`;
+	return {
+		legacyConfigRules: [{
+			path: ["channels", params.channelKey],
+			message: `${prefix} webhook listeners moved to Gateway routes. Run "openclaw doctor --fix" to preserve explicitly configured listener settings as legacyWebhook.`,
+			match: (value) => {
+				const accounts = asNullableRecord(asNullableRecord(value)?.accounts);
+				return hasLegacy(value) || Object.values(accounts ?? {}).some(hasLegacy);
+			}
+		}],
+		normalizeCompatibilityConfig: ({ cfg }) => {
+			const root = asNullableRecord(asNullableRecord(cfg.channels)?.[params.channelKey]);
+			const inherited = root && source(root);
+			const canonicalRoot = asNullableRecord(root?.legacyWebhook);
+			return normalizeChannelConfigEntries({
+				cfg,
+				channelId: params.channelKey,
+				normalizeEntry: ({ entry, accountId, pathPrefix, changes }) => {
+					const listener = source(entry);
+					if (!listener || !hasLegacy(entry)) return {
+						entry,
+						changed: false
+					};
+					const next = { ...entry };
+					const port = Object.hasOwn(listener, portKey) ? listener[portKey] : (accountId ? canonicalRoot?.port ?? inherited?.[portKey] : void 0) ?? params.defaultPort;
+					const inheritedHost = accountId ? canonicalRoot ? canonicalRoot.host : (hostKey ? inherited?.[hostKey] : void 0) ?? params.defaultHost : params.defaultHost;
+					const host = hostKey ? listener[hostKey] ?? inheritedHost : inheritedHost;
+					const legacyPath = [pathPrefix, params.webhookKey].filter(Boolean).join(".");
+					if (Object.hasOwn(entry, "legacyWebhook")) changes.push(`Removed ${legacyPath} legacy listener keys; ${pathPrefix}.legacyWebhook is already configured.`);
+					else if (accountId && root?.legacyWebhook === false) changes.push(`Removed ${legacyPath} legacy listener keys; ${prefix}.legacyWebhook: false keeps this account's inherited listener disabled.`);
+					else {
+						next.legacyWebhook = {
+							port,
+							...host !== void 0 ? { host } : {}
+						};
+						changes.push(`Moved ${legacyPath} listener settings to ${pathPrefix}.legacyWebhook. Point the external callback or reverse proxy at the Gateway port and webhook path, verify delivery, then set legacyWebhook: false to disable legacy forwarding.`);
+					}
+					const updated = params.webhookKey ? { ...listener } : next;
+					delete updated[portKey];
+					if (hostKey) delete updated[hostKey];
+					if (params.webhookKey) {
+						if (Object.keys(updated).length) next[params.webhookKey] = updated;
+						else delete next[params.webhookKey];
+					}
+					return {
+						entry: next,
+						changed: true
+					};
+				}
+			});
+		}
+	};
+}
+//#endregion
+//#region \0openclaw:bundled-sdk:openclaw/plugin-sdk/runtime-doctor-migrations
+var runtime_doctor_migrations_exports = /* @__PURE__ */ __exportAll({ createLegacyWebhookListenerDoctorContract: () => createLegacyWebhookListenerDoctorContract });
+import * as import_openclaw_plugin_sdk_runtime_doctor_migrations from "openclaw/plugin-sdk/runtime-doctor-migrations";
+__reExport(runtime_doctor_migrations_exports, import_openclaw_plugin_sdk_runtime_doctor_migrations);
+//#endregion
+//#region extensions/whatsapp/src/doctor.ts
+function resolveLegacyAckScope(ack) {
+	const direct = ack.direct !== false;
+	const group = ack.group ?? "mentions";
+	if (direct) return group === "always" ? "all" : group === "never" ? "direct" : void 0;
+	return group === "always" ? "group-all" : group === "mentions" ? "group-mentions" : group === "never" ? "off" : void 0;
+}
+function resolveDefaultAgentEmoji(cfg) {
+	const entries = (0, runtime_doctor_migrations_exports.asObjectRecord)((0, runtime_doctor_migrations_exports.asObjectRecord)(cfg.agents)?.entries);
+	const agents = entries ? Object.values(entries).flatMap((value) => {
+		const entry = (0, runtime_doctor_migrations_exports.asObjectRecord)(value);
+		return entry ? [entry] : [];
+	}) : [];
+	const agent = agents.find((entry) => entry.default === true) ?? agents[0];
+	const emoji = (0, runtime_doctor_migrations_exports.asObjectRecord)(agent?.identity)?.emoji;
+	return typeof emoji === "string" ? emoji : void 0;
+}
+function normalizeCompatibilityConfig({ cfg }) {
+	const changes = [];
+	const sources = [];
+	for (const scope of (0, runtime_doctor_migrations_exports.collectChannelAccountScopes)({
+		cfg,
+		channelId: "whatsapp"
+	})) {
+		const ack = (0, runtime_doctor_migrations_exports.asObjectRecord)(scope.account.ackReaction);
+		if (!ack) continue;
+		sources.push({
+			path: `${scope.prefix}.ackReaction`,
+			account: scope.account,
+			...typeof ack.emoji === "string" ? { emoji: ack.emoji } : {},
+			scope: resolveLegacyAckScope(ack),
+			unrepresentableScope: ack.direct !== false && (ack.group ?? "mentions") === "mentions"
+		});
+	}
+	if (sources.length === 0) return {
+		config: cfg,
+		changes
+	};
+	const messages = cfg.messages ??= {};
+	const identityEmoji = resolveDefaultAgentEmoji(cfg) ?? "👀";
+	for (const source of sources) {
+		messages.ackReaction ??= source.emoji ?? identityEmoji;
+		messages.ackReactionScope ??= source.scope;
+		delete source.account.ackReaction;
+		changes.push(`Moved translatable ${source.path} settings to messages ack settings.`);
+	}
+	const finalEmoji = messages.ackReaction.trim();
+	const finalScope = messages.ackReactionScope ?? "group-mentions";
+	const comparableFinalScope = finalScope === "none" ? "off" : finalScope;
+	for (const source of sources) {
+		const sourceEmoji = source.emoji?.trim();
+		if (source.emoji === void 0) changes.push(`${source.path} used a route-dependent agent identity acknowledgement emoji before migration; the final messages.ackReaction is ${JSON.stringify(finalEmoji)}. Review messages.ackReaction.`);
+		else if (sourceEmoji !== finalEmoji) changes.push(`${source.path} requested acknowledgement emoji ${JSON.stringify(sourceEmoji)}, but the final messages.ackReaction is ${JSON.stringify(finalEmoji)}. Review messages.ackReaction.`);
+		if (source.unrepresentableScope) changes.push(`${source.path} migration cannot preserve both direct-message and mentioned-group acknowledgements; the final messages.ackReactionScope is ${JSON.stringify(finalScope)}. Review messages.ackReactionScope.`);
+		else if (source.scope && source.scope !== comparableFinalScope) changes.push(`${source.path} requested acknowledgement scope ${JSON.stringify(source.scope)}, but the final messages.ackReactionScope is ${JSON.stringify(finalScope)}. Review messages.ackReactionScope.`);
+	}
+	return {
+		config: cfg,
+		changes
+	};
+}
+const whatsappDoctor = { normalizeCompatibilityConfig };
+//#endregion
+export { whatsappDoctor as n, runtime_doctor_migrations_exports as r, normalizeCompatibilityConfig as t };

package/dist/.setup/group-config-path-DZr3ucUO.mjs

@@ -0,0 +1,40 @@
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-core";
+//#region extensions/whatsapp/src/group-config-path.ts
+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 normalizePathAccountId(accountId) {
+	return typeof accountId === "string" ? accountId.trim() || DEFAULT_ACCOUNT_ID : DEFAULT_ACCOUNT_ID;
+}
+function hasConfiguredField(config, field) {
+	return Boolean(config && typeof config === "object" && Object.hasOwn(config, field) && config[field] !== void 0);
+}
+function resolveWhatsAppGroupScopeBasePath(params, fields = WHATSAPP_GROUP_SCOPE_FIELDS) {
+	const accountId = normalizePathAccountId(params.accountId);
+	const whatsapp = params.cfg.channels?.whatsapp;
+	const accounts = 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 hasField = (config) => fields.some((field) => hasConfiguredField(config, field));
+	if (hasField(accountConfig)) return `channels.whatsapp.accounts.${accountKey}`;
+	if (accountId !== DEFAULT_ACCOUNT_ID && hasField(defaultAccountConfig)) return `channels.whatsapp.accounts.${defaultAccountKey}`;
+	if (hasField(whatsapp)) return "channels.whatsapp";
+}
+function resolveWhatsAppConfigPath(params) {
+	return `${resolveWhatsAppGroupScopeBasePath(params) ?? "channels.whatsapp"}.${params.field}`;
+}
+function resolveWhatsAppGroupsConfigPath(params) {
+	return `${resolveWhatsAppGroupScopeBasePath(params, ["groups"]) ?? resolveWhatsAppGroupScopeBasePath(params) ?? "channels.whatsapp"}.groups`;
+}
+//#endregion
+export { resolveWhatsAppGroupsConfigPath as n, resolveWhatsAppConfigPath as t };

package/dist/.setup/{group-session-key-D22hYMdE.mjs → group-session-key-2-mja4OF.mjs}

@@ -1,8 +1,6 @@
-import { a as resolveWhatsAppAccount } from "./accounts-D_NGDjCx.mjs";
+import { a as resolveWhatsAppAccount } from "./accounts-CtRPAQCL.mjs";
 import { c as normalizeWhatsAppTarget } from "./normalize-target-BGra1ZnM.mjs";
-import "./normalize-DdsROMMa.mjs";
-import { r as jidToE164 } from "./targets-runtime-RBjx3pg_.mjs";
-import "./text-runtime-CHl0iPYe.mjs";
+import { r as jidToE164 } from "./targets-runtime-DmiqXIXO.mjs";
 import { formatMediaPlaceholderText } from "openclaw/plugin-sdk/channel-inbound";
 import { createChannelApprovalAuth } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { isHostedLidUser, isHostedPnUser, isLidUser, isPnUser } from "baileys";
@@ -96,11 +94,7 @@ function lookupInboundMessageMetaForTarget(accountId, targetJid, messageId) {
 	const exact = lookupInboundMessageMeta(accountId, targetJid, messageId);
 	if (exact) return {
 		remoteJid: targetJid,
-		participant: exact.participant,
-		participantE164: exact.participantE164,
-		body: exact.body,
-		media: exact.media,
-		fromMe: exact.fromMe
+		...exact
 	};
 	const prefix = `${accountId}:`;
 	const suffix = `:${messageId}`;

package/dist/.setup/{login-2dmd1TfE.mjs → login-BFlvSh9h.mjs}

@@ -1,11 +1,12 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { a as resolveWhatsAppAccount } from "./accounts-D_NGDjCx.mjs";
-import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-Dh8a3cba.mjs";
-import { f as renderQrTerminal, r as createWaSocket, u as resolveWhatsAppSocketTiming } from "./socket-close-CCVSFufF.mjs";
-import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-C60mU7j7.mjs";
+import { t as __exportAll } from "./rolldown-runtime-BBjsoOtd.mjs";
+import { a as resolveWhatsAppAccount } from "./accounts-CtRPAQCL.mjs";
+import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-BBonwKks.mjs";
+import { _ as renderQrTerminal, h as resolveWhatsAppSocketTiming, r as createWaSocket } from "./socket-close-CT__V2fz.mjs";
+import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-CHo1oRJA.mjs";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { logInfo } from "openclaw/plugin-sdk/logging-core";
 import { danger, defaultRuntime, success } from "openclaw/plugin-sdk/runtime-env";
+import { createDeferred } from "openclaw/plugin-sdk/extension-shared";
 import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";
 //#region extensions/whatsapp/src/login.ts
 var login_exports = /* @__PURE__ */ __exportAll({ loginWeb: () => loginWeb });
@@ -20,14 +21,11 @@ async function loginWeb(verbose, waitForConnection, runtime = defaultRuntime, ac
 	const socketTiming = resolveWhatsAppSocketTiming();
 	const restoredFromBackup = await restoreCredsFromBackupIfNeeded(account.authDir, { beforeCredentialPersistence: options?.beforeCredentialPersistence });
 	const credentialPersistenceState = { failure: null };
-	let resolveCredentialPersistenceFailure = (_failure) => {};
-	const credentialPersistenceFailurePromise = new Promise((resolve) => {
-		resolveCredentialPersistenceFailure = resolve;
-	});
+	const credentialPersistenceFailure = createDeferred();
 	const onCredentialPersistenceError = (error) => {
 		if (credentialPersistenceState.failure) return;
 		credentialPersistenceState.failure = { error };
-		resolveCredentialPersistenceFailure(credentialPersistenceState.failure);
+		credentialPersistenceFailure.resolve(credentialPersistenceState.failure);
 	};
 	const credentialPersistenceTasks = /* @__PURE__ */ new Set();
 	const onCredentialPersistenceTask = (task) => {
@@ -84,7 +82,7 @@ async function loginWeb(verbose, waitForConnection, runtime = defaultRuntime, ac
 			onQr,
 			...credentialPersistenceOptions,
 			...options?.beforeCredentialPersistence ? {
-				credentialPersistenceFailure: credentialPersistenceFailurePromise,
+				credentialPersistenceFailure: credentialPersistenceFailure.promise,
 				getCredentialPersistenceFailure: () => credentialPersistenceState.failure,
 				waitForCredentialPersistence
 			} : {},