@openclaw/slack 2026.10.10-beta.5 → 2026.11.5-beta.1

package/dist/.setup/{channel-meta-C443t-lI.mjs → channel-meta-C5vsCo3a.mjs}

@@ -1,4 +1,4 @@
-//#region extensions/slack/src/channel-meta.ts
+// extensions/slack/src/channel-meta.ts
 const SLACK_CHANNEL_META = {
 	id: "slack",
 	label: "Slack",
@@ -23,5 +23,4 @@ const DEFAULT_SLACK_SUGGESTED_PROMPTS = [
 		message: "Help me draft a reply."
 	}
 ];
-//#endregion
 export { SLACK_CHANNEL_META as n, DEFAULT_SLACK_SUGGESTED_PROMPTS as t };

package/dist/.setup/{channel-type-BEFP2ORi.mjs → channel-type-9Lw6yLf2.mjs}

@@ -1,12 +1,11 @@
-import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { d as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-msihSF3-.mjs";
-import { m as assertSlackDetachedTargetAllowed } from "./session-status-Dv8wNBEt.mjs";
-import { d as createSlackReadClient, m as createSlackWebClient, y as readLruMapEntry } from "./probe-IiHogLQN.mjs";
+import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
+import { f as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-EaPP0fFY.mjs";
+import { S as assertSlackDetachedTargetAllowed } from "./probe-B_Ax1vS1.mjs";
+import { i as createSlackReadClient, o as createSlackTokenCacheKey, p as readLruMapEntry, s as createSlackWebClient } from "./cursor-pages-jVn3Vkfi.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeStringEntriesLower } from "openclaw/plugin-sdk/string-normalization-runtime";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
-import { createHash } from "node:crypto";
-//#region extensions/slack/src/channel-type.ts
+// extensions/slack/src/channel-type.ts
 var channel_type_exports = /* @__PURE__ */ __exportAll({
 	resolveSlackChannelType: () => resolveSlackChannelType,
 	resolveSlackConversationInfo: () => resolveSlackConversationInfo
@@ -18,9 +17,6 @@ function setCachedSlackConversationInfo(cacheKey, conversationInfo) {
 	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);
@@ -43,7 +39,7 @@ async function resolveSlackConversationInfo(params) {
 	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 credentialFingerprint = token ? createSlackTokenCacheKey(token) : "none";
 	const teamId = normalizeLowercaseStringOrEmpty(params.teamId) || "no-team-id";
 	const cacheKey = `${account.accountId}:${teamId}:${operation}:${credentialRole}:${credentialFingerprint}:${channelId}`;
 	if (!params.requireFreshName) {
@@ -94,5 +90,4 @@ async function resolveSlackConversationInfo(params) {
 async function resolveSlackChannelType(params) {
 	return (await resolveSlackConversationInfo(params)).type;
 }
-//#endregion
 export { resolveSlackChannelType as n, resolveSlackConversationInfo as r, channel_type_exports as t };

package/dist/.setup/{channel.setup-u6QQdbTa.mjs → channel.setup-BlgXNuCJ.mjs}

@@ -1,8 +1,8 @@
-import { i as isSlackSetupAccountConfigured } from "./account-configured-zcR9TJJN.mjs";
-import { i as listSlackAccountIds, o as resolveDefaultSlackAccountId, s as resolveSlackAccount, u as resolveSlackConfigAccessorAccount } from "./accounts-msihSF3-.mjs";
-import { t as inspectSlackAccount } from "./account-inspect-CmkKiSb9.mjs";
-import { t as DEFAULT_SLACK_SUGGESTED_PROMPTS } from "./channel-meta-C443t-lI.mjs";
-import { t as SlackChannelConfigSchema } from "./config-schema-DNnh6bWU.mjs";
+import { i as isSlackSetupAccountConfigured } from "./account-configured-35y0-Hso.mjs";
+import { i as listSlackAccountIds, o as resolveDefaultSlackAccountId, s as resolveSlackAccount, u as resolveSlackConfigAccessorAccount } from "./accounts-EaPP0fFY.mjs";
+import { t as inspectSlackAccount } from "./account-inspect-DgQgj0wk.mjs";
+import { t as DEFAULT_SLACK_SUGGESTED_PROMPTS } from "./channel-meta-C5vsCo3a.mjs";
+import { t as SlackChannelConfigSchema } from "./config-schema-Bx1tCZB0.mjs";
 import { normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
@@ -13,7 +13,7 @@ import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { patchTopLevelChannelConfigSection } from "openclaw/plugin-sdk/setup";
-//#region extensions/slack/src/setup-shared.ts
+// extensions/slack/src/setup-shared.ts
 const SLACK_CHANNEL = "slack";
 function buildSlackAllowFromPrompt() {
 	const t = createSetupTranslator();
@@ -39,16 +39,15 @@ function buildSlackAllowFromPrompt() {
 		})
 	};
 }
-function buildSlackManifest(botName = "OpenClaw") {
-	const safeName = botName.trim() || "OpenClaw";
-	const manifest = {
+function buildSlackManifest() {
+	return JSON.stringify({
 		display_information: {
-			name: safeName,
-			description: `${safeName} connector for OpenClaw`
+			name: "OpenClaw",
+			description: "OpenClaw app for OpenClaw"
 		},
 		features: {
 			bot_user: {
-				display_name: safeName,
+				display_name: "OpenClaw",
 				always_online: true
 			},
 			app_home: {
@@ -57,7 +56,7 @@ function buildSlackManifest(botName = "OpenClaw") {
 				messages_tab_read_only_enabled: false
 			},
 			agent_view: {
-				agent_description: `${safeName} connects Slack Agent View conversations to OpenClaw agents.`,
+				agent_description: "OpenClaw connects Slack Agent View conversations to OpenClaw agents.",
 				suggested_prompts: DEFAULT_SLACK_SUGGESTED_PROMPTS
 			},
 			slash_commands: [{
@@ -70,7 +69,9 @@ function buildSlackManifest(botName = "OpenClaw") {
 			"app_mentions:read",
 			"assistant:write",
 			"channels:history",
+			"channels:manage",
 			"channels:read",
+			"channels:write.invites",
 			"chat:write",
 			"commands",
 			"emoji:read",
@@ -112,8 +113,7 @@ function buildSlackManifest(botName = "OpenClaw") {
 				"reaction_removed"
 			] }
 		}
-	};
-	return JSON.stringify(manifest, null, 2);
+	}, null, 2);
 }
 function buildSlackSetupLines() {
 	return [
@@ -150,8 +150,7 @@ function describeSlackSetupAccount(account) {
 		}
 	});
 }
-//#endregion
-//#region extensions/slack/src/config-adapter.ts
+// extensions/slack/src/config-adapter.ts
 const slackBaseConfigAdapter = createScopedChannelConfigAdapter({
 	sectionKey: SLACK_CHANNEL,
 	listAccountIds: listSlackAccountIds,
@@ -169,8 +168,7 @@ const slackBaseConfigAdapter = createScopedChannelConfigAdapter({
 	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
 	resolveDefaultTo: (account) => account.defaultTo
 });
-//#endregion
-//#region extensions/slack/src/setup-core.ts
+// extensions/slack/src/setup-core.ts
 const t = createSetupTranslator();
 function enableSlackAccount(cfg, accountId) {
 	return patchChannelConfigForAccount({
@@ -534,8 +532,7 @@ function createSlackSetupWizardProxy(loadWizard) {
 		fallbackResolvedGroupAllowlist: (entries) => entries
 	});
 }
-//#endregion
-//#region extensions/slack/src/channel.setup.ts
+// extensions/slack/src/channel.setup.ts
 const slackSetupPlugin = {
 	id: SLACK_CHANNEL,
 	meta: {
@@ -550,7 +547,7 @@ const slackSetupPlugin = {
 		markdownCapable: true,
 		preferSessionLookupForAnnounceTarget: true
 	},
-	setupWizard: createSlackSetupWizardProxy(() => import("./setup-surface-9WVQgYCT.mjs")),
+	setupWizard: createSlackSetupWizardProxy(() => import("./setup-surface-uIqP2B0Y.mjs")),
 	capabilities: {
 		chatTypes: [
 			"direct",
@@ -628,5 +625,4 @@ const slackSetupPlugin = {
 	},
 	setupContract: slackSetupContract
 };
-//#endregion
 export { buildSlackAllowFromPrompt as a, SLACK_CHANNEL as i, createSlackSetupWizardBase as n, slackBaseConfigAdapter as r, slackSetupPlugin as t };

package/dist/.setup/{config-schema-DNnh6bWU.mjs → config-schema-Bx1tCZB0.mjs}

@@ -2,7 +2,7 @@ import { buildSecretInputSchema, hasConfiguredSecretInput } from "openclaw/plugi
 import { createChannelConfigUiHints } from "openclaw/plugin-sdk/channel-core";
 import { ChannelBotLoopProtectionSchema, ChannelDangerouslyAllowNameMatchingSchema, ChannelImplicitMentionsSchema, ChannelPreviewStreamingConfigSchema, ChannelStreamingProgressSchema, ProviderCommandsSchema, ReplyToModeSchema, buildChannelAccountSchemaParts, buildChannelAllowBotsSchema, buildChannelConfigSchema, buildChannelExecApprovalsSchema, buildChannelReactionShape, buildGroupEntrySchema, refineChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-schema";
 import { z } from "zod";
-//#region extensions/slack/src/config-ui-hints.ts
+// extensions/slack/src/config-ui-hints.ts
 const observedGroupHistoryHint = { help: "Automatic observed-message context uses a default of 50 and a maximum of 200 messages; 0 disables automatic injection. The JSON integer maximum selects the 50-message default. Session transcript trimming separately counts user turns, where 0 means no trimming. The observed-message cap does not rewrite saved values." };
 const observedDmHistoryHint = { help: "Automatic observed-DM context uses a default of 0 and a maximum of 200 messages; 0 disables that extra context. The JSON integer maximum selects the 0-message default. Session transcript trimming separately counts user turns, where 0 means no trimming. The observed-message cap does not rewrite saved values." };
 const botThreadMentionHint = {
@@ -174,8 +174,7 @@ const slackChannelConfigUiHints = {
 		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
+// extensions/slack/src/config-schema.ts
 const SecretInputSchema = buildSecretInputSchema();
 const SLACK_PRESENCE_EVENT_PROMPT_MAX_CHARS = 2e4;
 const SlackStreamingProgressSchema = ChannelStreamingProgressSchema.extend({
@@ -186,11 +185,6 @@ 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",
@@ -224,7 +218,7 @@ const SlackRelaySchema = z.object({
 	gatewayId: z.string().optional()
 }).strict();
 const SlackIdentitySchema = z.enum(["bot", "user"]);
-const { accountShape, rootPolicyShape } = buildChannelAccountSchemaParts({
+const { accountShape, rootPolicyShape, groupDmShape } = buildChannelAccountSchemaParts({
 	omit: ["groupAllowFrom"],
 	streaming: SlackStreamingConfigSchema.optional()
 });
@@ -270,6 +264,7 @@ const SlackAccountSchema = z.object({
 	actions: z.object({
 		reactions: z.boolean().optional(),
 		messages: z.boolean().optional(),
+		channels: z.boolean().optional(),
 		pins: z.boolean().optional(),
 		search: z.boolean().optional(),
 		permissions: z.boolean().optional(),
@@ -283,7 +278,7 @@ const SlackAccountSchema = z.object({
 		sessionPrefix: z.string().optional(),
 		ephemeral: z.boolean().optional()
 	}).strict().optional(),
-	dm: SlackDmSchema.optional(),
+	dm: z.strictObject(groupDmShape).optional(),
 	channels: z.record(z.string(), SlackChannelSchema.optional()).optional(),
 	typingReaction: z.string().optional()
 }).strict();
@@ -374,5 +369,4 @@ const SlackConfigSchema = SlackAccountSchema.safeExtend({
 	validateSlackSigningSecretRequirements(value, ctx);
 });
 const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { uiHints: slackChannelConfigUiHints });
-//#endregion
 export { SlackChannelConfigSchema as t };

package/dist/.setup/cursor-pages-jVn3Vkfi.mjs

@@ -0,0 +1,309 @@
+import { createRequire } from "node:module";
+import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { hash } from "node:crypto";
+import { WebAPIRateLimitedError, WebClient } from "@slack/web-api";
+import { addActiveManagedProxyTlsOptions, captureChannelReadAuthority, createHttp1EnvHttpProxyAgent, resolveEnvHttpProxyAgentOptions, resolveFetch } from "openclaw/plugin-sdk/fetch-runtime";
+import { isDebugProxyGlobalFetchPatchInstalled } from "openclaw/plugin-sdk/proxy-capture";
+import { parseRetryAfterHeaderSeconds, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
+import { fetchWithRuntimeDispatcher } from "openclaw/plugin-sdk/runtime-fetch";
+// extensions/slack/src/client-options.ts
+const SLACK_DEFAULT_RETRY_OPTIONS = {
+	retries: 2,
+	factor: 2,
+	minTimeout: 500,
+	maxTimeout: 3e3,
+	randomize: true
+};
+const SLACK_WRITE_RETRY_OPTIONS = { retries: 0 };
+const SLACK_READ_TIMEOUT_MS = 3e4;
+const SLACK_LOOKUP_RETRY_OPTIONS = { retries: 0 };
+function normalizeSlackFetchInit(init) {
+	if (init?.body !== "") return init;
+	const { body: _body, ...rest } = init;
+	return rest;
+}
+function resolveSlackProxyDispatcher() {
+	const options = resolveEnvHttpProxyAgentOptions();
+	if (!options) return;
+	try {
+		return createHttp1EnvHttpProxyAgent(options, void 0, process.env);
+	} catch {
+		return;
+	}
+}
+let slackSocketModeUndici;
+/**
+* Load the undici copy that @slack/socket-mode opens its WebSocket with.
+*
+* Socket Mode 3 calls `new undici.WebSocket(url, { dispatcher })` with its own
+* undici. A dispatcher from another undici copy fails the handshake, so we must
+* identify whether Socket Mode can share the runtime dispatcher. The explicit
+* `undici/index.js` subpath keeps Bun's bare-`undici` placeholder out of the
+* dispatcher (the same reason the runtime loads undici this way); under Bun,
+* Socket Mode's bare import gets Bun's WebSocket, which does not consult a
+* dispatcher at all.
+*/
+function loadSlackSocketModeUndici() {
+	if (slackSocketModeUndici) return slackSocketModeUndici;
+	const requireFromPlugin = createRequire(import.meta.url);
+	const requireFromBolt = createRequire(requireFromPlugin.resolve("@slack/bolt/package.json"));
+	slackSocketModeUndici = createRequire(requireFromBolt.resolve("@slack/socket-mode/package.json"))("undici/index.js");
+	return slackSocketModeUndici;
+}
+/**
+* Build the env-proxy dispatcher for Socket Mode's WebSocket.
+*
+* Reuse the Web API dispatcher when both transports load the same undici copy;
+* its custom proxy routing supports Socket Mode's CONNECT handshake. Otherwise
+* build one from Socket Mode's copy. Without a proxy env, preserve the default
+* direct connection.
+*/
+function resolveSlackSocketModeDispatcher(webApi) {
+	const options = resolveEnvHttpProxyAgentOptions();
+	if (!options) return;
+	const { EnvHttpProxyAgent } = loadSlackSocketModeUndici();
+	if (webApi instanceof EnvHttpProxyAgent) return webApi;
+	const agentOptions = addActiveManagedProxyTlsOptions(options);
+	try {
+		return new EnvHttpProxyAgent(agentOptions);
+	} catch {
+		return;
+	}
+}
+/** Pair each Slack monitor transport with the dispatcher from the undici copy it uses. */
+function resolveSlackMonitorDispatchers(mode) {
+	const webApi = resolveSlackProxyDispatcher();
+	const socketMode = mode === "socket" ? resolveSlackSocketModeDispatcher(webApi) : void 0;
+	return {
+		webApi,
+		socketMode,
+		close: async () => {
+			await webApi?.close();
+			if (socketMode !== webApi) await socketMode?.close();
+		}
+	};
+}
+const DIRECT_SLACK_DISPATCHER_OPTIONS = {
+	httpProxy: "",
+	httpsProxy: "",
+	noProxy: "*"
+};
+/** Create a probe-owned dispatcher so timeout cleanup can retire every socket. */
+function createSlackProbeDispatcher(timeoutMs) {
+	const options = resolveEnvHttpProxyAgentOptions() ?? DIRECT_SLACK_DISPATCHER_OPTIONS;
+	try {
+		return createHttp1EnvHttpProxyAgent(options, timeoutMs, process.env);
+	} catch {
+		return createHttp1EnvHttpProxyAgent(DIRECT_SLACK_DISPATCHER_OPTIONS, timeoutMs, {});
+	}
+}
+function buildSlackFetch(dispatcher) {
+	if (!dispatcher || isDebugProxyGlobalFetchPatchInstalled()) {
+		const slackFetch = resolveFetch();
+		if (!slackFetch) return;
+		return ((input, init) => slackFetch(input, normalizeSlackFetchInit(init)));
+	}
+	return ((input, init) => {
+		return fetchWithRuntimeDispatcher(input, {
+			...normalizeSlackFetchInit(init),
+			dispatcher
+		});
+	});
+}
+function fenceSlackReadFetch(slackFetch, assertDirectAdapterHandoff) {
+	const assertReadAuthority = captureChannelReadAuthority();
+	return async (input, init) => {
+		assertReadAuthority?.();
+		captureChannelReadAuthority()?.();
+		assertDirectAdapterHandoff?.();
+		return slackFetch(input, init);
+	};
+}
+function resolveSlackClientOptions(input, dispatcher, assertDirectAdapterHandoff) {
+	const options = Object.assign({}, input);
+	const slackApiUrl = options.slackApiUrl ?? (process.env.SLACK_API_URL?.trim() || void 0);
+	const fetch = options.fetch ?? buildSlackFetch(dispatcher);
+	if (slackApiUrl !== void 0) options.slackApiUrl = slackApiUrl;
+	else delete options.slackApiUrl;
+	if (!fetch) {
+		if (assertDirectAdapterHandoff) throw new Error("Slack request fetch is unavailable for live authority.");
+	} else options.fetch = fenceSlackReadFetch(fetch, assertDirectAdapterHandoff);
+	return options;
+}
+function resolveSlackWebClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
+	const resolved = resolveSlackClientOptions(options, dispatcher, assertDirectAdapterHandoff);
+	resolved.retryConfig ??= SLACK_DEFAULT_RETRY_OPTIONS;
+	return resolved;
+}
+function resolveSlackReadClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
+	const resolved = resolveSlackWebClientOptions(options, dispatcher, assertDirectAdapterHandoff);
+	resolved.timeout ??= SLACK_READ_TIMEOUT_MS;
+	return resolved;
+}
+function resolveSlackWriteClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
+	const resolved = resolveSlackClientOptions(options, dispatcher, assertDirectAdapterHandoff);
+	resolved.retryConfig ??= SLACK_WRITE_RETRY_OPTIONS;
+	if (resolved.rejectRateLimitedCalls !== true && resolved.retryConfig.retries === 0) {
+		const slackFetch = resolved.fetch ?? buildSlackFetch(dispatcher);
+		if (slackFetch) resolved.fetch = (input, init) => retryAsync(async () => {
+			init?.signal?.throwIfAborted();
+			const response = await slackFetch(input, init);
+			if (response.status !== 429) return response;
+			const retryAfter = parseRetryAfterHeaderSeconds(response.headers.get("retry-after"));
+			response.body?.cancel().catch(() => void 0);
+			init?.signal?.throwIfAborted();
+			if (retryAfter === void 0 || retryAfter * 1e3 > 2147e6) return response;
+			throw new WebAPIRateLimitedError(retryAfter);
+		}, {
+			attempts: 3,
+			minDelayMs: 0,
+			maxDelayMs: 0,
+			shouldRetry: (error) => error instanceof WebAPIRateLimitedError,
+			retryAfterMs: (error) => error instanceof WebAPIRateLimitedError ? error.retryAfter * 1e3 : void 0,
+			sleep: (delayMs) => sleepWithAbort(delayMs, init?.signal)
+		});
+		resolved.rejectRateLimitedCalls = true;
+	}
+	return resolved;
+}
+function resolveSlackLookupClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher(), assertDirectAdapterHandoff) {
+	const resolved = resolveSlackClientOptions(options, dispatcher, assertDirectAdapterHandoff);
+	resolved.rejectRateLimitedCalls = true;
+	resolved.retryConfig = SLACK_LOOKUP_RETRY_OPTIONS;
+	resolved.timeout ??= SLACK_READ_TIMEOUT_MS;
+	return resolved;
+}
+// extensions/slack/src/monitor/lru-map-cache.ts
+function getOrCreateWeakOwnerMap(owners, owner) {
+	let values = owners.get(owner);
+	if (!values) {
+		values = /* @__PURE__ */ new Map();
+		owners.set(owner, values);
+	}
+	return values;
+}
+/** LRU-touch read: move hit to newest so pruneMapToMaxSize keeps active keys. */
+function readLruMapEntry(cache, cacheKey) {
+	const cached = cache.get(cacheKey);
+	if (cached) {
+		cache.delete(cacheKey);
+		cache.set(cacheKey, cached);
+	}
+	return cached;
+}
+function writeLruMapEntry(cache, cacheKey, entry, maxEntries) {
+	cache.delete(cacheKey);
+	cache.set(cacheKey, entry);
+	pruneMapToMaxSize(cache, maxEntries);
+}
+function pruneExpiredMapEntries(cache, now) {
+	for (const [key, entry] of cache) if (entry.expiresAt <= now) cache.delete(key);
+}
+// extensions/slack/src/client.ts
+const SLACK_WRITE_CLIENT_CACHE_MAX = 32;
+const SLACK_STARTUP_AUTH_TIMEOUT_MS = 1e4;
+const SLACK_STARTUP_AUTH_RETRY_BUDGET_MS = 35e3;
+const slackWriteClientCache = /* @__PURE__ */ new Map();
+const slackListenerWriteClientCache = /* @__PURE__ */ new WeakMap();
+function createSlackClientFactory(resolveOptions) {
+	return (token, options, assertDirectAdapterHandoff) => new WebClient(token, resolveOptions(options, void 0, assertDirectAdapterHandoff));
+}
+const createSlackWebClient = createSlackClientFactory(resolveSlackWebClientOptions);
+const createSlackLookupClient = createSlackClientFactory(resolveSlackLookupClientOptions);
+const createSlackWriteClient = createSlackClientFactory(resolveSlackWriteClientOptions);
+function createSlackReadClient(token, options = {}, dispatcher, assertDirectAdapterHandoff) {
+	return new WebClient(token, resolveSlackReadClientOptions(options, dispatcher, assertDirectAdapterHandoff));
+}
+function createSlackStartupAuthFetch(baseFetch) {
+	const deadline = performance.now() + SLACK_STARTUP_AUTH_RETRY_BUDGET_MS;
+	return async (input, init) => {
+		const response = await baseFetch(input, init);
+		if (response.status !== 429) return response;
+		const retryAfter = Number.parseInt(response.headers.get("retry-after") ?? "", 10);
+		const remainingMs = Math.max(0, deadline - performance.now());
+		if (!Number.isFinite(retryAfter) || retryAfter * 1e3 <= remainingMs) return response;
+		await new Promise((resolve) => {
+			setTimeout(resolve, remainingMs);
+		});
+		throw new Error("Slack startup auth retry budget exhausted after rate limit");
+	};
+}
+function createSlackStartupAuthClient(token, options = {}) {
+	const resolvedOptions = resolveSlackWebClientOptions(options);
+	const baseFetch = resolvedOptions.fetch;
+	if (!baseFetch) throw new Error("Slack startup auth fetch is unavailable");
+	return new WebClient(token, {
+		...resolvedOptions,
+		fetch: createSlackStartupAuthFetch(baseFetch),
+		retryConfig: {
+			...SLACK_DEFAULT_RETRY_OPTIONS,
+			maxRetryTime: SLACK_STARTUP_AUTH_RETRY_BUDGET_MS
+		},
+		timeout: SLACK_STARTUP_AUTH_TIMEOUT_MS
+	});
+}
+function createSlackTokenCacheKey(token) {
+	return `sha256:${hash("sha256", token, "base64url")}`;
+}
+function slackWriteClientCacheKey(token, options) {
+	return `${createSlackTokenCacheKey(token)}${options.slackApiUrl ? `:api:${options.slackApiUrl}` : ""}${options.teamId ? `:team:${options.teamId.trim().toLowerCase()}` : ""}`;
+}
+function getSlackWriteClient(token, options = {}) {
+	const resolvedOptions = resolveSlackWriteClientOptions(options);
+	const tokenKey = slackWriteClientCacheKey(token, resolvedOptions);
+	const cached = readLruMapEntry(slackWriteClientCache, tokenKey);
+	if (cached) return cached;
+	const client = new WebClient(token, resolvedOptions);
+	slackWriteClientCache.set(tokenKey, client);
+	pruneMapToMaxSize(slackWriteClientCache, SLACK_WRITE_CLIENT_CACHE_MAX);
+	return client;
+}
+function getSlackListenerWriteClient(params) {
+	const token = params.listenerClient.token?.trim();
+	const teamId = params.teamId?.trim().toUpperCase();
+	if (!token) return;
+	const cached = slackListenerWriteClientCache.get(params.listenerClient);
+	if (cached) {
+		if (cached.teamId !== teamId) return;
+		return cached.client;
+	}
+	const headers = Object.fromEntries(Object.entries(params.clientOptions?.headers ?? {}).filter(([name]) => name.toLowerCase() !== "authorization"));
+	const client = new WebClient(token, resolveSlackWriteClientOptions({
+		...params.clientOptions,
+		headers,
+		slackApiUrl: params.listenerClient.slackApiUrl,
+		teamId,
+		retryConfig: SLACK_WRITE_RETRY_OPTIONS,
+		timeout: 0
+	}));
+	slackListenerWriteClientCache.set(params.listenerClient, {
+		teamId,
+		client
+	});
+	return client;
+}
+// extensions/slack/src/cursor-pages.ts
+const SLACK_CURSOR_PAGE_LIMIT = 1e4;
+const fetchSlackChannelListPage = (client, cursor) => client.conversations.list({
+	types: "public_channel,private_channel",
+	exclude_archived: false,
+	limit: 1e3,
+	cursor
+});
+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`);
+}
+export { createSlackProbeDispatcher as _, createSlackStartupAuthClient as a, resolveSlackWebClientOptions as b, createSlackWriteClient as c, getOrCreateWeakOwnerMap as d, pruneExpiredMapEntries as f, SLACK_WRITE_RETRY_OPTIONS as g, SLACK_DEFAULT_RETRY_OPTIONS as h, createSlackReadClient as i, getSlackListenerWriteClient as l, writeLruMapEntry as m, fetchSlackChannelListPage as n, createSlackTokenCacheKey as o, readLruMapEntry as p, createSlackLookupClient as r, createSlackWebClient as s, collectSlackCursorPages as t, getSlackWriteClient as u, resolveSlackLookupClientOptions as v, resolveSlackWriteClientOptions as x, resolveSlackMonitorDispatchers as y };

package/dist/.setup/{directory-config-Cjj0N8R0.mjs → directory-config-CGvKYg9F.mjs}

@@ -1,11 +1,11 @@
-import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { a as mergeSlackAccountConfig, c as resolveSlackAccountAllowFrom, o as resolveDefaultSlackAccountId } from "./accounts-msihSF3-.mjs";
-import { a as parseSlackTarget } from "./target-parsing-FFE26kOV.mjs";
-import "./targets-C6LZQL1Q.mjs";
+import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
+import { a as mergeSlackAccountConfig, c as resolveSlackAccountAllowFrom, o as resolveDefaultSlackAccountId } from "./accounts-EaPP0fFY.mjs";
+import { a as parseSlackTarget } from "./target-parsing-DwYAP3ts.mjs";
+import "./targets-eeOxA_b_.mjs";
 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
+// extensions/slack/src/directory-config.ts
 var directory_config_exports = /* @__PURE__ */ __exportAll({
 	listSlackDirectoryGroupsFromConfig: () => listSlackDirectoryGroupsFromConfig,
 	listSlackDirectoryPeersFromConfig: () => listSlackDirectoryPeersFromConfig
@@ -48,5 +48,4 @@ const listSlackDirectoryGroupsFromConfig = createResolvedDirectoryEntriesLister(
 		return normalized?.kind === "channel" ? `channel:${normalizeLowercaseStringOrEmpty(normalized.id)}` : null;
 	}
 });
-//#endregion
 export { listSlackDirectoryGroupsFromConfig as n, listSlackDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/.setup/{directory-live-BIKD-5B_.mjs → directory-live-DNdw97LA.mjs}

@@ -1,8 +1,8 @@
-import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { s as resolveSlackAccount } from "./accounts-msihSF3-.mjs";
-import { c as collectSlackCursorPages, l as fetchSlackChannelListPage, u as createSlackLookupClient } from "./probe-IiHogLQN.mjs";
+import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
+import { s as resolveSlackAccount } from "./accounts-EaPP0fFY.mjs";
+import { n as fetchSlackChannelListPage, r as createSlackLookupClient, t as collectSlackCursorPages } from "./cursor-pages-jVn3Vkfi.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/slack/src/directory-live.ts
+// extensions/slack/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({
 	getSlackDirectorySelfLive: () => getSlackDirectorySelfLive,
 	listSlackDirectoryGroupsLive: () => listSlackDirectoryGroupsLive,
@@ -55,9 +55,9 @@ function createSlackDirectoryLister(options) {
 	return async (params) => {
 		const client = createSlackDirectoryClient(params);
 		if (!client) return [];
-		const query = normalizeLowercaseStringOrEmpty(params.query);
+		const query = normalizeLowercaseStringOrEmpty(params.query).normalize("NFC");
 		const rows = (await options.fetchRows(client)).filter((row) => {
-			const candidates = options.searchValues(row).map(normalizeOptionalLowercaseString).filter(Boolean);
+			const candidates = options.searchValues(row).map((value) => normalizeOptionalLowercaseString(value)?.normalize("NFC"));
 			return !query || candidates.some((candidate) => candidate?.includes(query));
 		}).map(options.toEntry).filter((entry) => entry !== null);
 		return typeof params.limit === "number" && params.limit > 0 ? rows.slice(0, params.limit) : rows;
@@ -97,5 +97,4 @@ const listSlackDirectoryGroupsLive = createSlackDirectoryLister({
 		} : null;
 	}
 });
-//#endregion
 export { listSlackDirectoryGroupsLive as n, listSlackDirectoryPeersLive as r, directory_live_exports as t };