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

package/dist/{setup-core-CeiAVwQ3.js → config-adapter-Bb8hn2tM.js}

@@ -1,8 +1,13 @@
-import { t as inspectSlackAccount } from "./account-inspect-Bvbtu3iH.js";
+import { a as resolveSlackAccount, c as resolveSlackConfigAccessorAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds } from "./accounts-BSr252c_.js";
+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 { DEFAULT_ACCOUNT_ID, createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createAllowlistSetupWizardProxy, createLegacyCompatChannelDmPolicy, createPatchedAccountSetupAdapter, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, parseMentionOrPrefixedId, patchChannelConfigForAccount, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
+import { DEFAULT_ACCOUNT_ID, createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createAllowlistSetupWizardProxy, 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
@@ -24,8 +29,8 @@ function buildSlackManifest(botName = "OpenClaw") {
 				messages_tab_enabled: true,
 				messages_tab_read_only_enabled: false
 			},
-			assistant_view: {
-				assistant_description: `${safeName} connects Slack assistant threads to OpenClaw agents.`,
+			agent_view: {
+				agent_description: `${safeName} connects Slack Agent View conversations to OpenClaw agents.`,
 				suggested_prompts: [
 					{
 						title: "What can you do?",
@@ -77,8 +82,7 @@ function buildSlackManifest(botName = "OpenClaw") {
 			event_subscriptions: { bot_events: [
 				"app_home_opened",
 				"app_mention",
-				"assistant_thread_context_changed",
-				"assistant_thread_started",
+				"app_context_changed",
 				"channel_rename",
 				"member_joined_channel",
 				"member_left_channel",
@@ -100,8 +104,8 @@ function buildSlackSetupLines() {
 		"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",
+		"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")}`
@@ -157,14 +161,14 @@ function setSlackSetupIdentity(params) {
 		cfg: params.cfg,
 		channel: SLACK_CHANNEL,
 		accountId: params.accountId,
-		patch: params.identity === "user" ? { identity: "user" } : {}
+		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.identity;
+		delete nextSlack.postAs;
 		return {
 			...next,
 			channels: {
@@ -176,8 +180,8 @@ function setSlackSetupIdentity(params) {
 	const account = slack.accounts?.[params.accountId];
 	if (!account) return next;
 	const nextAccount = { ...account };
-	if (slack.identity === "user") nextAccount.identity = "bot";
-	else delete nextAccount.identity;
+	if (slack.postAs === "user") nextAccount.postAs = "bot";
+	else delete nextAccount.postAs;
 	return {
 		...next,
 		channels: {
@@ -192,30 +196,6 @@ function setSlackSetupIdentity(params) {
 		}
 	};
 }
-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,
@@ -263,53 +243,131 @@ function hasSlackSetupCredentials(params) {
 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 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 = input.identity ?? account.config.identity ?? "bot";
-		const mode = input.mode ?? account.config.mode ?? "socket";
+		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 (input.useEnv) return identity === "user" ? "Slack user identity setup does not support --use-env; configure userToken and the transport credential explicitly." : null;
+		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,
+			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) => ({
-		...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 } : {}
-	})
+	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 identity = input.identity ?? inspectSlackAccount({
+		const setupInput = input;
+		const identity = setupInput.identity ?? inspectSlackAccount({
 			cfg,
 			accountId
-		}).config.identity;
+		}).config.postAs;
 		return slackSetupAdapterBase.applyAccountConfig({
 			cfg,
 			accountId,
 			input: identity === "user" ? {
-				...input,
+				...setupInput,
 				identity
-			} : input
+			} : 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 = createLegacyCompatChannelDmPolicy({
+	const slackDmPolicy = createChannelDmPolicy({
 		label: "Slack",
 		channel: SLACK_CHANNEL,
+		resolveAccount: (cfg, accountId) => inspectSlackAccount({
+			cfg,
+			accountId
+		}),
+		buildPatch: ({ account, policy, allowFrom }) => ({
+			dmPolicy: policy,
+			...allowFrom === void 0 ? {} : { allowFrom },
+			dm: {
+				...account.config.dm,
+				enabled: typeof account.config.dm?.enabled === "boolean" ? account.config.dm.enabled : true
+			}
+		}),
 		promptAllowFrom: handlers.promptAllowFrom
 	});
 	return {
@@ -332,7 +390,7 @@ function createSlackSetupWizardBase(handlers) {
 				cfg,
 				accountId
 			});
-			if (currentAccount.configured && currentAccount.config.identity !== "user") return { cfg };
+			if (currentAccount.configured && currentAccount.config.postAs !== "user") return { cfg };
 			const identity = await prompter.select({
 				message: "How should OpenClaw appear in Slack?",
 				options: [{
@@ -344,14 +402,14 @@ function createSlackSetupWizardBase(handlers) {
 					label: "Slack user",
 					hint: "Post as the authorizing human"
 				}],
-				initialValue: currentAccount.config.identity ?? "bot"
+				initialValue: currentAccount.config.postAs ?? "bot"
 			});
 			const next = setSlackSetupIdentity({
 				cfg,
 				accountId,
 				identity
 			});
-			if (currentAccount.configured && identity === currentAccount.config.identity) return { cfg: next };
+			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([
@@ -375,7 +433,7 @@ function createSlackSetupWizardBase(handlers) {
 			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({
+			}).config.postAs ?? "bot") === "bot" && Boolean(process.env.SLACK_BOT_TOKEN?.trim()) && Boolean(process.env.SLACK_APP_TOKEN?.trim()) && !inspectSlackAccount({
 				cfg,
 				accountId
 			}).configured,
@@ -392,7 +450,7 @@ function createSlackSetupWizardBase(handlers) {
 				shouldPrompt: ({ cfg, accountId }) => (inspectSlackAccount({
 					cfg,
 					accountId
-				}).config.identity ?? "bot") === "bot"
+				}).config.postAs ?? "bot") === "bot"
 			}),
 			createSlackTokenCredential({
 				inputKey: "userToken",
@@ -404,7 +462,7 @@ function createSlackSetupWizardBase(handlers) {
 				shouldPrompt: ({ cfg, accountId }) => inspectSlackAccount({
 					cfg,
 					accountId
-				}).config.identity === "user"
+				}).config.postAs === "user"
 			}),
 			createSlackTokenCredential({
 				inputKey: "appToken",
@@ -418,7 +476,7 @@ function createSlackSetupWizardBase(handlers) {
 						cfg,
 						accountId
 					});
-					return (account.config.identity ?? "bot") === "bot" || (account.config.mode ?? "socket") === "socket";
+					return (account.config.postAs ?? "bot") === "bot" || (account.config.mode ?? "socket") === "socket";
 				}
 			}),
 			createSlackTokenCredential({
@@ -432,7 +490,7 @@ function createSlackSetupWizardBase(handlers) {
 						cfg,
 						accountId
 					});
-					return account.config.identity === "user" && account.config.mode === "http";
+					return account.config.postAs === "user" && account.config.mode === "http";
 				}
 			})
 		],
@@ -480,14 +538,6 @@ function createSlackSetupWizardBase(handlers) {
 			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)
 	};
 }
@@ -499,4 +549,23 @@ function createSlackSetupWizardProxy(loadWizard) {
 	});
 }
 //#endregion
-export { describeSlackSetupAccount as a, SLACK_CHANNEL as i, createSlackSetupWizardProxy as n, isSlackSetupAccountConfigured as o, slackSetupAdapter as r, createSlackSetupWizardBase as t };
+//#region extensions/slack/src/config-adapter.ts
+const slackBaseConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: SLACK_CHANNEL,
+	listAccountIds: listSlackAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveSlackAccount),
+	resolveAccessorAccount: resolveSlackConfigAccessorAccount,
+	defaultAccountId: resolveDefaultSlackAccountId,
+	clearBaseFields: [
+		"botToken",
+		"appToken",
+		"userToken",
+		"signingSecret",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+//#endregion
+export { slackSetupContract as a, isSlackSetupAccountConfigured as c, slackSetupAdapter as i, createSlackSetupWizardBase as n, SLACK_CHANNEL as o, createSlackSetupWizardProxy as r, describeSlackSetupAccount as s, slackBaseConfigAdapter as t };

package/dist/{config-schema-XjJGfwQC.js → config-schema-BajbuJGL.js}

@@ -1,8 +1,9 @@
-import { n as buildChannelConfigSchema, t as SlackConfigSchema } from "./config-api-Df9a1B8C.js";
+import { buildSecretInputSchema, hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-//#endregion
-//#region extensions/slack/src/config-schema.ts
-const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { uiHints: {
+import { ChannelBotLoopProtectionSchema, ChannelDangerouslyAllowNameMatchingSchema, ChannelImplicitMentionsSchema, ChannelPreviewStreamingConfigSchema, ChannelStreamingProgressSchema, GroupPolicySchema, ProviderCommandsSchema, ReplyToModeSchema, buildChannelAllowBotsSchema, buildChannelConfigSchema, buildChannelExecApprovalsSchema, buildChannelReactionShape, buildCommonChannelAccountShape, buildGroupEntrySchema, requireAllowlistAllowFrom, requireOpenAllowFrom } from "openclaw/plugin-sdk/channel-config-schema";
+import { z } from "zod";
+//#region extensions/slack/src/config-ui-hints.ts
+const slackChannelConfigUiHints = {
 	"": {
 		label: "Slack",
 		help: "Slack channel provider configuration for bot/app tokens, streaming behavior, and DM policy controls. Keep token handling and thread behavior explicit to avoid noisy workspace interactions."
@@ -11,16 +12,13 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Enterprise Grid Org Install",
 		help: "Enable only for an Enterprise Grid org-wide bot installation. OpenClaw verifies the token with Slack auth.test at startup; DMs must be disabled or use dmPolicy=\"open\" with allowFrom=[\"*\"]."
 	},
-	identity: {
+	postAs: {
 		label: "Slack Identity",
 		help: "Select \"bot\" (default) for the classic Slack app/bot identity or \"user\" to post as the authorizing human through a user token while the app carries event transport."
 	},
 	...createChannelConfigUiHints({
 		channelLabel: "Slack",
-		dmPolicy: {
-			channelKey: "slack",
-			includeLegacyNestedPolicy: true
-		},
+		dmPolicy: { channelKey: "slack" },
 		configWrites: true,
 		mentionPatterns: {
 			targetDescription: "Slack channel IDs",
@@ -54,22 +52,6 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Bot Loop Cooldown Seconds",
 		help: "How long to suppress the bot pair after it exceeds the budget. Default: 60."
 	},
-	socketMode: {
-		label: "Slack Socket Mode Transport",
-		help: "Slack Socket Mode transport tuning passed to the Slack SDK. Use only when investigating ping/pong timeout or stale websocket behavior."
-	},
-	"socketMode.clientPingTimeout": {
-		label: "Slack Socket Mode Pong Timeout",
-		help: "Milliseconds the Slack SDK waits for a pong after its client ping before treating the websocket as stale (OpenClaw default: 15000). Increase on hosts with event-loop starvation or slow network scheduling."
-	},
-	"socketMode.serverPingTimeout": {
-		label: "Slack Socket Mode Server Ping Timeout",
-		help: "Milliseconds the Slack SDK waits for Slack server pings before treating the websocket as stale."
-	},
-	"socketMode.pingPongLoggingEnabled": {
-		label: "Slack Socket Mode Ping/Pong Logging",
-		help: "Enable Slack SDK ping/pong transport logs while debugging Socket Mode websocket health."
-	},
 	relay: {
 		label: "Slack Relay Mode",
 		help: "Relay-delivered Slack events. Use with mode=\"relay\" when openclaw-slack-router owns the Slack Socket Mode connection."
@@ -102,10 +84,6 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack User Token Read Only",
 		help: "When true, treat configured Slack user token usage as read-only helper behavior where possible. Keep enabled if you only need supplemental reads without user-context writes."
 	},
-	"capabilities.interactiveReplies": {
-		label: "Slack Interactive Replies",
-		help: "Enable agent-authored Slack interactive reply directives (`[[slack_buttons: ...]]`, `[[slack_select: ...]]`). Default: false."
-	},
 	execApprovals: {
 		label: "Slack Exec Approvals",
 		help: "Slack-native exec approval routing and approver authorization. When unset, OpenClaw auto-enables DM-first native approvals if approvers can be resolved for this workspace account."
@@ -218,6 +196,227 @@ const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { u
 		label: "Slack Thread Initial History Limit",
 		help: "Maximum number of existing Slack thread messages to fetch when starting a new thread session (default: 20, set to 0 to disable)."
 	}
-} });
+};
+//#endregion
+//#region extensions/slack/src/config-schema.ts
+const SecretInputSchema = buildSecretInputSchema();
+const SlackStreamingProgressSchema = ChannelStreamingProgressSchema.extend({ nativeTaskCards: z.boolean().optional() }).strict();
+const SlackStreamingConfigSchema = ChannelPreviewStreamingConfigSchema.extend({
+	nativeTransport: z.boolean().optional(),
+	progress: SlackStreamingProgressSchema.optional()
+}).strict();
+const SlackDmSchema = z.object({
+	enabled: z.boolean().optional(),
+	groupEnabled: z.boolean().optional(),
+	groupChannels: z.array(z.union([z.string(), z.number()])).optional()
+}).strict();
+const SlackPresenceEventsSchema = z.object({ mode: z.enum([
+	"off",
+	"auto",
+	"on"
+]).optional() }).strict();
+const SlackChannelSchema = buildGroupEntrySchema({
+	ignoreOtherMentions: z.boolean().optional(),
+	replyToMode: ReplyToModeSchema.optional(),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	users: z.array(z.union([z.string(), z.number()])).optional(),
+	presenceEvents: SlackPresenceEventsSchema.optional()
+}, { omit: ["allowFrom"] });
+const SlackThreadSchema = z.object({
+	historyScope: z.enum(["thread", "channel"]).optional(),
+	inheritParent: z.boolean().optional(),
+	initialHistoryLimit: z.number().int().min(0).optional()
+}).strict();
+const ReplyToModeByChatTypeSchema = z.object({
+	direct: ReplyToModeSchema.optional(),
+	group: ReplyToModeSchema.optional(),
+	channel: ReplyToModeSchema.optional()
+}).strict();
+const SlackRelaySchema = z.object({
+	url: z.string().optional(),
+	authToken: SecretInputSchema.optional(),
+	gatewayId: z.string().optional()
+}).strict();
+const SlackIdentitySchema = z.enum(["bot", "user"]);
+const SlackAccountSchema = z.object({
+	...buildCommonChannelAccountShape({
+		omit: ["groupAllowFrom"],
+		streaming: SlackStreamingConfigSchema.optional()
+	}),
+	postAs: SlackIdentitySchema.default("bot"),
+	mode: z.enum([
+		"socket",
+		"http",
+		"relay"
+	]).optional(),
+	enterpriseOrgInstall: z.boolean().optional(),
+	relay: SlackRelaySchema.optional(),
+	signingSecret: SecretInputSchema.optional(),
+	webhookPath: z.string().optional(),
+	execApprovals: buildChannelExecApprovalsSchema(z.union([z.string(), z.number()])),
+	commands: ProviderCommandsSchema,
+	botToken: SecretInputSchema.optional(),
+	appToken: SecretInputSchema.optional(),
+	userToken: SecretInputSchema.optional(),
+	userTokenReadOnly: z.boolean().optional().default(true),
+	allowBots: buildChannelAllowBotsSchema({ allowMentions: true }),
+	botLoopProtection: ChannelBotLoopProtectionSchema.optional(),
+	dangerouslyAllowNameMatching: ChannelDangerouslyAllowNameMatchingSchema,
+	requireMention: z.boolean().optional(),
+	implicitMentions: ChannelImplicitMentionsSchema.optional(),
+	unfurlLinks: z.boolean().optional(),
+	unfurlMedia: z.boolean().optional(),
+	...buildChannelReactionShape({
+		notificationModes: [
+			"off",
+			"own",
+			"all",
+			"allowlist"
+		],
+		reactionAllowlist: true,
+		ackReaction: z.string().optional()
+	}),
+	replyToModeByChatType: ReplyToModeByChatTypeSchema.optional(),
+	thread: SlackThreadSchema.optional(),
+	presenceEvents: SlackPresenceEventsSchema.optional(),
+	actions: z.object({
+		reactions: z.boolean().optional(),
+		messages: z.boolean().optional(),
+		pins: z.boolean().optional(),
+		search: z.boolean().optional(),
+		permissions: z.boolean().optional(),
+		memberInfo: z.boolean().optional(),
+		channelInfo: z.boolean().optional(),
+		emojiList: z.boolean().optional()
+	}).strict().optional(),
+	slashCommand: z.object({
+		enabled: z.boolean().optional(),
+		name: z.string().optional(),
+		sessionPrefix: z.string().optional(),
+		ephemeral: z.boolean().optional()
+	}).strict().optional(),
+	dm: SlackDmSchema.optional(),
+	channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
+	typingReaction: z.string().optional()
+}).strict();
+const SlackAccountEntrySchema = SlackAccountSchema.extend({ postAs: SlackIdentitySchema.optional() });
+function validateSlackSigningSecretRequirements(value, ctx) {
+	const resolveMode = (mode) => mode === "http" || mode === "socket" || mode === "relay" ? mode : void 0;
+	const baseMode = resolveMode(value.mode) ?? "socket";
+	if (baseMode === "http" && !hasConfiguredSecretInput(value.signingSecret)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "channels.slack.mode=\"http\" requires channels.slack.signingSecret",
+		path: ["signingSecret"]
+	});
+	for (const [accountId, account] of Object.entries(value.accounts ?? {})) {
+		if (!account || account.enabled === false) continue;
+		if ((resolveMode(account.mode) ?? baseMode) !== "http") continue;
+		if (!hasConfiguredSecretInput(account.signingSecret ?? value.signingSecret)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.accounts.*.mode=\"http\" requires channels.slack.signingSecret or channels.slack.accounts.*.signingSecret",
+			path: [
+				"accounts",
+				accountId,
+				"signingSecret"
+			]
+		});
+	}
+}
+const SlackChannelConfigSchema = buildChannelConfigSchema(SlackAccountSchema.safeExtend({
+	mode: z.enum([
+		"socket",
+		"http",
+		"relay"
+	]).optional().default("socket"),
+	signingSecret: SecretInputSchema.optional(),
+	webhookPath: z.string().optional().default("/slack/events"),
+	groupPolicy: GroupPolicySchema.optional().default("allowlist"),
+	accounts: z.record(z.string(), SlackAccountEntrySchema.optional()).optional(),
+	defaultAccount: z.string().optional()
+}).superRefine((value, ctx) => {
+	const dmPolicy = value.dmPolicy ?? "pairing";
+	const allowFrom = value.allowFrom;
+	requireOpenAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.slack.dmPolicy=\"open\" requires channels.slack.allowFrom to include \"*\""
+	});
+	requireAllowlistAllowFrom({
+		policy: dmPolicy,
+		allowFrom,
+		ctx,
+		path: ["allowFrom"],
+		message: "channels.slack.dmPolicy=\"allowlist\" requires channels.slack.allowFrom to contain at least one sender ID"
+	});
+	const requireRelayConfig = (relay, path) => {
+		if (typeof relay?.url !== "string" || !relay.url.trim()) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.url",
+			path: [...path, "url"]
+		});
+		if (!hasConfiguredSecretInput(relay?.authToken)) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.authToken",
+			path: [...path, "authToken"]
+		});
+		if (typeof relay?.gatewayId !== "string" || !relay.gatewayId.trim()) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "channels.slack.mode=\"relay\" requires relay.gatewayId",
+			path: [...path, "gatewayId"]
+		});
+	};
+	const baseMode = value.mode ?? "socket";
+	const accountIds = value.accounts ? Object.keys(value.accounts) : [];
+	if (!value.accounts) {
+		if (baseMode === "relay") requireRelayConfig(value.relay, ["relay"]);
+		validateSlackSigningSecretRequirements(value, ctx);
+		return;
+	}
+	for (const accountId of accountIds) {
+		const account = value.accounts[accountId];
+		if (!account || account.enabled === false) continue;
+		const accountMode = account.mode ?? baseMode;
+		const effectiveRelay = {
+			...value.relay,
+			...account.relay
+		};
+		const effectivePolicy = account.dmPolicy ?? value.dmPolicy ?? "pairing";
+		const effectiveAllowFrom = account.allowFrom ?? value.allowFrom;
+		requireOpenAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.slack.accounts.*.dmPolicy=\"open\" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to include \"*\""
+		});
+		requireAllowlistAllowFrom({
+			policy: effectivePolicy,
+			allowFrom: effectiveAllowFrom,
+			ctx,
+			path: [
+				"accounts",
+				accountId,
+				"allowFrom"
+			],
+			message: "channels.slack.accounts.*.dmPolicy=\"allowlist\" requires channels.slack.accounts.*.allowFrom (or channels.slack.allowFrom) to contain at least one sender ID"
+		});
+		if (accountMode !== "http") {
+			if (accountMode === "relay") requireRelayConfig(effectiveRelay, [
+				"accounts",
+				accountId,
+				"relay"
+			]);
+			continue;
+		}
+	}
+	validateSlackSigningSecretRequirements(value, ctx);
+}), { uiHints: slackChannelConfigUiHints });
 //#endregion
 export { SlackChannelConfigSchema as t };

package/dist/{directory-config-Bv0lcUlH.js → directory-config-CeixfVuC.js}

@@ -1,5 +1,5 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-DQEbYKh9.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-BSr252c_.js";
 import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
 import "./targets-KmjP2E8s.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";

package/dist/directory-contract-api.js

@@ -1,2 +1,2 @@
-import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-Bv0lcUlH.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-CeixfVuC.js";
 export { listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig };