@openclaw/slack 2026.7.2-beta.2 → 2026.7.2-beta.4

package/dist/setup-core-tPxMuFez.js

@@ -0,0 +1,600 @@
+import { t as inspectSlackAccount } from "./account-inspect-jn1xLaVi.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 { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
+import { DEFAULT_ACCOUNT_ID, createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createAllowlistSetupWizardProxy, createPatchedAccountSetupAdapter, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, mergeAllowFromEntries, 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
+			},
+			agent_view: {
+				agent_description: `${safeName} connects Slack Agent View conversations 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",
+				"app_context_changed",
+				"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 Agent View events",
+		"5) App Home -> enable the Home tab, Messages tab for DMs, and Agent 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" ? { postAs: "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.postAs;
+		return {
+			...next,
+			channels: {
+				...next.channels,
+				slack: nextSlack
+			}
+		};
+	}
+	const account = slack.accounts?.[params.accountId];
+	if (!account) return next;
+	const nextAccount = { ...account };
+	if (slack.postAs === "user") nextAccount.postAs = "bot";
+	else delete nextAccount.postAs;
+	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 }) => {
+		const setupInput = input;
+		if (setupInput.useEnv && accountId !== DEFAULT_ACCOUNT_ID) return "Slack env tokens can only be used for the default account.";
+		const account = inspectSlackAccount({
+			cfg,
+			accountId
+		});
+		const identity = setupInput.identity ?? account.config.postAs ?? "bot";
+		const mode = setupInput.mode ?? account.config.mode ?? "socket";
+		if (identity === "user" && mode === "relay") return "Slack user identity setup supports mode \"socket\" or \"http\", not \"relay\".";
+		if (setupInput.useEnv) return identity === "user" ? "Slack user identity setup does not support --use-env; configure userToken and the transport credential explicitly." : null;
+		if (hasSlackSetupCredentials({
+			input: setupInput,
+			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) => {
+		const setupInput = input;
+		return {
+			...setupInput.identity ? { postAs: setupInput.identity } : {},
+			...setupInput.identity === "user" && setupInput.mode ? { mode: setupInput.mode } : {},
+			...setupInput.botToken ? { botToken: setupInput.botToken } : {},
+			...setupInput.appToken ? { appToken: setupInput.appToken } : {},
+			...setupInput.userToken ? { userToken: setupInput.userToken } : {},
+			...setupInput.signingSecret ? { signingSecret: setupInput.signingSecret } : {}
+		};
+	}
+});
+const slackSetupAdapter = {
+	...slackSetupAdapterBase,
+	singleAccountKeysToMove: ["appToken"],
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const setupInput = input;
+		const identity = setupInput.identity ?? inspectSlackAccount({
+			cfg,
+			accountId
+		}).config.postAs;
+		return slackSetupAdapterBase.applyAccountConfig({
+			cfg,
+			accountId,
+			input: identity === "user" ? {
+				...setupInput,
+				identity
+			} : setupInput
+		});
+	}
+};
+const slackSetupContract = defineChannelSetupContract({
+	fields: {
+		botToken: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--bot-token <token>",
+				description: "Slack bot token"
+			}
+		},
+		appToken: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--app-token <token>",
+				description: "Slack app token"
+			}
+		},
+		userToken: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--user-token <token>",
+				description: "Slack user token"
+			}
+		},
+		signingSecret: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--signing-secret <secret>",
+				description: "Slack signing secret"
+			}
+		},
+		identity: {
+			kind: "choice",
+			choices: ["bot", "user"],
+			cli: {
+				flags: "--identity <kind>",
+				description: "Slack identity"
+			}
+		},
+		mode: {
+			kind: "choice",
+			choices: ["socket", "http"],
+			cli: {
+				flags: "--mode <mode>",
+				description: "Slack connection mode"
+			}
+		},
+		useEnv: {
+			kind: "boolean",
+			cli: {
+				flags: "--use-env",
+				description: "Use Slack environment credentials"
+			}
+		}
+	},
+	legacyAdapter: slackSetupAdapter
+});
+function createSlackSetupWizardBase(handlers) {
+	const slackDmPolicy = {
+		label: "Slack",
+		channel: SLACK_CHANNEL,
+		policyKey: "channels.slack.dmPolicy",
+		allowFromKey: "channels.slack.allowFrom",
+		resolveConfigKeys: (_cfg, accountId) => accountId && accountId !== DEFAULT_ACCOUNT_ID ? {
+			policyKey: `channels.slack.accounts.${accountId}.dmPolicy`,
+			allowFromKey: `channels.slack.accounts.${accountId}.allowFrom`
+		} : {
+			policyKey: "channels.slack.dmPolicy",
+			allowFromKey: "channels.slack.allowFrom"
+		},
+		getCurrent: (cfg, accountId) => inspectSlackAccount({
+			cfg,
+			accountId
+		}).config.dmPolicy ?? "pairing",
+		setPolicy: (cfg, policy, accountId) => {
+			const account = inspectSlackAccount({
+				cfg,
+				accountId
+			});
+			return patchChannelConfigForAccount({
+				cfg,
+				channel: SLACK_CHANNEL,
+				accountId: account.accountId,
+				patch: {
+					dmPolicy: policy,
+					...policy === "open" ? { allowFrom: mergeAllowFromEntries(account.config.allowFrom ?? [], ["*"]) } : {},
+					dm: {
+						...account.config.dm,
+						enabled: typeof account.config.dm?.enabled === "boolean" ? account.config.dm.enabled : true
+					}
+				}
+			});
+		},
+		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.postAs !== "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.postAs ?? "bot"
+			});
+			const next = setSlackSetupIdentity({
+				cfg,
+				accountId,
+				identity
+			});
+			if (currentAccount.configured && identity === currentAccount.config.postAs) 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.postAs ?? "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.postAs ?? "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.postAs === "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.postAs ?? "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.postAs === "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 { SLACK_CHANNEL as a, slackSetupContract as i, createSlackSetupWizardProxy as n, describeSlackSetupAccount as o, slackSetupAdapter as r, isSlackSetupAccountConfigured as s, createSlackSetupWizardBase as t };

package/dist/setup-plugin-api.js

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