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

package/dist/{setup-core-3aSOoK2T.js → shared-CuqHFnKd.js}

@@ -1,8 +1,8 @@
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CxPuEFi-.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CKOFMPf-.js";
 import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-DSZnHkKF.js";
-import { t as WhatsAppChannelConfigSchema } from "./config-schema-BZ8h1hWA.js";
-import { n as whatsappDoctor } from "./doctor-By3SB4lm.js";
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-C6IeKIC0.js";
+import { n as whatsappDoctor } from "./doctor-CwzVXKoE.js";
 import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.js";
 import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.js";
 import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-nAzD945y.js";
@@ -11,12 +11,24 @@ import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-
 import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
 import { createChannelPluginBase } from "openclaw/plugin-sdk/core";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { buildChannelGroupsScopeTree, collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
+import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
 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";
-import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
+//#region extensions/whatsapp/src/channel-runtime-loader.ts
+const loadWhatsAppAuthStore = createLazyRuntimeModule(() => import("./auth-store-DirYMTbo.js").then((n) => n.i));
+async function isWhatsAppAuthConfigured(authDir) {
+	return await (await loadWhatsAppAuthStore()).readWebAuthState(authDir) === "linked";
+}
+const loadWhatsAppChannelRuntime = createLazyRuntimeModule(async () => {
+	await loadWhatsAppAuthStore();
+	return await import("./channel.runtime-DdKuhlNu.js");
+});
+//#endregion
 //#region extensions/whatsapp/src/config-accessors.ts
 function formatWhatsAppConfigAllowFromEntries(allowFrom) {
 	return normalizeWhatsAppAllowFromEntries(allowFrom);
@@ -41,6 +53,62 @@ function resolveWhatsAppGroupToolPolicy(params) {
 	});
 }
 //#endregion
