@openclaw/slack 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/actions.runtime-DLFyUkvg.js

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

package/dist/api.js

@@ -1,18 +1,18 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-BSr252c_.js";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-CK4AVI2_.js";
 import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { t as inspectSlackAccount } from "./account-inspect-jn1xLaVi.js";
-import { a as resolveSlackChannelId, i as parseSlackTarget, n as looksLikeSlackTargetId, r as normalizeSlackMessagingTarget } from "./target-parsing-N6lHogYZ.js";
-import "./targets-KmjP2E8s.js";
-import { n as buildSlackThreadingToolContext, r as resolveSlackAutoThreadId, t as slackPlugin } from "./channel-Cnrlie9S.js";
-import { R as buildSlackInteractiveBlocks, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, d as resolveSlackUserAllowed, et as SLACK_MAX_BLOCKS, l as normalizeSlackSlug, n as resolveSlackGroupRequireMention, nt as validateSlackBlocksArray, o as normalizeAllowList, r as resolveSlackGroupToolPolicy, s as normalizeAllowListLower, tt as parseSlackBlocksInput, u as resolveSlackAllowListMatch, z as buildSlackPresentationBlocks } from "./group-policy-CthIXE2T.js";
-import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-CvKoWYYQ.js";
-import { c as createSlackWebClient, d as getSlackWriteClient, f as SLACK_DEFAULT_RETRY_OPTIONS, g as resolveSlackWriteClientOptions, h as resolveSlackWebClientOptions, i as clearSlackWriteClientCacheForTest, l as createSlackWriteClient, p as SLACK_WRITE_RETRY_OPTIONS, s as createSlackTokenCacheKey, t as probeSlack } from "./probe-BhQTDVBQ.js";
-import { n as resetSlackChannelTypeCacheForTest, r as resolveSlackChannelType } from "./channel-type-CPDX8EV-.js";
-import { t as slackSetupPlugin } from "./channel.setup-DyZdLwUB.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-BkOaiDSX.js";
-import { l as recordSlackThreadParticipation, o as clearSlackThreadParticipationCache, s as hasSlackThreadParticipation } from "./send-2IoDXPeB.js";
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CeixfVuC.js";
+import { t as inspectSlackAccount } from "./account-inspect-Drw2gAiN.js";
+import { a as parseSlackTarget, i as normalizeSlackMessagingTarget, o as resolveSlackChannelId, r as looksLikeSlackTargetId } from "./target-parsing-BnMD2ZqZ.js";
+import "./targets-Cx5W_n3W.js";
+import { n as buildSlackThreadingToolContext, r as resolveSlackAutoThreadId, t as slackPlugin } from "./channel-D_tovcUL.js";
+import { H as buildSlackPresentationBlocks, V as buildSlackInteractiveBlocks, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, ct as SLACK_MAX_BLOCKS, f as resolveSlackUserAllowed, i as resolveSlackGroupToolPolicy, l as normalizeSlackSlug, lt as parseSlackBlocksInput, o as normalizeAllowList, r as resolveSlackGroupRequireMention, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, ut as validateSlackBlocksArray } from "./group-policy-c4RP9bjc.js";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-BykQB4AU.js";
+import { _ as resolveSlackWriteClientOptions, c as createSlackWebClient, d as getSlackWriteClient, f as SLACK_DEFAULT_RETRY_OPTIONS, g as resolveSlackWebClientOptions, l as createSlackWriteClient, p as SLACK_WRITE_RETRY_OPTIONS, s as createSlackTokenCacheKey, t as probeSlack } from "./probe-HoEg_WxB.js";
+import { n as resolveSlackChannelType } from "./channel-type-B9MSdoGN.js";
+import { t as slackSetupPlugin } from "./channel.setup-Bch9dYmA.js";
+import { a as getSlackMemberInfo, c as listSlackReactions, d as readSlackMessages, f as removeOwnSlackReactions, g as unpinSlackMessage, h as sendSlackMessage, l as pinSlackMessage, n as downloadSlackFile, o as listSlackEmojis, p as removeSlackReaction, r as editSlackMessage, s as listSlackPins, t as deleteSlackMessage, u as reactSlackMessage } from "./actions-BTDXwwE3.js";
+import { f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, s as clearSlackThreadParticipationCache } from "./send-Nor0iBwY.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CNBz8lJa.js";
 import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
-import { n as resolveSlackRuntimeGroupPolicy } from "./provider-PSppCU_K.js";
-export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, resetSlackChannelTypeCacheForTest as __resetSlackChannelTypeCacheForTest, resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, 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 };
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-CDNvBXUi.js";
+export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, collectSlackSecurityAuditFindings, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, 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-CJaNzAq2.js

