@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/replies-4s_Vq_z9.js

@@ -1,457 +0,0 @@
-import { C as hasSlackNativeDataBlock, E as isSlackNativeResponseUrlRejection, L as SLACK_TEXT_LIMIT, T as isSlackInvalidBlocksResponse, f as hasSlackReplyStructuredContent, h as resolveSlackReplyBlocks, j as buildSlackBlocksFallbackText, k as markdownToSlackMrkdwnChunks, m as resolveSlackReplyBlockResolution, x as buildSlackNativeDataAccessibilityText } from "./group-policy-NQZti9t-.js";
-import { d as chunkSlackTextAtHardLimit, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-DsLeZpST.js";
-import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-DmRizMZt.js";
-import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
-import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
-import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
-import { createChannelPartialDeliveryError } from "openclaw/plugin-sdk/channel-inbound";
-import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
-//#region extensions/slack/src/message-sent-hook.ts
-/**
-* Slack-side emission of the `message_sent` plugin hook.
-*
-* Mirrors the Telegram pattern in `extensions/telegram/src/bot/delivery.replies.ts`
-* (`buildTelegramSentHookContext`, `emitMessageSentHooks`, `emitTelegramMessageSentHooks`).
-*
-* Without this, plugins observing `message_sent` see Telegram outbound but not
-* Slack outbound — even though `docs/plugins/hooks.md` documents the hook as
-* firing for all successful outbound deliveries.
-*/
-function buildSlackSentHookContext(params) {
-	return buildCanonicalSentMessageHookContext({
-		to: params.to,
-		content: params.content,
-		success: params.success,
-		error: params.error,
-		channelId: "slack",
-		accountId: params.accountId ?? void 0,
-		conversationId: params.to,
-		sessionKey: params.sessionKeyForInternalHooks,
-		messageId: params.messageId,
-		isGroup: params.isGroup,
-		groupId: params.groupId
-	});
-}
-function emitInternalSlackMessageSentHook(params) {
-	if (!params.sessionKeyForInternalHooks) return;
-	const canonical = buildSlackSentHookContext(params);
-	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
-}
-function emitMessageSentHooks(params) {
-	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
-	const canonical = buildSlackSentHookContext(params);
-	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
-	emitInternalSlackMessageSentHook(params);
-}
-/**
-* Fire both the plugin `message_sent` hook and (if a session key is supplied)
-* the internal `message:sent` hook for a successful or failed Slack outbound
-* delivery.
-*
-* Safe to call after every `chat.postMessage` — the function self-gates on
-* `hookRunner.hasHooks("message_sent")` so plugins not observing the hook
-* incur no cost.
-*/
-function emitSlackMessageSentHooks(params) {
-	const hookRunner = getGlobalHookRunner();
-	emitMessageSentHooks({
-		...params,
-		hookRunner,
-		enabled: hookRunner?.hasHooks("message_sent") ?? false
-	});
-}
-//#endregion
-//#region extensions/slack/src/monitor/replies.ts
-function readSlackReplyBlocks(payload) {
-	return resolveSlackReplyBlocks(payload);
-}
-function resolveSlackMediaHookSpokenText(payload) {
-	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
-}
-function resolveDeliveredSlackReplyThreadTs(params) {
-	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
-}
-async function deliverReplies(params) {
-	let latestResult;
-	const sendReply = async (input) => {
-		return await sendMessageSlack(params.target, input.text, {
-			cfg: params.cfg,
-			token: params.token,
-			threadTs: input.threadTs,
-			accountId: params.accountId,
-			...input.mediaUrl ? { mediaUrl: input.mediaUrl } : {},
-			...input.blocks ? { blocks: input.blocks } : {},
-			...input.authoredTextPlacement ? { authoredTextPlacement: input.authoredTextPlacement } : {},
-			...Object.hasOwn(input, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: input.nativeDataFallbackBaseText } : {},
-			...input.textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
-			...input.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
-			...params.eventScope ? {
-				client: params.eventScope.client,
-				enterpriseEventScope: params.eventScope,
-				textLimit: params.textLimit,
-				...params.mediaMaxBytes !== void 0 ? { mediaMaxBytes: params.mediaMaxBytes } : {}
-			} : {},
-			...params.identity ? { identity: params.identity } : {},
-			...params.metadata ? { metadata: params.metadata } : {}
-		});
-	};
-	for (const payload of params.replies) {
-		if (payload.isReasoning === true) continue;
-		const threadTs = resolveDeliveredSlackReplyThreadTs({
-			replyToMode: params.replyToMode,
-			payloadReplyToId: payload.replyToId,
-			replyThreadTs: params.replyThreadTs
-		});
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
-		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText: !reply.hasMedia && hasSlackReplyStructuredContent(payload) });
-		if (!textRaw && !reply.hasMedia && segments.length === 0) continue;
-		const emitSent = (content, result) => {
-			if (params.deferMessageSentHooks) return;
-			emitSlackMessageSentHooks({
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				to: params.messageSentHookTarget ?? params.target,
-				accountId: params.accountId,
-				content,
-				success: true,
-				messageId: result?.messageId,
-				isGroup: params.isGroup,
-				groupId: params.groupId
-			});
-		};
-		const emitFailed = (content, error) => {
-			if (params.deferMessageSentHooks) return;
-			emitSlackMessageSentHooks({
-				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-				to: params.messageSentHookTarget ?? params.target,
-				accountId: params.accountId,
-				content,
-				success: false,
-				error: formatErrorMessage(error),
-				isGroup: params.isGroup,
-				groupId: params.groupId
-			});
-		};
-		const spokenText = resolveSlackMediaHookSpokenText(payload);
-		const hookParts = [];
-		let outsideText = authoredTextPlacement === "outside-blocks" ? textRaw ?? "" : "";
-		let lastResult;
-		let delivered = false;
-		try {
-			if (reply.hasMedia) {
-				const mediaCaption = outsideText;
-				if (mediaCaption) {
-					hookParts.push(mediaCaption);
-					outsideText = "";
-				} else if (!textRaw && spokenText) hookParts.push(spokenText);
-				const mediaDelivery = await deliverTextOrMediaReply({
-					payload,
-					text: mediaCaption,
-					sendText: async (text) => {
-						lastResult = await sendReply({
-							text,
-							threadTs
-						});
-					},
-					sendMedia: async ({ mediaUrl, caption }) => {
-						lastResult = await sendReply({
-							text: caption ?? "",
-							mediaUrl,
-							threadTs
-						});
-					}
-				});
-				delivered ||= mediaDelivery !== "empty";
-			}
-			for (const segment of segments) {
-				if (segment.kind === "text") {
-					const text = [outsideText, segment.text].filter(Boolean).join("\n\n");
-					outsideText = "";
-					if (!text) continue;
-					hookParts.push(text);
-					for (const chunk of chunkSlackTextAtHardLimit(text)) {
-						lastResult = await sendReply({
-							text: chunk,
-							threadTs,
-							textIsSlackPlainText: true
-						});
-						delivered = true;
-					}
-					continue;
-				}
-				const baseText = outsideText;
-				outsideText = "";
-				const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, segment.blocks) || buildSlackBlocksFallbackText(segment.blocks);
-				hookParts.push(accessibilityText);
-				const segmentPlacement = baseText ? "outside-blocks" : authoredTextPlacement === "blocks" ? "blocks" : "none";
-				lastResult = await sendReply({
-					text: baseText,
-					threadTs,
-					blocks: segment.blocks,
-					authoredTextPlacement: segmentPlacement,
-					...baseText ? { nativeDataFallbackBaseText: baseText } : {}
-				});
-				delivered = true;
-			}
-			if (outsideText && !reply.hasMedia) {
-				hookParts.push(outsideText);
-				lastResult = await sendReply({
-					text: outsideText,
-					threadTs
-				});
-				delivered = true;
-			}
-		} catch (error) {
-			emitFailed(hookParts.join("\n\n") || textRaw || spokenText || "", error);
-			throw error;
-		}
-		if (delivered) {
-			emitSent(hookParts.join("\n\n") || textRaw || spokenText || "", reply.hasMedia ? void 0 : lastResult);
-			latestResult = lastResult;
-			params.runtime.log?.(`delivered reply to ${params.target}`);
-		}
-	}
-	return latestResult;
-}
-/**
-* Compute effective threadTs for a Slack reply based on replyToMode.
-* - "off": stay in thread if already in one, otherwise main channel
-* - "first": first reply goes to thread, subsequent replies to main channel
-* - "all": all replies go to thread
-*/
-function resolveSlackThreadTs(params) {
-	return createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasReplied,
-		isThreadReply: params.isThreadReply
-	}).use();
-}
-function createSlackReplyReferencePlanner(params) {
-	return createReplyReferencePlanner({
-		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode,
-		existingId: params.incomingThreadTs,
-		startId: params.messageTs,
-		hasReplied: params.hasReplied
-	});
-}
-function createSlackReplyDeliveryPlan(params) {
-	const replyReference = createSlackReplyReferencePlanner({
-		replyToMode: params.replyToMode,
-		incomingThreadTs: params.incomingThreadTs,
-		messageTs: params.messageTs,
-		hasReplied: params.hasRepliedRef.value,
-		isThreadReply: params.isThreadReply
-	});
-	return {
-		peekThreadTs: () => replyReference.peek(),
-		nextThreadTs: () => replyReference.use(),
-		markSent: () => {
-			replyReference.markSent();
-			params.hasRepliedRef.value = replyReference.hasReplied();
-		}
-	};
-}
-async function deliverSlackSlashReplies(params) {
-	const deliveries = [];
-	const responseBudget = params.responseBudget ?? createSlackResponseUrlBudget(params.respond);
-	const chunkLimit = Math.max(1, Math.min(params.textLimit, SLACK_TEXT_LIMIT));
-	const createBlockMessagePlan = (input) => {
-		const plan = buildSlackNativeDataDeliveryPlan({
-			blocks: input.blocks,
-			baseText: input.baseText
-		});
-		return {
-			message: {
-				text: plan.accessibilityText,
-				blocks: input.blocks,
-				mrkdwn: false
-			},
-			nativeFallback: plan.fallbackMessages,
-			...plan.skipOriginalBlocks ? { skipOriginalBlocks: true } : {}
-		};
-	};
-	for (const [replyIndex, payload] of params.replies.entries()) {
-		if (payload.isReasoning === true) continue;
-		const reply = resolveSendableOutboundReplyParts(payload);
-		const textRaw = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
-		const { authoredTextPlacement, segments } = resolveSlackReplyBlockResolution(payload, { materializeAuthoredText: hasSlackReplyStructuredContent(payload) });
-		let outsideText = authoredTextPlacement === "outside-blocks" ? textRaw ?? "" : "";
-		const messages = [];
-		const hookParts = [];
-		for (const segment of segments) {
-			if (segment.kind === "text") {
-				const text = [outsideText, segment.text].filter(Boolean).join("\n\n");
-				outsideText = "";
-				if (text) {
-					hookParts.push(text);
-					messages.push(...chunkSlackTextAtHardLimit(text).map((chunk) => ({ message: {
-						text: chunk,
-						mrkdwn: false
-					} })));
-				}
-				continue;
-			}
-			const baseText = outsideText;
-			outsideText = "";
-			const accessibilityText = buildSlackNativeDataAccessibilityText(baseText, segment.blocks) || buildSlackBlocksFallbackText(segment.blocks);
-			hookParts.push(accessibilityText);
-			const blockPlan = createBlockMessagePlan({
-				blocks: segment.blocks,
-				baseText
-			});
-			messages.push(hasSlackNativeDataBlock(segment.blocks) || blockPlan.skipOriginalBlocks ? blockPlan : { message: {
-				text: accessibilityText,
-				blocks: segment.blocks,
-				mrkdwn: false
-			} });
-		}
-		if (outsideText) hookParts.push(outsideText);
-		if (reply.mediaUrls.length > 0) hookParts.push(...reply.mediaUrls);
-		if (segments.length > 0) {
-			const trailingText = [outsideText, ...reply.mediaUrls].filter(Boolean).join("\n");
-			if (trailingText) messages.push(...chunkSlackTextAtHardLimit(trailingText).map((text) => ({ message: {
-				text,
-				mrkdwn: false
-			} })));
-			if (messages.length > 0) deliveries.push({
-				replyIndex,
-				hookContent: hookParts.filter(Boolean).join("\n\n"),
-				messages
-			});
-			continue;
-		}
-		const combined = [textRaw ?? "", ...reply.mediaUrls].filter(Boolean).join("\n");
-		if (!combined) continue;
-		const chunkMode = params.chunkMode ?? "length";
-		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
-		deliveries.push({
-			replyIndex,
-			hookContent: textRaw ?? resolveSlackMediaHookSpokenText(payload) ?? combined,
-			messages: (chunks.length > 0 ? chunks : [combined]).map((text) => ({ message: { text } }))
-		});
-	}
-	const plannedReplyIndexes = new Set(deliveries.map((delivery) => delivery.replyIndex));
-	for (const replyIndex of params.replies.keys()) if (!plannedReplyIndexes.has(replyIndex)) params.onReplySettled?.({
-		replyIndex,
-		visibleReplySent: false
-	});
-	if (deliveries.length === 0) return;
-	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
-	const respond = async (message) => await responseBudget.respond({
-		text: message.text,
-		response_type: responseType,
-		...message.blocks ? { blocks: message.blocks } : {},
-		...message.mrkdwn === false ? { mrkdwn: false } : {}
-	});
-	const emitDeliveryFailure = (delivery, error) => {
-		if (!params.messageSentHookTarget) return;
-		emitSlackMessageSentHooks({
-			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-			to: params.messageSentHookTarget,
-			accountId: params.accountId,
-			content: delivery.hookContent,
-			success: false,
-			error: formatErrorMessage(error),
-			isGroup: params.isGroup,
-			groupId: params.groupId
-		});
-	};
-	const minimumCalls = deliveries.flatMap((delivery) => delivery.messages).map((planned) => planned.nativeFallback?.length ?? 1);
-	const minimumRemainingCalls = Array.from({ length: minimumCalls.length + 1 }, () => 0);
-	for (let index = minimumCalls.length - 1; index >= 0; index -= 1) minimumRemainingCalls[index] = (minimumRemainingCalls[index + 1] ?? 0) + (minimumCalls[index] ?? 0);
-	const failOversizedDelivery = async () => {
-		const message = "Slack response exceeds the remaining response_url delivery budget.";
-		let failure = /* @__PURE__ */ new Error(message);
-		if (responseBudget.remaining() !== 0) try {
-			await responseBudget.respond({
-				text: "This Slack response is too large to deliver within the remaining response window.",
-				response_type: "ephemeral"
-			});
-			failure = new SlackResponseAlreadyReportedError(message);
-		} catch (error) {
-			failure = error;
-		}
-		for (const delivery of deliveries) {
-			emitDeliveryFailure(delivery, failure);
-			params.onReplySettled?.({
-				replyIndex: delivery.replyIndex,
-				visibleReplySent: false,
-				error: failure
-			});
-		}
-		throw failure;
-	};
-	const initialRemaining = responseBudget.remaining();
-	const initialMinimumCalls = minimumCalls.reduce((total, calls) => total + calls, 0);
-	if (initialRemaining !== void 0 && initialMinimumCalls > initialRemaining) await failOversizedDelivery();
-	const deliverNativeFallback = async (messages, onVisible) => {
-		for (const message of messages) {
-			if (await isSlackInvalidBlocksResponse(await respond(message))) throw new Error("Slack rejected the native-data fallback blocks with invalid_blocks.");
-			onVisible();
-		}
-	};
-	let plannedIndex = 0;
-	for (const delivery of deliveries) {
-		let visibleReplySent = false;
-		const markVisible = () => {
-			visibleReplySent = true;
-		};
-		try {
-			for (const planned of delivery.messages) {
-				const minimumAfter = minimumRemainingCalls[plannedIndex + 1] ?? 0;
-				plannedIndex += 1;
-				const fallback = planned.nativeFallback;
-				if (!fallback) {
-					await respond(planned.message);
-					markVisible();
-					continue;
-				}
-				const remaining = responseBudget.remaining();
-				if (!(!planned.skipOriginalBlocks && (remaining === void 0 || 1 + fallback.length + minimumAfter <= remaining))) {
-					await deliverNativeFallback(fallback, markVisible);
-					continue;
-				}
-				let rejectedNativeBlocks = false;
-				try {
-					rejectedNativeBlocks = await isSlackInvalidBlocksResponse(await respond(planned.message));
-					if (!rejectedNativeBlocks) markVisible();
-				} catch (error) {
-					if (!isSlackNativeResponseUrlRejection(error)) throw error;
-					rejectedNativeBlocks = true;
-				}
-				if (rejectedNativeBlocks) await deliverNativeFallback(fallback, markVisible);
-			}
-		} catch (error) {
-			const deliveryError = visibleReplySent ? createChannelPartialDeliveryError(error, {
-				content: delivery.hookContent,
-				visibleReplySent: true
-			}) : error;
-			emitDeliveryFailure(delivery, deliveryError);
-			params.onReplySettled?.({
-				replyIndex: delivery.replyIndex,
-				visibleReplySent,
-				error: deliveryError
-			});
-			throw deliveryError;
-		}
-		if (params.messageSentHookTarget) emitSlackMessageSentHooks({
-			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
-			to: params.messageSentHookTarget,
-			accountId: params.accountId,
-			content: delivery.hookContent,
-			success: true,
-			isGroup: params.isGroup,
-			groupId: params.groupId
-		});
-		params.onReplySettled?.({
-			replyIndex: delivery.replyIndex,
-			visibleReplySent: true
-		});
-	}
-}
-//#endregion
-export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };

