@openclaw/msteams 2026.5.2-beta.2 → 2026.5.3-beta.1

package/dist/resolve-allowlist-D41JSziq.js

@@ -0,0 +1,219 @@
+import { c as normalizeQuery, f as resolveGraphToken, o as listChannelsForTeam, s as listTeamsByName, t as searchGraphUsers } from "./graph-users-9uQJepqr.js";
+import { mapAllowlistResolutionInputs } from "openclaw/plugin-sdk/allow-from";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalLowercaseString } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/msteams/src/resolve-allowlist.ts
+function stripProviderPrefix(raw) {
+	return raw.replace(/^(msteams|teams):/i, "");
+}
+function normalizeMSTeamsMessagingTarget(raw) {
+	let trimmed = raw.trim();
+	if (!trimmed) return;
+	trimmed = stripProviderPrefix(trimmed).trim();
+	if (/^conversation:/i.test(trimmed)) {
+		const id = trimmed.slice(13).trim();
+		return id ? `conversation:${id}` : void 0;
+	}
+	if (/^user:/i.test(trimmed)) {
+		const id = trimmed.slice(5).trim();
+		return id ? `user:${id}` : void 0;
+	}
+	return trimmed || void 0;
+}
+function normalizeMSTeamsUserInput(raw) {
+	return stripProviderPrefix(raw).replace(/^(user|conversation):/i, "").trim();
+}
+function parseMSTeamsConversationId(raw) {
+	const trimmed = stripProviderPrefix(raw).trim();
+	if (!/^conversation:/i.test(trimmed)) return null;
+	return trimmed.slice(13).trim();
+}
+/**
+* Detect whether a raw target string looks like a Microsoft Teams conversation
+* or user id that cron announce delivery and other explicit-target paths can
+* forward verbatim to the channel adapter.
+*
+* Accepts both prefixed and bare formats:
+* - `conversation:<id>` — explicit conversation prefix
+* - `user:<aad-guid>`   — user id (16+ hex chars, UUID-like)
+* - `19:abc@thread.tacv2` / `19:abc@thread.skype` — channel / legacy group
+* - `19:{userId}_{appId}@unq.gbl.spaces` — Graph 1:1 chat thread format
+* - `a:1xxx` — Bot Framework personal (1:1) chat id
+* - `8:orgid:xxx` — Bot Framework org-scoped personal chat id
+* - `29:xxx` — Bot Framework user id
+*
+* Display-name user targets such as `user:John Smith` intentionally return
+* false so that the Graph API directory lookup still runs for them.
+*/
+function looksLikeMSTeamsTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	if (/^conversation:/i.test(trimmed)) return true;
+	if (/^user:/i.test(trimmed)) {
+		const id = trimmed.slice(5).trim();
+		return /^[0-9a-fA-F-]{16,}$/.test(id);
+	}
+	if (/^19:.+@thread\.(tacv2|skype)$/i.test(trimmed)) return true;
+	if (/^19:.+@unq\.gbl\.spaces$/i.test(trimmed)) return true;
+	if (/^a:1[A-Za-z0-9_-]+$/i.test(trimmed)) return true;
+	if (/^8:orgid:[A-Za-z0-9-]+$/i.test(trimmed)) return true;
+	if (/^29:[A-Za-z0-9_-]+$/i.test(trimmed)) return true;
+	return /@thread\b/i.test(trimmed);
+}
+function normalizeMSTeamsTeamKey(raw) {
+	return stripProviderPrefix(raw).replace(/^team:/i, "").trim() || void 0;
+}
+function normalizeMSTeamsChannelKey(raw) {
+	return (raw?.trim().replace(/^#/, "").trim() ?? "") || void 0;
+}
+function normalizeMSTeamsConversationTargetId(raw) {
+	const trimmed = stripProviderPrefix(raw).trim();
+	return parseMSTeamsConversationId(trimmed) ?? trimmed;
+}
+function looksLikeMSTeamsThreadConversationId(raw) {
+	const normalized = normalizeMSTeamsConversationTargetId(raw);
+	return /^19:.+@thread\./i.test(normalized);
+}
+function parseMSTeamsTeamChannelInput(raw) {
+	const trimmed = stripProviderPrefix(raw).trim();
+	if (!trimmed) return {};
+	const parts = trimmed.split("/");
+	const team = normalizeMSTeamsTeamKey(parts[0] ?? "");
+	const channel = parts.length > 1 ? normalizeMSTeamsChannelKey(parts.slice(1).join("/")) : void 0;
+	return {
+		...team ? { team } : {},
+		...channel ? { channel } : {}
+	};
+}
+function parseMSTeamsTeamEntry(raw) {
+	const { team, channel } = parseMSTeamsTeamChannelInput(raw);
+	if (!team) return null;
+	return {
+		teamKey: team,
+		...channel ? { channelKey: channel } : {}
+	};
+}
+async function resolveMSTeamsChannelAllowlist(params) {
+	let tokenPromise;
+	const getToken = () => {
+		tokenPromise ??= resolveGraphToken(params.cfg);
+		return tokenPromise;
+	};
+	return await mapAllowlistResolutionInputs({
+		inputs: params.entries,
+		mapInput: async (input) => {
+			const { team, channel } = parseMSTeamsTeamChannelInput(input);
+			if (!team) return {
+				input,
+				resolved: false
+			};
+			if (looksLikeMSTeamsThreadConversationId(team)) {
+				const teamId = normalizeMSTeamsConversationTargetId(team);
+				if (!channel) return {
+					input,
+					resolved: true,
+					teamId,
+					teamName: teamId
+				};
+				if (!looksLikeMSTeamsThreadConversationId(channel)) return {
+					input,
+					resolved: false,
+					teamId,
+					teamName: teamId,
+					note: "channel id required for conversation-id team"
+				};
+				const channelId = normalizeMSTeamsConversationTargetId(channel);
+				return {
+					input,
+					resolved: true,
+					teamId,
+					teamName: teamId,
+					channelId,
+					channelName: channelId
+				};
+			}
+			const token = await getToken();
+			const teams = /^[0-9a-fA-F-]{16,}$/.test(team) ? [{
+				id: team,
+				displayName: team
+			}] : await listTeamsByName(token, team);
+			if (teams.length === 0) return {
+				input,
+				resolved: false,
+				note: "team not found"
+			};
+			const teamMatch = teams[0];
+			const graphTeamId = teamMatch.id?.trim();
+			const teamName = teamMatch.displayName?.trim() || team;
+			if (!graphTeamId) return {
+				input,
+				resolved: false,
+				note: "team id missing"
+			};
+			let teamChannels = [];
+			try {
+				teamChannels = await listChannelsForTeam(token, graphTeamId);
+			} catch {}
+			const teamId = teamChannels.find((ch) => normalizeOptionalLowercaseString(ch.displayName) === "general")?.id?.trim() || graphTeamId;
+			if (!channel) return {
+				input,
+				resolved: true,
+				teamId,
+				teamName,
+				note: teams.length > 1 ? "multiple teams; chose first" : void 0
+			};
+			const normalizedChannel = normalizeOptionalLowercaseString(channel);
+			const channelMatch = teamChannels.find((item) => item.id === channel) ?? teamChannels.find((item) => normalizeOptionalLowercaseString(item.displayName) === normalizedChannel) ?? teamChannels.find((item) => normalizeLowercaseStringOrEmpty(item.displayName ?? "").includes(normalizedChannel ?? ""));
+			if (!channelMatch?.id) return {
+				input,
+				resolved: false,
+				note: "channel not found"
+			};
+			return {
+				input,
+				resolved: true,
+				teamId,
+				teamName,
+				channelId: channelMatch.id,
+				channelName: channelMatch.displayName ?? channel,
+				note: teamChannels.length > 1 ? "multiple channels; chose first" : void 0
+			};
+		}
+	});
+}
+async function resolveMSTeamsUserAllowlist(params) {
+	const token = await resolveGraphToken(params.cfg);
+	return await mapAllowlistResolutionInputs({
+		inputs: params.entries,
+		mapInput: async (input) => {
+			const query = normalizeQuery(normalizeMSTeamsUserInput(input));
+			if (!query) return {
+				input,
+				resolved: false
+			};
+			if (/^[0-9a-fA-F-]{16,}$/.test(query)) return {
+				input,
+				resolved: true,
+				id: query
+			};
+			const users = await searchGraphUsers({
+				token,
+				query,
+				top: 10
+			});
+			const match = users[0];
+			if (!match?.id) return {
+				input,
+				resolved: false
+			};
+			return {
+				input,
+				resolved: true,
+				id: match.id,
+				name: match.displayName ?? void 0,
+				note: users.length > 1 ? "multiple matches; chose first" : void 0
+			};
+		}
+	});
+}
+//#endregion
+export { parseMSTeamsTeamChannelInput as a, resolveMSTeamsUserAllowlist as c, parseMSTeamsConversationId as i, normalizeMSTeamsMessagingTarget as n, parseMSTeamsTeamEntry as o, normalizeMSTeamsUserInput as r, resolveMSTeamsChannelAllowlist as s, looksLikeMSTeamsTargetId as t };

package/dist/runtime-api-DV1iVMn1.js

@@ -0,0 +1,28 @@
+import { mergeAllowlist, resolveAllowlistMatchSimple, summarizeMapping } from "openclaw/plugin-sdk/allow-from";
+import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
+import { evaluateSenderGroupAccessForPolicy, readStoreAllowFromForDmPolicy, resolveDmGroupAccessWithLists, resolveEffectiveAllowFromLists, resolveSenderScopedGroupPolicy, resolveToolsBySender } from "openclaw/plugin-sdk/channel-policy";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { logTypingFailure } from "openclaw/plugin-sdk/channel-logging";
+import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
+import { PAIRING_APPROVED_MESSAGE, buildProbeChannelStatusSummary, createDefaultChannelRuntimeState } from "openclaw/plugin-sdk/channel-status";
+import { buildChannelKeyCandidates, normalizeChannelSlug, resolveChannelEntryMatchWithFallback, resolveNestedAllowlistDecision } from "openclaw/plugin-sdk/channel-targets";
+import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
+import { resolveDefaultGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
+import { withFileLock as withFileLock$1 } from "openclaw/plugin-sdk/file-lock";
+import { keepHttpServerTaskAlive } from "openclaw/plugin-sdk/channel-lifecycle";
+import { detectMime, extensionForMime, extractOriginalFilename, getFileExtension, resolveChannelMediaMaxBytes } from "openclaw/plugin-sdk/media-runtime";
+import { dispatchReplyFromConfigWithSettledDispatcher as dispatchReplyFromConfigWithSettledDispatcher$1 } from "openclaw/plugin-sdk/inbound-reply-dispatch";
+import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
+import { buildMediaPayload } from "openclaw/plugin-sdk/reply-payload";
+import { fetchWithSsrFGuard as fetchWithSsrFGuard$1 } from "openclaw/plugin-sdk/ssrf-runtime";
+import { normalizeStringEntries } from "openclaw/plugin-sdk/string-normalization-runtime";
+import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
+import { DEFAULT_WEBHOOK_MAX_BODY_BYTES } from "openclaw/plugin-sdk/webhook-ingress";
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+//#region extensions/msteams/src/runtime.ts
+const { setRuntime: setMSTeamsRuntime, getRuntime: getMSTeamsRuntime, tryGetRuntime: getOptionalMSTeamsRuntime } = createPluginRuntimeStore({
+	pluginId: "msteams",
+	errorMessage: "MSTeams runtime not initialized"
+});
+//#endregion
+export { resolveDmGroupAccessWithLists as A, normalizeChannelSlug as C, resolveChannelEntryMatchWithFallback as D, resolveAllowlistMatchSimple as E, summarizeMapping as F, withFileLock$1 as I, getMSTeamsRuntime as L, resolveNestedAllowlistDecision as M, resolveSenderScopedGroupPolicy as N, resolveChannelMediaMaxBytes as O, resolveToolsBySender as P, getOptionalMSTeamsRuntime as R, mergeAllowlist as S, readStoreAllowFromForDmPolicy as T, getFileExtension as _, buildMediaPayload as a, loadOutboundMediaFromUrl as b, createChannelPairingController as c, detectMime as d, dispatchReplyFromConfigWithSettledDispatcher$1 as f, fetchWithSsrFGuard$1 as g, extractOriginalFilename as h, buildChannelKeyCandidates as i, resolveEffectiveAllowFromLists as j, resolveDefaultGroupPolicy as k, createChannelReplyPipeline as l, extensionForMime as m, DEFAULT_WEBHOOK_MAX_BODY_BYTES as n, buildProbeChannelStatusSummary as o, evaluateSenderGroupAccessForPolicy as p, PAIRING_APPROVED_MESSAGE as r, chunkTextForOutbound as s, DEFAULT_ACCOUNT_ID as t, createDefaultChannelRuntimeState as u, isDangerousNameMatchingEnabled as v, normalizeStringEntries as w, logTypingFailure as x, keepHttpServerTaskAlive as y, setMSTeamsRuntime as z };

package/dist/runtime-api.js

@@ -0,0 +1,2 @@
+import { A as resolveDmGroupAccessWithLists, C as normalizeChannelSlug, D as resolveChannelEntryMatchWithFallback, E as resolveAllowlistMatchSimple, F as summarizeMapping, I as withFileLock, M as resolveNestedAllowlistDecision, N as resolveSenderScopedGroupPolicy, O as resolveChannelMediaMaxBytes, P as resolveToolsBySender, S as mergeAllowlist, T as readStoreAllowFromForDmPolicy, _ as getFileExtension, a as buildMediaPayload, b as loadOutboundMediaFromUrl, c as createChannelPairingController, d as detectMime, f as dispatchReplyFromConfigWithSettledDispatcher, g as fetchWithSsrFGuard, h as extractOriginalFilename, i as buildChannelKeyCandidates, j as resolveEffectiveAllowFromLists, k as resolveDefaultGroupPolicy, l as createChannelReplyPipeline, m as extensionForMime, n as DEFAULT_WEBHOOK_MAX_BODY_BYTES, o as buildProbeChannelStatusSummary, p as evaluateSenderGroupAccessForPolicy, r as PAIRING_APPROVED_MESSAGE, s as chunkTextForOutbound, t as DEFAULT_ACCOUNT_ID, u as createDefaultChannelRuntimeState, v as isDangerousNameMatchingEnabled, w as normalizeStringEntries, x as logTypingFailure, y as keepHttpServerTaskAlive, z as setMSTeamsRuntime } from "./runtime-api-DV1iVMn1.js";
+export { DEFAULT_ACCOUNT_ID, DEFAULT_WEBHOOK_MAX_BODY_BYTES, PAIRING_APPROVED_MESSAGE, buildChannelKeyCandidates, buildMediaPayload, buildProbeChannelStatusSummary, chunkTextForOutbound, createChannelPairingController, createChannelReplyPipeline, createDefaultChannelRuntimeState, detectMime, dispatchReplyFromConfigWithSettledDispatcher, evaluateSenderGroupAccessForPolicy, extensionForMime, extractOriginalFilename, fetchWithSsrFGuard, getFileExtension, isDangerousNameMatchingEnabled, keepHttpServerTaskAlive, loadOutboundMediaFromUrl, logTypingFailure, mergeAllowlist, normalizeChannelSlug, normalizeStringEntries, readStoreAllowFromForDmPolicy, resolveAllowlistMatchSimple, resolveChannelEntryMatchWithFallback, resolveChannelMediaMaxBytes, resolveDefaultGroupPolicy, resolveDmGroupAccessWithLists, resolveEffectiveAllowFromLists, resolveNestedAllowlistDecision, resolveSenderScopedGroupPolicy, resolveToolsBySender, setMSTeamsRuntime, summarizeMapping, withFileLock };

package/dist/secret-contract-BuoEXmPS.js

@@ -0,0 +1,35 @@
+import { collectSecretInputAssignment, getChannelRecord } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+//#region extensions/msteams/src/secret-contract.ts
+const secretTargetRegistryEntries = [{
+	id: "channels.msteams.appPassword",
+	targetType: "channels.msteams.appPassword",
+	configFile: "openclaw.json",
+	pathPattern: "channels.msteams.appPassword",
+	secretShape: "secret_input",
+	expectedResolvedValue: "string",
+	includeInPlan: true,
+	includeInConfigure: true,
+	includeInAudit: true
+}];
+function collectRuntimeConfigAssignments(params) {
+	const msteams = getChannelRecord(params.config, "msteams");
+	if (!msteams) return;
+	collectSecretInputAssignment({
+		value: msteams.appPassword,
+		path: "channels.msteams.appPassword",
+		expected: "string",
+		defaults: params.defaults,
+		context: params.context,
+		active: msteams.enabled !== false,
+		inactiveReason: "Microsoft Teams channel is disabled.",
+		apply: (value) => {
+			msteams.appPassword = value;
+		}
+	});
+}
+const channelSecrets = {
+	secretTargetRegistryEntries,
+	collectRuntimeConfigAssignments
+};
+//#endregion
+export { collectRuntimeConfigAssignments as n, secretTargetRegistryEntries as r, channelSecrets as t };

package/dist/secret-contract-api.js

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

package/dist/setup-entry.js

@@ -0,0 +1,15 @@
+import { defineBundledChannelSetupEntry } from "openclaw/plugin-sdk/channel-entry-contract";
+//#region extensions/msteams/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "msteamsSetupPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

@@ -0,0 +1,64 @@
+import { h as resolveMSTeamsCredentials } from "./graph-users-9uQJepqr.js";
+import { t as MSTeamsChannelConfigSchema } from "./config-schema-B8QezH6t.js";
+import { i as msteamsSetupAdapter, t as msteamsSetupWizard } from "./setup-surface-BLkFQYIQ.js";
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
+import { createTopLevelChannelConfigAdapter } from "openclaw/plugin-sdk/channel-config-helpers";
+//#region extensions/msteams/src/channel.setup.ts
+const meta = {
+	id: "msteams",
+	label: "Microsoft Teams",
+	selectionLabel: "Microsoft Teams (Bot Framework)",
+	docsPath: "/channels/msteams",
+	docsLabel: "msteams",
+	blurb: "Teams SDK; enterprise support.",
+	aliases: ["teams"],
+	order: 60
+};
+const resolveMSTeamsChannelConfig = (cfg) => ({
+	allowFrom: cfg.channels?.msteams?.allowFrom,
+	defaultTo: cfg.channels?.msteams?.defaultTo
+});
+const msteamsConfigAdapter = createTopLevelChannelConfigAdapter({
+	sectionKey: "msteams",
+	resolveAccount: (cfg) => ({
+		accountId: "default",
+		enabled: cfg.channels?.msteams?.enabled !== false,
+		configured: Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams))
+	}),
+	resolveAccessorAccount: ({ cfg }) => resolveMSTeamsChannelConfig(cfg),
+	resolveAllowFrom: (account) => account.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
+	resolveDefaultTo: (account) => account.defaultTo
+});
+const msteamsSetupPlugin = {
+	id: "msteams",
+	meta: {
+		...meta,
+		aliases: [...meta.aliases]
+	},
+	capabilities: {
+		chatTypes: [
+			"direct",
+			"channel",
+			"thread"
+		],
+		polls: true,
+		threads: true,
+		media: true
+	},
+	reload: { configPrefixes: ["channels.msteams"] },
+	configSchema: MSTeamsChannelConfigSchema,
+	config: {
+		...msteamsConfigAdapter,
+		isConfigured: (_account, cfg) => Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)),
+		describeAccount: (account) => describeAccountSnapshot({
+			account,
+			configured: account.configured
+		})
+	},
+	setupWizard: msteamsSetupWizard,
+	setup: msteamsSetupAdapter
+};
+//#endregion
+export { msteamsSetupPlugin };