@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/.setup/shared-BqyNq0up.mjs

@@ -0,0 +1,269 @@
+import { a as resolveSlackAccount, c as resolveSlackConfigAccessorAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig, s as resolveSlackAccountDmPolicy } from "./accounts-uGn8E6uq.mjs";
+import { t as inspectSlackAccount } from "./account-inspect-CcqRNkC3.mjs";
+import { t as isSlackPluginAccountConfigured } from "./account-configured-DzC407uv.mjs";
+import { n as isSlackInteractiveRepliesEnabled } from "./interactive-replies-BLw4HEPS.mjs";
+import { f as getChatChannelMeta } from "./client-B6i83rHk.mjs";
+import { i as SLACK_CHANNEL } from "./setup-core-uPGudyJH.mjs";
+import { t as SlackChannelConfigSchema } from "./config-schema-DV93lEJ7.mjs";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-Dxk57DKz.mjs";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-C3ChHo5A.mjs";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+import { createDangerousNameMatchingMutableAllowlistWarningCollector, createOpenProviderConfiguredRouteWarningCollector } from "openclaw/plugin-sdk/channel-policy";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+//#region extensions/slack/src/security.ts
+const resolveSlackDmPolicy = createScopedDmSecurityResolver({
+	channelKey: "slack",
+	resolvePolicy: (account) => account.config.dmPolicy,
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	resolveAccess: ({ cfg, account }) => ({
+		dmPolicy: resolveSlackAccountDmPolicy({
+			cfg,
+			accountId: account.accountId
+		}),
+		allowFrom: resolveSlackAccountAllowFrom({
+			cfg,
+			accountId: account.accountId
+		})
+	}),
+	policyPathSuffix: "dmPolicy",
+	normalizeEntry: (raw) => raw.trim().replace(/^(slack|user):/i, "").trim()
+});
+const collectSlackSecurityWarnings = createOpenProviderConfiguredRouteWarningCollector({
+	providerConfigPresent: (cfg) => cfg.channels?.slack !== void 0,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	resolveRouteAllowlistConfigured: (account) => Boolean(account.config.channels) && Object.keys(account.config.channels ?? {}).length > 0,
+	configureRouteAllowlist: {
+		surface: "Slack channels",
+		openScope: "any channel not explicitly denied",
+		groupPolicyPath: "channels.slack.groupPolicy",
+		routeAllowlistPath: "channels.slack.channels"
+	},
+	missingRouteAllowlist: {
+		surface: "Slack channels",
+		openBehavior: "with no channel allowlist; any channel can trigger (mention-gated)",
+		remediation: "Set channels.slack.groupPolicy=\"allowlist\" and configure channels.slack.channels"
+	}
+});
+const loadSlackSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit-HMEYeSrJ.mjs").then((n) => n.n));
+const slackSecurityAdapter = {
+	resolveDmPolicy: resolveSlackDmPolicy,
+	collectWarnings: collectSlackSecurityWarnings,
+	collectAuditFindings: async (params) => {
+		const { collectSlackSecurityAuditFindings } = await loadSlackSecurityAuditModule();
+		return await collectSlackSecurityAuditFindings(params);
+	}
+};
+//#endregion
+//#region extensions/slack/src/security-doctor.ts
+function isSlackMutableAllowEntry(raw) {
+	const text = raw.trim();
+	if (!text || text === "*") return false;
+	const mentionMatch = text.match(/^<@([A-Z0-9]+)>$/i);
+	if (mentionMatch && /^[A-Z0-9]{8,}$/i.test(mentionMatch[1] ?? "")) return false;
+	const withoutPrefix = text.replace(/^(slack|user):/i, "").trim();
+	if (/^[UWBCGDT][A-Z0-9]{2,}$/.test(withoutPrefix)) return false;
+	if (/^[A-Z0-9]{8,}$/i.test(withoutPrefix)) return false;
+	return true;
+}
+//#endregion
+//#region extensions/slack/src/doctor.ts
+function asObjectRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+const collectSlackMutableAllowlistWarnings = createDangerousNameMatchingMutableAllowlistWarningCollector({
+	channel: "slack",
+	detector: isSlackMutableAllowEntry,
+	collectLists: (scope) => {
+		const lists = [{
+			pathLabel: `${scope.prefix}.allowFrom`,
+			list: scope.account.allowFrom
+		}];
+		const dm = asObjectRecord(scope.account.dm);
+		if (dm) lists.push({
+			pathLabel: `${scope.prefix}.dm.allowFrom`,
+			list: dm.allowFrom
+		});
+		const channels = asObjectRecord(scope.account.channels);
+		if (channels) for (const [channelKey, channelRaw] of Object.entries(channels)) {
+			const channel = asObjectRecord(channelRaw);
+			if (!channel) continue;
+			lists.push({
+				pathLabel: `${scope.prefix}.channels.${channelKey}.users`,
+				list: channel.users
+			});
+		}
+		return lists;
+	}
+});
+const SLACK_CANONICAL_CHANNEL_ID_RE = /^[CG][A-Z0-9]{8,}$/;
+const SLACK_LOWERCASE_CHANNEL_ID_RE = /^[cg][0-9][a-z0-9]{7,}$/;
+const SLACK_PREFIXED_CANONICAL_CHANNEL_ID_RE = /^channel:[CG][A-Z0-9]{8,}$/;
+const SLACK_PREFIXED_LOWERCASE_CHANNEL_ID_RE = /^channel:[cg][0-9][a-z0-9]{7,}$/;
+const SLACK_CANONICAL_DM_ID_RE = /^(?:channel:)?D[A-Z0-9]{8,}$/;
+const SLACK_PREFIXED_LOWERCASE_DM_ID_RE = /^channel:d[a-z0-9]{8,}$/;
+const SLACK_AMBIGUOUS_LOWERCASE_DM_ID_RE = /^d[a-z0-9]{8,}$/;
+const SLACK_AMBIGUOUS_LOWERCASE_CHANNEL_ID_RE = /^(?:channel:)?[cgd][a-z][a-z0-9]{7,}$/;
+const SLACK_CHANNEL_NAME_RE = /^[\p{L}\p{M}\p{N}_-]{1,80}$/u;
+const SLACK_CHANNEL_NAME_ALPHANUMERIC_RE = /[\p{L}\p{N}]/u;
+function looksLikeSlackChannelId(channelKey) {
+	return SLACK_CANONICAL_CHANNEL_ID_RE.test(channelKey) || SLACK_LOWERCASE_CHANNEL_ID_RE.test(channelKey) || SLACK_PREFIXED_CANONICAL_CHANNEL_ID_RE.test(channelKey) || SLACK_PREFIXED_LOWERCASE_CHANNEL_ID_RE.test(channelKey);
+}
+function looksLikeSlackDmId(channelKey) {
+	return SLACK_CANONICAL_DM_ID_RE.test(channelKey) || SLACK_PREFIXED_LOWERCASE_DM_ID_RE.test(channelKey);
+}
+function looksLikeSlackChannelNameKey(channelKey) {
+	const name = channelKey.startsWith("#") ? channelKey.slice(1) : channelKey;
+	return name === name.toLowerCase() && SLACK_CHANNEL_NAME_RE.test(name) && SLACK_CHANNEL_NAME_ALPHANUMERIC_RE.test(name);
+}
+function collectSlackNameKeyedChannelWarnings({ cfg }) {
+	const warnings = /* @__PURE__ */ new Set();
+	const slackCfg = asObjectRecord(asObjectRecord(cfg.channels)?.slack);
+	const providerChannels = asObjectRecord(slackCfg?.channels);
+	const accounts = asObjectRecord(slackCfg?.accounts);
+	for (const accountId of listSlackAccountIds(cfg)) {
+		const account = asObjectRecord(mergeSlackAccountConfig(cfg, accountId));
+		if (!account || slackCfg?.enabled === false || account.enabled === false) continue;
+		const effectiveGroupPolicy = (typeof account.groupPolicy === "string" ? account.groupPolicy : void 0) ?? "allowlist";
+		const rawAccount = asObjectRecord(accounts?.[accountId]);
+		const accountPrefix = rawAccount ? `channels.slack.accounts.${accountId}` : "channels.slack";
+		const accountChannels = asObjectRecord(rawAccount?.channels);
+		const channels = accountChannels ?? providerChannels;
+		if (!channels) continue;
+		const channelsPrefix = accountChannels ? `channels.slack.accounts.${accountId}` : "channels.slack";
+		const fallbackDescription = Object.hasOwn(channels, "*") ? `${channelsPrefix}.channels."*" applies instead and this entry's overrides are ignored` : effectiveGroupPolicy === "open" ? "this entry's overrides are ignored and the channel remains allowed by groupPolicy: \"open\"" : "messages from the channel are dropped";
+		for (const channelKey of Object.keys(channels)) {
+			if (channelKey === "*") continue;
+			if (looksLikeSlackDmId(channelKey)) {
+				warnings.add(`${channelsPrefix}.channels."${channelKey}" is a Slack DM conversation ID, but ${channelsPrefix}.channels only configures channel and group rooms. Configure DM access with ${accountPrefix}.dmPolicy and ${accountPrefix}.allowFrom instead.`);
+				continue;
+			}
+			if (SLACK_AMBIGUOUS_LOWERCASE_DM_ID_RE.test(channelKey)) {
+				if (account.dangerouslyAllowNameMatching === true && looksLikeSlackChannelNameKey(channelKey)) continue;
+				warnings.add(`${channelsPrefix}.channels."${channelKey}" is ambiguous: it may be a lowercase Slack DM conversation ID or a channel name. Configure DMs with ${accountPrefix}.dmPolicy and ${accountPrefix}.allowFrom; otherwise re-key the room with its stable C/G ID.`);
+				continue;
+			}
+			if (effectiveGroupPolicy === "disabled") continue;
+			const channelConfig = asObjectRecord(channels[channelKey]);
+			if (effectiveGroupPolicy === "open" && Object.keys(channelConfig ?? {}).length === 0) continue;
+			if (looksLikeSlackChannelId(channelKey)) continue;
+			if (account.dangerouslyAllowNameMatching === true && looksLikeSlackChannelNameKey(channelKey)) continue;
+			if (SLACK_AMBIGUOUS_LOWERCASE_CHANNEL_ID_RE.test(channelKey)) {
+				warnings.add(`${channelsPrefix}.channels."${channelKey}" is ambiguous: it may be a lowercase Slack channel ID or a channel name. If it is a channel name, inbound routing will not match it and ${fallbackDescription}. Re-key it with the channel's stable ID (e.g. C0123ABCD, from the channel's About details or conversations.info).`);
+				continue;
+			}
+			warnings.add(`${channelsPrefix}.channels."${channelKey}" is keyed by a channel name or non-canonical ID form, not a routable Slack channel ID; under groupPolicy: "${effectiveGroupPolicy}" inbound routing does not match this entry, so ${fallbackDescription}. Re-key it with the channel's ID (e.g. C0123ABCD, from the channel's About details or conversations.info).`);
+		}
+	}
+	return [...warnings];
+}
+const slackDoctor = {
+	dmAllowFromMode: "topOnly",
+	groupModel: "route",
+	groupAllowFromFallbackToAllowFrom: false,
+	warnOnEmptyGroupSenderAllowlist: false,
+	legacyConfigRules,
+	normalizeCompatibilityConfig,
+	collectMutableAllowlistWarnings: ({ cfg }) => [...collectSlackMutableAllowlistWarnings({ cfg }), ...collectSlackNameKeyedChannelWarnings({ cfg })]
+};
+//#endregion
+//#region extensions/slack/src/shared.ts
+const slackConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: SLACK_CHANNEL,
+	listAccountIds: listSlackAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveSlackAccount),
+	resolveAccessorAccount: resolveSlackConfigAccessorAccount,
+	inspectAccount: adaptScopedAccountAccessor(inspectSlackAccount),
+	defaultAccountId: resolveDefaultSlackAccountId,
+	clearBaseFields: [
+		"botToken",
+		"appToken",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+function createSlackPluginBase(params) {
+	return {
+		id: SLACK_CHANNEL,
+		meta: {
+			...getChatChannelMeta(SLACK_CHANNEL),
+			preferSessionLookupForAnnounceTarget: true
+		},
+		setupWizard: params.setupWizard,
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"channel",
+				"thread"
+			],
+			reactions: true,
+			threads: true,
+			media: true,
+			nativeCommands: true
+		},
+		commands: {
+			nativeCommandsAutoEnabled: false,
+			nativeSkillsAutoEnabled: false,
+			resolveNativeCommandName: ({ commandKey, defaultName }) => commandKey === "status" ? "agentstatus" : defaultName
+		},
+		doctor: slackDoctor,
+		agentPrompt: {
+			inboundFormattingHints: () => ({
+				text_markup: "slack_mrkdwn",
+				rules: [
+					"Use Slack mrkdwn, not standard Markdown.",
+					"Bold uses *single asterisks*.",
+					"Links use <url|label>.",
+					"Code blocks use triple backticks without a language identifier.",
+					"Do not use markdown headings or pipe tables."
+				]
+			}),
+			messageToolHints: ({ cfg, accountId }) => (isSlackInteractiveRepliesEnabled({
+				cfg,
+				accountId
+			}) ? [
+				"- Prefer Slack buttons/selects for 2-5 discrete choices or parameter picks instead of asking the user to type one.",
+				"- Slack interactive replies: use `[[slack_buttons: Label:value, Other:other]]` to add action buttons that route clicks back as Slack interaction system events.",
+				"- Slack selects: use `[[slack_select: Placeholder | Label:value, Other:other]]` to add a static select menu that routes the chosen value back as a Slack interaction system event."
+			] : ["- Slack interactive replies are disabled. If needed, ask to set `channels.slack.capabilities.interactiveReplies=true` (or the same under `channels.slack.accounts.<account>.capabilities`)."]).concat([
+				"- Slack plain text sends: write standard Markdown; OpenClaw converts it to Slack mrkdwn, including `**bold**`, headings, lists, and `[label](url)` links.",
+				"- When mentioning Slack users, use the stable `<@USER_ID>` token from Slack context instead of plain `@name` text so Slack notifies and links the user.",
+				"- Slack Block Kit or presentation text fields are sent as Slack mrkdwn directly; use `*bold*`, `_italic_`, `~strike~`, `<url|label>` links, and avoid Markdown headings or pipe tables there."
+			])
+		},
+		streaming: { blockStreamingCoalesceDefaults: {
+			minChars: 1500,
+			idleMs: 1e3
+		} },
+		reload: { configPrefixes: ["channels.slack"] },
+		security: slackSecurityAdapter,
+		configSchema: SlackChannelConfigSchema,
+		config: {
+			...slackConfigAdapter,
+			hasConfiguredState: ({ env }) => [
+				"SLACK_APP_TOKEN",
+				"SLACK_BOT_TOKEN",
+				"SLACK_USER_TOKEN"
+			].some((key) => typeof env?.[key] === "string" && env[key]?.trim().length > 0),
+			isConfigured: (account) => isSlackPluginAccountConfigured(account),
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: isSlackPluginAccountConfigured(account),
+				extra: {
+					botTokenSource: account.botTokenSource,
+					appTokenSource: account.appTokenSource
+				}
+			})
+		},
+		secrets: {
+			secretTargetRegistryEntries,
+			collectRuntimeConfigAssignments
+		},
+		setup: params.setup
+	};
+}
+//#endregion
+export { slackConfigAdapter as n, slackSecurityAdapter as r, createSlackPluginBase as t };

