@openclaw/slack 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/resolve-users-Dzomuwnr.js

@@ -0,0 +1,141 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { a as parseSlackTarget, n as formatSlackTarget } from "./target-parsing-BnMD2ZqZ.js";
+import { i as createSlackLookupClient } from "./probe-HoEg_WxB.js";
+import { t as collectSlackCursorPages } from "./cursor-pages-eX7p8Wwt.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveDirectoryAllowlistEntries } from "openclaw/plugin-sdk/directory-runtime";
+//#region extensions/slack/src/resolve-users.ts
+var resolve_users_exports = /* @__PURE__ */ __exportAll({ resolveSlackUserAllowlist: () => resolveSlackUserAllowlist });
+function resolveWorkspaceQualifiedUser(input) {
+	if (!/^team:/i.test(input)) return;
+	try {
+		const target = parseSlackTarget(input);
+		if (target?.kind !== "user" || !target.teamId) return;
+		return {
+			input,
+			resolved: true,
+			id: formatSlackTarget({
+				teamId: target.teamId,
+				kind: "user",
+				id: target.id
+			})
+		};
+	} catch {
+		return;
+	}
+}
+function parseSlackUserInput(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<@([A-Z0-9]+)>$/i);
+	if (mention) return { id: mention[1]?.toUpperCase() };
+	const prefixed = trimmed.replace(/^(slack:|user:)/i, "");
+	if (/^[A-Z][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
+	if (trimmed.includes("@") && !trimmed.startsWith("@")) return { email: normalizeLowercaseStringOrEmpty(trimmed) };
+	const name = trimmed.replace(/^@/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackUsers(client) {
+	return collectSlackCursorPages({
+		fetchPage: (cursor) => client.users.list({
+			limit: 200,
+			cursor
+		}),
+		collectPageItems: (res) => (res.members ?? []).map((member) => {
+			const id = normalizeOptionalString(member.id);
+			const name = normalizeOptionalString(member.name);
+			if (!id || !name) return null;
+			const profile = member.profile ?? {};
+			return {
+				id,
+				name,
+				displayName: normalizeOptionalString(profile.display_name),
+				realName: normalizeOptionalString(profile.real_name) ?? normalizeOptionalString(member.real_name),
+				email: normalizeOptionalString(profile.email) == null ? void 0 : normalizeLowercaseStringOrEmpty(profile.email),
+				deleted: Boolean(member.deleted),
+				isBot: Boolean(member.is_bot),
+				isAppUser: Boolean(member.is_app_user)
+			};
+		}).filter(Boolean)
+	});
+}
+function scoreSlackUser(user, match) {
+	let score = 0;
+	if (!user.deleted) score += 3;
+	if (!user.isBot && !user.isAppUser) score += 2;
+	if (match.email && user.email === match.email) score += 5;
+	if (match.name) {
+		const target = normalizeLowercaseStringOrEmpty(match.name);
+		if ([
+			user.name,
+			user.displayName,
+			user.realName
+		].map((value) => normalizeLowercaseStringOrEmpty(value)).filter(Boolean).some((value) => value === target)) score += 2;
+	}
+	return score;
+}
+function resolveSlackUserFromMatches(input, matches, parsed) {
+	const best = matches.map((user) => ({
+		user,
+		score: scoreSlackUser(user, parsed)
+	})).toSorted((a, b) => b.score - a.score)[0]?.user ?? matches[0];
+	if (!best) return {
+		input,
+		resolved: false
+	};
+	return {
+		input,
+		resolved: true,
+		id: best.id,
+		name: best.displayName ?? best.realName ?? best.name,
+		email: best.email,
+		deleted: best.deleted,
+		isBot: best.isBot,
+		note: matches.length > 1 ? "multiple matches; chose best" : void 0
+	};
+}
+async function resolveSlackUserAllowlist(params) {
+	const workspaceResolved = params.entries.map(resolveWorkspaceQualifiedUser);
+	const lookupEntries = params.entries.filter((_, index) => !workspaceResolved[index]);
+	if (lookupEntries.length === 0) return workspaceResolved.filter((entry) => entry !== void 0);
+	const resolved = resolveDirectoryAllowlistEntries({
+		entries: lookupEntries,
+		lookup: await listSlackUsers(params.client ?? createSlackLookupClient(params.token)),
+		parseInput: parseSlackUserInput,
+		findById: (lookup, id) => lookup.find((user) => user.id === id),
+		buildIdResolved: ({ input, parsed, match }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: match?.displayName ?? match?.realName ?? match?.name,
+			email: match?.email,
+			deleted: match?.deleted,
+			isBot: match?.isBot
+		}),
+		resolveNonId: ({ input, parsed, lookup }) => {
+			if (parsed.email) {
+				const matches = lookup.filter((user) => user.email === parsed.email);
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+			if (parsed.name) {
+				const target = normalizeLowercaseStringOrEmpty(parsed.name);
+				const matches = lookup.filter((user) => {
+					return [
+						user.name,
+						user.displayName,
+						user.realName
+					].map((value) => normalizeLowercaseStringOrEmpty(value)).filter(Boolean).includes(target);
+				});
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+	let resolvedIndex = 0;
+	return workspaceResolved.map((entry) => entry ?? resolved[resolvedIndex++]);
+}
+//#endregion
+export { resolve_users_exports as n, resolveSlackUserAllowlist as t };

package/dist/runtime-api-Cj9nxBNv.js

@@ -0,0 +1,10 @@
+import "./target-parsing-BnMD2ZqZ.js";
+import "./probe-HoEg_WxB.js";
+import "./config-schema-xto5jFIx.js";
+import "openclaw/plugin-sdk/account-id";
+import { createActionGate as createActionGate$1, imageResultFromFile, jsonResult, readPositiveIntegerParam, readReactionParams, readStringParam, withNormalizedTimestamp } from "openclaw/plugin-sdk/channel-actions";
+import "openclaw/plugin-sdk/channel-status";
+import "openclaw/plugin-sdk/channel-config-schema";
+import "openclaw/plugin-sdk/channel-plugin-common";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
+export { readPositiveIntegerParam as a, withNormalizedTimestamp as c, loadOutboundMediaFromUrl as i, imageResultFromFile as n, readReactionParams as o, jsonResult as r, readStringParam as s, createActionGate$1 as t };

package/dist/runtime-api.js

@@ -1,14 +1,14 @@
 import { t as registerSlackPluginHttpRoutes } from "./plugin-routes-CLp4obpN.js";
-import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-BSr252c_.js";
-import { n as resolveSlackGroupRequireMention, r as resolveSlackGroupToolPolicy } from "./group-policy-CthIXE2T.js";
-import { t as probeSlack } from "./probe-BhQTDVBQ.js";
+import { a as resolveSlackAccount, d as resolveSlackAppToken, f as resolveSlackBotToken, i as resolveDefaultSlackAccountId, n as listSlackAccountIds, t as listEnabledSlackAccounts } from "./accounts-CK4AVI2_.js";
+import { i as resolveSlackGroupToolPolicy, r as resolveSlackGroupRequireMention } from "./group-policy-c4RP9bjc.js";
+import { t as probeSlack } from "./probe-HoEg_WxB.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-BkOaiDSX.js";
-import { r as sendMessageSlack } from "./send-2IoDXPeB.js";
-import { t as resolveSlackChannelAllowlist } from "./resolve-channels-B3RlJKyV.js";
-import { t as resolveSlackUserAllowlist } from "./resolve-users-DTm7PEMa.js";
-import { t as monitorSlackProvider } from "./provider-PSppCU_K.js";
-import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-BO3HK_50.js";
-import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-CUwGPX2d.js";
-import "./monitor-Cb5ZsOTY.js";
+import { a as getSlackMemberInfo, c as listSlackReactions, d as readSlackMessages, f as removeOwnSlackReactions, g as unpinSlackMessage, h as sendSlackMessage, l as pinSlackMessage, o as listSlackEmojis, p as removeSlackReaction, r as editSlackMessage, s as listSlackPins, t as deleteSlackMessage, u as reactSlackMessage } from "./actions-BTDXwwE3.js";
+import { r as sendMessageSlack } from "./send-Nor0iBwY.js";
+import { t as resolveSlackChannelAllowlist } from "./resolve-channels-CNPrxaXY.js";
+import { t as resolveSlackUserAllowlist } from "./resolve-users-Dzomuwnr.js";
+import { t as monitorSlackProvider } from "./provider-CDNvBXUi.js";
+import { n as slackActionRuntime, t as handleSlackAction } from "./action-runtime-BkGe7ny_.js";
+import { n as listSlackDirectoryGroupsLive, r as listSlackDirectoryPeersLive } from "./directory-live-CFKUtW9E.js";
+import "./monitor-1nF1NtqT.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-cYXKkrRD.js

@@ -0,0 +1,73 @@
+import { a as createSlackReadClient, r as formatSlackError } from "./probe-HoEg_WxB.js";
+import { isRecord, normalizeOptionalString, normalizeStringEntries, sortUniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/slack/src/scopes.ts
+function collectScopes(value, into) {
+	if (!value) return;
+	if (Array.isArray(value)) {
+		for (const entry of value) if (typeof entry === "string" && entry.trim()) into.push(entry.trim());
+		return;
+	}
+	if (typeof value === "string") {
+		const raw = value.trim();
+		if (!raw) return;
+		const parts = raw.split(/[,\s]+/).map((part) => part.trim());
+		for (const part of parts) if (part) into.push(part);
+		return;
+	}
+	if (!isRecord(value)) return;
+	for (const entry of Object.values(value)) if (Array.isArray(entry) || typeof entry === "string") collectScopes(entry, into);
+}
+function normalizeScopes(scopes) {
+	return sortUniqueStrings(normalizeStringEntries(scopes));
+}
+function extractScopes(payload) {
+	if (!isRecord(payload)) return [];
+	const scopes = [];
+	collectScopes(payload.scopes, scopes);
+	collectScopes(payload.scope, scopes);
+	if (isRecord(payload.response_metadata)) collectScopes(payload.response_metadata.scopes, scopes);
+	if (isRecord(payload.info)) {
+		collectScopes(payload.info.scopes, scopes);
+		collectScopes(payload.info.scope, scopes);
+		collectScopes(payload.info.user_scopes, scopes);
+		collectScopes(payload.info.bot_scopes, scopes);
+	}
+	return normalizeScopes(scopes);
+}
+async function callSlack(client, method) {
+	try {
+		const result = await client.apiCall(method);
+		return isRecord(result) ? result : null;
+	} catch (err) {
+		return {
+			ok: false,
+			error: formatSlackError(err)
+		};
+	}
+}
+async function fetchSlackScopes(token, timeoutMs) {
+	const client = createSlackReadClient(token, { timeout: timeoutMs });
+	const attempts = [
+		"auth.test",
+		"auth.scopes",
+		"apps.permissions.info"
+	];
+	const errors = [];
+	for (const method of attempts) {
+		const result = await callSlack(client, method);
+		const scopes = extractScopes(result);
+		if (scopes.length > 0) return {
+			ok: true,
+			scopes,
+			source: method
+		};
+		const error = isRecord(result) ? normalizeOptionalString(result.error) : void 0;
+		if (error) errors.push(`${method}: ${error}`);
+	}
+	return {
+		ok: false,
+		error: errors.length > 0 ? errors.join(" | ") : "no scopes returned"
+	};
+}
+//#endregion
+export { fetchSlackScopes };