@noxsoft/anima 2.0.2 → 2.0.4

package/dist/pi-tools.policy-xYdDLEv9.js

@@ -0,0 +1,200 @@
+import { S as resolveThreadParentSessionKey, d as resolveAgentIdFromSessionKey } from "./session-key-CQT-NR6w.js";
+import { n as resolveAgentConfig } from "./agent-scope-DZgptr9J.js";
+import { l as normalizeMessageChannel } from "./message-channel-dua8OOGJ.js";
+import { c as resolveChannelGroupToolsPolicy, t as getChannelDock } from "./dock-BdXLb5oY.js";
+import { b as matchesAnyGlobPattern, g as normalizeToolName, h as expandToolGroups, y as compileGlobPatterns } from "./sandbox-CJTS3er6.js";
+
+//#region src/agents/pi-tools.policy.ts
+function makeToolPolicyMatcher(policy) {
+	const deny = compileGlobPatterns({
+		raw: expandToolGroups(policy.deny ?? []),
+		normalize: normalizeToolName
+	});
+	const allow = compileGlobPatterns({
+		raw: expandToolGroups(policy.allow ?? []),
+		normalize: normalizeToolName
+	});
+	return (name) => {
+		const normalized = normalizeToolName(name);
+		if (matchesAnyGlobPattern(normalized, deny)) return false;
+		if (allow.length === 0) return true;
+		if (matchesAnyGlobPattern(normalized, allow)) return true;
+		if (normalized === "apply_patch" && matchesAnyGlobPattern("exec", allow)) return true;
+		return false;
+	};
+}
+/**
+* Tools always denied for sub-agents regardless of depth.
+* These are system-level or interactive tools that sub-agents should never use.
+*/
+const SUBAGENT_TOOL_DENY_ALWAYS = [
+	"gateway",
+	"agents_list",
+	"whatsapp_login",
+	"session_status",
+	"cron",
+	"memory_search",
+	"memory_get",
+	"sessions_send"
+];
+/**
+* Additional tools denied for leaf sub-agents (depth >= maxSpawnDepth).
+* These are tools that only make sense for orchestrator sub-agents that can spawn children.
+*/
+const SUBAGENT_TOOL_DENY_LEAF = [
+	"sessions_list",
+	"sessions_history",
+	"sessions_spawn"
+];
+/**
+* Build the deny list for a sub-agent at a given depth.
+*
+* - Depth 1 with maxSpawnDepth >= 2 (orchestrator): allowed to use sessions_spawn,
+*   subagents, sessions_list, sessions_history so it can manage its children.
+* - Depth >= maxSpawnDepth (leaf): denied sessions_spawn and
+*   session management tools. Still allowed subagents (for list/status visibility).
+*/
+function resolveSubagentDenyList(depth, maxSpawnDepth) {
+	if (depth >= Math.max(1, Math.floor(maxSpawnDepth))) return [...SUBAGENT_TOOL_DENY_ALWAYS, ...SUBAGENT_TOOL_DENY_LEAF];
+	return [...SUBAGENT_TOOL_DENY_ALWAYS];
+}
+function resolveSubagentToolPolicy(cfg, depth) {
+	const configured = cfg?.tools?.subagents?.tools;
+	const maxSpawnDepth = cfg?.agents?.defaults?.subagents?.maxSpawnDepth ?? 1;
+	const deny = [...resolveSubagentDenyList(typeof depth === "number" && depth >= 0 ? depth : 1, maxSpawnDepth), ...Array.isArray(configured?.deny) ? configured.deny : []];
+	return {
+		allow: Array.isArray(configured?.allow) ? configured.allow : void 0,
+		deny
+	};
+}
+function isToolAllowedByPolicyName(name, policy) {
+	if (!policy) return true;
+	return makeToolPolicyMatcher(policy)(name);
+}
+function filterToolsByPolicy(tools, policy) {
+	if (!policy) return tools;
+	const matcher = makeToolPolicyMatcher(policy);
+	return tools.filter((tool) => matcher(tool.name));
+}
+function unionAllow(base, extra) {
+	if (!Array.isArray(extra) || extra.length === 0) return base;
+	if (!Array.isArray(base) || base.length === 0) return Array.from(new Set(["*", ...extra]));
+	return Array.from(new Set([...base, ...extra]));
+}
+function pickToolPolicy(config) {
+	if (!config) return;
+	const allow = Array.isArray(config.allow) ? unionAllow(config.allow, config.alsoAllow) : Array.isArray(config.alsoAllow) && config.alsoAllow.length > 0 ? unionAllow(void 0, config.alsoAllow) : void 0;
+	const deny = Array.isArray(config.deny) ? config.deny : void 0;
+	if (!allow && !deny) return;
+	return {
+		allow,
+		deny
+	};
+}
+function normalizeProviderKey(value) {
+	return value.trim().toLowerCase();
+}
+function resolveGroupContextFromSessionKey(sessionKey) {
+	const raw = (sessionKey ?? "").trim();
+	if (!raw) return {};
+	const parts = (resolveThreadParentSessionKey(raw) ?? raw).split(":").filter(Boolean);
+	let body = parts[0] === "agent" ? parts.slice(2) : parts;
+	if (body[0] === "subagent") body = body.slice(1);
+	if (body.length < 3) return {};
+	const [channel, kind, ...rest] = body;
+	if (kind !== "group" && kind !== "channel") return {};
+	const groupId = rest.join(":").trim();
+	if (!groupId) return {};
+	return {
+		channel: channel.trim().toLowerCase(),
+		groupId
+	};
+}
+function resolveProviderToolPolicy(params) {
+	const provider = params.modelProvider?.trim();
+	if (!provider || !params.byProvider) return;
+	const entries = Object.entries(params.byProvider);
+	if (entries.length === 0) return;
+	const lookup = /* @__PURE__ */ new Map();
+	for (const [key, value] of entries) {
+		const normalized = normalizeProviderKey(key);
+		if (!normalized) continue;
+		lookup.set(normalized, value);
+	}
+	const normalizedProvider = normalizeProviderKey(provider);
+	const rawModelId = params.modelId?.trim().toLowerCase();
+	const fullModelId = rawModelId && !rawModelId.includes("/") ? `${normalizedProvider}/${rawModelId}` : rawModelId;
+	const candidates = [...fullModelId ? [fullModelId] : [], normalizedProvider];
+	for (const key of candidates) {
+		const match = lookup.get(key);
+		if (match) return match;
+	}
+}
+function resolveEffectiveToolPolicy(params) {
+	const agentId = params.sessionKey ? resolveAgentIdFromSessionKey(params.sessionKey) : void 0;
+	const agentTools = (params.config && agentId ? resolveAgentConfig(params.config, agentId) : void 0)?.tools;
+	const globalTools = params.config?.tools;
+	const profile = agentTools?.profile ?? globalTools?.profile;
+	const providerPolicy = resolveProviderToolPolicy({
+		byProvider: globalTools?.byProvider,
+		modelProvider: params.modelProvider,
+		modelId: params.modelId
+	});
+	const agentProviderPolicy = resolveProviderToolPolicy({
+		byProvider: agentTools?.byProvider,
+		modelProvider: params.modelProvider,
+		modelId: params.modelId
+	});
+	return {
+		agentId,
+		globalPolicy: pickToolPolicy(globalTools),
+		globalProviderPolicy: pickToolPolicy(providerPolicy),
+		agentPolicy: pickToolPolicy(agentTools),
+		agentProviderPolicy: pickToolPolicy(agentProviderPolicy),
+		profile,
+		providerProfile: agentProviderPolicy?.profile ?? providerPolicy?.profile,
+		profileAlsoAllow: Array.isArray(agentTools?.alsoAllow) ? agentTools?.alsoAllow : Array.isArray(globalTools?.alsoAllow) ? globalTools?.alsoAllow : void 0,
+		providerProfileAlsoAllow: Array.isArray(agentProviderPolicy?.alsoAllow) ? agentProviderPolicy?.alsoAllow : Array.isArray(providerPolicy?.alsoAllow) ? providerPolicy?.alsoAllow : void 0
+	};
+}
+function resolveGroupToolPolicy(params) {
+	if (!params.config) return;
+	const sessionContext = resolveGroupContextFromSessionKey(params.sessionKey);
+	const spawnedContext = resolveGroupContextFromSessionKey(params.spawnedBy);
+	const groupId = params.groupId ?? sessionContext.groupId ?? spawnedContext.groupId;
+	if (!groupId) return;
+	const channel = normalizeMessageChannel(params.messageProvider ?? sessionContext.channel ?? spawnedContext.channel);
+	if (!channel) return;
+	let dock;
+	try {
+		dock = getChannelDock(channel);
+	} catch {
+		dock = void 0;
+	}
+	return pickToolPolicy(dock?.groups?.resolveToolPolicy?.({
+		cfg: params.config,
+		groupId,
+		groupChannel: params.groupChannel,
+		groupSpace: params.groupSpace,
+		accountId: params.accountId,
+		senderId: params.senderId,
+		senderName: params.senderName,
+		senderUsername: params.senderUsername,
+		senderE164: params.senderE164
+	}) ?? resolveChannelGroupToolsPolicy({
+		cfg: params.config,
+		channel,
+		groupId,
+		accountId: params.accountId,
+		senderId: params.senderId,
+		senderName: params.senderName,
+		senderUsername: params.senderUsername,
+		senderE164: params.senderE164
+	}));
+}
+function isToolAllowedByPolicies(name, policies) {
+	return policies.every((policy) => isToolAllowedByPolicyName(name, policy));
+}
+
+//#endregion
+export { resolveSubagentToolPolicy as a, resolveGroupToolPolicy as i, isToolAllowedByPolicies as n, resolveEffectiveToolPolicy as r, filterToolsByPolicy as t };

