@openclaw/slack 2026.5.12-beta.7

package/dist/registry-CeaoNfoP.js

@@ -0,0 +1,39 @@
+//#region extensions/slack/src/http/paths.ts
+function normalizeSlackWebhookPath(path) {
+	const trimmed = path?.trim();
+	if (!trimmed) return "/slack/events";
+	return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+//#endregion
+//#region extensions/slack/src/http/registry.ts
+const SLACK_HTTP_ROUTES_GLOBAL_KEY = Symbol.for("openclaw.slack.httpRoutes.v1");
+function getSlackHttpRoutes() {
+	const globalStore = globalThis;
+	const existing = globalStore[SLACK_HTTP_ROUTES_GLOBAL_KEY];
+	if (existing instanceof Map) return existing;
+	const routes = /* @__PURE__ */ new Map();
+	globalStore[SLACK_HTTP_ROUTES_GLOBAL_KEY] = routes;
+	return routes;
+}
+function registerSlackHttpHandler(params) {
+	const normalizedPath = normalizeSlackWebhookPath(params.path);
+	const routes = getSlackHttpRoutes();
+	if (routes.has(normalizedPath)) {
+		const suffix = params.accountId ? ` for account "${params.accountId}"` : "";
+		params.log?.(`slack: webhook path ${normalizedPath} already registered${suffix}`);
+		return () => {};
+	}
+	routes.set(normalizedPath, params.handler);
+	return () => {
+		getSlackHttpRoutes().delete(normalizedPath);
+	};
+}
+async function handleSlackHttpRequest(req, res) {
+	const url = new URL(req.url ?? "/", "http://localhost");
+	const handler = getSlackHttpRoutes().get(url.pathname);
+	if (!handler) return false;
+	await handler(req, res);
+	return true;
+}
+//#endregion
+export { registerSlackHttpHandler as n, normalizeSlackWebhookPath as r, handleSlackHttpRequest as t };

package/dist/replies-Xe_jMR6o.js

@@ -0,0 +1,139 @@
+import { r as SLACK_TEXT_LIMIT } from "./thread-ts-C2x7c5PP.js";
+import { t as resolveSlackReplyBlocks } from "./reply-blocks-Z5l6_R6H.js";
+import { o as markdownToSlackMrkdwnChunks, t as sendMessageSlack } from "./send-D_A9kL-C.js";
+import "./send.runtime-BRE_ncCU.js";
+import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { SILENT_REPLY_TOKEN, chunkMarkdownTextWithMode, isSilentReplyText } from "openclaw/plugin-sdk/reply-chunking";
+import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
+//#region extensions/slack/src/monitor/replies.ts
+function readSlackReplyBlocks(payload) {
+	return resolveSlackReplyBlocks(payload);
+}
+function resolveDeliveredSlackReplyThreadTs(params) {
+	return (params.replyToMode === "off" ? void 0 : params.payloadReplyToId) ?? params.replyThreadTs;
+}
+async function deliverReplies(params) {
+	for (const payload of params.replies) {
+		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;
+		if (!reply.hasMedia && slackBlocks?.length) {
+			const trimmed = reply.trimmedText;
+			if (!trimmed && !slackBlocks?.length) continue;
+			if (trimmed && isSilentReplyText(trimmed, SILENT_REPLY_TOKEN)) continue;
+			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.runtime.log?.(`delivered reply to ${params.target}`);
+			continue;
+		}
+		if (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) => {
+				await sendMessageSlack(params.target, trimmed, {
+					cfg: params.cfg,
+					token: params.token,
+					threadTs,
+					accountId: params.accountId,
+					...params.identity ? { identity: params.identity } : {}
+				});
+			},
+			sendMedia: async ({ mediaUrl, caption }) => {
+				await sendMessageSlack(params.target, caption ?? "", {
+					cfg: params.cfg,
+					token: params.token,
+					mediaUrl,
+					threadTs,
+					accountId: params.accountId,
+					...params.identity ? { identity: params.identity } : {}
+				});
+			}
+		}) !== "empty") params.runtime.log?.(`delivered reply to ${params.target}`);
+	}
+}
+/**
+* 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) {
+	return createReplyReferencePlanner({
+		replyToMode: params.isThreadReply ?? Boolean(params.incomingThreadTs && params.incomingThreadTs !== params.messageTs) ? "all" : params.replyToMode,
+		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 messages = [];
+	const chunkLimit = Math.min(params.textLimit, SLACK_TEXT_LIMIT);
+	for (const payload of params.replies) {
+		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) {
+			messages.push({
+				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);
+		for (const chunk of chunks) messages.push({ text: chunk });
+	}
+	if (messages.length === 0) return;
+	const responseType = params.ephemeral ? "ephemeral" : "in_channel";
+	for (const message of messages) await params.respond({
+		...message,
+		response_type: responseType
+	});
+}
+//#endregion
+export { resolveDeliveredSlackReplyThreadTs as a, readSlackReplyBlocks as i, deliverReplies as n, resolveSlackThreadTs as o, deliverSlackSlashReplies as r, createSlackReplyDeliveryPlan as t };

package/dist/reply-blocks-Z5l6_R6H.js

@@ -0,0 +1,14 @@
+import { t as buildSlackInteractiveBlocks } from "./blocks-render-BIDw-Pom.js";
+import { n as parseSlackBlocksInput } from "./blocks-input-CwTFVImV.js";
+//#region extensions/slack/src/reply-blocks.ts
+function resolveSlackReplyBlocks(payload) {
+	const slackData = payload.channelData?.slack;
+	const interactiveBlocks = buildSlackInteractiveBlocks(payload.interactive);
+	let channelBlocks = [];
+	if (slackData && typeof slackData === "object" && !Array.isArray(slackData)) channelBlocks = parseSlackBlocksInput(slackData.blocks) ?? [];
+	const blocks = [...channelBlocks, ...interactiveBlocks];
+	if (blocks.length > 50) throw new Error(`Slack blocks cannot exceed 50 items after interactive render`);
+	return blocks.length > 0 ? blocks : void 0;
+}
+//#endregion
+export { resolveSlackReplyBlocks as t };

package/dist/resolve-allowlist-common-Bk3clYPK.js

@@ -0,0 +1,43 @@
+//#region extensions/slack/src/resolve-allowlist-common.ts
+function readSlackNextCursor(response) {
+	const next = response.response_metadata?.next_cursor?.trim();
+	return next ? next : void 0;
+}
+async function collectSlackCursorItems(params) {
+	const items = [];
+	let cursor;
+	do {
+		const response = await params.fetchPage(cursor);
+		items.push(...params.collectPageItems(response));
+		cursor = readSlackNextCursor(response);
+	} while (cursor);
+	return items;
+}
+function resolveSlackAllowlistEntries(params) {
+	const results = [];
+	for (const input of params.entries) {
+		const parsed = params.parseInput(input);
+		if (parsed.id) {
+			const match = params.findById(params.lookup, parsed.id);
+			results.push(params.buildIdResolved({
+				input,
+				parsed,
+				match
+			}));
+			continue;
+		}
+		const resolved = params.resolveNonId({
+			input,
+			parsed,
+			lookup: params.lookup
+		});
+		if (resolved) {
+			results.push(resolved);
+			continue;
+		}
+		results.push(params.buildUnresolved(input));
+	}
+	return results;
+}
+//#endregion
+export { resolveSlackAllowlistEntries as n, collectSlackCursorItems as t };

package/dist/resolve-channels-BRYqyNVJ.js

@@ -0,0 +1,81 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { r as createSlackWebClient } from "./client-CPe4GmDR.js";
+import { n as resolveSlackAllowlistEntries, t as collectSlackCursorItems } from "./resolve-allowlist-common-Bk3clYPK.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/resolve-channels.ts
+var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveSlackChannelAllowlist: () => resolveSlackChannelAllowlist });
+function parseSlackChannelMention(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<#([A-Z0-9]+)(?:\|([^>]+))?>$/i);
+	if (mention) return {
+		id: mention[1]?.toUpperCase(),
+		name: mention[2]?.trim()
+	};
+	const prefixed = trimmed.replace(/^(slack:|channel:)/i, "");
+	if (/^[CG][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
+	const name = prefixed.replace(/^#/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackChannels(client) {
+	return collectSlackCursorItems({
+		fetchPage: async (cursor) => await client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: false,
+			limit: 1e3,
+			cursor
+		}),
+		collectPageItems: (res) => (res.channels ?? []).map((channel) => {
+			const id = channel.id?.trim();
+			const name = channel.name?.trim();
+			if (!id || !name) return null;
+			return {
+				id,
+				name,
+				archived: Boolean(channel.is_archived),
+				isPrivate: Boolean(channel.is_private)
+			};
+		}).filter(Boolean)
+	});
+}
+function resolveByName(name, channels) {
+	const target = normalizeLowercaseStringOrEmpty(name);
+	if (!target) return;
+	const matches = channels.filter((channel) => normalizeLowercaseStringOrEmpty(channel.name) === target);
+	if (matches.length === 0) return;
+	return matches.find((channel) => !channel.archived) ?? matches[0];
+}
+async function resolveSlackChannelAllowlist(params) {
+	const channels = await listSlackChannels(params.client ?? createSlackWebClient(params.token));
+	return resolveSlackAllowlistEntries({
+		entries: params.entries,
+		lookup: channels,
+		parseInput: parseSlackChannelMention,
+		findById: (lookup, id) => lookup.find((channel) => channel.id === id),
+		buildIdResolved: ({ input, parsed, match }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: match?.name ?? parsed.name,
+			archived: match?.archived
+		}),
+		resolveNonId: ({ input, parsed, lookup }) => {
+			if (!parsed.name) return;
+			const match = resolveByName(parsed.name, lookup);
+			if (!match) return;
+			return {
+				input,
+				resolved: true,
+				id: match.id,
+				name: match.name,
+				archived: match.archived
+			};
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+}
+//#endregion
+export { resolve_channels_exports as n, resolveSlackChannelAllowlist as t };

package/dist/resolve-users-Bd_SdP8j.js

@@ -0,0 +1,113 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { r as createSlackWebClient } from "./client-CPe4GmDR.js";
+import { n as resolveSlackAllowlistEntries, t as collectSlackCursorItems } from "./resolve-allowlist-common-Bk3clYPK.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/resolve-users.ts
+var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveSlackUserAllowlist: () => resolveSlackUserAllowlist });
+function parseSlackUserInput(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+	if (mention) return { id: mention[1]?.toUpperCase() };
+	const prefixed = trimmed.replace(/^(slack:|user:)/i, "");
+	if (/^[A-Z][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
+	if (trimmed.includes("@") && !trimmed.startsWith("@")) return { email: normalizeLowercaseStringOrEmpty(trimmed) };
+	const name = trimmed.replace(/^@/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackUsers(client) {
+	return collectSlackCursorItems({
+		fetchPage: async (cursor) => await client.users.list({
+			limit: 200,
+			cursor
+		}),
+		collectPageItems: (res) => (res.members ?? []).map((member) => {
+			const id = normalizeOptionalString(member.id);
+			const name = normalizeOptionalString(member.name);
+			if (!id || !name) return null;
+			const profile = member.profile ?? {};
+			return {
+				id,
+				name,
+				displayName: normalizeOptionalString(profile.display_name),
+				realName: normalizeOptionalString(profile.real_name) ?? normalizeOptionalString(member.real_name),
+				email: normalizeOptionalString(profile.email) == null ? void 0 : normalizeLowercaseStringOrEmpty(profile.email),
+				deleted: Boolean(member.deleted),
+				isBot: Boolean(member.is_bot),
+				isAppUser: Boolean(member.is_app_user)
+			};
+		}).filter(Boolean)
+	});
+}
+function scoreSlackUser(user, match) {
+	let score = 0;
+	if (!user.deleted) score += 3;
+	if (!user.isBot && !user.isAppUser) score += 2;
+	if (match.email && user.email === match.email) score += 5;
+	if (match.name) {
+		const target = normalizeLowercaseStringOrEmpty(match.name);
+		if ([
+			user.name,
+			user.displayName,
+			user.realName
+		].map((value) => normalizeLowercaseStringOrEmpty(value)).filter(Boolean).some((value) => value === target)) score += 2;
+	}
+	return score;
+}
+function resolveSlackUserFromMatches(input, matches, parsed) {
+	const best = matches.map((user) => ({
+		user,
+		score: scoreSlackUser(user, parsed)
+	})).toSorted((a, b) => b.score - a.score)[0]?.user ?? matches[0];
+	return {
+		input,
+		resolved: true,
+		id: best.id,
+		name: best.displayName ?? best.realName ?? best.name,
+		email: best.email,
+		deleted: best.deleted,
+		isBot: best.isBot,
+		note: matches.length > 1 ? "multiple matches; chose best" : void 0
+	};
+}
+async function resolveSlackUserAllowlist(params) {
+	const users = await listSlackUsers(params.client ?? createSlackWebClient(params.token));
+	return resolveSlackAllowlistEntries({
+		entries: params.entries,
+		lookup: users,
+		parseInput: parseSlackUserInput,
+		findById: (lookup, id) => lookup.find((user) => user.id === id),
+		buildIdResolved: ({ input, parsed, match }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: match?.displayName ?? match?.realName ?? match?.name,
+			email: match?.email,
+			deleted: match?.deleted,
+			isBot: match?.isBot
+		}),
+		resolveNonId: ({ input, parsed, lookup }) => {
+			if (parsed.email) {
+				const matches = lookup.filter((user) => user.email === parsed.email);
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+			if (parsed.name) {
+				const target = normalizeLowercaseStringOrEmpty(parsed.name);
+				const matches = lookup.filter((user) => {
+					return [
+						user.name,
+						user.displayName,
+						user.realName
+					].map((value) => normalizeLowercaseStringOrEmpty(value)).filter(Boolean).includes(target);
+				});
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+}
+//#endregion
+export { resolve_users_exports as n, resolveSlackUserAllowlist as t };

package/dist/rolldown-runtime-CiIaOW0V.js

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };