@openclaw/slack 2026.5.12-beta.7

package/dist/account-inspect-D7AZNs8C.js

@@ -0,0 +1,77 @@
+import { i as resolveDefaultSlackAccountId, r as mergeSlackAccountConfig } from "./accounts-ClAPP5ry.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 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 isHttpMode = mode === "http";
+	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 ? normalizeSecretInputString(params.envAppToken ?? process.env.SLACK_APP_TOKEN) : void 0;
+	const envUser = allowEnv ? normalizeSecretInputString(params.envUserToken ?? process.env.SLACK_USER_TOKEN) : void 0;
+	const botToken = configBot.token ?? envBot;
+	const appToken = configApp.token ?? envApp;
+	const signingSecret = configSigningSecret.token;
+	const userToken = configUser.token ?? envUser;
+	const botTokenSource = configBot.token ? "config" : configBot.status === "configured_unavailable" ? "config" : envBot ? "env" : "none";
+	const appTokenSource = configApp.token ? "config" : configApp.status === "configured_unavailable" ? "config" : envApp ? "env" : "none";
+	const signingSecretSource = configSigningSecret.token ? "config" : configSigningSecret.status === "configured_unavailable" ? "config" : "none";
+	const userTokenSource = configUser.token ? "config" : configUser.status === "configured_unavailable" ? "config" : envUser ? "env" : "none";
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		mode,
+		botToken,
+		appToken,
+		...isHttpMode ? { signingSecret } : {},
+		userToken,
+		botTokenSource,
+		appTokenSource,
+		...isHttpMode ? { signingSecretSource } : {},
+		userTokenSource,
+		botTokenStatus: configBot.token ? "available" : configBot.status === "configured_unavailable" ? "configured_unavailable" : envBot ? "available" : "missing",
+		appTokenStatus: configApp.token ? "available" : configApp.status === "configured_unavailable" ? "configured_unavailable" : envApp ? "available" : "missing",
+		...isHttpMode ? { signingSecretStatus: configSigningSecret.token ? "available" : configSigningSecret.status === "configured_unavailable" ? "configured_unavailable" : "missing" } : {},
+		userTokenStatus: configUser.token ? "available" : configUser.status === "configured_unavailable" ? "configured_unavailable" : envUser ? "available" : "missing",
+		configured: isHttpMode ? (configBot.status !== "missing" || Boolean(envBot)) && configSigningSecret.status !== "missing" : (configBot.status !== "missing" || Boolean(envBot)) && (configApp.status !== "missing" || Boolean(envApp)),
+		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

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

package/dist/accounts-ClAPP5ry.js

