pi-profile-switch 0.4.2 → 0.4.4

package/README.md

@@ -59,7 +59,6 @@ In the TUI, the `/profile` command family manages everything in-session:
 | `/profile use <name>` / `/profile reload` | Switch / reload without restarting (rollback on failure) |
 | `/profile create\|edit\|delete\|duplicate` | Guided profile CRUD (TUI only) |
 | `/profile customize` / `/profile reset` | Narrow the active profile for this session only |
-| `/mcp enable\|disable <server>` | Toggle MCP servers in the active profile |
 
 All commands work in non-interactive modes (`--mode rpc|print|json`); CRUD wizards are TUI-only.
 

package/README.zh-CN.md

@@ -59,7 +59,6 @@ Profile 只**引用**资源，从不复制资源。已安装的包和标准目
 | `/profile use <name>` / `/profile reload` | 会话内切换 / 重载（失败自动回滚） |
 | `/profile create\|edit\|delete\|duplicate` | 向导式 profile 增删改（仅 TUI） |
 | `/profile customize` / `/profile reset` | 仅本次会话收窄活动 profile |
-| `/mcp enable\|disable <server>` | 在活动 profile 中开关 MCP server |
 
 非交互模式（`--mode rpc|print|json`）下命令同样生效；CRUD 向导仅 TUI 可用。
 

package/bin/pi-profile.ts

