@openclaw/slack 2026.7.2-beta.1 → 2026.7.2-beta.3

package/dist/setup-core-CeiAVwQ3.js

@@ -0,0 +1,502 @@
+import { t as inspectSlackAccount } from "./account-inspect-Bvbtu3iH.js";
+import { t as isSlackPluginAccountConfigured } from "./account-configured-BwfXBo_F.js";
+import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { DEFAULT_ACCOUNT_ID, createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createAllowlistSetupWizardProxy, createLegacyCompatChannelDmPolicy, createPatchedAccountSetupAdapter, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, parseMentionOrPrefixedId, patchChannelConfigForAccount, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
+import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+//#region extensions/slack/src/setup-shared.ts
+const SLACK_CHANNEL = "slack";
+function buildSlackManifest(botName = "OpenClaw") {
+	const safeName = botName.trim() || "OpenClaw";
+	const manifest = {
+		display_information: {
+			name: safeName,
+			description: `${safeName} connector for OpenClaw`
+		},
+		features: {
+			bot_user: {
+				display_name: safeName,
+				always_online: true
+			},
+			app_home: {
+				home_tab_enabled: true,
+				messages_tab_enabled: true,
+				messages_tab_read_only_enabled: false
+			},
+			assistant_view: {
+				assistant_description: `${safeName} connects Slack assistant threads to OpenClaw agents.`,
+				suggested_prompts: [
+					{
+						title: "What can you do?",
+						message: "What can you help me with?"
+					},
+					{
+						title: "Summarize this channel",
+						message: "Summarize the recent activity in this channel."
+					},
+					{
+						title: "Draft a reply",
+						message: "Help me draft a reply."
+					}
+				]
+			},
+			slash_commands: [{
+				command: "/openclaw",
+				description: "Send a message to OpenClaw",
+				should_escape: false
+			}]
+		},
+		oauth_config: { scopes: { bot: [
+			"app_mentions:read",
+			"assistant:write",
+			"channels:history",
+			"channels:read",
+			"chat:write",
+			"commands",
+			"emoji:read",
+			"files:read",
+			"files:write",
+			"groups:history",
+			"groups:read",
+			"im:history",
+			"im:read",
+			"im:write",
+			"mpim:history",
+			"mpim:read",
+			"mpim:write",
+			"pins:read",
+			"pins:write",
+			"reactions:read",
+			"reactions:write",
+			"usergroups:read",
+			"users:read"
+		] } },
+		settings: {
+			socket_mode_enabled: true,
+			event_subscriptions: { bot_events: [
+				"app_home_opened",
+				"app_mention",
+				"assistant_thread_context_changed",
+				"assistant_thread_started",
+				"channel_rename",
+				"member_joined_channel",
+				"member_left_channel",
+				"message.channels",
+				"message.groups",
+				"message.im",
+				"message.mpim",
+				"pin_added",
+				"pin_removed",
+				"reaction_added",
+				"reaction_removed"
+			] }
+		}
+	};
+	return JSON.stringify(manifest, null, 2);
+}
+function buildSlackSetupLines() {
+	return [
+		"1) Slack API -> Create App -> From scratch or From manifest (with the JSON below)",
+		"2) Add Socket Mode + enable it to get the app-level token (xapp-...)",
+		"3) Install App to workspace to get the xoxb- bot token",
+		"4) Enable Event Subscriptions (socket) for message, App Home, and assistant events",
+		"5) App Home -> enable the Home tab, Messages tab for DMs, and AI assistant view",
+		"Manifest JSON follows as plain text for copy/paste.",
+		"Tip: set SLACK_BOT_TOKEN + SLACK_APP_TOKEN in your env.",
+		`Docs: ${formatDocsLink("/slack", "slack")}`
+	];
+}
+function setSlackChannelAllowlist(cfg, accountId, channelKeys) {
+	const channels = Object.fromEntries(channelKeys.map((key) => [key, { enabled: true }]));
+	return patchChannelConfigForAccount({
+		cfg,
+		channel: SLACK_CHANNEL,
+		accountId,
+		patch: { channels }
+	});
+}
+function isSlackSetupAccountConfigured(account) {
+	if (account.config.mode === "relay") return isSlackPluginAccountConfigured(account);
+	const hasConfiguredUserToken = Boolean(account.userToken?.trim()) || hasConfiguredSecretInput(account.config.userToken);
+	const hasConfiguredBotToken = Boolean(account.botToken?.trim()) || hasConfiguredSecretInput(account.config.botToken);
+	const hasConfiguredAppToken = Boolean(account.appToken?.trim()) || hasConfiguredSecretInput(account.config.appToken);
+	if (account.identity === "user") {
+		const hasTransportCredential = account.config.mode === "http" ? hasConfiguredSecretInput(account.config.signingSecret) : hasConfiguredAppToken;
+		return hasConfiguredUserToken && hasTransportCredential;
+	}
+	return hasConfiguredBotToken && hasConfiguredAppToken;
+}
+function describeSlackSetupAccount(account) {
+	return describeAccountSnapshot({
+		account,
+		configured: isSlackSetupAccountConfigured(account),
+		extra: {
+			botTokenSource: account.botTokenSource,
+			appTokenSource: account.appTokenSource,
+			...account.identity === "user" ? {
+				identity: account.identity,
+				userTokenSource: account.userTokenSource
+			} : {}
+		}
+	});
+}
+//#endregion
+//#region extensions/slack/src/setup-core.ts
+const t = createSetupTranslator();
+function enableSlackAccount(cfg, accountId) {
+	return patchChannelConfigForAccount({
+		cfg,
+		channel: SLACK_CHANNEL,
+		accountId,
+		patch: { enabled: true }
+	});
+}
+function setSlackSetupIdentity(params) {
+	const next = patchChannelConfigForAccount({
+		cfg: params.cfg,
+		channel: SLACK_CHANNEL,
+		accountId: params.accountId,
+		patch: params.identity === "user" ? { identity: "user" } : {}
+	});
+	if (params.identity === "user") return next;
+	const slack = next.channels?.slack;
+	if (!slack) return next;
+	if (params.accountId === DEFAULT_ACCOUNT_ID) {
+		const nextSlack = { ...slack };
+		delete nextSlack.identity;
+		return {
+			...next,
+			channels: {
+				...next.channels,
+				slack: nextSlack
+			}
+		};
+	}
+	const account = slack.accounts?.[params.accountId];
+	if (!account) return next;
+	const nextAccount = { ...account };
+	if (slack.identity === "user") nextAccount.identity = "bot";
+	else delete nextAccount.identity;
+	return {
+		...next,
+		channels: {
+			...next.channels,
+			slack: {
+				...slack,
+				accounts: {
+					...slack.accounts,
+					[params.accountId]: nextAccount
+				}
+			}
+		}
+	};
+}
+function hasSlackInteractiveRepliesConfig(cfg, accountId) {
+	const capabilities = inspectSlackAccount({
+		cfg,
+		accountId
+	}).config.capabilities;
+	if (Array.isArray(capabilities)) return capabilities.some((entry) => normalizeLowercaseStringOrEmpty(entry) === "interactivereplies");
+	if (!capabilities || typeof capabilities !== "object") return false;
+	return "interactiveReplies" in capabilities;
+}
+function setSlackInteractiveReplies(cfg, accountId, interactiveReplies) {
+	const capabilities = inspectSlackAccount({
+		cfg,
+		accountId
+	}).config.capabilities;
+	return patchChannelConfigForAccount({
+		cfg,
+		channel: SLACK_CHANNEL,
+		accountId,
+		patch: { capabilities: Array.isArray(capabilities) ? interactiveReplies ? uniqueStrings([...capabilities, "interactiveReplies"]) : capabilities.filter((entry) => normalizeLowercaseStringOrEmpty(entry) !== "interactivereplies") : {
+			...capabilities && typeof capabilities === "object" ? capabilities : {},
+			interactiveReplies
+		} }
+	});
+}
+function createSlackTokenCredential(params) {
+	return defineTokenCredential({
+		inputKey: params.inputKey,
+		configKey: params.inputKey,
+		providerHint: params.providerHint,
+		credentialLabel: params.credentialLabel,
+		preferredEnvVar: params.preferredEnvVar,
+		envPrompt: params.preferredEnvVar ? `${params.preferredEnvVar} detected. Use env var?` : "Use the configured Slack credential?",
+		keepPrompt: params.keepPrompt,
+		inputPrompt: params.inputPrompt,
+		allowEnv: ({ accountId }) => Boolean(params.preferredEnvVar) && accountId === DEFAULT_ACCOUNT_ID,
+		resolveAccount: ({ cfg, accountId }) => inspectSlackAccount({
+			cfg,
+			accountId
+		}),
+		resolvedValue: (account) => {
+			if (params.inputKey === "botToken") return normalizeOptionalString(account.botToken);
+			if (params.inputKey === "appToken") return normalizeOptionalString(account.appToken);
+			if (params.inputKey === "userToken") return normalizeOptionalString(account.userToken);
+			return normalizeSecretInputString(account.config.signingSecret);
+		},
+		envValue: ({ accountId }) => params.preferredEnvVar && accountId === DEFAULT_ACCOUNT_ID ? normalizeOptionalString(process.env[params.preferredEnvVar]) : void 0,
+		patchAccount: ({ cfg, accountId, mode, patch }) => mode === "env" ? enableSlackAccount(cfg, accountId) : patchChannelConfigForAccount({
+			cfg,
+			channel: SLACK_CHANNEL,
+			accountId,
+			patch: {
+				enabled: true,
+				...patch
+			}
+		}),
+		useEnv: { clearFields: [] },
+		set: {},
+		shouldPrompt: params.shouldPrompt
+	});
+}
+function hasSlackSetupCredentials(params) {
+	if (params.identity !== "user") {
+		const { input } = params;
+		return Boolean(input.botToken && input.appToken);
+	}
+	if (params.mode === "http") return Boolean(params.input.userToken && params.input.signingSecret);
+	return params.mode === "socket" && Boolean(params.input.userToken && params.input.appToken);
+}
+const slackSetupAdapterBase = createPatchedAccountSetupAdapter({
+	channelKey: SLACK_CHANNEL,
+	validateInput: ({ cfg, accountId, input }) => {
+		if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) return "Slack env tokens can only be used for the default account.";
+		const account = inspectSlackAccount({
+			cfg,
+			accountId
+		});
+		const identity = input.identity ?? account.config.identity ?? "bot";
+		const mode = input.mode ?? account.config.mode ?? "socket";
+		if (identity === "user" && mode === "relay") return "Slack user identity setup supports mode \"socket\" or \"http\", not \"relay\".";
+		if (input.useEnv) return identity === "user" ? "Slack user identity setup does not support --use-env; configure userToken and the transport credential explicitly." : null;
+		if (hasSlackSetupCredentials({
+			input,
+			identity,
+			mode
+		})) return null;
+		if (identity === "user") return mode === "http" ? "Slack user identity requires --user-token and --signing-secret." : "Slack user identity requires --user-token and --app-token.";
+		return "Slack requires --bot-token and --app-token (or --use-env).";
+	},
+	buildPatch: (input) => ({
+		...input.identity ? { identity: input.identity } : {},
+		...input.identity === "user" && input.mode ? { mode: input.mode } : {},
+		...input.botToken ? { botToken: input.botToken } : {},
+		...input.appToken ? { appToken: input.appToken } : {},
+		...input.userToken ? { userToken: input.userToken } : {},
+		...input.signingSecret ? { signingSecret: input.signingSecret } : {}
+	})
+});
+const slackSetupAdapter = {
+	...slackSetupAdapterBase,
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const identity = input.identity ?? inspectSlackAccount({
+			cfg,
+			accountId
+		}).config.identity;
+		return slackSetupAdapterBase.applyAccountConfig({
+			cfg,
+			accountId,
+			input: identity === "user" ? {
+				...input,
+				identity
+			} : input
+		});
+	}
+};
+function createSlackSetupWizardBase(handlers) {
+	const slackDmPolicy = createLegacyCompatChannelDmPolicy({
+		label: "Slack",
+		channel: SLACK_CHANNEL,
+		promptAllowFrom: handlers.promptAllowFrom
+	});
+	return {
+		channel: SLACK_CHANNEL,
+		status: createStandardChannelSetupStatus({
+			channelLabel: "Slack",
+			configuredLabel: t("wizard.channels.statusConfigured"),
+			unconfiguredLabel: t("wizard.channels.statusNeedsTokens"),
+			configuredHint: t("wizard.channels.statusConfigured"),
+			unconfiguredHint: t("wizard.channels.statusNeedsTokens"),
+			configuredScore: 2,
+			unconfiguredScore: 1,
+			resolveConfigured: ({ cfg, accountId }) => inspectSlackAccount({
+				cfg,
+				accountId
+			}).configured
+		}),
+		prepare: async ({ cfg, accountId, prompter }) => {
+			const currentAccount = inspectSlackAccount({
+				cfg,
+				accountId
+			});
+			if (currentAccount.configured && currentAccount.config.identity !== "user") return { cfg };
+			const identity = await prompter.select({
+				message: "How should OpenClaw appear in Slack?",
+				options: [{
+					value: "bot",
+					label: "Slack bot",
+					hint: "Post as the Slack app (default)"
+				}, {
+					value: "user",
+					label: "Slack user",
+					hint: "Post as the authorizing human"
+				}],
+				initialValue: currentAccount.config.identity ?? "bot"
+			});
+			const next = setSlackSetupIdentity({
+				cfg,
+				accountId,
+				identity
+			});
+			if (currentAccount.configured && identity === currentAccount.config.identity) return { cfg: next };
+			if (identity === "user") {
+				if (currentAccount.config.mode === "relay") throw new Error("Slack user identity setup supports mode \"socket\" or \"http\", not \"relay\".");
+				await prompter.note([
+					"Use a Slack user OAuth token with the User Token Scopes listed in the Slack docs.",
+					"Subscribe the companion app under 'Subscribe to events on behalf of users' using the documented user events.",
+					"Socket Mode needs an app-level token; HTTP mode needs the app signing secret.",
+					"No bot token or bot user is required.",
+					`Docs: ${formatDocsLink("/channels/slack#user-identity-post-as-a-real-person", "channels/slack")}`
+				].join("\n"), "Slack user identity");
+			} else {
+				await prompter.note(buildSlackSetupLines().join("\n"), t("wizard.slack.socketModeTokensTitle"));
+				const manifest = buildSlackManifest();
+				if (prompter.plain) await prompter.plain(manifest);
+				else await prompter.note(manifest, "Slack manifest JSON");
+			}
+			return { cfg: next };
+		},
+		envShortcut: {
+			prompt: t("wizard.slack.envPrompt"),
+			preferredEnvVar: "SLACK_BOT_TOKEN",
+			isAvailable: ({ cfg, accountId }) => accountId === DEFAULT_ACCOUNT_ID && (inspectSlackAccount({
+				cfg,
+				accountId
+			}).config.identity ?? "bot") === "bot" && Boolean(process.env.SLACK_BOT_TOKEN?.trim()) && Boolean(process.env.SLACK_APP_TOKEN?.trim()) && !inspectSlackAccount({
+				cfg,
+				accountId
+			}).configured,
+			apply: ({ cfg, accountId }) => enableSlackAccount(cfg, accountId)
+		},
+		credentials: [
+			createSlackTokenCredential({
+				inputKey: "botToken",
+				providerHint: "slack-bot",
+				credentialLabel: t("wizard.slack.botToken"),
+				preferredEnvVar: "SLACK_BOT_TOKEN",
+				keepPrompt: t("wizard.slack.botTokenKeep"),
+				inputPrompt: t("wizard.slack.botTokenInput"),
+				shouldPrompt: ({ cfg, accountId }) => (inspectSlackAccount({
+					cfg,
+					accountId
+				}).config.identity ?? "bot") === "bot"
+			}),
+			createSlackTokenCredential({
+				inputKey: "userToken",
+				providerHint: "slack-user",
+				credentialLabel: "Slack user OAuth token",
+				preferredEnvVar: "SLACK_USER_TOKEN",
+				keepPrompt: "Slack user OAuth token already configured. Keep it?",
+				inputPrompt: "Enter Slack user OAuth token",
+				shouldPrompt: ({ cfg, accountId }) => inspectSlackAccount({
+					cfg,
+					accountId
+				}).config.identity === "user"
+			}),
+			createSlackTokenCredential({
+				inputKey: "appToken",
+				providerHint: "slack-app",
+				credentialLabel: t("wizard.slack.appToken"),
+				preferredEnvVar: "SLACK_APP_TOKEN",
+				keepPrompt: t("wizard.slack.appTokenKeep"),
+				inputPrompt: t("wizard.slack.appTokenInput"),
+				shouldPrompt: ({ cfg, accountId }) => {
+					const account = inspectSlackAccount({
+						cfg,
+						accountId
+					});
+					return (account.config.identity ?? "bot") === "bot" || (account.config.mode ?? "socket") === "socket";
+				}
+			}),
+			createSlackTokenCredential({
+				inputKey: "signingSecret",
+				providerHint: "slack-signing-secret",
+				credentialLabel: "Slack signing secret",
+				keepPrompt: "Slack signing secret already configured. Keep it?",
+				inputPrompt: "Enter Slack signing secret",
+				shouldPrompt: ({ cfg, accountId }) => {
+					const account = inspectSlackAccount({
+						cfg,
+						accountId
+					});
+					return account.config.identity === "user" && account.config.mode === "http";
+				}
+			})
+		],
+		dmPolicy: slackDmPolicy,
+		allowFrom: createAccountScopedAllowFromSection({
+			channel: SLACK_CHANNEL,
+			helpTitle: t("wizard.slack.allowlistTitle"),
+			helpLines: [
+				t("wizard.slack.allowlistIntro"),
+				t("wizard.slack.examples"),
+				"- U12345678",
+				"- @alice",
+				t("wizard.slack.multipleEntries"),
+				t("wizard.channels.docs", { link: formatDocsLink("/slack", "slack") })
+			],
+			message: t("wizard.slack.allowFromPrompt"),
+			placeholder: "@alice, U12345678",
+			invalidWithoutCredentialNote: t("wizard.slack.allowFromInvalidWithoutToken"),
+			parseId: (value) => parseMentionOrPrefixedId({
+				value,
+				mentionPattern: /^<@([A-Z0-9]+)>$/i,
+				prefixPattern: /^(slack:|user:)/i,
+				idPattern: /^[A-Z][A-Z0-9]+$/i,
+				normalizeId: (id) => id.toUpperCase()
+			}),
+			resolveEntries: handlers.resolveAllowFromEntries
+		}),
+		groupAccess: createAccountScopedGroupAccessSection({
+			channel: SLACK_CHANNEL,
+			label: t("wizard.slack.channelsLabel"),
+			placeholder: "#general, #private, C123",
+			currentPolicy: ({ cfg, accountId }) => inspectSlackAccount({
+				cfg,
+				accountId
+			}).config.groupPolicy ?? "allowlist",
+			currentEntries: ({ cfg, accountId }) => Object.entries(inspectSlackAccount({
+				cfg,
+				accountId
+			}).config.channels ?? {}).filter(([, value]) => value?.enabled !== false).map(([key]) => key),
+			updatePrompt: ({ cfg, accountId }) => Boolean(inspectSlackAccount({
+				cfg,
+				accountId
+			}).config.channels),
+			resolveAllowlist: handlers.resolveGroupAllowlist,
+			fallbackResolved: (entries) => entries,
+			applyAllowlist: ({ cfg, accountId, resolved }) => setSlackChannelAllowlist(cfg, accountId, resolved)
+		}),
+		finalize: async ({ cfg, accountId, options, prompter }) => {
+			if (hasSlackInteractiveRepliesConfig(cfg, accountId)) return;
+			if (options?.quickstartDefaults) return { cfg: setSlackInteractiveReplies(cfg, accountId, true) };
+			return { cfg: setSlackInteractiveReplies(cfg, accountId, await prompter.confirm({
+				message: t("wizard.slack.interactiveRepliesPrompt"),
+				initialValue: true
+			})) };
+		},
+		disable: (cfg) => setSetupChannelEnabled(cfg, SLACK_CHANNEL, false)
+	};
+}
+function createSlackSetupWizardProxy(loadWizard) {
+	return createAllowlistSetupWizardProxy({
+		loadWizard: async () => (await loadWizard()).slackSetupWizard,
+		createBase: createSlackSetupWizardBase,
+		fallbackResolvedGroupAllowlist: (entries) => entries
+	});
+}
+//#endregion
+export { describeSlackSetupAccount as a, SLACK_CHANNEL as i, createSlackSetupWizardProxy as n, isSlackSetupAccountConfigured as o, slackSetupAdapter as r, createSlackSetupWizardBase as t };

