@openclaw/whatsapp 2026.7.2-beta.2 → 2026.7.2-beta.3

package/dist/directory-config-BZ775eGX.js

@@ -0,0 +1,196 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { c as resolveMergedWhatsAppAccountConfig, o as resolveWhatsAppAuthDir } from "./accounts-ejK8sXPU.js";
+import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
+import { i as hasPendingWhatsAppConnectionOwner, r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-9mEeAvu1.js";
+import "./normalize-C-Z16y7Q.js";
+import { f as readWebAuthExistsForDecision, w as waitForCredsSaveQueueWithTimeout } from "./auth-store-BQi9pZqQ.js";
+import { n as resolveWebAccountId } from "./active-listener-BbdlXooT.js";
+import { a as waitForWaConnection, h as acquireWhatsAppStandaloneConnectionOwner, n as createWaDirectorySocket, p as WhatsAppConnectionOwnerBusyError, t as closeWhatsAppSocketAndWait } from "./socket-close-jNGyZY4T.js";
+import { listResolvedDirectoryGroupEntriesFromMapKeys, listResolvedDirectoryUserEntriesFromAllowFrom } from "openclaw/plugin-sdk/directory-config-runtime";
+//#region extensions/whatsapp/src/directory-config.ts
+var directory_config_exports = /* @__PURE__ */ __exportAll({
+	WHATSAPP_DIRECTORY_UNAVAILABLE_CODE: () => WHATSAPP_DIRECTORY_UNAVAILABLE_CODE,
+	WhatsAppDirectoryUnavailableError: () => WhatsAppDirectoryUnavailableError,
+	listWhatsAppDirectoryGroupsFromConfig: () => listWhatsAppDirectoryGroupsFromConfig,
+	listWhatsAppDirectoryGroupsLive: () => listWhatsAppDirectoryGroupsLive,
+	listWhatsAppDirectoryPeersFromConfig: () => listWhatsAppDirectoryPeersFromConfig
+});
+function resolveWhatsAppDirectoryAccount(cfg, accountId) {
+	return resolveMergedWhatsAppAccountConfig({
+		cfg,
+		accountId
+	});
+}
+async function listWhatsAppDirectoryPeersFromConfig(params) {
+	return listResolvedDirectoryUserEntriesFromAllowFrom({
+		...params,
+		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveAllowFrom: (account) => account.allowFrom,
+		normalizeId: (entry) => {
+			const normalized = normalizeWhatsAppTarget(entry);
+			if (!normalized || isWhatsAppGroupJid(normalized)) return null;
+			return normalized;
+		}
+	});
+}
+async function listWhatsAppDirectoryGroupsFromConfig(params) {
+	return listResolvedDirectoryGroupEntriesFromMapKeys({
+		...params,
+		resolveAccount: resolveWhatsAppDirectoryAccount,
+		resolveGroups: (account) => account.groups
+	});
+}
+const WHATSAPP_DIRECTORY_UNAVAILABLE_CODE = "whatsapp_directory_unavailable";
+var WhatsAppDirectoryUnavailableError = class extends Error {
+	constructor(reason, message, options) {
+		super(message, options);
+		this.reason = reason;
+		this.code = WHATSAPP_DIRECTORY_UNAVAILABLE_CODE;
+		this.name = "WhatsAppDirectoryUnavailableError";
+	}
+};
+async function fetchLiveGroups(sock, params) {
+	const groups = await sock.groupFetchAllParticipating();
+	const query = params.query?.trim().toLowerCase() ?? "";
+	const limit = typeof params.limit === "number" && params.limit > 0 ? params.limit : void 0;
+	const entries = Object.entries(groups).map(([jid, metadata]) => ({
+		kind: "group",
+		id: jid,
+		name: metadata?.subject?.trim() || void 0
+	})).filter((entry) => {
+		if (!query) return true;
+		return entry.id.toLowerCase().includes(query) || entry.name?.toLowerCase().includes(query);
+	}).toSorted((left, right) => left.id.localeCompare(right.id));
+	return limit ? entries.slice(0, limit) : entries;
+}
+function unavailable(reason, message, cause) {
+	return new WhatsAppDirectoryUnavailableError(reason, message, cause ? { cause } : void 0);
+}
+const pendingStandaloneCleanups = /* @__PURE__ */ new Map();
+const STANDALONE_CLEANUP_RETRY_MS = 1e3;
+async function completeStandaloneCleanup(cleanup) {
+	if (cleanup.sock && !cleanup.socketClosed) {
+		await closeWhatsAppSocketAndWait(cleanup.sock, "OpenClaw WhatsApp standalone directory socket close");
+		cleanup.socketClosed = true;
+	}
+	if (cleanup.sock) {
+		if (await waitForCredsSaveQueueWithTimeout(cleanup.authDir) === "timed_out") throw new Error("WhatsApp credential persistence did not drain before socket release");
+	}
+	await cleanup.ownerLease.release();
+	if (pendingStandaloneCleanups.get(cleanup.authDir) === cleanup) pendingStandaloneCleanups.delete(cleanup.authDir);
+	if (cleanup.retryTimer) {
+		clearTimeout(cleanup.retryTimer);
+		cleanup.retryTimer = null;
+	}
+}
+function runStandaloneCleanup(cleanup) {
+	if (cleanup.inFlight) return cleanup.inFlight;
+	const task = completeStandaloneCleanup(cleanup).finally(() => {
+		if (cleanup.inFlight === task) cleanup.inFlight = null;
+	});
+	cleanup.inFlight = task;
+	return task;
+}
+function scheduleStandaloneCleanupRetry(cleanup) {
+	if (cleanup.retryTimer) return;
+	cleanup.retryTimer = setTimeout(() => {
+		cleanup.retryTimer = null;
+		runStandaloneCleanup(cleanup).catch(() => {
+			scheduleStandaloneCleanupRetry(cleanup);
+		});
+	}, STANDALONE_CLEANUP_RETRY_MS);
+	cleanup.retryTimer.unref?.();
+}
+function retainStandaloneCleanup(cleanup) {
+	pendingStandaloneCleanups.set(cleanup.authDir, cleanup);
+	scheduleStandaloneCleanupRetry(cleanup);
+}
+async function finishStandaloneCleanupOrThrow(cleanup, operationError) {
+	try {
+		await runStandaloneCleanup(cleanup);
+	} catch (cleanupError) {
+		retainStandaloneCleanup(cleanup);
+		throw cleanupUnavailable(operationError === void 0 ? cleanupError : new AggregateError([operationError, cleanupError], "WhatsApp live group lookup and cleanup failed", { cause: operationError }));
+	}
+}
+function cleanupUnavailable(error) {
+	return unavailable("cleanup_failed", "WhatsApp live group lookup could not safely close its standalone connection.", error);
+}
+async function finishPriorStandaloneCleanup(authDir) {
+	const cleanup = pendingStandaloneCleanups.get(authDir);
+	if (!cleanup) return;
+	try {
+		await runStandaloneCleanup(cleanup);
+	} catch (error) {
+		scheduleStandaloneCleanupRetry(cleanup);
+		throw cleanupUnavailable(error);
+	}
+}
+async function listGroupsThroughStandaloneOwner(params) {
+	const account = resolveWhatsAppDirectoryAccount(params.cfg, params.accountId);
+	const authDir = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId: account.accountId
+	}).authDir;
+	await finishPriorStandaloneCleanup(authDir);
+	let ownerLease;
+	try {
+		ownerLease = await acquireWhatsAppStandaloneConnectionOwner(authDir);
+	} catch (error) {
+		if (error instanceof WhatsAppConnectionOwnerBusyError) throw unavailable("connection_owner_busy", "WhatsApp live groups are unavailable because the account is owned by another process.", error);
+		throw unavailable("connection_failed", "WhatsApp live groups are unavailable because connection ownership failed.", error);
+	}
+	const cleanup = {
+		authDir,
+		inFlight: null,
+		ownerLease,
+		retryTimer: null,
+		sock: null,
+		socketClosed: true
+	};
+	let groups;
+	try {
+		let authState;
+		try {
+			authState = await readWebAuthExistsForDecision(authDir);
+		} catch (error) {
+			throw unavailable("auth_unstable", "WhatsApp live groups are unavailable because linked credentials could not be read.", error);
+		}
+		if (authState.outcome === "unstable") throw unavailable("auth_unstable", "WhatsApp live groups are unavailable while linked credentials are changing.");
+		if (!authState.exists) throw unavailable("not_linked", "WhatsApp live groups are unavailable because this account is not linked.");
+		try {
+			cleanup.sock = await createWaDirectorySocket(authDir);
+			cleanup.socketClosed = false;
+			await waitForWaConnection(cleanup.sock, { timeoutMs: 3e4 });
+		} catch (error) {
+			throw unavailable("connection_failed", "WhatsApp live groups are unavailable because the standalone connection failed.", error);
+		}
+		try {
+			groups = await fetchLiveGroups(cleanup.sock, params);
+		} catch (error) {
+			throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
+		}
+	} catch (error) {
+		await finishStandaloneCleanupOrThrow(cleanup, error);
+		throw error;
+	}
+	await finishStandaloneCleanupOrThrow(cleanup);
+	return groups;
+}
+async function listWhatsAppDirectoryGroupsLive(params) {
+	const accountId = resolveWebAccountId({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const controller = getWhatsAppConnectionController(accountId);
+	if (!controller && !hasPendingWhatsAppConnectionOwner(accountId)) return await listGroupsThroughStandaloneOwner(params);
+	const sock = controller?.getCurrentSock();
+	if (!sock) throw unavailable("active_owner_unavailable", "WhatsApp live groups are unavailable while the gateway connection is offline.");
+	try {
+		return await fetchLiveGroups(sock, params);
+	} catch (error) {
+		throw unavailable("lookup_failed", "WhatsApp live group lookup failed.", error);
+	}
+}
+//#endregion
+export { listWhatsAppDirectoryGroupsFromConfig as n, listWhatsAppDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/directory-contract-api.js

@@ -1,4 +1,4 @@
-import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-CLBQrjtC.js";
+import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-BZ775eGX.js";
 //#region extensions/whatsapp/directory-contract-api.ts
 const whatsappDirectoryContractPlugin = {
 	id: "whatsapp",

package/dist/{group-session-key-CLTZeH_F.js → group-session-key-Dh8WZun_.js}

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { c as normalizeWhatsAppTarget } from "./normalize-target-DSZnHkKF.js";
 import "./normalize-C-Z16y7Q.js";
 import { r as jidToE164 } from "./targets-runtime-Bsh0HR9y.js";

package/dist/light-runtime-api.js

@@ -1,5 +1,5 @@
 import { t as createWhatsAppLoginTool } from "./agent-tools-login-DfyToBpG.js";
 import { c as logoutWeb, g as readWebSelfId, l as pickWebChannel, o as getWebAuthAgeMs, s as logWebSelfId, t as WA_WEB_AUTH_DIR, x as webAuthExists, y as resolveDefaultWebAuthDir } from "./auth-store-BQi9pZqQ.js";
+import { t as getActiveWebListener } from "./active-listener-BbdlXooT.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
-import { t as getActiveWebListener } from "./active-listener-5kHap439.js";
 export { WA_WEB_AUTH_DIR, createWhatsAppLoginTool, formatError, getActiveWebListener, getStatusCode, getWebAuthAgeMs, logWebSelfId, logoutWeb, pickWebChannel, readWebSelfId, resolveDefaultWebAuthDir, webAuthExists };

package/dist/{login-DGIoToX8.js → login-ifOXCBjo.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-BQi9pZqQ.js";
-import { c as resolveWhatsAppSocketTiming, t as createWaSocket, u as renderQrTerminal } from "./session-mxWFn0eS.js";
-import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-C1rwfWb4.js";
+import { f as renderQrTerminal, r as createWaSocket, u as resolveWhatsAppSocketTiming } from "./socket-close-jNGyZY4T.js";
+import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-HGaffeFb.js";
 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";

package/dist/{login-qr-X-CZHOk9.js → login-qr-DUHzVH_Y.js}

@@ -1,9 +1,9 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { c as logoutWeb, f as readWebAuthExistsForDecision, g as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-BQi9pZqQ.js";
-import { c as resolveWhatsAppSocketTiming, t as createWaSocket } from "./session-mxWFn0eS.js";
+import { t as getActiveWebListener } from "./active-listener-BbdlXooT.js";
+import { r as createWaSocket, u as resolveWhatsAppSocketTiming } from "./socket-close-jNGyZY4T.js";
 import { t as formatError } from "./session-errors-JuazczrA.js";
-import { t as getActiveWebListener } from "./active-listener-5kHap439.js";
-import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-C1rwfWb4.js";
+import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-HGaffeFb.js";
 import { logInfo } from "openclaw/plugin-sdk/logging-core";
 import { danger, defaultRuntime, info, success } from "openclaw/plugin-sdk/runtime-env";
 import { renderQrPngDataUrl } from "openclaw/plugin-sdk/media-runtime";

package/dist/login-qr-runtime.js

@@ -1,6 +1,6 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/whatsapp/login-qr-runtime.ts
-const loadLoginQrModule = createLazyRuntimeModule(() => import("./login-qr-X-CZHOk9.js"));
+const loadLoginQrModule = createLazyRuntimeModule(() => import("./login-qr-DUHzVH_Y.js"));
 async function startWebLoginWithQr(...args) {
 	const { startWebLoginWithQr: startWebLoginWithQrLocal } = await loadLoginQrModule();
 	return await startWebLoginWithQrLocal(...args);