@openclaw/slack 2026.9.5 → 2026.9.7

package/dist/.setup/{account-inspect-B86OaUEt.mjs → account-inspect-DWBXpER6.mjs}

@@ -1,5 +1,5 @@
 import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.mjs";
-import { i as resolveDefaultSlackAccountId, r as mergeSlackAccountConfig } from "./accounts-C1FspRF-.mjs";
+import { a as mergeSlackAccountConfig, o as resolveDefaultSlackAccountId } from "./accounts-D_N9IqNA.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";

package/dist/.setup/{accounts-C1FspRF-.mjs → accounts-D_N9IqNA.mjs}

@@ -1,9 +1,11 @@
+import { r as __exportAll } from "./streaming-compat-C5Wut626.mjs";
 import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.mjs";
 import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { asOptionalRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { mapAllowFromEntries, normalizeChannelDmPolicy } from "openclaw/plugin-sdk/channel-config-helpers";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
+import { normalizeChatType } from "openclaw/plugin-sdk/account-core";
 //#region extensions/slack/src/token.ts
 function formatSlackBotTokenIdentityWarning(params) {
 	const userId = params.auth.user_id?.trim();
@@ -31,7 +33,27 @@ function resolveSlackUserToken(raw, path = "channels.slack.userToken") {
 	});
 }
 //#endregion
+//#region extensions/slack/src/account-reply-mode.ts
+function resolveSlackReplyToMode(account, chatType) {
+	const normalized = normalizeChatType(chatType ?? void 0);
+	if (normalized && account.replyToModeByChatType?.[normalized] !== void 0) return account.replyToModeByChatType[normalized] ?? "off";
+	return account.replyToMode ?? "off";
+}
+//#endregion
 //#region extensions/slack/src/accounts.ts
+var accounts_exports = /* @__PURE__ */ __exportAll({
+	hasImplicitDefaultSlackAccount: () => hasImplicitDefaultSlackAccount,
+	listEnabledSlackAccounts: () => listEnabledSlackAccounts,
+	listSlackAccountIds: () => listSlackAccountIds,
+	mergeSlackAccountConfig: () => mergeSlackAccountConfig,
+	resolveDefaultSlackAccountId: () => resolveDefaultSlackAccountId,
+	resolveSlackAccount: () => resolveSlackAccount,
+	resolveSlackAccountAllowFrom: () => resolveSlackAccountAllowFrom,
+	resolveSlackAccountDmPolicy: () => resolveSlackAccountDmPolicy,
+	resolveSlackConfigAccessorAccount: () => resolveSlackConfigAccessorAccount,
+	resolveSlackOperationToken: () => resolveSlackOperationToken,
+	resolveSlackReplyToMode: () => resolveSlackReplyToMode
+});
 function resolveSlackOperationToken(account, operation) {
 	if (account.identity === "user") return normalizeOptionalString(account.userToken);
 	const userToken = normalizeOptionalString(account.userToken);
@@ -39,21 +61,22 @@ function resolveSlackOperationToken(account, operation) {
 	if (operation === "read") return userToken ?? botToken;
 	return account.config.userTokenReadOnly === false ? botToken ?? userToken : botToken;
 }
+function hasImplicitDefaultSlackAccount(cfg) {
+	const slack = cfg.channels?.slack;
+	const userIdentity = slack?.postAs === "user";
+	return hasSlackAccountCredentials({
+		config: slack ?? {},
+		identityTokenConfigured: hasConfiguredAccountValue(userIdentity ? slack?.userToken : slack?.botToken) || hasConfiguredAccountValue(userIdentity ? process.env.SLACK_USER_TOKEN : process.env.SLACK_BOT_TOKEN),
+		appTokenConfigured: hasConfiguredAccountValue(slack?.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN)
+	});
+}
 const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedSlackAccountConfig } = createAccountListHelpers("slack", {
 	nestedObjectKeys: [
 		"botLoopProtection",
 		"presenceEvents",
 		"relay"
 	],
-	hasImplicitDefaultAccount: (cfg) => {
-		const slack = cfg.channels?.slack;
-		const userIdentity = slack?.postAs === "user";
-		return hasSlackAccountCredentials({
-			config: slack ?? {},
-			identityTokenConfigured: hasConfiguredAccountValue(userIdentity ? slack?.userToken : slack?.botToken) || hasConfiguredAccountValue(userIdentity ? process.env.SLACK_USER_TOKEN : process.env.SLACK_BOT_TOKEN),
-			appTokenConfigured: hasConfiguredAccountValue(slack?.appToken) || hasConfiguredAccountValue(process.env.SLACK_APP_TOKEN)
-		});
-	}
+	hasImplicitDefaultAccount: hasImplicitDefaultSlackAccount
 });
 const listSlackAccountIds = listAccountIds;
 const resolveDefaultSlackAccountId = resolveDefaultAccountId;
@@ -184,4 +207,4 @@ function listEnabledSlackAccounts(cfg) {
 	})).filter((account) => account.enabled);
 }
 //#endregion
-export { resolveSlackAccount as a, resolveSlackConfigAccessorAccount as c, resolveSlackAppToken as d, resolveSlackBotToken as f, resolveDefaultSlackAccountId as i, resolveSlackOperationToken as l, listSlackAccountIds as n, resolveSlackAccountAllowFrom as o, mergeSlackAccountConfig as r, resolveSlackAccountDmPolicy as s, listEnabledSlackAccounts as t, formatSlackBotTokenIdentityWarning as u };
+export { mergeSlackAccountConfig as a, resolveSlackAccountAllowFrom as c, resolveSlackOperationToken as d, resolveSlackReplyToMode as f, resolveSlackBotToken as h, listSlackAccountIds as i, resolveSlackAccountDmPolicy as l, resolveSlackAppToken as m, hasImplicitDefaultSlackAccount as n, resolveDefaultSlackAccountId as o, formatSlackBotTokenIdentityWarning as p, listEnabledSlackAccounts as r, resolveSlackAccount as s, accounts_exports as t, resolveSlackConfigAccessorAccount as u };

package/dist/.setup/{action-runtime-Aa-h24Fq.mjs → action-runtime-DfWvuiZd.mjs}