+//#region extensions/whatsapp/src/setup-core.ts
+const channel = "whatsapp";
+const whatsappSetupAdapter = {
+	singleAccountKeysToMove: ["authDir"],
+	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
+	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+		cfg,
+		channelKey: channel,
+		accountId,
+		name,
+		alwaysUseAccounts: true
+	}),
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const setupInput = input;
+		const next = migrateBaseNameToDefaultAccount({
+			cfg: applyAccountNameToChannelSection({
+				cfg,
+				channelKey: channel,
+				accountId,
+				name: setupInput.name,
+				alwaysUseAccounts: true
+			}),
+			channelKey: channel,
+			alwaysUseAccounts: true
+		});
+		const entry = {
+			...next.channels?.whatsapp?.accounts?.[accountId],
+			...setupInput.authDir ? { authDir: setupInput.authDir } : {},
+			enabled: true
+		};
+		return {
+			...next,
+			channels: {
+				...next.channels,
+				whatsapp: {
+					...next.channels?.whatsapp,
+					accounts: {
+						...next.channels?.whatsapp?.accounts,
+						[accountId]: entry
+					}
+				}
+			}
+		};
+	}
+};
+const whatsappSetupContract = defineChannelSetupContract({
+	fields: { authDir: {
+		kind: "string",
+		cli: {
+			flags: "--auth-dir <path>",
+			description: "WhatsApp auth directory override"
+		}
+	} },
+	legacyAdapter: whatsappSetupAdapter
+});
+//#endregion
 //#region extensions/whatsapp/src/security-fix.ts
 function applyGroupAllowFromFromStore(params) {
 	const next = structuredClone(params.cfg ?? {});
@@ -83,11 +151,8 @@ async function applyWhatsAppSecurityConfigFixes(params) {
 //#endregion
 //#region extensions/whatsapp/src/shared.ts
 const WHATSAPP_CHANNEL = "whatsapp";
-async function loadWhatsAppChannelRuntime() {
-	return await import("./channel.runtime-BDDy4Lhz.js");
-}
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-CiKGdNJv.js");
+	return await import("./setup-surface-Kv3mPki2.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({
@@ -191,7 +256,7 @@ function createWhatsAppPluginBase(params) {
 			docsLabel: "whatsapp",
 			blurb: "works with your own number; recommend a separate phone + eSIM.",
 			systemImage: "message",
-			showConfigured: false,
+			exposure: { configured: false },
 			quickstartAllowFrom: true,
 			forceAccountBinding: true,
 			preferSessionLookupForAnnounceTarget: true
@@ -213,7 +278,7 @@ function createWhatsAppPluginBase(params) {
 		},
 		reload: {
 			configPrefixes: [
-				"web",
+				"channels.whatsapp.enabled",
 				"channels.whatsapp.accounts",
 				"channels.whatsapp.selfChatMode"
 			],
@@ -223,7 +288,7 @@ function createWhatsAppPluginBase(params) {
 		configSchema: WhatsAppChannelConfigSchema,
 		config: {
 			...whatsappConfigAdapter,
-			isEnabled: (account, cfg) => account.enabled && cfg.web?.enabled !== false,
+			isEnabled: (account) => account.enabled,
 			disabledReason: () => "disabled",
 			isConfigured: params.isConfigured,
 			hasPersistedAuthState: ({ cfg }) => hasAnyWhatsAppAuth(cfg),
@@ -245,6 +310,7 @@ function createWhatsAppPluginBase(params) {
 		},
 		doctor: whatsappDoctor,
 		setup: params.setup,
+		...params.setupContract ? { setupContract: params.setupContract } : {},
 		groups: params.groups
 	});
 	return {
@@ -274,48 +340,4 @@ function createWhatsAppPluginBase(params) {
 	};
 }
 //#endregion
-//#region extensions/whatsapp/src/setup-core.ts
-const channel = "whatsapp";
-const whatsappSetupAdapter = {
-	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
-	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
-		cfg,
-		channelKey: channel,
-		accountId,
-		name,
-		alwaysUseAccounts: true
-	}),
-	applyAccountConfig: ({ cfg, accountId, input }) => {
-		const next = migrateBaseNameToDefaultAccount({
-			cfg: applyAccountNameToChannelSection({
-				cfg,
-				channelKey: channel,
-				accountId,
-				name: input.name,
-				alwaysUseAccounts: true
-			}),
-			channelKey: channel,
-			alwaysUseAccounts: true
-		});
-		const entry = {
-			...next.channels?.whatsapp?.accounts?.[accountId],
-			...input.authDir ? { authDir: input.authDir } : {},
-			enabled: true
-		};
-		return {
-			...next,
-			channels: {
-				...next.channels,
-				whatsapp: {
-					...next.channels?.whatsapp,
-					accounts: {
-						...next.channels?.whatsapp?.accounts,
-						[accountId]: entry
-					}
-				}
-			}
-		};
-	}
-};
-//#endregion
-export { resolveWhatsAppGroupRequireMention as a, whatsappSetupWizardProxy as i, createWhatsAppPluginBase as n, resolveWhatsAppGroupToolPolicy as o, loadWhatsAppChannelRuntime as r, formatWhatsAppConfigAllowFromEntries as s, whatsappSetupAdapter as t };
+export { resolveWhatsAppGroupRequireMention as a, isWhatsAppAuthConfigured as c, whatsappSetupContract as i, loadWhatsAppChannelRuntime as l, whatsappSetupWizardProxy as n, resolveWhatsAppGroupToolPolicy as o, whatsappSetupAdapter as r, formatWhatsAppConfigAllowFromEntries as s, createWhatsAppPluginBase as t };

package/dist/{session-mxWFn0eS.js → socket-close-BoSHhQNJ.js}

@@ -1,14 +1,166 @@
 import { o as resolveWebCredsBackupPath, s as resolveWebCredsPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-B1kSWtBg.js";
-import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-BQi9pZqQ.js";
+import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-DirYMTbo.js";
 import { n as getStatusCode } from "./session-errors-JuazczrA.js";
 import { a as makeWASocket, i as makeCacheableSignalKeyStore, n as createBaileysSignalRepository, r as fetchLatestBaileysVersion, s as useMultiFileAuthState } from "./session.runtime-Nsqaehbd.js";
 import { VERSION, formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { danger, getChildLogger, success, toPinoLikeLogger } from "openclaw/plugin-sdk/runtime-env";
 import { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";
 import { ensureDir, resolveUserPath } from "openclaw/plugin-sdk/text-utility-runtime";
+import fs from "node:fs/promises";
 import { parseStrictPositiveInteger, resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { FILE_LOCK_STALE_ERROR_CODE, FILE_LOCK_TIMEOUT_ERROR_CODE, acquireFileLock } from "openclaw/plugin-sdk/file-lock";
 import { randomUUID } from "node:crypto";
 import { createHttp1EnvHttpProxyAgent, createHttp1ProxyAgent, createNodeProxyAgent } from "openclaw/plugin-sdk/fetch-runtime";
+//#region extensions/whatsapp/src/connection-owner.ts
+const WHATSAPP_CONNECTION_OWNER_BUSY_CODE = "whatsapp_connection_owner_busy";
+var WhatsAppConnectionOwnerBusyError = class extends Error {
+	constructor(authDir, options) {
+		super("Another process owns this WhatsApp connection.", options);
+		this.authDir = authDir;
+		this.code = WHATSAPP_CONNECTION_OWNER_BUSY_CODE;
+		this.name = "WhatsAppConnectionOwnerBusyError";
+	}
+};
+const OWNER_LOCK_STALE_MS = 5 * 6e4;
+const GATEWAY_LOCAL_OWNER_WAIT_MS = 15e4;
+const processOwners = /* @__PURE__ */ new Map();
+function ownershipCancelledError(signal) {
+	const reason = signal?.reason;
+	return reason instanceof Error ? reason : new Error("WhatsApp connection ownership cancelled", reason === void 0 ? {} : { cause: reason });
+}
+async function waitForAbortableDelay(delayMs, signal) {
+	if (signal?.aborted) throw ownershipCancelledError(signal);
+	await new Promise((resolve, reject) => {
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(ownershipCancelledError(signal));
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, delayMs);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+async function reserveProcessOwner(params) {
+	while (true) {
+		if (params.signal?.aborted) throw ownershipCancelledError(params.signal);
+		const current = processOwners.get(params.ownerPath);
+		if (!current) {
+			let resolveReleased = () => {};
+			const owner = {
+				released: new Promise((resolve) => {
+					resolveReleased = resolve;
+				}),
+				resolveReleased,
+				token: Symbol(params.ownerPath)
+			};
+			processOwners.set(params.ownerPath, owner);
+			return owner;
+		}
+		if (!params.waitForLocalOwner) throw new WhatsAppConnectionOwnerBusyError(params.authDir);
+		let timer;
+		let onAbort;
+		const outcome = await Promise.race([
+			current.released.then(() => "released"),
+			new Promise((resolve) => {
+				timer = setTimeout(() => resolve("timed_out"), GATEWAY_LOCAL_OWNER_WAIT_MS);
+				timer.unref?.();
+			}),
+			new Promise((resolve) => {
+				onAbort = () => resolve("aborted");
+				params.signal?.addEventListener("abort", onAbort, { once: true });
+			})
+		]).finally(() => {
+			if (timer) clearTimeout(timer);
+			if (onAbort) params.signal?.removeEventListener("abort", onAbort);
+		});
+		if (outcome === "aborted") throw ownershipCancelledError(params.signal);
+		if (outcome === "timed_out") throw new WhatsAppConnectionOwnerBusyError(params.authDir);
+	}
+}
+function abandonProcessOwner(ownerPath, owner) {
+	if (processOwners.get(ownerPath)?.token !== owner.token) return;
+	processOwners.delete(ownerPath);
+	owner.resolveReleased();
+}
+async function acquireOwnerLease(params) {
+	const resolvedOwnerPath = resolveUserPath(params.authDir);
+	await fs.mkdir(resolvedOwnerPath, { recursive: true });
+	const ownerPath = await fs.realpath(resolvedOwnerPath);
+	const processOwner = await reserveProcessOwner({
+		authDir: params.authDir,
+		ownerPath,
+		signal: params.signal,
+		waitForLocalOwner: params.waitForLocalOwner
+	});
+	let fileLock;
+	let attempt = 0;
+	while (true) {
+		if (params.signal?.aborted) {
+			abandonProcessOwner(ownerPath, processOwner);
+			throw ownershipCancelledError(params.signal);
+		}
+		try {
+			fileLock = await acquireFileLock(ownerPath, {
+				retries: {
+					retries: 0,
+					factor: 1,
+					minTimeout: 1,
+					maxTimeout: 1
+				},
+				stale: OWNER_LOCK_STALE_MS,
+				staleRecovery: "remove-if-unchanged"
+			});
+			break;
+		} catch (error) {
+			const code = error.code;
+			if (code === FILE_LOCK_STALE_ERROR_CODE) {
+				abandonProcessOwner(ownerPath, processOwner);
+				throw new WhatsAppConnectionOwnerBusyError(params.authDir, { cause: error });
+			}
+			if (code !== FILE_LOCK_TIMEOUT_ERROR_CODE || attempt >= params.retries) {
+				abandonProcessOwner(ownerPath, processOwner);
+				if (code === FILE_LOCK_TIMEOUT_ERROR_CODE) throw new WhatsAppConnectionOwnerBusyError(params.authDir, { cause: error });
+				throw error;
+			}
+			const delayMs = Math.min(100 * 1.5 ** attempt, 1e3);
+			attempt += 1;
+			await waitForAbortableDelay(delayMs, params.signal).catch((delayError) => {
+				abandonProcessOwner(ownerPath, processOwner);
+				throw delayError;
+			});
+		}
+	}
+	let releasePromise = null;
+	return { release: async () => {
+		if (!releasePromise) releasePromise = fileLock.release().then(() => {
+			abandonProcessOwner(ownerPath, processOwner);
+		}).catch((releaseError) => {
+			releasePromise = null;
+			throw releaseError;
+		});
+		await releasePromise;
+	} };
+}
+/** Gateway owner waits for a bounded standalone lookup to finish before startup. */
+async function acquireWhatsAppGatewayConnectionOwner(authDir, signal) {
+	return await acquireOwnerLease({
+		authDir,
+		retries: 150,
+		signal,
+		waitForLocalOwner: true
+	});
+}
+/** Standalone lookup fails quickly when a gateway already owns the account. */
+async function acquireWhatsAppStandaloneConnectionOwner(authDir) {
+	return await acquireOwnerLease({
+		authDir,
+		retries: 3,
+		waitForLocalOwner: false
+	});
+}
+//#endregion
 //#region extensions/whatsapp/src/socket-timing.ts
 const socketSendMessageQueueTails = /* @__PURE__ */ new WeakMap();
 const DEFAULT_WHATSAPP_SOCKET_TIMING = {
@@ -25,12 +177,11 @@ var WhatsAppSocketOperationTimeoutError = class extends Error {
 		this.name = "WhatsAppSocketOperationTimeoutError";
 	}
 };
-function resolveWhatsAppSocketTiming(cfg, overrides) {
-	const configured = cfg.web?.whatsapp;
+function resolveWhatsAppSocketTiming(overrides) {
 	return {
-		keepAliveIntervalMs: parseStrictPositiveInteger(overrides?.keepAliveIntervalMs) ?? parseStrictPositiveInteger(configured?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
-		connectTimeoutMs: parseStrictPositiveInteger(overrides?.connectTimeoutMs) ?? parseStrictPositiveInteger(configured?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
-		defaultQueryTimeoutMs: parseStrictPositiveInteger(overrides?.defaultQueryTimeoutMs) ?? parseStrictPositiveInteger(configured?.defaultQueryTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
+		keepAliveIntervalMs: parseStrictPositiveInteger(overrides?.keepAliveIntervalMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.keepAliveIntervalMs,
+		connectTimeoutMs: parseStrictPositiveInteger(overrides?.connectTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.connectTimeoutMs,
+		defaultQueryTimeoutMs: parseStrictPositiveInteger(overrides?.defaultQueryTimeoutMs) ?? DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs
 	};
 }
 function isWhatsAppSocketOperationTimeoutError(error) {
@@ -170,6 +321,9 @@ function resolveEnvWaWebSocketUrl() {
 * Consumers can opt into QR printing for interactive login flows.
 */
 async function createWaSocket(printQr, verbose, opts = {}) {
+	return await createWaSocketInternal(printQr, verbose, opts, "normal");
+}
+async function createWaSocketInternal(printQr, verbose, opts, receiveMode) {
 	const logger = toPinoLikeLogger(getChildLogger({ module: "baileys" }, { level: verbose ? "info" : "silent" }), verbose ? "info" : "silent");
 	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
 	await rejectUnsafeWebCredsPath(authDir);
@@ -261,6 +415,7 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 			VERSION
 		],
 		syncFullHistory: false,
+		fireInitQueries: receiveMode !== "directory",
 		markOnlineOnConnect: false,
 		...socketTiming,
 		agent,
@@ -270,6 +425,19 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 		...opts.getMessage ? { getMessage: opts.getMessage } : {},
 		...opts.cachedGroupMetadata ? { cachedGroupMetadata: opts.cachedGroupMetadata } : {}
 	});
+	if (receiveMode === "directory") for (const event of [
+		"CB:message",
+		"CB:call",
+		"CB:receipt",
+		"CB:notification",
+		"CB:ack,class:message",
+		"CB:presence",
+		"CB:chatstate",
+		"CB:ib,,dirty",
+		"CB:ib,,offline_preview",
+		"CB:ib,,offline",
+		"CB:ib,,edge_routing"
+	]) sock.ws.removeAllListeners(event);
 	socketRef.current = sock;
 	if (pendingSocketAbort) abortSocketAfterCredentialPersistenceFailure(sock, pendingSocketAbort.error);
 	sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, sessionLogger, {
@@ -303,6 +471,9 @@ async function createWaSocket(printQr, verbose, opts = {}) {
 	});
 	return sock;
 }
+async function createWaDirectorySocket(authDir) {
+	return await createWaSocketInternal(false, false, { authDir }, "directory");
+}
 async function resolveEnvProxyAgent(logger) {
 	try {
 		const agent = createNodeProxyAgent({
@@ -400,4 +571,52 @@ function createConnectionTimeoutError(timeoutMs) {
 	return error;
 }
 //#endregion
-export { createWhatsAppSocketOperationTimeoutAdapter as a, resolveWhatsAppSocketTiming as c, DEFAULT_WHATSAPP_SOCKET_TIMING as i, withWhatsAppSocketOperationTimeout as l, newConnectionId as n, isWhatsAppSocketOperationTimeoutError as o, waitForWaConnection as r, resolveWhatsAppSocketOperationTimeoutMs as s, createWaSocket as t, renderQrTerminal as u };
+//#region extensions/whatsapp/src/socket-close.ts
+const SOCKET_CLOSE_TIMEOUT_MS = 15e3;
+async function withCloseTimeout(task, operationName) {
+	let timer;
+	await Promise.race([task, new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`WhatsApp ${operationName} timed out`)), SOCKET_CLOSE_TIMEOUT_MS);
+	})]).finally(() => {
+		if (timer) clearTimeout(timer);
+	});
+}
+async function waitForTransportClose(ws, operation, operationName) {
+	let onClose;
+	const closed = ws.isClosed ? Promise.resolve() : new Promise((resolve) => {
+		onClose = resolve;
+		ws.once("close", onClose);
+		if (ws.isClosed) onClose();
+	});
+	try {
+		await withCloseTimeout(Promise.all([Promise.resolve(operation), closed]), operationName);
+	} finally {
+		if (onClose) ws.removeListener("close", onClose);
+	}
+}
+/** Close Baileys and verify the transport state before connection ownership moves. */
+async function closeWhatsAppSocketAndWait(sock, reason) {
+	const errors = [];
+	try {
+		const endResult = sock.end(new Error(reason));
+		if (sock.ws.isClosed) {
+			await waitForTransportClose(sock.ws, endResult, "socket end");
+			return;
+		}
+		if (sock.ws.isClosing) await waitForTransportClose(sock.ws, endResult, "socket end");
+		else await withCloseTimeout(Promise.resolve(endResult), "socket end");
+	} catch (error) {
+		errors.push(error);
+	}
+	if (sock.ws.isClosed) return;
+	try {
+		const closeResult = sock.ws.close();
+		await waitForTransportClose(sock.ws, closeResult, "WebSocket close");
+	} catch (error) {
+		errors.push(error);
+	}
+	if (sock.ws.isClosed) return;
+	throw new AggregateError(errors, "WhatsApp socket close could not be confirmed");
+}
+//#endregion
+export { waitForWaConnection as a, isWhatsAppSocketOperationTimeoutError as c, withWhatsAppSocketOperationTimeout as d, renderQrTerminal as f, acquireWhatsAppStandaloneConnectionOwner as h, newConnectionId as i, resolveWhatsAppSocketOperationTimeoutMs as l, acquireWhatsAppGatewayConnectionOwner as m, createWaDirectorySocket as n, DEFAULT_WHATSAPP_SOCKET_TIMING as o, WhatsAppConnectionOwnerBusyError as p, createWaSocket as r, createWhatsAppSocketOperationTimeoutAdapter as s, closeWhatsAppSocketAndWait as t, resolveWhatsAppSocketTiming as u };

package/dist/{targets-runtime-Bsh0HR9y.js → targets-runtime-CKFrhoX4.js}

@@ -1,12 +1,66 @@
 import fs from "node:fs";
 import path from "node:path";
 import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { CONFIG_DIR, escapeRegExp, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
+import { markdownToIRWithMeta, renderMarkdownIRChunksWithinLimit, renderMarkdownWithMarkers, sliceMarkdownIR } from "openclaw/plugin-sdk/text-chunking";
+import { CONFIG_DIR, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/whatsapp/src/targets-runtime.ts
-const WHATSAPP_FENCE_PLACEHOLDER = "\0FENCE";
-const WHATSAPP_INLINE_CODE_PLACEHOLDER = "\0CODE";
-const WHATSAPP_PLACEHOLDER_TERMINATOR = "\0";
+const WHATSAPP_FORMAT_CAPABILITIES = {
+	mechanism: "markdown",
+	constructs: {
+		bold: "native",
+		italic: "native",
+		underline: "strip",
+		strikethrough: "native",
+		spoiler: "fallback",
+		codeInline: "native",
+		codeBlock: "native",
+		codeLanguage: "fallback",
+		linkLabel: "fallback",
+		heading: "fallback",
+		bulletList: "native",
+		orderedList: "native",
+		taskList: "fallback",
+		table: "fallback",
+		blockquote: "native",
+		image: "fallback",
+		mention: "native"
+	},
+	chunk: {
+		limit: 4096,
+		unit: "chars"
+	}
+};
+const WHATSAPP_STYLE_MARKERS = {
+	bold: {
+		open: "*",
+		close: "*"
+	},
+	italic: {
+		open: "_",
+		close: "_"
+	},
+	strikethrough: {
+		open: "~",
+		close: "~"
+	},
+	code: {
+		open: "```",
+		close: "```"
+	},
+	code_block: {
+		open: "```\n",
+		close: "```"
+	}
+};
+const WHATSAPP_INDENT_GUARD = "⁠";
+const WHATSAPP_MARKERS = [
+	"*",
+	"_",
+	"~",
+	"`"
+];
 function assertWebChannel(input) {
 	if (input !== "web") throw new Error("Web channel must be 'web'");
 }
@@ -165,31 +219,90 @@ async function resolveJidToE164(jid, opts) {
 		return null;
 	}
 }
-function markdownToWhatsApp(text) {
-	if (!text) return text;
-	const fences = [];
-	let result = text.replace(/```[\s\S]*?```/g, (match) => {
-		fences.push(match);
-		return `${WHATSAPP_FENCE_PLACEHOLDER}${fences.length - 1}${WHATSAPP_PLACEHOLDER_TERMINATOR}`;
-	});
-	const inlineCodes = [];
-	result = result.replace(/`[^`\n]+`/g, (match) => {
-		inlineCodes.push(match);
-		return `${WHATSAPP_INLINE_CODE_PLACEHOLDER}${inlineCodes.length - 1}${WHATSAPP_PLACEHOLDER_TERMINATOR}`;
+function protectWhatsAppEscapedMarkers(text) {
+	const placeholders = [];
+	for (const [start, end] of [[57344, 63743], [983040, 1048573]]) for (let codePoint = start; codePoint <= end && placeholders.length < WHATSAPP_MARKERS.length; codePoint += 1) {
+		const candidate = String.fromCodePoint(codePoint);
+		if (!text.includes(candidate)) placeholders.push(candidate);
+	}
+	if (placeholders.length < WHATSAPP_MARKERS.length) throw new Error("Unable to reserve WhatsApp formatting placeholders");
+	const markers = WHATSAPP_MARKERS.map((marker, index) => ({
+		source: `\\${marker}`,
+		placeholder: placeholders[index] ?? ""
+	}));
+	let protectedText = text;
+	for (const { source, placeholder } of markers) protectedText = protectedText.replaceAll(source, placeholder);
+	return {
+		text: protectedText,
+		markers
+	};
+}
+function restoreWhatsAppEscapedMarkers(text, markers) {
+	let restored = text;
+	for (const { source, placeholder } of markers) restored = restored.replaceAll(placeholder, source);
+	return restored;
+}
+function renderWhatsAppMarkdownIR(ir, escapedMarkers) {
+	return renderMarkdownWithMarkers(ir, {
+		styleMarkers: WHATSAPP_STYLE_MARKERS,
+		escapeText: (value) => restoreWhatsAppEscapedMarkers(value, escapedMarkers)
+	}, WHATSAPP_FORMAT_CAPABILITIES);
+}
+function prepareWhatsAppMarkdown(text, tableMode) {
+	const guardedIndent = /^[\t ]/u.test(text);
+	const escaped = protectWhatsAppEscapedMarkers(text);
+	const markdown = guardedIndent ? `${WHATSAPP_INDENT_GUARD}${escaped.text}` : escaped.text;
+	const trailingWhitespace = text.match(/\s+$/u)?.[0] ?? "";
+	const { ir: parsedIr, hasTables } = markdownToIRWithMeta(markdown, {
+		linkify: false,
+		autolink: false,
+		enableSpoilers: true,
+		enableHtmlUnderline: true,
+		enableTaskLists: true,
+		headingStyle: "rich",
+		blockquotePrefix: "> ",
+		tableMode: tableMode === "block" ? "code" : tableMode,
+		preserveSourceBlockSpacing: true
 	});
-	result = result.replace(/\*\*\*(.+?)\*\*\*/g, "*_$1_*");
-	result = result.replace(/___(.+?)___/g, "*_$1_*");
-	result = result.replace(/\*\*_(.+?)_\*\*/g, "*_$1_*");
-	result = result.replace(/__\*(.+?)\*__/g, "*_$1_*");
-	result = result.replace(/_\*\*(.+?)\*\*_/g, "*_$1_*");
-	result = result.replace(/\*__(.+?)__\*/g, "*_$1_*");
-	result = result.replace(/\*\*(.+?)\*\*/g, "*$1*");
-	result = result.replace(/__(.+?)__/g, "*$1*");
-	result = result.replace(/~~(.+?)~~/g, "~$1~");
-	const terminator = escapeRegExp(WHATSAPP_PLACEHOLDER_TERMINATOR);
-	result = result.replace(new RegExp(`${escapeRegExp(WHATSAPP_INLINE_CODE_PLACEHOLDER)}(\\d+)${terminator}`, "g"), (_, idx) => inlineCodes[Number(idx)] ?? "");
-	result = result.replace(new RegExp(`${escapeRegExp(WHATSAPP_FENCE_PLACEHOLDER)}(\\d+)${terminator}`, "g"), (_, idx) => fences[Number(idx)] ?? "");
-	return result;
+	let ir = parsedIr;
+	if (guardedIndent && ir.text.startsWith(WHATSAPP_INDENT_GUARD)) ir = sliceMarkdownIR(ir, 1, ir.text.length);
+	if (!hasTables && trailingWhitespace) ir.text = `${ir.text.trimEnd()}${trailingWhitespace}`;
+	return {
+		ir,
+		escapedMarkers: escaped.markers
+	};
+}
+function splitWhatsAppIRForChunkMode(ir, limit, chunkMode) {
+	if (chunkMode !== "newline") return [ir];
+	const chunkTexts = chunkMarkdownTextWithMode(ir.text, limit, chunkMode);
+	const chunks = [];
+	let cursor = 0;
+	for (const text of chunkTexts) {
+		const start = ir.text.indexOf(text, cursor);
+		if (start < 0) return [ir];
+		const end = start + text.length;
+		chunks.push(sliceMarkdownIR(ir, start, end));
+		cursor = end;
+	}
+	return chunks;
+}
+function markdownToWhatsAppChunks(text, limit, tableMode = "bullets", chunkMode = "length") {
+	if (!text) return [];
+	if (!text.trim()) return chunkMarkdownTextWithMode(text, limit, chunkMode);
+	const { ir, escapedMarkers } = prepareWhatsAppMarkdown(text, tableMode);
+	const render = (chunk) => renderWhatsAppMarkdownIR(chunk, escapedMarkers);
+	const rendered = render(ir);
+	let chunks = ir.styles.length === 0 && ir.links.length === 0 ? chunkMarkdownTextWithMode(rendered, limit, chunkMode) : splitWhatsAppIRForChunkMode(ir, limit, chunkMode).flatMap((source) => renderMarkdownIRChunksWithinLimit({
+		ir: source,
+		limit,
+		renderChunk: render,
+		measureRendered: (value) => value.length
+	}).map((chunk) => chunk.rendered));
+	if (chunkMode === "newline") chunks = chunks.map((chunk) => chunk.trimEnd()).filter(Boolean);
+	return chunks;
+}
+function markdownToWhatsApp(text, tableMode = "bullets") {
+	return markdownToWhatsAppChunks(text, Number.POSITIVE_INFINITY, tableMode).join("");
 }
 //#endregion
-export { resolveEquivalentWhatsAppDirectChatJids as a, toWhatsappJidWithLid as c, markdownToWhatsApp as i, isSelfChatMode as n, resolveJidToE164 as o, jidToE164 as r, toWhatsappJid as s, assertWebChannel as t };
+export { markdownToWhatsAppChunks as a, toWhatsappJid as c, markdownToWhatsApp as i, toWhatsappJidWithLid as l, isSelfChatMode as n, resolveEquivalentWhatsAppDirectChatJids as o, jidToE164 as r, resolveJidToE164 as s, assertWebChannel as t };

package/dist/text-runtime-CU_IlbK5.js

@@ -0,0 +1,4 @@
+import "./targets-runtime-CKFrhoX4.js";
+import { sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile, stripToolCallXmlTags } from "openclaw/plugin-sdk/text-chunking";
+import { normalizeE164, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
+export { stripToolCallXmlTags as a, sanitizeAssistantVisibleTextWithProfile as i, resolveUserPath$1 as n, sanitizeAssistantVisibleText as r, normalizeE164 as t };