@openclaw/slack 2026.7.2-beta.5 → 2026.7.2-beta.7

package/dist/policy-PRysPn23.js

@@ -0,0 +1,65 @@
+import { l as normalizeSlackSlug, t as buildSlackChannelPolicyScope } from "./group-policy-NQZti9t-.js";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { applyChannelMatchMeta, buildChannelKeyCandidates } from "openclaw/plugin-sdk/channel-targets";
+import { mergePairLoopGuardConfig } from "openclaw/plugin-sdk/pair-loop-guard-runtime";
+//#region extensions/slack/src/monitor/channel-config.ts
+function firstDefined(...values) {
+	for (const value of values) if (value !== void 0) return value;
+}
+function resolveSlackChannelLabel(params) {
+	const channelName = params.channelName?.trim();
+	if (channelName) return `#${normalizeSlackSlug(channelName) || channelName}`;
+	const channelId = params.channelId?.trim();
+	return channelId ? `#${channelId}` : "unknown channel";
+}
+function resolveSlackChannelConfig(params) {
+	const { channelId, channelName, channels, channelKeys, defaultRequireMention, allowNameMatching } = params;
+	const entries = channels ?? {};
+	const keys = channelKeys ?? Object.keys(entries);
+	const normalizedName = channelName ? normalizeSlackSlug(channelName) : "";
+	const directName = channelName ? channelName.trim() : "";
+	const channelIdLower = normalizeLowercaseStringOrEmpty(channelId);
+	const channelIdUpper = channelId.toUpperCase();
+	const channelTarget = `channel:${channelId}`;
+	const channelTargetLower = `channel:${channelIdLower}`;
+	const channelTargetUpper = `channel:${channelIdUpper}`;
+	const match = buildSlackChannelPolicyScope({
+		channels: entries,
+		candidates: buildChannelKeyCandidates(channelId, channelIdLower !== channelId ? channelIdLower : void 0, channelIdUpper !== channelId ? channelIdUpper : void 0, channelTarget, channelTargetLower !== channelTarget ? channelTargetLower : void 0, channelTargetUpper !== channelTarget ? channelTargetUpper : void 0, allowNameMatching ? channelName ? `#${directName}` : void 0 : void 0, allowNameMatching ? directName : void 0, allowNameMatching ? normalizedName : void 0)
+	});
+	const { entry: matched, wildcardEntry: fallback } = match;
+	const requireMentionDefault = defaultRequireMention ?? true;
+	if (keys.length === 0) return {
+		allowed: true,
+		requireMention: requireMentionDefault
+	};
+	if (!matched && !fallback) return {
+		allowed: false,
+		requireMention: requireMentionDefault
+	};
+	const resolved = matched ?? fallback ?? {};
+	const allowed = firstDefined(resolved.enabled, fallback?.enabled, true) ?? true;
+	const requireMention = firstDefined(resolved.requireMention, fallback?.requireMention, requireMentionDefault) ?? requireMentionDefault;
+	const ignoreOtherMentions = firstDefined(resolved.ignoreOtherMentions, fallback?.ignoreOtherMentions);
+	const allowBots = firstDefined(resolved.allowBots, fallback?.allowBots);
+	return applyChannelMatchMeta({
+		allowed,
+		requireMention,
+		ignoreOtherMentions,
+		replyToMode: firstDefined(resolved.replyToMode, fallback?.replyToMode),
+		allowBots,
+		botLoopProtection: mergePairLoopGuardConfig(fallback?.botLoopProtection, matched?.botLoopProtection),
+		users: firstDefined(resolved.users, fallback?.users),
+		skills: firstDefined(resolved.skills, fallback?.skills),
+		systemPrompt: firstDefined(resolved.systemPrompt, fallback?.systemPrompt),
+		presenceEvents: firstDefined(resolved.presenceEvents, fallback?.presenceEvents)
+	}, match);
+}
+//#endregion
+//#region extensions/slack/src/monitor/policy.ts
+function isSlackChannelAllowedByPolicy(params) {
+	if (params.groupPolicy === "disabled") return false;
+	return params.groupPolicy !== "allowlist" || params.channelAllowlistConfigured && params.channelAllowed;
+}
+//#endregion
+export { resolveSlackChannelConfig as n, resolveSlackChannelLabel as r, isSlackChannelAllowedByPolicy as t };

package/dist/probe-CgDsSops.js