package/dist/plugin-auto-enable-CViVVWgg.js

@@ -0,0 +1,282 @@
+import { ot as getChatChannelMeta, st as listChatChannels, ut as normalizeChatChannelId } from "./entry.js";
+import { j as normalizeProviderId } from "./auth-profiles-CxSHydjn.js";
+import { d as isRecord } from "./utils-DT8uXjFS.js";
+import { t as hasAnyWhatsAppAuth } from "./accounts-D8CPKNkN.js";
+import { n as getChannelPluginCatalogEntry, r as listChannelPluginCatalogEntries } from "./catalog-DMfEg-oK.js";
+
+//#region src/config/plugin-auto-enable.ts
+const CHANNEL_PLUGIN_IDS = Array.from(new Set([...listChatChannels().map((meta) => meta.id), ...listChannelPluginCatalogEntries().map((entry) => entry.id)]));
+const PROVIDER_PLUGIN_IDS = [
+	{
+		pluginId: "google-antigravity-auth",
+		providerId: "google-antigravity"
+	},
+	{
+		pluginId: "google-gemini-cli-auth",
+		providerId: "google-gemini-cli"
+	},
+	{
+		pluginId: "qwen-portal-auth",
+		providerId: "qwen-portal"
+	},
+	{
+		pluginId: "copilot-proxy",
+		providerId: "copilot-proxy"
+	},
+	{
+		pluginId: "minimax-portal-auth",
+		providerId: "minimax-portal"
+	}
+];
+function hasNonEmptyString(value) {
+	return typeof value === "string" && value.trim().length > 0;
+}
+function recordHasKeys(value) {
+	return isRecord(value) && Object.keys(value).length > 0;
+}
+function accountsHaveKeys(value, keys) {
+	if (!isRecord(value)) return false;
+	for (const account of Object.values(value)) {
+		if (!isRecord(account)) continue;
+		for (const key of keys) if (hasNonEmptyString(account[key])) return true;
+	}
+	return false;
+}
+function resolveChannelConfig(cfg, channelId) {
+	const entry = cfg.channels?.[channelId];
+	return isRecord(entry) ? entry : null;
+}
+function isTelegramConfigured(cfg, env) {
+	if (hasNonEmptyString(env.TELEGRAM_BOT_TOKEN)) return true;
+	const entry = resolveChannelConfig(cfg, "telegram");
+	if (!entry) return false;
+	if (hasNonEmptyString(entry.botToken) || hasNonEmptyString(entry.tokenFile)) return true;
+	if (accountsHaveKeys(entry.accounts, ["botToken", "tokenFile"])) return true;
+	return recordHasKeys(entry);
+}
+function isDiscordConfigured(cfg, env) {
+	if (hasNonEmptyString(env.DISCORD_BOT_TOKEN)) return true;
+	const entry = resolveChannelConfig(cfg, "discord");
+	if (!entry) return false;
+	if (hasNonEmptyString(entry.token)) return true;
+	if (accountsHaveKeys(entry.accounts, ["token"])) return true;
+	return recordHasKeys(entry);
+}
+function isIrcConfigured(cfg, env) {
+	if (hasNonEmptyString(env.IRC_HOST) && hasNonEmptyString(env.IRC_NICK)) return true;
+	const entry = resolveChannelConfig(cfg, "irc");
+	if (!entry) return false;
+	if (hasNonEmptyString(entry.host) || hasNonEmptyString(entry.nick)) return true;
+	if (accountsHaveKeys(entry.accounts, ["host", "nick"])) return true;
+	return recordHasKeys(entry);
+}
+function isSlackConfigured(cfg, env) {
+	if (hasNonEmptyString(env.SLACK_BOT_TOKEN) || hasNonEmptyString(env.SLACK_APP_TOKEN) || hasNonEmptyString(env.SLACK_USER_TOKEN)) return true;
+	const entry = resolveChannelConfig(cfg, "slack");
+	if (!entry) return false;
+	if (hasNonEmptyString(entry.botToken) || hasNonEmptyString(entry.appToken) || hasNonEmptyString(entry.userToken)) return true;
+	if (accountsHaveKeys(entry.accounts, [
+		"botToken",
+		"appToken",
+		"userToken"
+	])) return true;
+	return recordHasKeys(entry);
+}
+function isSignalConfigured(cfg) {
+	const entry = resolveChannelConfig(cfg, "signal");
+	if (!entry) return false;
+	if (hasNonEmptyString(entry.account) || hasNonEmptyString(entry.httpUrl) || hasNonEmptyString(entry.httpHost) || typeof entry.httpPort === "number" || hasNonEmptyString(entry.cliPath)) return true;
+	if (accountsHaveKeys(entry.accounts, [
+		"account",
+		"httpUrl",
+		"httpHost",
+		"cliPath"
+	])) return true;
+	return recordHasKeys(entry);
+}
+function isIMessageConfigured(cfg) {
+	const entry = resolveChannelConfig(cfg, "imessage");
+	if (!entry) return false;
+	if (hasNonEmptyString(entry.cliPath)) return true;
+	return recordHasKeys(entry);
+}
+function isWhatsAppConfigured(cfg) {
+	if (hasAnyWhatsAppAuth(cfg)) return true;
+	const entry = resolveChannelConfig(cfg, "whatsapp");
+	if (!entry) return false;
+	return recordHasKeys(entry);
+}
+function isGenericChannelConfigured(cfg, channelId) {
+	return recordHasKeys(resolveChannelConfig(cfg, channelId));
+}
+function isChannelConfigured(cfg, channelId, env = process.env) {
+	switch (channelId) {
+		case "whatsapp": return isWhatsAppConfigured(cfg);
+		case "telegram": return isTelegramConfigured(cfg, env);
+		case "discord": return isDiscordConfigured(cfg, env);
+		case "irc": return isIrcConfigured(cfg, env);
+		case "slack": return isSlackConfigured(cfg, env);
+		case "signal": return isSignalConfigured(cfg);
+		case "imessage": return isIMessageConfigured(cfg);
+		default: return isGenericChannelConfigured(cfg, channelId);
+	}
+}
+function collectModelRefs(cfg) {
+	const refs = [];
+	const pushModelRef = (value) => {
+		if (typeof value === "string" && value.trim()) refs.push(value.trim());
+	};
+	const collectFromAgent = (agent) => {
+		if (!agent) return;
+		const model = agent.model;
+		if (typeof model === "string") pushModelRef(model);
+		else if (isRecord(model)) {
+			pushModelRef(model.primary);
+			const fallbacks = model.fallbacks;
+			if (Array.isArray(fallbacks)) for (const entry of fallbacks) pushModelRef(entry);
+		}
+		const models = agent.models;
+		if (isRecord(models)) for (const key of Object.keys(models)) pushModelRef(key);
+	};
+	const defaults = cfg.agents?.defaults;
+	collectFromAgent(defaults);
+	const list = cfg.agents?.list;
+	if (Array.isArray(list)) {
+		for (const entry of list) if (isRecord(entry)) collectFromAgent(entry);
+	}
+	return refs;
+}
+function extractProviderFromModelRef(value) {
+	const trimmed = value.trim();
+	const slash = trimmed.indexOf("/");
+	if (slash <= 0) return null;
+	return normalizeProviderId(trimmed.slice(0, slash));
+}
+function isProviderConfigured(cfg, providerId) {
+	const normalized = normalizeProviderId(providerId);
+	const profiles = cfg.auth?.profiles;
+	if (profiles && typeof profiles === "object") for (const profile of Object.values(profiles)) {
+		if (!isRecord(profile)) continue;
+		if (normalizeProviderId(String(profile.provider ?? "")) === normalized) return true;
+	}
+	const providerConfig = cfg.models?.providers;
+	if (providerConfig && typeof providerConfig === "object") {
+		for (const key of Object.keys(providerConfig)) if (normalizeProviderId(key) === normalized) return true;
+	}
+	const modelRefs = collectModelRefs(cfg);
+	for (const ref of modelRefs) {
+		const provider = extractProviderFromModelRef(ref);
+		if (provider && provider === normalized) return true;
+	}
+	return false;
+}
+function resolveConfiguredPlugins(cfg, env) {
+	const changes = [];
+	const channelIds = new Set(CHANNEL_PLUGIN_IDS);
+	const configuredChannels = cfg.channels;
+	if (configuredChannels && typeof configuredChannels === "object") for (const key of Object.keys(configuredChannels)) {
+		if (key === "defaults") continue;
+		channelIds.add(key);
+	}
+	for (const channelId of channelIds) {
+		if (!channelId) continue;
+		if (isChannelConfigured(cfg, channelId, env)) changes.push({
+			pluginId: channelId,
+			reason: `${channelId} configured`
+		});
+	}
+	for (const mapping of PROVIDER_PLUGIN_IDS) if (isProviderConfigured(cfg, mapping.providerId)) changes.push({
+		pluginId: mapping.pluginId,
+		reason: `${mapping.providerId} auth configured`
+	});
+	return changes;
+}
+function isPluginExplicitlyDisabled(cfg, pluginId) {
+	return (cfg.plugins?.entries?.[pluginId])?.enabled === false;
+}
+function isPluginDenied(cfg, pluginId) {
+	const deny = cfg.plugins?.deny;
+	return Array.isArray(deny) && deny.includes(pluginId);
+}
+function resolvePreferredOverIds(pluginId) {
+	const normalized = normalizeChatChannelId(pluginId);
+	if (normalized) return getChatChannelMeta(normalized).preferOver ?? [];
+	return getChannelPluginCatalogEntry(pluginId)?.meta.preferOver ?? [];
+}
+function shouldSkipPreferredPluginAutoEnable(cfg, entry, configured) {
+	for (const other of configured) {
+		if (other.pluginId === entry.pluginId) continue;
+		if (isPluginDenied(cfg, other.pluginId)) continue;
+		if (isPluginExplicitlyDisabled(cfg, other.pluginId)) continue;
+		if (resolvePreferredOverIds(other.pluginId).includes(entry.pluginId)) return true;
+	}
+	return false;
+}
+function ensureAllowlisted(cfg, pluginId) {
+	const allow = cfg.plugins?.allow;
+	if (!Array.isArray(allow) || allow.includes(pluginId)) return cfg;
+	return {
+		...cfg,
+		plugins: {
+			...cfg.plugins,
+			allow: [...allow, pluginId]
+		}
+	};
+}
+function registerPluginEntry(cfg, pluginId) {
+	const entries = {
+		...cfg.plugins?.entries,
+		[pluginId]: {
+			...cfg.plugins?.entries?.[pluginId],
+			enabled: true
+		}
+	};
+	return {
+		...cfg,
+		plugins: {
+			...cfg.plugins,
+			entries
+		}
+	};
+}
+function formatAutoEnableChange(entry) {
+	let reason = entry.reason.trim();
+	const channelId = normalizeChatChannelId(entry.pluginId);
+	if (channelId) {
+		const label = getChatChannelMeta(channelId).label;
+		reason = reason.replace(new RegExp(`^${channelId}\\b`, "i"), label);
+	}
+	return `${reason}, enabled automatically.`;
+}
+function applyPluginAutoEnable(params) {
+	const env = params.env ?? process.env;
+	const configured = resolveConfiguredPlugins(params.config, env);
+	if (configured.length === 0) return {
+		config: params.config,
+		changes: []
+	};
+	let next = params.config;
+	const changes = [];
+	if (next.plugins?.enabled === false) return {
+		config: next,
+		changes
+	};
+	for (const entry of configured) {
+		if (isPluginDenied(next, entry.pluginId)) continue;
+		if (isPluginExplicitlyDisabled(next, entry.pluginId)) continue;
+		if (shouldSkipPreferredPluginAutoEnable(next, entry, configured)) continue;
+		const allow = next.plugins?.allow;
+		const allowMissing = Array.isArray(allow) && !allow.includes(entry.pluginId);
+		if (next.plugins?.entries?.[entry.pluginId]?.enabled === true && !allowMissing) continue;
+		next = registerPluginEntry(next, entry.pluginId);
+		next = ensureAllowlisted(next, entry.pluginId);
+		changes.push(formatAutoEnableChange(entry));
+	}
+	return {
+		config: next,
+		changes
+	};
+}
+
+//#endregion
+export { isChannelConfigured as n, applyPluginAutoEnable as t };