@openclaw/whatsapp 2026.5.2 → 2026.5.3-beta.2

package/dist/api.js

@@ -0,0 +1,148 @@
+import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-DG18xddX.js";
+import { a as resolveWhatsAppAccount, i as listWhatsAppAuthDirs, n as hasAnyWhatsAppAuth, o as resolveWhatsAppAuthDir, r as listEnabledWhatsAppAccounts, s as resolveWhatsAppMediaMaxBytes, t as DEFAULT_WHATSAPP_MEDIA_MAX_MB } from "./accounts-BDqgpFEB.js";
+import { a as normalizeWhatsAppAllowFromEntries, i as looksLikeWhatsAppTargetId, o as normalizeWhatsAppMessagingTarget, r as isWhatsAppUserTarget, s as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BPVHNsM5.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CN-Wo6IY.js";
+import "./reaction-level-CRVEVAfi.js";
+import { a as markdownToWhatsApp, i as jidToE164, n as assertWebChannel, o as resolveJidToE164, r as isSelfChatMode, s as toWhatsappJid, t as text_runtime_exports } from "./text-runtime-C1zNiZeO.js";
+import "./send-CIyLFxdZ.js";
+import { t as whatsappPlugin } from "./channel-DQ-5Xoj9.js";
+import { n as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS } from "./outbound-base-Bq1UYEK5.js";
+import { t as whatsappCommandPolicy } from "./command-policy-O8sRnqUV.js";
+import { a as resolveWhatsAppGroupToolPolicy, i as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupIntroHint } from "./shared-D_wzSVar.js";
+import "./config-schema-Dmo66Ubb.js";
+import { t as whatsappSetupPlugin } from "./channel.setup-DOHR2BGp.js";
+import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-DLGCIbfl.js";
+import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-DVs4ffXu.js";
+import { t as __testing } from "./access-control-BQ3tCkH8.js";
+import "openclaw/plugin-sdk/channel-actions";
+import "openclaw/plugin-sdk/account-resolution";
+import "openclaw/plugin-sdk/core";
+import "openclaw/plugin-sdk/account-id";
+var CONFIG_DIR = text_runtime_exports.CONFIG_DIR;
+var DEFAULT_LOG_DIR = text_runtime_exports.DEFAULT_LOG_DIR;
+var DEFAULT_LOG_FILE = text_runtime_exports.DEFAULT_LOG_FILE;
+var FILE_REF_EXTENSIONS_WITH_TLD = text_runtime_exports.FILE_REF_EXTENSIONS_WITH_TLD;
+var SYSTEM_MARK = text_runtime_exports.SYSTEM_MARK;
+var __test__ = text_runtime_exports.__test__;
+var asNullableObjectRecord = text_runtime_exports.asNullableObjectRecord;
+var asNullableRecord = text_runtime_exports.asNullableRecord;
+var asOptionalObjectRecord = text_runtime_exports.asOptionalObjectRecord;
+var asOptionalRecord = text_runtime_exports.asOptionalRecord;
+var asRecord = text_runtime_exports.asRecord;
+var bindAbortRelay = text_runtime_exports.bindAbortRelay;
+var buildTimeoutAbortSignal = text_runtime_exports.buildTimeoutAbortSignal;
+var chunkItems = text_runtime_exports.chunkItems;
+var chunkMarkdownIR = text_runtime_exports.chunkMarkdownIR;
+var clamp = text_runtime_exports.clamp;
+var clampInt = text_runtime_exports.clampInt;
+var clampNumber = text_runtime_exports.clampNumber;
+var convertMarkdownTables = text_runtime_exports.convertMarkdownTables;
+var createScopedExpiringIdCache = text_runtime_exports.createScopedExpiringIdCache;
+var diagnosticLogger = text_runtime_exports.diagnosticLogger;
+var displayPath = text_runtime_exports.displayPath;
+var displayString = text_runtime_exports.displayString;
+var ensureDir = text_runtime_exports.ensureDir;
+var escapeRegExp = text_runtime_exports.escapeRegExp;
+var fetchWithTimeout = text_runtime_exports.fetchWithTimeout;
+var findCodeRegions = text_runtime_exports.findCodeRegions;
+var getChildLogger = text_runtime_exports.getChildLogger;
+var getDefaultRedactPatterns = text_runtime_exports.getDefaultRedactPatterns;
+var getDiagnosticSessionStateCountForTest = text_runtime_exports.getDiagnosticSessionStateCountForTest;
+var getLogger = text_runtime_exports.getLogger;
+var getResolvedLoggerSettings = text_runtime_exports.getResolvedLoggerSettings;
+var hasNonEmptyString = text_runtime_exports.hasNonEmptyString;
+var hasOrphanReasoningCloseBoundary = text_runtime_exports.hasOrphanReasoningCloseBoundary;
+var hasSystemMark = text_runtime_exports.hasSystemMark;
+var isAutoLinkedFileRef = text_runtime_exports.isAutoLinkedFileRef;
+var isFileLogLevelEnabled = text_runtime_exports.isFileLogLevelEnabled;
+var isInsideCode = text_runtime_exports.isInsideCode;
+var isRecord = text_runtime_exports.isRecord;
+var localeLowercasePreservingWhitespace = text_runtime_exports.localeLowercasePreservingWhitespace;
+var logActiveRuns = text_runtime_exports.logActiveRuns;
+var logDebug = text_runtime_exports.logDebug;
+var logError = text_runtime_exports.logError;
+var logInfo = text_runtime_exports.logInfo;
+var logLaneDequeue = text_runtime_exports.logLaneDequeue;
+var logLaneEnqueue = text_runtime_exports.logLaneEnqueue;
+var logMessageProcessed = text_runtime_exports.logMessageProcessed;
+var logMessageQueued = text_runtime_exports.logMessageQueued;
+var logRunAttempt = text_runtime_exports.logRunAttempt;
+var logSessionStateChange = text_runtime_exports.logSessionStateChange;
+var logSuccess = text_runtime_exports.logSuccess;
+var logToolLoopAction = text_runtime_exports.logToolLoopAction;
+var logWarn = text_runtime_exports.logWarn;
+var logWebhookError = text_runtime_exports.logWebhookError;
+var logWebhookProcessed = text_runtime_exports.logWebhookProcessed;
+var logWebhookReceived = text_runtime_exports.logWebhookReceived;
+var lowercasePreservingWhitespace = text_runtime_exports.lowercasePreservingWhitespace;
+var markdownToIR = text_runtime_exports.markdownToIR;
+var markdownToIRWithMeta = text_runtime_exports.markdownToIRWithMeta;
+var normalizeArrayBackedTrimmedStringList = text_runtime_exports.normalizeArrayBackedTrimmedStringList;
+var normalizeAtHashSlug = text_runtime_exports.normalizeAtHashSlug;
+var normalizeCsvOrLooseStringList = text_runtime_exports.normalizeCsvOrLooseStringList;
+var normalizeE164 = text_runtime_exports.normalizeE164;
+var normalizeFastMode = text_runtime_exports.normalizeFastMode;
+var normalizeHyphenSlug = text_runtime_exports.normalizeHyphenSlug;
+var normalizeLowercaseStringOrEmpty = text_runtime_exports.normalizeLowercaseStringOrEmpty;
+var normalizeNullableString = text_runtime_exports.normalizeNullableString;
+var normalizeOptionalLowercaseString = text_runtime_exports.normalizeOptionalLowercaseString;
+var normalizeOptionalString = text_runtime_exports.normalizeOptionalString;
+var normalizeOptionalStringifiedId = text_runtime_exports.normalizeOptionalStringifiedId;
+var normalizeOptionalThreadValue = text_runtime_exports.normalizeOptionalThreadValue;
+var normalizeOptionalTrimmedStringList = text_runtime_exports.normalizeOptionalTrimmedStringList;
+var normalizeSingleOrTrimmedStringList = text_runtime_exports.normalizeSingleOrTrimmedStringList;
+var normalizeStringEntries = text_runtime_exports.normalizeStringEntries;
+var normalizeStringEntriesLower = text_runtime_exports.normalizeStringEntriesLower;
+var normalizeStringifiedOptionalString = text_runtime_exports.normalizeStringifiedOptionalString;
+var normalizeTrimmedStringList = text_runtime_exports.normalizeTrimmedStringList;
+var parseInlineDirectives = text_runtime_exports.parseInlineDirectives;
+var pathExists = text_runtime_exports.pathExists;
+var prefixSystemMessage = text_runtime_exports.prefixSystemMessage;
+var readStringField = text_runtime_exports.readStringField;
+var readStringValue = text_runtime_exports.readStringValue;
+var redactIdentifier = text_runtime_exports.redactIdentifier;
+var redactSensitiveLines = text_runtime_exports.redactSensitiveLines;
+var redactSensitiveText = text_runtime_exports.redactSensitiveText;
+var redactToolDetail = text_runtime_exports.redactToolDetail;
+var renderMarkdownIRChunksWithinLimit = text_runtime_exports.renderMarkdownIRChunksWithinLimit;
+var renderMarkdownWithMarkers = text_runtime_exports.renderMarkdownWithMarkers;
+var resetDiagnosticStateForTest = text_runtime_exports.resetDiagnosticStateForTest;
+var resetLogger = text_runtime_exports.resetLogger;
+var resolveConfigDir = text_runtime_exports.resolveConfigDir;
+var resolveGlobalMap = text_runtime_exports.resolveGlobalMap;
+var resolveGlobalSingleton = text_runtime_exports.resolveGlobalSingleton;
+var resolveHomeDir = text_runtime_exports.resolveHomeDir;
+var resolvePrimaryStringValue = text_runtime_exports.resolvePrimaryStringValue;
+var resolveReactionLevel = text_runtime_exports.resolveReactionLevel;
+var resolveRedactOptions = text_runtime_exports.resolveRedactOptions;
+var resolveStuckSessionWarnMs = text_runtime_exports.resolveStuckSessionWarnMs;
+var resolveUserPath = text_runtime_exports.resolveUserPath;
+var safeParseJson = text_runtime_exports.safeParseJson;
+var sanitizeAssistantVisibleText = text_runtime_exports.sanitizeAssistantVisibleText;
+var sanitizeAssistantVisibleTextWithOptions = text_runtime_exports.sanitizeAssistantVisibleTextWithOptions;
+var sanitizeAssistantVisibleTextWithProfile = text_runtime_exports.sanitizeAssistantVisibleTextWithProfile;
+var sanitizeReplyDirectiveId = text_runtime_exports.sanitizeReplyDirectiveId;
+var sanitizeTerminalText = text_runtime_exports.sanitizeTerminalText;
+var setLoggerOverride = text_runtime_exports.setLoggerOverride;
+var sha256HexPrefix = text_runtime_exports.sha256HexPrefix;
+var shortenHomeInString = text_runtime_exports.shortenHomeInString;
+var shortenHomePath = text_runtime_exports.shortenHomePath;
+var sleep = text_runtime_exports.sleep;
+var sliceMarkdownIR = text_runtime_exports.sliceMarkdownIR;
+var sliceUtf16Safe = text_runtime_exports.sliceUtf16Safe;
+var startDiagnosticHeartbeat = text_runtime_exports.startDiagnosticHeartbeat;
+var stopDiagnosticHeartbeat = text_runtime_exports.stopDiagnosticHeartbeat;
+var stripAssistantInternalScaffolding = text_runtime_exports.stripAssistantInternalScaffolding;
+var stripDowngradedToolCallText = text_runtime_exports.stripDowngradedToolCallText;
+var stripInlineDirectiveTagsForDelivery = text_runtime_exports.stripInlineDirectiveTagsForDelivery;
+var stripInlineDirectiveTagsForDisplay = text_runtime_exports.stripInlineDirectiveTagsForDisplay;
+var stripInlineDirectiveTagsFromMessageForDisplay = text_runtime_exports.stripInlineDirectiveTagsFromMessageForDisplay;
+var stripMarkdown = text_runtime_exports.stripMarkdown;
+var stripMinimaxToolCallXml = text_runtime_exports.stripMinimaxToolCallXml;
+var stripReasoningTagsFromText = text_runtime_exports.stripReasoningTagsFromText;
+var stripToolCallXmlTags = text_runtime_exports.stripToolCallXmlTags;
+var summarizeStringEntries = text_runtime_exports.summarizeStringEntries;
+var toPinoLikeLogger = text_runtime_exports.toPinoLikeLogger;
+var truncateUtf16Safe = text_runtime_exports.truncateUtf16Safe;
+var withTimeout = text_runtime_exports.withTimeout;
+export { CONFIG_DIR, DEFAULT_LOG_DIR, DEFAULT_LOG_FILE, DEFAULT_WEB_MEDIA_BYTES, DEFAULT_WHATSAPP_MEDIA_MAX_MB, FILE_REF_EXTENSIONS_WITH_TLD, SYSTEM_MARK, WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, __test__, asNullableObjectRecord, asNullableRecord, asOptionalObjectRecord, asOptionalRecord, asRecord, assertWebChannel, bindAbortRelay, buildTimeoutAbortSignal, chunkItems, chunkMarkdownIR, clamp, clampInt, clampNumber, convertMarkdownTables, createScopedExpiringIdCache, diagnosticLogger, displayPath, displayString, ensureDir, escapeRegExp, fetchWithTimeout, findCodeRegions, getChildLogger, getDefaultRedactPatterns, getDiagnosticSessionStateCountForTest, getLogger, getResolvedLoggerSettings, hasAnyWhatsAppAuth, hasNonEmptyString, hasOrphanReasoningCloseBoundary, hasSystemMark, isAutoLinkedFileRef, isFileLogLevelEnabled, isInsideCode, isRecord, isSelfChatMode, isWhatsAppGroupJid, isWhatsAppUserTarget, jidToE164, listEnabledWhatsAppAccounts, listAccountIds as listWhatsAppAccountIds, listWhatsAppAuthDirs, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, localeLowercasePreservingWhitespace, logActiveRuns, logDebug, logError, logInfo, logLaneDequeue, logLaneEnqueue, logMessageProcessed, logMessageQueued, logRunAttempt, logSessionStateChange, logSuccess, logToolLoopAction, logWarn, logWebhookError, logWebhookProcessed, logWebhookReceived, looksLikeWhatsAppTargetId, lowercasePreservingWhitespace, markdownToIR, markdownToIRWithMeta, markdownToWhatsApp, normalizeArrayBackedTrimmedStringList, normalizeAtHashSlug, normalizeCsvOrLooseStringList, normalizeE164, normalizeFastMode, normalizeHyphenSlug, normalizeLowercaseStringOrEmpty, normalizeNullableString, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, normalizeOptionalThreadValue, normalizeOptionalTrimmedStringList, normalizeSingleOrTrimmedStringList, normalizeStringEntries, normalizeStringEntriesLower, normalizeStringifiedOptionalString, normalizeTrimmedStringList, normalizeWhatsAppAllowFromEntries, normalizeWhatsAppMessagingTarget, normalizeWhatsAppTarget, parseInlineDirectives, pathExists, prefixSystemMessage, readStringField, readStringValue, redactIdentifier, redactSensitiveLines, redactSensitiveText, redactToolDetail, renderMarkdownIRChunksWithinLimit, renderMarkdownWithMarkers, resetDiagnosticStateForTest, resetLogger, resolveConfigDir, resolveDefaultWhatsAppAccountId, resolveGlobalMap, resolveGlobalSingleton, resolveHomeDir, resolveJidToE164, resolvePrimaryStringValue, resolveReactionLevel, resolveRedactOptions, resolveStuckSessionWarnMs, resolveUserPath, resolveWhatsAppAccount, resolveWhatsAppAuthDir, resolveWhatsAppGroupIntroHint, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, resolveWhatsAppMediaMaxBytes, resolveWhatsAppOutboundTarget, safeParseJson, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithOptions, sanitizeAssistantVisibleTextWithProfile, sanitizeReplyDirectiveId, sanitizeTerminalText, setLoggerOverride, sha256HexPrefix, shortenHomeInString, shortenHomePath, sleep, sliceMarkdownIR, sliceUtf16Safe, startDiagnosticHeartbeat, stopDiagnosticHeartbeat, stripAssistantInternalScaffolding, stripDowngradedToolCallText, stripInlineDirectiveTagsForDelivery, stripInlineDirectiveTagsForDisplay, stripInlineDirectiveTagsFromMessageForDisplay, stripMarkdown, stripMinimaxToolCallXml, stripReasoningTagsFromText, stripToolCallXmlTags, summarizeStringEntries, toPinoLikeLogger, toWhatsappJid, truncateUtf16Safe, __testing as whatsappAccessControlTesting, whatsappCommandPolicy, whatsappPlugin, whatsappSetupPlugin, withTimeout };

package/dist/audio-preflight.runtime-Bcdsl_ri.js

@@ -0,0 +1,7 @@
+import { transcribeFirstAudio as transcribeFirstAudio$1 } from "openclaw/plugin-sdk/media-runtime";
+//#region extensions/whatsapp/src/auto-reply/monitor/audio-preflight.runtime.ts
+async function transcribeFirstAudio(...args) {
+	return await transcribeFirstAudio$1(...args);
+}
+//#endregion
+export { transcribeFirstAudio };

package/dist/auth-presence.js

@@ -0,0 +1,32 @@
+import { t as hasWebCredsSync } from "./creds-files-_2V8jzQa.js";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveOAuthDir } from "openclaw/plugin-sdk/state-paths";
+import { resolveUserPath } from "openclaw/plugin-sdk/account-resolution";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/whatsapp/auth-presence.ts
+function addAccountAuthDirs(authDirs, accountId, authDir, accountsRoot, env) {
+	authDirs.add(path.join(accountsRoot, normalizeAccountId(accountId)));
+	const configuredAuthDir = authDir?.trim();
+	if (configuredAuthDir) authDirs.add(resolveUserPath(configuredAuthDir, env));
+}
+function listWhatsAppAuthDirs(cfg, env = process.env) {
+	const oauthDir = resolveOAuthDir(env);
+	const accountsRoot = path.join(oauthDir, "whatsapp");
+	const channel = cfg.channels?.whatsapp;
+	const authDirs = new Set([oauthDir, path.join(accountsRoot, DEFAULT_ACCOUNT_ID)]);
+	addAccountAuthDirs(authDirs, DEFAULT_ACCOUNT_ID, void 0, accountsRoot, env);
+	if (channel?.defaultAccount?.trim()) addAccountAuthDirs(authDirs, channel.defaultAccount, channel.accounts?.[channel.defaultAccount]?.authDir, accountsRoot, env);
+	const accounts = channel?.accounts;
+	if (accounts) for (const [accountId, account] of Object.entries(accounts)) addAccountAuthDirs(authDirs, accountId, account?.authDir, accountsRoot, env);
+	try {
+		const entries = fs.readdirSync(accountsRoot, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) authDirs.add(path.join(accountsRoot, entry.name));
+	} catch {}
+	return [...authDirs];
+}
+function hasAnyWhatsAppAuth(params, env = process.env) {
+	return listWhatsAppAuthDirs(params && typeof params === "object" && "cfg" in params ? params.cfg : params, params && typeof params === "object" && "cfg" in params ? params.env ?? env : env).some((authDir) => hasWebCredsSync(authDir));
+}
+//#endregion
+export { hasAnyWhatsAppAuth };

