@openclaw/slack 2026.6.10-beta.2 → 2026.6.11-beta.2

package/dist/{provider-DNl27IZC.js → provider-7YKru1TZ.js}

@@ -1,13 +1,14 @@
 import { n as registerSlackHttpHandler, r as normalizeSlackWebhookPath } from "./registry-bbjH7IHX.js";
-import { a as resolveSlackAccount, d as resolveSlackBotToken, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as resolveSlackAppToken } from "./accounts-f6Xcv9Vi.js";
-import { F as isSlackExecApprovalAuthorizedSender, N as isSlackApprovalAuthorizedSender, S as isSlackAnyNativeApprovalClientEnabled, a as SLACK_TEXT_LIMIT, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, l as normalizeAllowList, p as resolveSlackAllowListMatch, u as normalizeAllowListLower, v as truncateSlackText } from "./reply-blocks-DSfujQlj.js";
-import { c as resolveSlackWebClientOptions } from "./client-DhaHONzg.js";
-import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-DrBq4Mld.js";
+import { a as resolveSlackAccount, d as resolveSlackBotToken, o as resolveSlackAccountAllowFrom, s as resolveSlackAccountDmPolicy, u as resolveSlackAppToken } from "./accounts-BPCiCe8y.js";
+import { F as isSlackExecApprovalAuthorizedSender, N as isSlackApprovalAuthorizedSender, S as isSlackAnyNativeApprovalClientEnabled, a as SLACK_TEXT_LIMIT, c as allowListMatches, d as normalizeSlackAllowOwnerEntry, f as normalizeSlackSlug, l as normalizeAllowList, p as resolveSlackAllowListMatch, u as normalizeAllowListLower, v as truncateSlackText } from "./reply-blocks-BT_sNsDQ.js";
+import { n as isSlackInteractiveRepliesEnabled, t as compileSlackInteractiveReplies } from "./interactive-replies-D-22gTp3.js";
+import { c as resolveSlackWebClientOptions } from "./client-km2ba2l3.js";
 import { t as getOptionalSlackRuntime } from "./runtime-BOk7xkOl.js";
+import { n as setSlackDefaultSendIdentity } from "./send-CRoD-UQw.js";
 import { t as formatSlackError } from "./errors-CZtmv-h0.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-DNiE0Z0_.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-D_TmaIfG.js";
