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

package/dist/channel-type-DXkUajFP.js

@@ -1,109 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-BSr252c_.js";
-import { s as normalizeAllowListLower } from "./group-policy-CdnQzQBI.js";
-import { c as createSlackWebClient } from "./probe-CVRuArHA.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createHash } from "node:crypto";
-import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-//#region extensions/slack/src/channel-type.ts
-var channel_type_exports = /* @__PURE__ */ __exportAll({
-	__resetSlackChannelTypeCacheForTest: () => resetSlackChannelTypeCacheForTest,
-	resetSlackChannelTypeCacheForTest: () => resetSlackChannelTypeCacheForTest,
-	resolveSlackChannelType: () => resolveSlackChannelType,
-	resolveSlackConversationInfo: () => resolveSlackConversationInfo
-});
-const SLACK_CONVERSATION_INFO_CACHE_MAX_ENTRIES = 1024;
-const SLACK_CONVERSATION_INFO_CACHE = /* @__PURE__ */ new Map();
-function getCachedSlackConversationInfo(cacheKey) {
-	const cached = SLACK_CONVERSATION_INFO_CACHE.get(cacheKey);
-	if (cached) {
-		SLACK_CONVERSATION_INFO_CACHE.delete(cacheKey);
-		SLACK_CONVERSATION_INFO_CACHE.set(cacheKey, cached);
-	}
-	return cached;
-}
-function setCachedSlackConversationInfo(cacheKey, conversationInfo) {
-	SLACK_CONVERSATION_INFO_CACHE.delete(cacheKey);
-	SLACK_CONVERSATION_INFO_CACHE.set(cacheKey, conversationInfo);
-	pruneMapToMaxSize(SLACK_CONVERSATION_INFO_CACHE, SLACK_CONVERSATION_INFO_CACHE_MAX_ENTRIES);
-}
-function fingerprintSlackCredential(token) {
-	return createHash("sha256").update(token).digest("hex");
-}
-function resolveConfiguredSlackConversationInfo(params) {
-	if (/^D/i.test(params.channelId)) return { type: "dm" };
-	const channelIdLower = normalizeLowercaseStringOrEmpty(params.channelId);
-	const groupChannels = normalizeAllowListLower(params.account.dm?.groupChannels);
-	if (groupChannels.includes(channelIdLower) || groupChannels.includes(`slack:${channelIdLower}`) || groupChannels.includes(`channel:${channelIdLower}`) || groupChannels.includes(`group:${channelIdLower}`) || groupChannels.includes(`mpim:${channelIdLower}`)) return { type: "group" };
-	return { type: Object.keys(params.account.channels ?? {}).some((key) => {
-		const normalized = normalizeLowercaseStringOrEmpty(key);
-		return normalized === channelIdLower || normalized === `channel:${channelIdLower}` || normalized.replace(/^#/, "") === channelIdLower;
-	}) ? "channel" : "unknown" };
-}
-async function resolveSlackConversationInfo(params) {
-	const channelId = params.channelId.trim();
-	if (!channelId) return { type: "unknown" };
-	const account = resolveSlackAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const operation = params.operation ?? "read";
-	const token = resolveSlackOperationToken(account, operation);
-	const userToken = normalizeOptionalString(account.userToken);
-	const credentialRole = token ? token === userToken ? "user" : "bot" : "none";
-	const credentialFingerprint = token ? fingerprintSlackCredential(token) : "none";
-	const cacheKey = `${account.accountId}:${operation}:${credentialRole}:${credentialFingerprint}:${channelId}`;
-	if (!params.requireFreshName) {
-		const cached = getCachedSlackConversationInfo(cacheKey);
-		if (cached) return cached;
-	}
-	const isNativeImChannel = /^D/i.test(channelId);
-	const configuredInfo = resolveConfiguredSlackConversationInfo({
-		account,
-		channelId
-	});
-	if (token) try {
-		const client = createSlackWebClient(token);
-		if (isNativeImChannel && operation === "write") {
-			const opened = await client.conversations.open({
-				channel: channelId,
-				prevent_creation: true,
-				return_im: true
-			});
-			const user = typeof opened.channel?.user === "string" && opened.channel.user.trim() ? opened.channel.user.trim() : void 0;
-			const result = user ? {
-				type: "dm",
-				user
-			} : { type: "dm" };
-			if (user) setCachedSlackConversationInfo(cacheKey, result);
-			return result;
-		}
-		const channel = (await client.conversations.info({ channel: channelId })).channel;
-		const type = channel?.is_im ? "dm" : channel?.is_mpim ? "group" : "channel";
-		const name = normalizeOptionalString(channel?.name);
-		const user = normalizeOptionalString(channel?.user);
-		const result = {
-			type,
-			...name ? { name } : {},
-			...user ? { user } : {}
-		};
-		setCachedSlackConversationInfo(cacheKey, {
-			type,
-			...user ? { user } : {}
-		});
-		return result;
-	} catch {
-		return { type: isNativeImChannel ? "dm" : "unknown" };
-	}
-	const result = configuredInfo;
-	if (!isNativeImChannel) setCachedSlackConversationInfo(cacheKey, result);
-	return result;
-}
-async function resolveSlackChannelType(params) {
-	return (await resolveSlackConversationInfo(params)).type;
-}
-function resetSlackChannelTypeCacheForTest() {
-	SLACK_CONVERSATION_INFO_CACHE.clear();
-}
-//#endregion
-export { resolveSlackConversationInfo as i, resetSlackChannelTypeCacheForTest as n, resolveSlackChannelType as r, channel_type_exports as t };

package/dist/channel.setup-DOSTEDfA.js

@@ -1,76 +0,0 @@
-import { a as resolveSlackAccount, c as resolveSlackConfigAccessorAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds } from "./accounts-BSr252c_.js";
-import { a as SLACK_CHANNEL, i as slackSetupContract, n as createSlackSetupWizardProxy, o as describeSlackSetupAccount, r as slackSetupAdapter, s as isSlackSetupAccountConfigured } from "./setup-core-tPxMuFez.js";
-import { t as SlackChannelConfigSchema } from "./config-schema-B4j4tCOI.js";
-import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
-import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
-//#region extensions/slack/src/channel.setup.ts
-const slackSetupWizard = createSlackSetupWizardProxy(async () => ({ slackSetupWizard: (await import("./setup-surface-wV-S1dE_.js")).slackSetupWizard }));
-const slackSetupConfigAdapter = 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
-});
-const slackSetupPlugin = {
-	id: SLACK_CHANNEL,
-	meta: {
-		id: SLACK_CHANNEL,
-		label: "Slack",
-		selectionLabel: "Slack (Socket Mode)",
-		detailLabel: "Slack Bot",
-		docsPath: "/channels/slack",
-		docsLabel: "slack",
-		blurb: "supported (Socket Mode).",
-		systemImage: "number",
-		markdownCapable: true,
-		preferSessionLookupForAnnounceTarget: true
-	},
-	setupWizard: slackSetupWizard,
-	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
-	},
-	streaming: { blockStreamingCoalesceDefaults: {
-		minChars: 1500,
-		idleMs: 1e3
-	} },
-	reload: { configPrefixes: ["channels.slack"] },
-	configSchema: SlackChannelConfigSchema,
-	config: {
-		...slackSetupConfigAdapter,
-		hasConfiguredState: ({ env }) => [
-			"SLACK_APP_TOKEN",
-			"SLACK_BOT_TOKEN",
-			"SLACK_USER_TOKEN"
-		].some((key) => typeof env?.[key] === "string" && env[key]?.trim().length > 0),
-		isConfigured: (account) => isSlackSetupAccountConfigured(account),
-		describeAccount: (account) => describeSlackSetupAccount(account)
-	},
-	setup: slackSetupAdapter,
-	setupContract: slackSetupContract
-};
-//#endregion
-export { slackSetupPlugin as t };

