@openclaw/slack 2026.5.12-beta.7

package/dist/channel-api-B_nZwosg.js

@@ -0,0 +1,20 @@
+import "./target-parsing-CQmv-iSm.js";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
+import { PAIRING_APPROVED_MESSAGE, projectCredentialSnapshotFields, resolveConfiguredFromRequiredCredentialStatuses } from "openclaw/plugin-sdk/channel-status";
+//#region extensions/slack/src/channel-api.ts
+const SLACK_CHANNEL_META = {
+	id: "slack",
+	label: "Slack",
+	selectionLabel: "Slack",
+	docsPath: "/channels/slack",
+	docsLabel: "slack",
+	blurb: "supports bot + app tokens, channels, threads, and interactive replies.",
+	systemImage: "number.square",
+	markdownCapable: true
+};
+function getChatChannelMeta(id) {
+	if (id !== SLACK_CHANNEL_META.id) throw new Error(`Unsupported Slack channel meta lookup: ${id}`);
+	return SLACK_CHANNEL_META;
+}
+//#endregion
+export { resolveConfiguredFromRequiredCredentialStatuses as a, projectCredentialSnapshotFields as i, PAIRING_APPROVED_MESSAGE as n, getChatChannelMeta as r, DEFAULT_ACCOUNT_ID$1 as t };

package/dist/channel-config-api.js

@@ -0,0 +1,2 @@
+import { t as SlackChannelConfigSchema } from "./config-schema-D9B5LB_L.js";
+export { SlackChannelConfigSchema };

package/dist/channel-entry.js

@@ -0,0 +1,22 @@
+import { defineBundledChannelEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/slack/channel-entry.ts
+var channel_entry_default = defineBundledChannelEntry({
+	id: "slack",
+	name: "Slack",
+	description: "Slack channel plugin",
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./api.js",
+		exportName: "slackPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	},
+	runtime: {
+		specifier: "./runtime-setter-api.js",
+		exportName: "setSlackRuntime"
+	}
+});
+//#endregion
+export { channel_entry_default as default };

package/dist/channel-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as slackPlugin } from "./channel-DRjHBTDB.js";
+export { slackPlugin };

package/dist/channel.setup-Cayn7afd.js

