@openclaw/slack 2026.7.2-beta.2 → 2026.7.2-beta.3

package/dist/{relay-source-DMmgtvg4.js → relay-source-Ea_P9VcO.js}

@@ -1,4 +1,4 @@
-import { c as formatUnknownError, s as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-CmeoUiIM.js";
+import { c as formatUnknownError, s as SLACK_SOCKET_RECONNECT_POLICY } from "./provider-B-HVL5ZE.js";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { computeBackoff, sleepWithAbort, warn } from "openclaw/plugin-sdk/runtime-env";
 import { Buffer } from "node:buffer";
@@ -27,7 +27,7 @@ async function monitorSlackRelaySource(params) {
 			params.runtime.log?.(`slack relay mode connected gateway_id:${params.config.gatewayId}`);
 			await runRelayWebSocket({
 				connection,
-				handleSlackMessage: params.handleSlackMessage,
+				acceptRelayEvent: params.acceptRelayEvent,
 				runtime: params.runtime,
 				abortSignal: params.abortSignal,
 				setStatus: params.setStatus,
@@ -90,7 +90,6 @@ function openRelayWebSocket(config, abortSignal) {
 }
 function runRelayWebSocket(params) {
 	const ws = params.connection;
-	const relayState = {};
 	let pending = Promise.resolve();
 	return new Promise((resolve, reject) => {
 		const cleanup = () => {
@@ -111,8 +110,7 @@ function runRelayWebSocket(params) {
 			pending = pending.then(() => handleRelayFrame({
 				ws,
 				data,
-				handleSlackMessage: params.handleSlackMessage,
-				relayState,
+				acceptRelayEvent: params.acceptRelayEvent,
 				setStatus: params.setStatus,
 				setIdentity: params.setIdentity
 			})).catch((err) => {
@@ -150,7 +148,6 @@ 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;
@@ -163,11 +160,9 @@ async function handleRelayFrame(params) {
 		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 } : {}
+	await params.acceptRelayEvent({
+		deliveryId: event.deliveryId,
+		message: event.message
 	});
 	sendRelayAck(params.ws, event.deliveryId);
 }

package/dist/{replies-CJJCp6qz.js → replies-B4bOdrYb.js}

@@ -1,6 +1,6 @@
-import { A as buildSlackBlocksFallbackText, I as SLACK_TEXT_LIMIT, O as markdownToSlackMrkdwnChunks, S as buildSlackNativeDataAccessibilityText, T as isSlackInvalidBlocksError, g as resolveSlackReplyBlocks, h as resolveSlackReplyBlockResolution, p as hasSlackReplyStructuredContent, w as hasSlackNativeDataBlock } from "./group-policy-85UWiriS.js";
-import { l as buildSlackNativeDataDeliveryPlan, r as sendMessageSlack, u as chunkSlackTextAtHardLimit } from "./send-DYp8ca-l.js";
-import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-CmeoUiIM.js";
+import { C as hasSlackNativeDataBlock, D as markdownToSlackMrkdwnChunks, F as SLACK_TEXT_LIMIT, f as hasSlackReplyStructuredContent, h as resolveSlackReplyBlocks, k as buildSlackBlocksFallbackText, m as resolveSlackReplyBlockResolution, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText } from "./group-policy-Bw-65m3V.js";
+import { d as chunkSlackTextAtHardLimit, r as sendMessageSlack, u as buildSlackNativeDataDeliveryPlan } from "./send-KuTDky7i.js";
+import { a as createSlackResponseUrlBudget, i as SlackResponseAlreadyReportedError } from "./provider-B-HVL5ZE.js";
 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";

package/dist/{resolve-channels-Rfts6POK.js → resolve-channels-KTc568SU.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as createSlackLookupClient } from "./client-WIPAS3Yr.js";
+import { a as createSlackLookupClient } from "./probe-Borhn9PQ.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-DSmTg0su.js";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";

package/dist/{resolve-users-y6wAxR8E.js → resolve-users-DeGJf1yp.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { n as createSlackLookupClient } from "./client-WIPAS3Yr.js";
+import { a as createSlackLookupClient } from "./probe-Borhn9PQ.js";
 import { t as collectSlackCursorPages } from "./cursor-pages-DSmTg0su.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";

package/dist/{runtime-api-BGDyOt1D.js → runtime-api-BFfNpzDe.js}

@@ -1,5 +1,5 @@
 import "./target-parsing-N6lHogYZ.js";
-import "./client-WIPAS3Yr.js";
+import "./probe-Borhn9PQ.js";
 import "./config-api-Df9a1B8C.js";
 import "openclaw/plugin-sdk/account-id";
 import { createActionGate as createActionGate$1, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
 import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
-import { a as resolveSlackAccount, f as resolveSlackAppToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, p as resolveSlackBotToken, t as listEnabledSlackAccounts } from "./accounts-BOJJiHSr.js";
-import { n as resolveSlackGroupRequireMention, r as resolveSlackGroupToolPolicy } from "./group-policy-85UWiriS.js";
+import { a as resolveSlackAccount, f as resolveSlackAppToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, p as resolveSlackBotToken, t as listEnabledSlackAccounts } from "./accounts-DQEbYKh9.js";
+import { n as resolveSlackGroupRequireMention, r as resolveSlackGroupToolPolicy } from "./group-policy-Bw-65m3V.js";
+import { t as probeSlack } from "./probe-Borhn9PQ.js";
 import { r as setSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-BZiuSTIq.js";
-import { r as sendMessageSlack } from "./send-DYp8ca-l.js";
-import { t as probeSlack } from "./probe-CN0ssfLN.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-Rfts6POK.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-y6wAxR8E.js";
-import { t as monitorSlackProvider } from "./provider-CmeoUiIM.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-Cee2ih0s.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-D_yZhjgp.js";
-import "./monitor-CalGciTs.js";
+import { a as listSlackEmojis, c as pinSlackMessage, d as removeOwnSlackReactions, f as removeSlackReaction, h as unpinSlackMessage, i as getSlackMemberInfo, l as reactSlackMessage, m as sendSlackMessage, o as listSlackPins, r as editSlackMessage, s as listSlackReactions, t as deleteSlackMessage, u as readSlackMessages } from "./actions-CF0tUY5q.js";
+import { r as sendMessageSlack } from "./send-KuTDky7i.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-KTc568SU.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-DeGJf1yp.js";
+import { t as monitorSlackProvider } from "./provider-B-HVL5ZE.js";
+import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-DqkRwO3Z.js";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-CzUIB7th.js";
+import "./monitor-CNFeF30h.js";
 export { deleteSlackMessage, editSlackMessage, getSlackMemberInfo, handleSlackAction, listEnabledSlackAccounts, listSlackAccountIds, listSlackDirectoryGroupsLive, listSlackDirectoryPeersLive, listSlackEmojis, listSlackPins, listSlackReactions, monitorSlackProvider, pinSlackMessage, probeSlack, reactSlackMessage, readSlackMessages, registerSlackPluginHttpRoutes, removeOwnSlackReactions, removeSlackReaction, resolveDefaultSlackAccountId, resolveSlackAccount, resolveSlackAppToken, resolveSlackBotToken, resolveSlackChannelAllowlist, resolveSlackGroupRequireMention, resolveSlackGroupToolPolicy, resolveSlackUserAllowlist, sendMessageSlack, sendSlackMessage, setSlackRuntime, slackActionRuntime, unpinSlackMessage };

package/dist/{scopes-CuxNQZ6v.js → scopes-lx08L56K.js}

@@ -1,5 +1,4 @@
-import { i as formatSlackError } from "./group-policy-85UWiriS.js";
-import { a as createSlackWebClient } from "./client-WIPAS3Yr.js";
+import { c as createSlackWebClient, r as formatSlackError } from "./probe-Borhn9PQ.js";
 import { isRecord, normalizeOptionalString, normalizeStringEntries, sortUniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/slack/src/scopes.ts
 function collectScopes(value, into) {

package/dist/{secret-contract-CMohXFWS.js → secret-contract-DxmvbxBF.js}

@@ -73,6 +73,7 @@ function collectRuntimeConfigAssignments(params) {
 		defaults: params.defaults,
 		context: params.context,
 		topLevelActive: surface.channelEnabled && (!surface.hasExplicitAccounts && baseMode === "relay" || surface.accounts.some(({ account, enabled }) => enabled && resolveAccountMode(account) === "relay" && !hasNestedAuthTokenOverride(account))),
+		topLevelInheritedAccountActive: ({ account, enabled }) => enabled && resolveAccountMode(account) === "relay" && !hasNestedAuthTokenOverride(account),
 		topInactiveReason: "no enabled Slack relay-mode surface inherits this top-level relay authToken.",
 		accountActive: ({ account, enabled }) => enabled && resolveAccountMode(account) === "relay",
 		accountInactiveReason: "Slack account is disabled or not running in relay mode."

package/dist/secret-contract-api.js

@@ -1,2 +1,2 @@
-import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-CMohXFWS.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-DxmvbxBF.js";
 export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/{send-DYp8ca-l.js → send-KuTDky7i.js}

@@ -1,10 +1,10 @@
-import { a as resolveSlackAccount, l as resolveSlackOperationToken, p as resolveSlackBotToken } from "./accounts-BOJJiHSr.js";
+import { a as resolveSlackAccount, l as resolveSlackOperationToken } from "./accounts-DQEbYKh9.js";
 import { i as parseSlackTarget, t as canonicalizeSlackApiTargetId } from "./target-parsing-N6lHogYZ.js";
-import { B as truncateSlackText, C as createSlackNativeDataBaseTextConsumer, D as chunkSlackMrkdwnText, E as stripSlackNativeDataBlocks, F as SLACK_MESSAGE_TEXT_HARD_LIMIT, I as SLACK_TEXT_LIMIT, M as renderSlackBlockFallbackText, O as markdownToSlackMrkdwnChunks, Q as validateSlackBlocksArray, S as buildSlackNativeDataAccessibilityText, T as isSlackInvalidBlocksError, a as assertSlackDirectSendAllowed, j as buildSlackCompleteBlocksFallbackText, w as hasSlackNativeDataBlock, x as appendSlackNativeDataPlainTextFallback } from "./group-policy-85UWiriS.js";
+import { A as buildSlackCompleteBlocksFallbackText, C as hasSlackNativeDataBlock, D as markdownToSlackMrkdwnChunks, E as chunkSlackMrkdwnText, F as SLACK_TEXT_LIMIT, P as SLACK_MESSAGE_TEXT_HARD_LIMIT, S as createSlackNativeDataBaseTextConsumer, T as stripSlackNativeDataBlocks, b as appendSlackNativeDataPlainTextFallback, et as validateSlackBlocksArray, i as assertSlackDirectSendAllowed, j as renderSlackBlockFallbackText, w as isSlackInvalidBlocksError, x as buildSlackNativeDataAccessibilityText, z as truncateSlackText } from "./group-policy-Bw-65m3V.js";
 import { n as resolveSlackThreadTsValue, t as normalizeSlackThreadTsCandidate } from "./thread-ts-DUGhaYKq.js";
-import { a as createSlackWebClient, c as getSlackWriteClient, i as createSlackTokenCacheKey } from "./client-WIPAS3Yr.js";
+import { c as createSlackWebClient, d as getSlackWriteClient, s as createSlackTokenCacheKey } from "./probe-Borhn9PQ.js";
 import { t as getOptionalSlackRuntime } from "./runtime-JSVZSWAj.js";
-import { i as loadOutboundMediaFromUrl } from "./runtime-api-BGDyOt1D.js";
+import { i as loadOutboundMediaFromUrl } from "./runtime-api-BFfNpzDe.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
@@ -389,6 +389,7 @@ async function uploadSlackFile(params) {
 				...contentType ? { headers: { "Content-Type": contentType } } : {},
 				body: new Uint8Array(buffer)
 			},
+			timeoutMs: SLACK_UPLOAD_POST_TIMEOUT_MS,
 			signal: uploadTimeoutSignal,
 			requireHttps: uploadTransport.requireHttps,
 			policy: uploadTransport.policy,
@@ -545,6 +546,22 @@ function resolvePostedMessageThreadTs(response) {
 	const threadTs = response.message?.thread_ts;
 	return typeof threadTs === "string" ? normalizeSlackThreadTsCandidate(threadTs) : void 0;
 }
+async function updateMessageSlack(params) {
+	const account = resolveSlackAccount({
+		cfg: requireRuntimeConfig(params.cfg, "Slack update"),
+		accountId: params.accountId
+	});
+	await getSlackWriteClient(resolveToken({
+		accountId: account.accountId,
+		fallbackToken: account.botToken,
+		fallbackSource: account.botTokenSource
+	})).chat.update({
+		channel: params.channelId,
+		ts: params.messageTs,
+		text: truncateSlackText(params.text, SLACK_TEXT_LIMIT),
+		blocks: validateSlackBlocksArray(params.blocks)
+	});
+}
 function createSlackSendReceipt(params) {
 	return createMessageReceiptFromOutboundResults({
 		results: params.platformMessageIds.map((messageId) => messageId.trim()).filter((messageId) => messageId && messageId !== "unknown" && messageId !== "suppressed").map((messageId) => {
@@ -560,12 +577,12 @@ function createSlackSendReceipt(params) {
 	});
 }
 function resolveToken(params) {
-	const explicit = resolveSlackBotToken(params.explicit);
+	const explicit = normalizeOptionalString(params.explicit);
 	if (explicit) return explicit;
-	const fallback = resolveSlackBotToken(params.fallbackToken);
+	const fallback = normalizeOptionalString(params.fallbackToken);
 	if (!fallback) {
-		logVerbose(`slack send: missing bot token for account=${params.accountId} explicit=${Boolean(params.explicit)} source=${params.fallbackSource ?? "unknown"}`);
-		throw new Error(`Slack bot token missing for account "${params.accountId}" (set channels.slack.accounts.${params.accountId}.botToken or SLACK_BOT_TOKEN for default).`);
+		logVerbose(`slack send: missing write token for account=${params.accountId} explicit=${Boolean(params.explicit)} source=${params.fallbackSource ?? "unknown"}`);
+		throw new Error(`Slack write token missing for account "${params.accountId}".`);
 	}
 	return fallback;
 }
@@ -969,8 +986,8 @@ async function sendMessageSlack(to, message, opts) {
 	const token = enterpriseDelivery ? SLACK_ENTERPRISE_LISTENER_QUEUE_CREDENTIAL : resolveToken({
 		explicit: opts.token,
 		accountId: account.accountId,
-		fallbackToken: account.botToken,
-		fallbackSource: account.botTokenSource
+		fallbackToken: resolveSlackOperationToken(account, "write"),
+		fallbackSource: account.identity === "user" ? account.userTokenSource : account.botTokenSource
 	});
 	const recipient = enterpriseDelivery ? parseEnterpriseEventRecipient(to) : parseRecipient(to);
 	const queueKey = createSlackSendQueueKey({
@@ -1263,4 +1280,4 @@ async function sendMessageSlackQueuedInner(params) {
 	};
 }
 //#endregion
-export { clearSlackThreadParticipationCache as a, recordSlackThreadParticipation as c, setSlackDefaultSendIdentity as i, buildSlackNativeDataDeliveryPlan as l, resolveSlackDmChannelId as n, hasSlackThreadParticipation as o, sendMessageSlack as r, hasSlackThreadParticipationWithPersistence as s, reconcileSlackUnknownSend as t, chunkSlackTextAtHardLimit as u };
+export { updateMessageSlack as a, hasSlackThreadParticipationWithPersistence as c, chunkSlackTextAtHardLimit as d, setSlackDefaultSendIdentity as i, recordSlackThreadParticipation as l, resolveSlackDmChannelId as n, clearSlackThreadParticipationCache as o, sendMessageSlack as r, hasSlackThreadParticipation as s, reconcileSlackUnknownSend as t, buildSlackNativeDataDeliveryPlan as u };

package/dist/send.runtime-CXyxws1D.js

@@ -0,0 +1,2 @@
+import { a as updateMessageSlack, n as resolveSlackDmChannelId, r as sendMessageSlack, t as reconcileSlackUnknownSend } from "./send-KuTDky7i.js";
+export { reconcileSlackUnknownSend, resolveSlackDmChannelId, sendMessageSlack, updateMessageSlack };

package/dist/{setup-core-CkwVLzFO.js → setup-core-CeiAVwQ3.js}

@@ -1,9 +1,8 @@
-import { a as resolveSlackAccount } from "./accounts-BOJJiHSr.js";
-import { t as inspectSlackAccount } from "./account-inspect-Di7ditqZ.js";
-import { t as isSlackPluginAccountConfigured } from "./account-configured-DzC407uv.js";
-import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input";
+import { t as inspectSlackAccount } from "./account-inspect-Bvbtu3iH.js";
+import { t as isSlackPluginAccountConfigured } from "./account-configured-BwfXBo_F.js";
+import { hasConfiguredSecretInput, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { DEFAULT_ACCOUNT_ID, createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createAllowlistSetupWizardProxy, createEnvPatchedAccountSetupAdapter, createLegacyCompatChannelDmPolicy, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, parseMentionOrPrefixedId, patchChannelConfigForAccount, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
+import { DEFAULT_ACCOUNT_ID, createAccountScopedAllowFromSection, createAccountScopedGroupAccessSection, createAllowlistSetupWizardProxy, createLegacyCompatChannelDmPolicy, createPatchedAccountSetupAdapter, createSetupTranslator, createStandardChannelSetupStatus, defineTokenCredential, parseMentionOrPrefixedId, patchChannelConfigForAccount, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup-runtime";
 import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 //#region extensions/slack/src/setup-shared.ts
@@ -119,8 +118,13 @@ function setSlackChannelAllowlist(cfg, accountId, channelKeys) {
 }
 function isSlackSetupAccountConfigured(account) {
 	if (account.config.mode === "relay") return isSlackPluginAccountConfigured(account);
+	const hasConfiguredUserToken = Boolean(account.userToken?.trim()) || hasConfiguredSecretInput(account.config.userToken);
 	const hasConfiguredBotToken = Boolean(account.botToken?.trim()) || hasConfiguredSecretInput(account.config.botToken);
 	const hasConfiguredAppToken = Boolean(account.appToken?.trim()) || hasConfiguredSecretInput(account.config.appToken);
+	if (account.identity === "user") {
+		const hasTransportCredential = account.config.mode === "http" ? hasConfiguredSecretInput(account.config.signingSecret) : hasConfiguredAppToken;
+		return hasConfiguredUserToken && hasTransportCredential;
+	}
 	return hasConfiguredBotToken && hasConfiguredAppToken;
 }
 function describeSlackSetupAccount(account) {
@@ -129,7 +133,11 @@ function describeSlackSetupAccount(account) {
 		configured: isSlackSetupAccountConfigured(account),
 		extra: {
 			botTokenSource: account.botTokenSource,
-			appTokenSource: account.appTokenSource
+			appTokenSource: account.appTokenSource,
+			...account.identity === "user" ? {
+				identity: account.identity,
+				userTokenSource: account.userTokenSource
+			} : {}
 		}
 	});
 }
@@ -144,8 +152,48 @@ function enableSlackAccount(cfg, accountId) {
 		patch: { enabled: true }
 	});
 }
+function setSlackSetupIdentity(params) {
+	const next = patchChannelConfigForAccount({
+		cfg: params.cfg,
+		channel: SLACK_CHANNEL,
+		accountId: params.accountId,
+		patch: params.identity === "user" ? { identity: "user" } : {}
+	});
+	if (params.identity === "user") return next;
+	const slack = next.channels?.slack;
+	if (!slack) return next;
+	if (params.accountId === DEFAULT_ACCOUNT_ID) {
+		const nextSlack = { ...slack };
+		delete nextSlack.identity;
+		return {
+			...next,
+			channels: {
+				...next.channels,
+				slack: nextSlack
+			}
+		};
+	}
+	const account = slack.accounts?.[params.accountId];
+	if (!account) return next;
+	const nextAccount = { ...account };
+	if (slack.identity === "user") nextAccount.identity = "bot";
+	else delete nextAccount.identity;
+	return {
+		...next,
+		channels: {
+			...next.channels,
+			slack: {
+				...slack,
+				accounts: {
+					...slack.accounts,
+					[params.accountId]: nextAccount
+				}
+			}
+		}
+	};
+}
 function hasSlackInteractiveRepliesConfig(cfg, accountId) {
-	const capabilities = resolveSlackAccount({
+	const capabilities = inspectSlackAccount({
 		cfg,
 		accountId
 	}).config.capabilities;
@@ -154,7 +202,7 @@ function hasSlackInteractiveRepliesConfig(cfg, accountId) {
 	return "interactiveReplies" in capabilities;
 }
 function setSlackInteractiveReplies(cfg, accountId, interactiveReplies) {
-	const capabilities = resolveSlackAccount({
+	const capabilities = inspectSlackAccount({
 		cfg,
 		accountId
 	}).config.capabilities;
@@ -175,16 +223,21 @@ function createSlackTokenCredential(params) {
 		providerHint: params.providerHint,
 		credentialLabel: params.credentialLabel,
 		preferredEnvVar: params.preferredEnvVar,
-		envPrompt: `${params.preferredEnvVar} detected. Use env var?`,
+		envPrompt: params.preferredEnvVar ? `${params.preferredEnvVar} detected. Use env var?` : "Use the configured Slack credential?",
 		keepPrompt: params.keepPrompt,
 		inputPrompt: params.inputPrompt,
-		allowEnv: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID,
-		resolveAccount: ({ cfg, accountId }) => resolveSlackAccount({
+		allowEnv: ({ accountId }) => Boolean(params.preferredEnvVar) && accountId === DEFAULT_ACCOUNT_ID,
+		resolveAccount: ({ cfg, accountId }) => inspectSlackAccount({
 			cfg,
 			accountId
 		}),
-		resolvedValue: (account) => normalizeOptionalString(params.inputKey === "botToken" ? account.botToken : account.appToken),
-		envValue: ({ accountId }) => accountId === DEFAULT_ACCOUNT_ID ? normalizeOptionalString(process.env[params.preferredEnvVar]) : void 0,
+		resolvedValue: (account) => {
+			if (params.inputKey === "botToken") return normalizeOptionalString(account.botToken);
+			if (params.inputKey === "appToken") return normalizeOptionalString(account.appToken);
+			if (params.inputKey === "userToken") return normalizeOptionalString(account.userToken);
+			return normalizeSecretInputString(account.config.signingSecret);
+		},
+		envValue: ({ accountId }) => params.preferredEnvVar && accountId === DEFAULT_ACCOUNT_ID ? normalizeOptionalString(process.env[params.preferredEnvVar]) : void 0,
 		patchAccount: ({ cfg, accountId, mode, patch }) => mode === "env" ? enableSlackAccount(cfg, accountId) : patchChannelConfigForAccount({
 			cfg,
 			channel: SLACK_CHANNEL,
@@ -195,19 +248,64 @@ function createSlackTokenCredential(params) {
 			}
 		}),
 		useEnv: { clearFields: [] },
-		set: {}
+		set: {},
+		shouldPrompt: params.shouldPrompt
 	});
 }
-const slackSetupAdapter = createEnvPatchedAccountSetupAdapter({
+function hasSlackSetupCredentials(params) {
+	if (params.identity !== "user") {
+		const { input } = params;
+		return Boolean(input.botToken && input.appToken);
+	}
+	if (params.mode === "http") return Boolean(params.input.userToken && params.input.signingSecret);
+	return params.mode === "socket" && Boolean(params.input.userToken && params.input.appToken);
+}
+const slackSetupAdapterBase = createPatchedAccountSetupAdapter({
 	channelKey: SLACK_CHANNEL,
-	defaultAccountOnlyEnvError: "Slack env tokens can only be used for the default account.",
-	missingCredentialError: "Slack requires --bot-token and --app-token (or --use-env).",
-	hasCredentials: (input) => Boolean(input.botToken && input.appToken),
+	validateInput: ({ cfg, accountId, input }) => {
+		if (input.useEnv && accountId !== DEFAULT_ACCOUNT_ID) return "Slack env tokens can only be used for the default account.";
+		const account = inspectSlackAccount({
+			cfg,
+			accountId
+		});
+		const identity = input.identity ?? account.config.identity ?? "bot";
+		const mode = input.mode ?? account.config.mode ?? "socket";
+		if (identity === "user" && mode === "relay") return "Slack user identity setup supports mode \"socket\" or \"http\", not \"relay\".";
+		if (input.useEnv) return identity === "user" ? "Slack user identity setup does not support --use-env; configure userToken and the transport credential explicitly." : null;
+		if (hasSlackSetupCredentials({
+			input,
+			identity,
+			mode
+		})) return null;
+		if (identity === "user") return mode === "http" ? "Slack user identity requires --user-token and --signing-secret." : "Slack user identity requires --user-token and --app-token.";
+		return "Slack requires --bot-token and --app-token (or --use-env).";
+	},
 	buildPatch: (input) => ({
+		...input.identity ? { identity: input.identity } : {},
+		...input.identity === "user" && input.mode ? { mode: input.mode } : {},
 		...input.botToken ? { botToken: input.botToken } : {},
-		...input.appToken ? { appToken: input.appToken } : {}
+		...input.appToken ? { appToken: input.appToken } : {},
+		...input.userToken ? { userToken: input.userToken } : {},
+		...input.signingSecret ? { signingSecret: input.signingSecret } : {}
 	})
 });
+const slackSetupAdapter = {
+	...slackSetupAdapterBase,
+	applyAccountConfig: ({ cfg, accountId, input }) => {
+		const identity = input.identity ?? inspectSlackAccount({
+			cfg,
+			accountId
+		}).config.identity;
+		return slackSetupAdapterBase.applyAccountConfig({
+			cfg,
+			accountId,
+			input: identity === "user" ? {
+				...input,
+				identity
+			} : input
+		});
+	}
+};
 function createSlackSetupWizardBase(handlers) {
 	const slackDmPolicy = createLegacyCompatChannelDmPolicy({
 		label: "Slack",
@@ -229,51 +327,118 @@ function createSlackSetupWizardBase(handlers) {
 				accountId
 			}).configured
 		}),
-		introNote: {
-			title: t("wizard.slack.socketModeTokensTitle"),
-			lines: buildSlackSetupLines(),
-			shouldShow: ({ cfg, accountId }) => !isSlackSetupAccountConfigured(resolveSlackAccount({
-				cfg,
-				accountId
-			}))
-		},
 		prepare: async ({ cfg, accountId, prompter }) => {
-			if (isSlackSetupAccountConfigured(resolveSlackAccount({
+			const currentAccount = inspectSlackAccount({
 				cfg,
 				accountId
-			}))) return;
-			const manifest = buildSlackManifest();
-			if (prompter.plain) await prompter.plain(manifest);
-			else await prompter.note(manifest, "Slack manifest JSON");
+			});
+			if (currentAccount.configured && currentAccount.config.identity !== "user") return { cfg };
+			const identity = await prompter.select({
+				message: "How should OpenClaw appear in Slack?",
+				options: [{
+					value: "bot",
+					label: "Slack bot",
+					hint: "Post as the Slack app (default)"
+				}, {
+					value: "user",
+					label: "Slack user",
+					hint: "Post as the authorizing human"
+				}],
+				initialValue: currentAccount.config.identity ?? "bot"
+			});
+			const next = setSlackSetupIdentity({
+				cfg,
+				accountId,
+				identity
+			});
+			if (currentAccount.configured && identity === currentAccount.config.identity) return { cfg: next };
+			if (identity === "user") {
+				if (currentAccount.config.mode === "relay") throw new Error("Slack user identity setup supports mode \"socket\" or \"http\", not \"relay\".");
+				await prompter.note([
+					"Use a Slack user OAuth token with the User Token Scopes listed in the Slack docs.",
+					"Subscribe the companion app under 'Subscribe to events on behalf of users' using the documented user events.",
+					"Socket Mode needs an app-level token; HTTP mode needs the app signing secret.",
+					"No bot token or bot user is required.",
+					`Docs: ${formatDocsLink("/channels/slack#user-identity-post-as-a-real-person", "channels/slack")}`
+				].join("\n"), "Slack user identity");
+			} else {
+				await prompter.note(buildSlackSetupLines().join("\n"), t("wizard.slack.socketModeTokensTitle"));
+				const manifest = buildSlackManifest();
+				if (prompter.plain) await prompter.plain(manifest);
+				else await prompter.note(manifest, "Slack manifest JSON");
+			}
+			return { cfg: next };
 		},
 		envShortcut: {
 			prompt: t("wizard.slack.envPrompt"),
 			preferredEnvVar: "SLACK_BOT_TOKEN",
-			isAvailable: ({ cfg, accountId }) => accountId === DEFAULT_ACCOUNT_ID && Boolean(process.env.SLACK_BOT_TOKEN?.trim()) && Boolean(process.env.SLACK_APP_TOKEN?.trim()) && !isSlackSetupAccountConfigured(resolveSlackAccount({
+			isAvailable: ({ cfg, accountId }) => accountId === DEFAULT_ACCOUNT_ID && (inspectSlackAccount({
 				cfg,
 				accountId
-			})),
+			}).config.identity ?? "bot") === "bot" && Boolean(process.env.SLACK_BOT_TOKEN?.trim()) && Boolean(process.env.SLACK_APP_TOKEN?.trim()) && !inspectSlackAccount({
+				cfg,
+				accountId
+			}).configured,
 			apply: ({ cfg, accountId }) => enableSlackAccount(cfg, accountId)
 		},
-		credentials: [createSlackTokenCredential({
-			inputKey: "botToken",
-			providerHint: "slack-bot",
-			credentialLabel: t("wizard.slack.botToken"),
-			preferredEnvVar: "SLACK_BOT_TOKEN",
-			keepPrompt: t("wizard.slack.botTokenKeep"),
-			inputPrompt: t("wizard.slack.botTokenInput")
-		}), createSlackTokenCredential({
-			inputKey: "appToken",
-			providerHint: "slack-app",
-			credentialLabel: t("wizard.slack.appToken"),
-			preferredEnvVar: "SLACK_APP_TOKEN",
-			keepPrompt: t("wizard.slack.appTokenKeep"),
-			inputPrompt: t("wizard.slack.appTokenInput")
-		})],
+		credentials: [
+			createSlackTokenCredential({
+				inputKey: "botToken",
+				providerHint: "slack-bot",
+				credentialLabel: t("wizard.slack.botToken"),
+				preferredEnvVar: "SLACK_BOT_TOKEN",
+				keepPrompt: t("wizard.slack.botTokenKeep"),
+				inputPrompt: t("wizard.slack.botTokenInput"),
+				shouldPrompt: ({ cfg, accountId }) => (inspectSlackAccount({
+					cfg,
+					accountId
+				}).config.identity ?? "bot") === "bot"
+			}),
+			createSlackTokenCredential({
+				inputKey: "userToken",
+				providerHint: "slack-user",
+				credentialLabel: "Slack user OAuth token",
+				preferredEnvVar: "SLACK_USER_TOKEN",
+				keepPrompt: "Slack user OAuth token already configured. Keep it?",
+				inputPrompt: "Enter Slack user OAuth token",
+				shouldPrompt: ({ cfg, accountId }) => inspectSlackAccount({
+					cfg,
+					accountId
+				}).config.identity === "user"
+			}),
+			createSlackTokenCredential({
+				inputKey: "appToken",
+				providerHint: "slack-app",
+				credentialLabel: t("wizard.slack.appToken"),
+				preferredEnvVar: "SLACK_APP_TOKEN",
+				keepPrompt: t("wizard.slack.appTokenKeep"),
+				inputPrompt: t("wizard.slack.appTokenInput"),
+				shouldPrompt: ({ cfg, accountId }) => {
+					const account = inspectSlackAccount({
+						cfg,
+						accountId
+					});
+					return (account.config.identity ?? "bot") === "bot" || (account.config.mode ?? "socket") === "socket";
+				}
+			}),
+			createSlackTokenCredential({
+				inputKey: "signingSecret",
+				providerHint: "slack-signing-secret",
+				credentialLabel: "Slack signing secret",
+				keepPrompt: "Slack signing secret already configured. Keep it?",
+				inputPrompt: "Enter Slack signing secret",
+				shouldPrompt: ({ cfg, accountId }) => {
+					const account = inspectSlackAccount({
+						cfg,
+						accountId
+					});
+					return account.config.identity === "user" && account.config.mode === "http";
+				}
+			})
+		],
 		dmPolicy: slackDmPolicy,
 		allowFrom: createAccountScopedAllowFromSection({
 			channel: SLACK_CHANNEL,
-			credentialInputKey: "botToken",
 			helpTitle: t("wizard.slack.allowlistTitle"),
 			helpLines: [
 				t("wizard.slack.allowlistIntro"),
@@ -299,15 +464,15 @@ function createSlackSetupWizardBase(handlers) {
 			channel: SLACK_CHANNEL,
 			label: t("wizard.slack.channelsLabel"),
 			placeholder: "#general, #private, C123",
-			currentPolicy: ({ cfg, accountId }) => resolveSlackAccount({
+			currentPolicy: ({ cfg, accountId }) => inspectSlackAccount({
 				cfg,
 				accountId
 			}).config.groupPolicy ?? "allowlist",
-			currentEntries: ({ cfg, accountId }) => Object.entries(resolveSlackAccount({
+			currentEntries: ({ cfg, accountId }) => Object.entries(inspectSlackAccount({
 				cfg,
 				accountId
 			}).config.channels ?? {}).filter(([, value]) => value?.enabled !== false).map(([key]) => key),
-			updatePrompt: ({ cfg, accountId }) => Boolean(resolveSlackAccount({
+			updatePrompt: ({ cfg, accountId }) => Boolean(inspectSlackAccount({
 				cfg,
 				accountId
 			}).config.channels),

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as slackSetupPlugin } from "./channel.setup-C-mLz50O.js";
+import { t as slackSetupPlugin } from "./channel.setup-CgkADtZg.js";
 export { slackSetupPlugin };