@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.33

package/dist/auth-store-DcEpIOmE.js

@@ -1,400 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as readWebCredsJsonRawSync, c as statWebCredsFileSync, i as readWebCredsJsonRaw, o as resolveWebCredsBackupPath, r as hasWebCredsSync, s as resolveWebCredsPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-B1kSWtBg.js";
-import { n as resolveUserPath } from "./text-runtime-CaKLhowd.js";
-import { c as resolveComparableIdentity } from "./identity-CPrT5aEU.js";
-import path from "node:path";
-import { resolveOAuthDir as resolveOAuthDir$1 } from "openclaw/plugin-sdk/state-paths";
-import { replaceFileAtomic } from "openclaw/plugin-sdk/security-runtime";
-import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
-import { defaultRuntime, getChildLogger, info, success } from "openclaw/plugin-sdk/runtime-env";
-import fs from "node:fs/promises";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
-import { enqueueKeyedTask } from "openclaw/plugin-sdk/keyed-async-queue";
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-//#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-Nsqaehbd.js").then((n) => n.o);
-	return JSON.stringify(creds, BufferJSON.replacer);
-}
-async function writeWebCredsRawAtomically(params) {
-	await assertWebCredsPathRegularFileOrMissing(params.filePath);
-	await replaceFileAtomic({
-		filePath: params.filePath,
-		content: params.content,
-		dirMode: 448,
-		mode: CREDS_FILE_MODE,
-		tempPrefix: params.tempPrefix,
-		syncTempFile: true,
-		syncParentDir: true,
-		beforeRename: async ({ filePath }) => {
-			await assertWebCredsPathRegularFileOrMissing(filePath);
-		}
-	});
-}
-async function writeCredsJsonAtomically(authDir, creds) {
-	await writeWebCredsRawAtomically({
-		filePath: resolveWebCredsPath(authDir),
-		content: await stringifyCreds(creds),
-		tempPrefix: ".creds"
-	});
-}
-function enqueueCredsSave(authDir, saveCreds, onError) {
-	enqueueKeyedTask({
-		tails: credsSaveQueues,
-		key: authDir,
-		task: async () => {
-			try {
-				await saveCreds();
-			} catch (error) {
-				onError(error);
-			}
-		}
-	});
-}
-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) {
-	const boundedTimeoutMs = resolveTimerTimeoutMs(timeoutMs, CREDS_SAVE_FLUSH_TIMEOUT_MS, 0);
-	let flushTimeout;
-	return await Promise.race([waitForCredsSaveQueue(authDir).then(() => "drained"), new Promise((resolve) => {
-		flushTimeout = setTimeout(() => resolve("timed_out"), boundedTimeoutMs);
-	})]).finally(() => {
-		if (flushTimeout) clearTimeout(flushTimeout);
-	});
-}
-//#endregion
-//#region extensions/whatsapp/src/auth-store.ts
-var auth_store_exports = /* @__PURE__ */ __exportAll({
-	WA_WEB_AUTH_DIR: () => WA_WEB_AUTH_DIR,
-	WHATSAPP_AUTH_UNSTABLE_CODE: () => WHATSAPP_AUTH_UNSTABLE_CODE,
-	WhatsAppAuthUnstableError: () => WhatsAppAuthUnstableError,
-	formatWhatsAppWebAuthStatusState: () => formatWhatsAppWebAuthStatusState,
-	getWebAuthAgeMs: () => getWebAuthAgeMs,
-	hasWebCredsSync: () => hasWebCredsSync,
-	logWebSelfId: () => logWebSelfId,
-	logoutWeb: () => logoutWeb,
-	pickWebChannel: () => pickWebChannel,
-	readCredsJsonRaw: () => readCredsJsonRaw,
-	readWebAuthExistsBestEffort: () => readWebAuthExistsBestEffort,
-	readWebAuthExistsForDecision: () => readWebAuthExistsForDecision,
-	readWebAuthSnapshot: () => readWebAuthSnapshot,
-	readWebAuthSnapshotBestEffort: () => readWebAuthSnapshotBestEffort,
-	readWebAuthState: () => readWebAuthState,
-	readWebSelfId: () => readWebSelfId,
-	readWebSelfIdentity: () => readWebSelfIdentity,
-	readWebSelfIdentityForDecision: () => readWebSelfIdentityForDecision,
-	resolveDefaultWebAuthDir: () => resolveDefaultWebAuthDir,
-	resolveWebCredsBackupPath: () => resolveWebCredsBackupPath,
-	resolveWebCredsPath: () => resolveWebCredsPath,
-	restoreCredsFromBackupIfNeeded: () => restoreCredsFromBackupIfNeeded,
-	webAuthExists: () => webAuthExists
-});
-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) {
-	return readWebCredsJsonRawSync(filePath);
-}
-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;
-}
-function isValidJson(raw) {
-	try {
-		JSON.parse(raw);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function restoreCredsFromBackupIfNeeded(authDir, options) {
-	const logger = getChildLogger({ module: "web-session" });
-	let restore;
-	try {
-		const credsPath = resolveWebCredsPath(authDir);
-		const backupPath = resolveWebCredsBackupPath(authDir);
-		try {
-			await assertWebCredsPathRegularFileOrMissing(credsPath);
-		} catch {
-			return false;
-		}
-		const raw = readCredsJsonRaw(credsPath);
-		if (raw && isValidJson(raw)) return false;
-		const backupRaw = readCredsJsonRaw(backupPath);
-		if (!backupRaw || !isValidJson(backupRaw)) return false;
-		restore = {
-			content: backupRaw,
-			credsPath
-		};
-	} catch {
-		return false;
-	}
-	await options?.beforeCredentialPersistence?.();
-	try {
-		await writeWebCredsRawAtomically({
-			filePath: restore.credsPath,
-			content: restore.content,
-			tempPrefix: ".creds.restore"
-		});
-		logger.warn({ credsPath: restore.credsPath }, "restored corrupted WhatsApp creds.json from backup");
-		return true;
-	} catch {}
-	return false;
-}
-async function webAuthExists(authDir = resolveDefaultWebAuthDir()) {
-	const raw = await readWebCredsJsonRaw(resolveWebCredsPath(resolveUserPath(authDir)));
-	if (!raw) return false;
-	try {
-		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 = 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, beforeCredentialPersistence) {
-	const rootStats = await fs.lstat(authDir).catch(() => null);
-	if (!rootStats?.isDirectory() || rootStats.isSymbolicLink()) return;
-	const credentialFiles = (await fs.readdir(authDir, { withFileTypes: true })).filter((entry) => entry.isFile() && isBaileysAuthFileName(entry.name));
-	if (credentialFiles.length === 0) return;
-	await beforeCredentialPersistence?.();
-	await Promise.all(credentialFiles.map(async (entry) => {
-		await fs.rm(path.join(authDir, entry.name), { force: true });
-	}));
-}
-async function shouldClearOnLogout(authDir, isLegacyAuthDir) {
-	try {
-		const stats = await fs.lstat(authDir);
-		if (!stats.isDirectory() || stats.isSymbolicLink()) return false;
-		if (isLegacyAuthDir) return (await fs.readdir(authDir, { withFileTypes: true })).some((entry) => {
-			if (!entry.isFile()) return false;
-			return isBaileysAuthFileName(entry.name);
-		});
-		if ((await fs.lstat(resolveWebCredsPath(authDir)).catch(() => null))?.isFile()) return true;
-		return (await fs.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.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.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.realpath(whatsappAuthBase).catch(() => null), fs.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 = 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, params.beforeCredentialPersistence);
-	} else {
-		const ownership = await classifyWebAuthDirOwnership(resolvedAuthDir);
-		if (ownership.kind === "owned") {
-			await params.beforeCredentialPersistence?.();
-			await fs.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 raw = readCredsJsonRaw(resolveWebCredsPath(resolveUserPath(authDir)));
-		if (!raw) return emptyWebSelfId();
-		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 = resolveUserPath(authDir);
-	const raw = await readWebCredsJsonRaw(resolveWebCredsPath(resolvedAuthDir));
-	if (raw) try {
-		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 = 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()) {
-	const stats = statWebCredsFileSync(resolveWebCredsPath(resolveUserPath(authDir)));
-	return stats ? Math.max(0, Date.now() - stats.mtimeMs) : 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 { waitForCredsSaveQueue as C, writeWebCredsRawAtomically as E, enqueueCredsSave as S, writeCredsJsonAtomically as T, readWebSelfIdentity as _, formatWhatsAppWebAuthStatusState as a, restoreCredsFromBackupIfNeeded as b, logoutWeb as c, readWebAuthExistsBestEffort as d, readWebAuthExistsForDecision as f, readWebSelfId as g, readWebAuthState as h, auth_store_exports as i, pickWebChannel as l, readWebAuthSnapshotBestEffort as m, WHATSAPP_AUTH_UNSTABLE_CODE as n, getWebAuthAgeMs as o, readWebAuthSnapshot as p, WhatsAppAuthUnstableError as r, logWebSelfId as s, WA_WEB_AUTH_DIR as t, readCredsJsonRaw as u, readWebSelfIdentityForDecision as v, waitForCredsSaveQueueWithTimeout as w, webAuthExists as x, resolveDefaultWebAuthDir as y };

package/dist/call-tool-api.js

@@ -1,225 +0,0 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
-import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
-import { s as resolveJidToE164 } from "./targets-runtime-TMk0lGuy.js";
-import { createActionGate, stringEnum } from "openclaw/plugin-sdk/channel-actions";
-import path from "node:path";
-import { resolveOAuthDir } from "openclaw/plugin-sdk/state-paths";
-import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { Type } from "typebox";
-import fs from "node:fs/promises";
-import { mulawToPcm } from "openclaw/plugin-sdk/realtime-voice";
-import { detectBinary } from "openclaw/plugin-sdk/setup-tools";
-import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
-import { jsonResult as jsonResult$1 } from "openclaw/plugin-sdk/tool-results";
-//#region extensions/whatsapp/src/agent-tools-call.ts
-const MEOWCALLER_COMMAND = "meowcaller";
-const SESSION_DATABASE = "wa-voip.db";
-const MAX_AUDIO_DURATION_MS = 6e4;
-const MIN_CALL_WINDOW_MS = 115e3;
-const MAX_CALL_WINDOW_MS = 175e3;
-const MAX_MESSAGE_LENGTH = 4e3;
-const MAX_COMMAND_OUTPUT_BYTES = 64 * 1024;
-const MEOWCALLER_ANSWER_TIMEOUT = "45s";
-const MEOWCALLER_MAX_DURATION = "65s";
-const activeCallAccounts = /* @__PURE__ */ new Set();
-const WhatsAppCallToolSchema = Type.Object({
-	action: stringEnum(["status", "call"], { description: "Check MeowCaller setup or call the current WhatsApp requester" }),
-	message: Type.Optional(Type.String({
-		description: "Spoken message to play after the requester answers (maximum 60 seconds)",
-		maxLength: MAX_MESSAGE_LENGTH
-	}))
-}, { additionalProperties: false });
-const defaultDependencies = {
-	detectMeowCaller: () => detectBinary(MEOWCALLER_COMMAND),
-	resolveStateDir: (accountId) => path.join(resolveOAuthDir(), "whatsapp-calls", normalizeAccountId(accountId))
-};
-async function isRegularFile(filePath) {
-	try {
-		return (await fs.stat(filePath)).isFile();
-	} catch {
-		return false;
-	}
-}
-function quotePosixShellArg(value) {
-	return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-function quotePowerShellArg(value) {
-	return `'${value.replaceAll("'", "''")}'`;
-}
-function resolveSetupCommand(stateDir, sessionStorePath, platform = process.platform) {
-	if (platform === "win32") return `meowcaller pair --store ${quotePowerShellArg(sessionStorePath)}`;
-	const quotedStateDir = quotePosixShellArg(stateDir);
-	return `mkdir -p ${quotedStateDir} && chmod 700 ${quotedStateDir} && meowcaller pair --store ${quotePosixShellArg(sessionStorePath)}`;
-}
-function wrapPcm16MonoInWav(pcm, sampleRate) {
-	if (!Number.isInteger(sampleRate) || sampleRate <= 0) throw new Error("TTS returned an invalid sample rate");
-	if (pcm.length === 0 || pcm.length % 2 !== 0) throw new Error("TTS returned invalid 16-bit PCM audio");
-	const header = Buffer.alloc(44);
-	header.write("RIFF", 0, "ascii");
-	header.writeUInt32LE(36 + pcm.length, 4);
-	header.write("WAVE", 8, "ascii");
-	header.write("fmt ", 12, "ascii");
-	header.writeUInt32LE(16, 16);
-	header.writeUInt16LE(1, 20);
-	header.writeUInt16LE(1, 22);
-	header.writeUInt32LE(sampleRate, 24);
-	header.writeUInt32LE(sampleRate * 2, 28);
-	header.writeUInt16LE(2, 32);
-	header.writeUInt16LE(16, 34);
-	header.write("data", 36, "ascii");
-	header.writeUInt32LE(pcm.length, 40);
-	return Buffer.concat([header, pcm]);
-}
-function normalizeTelephonyPcm(audio, outputFormat) {
-	const normalizedFormat = outputFormat?.trim().toLowerCase();
-	if (normalizedFormat?.startsWith("pcm")) return audio;
-	if (normalizedFormat === "ulaw_8000" || normalizedFormat === "raw-8khz-8bit-mono-mulaw") return mulawToPcm(audio);
-	throw new Error(`TTS returned unsupported telephony format: ${outputFormat ?? "unknown"}`);
-}
-function resolveCallWindowMs(pcmBytes, sampleRate) {
-	const audioDurationMs = pcmBytes / 2 / sampleRate * 1e3;
-	if (audioDurationMs > MAX_AUDIO_DURATION_MS) throw new Error("TTS audio exceeds the 60-second WhatsApp call limit");
-	return Math.min(MAX_CALL_WINDOW_MS, Math.ceil(audioDurationMs + MIN_CALL_WINDOW_MS));
-}
-async function resolveRequesterE164(params) {
-	const senderId = params.requesterSenderId.trim();
-	if (!senderId.includes("@")) try {
-		return normalizeE164(senderId.replace(/^whatsapp:/i, ""));
-	} catch {
-		return null;
-	}
-	const account = resolveWhatsAppAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const lidLookup = getWhatsAppConnectionController(params.accountId)?.getCurrentSock()?.signalRepository.lidMapping;
-	return await resolveJidToE164(senderId, {
-		authDir: account.authDir,
-		lidLookup
-	});
-}
-async function resolveLinkedWhatsAppSelfE164(params) {
-	const controller = getWhatsAppConnectionController(params.accountId);
-	if (!controller) return null;
-	const identity = controller.getSelfIdentity();
-	if (!identity) return null;
-	if (identity.e164) return normalizeE164(identity.e164);
-	const account = resolveWhatsAppAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const lidLookup = controller.getCurrentSock()?.signalRepository.lidMapping;
-	return await resolveJidToE164(identity.jid ?? identity.lid, {
-		authDir: account.authDir,
-		lidLookup
-	});
-}
-function resolveRuntimeConfig(api, context) {
-	return context.getRuntimeConfig?.() ?? context.runtimeConfig ?? context.config ?? api.config;
-}
-function createWhatsAppCallToolWithDependencies(api, context, dependencies) {
-	const cfg = resolveRuntimeConfig(api, context);
-	const isActionEnabled = createActionGate(cfg.channels?.whatsapp?.actions);
-	const requesterSenderId = context.requesterSenderId?.trim();
-	if (!isActionEnabled("calls", false) || context.messageChannel !== "whatsapp" || !requesterSenderId) return null;
-	const accountId = normalizeAccountId(context.agentAccountId);
-	const stateDir = dependencies.resolveStateDir(accountId);
-	const sessionStorePath = path.join(stateDir, SESSION_DATABASE);
-	return {
-		name: "whatsapp_call",
-		label: "WhatsApp Call",
-		description: "Call the current WhatsApp requester and play a synthesized spoken message. This tool cannot call arbitrary phone numbers.",
-		parameters: WhatsAppCallToolSchema,
-		async execute(_toolCallId, rawParams, signal) {
-			const params = rawParams;
-			const binaryFound = await dependencies.detectMeowCaller();
-			const sessionStoreFound = await isRegularFile(sessionStorePath);
-			if (params.action === "status") return jsonResult$1({
-				binaryFound,
-				sessionStoreFound,
-				accountId,
-				stateDir,
-				setupCommand: resolveSetupCommand(stateDir, sessionStorePath),
-				setupShell: process.platform === "win32" ? "PowerShell" : "POSIX shell",
-				requiredCommand: "meowcaller notify --store <path> --answer-timeout 45s --max-duration 65s <target> <file>",
-				note: "MeowCaller uses a separate WhatsApp linked-device session; it cannot reuse OpenClaw's Baileys credentials."
-			});
-			const message = params.message?.trim();
-			if (!message) throw new Error("message required for call action");
-			if (message.length > MAX_MESSAGE_LENGTH) throw new Error(`message must be at most ${MAX_MESSAGE_LENGTH} characters`);
-			if (!binaryFound) throw new Error("MeowCaller is not installed; run whatsapp_call with action=status");
-			if (!sessionStoreFound) throw new Error("MeowCaller has no session store; run whatsapp_call with action=status, then run its setupCommand in an interactive terminal and scan the QR as a linked device");
-			const target = await resolveRequesterE164({
-				accountId,
-				cfg,
-				requesterSenderId
-			});
-			if (!target) throw new Error("Could not resolve the current WhatsApp requester to a phone number");
-			if (await resolveLinkedWhatsAppSelfE164({
-				accountId,
-				cfg
-			}) === target) throw new Error("WhatsApp cannot call the linked account itself; use a dedicated OpenClaw WhatsApp number");
-			if (activeCallAccounts.has(accountId)) throw new Error("A WhatsApp call is already active for this account");
-			activeCallAccounts.add(accountId);
-			try {
-				const speech = await api.runtime.tts.textToSpeechTelephony({
-					text: message,
-					cfg
-				});
-				if (!speech.success || !speech.audioBuffer || !speech.sampleRate) throw new Error(speech.error ?? "TTS synthesis failed");
-				const pcm = normalizeTelephonyPcm(speech.audioBuffer, speech.outputFormat);
-				const callWindowMs = resolveCallWindowMs(pcm.length, speech.sampleRate);
-				const tempDir = await fs.mkdtemp(path.join(resolvePreferredOpenClawTmpDir(), "openclaw-whatsapp-call-"));
-				const audioPath = path.join(tempDir, "message.wav");
-				try {
-					await fs.writeFile(audioPath, wrapPcm16MonoInWav(pcm, speech.sampleRate), { mode: 384 });
-					const result = await api.runtime.system.runCommandWithTimeout([
-						MEOWCALLER_COMMAND,
-						"notify",
-						"--store",
-						sessionStorePath,
-						"--answer-timeout",
-						MEOWCALLER_ANSWER_TIMEOUT,
-						"--max-duration",
-						MEOWCALLER_MAX_DURATION,
-						target,
-						audioPath
-					], {
-						cwd: stateDir,
-						env: { MEOW_LOG_LEVEL: "warn" },
-						timeoutMs: callWindowMs,
-						signal,
-						killProcessTree: true,
-						maxOutputBytes: MAX_COMMAND_OUTPUT_BYTES
-					});
-					if (result.termination === "signal") throw new Error("WhatsApp call cancelled");
-					if (result.termination === "timeout") throw new Error("MeowCaller exceeded the bounded WhatsApp call window");
-					if (result.termination !== "exit" || result.code !== 0) throw new Error(`MeowCaller did not complete the call (code ${result.code ?? "unknown"})`);
-					return jsonResult$1({
-						completed: true,
-						recipient: "current WhatsApp requester",
-						callWindowSeconds: Math.ceil(callWindowMs / 1e3),
-						ttsProvider: speech.provider,
-						note: "MeowCaller completed answer, playback, and hangup for the requester-bound call."
-					});
-				} finally {
-					await fs.rm(tempDir, {
-						recursive: true,
-						force: true
-					});
-				}
-			} finally {
-				activeCallAccounts.delete(accountId);
-			}
-		}
-	};
-}
-function createWhatsAppCallTool(api, context) {
-	return createWhatsAppCallToolWithDependencies(api, context, defaultDependencies);
-}
-function registerWhatsAppCallTool(api) {
-	api.registerTool((context) => createWhatsAppCallTool(api, context), { name: "whatsapp_call" });
-}
-//#endregion
-export { registerWhatsAppCallTool };