@openclaw/slack 2026.8.1-beta.2 → 2026.9.1-beta.1

package/dist/{actions-BTDXwwE3.js → actions-XdQyjG_p.js}

@@ -1,23 +1,19 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveSlackAccount, f as resolveSlackBotToken } from "./accounts-CK4AVI2_.js";
-import { E as isSlackInvalidBlocksError, K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, M as normalizeSlackOutboundText, N as buildSlackBlocksFallbackText, P as buildSlackCompleteBlocksFallbackText, S as appendSlackNativeDataPlainTextFallback, T as hasSlackNativeDataBlock, W as countSlackTextUtf8Bytes, at as escapeSlackMrkdwn, k as stripSlackNativeDataBlocks, p as assertSlackDetachedTargetAllowed, ut as validateSlackBlocksArray, x as appendSlackNativeDataFallbackText } from "./group-policy-c4RP9bjc.js";
-import { d as getSlackWriteClient, i as createSlackLookupClient } from "./probe-HoEg_WxB.js";
-import { a as resolveSlackMessageText$1, i as resolveSlackBlocksText, n as hasSlackTableBlock, r as isSlackUnfurlAttachment, t as hasSlackMessageTableBlock } from "./block-text-YtiNkqmx.js";
-import { p as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-Nor0iBwY.js";
+import { a as resolveSlackAccount, f as resolveSlackBotToken } from "./accounts-Dm_H77gH.js";
+import { K as truncateSlackTextByUtf8Bytes, L as SLACK_EDIT_TEXT_MAX_BYTES, M as stripSlackNativeDataBlocks, N as buildSlackBlocksFallbackText, O as hasSlackNativeDataBlock, P as buildSlackCompleteBlocksFallbackText, Rt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, T as appendSlackNativeDataPlainTextFallback, W as countSlackTextUtf8Bytes, ct as escapeSlackMrkdwn, g as assertSlackDetachedTargetAllowed, ht as validateSlackBlocksArray, k as isSlackInvalidBlocksError, ot as normalizeSlackOutboundText, w as appendSlackNativeDataFallbackText } from "./group-policy-CU1tEGpS.js";
+import { d as getSlackWriteClient, i as createSlackLookupClient } from "./probe-4_aHtVT3.js";
+import { c as resolveSlackMessageText, i as hasSlackMessageTableBlock, n as fetchWithRuntimeDispatcher, r as saveRemoteMedia, t as isGovSlackClient } from "./slack-client-kind-hSfjXyUM.js";
+import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-DtjEnlLh.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { logVerbose, logVerbose as logVerbose$1 } from "openclaw/plugin-sdk/runtime-env";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { z } from "zod";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import fs from "node:fs/promises";
+import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { normalizeHostname } from "openclaw/plugin-sdk/host-runtime";
 import { resolveRequestUrl } from "openclaw/plugin-sdk/request-url";
-import pMap, { pMapSkip } from "p-map";
-import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
-import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
-import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 //#region extensions/slack/src/edit-text.ts
 function buildSlackEditTextPayload(content, blocks) {
 	const trimmedContent = content.trim();
@@ -49,173 +45,12 @@ function formatSlackFileReferenceList(files) {
 	return files.map((file) => formatSlackFileReference(file)).join(", ");
 }
 //#endregion
-//#region extensions/slack/src/monitor/thread.ts
-const THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
-const THREAD_STARTER_CACHE_TTL_MS = 360 * 6e4;
-const THREAD_STARTER_CACHE_MAX = 2e3;
-function evictThreadStarterCache() {
-	const now = asDateTimestampMs(Date.now());
-	if (now === void 0) {
-		THREAD_STARTER_CACHE.clear();
-		return;
-	}
-	for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) if (asDateTimestampMs(entry.expiresAt) === void 0 || entry.expiresAt <= now) THREAD_STARTER_CACHE.delete(cacheKey);
-	pruneMapToMaxSize(THREAD_STARTER_CACHE, THREAD_STARTER_CACHE_MAX);
-}
-function formatSlackFilePlaceholder(files) {
-	return `[attached: ${formatSlackFileReferenceList(files)}]`;
-}
-function pushUniqueText(parts, value, options = {}) {
-	const text = options.preserveWhitespace ? typeof value === "string" && value.trim().length > 0 ? value : void 0 : normalizeOptionalString(value);
-	if (text && !parts.includes(text)) parts.push(text);
-}
-function resolveSlackBlocksFallbackText(blocks) {
-	return resolveSlackBlocksText(blocks)?.text;
-}
-function resolveSlackAttachmentFallbackText(attachments) {
-	if (!Array.isArray(attachments) || attachments.length === 0) return;
-	const parts = [];
-	for (const attachment of attachments) {
-		const excludeTableBlocks = isSlackUnfurlAttachment(attachment);
-		const fallbackBlocks = (blocks) => excludeTableBlocks ? blocks?.filter((block) => !hasSlackTableBlock([block])) : blocks;
-		pushUniqueText(parts, attachment.pretext);
-		pushUniqueText(parts, attachment.title);
-		pushUniqueText(parts, attachment.text);
-		if (!(hasSlackTableBlock(attachment.blocks) && normalizeOptionalString(attachment.fallback) === "[no preview available]")) pushUniqueText(parts, attachment.fallback);
-		for (const field of attachment.fields ?? []) {
-			pushUniqueText(parts, field.title);
-			pushUniqueText(parts, field.value);
-		}
-		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.blocks)), { preserveWhitespace: true });
-		pushUniqueText(parts, resolveSlackBlocksFallbackText(fallbackBlocks(attachment.message_blocks)), { preserveWhitespace: true });
-	}
-	return parts.length > 0 ? parts.join("\n") : void 0;
-}
-function resolveSlackMessageText(message) {
-	const messageText = normalizeOptionalString(message.text) ?? resolveSlackAttachmentFallbackText(message.attachments);
-	return resolveSlackMessageText$1({
-		...message,
-		text: messageText
-	}, { preserveMessageTextWhitespace: true });
-}
-async function resolveSlackThreadStarter(params) {
-	evictThreadStarterCache();
-	const cacheKey = JSON.stringify([
-		params.workspaceScope.accountId,
-		params.workspaceScope.teamId,
-		params.channelId,
-		params.threadTs
-	]);
-	const cached = THREAD_STARTER_CACHE.get(cacheKey);
-	if (cached) {
-		const now = asDateTimestampMs(Date.now());
-		if (now !== void 0 && cached.expiresAt > now) return cached.value;
-		THREAD_STARTER_CACHE.delete(cacheKey);
-	}
-	try {
-		const message = (await params.client.conversations.replies({
-			channel: params.channelId,
-			ts: params.threadTs,
-			limit: 1,
-			inclusive: true
-		}))?.messages?.[0];
-		const text = message ? resolveSlackMessageText(message) : void 0;
-		const files = message?.files?.length ? message.files : void 0;
-		if (!message || !text && !files) return null;
-		const starter = {
-			text: text || formatSlackFilePlaceholder(files),
-			userId: message.user,
-			botId: message.bot_id,
-			ts: message.ts,
-			files
-		};
-		const expiresAt = resolveExpiresAtMsFromDurationMs(THREAD_STARTER_CACHE_TTL_MS);
-		if (expiresAt !== void 0) {
-			if (THREAD_STARTER_CACHE.has(cacheKey)) THREAD_STARTER_CACHE.delete(cacheKey);
-			THREAD_STARTER_CACHE.set(cacheKey, {
-				value: starter,
-				expiresAt
-			});
-			evictThreadStarterCache();
-		}
-		return starter;
-	} catch (err) {
-		logVerbose$1(`slack thread starter fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
-		return null;
-	}
-}
-function resetSlackThreadStarterCacheForTest() {
-	THREAD_STARTER_CACHE.clear();
-}
-const SLACK_THREAD_HISTORY_MAX_PAGES = 3;
-/**
-* Fetches the most recent messages in a Slack thread (excluding the current message).
-* Used to populate thread context when a new thread session starts.
-*
-* Uses cursor pagination and keeps only the latest N retained messages when the full
-* thread fits in the bounded fetch window.
-*/
-async function resolveSlackThreadHistory(params) {
-	const maxMessages = params.limit ?? 20;
-	if (!Number.isFinite(maxMessages) || maxMessages <= 0) return [];
-	const fetchLimit = 200;
-	const retained = [];
-	let cursor;
-	let pagesFetched = 0;
-	try {
-		do {
-			pagesFetched += 1;
-			const response = await params.client.conversations.replies({
-				channel: params.channelId,
-				ts: params.threadTs,
-				limit: fetchLimit,
-				inclusive: true,
-				...cursor ? { cursor } : {}
-			});
-			for (const msg of response.messages ?? []) {
-				if (!resolveSlackMessageText(msg) && !msg.files?.length) continue;
-				if (params.currentMessageTs && msg.ts === params.currentMessageTs) continue;
-				retained.push(msg);
-			}
-			if (retained.length > maxMessages) retained.splice(0, retained.length - maxMessages);
-			const next = response.response_metadata?.next_cursor;
-			cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : void 0;
-		} while (cursor && pagesFetched < SLACK_THREAD_HISTORY_MAX_PAGES);
-		if (cursor) {
-			logVerbose$1(`slack thread history capped channel=${params.channelId} ts=${params.threadTs} pages=${SLACK_THREAD_HISTORY_MAX_PAGES}`);
-			return [];
-		}
-		return retained.map((msg) => ({
-			text: resolveSlackMessageText(msg) ?? formatSlackFilePlaceholder(msg.files),
-			userId: msg.user,
-			botId: msg.bot_id,
-			ts: msg.ts,
-			files: msg.files
-		}));
-	} catch (err) {
-		logVerbose$1(`slack thread history fetch failed channel=${params.channelId} ts=${params.threadTs}: ${formatErrorMessage(err)}`);
-		return [];
-	}
-}
-//#endregion
 //#region extensions/slack/src/monitor/media.ts
 var media_exports = /* @__PURE__ */ __exportAll({
 	SLACK_MEDIA_READ_IDLE_TIMEOUT_MS: () => SLACK_MEDIA_READ_IDLE_TIMEOUT_MS,
-	resetSlackThreadStarterCacheForTest: () => resetSlackThreadStarterCacheForTest,
 	resolveSlackAttachmentContent: () => resolveSlackAttachmentContent,
-	resolveSlackMedia: () => resolveSlackMedia,
-	resolveSlackThreadHistory: () => resolveSlackThreadHistory,
-	resolveSlackThreadStarter: () => resolveSlackThreadStarter
+	resolveSlackMedia: () => resolveSlackMedia
 });
-function isGovSlackClient(client) {
-	if (!client?.slackApiUrl) return false;
-	try {
-		const apiUrl = new URL(client.slackApiUrl);
-		return apiUrl.protocol === "https:" && !apiUrl.port && normalizeHostname(apiUrl.hostname) === "slack-gov.com";
-	} catch {
-		return false;
-	}
-}
 function isSlackHostname(hostname, govSlack) {
 	const normalized = normalizeHostname(hostname);
 	if (!normalized) return false;
@@ -349,6 +184,10 @@ async function fetchFreshSlackFileUrl(params) {
 	if (!params.file.id || !params.client) return null;
 	try {
 		const freshFile = (await params.client.files.info({ file: params.file.id })).file;
+		if (freshFile && params.isRefreshedFileAllowed?.(freshFile) === false) {
+			logVerbose$1(`slack: refreshed file metadata rejected for file id=${params.file.id}`);
+			return null;
+		}
 		const freshUrl = freshFile?.url_private_download ?? freshFile?.url_private;
 		if (freshUrl) {
 			logVerbose$1(`slack: refreshed file URL via files.info for file id=${params.file.id}`);
@@ -391,6 +230,7 @@ async function downloadSlackMediaFile(params) {
 	return {
 		path: saved.path,
 		...contentType ? { contentType } : {},
+		...label ? { fileName: label } : {},
 		placeholder: `[Slack file: ${formatSlackFileReference({
 			...params.file,
 			name: label
@@ -418,56 +258,88 @@ function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 async function resolveSlackMedia(params) {
 	const govSlack = isGovSlackClient(params.client);
 	const files = params.files ?? [];
-	const resolved = await pMap(files.length > 8 ? files.slice(0, 8) : files, async (file) => {
-		const preloaded = params.preloadedMedia?.get(file);
-		if (preloaded) return preloaded;
-		const eventUrl = file.url_private_download ?? file.url_private;
-		const url = eventUrl ?? await fetchFreshSlackFileUrl({
-			file,
-			client: params.client
-		});
-		if (!url) return pMapSkip;
-		const result = await downloadSlackMediaFile({
-			file,
-			url,
-			token: params.token,
-			maxBytes: params.maxBytes,
-			readIdleTimeoutMs: params.readIdleTimeoutMs,
-			totalTimeoutMs: params.totalTimeoutMs,
-			abortSignal: params.abortSignal,
-			govSlack
-		}).catch(() => null);
-		if (result || !eventUrl) return result ?? pMapSkip;
-		const freshUrl = await fetchFreshSlackFileUrl({
-			file,
-			client: params.client
-		});
-		if (!freshUrl) return pMapSkip;
-		return await downloadSlackMediaFile({
-			file,
-			url: freshUrl,
-			token: params.token,
-			maxBytes: params.maxBytes,
-			readIdleTimeoutMs: params.readIdleTimeoutMs,
-			totalTimeoutMs: params.totalTimeoutMs,
-			abortSignal: params.abortSignal,
-			govSlack
-		}).catch(() => null) ?? pMapSkip;
-	}, {
-		concurrency: MAX_SLACK_MEDIA_CONCURRENCY,
-		stopOnError: true
+	const limitedFiles = files.length > 8 ? files.slice(0, 8) : files;
+	const refreshFileUrl = (file) => fetchFreshSlackFileUrl({
+		file,
+		client: params.client,
+		isRefreshedFileAllowed: params.isRefreshedFileAllowed
+	});
+	const { results } = await runTasksWithConcurrency({
+		tasks: limitedFiles.map((file) => async () => {
+			const preloaded = params.preloadedMedia?.get(file);
+			if (preloaded) return preloaded;
+			const eventUrl = file.url_private_download ?? file.url_private;
+			const url = eventUrl ?? await refreshFileUrl(file);
+			if (!url) return null;
+			const result = await downloadSlackMediaFile({
+				file,
+				url,
+				token: params.token,
+				maxBytes: params.maxBytes,
+				readIdleTimeoutMs: params.readIdleTimeoutMs,
+				totalTimeoutMs: params.totalTimeoutMs,
+				abortSignal: params.abortSignal,
+				govSlack
+			}).catch(() => null);
+			if (result || !eventUrl) return result;
+			const freshUrl = await refreshFileUrl(file);
+			if (!freshUrl) return null;
+			return await downloadSlackMediaFile({
+				file,
+				url: freshUrl,
+				token: params.token,
+				maxBytes: params.maxBytes,
+				readIdleTimeoutMs: params.readIdleTimeoutMs,
+				totalTimeoutMs: params.totalTimeoutMs,
+				abortSignal: params.abortSignal,
+				govSlack
+			}).catch(() => null);
+		}),
+		limit: MAX_SLACK_MEDIA_CONCURRENCY,
+		errorMode: "stop",
+		throwOnError: true
+	});
+	const resolved = results.filter((result, index) => {
+		if (result) params.resolvedFiles?.add(limitedFiles[index]);
+		return result !== null;
 	});
 	return resolved.length > 0 ? resolved : null;
 }
 /** Extracts text and media from forwarded-message attachments. Returns null when empty. */
 async function resolveSlackAttachmentContent(params) {
-	const attachments = params.attachments;
-	if (!attachments || attachments.length === 0) return null;
-	const forwardedAttachments = attachments.filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
-	if (forwardedAttachments.length === 0) return null;
+	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => isForwardedSlackAttachment(attachment)).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
+	const candidates = [...params.files ?? [], ...forwardedAttachments.flatMap((attachment) => attachment.files ?? [])];
+	if (forwardedAttachments.length === 0 && candidates.length === 0) return null;
+	const fileIds = /* @__PURE__ */ new Set();
+	const allFiles = candidates.filter((file) => {
+		const fileId = normalizeOptionalString(file.id);
+		if (!fileId) return true;
+		if (fileIds.has(fileId)) return false;
+		fileIds.add(fileId);
+		return true;
+	}).slice(0, 8).map((file) => {
+		const fileId = normalizeOptionalString(file.id);
+		const preloaded = fileId && candidates.find((candidate) => normalizeOptionalString(candidate.id) === fileId && params.preloadedMedia?.has(candidate));
+		if (preloaded) return preloaded;
+		if (!fileId || file.url_private_download || file.url_private) return file;
+		const downloadable = candidates.find((candidate) => normalizeOptionalString(candidate.id) === fileId && (candidate.url_private_download || candidate.url_private));
+		return downloadable ? Object.assign({}, file, downloadable) : file;
+	});
+	const pendingFiles = new Map(allFiles.map((file) => [normalizeOptionalString(file.id) ?? file, file]));
+	const resolvedFiles = /* @__PURE__ */ new Set();
+	const resolveFiles = (files) => resolveSlackMedia({
+		...params,
+		resolvedFiles,
+		files: files?.flatMap((file) => {
+			const key = normalizeOptionalString(file.id) ?? file;
+			const selected = pendingFiles.get(key);
+			pendingFiles.delete(key);
+			return selected ? [selected] : [];
+		})
+	});
+	const directMediaPromise = resolveFiles(params.files);
 	const textBlocks = [];
-	const allMedia = [];
-	const allFiles = forwardedAttachments.flatMap((attachment) => attachment.files ?? []);
+	const attachmentMedia = [];
 	let unavailableImageCount = 0;
 	const govSlack = isGovSlackClient(params.client);
 	for (const att of forwardedAttachments) {
@@ -493,41 +365,51 @@ async function resolveSlackAttachmentContent(params) {
 				abortSignal: params.abortSignal
 			});
 			const label = saved.fileName ?? "forwarded image";
-			allMedia.push({
+			attachmentMedia.push({
 				path: saved.path,
 				contentType: saved.contentType,
+				...saved.fileName ? { fileName: saved.fileName } : {},
 				placeholder: `[Forwarded image: ${label}]`
 			});
 		} catch {
 			unavailableImageCount += 1;
 		}
-		if (att.files && att.files.length > 0) {
-			const fileMedia = await resolveSlackMedia({
-				files: att.files,
-				client: params.client,
-				token: params.token,
-				maxBytes: params.maxBytes,
-				readIdleTimeoutMs: params.readIdleTimeoutMs,
-				totalTimeoutMs: params.totalTimeoutMs,
-				abortSignal: params.abortSignal
-			});
-			if (fileMedia) allMedia.push(...fileMedia);
-		}
+		attachmentMedia.push(...await resolveFiles(att.files) ?? []);
 	}
+	const allMedia = [...await directMediaPromise ?? [], ...attachmentMedia];
+	const unavailableFiles = allFiles.filter((file) => !resolvedFiles.has(file));
 	const combinedText = textBlocks.join("\n\n");
 	if (!combinedText && allMedia.length === 0 && allFiles.length === 0 && unavailableImageCount === 0) return null;
 	return {
 		text: combinedText,
 		media: allMedia,
 		unavailableImageCount,
-		...allFiles.length > 0 ? { files: allFiles } : {}
+		...unavailableFiles.length > 0 ? { files: unavailableFiles } : {}
 	};
 }
 //#endregion
 //#region extensions/slack/src/actions.ts
+var actions_exports = /* @__PURE__ */ __exportAll({
+	deleteSlackMessage: () => deleteSlackMessage,
+	downloadSlackFile: () => downloadSlackFile,
+	editSlackMessage: () => editSlackMessage,
+	editSlackRenderedMessage: () => editSlackRenderedMessage,
+	getSlackMemberInfo: () => getSlackMemberInfo,
+	listSlackEmojis: () => listSlackEmojis,
+	listSlackPins: () => listSlackPins,
+	listSlackReactions: () => listSlackReactions,
+	pinSlackMessage: () => pinSlackMessage,
+	reactSlackMessage: () => reactSlackMessage,
+	readSlackMessages: () => readSlackMessages,
+	removeOwnSlackReactions: () => removeOwnSlackReactions,
+	removeSlackReaction: () => removeSlackReaction,
+	resolveSlackConversationName: () => resolveSlackConversationName,
+	sendSlackMessage: () => sendSlackMessage,
+	unpinSlackMessage: () => unpinSlackMessage
+});
 function renderSlackReadMessageText(message) {
 	if (!hasSlackMessageTableBlock(message)) return message;
-	const text = resolveSlackMessageText$1(message, { preserveMessageTextWhitespace: true });
+	const text = resolveSlackMessageText(message, { preserveMessageTextWhitespace: true });
 	return text && text !== message.text ? {
 		...message,
 		text
@@ -691,6 +573,7 @@ async function listSlackReactions(channelId, messageId, opts = {}) {
 	})).message?.reactions ?? [];
 }
 async function sendSlackMessage(to, content, opts) {
+	const onDeliveryResult = Object.getOwnPropertyDescriptor(opts, SLACK_PRIVATE_ACTION_DELIVERY_RESULT)?.value;
 	return await sendMessageSlack(to, content, {
 		accountId: opts.accountId,
 		cfg: opts.cfg,
@@ -709,6 +592,7 @@ async function sendSlackMessage(to, content, opts) {
 		...Object.hasOwn(opts, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: opts.nativeDataFallbackBaseText } : {},
 		...opts.uploadFileName ? { uploadFileName: opts.uploadFileName } : {},
 		...opts.uploadTitle ? { uploadTitle: opts.uploadTitle } : {},
+		...typeof onDeliveryResult === "function" ? { onDeliveryResult } : {},
 		blocks: opts.blocks
 	});
 }
@@ -842,48 +726,34 @@ function collectSlackShareMaps(file) {
 	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 = normalizeOptionalString(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;
+function collectSlackShares(file) {
+	const shares = [];
+	for (const shareMap of collectSlackShareMaps(file)) for (const [rawChannelId, rawEntries] of Object.entries(shareMap)) {
+		const channelId = normalizeOptionalString(rawChannelId);
+		if (!channelId || !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" ? normalizeOptionalString(entry.ts) : void 0;
 			const threadTs = typeof entry.thread_ts === "string" ? normalizeOptionalString(entry.thread_ts) : void 0;
-			matches.push({
+			if (ts || threadTs) shares.push({
 				channelId,
 				ts,
 				threadTs
 			});
 		}
 	}
-	return matches;
+	return shares;
 }
-function hasSlackScopeMismatch(params) {
+function lacksSlackScopeProof(params) {
 	const channelId = normalizeOptionalString(params.channelId);
-	if (!channelId) return false;
+	if (!channelId) return true;
 	const threadId = normalizeOptionalString(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;
+	const shares = collectSlackShares(params.file);
+	if (!(directIds.has(channelId) || shares.some((entry) => entry.channelId === channelId))) 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);
+	return !shares.some((entry) => entry.channelId === channelId && (entry.threadTs === threadId || entry.ts === threadId));
 }
 /**
 * Downloads a Slack file by ID and saves it to the local media store.
@@ -893,13 +763,14 @@ function hasSlackScopeMismatch(params) {
 async function downloadSlackFile(fileId, opts) {
 	const token = resolveToken(opts.token, opts.accountId, opts.cfg);
 	const client = await getClient(opts);
-	const file = (await client.files.info({ file: fileId })).file;
-	if (!file?.url_private_download && !file?.url_private) return null;
-	if (hasSlackScopeMismatch({
+	const isFileAllowed = (file) => !lacksSlackScopeProof({
 		file,
 		channelId: opts.channelId,
 		threadId: opts.threadId
-	})) return null;
+	});
+	const file = (await client.files.info({ file: fileId })).file;
+	if (!file?.url_private_download && !file?.url_private) return null;
+	if (!isFileAllowed(file)) return null;
 	return (await resolveSlackMedia({
 		files: [{
 			id: file.id,
@@ -909,9 +780,10 @@ async function downloadSlackFile(fileId, opts) {
 			url_private_download: file.url_private_download
 		}],
 		client,
+		isRefreshedFileAllowed: isFileAllowed,
 		token,
 		maxBytes: opts.maxBytes
 	}))?.[0] ?? null;
 }
 //#endregion
-export { media_exports as _, getSlackMemberInfo as a, formatSlackFileReference as b, listSlackReactions as c, readSlackMessages as d, removeOwnSlackReactions as f, unpinSlackMessage as g, sendSlackMessage as h, editSlackRenderedMessage as i, pinSlackMessage as l, resolveSlackConversationName as m, downloadSlackFile as n, listSlackEmojis as o, removeSlackReaction as p, editSlackMessage as r, listSlackPins as s, deleteSlackMessage as t, reactSlackMessage as u, resolveSlackThreadHistory as v, buildSlackEditTextPayload as x, resolveSlackThreadStarter as y };
+export { media_exports as _, editSlackRenderedMessage as a, formatSlackFileReferenceList as b, listSlackPins as c, reactSlackMessage as d, readSlackMessages as f, unpinSlackMessage as g, sendSlackMessage as h, editSlackMessage as i, listSlackReactions as l, removeSlackReaction as m, deleteSlackMessage as n, getSlackMemberInfo as o, removeOwnSlackReactions as p, downloadSlackFile as r, listSlackEmojis as s, actions_exports as t, pinSlackMessage as u, logVerbose$1 as v, buildSlackEditTextPayload as x, formatSlackFileReference as y };

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-CK4AVI2_.js";
-import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { t as inspectSlackAccount } from "./account-inspect-Drw2gAiN.js";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-Dm_H77gH.js";
+import { r as resolveSlackReplyToMode } from "./conversation-binding-route-DFVLUdYF.js";
+import { t as inspectSlackAccount } from "./account-inspect-CN2hBsim.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-CDNvBXUi.js";
+import { H as buildSlackPresentationBlocks, V as buildSlackInteractiveBlocks, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, h as resolveSlackUserAllowed, ht as validateSlackBlocksArray, i as resolveSlackGroupToolPolicy, l as normalizeAllowList, mt as parseSlackBlocksInput, p as resolveSlackAllowListMatch, pt as SLACK_MAX_BLOCKS, r as resolveSlackGroupRequireMention, u as normalizeAllowListLower, zt as resolveSlackAutoThreadId } from "./group-policy-CU1tEGpS.js";
+import { n as buildSlackThreadingToolContext, t as slackPlugin } from "./channel-C_vnTgxo.js";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-CWosHSi5.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-4_aHtVT3.js";
+import { n as resolveSlackChannelType } from "./channel-type-j-2lalcC.js";
+import { t as slackSetupPlugin } from "./channel.setup-aal8tokM.js";
+import { c as listSlackPins, d as reactSlackMessage, f as readSlackMessages, g as unpinSlackMessage, h as sendSlackMessage, i as editSlackMessage, l as listSlackReactions, m as removeSlackReaction, n as deleteSlackMessage, o as getSlackMemberInfo, p as removeOwnSlackReactions, r as downloadSlackFile, s as listSlackEmojis, u as pinSlackMessage } from "./actions-XdQyjG_p.js";
+import { f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, s as clearSlackThreadParticipationCache } from "./send-DtjEnlLh.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-DqfQ42OV.js";
+import { t as collectSlackSecurityAuditFindings } from "./security-audit-B_yKr7MW.js";
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-D4nDgxCh.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 };