sealclaw 2026.6.4 → 2026.6.6

package/dist/abort-Jin0SvNO.js

@@ -0,0 +1,202 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-Bje8XVt9.js";
+import { i as formatErrorMessage } from "./errors-D4jx1Axd.js";
+import { o as parseAgentSessionKey } from "./session-key-utils-BiZnc9ns.js";
+import { p as resolveSessionAgentId } from "./agent-scope-DcilFo3V.js";
+import { r as logVerbose } from "./globals-CHNs9cIE.js";
+import { u as resolveStorePath } from "./paths-B9zIGb6o.js";
+import { t as loadSessionStore } from "./store-load-CTQ_Vgus.js";
+import { d as resolveSessionStoreEntry, o as updateSessionStore } from "./store-DE_GYDhp.js";
+import "./sessions-BFkA1pEX.js";
+import { h as replyRunRegistry } from "./run-state-DEHDqFli.js";
+import { n as abortEmbeddedPiRun } from "./runs-C4SBEAfr.js";
+import { n as getAcpSessionManager } from "./manager-BsH5MV-S.js";
+import { c as resolveMainSessionAlias, s as resolveInternalSessionKey } from "./sessions-helpers-B74IGVI6.js";
+import { s as clearSessionQueues } from "./queue-CQgip91V.js";
+import { f as markSubagentRunTerminated, o as getLatestSubagentRunByChildSessionKey, u as listSubagentRunsForController } from "./subagent-registry-D3QFqUi9.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-CoKfBMbu.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-DTiyVtvz.js";
+import { t as resolveCommandAuthorization } from "./command-auth-CNmYqgdk.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-Br7JHgND.js";
+const abortDeps = {
+	getAcpSessionManager,
+	abortEmbeddedPiRun,
+	getLatestSubagentRunByChildSessionKey,
+	listSubagentRunsForController,
+	markSubagentRunTerminated
+};
+function formatAbortReplyText(stoppedSubagents) {
+	if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) return "⚙️ Agent was aborted.";
+	return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${stoppedSubagents === 1 ? "sub-agent" : "sub-agents"}.`;
+}
+function resolveSessionEntryForKey(store, sessionKey) {
+	if (!store || !sessionKey) return {};
+	const resolved = resolveSessionStoreEntry({
+		store,
+		sessionKey
+	});
+	if (resolved.existing) return resolved.legacyKeys.length > 0 ? {
+		entry: resolved.existing,
+		key: resolved.normalizedKey,
+		legacyKeys: resolved.legacyKeys
+	} : {
+		entry: resolved.existing,
+		key: resolved.normalizedKey
+	};
+	return {};
+}
+function normalizeRequesterSessionKey(cfg, key) {
+	const cleaned = normalizeOptionalString(key);
+	if (!cleaned) return;
+	const { mainKey, alias } = resolveMainSessionAlias(cfg);
+	return resolveInternalSessionKey({
+		key: cleaned,
+		alias,
+		mainKey
+	});
+}
+function stopSubagentsForRequester(params) {
+	const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
+	if (!requesterKey) return { stopped: 0 };
+	const dedupedRunsByChildKey = /* @__PURE__ */ new Map();
+	for (const run of abortDeps.listSubagentRunsForController(requesterKey)) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey) continue;
+		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
+		if (!latest) {
+			const existing = dedupedRunsByChildKey.get(childKey);
+			if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+			continue;
+		}
+		const latestControllerSessionKey = normalizeOptionalString(latest?.controllerSessionKey) ?? normalizeOptionalString(latest?.requesterSessionKey);
+		if (latest.runId !== run.runId || latestControllerSessionKey !== requesterKey) continue;
+		const existing = dedupedRunsByChildKey.get(childKey);
+		if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+	}
+	const runs = Array.from(dedupedRunsByChildKey.values());
+	if (runs.length === 0) return { stopped: 0 };
+	const storeCache = /* @__PURE__ */ new Map();
+	const seenChildKeys = /* @__PURE__ */ new Set();
+	let stopped = 0;
+	for (const run of runs) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey || seenChildKeys.has(childKey)) continue;
+		seenChildKeys.add(childKey);
+		if (!run.endedAt) {
+			const cleared = clearSessionQueues([childKey]);
+			const parsed = parseAgentSessionKey(childKey);
+			const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
+			let store = storeCache.get(storePath);
+			if (!store) {
+				store = loadSessionStore(storePath);
+				storeCache.set(storePath, store);
+			}
+			const entry = store[childKey];
+			const sessionId = replyRunRegistry.resolveSessionId(childKey) ?? entry?.sessionId;
+			const aborted = (childKey ? replyRunRegistry.abort(childKey) : false) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
+			if (abortDeps.markSubagentRunTerminated({
+				runId: run.runId,
+				childSessionKey: childKey,
+				reason: "killed"
+			}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) stopped += 1;
+		}
+		const cascadeResult = stopSubagentsForRequester({
+			cfg: params.cfg,
+			requesterSessionKey: childKey
+		});
+		stopped += cascadeResult.stopped;
+	}
+	if (stopped > 0) logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
+	return { stopped };
+}
+async function tryFastAbortFromMessage(params) {
+	const { ctx, cfg } = params;
+	const targetKey = normalizeOptionalString(ctx.CommandTargetSessionKey) ?? normalizeOptionalString(ctx.SessionKey);
+	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
+	if (!isAbortRequestText(normalizeOptionalLowercaseString(ctx.ChatType) === "group" ? stripMentions(raw, ctx, cfg, resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	})) : raw)) return {
+		handled: false,
+		aborted: false
+	};
+	const commandAuthorized = ctx.CommandAuthorized;
+	const auth = resolveCommandAuthorization({
+		ctx,
+		cfg,
+		commandAuthorized
+	});
+	if (!auth.isAuthorizedSender) return {
+		handled: false,
+		aborted: false
+	};
+	const agentId = resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	});
+	const abortKey = targetKey ?? auth.from ?? auth.to;
+	const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
+	if (targetKey) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		const store = loadSessionStore(storePath);
+		const { entry, key, legacyKeys } = resolveSessionEntryForKey(store, targetKey);
+		const resolvedTargetKey = key ?? targetKey;
+		const acpManager = abortDeps.getAcpSessionManager();
+		if (acpManager.resolveSession({
+			cfg,
+			sessionKey: resolvedTargetKey
+		}).kind !== "none") try {
+			await acpManager.cancelSession({
+				cfg,
+				sessionKey: resolvedTargetKey,
+				reason: "fast-abort"
+			});
+		} catch (error) {
+			logVerbose(`abort: ACP cancel failed for ${resolvedTargetKey}: ${formatErrorMessage(error)}`);
+		}
+		const sessionId = replyRunRegistry.resolveSessionId(resolvedTargetKey) ?? entry?.sessionId;
+		const aborted = replyRunRegistry.abort(resolvedTargetKey) || (sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false);
+		const cleared = clearSessionQueues([resolvedTargetKey, sessionId]);
+		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+		const abortCutoff = shouldPersistAbortCutoff({
+			commandSessionKey: ctx.SessionKey,
+			targetSessionKey: resolvedTargetKey
+		}) ? resolveAbortCutoffFromContext(ctx) : void 0;
+		if (entry && key) {
+			entry.abortedLastRun = true;
+			applyAbortCutoffToSessionEntry(entry, abortCutoff);
+			entry.updatedAt = Date.now();
+			store[key] = entry;
+			for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete store[legacyKey];
+			await updateSessionStore(storePath, (nextStore) => {
+				const nextEntry = nextStore[key] ?? entry;
+				if (!nextEntry) return;
+				nextEntry.abortedLastRun = true;
+				applyAbortCutoffToSessionEntry(nextEntry, abortCutoff);
+				nextEntry.updatedAt = Date.now();
+				nextStore[key] = nextEntry;
+				for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete nextStore[legacyKey];
+			});
+		} else if (abortKey) setAbortMemory(abortKey, true);
+		const { stopped } = stopSubagentsForRequester({
+			cfg,
+			requesterSessionKey
+		});
+		return {
+			handled: true,
+			aborted,
+			stoppedSubagents: stopped
+		};
+	}
+	if (abortKey) setAbortMemory(abortKey, true);
+	const { stopped } = stopSubagentsForRequester({
+		cfg,
+		requesterSessionKey
+	});
+	return {
+		handled: true,
+		aborted: false,
+		stoppedSubagents: stopped
+	};
+}
+//#endregion
+export { tryFastAbortFromMessage as i, resolveSessionEntryForKey as n, stopSubagentsForRequester as r, formatAbortReplyText as t };

package/dist/abort.runtime-VXjC8s0w.js

@@ -0,0 +1,2 @@
+import { i as tryFastAbortFromMessage, t as formatAbortReplyText } from "./abort-Jin0SvNO.js";
+export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-DD8nBpq4.js";
+export * from "./abort.runtime-VXjC8s0w.js";

package/dist/access-control-DhtxetPg.js

@@ -0,0 +1,295 @@
+import "./security-runtime-B5OM3Qlq.js";
+import { l as normalizeE164 } from "./utils-Ba75iQOz.js";
+import { n as defaultRuntime } from "./runtime-CxAzaBMy.js";
+import { b as resolveGroupSessionKey } from "./store-DE_GYDhp.js";
+import { n as resolveChannelGroupRequireMention, t as resolveChannelGroupPolicy } from "./group-policy-ZtoZIQLu.js";
+import { d as upsertChannelPairingRequest } from "./pairing-store-C1MHZVQH.js";
+import { a as warnMissingProviderGroupPolicyFallbackOnce, r as resolveDefaultGroupPolicy } from "./runtime-group-policy-Kz5pTCPx.js";
+import "./channel-policy-CdTfGR0V.js";
+import { a as resolveDmGroupAccessWithCommandGate, n as readStoreAllowFromForDmPolicy, o as resolveDmGroupAccessWithLists, s as resolveEffectiveAllowFromLists } from "./dm-policy-shared-DuCFOJo7.js";
+import { t as createChannelPairingChallengeIssuer } from "./channel-pairing-HXkrKiiD.js";
+import "./runtime-env-42oNjzv_.js";
+import "./conversation-runtime-CUgL1AZA.js";
+import { n as expandAllowFromWithAccessGroups } from "./access-groups-iQy8mgSJ.js";
+import "./session-store-runtime-CkVf8CfD.js";
+import { a as resolveWhatsAppAccount } from "./accounts-C0L8yPg8.js";
+import { n as isSelfChatMode } from "./text-runtime-pTqrQceo.js";
+import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-CGsm_-g9.js";
+import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-D_NDKAii.js";
+//#region extensions/whatsapp/src/inbound-policy.ts
+function resolveGroupConversationId(conversationId) {
+	return resolveGroupSessionKey({
+		From: conversationId,
+		ChatType: "group",
+		Provider: "whatsapp"
+	})?.id ?? conversationId;
+}
+function isNormalizedSenderAllowed(allowEntries, sender) {
+	if (allowEntries.includes("*")) return true;
+	const normalizedSender = normalizeE164(sender ?? "");
+	if (!normalizedSender) return false;
+	return new Set(allowEntries.map((entry) => normalizeE164(entry)).filter((entry) => Boolean(entry))).has(normalizedSender);
+}
+function buildResolvedWhatsAppGroupConfig(params) {
+	return { channels: { whatsapp: {
+		groupPolicy: params.groupPolicy,
+		groups: params.groups
+	} } };
+}
+function resolveWhatsAppInboundPolicy(params) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const configuredAllowFrom = account.allowFrom ?? [];
+	const dmPolicy = account.dmPolicy ?? "pairing";
+	const dmAllowFrom = configuredAllowFrom.length > 0 ? configuredAllowFrom : params.selfE164 ? [params.selfE164] : [];
+	const groupAllowFrom = account.groupAllowFrom ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0) ?? [];
+	const { effectiveGroupAllowFrom } = resolveEffectiveAllowFromLists({
+		allowFrom: configuredAllowFrom,
+		groupAllowFrom
+	});
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveWhatsAppRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.whatsapp !== void 0,
+		groupPolicy: account.groupPolicy,
+		defaultGroupPolicy
+	});
+	const resolvedGroupCfg = buildResolvedWhatsAppGroupConfig({
+		groupPolicy,
+		groups: account.groups
+	});
+	const isSamePhone = (value) => typeof value === "string" && typeof params.selfE164 === "string" && value === params.selfE164;
+	return {
+		account,
+		dmPolicy,
+		groupPolicy,
+		configuredAllowFrom,
+		dmAllowFrom,
+		groupAllowFrom,
+		isSelfChat: account.selfChatMode ?? isSelfChatMode(params.selfE164, configuredAllowFrom),
+		providerMissingFallbackApplied,
+		shouldReadStorePairingApprovals: dmPolicy !== "allowlist",
+		isSamePhone,
+		isDmSenderAllowed: (allowEntries, sender) => isSamePhone(sender) || isNormalizedSenderAllowed(allowEntries, sender),
+		isGroupSenderAllowed: (allowEntries, sender) => isNormalizedSenderAllowed(allowEntries, sender),
+		resolveConversationGroupPolicy: (conversationId) => resolveChannelGroupPolicy({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveGroupConversationId(conversationId),
+			hasGroupAllowFrom: effectiveGroupAllowFrom.length > 0
+		}),
+		resolveConversationRequireMention: (conversationId) => resolveChannelGroupRequireMention({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveGroupConversationId(conversationId)
+		})
+	};
+}
+async function resolveWhatsAppCommandAuthorized(params) {
+	const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
+	if (!useAccessGroups) return true;
+	const self = getSelfIdentity(params.msg);
+	const policy = params.policy ?? resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: params.msg.accountId,
+		selfE164: self.e164 ?? null
+	});
+	const isGroup = params.msg.chatType === "group";
+	const sender = getSenderIdentity(params.msg);
+	const dmSender = sender.e164 ?? params.msg.from ?? "";
+	const groupSender = sender.e164 ?? "";
+	const normalizedSender = normalizeE164(isGroup ? groupSender : dmSender);
+	if (!normalizedSender) return false;
+	const storeAllowFrom = isGroup || !policy.shouldReadStorePairingApprovals ? [] : await readStoreAllowFromForDmPolicy({
+		provider: "whatsapp",
+		accountId: policy.account.accountId,
+		dmPolicy: policy.dmPolicy,
+		shouldRead: policy.shouldReadStorePairingApprovals
+	});
+	const isSenderAllowed = (senderId, allowEntries) => isGroup ? policy.isGroupSenderAllowed(allowEntries, senderId) : policy.isDmSenderAllowed(allowEntries, senderId);
+	const [allowFrom, groupAllowFrom] = await Promise.all([expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: policy.dmAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: normalizedSender,
+		isSenderAllowed
+	}), expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: policy.groupAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: normalizedSender,
+		isSenderAllowed
+	})]);
+	const dmStoreAllowFrom = isGroup ? [] : await expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: storeAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: normalizedSender,
+		isSenderAllowed
+	});
+	return resolveDmGroupAccessWithCommandGate({
+		isGroup,
+		dmPolicy: policy.dmPolicy,
+		groupPolicy: policy.groupPolicy,
+		allowFrom,
+		groupAllowFrom,
+		storeAllowFrom: dmStoreAllowFrom,
+		isSenderAllowed: (allowEntries) => isGroup ? policy.isGroupSenderAllowed(allowEntries, groupSender) : policy.isDmSenderAllowed(allowEntries, dmSender),
+		command: {
+			useAccessGroups,
+			allowTextCommands: true,
+			hasControlCommand: true
+		}
+	}).commandAuthorized;
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/access-control.ts
+const PAIRING_REPLY_HISTORY_GRACE_MS = 3e4;
+function logWhatsAppVerbose(enabled, message) {
+	if (!enabled) return;
+	defaultRuntime.log(message);
+}
+async function checkInboundAccessControl(params) {
+	const policy = resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		selfE164: params.selfE164
+	});
+	const storeAllowFrom = params.group ? [] : await readStoreAllowFromForDmPolicy({
+		provider: "whatsapp",
+		accountId: policy.account.accountId,
+		dmPolicy: policy.dmPolicy,
+		shouldRead: policy.shouldReadStorePairingApprovals
+	});
+	const pairingGraceMs = typeof params.pairingGraceMs === "number" && params.pairingGraceMs > 0 ? params.pairingGraceMs : PAIRING_REPLY_HISTORY_GRACE_MS;
+	const suppressPairingReply = typeof params.connectedAtMs === "number" && typeof params.messageTimestampMs === "number" && params.messageTimestampMs < params.connectedAtMs - pairingGraceMs;
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied: policy.providerMissingFallbackApplied,
+		providerKey: "whatsapp",
+		accountId: policy.account.accountId,
+		log: (message) => logWhatsAppVerbose(params.verbose, message)
+	});
+	const accessGroupSenderId = params.group ? params.senderE164 ?? params.from : params.from;
+	const isAccessGroupSenderAllowed = (senderId, allowEntries) => {
+		return params.group ? policy.isGroupSenderAllowed(allowEntries, senderId) : policy.isDmSenderAllowed(allowEntries, senderId);
+	};
+	const [allowFrom, groupAllowFrom] = await Promise.all([expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: params.group ? policy.configuredAllowFrom : policy.dmAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: accessGroupSenderId,
+		isSenderAllowed: isAccessGroupSenderAllowed
+	}), expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: policy.groupAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: accessGroupSenderId,
+		isSenderAllowed: isAccessGroupSenderAllowed
+	})]);
+	const dmStoreAllowFrom = params.group ? [] : await expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: storeAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: accessGroupSenderId,
+		isSenderAllowed: isAccessGroupSenderAllowed
+	});
+	const access = resolveDmGroupAccessWithLists({
+		isGroup: params.group,
+		dmPolicy: policy.dmPolicy,
+		groupPolicy: policy.groupPolicy,
+		allowFrom,
+		groupAllowFrom,
+		storeAllowFrom: dmStoreAllowFrom,
+		isSenderAllowed: (allowEntries) => {
+			return params.group ? policy.isGroupSenderAllowed(allowEntries, params.senderE164) : policy.isDmSenderAllowed(allowEntries, params.from);
+		}
+	});
+	if (params.group && access.decision !== "allow") {
+		if (access.reason === "groupPolicy=disabled") logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: disabled)");
+		else if (access.reason === "groupPolicy=allowlist (empty allowlist)") logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: allowlist, no groupAllowFrom)");
+		else logWhatsAppVerbose(params.verbose, `Blocked group message from ${params.senderE164 ?? "unknown sender"} (groupPolicy: allowlist)`);
+		return {
+			allowed: false,
+			shouldMarkRead: false,
+			isSelfChat: policy.isSelfChat,
+			resolvedAccountId: policy.account.accountId
+		};
+	}
+	if (!params.group) {
+		if (params.isFromMe && !policy.isSamePhone(params.from)) {
+			logWhatsAppVerbose(params.verbose, "Skipping outbound DM (fromMe); no pairing reply needed.");
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+		if (access.decision === "block" && access.reason === "dmPolicy=disabled") {
+			logWhatsAppVerbose(params.verbose, "Blocked dm (dmPolicy: disabled)");
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+		if (access.decision === "pairing" && !policy.isSamePhone(params.from)) {
+			const candidate = params.from;
+			if (suppressPairingReply) logWhatsAppVerbose(params.verbose, `Skipping pairing reply for historical DM from ${candidate}.`);
+			else await createChannelPairingChallengeIssuer({
+				channel: "whatsapp",
+				upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+					channel: "whatsapp",
+					id,
+					accountId: policy.account.accountId,
+					meta
+				})
+			})({
+				senderId: candidate,
+				senderIdLine: `Your WhatsApp phone number: ${candidate}`,
+				meta: { name: (params.pushName ?? "").trim() || void 0 },
+				onCreated: () => {
+					logWhatsAppVerbose(params.verbose, `whatsapp pairing request sender=${candidate} name=${params.pushName ?? "unknown"}`);
+				},
+				sendPairingReply: async (text) => {
+					await params.sock.sendMessage(params.remoteJid, { text });
+				},
+				onReplyError: (err) => {
+					logWhatsAppVerbose(params.verbose, `whatsapp pairing reply failed for ${candidate}: ${String(err)}`);
+				}
+			});
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+		if (access.decision !== "allow") {
+			logWhatsAppVerbose(params.verbose, `Blocked unauthorized sender ${params.from} (dmPolicy=${policy.dmPolicy})`);
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+	}
+	return {
+		allowed: true,
+		shouldMarkRead: true,
+		isSelfChat: policy.isSelfChat,
+		resolvedAccountId: policy.account.accountId
+	};
+}
+const __testing = { resolveWhatsAppInboundPolicy };
+//#endregion
+export { resolveWhatsAppInboundPolicy as i, checkInboundAccessControl as n, resolveWhatsAppCommandAuthorized as r, __testing as t };

package/dist/account-inspect-XAOXTS6T.js

@@ -0,0 +1,161 @@
+import { c as normalizeOptionalString } from "./string-coerce-Bje8XVt9.js";
+import { a as coerceSecretRef, o as hasConfiguredSecretInput, u as normalizeSecretInputString } from "./types.secrets-CwOir82x.js";
+import { n as normalizeAccountId } from "./account-id-BcgJyVVC.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Bmx2xaIk.js";
+import { l as resolveDefaultSecretProviderAlias } from "./ref-contract-RR2KmPqX.js";
+import "./provider-auth-BZfSwa_G.js";
+import "./text-runtime-uNxLsJwI.js";
+import { t as resolveAccountWithDefaultFallback } from "./account-core-CHY1HiEh.js";
+import "./channel-core-D-llABwP.js";
+import "./routing-BsfCV6b8.js";
+import "./secret-input-DovViMFZ.js";
+import "./secret-input-runtime-CQrQxkKQ.js";
+import { n as resolveTelegramAccountConfig, t as mergeTelegramAccountConfig } from "./account-config-Bdg4uT_8.js";
+import { a as resolveDefaultTelegramAccountId } from "./accounts-CrFL3L9r.js";
+//#region extensions/telegram/src/account-inspect.ts
+function inspectTokenFile(pathValue) {
+	const tokenFile = normalizeOptionalString(pathValue) ?? "";
+	if (!tokenFile) return null;
+	const token = tryReadSecretFileSync(tokenFile, "Telegram bot token", { rejectSymlink: true });
+	return {
+		token: token ?? "",
+		tokenSource: "tokenFile",
+		tokenStatus: token ? "available" : "configured_unavailable"
+	};
+}
+function canResolveEnvSecretRefInReadOnlyPath(params) {
+	const providerConfig = params.cfg.secrets?.providers?.[params.provider];
+	if (!providerConfig) return params.provider === resolveDefaultSecretProviderAlias(params.cfg, "env");
+	if (providerConfig.source !== "env") return false;
+	const allowlist = providerConfig.allowlist;
+	return !allowlist || allowlist.includes(params.id);
+}
+function inspectTokenValue(params) {
+	const ref = coerceSecretRef(params.value, params.cfg.secrets?.defaults);
+	if (ref?.source === "env") {
+		if (!canResolveEnvSecretRefInReadOnlyPath({
+			cfg: params.cfg,
+			provider: ref.provider,
+			id: ref.id
+		})) return {
+			token: "",
+			tokenSource: "env",
+			tokenStatus: "configured_unavailable"
+		};
+		const envValue = normalizeOptionalString(process.env[ref.id]);
+		if (envValue) return {
+			token: envValue,
+			tokenSource: "env",
+			tokenStatus: "available"
+		};
+		return {
+			token: "",
+			tokenSource: "env",
+			tokenStatus: "configured_unavailable"
+		};
+	}
+	const token = normalizeSecretInputString(params.value);
+	if (token) return {
+		token,
+		tokenSource: "config",
+		tokenStatus: "available"
+	};
+	if (hasConfiguredSecretInput(params.value, params.cfg.secrets?.defaults)) return {
+		token: "",
+		tokenSource: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	return null;
+}
+function inspectTelegramAccountPrimary(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const merged = mergeTelegramAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.telegram?.enabled !== false && merged.enabled !== false;
+	const accountConfig = resolveTelegramAccountConfig(params.cfg, accountId);
+	const accountTokenFile = inspectTokenFile(accountConfig?.tokenFile);
+	if (accountTokenFile) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: accountTokenFile.token,
+		tokenSource: accountTokenFile.tokenSource,
+		tokenStatus: accountTokenFile.tokenStatus,
+		configured: accountTokenFile.tokenStatus !== "missing",
+		config: merged
+	};
+	const accountToken = inspectTokenValue({
+		cfg: params.cfg,
+		value: accountConfig?.botToken
+	});
+	if (accountToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: accountToken.token,
+		tokenSource: accountToken.tokenSource,
+		tokenStatus: accountToken.tokenStatus,
+		configured: accountToken.tokenStatus !== "missing",
+		config: merged
+	};
+	const channelTokenFile = inspectTokenFile(params.cfg.channels?.telegram?.tokenFile);
+	if (channelTokenFile) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: channelTokenFile.token,
+		tokenSource: channelTokenFile.tokenSource,
+		tokenStatus: channelTokenFile.tokenStatus,
+		configured: channelTokenFile.tokenStatus !== "missing",
+		config: merged
+	};
+	const channelToken = inspectTokenValue({
+		cfg: params.cfg,
+		value: params.cfg.channels?.telegram?.botToken
+	});
+	if (channelToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: channelToken.token,
+		tokenSource: channelToken.tokenSource,
+		tokenStatus: channelToken.tokenStatus,
+		configured: channelToken.tokenStatus !== "missing",
+		config: merged
+	};
+	const envToken = accountId === "default" ? normalizeOptionalString(params.envToken) ?? normalizeOptionalString(process.env.TELEGRAM_BOT_TOKEN) ?? "" : "";
+	if (envToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: envToken,
+		tokenSource: "env",
+		tokenStatus: "available",
+		configured: true,
+		config: merged
+	};
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+}
+function inspectTelegramAccount(params) {
+	return resolveAccountWithDefaultFallback({
+		accountId: params.accountId,
+		normalizeAccountId,
+		resolvePrimary: (accountId) => inspectTelegramAccountPrimary({
+			cfg: params.cfg,
+			accountId,
+			envToken: params.envToken
+		}),
+		hasCredential: (account) => account.tokenSource !== "none",
+		resolveDefaultAccountId: () => resolveDefaultTelegramAccountId(params.cfg)
+	});
+}
+//#endregion
+export { inspectTelegramAccount as t };