@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.34

package/dist/approval-reactions-Cu66aYdq.js

@@ -1,373 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
-import { n as getOptionalWhatsAppRuntime } from "./runtime-BLlToOi6.js";
-import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth } from "./group-session-key-DVMZlO3x.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { createApprovalReactionTargetStore, listApprovalReactionBindings, resolveTypedApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
-//#region extensions/whatsapp/src/approval-reactions.ts
-var approval_reactions_exports = /* @__PURE__ */ __exportAll({
-	clearWhatsAppApprovalReactionTargetsForTest: () => clearWhatsAppApprovalReactionTargetsForTest,
-	maybeResolveWhatsAppApprovalReaction: () => maybeResolveWhatsAppApprovalReaction,
-	prepareWhatsAppApprovalPayloadForDelivery: () => prepareWhatsAppApprovalPayloadForDelivery,
-	registerWhatsAppApprovalReactionTarget: () => registerWhatsAppApprovalReactionTarget,
-	registerWhatsAppApprovalReactionTargetForDeliveredPayload: () => registerWhatsAppApprovalReactionTargetForDeliveredPayload,
-	resolveWhatsAppApprovalReactionTargetWithPersistence: () => resolveWhatsAppApprovalReactionTargetWithPersistence,
-	unregisterWhatsAppApprovalReactionTarget: () => unregisterWhatsAppApprovalReactionTarget
-});
-const PERSISTENT_NAMESPACE = "whatsapp.approval-reactions";
-const PERSISTENT_MAX_ENTRIES = 1e3;
-const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
-const DELIVERY_BINDING_CHANNEL_DATA_KEY = "whatsappApprovalReactionBindingV1";
-const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-DoeBBt22.js"));
-const whatsappApprovalReactionTargets = createApprovalReactionTargetStore({
-	namespace: PERSISTENT_NAMESPACE,
-	maxEntries: PERSISTENT_MAX_ENTRIES,
-	defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS,
-	openStore: (storeParams) => getOptionalWhatsAppRuntime()?.state.openKeyedStore(storeParams),
-	logPersistentError: reportPersistentApprovalReactionError,
-	readPersistedTarget
-});
-const loadApprovalResolver = resolverRuntimeLoader;
-function buildReactionTargetKey(params) {
-	const accountId = params.accountId.trim();
-	const remoteJid = params.remoteJid.trim();
-	const messageId = params.messageId.trim();
-	if (!accountId || !remoteJid || !messageId) return null;
-	return `${accountId}:${remoteJid}:${messageId}`;
-}
-function addCandidateRemoteJid(target, value) {
-	const remoteJid = value?.trim();
-	if (remoteJid && !target.includes(remoteJid)) target.push(remoteJid);
-}
-function reportPersistentApprovalReactionError(error) {
-	try {
-		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
-			plugin: "whatsapp",
-			feature: "approval-reaction-state"
-		}).warn("WhatsApp persistent approval reaction state failed", { error: String(error) });
-	} catch {}
-}
-function reportApprovalBindingCorrelationMismatch(binding) {
-	try {
-		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
-			plugin: "whatsapp",
-			feature: "approval-reaction-state"
-		}).warn("WhatsApp approval prompt text failed binding correlation; reactions disabled", {
-			approvalId: binding.approvalId,
-			approvalKind: binding.approvalKind
-		});
-	} catch {}
-}
-function readPersistedTarget(target) {
-	const value = target;
-	if (!value || typeof value.approvalId !== "string" || !Array.isArray(value.allowedDecisions) || value.approvalKind !== "exec" && value.approvalKind !== "plugin") return null;
-	return {
-		approvalId: value.approvalId,
-		approvalKind: value.approvalKind,
-		allowedDecisions: value.allowedDecisions
-	};
-}
-function listWhatsAppApprovalReactionBindings(allowedDecisions) {
-	return listApprovalReactionBindings({ allowedDecisions });
-}
-const APPROVAL_ID_LINE_RE = /^\s*ID:\s*(\S(?:.*\S)?)\s*$/i;
-const APPROVAL_KIND_LINE_RE = /^\s*(?:\S+\s+)?(Exec|Plugin) approval required\s*$/i;
-function isApprovalDecision(value) {
-	return value === "allow-once" || value === "allow-always" || value === "deny";
-}
-function readStrictDecisionList(value) {
-	if (!Array.isArray(value) || value.length === 0 || !value.every(isApprovalDecision)) return null;
-	return new Set(value).size === value.length ? [...value] : null;
-}
-function readStrictApprovalMetadata(payload) {
-	const value = payload.channelData?.execApproval;
-	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
-	const record = value;
-	const approvalId = record.approvalId;
-	const approvalKind = record.approvalKind;
-	const allowedDecisions = readStrictDecisionList(record.allowedDecisions);
-	if (typeof approvalId !== "string" || !approvalId || approvalId !== approvalId.trim() || approvalKind !== "exec" && approvalKind !== "plugin" || !allowedDecisions) return null;
-	return {
-		version: 1,
-		approvalId,
-		approvalKind,
-		allowedDecisions
-	};
-}
-function listTypedApprovalActions(presentation) {
-	return presentation.blocks.flatMap((block) => {
-		if (block.type === "buttons") return block.buttons.flatMap((button) => button.action?.type === "approval" ? [button.action] : []);
-		return [];
-	});
-}
-function decisionSetsMatch(left, right) {
-	return left.length === right.length && left.every((decision) => right.includes(decision));
-}
-function readTypedApprovalDeliveryBinding(params) {
-	const metadata = readStrictApprovalMetadata(params.payload);
-	if (!metadata) return null;
-	const actions = listTypedApprovalActions(params.presentation);
-	if (actions.length === 0 || actions.some((action) => action.approvalId !== metadata.approvalId || action.approvalKind !== metadata.approvalKind)) return null;
-	const actionDecisions = actions.map((action) => action.decision);
-	if (new Set(actionDecisions).size !== actionDecisions.length || !decisionSetsMatch(metadata.allowedDecisions, actionDecisions)) return null;
-	return metadata;
-}
-function visibleApprovalBindingMatches(text, binding) {
-	const lines = (text ?? "").split(/\r?\n/).map((line) => line.replace(/\*\*/g, ""));
-	const kindMatches = lines.map((line) => line.match(APPROVAL_KIND_LINE_RE)).filter((match) => Boolean(match));
-	const idMatches = lines.map((line) => line.match(APPROVAL_ID_LINE_RE)).filter((match) => Boolean(match));
-	const visibleKind = kindMatches[0]?.[1]?.toLowerCase();
-	if (kindMatches.length !== 1 || idMatches.length !== 1 || visibleKind !== binding.approvalKind || idMatches[0]?.[1] !== binding.approvalId) return false;
-	const hintIndices = lines.flatMap((line, index) => line.trim().toLowerCase() === "react with:" ? [index] : []);
-	if (hintIndices.length !== 1) return false;
-	const hintIndex = hintIndices[0];
-	if (hintIndex === void 0) return false;
-	let cursor = hintIndex + 1;
-	while (cursor < lines.length && !lines[cursor]?.trim()) cursor += 1;
-	const decisionLines = [];
-	while (cursor < lines.length) {
-		const decisionLine = lines[cursor]?.trim();
-		if (!decisionLine) break;
-		decisionLines.push(decisionLine);
-		cursor += 1;
-	}
-	const knownBindings = listWhatsAppApprovalReactionBindings([
-		"allow-once",
-		"allow-always",
-		"deny"
-	]);
-	const visibleDecisions = decisionLines.map((line) => knownBindings.find((entry) => `${entry.emoji} ${entry.label}` === line)?.decision);
-	if (!visibleDecisions.every(isApprovalDecision)) return false;
-	return new Set(visibleDecisions).size === visibleDecisions.length && decisionSetsMatch(binding.allowedDecisions, visibleDecisions);
-}
-function readDeliveredApprovalBinding(payload) {
-	const metadata = readStrictApprovalMetadata(payload);
-	const value = payload.channelData?.[DELIVERY_BINDING_CHANNEL_DATA_KEY];
-	if (!metadata || !value || typeof value !== "object" || Array.isArray(value)) return null;
-	const record = value;
-	const allowedDecisions = readStrictDecisionList(record.allowedDecisions);
-	if (record.version !== 1 || record.approvalId !== metadata.approvalId || record.approvalKind !== metadata.approvalKind || !allowedDecisions || !decisionSetsMatch(metadata.allowedDecisions, allowedDecisions)) return null;
-	return metadata;
-}
-/** Preserve a validated typed approval binding until the platform message id is known. */
-function prepareWhatsAppApprovalPayloadForDelivery(params) {
-	const binding = readTypedApprovalDeliveryBinding(params);
-	if (!binding) return null;
-	if (!visibleApprovalBindingMatches(params.payload.text, binding)) {
-		reportApprovalBindingCorrelationMismatch(binding);
-		return null;
-	}
-	return {
-		...params.payload,
-		channelData: {
-			...params.payload.channelData,
-			[DELIVERY_BINDING_CHANNEL_DATA_KEY]: binding
-		}
-	};
-}
-function registerWhatsAppApprovalReactionTarget(params) {
-	const key = buildReactionTargetKey(params);
-	const approvalId = params.approvalId.trim();
-	const allowedDecisions = listWhatsAppApprovalReactionBindings(params.allowedDecisions).map((binding) => binding.decision);
-	if (!key || !approvalId || params.approvalKind !== "exec" && params.approvalKind !== "plugin" || allowedDecisions.length === 0) return null;
-	const target = {
-		approvalId,
-		approvalKind: params.approvalKind,
-		allowedDecisions
-	};
-	whatsappApprovalReactionTargets.register(key, target, { ttlMs: params.ttlMs });
-	return target;
-}
-function listWhatsAppDeliveredMessageIdentities(results) {
-	const identities = [];
-	const seen = /* @__PURE__ */ new Set();
-	const add = (params) => {
-		if (params.channel && params.channel !== "whatsapp") return;
-		const messageId = params.messageId?.trim() ?? "";
-		const remoteJid = params.toJid?.trim() ?? "";
-		const key = `${remoteJid}:${messageId}`;
-		if (!messageId || messageId === "unknown" || !remoteJid || seen.has(key)) return;
-		seen.add(key);
-		identities.push({
-			messageId,
-			remoteJid
-		});
-	};
-	for (const result of results) {
-		if (result.channel !== "whatsapp") continue;
-		add(result);
-		for (const raw of result.receipt?.raw ?? []) add(raw);
-		for (const part of result.receipt?.parts ?? []) add({
-			channel: part.raw?.channel,
-			messageId: part.raw?.messageId ?? part.platformMessageId,
-			toJid: part.raw?.toJid
-		});
-	}
-	return identities;
-}
-/** Bind generic forwarded approvals to the exact WhatsApp messages accepted by Baileys. */
-function registerWhatsAppApprovalReactionTargetForDeliveredPayload(params) {
-	if (params.target.channel.trim().toLowerCase() !== "whatsapp") return false;
-	const binding = readDeliveredApprovalBinding(params.payload);
-	if (!binding) return false;
-	if (!visibleApprovalBindingMatches(params.payload.text, binding)) {
-		reportApprovalBindingCorrelationMismatch(binding);
-		return false;
-	}
-	const accountId = resolveWhatsAppAccount({
-		cfg: params.cfg,
-		accountId: params.target.accountId
-	}).accountId;
-	let registered = false;
-	for (const { messageId, remoteJid } of listWhatsAppDeliveredMessageIdentities(params.results)) registered = Boolean(registerWhatsAppApprovalReactionTarget({
-		accountId,
-		remoteJid,
-		messageId,
-		approvalId: binding.approvalId,
-		approvalKind: binding.approvalKind,
-		allowedDecisions: binding.allowedDecisions,
-		ttlMs: params.ttlMs
-	})) || registered;
-	return registered;
-}
-function unregisterWhatsAppApprovalReactionTarget(params) {
-	const key = buildReactionTargetKey(params);
-	if (!key) return;
-	whatsappApprovalReactionTargets.delete(key);
-}
-function resolveTarget(params) {
-	const resolved = resolveTypedApprovalReactionTarget({
-		target: params.target,
-		reactionKey: params.reactionKey
-	});
-	return resolved ? {
-		approvalId: resolved.approvalId,
-		approvalKind: resolved.approvalKind,
-		decision: resolved.decision
-	} : null;
-}
-async function resolveWhatsAppApprovalReactionTargetWithPersistence(params) {
-	const key = buildReactionTargetKey(params);
-	if (!key) return null;
-	return resolveTarget({
-		target: await whatsappApprovalReactionTargets.lookup(key),
-		reactionKey: params.reactionKey
-	});
-}
-async function resolveWhatsAppApprovalReactionTargetFromCandidates(params) {
-	const candidateRemoteJids = [];
-	for (const observedRemoteJid of params.observedRemoteJids) {
-		addCandidateRemoteJid(candidateRemoteJids, observedRemoteJid);
-		try {
-			for (const candidate of await params.resolveReactionTargetJids?.(observedRemoteJid) ?? []) addCandidateRemoteJid(candidateRemoteJids, candidate);
-		} catch (error) {
-			params.logVerboseMessage?.(`whatsapp: approval reaction target JID mapping failed for ${observedRemoteJid}: ${String(error)}`);
-		}
-	}
-	for (const remoteJid of candidateRemoteJids) {
-		const target = await resolveWhatsAppApprovalReactionTargetWithPersistence({
-			accountId: params.accountId,
-			remoteJid,
-			messageId: params.messageId,
-			reactionKey: params.reactionKey
-		});
-		if (target) return {
-			...target,
-			remoteJid
-		};
-	}
-	return null;
-}
-function readWhatsAppApprovalReactionEvent(params) {
-	const msg = params.msg;
-	const reaction = msg.message?.reactionMessage;
-	const reactionKey = reaction?.text?.trim() ?? "";
-	const messageId = reaction?.key?.id?.trim() ?? "";
-	const remoteJids = [];
-	addCandidateRemoteJid(remoteJids, reaction?.key?.remoteJid);
-	addCandidateRemoteJid(remoteJids, msg.key?.remoteJid);
-	const actorJid = msg.key?.participant?.trim() || (msg.key?.fromMe ? params.selfLid?.trim() ?? params.selfJid?.trim() ?? "" : msg.key?.remoteJid?.trim() ?? "");
-	if (!reactionKey || !messageId || remoteJids.length === 0 || !actorJid) return null;
-	return {
-		remoteJids,
-		messageId,
-		actorJid,
-		reactionKey
-	};
-}
-async function maybeResolveWhatsAppApprovalReaction(params) {
-	const event = readWhatsAppApprovalReactionEvent({
-		msg: params.msg,
-		selfJid: params.selfJid,
-		selfLid: params.selfLid
-	});
-	if (!event) return false;
-	const target = await resolveWhatsAppApprovalReactionTargetFromCandidates({
-		accountId: params.accountId,
-		observedRemoteJids: event.remoteJids,
-		messageId: event.messageId,
-		reactionKey: event.reactionKey,
-		resolveReactionTargetJids: params.resolveReactionTargetJids,
-		logVerboseMessage: params.logVerboseMessage
-	});
-	if (!target) return false;
-	const actorId = await params.resolveInboundJid(event.actorJid);
-	if (!actorId) {
-		params.logVerboseMessage?.(`whatsapp: approval reaction ignored for ${target.approvalId}; missing actor identity`);
-		return true;
-	}
-	if (getWhatsAppApprovalApprovers({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).length === 0) {
-		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId}; reactions require explicit approvers`);
-		return true;
-	}
-	if (!whatsappApprovalAuth.authorizeActorAction({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		senderId: actorId,
-		action: "approve",
-		approvalKind: target.approvalKind
-	}).authorized) {
-		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId} sender=${actorId}`);
-		return true;
-	}
-	const { isApprovalNotFoundError, resolveWhatsAppApproval } = await loadApprovalResolver();
-	try {
-		const result = await resolveWhatsAppApproval({
-			cfg: params.cfg,
-			approvalId: target.approvalId,
-			approvalKind: target.approvalKind,
-			decision: target.decision,
-			senderId: actorId,
-			gatewayUrl: params.gatewayUrl
-		});
-		unregisterWhatsAppApprovalReactionTarget({
-			accountId: params.accountId,
-			remoteJid: target.remoteJid,
-			messageId: event.messageId
-		});
-		const canonicalDecision = "decision" in result.approval ? ` decision=${result.approval.decision}` : "";
-		params.logVerboseMessage?.(result.applied ? `whatsapp: approval reaction applied id=${target.approvalId} sender=${actorId} status=${result.approval.status}${canonicalDecision}` : `whatsapp: approval reaction already resolved id=${target.approvalId} sender=${actorId} status=${result.approval.status}${canonicalDecision}`);
-		return true;
-	} catch (error) {
-		if (isApprovalNotFoundError(error)) {
-			unregisterWhatsAppApprovalReactionTarget({
-				accountId: params.accountId,
-				remoteJid: target.remoteJid,
-				messageId: event.messageId
-			});
-			params.logVerboseMessage?.(`whatsapp: approval reaction ignored for expired approval id=${target.approvalId} sender=${actorId}`);
-			return true;
-		}
-		params.logVerboseMessage?.(`whatsapp: approval reaction failed id=${target.approvalId} sender=${actorId}: ${String(error)}`);
-		return true;
-	}
-}
-function clearWhatsAppApprovalReactionTargetsForTest() {
-	whatsappApprovalReactionTargets.clearForTest();
-	resolverRuntimeLoader.clear();
-}
-//#endregion
-export { unregisterWhatsAppApprovalReactionTarget as i, maybeResolveWhatsAppApprovalReaction as n, registerWhatsAppApprovalReactionTarget as r, approval_reactions_exports as t };

package/dist/channel.setup-pMwNVkCA.js

@@ -1,19 +0,0 @@
-import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupContract, l as readWhatsAppAccountLinkState, n as whatsappSetupWizardProxy, o as resolveWhatsAppGroupToolPolicy, r as whatsappSetupAdapter, t as createWhatsAppPluginBase } from "./shared-CAxd15bp.js";
-import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-CAMTrs2U.js";
-//#region extensions/whatsapp/src/channel.setup.ts
-const whatsappSetupPlugin = {
-	...createWhatsAppPluginBase({
-		groups: {
-			resolveRequireMention: resolveWhatsAppGroupRequireMention,
-			resolveToolPolicy: resolveWhatsAppGroupToolPolicy
-		},
-		setupWizard: whatsappSetupWizardProxy,
-		setup: whatsappSetupAdapter,
-		setupContract: whatsappSetupContract,
-		isConfigured: (account) => Boolean(account.authDir),
-		isLinked: async (account) => await readWhatsAppAccountLinkState(account.authDir)
-	}),
-	lifecycle: { detectLegacyStateMigrations: ({ oauthDir }) => detectWhatsAppLegacyStateMigrations({ oauthDir }) }
-};
-//#endregion
-export { whatsappSetupPlugin as t };

package/dist/config-schema-BQP5YCeK.js

