sealclaw 2026.6.21 → 2026.6.22-beta.2

package/dist/security-audit-CnxYeZDK.js

@@ -0,0 +1,118 @@
+import { a as readChannelAllowFromStore } from "./pairing-store-DsGzqUtj.js";
+import { r as resolveNativeSkillsEnabled } from "./commands-BIeknx-S.js";
+import "./conversation-runtime-DAuaOOHP.js";
+import "./native-command-config-runtime-SYHA-kNl.js";
+import { r as normalizeTelegramAllowFromEntry, t as isNumericTelegramSenderUserId } from "./allow-from-CxCcLhAZ.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-PIv4LiAv.js

@@ -0,0 +1,51 @@
+import { a as readChannelAllowFromStore } from "./pairing-store-DsGzqUtj.js";
+import { i as normalizeAllowFromList, t as coerceNativeSetting } from "./channel-policy-D-sji-7n.js";
+import { n as resolveNativeCommandsEnabled, r as resolveNativeSkillsEnabled } from "./commands-BIeknx-S.js";
+import "./conversation-runtime-DAuaOOHP.js";
+import "./native-command-config-runtime-SYHA-kNl.js";
+//#region extensions/slack/src/security-audit.ts
+async function collectSlackSecurityAuditFindings(params) {
+	const findings = [];
+	const slackCfg = params.account.config ?? {};
+	const accountId = params.accountId?.trim() || params.account.accountId || "default";
+	if (!(slackCfg.slashCommand?.enabled === true || resolveNativeCommandsEnabled({
+		providerId: "slack",
+		providerSetting: coerceNativeSetting(slackCfg.commands?.native),
+		globalSetting: params.cfg.commands?.native
+	}) || resolveNativeSkillsEnabled({
+		providerId: "slack",
+		providerSetting: coerceNativeSetting(slackCfg.commands?.nativeSkills),
+		globalSetting: params.cfg.commands?.nativeSkills
+	}))) return findings;
+	if (!(params.cfg.commands?.useAccessGroups !== false)) {
+		findings.push({
+			checkId: "channels.slack.commands.slash.useAccessGroups_off",
+			severity: "critical",
+			title: "Slack slash commands bypass access groups",
+			detail: "Slack slash/native commands are enabled while commands.useAccessGroups=false; this can allow unrestricted /… command execution from channels/users you didn't explicitly authorize.",
+			remediation: "Set commands.useAccessGroups=true (recommended)."
+		});
+		return findings;
+	}
+	const allowFromRaw = slackCfg.allowFrom;
+	const legacyAllowFromRaw = params.account.dm?.allowFrom;
+	const allowFrom = Array.isArray(allowFromRaw) ? allowFromRaw : Array.isArray(legacyAllowFromRaw) ? legacyAllowFromRaw : [];
+	const storeAllowFrom = await readChannelAllowFromStore("slack", process.env, accountId).catch(() => []);
+	const ownerAllowFromConfigured = normalizeAllowFromList([...allowFrom, ...storeAllowFrom]).length > 0;
+	const channels = slackCfg.channels ?? {};
+	const hasAnyChannelUsersAllowlist = Object.values(channels).some((value) => {
+		if (!value || typeof value !== "object") return false;
+		const channel = value;
+		return Array.isArray(channel.users) && channel.users.length > 0;
+	});
+	if (!ownerAllowFromConfigured && !hasAnyChannelUsersAllowlist) findings.push({
+		checkId: "channels.slack.commands.slash.no_allowlists",
+		severity: "warn",
+		title: "Slack slash commands have no allowlists",
+		detail: "Slack slash/native commands are enabled, but neither an owner allowFrom list nor any channels.<id>.users allowlist is configured; /… commands will be rejected for everyone.",
+		remediation: "Approve yourself via pairing (recommended), or set channels.slack.allowFrom and/or channels.slack.channels.<id>.users."
+	});
+	return findings;
+}
+//#endregion
+export { collectSlackSecurityAuditFindings as t };

package/dist/security-audit-y516uBqK.js

@@ -0,0 +1,122 @@
+import { a as readChannelAllowFromStore } from "./pairing-store-DsGzqUtj.js";
+import { i as normalizeAllowFromList, t as coerceNativeSetting } from "./channel-policy-D-sji-7n.js";
+import { n as isDangerousNameMatchingEnabled } from "./dangerous-name-matching-CG0ZuviF.js";
+import { n as resolveNativeCommandsEnabled, r as resolveNativeSkillsEnabled } from "./commands-BIeknx-S.js";
+import "./conversation-runtime-DAuaOOHP.js";
+import "./native-command-config-runtime-SYHA-kNl.js";
+import { t as isDiscordMutableAllowEntry } from "./security-doctor-DcT3wVkb.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: "~/.sealseek/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.runtime-saoKerPR.js

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

package/dist/security-audit.runtime.js

@@ -1 +1 @@
-export * from "./security-audit.runtime-BgaDHAe1.js";
+export * from "./security-audit.runtime-saoKerPR.js";

package/dist/selection-DzH_p5IU.js

@@ -0,0 +1,2 @@
+import { i as selectAgentHarness, n as resolveAgentHarnessPolicy, r as runAgentHarnessAttempt, t as maybeCompactAgentHarnessSession } from "./selection-eaosgACb.js";
+export { maybeCompactAgentHarnessSession, resolveAgentHarnessPolicy, runAgentHarnessAttempt, selectAgentHarness };