@openclaw/slack 2026.7.1 → 2026.7.2-beta.1

package/dist/accounts.runtime-KvftRRek.js

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

package/dist/{action-runtime-DoQGk_8D.js → action-runtime-p6M2ULpv.js}

@@ -1,8 +1,10 @@
-import { i as resolveSlackChannelId } from "./target-parsing-3jYH8LfB.js";
-import { t as slackContextTargetsMatch } from "./targets-Dll4NJgs.js";
-import { r as parseSlackBlocksInput } from "./reply-blocks-BGQ6zSqM.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-CEmqYxR-.js";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-Dj-puVPb.js";
+import { a as resolveSlackChannelId, i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
+import { t as slackContextTargetsMatch } from "./targets-KmjP2E8s.js";
+import { C as hasSlackNativeDataBlock, X as parseSlackBlocksInput } from "./group-policy-C-b2ZnSl.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-CVb6CQjX.js";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-f8b0edSi.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";
@@ -22,8 +24,9 @@ const pinActions = /* @__PURE__ */ new Set([
 	"unpinMessage",
 	"listPins"
 ]);
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions.runtime-C103_BPW.js"));
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-DWvaCb-X.js"));
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions.runtime-BSxpwgUc.js"));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-KvftRRek.js"));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-BpeTezY4.js").then((n) => n.t));
 function createLazySlackAction(key) {
 	return (async (...args) => {
 		const action = (await loadSlackActionsRuntime())[key];
@@ -45,6 +48,8 @@ const slackActionRuntime = {
 	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")
 };
@@ -75,7 +80,51 @@ function readSlackBlocksParam(params) {
 function isImageContentType(value) {
 	return value?.trim().toLowerCase().startsWith("image/") === true;
 }
-function resolveSlackReadTargetDecision(params) {
+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 ?? account.config.dm?.policy ?? "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({
@@ -87,29 +136,103 @@ function resolveSlackReadTargetDecision(params) {
 		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
 	});
-	if (isSlackChannelAllowedByPolicy({
+	const delegatedChannelAllowed = isSlackChannelAllowedByPolicy({
 		groupPolicy,
 		channelAllowlistConfigured: channelKeys.length > 0,
 		channelAllowed
-	})) return !channelAllowed && (groupPolicy !== "open" || channelConfig?.matchSource) ? "deny" : "allow";
-	return groupPolicy === "allowlist" && channelKeys.length > 0 && params.account.config.dangerouslyAllowNameMatching === true && !params.channelName && (channelConfig?.matchSource === void 0 || channelConfig.matchSource === "wildcard") ? "resolve-name" : "deny";
+	}) && !(!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 direct = resolveSlackReadTargetDecision(params);
-	if (direct === "allow") return;
-	if (direct === "resolve-name") {
-		const channelName = await params.resolveChannelName();
-		if (channelName && resolveSlackReadTargetDecision({
+	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,
-			channelName
-		}) === "allow") return;
+			userId: info.user
+		})) deny();
+		return;
 	}
-	throw new Error("Slack read target channel is not allowed.");
+	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 }));
@@ -120,6 +243,7 @@ async function handleSlackAction(params, cfg, context) {
 		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 userToken = account.userToken;
 	const botToken = account.botToken?.trim();
@@ -144,7 +268,8 @@ async function handleSlackAction(params, cfg, context) {
 		account,
 		cfg,
 		channelId,
-		resolveChannelName: async () => await slackActionRuntime.resolveSlackConversationName(channelId, readOpts)
+		conversationReadOrigin: context?.conversationReadOrigin,
+		context
 	});
 	if (reactionsActions.has(action)) {
 		if (!isActionEnabled("reactions")) throw new Error("Slack reactions are disabled.");
@@ -152,6 +277,7 @@ async function handleSlackAction(params, cfg, context) {
 		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);
@@ -186,25 +312,66 @@ async function handleSlackAction(params, cfg, context) {
 				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.");
+				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 sendOpts = {
+				const baseSendOpts = {
 					...writeOpts,
 					mediaLocalRoots: context?.mediaLocalRoots,
 					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...replyBroadcast ? { replyBroadcast } : {}
+					threadTs: threadTs ?? void 0
+				};
+				const sendOpts = {
+					...baseSendOpts,
+					...replyBroadcast ? { replyBroadcast } : {},
+					...textIsSlackMrkdwn ? { textIsSlackMrkdwn: true } : {},
+					...textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+					...authoredTextPlacement ? { authoredTextPlacement } : {},
+					...nativeDataFallbackBaseText !== void 0 ? { nativeDataFallbackBaseText } : {}
 				};
-				const result = mediaUrl && blocks ? await (async () => {
-					await slackActionRuntime.sendSlackMessage(to, "", {
+				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
 					});
-					return await slackActionRuntime.sendSlackMessage(to, content ?? "", {
+					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,
-						blocks
+						mediaUrl
 					});
+					return await sendContentAndBlocks();
 				})() : await slackActionRuntime.sendSlackMessage(to, content ?? "", {
 					...sendOpts,
 					mediaUrl: mediaUrl ?? void 0,
@@ -248,6 +415,7 @@ async function handleSlackAction(params, cfg, context) {
 				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
@@ -258,6 +426,7 @@ async function handleSlackAction(params, cfg, context) {
 			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 });
@@ -336,12 +505,14 @@ async function handleSlackAction(params, cfg, context) {
 		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 });
@@ -358,9 +529,14 @@ async function handleSlackAction(params, cfg, context) {
 	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: writeOpts ? await slackActionRuntime.getSlackMemberInfo(userId, readOpts) : await slackActionRuntime.getSlackMemberInfo(userId)
+			info: readOpts ? await slackActionRuntime.getSlackMemberInfo(userId, readOpts) : await slackActionRuntime.getSlackMemberInfo(userId)
 		});
 	}
 	if (action === "emojiList") {

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

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