@gaodefa/daocore 2026.5.73 → 2026.5.75

package/dist/sanitize-outbound-BDtDO_r3.js

@@ -0,0 +1,127 @@
+import { a as normalizeLowercaseStringOrEmpty, c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { l as normalizeE164 } from "./utils-CNnMhEDp.js";
+import { i as stripAssistantInternalScaffolding } from "./assistant-visible-text-ZquuOr5C.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import "./core-B9JJc5bK.js";
+import "./media-runtime-BII00FWc.js";
+import "./text-chunking-ObhJDe8L.js";
+import "./account-resolution-DvO8jOO3.js";
+import "./status-helpers-nyf_mfYa.js";
+import "./channel-status-1yY-1IXP.js";
+import { c as parseIMessageTarget, o as normalizeIMessageHandle$1 } from "./targets-ByhFAk_l.js";
+//#region extensions/imessage/src/normalize.ts
+const SERVICE_PREFIXES = [
+	"imessage:",
+	"sms:",
+	"auto:"
+];
+const CHAT_TARGET_PREFIX_RE = /^(chat_id:|chatid:|chat:|chat_guid:|chatguid:|guid:|chat_identifier:|chatidentifier:|chatident:)/i;
+function looksLikeHandleOrPhoneTarget(params) {
+	const trimmed = params.raw.trim();
+	if (!trimmed) return false;
+	if (params.prefixPattern.test(trimmed)) return true;
+	if (trimmed.includes("@")) return true;
+	return (params.phonePattern ?? /^\+?\d{3,}$/).test(trimmed);
+}
+function normalizeIMessageHandle(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("imessage:")) return normalizeIMessageHandle(trimmed.slice(9));
+	if (lowered.startsWith("sms:")) return normalizeIMessageHandle(trimmed.slice(4));
+	if (lowered.startsWith("auto:")) return normalizeIMessageHandle(trimmed.slice(5));
+	if (CHAT_TARGET_PREFIX_RE.test(trimmed)) {
+		const prefix = trimmed.match(CHAT_TARGET_PREFIX_RE)?.[0];
+		if (!prefix) return "";
+		const value = trimmed.slice(prefix.length).trim();
+		return `${normalizeLowercaseStringOrEmpty(prefix)}${value}`;
+	}
+	if (trimmed.includes("@")) return normalizeLowercaseStringOrEmpty(trimmed);
+	const normalized = normalizeE164(trimmed);
+	if (normalized) return normalized;
+	return trimmed.replace(/\s+/g, "");
+}
+function normalizeIMessageMessagingTarget(raw) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return;
+	const lower = normalizeLowercaseStringOrEmpty(trimmed);
+	for (const prefix of SERVICE_PREFIXES) if (lower.startsWith(prefix)) {
+		const normalizedHandle = normalizeIMessageHandle(trimmed.slice(prefix.length).trim());
+		if (!normalizedHandle) return;
+		if (CHAT_TARGET_PREFIX_RE.test(normalizedHandle)) return normalizedHandle;
+		return `${prefix}${normalizedHandle}`;
+	}
+	return normalizeIMessageHandle(trimmed) || void 0;
+}
+function looksLikeIMessageTargetId(raw) {
+	const trimmed = normalizeOptionalString(raw);
+	if (!trimmed) return false;
+	if (CHAT_TARGET_PREFIX_RE.test(trimmed)) return true;
+	return looksLikeHandleOrPhoneTarget({
+		raw: trimmed,
+		prefixPattern: /^(imessage:|sms:|auto:)/i
+	});
+}
+//#endregion
+//#region extensions/imessage/src/conversation-id-core.ts
+function normalizeIMessageAcpConversationId(conversationId) {
+	const trimmed = conversationId.trim();
+	if (!trimmed) return null;
+	try {
+		const parsed = parseIMessageTarget(trimmed);
+		if (parsed.kind === "handle") {
+			const handle = normalizeIMessageHandle$1(parsed.to);
+			return handle ? { conversationId: handle } : null;
+		}
+		if (parsed.kind === "chat_id") return { conversationId: String(parsed.chatId) };
+		if (parsed.kind === "chat_guid") return { conversationId: parsed.chatGuid };
+		return { conversationId: parsed.chatIdentifier };
+	} catch {
+		const handle = normalizeIMessageHandle$1(trimmed);
+		return handle ? { conversationId: handle } : null;
+	}
+}
+function matchIMessageAcpConversation(params) {
+	const binding = normalizeIMessageAcpConversationId(params.bindingConversationId);
+	const conversation = normalizeIMessageAcpConversationId(params.conversationId);
+	if (!binding || !conversation) return null;
+	if (binding.conversationId !== conversation.conversationId) return null;
+	return {
+		conversationId: conversation.conversationId,
+		matchPriority: 2
+	};
+}
+function resolveIMessageConversationIdFromTarget(target) {
+	return normalizeIMessageAcpConversationId(target)?.conversationId;
+}
+//#endregion
+//#region extensions/imessage/src/conversation-id.ts
+function resolveIMessageInboundConversationId(params) {
+	if (params.isGroup) return params.chatId != null && Number.isFinite(params.chatId) ? String(params.chatId) : void 0;
+	return normalizeIMessageHandle$1(params.sender) || void 0;
+}
+//#endregion
+//#region extensions/imessage/src/monitor/sanitize-outbound.ts
+/**
+* Patterns that indicate assistant-internal metadata leaked into text.
+* These must never reach a user-facing channel.
+*/
+const INTERNAL_SEPARATOR_RE = /(?:#\+){2,}#?/g;
+const ASSISTANT_ROLE_MARKER_RE = /\bassistant\s+to\s*=\s*\w+/gi;
+const ROLE_TURN_MARKER_RE = /\b(?:user|system|assistant)\s*:\s*$/gm;
+/**
+* Strip all assistant-internal scaffolding from outbound text before delivery.
+* Applies reasoning/thinking tag removal, memory tag removal, and
+* model-specific internal separator stripping.
+*/
+function sanitizeOutboundText(text) {
+	if (!text) return text;
+	let cleaned = stripAssistantInternalScaffolding(text);
+	cleaned = cleaned.replace(INTERNAL_SEPARATOR_RE, "");
+	cleaned = cleaned.replace(ASSISTANT_ROLE_MARKER_RE, "");
+	cleaned = cleaned.replace(ROLE_TURN_MARKER_RE, "");
+	cleaned = cleaned.replace(/\n{3,}/g, "\n\n").trim();
+	return cleaned;
+}
+//#endregion
+export { resolveIMessageConversationIdFromTarget as a, normalizeIMessageAcpConversationId as i, resolveIMessageInboundConversationId as n, looksLikeIMessageTargetId as o, matchIMessageAcpConversation as r, normalizeIMessageMessagingTarget as s, sanitizeOutboundText as t };

package/dist/sdk-setup-tools-Bw1sb2J0.js

@@ -0,0 +1,8 @@
+import "./runtime-env-BSECk1Nm.js";
+import "./setup-tools-BOGdbXzZ.js";
+import "./media-runtime-BII00FWc.js";
+import "./media-mime-j2Nhr7Df.js";
+import "./cli-runtime-DzLh8RWR.js";
+import "./agent-harness-runtime-Bt2xTt2z.js";
+import "./channel-actions-BEsMIO8Q.js";
+export {};

package/dist/secrets-Cexd83PL.js

@@ -0,0 +1,113 @@
+import { l as loadAuthProfileStoreWithoutExternalProfiles, p as updateAuthProfileStoreWithLock } from "./store-Ik30AbRk.js";
+import "./provider-auth-BcCl82SN.js";
+import "./agent-runtime-DDBYT9PU.js";
+import { o as parseEnv, u as readText } from "./helpers-w2CyK9G6.js";
+import { c as HERMES_REASON_SECRET_NO_LONGER_PRESENT, d as hermesItemConflict, f as hermesItemError, h as readHermesSecretDetails, n as HERMES_REASON_AUTH_PROFILE_EXISTS, p as hermesItemSkipped, r as HERMES_REASON_AUTH_PROFILE_WRITE_FAILED, s as HERMES_REASON_MISSING_SECRET_METADATA, u as createHermesSecretItem } from "./items-EdIOLB5m.js";
+//#region extensions/migrate-hermes/secrets.ts
+const SECRET_MAPPINGS = [
+	{
+		envVar: "OPENAI_API_KEY",
+		provider: "openai",
+		profileId: "openai:hermes-import"
+	},
+	{
+		envVar: "ANTHROPIC_API_KEY",
+		provider: "anthropic",
+		profileId: "anthropic:hermes-import"
+	},
+	{
+		envVar: "OPENROUTER_API_KEY",
+		provider: "openrouter",
+		profileId: "openrouter:hermes-import"
+	},
+	{
+		envVar: "GOOGLE_API_KEY",
+		provider: "google",
+		profileId: "google:hermes-import"
+	},
+	{
+		envVar: "GEMINI_API_KEY",
+		provider: "google",
+		profileId: "google:hermes-import"
+	},
+	{
+		envVar: "GROQ_API_KEY",
+		provider: "groq",
+		profileId: "groq:hermes-import"
+	},
+	{
+		envVar: "XAI_API_KEY",
+		provider: "xai",
+		profileId: "xai:hermes-import"
+	},
+	{
+		envVar: "MISTRAL_API_KEY",
+		provider: "mistral",
+		profileId: "mistral:hermes-import"
+	},
+	{
+		envVar: "DEEPSEEK_API_KEY",
+		provider: "deepseek",
+		profileId: "deepseek:hermes-import"
+	}
+];
+async function buildSecretItems(params) {
+	const env = parseEnv(await readText(params.source.envPath));
+	const store = loadAuthProfileStoreWithoutExternalProfiles(params.targets.agentDir);
+	const seenProfiles = /* @__PURE__ */ new Set();
+	const items = [];
+	for (const mapping of SECRET_MAPPINGS) {
+		if (!env[mapping.envVar]?.trim() || seenProfiles.has(mapping.profileId)) continue;
+		seenProfiles.add(mapping.profileId);
+		const existsAlready = Boolean(store.profiles[mapping.profileId]);
+		items.push(createHermesSecretItem({
+			id: `secret:${mapping.provider}`,
+			source: params.source.envPath,
+			target: `${params.targets.agentDir}/auth-profiles.json#${mapping.profileId}`,
+			includeSecrets: params.ctx.includeSecrets,
+			existsAlready: existsAlready && !params.ctx.overwrite,
+			details: {
+				envVar: mapping.envVar,
+				provider: mapping.provider,
+				profileId: mapping.profileId
+			}
+		}));
+	}
+	return items;
+}
+async function applySecretItem(ctx, item, targets) {
+	if (item.status !== "planned") return item;
+	const details = readHermesSecretDetails(item);
+	const source = item.source;
+	if (!details || !source) return hermesItemError(item, HERMES_REASON_MISSING_SECRET_METADATA);
+	const key = parseEnv(await readText(source))[details.envVar]?.trim();
+	if (!key) return hermesItemSkipped(item, HERMES_REASON_SECRET_NO_LONGER_PRESENT);
+	let conflicted = false;
+	let wrote = false;
+	const store = await updateAuthProfileStoreWithLock({
+		agentDir: targets.agentDir,
+		updater: (freshStore) => {
+			if (!ctx.overwrite && freshStore.profiles[details.profileId]) {
+				conflicted = true;
+				return false;
+			}
+			freshStore.profiles[details.profileId] = {
+				type: "api_key",
+				provider: details.provider,
+				key,
+				displayName: "Hermes import"
+			};
+			wrote = true;
+			return true;
+		}
+	});
+	if (conflicted) return hermesItemConflict(item, HERMES_REASON_AUTH_PROFILE_EXISTS);
+	if (!store?.profiles[details.profileId]) return hermesItemError(item, HERMES_REASON_AUTH_PROFILE_WRITE_FAILED);
+	if (!wrote && !ctx.overwrite) return hermesItemConflict(item, HERMES_REASON_AUTH_PROFILE_EXISTS);
+	return {
+		...item,
+		status: "migrated"
+	};
+}
+//#endregion
+export { buildSecretItems as n, applySecretItem as t };

package/dist/security-audit-DeMasGQi.js

@@ -0,0 +1,122 @@
+import { a as readChannelAllowFromStore } from "./pairing-store-D6kKcRDP.js";
+import { i as normalizeAllowFromList, t as coerceNativeSetting } from "./channel-policy-Be-Ujzjr.js";
+import { n as isDangerousNameMatchingEnabled } from "./dangerous-name-matching-jjAiM0PK.js";
+import { n as resolveNativeCommandsEnabled, r as resolveNativeSkillsEnabled } from "./commands-CJmR93qR.js";
+import "./conversation-runtime-B8IRh0X_.js";
+import "./native-command-config-runtime-cXDA9h2f.js";
+import { t as isDiscordMutableAllowEntry } from "./security-doctor-uUo8hTD5.js";
+//#region extensions/discord/src/security-audit.ts
+function normalizeOptionalString(value) {
+	const normalized = value?.trim();
+	return normalized ? normalized : void 0;
+}
+function addDiscordNameBasedEntries(params) {
+	if (!Array.isArray(params.values)) return;
+	for (const value of params.values) {
+		if (!isDiscordMutableAllowEntry(String(value))) continue;
+		const text = normalizeOptionalString(String(value)) ?? "";
+		if (!text) continue;
+		params.target.add(`${params.source}:${text}`);
+	}
+}
+async function collectDiscordSecurityAuditFindings(params) {
+	const findings = [];
+	const discordCfg = params.account.config ?? {};
+	const accountId = normalizeOptionalString(params.accountId) ?? params.account.accountId ?? "default";
+	const dangerousNameMatchingEnabled = isDangerousNameMatchingEnabled(discordCfg);
+	const storeAllowFrom = await readChannelAllowFromStore("discord", process.env, accountId).catch(() => []);
+	const discordNameBasedAllowEntries = /* @__PURE__ */ new Set();
+	const discordPathPrefix = params.orderedAccountIds.length > 1 || params.hasExplicitAccountPath ? `channels.discord.accounts.${accountId}` : "channels.discord";
+	addDiscordNameBasedEntries({
+		target: discordNameBasedAllowEntries,
+		values: discordCfg.allowFrom,
+		source: `${discordPathPrefix}.allowFrom`
+	});
+	addDiscordNameBasedEntries({
+		target: discordNameBasedAllowEntries,
+		values: discordCfg.dm?.allowFrom,
+		source: `${discordPathPrefix}.dm.allowFrom`
+	});
+	addDiscordNameBasedEntries({
+		target: discordNameBasedAllowEntries,
+		values: storeAllowFrom,
+		source: "~/.daocore/credentials/discord-allowFrom.json"
+	});
+	const guildEntries = discordCfg.guilds ?? {};
+	for (const [guildKey, guildValue] of Object.entries(guildEntries)) {
+		if (!guildValue || typeof guildValue !== "object") continue;
+		const guild = guildValue;
+		addDiscordNameBasedEntries({
+			target: discordNameBasedAllowEntries,
+			values: guild.users,
+			source: `${discordPathPrefix}.guilds.${guildKey}.users`
+		});
+		const channels = guild.channels;
+		if (!channels || typeof channels !== "object") continue;
+		for (const [channelKey, channelValue] of Object.entries(channels)) {
+			if (!channelValue || typeof channelValue !== "object") continue;
+			addDiscordNameBasedEntries({
+				target: discordNameBasedAllowEntries,
+				values: channelValue.users,
+				source: `${discordPathPrefix}.guilds.${guildKey}.channels.${channelKey}.users`
+			});
+		}
+	}
+	if (discordNameBasedAllowEntries.size > 0) {
+		const examples = Array.from(discordNameBasedAllowEntries).slice(0, 5);
+		const more = discordNameBasedAllowEntries.size > examples.length ? ` (+${discordNameBasedAllowEntries.size - examples.length} more)` : "";
+		findings.push({
+			checkId: "channels.discord.allowFrom.name_based_entries",
+			severity: dangerousNameMatchingEnabled ? "info" : "warn",
+			title: dangerousNameMatchingEnabled ? "Discord allowlist uses break-glass name/tag matching" : "Discord allowlist contains name or tag entries",
+			detail: dangerousNameMatchingEnabled ? `Discord name/tag allowlist matching is explicitly enabled via dangerouslyAllowNameMatching. This mutable-identity mode is operator-selected break-glass behavior and out-of-scope for vulnerability reports by itself. Found: ${examples.join(", ")}${more}.` : `Discord name/tag allowlist matching uses normalized slugs and can collide across users. Found: ${examples.join(", ")}${more}.`,
+			remediation: dangerousNameMatchingEnabled ? "Prefer stable Discord IDs (or <@id>/user:<id>/pk:<id>), then disable dangerouslyAllowNameMatching." : "Prefer stable Discord IDs (or <@id>/user:<id>/pk:<id>) in channels.discord.allowFrom and channels.discord.guilds.*.users, or explicitly opt in with dangerouslyAllowNameMatching=true if you accept the risk."
+		});
+	}
+	const nativeEnabled = resolveNativeCommandsEnabled({
+		providerId: "discord",
+		providerSetting: coerceNativeSetting(discordCfg.commands?.native),
+		globalSetting: params.cfg.commands?.native
+	});
+	const nativeSkillsEnabled = resolveNativeSkillsEnabled({
+		providerId: "discord",
+		providerSetting: coerceNativeSetting(discordCfg.commands?.nativeSkills),
+		globalSetting: params.cfg.commands?.nativeSkills
+	});
+	if (!nativeEnabled && !nativeSkillsEnabled) return findings;
+	const defaultGroupPolicy = params.cfg.channels?.defaults?.groupPolicy;
+	const groupPolicy = discordCfg.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+	const guildsConfigured = Object.keys(guildEntries).length > 0;
+	const hasAnyUserAllowlist = Object.values(guildEntries).some((guild) => {
+		if (!guild || typeof guild !== "object") return false;
+		const record = guild;
+		if (Array.isArray(record.users) && record.users.length > 0) return true;
+		const channels = record.channels;
+		if (!channels || typeof channels !== "object") return false;
+		return Object.values(channels).some((channel) => {
+			if (!channel || typeof channel !== "object") return false;
+			const channelRecord = channel;
+			return Array.isArray(channelRecord.users) && channelRecord.users.length > 0;
+		});
+	});
+	const dmAllowFromRaw = discordCfg.dm?.allowFrom;
+	const ownerAllowFromConfigured = normalizeAllowFromList([...Array.isArray(dmAllowFromRaw) ? dmAllowFromRaw : [], ...storeAllowFrom]).length > 0;
+	const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
+	if (!useAccessGroups && groupPolicy !== "disabled" && guildsConfigured && !hasAnyUserAllowlist) findings.push({
+		checkId: "channels.discord.commands.native.unrestricted",
+		severity: "critical",
+		title: "Discord slash commands are unrestricted",
+		detail: "commands.useAccessGroups=false disables sender allowlists for Discord slash commands unless a per-guild/channel users allowlist is configured; with no users allowlist, any user in allowed guild channels can invoke /… commands.",
+		remediation: "Set commands.useAccessGroups=true (recommended), or configure channels.discord.guilds.<id>.users (or channels.discord.guilds.<id>.channels.<channel>.users)."
+	});
+	else if (useAccessGroups && groupPolicy !== "disabled" && guildsConfigured && !ownerAllowFromConfigured && !hasAnyUserAllowlist) findings.push({
+		checkId: "channels.discord.commands.native.no_allowlists",
+		severity: "warn",
+		title: "Discord slash commands have no allowlists",
+		detail: "Discord slash commands are enabled, but neither an owner allowFrom list nor any per-guild/channel users allowlist is configured; /… commands will be rejected for everyone.",
+		remediation: "Add your user id to channels.discord.allowFrom (or approve yourself via pairing), or configure channels.discord.guilds.<id>.users."
+	});
+	return findings;
+}
+//#endregion
+export { collectDiscordSecurityAuditFindings as t };

package/dist/security-audit-lZXBiK8a.js

@@ -0,0 +1,118 @@
+import { a as readChannelAllowFromStore } from "./pairing-store-D6kKcRDP.js";
+import { r as resolveNativeSkillsEnabled } from "./commands-CJmR93qR.js";
+import "./conversation-runtime-B8IRh0X_.js";
+import "./native-command-config-runtime-cXDA9h2f.js";
+import { r as normalizeTelegramAllowFromEntry, t as isNumericTelegramSenderUserId } from "./allow-from-Byf7JKVc.js";
+//#region extensions/telegram/src/security-audit.ts
+function normalizeOptionalString(value) {
+	const normalized = value?.trim();
+	return normalized ? normalized : void 0;
+}
+function collectInvalidTelegramAllowFromEntries(params) {
+	if (!Array.isArray(params.entries)) return;
+	for (const entry of params.entries) {
+		const normalized = normalizeTelegramAllowFromEntry(entry);
+		if (!normalized || normalized === "*") continue;
+		if (!isNumericTelegramSenderUserId(normalized)) params.target.add(normalized);
+	}
+}
+function appendInvalidTelegramAllowFromFinding(findings, invalidTelegramAllowFromEntries) {
+	if (invalidTelegramAllowFromEntries.size === 0) return;
+	const examples = Array.from(invalidTelegramAllowFromEntries).slice(0, 5);
+	const more = invalidTelegramAllowFromEntries.size > examples.length ? ` (+${invalidTelegramAllowFromEntries.size - examples.length} more)` : "";
+	findings.push({
+		checkId: "channels.telegram.allowFrom.invalid_entries",
+		severity: "warn",
+		title: "Telegram allowlist contains non-numeric entries",
+		detail: `Telegram sender authorization requires numeric Telegram user IDs. Found non-numeric allowFrom entries: ${examples.join(", ")}${more}.`,
+		remediation: "Replace @username entries with numeric Telegram user IDs (use setup to resolve), then re-run the audit."
+	});
+}
+async function collectTelegramSecurityAuditFindings(params) {
+	const findings = [];
+	const telegramCfg = params.account.config ?? {};
+	const accountId = normalizeOptionalString(params.accountId) ?? params.account.accountId ?? "default";
+	const invalidTelegramAllowFromEntries = /* @__PURE__ */ new Set();
+	collectInvalidTelegramAllowFromEntries({
+		entries: Array.isArray(telegramCfg.allowFrom) ? telegramCfg.allowFrom : [],
+		target: invalidTelegramAllowFromEntries
+	});
+	if (params.cfg.commands?.text === false) {
+		appendInvalidTelegramAllowFromFinding(findings, invalidTelegramAllowFromEntries);
+		return findings;
+	}
+	const defaultGroupPolicy = params.cfg.channels?.defaults?.groupPolicy;
+	const groupPolicy = telegramCfg.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+	const groups = telegramCfg.groups;
+	const groupsConfigured = Boolean(groups) && Object.keys(groups ?? {}).length > 0;
+	if (!(groupPolicy === "open" || groupPolicy === "allowlist" && groupsConfigured)) {
+		appendInvalidTelegramAllowFromFinding(findings, invalidTelegramAllowFromEntries);
+		return findings;
+	}
+	const storeAllowFrom = await readChannelAllowFromStore("telegram", process.env, accountId).catch(() => []);
+	const storeHasWildcard = storeAllowFrom.some((value) => (normalizeOptionalString(value) ?? "") === "*");
+	collectInvalidTelegramAllowFromEntries({
+		entries: storeAllowFrom,
+		target: invalidTelegramAllowFromEntries
+	});
+	const groupAllowFrom = Array.isArray(telegramCfg.groupAllowFrom) ? telegramCfg.groupAllowFrom : [];
+	const groupAllowFromHasWildcard = groupAllowFrom.some((value) => (normalizeOptionalString(String(value)) ?? "") === "*");
+	collectInvalidTelegramAllowFromEntries({
+		entries: groupAllowFrom,
+		target: invalidTelegramAllowFromEntries
+	});
+	let anyGroupOverride = false;
+	if (groups) for (const value of Object.values(groups)) {
+		if (!value || typeof value !== "object") continue;
+		const group = value;
+		const allowFrom = Array.isArray(group.allowFrom) ? group.allowFrom : [];
+		if (allowFrom.length > 0) {
+			anyGroupOverride = true;
+			collectInvalidTelegramAllowFromEntries({
+				entries: allowFrom,
+				target: invalidTelegramAllowFromEntries
+			});
+		}
+		const topics = group.topics;
+		if (!topics || typeof topics !== "object") continue;
+		for (const topicValue of Object.values(topics)) {
+			if (!topicValue || typeof topicValue !== "object") continue;
+			const topic = topicValue;
+			const topicAllow = Array.isArray(topic.allowFrom) ? topic.allowFrom : [];
+			if (topicAllow.length > 0) anyGroupOverride = true;
+			collectInvalidTelegramAllowFromEntries({
+				entries: topicAllow,
+				target: invalidTelegramAllowFromEntries
+			});
+		}
+	}
+	const hasAnySenderAllowlist = storeAllowFrom.length > 0 || groupAllowFrom.length > 0 || anyGroupOverride;
+	appendInvalidTelegramAllowFromFinding(findings, invalidTelegramAllowFromEntries);
+	if (storeHasWildcard || groupAllowFromHasWildcard) {
+		findings.push({
+			checkId: "channels.telegram.groups.allowFrom.wildcard",
+			severity: "critical",
+			title: "Telegram group allowlist contains wildcard",
+			detail: "Telegram group sender allowlist contains \"*\", which allows any group member to run /… commands and control directives.",
+			remediation: "Remove \"*\" from channels.telegram.groupAllowFrom and pairing store; prefer explicit numeric Telegram user IDs."
+		});
+		return findings;
+	}
+	if (!hasAnySenderAllowlist) {
+		const skillsEnabled = resolveNativeSkillsEnabled({
+			providerId: "telegram",
+			providerSetting: telegramCfg.commands?.nativeSkills,
+			globalSetting: params.cfg.commands?.nativeSkills
+		});
+		findings.push({
+			checkId: "channels.telegram.groups.allowFrom.missing",
+			severity: "critical",
+			title: "Telegram group commands have no sender allowlist",
+			detail: `Telegram group access is enabled but no sender allowlist is configured; this allows any group member to invoke /… commands` + (skillsEnabled ? " (including skill commands)." : "."),
+			remediation: "Approve yourself via pairing (recommended), or set channels.telegram.groupAllowFrom (or per-group groups.<id>.allowFrom)."
+		});
+	}
+	return findings;
+}
+//#endregion
+export { collectTelegramSecurityAuditFindings as t };

package/dist/security-audit.runtime-B73uav0c.js

@@ -0,0 +1,2 @@
+import { t as collectDiscordSecurityAuditFindings } from "./security-audit-DeMasGQi.js";
+export { collectDiscordSecurityAuditFindings };

package/dist/security-audit.runtime.js

@@ -1 +1 @@
-export * from "./security-audit.runtime-nBiU375z.js";
+export * from "./security-audit.runtime-B73uav0c.js";