@openclaw/slack 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/index.js

@@ -23,7 +23,10 @@ var slack_default = defineBundledChannelEntry({
 		specifier: "./account-inspect-api.js",
 		exportName: "inspectSlackReadOnlyAccount"
 	},
-	registerFull: registerSlackPluginHttpRoutes
+	registerFull: (api) => {
+		if (api.registrationMode !== "full") return;
+		registerSlackPluginHttpRoutes(api);
+	}
 });
 //#endregion
 export { slack_default as default };

package/dist/message-tool-api-BykQB4AU.js

@@ -0,0 +1,138 @@
+import { n as listSlackAccountIds } from "./accounts-CK4AVI2_.js";
+import { t as inspectSlackAccount } from "./account-inspect-Drw2gAiN.js";
+import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
+import { createActionGate } from "openclaw/plugin-sdk/channel-actions";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { Type } from "typebox";
+//#region extensions/slack/src/message-actions.ts
+function listSlackMessageActions(cfg, accountId) {
+	const accounts = (accountId ? [inspectSlackAccount({
+		cfg,
+		accountId
+	})] : listSlackAccountIds(cfg).map((listedAccountId) => inspectSlackAccount({
+		cfg,
+		accountId: listedAccountId
+	}))).filter((account) => account.enabled && (account.identity === "user" ? account.userTokenStatus === "available" : account.botTokenStatus === "available"));
+	if (accounts.length === 0) return [];
+	const isActionEnabled = (key, defaultValue = true) => {
+		for (const account of accounts) if (createActionGate(account.actions ?? cfg.channels?.slack?.actions)(key, defaultValue)) return true;
+		return false;
+	};
+	const actions = /* @__PURE__ */ new Set(["send"]);
+	if (isActionEnabled("reactions")) {
+		actions.add("react");
+		actions.add("reactions");
+	}
+	if (isActionEnabled("messages")) {
+		actions.add("read");
+		actions.add("edit");
+		actions.add("delete");
+		actions.add("download-file");
+		actions.add("upload-file");
+	}
+	if (isActionEnabled("pins")) {
+		actions.add("pin");
+		actions.add("unpin");
+		actions.add("list-pins");
+	}
+	if (isActionEnabled("memberInfo")) actions.add("member-info");
+	if (isActionEnabled("emojiList")) actions.add("emoji-list");
+	return Array.from(actions);
+}
+function extractSlackToolSend(args) {
+	const action = args.action;
+	if (action !== "sendMessage" && action !== "uploadFile" && action !== "send" && action !== "upload-file") return null;
+	const extracted = extractToolSend(args, action);
+	if (!extracted) return null;
+	const nativeThreadTs = typeof args.threadTs === "string" ? normalizeSlackThreadTsCandidate(args.threadTs) : void 0;
+	const replyTo = typeof args.replyTo === "string" ? normalizeSlackThreadTsCandidate(args.replyTo) : void 0;
+	const threadTs = action === "send" ? resolveSlackThreadTsValue({
+		replyToId: replyTo,
+		threadId: extracted.threadId
+	}) : action === "upload-file" ? normalizeSlackThreadTsCandidate(extracted.threadId) ?? replyTo : nativeThreadTs ?? normalizeSlackThreadTsCandidate(extracted.threadId);
+	const threadSuppressed = extracted.threadSuppressed === true || args.topLevel === true || args.threadTs === null;
+	return {
+		...extracted,
+		threadId: threadTs ?? extracted.threadId,
+		...!threadTs && !extracted.threadId && !threadSuppressed ? { threadImplicit: true } : {},
+		...threadSuppressed ? { threadSuppressed: true } : {}
+	};
+}
+//#endregion
+//#region extensions/slack/src/message-tool-api.ts
+const SLACK_MESSAGE_ID_ACTIONS = [
+	"react",
+	"reactions",
+	"edit",
+	"delete",
+	"pin",
+	"unpin"
+];
+function createSlackFileActionSchema() {
+	return { fileId: Type.Optional(Type.String({ description: "Slack file id, starting with \"F\" (for example F0B0LTT8M36). Required for action=\"download-file\". Read it from inbound Slack file metadata at event.files[].id. This is not the Slack message timestamp/messageId." })) };
+}
+function createSlackReactionEmojiSchema() {
+	return { emoji: Type.Optional(Type.String({ description: "Slack emoji shortcode name (for example \"white_check_mark\" or \"+1\") or common emoji character (for example \"✅\"). Colons are optional around shortcodes." })) };
+}
+function createSlackForcedMediaSchema() {
+	const description = "Preserve original image bytes without image optimization. Slack still uploads a regular file; this does not convert it into a Slack document.";
+	return {
+		forceDocument: Type.Optional(Type.Boolean({ description })),
+		asDocument: Type.Optional(Type.Boolean({ description: `Alias for forceDocument. ${description}` }))
+	};
+}
+function createSlackMessageIdActionSchema() {
+	const description = "Slack message timestamp/message id (for example \"1777423717.666499\"). Used by react, reactions, edit, delete, pin, and unpin actions. React defaults to the current inbound message when available. Not used by download-file, which requires fileId from event.files[].id.";
+	return {
+		messageId: Type.Optional(Type.String({ description })),
+		message_id: Type.Optional(Type.String({ description: `${description} Alias for messageId.` }))
+	};
+}
+function createSlackSendActionSchema() {
+	return {
+		...createSlackForcedMediaSchema(),
+		topLevel: Type.Optional(Type.Boolean({ description: "Slack-only opt-out for action=\"send\" from a threaded same-channel context. Set true to post a new parent-channel message instead of inheriting the current Slack thread. `threadId: null` is accepted as the same top-level request." })),
+		replyBroadcast: Type.Optional(Type.Boolean({ description: "Slack-only opt-in for action=\"send\" thread replies. Set true with threadId or replyTo on text/block sends to also broadcast the reply to the parent channel. Not supported for media or upload-file." }))
+	};
+}
+function createSlackTopLevelActionSchema() {
+	return {
+		...createSlackForcedMediaSchema(),
+		topLevel: Type.Optional(Type.Boolean({ description: "Slack-only opt-out from threaded same-channel context. Set true to post at the channel root instead of inheriting the current Slack thread." }))
+	};
+}
+function describeSlackMessageTool({ cfg, accountId }) {
+	const actions = listSlackMessageActions(cfg, accountId);
+	const capabilities = /* @__PURE__ */ new Set();
+	const schema = [];
+	if (actions.includes("send")) capabilities.add("presentation");
+	if (actions.includes("download-file")) schema.push({
+		properties: createSlackFileActionSchema(),
+		actions: ["download-file"]
+	});
+	if (actions.includes("send")) schema.push({
+		properties: createSlackSendActionSchema(),
+		actions: ["send"]
+	});
+	if (actions.includes("upload-file")) schema.push({
+		properties: createSlackTopLevelActionSchema(),
+		actions: ["upload-file"]
+	});
+	if (actions.includes("react")) schema.push({
+		properties: createSlackReactionEmojiSchema(),
+		actions: ["react", "reactions"]
+	});
+	const messageIdActions = [];
+	for (const action of SLACK_MESSAGE_ID_ACTIONS) if (actions.includes(action)) messageIdActions.push(action);
+	if (messageIdActions.length > 0) schema.push({
+		properties: createSlackMessageIdActionSchema(),
+		actions: messageIdActions
+	});
+	return {
+		actions,
+		capabilities: Array.from(capabilities),
+		schema: schema.length > 0 ? schema : null
+	};
+}
+//#endregion
+export { extractSlackToolSend as n, listSlackMessageActions as r, describeSlackMessageTool as t };