package/dist/auth-store-BjCb50Ry.js

@@ -0,0 +1,381 @@
+import { n as resolveWebCredsBackupPath, r as resolveWebCredsPath } from "./creds-files-_2V8jzQa.js";
+import { t as text_runtime_exports } from "./text-runtime-C1zNiZeO.js";
+import { c as resolveComparableIdentity } from "./identity-QHAlV7Fu.js";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveOAuthDir as resolveOAuthDir$1 } from "openclaw/plugin-sdk/state-paths";
+import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
+import { defaultRuntime, getChildLogger, info, success } from "openclaw/plugin-sdk/runtime-env";
+import fs$1 from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
+//#region extensions/whatsapp/src/creds-persistence.ts
+const CREDS_FILE_MODE = 384;
+const CREDS_SAVE_FLUSH_TIMEOUT_MS = 15e3;
+const credsSaveQueues = /* @__PURE__ */ new Map();
+async function stringifyCreds(creds) {
+	const { BufferJSON } = await import("./session.runtime-C1eSE_KK.js").then((n) => n.a);
+	return JSON.stringify(creds, BufferJSON.replacer);
+}
+async function syncDirectory(dirPath) {
+	let handle;
+	try {
+		handle = await fs$1.open(dirPath, "r");
+		await handle.sync();
+	} catch {} finally {
+		await handle?.close().catch(() => {});
+	}
+}
+async function writeCredsJsonAtomically(authDir, creds) {
+	const credsPath = resolveWebCredsPath(authDir);
+	const tempPath = path.join(authDir, `.creds.${process.pid}.${randomUUID()}.tmp`);
+	const json = await stringifyCreds(creds);
+	let handle;
+	try {
+		handle = await fs$1.open(tempPath, "w", CREDS_FILE_MODE);
+		await handle.writeFile(json, { encoding: "utf-8" });
+		await handle.sync();
+		await handle.close();
+		handle = void 0;
+		await fs$1.rename(tempPath, credsPath);
+		await fs$1.chmod(credsPath, CREDS_FILE_MODE).catch(() => {});
+		await syncDirectory(path.dirname(credsPath));
+	} catch (error) {
+		await handle?.close().catch(() => {});
+		await fs$1.rm(tempPath, { force: true }).catch(() => {});
+		throw error;
+	}
+}
+function enqueueCredsSave(authDir, saveCreds, onError) {
+	const next = (credsSaveQueues.get(authDir) ?? Promise.resolve()).then(() => saveCreds()).catch((error) => {
+		onError(error);
+	}).finally(() => {
+		if (credsSaveQueues.get(authDir) === next) credsSaveQueues.delete(authDir);
+	});
+	credsSaveQueues.set(authDir, next);
+}
+function waitForCredsSaveQueue(authDir) {
+	if (authDir) return credsSaveQueues.get(authDir) ?? Promise.resolve();
+	return Promise.all(credsSaveQueues.values()).then(() => {});
+}
+async function waitForCredsSaveQueueWithTimeout(authDir, timeoutMs = CREDS_SAVE_FLUSH_TIMEOUT_MS) {
+	let flushTimeout;
+	return await Promise.race([waitForCredsSaveQueue(authDir).then(() => "drained"), new Promise((resolve) => {
+		flushTimeout = setTimeout(() => resolve("timed_out"), timeoutMs);
+	})]).finally(() => {
+		if (flushTimeout) clearTimeout(flushTimeout);
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/auth-store.ts
+const WHATSAPP_AUTH_UNSTABLE_CODE = "whatsapp-auth-unstable";
+const authStoreLogger = getChildLogger({ module: "web-auth-store" });
+const emptyWebSelfId = () => ({
+	e164: null,
+	jid: null,
+	lid: null
+});
+var WhatsAppAuthUnstableError = class extends Error {
+	constructor(message = "WhatsApp auth state is still stabilizing; retry shortly.") {
+		super(message);
+		this.code = WHATSAPP_AUTH_UNSTABLE_CODE;
+		this.name = "WhatsAppAuthUnstableError";
+	}
+};
+function resolveDefaultWebAuthDir() {
+	return path.join(resolveOAuthDir$1(), "whatsapp", DEFAULT_ACCOUNT_ID);
+}
+const WA_WEB_AUTH_DIR = resolveDefaultWebAuthDir();
+function readCredsJsonRaw(filePath) {
+	try {
+		if (!fs.existsSync(filePath)) return null;
+		const stats = fs.statSync(filePath);
+		if (!stats.isFile() || stats.size <= 1) return null;
+		return fs.readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+async function waitForWebAuthBarrier(authDir, context) {
+	const result = await waitForCredsSaveQueueWithTimeout(authDir);
+	if (result === "timed_out") authStoreLogger.warn({
+		authDir,
+		context
+	}, "timed out waiting for queued WhatsApp creds save before auth read");
+	return result;
+}
+async function restoreCredsFromBackupIfNeeded(authDir) {
+	const logger = getChildLogger({ module: "web-session" });
+	let tempRestorePath = null;
+	try {
+		const credsPath = resolveWebCredsPath(authDir);
+		const backupPath = resolveWebCredsBackupPath(authDir);
+		const raw = readCredsJsonRaw(credsPath);
+		if (raw) {
+			JSON.parse(raw);
+			return false;
+		}
+		const backupRaw = readCredsJsonRaw(backupPath);
+		if (!backupRaw) return false;
+		if (!(await fs$1.lstat(backupPath).catch(() => null))?.isFile()) return false;
+		JSON.parse(backupRaw);
+		tempRestorePath = path.join(authDir, `.creds.restore-${randomUUID()}.tmp`);
+		await fs$1.writeFile(tempRestorePath, backupRaw, {
+			encoding: "utf-8",
+			mode: 384,
+			flag: "wx"
+		});
+		await fs$1.rename(tempRestorePath, credsPath);
+		tempRestorePath = null;
+		logger.warn({ credsPath }, "restored corrupted WhatsApp creds.json from backup");
+		return true;
+	} catch {} finally {
+		if (tempRestorePath) await fs$1.rm(tempRestorePath, { force: true }).catch(() => {});
+	}
+	return false;
+}
+async function webAuthExists(authDir = resolveDefaultWebAuthDir()) {
+	const resolvedAuthDir = (0, text_runtime_exports.resolveUserPath)(authDir);
+	const credsPath = resolveWebCredsPath(resolvedAuthDir);
+	try {
+		await fs$1.access(resolvedAuthDir);
+	} catch {
+		return false;
+	}
+	try {
+		const stats = await fs$1.stat(credsPath);
+		if (!stats.isFile() || stats.size <= 1) return false;
+		const raw = await fs$1.readFile(credsPath, "utf-8");
+		JSON.parse(raw);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function resolveWebAuthState(params) {
+	if (params.barrierResult === "timed_out") return "unstable";
+	return params.linked ? "linked" : "not-linked";
+}
+async function readWebAuthStateCore(authDir, context) {
+	const resolvedAuthDir = (0, text_runtime_exports.resolveUserPath)(authDir);
+	const barrierResult = await waitForWebAuthBarrier(resolvedAuthDir, context);
+	const linked = await webAuthExists(resolvedAuthDir);
+	return {
+		authDir: resolvedAuthDir,
+		linked,
+		state: resolveWebAuthState({
+			linked,
+			barrierResult
+		})
+	};
+}
+function formatWhatsAppWebAuthStatusState(state) {
+	switch (state) {
+		case "linked": return "linked";
+		case "not-linked": return "not linked";
+		case "unstable": return "auth stabilizing";
+	}
+	return state;
+}
+async function readWebAuthState(authDir = resolveDefaultWebAuthDir()) {
+	return (await readWebAuthStateCore(authDir, "readWebAuthState")).state;
+}
+async function readWebAuthSnapshot(authDir = resolveDefaultWebAuthDir()) {
+	const auth = await readWebAuthStateCore(authDir, "readWebAuthSnapshot");
+	return {
+		state: auth.state,
+		authAgeMs: auth.state === "linked" ? getWebAuthAgeMs(auth.authDir) : null,
+		selfId: auth.state === "linked" ? readWebSelfId(auth.authDir) : emptyWebSelfId()
+	};
+}
+async function readWebAuthExistsBestEffort(authDir = resolveDefaultWebAuthDir()) {
+	const state = await readWebAuthState(authDir);
+	return {
+		exists: state === "linked",
+		timedOut: state === "unstable"
+	};
+}
+async function readWebAuthExistsForDecision(authDir = resolveDefaultWebAuthDir()) {
+	const state = await readWebAuthState(authDir);
+	if (state === "unstable") return { outcome: "unstable" };
+	return {
+		outcome: "stable",
+		exists: state === "linked"
+	};
+}
+async function readWebAuthSnapshotBestEffort(authDir = resolveDefaultWebAuthDir()) {
+	const snapshot = await readWebAuthSnapshot(authDir);
+	return {
+		linked: snapshot.state === "linked",
+		timedOut: snapshot.state === "unstable",
+		authAgeMs: snapshot.authAgeMs,
+		selfId: snapshot.selfId
+	};
+}
+function isBaileysAuthFileName(name) {
+	if (name === "oauth.json") return false;
+	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);
+}
+async function clearBaileysAuthFiles(authDir) {
+	const rootStats = await fs$1.lstat(authDir).catch(() => null);
+	if (!rootStats?.isDirectory() || rootStats.isSymbolicLink()) return;
+	const entries = await fs$1.readdir(authDir, { withFileTypes: true });
+	await Promise.all(entries.map(async (entry) => {
+		if (!entry.isFile()) return;
+		if (!isBaileysAuthFileName(entry.name)) return;
+		await fs$1.rm(path.join(authDir, entry.name), { force: true });
+	}));
+}
+async function shouldClearOnLogout(authDir, isLegacyAuthDir) {
+	try {
+		const stats = await fs$1.lstat(authDir);
+		if (!stats.isDirectory() || stats.isSymbolicLink()) return false;
+		if (isLegacyAuthDir) return (await fs$1.readdir(authDir, { withFileTypes: true })).some((entry) => {
+			if (!entry.isFile()) return false;
+			return isBaileysAuthFileName(entry.name);
+		});
+		if ((await fs$1.lstat(resolveWebCredsPath(authDir)).catch(() => null))?.isFile()) return true;
+		return (await fs$1.lstat(resolveWebCredsBackupPath(authDir)).catch(() => null))?.isFile() === true;
+	} catch (error) {
+		const codeValue = error && typeof error === "object" && "code" in error ? error.code : void 0;
+		return (typeof codeValue === "string" ? codeValue : "") !== "ENOENT";
+	}
+}
+function isPathInsideDirectory(baseDir, targetPath) {
+	const relativePath = path.relative(baseDir, targetPath);
+	return relativePath !== "" && !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+async function pathHasSymlinkComponent(baseDir, targetPath) {
+	const relativePath = path.relative(baseDir, targetPath);
+	let currentPath = baseDir;
+	for (const segment of relativePath.split(path.sep)) {
+		currentPath = path.join(currentPath, segment);
+		const stats = await fs$1.lstat(currentPath).catch(() => null);
+		if (!stats || stats.isSymbolicLink()) return true;
+	}
+	return false;
+}
+async function isLegacyWebAuthDir(authDir) {
+	const legacyAuthDir = path.resolve(resolveOAuthDir$1());
+	const resolvedAuthDir = path.resolve(authDir);
+	if (resolvedAuthDir !== legacyAuthDir) return false;
+	const stats = await fs$1.lstat(resolvedAuthDir).catch(() => null);
+	return stats?.isDirectory() === true && !stats.isSymbolicLink();
+}
+async function classifyWebAuthDirOwnership(authDir) {
+	const whatsappAuthBase = path.resolve(resolveOAuthDir$1(), "whatsapp");
+	const resolvedAuthDir = path.resolve(authDir);
+	if (!isPathInsideDirectory(whatsappAuthBase, resolvedAuthDir)) return { kind: "external" };
+	const [baseRealPath, authDirRealPath] = await Promise.all([fs$1.realpath(whatsappAuthBase).catch(() => null), fs$1.realpath(resolvedAuthDir).catch(() => null)]);
+	if (!baseRealPath || !authDirRealPath) return { kind: "unsafe-owned" };
+	if (!isPathInsideDirectory(baseRealPath, authDirRealPath)) return { kind: "unsafe-owned" };
+	if (await pathHasSymlinkComponent(whatsappAuthBase, resolvedAuthDir)) return { kind: "unsafe-owned" };
+	return {
+		kind: "owned",
+		authDir: resolvedAuthDir
+	};
+}
+async function logoutWeb(params) {
+	const runtime = params.runtime ?? defaultRuntime;
+	const resolvedAuthDir = (0, text_runtime_exports.resolveUserPath)(params.authDir ?? resolveDefaultWebAuthDir());
+	if (await waitForWebAuthBarrier(resolvedAuthDir, "logoutWeb") === "timed_out") runtime.log(info("WhatsApp auth state is still stabilizing; clearing cached credentials anyway."));
+	if (!await shouldClearOnLogout(resolvedAuthDir, Boolean(params.isLegacyAuthDir))) {
+		runtime.log(info("No WhatsApp Web session found; nothing to delete."));
+		return false;
+	}
+	if (params.isLegacyAuthDir) {
+		if (!await isLegacyWebAuthDir(resolvedAuthDir)) {
+			runtime.log(info("Skipped WhatsApp Web credential cleanup outside the managed legacy auth directory."));
+			return false;
+		}
+		await clearBaileysAuthFiles(resolvedAuthDir);
+	} else {
+		const ownership = await classifyWebAuthDirOwnership(resolvedAuthDir);
+		if (ownership.kind === "owned") await fs$1.rm(ownership.authDir, {
+			recursive: true,
+			force: true
+		});
+		else if (ownership.kind === "unsafe-owned") {
+			runtime.log(info("Skipped WhatsApp Web credential cleanup because the auth directory crosses a symlink boundary."));
+			return false;
+		} else {
+			runtime.log(info("Skipped WhatsApp Web credential cleanup outside the managed auth directory."));
+			return false;
+		}
+	}
+	runtime.log(success("Cleared WhatsApp Web credentials."));
+	return true;
+}
+function readWebSelfId(authDir = resolveDefaultWebAuthDir()) {
+	try {
+		const credsPath = resolveWebCredsPath((0, text_runtime_exports.resolveUserPath)(authDir));
+		if (!fs.existsSync(credsPath)) return emptyWebSelfId();
+		const raw = fs.readFileSync(credsPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		const identity = resolveComparableIdentity({
+			jid: parsed?.me?.id ?? null,
+			lid: parsed?.me?.lid ?? null
+		}, authDir);
+		return {
+			e164: identity.e164 ?? null,
+			jid: identity.jid ?? null,
+			lid: identity.lid ?? null
+		};
+	} catch {
+		return emptyWebSelfId();
+	}
+}
+async function readWebSelfIdentity(authDir = resolveDefaultWebAuthDir(), fallback) {
+	const resolvedAuthDir = (0, text_runtime_exports.resolveUserPath)(authDir);
+	try {
+		const raw = await fs$1.readFile(resolveWebCredsPath(resolvedAuthDir), "utf-8");
+		const parsed = JSON.parse(raw);
+		return resolveComparableIdentity({
+			jid: parsed?.me?.id ?? null,
+			lid: parsed?.me?.lid ?? null
+		}, resolvedAuthDir);
+	} catch {
+		return resolveComparableIdentity({
+			jid: fallback?.id ?? null,
+			lid: fallback?.lid ?? null
+		}, resolvedAuthDir);
+	}
+}
+async function readWebSelfIdentityForDecision(authDir = resolveDefaultWebAuthDir(), fallback) {
+	const resolvedAuthDir = (0, text_runtime_exports.resolveUserPath)(authDir);
+	if (await waitForWebAuthBarrier(resolvedAuthDir, "readWebSelfIdentityForDecision") === "timed_out") return { outcome: "unstable" };
+	return {
+		outcome: "stable",
+		identity: await readWebSelfIdentity(resolvedAuthDir, fallback)
+	};
+}
+/**
+* Return the age (in milliseconds) of the cached WhatsApp web auth state, or null when missing.
+* Helpful for heartbeats/observability to spot stale credentials.
+*/
+function getWebAuthAgeMs(authDir = resolveDefaultWebAuthDir()) {
+	try {
+		const stats = fs.statSync(resolveWebCredsPath((0, text_runtime_exports.resolveUserPath)(authDir)));
+		return Date.now() - stats.mtimeMs;
+	} catch {
+		return null;
+	}
+}
+function logWebSelfId(authDir = resolveDefaultWebAuthDir(), runtime = defaultRuntime, includeChannelPrefix = false) {
+	const { e164, jid, lid } = readWebSelfId(authDir);
+	const parts = [jid ? `jid ${jid}` : null, lid ? `lid ${lid}` : null].filter((value) => Boolean(value));
+	const details = e164 || parts.length > 0 ? `${e164 ?? "unknown"}${parts.length > 0 ? ` (${parts.join(", ")})` : ""}` : "unknown";
+	const prefix = includeChannelPrefix ? "Web Channel: " : "";
+	runtime.log(info(`${prefix}${details}`));
+}
+async function pickWebChannel(pref, authDir = resolveDefaultWebAuthDir()) {
+	const choice = pref === "auto" ? "web" : pref;
+	const auth = await readWebAuthExistsForDecision(authDir);
+	if (auth.outcome === "unstable") throw new WhatsAppAuthUnstableError();
+	if (!auth.exists) throw new Error(`No WhatsApp Web session found. Run \`${formatCliCommand("openclaw channels login --channel whatsapp --verbose")}\` to link.`);
+	return choice;
+}
+//#endregion
+export { waitForCredsSaveQueueWithTimeout as C, waitForCredsSaveQueue as S, readWebSelfIdentityForDecision as _, getWebAuthAgeMs as a, webAuthExists as b, pickWebChannel as c, readWebAuthExistsForDecision as d, readWebAuthSnapshot as f, readWebSelfIdentity as g, readWebSelfId as h, formatWhatsAppWebAuthStatusState as i, readCredsJsonRaw as l, readWebAuthState as m, WHATSAPP_AUTH_UNSTABLE_CODE as n, logWebSelfId as o, readWebAuthSnapshotBestEffort as p, WhatsAppAuthUnstableError as r, logoutWeb as s, WA_WEB_AUTH_DIR as t, readWebAuthExistsBestEffort as u, resolveDefaultWebAuthDir as v, writeCredsJsonAtomically as w, enqueueCredsSave as x, restoreCredsFromBackupIfNeeded as y };