@openclaw/slack 2026.5.12-beta.7

package/dist/actions-CYLFK-Zy.js

@@ -0,0 +1,292 @@
+import { a as resolveSlackAccount, d as resolveSlackBotToken } from "./accounts-ClAPP5ry.js";
+import { i as truncateSlackText, r as SLACK_TEXT_LIMIT } from "./thread-ts-C2x7c5PP.js";
+import { a as getSlackWriteClient, r as createSlackWebClient } from "./client-CPe4GmDR.js";
+import { r as validateSlackBlocksArray } from "./blocks-input-CwTFVImV.js";
+import { c as buildSlackBlocksFallbackText, t as sendMessageSlack } from "./send-D_A9kL-C.js";
+import { n as resolveSlackMedia } from "./media-D1XCd1uP.js";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+//#region extensions/slack/src/edit-text.ts
+function buildSlackEditTextPayload(content, blocks) {
+	const trimmedContent = content.trim();
+	if (trimmedContent) return trimmedContent;
+	if (blocks?.length) return truncateSlackText(buildSlackBlocksFallbackText(blocks), SLACK_TEXT_LIMIT);
+	return " ";
+}
+//#endregion
+//#region extensions/slack/src/actions.ts
+function resolveToken(explicit, accountId, cfg) {
+	if (explicit?.trim()) {
+		const token = resolveSlackBotToken(explicit);
+		if (token) return token;
+	}
+	if (!cfg) throw new Error("Slack actions requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
+	const account = resolveSlackAccount({
+		cfg: requireRuntimeConfig(cfg, "Slack actions"),
+		accountId
+	});
+	const token = resolveSlackBotToken(account.botToken ?? void 0);
+	if (!token) {
+		logVerbose(`slack actions: missing bot token for account=${account.accountId} explicit=${Boolean(explicit)} source=${account.botTokenSource ?? "unknown"}`);
+		throw new Error("SLACK_BOT_TOKEN or channels.slack.botToken is required for Slack actions");
+	}
+	return token;
+}
+function normalizeEmoji(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) throw new Error("Emoji is required for Slack reactions");
+	return trimmed.replace(/^:+|:+$/g, "");
+}
+function hasSlackPlatformError(err, code) {
+	if (!err || typeof err !== "object") return false;
+	const data = err.data;
+	if (!data || typeof data !== "object") return false;
+	return data.error === code;
+}
+async function getClient(opts = {}, mode = "read") {
+	if (opts.client) return opts.client;
+	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
+	return mode === "write" ? getSlackWriteClient(token) : createSlackWebClient(token);
+}
+async function resolveBotUserId(client) {
+	const auth = await client.auth.test();
+	if (!auth?.user_id) throw new Error("Failed to resolve Slack bot user id");
+	return auth.user_id;
+}
+async function reactSlackMessage(channelId, messageId, emoji, opts = {}) {
+	const client = await getClient(opts, "write");
+	try {
+		await client.reactions.add({
+			channel: channelId,
+			timestamp: messageId,
+			name: normalizeEmoji(emoji)
+		});
+	} catch (err) {
+		if (hasSlackPlatformError(err, "already_reacted")) return;
+		throw err;
+	}
+}
+async function removeSlackReaction(channelId, messageId, emoji, opts = {}) {
+	const client = await getClient(opts, "write");
+	try {
+		await client.reactions.remove({
+			channel: channelId,
+			timestamp: messageId,
+			name: normalizeEmoji(emoji)
+		});
+	} catch (err) {
+		if (hasSlackPlatformError(err, "no_reaction")) return;
+		throw err;
+	}
+}
+async function removeOwnSlackReactions(channelId, messageId, opts = {}) {
+	const client = await getClient(opts, "write");
+	const userId = await resolveBotUserId(client);
+	const reactions = await listSlackReactions(channelId, messageId, { client });
+	const toRemove = /* @__PURE__ */ new Set();
+	for (const reaction of reactions ?? []) {
+		const name = reaction?.name;
+		if (!name) continue;
+		if ((reaction?.users ?? []).includes(userId)) toRemove.add(name);
+	}
+	if (toRemove.size === 0) return [];
+	await Promise.all(Array.from(toRemove, (name) => removeSlackReaction(channelId, messageId, name, {
+		...opts,
+		client
+	})));
+	return Array.from(toRemove);
+}
+async function listSlackReactions(channelId, messageId, opts = {}) {
+	return (await (await getClient(opts)).reactions.get({
+		channel: channelId,
+		timestamp: messageId,
+		full: true
+	})).message?.reactions ?? [];
+}
+async function sendSlackMessage(to, content, opts) {
+	return await sendMessageSlack(to, content, {
+		accountId: opts.accountId,
+		cfg: opts.cfg,
+		token: opts.token,
+		mediaUrl: opts.mediaUrl,
+		mediaAccess: opts.mediaAccess,
+		mediaLocalRoots: opts.mediaLocalRoots,
+		mediaReadFile: opts.mediaReadFile,
+		client: opts.client,
+		threadTs: opts.threadTs,
+		replyBroadcast: opts.replyBroadcast,
+		...opts.uploadFileName ? { uploadFileName: opts.uploadFileName } : {},
+		...opts.uploadTitle ? { uploadTitle: opts.uploadTitle } : {},
+		blocks: opts.blocks
+	});
+}
+async function editSlackMessage(channelId, messageId, content, opts = {}) {
+	const client = await getClient(opts, "write");
+	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
+	await client.chat.update({
+		channel: channelId,
+		ts: messageId,
+		text: buildSlackEditTextPayload(content, blocks),
+		...blocks ? { blocks } : {}
+	});
+}
+async function deleteSlackMessage(channelId, messageId, opts = {}) {
+	await (await getClient(opts, "write")).chat.delete({
+		channel: channelId,
+		ts: messageId
+	});
+}
+async function readSlackMessages(channelId, opts = {}) {
+	const client = await getClient(opts);
+	const exactMessageId = opts.messageId?.trim();
+	const readLimit = exactMessageId ? 1 : opts.limit;
+	const exactBounds = exactMessageId ? {
+		inclusive: true,
+		latest: exactMessageId,
+		oldest: void 0
+	} : {
+		latest: opts.before,
+		oldest: opts.after
+	};
+	if (opts.threadId) {
+		const result = await client.conversations.replies({
+			channel: channelId,
+			ts: opts.threadId,
+			limit: readLimit,
+			...exactBounds
+		});
+		return {
+			messages: (result.messages ?? []).filter((message) => {
+				if (exactMessageId) return message.ts === exactMessageId;
+				return message.ts !== opts.threadId;
+			}),
+			hasMore: exactMessageId ? false : Boolean(result.has_more)
+		};
+	}
+	const result = await client.conversations.history({
+		channel: channelId,
+		limit: readLimit,
+		...exactBounds
+	});
+	return {
+		messages: (result.messages ?? []).filter((message) => !exactMessageId || message.ts === exactMessageId),
+		hasMore: exactMessageId ? false : Boolean(result.has_more)
+	};
+}
+async function getSlackMemberInfo(userId, opts = {}) {
+	return await (await getClient(opts)).users.info({ user: userId });
+}
+async function listSlackEmojis(opts = {}) {
+	return await (await getClient(opts)).emoji.list();
+}
+async function pinSlackMessage(channelId, messageId, opts = {}) {
+	await (await getClient(opts, "write")).pins.add({
+		channel: channelId,
+		timestamp: messageId
+	});
+}
+async function unpinSlackMessage(channelId, messageId, opts = {}) {
+	await (await getClient(opts, "write")).pins.remove({
+		channel: channelId,
+		timestamp: messageId
+	});
+}
+async function listSlackPins(channelId, opts = {}) {
+	return (await (await getClient(opts)).pins.list({ channel: channelId })).items ?? [];
+}
+function normalizeSlackScopeValue(value) {
+	const trimmed = value?.trim();
+	return trimmed ? trimmed : void 0;
+}
+function collectSlackDirectShareChannelIds(file) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const group of [
+		file.channels,
+		file.groups,
+		file.ims
+	]) {
+		if (!Array.isArray(group)) continue;
+		for (const entry of group) {
+			if (typeof entry !== "string") continue;
+			const normalized = normalizeSlackScopeValue(entry);
+			if (normalized) ids.add(normalized);
+		}
+	}
+	return ids;
+}
+function collectSlackShareMaps(file) {
+	if (!file.shares || typeof file.shares !== "object" || Array.isArray(file.shares)) return [];
+	const shares = file.shares;
+	return [shares.public, shares.private].filter((value) => Boolean(value) && typeof value === "object" && !Array.isArray(value));
+}
+function collectSlackSharedChannelIds(file) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const shareMap of collectSlackShareMaps(file)) for (const channelId of Object.keys(shareMap)) {
+		const normalized = normalizeSlackScopeValue(channelId);
+		if (normalized) ids.add(normalized);
+	}
+	return ids;
+}
+function collectSlackThreadShares(file, channelId) {
+	const matches = [];
+	for (const shareMap of collectSlackShareMaps(file)) {
+		const rawEntries = shareMap[channelId];
+		if (!Array.isArray(rawEntries)) continue;
+		for (const rawEntry of rawEntries) {
+			if (!rawEntry || typeof rawEntry !== "object" || Array.isArray(rawEntry)) continue;
+			const entry = rawEntry;
+			const ts = typeof entry.ts === "string" ? normalizeSlackScopeValue(entry.ts) : void 0;
+			const threadTs = typeof entry.thread_ts === "string" ? normalizeSlackScopeValue(entry.thread_ts) : void 0;
+			matches.push({
+				channelId,
+				ts,
+				threadTs
+			});
+		}
+	}
+	return matches;
+}
+function hasSlackScopeMismatch(params) {
+	const channelId = normalizeSlackScopeValue(params.channelId);
+	if (!channelId) return false;
+	const threadId = normalizeSlackScopeValue(params.threadId);
+	const directIds = collectSlackDirectShareChannelIds(params.file);
+	const sharedIds = collectSlackSharedChannelIds(params.file);
+	const hasChannelEvidence = directIds.size > 0 || sharedIds.size > 0;
+	const inChannel = directIds.has(channelId) || sharedIds.has(channelId);
+	if (hasChannelEvidence && !inChannel) return true;
+	if (!threadId) return false;
+	const threadShares = collectSlackThreadShares(params.file, channelId);
+	if (threadShares.length === 0) return false;
+	const threadEvidence = threadShares.filter((entry) => entry.threadTs || entry.ts);
+	if (threadEvidence.length === 0) return false;
+	return !threadEvidence.some((entry) => entry.threadTs === threadId || entry.ts === threadId);
+}
+/**
+* Downloads a Slack file by ID and saves it to the local media store.
+* Fetches a fresh download URL via files.info to avoid using stale private URLs.
+* Returns null when the file cannot be found or downloaded.
+*/
+async function downloadSlackFile(fileId, opts) {
+	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
+	const file = (await (await getClient(opts)).files.info({ file: fileId })).file;
+	if (!file?.url_private_download && !file?.url_private) return null;
+	if (hasSlackScopeMismatch({
+		file,
+		channelId: opts.channelId,
+		threadId: opts.threadId
+	})) return null;
+	return (await resolveSlackMedia({
+		files: [{
+			id: file.id,
+			name: file.name,
+			mimetype: file.mimetype,
+			url_private: file.url_private,
+			url_private_download: file.url_private_download
+		}],
+		token,
+		maxBytes: opts.maxBytes
+	}))?.[0] ?? null;
+}
+//#endregion
+export { listSlackEmojis as a, pinSlackMessage as c, removeOwnSlackReactions as d, removeSlackReaction as f, buildSlackEditTextPayload as h, getSlackMemberInfo as i, reactSlackMessage as l, unpinSlackMessage as m, downloadSlackFile as n, listSlackPins as o, sendSlackMessage as p, editSlackMessage as r, listSlackReactions as s, deleteSlackMessage as t, readSlackMessages as u };