package/dist/setup-plugin-api.js

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

package/dist/{setup-surface-BN2WeG5c.js → setup-surface-DLA0vHXp.js}

@@ -1,14 +1,19 @@
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom } from "./accounts-BOJJiHSr.js";
-import "./shared-BLnB9R1T.js";
-import { i as SLACK_CHANNEL, t as createSlackSetupWizardBase } from "./setup-core-fGd6Gquy.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DOMgNCWb.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-aL6-Ssee.js";
+import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom } from "./accounts-DQEbYKh9.js";
+import { t as inspectSlackAccount } from "./account-inspect-Bvbtu3iH.js";
+import "./shared-C4yVB0Q-.js";
+import { i as SLACK_CHANNEL, t as createSlackSetupWizardBase } from "./setup-core-CeiAVwQ3.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-KTc568SU.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-DeGJf1yp.js";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { adaptScopedAccountAccessor } from "openclaw/plugin-sdk/channel-config-helpers";
 import { createSetupTranslator, noteChannelLookupFailure, noteChannelLookupSummary, parseMentionOrPrefixedId, promptLegacyChannelAllowFromForAccount, resolveEntriesWithOptionalToken } from "openclaw/plugin-sdk/setup-runtime";
 import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 //#region extensions/slack/src/setup-surface.ts
 const t = createSetupTranslator();