package/dist/.setup/slash-dispatch.runtime-eyQo6mTA.mjs

@@ -0,0 +1,32 @@
+import { r as deliverSlackSlashReplies$1 } from "./replies-BO37R07g.mjs";
+import { resolveAgentRoute as resolveAgentRoute$1 } from "openclaw/plugin-sdk/routing";
+import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { recordInboundSessionMetaSafe as recordInboundSessionMetaSafe$1, resolveConversationLabel as resolveConversationLabel$1 } from "openclaw/plugin-sdk/conversation-runtime";
+import { dispatchReplyWithDispatcher as dispatchReplyWithDispatcher$1, finalizeInboundContext as finalizeInboundContext$1, resolveChunkMode as resolveChunkMode$1 } from "openclaw/plugin-sdk/reply-runtime";
+//#region extensions/slack/src/monitor/slash-dispatch.runtime.ts
+function resolveChunkMode(...args) {
+	return resolveChunkMode$1(...args);
+}
+function finalizeInboundContext(...args) {
+	return finalizeInboundContext$1(...args);
+}
+function dispatchReplyWithDispatcher(...args) {
+	return dispatchReplyWithDispatcher$1(...args);
+}
+function resolveConversationLabel(...args) {
+	return resolveConversationLabel$1(...args);
+}
+function recordInboundSessionMetaSafe(...args) {
+	return recordInboundSessionMetaSafe$1(...args);
+}
+function resolveMarkdownTableMode(...args) {
+	return resolveMarkdownTableMode$1(...args);
+}
+function resolveAgentRoute(...args) {
+	return resolveAgentRoute$1(...args);
+}
+function deliverSlackSlashReplies(...args) {
+	return deliverSlackSlashReplies$1(...args);
+}
+//#endregion
+export { deliverSlackSlashReplies, dispatchReplyWithDispatcher, finalizeInboundContext, recordInboundSessionMetaSafe, resolveAgentRoute, resolveChunkMode, resolveConversationLabel, resolveMarkdownTableMode };