@@ -0,0 +1,404 @@
+import { a as parseSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { At as normalizeSlackApproverId, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, _ as resolveSlackReplyBlocks, ft as isSlackAnyNativeApprovalClientEnabled, yt as shouldHandleSlackNativeApprovalRequest } from "./group-policy-c4RP9bjc.js";
+import { r as sendMessageSlack } from "./send-Nor0iBwY.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalPresentationFromActionDescriptors } from "openclaw/plugin-sdk/approval-reply-runtime";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { logError } from "openclaw/plugin-sdk/logging-core";
+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_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) {
+	const limit = Math.max(0, Math.floor(maxChars));
+	if (text.length <= limit) return text;
+	if (limit <= 1) return truncateUtf16Safe(text, limit);
+	return `${truncateUtf16Safe(text, limit - 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 buildSlackMetadataContextBlocks(metadata) {
+	const metadataElements = buildSlackMetadataContextElements(metadata);
+	return metadataElements.length > 0 ? [{
+		type: "context",
+		elements: metadataElements
+	}] : [];
+}
+function resolveSlackApprovalDecisionLabel(decision) {
+	return decision === "allow-once" ? "Allowed once" : decision === "allow-always" ? "Allowed always" : "Denied";
+}
+function buildSlackPluginMetadata(view) {
+	return [{
+		label: "Approval ID",
+		value: view.approvalId
+	}, ...view.metadata];
+}
+function resolveSlackPluginDescription(view) {
+	return normalizeOptionalString(view.description) ?? "A plugin action needs your approval.";
+}
+function buildSlackPluginRequestBlocks(view) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Request*\n${truncateSlackMrkdwn(view.title, 2600)}`
+		}
+	}, ...buildSlackMetadataContextBlocks(buildSlackPluginMetadata(view))];
+}
+function buildSlackExecPendingApprovalText(view) {
+	const metadataLines = buildSlackMetadataLines(view.metadata);
+	return [
+		"*Exec approval required*",
+		"A command needs your approval.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText),
+		...metadataLines
+	].join("\n");
+}
+function buildSlackPluginPendingApprovalText(view) {
+	const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+	return [
+		"*Plugin approval required*",
+		resolveSlackPluginDescription(view),
+		"",
+		"*Request*",
+		view.title,
+		...metadataLines
+	].join("\n");
+}
+function buildSlackPendingApprovalText(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginPendingApprovalText(view) : buildSlackExecPendingApprovalText(view);
+}
+function buildSlackExecPendingApprovalBlocks(view) {
+	const interactiveBlocks = resolveSlackReplyBlocks({
+		text: "",
+		presentation: buildApprovalPresentationFromActionDescriptors(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))}`
+			}
+		},
+		...buildSlackMetadataContextBlocks(view.metadata),
+		...interactiveBlocks
+	];
+}
+function buildSlackPluginPendingApprovalBlocks(view) {
+	const interactiveBlocks = resolveSlackReplyBlocks({
+		text: "",
+		presentation: buildApprovalPresentationFromActionDescriptors(view.actions)
+	}) ?? [];
+	return [
+		{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: `*Plugin approval required*\n${truncateSlackMrkdwn(resolveSlackPluginDescription(view), 2600)}`
+			}
+		},
+		...buildSlackPluginRequestBlocks(view),
+		...interactiveBlocks
+	];
+}
+function buildSlackPendingApprovalBlocks(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginPendingApprovalBlocks(view) : buildSlackExecPendingApprovalBlocks(view);
+}
+function buildSlackExecResolvedText(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [
+		`*Exec approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+		resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildSlackPluginResolvedText(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+	return [
+		`*Plugin approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*`,
+		resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved.",
+		"",
+		"*Request*",
+		view.title,
+		...metadataLines
+	].join("\n");
+}
+function buildSlackResolvedText(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginResolvedText(view) : buildSlackExecResolvedText(view);
+}
+function buildSlackExecResolvedBlocks(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 buildSlackPluginResolvedBlocks(view) {
+	const resolvedBy = formatSlackApprover(view.resolvedBy);
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: `*Plugin approval: ${resolveSlackApprovalDecisionLabel(view.decision)}*\n${resolvedBy ? `Resolved by ${resolvedBy}.` : "Resolved."}`
+		}
+	}, ...buildSlackPluginRequestBlocks(view)];
+}
+function buildSlackResolvedBlocks(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginResolvedBlocks(view) : buildSlackExecResolvedBlocks(view);
+}
+function buildSlackExecExpiredText(view) {
+	return [
+		"*Exec approval expired*",
+		"This approval request expired before it was resolved.",
+		"",
+		"*Command*",
+		buildSlackCodeBlock(view.commandText)
+	].join("\n");
+}
+function buildSlackPluginExpiredText(view) {
+	const metadataLines = buildSlackMetadataLines(buildSlackPluginMetadata(view));
+	return [
+		"*Plugin approval expired*",
+		"This approval request expired before it was resolved.",
+		"",
+		"*Request*",
+		view.title,
+		...metadataLines
+	].join("\n");
+}
+function buildSlackExpiredText(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginExpiredText(view) : buildSlackExecExpiredText(view);
+}
+function buildSlackExecExpiredBlocks(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))}`
+		}
+	}];
+}
+function buildSlackPluginExpiredBlocks(view) {
+	return [{
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text: "*Plugin approval expired*\nThis approval request expired before it was resolved."
+		}
+	}, ...buildSlackPluginRequestBlocks(view)];
+}
+function buildSlackExpiredBlocks(view) {
+	return view.approvalKind === "plugin" ? buildSlackPluginExpiredBlocks(view) : buildSlackExecExpiredBlocks(view);
+}
+async function updateMessage(params) {
+	try {
+		await params.client.chat.update({
+			channel: params.channelId,
+			ts: params.messageTs,
+			text: truncateSlackTextByUtf8Bytes(params.text, SLACK_EDIT_TEXT_MAX_BYTES),
+			blocks: params.blocks
+		});
+	} catch (err) {
+		logError(`slack approvals: failed to update message: ${String(err)}`);
+	}
+}
+const slackApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+	eventKinds: ["exec", "plugin"],
+	availability: {
+		isConfigured: (params) => {
+			const resolved = resolveHandlerContext(params);
+			return resolved ? isSlackAnyNativeApprovalClientEnabled({
+				cfg: params.cfg,
+				accountId: resolved.accountId
+			}) : false;
+		},
+		shouldHandle: (params) => {
+			const resolved = resolveHandlerContext(params);
+			if (!resolved) return false;
+			return shouldHandleSlackNativeApprovalRequest({
+				cfg: params.cfg,
+				accountId: resolved.accountId,
+				approvalKind: params.approvalKind,
+				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 }) => {
+			const parsed = parseSlackTarget(plannedTarget.target.to, { defaultKind: "channel" });
+			if (!parsed) throw new Error("Slack approval delivery target is missing");
+			return {
+				dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+				target: {
+					to: `${parsed.kind}:${parsed.id}`,
+					threadTs: plannedTarget.target.threadId != null ? String(plannedTarget.target.threadId) : void 0,
+					teamId: parsed.teamId
+				}
+			};
+		},
+		deliverPending: async ({ cfg, accountId, context, preparedTarget, pendingPayload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return null;
+			const client = resolveApprovalClient(resolved.context, preparedTarget.teamId);
+			const to = await resolveApprovalChannel(client, preparedTarget.to, preparedTarget.teamId);
+			const eventScope = resolveApprovalEventScope(client, preparedTarget.teamId);
+			const message = await sendMessageSlack(to, pendingPayload.text, {
+				cfg,
+				accountId: resolved.accountId,
+				threadTs: preparedTarget.threadTs,
+				blocks: pendingPayload.blocks,
+				client,
+				eventScope
+			});
+			return {
+				channelId: message.channelId,
+				messageTs: message.messageId,
+				teamId: preparedTarget.teamId
+			};
+		},
+		updateEntry: async ({ cfg, accountId, context, entry, payload }) => {
+			const resolved = resolveHandlerContext({
+				cfg,
+				accountId,
+				context
+			});
+			if (!resolved) return;
+			const nextPayload = payload;
+			await updateMessage({
+				client: resolveApprovalClient(resolved.context, entry.teamId),
+				channelId: entry.channelId,
+				messageTs: entry.messageTs,
+				text: nextPayload.text,
+				blocks: nextPayload.blocks
+			});
+		}
+	},
+	observe: { onDeliveryError: ({ error, request }) => {
+		logError(`slack approvals: failed to deliver approval ${request.id}: ${String(error)}`);
+	} }
+});
+function resolveApprovalClient(context, teamId) {
+	if (!teamId) return context.app.client;
+	if (!context.enterprise || !context.resolveClient) throw new Error("Slack Enterprise Grid approval client is unavailable");
+	const client = context.resolveClient(teamId);
+	if (!client) throw new Error("Slack Enterprise Grid approval client is unavailable");
+	return client;
+}
+function resolveApprovalEventScope(client, teamId) {
+	if (!teamId) return;
+	return {
+		teamId,
+		client
+	};
+}
+async function resolveApprovalChannel(client, target, teamId) {
+	if (!teamId) return target;
+	const parsed = parseSlackTarget(target, { defaultKind: "channel" });
+	if (!parsed) throw new Error("Slack approval delivery target is missing");
+	if (parsed.kind === "channel") return `channel:${parsed.id}`;
+	const channelId = normalizeOptionalString((await client.conversations.open({
+		users: parsed.id,
+		return_im: true
+	})).channel?.id);
+	if (!channelId) throw new Error("Slack Enterprise Grid approval DM did not return a channel id");
+	return `channel:${channelId}`;
+}
+//#endregion
+export { slackApprovalNativeRuntime };

package/dist/block-text-YtiNkqmx.js

@@ -0,0 +1,79 @@
+import { F as renderSlackBlockFallbackText } from "./group-policy-c4RP9bjc.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/monitor/block-text.ts
+function readSlackBlockType(block) {
+	return block && typeof block === "object" && !Array.isArray(block) ? block.type : void 0;
+}
+function hasSlackTableBlock(blocks) {
+	return blocks?.some((block) => readSlackBlockType(block) === "table") ?? false;
+}
+function hasSlackMessageTableBlock(message) {
+	return hasSlackTableBlock(message.blocks) || message.attachments?.some((attachment) => !isSlackUnfurlAttachment(attachment) && hasSlackTableBlock(attachment.blocks)) === true;
+}
+function isSlackUnfurlAttachment(attachment) {
+	return attachment.is_msg_unfurl === true || attachment.is_app_unfurl === true || typeof attachment.app_unfurl_url === "string" && attachment.app_unfurl_url.trim().length > 0;
+}
+function resolveSlackBlocksText(blocks) {
+	if (!blocks?.length) return;
+	const parts = [];
+	let hasRichText = false;
+	let hasNativeData = false;
+	for (const block of blocks) {
+		const blockType = readSlackBlockType(block);
+		hasRichText ||= blockType === "rich_text";
+		hasNativeData ||= blockType === "data_visualization" || blockType === "data_table" || blockType === "table";
+		const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+		if (text) parts.push(text);
+	}
+	return parts.length > 0 ? {
+		text: parts.join("\n"),
+		hasRichText,
+		hasNativeData
+	} : void 0;
+}
+function appendDistinctSlackText(base, addition) {
+	if (!base) return addition;
+	const comparableBase = `\n${base.replace(/\r\n?/g, "\n")}\n`;
+	const comparableAddition = `\n${addition.replace(/\r\n?/g, "\n")}\n`;
+	if (comparableBase.includes(comparableAddition)) return base;
+	return `${base}\n${addition}`;
+}
+function resolveSlackAttachmentTableTexts(attachments) {
+	const seen = /* @__PURE__ */ new Set();
+	const texts = [];
+	for (const attachment of attachments ?? []) {
+		if (isSlackUnfurlAttachment(attachment)) continue;
+		for (const block of attachment.blocks ?? []) {
+			if (readSlackBlockType(block) !== "table") continue;
+			const text = renderSlackBlockFallbackText(block, { nativeDataFormat: "plain" });
+			if (!text || seen.has(text)) continue;
+			seen.add(text);
+			texts.push(text);
+		}
+	}
+	return texts;
+}
+/** Resolve agent-visible Slack text while admitting only native tables from attachments. */
+function resolveSlackMessageText(message, options = {}) {
+	let resolved = chooseSlackPrimaryText({
+		messageText: options.preserveMessageTextWhitespace ? typeof message.text === "string" && message.text.trim().length > 0 ? message.text : void 0 : normalizeOptionalString(message.text),
+		blocksText: resolveSlackBlocksText(message.blocks)
+	});
+	for (const tableText of resolveSlackAttachmentTableTexts(message.attachments)) resolved = appendDistinctSlackText(resolved, tableText);
+	return resolved;
+}
+function chooseSlackPrimaryText(params) {
+	const { messageText, blocksText } = params;
+	if (!blocksText) return messageText;
+	if (!messageText) return blocksText.text;
+	if (blocksText.hasNativeData) {
+		const comparableMessageText = messageText.replace(/\s+/g, " ").trim();
+		const comparableBlocksText = blocksText.text.replace(/\s+/g, " ").trim();
+		if (comparableMessageText.includes(comparableBlocksText)) return messageText;
+		return comparableBlocksText.startsWith(comparableMessageText) ? blocksText.text : `${messageText}\n${blocksText.text}`;
+	}
+	if (blocksText.hasRichText && blocksText.text.length > messageText.length) return blocksText.text;
+	return blocksText.text.length > messageText.length && blocksText.text.startsWith(messageText) ? blocksText.text : messageText;
+}
+//#endregion
+export { resolveSlackMessageText as a, resolveSlackBlocksText as i, hasSlackTableBlock as n, isSlackUnfurlAttachment as r, hasSlackMessageTableBlock as t };