@@ -1,50 +0,0 @@
-import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-import { buildChannelConfigSchema } from "openclaw/plugin-sdk/channel-config-schema";
-import { WhatsAppConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
-//#endregion
-//#region extensions/whatsapp/src/config-schema.ts
-const WhatsAppChannelConfigSchema = buildChannelConfigSchema(WhatsAppConfigSchema, { uiHints: {
-	"": {
-		label: "WhatsApp",
-		help: "WhatsApp channel provider configuration for access policy and direct-message routing safety."
-	},
-	...createChannelConfigUiHints({
-		channelLabel: "WhatsApp",
-		dmPolicy: { channelKey: "whatsapp" }
-	}),
-	allowFrom: { presentation: "phone-number" },
-	defaultTo: { presentation: "phone-number" },
-	groupAllowFrom: { presentation: "phone-number" },
-	"accounts.*.allowFrom.*": { presentation: "phone-number" },
-	"accounts.*.defaultTo": { presentation: "phone-number" },
-	"accounts.*.groupAllowFrom.*": { presentation: "phone-number" },
-	selfChatMode: {
-		label: "WhatsApp Self-Phone Mode",
-		help: "Same-phone setup (bot uses your personal WhatsApp number)."
-	},
-	direct: {
-		label: "WhatsApp Direct Chat Overrides",
-		help: "Per-conversation overrides keyed by WhatsApp DM id. Applied after a DM is already admitted by dmPolicy; \"*\" supplies a default without admitting anyone."
-	},
-	pluginHooks: {
-		label: "WhatsApp Plugin Hooks",
-		help: "Opt in to broadcasting inbound WhatsApp events to plugins. Payloads carry personal content, so only enable it for plugins you trust."
-	},
-	...createChannelConfigUiHints({
-		channelLabel: "WhatsApp",
-		configWrites: true
-	}),
-	"actions.calls": {
-		label: "WhatsApp Voice Calls",
-		help: "Expose the experimental requester-bound WhatsApp voice-call tool. Default: false. Requires a separately paired MeowCaller CLI."
-	},
-	...createChannelConfigUiHints({
-		channelLabel: "WhatsApp",
-		mentionPatterns: {
-			targetDescription: "WhatsApp conversation IDs",
-			policyTargetDescription: "WhatsApp conversation IDs such as 123@g.us"
-		}
-	})
-} });
-//#endregion
-export { WhatsAppChannelConfigSchema as t };

package/dist/connection-controller-runtime-context-DG0tuYuw.js

@@ -1,23 +0,0 @@
-import { t as getOptionalWhatsAppChannelRuntime } from "./runtime-BLlToOi6.js";
-import { getChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
-//#region extensions/whatsapp/src/connection-controller-runtime-context.ts
-const WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY = "connection-controller";
-const WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY = "connection-owner-pending";
-function getWhatsAppConnectionController(accountId) {
-	return getChannelRuntimeContext({
-		channelRuntime: getOptionalWhatsAppChannelRuntime() ?? void 0,
-		channelId: "whatsapp",
-		accountId,
-		capability: "connection-controller"
-	}) ?? null;
-}
-function hasPendingWhatsAppConnectionOwner(accountId) {
-	return Boolean(getChannelRuntimeContext({
-		channelRuntime: getOptionalWhatsAppChannelRuntime() ?? void 0,
-		channelId: "whatsapp",
-		accountId,
-		capability: WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY
-	}));
-}
-//#endregion
-export { hasPendingWhatsAppConnectionOwner as i, WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY as n, getWhatsAppConnectionController as r, WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY as t };

package/dist/directory-config-DalGrfGN.js

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

package/dist/doctor-CwzVXKoE.js

@@ -1,10 +0,0 @@
-//#region extensions/whatsapp/src/doctor.ts
-function normalizeCompatibilityConfig({ cfg }) {
-	return {
-		config: cfg,
-		changes: []
-	};
-}
-const whatsappDoctor = { normalizeCompatibilityConfig };
-//#endregion
-export { whatsappDoctor as n, normalizeCompatibilityConfig as t };

package/dist/normalize-C7Hkc_vE.js

@@ -1,2 +0,0 @@
-import "./normalize-target-CugRyONv.js";
-export {};