@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/config-schema-SgZT6nXV.js

@@ -1,373 +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,
-		streaming: {
-			"": "Unified Slack stream preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". Legacy boolean/streamMode keys are auto-mapped.",
-			mode: "Canonical Slack preview mode: \"off\" | \"partial\" | \"block\" | \"progress\".",
-			chunkMode: "Chunking mode for outbound Slack text delivery: \"length\" (default) or \"newline\".",
-			"block.enabled": "Enable chunked block-style Slack preview delivery when channels.slack.streaming.mode=\"block\".",
-			"block.coalesce": "Merge streamed Slack block replies before final delivery.",
-			nativeTransport: "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.",
-			"preview.toolProgress": "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.",
-			"preview.commandText": "Command/exec detail in preview tool-progress lines: \"raw\" preserves released behavior; \"status\" shows only the tool label.",
-			"progress.render": "Progress draft renderer: \"text\" uses one portable text body; \"rich\" renders structured Slack Block Kit fields with the same text fallback.",
-			"progress.nativeTaskCards": "Opt in to Slack native task-card progress updates when channels.slack.streaming.mode=\"progress\" and streaming.nativeTransport is enabled. Default: false."
-		},
-		progress: { labels: "openclaw" }
-	}),
-	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."
-	},
-	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."
-	},
-	"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 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";
-	const hasImplicitRootAccount = Object.keys(value.accounts ?? {}).length === 0;
-	if (baseMode === "http" && hasImplicitRootAccount && !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) => {
-	if (value.enabled === false) return;
-	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-eX7p8Wwt.js

@@ -1,19 +0,0 @@
-//#region extensions/slack/src/cursor-pages.ts
-const SLACK_CURSOR_PAGE_LIMIT = 1e4;
-async function collectSlackCursorPages(params) {
-	const items = [];
-	let cursor;
-	const seenCursors = /* @__PURE__ */ new Set();
-	for (let pageCount = 1; pageCount <= SLACK_CURSOR_PAGE_LIMIT; pageCount += 1) {
-		const response = await params.fetchPage(cursor);
-		items.push(...params.collectPageItems(response));
-		const nextCursor = response.response_metadata?.next_cursor?.trim() || void 0;
-		if (!nextCursor) return items;
-		if (seenCursors.has(nextCursor)) throw new Error(`Slack cursor pagination repeated a cursor after ${pageCount} pages`);
-		seenCursors.add(nextCursor);
-		cursor = nextCursor;
-	}
-	throw new Error(`Slack cursor pagination exceeded ${SLACK_CURSOR_PAGE_LIMIT} pages`);
-}
-//#endregion
-export { collectSlackCursorPages as t };

package/dist/directory-config-CnCIAktf.js

@@ -1,54 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-CHAeNZOX.js";
-import { i as parseSlackTarget } from "./target-parsing-N6lHogYZ.js";
-import "./targets-KmjP2E8s.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createResolvedDirectoryEntriesLister } from "openclaw/plugin-sdk/directory-config-runtime";
-//#region extensions/slack/src/directory-config.ts
-var directory_config_exports = /* @__PURE__ */ __exportAll({
-	listSlackDirectoryGroupsFromConfig: () => listSlackDirectoryGroupsFromConfig,
-	listSlackDirectoryPeersFromConfig: () => listSlackDirectoryPeersFromConfig
-});
-function resolveSlackDirectoryConfigAccount(cfg, accountId) {
-	const resolvedAccountId = normalizeAccountId(accountId ?? resolveDefaultSlackAccountId(cfg));
-	const config = mergeSlackAccountConfig(cfg, resolvedAccountId);
-	return {
-		accountId: resolvedAccountId,
-		config,
-		dm: config.dm,
-		allowFrom: resolveSlackAccountAllowFrom({
-			cfg,
-			accountId: resolvedAccountId
-		}) ?? []
-	};
-}
-const listSlackDirectoryPeersFromConfig = createResolvedDirectoryEntriesLister({
-	kind: "user",
-	resolveAccount: (cfg, accountId) => resolveSlackDirectoryConfigAccount(cfg, accountId),
-	resolveSources: (account) => {
-		const channelUsers = Object.values(account.config.channels ?? {}).flatMap((channel) => channel.users ?? []);
-		return [
-			account.allowFrom,
-			Object.keys(account.config.dms ?? {}),
-			channelUsers
-		];
-	},
-	normalizeId: (raw) => {
-		const normalizedUserId = (raw.match(/^<@([A-Z0-9]+)>$/i)?.[1] ?? raw).replace(/^(slack|user):/i, "").trim();
-		if (!normalizedUserId) return null;
-		const normalized = parseSlackTarget(`user:${normalizedUserId}`, { defaultKind: "user" });
-		return normalized?.kind === "user" ? `user:${normalizeLowercaseStringOrEmpty(normalized.id)}` : null;
-	}
-});
-const listSlackDirectoryGroupsFromConfig = createResolvedDirectoryEntriesLister({
-	kind: "group",
-	resolveAccount: (cfg, accountId) => resolveSlackDirectoryConfigAccount(cfg, accountId),
-	resolveSources: (account) => [Object.keys(account.config.channels ?? {})],
-	normalizeId: (raw) => {
-		const normalized = parseSlackTarget(raw, { defaultKind: "channel" });
-		return normalized?.kind === "channel" ? `channel:${normalizeLowercaseStringOrEmpty(normalized.id)}` : null;
-	}
-});
-//#endregion
-export { listSlackDirectoryGroupsFromConfig as n, listSlackDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/directory-live-DKunWh3A.js

@@ -1,131 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { a as resolveSlackAccount } from "./accounts-CHAeNZOX.js";
-import { a as createSlackLookupClient } from "./probe-CgDsSops.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/slack/src/directory-live.ts
-var directory_live_exports = /* @__PURE__ */ __exportAll({
-	getSlackDirectorySelfLive: () => getSlackDirectorySelfLive,
-	listSlackDirectoryGroupsLive: () => listSlackDirectoryGroupsLive,
-	listSlackDirectoryPeersLive: () => listSlackDirectoryPeersLive
-});
-function createSlackDirectoryClient(params) {
-	const account = resolveSlackAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const token = account.userToken ?? account.botToken?.trim();
-	return token ? createSlackLookupClient(token) : null;
-}
-function normalizeQuery(value) {
-	return normalizeLowercaseStringOrEmpty(value);
-}
-function buildUserRank(user) {
-	let rank = 0;
-	if (!user.deleted) rank += 2;
-	if (!user.is_bot && !user.is_app_user) rank += 1;
-	return rank;
-}
-function buildChannelRank(channel) {
-	return channel.is_archived ? 0 : 1;
-}
-function slackUserToDirectoryEntry(user, fallback) {
-	const id = normalizeOptionalString(user.id) ?? normalizeOptionalString(fallback?.id);
-	if (!id) return null;
-	const handle = normalizeOptionalString(user.name) ?? normalizeOptionalString(fallback?.name);
-	const display = normalizeOptionalString(user.profile?.display_name) || normalizeOptionalString(user.profile?.real_name) || normalizeOptionalString(user.real_name) || handle;
-	return {
-		kind: "user",
-		id: `user:${id}`,
-		name: display || void 0,
-		handle: handle ? `@${handle}` : void 0,
-		rank: buildUserRank(user),
-		raw: user
-	};
-}
-async function getSlackDirectorySelfLive(params) {
-	const client = createSlackDirectoryClient(params);
-	if (!client) return null;
-	const auth = await client.auth.test();
-	const userId = normalizeOptionalString(auth.user_id);
-	if (!userId) return null;
-	try {
-		return slackUserToDirectoryEntry((await client.users.info({ user: userId })).user ?? {}, {
-			id: userId,
-			name: auth.user
-		});
-	} catch {
-		return slackUserToDirectoryEntry({
-			id: userId,
-			name: auth.user
-		}, {
-			id: userId,
-			name: auth.user
-		});
-	}
-}
-async function listSlackDirectoryPeersLive(params) {
-	const client = createSlackDirectoryClient(params);
-	if (!client) return [];
-	const query = normalizeQuery(params.query);
-	const members = [];
-	let cursor;
-	do {
-		const res = await client.users.list({
-			limit: 200,
-			cursor
-		});
-		if (Array.isArray(res.members)) members.push(...res.members);
-		const next = res.response_metadata?.next_cursor?.trim();
-		cursor = next ? next : void 0;
-	} while (cursor);
-	const rows = members.filter((member) => {
-		const candidates = [
-			member.profile?.display_name || member.profile?.real_name || member.real_name,
-			member.name,
-			member.profile?.email
-		].map((item) => normalizeOptionalLowercaseString(item)).filter(Boolean);
-		if (!query) return true;
-		return candidates.some((candidate) => candidate?.includes(query));
-	}).map((member) => slackUserToDirectoryEntry(member)).filter(Boolean);
-	if (typeof params.limit === "number" && params.limit > 0) return rows.slice(0, params.limit);
-	return rows;
-}
-async function listSlackDirectoryGroupsLive(params) {
-	const client = createSlackDirectoryClient(params);
-	if (!client) return [];
-	const query = normalizeQuery(params.query);
-	const channels = [];
-	let cursor;
-	do {
-		const res = await client.conversations.list({
-			types: "public_channel,private_channel",
-			exclude_archived: false,
-			limit: 1e3,
-			cursor
-		});
-		if (Array.isArray(res.channels)) channels.push(...res.channels);
-		const next = res.response_metadata?.next_cursor?.trim();
-		cursor = next ? next : void 0;
-	} while (cursor);
-	const rows = channels.filter((channel) => {
-		const name = normalizeOptionalLowercaseString(channel.name);
-		if (!query) return true;
-		return Boolean(name && name.includes(query));
-	}).map((channel) => {
-		const id = channel.id?.trim();
-		const name = channel.name?.trim();
-		if (!id || !name) return null;
-		return {
-			kind: "group",
-			id: `channel:${id}`,
-			name,
-			handle: `#${name}`,
-			rank: buildChannelRank(channel),
-			raw: channel
-		};
-	}).filter(Boolean);
-	if (typeof params.limit === "number" && params.limit > 0) return rows.slice(0, params.limit);
-	return rows;
-}
-//#endregion
-export { listSlackDirectoryGroupsLive as n, listSlackDirectoryPeersLive as r, directory_live_exports as t };