@openclaw/slack 2026.7.2-beta.7 → 2026.7.34

package/README.md

@@ -5,7 +5,7 @@ Official OpenClaw channel plugin for Slack channels, DMs, commands, and app even
 Install from OpenClaw:
 
 ```bash
-openclaw plugins install @openclaw/slack
+openclaw plugin add @openclaw/slack
 ```
 
 Configure the Slack app credentials and allowed workspaces/channels in OpenClaw. The plugin lets agents receive Slack events and reply through the configured Slack app.

package/dist/.setup/account-configured-DzC407uv.mjs

@@ -0,0 +1,14 @@
+import { hasConfiguredAccountValue } from "openclaw/plugin-sdk/account-resolution";
+//#region extensions/slack/src/account-configured.ts
+function isSlackPluginAccountConfigured(account) {
+	const mode = account.config.mode ?? "socket";
+	if (!Boolean(account.botToken?.trim())) return false;
+	if (mode === "http") return hasConfiguredAccountValue(account.config.signingSecret);
+	if (mode === "relay") {
+		const relay = account.config.relay;
+		return hasConfiguredAccountValue(relay?.url) && hasConfiguredAccountValue(relay?.authToken) && hasConfiguredAccountValue(relay?.gatewayId);
+	}
+	return Boolean(account.appToken?.trim());
+}
+//#endregion
+export { isSlackPluginAccountConfigured as t };

package/dist/.setup/account-inspect-CcqRNkC3.mjs

@@ -0,0 +1,79 @@
+import { i as resolveDefaultSlackAccountId, r as mergeSlackAccountConfig } from "./accounts-uGn8E6uq.mjs";
+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 isRelayMode = mode === "relay";
+	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 && !isRelayMode ? 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 relayConfigured = isRelayMode && Boolean(normalizeOptionalString(merged.relay?.url)) && hasConfiguredSecretInput(merged.relay?.authToken) && Boolean(normalizeOptionalString(merged.relay?.gatewayId));
+	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" : isRelayMode ? (configBot.status !== "missing" || Boolean(envBot)) && relayConfigured : (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/.setup/account-reply-mode-Bvoq75cS.mjs

@@ -0,0 +1,15 @@
+//#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
+export { resolveSlackReplyToMode as t };

package/dist/.setup/accounts-uGn8E6uq.mjs

@@ -0,0 +1,187 @@
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, 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 formatSlackBotTokenIdentityWarning(params) {
+	const userId = params.auth.user_id?.trim();
+	const botId = params.auth.bot_id?.trim();
+	if (!userId || botId) return;
+	const accountId = params.accountId?.trim() || "default";
+	return `Slack auth.test identified account "${accountId}" as user ${userId} without bot_id. ${accountId === "default" ? "channels.slack.botToken, channels.slack.accounts.default.botToken, or SLACK_BOT_TOKEN" : `channels.slack.accounts.${accountId}.botToken`} appears to contain a user token; replace it with a Bot User OAuth Token. Until replaced, explicit bot-mention detection is disabled and required-mention channels fail closed.`;
+}
+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/accounts.ts
+function resolveSlackOperationToken(account, operation) {
+	const userToken = normalizeOptionalString(account.userToken);
+	const botToken = normalizeOptionalString(account.botToken);
+	if (operation === "read") return userToken ?? botToken;
+	return account.config.userTokenReadOnly === false ? botToken ?? userToken : botToken;
+}
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("slack", { hasImplicitDefaultAccount: (cfg) => {
+	const slack = cfg.channels?.slack;
+	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 listSlackAccountIds = listAccountIds;
+const resolveDefaultSlackAccountId = resolveDefaultAccountId;
+function resolveSlackAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.slack?.accounts, accountId);
+}
+function asStreamingConfigObject(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asLegacyStreamingScalar(value) {
+	return typeof value === "boolean" || typeof value === "string" ? value : void 0;
+}
+function mergeSlackStreamingConfig(base, account) {
+	const accountObject = asStreamingConfigObject(account);
+	if (account !== void 0 && !accountObject) return asLegacyStreamingScalar(account);
+	const baseObject = asStreamingConfigObject(base);
+	if (base !== void 0 && !baseObject) return accountObject ?? asLegacyStreamingScalar(base);
+	const baseConfig = baseObject;
+	const accountConfig = accountObject;
+	if (!baseConfig || !accountConfig) return accountConfig ?? baseConfig;
+	return {
+		...baseConfig,
+		...accountConfig,
+		...baseConfig.preview || accountConfig.preview ? { preview: {
+			...baseConfig.preview,
+			...accountConfig.preview
+		} } : {},
+		...baseConfig.progress || accountConfig.progress ? { progress: {
+			...baseConfig.progress,
+			...accountConfig.progress
+		} } : {},
+		...baseConfig.block || accountConfig.block ? { block: {
+			...baseConfig.block,
+			...accountConfig.block,
+			...baseConfig.block?.coalesce || accountConfig.block?.coalesce ? { coalesce: {
+				...baseConfig.block?.coalesce,
+				...accountConfig.block?.coalesce
+			} } : {}
+		} } : {}
+	};
+}
+function mergeSlackAccountConfig(cfg, accountId) {
+	const accountConfig = resolveSlackAccountConfig(cfg, accountId);
+	const merged = resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.slack,
+		accounts: cfg.channels?.slack?.accounts,
+		accountId,
+		nestedObjectKeys: ["botLoopProtection", "relay"]
+	});
+	const streaming = mergeSlackStreamingConfig((cfg.channels?.slack)?.streaming, accountConfig?.streaming);
+	return streaming !== void 0 ? {
+		...merged,
+		streaming
+	} : merged;
+}
+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;
+	const policy = resolveChannelDmPolicy({
+		account: accountConfig,
+		parent: rootConfig,
+		defaultPolicy: "pairing"
+	});
+	return normalizeChannelDmPolicy(policy);
+}
+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 === "socket";
+	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, resolveSlackAppToken as d, resolveSlackBotToken as f, resolveDefaultSlackAccountId as i, resolveSlackOperationToken as l, listSlackAccountIds as n, resolveSlackAccountAllowFrom as o, mergeSlackAccountConfig as r, resolveSlackAccountDmPolicy as s, listEnabledSlackAccounts as t, formatSlackBotTokenIdentityWarning as u };

package/dist/.setup/accounts.runtime-k_V5-EOr.mjs

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