@openclaw/whatsapp 2026.5.7 → 2026.5.9-beta.1

package/dist/session-BXC3R43P.js

@@ -0,0 +1,198 @@
+import { n as resolveWebCredsBackupPath, r as resolveWebCredsPath } from "./creds-files-_2V8jzQa.js";
+import { n as getStatusCode } from "./session-errors-CSuKZPub.js";
+import { C as waitForCredsSaveQueueWithTimeout, l as readCredsJsonRaw, v as resolveDefaultWebAuthDir, w as writeCredsJsonAtomically, x as enqueueCredsSave, y as restoreCredsFromBackupIfNeeded } from "./auth-store-CG0eSZ0D.js";
+import { i as makeWASocket, n as fetchLatestBaileysVersion, o as useMultiFileAuthState, r as makeCacheableSignalKeyStore, t as DisconnectReason } from "./session.runtime-CVhtXjTk.js";
+import fs from "node:fs";
+import { ensureDir, resolveUserPath } from "openclaw/plugin-sdk/text-runtime";
+import { VERSION, formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
+import { danger, getChildLogger as getChildLogger$1, success, toPinoLikeLogger } from "openclaw/plugin-sdk/runtime-env";
+import { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";
+import { randomUUID } from "node:crypto";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { resolveEnvHttpProxyUrl, shouldUseEnvHttpProxyForUrl } from "openclaw/plugin-sdk/fetch-runtime";
+//#region extensions/whatsapp/src/socket-timing.ts
+const DEFAULT_WHATSAPP_SOCKET_TIMING = {
+	keepAliveIntervalMs: 25e3,
+	connectTimeoutMs: 6e4,
+	defaultQueryTimeoutMs: 6e4
+};
+function positiveInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : void 0;
+}
+function resolveWhatsAppSocketTiming(cfg, overrides) {
+	const configured = cfg.web?.whatsapp;
+	return {
+		keepAliveIntervalMs: positiveInteger(overrides?.keepAliveIntervalMs) ?? positiveInteger(configured?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
+		connectTimeoutMs: positiveInteger(overrides?.connectTimeoutMs) ?? positiveInteger(configured?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
+		defaultQueryTimeoutMs: positiveInteger(overrides?.defaultQueryTimeoutMs) ?? positiveInteger(configured?.defaultQueryTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/session.ts
+const LOGGED_OUT_STATUS = DisconnectReason?.loggedOut ?? 401;
+const WHATSAPP_WEBSOCKET_PROXY_TARGET = "https://mmg.whatsapp.net/";
+const CREDS_FLUSH_TIMEOUT_MESSAGE = "Queued WhatsApp creds save did not finish before auth bootstrap; skipping repair and continuing with primary creds.";
+function enqueueSaveCreds(authDir, saveCreds, logger) {
+	enqueueCredsSave(authDir, () => safeSaveCreds(authDir, saveCreds, logger), (err) => {
+		logger.warn({ error: String(err) }, "WhatsApp creds save queue error");
+	});
+}
+async function safeSaveCreds(authDir, saveCreds, logger) {
+	try {
+		const credsPath = resolveWebCredsPath(authDir);
+		const backupPath = resolveWebCredsBackupPath(authDir);
+		const raw = readCredsJsonRaw(credsPath);
+		if (raw) try {
+			JSON.parse(raw);
+			fs.copyFileSync(credsPath, backupPath);
+			try {
+				fs.chmodSync(backupPath, 384);
+			} catch {}
+		} catch {}
+	} catch {}
+	try {
+		await Promise.resolve(saveCreds());
+	} catch (err) {
+		logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+	}
+}
+async function printTerminalQr(qr) {
+	const output = await renderQrTerminal(qr, { small: true });
+	process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+}
+/**
+* Create a Baileys socket backed by the multi-file auth store we keep on disk.
+* Consumers can opt into QR printing for interactive login flows.
+*/
+async function createWaSocket(printQr, verbose, opts = {}) {
+	const logger = toPinoLikeLogger(getChildLogger$1({ module: "baileys" }, { level: verbose ? "info" : "silent" }), verbose ? "info" : "silent");
+	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
+	await ensureDir(authDir);
+	const sessionLogger = getChildLogger$1({ module: "web-session" });
+	if (await waitForCredsSaveQueueWithTimeout(authDir) === "timed_out") sessionLogger.warn({ authDir }, CREDS_FLUSH_TIMEOUT_MESSAGE);
+	else await restoreCredsFromBackupIfNeeded(authDir);
+	const { state } = await useMultiFileAuthState(authDir);
+	const saveCreds = async () => {
+		await writeCredsJsonAtomically(authDir, state.creds);
+	};
+	const { version } = await fetchLatestBaileysVersion();
+	const agent = await resolveEnvProxyAgent(sessionLogger);
+	const fetchAgent = await resolveEnvFetchDispatcher(sessionLogger, agent);
+	const socketTiming = {
+		keepAliveIntervalMs: opts.keepAliveIntervalMs ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
+		connectTimeoutMs: opts.connectTimeoutMs ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
+		defaultQueryTimeoutMs: opts.defaultQueryTimeoutMs ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
+	};
+	const sock = makeWASocket({
+		auth: {
+			creds: state.creds,
+			keys: makeCacheableSignalKeyStore(state.keys, logger)
+		},
+		version,
+		logger,
+		printQRInTerminal: false,
+		browser: [
+			"openclaw",
+			"cli",
+			VERSION
+		],
+		syncFullHistory: false,
+		markOnlineOnConnect: false,
+		...socketTiming,
+		agent,
+		fetchAgent
+	});
+	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger));
+	sock.ev.on("connection.update", async (update) => {
+		try {
+			const { connection, lastDisconnect, qr } = update;
+			if (qr) {
+				opts.onQr?.(qr);
+				if (printQr) {
+					console.log("Open the WhatsApp app, go to Linked Devices, then scan this QR:");
+					printTerminalQr(qr).catch((err) => {
+						sessionLogger.warn({ error: String(err) }, "failed rendering WhatsApp QR");
+					});
+				}
+			}
+			if (connection === "close") {
+				if (getStatusCode(lastDisconnect?.error) === LOGGED_OUT_STATUS) console.error(danger(`WhatsApp session logged out. Run: ${formatCliCommand("openclaw channels login")}`));
+			}
+			if (connection === "open" && verbose) console.log(success("WhatsApp Web connected."));
+		} catch (err) {
+			sessionLogger.error({ error: String(err) }, "connection.update handler error");
+		}
+	});
+	if (sock.ws && typeof sock.ws.on === "function") sock.ws.on("error", (err) => {
+		sessionLogger.error({ error: String(err) }, "WebSocket error");
+	});
+	return sock;
+}
+async function resolveEnvProxyAgent(logger) {
+	if (!shouldUseEnvHttpProxyForUrl(WHATSAPP_WEBSOCKET_PROXY_TARGET)) return;
+	const proxyUrl = resolveEnvHttpProxyUrl("https");
+	if (!proxyUrl) return;
+	try {
+		const agent = new HttpsProxyAgent(proxyUrl);
+		logger.info("Using ambient env proxy for WhatsApp WebSocket connection");
+		return agent;
+	} catch (error) {
+		logger.warn({ error: String(error) }, "Failed to initialize env proxy agent for WhatsApp WebSocket connection");
+		return;
+	}
+}
+async function resolveEnvFetchDispatcher(logger, agent) {
+	const proxyUrl = resolveProxyUrlFromAgent(agent);
+	const envProxyUrl = resolveEnvHttpsProxyUrl();
+	if (!proxyUrl && !envProxyUrl) return;
+	try {
+		const { EnvHttpProxyAgent, ProxyAgent } = await import("undici");
+		return proxyUrl ? new ProxyAgent({
+			allowH2: false,
+			uri: proxyUrl
+		}) : new EnvHttpProxyAgent({ allowH2: false });
+	} catch (error) {
+		logger.warn({ error: String(error) }, "Failed to initialize env proxy dispatcher for WhatsApp media uploads");
+		return;
+	}
+}
+function resolveProxyUrlFromAgent(agent) {
+	if (typeof agent !== "object" || agent === null || !("proxy" in agent)) return;
+	const proxy = agent.proxy;
+	if (proxy instanceof URL) return proxy.toString();
+	return typeof proxy === "string" && proxy.length > 0 ? proxy : void 0;
+}
+function resolveEnvHttpsProxyUrl(env = process.env) {
+	const lowerHttpsProxy = normalizeEnvProxyValue(env.https_proxy);
+	const lowerHttpProxy = normalizeEnvProxyValue(env.http_proxy);
+	const httpsProxy = lowerHttpsProxy !== void 0 ? lowerHttpsProxy : normalizeEnvProxyValue(env.HTTPS_PROXY);
+	const httpProxy = lowerHttpProxy !== void 0 ? lowerHttpProxy : normalizeEnvProxyValue(env.HTTP_PROXY);
+	return httpsProxy ?? httpProxy ?? void 0;
+}
+function normalizeEnvProxyValue(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+async function waitForWaConnection(sock) {
+	return new Promise((resolve, reject) => {
+		const evWithOff = sock.ev;
+		const handler = (...args) => {
+			const update = args[0] ?? {};
+			if (update.connection === "open") {
+				evWithOff.off?.("connection.update", handler);
+				resolve();
+			}
+			if (update.connection === "close") {
+				evWithOff.off?.("connection.update", handler);
+				reject(update.lastDisconnect ?? /* @__PURE__ */ new Error("Connection closed"));
+			}
+		};
+		sock.ev.on("connection.update", handler);
+	});
+}
+function newConnectionId() {
+	return randomUUID();
+}
+//#endregion
+export { renderQrTerminal as a, resolveWhatsAppSocketTiming as i, newConnectionId as n, waitForWaConnection as r, createWaSocket as t };

package/dist/setup-plugin-api.js

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

package/dist/{setup-surface-CF3l3gEZ.js → setup-surface-RbOpXjSR.js}

@@ -1,7 +1,7 @@
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-DG18xddX.js";
 import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-BDqgpFEB.js";
 import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-nXxC_hxG.js";
-import { i as formatWhatsAppWebAuthStatusState, m as readWebAuthState } from "./auth-store-BNZmNP-s.js";
+import { i as formatWhatsAppWebAuthStatusState, m as readWebAuthState } from "./auth-store-CG0eSZ0D.js";
 import { t as whatsappSetupAdapter } from "./setup-core-DZKvpzbH.js";
 import path from "node:path";
 import { DEFAULT_ACCOUNT_ID, pathExists, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup";
@@ -280,7 +280,7 @@ async function finalizeWhatsAppSetup(params) {
 		message: linked ? "WhatsApp already linked. Re-link now?" : "Link WhatsApp now (QR)?",
 		initialValue: !linked
 	})) try {
-		const { loginWeb } = await import("./login-DSUTCcJ7.js").then((n) => n.n);
+		const { loginWeb } = await import("./login-B_u009k0.js").then((n) => n.n);
 		await loginWeb(false, void 0, params.runtime, accountId);
 	} catch (error) {
 		params.runtime.error(`WhatsApp login failed: ${String(error)}`);

package/dist/{shared-CTSTwprn.js → shared-h4cwNeYT.js}

@@ -124,10 +124,10 @@ function resolveWhatsAppConfigPath(params) {
 	return `${resolveWhatsAppGroupScopeBasePath(params)}.${params.field}`;
 }
 async function loadWhatsAppChannelRuntime() {
-	return await import("./channel.runtime-C3i9Svfj.js");
+	return await import("./channel.runtime-CCZpOzbU.js");
 }
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-CF3l3gEZ.js");
+	return await import("./setup-surface-RbOpXjSR.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({

package/dist/{state-migrations-DnCdvoYD.js → state-migrations-Bm0S67yH.js}

@@ -1,10 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
+import { statRegularFileSync } from "openclaw/plugin-sdk/security-runtime";
 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();
+		return !statRegularFileSync(pathValue).missing;
 	} catch {
 		return false;
 	}

package/dist/test-api.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/whatsapp",
-  "version": "2026.5.7",
+  "version": "2026.5.9-beta.1",
   "description": "OpenClaw WhatsApp channel plugin",
   "repository": {
     "type": "git",
@@ -11,7 +11,7 @@
     "@whiskeysockets/baileys": "7.0.0-rc.9",
     "https-proxy-agent": "^9.0.0",
     "jimp": "^1.6.1",
-    "typebox": "1.1.37",
+    "typebox": "1.1.38",
     "undici": "8.2.0"
   },
   "devDependencies": {
@@ -19,7 +19,7 @@
     "openclaw": "workspace:*"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.5.7"
+    "openclaw": ">=2026.5.9-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -61,10 +61,10 @@
       "minHostVersion": ">=2026.4.25"
     },
     "compat": {
-      "pluginApi": ">=2026.5.7"
+      "pluginApi": ">=2026.5.9-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.7"
+      "openclawVersion": "2026.5.9-beta.1"
     },
     "release": {
       "publishToClawHub": true,

package/dist/{access-control-CTj7P7WP.js → access-control-hFVqAWSd.js}

@@ -3,11 +3,11 @@ import { r as isSelfChatMode, t as text_runtime_exports } from "./text-runtime-D
 import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-DhaC0MoD.js";
 import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-Gp1lQ0at.js";
 import { defaultRuntime } from "openclaw/plugin-sdk/runtime-env";
+import { expandAllowFromWithAccessGroups, readStoreAllowFromForDmPolicy, resolveDmGroupAccessWithCommandGate, resolveDmGroupAccessWithLists, resolveEffectiveAllowFromLists } from "openclaw/plugin-sdk/security-runtime";
 import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
 import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
 import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
 import { resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
-import { expandAllowFromWithAccessGroups, readStoreAllowFromForDmPolicy, resolveDmGroupAccessWithCommandGate, resolveDmGroupAccessWithLists, resolveEffectiveAllowFromLists } from "openclaw/plugin-sdk/security-runtime";
 import { resolveGroupSessionKey } from "openclaw/plugin-sdk/session-store-runtime";
 //#region extensions/whatsapp/src/inbound-policy.ts
 function resolveGroupConversationId(conversationId) {