package/dist/resolve-channels-yEqmM-3I.js

@@ -1,92 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as createSlackLookupClient } from "./probe-CgDsSops.js";
-import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
-//#region extensions/slack/src/resolve-channels.ts
-var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveSlackChannelAllowlist: () => resolveSlackChannelAllowlist });
-function parseSlackChannelMention(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return {};
-	const mention = trimmed.match(/^<#([A-Z0-9]+)(?:\|([^>]+))?>$/i);
-	if (mention) return {
-		id: mention[1]?.toUpperCase(),
-		name: mention[2]?.trim()
-	};
-	const prefixed = trimmed.replace(/^(slack:|channel:)/i, "");
-	if (/^[CG][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
-	const name = prefixed.replace(/^#/, "").trim();
-	return name ? { name } : {};
-}
-async function listSlackChannels(client) {
-	return collectSlackCursorPages({
-		fetchPage: (cursor) => client.conversations.list({
-			types: "public_channel,private_channel",
-			exclude_archived: false,
-			limit: 1e3,
-			cursor
-		}),
-		collectPageItems: (res) => (res.channels ?? []).map((channel) => {
-			const id = channel.id?.trim();
-			const name = channel.name?.trim();
-			if (!id || !name) return null;
-			return {
-				id,
-				name,
-				archived: Boolean(channel.is_archived),
-				isPrivate: Boolean(channel.is_private)
-			};
-		}).filter(Boolean)
-	});
-}
-function resolveByName(name, channels) {
-	const target = normalizeLowercaseStringOrEmpty(name);
-	if (!target) return;
-	const matches = channels.filter((channel) => normalizeLowercaseStringOrEmpty(channel.name) === target);
-	if (matches.length === 0) return;
-	return matches.find((channel) => !channel.archived) ?? matches[0];
-}
-async function resolveSlackChannelAllowlist(params) {
-	const parsedEntries = params.entries.map((input) => ({
-		input,
-		parsed: parseSlackChannelMention(input)
-	}));
-	if (parsedEntries.every((entry) => Boolean(entry.parsed.id))) return parsedEntries.map(({ input, parsed }) => ({
-		input,
-		resolved: true,
-		id: parsed.id,
-		name: parsed.name
-	}));
-	const channels = await listSlackChannels(params.client ?? createSlackLookupClient(params.token));
-	return resolveDirectoryAllowlistEntries({
-		entries: params.entries,
-		lookup: channels,
-		parseInput: parseSlackChannelMention,
-		findById: (lookup, id) => lookup.find((channel) => channel.id === id),
-		buildIdResolved: ({ input, parsed, match }) => ({
-			input,
-			resolved: true,
-			id: parsed.id,
-			name: match?.name ?? parsed.name,
-			archived: match?.archived
-		}),
-		resolveNonId: ({ input, parsed, lookup }) => {
-			if (!parsed.name) return;
-			const match = resolveByName(parsed.name, lookup);
-			if (!match) return;
-			return {
-				input,
-				resolved: true,
-				id: match.id,
-				name: match.name,
-				archived: match.archived
-			};
-		},
-		buildUnresolved: (input) => ({
-			input,
-			resolved: false
-		})
-	});
-}
-//#endregion
-export { resolve_channels_exports as n, resolveSlackChannelAllowlist as t };

package/dist/resolve-users-BOrt5K-5.js

@@ -1,118 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as createSlackLookupClient } from "./probe-CgDsSops.js";
-import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
-//#region extensions/slack/src/resolve-users.ts
-var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveSlackUserAllowlist: () => resolveSlackUserAllowlist });
-function parseSlackUserInput(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed) return {};
-	const mention = trimmed.match(/^<@([A-Z0-9]+)>$/i);
-	if (mention) return { id: mention[1]?.toUpperCase() };
-	const prefixed = trimmed.replace(/^(slack:|user:)/i, "");
-	if (/^[A-Z][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
-	if (trimmed.includes("@") && !trimmed.startsWith("@")) return { email: normalizeLowercaseStringOrEmpty(trimmed) };
-	const name = trimmed.replace(/^@/, "").trim();
-	return name ? { name } : {};
-}
-async function listSlackUsers(client) {
-	return collectSlackCursorPages({
-		fetchPage: (cursor) => client.users.list({
-			limit: 200,
-			cursor
-		}),
-		collectPageItems: (res) => (res.members ?? []).map((member) => {
-			const id = normalizeOptionalString(member.id);
-			const name = normalizeOptionalString(member.name);
-			if (!id || !name) return null;
-			const profile = member.profile ?? {};
-			return {
-				id,
-				name,
-				displayName: normalizeOptionalString(profile.display_name),
-				realName: normalizeOptionalString(profile.real_name) ?? normalizeOptionalString(member.real_name),
-				email: normalizeOptionalString(profile.email) == null ? void 0 : normalizeLowercaseStringOrEmpty(profile.email),
-				deleted: Boolean(member.deleted),
-				isBot: Boolean(member.is_bot),
-				isAppUser: Boolean(member.is_app_user)
-			};
-		}).filter(Boolean)
-	});
-}
-function scoreSlackUser(user, match) {
-	let score = 0;
-	if (!user.deleted) score += 3;
-	if (!user.isBot && !user.isAppUser) score += 2;
-	if (match.email && user.email === match.email) score += 5;
-	if (match.name) {
-		const target = normalizeLowercaseStringOrEmpty(match.name);
-		if ([
-			user.name,
-			user.displayName,
-			user.realName
-		].map((value) => normalizeLowercaseStringOrEmpty(value)).filter(Boolean).some((value) => value === target)) score += 2;
-	}
-	return score;
-}
-function resolveSlackUserFromMatches(input, matches, parsed) {
-	const best = matches.map((user) => ({
-		user,
-		score: scoreSlackUser(user, parsed)
-	})).toSorted((a, b) => b.score - a.score)[0]?.user ?? matches[0];
-	if (!best) return {
-		input,
-		resolved: false
-	};
-	return {
-		input,
-		resolved: true,
-		id: best.id,
-		name: best.displayName ?? best.realName ?? best.name,
-		email: best.email,
-		deleted: best.deleted,
-		isBot: best.isBot,
-		note: matches.length > 1 ? "multiple matches; chose best" : void 0
-	};
-}
-async function resolveSlackUserAllowlist(params) {
-	const users = await listSlackUsers(params.client ?? createSlackLookupClient(params.token));
-	return resolveDirectoryAllowlistEntries({
-		entries: params.entries,
-		lookup: users,
-		parseInput: parseSlackUserInput,
-		findById: (lookup, id) => lookup.find((user) => user.id === id),
-		buildIdResolved: ({ input, parsed, match }) => ({
-			input,
-			resolved: true,
-			id: parsed.id,
-			name: match?.displayName ?? match?.realName ?? match?.name,
-			email: match?.email,
-			deleted: match?.deleted,
-			isBot: match?.isBot
-		}),
-		resolveNonId: ({ input, parsed, lookup }) => {
-			if (parsed.email) {
-				const matches = lookup.filter((user) => user.email === parsed.email);
-				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
-			}
-			if (parsed.name) {
-				const target = normalizeLowercaseStringOrEmpty(parsed.name);
-				const matches = lookup.filter((user) => {
-					return [
-						user.name,
-						user.displayName,
-						user.realName
-					].map((value) => normalizeLowercaseStringOrEmpty(value)).filter(Boolean).includes(target);
-				});
-				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
-			}
-		},
-		buildUnresolved: (input) => ({
-			input,
-			resolved: false
-		})
-	});
-}
-//#endregion
-export { resolve_users_exports as n, resolveSlackUserAllowlist as t };

package/dist/rolldown-runtime-8H4AJuhK.js

@@ -1,14 +0,0 @@
-import "node:module";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-export { __exportAll as t };

package/dist/runtime-JSVZSWAj.js

@@ -1,8 +0,0 @@
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-//#region extensions/slack/src/runtime.ts
-const { setRuntime: setSlackRuntime, tryGetRuntime: getOptionalSlackRuntime, getRuntime: getSlackRuntime } = createPluginRuntimeStore({
-	pluginId: "slack",
-	errorMessage: "Slack runtime not initialized"
-});
-//#endregion
-export { getSlackRuntime as n, setSlackRuntime as r, getOptionalSlackRuntime as t };