package/dist/config-schema-B4j4tCOI.js

@@ -1,428 +0,0 @@
-import { buildSecretInputSchema, hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
-import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
-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."
-	},
-	enterpriseOrgInstall: {
-		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=[\"*\"]."
-	},
-	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" },
-		configWrites: true,
-		mentionPatterns: {
-			targetDescription: "Slack channel IDs",
-			policyNote: "Native Slack @mentions still trigger even when regex patterns are denied.",
-			denyNote: "Native @mentions still trigger."
-		},
-		nativeCommands: true,
-		implicitMentions: true
-	}),
-	allowBots: {
-		label: "Slack Allow Bot Messages",
-		help: "Allow bot-authored messages to trigger Slack replies (default: false)."
-	},
-	botLoopProtection: {
-		label: "Slack Bot Loop Protection",
-		help: "Sliding-window guard for Slack bot-to-bot loops. Default is enabled whenever allowBots lets bot-authored messages reach dispatch."
-	},
-	"botLoopProtection.enabled": {
-		label: "Slack Bot Loop Protection Enabled",
-		help: "Enable the bot-pair loop guard. Defaults to true when allowBots is true or \"mentions\", and false when bot messages are ignored."
-	},
-	"botLoopProtection.maxEventsPerWindow": {
-		label: "Slack Bot Loop Events per Window",
-		help: "Maximum accepted bot-pair messages within the sliding window before suppression starts. Default: 20."
-	},
-	"botLoopProtection.windowSeconds": {
-		label: "Slack Bot Loop Window Seconds",
-		help: "Sliding window length for counting bot-pair messages. Default: 60."
-	},
-	"botLoopProtection.cooldownSeconds": {
-		label: "Slack Bot Loop Cooldown Seconds",
-		help: "How long to suppress the bot pair after it exceeds the budget. Default: 60."
-	},
-	relay: {
-		label: "Slack Relay Mode",
-		help: "Relay-delivered Slack events. Use with mode=\"relay\" when openclaw-slack-router owns the Slack Socket Mode connection."
-	},
-	"relay.url": {
-		label: "Slack Relay URL",
-		help: "Full websocket URL for openclaw-slack-router. Include the route path, for example ws://127.0.0.1:8081/gateway/ws."
-	},
-	"relay.authToken": {
-		label: "Slack Relay Auth Token",
-		help: "Bearer token used by this gateway to authenticate its reverse websocket connection to openclaw-slack-router."
-	},
-	"relay.gatewayId": {
-		label: "Slack Relay Gateway ID",
-		help: "Destination id that openclaw-slack-router uses when routing user-group mentions to this gateway."
-	},
-	botToken: {
-		label: "Slack Bot Token",
-		help: "Slack bot token used for standard chat actions in the configured workspace. Keep this credential scoped and rotate if workspace app permissions change."
-	},
-	appToken: {
-		label: "Slack App Token",
-		help: "Slack app-level token used for Socket Mode connections and event transport when enabled. Use least-privilege app scopes and store this token as a secret."
-	},
-	userToken: {
-		label: "Slack User Token",
-		help: "Optional Slack user token for workflows requiring user-context API access beyond bot permissions. Use sparingly and audit scopes because this token can carry broader authority."
-	},
-	userTokenReadOnly: {
-		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."
-	},
-	presenceEvents: {
-		label: "Slack Presence Events",
-		help: "Poll observed human participants and wake the routed agent on away-to-active transitions. Default: \"off\"."
-	},
-	"presenceEvents.mode": {
-		label: "Slack Presence Event Mode",
-		help: "\"off\" disables polling; \"auto\" covers DMs, MPIMs, and recent threads with up to 8 observed people; \"on\" also covers larger threads and top-level channels."
-	},
-	"channels.*.presenceEvents.mode": {
-		label: "Slack Channel Presence Event Mode",
-		help: "Override presence events for one Slack channel. Use \"on\" to include large threads or top-level channel sessions."
-	},
-	"execApprovals.enabled": {
-		label: "Slack Exec Approvals Enabled",
-		help: "Controls Slack native exec approvals for this account: unset or \"auto\" enables DM-first native approvals when approvers can be resolved, true forces native approvals on, and false disables them."
-	},
-	"execApprovals.approvers": {
-		label: "Slack Exec Approval Approvers",
-		help: "Slack user IDs allowed to approve exec requests for this workspace account. Use Slack user IDs or user targets such as `U123`, `user:U123`, or `<@U123>`. If you leave this unset, OpenClaw falls back to commands.ownerAllowFrom when possible."
-	},
-	"execApprovals.agentFilter": {
-		label: "Slack Exec Approval Agent Filter",
-		help: "Optional allowlist of agent IDs eligible for Slack exec approvals, for example `[\"main\", \"ops-agent\"]`. Use this to keep approval prompts scoped to the agents you actually operate from Slack."
-	},
-	"execApprovals.sessionFilter": {
-		label: "Slack Exec Approval Session Filter",
-		help: "Optional session-key filters matched as substring or regex-style patterns before Slack approval routing is used. Use narrow patterns so Slack approvals only appear for intended sessions."
-	},
-	"execApprovals.target": {
-		label: "Slack Exec Approval Target",
-		help: "Controls where Slack approval prompts are sent: \"dm\" sends to approver DMs (default), \"channel\" sends to the originating Slack chat/thread, and \"both\" sends to both. Channel delivery exposes the command text to the chat, so only use it in trusted channels."
-	},
-	streaming: {
-		label: "Slack Streaming Mode",
-		help: "Unified Slack stream preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". Legacy boolean/streamMode keys are auto-mapped."
-	},
-	"streaming.mode": {
-		label: "Slack Streaming Mode",
-		help: "Canonical Slack preview mode: \"off\" | \"partial\" | \"block\" | \"progress\"."
-	},
-	"streaming.chunkMode": {
-		label: "Slack Chunk Mode",
-		help: "Chunking mode for outbound Slack text delivery: \"length\" (default) or \"newline\"."
-	},
-	"streaming.block.enabled": {
-		label: "Slack Block Streaming Enabled",
-		help: "Enable chunked block-style Slack preview delivery when channels.slack.streaming.mode=\"block\"."
-	},
-	"streaming.block.coalesce": {
-		label: "Slack Block Streaming Coalesce",
-		help: "Merge streamed Slack block replies before final delivery."
-	},
-	"streaming.nativeTransport": {
-		label: "Slack Native Streaming",
-		help: "Enable native Slack text streaming (chat.startStream/chat.appendStream/chat.stopStream) when channels.slack.streaming.mode is partial (default: true). Native streaming and Slack assistant thread status require a reply thread target; top-level DMs can still use draft post-and-edit preview streaming."
-	},
-	"streaming.preview.toolProgress": {
-		label: "Slack Draft Tool Progress",
-		help: "Show tool/progress activity in the live draft preview message (default: true). Set false to hide interim tool updates while the draft preview stays active."
-	},
-	"streaming.preview.commandText": {
-		label: "Slack Draft Command Text",
-		help: "Command/exec detail in preview tool-progress lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
-	},
-	"streaming.progress.label": {
-		label: "Slack Progress Label",
-		help: "Initial progress draft title. Use \"auto\" for built-in single-word labels, a custom string, or false to hide the title."
-	},
-	"streaming.progress.labels": {
-		label: "Slack Progress Label Pool",
-		help: "Candidate labels for streaming.progress.label=\"auto\". Leave unset to use OpenClaw built-in progress labels."
-	},
-	"streaming.progress.maxLines": {
-		label: "Slack Progress Max Lines",
-		help: "Maximum number of compact progress lines to keep below the draft label (default: 8)."
-	},
-	"streaming.progress.maxLineChars": {
-		label: "Slack Progress Max Line Chars",
-		help: "Maximum characters per compact progress line before truncation (default: 120). Prose cuts at word boundaries; commands and paths keep useful suffixes."
-	},
-	"streaming.progress.render": {
-		label: "Slack Progress Renderer",
-		help: "Progress draft renderer: \"text\" uses one portable text body; \"rich\" renders structured Slack Block Kit fields with the same text fallback."
-	},
-	"streaming.progress.nativeTaskCards": {
-		label: "Slack Native Progress Task Cards",
-		help: "Opt in to Slack native task-card progress updates when channels.slack.streaming.mode=\"progress\" and streaming.nativeTransport is enabled. Default: false."
-	},
-	"streaming.progress.toolProgress": {
-		label: "Slack Progress Tool Lines",
-		help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery."
-	},
-	"streaming.progress.commandText": {
-		label: "Slack Progress Command Text",
-		help: "Command/exec detail in progress draft lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
-	},
-	"thread.historyScope": {
-		label: "Slack Thread History Scope",
-		help: "Scope for Slack thread history context (\"thread\" isolates per thread; \"channel\" reuses channel history)."
-	},
-	"thread.inheritParent": {
-		label: "Slack Thread Parent Inheritance",
-		help: "If true, Slack thread sessions inherit the parent channel transcript (default: false)."
-	},
-	"thread.initialHistoryLimit": {
-		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 SlackCapabilitiesSchema = z.union([z.array(z.string()), z.object({ interactiveReplies: z.boolean().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"],
-		capabilities: SlackCapabilitiesSchema.optional(),
-		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/cursor-pages-DSmTg0su.js

@@ -1,13 +0,0 @@
-//#region extensions/slack/src/cursor-pages.ts
-async function collectSlackCursorPages(params) {
-	const items = [];
-	let cursor;
-	do {
-		const response = await params.fetchPage(cursor);
-		items.push(...params.collectPageItems(response));
-		cursor = response.response_metadata?.next_cursor?.trim() || void 0;
-	} while (cursor);
-	return items;
-}
-//#endregion
-export { collectSlackCursorPages as t };