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

package/dist/action-runtime-BO3HK_50.js

@@ -1,561 +0,0 @@
-import { a as resolveSlackChannelId, i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
-import { t as slackContextTargetsMatch } from "./targets-KmjP2E8s.js";
-import { C as hasSlackNativeDataBlock, tt as parseSlackBlocksInput } from "./group-policy-CthIXE2T.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-jpn3vQ7e.js";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-DVg6FyMP.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 { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
-//#region extensions/slack/src/action-runtime.ts
-const messagingActions = /* @__PURE__ */ new Set([
-	"sendMessage",
-	"uploadFile",
-	"editMessage",
-	"deleteMessage",
-	"readMessages",
-	"downloadFile"
-]);
-const reactionsActions = /* @__PURE__ */ new Set(["react", "reactions"]);
-const pinActions = /* @__PURE__ */ new Set([
-	"pinMessage",
-	"unpinMessage",
-	"listPins"
-]);
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions.runtime-Do-iOL51.js"));
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-CjULMLTa.js"));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-CPDX8EV-.js").then((n) => n.t));
-function createLazySlackAction(key) {
-	return (async (...args) => {
-		const action = (await loadSlackActionsRuntime())[key];
-		return action(...args);
-	});
-}
-const slackActionRuntime = {
-	deleteSlackMessage: createLazySlackAction("deleteSlackMessage"),
-	downloadSlackFile: createLazySlackAction("downloadSlackFile"),
-	editSlackMessage: createLazySlackAction("editSlackMessage"),
-	getSlackMemberInfo: createLazySlackAction("getSlackMemberInfo"),
-	listSlackEmojis: createLazySlackAction("listSlackEmojis"),
-	listSlackPins: createLazySlackAction("listSlackPins"),
-	listSlackReactions: createLazySlackAction("listSlackReactions"),
-	parseSlackBlocksInput,
-	pinSlackMessage: createLazySlackAction("pinSlackMessage"),
-	reactSlackMessage: createLazySlackAction("reactSlackMessage"),
-	readSlackMessages: createLazySlackAction("readSlackMessages"),
-	removeOwnSlackReactions: createLazySlackAction("removeOwnSlackReactions"),
-	removeSlackReaction: createLazySlackAction("removeSlackReaction"),
-	resolveSlackConversationName: createLazySlackAction("resolveSlackConversationName"),
-	resolveSlackConversationInfo: async (params) => (await loadSlackChannelTypeRuntime()).resolveSlackConversationInfo(params),
-	resolveSlackChannelType: async (params) => (await loadSlackChannelTypeRuntime()).resolveSlackChannelType(params),
-	sendSlackMessage: createLazySlackAction("sendSlackMessage"),
-	unpinSlackMessage: createLazySlackAction("unpinSlackMessage")
-};
-/**
-* Resolve threadTs for a Slack message based on context and replyToMode.
-* - "all": always inject threadTs
-* - "first"/"batched": inject only for the first eligible message (updates hasRepliedRef)
-* - "off": never auto-inject
-*/
-function resolveThreadTsFromContext(explicitThreadTs, targetChannel, context, opts) {
-	if (explicitThreadTs) return explicitThreadTs;
-	if (opts?.suppressImplicitThread) return;
-	if (!context?.currentChannelId && !context?.currentMessagingTarget) return;
-	if (!slackContextTargetsMatch(targetChannel, context)) return;
-	if (!context.currentThreadTs) {
-		if (context.sameChannelThreadRequired) throw new Error("Slack thread context is required for same-channel replies from a threaded Slack turn. Set topLevel=true or threadId=null to post at the channel root.");
-		return;
-	}
-	if (context.replyToMode === "all") return context.currentThreadTs;
-	if (isSingleUseReplyToMode(context.replyToMode ?? "off") && context.hasRepliedRef && !context.hasRepliedRef.value) {
-		context.hasRepliedRef.value = true;
-		return context.currentThreadTs;
-	}
-}
-function readSlackBlocksParam(params) {
-	return slackActionRuntime.parseSlackBlocksInput(params.blocks);
-}
-function isImageContentType(value) {
-	return value?.trim().toLowerCase().startsWith("image/") === true;
-}
-function hasPotentialSlackNamedPolicy(params) {
-	if (params.allowNameMatching !== true) return false;
-	return Object.entries(params.channels ?? {}).some(([key, entry]) => {
-		if (entry == null || key === "*") return false;
-		const named = !/^(?:channel:)?[CDG][A-Z0-9]+$/i.test(key);
-		const entryAllows = entry.enabled !== false;
-		return named && (params.decision === "allow" ? entryAllows : !entryAllows);
-	});
-}
-function resolveSlackDmReadAllowed(account) {
-	const dmPolicy = account.config.dmPolicy ?? "pairing";
-	return account.config.dm?.enabled !== false && dmPolicy !== "disabled";
-}
-function normalizeConfiguredSlackDmUserId(value) {
-	const target = parseSlackTarget(String(value), { defaultKind: "user" });
-	if (target?.kind !== "user") return;
-	const userId = target.id.trim().toLowerCase();
-	return /^[uw][a-z0-9]+$/i.test(userId) ? userId : void 0;
-}
-async function isSlackDmTargetConfigured(params) {
-	const defaultTo = params.account.config.defaultTo?.trim();
-	if (defaultTo && slackContextTargetsMatch(params.channelId, { currentChannelId: defaultTo })) return true;
-	const userId = normalizeConfiguredSlackDmUserId(params.userId);
-	if (!userId) return false;
-	const { resolveSlackAccountAllowFrom } = await loadSlackAccountsRuntime();
-	return [
-		...resolveSlackAccountAllowFrom({
-			cfg: params.cfg,
-			accountId: params.account.accountId
-		}) ?? [],
-		...Object.keys(params.account.config.dms ?? {}),
-		...defaultTo ? [defaultTo] : []
-	].some((entry) => normalizeConfiguredSlackDmUserId(entry) === userId);
-}
-function isCurrentSlackReadTarget(params) {
-	const requesterAccountId = params.context?.requesterAccountId?.trim();
-	return Boolean(normalizeOptionalLowercaseString(params.context?.currentChannelProvider) === "slack" && requesterAccountId && normalizeAccountId(requesterAccountId) === normalizeAccountId(params.account.accountId) && params.context && slackContextTargetsMatch(params.channelId, params.context));
-}
-function assertSlackMemberInfoAllowed(params) {
-	if (params.context?.conversationReadOrigin === "direct-operator") return;
-	const requesterAccountId = params.context?.requesterAccountId?.trim();
-	const requesterSenderId = normalizeOptionalLowercaseString(params.context?.requesterSenderId);
-	if (normalizeOptionalLowercaseString(params.context?.currentChannelProvider) !== "slack" || !requesterAccountId || normalizeAccountId(requesterAccountId) !== normalizeAccountId(params.account.accountId) || !requesterSenderId || requesterSenderId !== normalizeOptionalLowercaseString(params.userId)) throw new Error("Delegated Slack member info is limited to the current requester.");
-}
-function resolveSlackChannelReadPolicy(params) {
-	const channels = params.account.config.channels;
-	const channelKeys = Object.keys(channels ?? {});
-	const channelConfig = resolveSlackChannelConfig({
-		channelId: params.channelId,
-		channelName: params.channelName,
-		channels,
-		channelKeys,
-		allowNameMatching: params.account.config.dangerouslyAllowNameMatching,
-		defaultRequireMention: params.account.config.requireMention
-	});
-	const channelAllowed = channelConfig?.allowed !== false;
-	const channelExplicitlyDisabled = !channelAllowed && channelConfig?.matchSource === "direct";
-	const channelWildcardDisabled = !channelAllowed && channelConfig?.matchSource === "wildcard";
-	const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
-		providerConfigPresent: params.cfg.channels?.slack !== void 0,
-		groupPolicy: params.account.config.groupPolicy,
-		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
-	});
-	const delegatedChannelAllowed = isSlackChannelAllowedByPolicy({
-		groupPolicy,
-		channelAllowlistConfigured: channelKeys.length > 0,
-		channelAllowed
-	}) && !(!channelAllowed && (groupPolicy !== "open" || channelConfig?.matchSource));
-	const directChannelAllowed = groupPolicy !== "disabled" && !channelExplicitlyDisabled && !channelWildcardDisabled;
-	const baseChannelAllowed = params.conversationReadOrigin === "direct-operator" || params.currentConversation ? directChannelAllowed : delegatedChannelAllowed;
-	const allowNameMatching = params.account.config.dangerouslyAllowNameMatching;
-	const shouldResolveName = !params.metadataResolved && !params.channelName && (baseChannelAllowed && channelConfig?.matchSource !== "direct" && hasPotentialSlackNamedPolicy({
-		channels,
-		allowNameMatching,
-		decision: "deny"
-	}) || !baseChannelAllowed && groupPolicy !== "disabled" && !channelExplicitlyDisabled && hasPotentialSlackNamedPolicy({
-		channels,
-		allowNameMatching,
-		decision: "allow"
-	}));
-	return {
-		channelAllowed: baseChannelAllowed,
-		channelExplicitlyDisabled,
-		groupDmAllowed: params.account.config.dm?.enabled !== false && params.account.config.dm?.groupEnabled === true && (params.currentConversation || isSlackGroupDmTargetConfigured(params.account, params.channelId)),
-		shouldResolveName
-	};
-}
-async function assertSlackReadTargetAllowed(params) {
-	const deny = () => {
-		throw new Error("Slack read target channel is not allowed.");
-	};
-	const currentConversation = isCurrentSlackReadTarget({
-		account: params.account,
-		channelId: params.channelId,
-		context: params.context
-	});
-	const directOperator = params.conversationReadOrigin === "direct-operator";
-	if (/^D/i.test(params.channelId)) {
-		if (!resolveSlackDmReadAllowed(params.account)) deny();
-		if (directOperator || currentConversation) return;
-		const info = await slackActionRuntime.resolveSlackConversationInfo({
-			cfg: params.cfg,
-			accountId: params.account.accountId,
-			channelId: params.channelId,
-			operation: "read"
-		});
-		if (info.type !== "dm" || !await isSlackDmTargetConfigured({
-			...params,
-			userId: info.user
-		})) deny();
-		return;
-	}
-	const preliminary = resolveSlackChannelReadPolicy({
-		...params,
-		currentConversation
-	});
-	if (preliminary.channelExplicitlyDisabled) deny();
-	if (!(preliminary.shouldResolveName || preliminary.channelAllowed !== preliminary.groupDmAllowed)) {
-		if (!preliminary.channelAllowed) deny();
-		return;
-	}
-	const info = await slackActionRuntime.resolveSlackConversationInfo({
-		cfg: params.cfg,
-		accountId: params.account.accountId,
-		channelId: params.channelId,
-		operation: "read",
-		...preliminary.shouldResolveName ? { requireFreshName: true } : {}
-	});
-	if (preliminary.shouldResolveName && (info.type === "channel" || info.type === "unknown") && !info.name) deny();
-	const resolved = resolveSlackChannelReadPolicy({
-		...params,
-		channelName: info.name,
-		metadataResolved: true,
-		currentConversation
-	});
-	if (resolved.channelExplicitlyDisabled) deny();
-	if (info.type === "dm") {
-		if (!resolveSlackDmReadAllowed(params.account) || !directOperator && !currentConversation && !await isSlackDmTargetConfigured({
-			...params,
-			userId: info.user
-		})) deny();
-		return;
-	}
-	if (!(info.type === "channel" ? resolved.channelAllowed : info.type === "group" ? resolved.groupDmAllowed : resolved.channelAllowed && resolved.groupDmAllowed)) deny();
-}
-function isSlackGroupDmTargetConfigured(account, channelId) {
-	const entries = account.config.dm?.groupChannels ?? [];
-	if (entries.length === 0) return true;
-	const target = channelId.trim().toLowerCase();
-	return entries.some((entry) => {
-		const candidate = String(entry).trim().toLowerCase();
-		return candidate === "*" || candidate === target || candidate === `slack:${target}` || candidate === `channel:${target}` || candidate === `group:${target}` || candidate === `mpim:${target}`;
-	});
-}
-async function handleSlackAction(params, cfg, context) {
-	const resolveChannelId = () => resolveSlackChannelId(readStringParam(params, "channelId", { required: true }));
-	const action = readStringParam(params, "action", { required: true });
-	const accountId = readStringParam(params, "accountId");
-	const { resolveSlackAccount, resolveSlackOperationToken } = await loadSlackAccountsRuntime();
-	const account = resolveSlackAccount({
-		cfg,
-		accountId
-	});
-	if (account.config.enterpriseOrgInstall === true) throw new Error("Slack action tools are unavailable for Enterprise Grid org installs.");
-	const isActionEnabled = createActionGate(account.actions ?? cfg.channels?.slack?.actions);
-	const botToken = account.botToken?.trim();
-	const buildActionOpts = (operation) => {
-		const token = resolveSlackOperationToken(account, operation);
-		if (!token && account.identity === "user") throw new Error(`Slack operation token missing for account "${account.accountId}".`);
-		const tokenOverride = token && token !== botToken ? token : void 0;
-		return {
-			cfg,
-			...accountId ? { accountId } : {},
-			...tokenOverride ? { token: tokenOverride } : {}
-		};
-	};
-	const readOpts = buildActionOpts("read");
-	const writeOpts = buildActionOpts("write");
-	const assertReadTargetAllowed = async (channelId) => await assertSlackReadTargetAllowed({
-		account,
-		cfg,
-		channelId,
-		conversationReadOrigin: context?.conversationReadOrigin,
-		context
-	});
-	if (reactionsActions.has(action)) {
-		if (!isActionEnabled("reactions")) throw new Error("Slack reactions are disabled.");
-		const channelId = resolveChannelId();
-		const messageId = readStringParam(params, "messageId", { required: true });
-		if (action === "react") {
-			const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a Slack reaction." });
-			await assertReadTargetAllowed(channelId);
-			if (remove) {
-				if (writeOpts) await slackActionRuntime.removeSlackReaction(channelId, messageId, emoji, writeOpts);
-				else await slackActionRuntime.removeSlackReaction(channelId, messageId, emoji);
-				return jsonResult({
-					ok: true,
-					removed: emoji
-				});
-			}
-			if (isEmpty) return jsonResult({
-				ok: true,
-				removed: writeOpts ? await slackActionRuntime.removeOwnSlackReactions(channelId, messageId, writeOpts) : await slackActionRuntime.removeOwnSlackReactions(channelId, messageId)
-			});
-			if (writeOpts) await slackActionRuntime.reactSlackMessage(channelId, messageId, emoji, writeOpts);
-			else await slackActionRuntime.reactSlackMessage(channelId, messageId, emoji);
-			return jsonResult({
-				ok: true,
-				added: emoji
-			});
-		}
-		await assertReadTargetAllowed(channelId);
-		return jsonResult({
-			ok: true,
-			reactions: readOpts ? await slackActionRuntime.listSlackReactions(channelId, messageId, readOpts) : await slackActionRuntime.listSlackReactions(channelId, messageId)
-		});
-	}
-	if (messagingActions.has(action)) {
-		if (!isActionEnabled("messages")) throw new Error("Slack messages are disabled.");
-		switch (action) {
-			case "sendMessage": {
-				const to = readStringParam(params, "to", { required: true });
-				const content = readStringParam(params, "content", { allowEmpty: true });
-				const mediaUrl = readStringParam(params, "mediaUrl");
-				const blocks = readSlackBlocksParam(params);
-				const replyBroadcast = readBooleanParam(params, "replyBroadcast");
-				const textIsSlackMrkdwn = readBooleanParam(params, "textIsSlackMrkdwn");
-				const textIsSlackPlainText = readBooleanParam(params, "textIsSlackPlainText");
-				const preparedMessages = context?.preparedMessages;
-				const authoredTextPlacement = readStringParam(params, "authoredTextPlacement");
-				if (authoredTextPlacement && authoredTextPlacement !== "none" && authoredTextPlacement !== "blocks" && authoredTextPlacement !== "outside-blocks") throw new Error("Slack authoredTextPlacement is invalid.");
-				const nativeDataFallbackBaseText = readStringParam(params, "nativeDataFallbackBaseText", { allowEmpty: true });
-				if (!content && !mediaUrl && !blocks && !preparedMessages?.length) throw new Error("Slack sendMessage requires content, blocks, or mediaUrl.");
-				if (replyBroadcast && mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), to, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
-				const baseSendOpts = {
-					...writeOpts,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0
-				};
-				const sendOpts = {
-					...baseSendOpts,
-					...replyBroadcast ? { replyBroadcast } : {},
-					...textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
-					...textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
-					...authoredTextPlacement ? { authoredTextPlacement } : {},
-					...nativeDataFallbackBaseText !== void 0 ? { nativeDataFallbackBaseText } : {}
-				};
-				const sendContentAndBlocks = async () => {
-					const shouldSplitLongContent = content && content.length > 8e3 && !hasSlackNativeDataBlock(blocks);
-					if (content && shouldSplitLongContent) {
-						const { replyBroadcast: _replyBroadcast, ...blockSendOpts } = sendOpts;
-						await slackActionRuntime.sendSlackMessage(to, "", {
-							...blockSendOpts,
-							blocks
-						});
-						return await slackActionRuntime.sendSlackMessage(to, content, sendOpts);
-					}
-					return await slackActionRuntime.sendSlackMessage(to, content ?? "", {
-						...sendOpts,
-						blocks
-					});
-				};
-				const result = preparedMessages?.length ? await (async () => {
-					let lastResult;
-					if (mediaUrl) lastResult = await slackActionRuntime.sendSlackMessage(to, "", {
-						...baseSendOpts,
-						mediaUrl
-					});
-					for (const [index, message] of preparedMessages.entries()) lastResult = await slackActionRuntime.sendSlackMessage(to, message.text, {
-						...baseSendOpts,
-						...index === 0 && replyBroadcast ? { replyBroadcast: true } : {},
-						...message.blocks ? { blocks: message.blocks } : {},
-						...message.authoredTextPlacement ? { authoredTextPlacement: message.authoredTextPlacement } : {},
-						...Object.hasOwn(message, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: message.nativeDataFallbackBaseText } : {},
-						...message.textIsSlackPlainText ? { textIsSlackPlainText: true } : {}
-					});
-					if (!lastResult) throw new Error("Slack prepared message plan produced no delivery.");
-					return lastResult;
-				})() : blocks ? await (async () => {
-					if (mediaUrl) await slackActionRuntime.sendSlackMessage(to, "", {
-						...sendOpts,
-						mediaUrl
-					});
-					return await sendContentAndBlocks();
-				})() : await slackActionRuntime.sendSlackMessage(to, content ?? "", {
-					...sendOpts,
-					mediaUrl: mediaUrl ?? void 0,
-					blocks
-				});
-				if (context?.hasRepliedRef && slackContextTargetsMatch(to, context)) context.hasRepliedRef.value = true;
-				return jsonResult({
-					ok: true,
-					result
-				});
-			}
-			case "uploadFile": {
-				const to = readStringParam(params, "to", { required: true });
-				const filePath = readStringParam(params, "filePath", {
-					required: true,
-					trim: false
-				});
-				const initialComment = readStringParam(params, "initialComment", { allowEmpty: true });
-				const filename = readStringParam(params, "filename");
-				const title = readStringParam(params, "title");
-				if (readBooleanParam(params, "replyBroadcast")) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), to, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
-				const result = await slackActionRuntime.sendSlackMessage(to, initialComment ?? "", {
-					...writeOpts,
-					mediaUrl: filePath,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...filename ? { uploadFileName: filename } : {},
-					...title ? { uploadTitle: title } : {}
-				});
-				if (context?.hasRepliedRef && slackContextTargetsMatch(to, context)) context.hasRepliedRef.value = true;
-				return jsonResult({
-					ok: true,
-					result
-				});
-			}
-			case "editMessage": {
-				const channelId = resolveChannelId();
-				const messageId = readStringParam(params, "messageId", { required: true });
-				const content = readStringParam(params, "content", { allowEmpty: true });
-				const blocks = readSlackBlocksParam(params);
-				if (!content && !blocks) throw new Error("Slack editMessage requires content or blocks.");
-				await assertReadTargetAllowed(channelId);
-				if (writeOpts) await slackActionRuntime.editSlackMessage(channelId, messageId, content ?? "", {
-					...writeOpts,
-					blocks
-				});
-				else await slackActionRuntime.editSlackMessage(channelId, messageId, content ?? "", { blocks });
-				return jsonResult({ ok: true });
-			}
-			case "deleteMessage": {
-				const channelId = resolveChannelId();
-				const messageId = readStringParam(params, "messageId", { required: true });
-				await assertReadTargetAllowed(channelId);
-				if (writeOpts) await slackActionRuntime.deleteSlackMessage(channelId, messageId, writeOpts);
-				else await slackActionRuntime.deleteSlackMessage(channelId, messageId);
-				return jsonResult({ ok: true });
-			}
-			case "readMessages": {
-				const channelId = resolveChannelId();
-				await assertReadTargetAllowed(channelId);
-				const limit = readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." });
-				const before = readStringParam(params, "before");
-				const after = readStringParam(params, "after");
-				const threadId = readStringParam(params, "threadId");
-				const messageId = readStringParam(params, "messageId");
-				const result = await slackActionRuntime.readSlackMessages(channelId, {
-					...readOpts,
-					limit,
-					before: before ?? void 0,
-					after: after ?? void 0,
-					threadId: threadId ?? void 0,
-					messageId: messageId ?? void 0
-				});
-				const messages = result.messages.map((message) => withNormalizedTimestamp(message, message.ts));
-				return jsonResult({
-					ok: true,
-					channelId,
-					...threadId ? { threadId } : {},
-					messages,
-					hasMore: result.hasMore
-				});
-			}
-			case "downloadFile": {
-				const fileId = readStringParam(params, "fileId", { required: true });
-				const channelTarget = readStringParam(params, "channelId") ?? readStringParam(params, "to") ?? context?.currentChannelId;
-				if (!channelTarget) throw new Error("Slack file download requires channelId or to so the read target can be authorized.");
-				const channelId = resolveSlackChannelId(channelTarget);
-				await assertReadTargetAllowed(channelId);
-				const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
-				const maxBytes = account.config?.mediaMaxMb ? account.config.mediaMaxMb * 1024 * 1024 : 20 * 1024 * 1024;
-				const readToken = resolveSlackOperationToken(account, "read");
-				const downloaded = await slackActionRuntime.downloadSlackFile(fileId, {
-					...readOpts,
-					...readToken && !readOpts?.token ? { token: readToken } : {},
-					maxBytes,
-					channelId,
-					threadId: threadId ?? void 0
-				});
-				if (!downloaded) return jsonResult({
-					ok: false,
-					error: "File could not be downloaded (not found, too large, or inaccessible)."
-				});
-				if (!isImageContentType(downloaded.contentType)) return jsonResult({
-					ok: true,
-					fileId,
-					path: downloaded.path,
-					contentType: downloaded.contentType,
-					placeholder: downloaded.placeholder,
-					media: {
-						mediaUrl: downloaded.path,
-						outbound: false,
-						...downloaded.contentType ? { contentType: downloaded.contentType } : {}
-					}
-				});
-				return await imageResultFromFile({
-					label: "slack-file",
-					path: downloaded.path,
-					extraText: downloaded.placeholder,
-					details: {
-						fileId,
-						path: downloaded.path,
-						...downloaded.contentType ? { contentType: downloaded.contentType } : {},
-						media: { outbound: false }
-					}
-				});
-			}
-			default: break;
-		}
-	}
-	if (pinActions.has(action)) {
-		if (!isActionEnabled("pins")) throw new Error("Slack pins are disabled.");
-		const channelId = resolveChannelId();
-		if (action === "pinMessage") {
-			const messageId = readStringParam(params, "messageId", { required: true });
-			await assertReadTargetAllowed(channelId);
-			if (writeOpts) await slackActionRuntime.pinSlackMessage(channelId, messageId, writeOpts);
-			else await slackActionRuntime.pinSlackMessage(channelId, messageId);
-			return jsonResult({ ok: true });
-		}
-		if (action === "unpinMessage") {
-			const messageId = readStringParam(params, "messageId", { required: true });
-			await assertReadTargetAllowed(channelId);
-			if (writeOpts) await slackActionRuntime.unpinSlackMessage(channelId, messageId, writeOpts);
-			else await slackActionRuntime.unpinSlackMessage(channelId, messageId);
-			return jsonResult({ ok: true });
-		}
-		await assertReadTargetAllowed(channelId);
-		return jsonResult({
-			ok: true,
-			pins: (writeOpts ? await slackActionRuntime.listSlackPins(channelId, readOpts) : await slackActionRuntime.listSlackPins(channelId)).map((pin) => {
-				const message = pin.message ? withNormalizedTimestamp(pin.message, pin.message.ts) : pin.message;
-				return message ? Object.assign({}, pin, { message }) : pin;
-			})
-		});
-	}
-	if (action === "memberInfo") {
-		if (!isActionEnabled("memberInfo")) throw new Error("Slack member info is disabled.");
-		const userId = readStringParam(params, "userId", { required: true });
-		assertSlackMemberInfoAllowed({
-			account,
-			context,
-			userId
-		});
-		return jsonResult({
-			ok: true,
-			info: readOpts ? await slackActionRuntime.getSlackMemberInfo(userId, readOpts) : await slackActionRuntime.getSlackMemberInfo(userId)
-		});
-	}
-	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 result = readOpts ? await slackActionRuntime.listSlackEmojis(readOpts) : await slackActionRuntime.listSlackEmojis();
-		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
-		});
-	}
-	throw new Error(`Unknown action: ${action}`);
-}
-//#endregion
-export { slackActionRuntime as n, handleSlackAction as t };

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

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