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

package/dist/account-configured-sUohAxZr.js

@@ -0,0 +1,33 @@
+import { hasConfiguredAccountValue } from "openclaw/plugin-sdk/account-resolution";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+//#region extensions/slack/src/account-configured.ts
+function hasSlackAccountCredentials(params) {
+	if (!params.identityTokenConfigured) return false;
+	const mode = params.config.mode ?? "socket";
+	if (mode === "http") return hasConfiguredAccountValue(params.config.signingSecret);
+	if (mode === "relay") {
+		const relay = params.config.relay;
+		return hasConfiguredAccountValue(relay?.url) && hasConfiguredAccountValue(relay?.authToken) && hasConfiguredAccountValue(relay?.gatewayId);
+	}
+	return params.appTokenConfigured;
+}
+function isSlackPluginAccountConfigured(account) {
+	const identityToken = account.identity === "user" ? account.userToken : account.botToken;
+	return hasSlackAccountCredentials({
+		config: account.config,
+		identityTokenConfigured: Boolean(identityToken?.trim()),
+		appTokenConfigured: Boolean(account.appToken?.trim())
+	});
+}
+function isSlackSetupAccountConfigured(account) {
+	if (account.config.mode === "relay") return isSlackPluginAccountConfigured(account);
+	const identityToken = account.identity === "user" ? account.userToken : account.botToken;
+	const configuredIdentityToken = account.identity === "user" ? account.config.userToken : account.config.botToken;
+	return hasSlackAccountCredentials({
+		config: account.config,
+		identityTokenConfigured: Boolean(identityToken?.trim()) || hasConfiguredSecretInput(configuredIdentityToken),
+		appTokenConfigured: Boolean(account.appToken?.trim()) || hasConfiguredSecretInput(account.config.appToken)
+	});
+}
+//#endregion
+export { isSlackPluginAccountConfigured as n, isSlackSetupAccountConfigured as r, hasSlackAccountCredentials as t };

package/dist/account-inspect-CN2hBsim.js

@@ -0,0 +1,87 @@
+import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.js";
+import { i as resolveDefaultSlackAccountId, r as mergeSlackAccountConfig } from "./accounts-Dm_H77gH.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/account-inspect.ts
+function inspectSlackToken(value) {
+	const token = normalizeSecretInputString(value);
+	if (token) return {
+		token,
+		source: "config",
+		status: "available"
+	};
+	if (hasConfiguredSecretInput(value)) return {
+		source: "config",
+		status: "configured_unavailable"
+	};
+	return {
+		source: "none",
+		status: "missing"
+	};
+}
+function resolveInspectedSlackToken(configured, envToken) {
+	return configured.status === "missing" && envToken ? {
+		token: envToken,
+		source: "env",
+		status: "available"
+	} : configured;
+}
+function inspectSlackAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const merged = mergeSlackAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.slack?.enabled !== false && merged.enabled !== false;
+	const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+	const mode = merged.mode ?? "socket";
+	const identity = merged.postAs ?? "bot";
+	const isHttpMode = mode === "http";
+	const isRelayMode = mode === "relay";
+	const configBot = inspectSlackToken(merged.botToken);
+	const configApp = inspectSlackToken(merged.appToken);
+	const configSigningSecret = inspectSlackToken(merged.signingSecret);
+	const configUser = inspectSlackToken(merged.userToken);
+	const envBot = allowEnv ? normalizeSecretInputString(params.envBotToken ?? process.env.SLACK_BOT_TOKEN) : void 0;
+	const envApp = allowEnv && !isRelayMode ? normalizeSecretInputString(params.envAppToken ?? process.env.SLACK_APP_TOKEN) : void 0;
+	const envUser = allowEnv ? normalizeSecretInputString(params.envUserToken ?? process.env.SLACK_USER_TOKEN) : void 0;
+	const botCredential = resolveInspectedSlackToken(configBot, envBot);
+	const appCredential = resolveInspectedSlackToken(configApp, envApp);
+	const userCredential = resolveInspectedSlackToken(configUser, envUser);
+	return {
+		accountId,
+		enabled,
+		...identity === "user" ? { identity } : {},
+		name: normalizeOptionalString(merged.name),
+		mode,
+		botToken: botCredential.token,
+		appToken: appCredential.token,
+		...isHttpMode ? { signingSecret: configSigningSecret.token } : {},
+		userToken: userCredential.token,
+		botTokenSource: botCredential.source,
+		appTokenSource: appCredential.source,
+		...isHttpMode ? { signingSecretSource: configSigningSecret.source } : {},
+		userTokenSource: userCredential.source,
+		botTokenStatus: botCredential.status,
+		appTokenStatus: appCredential.status,
+		...isHttpMode ? { signingSecretStatus: configSigningSecret.status } : {},
+		userTokenStatus: userCredential.status,
+		configured: hasSlackAccountCredentials({
+			config: merged,
+			identityTokenConfigured: (identity === "user" ? userCredential : botCredential).status !== "missing",
+			appTokenConfigured: appCredential.status !== "missing"
+		}),
+		config: merged,
+		groupPolicy: merged.groupPolicy,
+		textChunkLimit: merged.textChunkLimit,
+		mediaMaxMb: merged.mediaMaxMb,
+		reactionNotifications: merged.reactionNotifications,
+		reactionAllowlist: merged.reactionAllowlist,
+		replyToMode: merged.replyToMode,
+		replyToModeByChatType: merged.replyToModeByChatType,
+		actions: merged.actions,
+		slashCommand: merged.slashCommand,
+		dm: merged.dm,
+		channels: merged.channels
+	};
+}
+//#endregion
+export { inspectSlackAccount as t };