@@ -0,0 +1,139 @@
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { mapAllowFromEntries, normalizeChannelDmPolicy, resolveChannelDmAllowFrom, resolveChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
+import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
+//#region extensions/slack/src/token.ts
+function resolveSlackBotToken(raw, path = "channels.slack.botToken") {
+	return normalizeResolvedSecretInputString({
+		value: raw,
+		path
+	});
+}
+function resolveSlackAppToken(raw, path = "channels.slack.appToken") {
+	return normalizeResolvedSecretInputString({
+		value: raw,
+		path
+	});
+}
+function resolveSlackUserToken(raw, path = "channels.slack.userToken") {
+	return normalizeResolvedSecretInputString({
+		value: raw,
+		path
+	});
+}
+//#endregion
+//#region extensions/slack/src/account-reply-mode.ts
+function normalizeSlackChatType(raw) {
+	const value = raw?.trim().toLowerCase();
+	if (!value) return;
+	if (value === "direct" || value === "dm") return "direct";
+	if (value === "group" || value === "channel") return value;
+}
+function resolveSlackReplyToMode(account, chatType) {
+	const normalized = normalizeSlackChatType(chatType ?? void 0);
+	if (normalized && account.replyToModeByChatType?.[normalized] !== void 0) return account.replyToModeByChatType[normalized] ?? "off";
+	if (normalized === "direct" && account.dm?.replyToMode !== void 0) return account.dm.replyToMode;
+	return account.replyToMode ?? "off";
+}
+//#endregion
+//#region extensions/slack/src/accounts.ts
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("slack");
+const listSlackAccountIds = listAccountIds;
+const resolveDefaultSlackAccountId = resolveDefaultAccountId;
+function resolveSlackAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.slack?.accounts, accountId);
+}
+function mergeSlackAccountConfig(cfg, accountId) {
+	return resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.slack,
+		accounts: cfg.channels?.slack?.accounts,
+		accountId
+	});
+}
+function resolveSlackAccountAllowFrom(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const accountConfig = resolveSlackAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.slack;
+	const allowFrom = resolveChannelDmAllowFrom({
+		account: accountConfig,
+		parent: rootConfig
+	});
+	return allowFrom ? mapAllowFromEntries(allowFrom) : void 0;
+}
+function resolveSlackConfigAccessorAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const config = mergeSlackAccountConfig(params.cfg, accountId);
+	return {
+		allowFrom: resolveSlackAccountAllowFrom({
+			cfg: params.cfg,
+			accountId
+		}),
+		defaultTo: config.defaultTo
+	};
+}
+function resolveSlackAccountDmPolicy(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const accountConfig = resolveSlackAccountConfig(params.cfg, accountId);
+	const rootConfig = params.cfg.channels?.slack;
+	return normalizeChannelDmPolicy(resolveChannelDmPolicy({
+		account: accountConfig,
+		parent: rootConfig,
+		defaultPolicy: "pairing"
+	}));
+}
+function resolveSlackAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
+	const baseEnabled = params.cfg.channels?.slack?.enabled !== false;
+	const merged = mergeSlackAccountConfig(params.cfg, accountId);
+	const accountEnabled = merged.enabled !== false;
+	const enabled = baseEnabled && accountEnabled;
+	const mode = merged.mode ?? "socket";
+	const baseAllowEnv = accountId === DEFAULT_ACCOUNT_ID;
+	const botActive = enabled;
+	const appActive = enabled && mode !== "http";
+	const userActive = enabled;
+	const envBot = botActive && baseAllowEnv ? resolveSlackBotToken(process.env.SLACK_BOT_TOKEN) : void 0;
+	const envApp = appActive && baseAllowEnv ? resolveSlackAppToken(process.env.SLACK_APP_TOKEN) : void 0;
+	const envUser = userActive && baseAllowEnv ? resolveSlackUserToken(process.env.SLACK_USER_TOKEN) : void 0;
+	const configBot = botActive ? resolveSlackBotToken(merged.botToken, `channels.slack.accounts.${accountId}.botToken`) : void 0;
+	const configApp = appActive ? resolveSlackAppToken(merged.appToken, `channels.slack.accounts.${accountId}.appToken`) : void 0;
+	const configUser = userActive ? resolveSlackUserToken(merged.userToken, `channels.slack.accounts.${accountId}.userToken`) : void 0;
+	const botToken = configBot ?? envBot;
+	const appToken = configApp ?? envApp;
+	const userToken = configUser ?? envUser;
+	const botTokenSource = configBot ? "config" : envBot ? "env" : "none";
+	const appTokenSource = configApp ? "config" : envApp ? "env" : "none";
+	const userTokenSource = configUser ? "config" : envUser ? "env" : "none";
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		botToken,
+		appToken,
+		userToken,
+		botTokenSource,
+		appTokenSource,
+		userTokenSource,
+		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
+	};
+}
+function listEnabledSlackAccounts(cfg) {
+	return listSlackAccountIds(cfg).map((accountId) => resolveSlackAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resolveSlackAccount as a, resolveSlackConfigAccessorAccount as c, resolveSlackBotToken as d, resolveDefaultSlackAccountId as i, resolveSlackReplyToMode as l, listSlackAccountIds as n, resolveSlackAccountAllowFrom as o, mergeSlackAccountConfig as r, resolveSlackAccountDmPolicy as s, listEnabledSlackAccounts as t, resolveSlackAppToken as u };

package/dist/accounts.runtime-DDVcLJUI.js

@@ -0,0 +1,2 @@
+import { a as resolveSlackAccount } from "./accounts-ClAPP5ry.js";
+export { resolveSlackAccount };

package/dist/action-runtime-e2UhRsNx.js

@@ -0,0 +1,350 @@
+import { i as resolveSlackChannelId, r as parseSlackTarget } from "./target-parsing-CQmv-iSm.js";
+import "./targets-B1tYCAr6.js";
+import { n as parseSlackBlocksInput } from "./blocks-input-CwTFVImV.js";
+import { a as readNumberParam, c as withNormalizedTimestamp, n as imageResultFromFile, o as readReactionParams, r as jsonResult, s as readStringParam, t as createActionGate } from "./runtime-api-Dd1xIV5v.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
+import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
+//#region extensions/slack/src/action-runtime.ts
+const messagingActions = new Set([
+	"sendMessage",
+	"uploadFile",
+	"editMessage",
+	"deleteMessage",
+	"readMessages",
+	"downloadFile"
+]);
+const reactionsActions = new Set(["react", "reactions"]);
+const pinActions = new Set([
+	"pinMessage",
+	"unpinMessage",
+	"listPins"
+]);
+function sameSlackChannelTarget(targetChannel, currentChannelId) {
+	const parsedTarget = parseSlackTarget(targetChannel, { defaultKind: "channel" });
+	if (!parsedTarget || parsedTarget.kind !== "channel") return false;
+	return normalizeLowercaseStringOrEmpty(parsedTarget.id) === normalizeLowercaseStringOrEmpty(currentChannelId);
+}
+let slackActionsRuntimePromise;
+let slackAccountsRuntimePromise;
+function loadSlackActionsRuntime() {
+	slackActionsRuntimePromise ??= import("./actions.runtime-CO3OaTLb.js");
+	return slackActionsRuntimePromise;
+}
+function loadSlackAccountsRuntime() {
+	slackAccountsRuntimePromise ??= import("./accounts.runtime-DDVcLJUI.js");
+	return slackAccountsRuntimePromise;
+}
+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"),
+	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?.currentThreadTs || !context?.currentChannelId) return;
+	if (!sameSlackChannelTarget(targetChannel, context.currentChannelId)) 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;
+}
+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 } = await loadSlackAccountsRuntime();
+	const account = resolveSlackAccount({
+		cfg,
+		accountId
+	});
+	const isActionEnabled = createActionGate(account.actions ?? cfg.channels?.slack?.actions);
+	const userToken = account.userToken;
+	const botToken = account.botToken?.trim();
+	const allowUserWrites = account.config.userTokenReadOnly === false;
+	const getTokenForOperation = (operation) => {
+		if (operation === "read") return userToken ?? botToken;
+		if (!allowUserWrites) return botToken;
+		return botToken ?? userToken;
+	};
+	const buildActionOpts = (operation) => {
+		const token = getTokenForOperation(operation);
+		const tokenOverride = token && token !== botToken ? token : void 0;
+		return {
+			cfg,
+			...accountId ? { accountId } : {},
+			...tokenOverride ? { token: tokenOverride } : {}
+		};
+	};
+	const readOpts = buildActionOpts("read");
+	const writeOpts = buildActionOpts("write");
+	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." });
+			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
+			});
+		}
+		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");
+				if (!content && !mediaUrl && !blocks) 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 sendOpts = {
+					...writeOpts,
+					mediaLocalRoots: context?.mediaLocalRoots,
+					mediaReadFile: context?.mediaReadFile,
+					threadTs: threadTs ?? void 0,
+					...replyBroadcast ? { replyBroadcast } : {}
+				};
+				const result = mediaUrl && blocks ? await (async () => {
+					await slackActionRuntime.sendSlackMessage(to, "", {
+						...sendOpts,
+						mediaUrl
+					});
+					return await slackActionRuntime.sendSlackMessage(to, content ?? "", {
+						...sendOpts,
+						blocks
+					});
+				})() : await slackActionRuntime.sendSlackMessage(to, content ?? "", {
+					...sendOpts,
+					mediaUrl: mediaUrl ?? void 0,
+					blocks
+				});
+				if (context?.hasRepliedRef && context.currentChannelId) {
+					if (sameSlackChannelTarget(to, context.currentChannelId)) 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 && context.currentChannelId) {
+					if (sameSlackChannelTarget(to, context.currentChannelId)) 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.");
+				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 });
+				if (writeOpts) await slackActionRuntime.deleteSlackMessage(channelId, messageId, writeOpts);
+				else await slackActionRuntime.deleteSlackMessage(channelId, messageId);
+				return jsonResult({ ok: true });
+			}
+			case "readMessages": {
+				const channelId = resolveChannelId();
+				const limitRaw = params.limit;
+				const limit = typeof limitRaw === "number" && Number.isFinite(limitRaw) ? limitRaw : void 0;
+				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
+				});
+				return jsonResult({
+					ok: true,
+					messages: result.messages.map((message) => withNormalizedTimestamp(message, message.ts)),
+					hasMore: result.hasMore
+				});
+			}
+			case "downloadFile": {
+				const fileId = readStringParam(params, "fileId", { required: true });
+				const channelTarget = readStringParam(params, "channelId") ?? readStringParam(params, "to");
+				const channelId = channelTarget ? resolveSlackChannelId(channelTarget) : void 0;
+				const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
+				const maxBytes = account.config?.mediaMaxMb ? account.config.mediaMaxMb * 1024 * 1024 : 20 * 1024 * 1024;
+				const readToken = getTokenForOperation("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,
+						...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 } : {}
+					}
+				});
+			}
+			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 });
+			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 });
+			if (writeOpts) await slackActionRuntime.unpinSlackMessage(channelId, messageId, writeOpts);
+			else await slackActionRuntime.unpinSlackMessage(channelId, messageId);
+			return jsonResult({ ok: true });
+		}
+		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 });
+		return jsonResult({
+			ok: true,
+			info: writeOpts ? await slackActionRuntime.getSlackMemberInfo(userId, readOpts) : await slackActionRuntime.getSlackMemberInfo(userId)
+		});
+	}
+	if (action === "emojiList") {
+		if (!isActionEnabled("emojiList")) throw new Error("Slack emoji list is disabled.");
+		const result = readOpts ? await slackActionRuntime.listSlackEmojis(readOpts) : await slackActionRuntime.listSlackEmojis();
+		const limit = readNumberParam(params, "limit", { integer: true });
+		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-BFcqMbOm.js

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