@openclaw/slack 2026.7.2-beta.7 → 2026.7.33

package/dist/.setup/relay-source-DR--lDW8.mjs

@@ -0,0 +1,289 @@
+import { a as SLACK_SOCKET_RECONNECT_POLICY, o as formatUnknownError } from "./provider-Bjv1R5E2.mjs";
+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 = /* @__PURE__ */ new Set([
+	"user_group",
+	"thread_affinity",
+	"channel_default"
+]);
+const SLACK_RELAY_MAX_PAYLOAD_BYTES = 1048576;
+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 url = buildRelayWebSocketUrl(config);
+		const ws = new WebSocket(url, 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.");
+}
+var SlackRelayMalformedFrameError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "SlackRelayMalformedFrameError";
+	}
+};
+function parseRelayFrame(data) {
+	const text = rawDataToString(data);
+	try {
+		return JSON.parse(text);
+	} catch (cause) {
+		throw new SlackRelayMalformedFrameError("Slack relay received malformed JSON frame", { cause });
+	}
+}
+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, SlackRelayMalformedFrameError, buildRelayWebSocketOptions, buildRelayWebSocketUrl, monitorSlackRelaySource, parseRelayFrame };

package/dist/.setup/replies-BO37R07g.mjs

@@ -0,0 +1,288 @@
+import { a as SLACK_TEXT_LIMIT, t as resolveSlackReplyBlocks } from "./reply-blocks-Cwu6LYJI.mjs";
+import { r as sendMessageSlack } from "./send-DEOvcVM4.mjs";
+import { t as markdownToSlackMrkdwnChunks } from "./format-xuAop9a-.mjs";
+import "./provider-Bjv1R5E2.mjs";
+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";
+import { deliverTextOrMediaReply, getReplyPayloadTtsSupplement, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+import { getGlobalHookRunner } from "openclaw/plugin-sdk/plugin-runtime";
+import { buildCanonicalSentMessageHookContext, createInternalHookEvent, fireAndForgetHook, toInternalMessageSentContext, toPluginMessageContext, toPluginMessageSentEvent, triggerInternalHook } from "openclaw/plugin-sdk/hook-runtime";
+//#region extensions/slack/src/message-sent-hook.ts
+/**
+* Slack-side emission of the `message_sent` plugin hook.
+*
+* Mirrors the Telegram pattern in `extensions/telegram/src/bot/delivery.replies.ts`
+* (`buildTelegramSentHookContext`, `emitMessageSentHooks`, `emitTelegramMessageSentHooks`).
+*
+* Without this, plugins observing `message_sent` see Telegram outbound but not
+* Slack outbound — even though `docs/plugins/hooks.md` documents the hook as
+* firing for all successful outbound deliveries.
+*/
+function buildSlackSentHookContext(params) {
+	return buildCanonicalSentMessageHookContext({
+		to: params.to,
+		content: params.content,
+		success: params.success,
+		error: params.error,
+		channelId: "slack",
+		accountId: params.accountId ?? void 0,
+		conversationId: params.to,
+		sessionKey: params.sessionKeyForInternalHooks,
+		messageId: params.messageId,
+		isGroup: params.isGroup,
+		groupId: params.groupId
+	});
+}
+function emitInternalSlackMessageSentHook(params) {
+	if (!params.sessionKeyForInternalHooks) return;
+	const canonical = buildSlackSentHookContext(params);
+	fireAndForgetHook(triggerInternalHook(createInternalHookEvent("message", "sent", params.sessionKeyForInternalHooks, toInternalMessageSentContext(canonical))), "slack: message:sent internal hook failed");
+}
+function emitMessageSentHooks(params) {
+	if (!params.enabled && !params.sessionKeyForInternalHooks) return;
+	const canonical = buildSlackSentHookContext(params);
+	if (params.enabled) fireAndForgetHook(Promise.resolve(params.hookRunner.runMessageSent(toPluginMessageSentEvent(canonical), toPluginMessageContext(canonical))), "slack: message_sent plugin hook failed");
+	emitInternalSlackMessageSentHook(params);
+}
+/**
+* Fire both the plugin `message_sent` hook and (if a session key is supplied)
+* the internal `message:sent` hook for a successful or failed Slack outbound
+* delivery.
+*
+* Safe to call after every `chat.postMessage` — the function self-gates on
+* `hookRunner.hasHooks("message_sent")` so plugins not observing the hook
+* incur no cost.
+*/
+function emitSlackMessageSentHooks(params) {
+	const hookRunner = getGlobalHookRunner();
+	emitMessageSentHooks({
+		...params,
+		hookRunner,
+		enabled: hookRunner?.hasHooks("message_sent") ?? false
+	});
+}
+//#endregion
+//#region extensions/slack/src/monitor/replies.ts
+function readSlackReplyBlocks(payload) {
+	return resolveSlackReplyBlocks(payload);
+}
+function resolveSlackMediaHookSpokenText(payload) {
+	return (getReplyPayloadTtsSupplement(payload)?.spokenText ?? payload.spokenText)?.trim() || void 0;
+}
+function resolveDeliveredSlackReplyThreadTs(params) {
+	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
+}
+async function deliverReplies(params) {
+	let latestResult;
+	for (const payload of params.replies) {
+		if (payload.isReasoning === true) continue;
+		const threadTs = resolveDeliveredSlackReplyThreadTs({
+			replyToMode: params.replyToMode,
+			payloadReplyToId: payload.replyToId,
+			replyThreadTs: params.replyThreadTs
+		});
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const slackBlocks = readSlackReplyBlocks(payload);
+		if (!reply.hasContent && !slackBlocks?.length) continue;
+		const emitSent = (content, result) => {
+			if (params.deferMessageSentHooks) return;
+			emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget ?? params.target,
+				accountId: params.accountId,
+				content,
+				success: true,
+				messageId: result?.messageId,
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+		};
+		const emitFailed = (content, error) => {
+			if (params.deferMessageSentHooks) return;
+			emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget ?? params.target,
+				accountId: params.accountId,
+				content,
+				success: false,
+				error: formatErrorMessage(error),
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+		};
+		if (!reply.hasMedia && slackBlocks?.length) {
+			const trimmed = reply.trimmedText;
+			if (!trimmed && !slackBlocks?.length) continue;
+			if (trimmed && isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) continue;
+			let result;
+			try {
+				result = await sendMessageSlack(params.target, trimmed, {
+					cfg: params.cfg,
+					token: params.token,
+					threadTs,
+					accountId: params.accountId,
+					...slackBlocks?.length ? { blocks: slackBlocks } : {},
+					...params.identity ? { identity: params.identity } : {},
+					...params.metadata ? { metadata: params.metadata } : {}
+				});
+			} catch (error) {
+				emitFailed(trimmed, error);
+				throw error;
+			}
+			emitSent(trimmed, result);
+			latestResult = result;
+			params.runtime.log?.(`delivered reply to ${params.target}`);
+			continue;
+		}
+		const spokenText = resolveSlackMediaHookSpokenText(payload);
+		const mediaHookContent = reply.hasText ? reply.text : spokenText || reply.text;
+		const hookContent = reply.hasMedia ? mediaHookContent : reply.trimmedText;
+		let lastResult;
+		let delivered;
+		try {
+			delivered = await deliverTextOrMediaReply({
+				payload,
+				text: reply.text,
+				chunkText: !reply.hasMedia ? (value) => {
+					const trimmed = value.trim();
+					if (!trimmed || isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) return [];
+					return [trimmed];
+				} : void 0,
+				sendText: async (trimmed) => {
+					lastResult = await sendMessageSlack(params.target, trimmed, {
+						cfg: params.cfg,
+						token: params.token,
+						threadTs,
+						accountId: params.accountId,
+						...params.identity ? { identity: params.identity } : {},
+						...params.metadata ? { metadata: params.metadata } : {}
+					});
+				},
+				sendMedia: async ({ mediaUrl, caption }) => {
+					lastResult = await sendMessageSlack(params.target, caption ?? "", {
+						cfg: params.cfg,
+						token: params.token,
+						mediaUrl,
+						threadTs,
+						accountId: params.accountId,
+						...params.identity ? { identity: params.identity } : {},
+						...params.metadata ? { metadata: params.metadata } : {}
+					});
+				}
+			});
+		} catch (error) {
+			emitFailed(hookContent, error);
+			throw error;
+		}
+		if (delivered !== "empty") {
+			emitSent(hookContent, reply.hasMedia ? void 0 : lastResult);
+			latestResult = lastResult;
+			params.runtime.log?.(`delivered reply to ${params.target}`);
+		}
+	}
+	return latestResult;
+}
+/**
+* Compute effective threadTs for a Slack reply based on replyToMode.
+* - "off": stay in thread if already in one, otherwise main channel
+* - "first": first reply goes to thread, subsequent replies to main channel
+* - "all": all replies go to thread
+*/
+function resolveSlackThreadTs(params) {
+	return createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasReplied,
+		isThreadReply: params.isThreadReply
+	}).use();
+}
+function createSlackReplyReferencePlanner(params) {
+	const effectiveMode = params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode;
+	return createReplyReferencePlanner({
+		replyToMode: effectiveMode,
+		existingId: params.incomingThreadTs,
+		startId: params.messageTs,
+		hasReplied: params.hasReplied
+	});
+}
+function createSlackReplyDeliveryPlan(params) {
+	const replyReference = createSlackReplyReferencePlanner({
+		replyToMode: params.replyToMode,
+		incomingThreadTs: params.incomingThreadTs,
+		messageTs: params.messageTs,
+		hasReplied: params.hasRepliedRef.value,
+		isThreadReply: params.isThreadReply
+	});
+	return {
+		peekThreadTs: () => replyReference.peek(),
+		nextThreadTs: () => replyReference.use(),
+		markSent: () => {
+			replyReference.markSent();
+			params.hasRepliedRef.value = replyReference.hasReplied();
+		}
+	};
+}
+async function deliverSlackSlashReplies(params) {
+	const deliveries = [];
+	const chunkLimit = Math.min(params.textLimit, SLACK_TEXT_LIMIT);
+	for (const payload of params.replies) {
+		if (payload.isReasoning === true) continue;
+		const reply = resolveSendableOutboundReplyParts(payload);
+		const slackBlocks = readSlackReplyBlocks(payload);
+		const text = reply.hasText && !isSilentReplyText(reply.trimmedText, SILENT_REPLY_TOKEN) ? reply.trimmedText : void 0;
+		if (slackBlocks?.length && !reply.hasMedia) {
+			deliveries.push({
+				hookContent: text ?? "",
+				messages: [{
+					text: text ?? "",
+					blocks: slackBlocks
+				}]
+			});
+			continue;
+		}
+		const combined = [text ?? "", ...reply.mediaUrls].filter(Boolean).join("\n");
+		if (!combined) continue;
+		const chunkMode = params.chunkMode ?? "length";
+		const chunks = (chunkMode === "newline" ? chunkMarkdownTextWithMode(combined, chunkLimit, chunkMode) : [combined]).flatMap((markdown) => markdownToSlackMrkdwnChunks(markdown, chunkLimit, { tableMode: params.tableMode }));
+		if (!chunks.length && combined) chunks.push(combined);
+		deliveries.push({
+			hookContent: text ?? resolveSlackMediaHookSpokenText(payload) ?? combined,
+			messages: chunks.map((chunk) => ({ text: chunk }))
+		});
+	}
+	if (deliveries.length === 0) return;
+	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
+	for (const delivery of deliveries) {
+		try {
+			for (const message of delivery.messages) await params.respond({
+				...message,
+				response_type: responseType
+			});
+		} catch (error) {
+			if (params.messageSentHookTarget) emitSlackMessageSentHooks({
+				sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+				to: params.messageSentHookTarget,
+				accountId: params.accountId,
+				content: delivery.hookContent,
+				success: false,
+				error: formatErrorMessage(error),
+				isGroup: params.isGroup,
+				groupId: params.groupId
+			});
+			throw error;
+		}
+		if (params.messageSentHookTarget) emitSlackMessageSentHooks({
+			sessionKeyForInternalHooks: params.sessionKeyForInternalHooks,
+			to: params.messageSentHookTarget,
+			accountId: params.accountId,
+			content: delivery.hookContent,
+			success: true,
+			isGroup: params.isGroup,
+			groupId: params.groupId
+		});
+	}
+}
+//#endregion
+export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, emitSlackMessageSentHooks as s, createSlackReplyDeliveryPlan as t };