package/dist/.setup/streaming-compat-DjlgH-Be.mjs

@@ -0,0 +1,43 @@
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { getChannelStreamingConfigObject, resolveChannelStreamingNativeTransport } from "openclaw/plugin-sdk/channel-outbound";
+//#region extensions/slack/src/streaming-compat.ts
+function normalizeStreamingMode(value) {
+	if (typeof value !== "string") return null;
+	return (normalizeOptionalString(value) == null ? "" : normalizeLowercaseStringOrEmpty(value)) || null;
+}
+function parseStreamingMode(value) {
+	const normalized = normalizeStreamingMode(value);
+	if (normalized === "off" || normalized === "partial" || normalized === "block" || normalized === "progress") return normalized;
+	return null;
+}
+function parseSlackLegacyDraftStreamMode(value) {
+	const normalized = normalizeStreamingMode(value);
+	if (normalized === "replace" || normalized === "status_final" || normalized === "append") return normalized;
+	return null;
+}
+function mapSlackLegacyDraftStreamModeToStreaming(mode) {
+	if (mode === "append") return "block";
+	if (mode === "status_final") return "progress";
+	return "partial";
+}
+function mapStreamingModeToSlackLegacyDraftStreamMode(mode) {
+	if (mode === "block") return "append";
+	if (mode === "progress") return "status_final";
+	return "replace";
+}
+function resolveSlackStreamingMode(params = {}) {
+	const parsedStreaming = parseStreamingMode(getChannelStreamingConfigObject(params)?.mode ?? params.streaming);
+	if (parsedStreaming) return parsedStreaming;
+	const legacyStreamMode = parseSlackLegacyDraftStreamMode(params.streamMode);
+	if (legacyStreamMode) return mapSlackLegacyDraftStreamModeToStreaming(legacyStreamMode);
+	if (typeof params.streaming === "boolean") return params.streaming ? "partial" : "off";
+	return "partial";
+}
+function resolveSlackNativeStreaming(params = {}) {
+	const canonical = resolveChannelStreamingNativeTransport(params);
+	if (typeof canonical === "boolean") return canonical;
+	if (typeof params.streaming === "boolean") return params.streaming;
+	return true;
+}
+//#endregion
+export { resolveSlackNativeStreaming as n, resolveSlackStreamingMode as r, mapStreamingModeToSlackLegacyDraftStreamMode as t };

