@openclaw/slack 2026.7.2-beta.5 → 2026.7.33

package/dist/.setup/reply-blocks-Cwu6LYJI.mjs

@@ -0,0 +1,882 @@
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-uGn8E6uq.mjs";
+import { r as parseSlackTarget } from "./target-parsing-C36VFWHQ.mjs";
+import "./targets-DnpzC22e.mjs";
+import { t as isSlackPluginAccountConfigured } from "./account-configured-DzC407uv.mjs";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeMessageChannel } from "openclaw/plugin-sdk/routing";
+import { createNativeApprovalChannelRouteGates, 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 { channelRouteTargetsMatchExact, stringifyRouteThreadId } from "openclaw/plugin-sdk/channel-route";
+import { reduceInteractiveReply, resolveMessagePresentationControlValue } from "openclaw/plugin-sdk/interactive-runtime";
+import { parseExecApprovalCommandText } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { sliceUtf16Safe } from "openclaw/plugin-sdk/text-utility-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 { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
+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;
+	const approvers = getSlackApprovalApprovers(params);
+	if (approvers.length > 0) return approvers.includes(senderId);
+	return (resolveSlackAccountAllowFrom(params) ?? []).some((entry) => entry.trim() === "*");
+}
+createResolvedApproverActionAuthAdapter({
+	channelLabel: "Slack",
+	resolveApprovers: ({ cfg, accountId }) => getSlackApprovalApprovers({
+		cfg,
+		accountId
+	}),
+	normalizeSenderId: (value) => normalizeSlackApproverId(value)
+});
+//#endregion
+//#region extensions/slack/src/approval-native-gates.ts
+const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
+const SLACK_DM_CHANNEL_ID_RE = /^D[A-Z0-9]{8,}$/i;
+const SLACK_USER_ID_RE = /^[UW][A-Z0-9]{8,}$/i;
+function resolveSlackApprovalKind(request) {
+	return request.id.startsWith("plugin:") ? "plugin" : "exec";
+}
+function isSlackApprovalTransportEnabled(params) {
+	return isSlackPluginAccountConfigured(resolveSlackAccount(params));
+}
+function resolveSlackNativeApprovalConfig(params) {
+	return resolveSlackAccount(params).config.execApprovals;
+}
+function resolvePluginApprovalForwardingConfig(cfg) {
+	return cfg.approvals?.plugin;
+}
+function normalizeSlackThreadMatchKey(threadId) {
+	return threadId == null ? "" : String(threadId).trim();
+}
+function normalizeComparableTarget(value) {
+	return normalizeLowercaseStringOrEmpty(value);
+}
+function extractSlackSessionKind(sessionKey) {
+	if (!sessionKey) return null;
+	const match = sessionKey.match(/slack:(direct|channel|group):/i);
+	const kind = normalizeLowercaseStringOrEmpty(match?.[1]);
+	return kind ? kind : null;
+}
+function resolveSlackTurnSourceDefaultKind(params) {
+	if (SLACK_DM_CHANNEL_ID_RE.test(params.turnSourceTo)) return "channel";
+	return params.sessionKind === "direct" ? "user" : "channel";
+}
+function resolveTurnSourceSlackOriginTarget(request) {
+	const turnSourceChannel = normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel);
+	const turnSourceTo = normalizeOptionalString(request.request.turnSourceTo) ?? "";
+	if (turnSourceChannel !== "slack" || !turnSourceTo) return null;
+	const sessionKind = extractSlackSessionKind(request.request.sessionKey ?? void 0);
+	const parsed = parseSlackTarget(turnSourceTo, { defaultKind: resolveSlackTurnSourceDefaultKind({
+		turnSourceTo,
+		sessionKind
+	}) });
+	if (!parsed) return null;
+	return {
+		to: `${parsed.kind}:${parsed.id}`,
+		threadId: stringifyRouteThreadId(request.request.turnSourceThreadId)
+	};
+}
+function resolveSessionSlackOriginTarget(sessionTarget) {
+	return {
+		to: sessionTarget.to,
+		threadId: stringifyRouteThreadId(sessionTarget.threadId)
+	};
+}
+function resolveSlackFallbackOriginTarget(request) {
+	const sessionTarget = resolveApprovalRequestSessionConversation({
+		request,
+		channel: "slack",
+		bundledFallback: false
+	});
+	if (!sessionTarget) return null;
+	const parsed = parseSlackTarget(sessionTarget.id.toUpperCase(), { defaultKind: "channel" });
+	if (!parsed) return null;
+	return {
+		to: `${parsed.kind}:${parsed.id}`,
+		threadId: sessionTarget.threadId
+	};
+}
+function normalizeSlackOriginTarget(target) {
+	return {
+		...target,
+		to: normalizeComparableTarget(target.to)
+	};
+}
+function parseComparableSlackTarget(target) {
+	return parseSlackTarget(target.to, { defaultKind: "channel" });
+}
+function isSlackDmChannelToUserRoutePair(a, b) {
+	const left = parseComparableSlackTarget(a);
+	const right = parseComparableSlackTarget(b);
+	if (!left || !right) return false;
+	return left.kind === "channel" && SLACK_DM_CHANNEL_ID_RE.test(left.id) && right.kind === "user" || right.kind === "channel" && SLACK_DM_CHANNEL_ID_RE.test(right.id) && left.kind === "user";
+}
+function slackTargetsMatch(a, b) {
+	const threadKey = normalizeSlackThreadMatchKey(a.threadId);
+	if (threadKey !== normalizeSlackThreadMatchKey(b.threadId)) return false;
+	if (channelRouteTargetsMatchExact({
+		left: {
+			channel: "slack",
+			to: a.to
+		},
+		right: {
+			channel: "slack",
+			to: b.to
+		}
+	})) return true;
+	return Boolean(threadKey && isSlackDmChannelToUserRoutePair(a, b));
+}
+function normalizeSlackForwardTarget(target) {
+	if ((normalizeMessageChannel(target.channel) ?? target.channel) !== "slack") return null;
+	const to = normalizeOptionalString(target.to);
+	if (!to) return null;
+	const parsed = parseSlackTarget(to, { defaultKind: SLACK_USER_ID_RE.test(to) ? "user" : "channel" });
+	if (!parsed) return null;
+	return {
+		to: `${parsed.kind}:${parsed.id}`,
+		accountId: normalizeOptionalString(target.accountId),
+		threadId: stringifyRouteThreadId(target.threadId)
+	};
+}
+const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToSlack, isSessionApprovalEligible: isForwardedSlackSessionApprovalEligible, isExplicitTargetEligible: isForwardedSlackExplicitTargetEligible } = createNativeApprovalChannelRouteGates({
+	channel: "slack",
+	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
+	isTransportEnabled: isSlackApprovalTransportEnabled,
+	listAccountIds: listSlackAccountIds,
+	resolveDefaultAccountId: resolveDefaultSlackAccountId,
+	normalizeForwardTarget: normalizeSlackForwardTarget,
+	resolveTurnSourceTarget: resolveTurnSourceSlackOriginTarget,
+	targetsMatch: slackTargetsMatch
+});
+function hasSlackPluginApprovers(params) {
+	return getSlackApprovalApprovers(params).length > 0;
+}
+function isSlackPluginNativeApprovalClientConfigEnabled(params) {
+	const slackNativeConfig = resolveSlackNativeApprovalConfig(params);
+	return isChannelExecApprovalClientEnabledFromConfig({
+		enabled: slackNativeConfig?.enabled,
+		approverCount: getSlackApprovalApprovers(params).length
+	});
+}
+function isSlackPluginForwardingRoutePotentiallyEnabled(params) {
+	return canApprovalPotentiallyRouteToSlack({
+		...params,
+		approvalKind: "plugin"
+	});
+}
+function isSlackPluginNativeApprovalClientEnabled(params) {
+	return isSlackPluginNativeApprovalClientConfigEnabled(params) || isSlackPluginForwardingRoutePotentiallyEnabled(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 matchesSlackNativeApprovalFilters({
+		request: params.request,
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+function matchesSlackNativeApprovalFilters(params) {
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: params.agentFilter,
+		sessionFilter: params.sessionFilter
+	});
+}
+function isAnyForwardedSlackExplicitTargetEligible(params) {
+	return (resolvePluginApprovalForwardingConfig(params.cfg)?.targets ?? []).some((target) => isForwardedSlackExplicitTargetEligible({
+		...params,
+		approvalKind: "plugin",
+		target
+	}));
+}
+function shouldHandleSlackPluginViaForwarding(params) {
+	return isForwardedSlackSessionApprovalEligible({
+		...params,
+		approvalKind: "plugin"
+	}) || isAnyForwardedSlackExplicitTargetEligible(params);
+}
+function shouldHandleSlackPluginViaForwardingSession(params) {
+	return isForwardedSlackSessionApprovalEligible({
+		...params,
+		approvalKind: "plugin"
+	});
+}
+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) {
+	if ((params.approvalKind ?? resolveSlackApprovalKind(params.request)) === "plugin") return shouldHandleSlackPluginViaNativeClientConfig(params) || shouldHandleSlackPluginViaForwarding(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: getSlackExecApprovalApprovers(params).length
+	})) return false;
+	return matchesSlackNativeApprovalFilters({
+		request: params.request,
+		agentFilter: config?.agentFilter,
+		sessionFilter: config?.sessionFilter
+	});
+}
+const SLACK_BUTTON_VALUE_MAX = 2e3;
+const SLACK_SECTION_TEXT_MAX = 3e3;
+const SLACK_PRESENTATION_CAPABILITIES = {
+	supported: true,
+	buttons: true,
+	selects: true,
+	context: true,
+	divider: true,
+	limits: {
+		actions: {
+			maxActionsPerRow: 25,
+			maxLabelLength: 75,
+			maxValueBytes: SLACK_BUTTON_VALUE_MAX,
+			supportsStyles: true
+		},
+		selects: {
+			maxOptions: 100,
+			maxLabelLength: 75,
+			maxValueBytes: 150
+		},
+		text: {
+			encoding: "characters",
+			markdownDialect: "slack-mrkdwn",
+			supportsEdit: true
+		}
+	}
+};
+//#endregion
+//#region extensions/slack/src/reply-action-ids.ts
+const SLACK_REPLY_BUTTON_ACTION_ID = "openclaw:reply_button";
+const SLACK_REPLY_LINK_ACTION_ID = "openclaw:reply_link";
+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 sliceUtf16Safe(trimmed, 0, max);
+	return `${sliceUtf16Safe(trimmed, 0, max - 1)}…`;
+}
+//#endregion
+//#region extensions/slack/src/blocks-render.ts
+const SLACK_BUTTON_URL_MAX = 3e3;
+function buildSlackReplyButtonActionId(buttonIndex, choiceIndex) {
+	return `${SLACK_REPLY_BUTTON_ACTION_ID}:${String(buttonIndex)}:${String(choiceIndex + 1)}`;
+}
+function buildSlackReplyLinkActionId(buttonIndex, choiceIndex) {
+	return `${SLACK_REPLY_LINK_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 resolveSlackControlValue(control) {
+	if (control.action?.type === "command") {
+		const command = normalizeOptionalString(control.action.command);
+		if (command && parseExecApprovalCommandText(command)) return command;
+		const legacyValue = normalizeOptionalString(control.value);
+		return legacyValue && parseExecApprovalCommandText(legacyValue) ? legacyValue : void 0;
+	}
+	return resolveMessagePresentationControlValue(control);
+}
+function isWithinSlackLimit(value, maxLength) {
+	return value.length <= maxLength;
+}
+function isRenderableSlackOption(option) {
+	return option.value !== void 0 && isWithinSlackLimit(option.value, 150);
+}
+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 = {}) {
+	const initialState = {
+		blocks: [],
+		buttonIndex: options.buttonIndexOffset ?? 0,
+		selectIndex: options.selectIndexOffset ?? 0
+	};
+	return reduceInteractiveReply(interactive, initialState, (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 callbackData = resolveSlackControlValue(button);
+				const value = callbackData && isWithinSlackLimit(callbackData, 2e3) ? callbackData : void 0;
+				const url = button.url && isWithinSlackLimit(button.url, SLACK_BUTTON_URL_MAX) ? button.url : void 0;
+				if (!value && !url) return [];
+				const target = url ? { url } : { value };
+				const style = resolveSlackButtonStyle(button.style);
+				return [{
+					type: "button",
+					action_id: url ? buildSlackReplyLinkActionId(state.buttonIndex + 1, choiceIndex) : buildSlackReplyButtonActionId(state.buttonIndex + 1, choiceIndex),
+					text: {
+						type: "plain_text",
+						text: truncateSlackText(button.label, 75),
+						emoji: true
+					},
+					...target,
+					...style ? { style } : {}
+				}];
+			}).slice(0, 25);
+			if (elements.length === 0) return state;
+			state.blocks.push({
+				type: "actions",
+				block_id: `openclaw_reply_buttons_${++state.buttonIndex}`,
+				elements
+			});
+			return state;
+		}
+		const optionsLocal = block.options.map((option) => ({
+			label: option.label,
+			value: resolveSlackControlValue(option)
+		})).filter(isRenderableSlackOption).slice(0, 100);
+		if (optionsLocal.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", 75),
+					emoji: true
+				},
+				options: optionsLocal.map((option, _choiceIndex) => ({
+					text: {
+						type: "plain_text",
+						text: truncateSlackText(option.label, 75),
+						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
+		}
+	});
+	let buttonIndex = options.buttonIndexOffset ?? 0;
+	let selectIndex = options.selectIndexOffset ?? 0;
+	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" });
+			continue;
+		}
+		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 target = resolveSlackPresentationButtonTarget(button);
+		if (!target) return [];
+		const style = resolveSlackButtonStyle(button.style);
+		return [{
+			type: "button",
+			action_id: target.url ? buildSlackReplyLinkActionId(buttonIndex, choiceIndex) : buildSlackReplyButtonActionId(buttonIndex, choiceIndex),
+			text: {
+				type: "plain_text",
+				text: truncateSlackText(button.label, 75),
+				emoji: true
+			},
+			...target,
+			...style ? { style } : {}
+		}];
+	}).slice(0, 25);
+	return elements.length > 0 ? {
+		type: "actions",
+		block_id: `openclaw_reply_buttons_${buttonIndex}`,
+		elements
+	} : void 0;
+}
+function resolveSlackPresentationButtonTarget(button) {
+	const callbackData = resolveSlackControlValue(button);
+	const value = callbackData && isWithinSlackLimit(callbackData, 2e3) ? callbackData : void 0;
+	const rawUrl = button.url ?? button.webApp?.url ?? button.web_app?.url;
+	const url = rawUrl && isWithinSlackLimit(rawUrl, SLACK_BUTTON_URL_MAX) ? rawUrl : void 0;
+	return url ? { url } : value ? { value } : void 0;
+}
+/** True when native Slack rendering preserves every portable control. */
+function canRenderSlackPresentation(presentation) {
+	if (presentation.title && !isWithinSlackLimit(presentation.title.trim(), 150)) return false;
+	return presentation.blocks.every((block) => {
+		if (block.type === "text" || block.type === "context") return isWithinSlackLimit(block.text.trim(), SLACK_SECTION_TEXT_MAX);
+		if (block.type === "buttons") return block.buttons.length <= 25 && block.buttons.every((button) => resolveSlackPresentationButtonTarget(button) !== void 0);
+		if (block.type === "select") return block.options.length <= 100 && block.options.every((option) => isRenderableSlackOption({
+			label: option.label,
+			value: resolveSlackControlValue(option)
+		}));
+		return true;
+	});
+}
+function buildSlackPresentationSelectBlock(block, selectIndex) {
+	const options = block.options.map((option) => ({
+		label: option.label,
+		value: resolveSlackControlValue(option)
+	})).filter(isRenderableSlackOption).slice(0, 100);
+	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", 75),
+				emoji: true
+			},
+			options: options.map((option) => ({
+				text: {
+					type: "plain_text",
+					text: truncateSlackText(option.label, 75),
+					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);
+	const 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"
+			}
+		] : []
+	];
+	return resolveCompiledAllowlistMatch({
+		compiledAllowlist: compiledAllowList,
+		candidates
+	});
+}
+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/errors.ts
+const NO_ERROR_DETAIL = "no error detail";
+function redact(value) {
+	return redactSensitiveText(value);
+}
+function addStringDetail(details, label, value) {
+	if (typeof value !== "string") return;
+	const trimmed = redact(value.trim());
+	if (trimmed) details.push(label ? `${label}: ${trimmed}` : trimmed);
+}
+function addScalarDetail(details, label, value) {
+	if (typeof value === "string") {
+		addStringDetail(details, label, value);
+		return;
+	}
+	if (typeof value === "number" || typeof value === "boolean") details.push(`${label}: ${String(value)}`);
+}
+function addStringListDetail(details, label, value) {
+	if (!Array.isArray(value)) return;
+	const entries = value.flatMap((entry) => {
+		if (typeof entry !== "string") return [];
+		const trimmed = redact(entry.trim());
+		return trimmed ? [trimmed] : [];
+	});
+	if (entries.length) details.push(`${label}: ${entries.join(", ")}`);
+}
+function safeStringify(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		const result = JSON.stringify(value, (_key, nested) => {
+			if (typeof nested !== "object" || nested === null) return nested;
+			if (seen.has(nested)) return "[Circular]";
+			seen.add(nested);
+			return nested;
+		});
+		return result ? redact(result) : void 0;
+	} catch {
+		return;
+	}
+}
+function addSlackResponseMetadata(details, value) {
+	if (!isRecord(value)) return;
+	addStringListDetail(details, "scopes", value.scopes);
+	addStringListDetail(details, "accepted", value.acceptedScopes);
+	const messages = value.messages;
+	if (Array.isArray(messages)) for (const message of messages) addStringDetail(details, "slack message", message);
+	const warnings = value.warnings;
+	if (Array.isArray(warnings)) for (const warning of warnings) addStringDetail(details, "slack warning", warning);
+}
+function addSlackDataDetails(details, value) {
+	if (!isRecord(value)) return;
+	addScalarDetail(details, "slack error", value.error);
+	addScalarDetail(details, "needed", value.needed);
+	addScalarDetail(details, "provided", value.provided);
+	addSlackResponseMetadata(details, value.response_metadata);
+}
+function addRecordDetails(details, value) {
+	addScalarDetail(details, "code", value.code);
+	addScalarDetail(details, "status", value.status);
+	addScalarDetail(details, "statusCode", value.statusCode);
+	addScalarDetail(details, "statusMessage", value.statusMessage);
+	addScalarDetail(details, "retryAfter", value.retryAfter);
+	addScalarDetail(details, "errno", value.errno);
+	addScalarDetail(details, "syscall", value.syscall);
+	addScalarDetail(details, "hostname", value.hostname);
+	addScalarDetail(details, "type", value.type);
+	addStringDetail(details, "statusText", value.statusText);
+	addStringDetail(details, "body", value.body);
+	addSlackDataDetails(details, value.data);
+	if (isRecord(value.response)) {
+		addScalarDetail(details, "response status", value.response.status);
+		addStringDetail(details, "response statusText", value.response.statusText);
+		addSlackDataDetails(details, value.response.data);
+	}
+}
+function collectSlackErrorDetails(error) {
+	const details = [];
+	if (error === void 0 || error === null) return details;
+	if (typeof error === "string") {
+		addStringDetail(details, "", error);
+		return details;
+	}
+	if (error instanceof Error) {
+		addStringDetail(details, "", error.message || error.name);
+		if (error.cause !== void 0) {
+			const cause = formatSlackError(error.cause, "");
+			if (cause) details.push(`cause: ${cause}`);
+		}
+	}
+	if (isRecord(error)) {
+		addRecordDetails(details, error);
+		const fallback = safeStringify(error);
+		if (details.length === 0 && fallback && fallback !== "{}") details.push(fallback);
+	}
+	return details;
+}
+function formatSlackError(error, fallback = NO_ERROR_DETAIL) {
+	const details = collectSlackErrorDetails(error);
+	if (details.length > 0) return details.join("; ");
+	if (error === void 0 || error === null) return fallback;
+	if (typeof error === "string" && !error.trim()) return fallback;
+	return safeStringify(error) ?? fallback;
+}
+//#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
+export { resolveSessionSlackOriginTarget as A, isSlackExecApprovalAuthorizedSender as B, SLACK_REPLY_SELECT_ACTION_ID as C, isSlackAnyNativeApprovalClientEnabled as D, hasSlackPluginApprovers as E, shouldHandleSlackPluginViaForwardingSession as F, normalizeSlackApproverId as H, slackTargetsMatch as I, getSlackApprovalApprovers as L, resolveSlackFallbackOriginTarget as M, resolveTurnSourceSlackOriginTarget as N, normalizeSlackForwardTarget as O, shouldHandleSlackNativeApprovalRequest as P, isSlackApprovalAuthorizedSender as R, SLACK_REPLY_LINK_ACTION_ID as S, SLACK_SECTION_TEXT_MAX as T, resolveSlackExecApprovalTarget as U, isSlackExecApprovalClientEnabled as V, shouldSuppressLocalSlackExecApprovalPrompt as W, buildSlackPresentationBlocks as _, SLACK_TEXT_LIMIT as a, truncateSlackText as b, formatSlackError as c, normalizeAllowListLower as d, normalizeSlackAllowOwnerEntry as f, buildSlackInteractiveBlocks as g, resolveSlackUserAllowed as h, validateSlackBlocksArray as i, resolveSlackApprovalKind as j, normalizeSlackOriginTarget as k, allowListMatches as l, resolveSlackAllowListMatch as m, SLACK_MAX_BLOCKS as n, resolveSlackGroupRequireMention as o, normalizeSlackSlug as p, parseSlackBlocksInput as r, resolveSlackGroupToolPolicy as s, resolveSlackReplyBlocks as t, normalizeAllowList as u, canRenderSlackPresentation as v, SLACK_PRESENTATION_CAPABILITIES as w, SLACK_REPLY_BUTTON_ACTION_ID as x, resolveSlackInteractiveBlockOffsets as y, getSlackExecApprovalApprovers as z };