@@ -1,11 +1,11 @@
-import { Mt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, Nt as resolveSlackAutoThreadId, ct as parseSlackBlocksInput, f as assertSlackDetachedTargetAllowed, r as buildSlackChannelIdCandidates, v as hasSlackNativeDataBlock, xt as getSlackInstallationKind } from "./session-status-BhG6pdiH.mjs";
-import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-DEsPjngB.mjs";
-import { t as slackContextTargetsMatch } from "./targets-Cku2KCvg.mjs";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-Db_QWCZZ.mjs";
+import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-FFE26kOV.mjs";
+import { t as slackContextTargetsMatch } from "./targets-C6LZQL1Q.mjs";
+import { Nt as getSlackInstallationKind, Ut as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, Wt as resolveSlackAutoThreadId, _t as parseSlackBlocksInput, f as assertSlackDetachedTargetAllowed, r as buildSlackChannelIdCandidates, v as hasSlackNativeDataBlock } from "./session-status-DscajIsd.mjs";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-D-jfM174.mjs";
 import { t as mergeSlackSendResults } from "./send-results-eeOu_HYm.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { createLazyRuntimeMethodBinder, createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
 import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";
 import { createActionGate, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
@@ -27,35 +27,31 @@ const pinActions = /* @__PURE__ */ new Set([
 	"listPins"
 ]);
 const SLACK_REACTION_RESULT_LIMIT = 100;
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-BvGUGk3w.mjs").then((n) => n.t));
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts.runtime-BpWv-6-2.mjs"));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-osC0XOES.mjs").then((n) => n.t));
-function createLazySlackAction(key) {
-	return (async (...args) => {
-		const action = (await loadSlackActionsRuntime())[key];
-		return action(...args);
-	});
-}
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-Df0CzcDl.mjs").then((n) => n.t));
+const bindSlackAction = createLazyRuntimeMethodBinder(loadSlackActionsRuntime);
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts-D_N9IqNA.mjs").then((n) => n.t));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-ClOttrZ5.mjs").then((n) => n.t));
+const bindSlackChannelType = createLazyRuntimeMethodBinder(loadSlackChannelTypeRuntime);
 const slackActionRuntime = {
-	deleteSlackMessage: createLazySlackAction("deleteSlackMessage"),
-	downloadSlackFile: createLazySlackAction("downloadSlackFile"),
-	editSlackMessage: createLazySlackAction("editSlackMessage"),
-	getSlackMemberInfo: createLazySlackAction("getSlackMemberInfo"),
-	listSlackEmojis: createLazySlackAction("listSlackEmojis"),
-	listSlackPins: createLazySlackAction("listSlackPins"),
-	listSlackReactions: createLazySlackAction("listSlackReactions"),
-	openSlackConversation: createLazySlackAction("openSlackConversation"),
+	deleteSlackMessage: bindSlackAction((runtime) => runtime.deleteSlackMessage),
+	downloadSlackFile: bindSlackAction((runtime) => runtime.downloadSlackFile),
+	editSlackMessage: bindSlackAction((runtime) => runtime.editSlackMessage),
+	getSlackMemberInfo: bindSlackAction((runtime) => runtime.getSlackMemberInfo),
+	listSlackEmojis: bindSlackAction((runtime) => runtime.listSlackEmojis),
+	listSlackPins: bindSlackAction((runtime) => runtime.listSlackPins),
+	listSlackReactions: bindSlackAction((runtime) => runtime.listSlackReactions),
+	openSlackConversation: bindSlackAction((runtime) => runtime.openSlackConversation),
 	parseSlackBlocksInput,
-	pinSlackMessage: createLazySlackAction("pinSlackMessage"),
-	reactSlackMessage: createLazySlackAction("reactSlackMessage"),
-	readSlackMessages: createLazySlackAction("readSlackMessages"),
-	removeOwnSlackReactions: createLazySlackAction("removeOwnSlackReactions"),
-	removeSlackReaction: createLazySlackAction("removeSlackReaction"),
-	resolveSlackConversationName: createLazySlackAction("resolveSlackConversationName"),
-	resolveSlackConversationInfo: async (params) => (await loadSlackChannelTypeRuntime()).resolveSlackConversationInfo(params),
-	resolveSlackChannelType: async (params) => (await loadSlackChannelTypeRuntime()).resolveSlackChannelType(params),
-	sendSlackMessage: createLazySlackAction("sendSlackMessage"),
-	unpinSlackMessage: createLazySlackAction("unpinSlackMessage")
+	pinSlackMessage: bindSlackAction((runtime) => runtime.pinSlackMessage),
+	reactSlackMessage: bindSlackAction((runtime) => runtime.reactSlackMessage),
+	readSlackMessages: bindSlackAction((runtime) => runtime.readSlackMessages),
+	removeOwnSlackReactions: bindSlackAction((runtime) => runtime.removeOwnSlackReactions),
+	removeSlackReaction: bindSlackAction((runtime) => runtime.removeSlackReaction),
+	resolveSlackConversationName: bindSlackAction((runtime) => runtime.resolveSlackConversationName),
+	resolveSlackConversationInfo: bindSlackChannelType((runtime) => runtime.resolveSlackConversationInfo),
+	resolveSlackChannelType: bindSlackChannelType((runtime) => runtime.resolveSlackChannelType),
+	sendSlackMessage: bindSlackAction((runtime) => runtime.sendSlackMessage),
+	unpinSlackMessage: bindSlackAction((runtime) => runtime.unpinSlackMessage)
 };
 function resolveThreadTsFromContext(explicitThreadTs, targetChannel, context, opts) {
 	if (explicitThreadTs) return explicitThreadTs;
@@ -67,12 +63,6 @@ function resolveThreadTsFromContext(explicitThreadTs, targetChannel, context, op
 	if (isSingleUseReplyToMode(context?.replyToMode ?? "off") && !context?.hasRepliedRef) return;
 	return threadTs;
 }
-function readSlackBlocksParam(params) {
-	return slackActionRuntime.parseSlackBlocksInput(params.blocks);
-}
-function isImageContentType(value) {
-	return value?.trim().toLowerCase().startsWith("image/") === true;
-}
 function hasPotentialSlackNamedPolicy(params) {
 	if (params.allowNameMatching !== true) return false;
 	return Object.entries(params.channels ?? {}).some(([key, entry]) => {
@@ -349,6 +339,17 @@ async function handleSlackAction(params, cfg, context) {
 	if (messagingActions.has(action)) {
 		if (!isActionEnabled("messages")) throw new Error("Slack messages are disabled.");
 		const sentResults = [];
+		const buildSendOpts = (destination, forceDocument) => {
+			const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
+			return {
+				...buildActionOpts("write"),
+				mediaAccess: context?.mediaAccess,
+				mediaLocalRoots: context?.mediaLocalRoots,
+				mediaReadFile: context?.mediaReadFile,
+				threadTs,
+				...forceDocument ? { forceDocument: true } : {}
+			};
+		};
 		const sendSlackMessage = async (target, content, options) => {
 			const replyReference = context?.hasRepliedRef && slackContextTargetsMatch(target, context) ? context.hasRepliedRef : void 0;
 			const result = await slackActionRuntime.sendSlackMessage(target, content, {
@@ -378,7 +379,7 @@ async function handleSlackAction(params, cfg, context) {
 				const destination = resolveSlackActionTarget(account, readStringParam(params, "to", { required: true }), context).routingTarget;
 				const content = readStringParam(params, "content", { allowEmpty: true });
 				const mediaUrl = readStringParam(params, "mediaUrl");
-				const blocks = readSlackBlocksParam(params);
+				const blocks = slackActionRuntime.parseSlackBlocksInput(params.blocks);
 				const replyBroadcast = readBooleanParam(params, "replyBroadcast");
 				const textIsSlackMrkdwn = readBooleanParam(params, "textIsSlackMrkdwn");
 				const textIsSlackPlainText = readBooleanParam(params, "textIsSlackPlainText");
@@ -389,15 +390,7 @@ async function handleSlackAction(params, cfg, context) {
 				const nativeDataFallbackBaseText = readStringParam(params, "nativeDataFallbackBaseText", { allowEmpty: true });
 				if (!content && !mediaUrl && !blocks && !preparedMessages?.length) throw new Error("Slack sendMessage requires content, blocks, or mediaUrl.");
 				if (replyBroadcast && mediaUrl) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
-				const baseSendOpts = {
-					...buildActionOpts("write"),
-					mediaAccess: context?.mediaAccess,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...forceDocument ? { forceDocument: true } : {}
-				};
+				const baseSendOpts = buildSendOpts(destination, forceDocument);
 				const sendOpts = {
 					...baseSendOpts,
 					...replyBroadcast ? { replyBroadcast } : {},
@@ -455,15 +448,9 @@ async function handleSlackAction(params, cfg, context) {
 				const title = readStringParam(params, "title");
 				const forceDocument = readBooleanParam(params, "forceDocument") === true;
 				if (readBooleanParam(params, "replyBroadcast")) throw new Error("Slack replyBroadcast is only supported for text or block thread replies.");
-				const threadTs = resolveThreadTsFromContext(readStringParam(params, "threadTs"), destination, context, { suppressImplicitThread: params.topLevel === true || params.threadTs === null });
 				const result = await sendSlackMessage(destination, initialComment ?? "", {
-					...buildActionOpts("write"),
+					...buildSendOpts(destination, forceDocument),
 					mediaUrl: filePath,
-					mediaAccess: context?.mediaAccess,
-					mediaLocalRoots: context?.mediaLocalRoots,
-					mediaReadFile: context?.mediaReadFile,
-					threadTs: threadTs ?? void 0,
-					...forceDocument ? { forceDocument: true } : {},
 					...filename ? { uploadFileName: filename } : {},
 					...title ? { uploadTitle: title } : {}
 				});
@@ -477,7 +464,7 @@ async function handleSlackAction(params, cfg, context) {
 				const { channelId } = target;
 				const messageId = readStringParam(params, "messageId", { required: true });
 				const content = readStringParam(params, "content", { allowEmpty: true });
-				const blocks = readSlackBlocksParam(params);
+				const blocks = slackActionRuntime.parseSlackBlocksInput(params.blocks);
 				if (!content && !blocks) throw new Error("Slack editMessage requires content or blocks.");
 				await assertReadTargetAllowed(target);
 				const writeOpts = buildActionOpts("write", target.teamId);
@@ -545,7 +532,7 @@ async function handleSlackAction(params, cfg, context) {
 					ok: false,
 					error: "File could not be downloaded. Confirm the fileId came from the requested Slack channel or explicit thread and that the file is accessible and within the size limit."
 				});
-				if (!isImageContentType(downloaded.contentType)) return jsonResult({
+				if (!downloaded.contentType?.trim().toLowerCase().startsWith("image/")) return jsonResult({
 					ok: true,
 					fileId,
 					path: downloaded.path,
@@ -578,16 +565,10 @@ async function handleSlackAction(params, cfg, context) {
 		const { channelId } = target;
 		const readOpts = buildActionOpts("read", target.teamId);
 		const writeOpts = buildActionOpts("write", target.teamId);
-		if (action === "pinMessage") {
-			const messageId = readStringParam(params, "messageId", { required: true });
-			await assertReadTargetAllowed(target);
-			await slackActionRuntime.pinSlackMessage(channelId, messageId, writeOpts);
-			return jsonResult({ ok: true });
-		}
-		if (action === "unpinMessage") {
+		if (action === "pinMessage" || action === "unpinMessage") {
 			const messageId = readStringParam(params, "messageId", { required: true });
 			await assertReadTargetAllowed(target);
-			await slackActionRuntime.unpinSlackMessage(channelId, messageId, writeOpts);
+			await (action === "pinMessage" ? slackActionRuntime.pinSlackMessage : slackActionRuntime.unpinSlackMessage)(channelId, messageId, writeOpts);
 			return jsonResult({ ok: true });
 		}
 		await assertReadTargetAllowed(target);

package/dist/.setup/action-runtime.runtime-Ck4bAWOX.mjs

@@ -0,0 +1,2 @@
+import { t as handleSlackAction } from "./action-runtime-DfWvuiZd.mjs";
+export { handleSlackAction };