package/dist/.setup/target-parsing-C36VFWHQ.mjs

@@ -0,0 +1,65 @@
+import { buildMessagingTarget, ensureTargetId, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
+//#region extensions/slack/src/target-parsing.ts
+function parseSlackTarget(raw, options = {}) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const userTarget = parseMentionPrefixOrAtUserTarget({
+		raw: trimmed,
+		mentionPattern: /^<@([A-Z0-9]+)>$/i,
+		prefixes: [
+			{
+				prefix: "user:",
+				kind: "user"
+			},
+			{
+				prefix: "channel:",
+				kind: "channel"
+			},
+			{
+				prefix: "slack:",
+				kind: "user"
+			}
+		],
+		atUserPattern: /^[A-Z0-9]+$/i,
+		atUserErrorMessage: "Slack DMs require a user id (use user:<id> or <@id>)"
+	});
+	if (userTarget) return userTarget;
+	if (trimmed.startsWith("#")) {
+		const candidate = trimmed.slice(1).trim();
+		const id = ensureTargetId({
+			candidate,
+			pattern: /^[A-Z0-9]+$/i,
+			errorMessage: "Slack channels require a channel id (use channel:<id>)"
+		});
+		return buildMessagingTarget("channel", id, trimmed);
+	}
+	if (options.defaultKind) return buildMessagingTarget(options.defaultKind, trimmed, trimmed);
+	return buildMessagingTarget("channel", trimmed, trimmed);
+}
+function resolveSlackChannelId(raw) {
+	const target = parseSlackTarget(raw, { defaultKind: "channel" });
+	return requireTargetKind({
+		platform: "Slack",
+		target,
+		kind: "channel"
+	});
+}
+function normalizeSlackMessagingTarget(raw) {
+	return parseSlackTarget(raw, { defaultKind: "channel" })?.normalized;
+}
+function slackTargetsMatch(left, right) {
+	const leftTarget = normalizeSlackMessagingTarget(left);
+	const rightTarget = normalizeSlackMessagingTarget(right);
+	return Boolean(leftTarget && rightTarget && leftTarget === rightTarget);
+}
+function looksLikeSlackTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	if (/^<@([A-Z0-9]+)>$/i.test(trimmed)) return true;
+	if (/^(user|channel):/i.test(trimmed)) return true;
+	if (/^slack:/i.test(trimmed)) return true;
+	if (/^[@#]/.test(trimmed)) return true;
+	return /^[CUWGD][A-Z0-9]{8,}$/i.test(trimmed);
+}
+//#endregion
+export { slackTargetsMatch as a, resolveSlackChannelId as i, normalizeSlackMessagingTarget as n, parseSlackTarget as r, looksLikeSlackTargetId as t };

package/dist/.setup/targets-DnpzC22e.mjs

@@ -0,0 +1,13 @@
+import { a as slackTargetsMatch, r as parseSlackTarget } from "./target-parsing-C36VFWHQ.mjs";
+//#region extensions/slack/src/targets.ts
+function matchesResolvedUserTarget(target, currentMessagingTarget) {
+	const resolvedId = target.trim();
+	if (!/^[UW][A-Z0-9]+$/i.test(resolvedId)) return false;
+	const currentTarget = parseSlackTarget(currentMessagingTarget);
+	return currentTarget?.kind === "user" && currentTarget.id.toLowerCase() === resolvedId.toLowerCase();
+}
+function slackContextTargetsMatch(target, context) {
+	return Boolean(context.currentMessagingTarget && (slackTargetsMatch(target, context.currentMessagingTarget) || matchesResolvedUserTarget(target, context.currentMessagingTarget)) || context.currentChannelId && slackTargetsMatch(target, context.currentChannelId));
+}
+//#endregion
+export { slackContextTargetsMatch as t };

package/dist/account-inspect-api.js

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

package/dist/api.js

@@ -1,18 +1,19 @@
-import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./accounts-CHAeNZOX.js";
-import { t as resolveSlackReplyToMode } from "./account-reply-mode-DrUXogvO.js";
-import { t as inspectSlackAccount } from "./account-inspect-DEKpg9Ip.js";
-import { a as resolveSlackChannelId, i as parseSlackTarget, n as looksLikeSlackTargetId, r as normalizeSlackMessagingTarget } from "./target-parsing-N6lHogYZ.js";
-import "./targets-KmjP2E8s.js";
-import { n as buildSlackThreadingToolContext, r as resolveSlackAutoThreadId, t as slackPlugin } from "./channel-B9fVdW3s.js";
-import { R as buildSlackInteractiveBlocks, a as allowListMatches, c as normalizeSlackAllowOwnerEntry, d as resolveSlackUserAllowed, it as validateSlackBlocksArray, l as normalizeSlackSlug, n as resolveSlackGroupRequireMention, nt as SLACK_MAX_BLOCKS, o as normalizeAllowList, r as resolveSlackGroupToolPolicy, rt as parseSlackBlocksInput, s as normalizeAllowListLower, u as resolveSlackAllowListMatch, z as buildSlackPresentationBlocks } from "./group-policy-NQZti9t-.js";
-import { n as extractSlackToolSend, r as listSlackMessageActions } from "./message-tool-api-DkhFpMoy.js";
-import { _ as resolveSlackWriteClientOptions, c as createSlackTokenCacheKey, f as getSlackWriteClient, g as resolveSlackWebClientOptions, i as clearSlackWriteClientCacheForTest, l as createSlackWebClient, m as SLACK_WRITE_RETRY_OPTIONS, p as SLACK_DEFAULT_RETRY_OPTIONS, t as probeSlack, u as createSlackWriteClient } from "./probe-CgDsSops.js";
-import { n as resetSlackChannelTypeCacheForTest, r as resolveSlackChannelType } from "./channel-type-DXyos1d2.js";
-import { t as slackSetupPlugin } from "./channel.setup-CLP5oTvh.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-D3NuJvva.js";
-import { l as recordSlackThreadParticipation, o as clearSlackThreadParticipationCache, s as hasSlackThreadParticipation } from "./send-DsLeZpST.js";
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CnCIAktf.js";
-import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
-import { n as resolveSlackRuntimeGroupPolicy } from "./provider-DmRizMZt.js";
-export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, resetSlackChannelTypeCacheForTest as __resetSlackChannelTypeCacheForTest, resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };
+import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath, t as handleSlackHttpRequest } from "./.setup/registry-bbjH7IHX.mjs";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, r as mergeSlackAccountConfig, t as listEnabledSlackAccounts } from "./.setup/accounts-uGn8E6uq.mjs";
+import { t as resolveSlackReplyToMode } from "./.setup/account-reply-mode-Bvoq75cS.mjs";
+import { t as inspectSlackAccount } from "./.setup/account-inspect-CcqRNkC3.mjs";
+import { i as resolveSlackChannelId, n as normalizeSlackMessagingTarget, r as parseSlackTarget, t as looksLikeSlackTargetId } from "./.setup/target-parsing-C36VFWHQ.mjs";
+import "./.setup/targets-DnpzC22e.mjs";
+import { a as resolveSlackAutoThreadId, i as resolveSlackChannelType, n as buildSlackThreadingToolContext, r as resetSlackChannelTypeCacheForTest, t as slackPlugin } from "./.setup/channel-BqOekthS.mjs";
+import { _ as buildSlackPresentationBlocks, d as normalizeAllowListLower, f as normalizeSlackAllowOwnerEntry, g as buildSlackInteractiveBlocks, h as resolveSlackUserAllowed, i as validateSlackBlocksArray, l as allowListMatches, m as resolveSlackAllowListMatch, n as SLACK_MAX_BLOCKS, o as resolveSlackGroupRequireMention, p as normalizeSlackSlug, r as parseSlackBlocksInput, s as resolveSlackGroupToolPolicy, u as normalizeAllowList } from "./.setup/reply-blocks-Cwu6LYJI.mjs";
+import { n as extractSlackToolSend, r as listSlackMessageActions } from "./.setup/message-tool-api-D2m68v1f.mjs";
+import { n as isSlackInteractiveRepliesEnabled, r as parseSlackOptionsLine, t as compileSlackInteractiveReplies } from "./.setup/interactive-replies-BLw4HEPS.mjs";
+import { a as getSlackWriteClient, c as resolveSlackWebClientOptions, i as createSlackWriteClient, l as resolveSlackWriteClientOptions, n as createSlackTokenCacheKey, o as SLACK_DEFAULT_RETRY_OPTIONS, r as createSlackWebClient, s as SLACK_WRITE_RETRY_OPTIONS, t as clearSlackWriteClientCacheForTest } from "./.setup/client-B6i83rHk.mjs";
+import { t as slackSetupPlugin } from "./.setup/channel.setup-DBlZCEvc.mjs";
+import { a as clearSlackThreadParticipationCache, c as recordSlackThreadParticipation, o as hasSlackThreadParticipation } from "./.setup/send-DEOvcVM4.mjs";
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, n as downloadSlackFile, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./.setup/actions-2VEX4Wdz.mjs";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./.setup/directory-config-DB0OcZzw.mjs";
+import { t as probeSlack } from "./.setup/probe-tmU762D2.mjs";
+import { t as collectSlackSecurityAuditFindings } from "./.setup/security-audit-HMEYeSrJ.mjs";
+import { n as resolveSlackRuntimeGroupPolicy } from "./.setup/provider-Bjv1R5E2.mjs";
+export { SLACK_DEFAULT_RETRY_OPTIONS, SLACK_MAX_BLOCKS, SLACK_WRITE_RETRY_OPTIONS, resetSlackChannelTypeCacheForTest as __resetSlackChannelTypeCacheForTest, resetSlackChannelTypeCacheForTest, allowListMatches, buildSlackInteractiveBlocks, buildSlackPresentationBlocks, buildSlackThreadingToolContext, clearSlackThreadParticipationCache, clearSlackWriteClientCacheForTest, collectSlackSecurityAuditFindings, compileSlackInteractiveReplies, createSlackTokenCacheKey, createSlackWebClient, createSlackWriteClient, deleteSlackMessage, downloadSlackFile, editSlackMessage, extractSlackToolSend, getSlackMemberInfo, getSlackWriteClient, handleSlackHttpRequest, hasSlackThreadParticipation, inspectSlackAccount, isSlackInteractiveRepliesEnabled, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, listSlackEmojis, listSlackMessageActions, listSlackPins, listSlackReactions, looksLikeSlackTargetId, mergeSlackAccountConfig, normalizeAllowList, normalizeAllowListLower, normalizeSlackAllowOwnerEntry, normalizeSlackMessagingTarget, normalizeSlackSlug, normalizeSlackWebhookPath, parseSlackBlocksInput, parseSlackOptionsLine, parseSlackTarget, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, recordSlackThreadParticipation, registerSlackHttpHandler, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAllowListMatch, resolveSlackAutoThreadId, resolveSlackChannelId, resolveSlackChannelType, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackReplyToMode, resolveSlackRuntimeGroupPolicy, resolveSlackUserAllowed, resolveSlackWebClientOptions, resolveSlackWriteClientOptions, sendSlackMessage, slackPlugin, slackSetupPlugin, unpinSlackMessage, validateSlackBlocksArray };

