@openclaw/slack 2026.8.1-beta.3 → 2026.8.2

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-C3sePHWa.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 isSocketMode = mode === "socket";
+	const configBot = inspectSlackToken(merged.botToken);
+	const configApp = inspectSlackToken(isSocketMode ? merged.appToken : void 0);
+	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 && isSocketMode ? 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-C3sePHWa.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-B0kRJ69h.js}

@@ -1,16 +1,18 @@
-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 { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-PbxGDbr9.js";
+import { t as slackContextTargetsMatch } from "./targets-7FexXJ62.js";
+import { At as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, b as hasSlackNativeDataBlock, c as assertSlackDetachedTargetAllowed, jt as resolveSlackAutoThreadId, ot as parseSlackBlocksInput, t as buildSlackChannelIdCandidates, yt as getSlackInstallationKind } from "./group-policy-BYH74y50.js";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-CUpBeOt9.js";
+import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.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([
+	"openConversation",
 	"sendMessage",
 	"uploadFile",
 	"editMessage",
@@ -24,10 +26,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-BOxiu2Vy.js").then((n) => n.t));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-DRuEK6mL.js"));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-ChkODKBW.js").then((n) => n.t));
 function createLazySlackAction(key) {
 	return (async (...args) => {
 		const action = (await loadSlackActionsRuntime())[key];
@@ -42,6 +44,7 @@ const slackActionRuntime = {
 	listSlackEmojis: createLazySlackAction("listSlackEmojis"),
 	listSlackPins: createLazySlackAction("listSlackPins"),
 	listSlackReactions: createLazySlackAction("listSlackReactions"),
+	openSlackConversation: createLazySlackAction("openSlackConversation"),
 	parseSlackBlocksInput,
 	pinSlackMessage: createLazySlackAction("pinSlackMessage"),
 	reactSlackMessage: createLazySlackAction("reactSlackMessage"),
@@ -278,7 +281,8 @@ async function handleSlackAction(params, cfg, context) {
 		accountId
 	});
 	const resolveChannelTarget = () => resolveSlackActionChannelTarget(account, readStringParam(params, "channelId", { required: true }), context);
-	const isActionEnabled = createActionGate(account.actions ?? cfg.channels?.slack?.actions);
+	const actionConfig = account.actions ?? cfg.channels?.slack?.actions;
+	const isActionEnabled = createActionGate(actionConfig);
 	const botToken = account.botToken?.trim();
 	const buildActionOpts = (operation, teamId) => {
 		const token = resolveSlackOperationToken(account, operation);
@@ -318,10 +322,13 @@ async function handleSlackAction(params, cfg, context) {
 					removed: emoji
 				});
 			}
-			if (isEmpty) return jsonResult({
-				ok: true,
-				removed: await slackActionRuntime.removeOwnSlackReactions(channelId, messageId, writeOpts)
-			});
+			if (isEmpty) {
+				const removed = await slackActionRuntime.removeOwnSlackReactions(channelId, messageId, writeOpts);
+				return jsonResult({
+					ok: true,
+					removed
+				});
+			}
 			await slackActionRuntime.reactSlackMessage(channelId, messageId, emoji, writeOpts);
 			return jsonResult({
 				ok: true,
@@ -329,14 +336,16 @@ 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);
+		const reactions = await slackActionRuntime.listSlackReactions(channelId, messageId, readOpts);
 		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)
+			reactions: reactions?.map((reaction) => reaction.users ? Object.assign({}, reaction, { users: reaction.users.slice(0, limit) }) : reaction)
 		});
 	}
 	if (messagingActions.has(action)) {
 		if (!isActionEnabled("messages")) throw new Error("Slack messages are disabled.");
+		const sentResults = [];
 		const sendSlackMessage = async (target, content, options) => {
 			const replyReference = context?.hasRepliedRef && slackContextTargetsMatch(target, context) ? context.hasRepliedRef : void 0;
 			const result = await slackActionRuntime.sendSlackMessage(target, content, {
@@ -346,9 +355,22 @@ async function handleSlackAction(params, cfg, context) {
 				} } : {}
 			});
 			if (replyReference) replyReference.value = true;
+			sentResults.push(result);
 			return result;
 		};
 		switch (action) {
+			case "openConversation": {
+				const teamId = readStringParam(params, "teamId") ?? resolveTrustedCurrentSlackTeamId({
+					account,
+					context
+				});
+				assertSlackDetachedTargetAllowed(account.accountId, teamId);
+				const result = await slackActionRuntime.openSlackConversation(params.userIds, buildActionOpts("write", teamId));
+				return jsonResult({
+					ok: true,
+					...result
+				});
+			}
 			case "sendMessage": {
 				const destination = resolveSlackActionTarget(account, readStringParam(params, "to", { required: true }), context).routingTarget;
 				const content = readStringParam(params, "content", { allowEmpty: true });
@@ -396,35 +418,27 @@ async function handleSlackAction(params, cfg, context) {
 						blocks
 					});
 				};
