@openclaw/slack 2026.10.10 → 2026.11.5-beta.1

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

@@ -1,11 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
-import { d as resolveSlackOperationToken, s as resolveSlackAccount } from "./accounts-CEgdyqoW.mjs";
-import { m as assertSlackDetachedTargetAllowed } from "./session-status-CHkEn3HM.mjs";
-import { d as createSlackReadClient, m as createSlackWebClient, y as readLruMapEntry } from "./probe-C5VWf3sz.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";
 // extensions/slack/src/channel-type.ts
 var channel_type_exports = /* @__PURE__ */ __exportAll({
 	resolveSlackChannelType: () => resolveSlackChannelType,
@@ -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) {

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

@@ -1,8 +1,8 @@
 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-CEgdyqoW.mjs";
-import { t as inspectSlackAccount } from "./account-inspect-Bc7TVU8F.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-Cz3uId-c.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";
@@ -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 [
@@ -547,7 +547,7 @@ const slackSetupPlugin = {
 		markdownCapable: true,
 		preferSessionLookupForAnnounceTarget: true
 	},
-	setupWizard: createSlackSetupWizardProxy(() => import("./setup-surface-CtM1pm-9.mjs")),
+	setupWizard: createSlackSetupWizardProxy(() => import("./setup-surface-uIqP2B0Y.mjs")),
 	capabilities: {
 		chatTypes: [
 			"direct",

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

@@ -185,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",
@@ -223,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()
 });
@@ -269,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(),
@@ -282,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();

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-BEPra1E2.mjs → directory-config-CGvKYg9F.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
-import { a as mergeSlackAccountConfig, c as resolveSlackAccountAllowFrom, o as resolveDefaultSlackAccountId } from "./accounts-CEgdyqoW.mjs";
-import { a as parseSlackTarget } from "./target-parsing-0pRZtahO.mjs";
-import "./targets-BqXz7CpG.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";

package/dist/.setup/{directory-live-BkUwPrS0.mjs → directory-live-DNdw97LA.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-nwUcYXjP.mjs";
-import { s as resolveSlackAccount } from "./accounts-CEgdyqoW.mjs";
-import { c as collectSlackCursorPages, l as fetchSlackChannelListPage, u as createSlackLookupClient } from "./probe-C5VWf3sz.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";
 // extensions/slack/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({
@@ -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;

package/dist/.setup/{doctor-contract-HK8aedwU.mjs → doctor-contract-BB2KJ9Ni.mjs}

@@ -207,35 +207,6 @@ function hasInteractiveRepliesCapability(value) {
 function hasEnterpriseOrgInstall(value) {
 	return Object.hasOwn((0, runtime_doctor_migrations_exports.asObjectRecord)(value) ?? {}, "enterpriseOrgInstall");
 }
-function removeInteractiveRepliesCapability(params) {
-	const capabilities = params.entry.capabilities;
-	let nextCapabilities;
-	let removedEmptyObject = false;
-	if (Array.isArray(capabilities)) {
-		nextCapabilities = capabilities.filter((entry) => !(typeof entry === "string" && entry.trim().toLowerCase() === "interactivereplies"));
-		if (nextCapabilities.length === capabilities.length) return {
-			entry: params.entry,
-			changed: false
-		};
-	} else {
-		const capabilitiesRecord = (0, runtime_doctor_migrations_exports.asObjectRecord)(capabilities);
-		if (!capabilitiesRecord || Object.keys(capabilitiesRecord).length > 0 && !Object.hasOwn(capabilitiesRecord, "interactiveReplies")) return {
-			entry: params.entry,
-			changed: false
-		};
-		removedEmptyObject = Object.keys(capabilitiesRecord).length === 0;
-		const { interactiveReplies: _retired, ...rest } = capabilitiesRecord;
-		nextCapabilities = rest;
-	}
-	const entry = { ...params.entry };
-	if (Array.isArray(nextCapabilities) ? nextCapabilities.length === 0 : Object.keys(nextCapabilities).length === 0) delete entry.capabilities;
-	else entry.capabilities = nextCapabilities;
-	params.changes.push(removedEmptyObject ? `Removed retired empty ${params.pathPrefix}.capabilities object; use typed presentation actions instead.` : `Removed retired ${params.pathPrefix}.capabilities.interactiveReplies; use typed presentation actions instead.`);
-	return {
-		entry,
-		changed: true
-	};
-}
 const legacyConfigRules = [
 	...streamingAliasMigration.legacyConfigRules,
 	{
@@ -298,21 +269,6 @@ const legacyConfigRules = [
 		match: (value) => (0, runtime_doctor_migrations_exports.hasLegacyAccountStreamingAliases)(value, threadMentionPolicyMigration.hasLegacy)
 	}
 ];
-function normalizeSlackEntry(params) {
-	const retiredInteractiveReplies = removeInteractiveRepliesCapability(params);
-	const dm = dmReplyModeMigration.normalize({
-		...params,
-		entry: retiredInteractiveReplies.entry
-	});
-	const thread = threadMentionPolicyMigration.normalize({
-		...params,
-		entry: dm.entry
-	});
-	return {
-		entry: thread.entry,
-		changed: retiredInteractiveReplies.changed || dm.changed || thread.changed
-	};
-}
 function normalizeCompatibilityConfig({ cfg }) {
 	const changes = [];
 	const retired = (0, runtime_doctor_migrations_exports.stripRetiredChannelKeys)({
@@ -330,7 +286,43 @@ function normalizeCompatibilityConfig({ cfg }) {
 		cfg: aliases.config,
 		channelId: "slack",
 		changes,
-		normalizeEntry: normalizeSlackEntry
+		normalizeEntry: (params) => {
+			let { entry } = params;
+			let changed = false;
+			const capabilities = entry.capabilities;
+			let nextCapabilities;
+			let removedEmptyObject = false;
+			if (Array.isArray(capabilities)) {
+				const filtered = capabilities.filter((capability) => !(typeof capability === "string" && capability.trim().toLowerCase() === "interactivereplies"));
+				if (filtered.length !== capabilities.length) nextCapabilities = filtered;
+			} else {
+				const capabilitiesRecord = (0, runtime_doctor_migrations_exports.asObjectRecord)(capabilities);
+				if (capabilitiesRecord && (Object.keys(capabilitiesRecord).length === 0 || Object.hasOwn(capabilitiesRecord, "interactiveReplies"))) {
+					removedEmptyObject = Object.keys(capabilitiesRecord).length === 0;
+					const { interactiveReplies: _retired, ...rest } = capabilitiesRecord;
+					nextCapabilities = rest;
+				}
+			}
+			if (nextCapabilities !== void 0) {
+				entry = { ...entry };
+				if (Array.isArray(nextCapabilities) ? nextCapabilities.length === 0 : Object.keys(nextCapabilities).length === 0) delete entry.capabilities;
+				else entry.capabilities = nextCapabilities;
+				params.changes.push(removedEmptyObject ? `Removed retired empty ${params.pathPrefix}.capabilities object; use typed presentation actions instead.` : `Removed retired ${params.pathPrefix}.capabilities.interactiveReplies; use typed presentation actions instead.`);
+				changed = true;
+			}
+			const dm = dmReplyModeMigration.normalize({
+				...params,
+				entry
+			});
+			const thread = threadMentionPolicyMigration.normalize({
+				...params,
+				entry: dm.entry
+			});
+			return {
+				entry: thread.entry,
+				changed: changed || dm.changed || thread.changed
+			};
+		}
 	});
 }
 export { normalizeCompatibilityConfig as n, runtime_doctor_migrations_exports as r, legacyConfigRules as t };

package/dist/.setup/{message-tool-api-DeiQJoRV.mjs → message-tool-api-B38BpEaE.mjs}

@@ -1,5 +1,5 @@
-import { i as listSlackAccountIds } from "./accounts-CEgdyqoW.mjs";
-import { t as inspectSlackAccount } from "./account-inspect-Bc7TVU8F.mjs";
+import { i as listSlackAccountIds } from "./accounts-EaPP0fFY.mjs";
+import { t as inspectSlackAccount } from "./account-inspect-DgQgj0wk.mjs";
 import { r as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-47Au2-Yn.mjs";
 import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
@@ -18,6 +18,7 @@ function listSlackMessageActions(cfg, accountId) {
 	const actions = ["send"];
 	for (const [gate, enabledActions] of [
 		["reactions", ["react", "reactions"]],
+		["channels", ["channel-create"]],
 		["messages", [
 			"conversation-open",
 			"read",
@@ -33,7 +34,7 @@ function listSlackMessageActions(cfg, accountId) {
 		]],
 		["memberInfo", ["member-info"]],
 		["emojiList", ["emoji-list"]]
-	]) if (gates.some((isEnabled) => isEnabled(gate))) actions.push(...enabledActions);
+	]) if (gates.some((isEnabled) => isEnabled(gate, gate === "channels" ? false : void 0))) actions.push(...enabledActions);
 	return actions;
 }
 function extractSlackToolSend(args) {