package/dist/channel-config-api.js

@@ -1,2 +1,2 @@
-import { t as SlackChannelConfigSchema } from "./config-schema-SgZT6nXV.js";
+import { t as SlackChannelConfigSchema } from "./.setup/config-schema-DV93lEJ7.mjs";
 export { SlackChannelConfigSchema };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as slackPlugin } from "./channel-B9fVdW3s.js";
+import { t as slackPlugin } from "./.setup/channel-BqOekthS.mjs";
 export { slackPlugin };

package/dist/configured-state.js

@@ -0,0 +1,11 @@
+//#region extensions/slack/configured-state.ts
+const SLACK_CONFIGURED_ENV_KEYS = [
+	"SLACK_APP_TOKEN",
+	"SLACK_BOT_TOKEN",
+	"SLACK_USER_TOKEN"
+];
+function hasSlackConfiguredState(params) {
+	return SLACK_CONFIGURED_ENV_KEYS.some((key) => typeof params.env?.[key] === "string" && params.env[key]?.trim().length > 0);
+}
+//#endregion
+export { hasSlackConfiguredState };

package/dist/directory-contract-api.js

@@ -1,2 +1,2 @@
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CnCIAktf.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./.setup/directory-config-DB0OcZzw.mjs";
 export { listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig };

