pi-subagents 0.57.0 → 0.58.0

package/src/runs/shared/dynamic-fanout.ts

@@ -49,9 +49,9 @@ const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
 const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "fast", "toolBudget", "acceptance", "agentContract", "gateOn"]);
 const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
 	...DYNAMIC_PARALLEL_KEYS,
-	"outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "timeoutMs", "waitToolEnabled",
-	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "capabilityCeiling", "completionGuard", "systemPrompt",
-	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId", "launchResolvedExtensions",
+	"outputName", "structured", "inheritProjectContext", "inheritGlobalContext", "inheritSkills", "skills", "outputPath", "namespaceOutputPath", "maxSubagentDepth", "timeoutMs", "waitToolEnabled",
+	"structuredOutput", "structuredOutputSchema", "tools", "extensions", "subagentOnlyExtensions", "mcpDirectTools", "mutationTools", "capabilityCeiling", "completionGuard", "systemPrompt",
+	"systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "acceptanceInput", "acceptanceRole", "parentSessionId", "launchResolvedExtensions", "requestedCwd",
 ]);
 const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
 

package/src/runs/shared/fast-mode-extension.ts

@@ -1,10 +1,10 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { BeforeProviderRequestEvent, ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-function withPriorityServiceTier(payload: unknown): unknown {
-	if (!payload || typeof payload !== "object" || Array.isArray(payload)) return payload;
-	return { ...payload, service_tier: "priority" };
+export function rewriteFastModeProviderRequest(event: BeforeProviderRequestEvent): unknown {
+	if (!event.payload || typeof event.payload !== "object" || Array.isArray(event.payload)) return event.payload;
+	return { ...event.payload, service_tier: "priority" };
 }
 
 export default function registerSubagentFastModeExtension(pi: ExtensionAPI): void {
-	pi.on("before_provider_request", (event) => ({ payload: withPriorityServiceTier(event.payload) }));
+	pi.on("before_provider_request", rewriteFastModeProviderRequest);
 }

package/src/runs/shared/launch-cwd.ts

@@ -0,0 +1,16 @@
+import * as fs from "node:fs";
+
+export function preflightLaunchCwd(requestedCwd: string, effectiveCwd: string): string | undefined {
+	const resolution = requestedCwd === effectiveCwd ? "" : `\n(resolved from ${JSON.stringify(requestedCwd)})`;
+	try {
+		if (!fs.statSync(effectiveCwd).isDirectory()) {
+			return `Subagent launch aborted: cwd is not a directory: ${effectiveCwd}${resolution}`;
+		}
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return `Subagent launch aborted: cwd does not exist: ${effectiveCwd}${resolution}`;
+		}
+		return `Subagent launch aborted: cwd could not be accessed: ${effectiveCwd}${resolution}\n${error instanceof Error ? error.message : String(error)}`;
+	}
+	return undefined;
+}

package/src/runs/shared/long-running-guard.ts

@@ -141,8 +141,9 @@ export function isMutatingBashCommand(command: string): boolean {
 		|| MUTATING_BASH_PATTERNS.some((pattern) => pattern.test(command));
 }
 
-export function isMutatingTool(toolName: string | undefined, args: Record<string, unknown> | undefined): boolean {
+export function isMutatingTool(toolName: string | undefined, args: Record<string, unknown> | undefined, mutationTools?: readonly string[]): boolean {
 	if (!toolName) return false;
+	if (mutationTools?.includes(toolName)) return true;
 	if (toolName === "edit" || toolName === "write") return true;
 	if (toolName === "cursor") {
 		const activityTitle = typeof args?.activityTitle === "string" ? args.activityTitle : "";

package/src/runs/shared/mcp-config-sources.ts

@@ -0,0 +1,386 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { findConfiguredProjectRoot } from "../../agents/agents.ts";
+import { getAgentDir, getConfigDirName, getProjectConfigDir } from "../../shared/utils.ts";
+
+const PACKAGE_CONFIG_ROOT = "npm";
+const PACKAGE_GIT_ROOT = "git";
+const PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+const PLUGIN_MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+const PLUGIN_NAME_PATTERN = /^(?!.*(?:--|\.\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+const PLUGIN_STDIO_FIELDS = new Set(["type", "command", "args", "env", "cwd"]);
+const PLUGIN_HTTP_FIELDS = new Set(["type", "url", "headers"]);
+
+export interface McpServerDefinition {
+	command?: string;
+	args?: string[];
+	socket?: string;
+	env?: Record<string, string>;
+	cwd?: string;
+	url?: string;
+	headers?: Record<string, string>;
+	requestHeadersCommand?: {
+		command: string;
+		args?: string[];
+		env?: Record<string, string>;
+		timeoutMs?: number;
+	};
+	auth?: "oauth" | "bearer" | false;
+	bearerToken?: string;
+	bearerTokenEnv?: string;
+	exposeResources?: boolean;
+	includeTools?: string[];
+	excludeTools?: string[];
+	protocolVersion?: string;
+	directTools?: boolean | string[];
+	httpTransport?: string;
+	pluginDataDir?: string;
+	literalEnv?: boolean;
+}
+
+export function loadPackageMcpServers(cwd: string): Record<string, McpServerDefinition> {
+	const servers: Record<string, McpServerDefinition> = {};
+	const seen = new Set<string>();
+
+	for (const packageRoot of getConfiguredPackageRoots(cwd)) {
+		const manifest = readJson(path.join(packageRoot, "package.json"));
+		if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) continue;
+		const packageName = (manifest as { name?: unknown }).name;
+		if (typeof packageName !== "string" || !packageName) continue;
+		const mcpValue = (manifest as { pi?: { mcp?: unknown } }).pi?.mcp;
+		const configPaths = typeof mcpValue === "string"
+			? [mcpValue]
+			: Array.isArray(mcpValue) && mcpValue.every((value): value is string => typeof value === "string")
+				? mcpValue
+				: [];
+		const packagePrefix = formatName(packageName, "package");
+
+		for (const configPath of configPaths) {
+			const resolvedPath = resolvePackageConfigPath(packageRoot, configPath);
+			if (!resolvedPath) continue;
+			const config = readJson(resolvedPath);
+			if (!config || typeof config !== "object" || Array.isArray(config)) continue;
+			const rawServers = (config as { mcpServers?: unknown }).mcpServers;
+			if (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers)) continue;
+			for (const [serverName, definition] of Object.entries(rawServers)) {
+				if (!definition || typeof definition !== "object" || Array.isArray(definition)) continue;
+				const normalizedName = `${packagePrefix}__${formatName(serverName, "server")}`;
+				if (seen.has(normalizedName)) continue;
+				seen.add(normalizedName);
+				servers[normalizedName] = definition as McpServerDefinition;
+			}
+		}
+	}
+
+	return servers;
+}
+
+export function loadAgentPluginMcpServers(paths: unknown, cwd: string): Record<string, McpServerDefinition> {
+	const servers: Record<string, McpServerDefinition> = {};
+	if (!Array.isArray(paths)) return servers;
+
+	for (const configuredPath of paths) {
+		if (typeof configuredPath !== "string") continue;
+		const pluginRoot = resolvePluginPath(configuredPath, cwd);
+		const manifest = readJson(path.join(pluginRoot, "plugin.json"));
+		if (!isValidPluginManifest(manifest)) continue;
+		const config = readJson(path.join(pluginRoot, "mcp.json"));
+		if (!isValidPluginConfig(config)) continue;
+		const rawServers = (config as { mcpServers: Record<string, unknown> }).mcpServers;
+
+		for (const [serverName, rawDefinition] of Object.entries(rawServers)) {
+			const definition = translatePluginServer(manifest.name, pluginRoot, serverName, rawDefinition);
+			if (!definition) continue;
+			const normalizedName = `${formatName(manifest.name, "plugin")}__${formatName(serverName, "server")}`;
+			if (Object.hasOwn(servers, normalizedName)) continue;
+			servers[normalizedName] = definition;
+		}
+	}
+
+	return servers;
+}
+
+function getConfiguredPackageRoots(cwd: string): string[] {
+	const roots: string[] = [];
+	const projectConfigDir = findProjectConfigDir(cwd);
+	const sources = [
+		{ path: path.join(projectConfigDir, "settings.json"), baseDir: projectConfigDir },
+		{ path: path.join(getAgentDir(), "settings.json"), baseDir: getAgentDir() },
+	];
+	for (const source of sources) {
+		const settings = readJson(source.path);
+		if (!settings || typeof settings !== "object" || Array.isArray(settings)) continue;
+		const packages = (settings as { packages?: unknown }).packages;
+		if (!Array.isArray(packages)) continue;
+		for (const entry of packages) {
+			const packageSource = typeof entry === "string"
+				? entry
+				: entry && typeof entry === "object" && !Array.isArray(entry) && typeof (entry as { source?: unknown }).source === "string"
+					? (entry as { source: string }).source
+					: undefined;
+			if (!packageSource) continue;
+			const root = resolvePackageRoot(packageSource, source.baseDir);
+			if (root && !roots.includes(root)) roots.push(root);
+		}
+	}
+	return roots;
+}
+
+function findProjectConfigDir(cwd: string): string {
+	const projectRoot = findConfiguredProjectRoot(path.resolve(cwd));
+	return projectRoot ? getProjectConfigDir(projectRoot) : path.join(path.resolve(cwd), getConfigDirName());
+}
+
+function resolvePackageRoot(source: string, baseDir: string): string | undefined {
+	const trimmed = source.trim();
+	if (!trimmed) return undefined;
+	if (trimmed.startsWith("npm:")) {
+		const packageName = parseNpmPackageName(trimmed);
+		return packageName ? resolveContainedPath(path.join(baseDir, PACKAGE_CONFIG_ROOT, "node_modules"), packageName) ?? undefined : undefined;
+	}
+
+	if (trimmed.startsWith("git:") || /^(?:https?:\/\/|ssh:\/\/|git@[^:]+:)/.test(trimmed)) {
+		const parsed = parseGitPackagePath(trimmed.startsWith("git:") ? trimmed : `git:${trimmed}`);
+		return parsed ? path.join(baseDir, PACKAGE_GIT_ROOT, parsed.host, parsed.repoPath) : undefined;
+	}
+
+	const localPath = trimmed.startsWith("file:") ? trimmed.slice(5) : trimmed;
+	if (localPath === "~") return os.homedir();
+	if (localPath.startsWith("~/")) return path.join(os.homedir(), localPath.slice(2));
+	return path.isAbsolute(localPath) ? path.resolve(localPath) : path.resolve(baseDir, localPath);
+}
+
+function parseNpmPackageName(source: string): string | undefined {
+	const spec = source.slice(4).trim();
+	if (!spec) return undefined;
+	const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
+	const packageName = match?.[1] ?? spec;
+	return resolveContainedPath("/", packageName) ? packageName : undefined;
+}
+
+function parseGitPackagePath(source: string): { host: string; repoPath: string } | undefined {
+	const spec = source.slice(4).trim();
+	if (!spec) return undefined;
+
+	let host = "";
+	let repoPath = "";
+	const scpLike = spec.match(/^git@([^:]+):(.+)$/);
+	if (scpLike) {
+		host = scpLike[1] ?? "";
+		repoPath = scpLike[2] ?? "";
+	} else if (/^[a-z][a-z0-9+.-]*:\/\//i.test(spec)) {
+		try {
+			const url = new URL(spec);
+			host = url.hostname;
+			repoPath = url.pathname.replace(/^\/+/, "");
+		} catch {
+			return undefined;
+		}
+	} else {
+		const slashIndex = spec.indexOf("/");
+		if (slashIndex < 0) return undefined;
+		host = spec.slice(0, slashIndex);
+		repoPath = spec.slice(slashIndex + 1);
+	}
+
+	const normalizedPath = stripGitRef(repoPath).replace(/\.git$/, "").replace(/^\/+/, "");
+	if (!host || !isSafePackagePath(host) || !isSafePackagePath(normalizedPath) || normalizedPath.split(/[\\/]/).length < 2) {
+		return undefined;
+	}
+	return { host, repoPath: normalizedPath };
+}
+
+function stripGitRef(repoPath: string): string {
+	const atIndex = repoPath.indexOf("@");
+	const hashIndex = repoPath.indexOf("#");
+	const refIndex = [atIndex, hashIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+	return refIndex === undefined ? repoPath : repoPath.slice(0, refIndex);
+}
+
+function isSafePackagePath(value: string): boolean {
+	return value.length > 0
+		&& !path.isAbsolute(value)
+		&& value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+
+function resolvePackageConfigPath(packageRoot: string, configuredPath: string): string | undefined {
+	const lexicalPath = resolveContainedPath(packageRoot, configuredPath);
+	if (!lexicalPath || !fs.existsSync(lexicalPath)) return undefined;
+	try {
+		if (!fs.statSync(lexicalPath).isFile()) return undefined;
+		const packageRealPath = fs.realpathSync(packageRoot);
+		const configRealPath = fs.realpathSync(lexicalPath);
+		return resolveContainedPath(packageRealPath, configRealPath) ?? undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveContainedPath(root: string, value: string): string | undefined {
+	const resolved = path.resolve(root, value);
+	const relative = path.relative(root, resolved);
+	return relative === "" || (!relative.startsWith("..") && !relative.startsWith(path.sep) && !path.isAbsolute(relative))
+		? resolved
+		: undefined;
+}
+
+function resolvePluginPath(configuredPath: string, cwd: string): string {
+	if (configuredPath === "~") return path.resolve(process.env.HOME ?? "", ".");
+	if (configuredPath.startsWith("~/")) return path.resolve(process.env.HOME ?? "", configuredPath.slice(2));
+	return path.isAbsolute(configuredPath) ? path.resolve(configuredPath) : path.resolve(cwd, configuredPath);
+}
+
+function isValidPluginManifest(value: unknown): value is { name: string } {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const manifest = value as { $schema?: unknown; name?: unknown };
+	return manifest.$schema === PLUGIN_SCHEMA
+		&& typeof manifest.name === "string"
+		&& manifest.name.length >= 1
+		&& manifest.name.length <= 64
+		&& PLUGIN_NAME_PATTERN.test(manifest.name);
+}
+
+function isValidPluginConfig(value: unknown): value is { mcpServers: Record<string, unknown> } {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const config = value as Record<string, unknown>;
+	return config.$schema === PLUGIN_MCP_SCHEMA
+		&& Object.keys(config).every((key) => key === "$schema" || key === "mcpServers")
+		&& !!config.mcpServers
+		&& typeof config.mcpServers === "object"
+		&& !Array.isArray(config.mcpServers);
+}
+
+function translatePluginServer(
+	pluginName: string,
+	pluginRoot: string,
+	serverName: string,
+	value: unknown,
+): McpServerDefinition | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const raw = value as Record<string, unknown>;
+	if (raw.type === "stdio") return translatePluginStdioServer(pluginName, pluginRoot, serverName, raw);
+	if (raw.type === "streamable-http" || raw.type === "sse") return translatePluginHttpServer(raw);
+	return undefined;
+}
+
+function translatePluginStdioServer(
+	pluginName: string,
+	pluginRoot: string,
+	serverName: string,
+	raw: Record<string, unknown>,
+): McpServerDefinition | undefined {
+	if ([...Object.keys(raw)].some((key) => !PLUGIN_STDIO_FIELDS.has(key))) return undefined;
+	if (typeof raw.command !== "string" || !raw.command) return undefined;
+	if (!isBareCommand(raw.command) && !raw.command.startsWith("./")) return undefined;
+	const args = stringArray(raw.args);
+	if (raw.args !== undefined && !args) return undefined;
+	const env = stringRecord(raw.env);
+	if (raw.env !== undefined && !env) return undefined;
+	if (env && (Object.hasOwn(env, "PLUGIN_ROOT") || Object.hasOwn(env, "PLUGIN_DATA"))) return undefined;
+
+	const pluginDataDir = path.join(getAgentDir(), "agent-plugin-data", pluginName);
+	const command = raw.command.startsWith("./") ? resolveContainedPath(pluginRoot, raw.command) : raw.command;
+	if (!command) return undefined;
+	const cwd = resolvePluginCwd(raw.cwd, pluginRoot, pluginDataDir);
+	if (!cwd) return undefined;
+
+	return {
+		command,
+		args: (args ?? []).map((value) => expandPluginPlaceholders(value, pluginRoot, pluginDataDir)),
+		env: {
+			...Object.fromEntries(Object.entries(env ?? {}).map(([key, value]) => [key, expandPluginPlaceholders(value, pluginRoot, pluginDataDir)])),
+			PLUGIN_ROOT: pluginRoot,
+			PLUGIN_DATA: pluginDataDir,
+		},
+		cwd,
+		pluginDataDir,
+		literalEnv: true,
+	};
+}
+
+function translatePluginHttpServer(raw: Record<string, unknown>): McpServerDefinition | undefined {
+	if ([...Object.keys(raw)].some((key) => !PLUGIN_HTTP_FIELDS.has(key))) return undefined;
+	if (typeof raw.url !== "string" || !isValidPluginUrl(raw.url)) return undefined;
+	const headers = stringRecord(raw.headers);
+	if (raw.headers !== undefined && !headers) return undefined;
+	if (headers) {
+		const normalized = new Set<string>();
+		for (const key of Object.keys(headers)) {
+			const lower = key.toLowerCase();
+			if (normalized.has(lower)) return undefined;
+			normalized.add(lower);
+		}
+		try {
+			new Headers(headers);
+		} catch {
+			return undefined;
+		}
+	}
+	return { url: raw.url, ...(headers ? { headers } : {}), httpTransport: raw.type as string };
+}
+
+function resolvePluginCwd(value: unknown, pluginRoot: string, pluginDataDir: string): string | undefined {
+	if (value === undefined) return pluginRoot;
+	if (typeof value !== "string") return undefined;
+	if (value.startsWith("./")) return resolveContainedPath(pluginRoot, value);
+	if (value === "${PLUGIN_ROOT}" || value.startsWith("${PLUGIN_ROOT}/")) return resolveContainedPath(pluginRoot, value.replace("${PLUGIN_ROOT}", "."));
+	if (value === "${PLUGIN_DATA}" || value.startsWith("${PLUGIN_DATA}/")) return resolveContainedPath(pluginDataDir, value.replace("${PLUGIN_DATA}", "."));
+	return undefined;
+}
+
+function expandPluginPlaceholders(value: string, pluginRoot: string, pluginDataDir: string): string {
+	return value.replaceAll("${PLUGIN_ROOT}", pluginRoot).replaceAll("${PLUGIN_DATA}", pluginDataDir);
+}
+
+function isBareCommand(command: string): boolean {
+	return !command.includes("/")
+		&& !command.includes("\\")
+		&& !command.includes("${PLUGIN_ROOT}")
+		&& !command.includes("${PLUGIN_DATA}");
+}
+
+function isValidPluginUrl(value: string): boolean {
+	if (value.includes("${") || value.includes("$env:") || value.includes("{env:")) return false;
+	let url: URL;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+	if (url.username || url.password || url.hash) return false;
+	if (url.protocol === "https:") return true;
+	const host = url.hostname.toLowerCase();
+	return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(host);
+}
+
+function stringArray(value: unknown): string[] | undefined {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : undefined;
+}
+
+function stringRecord(value: unknown): Record<string, string> | undefined {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+	const entries = Object.entries(value);
+	if (entries.some(([, entry]) => typeof entry !== "string")) return undefined;
+	return Object.fromEntries(entries) as Record<string, string>;
+}
+
+function formatName(value: string, fallback: string): string {
+	return value.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || fallback;
+}
+
+function readJson(filePath: string): unknown | undefined {
+	let content: string;
+	try {
+		content = fs.readFileSync(filePath, "utf-8");
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") return undefined;
+		throw new Error(`Failed to read JSON file '${filePath}': ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+	try {
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(`Invalid JSON in '${filePath}': ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+	}
+}