@spacebar_ai/moldclaw-core 2026.3.14 → 2026.3.16

package/dist/resolve-channels-BtrGC95o.js

@@ -0,0 +1,262 @@
+import { _t as fetchDiscord, gt as DiscordApiError, nt as normalizeDiscordSlug } from "./auth-profiles-9zZdaXJK.js";
+import { a as listGuilds, i as resolveDiscordAllowlistToken, n as buildDiscordUnresolvedResults, r as filterDiscordGuilds } from "./resolve-users-CgSxHrU0.js";
+//#region extensions/discord/src/resolve-channels.ts
+function parseDiscordChannelInput(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<#(\d+)>$/);
+	if (mention) return { channelId: mention[1] };
+	const channelPrefix = trimmed.match(/^(?:channel:|discord:)?(\d+)$/i);
+	if (channelPrefix) return { channelId: channelPrefix[1] };
+	const guildPrefix = trimmed.match(/^(?:guild:|server:)?(\d+)$/i);
+	if (guildPrefix && !trimmed.includes("/") && !trimmed.includes("#")) return {
+		guildId: guildPrefix[1],
+		guildOnly: true
+	};
+	const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
+	if (split.length >= 2) {
+		const guild = split[0]?.trim();
+		const channel = split.slice(1).join("#").trim();
+		if (!channel) return guild ? {
+			guild: guild.trim(),
+			guildOnly: true
+		} : {};
+		if (guild && /^\d+$/.test(guild)) {
+			if (/^\d+$/.test(channel)) return {
+				guildId: guild,
+				channelId: channel
+			};
+			return {
+				guildId: guild,
+				channel
+			};
+		}
+		return {
+			guild,
+			channel
+		};
+	}
+	return {
+		guild: trimmed,
+		guildOnly: true
+	};
+}
+async function listGuildChannels(token, fetcher, guildId) {
+	return (await fetchDiscord(`/guilds/${guildId}/channels`, token, fetcher)).map((channel) => {
+		const archived = channel.thread_metadata?.archived;
+		return {
+			id: typeof channel.id === "string" ? channel.id : "",
+			name: typeof channel.name === "string" ? channel.name : "",
+			guildId,
+			type: channel.type,
+			archived
+		};
+	}).filter((channel) => Boolean(channel.id) && Boolean(channel.name));
+}
+async function fetchChannel(token, fetcher, channelId) {
+	let raw;
+	try {
+		raw = await fetchDiscord(`/channels/${channelId}`, token, fetcher);
+	} catch (err) {
+		if (err instanceof DiscordApiError && err.status === 403) return { status: "forbidden" };
+		if (err instanceof DiscordApiError && err.status === 404) return { status: "not-found" };
+		throw err;
+	}
+	if (!raw || typeof raw.guild_id !== "string" || typeof raw.id !== "string") return { status: "invalid" };
+	return {
+		status: "found",
+		channel: {
+			id: raw.id,
+			name: typeof raw.name === "string" ? raw.name : "",
+			guildId: raw.guild_id,
+			type: raw.type
+		}
+	};
+}
+function preferActiveMatch(candidates) {
+	if (candidates.length === 0) return;
+	const scored = candidates.map((channel) => {
+		const isThread = channel.type === 11 || channel.type === 12;
+		return {
+			channel,
+			score: (Boolean(channel.archived) ? 0 : 2) + (isThread ? 0 : 1)
+		};
+	});
+	scored.sort((a, b) => b.score - a.score);
+	return scored[0]?.channel ?? candidates[0];
+}
+async function resolveDiscordChannelAllowlist(params) {
+	const token = resolveDiscordAllowlistToken(params.token);
+	if (!token) return buildDiscordUnresolvedResults(params.entries, (input) => ({
+		input,
+		resolved: false
+	}));
+	const fetcher = params.fetcher ?? fetch;
+	const guilds = await listGuilds(token, fetcher);
+	const channelsByGuild = /* @__PURE__ */ new Map();
+	const getChannels = (guildId) => {
+		const existing = channelsByGuild.get(guildId);
+		if (existing) return existing;
+		const promise = listGuildChannels(token, fetcher, guildId);
+		channelsByGuild.set(guildId, promise);
+		return promise;
+	};
+	const results = [];
+	for (const input of params.entries) {
+		const parsed = parseDiscordChannelInput(input);
+		if (parsed.guildOnly) {
+			const guild = filterDiscordGuilds(guilds, {
+				guildId: parsed.guildId,
+				guildName: parsed.guild
+			})[0];
+			if (guild) results.push({
+				input,
+				resolved: true,
+				guildId: guild.id,
+				guildName: guild.name
+			});
+			else results.push({
+				input,
+				resolved: false,
+				guildId: parsed.guildId,
+				guildName: parsed.guild
+			});
+			continue;
+		}
+		if (parsed.channelId) {
+			const channelId = parsed.channelId;
+			const result = await fetchChannel(token, fetcher, channelId);
+			if (result.status === "found") {
+				const channel = result.channel;
+				if (parsed.guildId && parsed.guildId !== channel.guildId) {
+					const expectedGuild = guilds.find((entry) => entry.id === parsed.guildId);
+					const actualGuild = guilds.find((entry) => entry.id === channel.guildId);
+					results.push({
+						input,
+						resolved: false,
+						guildId: parsed.guildId,
+						guildName: expectedGuild?.name,
+						channelId,
+						channelName: channel.name,
+						note: actualGuild?.name ? `channel belongs to guild ${actualGuild.name}` : "channel belongs to a different guild"
+					});
+					continue;
+				}
+				const guild = guilds.find((entry) => entry.id === channel.guildId);
+				results.push({
+					input,
+					resolved: true,
+					guildId: channel.guildId,
+					guildName: guild?.name,
+					channelId: channel.id,
+					channelName: channel.name,
+					archived: channel.archived
+				});
+				continue;
+			}
+			if (result.status === "not-found" && parsed.guildId) {
+				const guild = guilds.find((entry) => entry.id === parsed.guildId);
+				if (guild) {
+					const match = preferActiveMatch((await getChannels(guild.id)).filter((channel) => normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelId)));
+					if (match) {
+						results.push({
+							input,
+							resolved: true,
+							guildId: guild.id,
+							guildName: guild.name,
+							channelId: match.id,
+							channelName: match.name,
+							archived: match.archived
+						});
+						continue;
+					}
+				}
+			}
+			results.push({
+				input,
+				resolved: false,
+				guildId: parsed.guildId,
+				channelId
+			});
+			continue;
+		}
+		if (parsed.guildId || parsed.guild) {
+			const guild = filterDiscordGuilds(guilds, {
+				guildId: parsed.guildId,
+				guildName: parsed.guild
+			})[0];
+			const channelQuery = parsed.channel?.trim();
+			if (!guild || !channelQuery) {
+				results.push({
+					input,
+					resolved: false,
+					guildId: parsed.guildId,
+					guildName: parsed.guild,
+					channelName: channelQuery ?? parsed.channel
+				});
+				continue;
+			}
+			const channels = await getChannels(guild.id);
+			const normalizedChannelQuery = normalizeDiscordSlug(channelQuery);
+			const isNumericId = /^\d+$/.test(channelQuery);
+			let matches = channels.filter((channel) => isNumericId ? channel.id === channelQuery : normalizeDiscordSlug(channel.name) === normalizedChannelQuery);
+			if (isNumericId && matches.length === 0) matches = channels.filter((channel) => normalizeDiscordSlug(channel.name) === normalizedChannelQuery);
+			const match = preferActiveMatch(matches);
+			if (match) results.push({
+				input,
+				resolved: true,
+				guildId: guild.id,
+				guildName: guild.name,
+				channelId: match.id,
+				channelName: match.name,
+				archived: match.archived
+			});
+			else results.push({
+				input,
+				resolved: false,
+				guildId: guild.id,
+				guildName: guild.name,
+				channelName: parsed.channel,
+				note: `channel not found in guild ${guild.name}`
+			});
+			continue;
+		}
+		const channelName = input.trim().replace(/^#/, "");
+		if (!channelName) {
+			results.push({
+				input,
+				resolved: false,
+				channelName
+			});
+			continue;
+		}
+		const candidates = [];
+		for (const guild of guilds) {
+			const channels = await getChannels(guild.id);
+			for (const channel of channels) if (normalizeDiscordSlug(channel.name) === normalizeDiscordSlug(channelName)) candidates.push(channel);
+		}
+		const match = preferActiveMatch(candidates);
+		if (match) {
+			const guild = guilds.find((entry) => entry.id === match.guildId);
+			results.push({
+				input,
+				resolved: true,
+				guildId: match.guildId,
+				guildName: guild?.name,
+				channelId: match.id,
+				channelName: match.name,
+				archived: match.archived,
+				note: candidates.length > 1 && guild?.name ? `matched multiple; chose ${guild.name}` : void 0
+			});
+			continue;
+		}
+		results.push({
+			input,
+			resolved: false,
+			channelName
+		});
+	}
+	return results;
+}
+//#endregion
+export { resolveDiscordChannelAllowlist as t };

