@wednesdayai/whatsapp 0.4.10

package/dist/login-qr-B5goEXCP.js

@@ -0,0 +1,1064 @@
+import { DEFAULT_ACCOUNT_ID, VERSION, acquireFileLock, createAccountListHelpers, danger, defaultRuntime, encodePngRgba, ensureDir, fillPixel, formatCliCommand, getChildLogger, info, jidToE164, logInfo, normalizeAccountId, resolveAccountEntry, resolveOAuthDir, resolveUserPath, success, toPinoLikeLogger } from "openclaw/plugin-sdk";
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import fs$1 from "node:fs/promises";
+import { resolveProcessScopedMap } from "openclaw/plugin-sdk/process-scoped-map";
+import QRCodeModule from "qrcode-terminal/vendor/QRCode/index.js";
+import QRErrorCorrectLevelModule from "qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js";
+import qrcode from "qrcode-terminal";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/accounts.ts
+const { listConfiguredAccountIds, listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("whatsapp");
+const listWhatsAppAccountIds = listAccountIds;
+const resolveDefaultWhatsAppAccountId = resolveDefaultAccountId;
+function resolveAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.whatsapp?.accounts, accountId);
+}
+function resolveDefaultAuthDir(accountId) {
+	return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
+}
+function resolveLegacyAuthDir() {
+	return resolveOAuthDir();
+}
+function legacyAuthExists(authDir) {
+	try {
+		return fs.existsSync(path.join(authDir, "creds.json"));
+	} catch {
+		return false;
+	}
+}
+function resolveWhatsAppAuthDir(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	const configured = resolveAccountConfig(params.cfg, accountId)?.authDir?.trim();
+	if (configured) return {
+		authDir: resolveUserPath(configured),
+		isLegacy: false
+	};
+	const defaultDir = resolveDefaultAuthDir(accountId);
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const legacyDir = resolveLegacyAuthDir();
+		if (legacyAuthExists(legacyDir) && !legacyAuthExists(defaultDir)) return {
+			authDir: legacyDir,
+			isLegacy: true
+		};
+	}
+	return {
+		authDir: defaultDir,
+		isLegacy: false
+	};
+}
+function resolveWhatsAppAccount$1(params) {
+	const rootCfg = params.cfg.channels?.whatsapp;
+	const accountId = params.accountId?.trim() || resolveDefaultWhatsAppAccountId(params.cfg);
+	const accountCfg = resolveAccountConfig(params.cfg, accountId);
+	const enabled = rootCfg?.enabled !== false && accountCfg?.enabled !== false;
+	const { authDir, isLegacy } = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		name: accountCfg?.name?.trim() || void 0,
+		enabled,
+		sendReadReceipts: accountCfg?.sendReadReceipts ?? rootCfg?.sendReadReceipts ?? true,
+		messagePrefix: accountCfg?.messagePrefix ?? rootCfg?.messagePrefix ?? params.cfg.messages?.messagePrefix,
+		authDir,
+		isLegacyAuthDir: isLegacy,
+		selfChatMode: accountCfg?.selfChatMode ?? rootCfg?.selfChatMode,
+		dmPolicy: accountCfg?.dmPolicy ?? rootCfg?.dmPolicy,
+		allowFrom: accountCfg?.allowFrom ?? rootCfg?.allowFrom,
+		groupAllowFrom: accountCfg?.groupAllowFrom ?? rootCfg?.groupAllowFrom,
+		groupPolicy: accountCfg?.groupPolicy ?? rootCfg?.groupPolicy,
+		textChunkLimit: accountCfg?.textChunkLimit ?? rootCfg?.textChunkLimit,
+		chunkMode: accountCfg?.chunkMode ?? rootCfg?.chunkMode,
+		chunkNewlinePacking: accountCfg?.chunkNewlinePacking ?? rootCfg?.chunkNewlinePacking,
+		mediaMaxMb: accountCfg?.mediaMaxMb ?? rootCfg?.mediaMaxMb,
+		blockStreaming: accountCfg?.blockStreaming ?? rootCfg?.blockStreaming,
+		ackReaction: accountCfg?.ackReaction ?? rootCfg?.ackReaction,
+		groups: accountCfg?.groups ?? rootCfg?.groups,
+		debounceMs: accountCfg?.debounceMs ?? rootCfg?.debounceMs
+	};
+}
+
+//#endregion
+//#region src/active-listener.ts
+const listeners = /* @__PURE__ */ new Map();
+const connectionLocks = /* @__PURE__ */ new Map();
+function withAccountLock(accountId, fn) {
+	const next = (connectionLocks.get(accountId) ?? Promise.resolve()).then(fn);
+	const settled = next.catch(() => void 0);
+	connectionLocks.set(accountId, settled);
+	settled.finally(() => {
+		if (connectionLocks.get(accountId) === settled) connectionLocks.delete(accountId);
+	});
+	return next;
+}
+function resolveWebAccountId(accountId) {
+	return (accountId ?? "").trim() || DEFAULT_ACCOUNT_ID;
+}
+function setActiveWebListener(accountIdOrListener, maybeListener) {
+	const { accountId, listener } = typeof accountIdOrListener === "string" ? {
+		accountId: accountIdOrListener,
+		listener: maybeListener ?? null
+	} : {
+		accountId: DEFAULT_ACCOUNT_ID,
+		listener: accountIdOrListener ?? null
+	};
+	const id = resolveWebAccountId(accountId);
+	if (!listener) listeners.delete(id);
+	else listeners.set(id, listener);
+}
+function getActiveWebListener(accountId) {
+	const id = resolveWebAccountId(accountId);
+	return listeners.get(id) ?? null;
+}
+async function stopActiveWebListener(accountId, reason = {
+	status: void 0,
+	isLoggedOut: false,
+	error: "closed"
+}) {
+	const id = resolveWebAccountId(accountId);
+	if (!listeners.has(id)) return false;
+	let stopped = false;
+	await withAccountLock(id, async () => {
+		const current = listeners.get(id);
+		if (!current) return;
+		listeners.delete(id);
+		try {
+			current.signalClose?.(reason);
+		} catch {}
+		try {
+			await current.close?.();
+			stopped = true;
+		} catch (err) {
+			if (!listeners.has(id)) listeners.set(id, current);
+			throw err;
+		}
+	});
+	return stopped;
+}
+
+//#endregion
+//#region src/runtime.ts
+let runtime = null;
+function setWhatsAppRuntime(next) {
+	runtime = next;
+}
+function getWhatsAppRuntime() {
+	if (!runtime) throw new Error("WhatsApp runtime not initialized");
+	return runtime;
+}
+
+//#endregion
+//#region src/auth-store.ts
+function resolveDefaultWebAuthDir() {
+	return path.join(resolveOAuthDir(), "whatsapp", DEFAULT_ACCOUNT_ID);
+}
+const WA_WEB_AUTH_DIR = resolveDefaultWebAuthDir();
+function resolveWebCredsPath(authDir) {
+	return path.join(authDir, "creds.json");
+}
+function resolveWebCredsBackupPath(authDir) {
+	return path.join(authDir, "creds.json.bak");
+}
+const RECENT_CREDS_WRITE_GRACE_MS = 5e3;
+const AUTH_CLEAR_SAVE_SUPPRESSION_MS = 5e3;
+const WA_SOCKET_LOCK_OPTIONS$1 = {
+	retries: {
+		retries: 0,
+		factor: 1,
+		minTimeout: 100,
+		maxTimeout: 100
+	},
+	stale: 10080 * 60 * 1e3,
+	reentrant: false
+};
+const authDirsBeingCleared = resolveProcessScopedMap(Symbol.for("openclaw.webAuthDirsBeingCleared"));
+const authDirClearSuppressedUntil = resolveProcessScopedMap(Symbol.for("openclaw.webAuthDirClearSuppressedUntil"));
+const credsSaveQueues = resolveProcessScopedMap(Symbol.for("openclaw.webCredsSaveQueues"));
+function canonicalWebAuthDir(authDir) {
+	const resolvedAuthDir = resolveUserPath(authDir);
+	try {
+		return fs.realpathSync.native(resolvedAuthDir);
+	} catch (err) {
+		if (err.code === "ENOENT") return resolvedAuthDir;
+		throw err;
+	}
+}
+function isWebAuthBeingCleared(authDir) {
+	const authDirKey = canonicalWebAuthDir(authDir);
+	const suppressedUntil = authDirClearSuppressedUntil.get(authDirKey) ?? 0;
+	if (suppressedUntil > Date.now()) return true;
+	if (suppressedUntil) authDirClearSuppressedUntil.delete(authDirKey);
+	return authDirsBeingCleared.has(authDirKey);
+}
+function statFileSync(filePath) {
+	try {
+		return fs.statSync(filePath);
+	} catch {
+		return null;
+	}
+}
+function isRecentFileWrite(stats) {
+	return Boolean(stats?.isFile() && Date.now() - stats.mtimeMs < RECENT_CREDS_WRITE_GRACE_MS);
+}
+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;
+	}
+}
+function enqueueWebCredsSave(authDir, saveCreds, logger) {
+	const resolvedAuthDir = resolveUserPath(authDir);
+	const authDirKey = canonicalWebAuthDir(resolvedAuthDir);
+	if (isWebAuthBeingCleared(authDirKey)) return;
+	const previous = credsSaveQueues.get(authDirKey) ?? Promise.resolve();
+	let next;
+	next = previous.then(() => safeSaveCreds(resolvedAuthDir, saveCreds, logger)).catch((err) => {
+		logger.warn({ error: String(err) }, "WhatsApp creds save queue error");
+	}).finally(() => {
+		if (credsSaveQueues.get(authDirKey) === next) credsSaveQueues.delete(authDirKey);
+	});
+	credsSaveQueues.set(authDirKey, next);
+}
+function suppressPostClearCredsSaves(authDir) {
+	const authDirKey = canonicalWebAuthDir(authDir);
+	const suppressedUntil = Date.now() + AUTH_CLEAR_SAVE_SUPPRESSION_MS;
+	authDirClearSuppressedUntil.set(authDirKey, suppressedUntil);
+	setTimeout(() => {
+		if (authDirClearSuppressedUntil.get(authDirKey) === suppressedUntil) authDirClearSuppressedUntil.delete(authDirKey);
+	}, AUTH_CLEAR_SAVE_SUPPRESSION_MS).unref?.();
+}
+function clearWebAuthClearSuppression(authDir) {
+	authDirClearSuppressedUntil.delete(canonicalWebAuthDir(authDir));
+}
+async function waitForWebCredsSaveQueue(authDir) {
+	const authDirKey = canonicalWebAuthDir(authDir);
+	while (true) {
+		const queue = credsSaveQueues.get(authDirKey);
+		if (!queue) return;
+		await queue;
+	}
+}
+async function safeSaveCreds(authDir, saveCreds, logger) {
+	if (isWebAuthBeingCleared(authDir)) return;
+	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 {}
+	if (isWebAuthBeingCleared(authDir)) return;
+	try {
+		await Promise.resolve(saveCreds());
+		try {
+			fs.chmodSync(resolveWebCredsPath(authDir), 384);
+		} catch {}
+	} catch (err) {
+		logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+	}
+}
+function isParseableJson(raw) {
+	try {
+		JSON.parse(raw);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function maybeRestoreCredsFromBackup(authDir) {
+	const logger = getChildLogger({ module: "web-session" });
+	try {
+		if (isWebAuthBeingCleared(authDir)) return;
+		const credsPath = resolveWebCredsPath(authDir);
+		const backupPath = resolveWebCredsBackupPath(authDir);
+		const raw = readCredsJsonRaw(credsPath);
+		if (raw && isParseableJson(raw)) return;
+		if (isRecentFileWrite(statFileSync(credsPath))) return;
+		const backupRaw = readCredsJsonRaw(backupPath);
+		const backupStats = statFileSync(backupPath);
+		if (!backupStats?.isFile() || !backupRaw || !isParseableJson(backupRaw)) return;
+		fs.copyFileSync(backupPath, credsPath);
+		try {
+			fs.chmodSync(credsPath, 384);
+		} catch {}
+		try {
+			fs.utimesSync(credsPath, backupStats.atime, backupStats.mtime);
+		} catch {}
+		logger.warn({ credsPath }, "restored corrupted WhatsApp creds.json from backup");
+	} catch {}
+}
+async function webAuthExists(authDir = resolveDefaultWebAuthDir()) {
+	const resolvedAuthDir = resolveUserPath(authDir);
+	maybeRestoreCredsFromBackup(resolvedAuthDir);
+	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 isLegacyBaileysAuthFile(name) {
+	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 clearBaileysAuthState(authDir, isLegacyAuthDir) {
+	const entries = await fs$1.readdir(authDir, { withFileTypes: true });
+	const shouldDelete = (name) => {
+		if (name === "oauth.json") return false;
+		if (isLegacyAuthDir) return isLegacyBaileysAuthFile(name);
+		return name === "creds.json.bak" || name.endsWith(".json");
+	};
+	const deleteNames = entries.filter((entry) => (entry.isFile() || entry.isSymbolicLink()) && shouldDelete(entry.name)).map((entry) => entry.name).toSorted((a, b) => {
+		if (a === "creds.json.bak") return -1;
+		if (b === "creds.json.bak") return 1;
+		if (a === "creds.json") return -1;
+		if (b === "creds.json") return 1;
+		return a.localeCompare(b);
+	});
+	for (const name of deleteNames) await fs$1.rm(path.join(authDir, name), { force: true });
+	return deleteNames.length;
+}
+function resolveWaSocketLockPath$1(authDir) {
+	return path.join(authDir, ".socket-owner");
+}
+async function acquireWaLogoutLock(authDir) {
+	try {
+		return await acquireFileLock(resolveWaSocketLockPath$1(authDir), WA_SOCKET_LOCK_OPTIONS$1);
+	} catch (err) {
+		throw new Error(`WhatsApp auth directory is already in use by another openclaw process or socket in this process (${authDir}). Stop the gateway before logging out.`, { cause: err });
+	}
+}
+async function releaseWaLogoutLock(lock) {
+	try {
+		await lock.release();
+	} catch {
+		await lock.release();
+	}
+}
+async function logoutWeb(params) {
+	const runtime = params.runtime ?? defaultRuntime;
+	const resolvedAuthDir = resolveUserPath(params.authDir ?? resolveDefaultWebAuthDir());
+	let stats;
+	try {
+		stats = await fs$1.lstat(resolvedAuthDir);
+	} catch {
+		runtime.log(info("No WhatsApp Web session found; nothing to delete."));
+		return false;
+	}
+	if (stats.isSymbolicLink()) throw new Error(`Refusing to clear WhatsApp auth directory because it is a symlink: ${resolvedAuthDir}`);
+	if (!stats.isDirectory()) {
+		runtime.log(info("No WhatsApp Web session found; nothing to delete."));
+		return false;
+	}
+	const socketLock = await acquireWaLogoutLock(resolvedAuthDir);
+	let authDirKey = null;
+	try {
+		authDirKey = canonicalWebAuthDir(resolvedAuthDir);
+		authDirsBeingCleared.set(authDirKey, true);
+		await waitForWebCredsSaveQueue(authDirKey);
+		const exists = await webAuthExists(resolvedAuthDir);
+		const deletedCount = await clearBaileysAuthState(resolvedAuthDir, Boolean(params.isLegacyAuthDir));
+		if (!exists && deletedCount === 0) {
+			runtime.log(info("No WhatsApp Web session found; nothing to delete."));
+			return false;
+		}
+		runtime.log(success("Cleared WhatsApp Web credentials."));
+		return true;
+	} finally {
+		if (authDirKey) {
+			authDirsBeingCleared.delete(authDirKey);
+			suppressPostClearCredsSaves(authDirKey);
+		}
+		await releaseWaLogoutLock(socketLock);
+	}
+}
+function readWebSelfId(authDir = resolveDefaultWebAuthDir()) {
+	try {
+		const credsPath = resolveWebCredsPath(resolveUserPath(authDir));
+		if (!fs.existsSync(credsPath)) return {
+			e164: null,
+			jid: null
+		};
+		const raw = fs.readFileSync(credsPath, "utf-8");
+		const jid = JSON.parse(raw)?.me?.id ?? null;
+		return {
+			e164: jid ? jidToE164(jid, { authDir }) : null,
+			jid
+		};
+	} catch {
+		return {
+			e164: null,
+			jid: null
+		};
+	}
+}
+/**
+* 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(resolveUserPath(authDir)));
+		return Date.now() - stats.mtimeMs;
+	} catch {
+		return null;
+	}
+}
+function logWebSelfId(authDir = resolveDefaultWebAuthDir(), runtime = defaultRuntime, includeChannelPrefix = false) {
+	const { e164, jid } = readWebSelfId(authDir);
+	const details = e164 || jid ? `${e164 ?? "unknown"}${jid ? ` (jid ${jid})` : ""}` : "unknown";
+	const prefix = includeChannelPrefix ? "Web Channel: " : "";
+	runtime.log(info(`${prefix}${details}`));
+}
+
+//#endregion
+//#region src/baileys.ts
+var WhatsAppDependencyError = class extends Error {
+	constructor(cause) {
+		super("WhatsApp dependency '@whiskeysockets/baileys' is not installed. Install the WhatsApp extension's dependencies (run `npm install --omit=dev` in the extension directory, or install the channel via `openclaw plugins install`).", { cause });
+		this.name = "WhatsAppDependencyError";
+	}
+};
+function isModuleNotFound(err) {
+	if (typeof err !== "object" || err === null) return false;
+	const code = err.code;
+	if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return true;
+	const message = err.message;
+	return typeof message === "string" && message.includes("Cannot find module");
+}
+let cached = null;
+/**
+* Resolve baileys via an injectable importer. `getBaileys` calls this with the
+* real dynamic import; tests inject a controlled importer to exercise the
+* dependency-missing path without uninstalling the package. Throws
+* WhatsAppDependencyError when the package is absent; re-throws any other
+* import failure unchanged.
+*/
+async function resolveBaileys(importer) {
+	try {
+		return await importer();
+	} catch (err) {
+		if (isModuleNotFound(err)) throw new WhatsAppDependencyError(err);
+		throw err;
+	}
+}
+/**
+* Lazily resolve @whiskeysockets/baileys. Caches the in-flight promise so
+* concurrent first-callers share one import. On failure the cache is cleared so
+* a later call can retry.
+*/
+async function getBaileys() {
+	if (cached) return cached;
+	cached = resolveBaileys(() => import("@whiskeysockets/baileys")).catch((err) => {
+		cached = null;
+		throw err;
+	});
+	return cached;
+}
+
+//#endregion
+//#region src/qr-image.ts
+const QRCode = QRCodeModule;
+const QRErrorCorrectLevel = QRErrorCorrectLevelModule;
+function createQrMatrix(input) {
+	const qr = new QRCode(-1, QRErrorCorrectLevel.L);
+	qr.addData(input);
+	qr.make();
+	return qr;
+}
+async function renderQrPngBase64(input, opts = {}) {
+	const { scale = 6, marginModules = 4 } = opts;
+	const qr = createQrMatrix(input);
+	const modules = qr.getModuleCount();
+	const size = (modules + marginModules * 2) * scale;
+	const buf = Buffer.alloc(size * size * 4, 255);
+	for (let row = 0; row < modules; row += 1) for (let col = 0; col < modules; col += 1) {
+		if (!qr.isDark(row, col)) continue;
+		const startX = (col + marginModules) * scale;
+		const startY = (row + marginModules) * scale;
+		for (let y = 0; y < scale; y += 1) {
+			const pixelY = startY + y;
+			for (let x = 0; x < scale; x += 1) fillPixel(buf, startX + x, pixelY, size, 0, 0, 0, 255);
+		}
+	}
+	return encodePngRgba(buf, size, size).toString("base64");
+}
+
+//#endregion
+//#region src/session.ts
+const BAILEYS_VERSION_CACHE_TTL_MS = 1440 * 60 * 1e3;
+const BAILEYS_VERSION_FETCH_TIMEOUT_MS = 3e3;
+const BAILEYS_VERSION_FETCH_BACKOFF_MS = 300 * 1e3;
+const WA_SOCKET_LOCK_OPTIONS = {
+	retries: {
+		retries: 0,
+		factor: 1,
+		minTimeout: 100,
+		maxTimeout: 100
+	},
+	stale: 10080 * 60 * 1e3,
+	reentrant: false
+};
+const WA_SOCKET_LOCK_RELEASE_KEY = "__openclawWaSocketLockRelease";
+let cachedBaileysVersion = null;
+let inflightBaileysVersion = null;
+let baileysVersionFetchBackoffUntil = 0;
+function fetchBaileysVersionOnce() {
+	if (inflightBaileysVersion) return inflightBaileysVersion;
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), BAILEYS_VERSION_FETCH_TIMEOUT_MS);
+	const next = getBaileys().then(({ fetchLatestBaileysVersion }) => fetchLatestBaileysVersion({ signal: controller.signal })).finally(() => {
+		clearTimeout(timeout);
+		if (inflightBaileysVersion === next) inflightBaileysVersion = null;
+	});
+	inflightBaileysVersion = next;
+	return next;
+}
+function backOffBaileysVersionFetch() {
+	baileysVersionFetchBackoffUntil = Date.now() + BAILEYS_VERSION_FETCH_BACKOFF_MS;
+	inflightBaileysVersion = null;
+}
+function resolveWaSocketLockPath(authDir) {
+	return path.join(authDir, ".socket-owner");
+}
+function shouldAcquireWaSocketLock() {
+	return process.env.VITEST !== "true" || process.env.OPENCLAW_TEST_WA_SOCKET_LOCK === "1";
+}
+async function acquireWaSocketLock(authDir) {
+	try {
+		return await acquireFileLock(resolveWaSocketLockPath(authDir), WA_SOCKET_LOCK_OPTIONS);
+	} catch (err) {
+		throw new Error(`WhatsApp auth directory is already in use by another openclaw process or socket in this process (${authDir}). Stop the gateway or use the gateway login flow before relinking.`, { cause: err });
+	}
+}
+function attachWaSocketLockRelease(sock, lock) {
+	let releasePromise = null;
+	const release = () => {
+		if (!releasePromise) releasePromise = lock.release().catch((err) => {
+			releasePromise = null;
+			throw err;
+		});
+		return releasePromise;
+	};
+	sock[WA_SOCKET_LOCK_RELEASE_KEY] = release;
+}
+async function closeWaSocket(sock) {
+	const release = sock[WA_SOCKET_LOCK_RELEASE_KEY];
+	try {
+		sock.ws?.close();
+	} catch {}
+	await release?.();
+	if (release) delete sock[WA_SOCKET_LOCK_RELEASE_KEY];
+}
+function withBaileysVersionTimeout(promise, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => resolve(null), timeoutMs);
+		promise.then((result) => {
+			clearTimeout(timeout);
+			resolve(result);
+		}, (err) => {
+			clearTimeout(timeout);
+			reject(err);
+		});
+	});
+}
+async function resolveBaileysVersion(logger) {
+	const { DEFAULT_CONNECTION_CONFIG } = await getBaileys();
+	const now = Date.now();
+	if (cachedBaileysVersion && now - cachedBaileysVersion.fetchedAt < BAILEYS_VERSION_CACHE_TTL_MS) return cachedBaileysVersion.version;
+	if (now < baileysVersionFetchBackoffUntil) return cachedBaileysVersion?.version ?? DEFAULT_CONNECTION_CONFIG.version;
+	try {
+		const result = await withBaileysVersionTimeout(fetchBaileysVersionOnce(), BAILEYS_VERSION_FETCH_TIMEOUT_MS);
+		if (!result) {
+			logger.warn("timed out fetching latest WhatsApp Web version");
+			backOffBaileysVersionFetch();
+			return cachedBaileysVersion?.version ?? DEFAULT_CONNECTION_CONFIG.version;
+		}
+		if (result.error) {
+			logger.warn({ error: safeStringify(result.error) }, "failed fetching latest WhatsApp Web version");
+			backOffBaileysVersionFetch();
+		} else {
+			cachedBaileysVersion = {
+				version: result.version,
+				fetchedAt: now
+			};
+			baileysVersionFetchBackoffUntil = 0;
+			return result.version;
+		}
+	} catch (err) {
+		logger.warn({ error: String(err) }, "failed fetching latest WhatsApp Web version");
+		backOffBaileysVersionFetch();
+	}
+	return cachedBaileysVersion?.version ?? DEFAULT_CONNECTION_CONFIG.version;
+}
+async function createWaSocket(printQr, verbose, opts = {}) {
+	const noop = (..._args) => {};
+	const noopLogger = {
+		level: "silent",
+		child: () => noopLogger,
+		trace: noop,
+		debug: noop,
+		info: noop,
+		warn: noop,
+		error: noop,
+		fatal: noop
+	};
+	const logger = verbose ? toPinoLikeLogger(getChildLogger({ module: "baileys" }, { level: "info" }), "info") : noopLogger;
+	const authDir = resolveUserPath(opts.authDir ?? resolveDefaultWebAuthDir());
+	await ensureDir(authDir);
+	const sessionLogger = getChildLogger({ module: "web-session" });
+	const socketLock = shouldAcquireWaSocketLock() ? await acquireWaSocketLock(authDir) : null;
+	let sock;
+	try {
+		const { useMultiFileAuthState, makeWASocket, makeCacheableSignalKeyStore } = await getBaileys();
+		clearWebAuthClearSuppression(authDir);
+		maybeRestoreCredsFromBackup(authDir);
+		const { state, saveCreds } = await useMultiFileAuthState(authDir);
+		const version = await resolveBaileysVersion(sessionLogger);
+		sock = makeWASocket({
+			auth: {
+				creds: state.creds,
+				keys: makeCacheableSignalKeyStore(state.keys, logger)
+			},
+			version,
+			logger,
+			printQRInTerminal: false,
+			browser: [
+				"openclaw",
+				"cli",
+				VERSION
+			],
+			syncFullHistory: false,
+			markOnlineOnConnect: false
+		});
+		sock.ev.on("creds.update", () => enqueueWebCredsSave(authDir, saveCreds, sessionLogger));
+	} catch (err) {
+		await socketLock?.release();
+		throw err;
+	}
+	if (socketLock) attachWaSocketLockRelease(sock, socketLock);
+	const attachedWebSockets = /* @__PURE__ */ new WeakSet();
+	const attachWebSocketErrorHandler = () => {
+		const ws = sock.ws;
+		if (!ws || typeof ws !== "object" || attachedWebSockets.has(ws)) return;
+		const on = ws.on;
+		if (typeof on !== "function") return;
+		on.call(ws, "error", (err) => {
+			sessionLogger.error({ error: String(err) }, "WebSocket error");
+		});
+		attachedWebSockets.add(ws);
+	};
+	const { DisconnectReason } = await getBaileys();
+	sock.ev.on("connection.update", (update) => {
+		try {
+			const { connection, lastDisconnect, qr } = update;
+			attachWebSocketErrorHandler();
+			if (qr) {
+				opts.onQr?.(qr);
+				if (printQr) {
+					sessionLogger.info("Scan this QR in WhatsApp (Linked Devices):");
+					qrcode.generate(qr, { small: true });
+				}
+			}
+			if (connection === "close") {
+				if (getStatusCode(lastDisconnect?.error) === DisconnectReason.loggedOut) sessionLogger.error(danger(`WhatsApp session logged out. Run: ${formatCliCommand("openclaw channels login")}`));
+			}
+			if (connection === "open" && verbose) sessionLogger.info(success("WhatsApp Web connected."));
+		} catch (err) {
+			sessionLogger.error({ error: String(err) }, "connection.update handler error");
+		}
+	});
+	attachWebSocketErrorHandler();
+	return sock;
+}
+async function waitForWaConnection(sock) {
+	return new Promise((resolve, reject) => {
+		const evWithOff = sock.ev;
+		const handler = (...args) => {
+			const update = args[0] ?? {};
+			if (update.connection === "open") {
+				removeHandler();
+				resolve();
+			}
+			if (update.connection === "close") {
+				removeHandler();
+				reject(update.lastDisconnect ?? /* @__PURE__ */ new Error("Connection closed"));
+			}
+		};
+		function removeHandler() {
+			if (typeof evWithOff.off === "function") {
+				evWithOff.off("connection.update", handler);
+				return;
+			}
+			evWithOff.removeListener?.("connection.update", handler);
+		}
+		sock.ev.on("connection.update", handler);
+	});
+}
+function getStatusCode(err) {
+	const nested = err;
+	return nested.output?.statusCode ?? nested.status ?? nested.error?.output?.statusCode ?? nested.error?.status ?? nested.lastDisconnect?.error?.output?.statusCode ?? nested.lastDisconnect?.error?.status;
+}
+function safeStringify(value, limit = 800) {
+	try {
+		const seen = /* @__PURE__ */ new WeakSet();
+		const raw = JSON.stringify(value, (_key, v) => {
+			if (typeof v === "bigint") return v.toString();
+			if (typeof v === "function") {
+				const maybeName = v.name;
+				return `[Function ${typeof maybeName === "string" && maybeName.length > 0 ? maybeName : "anonymous"}]`;
+			}
+			if (typeof v === "object" && v) {
+				if (seen.has(v)) return "[Circular]";
+				seen.add(v);
+			}
+			return v;
+		}, 2);
+		if (!raw) return String(value);
+		return raw.length > limit ? `${raw.slice(0, limit)}...` : raw;
+	} catch {
+		return String(value);
+	}
+}
+function extractBoomDetails(err) {
+	if (!err || typeof err !== "object") return null;
+	const output = err?.output;
+	if (!output || typeof output !== "object") return null;
+	const payload = output.payload;
+	const statusCode = typeof output.statusCode === "number" ? output.statusCode : typeof payload?.statusCode === "number" ? payload.statusCode : void 0;
+	const error = typeof payload?.error === "string" ? payload.error : void 0;
+	const message = typeof payload?.message === "string" ? payload.message : void 0;
+	if (!statusCode && !error && !message) return null;
+	return {
+		statusCode,
+		error,
+		message
+	};
+}
+function formatError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (!err || typeof err !== "object") return String(err);
+	const boom = extractBoomDetails(err) ?? extractBoomDetails(err?.error) ?? extractBoomDetails(err?.lastDisconnect?.error);
+	const status = boom?.statusCode ?? getStatusCode(err);
+	const code = err?.code;
+	const codeText = typeof code === "string" || typeof code === "number" ? String(code) : void 0;
+	const message = [
+		boom?.message,
+		typeof err?.message === "string" ? err.message : void 0,
+		typeof err?.error?.message === "string" ? err.error?.message : void 0
+	].filter((v) => Boolean(v && v.trim().length > 0))[0];
+	const pieces = [];
+	if (typeof status === "number") pieces.push(`status=${status}`);
+	if (boom?.error) pieces.push(boom.error);
+	if (message) pieces.push(message);
+	if (codeText) pieces.push(`code=${codeText}`);
+	if (pieces.length > 0) return pieces.join(" ");
+	return safeStringify(err);
+}
+
+//#endregion
+//#region src/login-qr.ts
+var login_qr_exports = /* @__PURE__ */ __exportAll({
+	canonicalWhatsAppAuthDir: () => canonicalWhatsAppAuthDir,
+	closeActiveWebLoginsForAuthDir: () => closeActiveWebLoginsForAuthDir,
+	startWebLoginWithQr: () => startWebLoginWithQr,
+	tryCanonicalWhatsAppAuthDir: () => tryCanonicalWhatsAppAuthDir,
+	waitForWebLogin: () => waitForWebLogin
+});
+const ACTIVE_LOGIN_TTL_MS = 3 * 6e4;
+const activeLogins = /* @__PURE__ */ new Map();
+function loadRuntimeConfig(cfg) {
+	return cfg ?? getWhatsAppRuntime().config.loadConfig();
+}
+async function closeSocket(sock) {
+	try {
+		await closeWaSocket(sock);
+	} catch {
+		await closeWaSocket(sock);
+	}
+}
+async function resetActiveLogin(accountId, reason) {
+	const login = activeLogins.get(accountId);
+	if (login) try {
+		await closeSocket(login.sock);
+	} finally {
+		activeLogins.delete(accountId);
+	}
+	if (reason) logInfo(reason);
+}
+function canonicalWhatsAppAuthDir(authDir) {
+	const resolvedAuthDir = resolveUserPath(authDir);
+	try {
+		return fs.realpathSync.native(resolvedAuthDir);
+	} catch (err) {
+		if (err.code === "ENOENT") return resolvedAuthDir;
+		throw err;
+	}
+}
+function tryCanonicalWhatsAppAuthDir(authDir) {
+	try {
+		return canonicalWhatsAppAuthDir(authDir);
+	} catch {
+		return null;
+	}
+}
+async function closeActiveWebLoginsForAuthDir(authDir) {
+	const resolvedAuthDir = tryCanonicalWhatsAppAuthDir(authDir);
+	if (!resolvedAuthDir) return 0;
+	const accountIds = [...activeLogins.values()].filter((login) => tryCanonicalWhatsAppAuthDir(login.authDir) === resolvedAuthDir).map((login) => login.accountId);
+	await Promise.all(accountIds.map((accountId) => resetActiveLogin(accountId)));
+	return accountIds.length;
+}
+function isLoginFresh(login) {
+	return Date.now() - login.startedAt < ACTIVE_LOGIN_TTL_MS;
+}
+function findActiveGatewayAccountForAuthDir(params) {
+	const resolvedAuthDir = tryCanonicalWhatsAppAuthDir(params.authDir);
+	if (resolvedAuthDir === null) return null;
+	const candidateAccountIds = new Set([params.accountId, ...listWhatsAppAccountIds(params.cfg)]);
+	for (const accountId of candidateAccountIds) {
+		if (tryCanonicalWhatsAppAuthDir(resolveWhatsAppAccount$1({
+			cfg: params.cfg,
+			accountId
+		}).authDir) !== resolvedAuthDir) continue;
+		if (getActiveWebListener(accountId)) return accountId;
+	}
+	return null;
+}
+function attachLoginWaiter(accountId, login) {
+	login.waitPromise = waitForWaConnection(login.sock).then(() => {
+		const current = activeLogins.get(accountId);
+		if (current?.id === login.id) current.connected = true;
+	}).catch((err) => {
+		const current = activeLogins.get(accountId);
+		if (current?.id !== login.id) return;
+		current.error = formatError(err);
+		current.errorStatus = getStatusCode(err);
+	});
+}
+async function restartLoginSocket(login, runtime) {
+	if (login.restartAttempted) return false;
+	login.restartAttempted = true;
+	runtime.log(info("WhatsApp asked for a restart after pairing (code 515); retrying connection once..."));
+	await closeSocket(login.sock);
+	try {
+		login.sock = await createWaSocket(false, login.verbose, { authDir: login.authDir });
+		login.connected = false;
+		login.error = void 0;
+		login.errorStatus = void 0;
+		attachLoginWaiter(login.accountId, login);
+		return true;
+	} catch (err) {
+		login.error = formatError(err);
+		login.errorStatus = getStatusCode(err);
+		return false;
+	}
+}
+async function startWebLoginWithQr(opts = {}) {
+	const runtime = opts.runtime ?? defaultRuntime;
+	const cfg = loadRuntimeConfig(opts.cfg);
+	const account = resolveWhatsAppAccount$1({
+		cfg,
+		accountId: opts.accountId
+	});
+	const hasWeb = await webAuthExists(account.authDir);
+	const selfId = readWebSelfId(account.authDir);
+	if (hasWeb && !opts.force) return { message: `WhatsApp is already linked (${selfId.e164 ?? selfId.jid ?? "unknown"}). Say "relink" if you want a fresh QR.` };
+	if (tryCanonicalWhatsAppAuthDir(account.authDir) === null) return { message: `Cannot start QR login: WhatsApp auth directory ${account.authDir} is not accessible (broken symlink or permission error). Fix the directory before relinking.` };
+	const activeGatewayAccount = findActiveGatewayAccountForAuthDir({
+		cfg,
+		accountId: account.accountId,
+		authDir: account.authDir
+	});
+	if (activeGatewayAccount) return { message: activeGatewayAccount === account.accountId ? "WhatsApp gateway is running for this account. Stop the channel or use the gateway login flow before relinking." : `WhatsApp gateway is running for account ${activeGatewayAccount} using this auth directory. Stop that channel or use the gateway login flow before relinking.` };
+	const existing = activeLogins.get(account.accountId);
+	if (existing && isLoginFresh(existing) && existing.qrDataUrl) return {
+		qrDataUrl: existing.qrDataUrl,
+		message: "QR already active. Scan it in WhatsApp -> Linked Devices."
+	};
+	await resetActiveLogin(account.accountId);
+	let resolveQr = null;
+	let rejectQr = null;
+	const qrPromise = new Promise((resolve, reject) => {
+		resolveQr = resolve;
+		rejectQr = reject;
+	});
+	const qrTimer = setTimeout(() => {
+		rejectQr?.(/* @__PURE__ */ new Error("Timed out waiting for WhatsApp QR"));
+	}, Math.max(opts.timeoutMs ?? 3e4, 5e3));
+	let sock;
+	let pendingQr = null;
+	try {
+		sock = await createWaSocket(false, Boolean(opts.verbose), {
+			authDir: account.authDir,
+			onQr: (qr) => {
+				if (pendingQr) return;
+				pendingQr = qr;
+				const current = activeLogins.get(account.accountId);
+				if (current && !current.qr) current.qr = qr;
+				clearTimeout(qrTimer);
+				runtime.log(info("WhatsApp QR received."));
+				resolveQr?.(qr);
+			}
+		});
+	} catch (err) {
+		clearTimeout(qrTimer);
+		await resetActiveLogin(account.accountId);
+		return { message: `Failed to start WhatsApp login: ${String(err)}` };
+	}
+	const login = {
+		accountId: account.accountId,
+		authDir: account.authDir,
+		isLegacyAuthDir: account.isLegacyAuthDir,
+		id: randomUUID(),
+		sock,
+		startedAt: Date.now(),
+		connected: false,
+		waitPromise: Promise.resolve(),
+		restartAttempted: false,
+		verbose: Boolean(opts.verbose)
+	};
+	activeLogins.set(account.accountId, login);
+	if (pendingQr && !login.qr) login.qr = pendingQr;
+	attachLoginWaiter(account.accountId, login);
+	let qr;
+	try {
+		qr = await qrPromise;
+	} catch (err) {
+		clearTimeout(qrTimer);
+		await resetActiveLogin(account.accountId);
+		return { message: `Failed to get QR: ${String(err)}` };
+	}
+	login.qrDataUrl = `data:image/png;base64,${await renderQrPngBase64(qr)}`;
+	return {
+		qrDataUrl: login.qrDataUrl,
+		message: "Scan this QR in WhatsApp -> Linked Devices."
+	};
+}
+async function waitForWebLogin(opts = {}) {
+	const { DisconnectReason } = await getBaileys();
+	const runtime = opts.runtime ?? defaultRuntime;
+	const account = resolveWhatsAppAccount$1({
+		cfg: loadRuntimeConfig(opts.cfg),
+		accountId: opts.accountId
+	});
+	const activeLogin = activeLogins.get(account.accountId);
+	if (!activeLogin) return {
+		connected: false,
+		message: "No active WhatsApp login in progress."
+	};
+	const login = activeLogin;
+	if (!isLoginFresh(login)) {
+		await resetActiveLogin(account.accountId);
+		return {
+			connected: false,
+			message: "The login QR expired. Ask me to generate a new one."
+		};
+	}
+	const timeoutMs = Math.max(opts.timeoutMs ?? 12e4, 1e3);
+	const deadline = Date.now() + timeoutMs;
+	while (true) {
+		const remaining = deadline - Date.now();
+		if (remaining <= 0) return {
+			connected: false,
+			message: "Still waiting for the QR scan. Let me know when you've scanned it."
+		};
+		let timeoutHandle;
+		const timeout = new Promise((resolve) => {
+			timeoutHandle = setTimeout(() => resolve("timeout"), remaining);
+		});
+		let result;
+		try {
+			result = await Promise.race([login.waitPromise.then(() => "done"), timeout]);
+		} finally {
+			if (timeoutHandle) clearTimeout(timeoutHandle);
+		}
+		if (result === "timeout") return {
+			connected: false,
+			message: "Still waiting for the QR scan. Let me know when you've scanned it."
+		};
+		if (login.error) {
+			if (login.errorStatus === DisconnectReason.loggedOut) {
+				await closeActiveWebLoginsForAuthDir(login.authDir);
+				await logoutWeb({
+					authDir: login.authDir,
+					isLegacyAuthDir: login.isLegacyAuthDir,
+					runtime
+				});
+				const message = "WhatsApp reported the session is logged out. Cleared cached web session; please scan a new QR.";
+				logInfo(message);
+				runtime.log(danger(message));
+				return {
+					connected: false,
+					message
+				};
+			}
+			if (login.errorStatus === 515) {
+				if (await restartLoginSocket(login, runtime) && isLoginFresh(login)) continue;
+			}
+			const message = `WhatsApp login failed: ${login.error}`;
+			await resetActiveLogin(account.accountId, message);
+			runtime.log(danger(message));
+			return {
+				connected: false,
+				message
+			};
+		}
+		if (login.connected) {
+			const message = "Linked! WhatsApp is ready.";
+			runtime.log(success(message));
+			await resetActiveLogin(account.accountId);
+			return {
+				connected: true,
+				message
+			};
+		}
+		return {
+			connected: false,
+			message: "Login ended without a connection."
+		};
+	}
+}
+
+//#endregion
+export { listWhatsAppAccountIds as C, resolveWhatsAppAuthDir as E, stopActiveWebListener as S, resolveWhatsAppAccount$1 as T, webAuthExists as _, waitForWebLogin as a, getActiveWebListener as b, formatError as c, getBaileys as d, getWebAuthAgeMs as f, waitForWebCredsSaveQueue as g, readWebSelfId as h, tryCanonicalWhatsAppAuthDir as i, getStatusCode as l, logoutWeb as m, login_qr_exports as n, closeWaSocket as o, logWebSelfId as p, startWebLoginWithQr as r, createWaSocket as s, closeActiveWebLoginsForAuthDir as t, waitForWaConnection as u, getWhatsAppRuntime as v, resolveDefaultWhatsAppAccountId as w, setActiveWebListener as x, setWhatsAppRuntime as y };