package/dist/account-inspect-api.js

@@ -1,4 +1,4 @@
-import { t as inspectSlackAccount } from "./account-inspect-YJvFBbCR.js";
+import { t as inspectSlackAccount } from "./account-inspect-CN2hBsim.js";
 //#region extensions/slack/account-inspect-api.ts
 function inspectSlackReadOnlyAccount(cfg, accountId) {
 	return inspectSlackAccount({

package/dist/{accounts-BlzxuYle.js → accounts-Dm_H77gH.js}

@@ -1,3 +1,4 @@
+import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.js";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
@@ -46,16 +47,12 @@ const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMe
 	],
 	hasImplicitDefaultAccount: (cfg) => {
 		const slack = cfg.channels?.slack;
-		if (slack?.postAs === "user") {
-			if (!(hasConfiguredAccountValue(slack.userToken) || hasConfiguredAccountValue(process.env.SLACK_USER_TOKEN))) return false;
-			if (slack.mode === "http") return hasConfiguredAccountValue(slack.signingSecret);
-			if (slack.mode === "relay") return hasConfiguredAccountValue(slack.relay?.url) && hasConfiguredAccountValue(slack.relay?.authToken) && hasConfiguredAccountValue(slack.relay?.gatewayId);
-			return hasConfiguredAccountValue(slack.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN);
-		}
-		if (!(hasConfiguredAccountValue(slack?.botToken) || hasConfiguredAccountValue(process.env.SLACK_BOT_TOKEN))) return false;
-		if (slack?.mode === "http") return hasConfiguredAccountValue(slack.signingSecret);
-		if (slack?.mode === "relay") return hasConfiguredAccountValue(slack.relay?.url) && hasConfiguredAccountValue(slack.relay?.authToken) && hasConfiguredAccountValue(slack.relay?.gatewayId);
-		return hasConfiguredAccountValue(slack?.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN);
+		const userIdentity = slack?.postAs === "user";
+		return hasSlackAccountCredentials({
+			config: slack ?? {},
+			identityTokenConfigured: hasConfiguredAccountValue(userIdentity ? slack?.userToken : slack?.botToken) || hasConfiguredAccountValue(userIdentity ? process.env.SLACK_USER_TOKEN : process.env.SLACK_BOT_TOKEN),
+			appTokenConfigured: hasConfiguredAccountValue(slack?.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN)
+		});
 	}
 });
 const listSlackAccountIds = listAccountIds;

package/dist/{accounts.runtime-CbabBL8x.js → accounts.runtime-DRuEK6mL.js}

@@ -1,2 +1,2 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken, o as resolveSlackAccountAllowFrom } from "./accounts-BlzxuYle.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken, o as resolveSlackAccountAllowFrom } from "./accounts-Dm_H77gH.js";
 export { resolveSlackAccount, resolveSlackAccountAllowFrom, resolveSlackOperationToken };

package/dist/{action-runtime-D6jg2CQd.js → action-runtime-BoSeX09X.js}

@@ -1,13 +1,13 @@
 import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-BnMD2ZqZ.js";
 import { t as slackContextTargetsMatch } from "./targets-Cx5W_n3W.js";
-import { Et as getSlackInstallationKind, Lt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, O as hasSlackNativeDataBlock, Rt as resolveSlackAutoThreadId, g as assertSlackDetachedTargetAllowed, pt as parseSlackBlocksInput, t as buildSlackChannelIdCandidates } from "./group-policy-DyfB_ZIE.js";
-import { a as readPositiveIntegerParam, c as withNormalizedTimestamp, n as imageResultFromFile, o as readReactionParams, r as jsonResult, s as readStringParam, t as createActionGate } from "./runtime-api-DBi7xc_g.js";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-BKXSxrIS.js";
+import { Dt as getSlackInstallationKind, O as hasSlackNativeDataBlock, Rt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, g as assertSlackDetachedTargetAllowed, mt as parseSlackBlocksInput, t as buildSlackChannelIdCandidates, zt as resolveSlackAutoThreadId } from "./group-policy-CU1tEGpS.js";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-BoP6t88v.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
 import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