package/dist/message-tool-api.js

@@ -1,2 +1,2 @@
-import { t as describeSlackMessageTool } from "./message-tool-api-CvKoWYYQ.js";
+import { t as describeSlackMessageTool } from "./message-tool-api-BykQB4AU.js";
 export { describeSlackMessageTool as describeMessageTool };

package/dist/monitor-1nF1NtqT.js

@@ -0,0 +1,13 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { E as buildSlackSlashCommandMatcher, t as monitorSlackProvider } from "./provider-CDNvBXUi.js";
+import { t as isSlackChannelAllowedByPolicy } from "./policy-TapwbeaT.js";
+import { o as resolveSlackThreadTs } from "./replies-CeOfv82I.js";
+//#region extensions/slack/src/monitor.ts
+var monitor_exports = /* @__PURE__ */ __exportAll({
+	buildSlackSlashCommandMatcher: () => buildSlackSlashCommandMatcher,
+	isSlackChannelAllowedByPolicy: () => isSlackChannelAllowedByPolicy,
+	monitorSlackProvider: () => monitorSlackProvider,
+	resolveSlackThreadTs: () => resolveSlackThreadTs
+});
+//#endregion
+export { monitor_exports as t };

package/dist/outbound-adapter-S81tsswN.js

@@ -0,0 +1,238 @@
+import { a as parseSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { B as SLACK_TEXT_LIMIT, I as resolveSlackAuthoredTextPlacement, at as escapeSlackMrkdwn, g as resolveSlackReplyBlockResolution, h as parseSlackReplyBlockSegments, q as SLACK_QUESTION_FINALIZATION_BLOCKS, st as SLACK_PRESENTATION_CAPABILITIES, tt as resolveSlackQuestionActionIds, v as resolveSlackReplyDeliveryMessages } from "./group-policy-c4RP9bjc.js";
+import { n as resolveSlackThreadTsValue } from "./thread-ts-DUGhaYKq.js";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { normalizeMessagePresentation, resolveLegacyInteractiveTextFallback } from "openclaw/plugin-sdk/interactive-runtime";
+import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { resolvePayloadMediaUrls, sendPayloadMediaSequenceAndFinalize, sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
+import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
+//#region extensions/slack/src/outbound-adapter.ts
+const SLACK_RENDERED_PRESENTATION_PROVENANCE_KEY = randomBytes(32);
+function createSlackRenderedPresentationProvenance(resolution) {
+	return createHmac("sha256", SLACK_RENDERED_PRESENTATION_PROVENANCE_KEY).update(JSON.stringify([resolution.authoredTextPlacement, resolution.segments])).digest("base64url");
+}
+function hasValidSlackRenderedPresentationProvenance(params) {
+	const expected = createSlackRenderedPresentationProvenance(params.resolution);
+	const actualBuffer = Buffer.from(params.provenance);
+	const expectedBuffer = Buffer.from(expected);
+	return actualBuffer.length === expectedBuffer.length && timingSafeEqual(actualBuffer, expectedBuffer);
+}
+function readSlackRenderedPresentation(slackData) {
+	const provenance = slackData?.renderedPresentationProvenance;
+	if (typeof provenance !== "string") return;
+	try {
+		const segments = parseSlackReplyBlockSegments(slackData?.renderedPresentationSegments);
+		const authoredTextPlacement = readSlackAuthoredTextPlacement(slackData?.authoredTextPlacement);
+		if (!segments || !authoredTextPlacement) return;
+		const resolution = {
+			authoredTextPlacement,
+			segments
+		};
+		return hasValidSlackRenderedPresentationProvenance({
+			provenance,
+			resolution
+		}) ? resolution : void 0;
+	} catch {
+		return;
+	}
+}
+const loadSlackSendRuntime = createLazyRuntimeModule(() => import("./send.runtime-BmgNe6S9.js"));
+function resolveSlackSendIdentity(identity) {
+	if (!identity) return;
+	const username = normalizeOptionalString(identity.name);
+	const iconUrl = normalizeOptionalString(identity.avatarUrl);
+	const rawEmoji = normalizeOptionalString(identity.emoji);
+	const iconEmoji = !iconUrl ? rawEmoji : void 0;
+	if (!username && !iconUrl && !iconEmoji) return;
+	return {
+		username,
+		iconUrl,
+		iconEmoji
+	};
+}
+function resolveSlackOutboundBlockResolution(payload) {
+	const slackData = payload.channelData?.slack;
+	const presentation = normalizeMessagePresentation(payload.presentation);
+	if (!Boolean(slackData?.blocks !== void 0 || presentation || payload.interactive?.blocks.length)) return {
+		authoredTextPlacement: resolveSlackAuthoredTextPlacement(payload),
+		segments: []
+	};
+	const { authoredTextPlacement: _authoredTextPlacement, renderedPresentationProvenance: _renderedPresentationProvenance, renderedPresentationSegments: _renderedPresentationSegments, ...preservedSlackData } = slackData ?? {};
+	return resolveSlackReplyBlockResolution({
+		...payload,
+		channelData: {
+			...payload.channelData,
+			slack: preservedSlackData
+		}
+	}, { materializeAuthoredText: true });
+}
+function withSlackRenderedPresentation(payload, slackData, resolution) {
+	const { authoredTextPlacement: _authoredTextPlacement, blocks: _blocks, renderedPresentationProvenance: _renderedPresentationProvenance, renderedPresentationSegments: _renderedPresentationSegments, ...preservedSlackData } = slackData ?? {};
+	return {
+		...payload,
+		channelData: {
+			...payload.channelData,
+			slack: {
+				...preservedSlackData,
+				authoredTextPlacement: resolution.authoredTextPlacement,
+				renderedPresentationProvenance: createSlackRenderedPresentationProvenance(resolution),
+				renderedPresentationSegments: resolution.segments
+			}
+		}
+	};
+}
+function readSlackAuthoredTextPlacement(value) {
+	return value === "none" || value === "blocks" || value === "outside-blocks" ? value : void 0;
+}
+async function sendSlackOutboundMessage(params) {
+	const send = resolveOutboundSendDep(params.deps, "slack") ?? (await loadSlackSendRuntime()).sendMessageSlack;
+	const slackIdentity = resolveSlackSendIdentity(params.identity);
+	const threadTs = resolveSlackThreadTsValue({
+		replyToId: params.replyToId,
+		threadId: params.threadId
+	});
+	const sendOptions = {
+		cfg: params.cfg,
+		threadTs,
+		accountId: params.accountId ?? void 0,
+		...params.mediaUrl ? {
+			mediaUrl: params.mediaUrl,
+			mediaAccess: params.mediaAccess,
+			mediaLocalRoots: params.mediaLocalRoots,
+			mediaReadFile: params.mediaReadFile,
+			...params.forceDocument ? { forceDocument: true } : {}
+		} : {},
+		...params.blocks ? { blocks: params.blocks } : {},
+		...params.authoredTextPlacement ? { authoredTextPlacement: params.authoredTextPlacement } : {},
+		...Object.hasOwn(params, "nativeDataFallbackBaseText") ? { nativeDataFallbackBaseText: params.nativeDataFallbackBaseText } : {},
+		...params.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+		...slackIdentity ? { identity: slackIdentity } : {},
+		...params.deliveryQueueId ? { deliveryQueueId: params.deliveryQueueId } : {},
+		...params.onPlatformSendDispatch ? { onPlatformSendDispatch: params.onPlatformSendDispatch } : {},
+		...params.onDeliveryResult ? { onDeliveryResult: async (progress) => {
+			await params.onDeliveryResult?.(attachChannelToResult("slack", progress));
+		} } : {}
+	};
+	return await send(params.to, params.text, sendOptions);
+}
+function createSlackAttachedSendAdapter() {
+	return createAttachedChannelResultAdapter({
+		channel: "slack",
+		sendText: sendSlackOutboundMessage,
+		sendMedia: sendSlackOutboundMessage
+	});
+}
+const slackOutbound = {
+	deliveryMode: "direct",
+	chunker: null,
+	textChunkLimit: SLACK_TEXT_LIMIT,
+	presentationCapabilities: SLACK_PRESENTATION_CAPABILITIES,
+	renderPresentation: ({ payload }) => {
+		const slackData = payload.channelData?.slack;
+		const resolution = resolveSlackOutboundBlockResolution(payload);
+		return resolution.segments.length > 0 ? withSlackRenderedPresentation(payload, slackData, resolution) : null;
+	},
+	sendPayload: async (ctx) => {
+		const payload = {
+			...ctx.payload,
+			text: resolveLegacyInteractiveTextFallback({
+				text: ctx.payload.text,
+				interactive: ctx.payload.interactive
+			}) ?? ""
+		};
+		const slackData = payload.channelData?.slack;
+		const renderedResolution = readSlackRenderedPresentation(slackData);
+		let resolution;
+		if (renderedResolution) resolution = renderedResolution;
+		else resolution = resolveSlackOutboundBlockResolution(payload);
+		if (resolution.segments.length === 0) return await sendTextMediaPayload({
+			channel: "slack",
+			ctx: {
+				...ctx,
+				payload
+			},
+			adapter: slackOutbound
+		});
+		const mediaUrls = resolvePayloadMediaUrls(payload);
+		const deliveryMessages = resolveSlackReplyDeliveryMessages({
+			authoredTextPlacement: resolution.authoredTextPlacement,
+			segments: resolution.segments,
+			text: payload.text
+		});
+		const useSingleDeliveryMarker = mediaUrls.length === 0 && deliveryMessages.length === 1;
+		return attachChannelToResult("slack", await sendPayloadMediaSequenceAndFinalize({
+			text: "",
+			mediaUrls,
+			send: async ({ text, mediaUrl }) => await sendSlackOutboundMessage({
+				...ctx,
+				text,
+				mediaUrl,
+				deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0
+			}),
+			finalize: async () => {
+				let lastResult;
+				for (const message of deliveryMessages) lastResult = await sendSlackOutboundMessage({
+					...ctx,
+					text: message.text,
+					...message.blocks ? { blocks: message.blocks } : {},
+					...message.authoredTextPlacement ? { authoredTextPlacement: message.authoredTextPlacement } : {},
+					...message.nativeDataFallbackBaseText ? { nativeDataFallbackBaseText: message.nativeDataFallbackBaseText } : {},
+					...message.textIsSlackPlainText ? { textIsSlackPlainText: true } : {},
+					deliveryQueueId: useSingleDeliveryMarker ? ctx.deliveryQueueId : void 0
+				});
+				if (!lastResult) throw new Error("Slack rendered presentation produced no deliverable segment");
+				return lastResult;
+			}
+		}));
+	},
+	afterDeliverPayload: async ({ cfg, target, payload, results }) => {
+		const questionId = questionGatewayRuntime.readAskUserQuestionId(payload);
+		const slackData = payload.channelData?.slack;
+		if (!questionId) return;
+		const resolution = readSlackRenderedPresentation(slackData);
+		if (!resolution) return;
+		const deliveryMessage = resolveSlackReplyDeliveryMessages({
+			authoredTextPlacement: resolution.authoredTextPlacement,
+			segments: resolution.segments,
+			text: payload.text
+		}).find((message) => resolveSlackQuestionActionIds(message.blocks).length > 0);
+		const questionActionIds = resolveSlackQuestionActionIds(deliveryMessage?.blocks);
+		const result = results.find(({ channel, meta }) => channel === "slack" && Array.isArray(meta?.slackQuestionActionIds) && meta.slackQuestionActionIds.some((actionId) => typeof actionId === "string" && questionActionIds.includes(actionId)));
+		const deliveredDisplayBlocks = (result?.meta)?.[SLACK_QUESTION_FINALIZATION_BLOCKS];
+		if (!deliveryMessage || !deliveredDisplayBlocks || !result?.messageId) return;
+		const channelId = result.channelId;
+		if (!channelId) return;
+		const teamId = parseSlackTarget(target.to, { defaultKind: "channel" })?.teamId;
+		const questionMessageId = typeof result.meta?.slackQuestionMessageId === "string" ? result.meta.slackQuestionMessageId : result.messageId;
+		questionGatewayRuntime.registerChannelDelivery({
+			questionId,
+			deliveryId: `slack:${target.accountId ?? "default"}:${channelId}:${questionMessageId}`,
+			finalize: async (statusLine) => {
+				const { updateMessageSlack } = await loadSlackSendRuntime();
+				const escapedStatusLine = escapeSlackMrkdwn(statusLine);
+				const blocks = [...deliveredDisplayBlocks, {
+					type: "context",
+					elements: [{
+						type: "mrkdwn",
+						text: escapedStatusLine
+					}]
+				}];
+				await updateMessageSlack({
+					cfg,
+					accountId: target.accountId ?? void 0,
+					channelId,
+					teamId,
+					messageTs: questionMessageId,
+					text: `${deliveryMessage.text}\n\n${escapedStatusLine}`,
+					blocks
+				});
+			}
+		});
+	},
+	...createSlackAttachedSendAdapter()
+};
+//#endregion
+export { slackOutbound };