@@ -0,0 +1,73 @@
+import { a as resolveSlackAccount, c as resolveSlackConfigAccessorAccount, i as resolveDefaultSlackAccountId, n as listSlackAccountIds } from "./accounts-ClAPP5ry.js";
+import { a as describeSlackSetupAccount, i as SLACK_CHANNEL, n as createSlackSetupWizardProxy, o as isSlackSetupAccountConfigured, r as slackSetupAdapter } from "./setup-core-B9NetDkM.js";
+import { t as SlackChannelConfigSchema } from "./config-schema-D9B5LB_L.js";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+//#region extensions/slack/src/channel.setup.ts
+const slackSetupWizard = createSlackSetupWizardProxy(async () => ({ slackSetupWizard: (await import("./setup-surface-D88QBVOW.js")).slackSetupWizard }));
+const slackSetupConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: SLACK_CHANNEL,
+	listAccountIds: listSlackAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveSlackAccount),
+	resolveAccessorAccount: resolveSlackConfigAccessorAccount,
+	defaultAccountId: resolveDefaultSlackAccountId,
+	clearBaseFields: [
+		"botToken",
+		"appToken",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+const slackSetupPlugin = {
+	id: SLACK_CHANNEL,
+	meta: {
+		id: SLACK_CHANNEL,
+		label: "Slack",
+		selectionLabel: "Slack (Socket Mode)",
+		detailLabel: "Slack Bot",
+		docsPath: "/channels/slack",
+		docsLabel: "slack",
+		blurb: "supported (Socket Mode).",
+		systemImage: "number",
+		markdownCapable: true,
+		preferSessionLookupForAnnounceTarget: true
+	},
+	setupWizard: slackSetupWizard,
+	capabilities: {
+		chatTypes: [
+			"direct",
+			"channel",
+			"thread"
+		],
+		reactions: true,
+		threads: true,
+		media: true,
+		nativeCommands: true
+	},
+	commands: {
+		nativeCommandsAutoEnabled: false,
+		nativeSkillsAutoEnabled: false,
+		resolveNativeCommandName: ({ commandKey, defaultName }) => commandKey === "status" ? "agentstatus" : defaultName
+	},
+	streaming: { blockStreamingCoalesceDefaults: {
+		minChars: 1500,
+		idleMs: 1e3
+	} },
+	reload: { configPrefixes: ["channels.slack"] },
+	configSchema: SlackChannelConfigSchema,
+	config: {
+		...slackSetupConfigAdapter,
+		hasConfiguredState: ({ env }) => [
+			"SLACK_APP_TOKEN",
+			"SLACK_BOT_TOKEN",
+			"SLACK_USER_TOKEN"
+		].some((key) => typeof env?.[key] === "string" && env[key]?.trim().length > 0),
+		isConfigured: (account) => isSlackSetupAccountConfigured(account),
+		describeAccount: (account) => describeSlackSetupAccount(account)
+	},
+	setup: slackSetupAdapter
+};
+//#endregion
+export { slackSetupPlugin as t };

package/dist/client-CPe4GmDR.js

@@ -0,0 +1,103 @@
+import { createHash } from "node:crypto";
+import { WebClient } from "@slack/web-api";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { resolveEnvHttpProxyUrl } from "openclaw/plugin-sdk/fetch-runtime";
+//#region extensions/slack/src/client-options.ts
+const SLACK_DEFAULT_RETRY_OPTIONS = {
+	retries: 2,
+	factor: 2,
+	minTimeout: 500,
+	maxTimeout: 3e3,
+	randomize: true
+};
+const SLACK_WRITE_RETRY_OPTIONS = { retries: 0 };
+/**
+* Check whether a hostname is excluded from proxying by `NO_PROXY` / `no_proxy`.
+* Supports comma-separated entries with optional leading dots (e.g. `.slack.com`).
+*/
+function isHostExcludedByNoProxy(hostname, env = process.env) {
+	const raw = env.no_proxy ?? env.NO_PROXY;
+	if (!raw) return false;
+	const entries = raw.split(/[,\s]+/).map((e) => e.trim().toLowerCase()).filter(Boolean);
+	const lower = hostname.toLowerCase();
+	for (const entry of entries) {
+		if (entry === "*") return true;
+		const bare = entry.startsWith("*.") ? entry.slice(2) : entry.startsWith(".") ? entry.slice(1) : entry;
+		if (lower === bare || lower.endsWith(`.${bare}`)) return true;
+	}
+	return false;
+}
+/**
+* Build an HTTPS proxy agent from env vars (HTTPS_PROXY, HTTP_PROXY, etc.)
+* for use as the `agent` option in Slack WebClient and Socket Mode connections.
+*
+* When set, this agent is forwarded through @slack/bolt -> @slack/socket-mode ->
+* SlackWebSocket as the `httpAgent`, which the `ws` library uses to tunnel the
+* WebSocket upgrade request through the proxy. This fixes Socket Mode in
+* environments where outbound traffic must go through an HTTP CONNECT proxy.
+*
+* Respects `NO_PROXY` / `no_proxy`; if `*.slack.com` (or a matching pattern)
+* appears in the exclusion list, returns `undefined` so the connection is direct.
+*
+* Returns `undefined` when no proxy env var is configured or when Slack hosts
+* are excluded by `NO_PROXY`.
+*/
+function resolveSlackProxyAgent() {
+	const proxyUrl = resolveEnvHttpProxyUrl("https");
+	if (!proxyUrl) return;
+	if (isHostExcludedByNoProxy("slack.com")) return;
+	try {
+		return new HttpsProxyAgent(proxyUrl);
+	} catch {
+		return;
+	}
+}
+function resolveSlackWebClientOptions(options = {}) {
+	return {
+		...options,
+		agent: options.agent ?? resolveSlackProxyAgent(),
+		retryConfig: options.retryConfig ?? SLACK_DEFAULT_RETRY_OPTIONS
+	};
+}
+function resolveSlackWriteClientOptions(options = {}) {
+	return {
+		...options,
+		agent: options.agent ?? resolveSlackProxyAgent(),
+		retryConfig: options.retryConfig ?? SLACK_WRITE_RETRY_OPTIONS,
+		maxRequestConcurrency: options.maxRequestConcurrency ?? 1
+	};
+}
+//#endregion
+//#region extensions/slack/src/client.ts
+const SLACK_WRITE_CLIENT_CACHE_MAX = 32;
+const slackWriteClientCache = /* @__PURE__ */ new Map();
+function createSlackWebClient(token, options = {}) {
+	return new WebClient(token, resolveSlackWebClientOptions(options));
+}
+function createSlackWriteClient(token, options = {}) {
+	return new WebClient(token, resolveSlackWriteClientOptions(options));
+}
+function createSlackTokenCacheKey(token) {
+	return `sha256:${createHash("sha256").update(token).digest("base64url")}`;
+}
+function getSlackWriteClient(token) {
+	const tokenKey = createSlackTokenCacheKey(token);
+	const cached = slackWriteClientCache.get(tokenKey);
+	if (cached) {
+		slackWriteClientCache.delete(tokenKey);
+		slackWriteClientCache.set(tokenKey, cached);
+		return cached;
+	}
+	const client = createSlackWriteClient(token);
+	if (slackWriteClientCache.size >= SLACK_WRITE_CLIENT_CACHE_MAX) {
+		const oldestTokenKey = slackWriteClientCache.keys().next().value;
+		if (oldestTokenKey) slackWriteClientCache.delete(oldestTokenKey);
+	}
+	slackWriteClientCache.set(tokenKey, client);
+	return client;
+}
+function clearSlackWriteClientCacheForTest() {
+	slackWriteClientCache.clear();
+}
+//#endregion
+export { getSlackWriteClient as a, resolveSlackWebClientOptions as c, createSlackWriteClient as i, resolveSlackWriteClientOptions as l, createSlackTokenCacheKey as n, SLACK_DEFAULT_RETRY_OPTIONS as o, createSlackWebClient as r, SLACK_WRITE_RETRY_OPTIONS as s, clearSlackWriteClientCacheForTest as t };

package/dist/config-api-B_jq4NJW.js

@@ -0,0 +1,2 @@
+import { SlackConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/bundled-channel-config-schema";
+export { buildChannelConfigSchema as n, SlackConfigSchema as t };

package/dist/config-schema-D9B5LB_L.js

@@ -0,0 +1,167 @@
+import { n as buildChannelConfigSchema, t as SlackConfigSchema } from "./config-api-B_jq4NJW.js";
+//#endregion
+//#region extensions/slack/src/config-schema.ts
+const SlackChannelConfigSchema = buildChannelConfigSchema(SlackConfigSchema, { uiHints: {
+	"": {
+		label: "Slack",
+		help: "Slack channel provider configuration for bot/app tokens, streaming behavior, and DM policy controls. Keep token handling and thread behavior explicit to avoid noisy workspace interactions."
+	},
+	"dm.policy": {
+		label: "Slack DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.slack.allowFrom=[\"*\"] (legacy: channels.slack.dm.allowFrom)."
+	},
+	dmPolicy: {
+		label: "Slack DM Policy",
+		help: "Direct message access control (\"pairing\" recommended). \"open\" requires channels.slack.allowFrom=[\"*\"]."
+	},
+	configWrites: {
+		label: "Slack Config Writes",
+		help: "Allow Slack to write config in response to channel events/commands (default: true)."
+	},
+	"commands.native": {
+		label: "Slack Native Commands",
+		help: "Override native commands for Slack (bool or \"auto\")."
+	},
+	"commands.nativeSkills": {
+		label: "Slack Native Skill Commands",
+		help: "Override native skill commands for Slack (bool or \"auto\")."
+	},
+	allowBots: {
+		label: "Slack Allow Bot Messages",
+		help: "Allow bot-authored messages to trigger Slack replies (default: false)."
+	},
+	socketMode: {
+		label: "Slack Socket Mode Transport",
+		help: "Slack Socket Mode transport tuning passed to the Slack SDK. Use only when investigating ping/pong timeout or stale websocket behavior."
+	},
+	"socketMode.clientPingTimeout": {
+		label: "Slack Socket Mode Pong Timeout",
+		help: "Milliseconds the Slack SDK waits for a pong after its client ping before treating the websocket as stale (OpenClaw default: 15000). Increase on hosts with event-loop starvation or slow network scheduling."
+	},
+	"socketMode.serverPingTimeout": {
+		label: "Slack Socket Mode Server Ping Timeout",
+		help: "Milliseconds the Slack SDK waits for Slack server pings before treating the websocket as stale."
+	},
+	"socketMode.pingPongLoggingEnabled": {
+		label: "Slack Socket Mode Ping/Pong Logging",
+		help: "Enable Slack SDK ping/pong transport logs while debugging Socket Mode websocket health."
+	},
+	botToken: {
+		label: "Slack Bot Token",
+		help: "Slack bot token used for standard chat actions in the configured workspace. Keep this credential scoped and rotate if workspace app permissions change."
+	},
+	appToken: {
+		label: "Slack App Token",
+		help: "Slack app-level token used for Socket Mode connections and event transport when enabled. Use least-privilege app scopes and store this token as a secret."
+	},
+	userToken: {
+		label: "Slack User Token",
+		help: "Optional Slack user token for workflows requiring user-context API access beyond bot permissions. Use sparingly and audit scopes because this token can carry broader authority."
+	},
+	userTokenReadOnly: {
+		label: "Slack User Token Read Only",
+		help: "When true, treat configured Slack user token usage as read-only helper behavior where possible. Keep enabled if you only need supplemental reads without user-context writes."
+	},
+	"capabilities.interactiveReplies": {
+		label: "Slack Interactive Replies",
+		help: "Enable agent-authored Slack interactive reply directives (`[[slack_buttons: ...]]`, `[[slack_select: ...]]`). Default: false."
+	},
+	execApprovals: {
+		label: "Slack Exec Approvals",
+		help: "Slack-native exec approval routing and approver authorization. When unset, OpenClaw auto-enables DM-first native approvals if approvers can be resolved for this workspace account."
+	},
+	"execApprovals.enabled": {
+		label: "Slack Exec Approvals Enabled",
+		help: "Controls Slack native exec approvals for this account: unset or \"auto\" enables DM-first native approvals when approvers can be resolved, true forces native approvals on, and false disables them."
+	},
+	"execApprovals.approvers": {
+		label: "Slack Exec Approval Approvers",
+		help: "Slack user IDs allowed to approve exec requests for this workspace account. Use Slack user IDs or user targets such as `U123`, `user:U123`, or `<@U123>`. If you leave this unset, OpenClaw falls back to commands.ownerAllowFrom when possible."
+	},
+	"execApprovals.agentFilter": {
+		label: "Slack Exec Approval Agent Filter",
+		help: "Optional allowlist of agent IDs eligible for Slack exec approvals, for example `[\"main\", \"ops-agent\"]`. Use this to keep approval prompts scoped to the agents you actually operate from Slack."
+	},
+	"execApprovals.sessionFilter": {
+		label: "Slack Exec Approval Session Filter",
+		help: "Optional session-key filters matched as substring or regex-style patterns before Slack approval routing is used. Use narrow patterns so Slack approvals only appear for intended sessions."
+	},
+	"execApprovals.target": {
+		label: "Slack Exec Approval Target",
+		help: "Controls where Slack approval prompts are sent: \"dm\" sends to approver DMs (default), \"channel\" sends to the originating Slack chat/thread, and \"both\" sends to both. Channel delivery exposes the command text to the chat, so only use it in trusted channels."
+	},
+	streaming: {
+		label: "Slack Streaming Mode",
+		help: "Unified Slack stream preview mode: \"off\" | \"partial\" | \"block\" | \"progress\". Legacy boolean/streamMode keys are auto-mapped."
+	},
+	"streaming.mode": {
+		label: "Slack Streaming Mode",
+		help: "Canonical Slack preview mode: \"off\" | \"partial\" | \"block\" | \"progress\"."
+	},
+	"streaming.chunkMode": {
+		label: "Slack Chunk Mode",
+		help: "Chunking mode for outbound Slack text delivery: \"length\" (default) or \"newline\"."
+	},
+	"streaming.block.enabled": {
+		label: "Slack Block Streaming Enabled",
+		help: "Enable chunked block-style Slack preview delivery when channels.slack.streaming.mode=\"block\"."
+	},
+	"streaming.block.coalesce": {
+		label: "Slack Block Streaming Coalesce",
+		help: "Merge streamed Slack block replies before final delivery."
+	},
+	"streaming.nativeTransport": {
+		label: "Slack Native Streaming",
+		help: "Enable native Slack text streaming (chat.startStream/chat.appendStream/chat.stopStream) when channels.slack.streaming.mode is partial (default: true). Native streaming and Slack assistant thread status require a reply thread target; top-level DMs can still use draft post-and-edit preview streaming."
+	},
+	"streaming.preview.toolProgress": {
+		label: "Slack Draft Tool Progress",
+		help: "Show tool/progress activity in the live draft preview message (default: true). Set false to hide interim tool updates while the draft preview stays active."
+	},
+	"streaming.preview.commandText": {
+		label: "Slack Draft Command Text",
+		help: "Command/exec detail in preview tool-progress lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
+	},
+	"streaming.progress.label": {
+		label: "Slack Progress Label",
+		help: "Initial progress draft title. Use \"auto\" for built-in single-word labels, a custom string, or false to hide the title."
+	},
+	"streaming.progress.labels": {
+		label: "Slack Progress Label Pool",
+		help: "Candidate labels for streaming.progress.label=\"auto\". Leave unset to use OpenClaw built-in progress labels."
+	},
+	"streaming.progress.maxLines": {
+		label: "Slack Progress Max Lines",
+		help: "Maximum number of compact progress lines to keep below the draft label (default: 8)."
+	},
+	"streaming.progress.render": {
+		label: "Slack Progress Renderer",
+		help: "Progress draft renderer: \"text\" uses one portable text body; \"rich\" renders structured Slack Block Kit fields with the same text fallback."
+	},
+	"streaming.progress.toolProgress": {
+		label: "Slack Progress Tool Lines",
+		help: "Show compact tool/progress lines in progress draft mode (default: true). Set false to keep only the label until final delivery."
+	},
+	"streaming.progress.commandText": {
+		label: "Slack Progress Command Text",
+		help: "Command/exec detail in progress draft lines: \"raw\" preserves released behavior; \"status\" shows only the tool label."
+	},
+	"thread.historyScope": {
+		label: "Slack Thread History Scope",
+		help: "Scope for Slack thread history context (\"thread\" isolates per thread; \"channel\" reuses channel history)."
+	},
+	"thread.inheritParent": {
+		label: "Slack Thread Parent Inheritance",
+		help: "If true, Slack thread sessions inherit the parent channel transcript (default: false)."
+	},
+	"thread.initialHistoryLimit": {
+		label: "Slack Thread Initial History Limit",
+		help: "Maximum number of existing Slack thread messages to fetch when starting a new thread session (default: 20, set to 0 to disable)."
+	},
+	"thread.requireExplicitMention": {
+		label: "Slack Thread Require Explicit Mention",
+		help: "If true, require an explicit @mention even inside threads where the bot has participated. Suppresses implicit thread mention behavior so the bot only responds to explicit @bot mentions in threads (default: false)."
+	}
+} });
+//#endregion
+export { SlackChannelConfigSchema as t };

package/dist/configured-state.js

@@ -0,0 +1,11 @@
+//#region extensions/slack/configured-state.ts
+const SLACK_CONFIGURED_ENV_KEYS = [
+	"SLACK_APP_TOKEN",
+	"SLACK_BOT_TOKEN",
+	"SLACK_USER_TOKEN"
+];
+function hasSlackConfiguredState(params) {
+	return SLACK_CONFIGURED_ENV_KEYS.some((key) => typeof params.env?.[key] === "string" && params.env[key]?.trim().length > 0);
+}
+//#endregion
+export { hasSlackConfiguredState };

package/dist/contract-api.js

@@ -0,0 +1,5 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-KUjHnkQm.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-Bo6lbSkh.js";
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-B3JiHeB7.js";
+import { t as collectSlackSecurityAuditFindings } from "./security-audit-BtHGnD3d.js";
+export { collectRuntimeConfigAssignments, collectSlackSecurityAuditFindings, legacyConfigRules, listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig, normalizeCompatibilityConfig, secretTargetRegistryEntries };

package/dist/directory-config-B3JiHeB7.js

@@ -0,0 +1,54 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { i as resolveDefaultSlackAccountId, o as resolveSlackAccountAllowFrom, r as mergeSlackAccountConfig } from "./accounts-ClAPP5ry.js";
+import { r as parseSlackTarget } from "./target-parsing-CQmv-iSm.js";
+import "./targets-B1tYCAr6.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-resolution";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { createResolvedDirectoryEntriesLister } from "openclaw/plugin-sdk/directory-config-runtime";
+//#region extensions/slack/src/directory-config.ts
+var directory_config_exports = /* @__PURE__ */ __exportAll({
+	listSlackDirectoryGroupsFromConfig: () => listSlackDirectoryGroupsFromConfig,
+	listSlackDirectoryPeersFromConfig: () => listSlackDirectoryPeersFromConfig
+});
+function resolveSlackDirectoryConfigAccount(cfg, accountId) {
+	const resolvedAccountId = normalizeAccountId(accountId ?? resolveDefaultSlackAccountId(cfg));
+	const config = mergeSlackAccountConfig(cfg, resolvedAccountId);
+	return {
+		accountId: resolvedAccountId,
+		config,
+		dm: config.dm,
+		allowFrom: resolveSlackAccountAllowFrom({
+			cfg,
+			accountId: resolvedAccountId
+		}) ?? []
+	};
+}
+const listSlackDirectoryPeersFromConfig = createResolvedDirectoryEntriesLister({
+	kind: "user",
+	resolveAccount: (cfg, accountId) => resolveSlackDirectoryConfigAccount(cfg, accountId),
+	resolveSources: (account) => {
+		const channelUsers = Object.values(account.config.channels ?? {}).flatMap((channel) => channel.users ?? []);
+		return [
+			account.allowFrom,
+			Object.keys(account.config.dms ?? {}),
+			channelUsers
+		];
+	},
+	normalizeId: (raw) => {
+		const normalizedUserId = (raw.match(/^<@([A-Z0-9]+)>$/i)?.[1] ?? raw).replace(/^(slack|user):/i, "").trim();
+		if (!normalizedUserId) return null;
+		const normalized = parseSlackTarget(`user:${normalizedUserId}`, { defaultKind: "user" });
+		return normalized?.kind === "user" ? `user:${normalizeLowercaseStringOrEmpty(normalized.id)}` : null;
+	}
+});
+const listSlackDirectoryGroupsFromConfig = createResolvedDirectoryEntriesLister({
+	kind: "group",
+	resolveAccount: (cfg, accountId) => resolveSlackDirectoryConfigAccount(cfg, accountId),
+	resolveSources: (account) => [Object.keys(account.config.channels ?? {})],
+	normalizeId: (raw) => {
+		const normalized = parseSlackTarget(raw, { defaultKind: "channel" });
+		return normalized?.kind === "channel" ? `channel:${normalizeLowercaseStringOrEmpty(normalized.id)}` : null;
+	}
+});
+//#endregion
+export { listSlackDirectoryGroupsFromConfig as n, listSlackDirectoryPeersFromConfig as r, directory_config_exports as t };

package/dist/directory-contract-api.js

@@ -0,0 +1,2 @@
+import { n as listSlackDirectoryGroupsFromConfig, r as listSlackDirectoryPeersFromConfig } from "./directory-config-B3JiHeB7.js";
+export { listSlackDirectoryGroupsFromConfig, listSlackDirectoryPeersFromConfig };

package/dist/directory-live-Bf16GwDh.js

@@ -0,0 +1,133 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { a as resolveSlackAccount } from "./accounts-ClAPP5ry.js";
+import { r as createSlackWebClient } from "./client-CPe4GmDR.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/directory-live.ts
+var directory_live_exports = /* @__PURE__ */ __exportAll({
+	getSlackDirectorySelfLive: () => getSlackDirectorySelfLive,
+	listSlackDirectoryGroupsLive: () => listSlackDirectoryGroupsLive,
+	listSlackDirectoryPeersLive: () => listSlackDirectoryPeersLive
+});
+function resolveReadToken(params) {
+	const account = resolveSlackAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return account.userToken ?? account.botToken?.trim();
+}
+function normalizeQuery(value) {
+	return normalizeLowercaseStringOrEmpty(value);
+}
+function buildUserRank(user) {
+	let rank = 0;
+	if (!user.deleted) rank += 2;
+	if (!user.is_bot && !user.is_app_user) rank += 1;
+	return rank;
+}
+function buildChannelRank(channel) {
+	return channel.is_archived ? 0 : 1;
+}
+function slackUserToDirectoryEntry(user, fallback) {
+	const id = normalizeOptionalString(user.id) ?? normalizeOptionalString(fallback?.id);
+	if (!id) return null;
+	const handle = normalizeOptionalString(user.name) ?? normalizeOptionalString(fallback?.name);
+	const display = normalizeOptionalString(user.profile?.display_name) || normalizeOptionalString(user.profile?.real_name) || normalizeOptionalString(user.real_name) || handle;
+	return {
+		kind: "user",
+		id: `user:${id}`,
+		name: display || void 0,
+		handle: handle ? `@${handle}` : void 0,
+		rank: buildUserRank(user),
+		raw: user
+	};
+}
+async function getSlackDirectorySelfLive(params) {
+	const token = resolveReadToken(params);
+	if (!token) return null;
+	const client = createSlackWebClient(token);
+	const auth = await client.auth.test();
+	const userId = normalizeOptionalString(auth.user_id);
+	if (!userId) return null;
+	try {
+		return slackUserToDirectoryEntry((await client.users.info({ user: userId })).user ?? {}, {
+			id: userId,
+			name: auth.user
+		});
+	} catch {
+		return slackUserToDirectoryEntry({
+			id: userId,
+			name: auth.user
+		}, {
+			id: userId,
+			name: auth.user
+		});
+	}
+}
+async function listSlackDirectoryPeersLive(params) {
+	const token = resolveReadToken(params);
+	if (!token) return [];
+	const client = createSlackWebClient(token);
+	const query = normalizeQuery(params.query);
+	const members = [];
+	let cursor;
+	do {
+		const res = await client.users.list({
+			limit: 200,
+			cursor
+		});
+		if (Array.isArray(res.members)) members.push(...res.members);
+		const next = res.response_metadata?.next_cursor?.trim();
+		cursor = next ? next : void 0;
+	} while (cursor);
+	const rows = members.filter((member) => {
+		const candidates = [
+			member.profile?.display_name || member.profile?.real_name || member.real_name,
+			member.name,
+			member.profile?.email
+		].map((item) => normalizeOptionalLowercaseString(item)).filter(Boolean);
+		if (!query) return true;
+		return candidates.some((candidate) => candidate?.includes(query));
+	}).map((member) => slackUserToDirectoryEntry(member)).filter(Boolean);
+	if (typeof params.limit === "number" && params.limit > 0) return rows.slice(0, params.limit);
+	return rows;
+}
+async function listSlackDirectoryGroupsLive(params) {
+	const token = resolveReadToken(params);
+	if (!token) return [];
+	const client = createSlackWebClient(token);
+	const query = normalizeQuery(params.query);
+	const channels = [];
+	let cursor;
+	do {
+		const res = await client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: false,
+			limit: 1e3,
+			cursor
+		});
+		if (Array.isArray(res.channels)) channels.push(...res.channels);
+		const next = res.response_metadata?.next_cursor?.trim();
+		cursor = next ? next : void 0;
+	} while (cursor);
+	const rows = channels.filter((channel) => {
+		const name = normalizeOptionalLowercaseString(channel.name);
+		if (!query) return true;
+		return Boolean(name && name.includes(query));
+	}).map((channel) => {
+		const id = channel.id?.trim();
+		const name = channel.name?.trim();
+		if (!id || !name) return null;
+		return {
+			kind: "group",
+			id: `channel:${id}`,
+			name,
+			handle: `#${name}`,
+			rank: buildChannelRank(channel),
+			raw: channel
+		};
+	}).filter(Boolean);
+	if (typeof params.limit === "number" && params.limit > 0) return rows.slice(0, params.limit);
+	return rows;
+}
+//#endregion
+export { listSlackDirectoryGroupsLive as n, listSlackDirectoryPeersLive as r, directory_live_exports as t };