+				if (mediaUrl && (preparedMessages?.length || blocks)) await sendSlackMessage(destination, "", {
+					...preparedMessages?.length ? baseSendOpts : sendOpts,
+					mediaUrl
+				});
+				if (preparedMessages?.length) for (const [index, message] of preparedMessages.entries()) await sendSlackMessage(destination, 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 } : {}
+				});
+				else if (blocks) await sendContentAndBlocks();
+				else await sendSlackMessage(destination, content ?? "", {
+					...sendOpts,
+					mediaUrl: mediaUrl ?? void 0,
+					blocks
+				});
 				return jsonResult({
 					ok: true,
-					result: preparedMessages?.length ? await (async () => {
-						let lastResult;
-						if (mediaUrl) lastResult = await sendSlackMessage(destination, "", {
-							...baseSendOpts,
-							mediaUrl
-						});
-						for (const [index, message] of preparedMessages.entries()) lastResult = await sendSlackMessage(destination, 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 sendSlackMessage(destination, "", {
-							...sendOpts,
-							mediaUrl
-						});
-						return await sendContentAndBlocks();
-					})() : await sendSlackMessage(destination, content ?? "", {
-						...sendOpts,
-						mediaUrl: mediaUrl ?? void 0,
-						blocks
-					})
+					result: mergeSlackSendResults(sentResults)
 				});
 			}
 			case "uploadFile": {
@@ -439,19 +453,20 @@ async function handleSlackAction(params, cfg, context) {
 				const forceDocument = readBooleanParam(params, "forceDocument") === true;
 				if (readBooleanParam(params, "replyBroadcast")) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
 				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
+				const result = await sendSlackMessage(destination, initialComment ?? "", {
+					...buildActionOpts("write"),
+					mediaUrl: filePath,
+					mediaAccess: context?.mediaAccess,
+					mediaLocalRoots: context?.mediaLocalRoots,
+					mediaReadFile: context?.mediaReadFile,
+					threadTs: threadTs ?? void 0,
+					...forceDocument ? { forceDocument: true } : {},
+					...filename ? { uploadFileName: filename } : {},
+					...title ? { uploadTitle: title } : {}
+				});
 				return jsonResult({
 					ok: true,
-					result: await sendSlackMessage(destination, initialComment ?? "", {
-						...buildActionOpts("write"),
-						mediaUrl: filePath,
-						mediaAccess: context?.mediaAccess,
-						mediaLocalRoots: context?.mediaLocalRoots,
-						mediaReadFile: context?.mediaReadFile,
-						threadTs: threadTs ?? void 0,
-						...forceDocument ? { forceDocument: true } : {},
-						...filename ? { uploadFileName: filename } : {},
-						...title ? { uploadTitle: title } : {}
-					})
+					result
 				});
 			}
 			case "editMessage": {
@@ -513,7 +528,7 @@ async function handleSlackAction(params, cfg, context) {
 				const { channelId } = target;
 				await assertReadTargetAllowed(target);
 				const threadId = readStringParam(params, "threadId") ?? readStringParam(params, "replyTo");
-				const maxBytes = account.config?.mediaMaxMb ? account.config.mediaMaxMb * 1024 * 1024 : 20 * 1024 * 1024;
+				const maxBytes = account.config?.mediaMaxMb ? account.config.mediaMaxMb * 1024 * 1024 : 20971520;
 				const readToken = resolveSlackOperationToken(account, "read");
 				const readOpts = buildActionOpts("read", target.teamId);
 				const downloaded = await slackActionRuntime.downloadSlackFile(fileId, {
@@ -525,7 +540,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,
@@ -548,10 +563,10 @@ async function handleSlackAction(params, cfg, context) {
 						path: downloaded.path,
 						...downloaded.contentType ? { contentType: downloaded.contentType } : {},
 						media: { outbound: false }
-					}
+					},
+					imageSanitization: { maxDimensionPx: cfg.agents?.defaults?.imageMaxDimensionPx }
 				});
 			}
-			default: break;
 		}
 	}
 	if (pinActions.has(action)) {
@@ -573,12 +588,13 @@ async function handleSlackAction(params, cfg, context) {
 			return jsonResult({ ok: true });
 		}
 		await assertReadTargetAllowed(target);
+		const normalizedPins = (await slackActionRuntime.listSlackPins(channelId, readOpts)).map((pin) => {
+			const message = pin.message ? withNormalizedTimestamp(pin.message, pin.message.ts) : pin.message;
+			return message ? Object.assign({}, pin, { message }) : pin;
+		});
 		return jsonResult({
 			ok: true,
-			pins: (await slackActionRuntime.listSlackPins(channelId, readOpts)).map((pin) => {
-				const message = pin.message ? withNormalizedTimestamp(pin.message, pin.message.ts) : pin.message;
-				return message ? Object.assign({}, pin, { message }) : pin;
-			})
+			pins: normalizedPins
 		});
 	}
 	if (action === "memberInfo") {
@@ -594,33 +610,32 @@ async function handleSlackAction(params, cfg, context) {
 			context
 		});
 		assertSlackDetachedTargetAllowed(account.accountId, teamId);
+		const info = await slackActionRuntime.getSlackMemberInfo(userId, buildActionOpts("read", teamId));
 		return jsonResult({
 			ok: true,
-			info: await slackActionRuntime.getSlackMemberInfo(userId, buildActionOpts("read", teamId))
+			info
 		});
 	}
 	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))
-				}
-			});
-		}
+		const 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
+		});
 		return jsonResult({
 			ok: true,
-			emojis: result
+			emojis
 		});
 	}
 	throw new Error(`Unknown action: ${action}`);

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

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