@openclaw/slack 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/account-configured-zcR9TJJN.mjs

@@ -0,0 +1,35 @@
+import { hasConfiguredAccountValue } from "openclaw/plugin-sdk/account-resolution";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+//#region extensions/slack/src/account-configured.ts
+function hasSlackAccountCredentials(params) {
+	if (!params.identityTokenConfigured) return false;
+	const mode = params.config.mode ?? "socket";
+	if (mode === "http") return hasConfiguredAccountValue(params.config.signingSecret);
+	if (mode === "relay") {
+		const relay = params.config.relay;
+		return hasConfiguredAccountValue(relay?.url) && hasConfiguredAccountValue(relay?.authToken) && hasConfiguredAccountValue(relay?.gatewayId);
+	}
+	return params.appTokenConfigured;
+}
+function hasSlackAccountCredentialsFromConfig(config, env) {
+	const userIdentity = config?.postAs === "user";
+	return hasSlackAccountCredentials({
+		config: config ?? {},
+		identityTokenConfigured: hasConfiguredAccountValue(userIdentity ? config?.userToken : config?.botToken) || hasConfiguredAccountValue(userIdentity ? env.SLACK_USER_TOKEN : env.SLACK_BOT_TOKEN),
+		appTokenConfigured: hasConfiguredAccountValue(config?.appToken) || hasConfiguredAccountValue(env.SLACK_APP_TOKEN)
+	});
+}
+function createSlackAccountConfiguredChecker(allowSecretRefs) {
+	return (account) => {
+		const hasToken = (key) => Boolean(account[key]?.trim()) || allowSecretRefs && account.config.mode !== "relay" && hasConfiguredSecretInput(account.config[key]);
+		return hasSlackAccountCredentials({
+			config: account.config,
+			identityTokenConfigured: hasToken(account.identity === "user" ? "userToken" : "botToken"),
+			appTokenConfigured: hasToken("appToken")
+		});
+	};
+}
+const isSlackPluginAccountConfigured = createSlackAccountConfiguredChecker(false);
+const isSlackSetupAccountConfigured = createSlackAccountConfiguredChecker(true);
+//#endregion
+export { isSlackSetupAccountConfigured as i, hasSlackAccountCredentialsFromConfig as n, isSlackPluginAccountConfigured as r, hasSlackAccountCredentials as t };

package/dist/.setup/{account-inspect-Cs-7DXXW.mjs → account-inspect-D58VVDjk.mjs}

@@ -1,31 +1,24 @@
-import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.mjs";
-import { a as mergeSlackAccountConfig, o as resolveDefaultSlackAccountId } from "./accounts-CDgkV7Cm.mjs";
+import { t as hasSlackAccountCredentials } from "./account-configured-zcR9TJJN.mjs";
+import { a as mergeSlackAccountConfig, g as buildSlackAccountSurfaceFields, o as resolveDefaultSlackAccountId } from "./accounts-BMg9YLIv.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";
 //#region extensions/slack/src/account-inspect.ts