-import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-Dfbxkneh.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CtUOIX8D.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-DfFN2BcP.js";
+import { n as resolveSlackChannelConfig, r as resolveSlackChannelLabel, t as isSlackChannelAllowedByPolicy } from "./policy-Bi92bs5t.js";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asOptionalRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringEntries, normalizeStringEntriesLower, normalizeUniqueTrimmedStringList } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, normalizeMainKey, resolveAgentRoute, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
@@ -2820,9 +2821,21 @@ function createSlackThreadTsResolver(params) {
 //#region extensions/slack/src/monitor/message-handler.ts
 let slackMessagePipelinePromise;
 function loadSlackMessagePipeline() {
-	slackMessagePipelinePromise ??= import("./pipeline.runtime-DQXhebqH.js");
+	slackMessagePipelinePromise ??= import("./pipeline.runtime-5R4HgM_7.js");
 	return slackMessagePipelinePromise;
 }
+function createSlackDispatchCompletion() {
+	let resolve;
+	let reject;
+	return {
+		promise: new Promise((nextResolve, nextReject) => {
+			resolve = nextResolve;
+			reject = nextReject;
+		}),
+		resolve,
+		reject
+	};
+}
 const APP_MENTION_RETRY_TTL_MS = 6e4;
 var SlackRetryableInboundError = class extends Error {
 	constructor(message, options) {
@@ -2849,72 +2862,82 @@ function createSlackMessageHandler(params) {
 		buildKey: (entry) => buildSlackDebounceKey(entry.message, ctx.accountId),
 		shouldDebounce: (entry) => shouldDebounceSlackMessage(entry.message, ctx.cfg),
 		onFlush: async (entries) => {
-			const last = entries.at(-1);
-			if (!last) return;
-			const flushedKey = buildSlackDebounceKey(last.message, ctx.accountId);
-			const topLevelConversationKey = buildTopLevelSlackConversationKey(last.message, ctx.accountId);
-			if (flushedKey && topLevelConversationKey) {
-				const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
-				if (pendingKeys) {
-					pendingKeys.delete(flushedKey);
-					if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
-				}
-			}
-			const combinedText = entries.length === 1 ? last.message.text ?? "" : entries.map((entry) => entry.message.text ?? "").filter(Boolean).join("\n");
-			const combinedMentioned = entries.some((entry) => Boolean(entry.opts.wasMentioned));
-			const syntheticMessage = {
-				...last.message,
-				text: combinedText
-			};
-			const seenMessageKey = buildSeenMessageKey(last.message.channel, last.message.ts);
+			const completions = entries.map((entry) => entry.opts.dispatchCompletion).filter((completion) => completion !== void 0);
 			try {
-				const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
-				const prepared = await prepareSlackMessage({
-					ctx,
-					account,
-					message: syntheticMessage,
-					opts: {
-						...last.opts,
-						wasMentioned: combinedMentioned || last.opts.wasMentioned
-					}
-				});
-				if (!prepared) return;
-				if (seenMessageKey) {
-					pruneAppMentionRetryKeys(Date.now());
-					if (last.opts.source === "app_mention") rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
-					else if (last.opts.source === "message" && appMentionDispatchedKeys.has(seenMessageKey)) {
-						appMentionDispatchedKeys.delete(seenMessageKey);
-						appMentionRetryKeys.delete(seenMessageKey);
-						return;
+				await (async () => {
+					const last = entries.at(-1);
+					if (!last) return;
+					const flushedKey = buildSlackDebounceKey(last.message, ctx.accountId);
+					const topLevelConversationKey = buildTopLevelSlackConversationKey(last.message, ctx.accountId);
+					if (flushedKey && topLevelConversationKey) {
+						const pendingKeys = pendingTopLevelDebounceKeys.get(topLevelConversationKey);
+						if (pendingKeys) {
+							pendingKeys.delete(flushedKey);
+							if (pendingKeys.size === 0) pendingTopLevelDebounceKeys.delete(topLevelConversationKey);
+						}
 					}
-					appMentionRetryKeys.delete(seenMessageKey);
-				}
-				if (entries.length > 1) {
-					const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
-					if (ids.length > 0) {
-						prepared.ctxPayload.MessageSids = ids;
-						prepared.ctxPayload.MessageSidFirst = ids[0];
-						prepared.ctxPayload.MessageSidLast = ids[ids.length - 1];
+					const combinedText = entries.length === 1 ? last.message.text ?? "" : entries.map((entry) => entry.message.text ?? "").filter(Boolean).join("\n");
+					const combinedMentioned = entries.some((entry) => Boolean(entry.opts.wasMentioned));
+					const syntheticMessage = {
+						...last.message,
+						text: combinedText
+					};
+					const seenMessageKey = buildSeenMessageKey(last.message.channel, last.message.ts);
+					try {
+						const { prepareSlackMessage, dispatchPreparedSlackMessage } = await loadSlackMessagePipeline();
+						const { dispatchCompletion: _completion, awaitDispatch: _awaitDispatch, ...lastOpts } = last.opts;
+						const prepared = await prepareSlackMessage({
+							ctx,
+							account,
+							message: syntheticMessage,
+							opts: {
+								...lastOpts,
+								wasMentioned: combinedMentioned || last.opts.wasMentioned
+							}
+						});
+						if (!prepared) return;
+						if (seenMessageKey) {
+							pruneAppMentionRetryKeys(Date.now());
+							if (last.opts.source === "app_mention") rememberExpiringAppMentionKey(appMentionDispatchedKeys, seenMessageKey);
+							else if (last.opts.source === "message" && appMentionDispatchedKeys.has(seenMessageKey)) {
+								appMentionDispatchedKeys.delete(seenMessageKey);
+								appMentionRetryKeys.delete(seenMessageKey);
+								return;
+							}
+							appMentionRetryKeys.delete(seenMessageKey);
+						}
+						if (entries.length > 1) {
+							const ids = entries.map((entry) => entry.message.ts).filter(Boolean);
+							if (ids.length > 0) {
+								prepared.ctxPayload.MessageSids = ids;
+								prepared.ctxPayload.MessageSidFirst = ids[0];
+								prepared.ctxPayload.MessageSidLast = ids[ids.length - 1];
+							}
+						}
+						try {
+							await dispatchPreparedSlackMessage(prepared);
+							await recordSlackInboundMessageDeliveries({
+								accountId: ctx.accountId,
+								messages: entries.map((entry) => entry.message)
+							});
+						} catch (error) {
+							if (!(error instanceof SlackRetryableInboundError)) await recordSlackInboundMessageDeliveries({
+								accountId: ctx.accountId,
+								messages: entries.map((entry) => entry.message)
+							});
+							throw error;
+						}
+					} catch (error) {
+						if (error instanceof SlackRetryableInboundError) {
+							if (seenMessageKey) appMentionDispatchedKeys.delete(seenMessageKey);
+							ctx.releaseSeenMessage(last.message.channel, last.message.ts);
+						}
+						throw error;
 					}
-				}
-				try {
-					await dispatchPreparedSlackMessage(prepared);
-					await recordSlackInboundMessageDeliveries({
-						accountId: ctx.accountId,
-						messages: entries.map((entry) => entry.message)
-					});
-				} catch (error) {
-					if (!(error instanceof SlackRetryableInboundError)) await recordSlackInboundMessageDeliveries({
-						accountId: ctx.accountId,
-						messages: entries.map((entry) => entry.message)
-					});
-					throw error;
-				}
+				})();
+				for (const completion of completions) completion.resolve();
 			} catch (error) {
-				if (error instanceof SlackRetryableInboundError) {
-					if (seenMessageKey) appMentionDispatchedKeys.delete(seenMessageKey);
-					ctx.releaseSeenMessage(last.message.channel, last.message.ts);
-				}
+				for (const completion of completions) completion.reject(error);
 				throw error;
 			}
 		},
@@ -2986,10 +3009,18 @@ function createSlackMessageHandler(params) {
 			pendingKeys.add(debounceKey);
 			pendingTopLevelDebounceKeys.set(conversationKey, pendingKeys);
 		}
+		const dispatchCompletion = opts.awaitDispatch ? createSlackDispatchCompletion() : void 0;
 		await debouncer.enqueue({
 			message: resolvedMessage,
-			opts
+			opts: {
+				...opts,
+				...dispatchCompletion ? { dispatchCompletion: {
+					resolve: dispatchCompletion.resolve,
+					reject: dispatchCompletion.reject
+				} } : {}
+			}
 		});
+		await dispatchCompletion?.promise;
 	};
 }
 //#endregion
@@ -3106,6 +3137,13 @@ function installSlackNativeReconnectFailureObserver(receiver) {
 		});
 	});
 }
