@openclaw/slack 2026.8.1-beta.3 → 2026.8.1

package/dist/{actions-DFk0ANVB.js → actions-BI7JkfVm.js}

@@ -1,12 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveSlackAccount, f as resolveSlackBotToken } from "./accounts-BlzxuYle.js";
-import { B as SLACK_EDIT_TEXT_MAX_BYTES, F as normalizeSlackOutboundText, I as buildSlackBlocksFallbackText, L as buildSlackCompleteBlocksFallbackText, Lt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, M as stripSlackNativeDataBlocks, O as hasSlackNativeDataBlock, T as appendSlackNativeDataPlainTextFallback, Y as truncateSlackTextByUtf8Bytes, ct as escapeSlackMrkdwn, g as assertSlackDetachedTargetAllowed, k as isSlackInvalidBlocksError, mt as validateSlackBlocksArray, q as countSlackTextUtf8Bytes, w as appendSlackNativeDataFallbackText } from "./group-policy-DyfB_ZIE.js";
-import { d as getSlackWriteClient, i as createSlackLookupClient } from "./probe-BVA65leh.js";
-import { c as resolveSlackMessageText, i as hasSlackMessageTableBlock, n as fetchWithRuntimeDispatcher, r as saveRemoteMedia, t as isGovSlackClient } from "./slack-client-kind-BXyOOICI.js";
-import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-CtnOxKCc.js";
+import { a as resolveSlackAccount, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId } from "./accounts-Dm_H77gH.js";
+import { n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { At as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, D as renderSlackBlockFallbackText, E as buildSlackCompleteBlocksFallbackText, I as countSlackTextUtf8Bytes, Q as normalizeSlackOutboundText, R as truncateSlackTextByUtf8Bytes, T as buildSlackBlocksFallbackText, _ as appendSlackNativeDataPlainTextFallback, b as hasSlackNativeDataBlock, c as assertSlackDetachedTargetAllowed, et as escapeSlackMrkdwn, g as appendSlackNativeDataFallbackText, k as SLACK_EDIT_TEXT_MAX_BYTES, st as validateSlackBlocksArray, w as stripSlackNativeDataBlocks, x as isSlackInvalidBlocksError } from "./group-policy-BdwszjYn.js";
+import { S as getSlackWriteClient, h as createSlackLookupClient } from "./probe-0usmAb0i.js";
+import { m as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack } from "./send-DS9ICrBI.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 { createSubsystemLogger, logVerbose, logVerbose as logVerbose$1 } from "openclaw/plugin-sdk/runtime-env";
+import { resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { redactToolPayloadText } from "openclaw/plugin-sdk/logging-core";
 import { z } from "zod";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
 import fs from "node:fs/promises";
@@ -14,6 +16,31 @@ 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 { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
+import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
+//#region extensions/slack/src/conversation-open.ts
+function parseSlackConversationOpenInput(userIds, teamId) {
+	const users = z.array(z.string().trim().regex(/^[UW][A-Z0-9]+$/)).min(1).max(8).parse(userIds);
+	if (new Set(users).size !== users.length) throw new Error("Slack conversation-open requires distinct userIds.");
+	return {
+		users,
+		teamId: teamId === void 0 ? void 0 : z.string().trim().regex(/^T[A-Z0-9]+$/i).parse(teamId)
+	};
+}
+async function openSlackConversationWithClient(client, input) {
+	const channelId = (await client.conversations.open({ users: input.users.join(",") })).channel?.id?.trim();
+	if (!channelId || !/^[CDG][A-Z0-9]+$/i.test(channelId)) throw new Error("Slack conversations.open did not return a valid conversation ID.");
+	return {
+		channelId,
+		target: formatSlackTarget({
+			teamId: input.teamId,
+			kind: "channel",
+			id: channelId,
+			explicitKind: true
+		})
+	};
+}
+//#endregion
 //#region extensions/slack/src/edit-text.ts
 function buildSlackEditTextPayload(content, blocks) {
 	const trimmedContent = content.trim();
@@ -27,6 +54,85 @@ function buildSlackEditTextPayload(content, blocks) {
 	return " ";
 }
 //#endregion
+//#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",
+			nativeReferenceFormat: "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
 //#region extensions/slack/src/file-reference.ts
 function formatSlackFileReference(file) {
 	const name = normalizeOptionalString(file?.name) ?? "file";
@@ -45,6 +151,21 @@ function formatSlackFileReferenceList(files) {
 	return files.map((file) => formatSlackFileReference(file)).join(", ");
 }
 //#endregion
+//#region extensions/slack/src/monitor/media.runtime.ts
+const slackMediaLog = createSubsystemLogger("gateway/channels/slack").child("media");
+//#endregion
+//#region extensions/slack/src/monitor/slack-client-kind.ts
+/** Detects the isolated GovSlack API plane without consulting mutable config. */
+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;
+	}
+}
+//#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,
@@ -180,10 +301,18 @@ async function looksLikeHtmlFile(filePath) {
 }
 const MAX_SLACK_MEDIA_CONCURRENCY = 3;
 const MAX_SLACK_FORWARDED_ATTACHMENTS = 8;
+const SLACK_MEDIA_LIMIT_REASON = `omitted: 8-file limit`;
+function formatSlackMediaFailure(error) {
+	return redactToolPayloadText(formatErrorMessage(error)).replace(/\s+/g, " ").slice(0, 200);
+}
 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}`);
@@ -217,7 +346,7 @@ async function downloadSlackMediaFile(params) {
 	if (!(fileMime === "text/html" || fileName.endsWith(".html") || fileName.endsWith(".htm"))) {
 		if (normalizeOptionalLowercaseString(saved.contentType?.split(";")[0]) === "text/html" || await looksLikeHtmlFile(saved.path)) {
 			await fs.rm(saved.path, { force: true }).catch(() => void 0);
-			return null;
+			throw new Error("blocked: unexpected HTML content");
 		}
 	}
 	const effectiveMime = resolveSlackMediaMimetype(params.file, saved.contentType);
@@ -226,6 +355,7 @@ async function downloadSlackMediaFile(params) {
 	return {
 		path: saved.path,
 		...contentType ? { contentType } : {},
+		...label ? { fileName: label } : {},
 		placeholder: `[Slack file: ${formatSlackFileReference({
 			...params.file,
 			name: label
@@ -253,42 +383,36 @@ function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 async function resolveSlackMedia(params) {
 	const govSlack = isGovSlackClient(params.client);
 	const files = params.files ?? [];
+	const limitedFiles = files.length > 8 ? files.slice(0, 8) : files;
+	for (const file of files.slice(8)) params.unavailableFiles?.set(file, SLACK_MEDIA_LIMIT_REASON);
+	const refreshFileUrl = (file) => fetchFreshSlackFileUrl({
+		file,
+		client: params.client,
+		isRefreshedFileAllowed: params.isRefreshedFileAllowed
+	});
 	const { results } = await runTasksWithConcurrency({
-		tasks: (files.length > 8 ? files.slice(0, 8) : files).map((file) => async () => {
+		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 fetchFreshSlackFileUrl({
-				file,
-				client: params.client
-			});
-			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 fetchFreshSlackFileUrl({
-				file,
-				client: params.client
-			});
-			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);
+			let url = eventUrl ?? await refreshFileUrl(file);
+			let reason = "no private download URL";
+			for (let attempt = 0; url && attempt < 2; attempt += 1) {
+				try {
+					return await downloadSlackMediaFile({
+						...params,
+						file,
+						url,
+						govSlack
+					});
+				} catch (error) {
+					reason = formatSlackMediaFailure(error);
+				}
+				url = attempt === 0 && eventUrl ? await refreshFileUrl(file) : null;
+			}
+			params.unavailableFiles?.set(file, reason);
+			slackMediaLog.warn(`slack: file ${formatSlackFileReference(file)} unavailable (${reason})`);
+			return null;
 		}),
 		limit: MAX_SLACK_MEDIA_CONCURRENCY,
 		errorMode: "stop",
@@ -299,14 +423,41 @@ async function resolveSlackMedia(params) {
 }
 /** 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;
+	}).map((file, index) => {
+		if (index >= 8) return 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.slice(0, 8).map((file) => [normalizeOptionalString(file.id) ?? file, file]));
+	const unavailableFileReasons = /* @__PURE__ */ new Map();
+	const resolveFiles = (files) => resolveSlackMedia({
+		...params,
+		unavailableFiles: unavailableFileReasons,
+		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 ?? []);
-	let unavailableImageCount = 0;
+	const attachmentMedia = [];
+	let unavailableMediaCount = 0;
 	const govSlack = isGovSlackClient(params.client);
 	for (const att of forwardedAttachments) {
 		const text = att.text?.trim() || att.fallback?.trim();
@@ -331,38 +482,57 @@ 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);
+		} catch (error) {
+			unavailableMediaCount += 1;
+			slackMediaLog.warn(`slack: forwarded image unavailable (${formatSlackMediaFailure(error)})`);
 		}
+		attachmentMedia.push(...await resolveFiles(att.files) ?? []);
 	}
+	const allMedia = [...await directMediaPromise ?? [], ...attachmentMedia];
+	const unavailableFiles = allFiles.flatMap((file, index) => {
+		const reason = index >= 8 ? SLACK_MEDIA_LIMIT_REASON : unavailableFileReasons.get(file);
+		return reason ? [{
+			...file,
+			reason
+		}] : [];
+	});
+	unavailableMediaCount += unavailableFiles.length;
 	const combinedText = textBlocks.join("\n\n");
-	if (!combinedText && allMedia.length === 0 && allFiles.length === 0 && unavailableImageCount === 0) return null;
+	if (!combinedText && allMedia.length === 0 && allFiles.length === 0 && unavailableMediaCount === 0) return null;
 	return {
 		text: combinedText,
 		media: allMedia,
-		unavailableImageCount,
-		...allFiles.length > 0 ? { files: allFiles } : {}
+		unavailableMediaCount,
+		...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,
+	openSlackConversation: () => openSlackConversation,
+	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(message, { preserveMessageTextWhitespace: true });
@@ -553,7 +723,12 @@ async function sendSlackMessage(to, content, opts) {
 	});
 }
 async function editSlackMessage(channelId, messageId, content, opts = {}) {
-	await editSlackRenderedMessage(channelId, messageId, normalizeSlackOutboundText(content), opts);
+	const accountId = opts.accountId ?? (opts.cfg ? resolveDefaultSlackAccountId(opts.cfg) : void 0);
+	await editSlackRenderedMessage(channelId, messageId, normalizeSlackOutboundText(content, { tableMode: resolveMarkdownTableMode({
+		cfg: opts.cfg,
+		channel: "slack",
+		accountId
+	}) }), opts);
 }
 async function editSlackRenderedMessage(channelId, messageId, content, opts = {}) {
 	const client = await getClient(opts, "write");
@@ -598,6 +773,13 @@ async function deleteSlackMessage(channelId, messageId, opts = {}) {
 		ts: messageId
 	});
 }
+async function openSlackConversation(userIds, opts = {}) {
+	const input = parseSlackConversationOpenInput(userIds, opts.teamId);
+	return await openSlackConversationWithClient(await getClient({
+		...opts,
+		teamId: input.teamId
+	}, "write"), input);
+}
 async function resolveSlackConversationName(channelId, opts = {}) {
 	return (await (await getClient(opts, "read")).conversations.info({ channel: channelId })).channel?.name?.trim() || void 0;
 }
@@ -682,48 +864,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.
@@ -733,13 +901,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,
@@ -749,9 +918,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, formatSlackFileReferenceList 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, logVerbose$1 as v, buildSlackEditTextPayload as x, formatSlackFileReference as y };
+export { hasSlackMessageTableBlock as C, resolveSlackMessageText as D, resolveSlackBlocksText as E, buildSlackEditTextPayload as O, formatSlackFileReferenceList as S, isSlackUnfurlAttachment as T, media_exports as _, editSlackRenderedMessage as a, saveRemoteMedia 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, hasSlackTableBlock as w, formatSlackFileReference as x, isGovSlackClient 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-BlzxuYle.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-YJvFBbCR.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 { G as buildSlackPresentationBlocks, Rt as resolveSlackAutoThreadId, W as buildSlackInteractiveBlocks, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, ft as SLACK_MAX_BLOCKS, h as resolveSlackUserAllowed, i as resolveSlackGroupToolPolicy, l as normalizeAllowList, mt as validateSlackBlocksArray, p as resolveSlackAllowListMatch, pt as parseSlackBlocksInput, r as resolveSlackGroupRequireMention, u as normalizeAllowListLower } from "./group-policy-DyfB_ZIE.js";
-import { n as buildSlackThreadingToolContext, t as slackPlugin } from "./channel-CA5w7qDF.js";
-import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-CqMr5Rmc.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-BVA65leh.js";
-import { n as resolveSlackChannelType } from "./channel-type-CZWv55Wu.js";
-import { t as slackSetupPlugin } from "./channel.setup-CpyYsEXH.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-DFk0ANVB.js";
-import { f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, s as clearSlackThreadParticipationCache } from "./send-CtnOxKCc.js";
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-BGYyuzWh.js";
+import { N as buildSlackInteractiveBlocks, P as buildSlackPresentationBlocks, at as SLACK_MAX_BLOCKS, i as resolveSlackGroupToolPolicy, jt as resolveSlackAutoThreadId, ot as parseSlackBlocksInput, r as resolveSlackGroupRequireMention, st as validateSlackBlocksArray } from "./group-policy-BdwszjYn.js";
+import { n as buildSlackThreadingToolContext, t as slackPlugin } from "./channel-1vIJOzPx.js";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-CJ0kjcg5.js";
+import { C as SLACK_DEFAULT_RETRY_OPTIONS, D as resolveSlackWebClientOptions, O as resolveSlackWriteClientOptions, S as getSlackWriteClient, b as createSlackWriteClient, c as normalizeAllowList, d as normalizeSlackSlug, f as resolveSlackAllowListMatch, l as normalizeAllowListLower, m as resolveSlackUserAllowed, s as allowListMatches, t as probeSlack, u as normalizeSlackAllowOwnerEntry, v as createSlackTokenCacheKey, w as SLACK_WRITE_RETRY_OPTIONS, y as createSlackWebClient } from "./probe-0usmAb0i.js";
+import { n as resolveSlackChannelType } from "./channel-type-DlFSKeIZ.js";
+import { t as slackSetupPlugin } from "./channel.setup-ofDi3_Pu.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-BI7JkfVm.js";
+import { f as recordSlackThreadParticipation, l as hasSlackThreadParticipation, s as clearSlackThreadParticipationCache } from "./send-DS9ICrBI.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-CUUiwsg2.js";
+import { n as resolveSlackRuntimeGroupPolicy } from "./provider-CN_8hFv2.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 };