@agimon-ai/po-mcp 0.0.0-alpha.0

package/dist/mcpCatalog-6Tpt6Gqn.cjs

@@ -0,0 +1,900 @@
+const require_rolldown_runtime = require("./rolldown-runtime-C0BPl7ul.cjs");
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let _agimon_ai_po_config_agentPluginMcp = require("@agimon-ai/po-config/agentPluginMcp");
+let yaml = require("yaml");
+let node_os = require("node:os");
+node_os = require_rolldown_runtime.__toESM(node_os, 1);
+let _agimon_ai_mcp_proxy_package_json = require("@agimon-ai/mcp-proxy/package.json");
+_agimon_ai_mcp_proxy_package_json = require_rolldown_runtime.__toESM(_agimon_ai_mcp_proxy_package_json, 1);
+let _agimon_ai_po_core_mcpSession = require("@agimon-ai/po-core/mcpSession");
+//#region src/services/configSources/index.ts
+/** Wrapper entry used by non-Doom clients to expose `mcp-config.yaml` as one MCP. */
+const PROXY_SERVER_NAME = "mcp-proxy";
+const PROXY_SERVER_ALIASES = /* @__PURE__ */ new Set([PROXY_SERVER_NAME, "agiflow-proxy"]);
+const PRIVATE_FILE_MODE = 384;
+const PRIVATE_DIRECTORY_MODE = 448;
+const DEFAULT_UPSTREAM_CONFIG = "mcp-config.yaml";
+const CONFIG_ARGUMENT = "--config";
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isYamlPath(filePath) {
+	const extension = node_path.default.extname(filePath).toLowerCase();
+	return extension === ".yaml" || extension === ".yml";
+}
+function readConfigDocument(filePath) {
+	try {
+		const contents = node_fs.default.readFileSync(filePath, "utf8");
+		const parsed = isYamlPath(filePath) ? (0, yaml.parse)(contents) : JSON.parse(contents);
+		return isObject(parsed) ? {
+			config: parsed,
+			contents
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+function readConfigObject(filePath) {
+	return readConfigDocument(filePath)?.config;
+}
+function serverDefinitions(config) {
+	return isObject(config?.mcpServers) ? config.mcpServers : {};
+}
+function isEnabledDefinition(definition) {
+	return !isObject(definition) || definition.disabled !== true;
+}
+function isProxyWrapper(name) {
+	return PROXY_SERVER_ALIASES.has(name);
+}
+/**
+* Resolves the upstream config referenced by the repository proxy wrapper.
+*
+* The wrapper remains useful to Claude, Codex, and other external clients. Doom
+* embeds the same client/runtime code, so it reads this path and connects each
+* declared server itself instead of starting the wrapper as a nested MCP.
+*/
+function resolveSharedConfigPathFrom(repoRoot, repositoryConfigPath) {
+	const servers = serverDefinitions(readConfigObject(repositoryConfigPath));
+	const rawArgs = [...PROXY_SERVER_ALIASES].map((name) => servers[name]).find((definition) => isObject(definition))?.args;
+	const args = Array.isArray(rawArgs) ? rawArgs : [];
+	const configArgumentIndex = args.indexOf(CONFIG_ARGUMENT);
+	const declared = args[configArgumentIndex + 1];
+	const candidate = configArgumentIndex >= 0 && typeof declared === "string" ? node_path.default.resolve(repoRoot, declared) : node_path.default.join(repoRoot, DEFAULT_UPSTREAM_CONFIG);
+	return node_fs.default.existsSync(candidate) ? candidate : void 0;
+}
+function resolveSharedConfigPath(repoRoot) {
+	return resolveSharedConfigPathFrom(repoRoot, node_path.default.join(repoRoot, ".mcp.json"));
+}
+/** Empty and absent allowlists both mean "keep everything". */
+function isAllowed(name, allowed) {
+	return !allowed || allowed.length === 0 || allowed.includes(name);
+}
+function stagedPath(filePath, contents, stagingDirectory) {
+	const digest = (0, node_crypto.createHash)("sha256").update(filePath).update("\0").update(contents).digest("hex").slice(0, 16);
+	const extension = isYamlPath(filePath) ? ".yaml" : ".json";
+	return node_path.default.join(stagingDirectory, `mcp-${digest}${extension}`);
+}
+function serializeConfig(filePath, config) {
+	return isYamlPath(filePath) ? (0, yaml.stringify)(config) : `${JSON.stringify(config, null, 2)}\n`;
+}
+function layerCacheKey(filePath, format, originalContents, effectiveContents, sourceIdentity) {
+	return (0, node_crypto.createHash)("sha256").update(format).update("\0").update(node_fs.default.realpathSync(filePath)).update("\0").update(sourceIdentity ?? "unprojected").update("\0").update(originalContents).update("\0").update(effectiveContents).digest("hex");
+}
+/**
+* Rewrites one config layer with disallowed servers removed.
+*
+* Proxy wrapper entries are stripped from `.mcp.json` layers because Doom reaches
+* their upstream config directly. Entries are removed rather than marked disabled,
+* so a filtered stdio server is never spawned at all.
+*/
+function filterLayer(filePath, allowed, stagingDirectory, options) {
+	const document = readConfigDocument(filePath);
+	if (!document) return void 0;
+	const { config, contents: originalContents } = document;
+	const servers = serverDefinitions(config);
+	const kept = {};
+	const dropped = [];
+	for (const [name, definition] of Object.entries(servers)) if (options.stripProxyWrappers && isProxyWrapper(name) || !isAllowed(name, allowed)) dropped.push(name);
+	else kept[name] = definition;
+	const keptNames = Object.entries(kept).filter(([, definition]) => isEnabledDefinition(definition)).map(([name]) => name);
+	if (dropped.length === 0) return {
+		source: {
+			path: filePath,
+			format: "claude",
+			cacheKey: layerCacheKey(filePath, "claude", originalContents, originalContents, options.sourceIdentity)
+		},
+		kept: keptNames,
+		dropped
+	};
+	node_fs.default.mkdirSync(stagingDirectory, {
+		mode: PRIVATE_DIRECTORY_MODE,
+		recursive: true
+	});
+	const contents = serializeConfig(filePath, {
+		...config,
+		mcpServers: kept
+	});
+	const target = stagedPath(filePath, contents, stagingDirectory);
+	node_fs.default.writeFileSync(target, contents, { mode: PRIVATE_FILE_MODE });
+	return {
+		source: {
+			path: target,
+			format: "claude",
+			cacheKey: layerCacheKey(filePath, "claude", originalContents, contents, options.sourceIdentity)
+		},
+		kept: keptNames,
+		dropped
+	};
+}
+function digestMatches(source) {
+	try {
+		return (0, node_crypto.createHash)("sha256").update(node_fs.default.readFileSync(source.configPath)).digest("hex") === source.contentDigest;
+	} catch {
+		return false;
+	}
+}
+function emptyGroups(diagnostics = []) {
+	return {
+		shared: {
+			configSources: [],
+			configPaths: [],
+			serverNames: []
+		},
+		sessionLocal: {
+			configSources: [],
+			configPaths: [],
+			serverNames: []
+		},
+		droppedServers: [],
+		diagnostics
+	};
+}
+/**
+* Resolves every config layer for this session and applies its domain allowlist.
+*
+* All returned layers go into one embedded `@agimon-ai/mcp-proxy` client container.
+* The package is used as a library only: its wrapper MCP never becomes a Doom MCP
+* server, so status, enable/disable, resources, and OAuth stay attached to each
+* actual downstream server.
+*/
+function buildMcpConfigGroups(input) {
+	if (input.enabled === false) return emptyGroups();
+	const projectedSources = input.sources;
+	const legacyLayers = projectedSources ? [] : [node_path.default.join(input.repoRoot, ".mcp.json"), ...(input.pluginConfigPaths ?? []).map((candidate) => node_path.default.resolve(input.repoRoot, candidate))].filter((candidate) => node_fs.default.existsSync(candidate));
+	const configSources = [];
+	const serverNames = [];
+	const droppedServers = [];
+	const diagnostics = [];
+	for (const layer of legacyLayers) {
+		const filtered = filterLayer(layer, input.allowlist?.servers, input.stagingDirectory, { stripProxyWrappers: true });
+		if (!filtered) continue;
+		configSources.push(filtered.source);
+		serverNames.push(...filtered.kept);
+		droppedServers.push(...filtered.dropped);
+	}
+	for (const source of projectedSources ?? []) {
+		if (source.format === "agent-plugin-v1") {
+			const normalized = (0, _agimon_ai_po_config_agentPluginMcp.normalizeAgentPluginMcpSource)(source, {
+				stagingDirectory: input.stagingDirectory,
+				allowedServers: input.allowlist?.servers
+			});
+			if (normalized.configSource) configSources.push(normalized.configSource);
+			serverNames.push(...normalized.serverNames);
+			droppedServers.push(...normalized.droppedServers);
+			diagnostics.push(...normalized.diagnostics);
+			continue;
+		}
+		if (!digestMatches(source)) {
+			diagnostics.push(`Native MCP source "${source.sourceId}" was disabled: the file is missing or its content digest changed.`);
+			continue;
+		}
+		const filtered = filterLayer(source.configPath, input.allowlist?.servers, input.stagingDirectory, {
+			stripProxyWrappers: true,
+			sourceIdentity: `${source.sourceId}:${source.contentDigest}`
+		});
+		if (!filtered) {
+			diagnostics.push(`Native MCP source "${source.sourceId}" was disabled: the config could not be parsed.`);
+			continue;
+		}
+		configSources.push(filtered.source);
+		serverNames.push(...filtered.kept);
+		droppedServers.push(...filtered.dropped);
+	}
+	const repositorySource = projectedSources?.find((source) => source.format === "native" && source.owner === "repository");
+	const upstreamPath = projectedSources ? repositorySource && digestMatches(repositorySource) ? resolveSharedConfigPathFrom(input.repoRoot, repositorySource.configPath) : void 0 : resolveSharedConfigPath(input.repoRoot);
+	const upstream = upstreamPath ? filterLayer(upstreamPath, input.allowlist?.proxy, input.stagingDirectory, { stripProxyWrappers: true }) : void 0;
+	if (upstream) droppedServers.push(...upstream.dropped);
+	return {
+		shared: {
+			configSources: upstream ? [upstream.source] : [],
+			configPaths: upstream ? [upstream.source.path] : [],
+			serverNames: upstream ? upstream.kept : []
+		},
+		sessionLocal: {
+			configSources,
+			configPaths: configSources.map((source) => source.path),
+			serverNames: [...new Set(serverNames)]
+		},
+		droppedServers: [...new Set(droppedServers)],
+		diagnostics
+	};
+}
+//#endregion
+//#region src/services/mcpRuntime/index.ts
+var mcpRuntime_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	McpRuntimeOwner: () => McpRuntimeOwner,
+	definitionsCachePath: () => definitionsCachePath,
+	hubCallbackSink: () => hubCallbackSink,
+	readCachedCatalog: () => readCachedCatalog
+});
+/**
+* Presents the hub's redirect surface as the proxy's callback collaborator.
+*
+* `listen` binds nothing: the hub already serves the address this advertises,
+* so opening a loopback port would only create one nobody redirects to.
+*/
+function hubCallbackSink(redirect) {
+	return {
+		redirectUri: () => redirect.redirectUri,
+		getPort: () => void 0,
+		listen: (preferredPort) => Promise.resolve(preferredPort),
+		reserve: (state, timeoutMs) => redirect.reserve(state, timeoutMs),
+		waitForCallback: (state, timeoutMs) => redirect.wait(state, timeoutMs),
+		cancel: (state) => redirect.cancel(state)
+	};
+}
+const MCP_APP_CLIENT_CAPABILITIES = { extensions: { "io.modelcontextprotocol/ui": { mimeTypes: ["text/html;profile=mcp-app", "text/html+skybridge"] } } };
+/**
+* Definitions cache path shared by Doom's synchronous warm reader and mcp-proxy.
+*
+* Generated staging paths are deliberately absent: projected source content must
+* invalidate a reused path, while identical portable content must survive a new
+* private staging directory. Stable source origins are carried inside each cache
+* key; format and merge behavior remain part of the ordered identity.
+*/
+function definitionsCachePath(configSources) {
+	if (configSources.length === 0) throw new Error("definitionsCachePath requires at least one config source");
+	const digest = (0, node_crypto.createHash)("sha256").update(JSON.stringify(configSources.map((source) => ({
+		cacheKey: source.cacheKey,
+		format: source.format,
+		optional: source.optional ?? false,
+		mergeStrategy: source.mergeStrategy ?? "remote-priority"
+	})))).update("\0").update(_agimon_ai_mcp_proxy_package_json.default.version).update("\0").update(JSON.stringify(MCP_APP_CLIENT_CAPABILITIES)).digest("hex");
+	return (0, node_path.join)((0, node_os.homedir)(), ".mcp-proxy", `po-${digest}.definitions-cache.json`);
+}
+/**
+* Reads the catalog the previous run left behind.
+*
+* Synchronous on purpose: Pi has to be able to register these tools during
+* extension install, before it takes its first turn, and awaiting a file read
+* would let that turn start with an empty tool set. A miss is normal on a first
+* run and resolves to an empty catalog rather than an error.
+*
+* The file path is content-addressed from the current ordered layers, and its proxy
+* version is checked before any schema is registered. Servers filtered out of the
+* current configuration are also excluded later by `McpCatalog.seed`.
+*/
+function readCachedCatalog(configSources, cachePathFor = definitionsCachePath) {
+	if (configSources.length === 0) return { servers: [] };
+	try {
+		const cachePath = cachePathFor(configSources);
+		const cache = JSON.parse((0, node_fs.readFileSync)(cachePath, "utf8"));
+		if (cache.oneMcpVersion !== _agimon_ai_mcp_proxy_package_json.default.version) return { servers: [] };
+		return { servers: Object.values(cache.servers ?? {}).map((server) => ({
+			name: server.serverName,
+			tools: server.tools ?? []
+		})) };
+	} catch {
+		return { servers: [] };
+	}
+}
+function toProxyConfigSource(source) {
+	return {
+		path: source.path,
+		format: source.format,
+		...source.optional === void 0 ? {} : { optional: source.optional },
+		...source.mergeStrategy === void 0 ? {} : { mergeStrategy: source.mergeStrategy }
+	};
+}
+/**
+* Owns the one live mcp-proxy container for this extension.
+*
+* Pi reloads extensions in process, so a connect that lands after a session restart
+* or a `/domains` switch would otherwise fold tools into a dead context. Every start
+* takes the next generation; anything an older generation produces is dropped and its
+* container disposed.
+*/
+var McpRuntimeOwner = class {
+	generation = 0;
+	active;
+	unsubscribe;
+	get currentGeneration() {
+		return this.generation;
+	}
+	/** The live container, or undefined before the first start and after dispose. */
+	getServices() {
+		return this.active;
+	}
+	/**
+	* Whether a container a caller captured earlier is still the live one.
+	*
+	* An async continuation that started under one container has to check this
+	* before writing its result, or a `/domains` switch would fold stale tools into
+	* the new session.
+	*/
+	isCurrent(services) {
+		return services !== void 0 && services === this.active;
+	}
+	/**
+	* Starts a container for the current configuration, replacing any predecessor.
+	*
+	* Returns undefined when a newer generation started while this one was building,
+	* which is the signal for the caller to abandon its half-finished work.
+	*/
+	async start(options) {
+		const generation = ++this.generation;
+		await this.retire();
+		if (options.configSources.length === 0) return void 0;
+		const { createProxyContainer } = await import("@agimon-ai/mcp-proxy");
+		const cachePath = definitionsCachePath(options.configSources);
+		const services = await createProxyContainer({
+			configSources: options.configSources.map(toProxyConfigSource),
+			workspaceRoot: options.workspaceRoot,
+			executionCwd: options.executionCwd,
+			environment: options.environment,
+			definitionsCachePath: cachePath,
+			startupMode: "background",
+			clientCapabilities: MCP_APP_CLIENT_CAPABILITIES,
+			outputSchemaValidation: {
+				mode: "warn",
+				onWarning: (warning) => {
+					if (generation === this.generation) options.onOutputSchemaWarning?.(warning);
+				}
+			},
+			auth: {
+				tokenStore: options.tokenStore,
+				onAuthorizationUrl: options.onAuthorizationUrl,
+				...options.callbackServer ? { callbackServer: options.callbackServer } : {}
+			}
+		});
+		if (generation !== this.generation) {
+			await services.dispose().catch(() => void 0);
+			return;
+		}
+		this.active = services;
+		const forward = options.onServerStateChange;
+		if (forward) this.unsubscribe = services.clientManager.onServerStateChange((change) => {
+			if (generation === this.generation) forward(change);
+		});
+		return {
+			generation,
+			services,
+			connectionsSettled: services.connectionsSettled
+		};
+	}
+	/** Tears the container down and invalidates every generation still in flight. */
+	async dispose() {
+		++this.generation;
+		await this.retire();
+	}
+	async retire() {
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		const services = this.active;
+		this.active = void 0;
+		if (services) await services.dispose().catch(() => void 0);
+	}
+};
+//#endregion
+//#region src/services/sessionConfig/index.ts
+function asStringArray(value) {
+	if (!Array.isArray(value)) return void 0;
+	const strings = value.filter((entry) => typeof entry === "string" && entry.length > 0);
+	return strings.length > 0 ? strings : void 0;
+}
+function readAllowlist(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const { servers, proxy } = value;
+	const allowlist = {};
+	const allowedServers = asStringArray(servers);
+	const allowedProxy = asStringArray(proxy);
+	if (allowedServers) allowlist.servers = allowedServers;
+	if (allowedProxy) allowlist.proxy = allowedProxy;
+	return allowlist.servers || allowlist.proxy ? allowlist : void 0;
+}
+/**
+* Resolves what this session should connect to.
+*
+* Every field falls back to a working default so the extension is usable outside
+* po: a bare Pi session in a repository still gets that repository's
+* `.mcp.json` with no allowlist. A malformed value is treated as absent rather
+* than fatal, because losing MCP is better than losing the session.
+*/
+function readSessionConfig(env = process.env, defaultRepoRoot = process.cwd()) {
+	const fallback = {
+		repoRoot: defaultRepoRoot,
+		stagingDirectory: node_path.default.join(node_os.default.tmpdir(), "doom-mcp")
+	};
+	const strict = (0, _agimon_ai_po_core_mcpSession.readDoomMcpSessionConfig)(env);
+	if (strict) {
+		const { allowlist, pluginConfigPaths, ...required } = strict;
+		const strictAllowlist = readAllowlist(allowlist);
+		return {
+			...required,
+			...pluginConfigPaths?.length ? { pluginConfigPaths: [...pluginConfigPaths] } : {},
+			...strictAllowlist ? { allowlist: strictAllowlist } : {}
+		};
+	}
+	const raw = env[_agimon_ai_po_core_mcpSession.DOOM_MCP_SESSION_ENV_VAR];
+	if (!raw) return fallback;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return fallback;
+	}
+	if (typeof parsed !== "object" || parsed === null) return fallback;
+	const { repoRoot, generatedConfigPath, pluginConfigPaths, allowlist, stagingDirectory } = parsed;
+	const resolvedRoot = typeof repoRoot === "string" && repoRoot ? repoRoot : fallback.repoRoot;
+	const generatedConfig = typeof generatedConfigPath === "string" && generatedConfigPath ? generatedConfigPath : void 0;
+	const plugins = asStringArray(pluginConfigPaths);
+	const resolvedAllowlist = readAllowlist(allowlist);
+	return {
+		repoRoot: resolvedRoot,
+		stagingDirectory: typeof stagingDirectory === "string" && stagingDirectory ? stagingDirectory : fallback.stagingDirectory,
+		...generatedConfig ? { generatedConfigPath: generatedConfig } : {},
+		...plugins ? { pluginConfigPaths: plugins } : {},
+		...resolvedAllowlist ? { allowlist: resolvedAllowlist } : {}
+	};
+}
+/** Serializes the configuration for the Pi child process po launches. */
+function sessionConfigEnvironment(config) {
+	return (0, _agimon_ai_po_core_mcpSession.doomMcpSessionEnvironment)(config);
+}
+//#endregion
+//#region src/schemas/directTools.ts
+/** Environment variable carrying a child agent's MCP tool selection. */
+const DIRECT_TOOLS_ENV = "MCP_DIRECT_TOOLS";
+/** Explicit "no MCP tools", distinct from an unset variable meaning "no limit". */
+const NO_DIRECT_TOOLS = "__none__";
+//#endregion
+//#region src/services/mcpCatalog/index.ts
+function metadataRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+/** Standard fields take precedence, including explicitly invalid fields (fail closed). */
+function normalizeMcpAppMetadata(meta) {
+	const ui = metadataRecord(meta?.ui);
+	const standardUri = ui && "resourceUri" in ui ? ui.resourceUri : meta?.["ui/resourceUri"];
+	const legacyUri = meta?.["openai/outputTemplate"];
+	const standard = standardUri !== void 0;
+	const candidate = standard ? standardUri : legacyUri;
+	const resourceUri = typeof candidate === "string" && candidate.startsWith("ui://") && candidate.length <= 8192 && !Array.from(candidate).some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127) ? candidate : void 0;
+	const visibility = ui?.visibility;
+	const validVisibility = Array.isArray(visibility) && visibility.every((value) => value === "model" || value === "app");
+	const legacy = legacyUri !== void 0 || meta?.["openai/widgetAccessible"] !== void 0 || meta?.["openai/visibility"] !== void 0;
+	const modelVisible = visibility === void 0 ? standard || meta?.["openai/visibility"] !== "private" : validVisibility && visibility.includes("model");
+	const appVisible = visibility === void 0 ? standard || !legacy ? true : meta?.["openai/widgetAccessible"] === true : validVisibility && visibility.includes("app");
+	return {
+		...resourceUri === void 0 ? {} : {
+			resourceUri,
+			protocol: standard ? "mcp" : "openai"
+		},
+		modelVisible,
+		appVisible
+	};
+}
+function isModelVisibleMcpTool(tool) {
+	return normalizeMcpAppMetadata(tool._meta).modelVisible;
+}
+/** Execution projections carry normalized visibility; discovery retains the untouched metadata. */
+function mcpToolExecutionMetadata(tool) {
+	if (tool._meta === void 0) return void 0;
+	const normalized = normalizeMcpAppMetadata(tool._meta);
+	return {
+		...tool._meta,
+		ui: {
+			...metadataRecord(tool._meta.ui),
+			visibility: [...normalized.modelVisible ? ["model"] : [], ...normalized.appVisible ? ["app"] : []]
+		}
+	};
+}
+function isAppVisibleMcpTool(tool) {
+	return normalizeMcpAppMetadata(tool._meta).appVisible;
+}
+/**
+* States where calling a tool cannot succeed, so its tools are withheld.
+*
+* `closed` is absent deliberately: a server closed after an idle timeout is
+* reconnected by the next call rather than gone. `disabled` is absent because it is
+* no longer a reachable transition; `entry.disabled` carries that instead.
+*/
+const UNAVAILABLE_STATES = /* @__PURE__ */ new Set(["failed", "needs-auth"]);
+/** Where a server starts: known to the session, not yet dialled. */
+const NOT_CONNECTED = "not-connected";
+const DISABLED = "disabled";
+const ALL_SERVERS_SELECTOR = "*";
+const SELECTOR_SEPARATOR = "/";
+/**
+* Pi's tool name for a downstream tool.
+*
+* Always prefixed, matching what `pi-mcp-adapter` produced by default. Tool names
+* are a contract with agent frontmatter selectors, transcripts, and user habit, so
+* they stay stable across the swap rather than following mcp-proxy's internal
+* scheme, which prefixes only on a clash.
+*/
+function toPiToolName(serverName, toolName) {
+	return `${serverName.replace(/[^a-zA-Z0-9]/g, "_")}_${toolName}`;
+}
+function toCatalogTool(serverName, tool) {
+	return {
+		piName: toPiToolName(serverName, tool.name),
+		toolName: tool.name,
+		serverName,
+		...tool.description ? { description: tool.description } : {},
+		inputSchema: tool.inputSchema,
+		...tool.annotations === void 0 ? {} : { annotations: tool.annotations },
+		...tool.outputSchema === void 0 ? {} : { outputSchema: tool.outputSchema },
+		...tool._meta === void 0 ? {} : { _meta: tool._meta }
+	};
+}
+/**
+* The session's MCP servers and the tools registered for each.
+*
+* Seeded from the previous run's catalog so tools exist before any socket opens,
+* then folded forward as servers report in. Tools are never removed: Pi 0.84 has no
+* way to unregister one, so a tool whose server later fails stays registered and is
+* simply left out of the active set.
+*/
+var McpCatalog = class {
+	directTools;
+	entries = /* @__PURE__ */ new Map();
+	diagnostics = [];
+	/** Pi names already claimed, so two servers cannot register the same one. */
+	claimed = /* @__PURE__ */ new Map();
+	/**
+	* @param directTools - A child agent's tool selection. Undefined in a normal
+	*   session, where every configured tool is available.
+	*/
+	constructor(directTools) {
+		this.directTools = directTools;
+	}
+	/**
+	* Seeds the servers this session will connect to, all still `not-connected`.
+	*
+	* Configured names come first so a run with no cache still reports what it is
+	* about to reach rather than looking empty; the cache then fills in their tools.
+	* A cached server that configuration has since dropped is not seeded at all.
+	*/
+	seed(catalog, configuredServers = []) {
+		for (const name of configuredServers) this.entries.set(name, {
+			name,
+			state: NOT_CONNECTED,
+			tools: [],
+			resourceCount: 0
+		});
+		for (const server of catalog.servers) {
+			if (configuredServers.length > 0 && !this.entries.has(server.name)) continue;
+			this.entries.set(server.name, {
+				name: server.name,
+				state: NOT_CONNECTED,
+				tools: this.claimTools(server.name, server.tools),
+				resourceCount: 0
+			});
+		}
+	}
+	/**
+	* Hides or restores a server's tools for this session.
+	*
+	* Only the flag moves: `state` keeps tracking what the server reports, so
+	* re-enabling lands on the current truth rather than on a remembered value that
+	* may have gone stale while the server was hidden.
+	*/
+	setDisabled(serverName, disabled) {
+		const entry = this.entries.get(serverName);
+		if (entry) entry.disabled = disabled;
+		else this.entries.set(serverName, {
+			name: serverName,
+			state: NOT_CONNECTED,
+			disabled,
+			tools: [],
+			resourceCount: 0
+		});
+	}
+	/** Records how many resources a server offered the last time they were listed. */
+	setResourceCount(serverName, resourceCount) {
+		const entry = this.entries.get(serverName);
+		if (entry) entry.resourceCount = resourceCount;
+	}
+	/**
+	* Folds a live server transition into the catalog.
+	*
+	* Returns the tools that are new to this catalog, which is what the caller has to
+	* register with Pi. A reconnect returns nothing, since its tools already exist.
+	*/
+	applyStateChange(change, tools, resourceCount) {
+		const entry = this.entries.get(change.serverName) ?? {
+			name: change.serverName,
+			state: change.state,
+			tools: [],
+			resourceCount: 0
+		};
+		entry.state = change.state;
+		if (change.error) entry.error = change.error;
+		else delete entry.error;
+		if (resourceCount !== void 0) entry.resourceCount = resourceCount;
+		if (change.state === "connected" && tools !== void 0) {
+			const known = new Map(entry.tools.map((tool) => [tool.toolName, tool]));
+			const next = [];
+			const added = [];
+			for (const tool of tools) {
+				if (known.get(tool.name) !== void 0) {
+					next.push(toCatalogTool(change.serverName, tool));
+					continue;
+				}
+				const [claimed] = this.claimTools(change.serverName, [tool]);
+				if (claimed !== void 0) {
+					next.push(claimed);
+					added.push(claimed);
+				}
+			}
+			entry.tools = next;
+			this.entries.set(change.serverName, entry);
+			return added;
+		}
+		this.entries.set(change.serverName, entry);
+		return [];
+	}
+	/**
+	* Tool names Pi should currently expose.
+	*
+	* Optimistic: a server that has not reported yet still contributes its cached
+	* tools, because calling one connects it on demand. The live background pass can
+	* take longer than Pi startup, so requiring `connected` first would make a warm
+	* session needlessly start with no tools.
+	*
+	* Only a server that is known to be unusable, or one the user disabled, is held
+	* back.
+	*/
+	activeToolNames() {
+		const names = [];
+		for (const entry of this.entries.values()) {
+			if (entry.disabled || UNAVAILABLE_STATES.has(entry.state)) continue;
+			for (const tool of entry.tools) {
+				if (this.directTools && !this.directTools.allows(entry.name, tool.toolName)) continue;
+				names.push(tool.piName);
+			}
+		}
+		return names;
+	}
+	/** Every tool ever registered, whether or not its server is reachable. */
+	allTools() {
+		return [...this.entries.values()].flatMap((entry) => entry.tools);
+	}
+	/** Resolve configured selectors only to tool names this authoritative catalog confirms. */
+	resolveToolSelectors(selectors) {
+		let allServers = false;
+		const selectedServers = /* @__PURE__ */ new Set();
+		const selectedTools = /* @__PURE__ */ new Map();
+		for (const selection of selectors) {
+			const item = selection.trim().replace(/\/+$/u, "");
+			if (!item) continue;
+			if (item === ALL_SERVERS_SELECTOR) {
+				allServers = true;
+				continue;
+			}
+			const separator = item.indexOf(SELECTOR_SEPARATOR);
+			if (separator === -1) {
+				selectedServers.add(item);
+				continue;
+			}
+			const server = item.slice(0, separator);
+			const tool = item.slice(separator + 1);
+			if (!server) continue;
+			if (!tool) {
+				selectedServers.add(server);
+				continue;
+			}
+			const names = selectedTools.get(server) ?? /* @__PURE__ */ new Set();
+			names.add(tool);
+			selectedTools.set(server, names);
+		}
+		const resolved = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const tool of this.allTools()) {
+			if (!isModelVisibleMcpTool(tool)) continue;
+			if (!(allServers || selectedServers.has(tool.serverName)) && !selectedTools.get(tool.serverName)?.has(tool.toolName)) continue;
+			if (seen.has(tool.piName)) continue;
+			seen.add(tool.piName);
+			resolved.push({
+				name: tool.piName,
+				selector: `${tool.serverName}${SELECTOR_SEPARATOR}${tool.toolName}`
+			});
+		}
+		return resolved;
+	}
+	findTool(piName) {
+		return this.allTools().find((tool) => tool.piName === piName);
+	}
+	/**
+	* The cross-extension status shape.
+	*
+	* A disabled server reports `disabled` as its state, because that is the one word
+	* the wire contract has for "configured but contributing nothing", and consumers
+	* outside this process have no use for the transition underneath it.
+	*/
+	toSnapshot() {
+		return { servers: [...this.entries.values()].map((entry) => ({
+			name: entry.name,
+			state: entry.disabled ? DISABLED : entry.state,
+			tools: entry.tools.filter(isModelVisibleMcpTool).map((tool) => tool.piName),
+			resourceCount: entry.resourceCount,
+			...entry.error ? { error: entry.error } : {}
+		})) };
+	}
+	/**
+	* The fuller picture the overlay renders.
+	*
+	* Carries what the snapshot cannot: each tool's downstream name and description,
+	* whether a child agent's selection withholds it, and `enabled` as its own field
+	* so the overlay can offer disable and enable against the real server state.
+	*/
+	toView() {
+		return [...this.entries.values()].map((entry) => ({
+			name: entry.name,
+			state: entry.state,
+			tools: entry.tools.map((tool) => ({
+				piName: tool.piName,
+				toolName: tool.toolName,
+				...tool.description ? { description: tool.description } : {},
+				active: isModelVisibleMcpTool(tool) && (!this.directTools || this.directTools.allows(entry.name, tool.toolName))
+			})),
+			resourceCount: entry.resourceCount,
+			enabled: !entry.disabled,
+			...entry.error ? { error: entry.error } : {}
+		}));
+	}
+	/** Problems worth surfacing to the user. Reported, never thrown. */
+	getDiagnostics() {
+		return this.diagnostics;
+	}
+	/**
+	* Records a problem for the user without interrupting whatever hit it.
+	*
+	* Deduplicated: a fault that recurs on every repaint would otherwise grow this
+	* list for as long as the session runs, and the second copy tells nobody
+	* anything the first did not.
+	*/
+	addDiagnostic(diagnostic) {
+		if (!this.diagnostics.includes(diagnostic)) this.diagnostics.push(diagnostic);
+	}
+	/**
+	* Assigns Pi names, dropping any that another server already owns.
+	*
+	* Two server names that normalize to the same prefix (`code-intel` and
+	* `code_intel`) would otherwise have one silently shadow the other's tool.
+	*/
+	claimTools(serverName, tools) {
+		const claimed = [];
+		for (const tool of tools) {
+			const candidate = toCatalogTool(serverName, tool);
+			const owner = this.claimed.get(candidate.piName);
+			if (owner !== void 0 && owner !== serverName) {
+				this.diagnostics.push(`MCP tool "${candidate.piName}" from "${serverName}" was dropped: "${owner}" already registered that name.`);
+				continue;
+			}
+			this.claimed.set(candidate.piName, serverName);
+			claimed.push(candidate);
+		}
+		return claimed;
+	}
+};
+//#endregion
+Object.defineProperty(exports, "DIRECT_TOOLS_ENV", {
+	enumerable: true,
+	get: function() {
+		return DIRECT_TOOLS_ENV;
+	}
+});
+Object.defineProperty(exports, "McpCatalog", {
+	enumerable: true,
+	get: function() {
+		return McpCatalog;
+	}
+});
+Object.defineProperty(exports, "McpRuntimeOwner", {
+	enumerable: true,
+	get: function() {
+		return McpRuntimeOwner;
+	}
+});
+Object.defineProperty(exports, "NO_DIRECT_TOOLS", {
+	enumerable: true,
+	get: function() {
+		return NO_DIRECT_TOOLS;
+	}
+});
+Object.defineProperty(exports, "PROXY_SERVER_NAME", {
+	enumerable: true,
+	get: function() {
+		return PROXY_SERVER_NAME;
+	}
+});
+Object.defineProperty(exports, "buildMcpConfigGroups", {
+	enumerable: true,
+	get: function() {
+		return buildMcpConfigGroups;
+	}
+});
+Object.defineProperty(exports, "definitionsCachePath", {
+	enumerable: true,
+	get: function() {
+		return definitionsCachePath;
+	}
+});
+Object.defineProperty(exports, "hubCallbackSink", {
+	enumerable: true,
+	get: function() {
+		return hubCallbackSink;
+	}
+});
+Object.defineProperty(exports, "isAppVisibleMcpTool", {
+	enumerable: true,
+	get: function() {
+		return isAppVisibleMcpTool;
+	}
+});
+Object.defineProperty(exports, "isModelVisibleMcpTool", {
+	enumerable: true,
+	get: function() {
+		return isModelVisibleMcpTool;
+	}
+});
+Object.defineProperty(exports, "mcpRuntime_exports", {
+	enumerable: true,
+	get: function() {
+		return mcpRuntime_exports;
+	}
+});
+Object.defineProperty(exports, "mcpToolExecutionMetadata", {
+	enumerable: true,
+	get: function() {
+		return mcpToolExecutionMetadata;
+	}
+});
+Object.defineProperty(exports, "normalizeMcpAppMetadata", {
+	enumerable: true,
+	get: function() {
+		return normalizeMcpAppMetadata;
+	}
+});
+Object.defineProperty(exports, "readCachedCatalog", {
+	enumerable: true,
+	get: function() {
+		return readCachedCatalog;
+	}
+});
+Object.defineProperty(exports, "readSessionConfig", {
+	enumerable: true,
+	get: function() {
+		return readSessionConfig;
+	}
+});
+Object.defineProperty(exports, "sessionConfigEnvironment", {
+	enumerable: true,
+	get: function() {
+		return sessionConfigEnvironment;
+	}
+});
+Object.defineProperty(exports, "toPiToolName", {
+	enumerable: true,
+	get: function() {
+		return toPiToolName;
+	}
+});
+
+//# sourceMappingURL=mcpCatalog-6Tpt6Gqn.cjs.map