+import { createActionGate, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
 //#region extensions/slack/src/action-runtime.ts
 const messagingActions = /* @__PURE__ */ new Set([
@@ -24,10 +24,10 @@ const pinActions = /* @__PURE__ */ new Set([
 	"unpinMessage",
 	"listPins"
 ]);
-const SLACK_REACTION_USER_LIMIT = 100;
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions.runtime-CYLsYRai.js"));
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-CbabBL8x.js"));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-CZWv55Wu.js").then((n) => n.t));
+const SLACK_REACTION_RESULT_LIMIT = 100;
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-XdQyjG_p.js").then((n) => n.t));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-DRuEK6mL.js"));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-j-2lalcC.js").then((n) => n.t));
 function createLazySlackAction(key) {
 	return (async (...args) => {
 		const action = (await loadSlackActionsRuntime())[key];
@@ -329,7 +329,7 @@ async function handleSlackAction(params, cfg, context) {
 			});
 		}
 		await assertReadTargetAllowed(target);
-		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_USER_LIMIT, SLACK_REACTION_USER_LIMIT);
+		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
 		return jsonResult({
 			ok: true,
 			reactions: (await slackActionRuntime.listSlackReactions(channelId, messageId, readOpts))?.map((reaction) => reaction.users ? Object.assign({}, reaction, { users: reaction.users.slice(0, limit) }) : reaction)
@@ -525,7 +525,7 @@ async function handleSlackAction(params, cfg, context) {
 				});
 				if (!downloaded) return jsonResult({
 					ok: false,
-					error: "File could not be downloaded (not found, too large, or inaccessible)."
+					error: "File could not be downloaded. Confirm the fileId came from the requested Slack channel or explicit thread and that the file is accessible and within the size limit."
 				});
 				if (!isImageContentType(downloaded.contentType)) return jsonResult({
 					ok: true,
@@ -601,26 +601,23 @@ async function handleSlackAction(params, cfg, context) {
 	}
 	if (action === "emojiList") {
 		if (!isActionEnabled("emojiList")) throw new Error("Slack emoji list is disabled.");
-		const limit = readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." });
+		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
 		const teamId = resolveTrustedCurrentSlackTeamId({
 			account,
 			context
 		});
 		assertSlackDetachedTargetAllowed(account.accountId, teamId);
 		const result = await slackActionRuntime.listSlackEmojis(buildActionOpts("read", teamId));
-		if (limit != null && limit > 0 && result.emoji != null) {
-			const entries = Object.entries(result.emoji).toSorted(([a], [b]) => a.localeCompare(b));
-			if (entries.length > limit) return jsonResult({
-				ok: true,
-				emojis: {
-					...result,
-					emoji: Object.fromEntries(entries.slice(0, limit))
-				}
-			});
-		}
 		return jsonResult({
 			ok: true,
-			emojis: result
+			emojis: Object.entries(result.emoji ?? {}).toSorted(([left], [right]) => left.localeCompare(right)).slice(0, limit).map(([name, value]) => value.startsWith("alias:") ? {
+				name,
+				identifier: name,
+				aliasOf: value.slice(6)
+			} : {
+				name,
+				identifier: name
+			})
 		});
 	}
 	throw new Error(`Unknown action: ${action}`);

package/dist/action-runtime.runtime-Dpa16J87.js

@@ -0,0 +1,2 @@
+import { t as handleSlackAction } from "./action-runtime-BoSeX09X.js";
+export { handleSlackAction };

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

@@ -1,9 +1,9 @@
 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 } 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";
@@ -184,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}`);
@@ -226,6 +230,7 @@ async function downloadSlackMediaFile(params) {
 	return {
 		path: saved.path,
 		...contentType ? { contentType } : {},
+		...label ? { fileName: label } : {},
 		placeholder: `[Slack file: ${formatSlackFileReference({
 			...params.file,
 			name: label
@@ -253,15 +258,18 @@ 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;
+	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
-			});
+			const url = eventUrl ?? await refreshFileUrl(file);
 			if (!url) return null;
 			const result = await downloadSlackMediaFile({
 				file,
@@ -274,10 +282,7 @@ async function resolveSlackMedia(params) {
 				govSlack
 			}).catch(() => null);
 			if (result || !eventUrl) return result;
-			const freshUrl = await fetchFreshSlackFileUrl({
-				file,
-				client: params.client
-			});
+			const freshUrl = await refreshFileUrl(file);
 			if (!freshUrl) return null;
 			return await downloadSlackMediaFile({
 				file,
@@ -294,18 +299,47 @@ async function resolveSlackMedia(params) {
 		errorMode: "stop",
 		throwOnError: true
 	});
-	const resolved = results.filter((result) => result !== null);
+	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) {
@@ -331,38 +365,48 @@ 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(message, { preserveMessageTextWhitespace: true });
@@ -682,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.
@@ -733,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,
@@ -749,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, 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 { 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-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 { 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-CUUiwsg2.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 };