@@ -29,7 +29,7 @@ try {
 	const agentDir = getAgentDir();
 	// Fails before spawning when the profile is unknown or cannot activate.
 	// --approve/--no-approve are consumed here as a one-run trust input.
-	const { plan, discovery, projectSettings, warnings } = await resolveInitialProfile(args.profile, {
+	const { plan, discovery, projectSettings, projectDir, warnings } = await resolveInitialProfile(args.profile, {
 		agentDir,
 		cwd: process.cwd(),
 		trustOverride: args.trustOverride,
@@ -41,7 +41,7 @@ try {
 	// window) are swept before this launch materializes its own. Best-effort:
 	// sweep errors never block the launch.
 	await sweepStaleRuntimeDirs(agentDir);
-	const generated = await generateRuntimeDir(plan, { agentDir, discovery, projectSettings });
+	const generated = await generateRuntimeDir(plan, { agentDir, discovery, projectSettings, projectDir });
 	process.exitCode = await spawnPi({
 		generated,
 		piArgs: args.piArgs,

package/extensions/pi-profile/index.ts

@@ -21,8 +21,6 @@ import {
 	runProfileDuplicateWizard,
 	runProfileEditWizard,
 } from "../../src/switching/profile-wizard.ts";
-import { probeAdapterPresence } from "../../src/mcp-coordination.ts";
-import { setMcpServerEnabled } from "../../src/switching/mcp-toggle.ts";
 import { buildStatusReport, formatStatusMarkdown } from "../../src/switching/status.ts";
 import { switchProfile, type SwitchDeps } from "../../src/switching/switch-profile.ts";
 import { getGlobalStateDir } from "../../src/workspace.ts";
@@ -53,9 +51,6 @@ import { getGlobalStateDir } from "../../src/workspace.ts";
  *   is stale afterwards.
  * - list/status ship structured `details` payloads (`{kind, profiles}` /
  *   `{kind, report}`) for RPC consumers (ticket 11).
- * - `/mcp enable|disable <server>`: edit the active profile's mcp array in
- *   its owning catalog, then reload (ticket 10). Fails clearly with the
- *   adapter absent; notifies before the reload (stale context after).
  *
  * Pi re-executes this module on reload, so post-reload state is established
  * exclusively through `session_start` — nothing stale survives.
@@ -383,69 +378,4 @@ export default function piProfileExtension(pi: ExtensionAPI): void {
 			}
 		},
 	});
-
-	// Persistent profile-scoped MCP toggles (ticket 10): edit the active
-	// profile's mcp array in its owning catalog, then reload so the runtime
-	// and the republished allowlist match. The adapter's own configuration
-	// (mcp.json files) is never written.
-	pi.registerCommand("mcp", {
-		description: "pi-profile: /mcp enable <server> | /mcp disable <server>",
-		handler: async (args, ctx) => {
-			const notify = (message: string, level: "info" | "warning" | "error") => {
-				try {
-					ctx.ui?.notify(message, level);
-				} catch {
-					// stale context after reload — see /profile
-				}
-			};
-			const [action, server] = args.trim().split(/\s+/).filter(Boolean);
-			if (!["enable", "disable"].includes(action ?? "") || server === undefined) {
-				notify("usage: /mcp enable <server> | /mcp disable <server>", "error");
-				return;
-			}
-			try {
-				const plan = await readLaunchPlanFile(runtimeDir);
-				if (plan?.agentDir === undefined) {
-					notify("pi-profile: launch plan is missing agentDir — cannot toggle MCP servers", "error");
-					return;
-				}
-				if (!probeAdapterPresence(pi.events)) {
-					throw new Error(
-						"pi-mcp-adapter is not active in this session — /mcp enable|disable requires it " +
-							"(select the adapter in the profile's extensions).",
-					);
-				}
-				const result = await setMcpServerEnabled(
-					{ realAgentDir: plan.agentDir, cwd: ctx.cwd, profile: { name: plan.profile, source: plan.source } },
-					server,
-					action === "enable",
-				);
-				if (!result.changed) {
-					notify(`MCP server "${server}" is already ${action}d in profile "${plan.profile}"`, "info");
-					return;
-				}
-				// Notify BEFORE the reload: this context is stale afterwards.
-				notify(
-					`${action}d MCP server "${server}" in profile "${plan.profile}" (mcps: [${result.mcps.join(", ")}]); reloading`,
-					"info",
-				);
-				const switched = await switchProfile(plan.profile, {
-					runtimeDir,
-					realAgentDir: plan.agentDir,
-					cwd: ctx.cwd,
-					waitForIdle: () => ctx.waitForIdle(),
-					reload: () => ctx.reload(),
-					// Same staleness probe as /profile: interactive Pi
-					// swallows reload refusals; a live context afterwards
-					// means the reload never ran.
-					assertStale: () => {
-						void ctx.cwd;
-					},
-				}, { reloadCurrent: true });
-				for (const warning of switched.warnings) notify(warning, "warning");
-			} catch (error) {
-				notify(error instanceof Error ? error.message : String(error), "error");
-			}
-		},
-	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-profile-switch",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Named profiles for Pi: reference skills, extensions, MCP servers, and tools per workflow, switched without restarting.",
   "type": "module",
   "keywords": [

package/src/launcher/initial-profile.ts

@@ -56,6 +56,8 @@ export interface InitialProfile {
 	/** The trusted project's `.pi/settings.json` content, when trusted and
 	 *  present. The generator merges it into the base for selection plans. */
 	projectSettings?: Record<string, unknown>;
+	/** The trusted project directory, when trusted. */
+	projectDir?: string;
 	/** Non-fatal notices for the user (e.g. a dangling restored profile that
 	 *  fell back to default). The launcher prints them. */
 	warnings: string[];
@@ -154,7 +156,7 @@ export async function resolveInitialProfile(
 			overlay,
 		});
 		warnings.push(...discovery.extensions.warnings(), ...unmatchedWarnings(plan));
-		return { plan, discovery, projectSettings, warnings };
+		return { plan, discovery, projectSettings, projectDir, warnings };
 	}
 
 	const discovery = await discoverLauncherResources({ ...context, projectTrusted });
@@ -175,5 +177,5 @@ export async function resolveInitialProfile(
 		// silently do nothing or leak through unfiltered.
 		throw new MissingMcpAdapterError(plan.profile);
 	}
-	return { plan, discovery, projectSettings, warnings };
+	return { plan, discovery, projectSettings, projectDir, warnings };
 }

package/src/mcp-config.ts

@@ -1,25 +1,26 @@
 /**
- * AdapterConfigDiscovery: reads the MCP server NAMES pi-mcp-adapter would
- * discover from its pi-native config files, without ever managing them.
+ * AdapterConfigDiscovery: reads MCP server names and configurations
+ * pi-mcp-adapter would discover from its standard configuration files,
+ * without ever managing them.
  *
  * pi-profile never stores MCP connection parameters or credentials
- * (ADR-0002); this module reads only the `mcpServers` key names so the
- * launcher can validate a profile's `mcp` references before spawn.
+ * (ADR-0002); this module reads config definitions to validate references
+ * before spawn and filter instance mcp.json files.
  *
- * Discovery scope (documented limitation): the pi-native files only — the
- * global `<agentDir>/mcp.json` and, when trusted, the project's
+ * Discovery scope: standard user-global configs (~/.config/mcp/mcp.json,
+ * ~/.agents/mcp.json, ~/.agents/mcp/mcp.json), the Pi-global
+ * `<agentDir>/mcp.json`, and, when trusted, the project's `.mcp.json` and
  * `.pi/mcp.json`. Servers defined solely in the adapter's editor-specific
- * legacy locations (~/.claude/mcp.json et al.) are invisible here; profiles
- * referencing them fail launch validation. The pi-native files are the
- * adapter's documented default, and no in-session re-validation exists (the
- * adapter's status snapshots arrive too late and only post-init), so the
- * launch check is the only name validation — keep configs in the pi-native
- * files.
+ * legacy locations (~/.claude/mcp.json et al.) are invisible here unless
+ * imported.
  *
  * Malformed config files fail loudly — a broken mcp.json must not silently
  * read as "no servers" and reject every reference.
  */
 
+import { homedir } from "node:os";
+import path from "node:path";
+
 import { isRecord, readJsonFile } from "./json-file.ts";
 
 export class McpConfigError extends Error {
@@ -32,35 +33,104 @@ export class McpConfigError extends Error {
 	}
 }
 
-async function readServerNames(filePath: string): Promise<string[]> {
-	const result = await readJsonFile(filePath);
-	if (!result.ok) {
-		if (result.reason === "missing") {
-			return [];
-		}
-		throw new McpConfigError(`MCP config is not valid JSON: ${filePath}`, filePath);
-	}
-	if (!isRecord(result.value)) {
-		throw new McpConfigError(`MCP config must be a JSON object: ${filePath}`, filePath);
-	}
-	if (result.value.mcpServers === undefined) {
-		return [];
-	}
-	if (!isRecord(result.value.mcpServers)) {
-		throw new McpConfigError(`"mcpServers" must be a JSON object: ${filePath}`, filePath);
-	}
-	return Object.keys(result.value.mcpServers);
+export interface McpDiscoveryOptions {
+	homeDir?: string;
 }
 
-/** Server names the adapter would discover: global agentDir config plus the
- *  trusted project's config. Pass `projectDir` only when the trust check
- *  passed — an untrusted project's config is never read. */
-export async function discoverAdapterServerNames(agentDir: string, projectDir?: string): Promise<string[]> {
-	const names = new Set(await readServerNames(`${agentDir}/mcp.json`));
+export interface MergedMcpResult {
+	servers: Record<string, Record<string, unknown>>;
+	sharedServers: Set<string>;
+	baseConfig?: Record<string, unknown>;
+}
+
+export interface McpConfigSource {
+	path: string;
+	isShared: boolean;
+	isAgentDir?: boolean;
+}
+
+/**
+ * Standard MCP configuration sources recognized by pi-mcp-adapter in precedence order:
+ * 1. ~/.config/mcp/mcp.json (user-global standard MCP)
+ * 2. ~/.agents/mcp.json (user-global .agents MCP)
+ * 3. ~/.agents/mcp/mcp.json (user-global .agents nested MCP)
+ * 4. <agentDir>/mcp.json (Pi global override)
+ * 5. <projectDir>/.mcp.json (project standard MCP, when project is trusted)
+ * 6. <projectDir>/.pi/mcp.json (project Pi override, when project is trusted)
+ */
+export function getStandardMcpConfigSources(
+	agentDir: string,
+	projectDir?: string,
+	options?: McpDiscoveryOptions,
+): McpConfigSource[] {
+	const home = options?.homeDir ?? process.env.HOME ?? homedir();
+	const sources: McpConfigSource[] = [
+		{ path: path.join(home, ".config", "mcp", "mcp.json"), isShared: true },
+		{ path: path.join(home, ".agents", "mcp.json"), isShared: true },
+		{ path: path.join(home, ".agents", "mcp", "mcp.json"), isShared: true },
+		{ path: path.join(agentDir, "mcp.json"), isShared: false, isAgentDir: true },
+	];
 	if (projectDir !== undefined) {
-		for (const name of await readServerNames(`${projectDir}/.pi/mcp.json`)) {
-			names.add(name);
+		sources.push({ path: path.join(projectDir, ".mcp.json"), isShared: true });
+		sources.push({ path: path.join(projectDir, ".pi", "mcp.json"), isShared: false });
+	}
+	return sources;
+}
+
+export async function loadMergedMcpServers(
+	agentDir: string,
+	projectDir?: string,
+	options?: McpDiscoveryOptions,
+): Promise<MergedMcpResult> {
+	const sources = getStandardMcpConfigSources(agentDir, projectDir, options);
+	const seenPaths = new Set<string>();
+	const servers: Record<string, Record<string, unknown>> = {};
+	const sharedServers = new Set<string>();
+	let baseConfig: Record<string, unknown> | undefined;
+
+	for (const source of sources) {
+		const resolvedPath = path.resolve(source.path);
+		if (seenPaths.has(resolvedPath)) continue;
+		seenPaths.add(resolvedPath);
+
+		const result = await readJsonFile(resolvedPath);
+		if (!result.ok) {
+			if (result.reason === "missing") continue;
+			throw new McpConfigError(`MCP config is not valid JSON: ${resolvedPath}`, resolvedPath);
+		}
+		if (!isRecord(result.value)) {
+			throw new McpConfigError(`MCP config must be a JSON object: ${resolvedPath}`, resolvedPath);
+		}
+		if (source.isAgentDir) {
+			baseConfig = result.value;
+		}
+		if (result.value.mcpServers === undefined) continue;
+		if (!isRecord(result.value.mcpServers)) {
+			throw new McpConfigError(`"mcpServers" must be a JSON object: ${resolvedPath}`, resolvedPath);
+		}
+		for (const [name, def] of Object.entries(result.value.mcpServers)) {
+			if (source.isShared) {
+				sharedServers.add(name);
+			}
+			if (isRecord(def)) {
+				servers[name] = { ...(servers[name] ?? {}), ...def };
+			} else {
+				servers[name] = { ...(servers[name] ?? {}) };
+			}
 		}
 	}
-	return [...names].sort();
+
+	return { servers, sharedServers, baseConfig };
+}
+
+/** Server names the adapter would discover: standard global MCP configs,
+ *  global agentDir config, plus the trusted project's configs. Pass `projectDir`
+ *  only when the trust check passed — an untrusted project's config is never read. */
+export async function discoverAdapterServerNames(
+	agentDir: string,
+	projectDir?: string,
+	options?: McpDiscoveryOptions,
+): Promise<string[]> {
+	const { servers } = await loadMergedMcpServers(agentDir, projectDir, options);
+	return Object.keys(servers).sort();
 }

package/src/settings-generator.ts

@@ -45,6 +45,7 @@ import path from "node:path";
 import type { ActivationPlan } from "./profile-resolver.ts";
 import { getInstancesRootDir } from "./workspace.ts";
 import { isRecord } from "./json-file.ts";
+import { loadMergedMcpServers } from "./mcp-config.ts";
 import type { SkillEntry } from "./skill-registry.ts";
 
 /** A configured global package and its resolved install/local root. */
@@ -66,6 +67,10 @@ export interface DiscoveryContext {
 export interface GenerateOptions {
 	/** The user's real agent dir (e.g. ~/.pi/agent). */
 	agentDir: string;
+	/** Optional home dir override (useful for testing). */
+	homeDir?: string;
+	/** Optional trusted project dir. */
+	projectDir?: string;
 	/** Required for selection plans; unused for the default profile. */
 	discovery?: DiscoveryContext;
 	/** The trusted project's `.pi/settings.json` content (already parsed).
@@ -276,6 +281,10 @@ function buildSelectionSettings(
 export interface RuntimeFileOptions {
 	/** The user's real agent dir (e.g. ~/.pi/agent). */
 	agentDir: string;
+	/** Optional home dir override (useful for testing). */
+	homeDir?: string;
+	/** Optional trusted project dir. */
+	projectDir?: string;
 	/** Required for selection plans; unused for the default profile. */
 	discovery?: DiscoveryContext;
 	/** The trusted project's `.pi/settings.json` content (already parsed). */
@@ -418,29 +427,34 @@ export async function writeRuntimeFiles(
 	} else {
 		// Filter MCP servers
 		try { await rm(mcpInstancePath); } catch {}
-		if (await exists(mcpTarget)) {
-			try {
-				const mcpContent = await readFile(mcpTarget, "utf8");
-				let mcpParsed = JSON.parse(mcpContent);
-				if (isRecord(mcpParsed) && isRecord(mcpParsed.mcpServers)) {
-					const filteredServers: Record<string, unknown> = {};
-					for (const serverName of plan.mcps) {
-						if (mcpParsed.mcpServers[serverName] !== undefined) {
-							filteredServers[serverName] = mcpParsed.mcpServers[serverName];
-						}
-					}
-					mcpParsed.mcpServers = filteredServers;
-					await writeFile(mcpInstancePath, JSON.stringify(mcpParsed, null, 2));
-				} else {
-					// Malformed or empty, write empty
-					await writeFile(mcpInstancePath, JSON.stringify({ mcpServers: {} }, null, 2));
-				}
-			} catch {
-				await writeFile(mcpInstancePath, JSON.stringify({ mcpServers: {} }, null, 2));
+		const { servers, sharedServers, baseConfig } = await loadMergedMcpServers(
+			options.agentDir,
+			options.projectDir,
+			options.homeDir !== undefined ? { homeDir: options.homeDir } : undefined,
+		);
+
+		const allowedSet = new Set(plan.mcps);
+		const filteredServers: Record<string, unknown> = {};
+
+		for (const serverName of plan.mcps) {
+			if (servers[serverName] !== undefined) {
+				const def = { ...servers[serverName] };
+				delete def.disabled;
+				filteredServers[serverName] = def;
+			}
+		}
+
+		for (const sharedName of sharedServers) {
+			if (!allowedSet.has(sharedName)) {
+				filteredServers[sharedName] = { disabled: true };
 			}
-		} else {
-			await writeFile(mcpInstancePath, JSON.stringify({ mcpServers: {} }, null, 2));
 		}
+
+		const outputConfig: Record<string, unknown> = isRecord(baseConfig)
+			? { ...baseConfig, mcpServers: filteredServers }
+			: { mcpServers: filteredServers };
+
+		await writeFile(mcpInstancePath, JSON.stringify(outputConfig, null, 2));
 	}
 
 	// Instructions generation (Ticket 04)

package/src/switching/switch-profile.ts

@@ -164,6 +164,7 @@ export async function switchProfile(
 			: undefined;
 	await writeRuntimeFiles(deps.runtimeDir, resolved.plan, {
 		agentDir: deps.realAgentDir,
+		projectDir: resolved.projectDir,
 		discovery: resolved.discovery,
 		projectSettings: resolved.projectSettings,
 		planExtras: {

package/src/switching/mcp-toggle.ts

@@ -1,71 +0,0 @@
-/**
- * McpToggle: persistent, profile-scoped `/mcp enable|disable` (ticket 10).
- *
- * The profile's `mcps` array in its OWNING catalog is the profile-scoped
- * state store (ticket 04 established that pi-mcp-adapter@2.33.0 has no
- * allowlist/profile-state API — ADR-0002's assumed store does not exist;
- * pi-profile owns the contract). Runtime effect flows through the standard
- * rewrite-settings-and-reload path: the post-reload session_start
- * republishes the allowlist over the coordination channel.
- *
- * Invariants:
- * - Enable accepts only adapter-discovered names (fail fast on typos);
- *   disable also removes names the adapter no longer reports (stale
- *   cleanup).
- * - The built-in default profile has no catalog entry — toggling it is a
- *   clear error, not a synthetic write.
- * - Only the ACTIVE profile's array changes; other profiles and the
- *   adapter's own configuration (global mcp.json, project .pi/mcp.json)
- *   are never modified.
- */
-
-import { discoverAdapterServerNames } from "../mcp-config.ts";
-import { CatalogError, DEFAULT_PROFILE_NAME, type ProfileDefinition } from "../profile-catalog.ts";
-import { readTrustInputs as readTrust } from "../launcher/initial-profile.ts";
-import { catalogStore, readCatalogScope, type CatalogScope } from "./profile-crud.ts";
-
-export async function setMcpServerEnabled(
-	input: { realAgentDir: string; cwd: string; profile: { name: string; source: string } },
-	server: string,
-	enabled: boolean,
-): Promise<{ mcps: string[]; changed: boolean }> {
-	if (input.profile.name === DEFAULT_PROFILE_NAME || input.profile.source === "builtin") {
-		throw new CatalogError(
-			`the built-in default profile has no catalog entry — create a named profile (/profile create) to toggle MCP servers`,
-		);
-	}
-	const scope = input.profile.source as CatalogScope;
-	if (scope !== "global" && scope !== "project") {
-		throw new CatalogError(`profile "${input.profile.name}" has no writable owning catalog (source: ${input.profile.source})`);
-	}
-
-	const { projectTrusted } = await readTrust({ agentDir: input.realAgentDir, cwd: input.cwd });
-	if (scope === "project" && !projectTrusted) {
-		throw new CatalogError(`project catalog is unavailable: ${input.cwd} is not trusted`);
-	}
-	const discovered = await discoverAdapterServerNames(input.realAgentDir, projectTrusted ? input.cwd : undefined);
-	if (enabled && !discovered.includes(server)) {
-		throw new CatalogError(
-			`unknown MCP server "${server}" — adapter discovered: [${discovered.join(", ") || "(none)"}]`,
-		);
-	}
-
-	const definitions = await readCatalogScope(input, scope);
-	const definition = definitions.get(input.profile.name);
-	if (definition === undefined) {
-		throw new CatalogError(`profile "${input.profile.name}" not found in the ${scope} catalog`);
-	}
-
-	const current = definition.mcps ?? [];
-	if (enabled === current.includes(server)) {
-		return { mcps: current, changed: false }; // already in the requested state
-	}
-	const next = enabled ? [...current, server] : current.filter((name) => name !== server);
-	// Drop the key entirely when empty (exactOptionalPropertyTypes; a
-	// written `mcps: undefined` would also misrepresent the definition).
-	const rest = { ...definition };
-	delete rest.mcps;
-	const updated: ProfileDefinition = next.length > 0 ? { ...rest, mcps: next } : rest;
-	await catalogStore(input, scope).upsert(input.profile.name, updated);
-	return { mcps: next, changed: true };
-}