+function createSlackRelayReceiver() {
+	return {
+		init() {},
+		start: () => Promise.resolve(void 0),
+		stop: () => Promise.resolve(void 0)
+	};
+}
 function resolveSlackBoltModule(value) {
 	if (!value || typeof value !== "object") return null;
 	const app = Reflect.get(value, "App");
@@ -3217,17 +3255,21 @@ function createSlackBoltApp(params) {
 	};
 	if (params.socketMode?.serverPingTimeout !== void 0) socketModeReceiverOptions.serverPingTimeout = params.socketMode.serverPingTimeout;
 	if (params.socketMode?.pingPongLoggingEnabled !== void 0) socketModeReceiverOptions.pingPongLoggingEnabled = params.socketMode.pingPongLoggingEnabled;
-	const receiver = params.slackMode === "socket" ? new params.interop.SocketModeReceiver(socketModeReceiverOptions) : new params.interop.HTTPReceiver({
+	let receiver;
+	if (params.slackMode === "socket") {
+		receiver = new params.interop.SocketModeReceiver(socketModeReceiverOptions);
+		installSlackNativeReconnectFailureObserver(receiver);
+	} else if (params.slackMode === "http") receiver = new params.interop.HTTPReceiver({
 		signingSecret: params.signingSecret ?? "",
 		endpoints: params.slackWebhookPath
 	});
-	if (params.slackMode === "socket") installSlackNativeReconnectFailureObserver(receiver);
+	else receiver = createSlackRelayReceiver();
 	const app = new params.interop.App({
 		token: params.botToken,
-		receiver,
 		clientOptions: params.clientOptions,
 		ignoreSelf: false,
-		tokenVerificationEnabled: false
+		tokenVerificationEnabled: false,
+		...receiver ? { receiver } : {}
 	});
 	app.use(async (args) => {
 		if (shouldSkipOpenClawSlackSelfEvent(args)) return;
@@ -3460,7 +3502,7 @@ function loadSlashCommandsRuntime() {
 	return slashCommandsRuntimePromise;
 }
 function loadSlashDispatchRuntime() {
-	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-BOl9Cbn9.js");
+	slashDispatchRuntimePromise ??= import("./slash-dispatch.runtime-D1qKAWNN.js");
 	return slashDispatchRuntimePromise;
 }
 function loadSlackPluginCommandsRuntime() {
@@ -4161,6 +4203,7 @@ async function registerSlackMonitorSlashCommands(params) {
 //#endregion
 //#region extensions/slack/src/monitor/provider.ts
 let slackBoltInterop;
+let slackRelaySourcePromise;
 async function getSlackBoltInterop() {
 	if (!slackBoltInterop) {
 		const slackBoltModule = await import("@slack/bolt");
@@ -4171,6 +4214,10 @@ async function getSlackBoltInterop() {
 	}
 	return slackBoltInterop;
 }
+function loadSlackRelaySource() {
+	slackRelaySourcePromise ??= import("./relay-source-42fP7Ktr.js");
+	return slackRelaySourcePromise;
+}
 const SLACK_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 const SLACK_WEBHOOK_BODY_TIMEOUT_MS = 3e4;
 function resolveStableSlackUserIdEntry(raw) {
@@ -4208,6 +4255,21 @@ function parseApiAppIdFromAppToken(raw) {
 	if (!token) return;
 	return /^xapp-\d-([a-z0-9]+)-/i.exec(token)?.[1]?.toUpperCase();
 }
+function resolveSlackRelayConfig(params) {
+	const relay = params.relay && typeof params.relay === "object" && !Array.isArray(params.relay) ? params.relay : {};
+	const url = normalizeOptionalString(relay.url);
+	const authToken = normalizeResolvedSecretInputString({
+		value: relay.authToken,
+		path: `channels.slack.accounts.${params.accountId}.relay.authToken`
+	});
+	const gatewayId = normalizeOptionalString(relay.gatewayId);
+	if (!url || !authToken || !gatewayId) throw new Error(`Slack relay mode requires relay.url, relay.authToken, and relay.gatewayId for account "${params.accountId}".`);
+	return {
+		url,
+		authToken,
+		gatewayId
+	};
+}
 async function monitorSlackProvider(opts = {}) {
 	const cfg = opts.config ?? getRuntimeConfig$1();
 	const runtime = opts.runtime ?? createNonExitingRuntime();
@@ -4236,8 +4298,12 @@ async function monitorSlackProvider(opts = {}) {
 	});
 	const botToken = resolveSlackBotToken(opts.botToken ?? account.botToken);
 	const appToken = resolveSlackAppToken(opts.appToken ?? account.appToken);
-	if (!botToken || slackMode !== "http" && !appToken) {
-		const missing = slackMode === "http" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : `Slack bot + app tokens missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken/appToken or SLACK_BOT_TOKEN/SLACK_APP_TOKEN for default).`;
+	const relayConfig = slackMode === "relay" ? resolveSlackRelayConfig({
+		relay: account.config.relay,
+		accountId: account.accountId
+	}) : void 0;
+	if (!botToken || slackMode === "socket" && !appToken) {
+		const missing = slackMode === "http" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : slackMode === "relay" ? `Slack bot token missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken or SLACK_BOT_TOKEN for default).` : `Slack bot + app tokens missing for account "${account.accountId}" (set channels.slack.accounts.${account.accountId}.botToken/appToken or SLACK_BOT_TOKEN/SLACK_APP_TOKEN for default).`;
 		throw new Error(missing);
 	}
 	if (slackMode === "http" && !signingSecret) throw new Error(`Slack signing secret missing for account "${account.accountId}" (set channels.slack.signingSecret or channels.slack.accounts.${account.accountId}.signingSecret).`);
@@ -4287,8 +4353,8 @@ async function monitorSlackProvider(opts = {}) {
 		interop: await getSlackBoltInterop(),
 		slackMode,
 		botToken,
-		appToken: appToken ?? void 0,
-		signingSecret: signingSecret ?? void 0,
+		appToken: slackMode === "socket" ? appToken ?? void 0 : void 0,
+		signingSecret: slackMode === "http" ? signingSecret ?? void 0 : void 0,
 		slackWebhookPath,
 		clientOptions,
 		...slackCfg.socketMode ? { socketMode: slackCfg.socketMode } : {}
@@ -4317,7 +4383,7 @@ async function monitorSlackProvider(opts = {}) {
 	let botId = "";
 	let teamId = "";
 	let apiAppId = "";
-	const expectedApiAppIdFromAppToken = parseApiAppIdFromAppToken(appToken);
+	const expectedApiAppIdFromAppToken = slackMode === "socket" ? parseApiAppIdFromAppToken(appToken) : void 0;
 	let authTestFailed = false;
 	let authTestError;
 	try {
@@ -4570,6 +4636,16 @@ async function monitorSlackProvider(opts = {}) {
 				}
 				continue;
 			}
+		} else if (slackMode === "relay" && relayConfig) {
+			runtime.log?.(`slack relay mode connecting to ${relayConfig.url} gateway_id:${relayConfig.gatewayId}`);
+			await (await loadSlackRelaySource()).monitorSlackRelaySource({
+				config: relayConfig,
+				handleSlackMessage,
+				runtime,
+				abortSignal: opts.abortSignal,
+				setStatus: opts.setStatus,
+				setIdentity: (identity) => setSlackDefaultSendIdentity(account.accountId, identity)
+			});
 		} else {
 			runtime.log?.(`slack http mode listening at ${slackWebhookPath}`);
 			if (!opts.abortSignal?.aborted) await new Promise((resolve) => {
@@ -4577,6 +4653,7 @@ async function monitorSlackProvider(opts = {}) {
 			});
 		}
 	} finally {
+		if (slackMode === "relay") setSlackDefaultSendIdentity(account.accountId, void 0);
 		opts.abortSignal?.removeEventListener("abort", stopOnAbort);
 		unregisterHttpHandler?.();
 		await gracefulStop();
@@ -4584,4 +4661,4 @@ async function monitorSlackProvider(opts = {}) {
 }
 const resolveSlackRuntimeGroupPolicy = resolveOpenProviderRuntimeGroupPolicy$1;
 //#endregion
-export { resolveStorePath$1 as _, escapeSlackMrkdwn as a, stripSlackMentionsForCommandDetection as b, authorizeSlackBotRoomMessage as c, buildSlackAssistantThreadMetadata as d, parseSlackAssistantThreadMetadata as f, resolveChannelContextVisibilityMode as g, readSessionUpdatedAt as h, authorizeSlackDirectMessage as i, resolveSlackCommandIngress as l, resolveSlackChatType as m, resolveSlackRuntimeGroupPolicy as n, recordInboundSession as o, normalizeSlackChannelType as p, resolveSlackRoomContextHints as r, resolveConversationLabel$1 as s, monitorSlackProvider as t, resolveSlackEffectiveAllowFrom as u, updateLastRoute as v, buildSlackSlashCommandMatcher as y };
+export { stripSlackMentionsForCommandDetection as S, readSessionUpdatedAt as _, SLACK_SOCKET_RECONNECT_POLICY as a, updateLastRoute as b, recordInboundSession as c, resolveSlackCommandIngress as d, resolveSlackEffectiveAllowFrom as f, resolveSlackChatType as g, normalizeSlackChannelType as h, authorizeSlackDirectMessage as i, resolveConversationLabel$1 as l, parseSlackAssistantThreadMetadata as m, resolveSlackRuntimeGroupPolicy as n, formatUnknownError as o, buildSlackAssistantThreadMetadata as p, resolveSlackRoomContextHints as r, escapeSlackMrkdwn as s, monitorSlackProvider as t, authorizeSlackBotRoomMessage as u, resolveChannelContextVisibilityMode as v, buildSlackSlashCommandMatcher as x, resolveStorePath$1 as y };

package/dist/relay-source-42fP7Ktr.js

@@ -0,0 +1,278 @@
+import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-7YKru1TZ.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
+import { Buffer } from "node:buffer";
+import { isIP } from "node:net";
+import WebSocket from "ws";
+//#region extensions/slack/src/monitor/relay-source.ts
+const SLACK_RELAY_ROUTE_KINDS = new Set([
+	"user_group",
+	"thread_affinity",
+	"channel_default"
+]);
+const SLACK_RELAY_MAX_PAYLOAD_BYTES = 1024 * 1024;
+async function monitorSlackRelaySource(params) {
+	let reconnectAttempts = 0;
+	while (!params.abortSignal?.aborted) {
+		let connection;
+		try {
+			connection = await openRelayWebSocket(params.config, params.abortSignal);
+			reconnectAttempts = 0;
+			params.setStatus?.({
+				connected: true,
+				lastConnectedAt: Date.now(),
+				healthState: "healthy",
+				lastError: null
+			});
+			params.runtime.log?.(`slack relay mode connected gateway_id:${params.config.gatewayId}`);
+			await runRelayWebSocket({
+				connection,
+				handleSlackMessage: params.handleSlackMessage,
+				runtime: params.runtime,
+				abortSignal: params.abortSignal,
+				setStatus: params.setStatus,
+				setIdentity: params.setIdentity
+			});
+		} catch (err) {
+			if (params.abortSignal?.aborted) break;
+			reconnectAttempts += 1;
+			const delayMs = computeBackoff(SLACK_SOCKET_RECONNECT_POLICY, reconnectAttempts);
+			params.setStatus?.({
+				connected: false,
+				healthState: "disconnected",
+				lastDisconnect: {
+					at: Date.now(),
+					error: formatUnknownError(err)
+				},
+				lastError: formatUnknownError(err)
+			});
+			params.runtime.log?.(warn(`slack relay mode disconnected; reconnecting in ${Math.round(delayMs / 1e3)}s (attempt ${reconnectAttempts}) reason="${formatUnknownError(err)}"`));
+			await sleepWithAbort(delayMs, params.abortSignal);
+		} finally {
+			closeRelayWebSocket(connection?.ws);
+			params.setIdentity?.(void 0);
+		}
+	}
+}
+function openRelayWebSocket(config, abortSignal) {
+	if (abortSignal?.aborted) return Promise.reject(/* @__PURE__ */ new Error("Slack relay websocket aborted before connect"));
+	return new Promise((resolve, reject) => {
+		const ws = new WebSocket(buildRelayWebSocketUrl(config), buildRelayWebSocketOptions(config.authToken));
+		const bufferedMessages = [];
+		const onEarlyMessage = (data) => bufferedMessages.push(data);
+		const detachBuffer = () => ws.off("message", onEarlyMessage);
+		ws.on("message", onEarlyMessage);
+		const cleanup = () => {
+			ws.off("open", onOpen);
+			ws.off("error", onError);
+			ws.off("close", onClose);
+			abortSignal?.removeEventListener("abort", onAbort);
+		};
+		const onOpen = () => {
+			cleanup();
+			resolve({
+				ws,
+				bufferedMessages,
+				detachBuffer
+			});
+		};
+		const onError = (error) => {
+			cleanup();
+			detachBuffer();
+			reject(error);
+		};
+		const onClose = (code, reason) => {
+			cleanup();
+			detachBuffer();
+			reject(new Error(formatRelayClose(code, reason)));
+		};
+		const onAbort = () => {
+			cleanup();
+			detachBuffer();
+			closeRelayWebSocket(ws);
+			reject(/* @__PURE__ */ new Error("Slack relay websocket aborted during connect"));
+		};
+		ws.once("open", onOpen);
+		ws.once("error", onError);
+		ws.once("close", onClose);
+		abortSignal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function runRelayWebSocket(params) {
+	const { ws } = params.connection;
+	const relayState = {};
+	let pending = Promise.resolve();
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			ws.off("message", onMessage);
+			ws.off("error", onError);
+			ws.off("close", onClose);
+			params.abortSignal?.removeEventListener("abort", onAbort);
+		};
+		const settleResolve = () => {
+			cleanup();
+			pending.then(resolve, reject);
+		};
+		const settleReject = (error) => {
+			cleanup();
+			pending.then(() => reject(error), reject);
+		};
+		const onMessage = (data) => {
+			pending = pending.then(() => handleRelayFrame({
+				ws,
+				data,
+				handleSlackMessage: params.handleSlackMessage,
+				relayState,
+				setStatus: params.setStatus,
+				setIdentity: params.setIdentity
+			})).catch((err) => {
+				params.runtime.error?.(`slack relay frame failed: ${formatUnknownError(err)}`);
+			});
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		const onClose = (code, reason) => {
+			const closeReason = formatRelayClose(code, reason);
+			params.setStatus?.({
+				connected: false,
+				healthState: "disconnected",
+				lastDisconnect: {
+					at: Date.now(),
+					error: closeReason
+				}
+			});
+			settleReject(new Error(closeReason));
+		};
+		const onAbort = () => {
+			closeRelayWebSocket(ws);
+			settleResolve();
+		};
+		params.connection.detachBuffer();
+		ws.on("message", onMessage);
+		ws.once("error", onError);
+		ws.once("close", onClose);
+		params.abortSignal?.addEventListener("abort", onAbort, { once: true });
+		for (const message of params.connection.bufferedMessages) onMessage(message);
+	});
+}
+async function handleRelayFrame(params) {
+	const frame = parseRelayFrame(params.data);
+	const hello = extractRelayHello(frame);
+	if (hello) {
+		params.relayState.identity = hello.identity;
+		params.setIdentity?.(hello.identity);
+		params.setStatus?.({ relayIdentity: hello.identity ?? null });
+		return;
+	}
+	const event = extractRelaySlackMessageEvent(frame);
+	if (!event) return;
+	const now = Date.now();
+	params.setStatus?.({
+		lastEventAt: now,
+		lastInboundAt: now
+	});
+	params.setStatus?.({ relayRoute: event.route });
+	await params.handleSlackMessage(event.message, {
+		source: "message",
+		wasMentioned: true,
+		awaitDispatch: true,
+		...params.relayState.identity ? { relayIdentity: params.relayState.identity } : {}
+	});
+	sendRelayAck(params.ws, event.deliveryId);
+}
+function buildRelayWebSocketOptions(authToken) {
+	return {
+		headers: { Authorization: `Bearer ${authToken}` },
+		handshakeTimeout: 3e4,
+		maxPayload: SLACK_RELAY_MAX_PAYLOAD_BYTES,
+		perMessageDeflate: false
+	};
+}
+function buildRelayWebSocketUrl(config) {
+	const url = new URL(config.url);
+	if (url.protocol === "http:") url.protocol = "ws:";
+	else if (url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol !== "ws:" && url.protocol !== "wss:") throw new Error(`Slack relay URL must use http(s) or ws(s): ${config.url}`);
+	if (url.protocol === "ws:" && !isLocalRelayHost(url.hostname)) throw new Error(`Slack relay URL uses plaintext ws:// for non-local host "${url.host}". Use wss:// for remote relay URLs; ws:// is only allowed for localhost, 127.0.0.1, or [::1].`);
+	if (!url.pathname || url.pathname === "/") throw new Error(`Slack relay URL must include its websocket path: ${config.url}`);
+	url.searchParams.set("gateway_id", config.gatewayId);
+	return url.toString();
+}
+function isLocalRelayHost(hostname) {
+	const normalized = hostname.trim().toLowerCase();
+	const host = normalized.startsWith("[") && normalized.endsWith("]") ? normalized.slice(1, -1) : normalized;
+	if (host === "localhost" || host === "::1") return true;
+	return isIP(host) === 4 && host.startsWith("127.");
+}
+function parseRelayFrame(data) {
+	const text = rawDataToString(data);
+	return JSON.parse(text);
+}
+function rawDataToString(data) {
+	if (typeof data === "string") return data;
+	if (Buffer.isBuffer(data)) return data.toString("utf8");
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+	return Buffer.from(data).toString("utf8");
+}
+function extractRelaySlackMessageEvent(frame) {
+	const record = asRecord(frame);
+	if (!record || record.type !== "slack_event") return;
+	const deliveryId = stringValue(record.delivery_id);
+	const routeRecord = asRecord(record.route);
+	const routeKind = stringValue(routeRecord?.kind);
+	const routeKey = stringValue(routeRecord?.key);
+	const event = asRecord(asRecord(record.payload)?.event);
+	if (event?.type !== "message" || typeof event.channel !== "string") return;
+	if (!deliveryId || !routeKind || !SLACK_RELAY_ROUTE_KINDS.has(routeKind) || !routeKey) return;
+	return {
+		deliveryId,
+		message: event,
+		route: {
+			kind: routeKind,
+			key: routeKey
+		}
+	};
+}
+function extractRelayHello(frame) {
+	const record = asRecord(frame);
+	if (!record || record.type !== "hello") return;
+	return { identity: extractRelayIdentity(record) };
+}
+function extractRelayIdentity(record) {
+	const identityRecord = asRecord(record.slack_identity) ?? asRecord(record.slackIdentity);
+	if (!identityRecord) return;
+	const username = normalizeOptionalString(identityRecord.username);
+	const iconUrl = normalizeOptionalString(identityRecord.icon_url) ?? normalizeOptionalString(identityRecord.iconUrl);
+	const iconEmoji = normalizeOptionalString(identityRecord.icon_emoji) ?? normalizeOptionalString(identityRecord.iconEmoji);
+	if (!username && !iconUrl && !iconEmoji) return;
+	return {
+		...username ? { username } : {},
+		...iconUrl ? { iconUrl } : {},
+		...iconEmoji ? { iconEmoji } : {}
+	};
+}
+function sendRelayAck(ws, deliveryId) {
+	if (ws.readyState !== WebSocket.OPEN) return;
+	ws.send(JSON.stringify({
+		type: "ack",
+		delivery_id: deliveryId
+	}));
+}
+function closeRelayWebSocket(ws) {
+	if (!ws || ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) return;
+	ws.close();
+}
+function formatRelayClose(code, reason) {
+	const text = reason.toString("utf8");
+	return text ? `Slack relay websocket closed (${code} ${text})` : `Slack relay websocket closed (${code})`;
+}
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+//#endregion
+export { SLACK_RELAY_MAX_PAYLOAD_BYTES, buildRelayWebSocketOptions, buildRelayWebSocketUrl, monitorSlackRelaySource };

package/dist/{replies-CH4Dmgbr.js → replies-Dlxge48k.js}

@@ -1,5 +1,6 @@
-import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-DSfujQlj.js";
-import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-EpqsWCGd.js";
+import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-BT_sNsDQ.js";
+import { s as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-CRoD-UQw.js";
+import "./provider-7YKru1TZ.js";
 import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";

package/dist/{reply-blocks-DSfujQlj.js → reply-blocks-BT_sNsDQ.js}

@@ -1,7 +1,7 @@
-import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-f6Xcv9Vi.js";
+import { a as resolveSlackAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-BPCiCe8y.js";
 import { r as parseSlackTarget } from "./target-parsing-3jYH8LfB.js";
 import "./targets-Dll4NJgs.js";
-import { h as isSlackPluginAccountConfigured } from "./client-DhaHONzg.js";
+import { t as isSlackPluginAccountConfigured } from "./account-configured-DzC407uv.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, normalizeStringifiedOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeMessageChannel } from "openclaw/plugin-sdk/routing";

package/dist/{resolve-channels-DNiE0Z0_.js → resolve-channels-CtUOIX8D.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { r as createSlackWebClient } from "./client-DhaHONzg.js";
+import { r as createSlackWebClient } from "./client-km2ba2l3.js";
 import { n as resolveSlackAllowlistEntries, t as collectSlackCursorItems } from "./resolve-allowlist-common-CP8SH0Zf.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/resolve-channels.ts