+function resolveSlackSetupAuth(account, credentialValues) {
+	if (account.config.identity === "user") return credentialValues.userToken || account.userToken;
+	return credentialValues.botToken || account.botToken;
+}
 async function resolveSlackAllowFromEntries(params) {
 	return await resolveEntriesWithOptionalToken({
 		token: params.token,
@@ -42,7 +47,7 @@ async function promptSlackAllowFrom(params) {
 		prompter: params.prompter,
 		accountId: params.accountId,
 		defaultAccountId: resolveDefaultSlackAccountId(params.cfg),
-		resolveAccount: adaptScopedAccountAccessor(resolveSlackAccount),
+		resolveAccount: adaptScopedAccountAccessor(inspectSlackAccount),
 		resolveExisting: (account, cfg) => resolveSlackAccountAllowFrom({
 			cfg,
 			accountId: account.accountId
@@ -73,13 +78,13 @@ async function promptSlackAllowFrom(params) {
 }
 async function resolveSlackGroupAllowlist(params) {
 	let keys = params.entries;
-	const activeBotToken = resolveSlackAccount({
+	const auth = resolveSlackSetupAuth(inspectSlackAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
-	}).botToken || params.credentialValues.botToken || "";
+	}), params.credentialValues) || "";
 	if (params.entries.length > 0) try {
 		const resolved = await resolveEntriesWithOptionalToken({
-			token: activeBotToken,
+			token: auth,
 			entries: params.entries,
 			buildWithoutToken: (input) => ({
 				input,
@@ -114,10 +119,15 @@ async function resolveSlackGroupAllowlist(params) {
 }
 const slackSetupWizard = createSlackSetupWizardBase({
 	promptAllowFrom: promptSlackAllowFrom,
-	resolveAllowFromEntries: async ({ credentialValues, entries }) => await resolveSlackAllowFromEntries({
-		token: credentialValues.botToken,
-		entries
-	}),
+	resolveAllowFromEntries: async ({ cfg, accountId, credentialValues, entries }) => {
+		return await resolveSlackAllowFromEntries({
+			token: resolveSlackSetupAuth(inspectSlackAccount({
+				cfg,
+				accountId
+			}), credentialValues),
+			entries
+		});
+	},
 	resolveGroupAllowlist: async ({ cfg, accountId, credentialValues, entries, prompter }) => await resolveSlackGroupAllowlist({
 		cfg,
 		accountId,