@@ -0,0 +1,345 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { u as formatSlackBotTokenIdentityWarning } from "./accounts-CHAeNZOX.js";
+import "./target-parsing-N6lHogYZ.js";
+import { createRequire } from "node:module";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/account-id";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { PAIRING_APPROVED_MESSAGE, projectCredentialSnapshotFields, resolveConfiguredFromRequiredCredentialStatuses } from "openclaw/plugin-sdk/channel-status";
+import { createHash } from "node:crypto";
+import { WebClient } from "@slack/web-api";
+import { addActiveManagedProxyTlsOptions, resolveEnvHttpProxyAgentOptions } from "openclaw/plugin-sdk/fetch-runtime";
+import { redactSensitiveText } from "openclaw/plugin-sdk/logging-core";
+//#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
+//#region extensions/slack/src/client-options.ts
+const requireFromSlackSocketMode = (() => {
+	return createRequire(createRequire(import.meta.url).resolve("@slack/socket-mode/package.json"));
+})();
+function loadSlackUndiciRuntime() {
+	return requireFromSlackSocketMode("undici");
+}
+const SLACK_DEFAULT_RETRY_OPTIONS = {
+	retries: 2,
+	factor: 2,
+	minTimeout: 500,
+	maxTimeout: 3e3,
+	randomize: true
+};
+const SLACK_WRITE_RETRY_OPTIONS = { retries: 0 };
+const SLACK_READ_TIMEOUT_MS = 3e4;
+const SLACK_LOOKUP_RETRY_OPTIONS = { retries: 0 };
+/** Build the dispatcher shared by Slack Web API fetches and Socket Mode. */
+function resolveSlackProxyDispatcher() {
+	const options = resolveEnvHttpProxyAgentOptions();
+	if (!options) return;
+	try {
+		const { EnvHttpProxyAgent } = loadSlackUndiciRuntime();
+		return new EnvHttpProxyAgent(addActiveManagedProxyTlsOptions(options));
+	} catch {
+		return;
+	}
+}
+function createSlackDispatcherFetch(dispatcher) {
+	const { fetch: slackFetch } = loadSlackUndiciRuntime();
+	return ((input, init) => {
+		const slackInput = input;
+		const slackInit = {
+			...init,
+			dispatcher
+		};
+		return slackFetch(slackInput, slackInit);
+	});
+}
+function resolveSlackApiUrlFromEnv() {
+	return process.env.SLACK_API_URL?.trim() || void 0;
+}
+function applySlackApiUrlAndProxyOptions(options, dispatcher) {
+	const slackApiUrl = options.slackApiUrl ?? resolveSlackApiUrlFromEnv();
+	if (dispatcher && !options.fetch) options.fetch = createSlackDispatcherFetch(dispatcher);
+	if (slackApiUrl !== void 0) options.slackApiUrl = slackApiUrl;
+	else delete options.slackApiUrl;
+}
+function resolveSlackWebClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher()) {
+	const resolved = Object.assign({}, options);
+	applySlackApiUrlAndProxyOptions(resolved, dispatcher);
+	resolved.retryConfig ??= SLACK_DEFAULT_RETRY_OPTIONS;
+	return resolved;
+}
+function resolveSlackReadClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher()) {
+	const resolved = resolveSlackWebClientOptions(options, dispatcher);
+	resolved.timeout ??= SLACK_READ_TIMEOUT_MS;
+	return resolved;
+}
+function resolveSlackWriteClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher()) {
+	const resolved = Object.assign({}, options);
+	applySlackApiUrlAndProxyOptions(resolved, dispatcher);
+	resolved.retryConfig ??= SLACK_WRITE_RETRY_OPTIONS;
+	return resolved;
+}
+function resolveSlackLookupClientOptions(options = {}, dispatcher = resolveSlackProxyDispatcher()) {
+	const resolved = Object.assign({}, options);
+	applySlackApiUrlAndProxyOptions(resolved, dispatcher);
+	resolved.rejectRateLimitedCalls = true;
+	resolved.retryConfig = SLACK_LOOKUP_RETRY_OPTIONS;
+	resolved.timeout ??= SLACK_READ_TIMEOUT_MS;
+	return resolved;
+}
+//#endregion
+//#region extensions/slack/src/client.ts
+const SLACK_WRITE_CLIENT_CACHE_MAX = 32;
+const slackWriteClientCache = /* @__PURE__ */ new Map();
+let slackListenerUploadCompletionClientCache = /* @__PURE__ */ new WeakMap();
+function createSlackWebClient(token, options = {}) {
+	return new WebClient(token, resolveSlackWebClientOptions(options));
+}
+function createSlackReadClient(token, options = {}) {
+	return new WebClient(token, resolveSlackReadClientOptions(options));
+}
+function createSlackStartupAuthClient(token, options = {}) {
+	return createSlackWebClient(token, {
+		...options,
+		rejectRateLimitedCalls: true,
+		retryConfig: { retries: 0 },
+		timeout: 1e4
+	});
+}
+function createSlackLookupClient(token, options = {}) {
+	return new WebClient(token, resolveSlackLookupClientOptions(options));
+}
+function createSlackWriteClient(token, options = {}) {
+	return new WebClient(token, resolveSlackWriteClientOptions(options));
+}
+function createSlackTokenCacheKey(token) {
+	return `sha256:${createHash("sha256").update(token).digest("base64url")}`;
+}
+function slackWriteClientCacheKey(token, options) {
+	const tokenKey = createSlackTokenCacheKey(token);
+	return options.slackApiUrl ? `${tokenKey}:api:${options.slackApiUrl}` : tokenKey;
+}
+function getSlackWriteClient(token, options = {}) {
+	const resolvedOptions = resolveSlackWriteClientOptions(options);
+	const tokenKey = slackWriteClientCacheKey(token, resolvedOptions);
+	const cached = slackWriteClientCache.get(tokenKey);
+	if (cached) {
+		slackWriteClientCache.delete(tokenKey);
+		slackWriteClientCache.set(tokenKey, cached);
+		return cached;
+	}
+	const client = new WebClient(token, resolvedOptions);
+	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 getSlackListenerUploadCompletionClient(params) {
+	const token = params.listenerClient.token?.trim();
+	const teamId = params.teamId.trim().toUpperCase();
+	if (!token || !teamId) return;
+	const cached = slackListenerUploadCompletionClientCache.get(params.listenerClient);
+	if (cached) return cached.teamId === teamId ? cached.client : void 0;
+	const headers = Object.fromEntries(Object.entries(params.clientOptions?.headers ?? {}).filter(([name]) => name.toLowerCase() !== "authorization"));
+	const client = new WebClient(token, resolveSlackWriteClientOptions({
+		...params.clientOptions,
+		headers,
+		slackApiUrl: params.listenerClient.slackApiUrl,
+		teamId,
+		retryConfig: SLACK_WRITE_RETRY_OPTIONS,
+		timeout: 0
+	}));
+	slackListenerUploadCompletionClientCache.set(params.listenerClient, {
+		teamId,
+		client
+	});
+	return client;
+}
+function clearSlackWriteClientCacheForTest() {
+	slackWriteClientCache.clear();
+	slackListenerUploadCompletionClientCache = /* @__PURE__ */ new WeakMap();
+}
+//#endregion
+//#region extensions/slack/src/errors.ts
+const NO_ERROR_DETAIL = "no error detail";
+function redact(value) {
+	return redactSensitiveText(value);
+}
+function addStringDetail(details, label, value) {
+	if (typeof value !== "string") return;
+	const trimmed = redact(value.trim());
+	if (trimmed) details.push(label ? `${label}: ${trimmed}` : trimmed);
+}
+function addScalarDetail(details, label, value) {
+	if (typeof value === "string") {
+		addStringDetail(details, label, value);
+		return;
+	}
+	if (typeof value === "number" || typeof value === "boolean") details.push(`${label}: ${String(value)}`);
+}
+function addStringListDetail(details, label, value) {
+	if (!Array.isArray(value)) return;
+	const entries = value.flatMap((entry) => {
+		if (typeof entry !== "string") return [];
+		const trimmed = redact(entry.trim());
+		return trimmed ? [trimmed] : [];
+	});
+	if (entries.length) details.push(`${label}: ${entries.join(", ")}`);
+}
+function safeStringify(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	try {
+		const result = JSON.stringify(value, (_key, nested) => {
+			if (typeof nested !== "object" || nested === null) return nested;
+			if (seen.has(nested)) return "[Circular]";
+			seen.add(nested);
+			return nested;
+		});
+		return result ? redact(result) : void 0;
+	} catch {
+		return;
+	}
+}
+function addSlackResponseMetadata(details, value) {
+	if (!isRecord(value)) return;
+	addStringListDetail(details, "scopes", value.scopes);
+	addStringListDetail(details, "accepted", value.acceptedScopes);
+	const messages = value.messages;
+	if (Array.isArray(messages)) for (const message of messages) addStringDetail(details, "slack message", message);
+	const warnings = value.warnings;
+	if (Array.isArray(warnings)) for (const warning of warnings) addStringDetail(details, "slack warning", warning);
+}
+function addSlackDataDetails(details, value) {
+	if (!isRecord(value)) return;
+	addScalarDetail(details, "slack error", value.error);
+	addScalarDetail(details, "needed", value.needed);
+	addScalarDetail(details, "provided", value.provided);
+	addSlackResponseMetadata(details, value.response_metadata);
+}
+function addRecordDetails(details, value) {
+	addScalarDetail(details, "code", value.code);
+	addScalarDetail(details, "status", value.status);
+	addScalarDetail(details, "statusCode", value.statusCode);
+	addScalarDetail(details, "statusMessage", value.statusMessage);
+	addScalarDetail(details, "retryAfter", value.retryAfter);
+	addScalarDetail(details, "errno", value.errno);
+	addScalarDetail(details, "syscall", value.syscall);
+	addScalarDetail(details, "hostname", value.hostname);
+	addScalarDetail(details, "type", value.type);
+	addStringDetail(details, "statusText", value.statusText);
+	addStringDetail(details, "body", value.body);
+	addSlackDataDetails(details, value.data);
+	if (isRecord(value.response)) {
+		addScalarDetail(details, "response status", value.response.status);
+		addStringDetail(details, "response statusText", value.response.statusText);
+		addSlackDataDetails(details, value.response.data);
+	}
+}
+function collectSlackErrorDetails(error) {
+	const details = [];
+	if (error === void 0 || error === null) return details;
+	if (typeof error === "string") {
+		addStringDetail(details, "", error);
+		return details;
+	}
+	if (error instanceof Error) {
+		addStringDetail(details, "", error.message || error.name);
+		if (error.cause !== void 0) {
+			const cause = formatSlackError(error.cause, "");
+			if (cause) details.push(`cause: ${cause}`);
+		}
+	}
+	if (isRecord(error)) {
+		addRecordDetails(details, error);
+		const fallback = safeStringify(error);
+		if (details.length === 0 && fallback && fallback !== "{}") details.push(fallback);
+	}
+	return details;
+}
+function formatSlackError(error, fallback = NO_ERROR_DETAIL) {
+	const details = collectSlackErrorDetails(error);
+	if (details.length > 0) return details.join("; ");
+	if (error === void 0 || error === null) return fallback;
+	if (typeof error === "string" && !error.trim()) return fallback;
+	return safeStringify(error) ?? fallback;
+}
+//#endregion
+//#region extensions/slack/src/probe.ts
+var probe_exports = /* @__PURE__ */ __exportAll({ probeSlack: () => probeSlack });
+async function probeSlack(token, timeoutMs = 2500, opts) {
+	const client = createSlackReadClient(token, {
+		rejectRateLimitedCalls: true,
+		retryConfig: { retries: 0 },
+		timeout: timeoutMs
+	});
+	return await runChannelProbe(timeoutMs, async () => {
+		const result = await client.auth.test();
+		if (!result.ok) return {
+			ok: false,
+			status: 200,
+			error: result.error ?? "unknown"
+		};
+		if (opts?.identity === "user") {
+			if (result.bot_id?.trim()) return {
+				ok: false,
+				status: 200,
+				error: "Slack auth.test identified a bot token; user identity requires a user OAuth token"
+			};
+			const userId = result.user_id?.trim();
+			if (!userId) return {
+				ok: false,
+				status: 200,
+				error: "Slack auth.test returned no human user_id for user identity"
+			};
+			return {
+				ok: true,
+				status: 200,
+				user: {
+					id: userId,
+					name: result.user
+				},
+				team: {
+					id: result.team_id,
+					name: result.team
+				}
+			};
+		}
+		const warning = formatSlackBotTokenIdentityWarning({
+			auth: result,
+			accountId: opts?.accountId
+		});
+		return {
+			ok: true,
+			status: 200,
+			bot: {
+				id: result.user_id,
+				name: result.user
+			},
+			team: {
+				id: result.team_id,
+				name: result.team
+			},
+			...warning ? { warning } : {}
+		};
+	}, (error) => ({
+		ok: false,
+		status: typeof error.statusCode === "number" ? error.statusCode : null,
+		error: formatSlackError(error)
+	}));
+}
+//#endregion
+export { resolveConfiguredFromRequiredCredentialStatuses as S, resolveSlackWriteClientOptions as _, createSlackLookupClient as a, getChatChannelMeta as b, createSlackTokenCacheKey as c, getSlackListenerUploadCompletionClient as d, getSlackWriteClient as f, resolveSlackWebClientOptions as g, resolveSlackProxyDispatcher as h, clearSlackWriteClientCacheForTest as i, createSlackWebClient as l, SLACK_WRITE_RETRY_OPTIONS as m, probe_exports as n, createSlackReadClient as o, SLACK_DEFAULT_RETRY_OPTIONS as p, formatSlackError as r, createSlackStartupAuthClient as s, probeSlack as t, createSlackWriteClient as u, DEFAULT_ACCOUNT_ID$1 as v, projectCredentialSnapshotFields as x, PAIRING_APPROVED_MESSAGE as y };