package/dist/doctor-contract-api.js

@@ -1,2 +1,2 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-CsGH1Dfc.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./.setup/doctor-contract-Dxk57DKz.mjs";
 export { legacyConfigRules, normalizeCompatibilityConfig };

package/dist/http-routes-api.js

@@ -1,2 +1,2 @@
-import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
+import { t as registerSlackPluginHttpRoutes } from "./.setup/plugin-routes-C3X0eVaK.mjs";
 export { registerSlackPluginHttpRoutes };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
+import { t as registerSlackPluginHttpRoutes } from "./.setup/plugin-routes-C3X0eVaK.mjs";
 import "./http-routes-api.js";
 import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/slack/index.ts

package/dist/interactive-replies-api.js

@@ -0,0 +1,2 @@
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./.setup/interactive-replies-BLw4HEPS.mjs";
+export { compileSlackInteractiveReplies, isSlackInteractiveRepliesEnabled };

package/dist/message-tool-api.js

@@ -1,2 +1,2 @@
-import { t as describeSlackMessageTool } from "./message-tool-api-DkhFpMoy.js";
+import { t as describeSlackMessageTool } from "./.setup/message-tool-api-D2m68v1f.mjs";
 export { describeSlackMessageTool as describeMessageTool };

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
-import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
-import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-CHAeNZOX.js";
-import { n as resolveSlackGroupRequireMention, r as resolveSlackGroupToolPolicy } from "./group-policy-NQZti9t-.js";
-import { t as probeSlack } from "./probe-CgDsSops.js";
-import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-D3NuJvva.js";
-import { r as sendMessageSlack } from "./send-DsLeZpST.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-yEqmM-3I.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-BOrt5K-5.js";
-import { t as monitorSlackProvider } from "./provider-DmRizMZt.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-DfuYoMjG.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-DKunWh3A.js";
-import "./monitor-CmKz0wtI.js";
+import { t as registerSlackPluginHttpRoutes } from "./.setup/plugin-routes-C3X0eVaK.mjs";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./.setup/accounts-uGn8E6uq.mjs";
+import { o as resolveSlackGroupRequireMention, s as resolveSlackGroupToolPolicy } from "./.setup/reply-blocks-Cwu6LYJI.mjs";
+import { n as setSlackRuntime } from "./.setup/runtime-BOk7xkOl.mjs";
+import { r as sendMessageSlack } from "./.setup/send-DEOvcVM4.mjs";
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./.setup/actions-2VEX4Wdz.mjs";
+import { t as probeSlack } from "./.setup/probe-tmU762D2.mjs";
+import { t as resolveSlackChannelAllowlist } from "./.setup/resolve-channels-CivvCeZv.mjs";
+import { t as resolveSlackUserAllowlist } from "./.setup/resolve-users-D5Qb64BJ.mjs";
+import { t as monitorSlackProvider } from "./.setup/provider-Bjv1R5E2.mjs";
+import { n as slackActionRuntime, t as handleSlackAction } from "./.setup/action-runtime-iq6ZxO_b.mjs";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./.setup/directory-live-O3jkDEJH.mjs";
+import "./.setup/monitor-jTrujB_u.mjs";
 export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, handleSlackAction, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsLive, listSlackDirectoryPeersLive, listSlackEmojis, listSlackPins, listSlackReactions, monitorSlackProvider, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, registerSlackPluginHttpRoutes, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAppToken, resolveSlackBotToken, resolveSlackChannelAllowlist, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackUserAllowlist, sendMessageSlack, sendSlackMessage, setSlackRuntime, slackActionRuntime, unpinSlackMessage };