-function inspectSlackToken(value) {
+function inspectSlackToken(value, envToken) {
 	const token = normalizeSecretInputString(value);
-	if (token) return {
+	if (token || hasConfiguredSecretInput(value)) return {
 		token,
 		source: "config",
-		status: "available"
-	};
-	if (hasConfiguredSecretInput(value)) return {
-		source: "config",
-		status: "configured_unavailable"
-	};
-	return {
-		source: "none",
-		status: "missing"
+		status: token ? "available" : "configured_unavailable"
 	};
-}
-function resolveInspectedSlackToken(configured, envToken) {
-	return configured.status === "missing" && envToken ? {
+	return envToken ? {
 		token: envToken,
 		source: "env",
 		status: "available"
-	} : configured;
+	} : {
+		source: "none",
+		status: "missing"
+	};
 }
 function inspectSlackAccount(params) {
 	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultSlackAccountId(params.cfg));
@@ -36,16 +29,13 @@ function inspectSlackAccount(params) {
 	const identity = merged.postAs ?? "bot";
 	const isHttpMode = mode === "http";
 	const isSocketMode = mode === "socket";
-	const configBot = inspectSlackToken(merged.botToken);
-	const configApp = inspectSlackToken(isSocketMode ? merged.appToken : void 0);
-	const configSigningSecret = inspectSlackToken(merged.signingSecret);
-	const configUser = inspectSlackToken(merged.userToken);
 	const envBot = allowEnv ? normalizeSecretInputString(params.envBotToken ?? process.env.SLACK_BOT_TOKEN) : void 0;
 	const envApp = allowEnv && isSocketMode ? normalizeSecretInputString(params.envAppToken ?? process.env.SLACK_APP_TOKEN) : void 0;
 	const envUser = allowEnv ? normalizeSecretInputString(params.envUserToken ?? process.env.SLACK_USER_TOKEN) : void 0;
-	const botCredential = resolveInspectedSlackToken(configBot, envBot);
-	const appCredential = resolveInspectedSlackToken(configApp, envApp);
-	const userCredential = resolveInspectedSlackToken(configUser, envUser);
+	const botCredential = inspectSlackToken(merged.botToken, envBot);
+	const appCredential = inspectSlackToken(isSocketMode ? merged.appToken : void 0, envApp);
+	const configSigningSecret = inspectSlackToken(merged.signingSecret);
+	const userCredential = inspectSlackToken(merged.userToken, envUser);
 	return {
 		accountId,
 		enabled,
@@ -70,17 +60,7 @@ function inspectSlackAccount(params) {
 			appTokenConfigured: appCredential.status !== "missing"
 		}),
 		config: merged,
-		groupPolicy: merged.groupPolicy,
-		textChunkLimit: merged.textChunkLimit,
-		mediaMaxMb: merged.mediaMaxMb,
-		reactionNotifications: merged.reactionNotifications,
-		reactionAllowlist: merged.reactionAllowlist,
-		replyToMode: merged.replyToMode,
-		replyToModeByChatType: merged.replyToModeByChatType,
-		actions: merged.actions,
-		slashCommand: merged.slashCommand,
-		dm: merged.dm,
-		channels: merged.channels
+		...buildSlackAccountSurfaceFields(merged)
 	};
 }
 //#endregion

package/dist/.setup/{accounts-CDgkV7Cm.mjs → accounts-BMg9YLIv.mjs}

@@ -1,11 +1,28 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { t as hasSlackAccountCredentials } from "./account-configured-sUohAxZr.mjs";
-import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, hasConfiguredAccountValue, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { n as hasSlackAccountCredentialsFromConfig } from "./account-configured-zcR9TJJN.mjs";
+import { DEFAULT_ACCOUNT_ID, createAccountListHelpers, normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { 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/account-surface-fields.ts
+function buildSlackAccountSurfaceFields(config) {
+	return {
+		groupPolicy: config.groupPolicy,
+		textChunkLimit: config.textChunkLimit,
+		mediaMaxMb: config.mediaMaxMb,
+		reactionNotifications: config.reactionNotifications,
+		reactionAllowlist: config.reactionAllowlist,
+		replyToMode: config.replyToMode,
+		replyToModeByChatType: config.replyToModeByChatType,
+		actions: config.actions,
+		slashCommand: config.slashCommand,
+		dm: config.dm,
+		channels: config.channels
+	};
+}
+//#endregion
 //#region extensions/slack/src/token.ts
 function formatSlackBotTokenIdentityWarning(params) {
 	const userId = params.auth.user_id?.trim();
@@ -14,24 +31,15 @@ function formatSlackBotTokenIdentityWarning(params) {
 	const accountId = params.accountId?.trim() || "default";
 	return `Slack auth.test identified account "${accountId}" as user ${userId} without bot_id. ${accountId === "default" ? "channels.slack.botToken, channels.slack.accounts.default.botToken, or SLACK_BOT_TOKEN" : `channels.slack.accounts.${accountId}.botToken`} appears to contain a user token; replace it with a Bot User OAuth Token. Until replaced, explicit bot-mention detection is disabled and required-mention channels fail closed.`;
 }
-function resolveSlackBotToken(raw, path = "channels.slack.botToken") {
-	return normalizeResolvedSecretInputString({
-		value: raw,
-		path
-	});
-}
-function resolveSlackAppToken(raw, path = "channels.slack.appToken") {
-	return normalizeResolvedSecretInputString({
-		value: raw,
-		path
-	});
-}
-function resolveSlackUserToken(raw, path = "channels.slack.userToken") {
-	return normalizeResolvedSecretInputString({
+function createSlackTokenResolver(defaultPath) {
+	return (raw, path = defaultPath) => normalizeResolvedSecretInputString({
 		value: raw,
 		path
 	});
 }
+const resolveSlackBotToken = createSlackTokenResolver("channels.slack.botToken");
+const resolveSlackAppToken = createSlackTokenResolver("channels.slack.appToken");
+const resolveSlackUserToken = createSlackTokenResolver("channels.slack.userToken");
 //#endregion
 //#region extensions/slack/src/account-reply-mode.ts
 function resolveSlackReplyToMode(account, chatType) {
@@ -62,13 +70,7 @@ function resolveSlackOperationToken(account, operation) {
 	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)
-	});
+	return hasSlackAccountCredentialsFromConfig(cfg.channels?.slack, process.env);
 }
 const { listAccountIds, resolveDefaultAccountId, resolveAccountConfig: resolveMergedSlackAccountConfig } = createAccountListHelpers("slack", {
 	nestedObjectKeys: [
@@ -85,26 +87,25 @@ function resolveSlackAccountConfig(cfg, accountId) {
 }
 function mergeSlackStreamingConfig(baseConfig, accountConfig) {
 	if (!baseConfig || !accountConfig) return accountConfig ?? baseConfig;
-	return {
+	const merged = {
 		...baseConfig,
-		...accountConfig,
-		...baseConfig.preview || accountConfig.preview ? { preview: {
-			...baseConfig.preview,
-			...accountConfig.preview
-		} } : {},
-		...baseConfig.progress || accountConfig.progress ? { progress: {
-			...baseConfig.progress,
-			...accountConfig.progress
-		} } : {},
-		...baseConfig.block || accountConfig.block ? { block: {
-			...baseConfig.block,
-			...accountConfig.block,
-			...baseConfig.block?.coalesce || accountConfig.block?.coalesce ? { coalesce: {
-				...baseConfig.block?.coalesce,
-				...accountConfig.block?.coalesce
-			} } : {}
-		} } : {}
+		...accountConfig
+	};
+	for (const key of [
+		"preview",
+		"progress",
+		"block"
+	]) if (baseConfig[key] || accountConfig[key]) merged[key] = {
+		...baseConfig[key],
+		...accountConfig[key]
+	};
+	const baseCoalesce = baseConfig.block?.coalesce;
+	const accountCoalesce = accountConfig.block?.coalesce;
+	if (merged.block && (baseCoalesce || accountCoalesce)) merged.block.coalesce = {
+		...baseCoalesce,
+		...accountCoalesce
 	};
+	return merged;
 }
 function mergeSlackAccountConfig(cfg, accountId) {
 	const accountConfig = resolveSlackAccountConfig(cfg, accountId);
@@ -175,17 +176,7 @@ function resolveSlackAccount(params) {
 		appTokenSource,
 		userTokenSource,
 		config: merged,
-		groupPolicy: merged.groupPolicy,
-		textChunkLimit: merged.textChunkLimit,
-		mediaMaxMb: merged.mediaMaxMb,
-		reactionNotifications: merged.reactionNotifications,
-		reactionAllowlist: merged.reactionAllowlist,
-		replyToMode: merged.replyToMode,
-		replyToModeByChatType: merged.replyToModeByChatType,
-		actions: merged.actions,
-		slashCommand: merged.slashCommand,
-		dm: merged.dm,
-		channels: merged.channels
+		...buildSlackAccountSurfaceFields(merged)
 	};
 }
 function listEnabledSlackAccounts(cfg) {
@@ -195,4 +186,4 @@ function listEnabledSlackAccounts(cfg) {
 	})).filter((account) => account.enabled);
 }
 //#endregion
-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 };
+export { mergeSlackAccountConfig as a, resolveSlackAccountAllowFrom as c, resolveSlackOperationToken as d, resolveSlackReplyToMode as f, buildSlackAccountSurfaceFields as g, 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-DJ1daRAZ.mjs → action-runtime-BiRZNsIG.mjs}

@@ -1,7 +1,7 @@
 import { a as parseSlackTarget, n as formatSlackTarget, o as resolveSlackChannelId } from "./target-parsing-FFE26kOV.mjs";
 import { t as slackContextTargetsMatch } from "./targets-C6LZQL1Q.mjs";
-import { At as getSlackInstallationKind, Bt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, Vt as resolveSlackAutoThreadId, f as assertSlackDetachedTargetAllowed, mt as parseSlackBlocksInput, r as buildSlackChannelIdCandidates, v as hasSlackNativeDataBlock } from "./session-status-D46GHwOV.mjs";
-import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-KKTqEiDv.mjs";
+import { Bt as resolveSlackAutoThreadId, f as assertSlackDetachedTargetAllowed, kt as getSlackInstallationKind, pt as parseSlackBlocksInput, r as buildSlackChannelIdCandidates, v as hasSlackNativeDataBlock, zt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT } from "./session-status-CcXe10zN.mjs";
+import { n as resolveSlackChannelConfig, t as isSlackChannelAllowedByPolicy } from "./policy-BaY9_eh1.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";
@@ -27,10 +27,13 @@ const pinActions = /* @__PURE__ */ new Set([
 	"listPins"
 ]);
 const SLACK_REACTION_RESULT_LIMIT = 100;
-const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-DDoAJnrH.mjs").then((n) => n.t));
+function readSlackResultLimit(params) {
+	return Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
+}
+const loadSlackActionsRuntime = createLazyRuntimeModule(() => import("./actions-KGKwTAKO.mjs").then((n) => n.t));
 const bindSlackAction = createLazyRuntimeMethodBinder(loadSlackActionsRuntime);
-const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts-CDgkV7Cm.mjs").then((n) => n.t));
-const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-B9zYYzBU.mjs").then((n) => n.t));
+const loadSlackAccountsRuntime = createLazyRuntimeModule(() => import("./accounts-BMg9YLIv.mjs").then((n) => n.t));
+const loadSlackChannelTypeRuntime = createLazyRuntimeModule(() => import("./channel-type-NjX2SwvS.mjs").then((n) => n.t));
 const bindSlackChannelType = createLazyRuntimeMethodBinder(loadSlackChannelTypeRuntime);
 const slackActionRuntime = {
 	deleteSlackMessage: bindSlackAction((runtime) => runtime.deleteSlackMessage),
@@ -95,15 +98,14 @@ async function isSlackDmTargetConfigured(params) {
 		...defaultTo ? [defaultTo] : []
 	].some((entry) => normalizeConfiguredSlackDmUserId(entry) === userId);
 }
-function isCurrentSlackReadTarget(params) {
-	const requesterAccountId = params.context?.requesterAccountId?.trim();
-	return Boolean(normalizeOptionalLowercaseString(params.context?.currentChannelProvider) === "slack" && requesterAccountId && normalizeAccountId(requesterAccountId) === normalizeAccountId(params.account.accountId) && params.context && slackContextTargetsMatch(params.target, params.context));
+function hasSlackRequesterAccount(account, context) {
+	const requesterAccountId = context?.requesterAccountId?.trim();
+	return Boolean(normalizeOptionalLowercaseString(context?.currentChannelProvider) === "slack" && requesterAccountId && normalizeAccountId(requesterAccountId) === normalizeAccountId(account.accountId));
 }
 function assertSlackMemberInfoAllowed(params) {
 	if (params.context?.conversationReadOrigin === "direct-operator") return;
-	const requesterAccountId = params.context?.requesterAccountId?.trim();
 	const requesterSenderId = normalizeOptionalLowercaseString(params.context?.requesterSenderId);
-	if (normalizeOptionalLowercaseString(params.context?.currentChannelProvider) !== "slack" || !requesterAccountId || normalizeAccountId(requesterAccountId) !== normalizeAccountId(params.account.accountId) || !requesterSenderId || requesterSenderId !== normalizeOptionalLowercaseString(params.userId)) throw new Error("Delegated Slack member info is limited to the current requester.");
+	if (!hasSlackRequesterAccount(params.account, params.context) || !requesterSenderId || requesterSenderId !== normalizeOptionalLowercaseString(params.userId)) throw new Error("Delegated Slack member info is limited to the current requester.");
 }
 function resolveSlackChannelReadPolicy(params) {
 	const channels = params.account.config.channels;
@@ -154,15 +156,12 @@ async function assertSlackReadTargetAllowed(params) {
 	const deny = () => {
 		throw new Error("Slack read target channel is not allowed.");
 	};
-	const currentConversation = isCurrentSlackReadTarget({
-		account: params.account,
-		target: formatSlackTarget({
-			teamId: params.teamId,
-			kind: "channel",
-			id: params.channelId
-		}),
-		context: params.context
+	const target = formatSlackTarget({
+		teamId: params.teamId,
+		kind: "channel",
+		id: params.channelId
 	});
+	const currentConversation = Boolean(hasSlackRequesterAccount(params.account, params.context) && params.context && slackContextTargetsMatch(target, params.context));
 	const directOperator = params.conversationReadOrigin === "direct-operator";
 	if (/^D/i.test(params.channelId)) {
 		if (!resolveSlackDmReadAllowed(params.account)) deny();
@@ -227,8 +226,7 @@ function isSlackGroupDmTargetConfigured(account, channelId, teamId) {
 	});
 }
 function resolveTrustedCurrentSlackTeamId(params) {
-	const requesterAccountId = params.context?.requesterAccountId?.trim();
-	if (normalizeOptionalLowercaseString(params.context?.currentChannelProvider) !== "slack" || !requesterAccountId || normalizeAccountId(requesterAccountId) !== normalizeAccountId(params.account.accountId)) return;
+	if (!hasSlackRequesterAccount(params.account, params.context)) return;
 	const matchingTeams = /* @__PURE__ */ new Map();
 	for (const raw of [params.context?.currentChannelId, params.context?.currentMessagingTarget]) {
 		if (!raw) continue;
@@ -327,7 +325,7 @@ async function handleSlackAction(params, cfg, context) {
 			});
 		}
 		await assertReadTargetAllowed(target);
-		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
+		const limit = readSlackResultLimit(params);
 		const reactions = await slackActionRuntime.listSlackReactions(channelId, messageId, readOpts);
 		return jsonResult({
 			ok: true,
@@ -600,7 +598,7 @@ async function handleSlackAction(params, cfg, context) {
 	}
 	if (action === "emojiList") {
 		if (!isActionEnabled("emojiList")) throw new Error("Slack emoji list is disabled.");
-		const limit = Math.min(readPositiveIntegerParam(params, "limit", { message: "limit must be a positive integer." }) ?? SLACK_REACTION_RESULT_LIMIT, SLACK_REACTION_RESULT_LIMIT);
+		const limit = readSlackResultLimit(params);
 		const teamId = resolveTrustedCurrentSlackTeamId({
 			account,
 			context

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

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

package/dist/.setup/{actions-DDoAJnrH.mjs → actions-KGKwTAKO.mjs}

@@ -1,9 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { h as resolveSlackBotToken, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-CDgkV7Cm.mjs";
+import { h as resolveSlackBotToken, o as resolveDefaultSlackAccountId, s as resolveSlackAccount } from "./accounts-BMg9YLIv.mjs";
 import { n as formatSlackTarget } from "./target-parsing-FFE26kOV.mjs";
-import { A as countSlackTextUtf8Bytes, Bt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT, C as buildSlackBlocksFallbackText, E as SLACK_EDIT_TEXT_MAX_BYTES, M as truncateSlackTextByUtf8Bytes, S as stripSlackNativeDataBlocks, T as renderSlackBlockFallbackText, Y as normalizeSlackOutboundText, f as assertSlackDetachedTargetAllowed, h as appendSlackNativeDataPlainTextFallback, ht as validateSlackBlocksArray, m as appendSlackNativeDataFallbackText, ot as escapeSlackMrkdwn, v as hasSlackNativeDataBlock, w as buildSlackCompleteBlocksFallbackText, y as isSlackInvalidBlocksError } from "./session-status-D46GHwOV.mjs";
-import { _ as getSlackWriteClient, h as createSlackWriteClient, u as createSlackLookupClient } from "./probe-BVlJ3dp0.mjs";
-import { m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-CgPI3Zj8.mjs";
+import { C as stripSlackNativeDataBlocks, D as SLACK_EDIT_TEXT_MAX_BYTES, E as renderSlackBlockFallbackText, N as truncateSlackTextByUtf8Bytes, T as buildSlackCompleteBlocksFallbackText, X as normalizeSlackOutboundText, at as escapeSlackMrkdwn, f as assertSlackDetachedTargetAllowed, h as appendSlackNativeDataPlainTextFallback, j as countSlackTextUtf8Bytes, m as appendSlackNativeDataFallbackText, mt as validateSlackBlocksArray, v as hasSlackNativeDataBlock, w as buildSlackBlocksFallbackText, y as isSlackInvalidBlocksError, zt as SLACK_PRIVATE_ACTION_DELIVERY_RESULT } from "./session-status-CcXe10zN.mjs";
+import { _ as getSlackWriteClient, h as createSlackWriteClient, u as createSlackLookupClient } from "./probe-CyX52GtD.mjs";
+import { m as buildSlackNativeDataDeliveryPlan, t as sendMessageSlack } from "./send-CLmsR42r.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
 import { asOptionalObjectRecord, asOptionalRecord, isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString, readNonBlankString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
@@ -157,13 +157,8 @@ const slackMediaLog = createSubsystemLogger("gateway/channels/slack").child("med
 //#region extensions/slack/src/monitor/slack-client-kind.ts
 /** Detects the isolated GovSlack API plane without consulting mutable config. */
 function isGovSlackClient(client) {
-	if (!client?.slackApiUrl) return false;
-	try {
-		const apiUrl = new URL(client.slackApiUrl);
-		return apiUrl.protocol === "https:" && !apiUrl.port && normalizeHostname(apiUrl.hostname) === "slack-gov.com";
-	} catch {
-		return false;
-	}
+	const apiUrl = client?.slackApiUrl ? URL.parse(client.slackApiUrl) : null;
+	return apiUrl?.protocol === "https:" && !apiUrl.port && normalizeHostname(apiUrl.hostname) === "slack-gov.com";
 }
 //#endregion
 //#region extensions/slack/src/monitor/media.ts
@@ -183,12 +178,8 @@ function isSlackHostname(hostname, govSlack) {
 	].some((suffix) => normalized === suffix || normalized.endsWith(`.${suffix}`));
 }
 function assertSlackFileUrl(rawUrl, govSlack) {
-	let parsed;
-	try {
-		parsed = new URL(rawUrl);
-	} catch {
-		throw new Error(`Invalid Slack file URL: ${rawUrl}`);
-	}
+	const parsed = URL.parse(rawUrl);
+	if (!parsed) throw new Error(`Invalid Slack file URL: ${rawUrl}`);
 	if (parsed.protocol !== "https:") throw new Error(`Refusing Slack file URL with non-HTTPS protocol: ${parsed.protocol}`);
 	if (!isSlackHostname(parsed.hostname, govSlack)) throw new Error(`Refusing to send Slack token to non-Slack host "${parsed.hostname}" (url: ${rawUrl})`);
 	return parsed;
@@ -362,10 +353,6 @@ function resolveForwardedAttachmentImageUrl(attachment, govSlack) {
 		return null;
 	}
 }
-/**
-* Downloads all files attached to a Slack message and returns them as an array.
-* Returns `null` when no files could be downloaded.
-*/
 async function resolveSlackMedia(params) {
 	const assertCurrent = captureSlackMediaReadGuard(params);
 	const govSlack = isGovSlackClient(params.client);
@@ -412,25 +399,28 @@ async function resolveSlackMedia(params) {
 	const resolved = results.filter((result) => result !== null);
 	return resolved.length > 0 ? resolved : null;
 }
-/** Extracts text and media from forwarded-message attachments. Returns null when empty. */
 async function resolveSlackAttachmentContent(params) {
 	const forwardedAttachments = (params.attachments ?? []).filter((attachment) => attachment.is_share === true).slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
 	const candidates = [...params.files ?? [], ...forwardedAttachments.flatMap((attachment) => attachment.files ?? [])];
 	if (forwardedAttachments.length === 0 && candidates.length === 0) return null;
-	const fileIds = /* @__PURE__ */ new Set();
+	const fileGroups = /* @__PURE__ */ new Map();
 	const allFiles = candidates.filter((file) => {
 		const fileId = normalizeOptionalString(file.id);
 		if (!fileId) return true;
-		if (fileIds.has(fileId)) return false;
-		fileIds.add(fileId);
+		const group = fileGroups.get(fileId);
+		if (group) {
+			group.push(file);
+			return false;
+		}
+		fileGroups.set(fileId, [file]);
 		return true;
 	}).map((file, index) => {
 		if (index >= 8) return file;
-		const fileId = normalizeOptionalString(file.id);
-		const preloaded = fileId && candidates.find((candidate) => normalizeOptionalString(candidate.id) === fileId && params.preloadedMedia?.has(candidate));
+		const group = fileGroups.get(normalizeOptionalString(file.id) ?? "");
+		const preloaded = group?.find((candidate) => params.preloadedMedia?.has(candidate));
 		if (preloaded) return preloaded;
-		if (!fileId || file.url_private_download || file.url_private) return file;
-		const downloadable = candidates.find((candidate) => normalizeOptionalString(candidate.id) === fileId && (candidate.url_private_download || candidate.url_private));
+		if (!group || file.url_private_download || file.url_private) return file;
+		const downloadable = group.find((candidate) => candidate.url_private_download || candidate.url_private);
 		return downloadable ? Object.assign({}, file, downloadable) : file;
 	});
 	const pendingFiles = new Map(allFiles.slice(0, 8).map((file) => [normalizeOptionalString(file.id) ?? file, file]));
@@ -708,13 +698,16 @@ async function editSlackMessage(channelId, messageId, content, opts = {}) {
 	});
 	await editSlackRenderedMessage(channelId, messageId, normalizeSlackOutboundText(content, { tableMode }), opts);
 }
+function slackNativeEditLimitError(options) {
+	return new Error(`Slack native chart or table fallback exceeds the ${String(SLACK_EDIT_TEXT_MAX_BYTES)}-byte edit limit. Send a new message instead.`, options);
+}
 async function editSlackRenderedMessage(channelId, messageId, content, opts = {}) {
 	const client = await getClient(opts, "write");
 	const blocks = opts.blocks == null ? void 0 : validateSlackBlocksArray(opts.blocks);
 	const editText = buildSlackEditTextPayload(content, blocks);
 	const hasNativeData = hasSlackNativeDataBlock(blocks);
 	const nativeFallbackText = hasNativeData ? appendSlackNativeDataFallbackText(editText, blocks) : editText;
-	if (hasNativeData && countSlackTextUtf8Bytes(nativeFallbackText) > 4e3) throw new Error(`Slack native chart or table fallback exceeds the ${String(SLACK_EDIT_TEXT_MAX_BYTES)}-byte edit limit. Send a new message instead.`);
+	if (hasNativeData && countSlackTextUtf8Bytes(nativeFallbackText) > 4e3) throw slackNativeEditLimitError();
 	const update = {
 		channel: channelId,
 		ts: messageId,
@@ -736,9 +729,9 @@ async function editSlackRenderedMessage(channelId, messageId, content, opts = {}
 		});
 		if (fallbackPlan.fallbackMessages.length !== 1) throw new Error("Slack native chart or table edit fallback requires multiple messages. Send a new message instead.", { cause: error });
 		const fallback = fallbackPlan.fallbackMessages[0];
-		if (!fallback || countSlackTextUtf8Bytes(fallback.text) > 4e3) throw new Error(`Slack native chart or table fallback exceeds the ${String(SLACK_EDIT_TEXT_MAX_BYTES)}-byte edit limit. Send a new message instead.`, { cause: error });
+		if (!fallback || countSlackTextUtf8Bytes(fallback.text) > 4e3) throw slackNativeEditLimitError({ cause: error });
 		const fallbackText = fallback.blocks ? escapeSlackMrkdwn(fallback.text) : truncateSlackTextByUtf8Bytes(appendSlackNativeDataFallbackText(editText, blocks), SLACK_EDIT_TEXT_MAX_BYTES);
-		if (countSlackTextUtf8Bytes(fallbackText) > 4e3) throw new Error(`Slack native chart or table fallback exceeds the ${String(SLACK_EDIT_TEXT_MAX_BYTES)}-byte edit limit. Send a new message instead.`, { cause: error });
+		if (countSlackTextUtf8Bytes(fallbackText) > 4e3) throw slackNativeEditLimitError({ cause: error });
 		await client.chat.update({
 			channel: channelId,
 			ts: messageId,
@@ -793,18 +786,16 @@ async function getSlackMemberInfo(userId, opts = {}) {
 async function listSlackEmojis(opts = {}) {
 	return await (await getClient(opts)).emoji.list();
 }
-async function pinSlackMessage(channelId, messageId, opts = {}) {
-	await (await getClient(opts, "write")).pins.add({
-		channel: channelId,
-		timestamp: messageId
-	});
-}
-async function unpinSlackMessage(channelId, messageId, opts = {}) {
-	await (await getClient(opts, "write")).pins.remove({
-		channel: channelId,
-		timestamp: messageId
-	});
+function createSlackPinUpdater(method) {
+	return async (channelId, messageId, opts = {}) => {
+		await (await getClient(opts, "write")).pins[method]({
+			channel: channelId,
+			timestamp: messageId
+		});
+	};
 }
+const pinSlackMessage = createSlackPinUpdater("add");
+const unpinSlackMessage = createSlackPinUpdater("remove");
 async function listSlackPins(channelId, opts = {}) {
 	return (await (await getClient(opts)).pins.list({ channel: channelId })).items ?? [];
 }