package/dist/actions.runtime-CO3OaTLb.js

@@ -0,0 +1,2 @@
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, i as getSlackMemberInfo, l as reactSlackMessage, m as unpinSlackMessage, n as downloadSlackFile, o as listSlackPins, p as sendSlackMessage, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-CYLFK-Zy.js";
+export { deleteSlackMessage, downloadSlackFile, editSlackMessage, getSlackMemberInfo, listSlackEmojis, listSlackPins, listSlackReactions, pinSlackMessage, reactSlackMessage, readSlackMessages, removeOwnSlackReactions, removeSlackReaction, sendSlackMessage, unpinSlackMessage };

package/dist/allow-list-BPnnlRPL.js

@@ -0,0 +1,82 @@
+import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { compileAllowlist, resolveCompiledAllowlistMatch } from "openclaw/plugin-sdk/allow-from";
+import { normalizeHyphenSlug, normalizeStringEntries as normalizeStringEntries$1, normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
+//#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(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
+export { normalizeSlackSlug as a, normalizeSlackAllowOwnerEntry as i, normalizeAllowList as n, resolveSlackAllowListMatch as o, normalizeAllowListLower as r, resolveSlackUserAllowed as s, allowListMatches as t };

package/dist/api.js

@@ -0,0 +1,21 @@
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, l as resolveSlackReplyToMode, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-ClAPP5ry.js";
+import { t as inspectSlackAccount } from "./account-inspect-D7AZNs8C.js";
+import { i as resolveSlackChannelId, n as normalizeSlackMessagingTarget, r as parseSlackTarget, t as looksLikeSlackTargetId } from "./target-parsing-CQmv-iSm.js";
+import "./targets-B1tYCAr6.js";
+import { i as resolveSlackChannelType, n as buildSlackThreadingToolContext, o as resolveSlackAutoThreadId, r as __resetSlackChannelTypeCacheForTest, t as slackPlugin } from "./channel-DRjHBTDB.js";
+import { n as buildSlackPresentationBlocks, t as buildSlackInteractiveBlocks } from "./blocks-render-BIDw-Pom.js";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-6lowf9zE.js";
+import { n as isSlackInteractiveRepliesEnabled, r as parseSlackOptionsLine, t as compileSlackInteractiveReplies } from "./interactive-replies-qAIfuBor.js";
+import { a as getSlackWriteClient, c as resolveSlackWebClientOptions, i as createSlackWriteClient, l as resolveSlackWriteClientOptions, n as createSlackTokenCacheKey, o as SLACK_DEFAULT_RETRY_OPTIONS, r as createSlackWebClient, s as SLACK_WRITE_RETRY_OPTIONS, t as clearSlackWriteClientCacheForTest } from "./client-CPe4GmDR.js";
+import { a as normalizeSlackSlug, i as normalizeSlackAllowOwnerEntry, n as normalizeAllowList, o as resolveSlackAllowListMatch, r as normalizeAllowListLower, s as resolveSlackUserAllowed, t as allowListMatches } from "./allow-list-BPnnlRPL.js";
+import { n as resolveSlackGroupToolPolicy, t as resolveSlackGroupRequireMention } from "./group-policy-CyLUK6My.js";
+import { n as parseSlackBlocksInput, r as validateSlackBlocksArray, t as SLACK_MAX_BLOCKS } from "./blocks-input-CwTFVImV.js";
+import { t as slackSetupPlugin } from "./channel.setup-Cayn7afd.js";
+import { a as recordSlackThreadParticipation, n as clearSlackThreadParticipationCache, r as hasSlackThreadParticipation } from "./send-D_A9kL-C.js";
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, i as getSlackMemberInfo, l as reactSlackMessage, m as unpinSlackMessage, n as downloadSlackFile, o as listSlackPins, p as sendSlackMessage, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-CYLFK-Zy.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-B3JiHeB7.js";
+import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-CeaoNfoP.js";
+import { t as probeSlack } from "./probe-3eZf1FjI.js";
+import { t as collectSlackSecurityAuditFindings } from "./security-audit-BtHGnD3d.js";
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-D7uAN3Fq.js";
+export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, __resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, compileSlackInteractiveReplies, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, isSlackInteractiveRepliesEnabled, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackOptionsLine, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };

package/dist/approval-handler.runtime-CmeRr9qA.js

@@ -0,0 +1,256 @@
+import { a as normalizeSlackApproverId, i as isSlackExecApprovalClientEnabled, s as shouldHandleSlackExecApprovalRequest } from "./exec-approvals-7xUNgLi9.js";
+import { i as truncateSlackText } from "./thread-ts-C2x7c5PP.js";
+import { t as resolveSlackReplyBlocks } from "./reply-blocks-Z5l6_R6H.js";
+import { t as sendMessageSlack } from "./send-D_A9kL-C.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { logError } from "openclaw/plugin-sdk/logging-core";
+import { buildApprovalInteractiveReplyFromActionDescriptors } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+//#region extensions/slack/src/approval-handler.runtime.ts
+const SLACK_CONTEXT_ELEMENTS_MAX = 10;
+const SLACK_CHAT_UPDATE_TEXT_LIMIT = 4e3;
+const SLACK_TEXT_OBJECT_MAX = 3e3;
+function resolveHandlerContext(params) {
+	const context = params.context;
+	const accountId = normalizeOptionalString(params.accountId) ?? "";
+	if (!context?.app || !accountId) return null;
+	return {
+		accountId,
+		context
+	};
+}
+function truncateSlackMrkdwn(text, maxChars) {
+	return text.length <= maxChars ? text : `${text.slice(0, maxChars - 1)}…`;
+}
+function buildSlackCodeBlock(text) {
+	let fence = "```";
+	while (text.includes(fence)) fence += "`";
+	return `${fence}\n${text}\n${fence}`;
+}
+function formatSlackApprover(resolvedBy) {
+	const normalized = resolvedBy ? normalizeSlackApproverId(resolvedBy) : void 0;
+	if (normalized) return `<@${normalized}>`;
+	const trimmed = normalizeOptionalString(resolvedBy);
+	return trimmed ? trimmed : null;
+}
+function formatSlackMetadataLine(label, value) {
+	return `*${label}:* ${value}`;
+}
+function buildSlackMetadataLines(metadata) {
+	const lines = [];
+	for (const item of metadata) lines.push(formatSlackMetadataLine(item.label, item.value));
+	return lines;
+}
+function buildSlackMetadataContextElements(metadata) {
+	const lines = buildSlackMetadataLines(metadata);
+	const visibleLineCount = lines.length > SLACK_CONTEXT_ELEMENTS_MAX ? SLACK_CONTEXT_ELEMENTS_MAX - 1 : lines.length;
+	const elements = [];
+	for (let index = 0; index < visibleLineCount; index += 1) {
+		const line = lines[index];
+		if (line === void 0) continue;
+		elements.push({
+			type: "mrkdwn",
+			text: truncateSlackMrkdwn(line, SLACK_TEXT_OBJECT_MAX)
+		});
+	}
+	if (lines.length > SLACK_CONTEXT_ELEMENTS_MAX) elements.push({
+		type: "mrkdwn",
+		text: `…+${lines.length - visibleLineCount} more`
+	});
+	return elements;
+}
+function resolveSlackApprovalDecisionLabel(decision) {
+	return decision === "allow-once" ? "Allowed once" : decision === "allow-always" ? "Allowed always" : "Denied";
+}
+function buildSlackPendingApprovalText(view) {
+	const metadataLines = buildSlackMetadataLines(view.metadata);
+	return [
+		"*Exec approval required*",
+		"A command needs your approval.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText),
+		...metadataLines
+	].join("\n");
+}
+function buildSlackPendingApprovalBlocks(view) {
+	const metadataElements = buildSlackMetadataContextElements(view.metadata);
+	const interactiveBlocks = resolveSlackReplyBlocks({
+		text: "",
+		interactive: buildApprovalInteractiveReplyFromActionDescriptors(view.actions)
+	}) ?? [];
+	return [
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: "*Exec approval required*\nA command needs your approval."
+			}
+		},
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`
+			}
+		},
+		...metadataElements.length > 0 ? [{
+			type: "context",
+			elements: metadataElements
+		}] : [],
+		...interactiveBlocks
+	];
+}
+function buildSlackResolvedText(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [
+		`*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+		resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildSlackResolvedBlocks(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*\n${resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved."}`
+		}
+	}, {
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`
+		}
+	}];
+}
+function buildSlackExpiredText(view) {
+	return [
+		"*Exec approval expired*",
+		"This approval request expired before it was resolved.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildSlackExpiredBlocks(view) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: "*Exec approval expired*\nThis approval request expired before it was resolved."
+		}
+	}, {
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Command*\n${buildSlackCodeBlock(truncateSlackMrkdwn(view.commandText, 2600))}`
+		}
+	}];
+}
+async function updateMessage(params) {
+	try {
+		await params.app.client.chat.update({
+			channel: params.channelId,
+			ts: params.messageTs,
+			text: truncateSlackText(params.text, SLACK_CHAT_UPDATE_TEXT_LIMIT),
+			blocks: params.blocks
+		});
+	} catch (err) {
+		logError(`slack exec approvals: failed to update message: ${String(err)}`);
+	}
+}
+const slackApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec"],
+	availability: {
+		isConfigured: (params) => {
+			const resolved = resolveHandlerContext(params);
+			return resolved ? isSlackExecApprovalClientEnabled({
+				cfg: params.cfg,
+				accountId: resolved.accountId
+			}) : false;
+		},
+		shouldHandle: (params) => {
+			const resolved = resolveHandlerContext(params);
+			if (!resolved) return false;
+			return shouldHandleSlackExecApprovalRequest({
+				cfg: params.cfg,
+				accountId: resolved.accountId,
+				request: params.request
+			});
+		}
+	},
+	presentation: {
+		buildPendingPayload: ({ view }) => ({
+			text: buildSlackPendingApprovalText(view),
+			blocks: buildSlackPendingApprovalBlocks(view)
+		}),
+		buildResolvedResult: ({ view }) => ({
+			kind: "update",
+			payload: {
+				text: buildSlackResolvedText(view),
+				blocks: buildSlackResolvedBlocks(view)
+			}
+		}),
+		buildExpiredResult: ({ view }) => ({
+			kind: "update",
+			payload: {
+				text: buildSlackExpiredText(view),
+				blocks: buildSlackExpiredBlocks(view)
+			}
+		})
+	},
+	transport: {
+		prepareTarget: ({ plannedTarget }) => ({
+			dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+			target: {
+				to: plannedTarget.target.to,
+				threadTs: plannedTarget.target.threadId != null ? String(plannedTarget.target.threadId) : void 0
+			}
+		}),
+		deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return null;
+			const message = await sendMessageSlack(preparedTarget.to, pendingPayload.text, {
+				cfg,
+				accountId: resolved.accountId,
+				threadTs: preparedTarget.threadTs,
+				blocks: pendingPayload.blocks,
+				client: resolved.context.app.client
+			});
+			return {
+				channelId: message.channelId,
+				messageTs: message.messageId
+			};
+		},
+		updateEntry: async ({ cfg, accountId, context, entry, payload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return;
+			const nextPayload = payload;
+			await updateMessage({
+				app: resolved.context.app,
+				channelId: entry.channelId,
+				messageTs: entry.messageTs,
+				text: nextPayload.text,
+				blocks: nextPayload.blocks
+			});
+		}
+	},
+	observe: { onDeliveryError: ({ error, request }) => {
+		logError(`slack exec approvals: failed to deliver approval ${request.id}: ${String(error)}`);
+	} }
+});
+//#endregion
+export { slackApprovalNativeRuntime };

package/dist/blocks-input-CwTFVImV.js

@@ -0,0 +1,29 @@
+//#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
+export { parseSlackBlocksInput as n, validateSlackBlocksArray as r, SLACK_MAX_BLOCKS as t };