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

package/dist/{policy-BVs4LiSa.js → policy-C31RYSuT.js}

@@ -1,4 +1,4 @@
-import { t as buildSlackChannelPolicyScope, u as normalizeSlackSlug } from "./group-policy-85UWiriS.js";
+import { l as normalizeSlackSlug, t as buildSlackChannelPolicyScope } from "./group-policy-CdnQzQBI.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";

package/dist/probe-CVRuArHA.js

@@ -0,0 +1,340 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { u as formatSlackBotTokenIdentityWarning } from "./accounts-BSr252c_.js";
+import "./target-parsing-N6lHogYZ.js";
+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 { withTimeout } 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 { createNodeProxyAgent } 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 SLACK_DEFAULT_RETRY_OPTIONS = {
+	retries: 2,
+	factor: 2,
+	minTimeout: 500,
+	maxTimeout: 3e3,
+	randomize: true
+};
+const SLACK_WRITE_RETRY_OPTIONS = { retries: 0 };
+const SLACK_LOOKUP_TIMEOUT_MS = 3e4;
+const SLACK_LOOKUP_RETRY_OPTIONS = { retries: 0 };
+/**
+* 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(targetUrl) {
+	try {
+		return createNodeProxyAgent({
+			mode: "env",
+			targetUrl
+		});
+	} catch {
+		return;
+	}
+}
+function resolveSlackApiUrlFromEnv() {
+	return process.env.SLACK_API_URL?.trim() || void 0;
+}
+function applySlackApiUrlAndProxyOptions(options) {
+	const slackApiUrl = options.slackApiUrl ?? resolveSlackApiUrlFromEnv();
+	options.agent ??= resolveSlackProxyAgent(slackApiUrl ?? "https://slack.com/");
+	if (slackApiUrl !== void 0) options.slackApiUrl = slackApiUrl;
+	else delete options.slackApiUrl;
+}
+function resolveSlackWebClientOptions(options = {}) {
+	const resolved = Object.assign({}, options);
+	applySlackApiUrlAndProxyOptions(resolved);
+	resolved.retryConfig ??= SLACK_DEFAULT_RETRY_OPTIONS;
+	return resolved;
+}
+function resolveSlackWriteClientOptions(options = {}) {
+	const resolved = Object.assign({}, options);
+	applySlackApiUrlAndProxyOptions(resolved);
+	resolved.retryConfig ??= SLACK_WRITE_RETRY_OPTIONS;
+	return resolved;
+}
+function resolveSlackLookupClientOptions(options = {}) {
+	const resolved = Object.assign({}, options);
+	applySlackApiUrlAndProxyOptions(resolved);
+	resolved.rejectRateLimitedCalls = true;
+	resolved.retryConfig = SLACK_LOOKUP_RETRY_OPTIONS;
+	resolved.timeout ??= SLACK_LOOKUP_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 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 = createSlackWebClient(token);
+	const start = Date.now();
+	try {
+		const result = await withTimeout(client.auth.test(), timeoutMs);
+		if (!result.ok) return {
+			ok: false,
+			status: 200,
+			error: result.error ?? "unknown",
+			elapsedMs: Date.now() - start
+		};
+		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",
+				elapsedMs: Date.now() - start
+			};
+			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",
+				elapsedMs: Date.now() - start
+			};
+			return {
+				ok: true,
+				status: 200,
+				elapsedMs: Date.now() - start,
+				user: {
+					id: userId,
+					name: result.user
+				},
+				team: {
+					id: result.team_id,
+					name: result.team
+				}
+			};
+		}
+		const warning = formatSlackBotTokenIdentityWarning({
+			auth: result,
+			accountId: opts?.accountId
+		});
+		const authIdentity = {
+			id: result.user_id,
+			name: result.user
+		};
+		return {
+			ok: true,
+			status: 200,
+			elapsedMs: Date.now() - start,
+			bot: authIdentity,
+			team: {
+				id: result.team_id,
+				name: result.team
+			},
+			...warning ? { warning } : {}
+		};
+	} catch (err) {
+		const message = formatSlackError(err);
+		return {
+			ok: false,
+			status: typeof err.statusCode === "number" ? err.statusCode : null,
+			error: message,
+			elapsedMs: Date.now() - start
+		};
+	}
+}
+//#endregion
+export { PAIRING_APPROVED_MESSAGE as _, createSlackLookupClient as a, resolveConfiguredFromRequiredCredentialStatuses as b, createSlackWebClient as c, getSlackWriteClient as d, SLACK_DEFAULT_RETRY_OPTIONS as f, DEFAULT_ACCOUNT_ID$1 as g, resolveSlackWriteClientOptions as h, clearSlackWriteClientCacheForTest as i, createSlackWriteClient as l, resolveSlackWebClientOptions as m, probe_exports as n, createSlackStartupAuthClient as o, SLACK_WRITE_RETRY_OPTIONS as p, formatSlackError as r, createSlackTokenCacheKey as s, probeSlack as t, getSlackListenerUploadCompletionClient as u, getChatChannelMeta as v, projectCredentialSnapshotFields as y };