package/dist/runtime-setter-api.js

@@ -1,2 +1,2 @@
-import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
+import { n as setSlackRuntime } from "./.setup/runtime-BOk7xkOl.mjs";
 export { setSlackRuntime };

package/dist/secret-contract-api.js

@@ -1,2 +1,2 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DxmvbxBF.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./.setup/secret-contract-C3ChHo5A.mjs";
 export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/security-contract-api.js

@@ -1,2 +1,2 @@
-import { t as collectSlackSecurityAuditFindings } from "./security-audit-DR097212.js";
+import { t as collectSlackSecurityAuditFindings } from "./.setup/security-audit-HMEYeSrJ.mjs";
 export { collectSlackSecurityAuditFindings };

package/dist/setup-entry.js

@@ -1,19 +1,20 @@
-import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
+import { t as registerSlackPluginHttpRoutes } from "./.setup/plugin-routes-C3X0eVaK.mjs";
 import "./http-routes-api.js";
 import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+import { fileURLToPath } from "node:url";
 //#region extensions/slack/setup-entry.ts
 var setup_entry_default = defineBundledChannelSetupEntry({
 	importMetaUrl: import.meta.url,
 	plugin: {
-		specifier: "./setup-plugin-api.js",
+		specifier: fileURLToPath(new URL(".setup/setup-plugin-api-DMKdqvij.mjs", import.meta.url).href),
 		exportName: "slackSetupPlugin"
 	},
 	secrets: {
-		specifier: "./secret-contract-api.js",
+		specifier: fileURLToPath(new URL(".setup/secret-contract-api-CcCSHlV7.mjs", import.meta.url).href),
 		exportName: "channelSecrets"
 	},
 	runtime: {
-		specifier: "./runtime-setter-api.js",
+		specifier: fileURLToPath(new URL(".setup/runtime-setter-api-C-6lgBvk.mjs", import.meta.url).href),
 		exportName: "setSlackRuntime"
 	},
 	registerSetupRuntime: registerSlackPluginHttpRoutes

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as slackSetupPlugin } from "./channel.setup-CLP5oTvh.js";
+import { t as slackSetupPlugin } from "./.setup/channel.setup-DBlZCEvc.mjs";
 export { slackSetupPlugin };