package/dist/resolve-channels-C1SthO1N.js

@@ -0,0 +1,226 @@
+import { ri as createSlackWebClient } from "./auth-profiles-9zZdaXJK.js";
+//#region extensions/slack/src/resolve-allowlist-common.ts
+function readSlackNextCursor(response) {
+	const next = response.response_metadata?.next_cursor?.trim();
+	return next ? next : void 0;
+}
+async function collectSlackCursorItems(params) {
+	const items = [];
+	let cursor;
+	do {
+		const response = await params.fetchPage(cursor);
+		items.push(...params.collectPageItems(response));
+		cursor = readSlackNextCursor(response);
+	} while (cursor);
+	return items;
+}
+function resolveSlackAllowlistEntries(params) {
+	const results = [];
+	for (const input of params.entries) {
+		const parsed = params.parseInput(input);
+		if (parsed.id) {
+			const match = params.findById(params.lookup, parsed.id);
+			results.push(params.buildIdResolved({
+				input,
+				parsed,
+				match
+			}));
+			continue;
+		}
+		const resolved = params.resolveNonId({
+			input,
+			parsed,
+			lookup: params.lookup
+		});
+		if (resolved) {
+			results.push(resolved);
+			continue;
+		}
+		results.push(params.buildUnresolved(input));
+	}
+	return results;
+}
+//#endregion
+//#region extensions/slack/src/resolve-users.ts
+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: trimmed.toLowerCase() };
+	const name = trimmed.replace(/^@/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackUsers(client) {
+	return collectSlackCursorItems({
+		fetchPage: async (cursor) => await client.users.list({
+			limit: 200,
+			cursor
+		}),
+		collectPageItems: (res) => (res.members ?? []).map((member) => {
+			const id = member.id?.trim();
+			const name = member.name?.trim();
+			if (!id || !name) return null;
+			const profile = member.profile ?? {};
+			return {
+				id,
+				name,
+				displayName: profile.display_name?.trim() || void 0,
+				realName: profile.real_name?.trim() || member.real_name?.trim() || void 0,
+				email: profile.email?.trim()?.toLowerCase() || void 0,
+				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 = match.name.toLowerCase();
+		if ([
+			user.name,
+			user.displayName,
+			user.realName
+		].map((value) => value?.toLowerCase()).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];
+	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 users = await listSlackUsers(params.client ?? createSlackWebClient(params.token));
+	return resolveSlackAllowlistEntries({
+		entries: params.entries,
+		lookup: users,
+		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 = parsed.name.toLowerCase();
+				const matches = lookup.filter((user) => {
+					return [
+						user.name,
+						user.displayName,
+						user.realName
+					].map((value) => value?.toLowerCase()).filter(Boolean).includes(target);
+				});
+				if (matches.length > 0) return resolveSlackUserFromMatches(input, matches, parsed);
+			}
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+}
+//#endregion
+//#region extensions/slack/src/resolve-channels.ts
+function parseSlackChannelMention(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<#([A-Z0-9]+)(?:\|([^>]+))?>$/i);
+	if (mention) return {
+		id: mention[1]?.toUpperCase(),
+		name: mention[2]?.trim()
+	};
+	const prefixed = trimmed.replace(/^(slack:|channel:)/i, "");
+	if (/^[CG][A-Z0-9]+$/i.test(prefixed)) return { id: prefixed.toUpperCase() };
+	const name = prefixed.replace(/^#/, "").trim();
+	return name ? { name } : {};
+}
+async function listSlackChannels(client) {
+	return collectSlackCursorItems({
+		fetchPage: async (cursor) => await client.conversations.list({
+			types: "public_channel,private_channel",
+			exclude_archived: false,
+			limit: 1e3,
+			cursor
+		}),
+		collectPageItems: (res) => (res.channels ?? []).map((channel) => {
+			const id = channel.id?.trim();
+			const name = channel.name?.trim();
+			if (!id || !name) return null;
+			return {
+				id,
+				name,
+				archived: Boolean(channel.is_archived),
+				isPrivate: Boolean(channel.is_private)
+			};
+		}).filter(Boolean)
+	});
+}
+function resolveByName(name, channels) {
+	const target = name.trim().toLowerCase();
+	if (!target) return;
+	const matches = channels.filter((channel) => channel.name.toLowerCase() === target);
+	if (matches.length === 0) return;
+	return matches.find((channel) => !channel.archived) ?? matches[0];
+}
+async function resolveSlackChannelAllowlist(params) {
+	const channels = await listSlackChannels(params.client ?? createSlackWebClient(params.token));
+	return resolveSlackAllowlistEntries({
+		entries: params.entries,
+		lookup: channels,
+		parseInput: parseSlackChannelMention,
+		findById: (lookup, id) => lookup.find((channel) => channel.id === id),
+		buildIdResolved: ({ input, parsed, match }) => ({
+			input,
+			resolved: true,
+			id: parsed.id,
+			name: match?.name ?? parsed.name,
+			archived: match?.archived
+		}),
+		resolveNonId: ({ input, parsed, lookup }) => {
+			if (!parsed.name) return;
+			const match = resolveByName(parsed.name, lookup);
+			if (!match) return;
+			return {
+				input,
+				resolved: true,
+				id: match.id,
+				name: match.name,
+				archived: match.archived
+			};
+		},
+		buildUnresolved: (input) => ({
+			input,
+			resolved: false
+		})
+	});
+}
+//#endregion
+export { resolveSlackUserAllowlist as n, resolveSlackChannelAllowlist as t };

package/dist/resolve-users-CgSxHrU0.js

@@ -0,0 +1,143 @@
+import { $S as normalizeDiscordToken, _t as fetchDiscord, nt as normalizeDiscordSlug } from "./auth-profiles-9zZdaXJK.js";
+//#region extensions/discord/src/guilds.ts
+async function listGuilds(token, fetcher) {
+	return (await fetchDiscord("/users/@me/guilds", token, fetcher)).filter((guild) => typeof guild.id === "string" && typeof guild.name === "string").map((guild) => ({
+		id: guild.id,
+		name: guild.name,
+		slug: normalizeDiscordSlug(guild.name)
+	}));
+}
+//#endregion
+//#region extensions/discord/src/resolve-allowlist-common.ts
+function resolveDiscordAllowlistToken(token) {
+	return normalizeDiscordToken(token, "channels.discord.token");
+}
+function buildDiscordUnresolvedResults(entries, buildResult) {
+	return entries.map((input) => buildResult(input));
+}
+function findDiscordGuildByName(guilds, input) {
+	const slug = normalizeDiscordSlug(input);
+	if (!slug) return;
+	return guilds.find((guild) => guild.slug === slug);
+}
+function filterDiscordGuilds(guilds, params) {
+	if (params.guildId) return guilds.filter((guild) => guild.id === params.guildId);
+	if (params.guildName) {
+		const match = findDiscordGuildByName(guilds, params.guildName);
+		return match ? [match] : [];
+	}
+	return guilds;
+}
+//#endregion
+//#region extensions/discord/src/resolve-users.ts
+function parseDiscordUserInput(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(/^<@!?(\d+)>$/);
+	if (mention) return { userId: mention[1] };
+	const prefixed = trimmed.match(/^(?:user:|discord:)?(\d+)$/i);
+	if (prefixed) return { userId: prefixed[1] };
+	const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
+	if (split.length >= 2) {
+		const guild = split[0]?.trim();
+		const user = split.slice(1).join("#").trim();
+		if (guild && /^\d+$/.test(guild)) return {
+			guildId: guild,
+			userName: user
+		};
+		return {
+			guildName: guild,
+			userName: user
+		};
+	}
+	return { userName: trimmed.replace(/^@/, "") };
+}
+function scoreDiscordMember(member, query) {
+	const q = query.toLowerCase();
+	const user = member.user;
+	const candidates = [
+		user.username,
+		user.global_name,
+		member.nick ?? void 0
+	].map((value) => value?.toLowerCase()).filter(Boolean);
+	let score = 0;
+	if (candidates.some((value) => value === q)) score += 3;
+	if (candidates.some((value) => value?.includes(q))) score += 1;
+	if (!user.bot) score += 1;
+	return score;
+}
+async function resolveDiscordUserAllowlist(params) {
+	const token = resolveDiscordAllowlistToken(params.token);
+	if (!token) return buildDiscordUnresolvedResults(params.entries, (input) => ({
+		input,
+		resolved: false
+	}));
+	const fetcher = params.fetcher ?? fetch;
+	let guilds = null;
+	const getGuilds = async () => {
+		if (!guilds) guilds = await listGuilds(token, fetcher);
+		return guilds;
+	};
+	const results = [];
+	for (const input of params.entries) {
+		const parsed = parseDiscordUserInput(input);
+		if (parsed.userId) {
+			results.push({
+				input,
+				resolved: true,
+				id: parsed.userId
+			});
+			continue;
+		}
+		const query = parsed.userName?.trim();
+		if (!query) {
+			results.push({
+				input,
+				resolved: false
+			});
+			continue;
+		}
+		const guildList = filterDiscordGuilds(await getGuilds(), {
+			guildId: parsed.guildId,
+			guildName: parsed.guildName?.trim()
+		});
+		let best = null;
+		let matches = 0;
+		for (const guild of guildList) {
+			const paramsObj = new URLSearchParams({
+				query,
+				limit: "25"
+			});
+			const members = await fetchDiscord(`/guilds/${guild.id}/members/search?${paramsObj.toString()}`, token, fetcher);
+			for (const member of members) {
+				const score = scoreDiscordMember(member, query);
+				if (score === 0) continue;
+				matches += 1;
+				if (!best || score > best.score) best = {
+					member,
+					guild,
+					score
+				};
+			}
+		}
+		if (best) {
+			const user = best.member.user;
+			const name = best.member.nick?.trim() || user.global_name?.trim() || user.username?.trim() || void 0;
+			results.push({
+				input,
+				resolved: true,
+				id: user.id,
+				name,
+				guildId: best.guild.id,
+				guildName: best.guild.name,
+				note: matches > 1 ? "multiple matches; chose best" : void 0
+			});
+		} else results.push({
+			input,
+			resolved: false
+		});
+	}
+	return results;
+}
+//#endregion
+export { listGuilds as a, resolveDiscordAllowlistToken as i, buildDiscordUnresolvedResults as n, filterDiscordGuilds as r, resolveDiscordUserAllowlist as t };