@openclaw/slack 2026.5.27-beta.1 → 2026.5.28-beta.1

package/dist/thread-ts-NSVqWybn.js

@@ -0,0 +1,646 @@
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-f6Xcv9Vi.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeMessageChannel } from "openclaw/plugin-sdk/routing";
+import { doesApprovalRequestMatchChannelAccount, resolveApprovalRequestSessionConversation } from "openclaw/plugin-sdk/approval-native-runtime";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { createChannelExecApprovalProfile, isChannelExecApprovalClientEnabledFromConfig, isChannelExecApprovalTargetRecipient, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { reduceInteractiveReply } from "openclaw/plugin-sdk/interactive-runtime";
+import { compileAllowlist, resolveCompiledAllowlistMatch } from "openclaw/plugin-sdk/allow-from";
+import { normalizeHyphenSlug, normalizeStringEntries as normalizeStringEntries$1, normalizeStringEntriesLower as normalizeStringEntriesLower$1 } from "openclaw/plugin-sdk/string-normalization-runtime";
+import { resolveToolsBySender } from "openclaw/plugin-sdk/channel-policy";
+//#region extensions/slack/src/exec-approvals.ts
+function normalizeSlackUserLikeId(value) {
+	const upper = value.toUpperCase();
+	return /^[UW][A-Z0-9]+$/.test(upper) ? upper : void 0;
+}
+function normalizeSlackApproverId(value) {
+	const trimmed = normalizeStringifiedOptionalString(value);
+	if (!trimmed) return;
+	const prefixed = trimmed.match(/^(?:slack|user):([A-Z0-9]+)$/i);
+	if (prefixed?.[1]) return normalizeSlackUserLikeId(prefixed[1]);
+	const mention = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+	if (mention?.[1]) return normalizeSlackUserLikeId(mention[1]);
+	return normalizeSlackUserLikeId(trimmed);
+}
+function resolveSlackOwnerApprovers(cfg) {
+	const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+	if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) return [];
+	return resolveApprovalApprovers({
+		explicit: ownerAllowFrom,
+		normalizeApprover: normalizeSlackApproverId
+	});
+}
+function getSlackExecApprovalApprovers(params) {
+	const account = resolveSlackAccount(params).config;
+	return resolveApprovalApprovers({
+		explicit: account.execApprovals?.approvers ?? resolveSlackOwnerApprovers(params.cfg),
+		normalizeApprover: normalizeSlackApproverId
+	});
+}
+function isSlackExecApprovalTargetRecipient(params) {
+	return isChannelExecApprovalTargetRecipient({
+		...params,
+		channel: "slack",
+		normalizeSenderId: normalizeSlackApproverId,
+		matchTarget: ({ target, normalizedSenderId }) => normalizeSlackApproverId(target.to) === normalizedSenderId
+	});
+}
+const slackExecApprovalProfile = createChannelExecApprovalProfile({
+	resolveConfig: (params) => resolveSlackAccount(params).config.execApprovals,
+	resolveApprovers: getSlackExecApprovalApprovers,
+	normalizeSenderId: normalizeSlackApproverId,
+	isTargetRecipient: isSlackExecApprovalTargetRecipient,
+	matchesRequestAccount: (params) => doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "slack",
+		accountId: params.accountId
+	})
+});
+const isSlackExecApprovalClientEnabled = slackExecApprovalProfile.isClientEnabled;
+slackExecApprovalProfile.isApprover;
+const isSlackExecApprovalAuthorizedSender = slackExecApprovalProfile.isAuthorizedSender;
+const resolveSlackExecApprovalTarget = slackExecApprovalProfile.resolveTarget;
+slackExecApprovalProfile.shouldHandleRequest;
+const shouldSuppressLocalSlackExecApprovalPrompt = slackExecApprovalProfile.shouldSuppressLocalPrompt;
+//#endregion
+//#region extensions/slack/src/approval-auth.ts
+function getSlackApprovalApprovers(params) {
+	const account = resolveSlackAccount(params).config;
+	return resolveApprovalApprovers({
+		allowFrom: resolveSlackAccountAllowFrom(params),
+		defaultTo: account.defaultTo,
+		normalizeApprover: normalizeSlackApproverId,
+		normalizeDefaultTo: normalizeSlackApproverId
+	});
+}
+function isSlackApprovalAuthorizedSender(params) {
+	const senderId = params.senderId ? normalizeSlackApproverId(params.senderId) : void 0;
+	if (!senderId) return false;
+	return getSlackApprovalApprovers(params).includes(senderId);
+}
+createResolvedApproverActionAuthAdapter({
+	channelLabel: "Slack",
+	resolveApprovers: ({ cfg, accountId }) => getSlackApprovalApprovers({
+		cfg,
+		accountId
+	}),
+	normalizeSenderId: (value) => normalizeSlackApproverId(value)
+});
+//#endregion
+//#region extensions/slack/src/approval-native-gates.ts
+function resolveSlackApprovalKind(request) {
+	return request.id.startsWith("plugin:") ? "plugin" : "exec";
+}
+function resolveSlackNativeApprovalConfig(params) {
+	return resolveSlackAccount(params).config.execApprovals;
+}
+function resolvePluginApprovalForwardingConfig(cfg) {
+	return cfg.approvals?.plugin;
+}
+function getSlackNativeApprovalApprovers(params) {
+	return params.approvalKind === "plugin" ? getSlackApprovalApprovers(params) : getSlackExecApprovalApprovers(params);
+}
+function normalizeAccountId$2(value) {
+	return normalizeOptionalString(value)?.toLowerCase();
+}
+function matchesSlackAccount(params) {
+	const expected = normalizeAccountId$2(params.expectedAccountId);
+	const actual = normalizeAccountId$2(params.actualAccountId);
+	return !expected || !actual || expected === actual;
+}
+function modeIncludesSession(mode) {
+	return mode === void 0 || mode === "session" || mode === "both";
+}
+function modeIncludesTargets(mode) {
+	return mode === "targets" || mode === "both";
+}
+function hasSlackPluginForwardingTarget(params) {
+	return (resolvePluginApprovalForwardingConfig(params.cfg)?.targets ?? []).some((target) => {
+		return (normalizeMessageChannel(target.channel) ?? target.channel) === "slack" && matchesSlackAccount({
+			expectedAccountId: params.accountId,
+			actualAccountId: target.accountId
+		});
+	});
+}
+function requestHasSlackOriginOrSession(params) {
+	const request = params.request.request;
+	const turnSourceChannel = normalizeMessageChannel(request.turnSourceChannel);
+	if (turnSourceChannel) return turnSourceChannel === "slack" && matchesSlackAccount({
+		expectedAccountId: params.accountId,
+		actualAccountId: request.turnSourceAccountId
+	});
+	return resolveApprovalRequestSessionConversation({
+		request: params.request,
+		channel: "slack",
+		bundledFallback: false
+	}) !== null && doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "slack",
+		accountId: params.accountId
+	});
+}
+function isPluginForwardingEnabledForRequest(params) {
+	const config = resolvePluginApprovalForwardingConfig(params.cfg);
+	if (!config?.enabled) return false;
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: config.agentFilter,
+		sessionFilter: config.sessionFilter
+	});
+}
+function canPluginForwardingRouteToSlack(params) {
+	const mode = resolvePluginApprovalForwardingConfig(params.cfg)?.mode;
+	if (modeIncludesSession(mode) && requestHasSlackOriginOrSession({
+		cfg: params.cfg,
+		request: params.request,
+		accountId: params.accountId
+	})) return true;
+	return modeIncludesTargets(mode) && hasSlackPluginForwardingTarget(params);
+}
+function isSlackPluginNativeApprovalClientEnabled(params) {
+	if (isChannelExecApprovalClientEnabledFromConfig({
+		enabled: resolveSlackNativeApprovalConfig(params)?.enabled,
+		approverCount: getSlackApprovalApprovers(params).length
+	})) return true;
+	const config = resolvePluginApprovalForwardingConfig(params.cfg);
+	if (!config?.enabled || getSlackApprovalApprovers(params).length <= 0) return false;
+	const mode = config.mode;
+	return modeIncludesSession(mode) || modeIncludesTargets(mode) && hasSlackPluginForwardingTarget(params);
+}
+function shouldHandleSlackPluginViaNativeClientConfig(params) {
+	if (!doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "slack",
+		accountId: params.accountId
+	})) return false;
+	const config = resolveSlackNativeApprovalConfig(params);
+	if (!isChannelExecApprovalClientEnabledFromConfig({
+		enabled: config?.enabled,
+		approverCount: getSlackApprovalApprovers(params).length
+	})) return false;
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+function shouldHandleSlackPluginNativeApprovalRequest(params) {
+	if (getSlackApprovalApprovers(params).length <= 0) return false;
+	if (shouldHandleSlackPluginViaNativeClientConfig(params)) return true;
+	if (!isPluginForwardingEnabledForRequest(params)) return false;
+	return canPluginForwardingRouteToSlack(params);
+}
+function isSlackNativeApprovalClientEnabled(params) {
+	if (params.approvalKind === "exec") return isSlackExecApprovalClientEnabled(params);
+	return isSlackPluginNativeApprovalClientEnabled(params);
+}
+function isSlackAnyNativeApprovalClientEnabled(params) {
+	return isSlackNativeApprovalClientEnabled({
+		...params,
+		approvalKind: "exec"
+	}) || isSlackNativeApprovalClientEnabled({
+		...params,
+		approvalKind: "plugin"
+	});
+}
+function shouldHandleSlackNativeApprovalRequest(params) {
+	const approvalKind = params.approvalKind ?? resolveSlackApprovalKind(params.request);
+	if (approvalKind === "plugin") return shouldHandleSlackPluginNativeApprovalRequest({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		request: params.request
+	});
+	if (!doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "slack",
+		accountId: params.accountId
+	})) return false;
+	const config = resolveSlackNativeApprovalConfig(params);
+	if (!isChannelExecApprovalClientEnabledFromConfig({
+		enabled: config?.enabled,
+		approverCount: getSlackNativeApprovalApprovers({
+			...params,
+			approvalKind
+		}).length
+	})) return false;
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+//#endregion
+//#region extensions/slack/src/reply-action-ids.ts
+const SLACK_REPLY_BUTTON_ACTION_ID = "openclaw:reply_button";
+const SLACK_REPLY_SELECT_ACTION_ID = "openclaw:reply_select";
+//#endregion
+//#region extensions/slack/src/truncate.ts
+function truncateSlackText(value, max) {
+	const trimmed = value.trim();
+	if (trimmed.length <= max) return trimmed;
+	if (max <= 1) return trimmed.slice(0, max);
+	return `${trimmed.slice(0, max - 1)}…`;
+}
+//#endregion
+//#region extensions/slack/src/blocks-render.ts
+const SLACK_SECTION_TEXT_MAX = 3e3;
+const SLACK_PLAIN_TEXT_MAX = 75;
+const SLACK_OPTION_VALUE_MAX = 150;
+const SLACK_BUTTON_VALUE_MAX = 2e3;
+const SLACK_BUTTON_URL_MAX = 3e3;
+const SLACK_STATIC_SELECT_OPTIONS_MAX = 100;
+const SLACK_ACTION_BLOCK_ELEMENTS_MAX = 25;
+function buildSlackReplyButtonActionId(buttonIndex, choiceIndex) {
+	return `${SLACK_REPLY_BUTTON_ACTION_ID}:${String(buttonIndex)}:${String(choiceIndex + 1)}`;
+}
+function buildSlackReplySelectActionId(selectIndex) {
+	return `${SLACK_REPLY_SELECT_ACTION_ID}:${String(selectIndex)}`;
+}
+function resolveSlackButtonStyle(style) {
+	if (style === "primary" || style === "danger") return style;
+	if (style === "success") return "primary";
+}
+function isWithinSlackLimit(value, maxLength) {
+	return value.length <= maxLength;
+}
+function readSlackBlockId(block) {
+	const value = block.block_id;
+	return typeof value === "string" ? value : void 0;
+}
+function readSlackOpenClawBlockIndex(blockId, prefix) {
+	if (!blockId.startsWith(prefix)) return;
+	const value = Number.parseInt(blockId.slice(prefix.length), 10);
+	return Number.isSafeInteger(value) && value > 0 ? value : void 0;
+}
+/** Resolve existing OpenClaw Block Kit indexes so appended controls keep stable unique IDs. */
+function resolveSlackInteractiveBlockOffsets(blocks) {
+	let buttonIndexOffset = 0;
+	let selectIndexOffset = 0;
+	for (const block of blocks ?? []) {
+		const blockId = readSlackBlockId(block);
+		if (!blockId) continue;
+		buttonIndexOffset = Math.max(buttonIndexOffset, readSlackOpenClawBlockIndex(blockId, "openclaw_reply_buttons_") ?? 0);
+		selectIndexOffset = Math.max(selectIndexOffset, readSlackOpenClawBlockIndex(blockId, "openclaw_reply_select_") ?? 0);
+	}
+	return {
+		buttonIndexOffset,
+		selectIndexOffset
+	};
+}
+/**
+* @deprecated Use buildSlackPresentationBlocks with MessagePresentation.
+*/
+function buildSlackInteractiveBlocks(interactive, options = {}) {
+	return reduceInteractiveReply(interactive, {
+		blocks: [],
+		buttonIndex: options.buttonIndexOffset ?? 0,
+		selectIndex: options.selectIndexOffset ?? 0
+	}, (state, block) => {
+		if (block.type === "text") {
+			const trimmed = block.text.trim();
+			if (!trimmed) return state;
+			state.blocks.push({
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: truncateSlackText(trimmed, SLACK_SECTION_TEXT_MAX)
+				}
+			});
+			return state;
+		}
+		if (block.type === "buttons") {
+			const elements = block.buttons.flatMap((button, choiceIndex) => {
+				const value = button.value && isWithinSlackLimit(button.value, SLACK_BUTTON_VALUE_MAX) ? button.value : void 0;
+				const url = button.url && isWithinSlackLimit(button.url, SLACK_BUTTON_URL_MAX) ? button.url : void 0;
+				if (!value && !url) return [];
+				const style = resolveSlackButtonStyle(button.style);
+				return [{
+					type: "button",
+					action_id: buildSlackReplyButtonActionId(state.buttonIndex + 1, choiceIndex),
+					text: {
+						type: "plain_text",
+						text: truncateSlackText(button.label, SLACK_PLAIN_TEXT_MAX),
+						emoji: true
+					},
+					...value ? { value } : {},
+					...url ? { url } : {},
+					...style ? { style } : {}
+				}];
+			}).slice(0, SLACK_ACTION_BLOCK_ELEMENTS_MAX);
+			if (elements.length === 0) return state;
+			state.blocks.push({
+				type: "actions",
+				block_id: `openclaw_reply_buttons_${++state.buttonIndex}`,
+				elements
+			});
+			return state;
+		}
+		const options = block.options.filter((option) => isWithinSlackLimit(option.value, SLACK_OPTION_VALUE_MAX)).slice(0, SLACK_STATIC_SELECT_OPTIONS_MAX);
+		if (options.length === 0) return state;
+		state.blocks.push({
+			type: "actions",
+			block_id: `openclaw_reply_select_${++state.selectIndex}`,
+			elements: [{
+				type: "static_select",
+				action_id: buildSlackReplySelectActionId(state.selectIndex),
+				placeholder: {
+					type: "plain_text",
+					text: truncateSlackText(normalizeOptionalString(block.placeholder) ?? "Choose an option", SLACK_PLAIN_TEXT_MAX),
+					emoji: true
+				},
+				options: options.map((option, _choiceIndex) => ({
+					text: {
+						type: "plain_text",
+						text: truncateSlackText(option.label, SLACK_PLAIN_TEXT_MAX),
+						emoji: true
+					},
+					value: option.value
+				}))
+			}]
+		});
+		return state;
+	}).blocks;
+}
+/** Render portable presentation blocks as Slack Block Kit blocks. */
+function buildSlackPresentationBlocks(presentation, options = {}) {
+	if (!presentation) return [];
+	const blocks = [];
+	if (presentation.title) blocks.push({
+		type: "header",
+		text: {
+			type: "plain_text",
+			text: truncateSlackText(presentation.title, 150),
+			emoji: true
+		}
+	});
+	for (const block of presentation.blocks) {
+		if (block.type === "text" || block.type === "context") {
+			const text = block.text.trim();
+			if (!text) continue;
+			if (block.type === "context") blocks.push({
+				type: "context",
+				elements: [{
+					type: "mrkdwn",
+					text: truncateSlackText(text, SLACK_SECTION_TEXT_MAX)
+				}]
+			});
+			else blocks.push({
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: truncateSlackText(text, SLACK_SECTION_TEXT_MAX)
+				}
+			});
+			continue;
+		}
+		if (block.type === "divider") blocks.push({ type: "divider" });
+	}
+	let buttonIndex = options.buttonIndexOffset ?? 0;
+	let selectIndex = options.selectIndexOffset ?? 0;
+	for (const block of presentation.blocks) {
+		if (block.type === "buttons") {
+			const rendered = buildSlackPresentationButtonBlock(block, buttonIndex + 1);
+			if (rendered) {
+				buttonIndex += 1;
+				blocks.push(rendered);
+			}
+			continue;
+		}
+		if (block.type === "select") {
+			const rendered = buildSlackPresentationSelectBlock(block, selectIndex + 1);
+			if (rendered) {
+				selectIndex += 1;
+				blocks.push(rendered);
+			}
+		}
+	}
+	return blocks;
+}
+function buildSlackPresentationButtonBlock(block, buttonIndex) {
+	const elements = block.buttons.flatMap((button, choiceIndex) => {
+		const value = button.value && isWithinSlackLimit(button.value, SLACK_BUTTON_VALUE_MAX) ? button.value : void 0;
+		const url = button.url && isWithinSlackLimit(button.url, SLACK_BUTTON_URL_MAX) ? button.url : void 0;
+		if (!value && !url) return [];
+		const style = resolveSlackButtonStyle(button.style);
+		return [{
+			type: "button",
+			action_id: buildSlackReplyButtonActionId(buttonIndex, choiceIndex),
+			text: {
+				type: "plain_text",
+				text: truncateSlackText(button.label, SLACK_PLAIN_TEXT_MAX),
+				emoji: true
+			},
+			...value ? { value } : {},
+			...url ? { url } : {},
+			...style ? { style } : {}
+		}];
+	}).slice(0, SLACK_ACTION_BLOCK_ELEMENTS_MAX);
+	return elements.length > 0 ? {
+		type: "actions",
+		block_id: `openclaw_reply_buttons_${buttonIndex}`,
+		elements
+	} : void 0;
+}
+function buildSlackPresentationSelectBlock(block, selectIndex) {
+	const options = block.options.filter((option) => isWithinSlackLimit(option.value, SLACK_OPTION_VALUE_MAX)).slice(0, SLACK_STATIC_SELECT_OPTIONS_MAX);
+	return options.length > 0 ? {
+		type: "actions",
+		block_id: `openclaw_reply_select_${selectIndex}`,
+		elements: [{
+			type: "static_select",
+			action_id: buildSlackReplySelectActionId(selectIndex),
+			placeholder: {
+				type: "plain_text",
+				text: truncateSlackText(normalizeOptionalString(block.placeholder) ?? "Choose an option", SLACK_PLAIN_TEXT_MAX),
+				emoji: true
+			},
+			options: options.map((option) => ({
+				text: {
+					type: "plain_text",
+					text: truncateSlackText(option.label, SLACK_PLAIN_TEXT_MAX),
+					emoji: true
+				},
+				value: option.value
+			}))
+		}]
+	} : void 0;
+}
+//#endregion
+//#region extensions/slack/src/monitor/allow-list.ts
+const SLACK_SLUG_CACHE_MAX = 512;
+const slackSlugCache = /* @__PURE__ */ new Map();
+function normalizeSlackSlug(raw) {
+	const key = raw ?? "";
+	const cached = slackSlugCache.get(key);
+	if (cached !== void 0) return cached;
+	const normalized = normalizeHyphenSlug(raw);
+	slackSlugCache.set(key, normalized);
+	if (slackSlugCache.size > SLACK_SLUG_CACHE_MAX) {
+		const oldest = slackSlugCache.keys().next();
+		if (!oldest.done) slackSlugCache.delete(oldest.value);
+	}
+	return normalized;
+}
+function normalizeAllowList(list) {
+	return normalizeStringEntries$1(list);
+}
+function normalizeAllowListLower(list) {
+	return normalizeStringEntriesLower$1(list);
+}
+function normalizeSlackAllowOwnerEntry(entry) {
+	const trimmed = normalizeOptionalLowercaseString(entry);
+	if (!trimmed || trimmed === "*") return;
+	const withoutPrefix = trimmed.replace(/^(slack:|user:)/, "");
+	return /^u[a-z0-9]+$/.test(withoutPrefix) ? withoutPrefix : void 0;
+}
+function resolveSlackAllowListMatch(params) {
+	const compiledAllowList = compileAllowlist(params.allowList);
+	const id = normalizeOptionalLowercaseString(params.id);
+	const name = normalizeOptionalLowercaseString(params.name);
+	const slug = normalizeSlackSlug(name);
+	return resolveCompiledAllowlistMatch({
+		compiledAllowlist: compiledAllowList,
+		candidates: [
+			{
+				value: id,
+				source: "id"
+			},
+			{
+				value: id ? `slack:${id}` : void 0,
+				source: "prefixed-id"
+			},
+			{
+				value: id ? `user:${id}` : void 0,
+				source: "prefixed-user"
+			},
+			...params.allowNameMatching === true ? [
+				{
+					value: name,
+					source: "name"
+				},
+				{
+					value: name ? `slack:${name}` : void 0,
+					source: "prefixed-name"
+				},
+				{
+					value: slug,
+					source: "slug"
+				}
+			] : []
+		]
+	});
+}
+function allowListMatches(params) {
+	return resolveSlackAllowListMatch(params).allowed;
+}
+function resolveSlackUserAllowed(params) {
+	const allowList = normalizeAllowListLower(params.allowList);
+	if (allowList.length === 0) return true;
+	return allowListMatches({
+		allowList,
+		id: params.userId,
+		name: params.userName,
+		allowNameMatching: params.allowNameMatching
+	});
+}
+//#endregion
+//#region extensions/slack/src/group-policy.ts
+function resolveSlackChannelPolicyEntry(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const channelMap = mergeSlackAccountConfig(params.cfg, accountId).channels ?? {};
+	if (Object.keys(channelMap).length === 0) return;
+	const channelId = params.groupId?.trim();
+	const channelName = params.groupChannel?.replace(/^#/, "");
+	const normalizedName = normalizeHyphenSlug(channelName);
+	const candidates = [
+		channelId ?? "",
+		channelName ? `#${channelName}` : "",
+		channelName ?? "",
+		normalizedName
+	].filter(Boolean);
+	for (const candidate of candidates) if (candidate && channelMap[candidate]) return channelMap[candidate];
+	return channelMap["*"];
+}
+function resolveSenderToolsEntry(entry, params) {
+	if (!entry) return;
+	return resolveToolsBySender({
+		toolsBySender: entry.toolsBySender,
+		senderId: params.senderId,
+		senderName: params.senderName,
+		senderUsername: params.senderUsername,
+		senderE164: params.senderE164
+	}) ?? entry.tools;
+}
+function resolveSlackGroupRequireMention(params) {
+	const resolved = resolveSlackChannelPolicyEntry(params);
+	if (typeof resolved?.requireMention === "boolean") return resolved.requireMention;
+	return true;
+}
+function resolveSlackGroupToolPolicy(params) {
+	return resolveSenderToolsEntry(resolveSlackChannelPolicyEntry(params), params);
+}
+//#endregion
+//#region extensions/slack/src/limits.ts
+const SLACK_TEXT_LIMIT = 8e3;
+//#endregion
+//#region extensions/slack/src/blocks-input.ts
+const SLACK_MAX_BLOCKS = 50;
+function parseBlocksJson(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch {
+		throw new Error("blocks must be valid JSON");
+	}
+}
+function assertBlocksArray(raw) {
+	if (!Array.isArray(raw)) throw new Error("blocks must be an array");
+	if (raw.length === 0) throw new Error("blocks must contain at least one block");
+	if (raw.length > 50) throw new Error(`blocks cannot exceed 50 items`);
+	for (const block of raw) {
+		if (!block || typeof block !== "object" || Array.isArray(block)) throw new Error("each block must be an object");
+		const type = block.type;
+		if (typeof type !== "string" || type.trim().length === 0) throw new Error("each block must include a non-empty string type");
+	}
+}
+function validateSlackBlocksArray(raw) {
+	assertBlocksArray(raw);
+	return raw;
+}
+function parseSlackBlocksInput(raw) {
+	if (raw == null) return;
+	return validateSlackBlocksArray(typeof raw === "string" ? parseBlocksJson(raw) : raw);
+}
+//#endregion
+//#region extensions/slack/src/reply-blocks.ts
+function resolveSlackReplyBlocks(payload) {
+	const slackData = payload.channelData?.slack;
+	let channelBlocks = [];
+	if (slackData && typeof slackData === "object" && !Array.isArray(slackData)) channelBlocks = parseSlackBlocksInput(slackData.blocks) ?? [];
+	const presentationBlocks = buildSlackPresentationBlocks(payload.presentation, resolveSlackInteractiveBlockOffsets(channelBlocks));
+	const interactiveBlocks = buildSlackInteractiveBlocks(payload.interactive, resolveSlackInteractiveBlockOffsets([...channelBlocks, ...presentationBlocks]));
+	const blocks = [
+		...channelBlocks,
+		...presentationBlocks,
+		...interactiveBlocks
+	];
+	if (blocks.length > 50) throw new Error(`Slack blocks cannot exceed 50 items after interactive render`);
+	return blocks.length > 0 ? blocks : void 0;
+}
+//#endregion
+//#region extensions/slack/src/thread-ts.ts
+const SLACK_THREAD_TS_PATTERN = /^\d+\.\d+$/;
+function normalizeSlackThreadTsCandidate(value) {
+	if (typeof value !== "string") return;
+	const normalized = normalizeOptionalString(value);
+	return normalized && SLACK_THREAD_TS_PATTERN.test(normalized) ? normalized : void 0;
+}
+function resolveSlackThreadTsValue(params) {
+	return normalizeSlackThreadTsCandidate(params.replyToId) ?? normalizeSlackThreadTsCandidate(params.threadId);
+}
+//#endregion
+export { isSlackExecApprovalClientEnabled as A, isSlackAnyNativeApprovalClientEnabled as C, isSlackApprovalAuthorizedSender as D, getSlackApprovalApprovers as E, resolveSlackExecApprovalTarget as M, shouldSuppressLocalSlackExecApprovalPrompt as N, getSlackExecApprovalApprovers as O, SLACK_REPLY_SELECT_ACTION_ID as S, shouldHandleSlackNativeApprovalRequest as T, buildSlackInteractiveBlocks as _, parseSlackBlocksInput as a, truncateSlackText as b, resolveSlackGroupRequireMention as c, normalizeAllowList as d, normalizeAllowListLower as f, resolveSlackUserAllowed as g, resolveSlackAllowListMatch as h, SLACK_MAX_BLOCKS as i, normalizeSlackApproverId as j, isSlackExecApprovalAuthorizedSender as k, resolveSlackGroupToolPolicy as l, normalizeSlackSlug as m, resolveSlackThreadTsValue as n, validateSlackBlocksArray as o, normalizeSlackAllowOwnerEntry as p, resolveSlackReplyBlocks as r, SLACK_TEXT_LIMIT as s, normalizeSlackThreadTsCandidate as t, allowListMatches as u, buildSlackPresentationBlocks as v, resolveSlackApprovalKind as w, SLACK_REPLY_BUTTON_ACTION_ID as x, resolveSlackInteractiveBlockOffsets as y };

package/node_modules/semver/classes/range.js

@@ -98,6 +98,9 @@ class Range {
   }
 
   parseRange (range) {
+    // strip build metadata so it can't bleed into the version
+    range = range.replace(BUILDSTRIPRE, '')
+
     // memoize range parsing for performance.
     // this is a very hot path, and fully deterministic.
     const memoOpts =
@@ -223,6 +226,7 @@ const debug = require('../internal/debug')
 const SemVer = require('./semver')
 const {
   safeRe: re,
+  src,
   t,
   comparatorTrimReplace,
   tildeTrimReplace,
@@ -230,6 +234,9 @@ const {
 } = require('../internal/re')
 const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require('../internal/constants')
 
+// unbounded global build-metadata stripper used by parseRange
+const BUILDSTRIPRE = new RegExp(src[t.BUILD], 'g')
+
 const isNullSet = c => c.value === '<0.0.0-0'
 const isAny = c => c.value === ''
 

package/node_modules/semver/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semver",
-  "version": "7.8.0",
+  "version": "7.8.1",
   "description": "The semantic version parser used by npm.",
   "main": "index.js",
   "scripts": {

package/node_modules/semver/ranges/subset.js

@@ -174,7 +174,7 @@ const simpleSubset = (sub, dom, options) => {
         if (higher === c && higher !== gt) {
           return false
         }
-      } else if (gt.operator === '>=' && !satisfies(gt.semver, String(c), options)) {
+      } else if (gt.operator === '>=' && !c.test(gt.semver)) {
         return false
       }
     }
@@ -192,7 +192,7 @@ const simpleSubset = (sub, dom, options) => {
         if (lower === c && lower !== lt) {
           return false
         }
-      } else if (lt.operator === '<=' && !satisfies(lt.semver, String(c), options)) {
+      } else if (lt.operator === '<=' && !c.test(lt.semver)) {
         return false
       }
     }