one-code-extension 0.4.1 → 0.6.0

package/extensions/mcp/config.ts

@@ -2,17 +2,36 @@
  * MCP server configuration in Claude Code's format (pure).
  *
  * Sources, lowest to highest precedence:
+ *   plugins' .mcp.json                (bare server maps)
+ *   pi.registerMcpServer()            (servers other pi extensions register, pi 0.99+)
+ *   <agentDir>/mcp.json               (pi's own user file, ~/.pi/agent/mcp.json)
+ *   <cwd>/.pi/mcp.json                (pi's own project file)
  *   ~/.claude.json                    (user, global)
  *   <cwd>/.mcp.json                   (project, checked in — walked up to the repo root)
  *   <cwd>/.claude/settings.local.json (project, personal)
  *
+ * Independent mode (lib/config-mode.ts) reads none of the three Claude Code
+ * files: plugins, registered servers and pi's two files only.
+ *
  * Every file holds an `mcpServers` object. A stdio server has `command` (plus
  * optional `args`, `env`); a remote one has `url` and optional `type`/`headers`.
+ *
+ * pi's two files are read because One Code's `/mcp` replaces pi 0.99's
+ * built-in MCP, which would otherwise have read them (decisions/mcp.md). Their
+ * format is pi's: `enabled: false` turns a server off, a stdio server may set
+ * `cwd` (relative to the session directory), and a leading `~/` in `command`,
+ * an argument or `cwd` names the home directory. A server with a `!command`
+ * value in `env` or `headers` is skipped with a note: running a shell command
+ * from a config file to build a credential is not supported. pi's
+ * `oauth`/`auth` settings, `exposure`, `timeout` and `description` are
+ * ignored. A Claude Code file's server of the same name wins, with a note.
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { claudeJsonPath } from "../lib/paths.ts";
+import { dirname, join, resolve } from "node:path";
+import { claudeSourcesOn } from "../lib/config-mode.ts";
+import { claudeJsonPath, expandTilde } from "../lib/paths.ts";
+import { hashServerConfig } from "./trust.ts";
 
 export interface StdioServer {
 	kind: "stdio";
@@ -20,7 +39,11 @@ export interface StdioServer {
 	command: string;
 	args: string[];
 	env?: Record<string, string>;
+	/** Working directory (pi's `mcp.json` only); the session's directory when absent. */
+	cwd?: string;
 	source: string;
+	/** Set for a server read in pi's format: which of pi's sources defined it. */
+	piOrigin?: PiOrigin;
 	/** Config referenced these environment variables and they are not set. */
 	missingEnv?: string[];
 	/** Every env var the config references (set or not), for the consent dialog — values are expanded away by parse time. */
@@ -29,10 +52,13 @@ export interface StdioServer {
 
 export interface HttpServer {
 	kind: "http";
+	/** Legacy HTTP+SSE when explicitly configured; otherwise Streamable HTTP. */
+	transport?: "sse";
 	name: string;
 	url: string;
 	headers?: Record<string, string>;
 	source: string;
+	piOrigin?: PiOrigin;
 	/** Config referenced these environment variables and they are not set. */
 	missingEnv?: string[];
 	/** Every env var the config references (set or not), for the consent dialog — values are expanded away by parse time. */
@@ -41,6 +67,9 @@ export interface HttpServer {
 
 export type McpServer = StdioServer | HttpServer;
 
+/** pi's user `mcp.json`, its project `mcp.json`, or an extension's `pi.registerMcpServer()`. */
+export type PiOrigin = "user" | "project" | "extension";
+
 interface RawServer {
 	command?: unknown;
 	args?: unknown;
@@ -49,6 +78,26 @@ interface RawServer {
 	type?: unknown;
 	headers?: unknown;
 	disabled?: unknown;
+	/** pi's `mcp.json`: `false` keeps the entry without connecting. */
+	enabled?: unknown;
+	/** pi's `mcp.json`: a stdio server's working directory. */
+	cwd?: unknown;
+}
+
+/** How to read a server from one of pi's own `mcp.json` files. */
+export interface PiFormat {
+	home: string;
+	/** The session directory a relative `cwd` resolves against. */
+	cwd: string;
+}
+
+/**
+ * Why a pi-format server cannot be loaded, or undefined: a `!command` value
+ * in `env` or `headers` (pi runs it in a shell to build the value).
+ */
+export function piFormatProblem(raw: RawServer): string | undefined {
+	const values = [...Object.values(asStringRecord(raw.env) ?? {}), ...Object.values(asStringRecord(raw.headers) ?? {})];
+	return values.some((value) => value.startsWith("!")) ? "a `!command` value in env or headers is not supported" : undefined;
 }
 
 function asStringRecord(value: unknown): Record<string, string> | undefined {
@@ -100,8 +149,11 @@ export function parseServer(
 	raw: RawServer,
 	source: string,
 	env: Record<string, string | undefined>,
+	pi?: PiFormat,
 ): McpServer | undefined {
 	if (raw.disabled === true) return undefined;
+	if (pi && raw.enabled === false) return undefined;
+	const home = (value: string) => (pi ? expandTilde(value, pi.home) : value);
 
 	if (typeof raw.url === "string" && raw.url.trim()) {
 		const headers = asStringRecord(raw.headers);
@@ -112,6 +164,7 @@ export function parseServer(
 		const referenced = referencedEnvVars(raw.url, ...Object.values(headers ?? {}));
 		return {
 			kind: "http",
+			...(raw.type === "sse" ? { transport: "sse" as const } : {}),
 			name,
 			url: expandEnv(raw.url, env),
 			headers: headers
@@ -125,11 +178,14 @@ export function parseServer(
 
 	if (typeof raw.command === "string" && raw.command.trim()) {
 		const args = Array.isArray(raw.args)
-			? raw.args.filter((a): a is string => typeof a === "string").map((a) => expandEnv(a, env))
+			? raw.args.filter((a): a is string => typeof a === "string").map((a) => home(expandEnv(a, env)))
 			: [];
+		const rawCwd = pi && typeof raw.cwd === "string" && raw.cwd.trim() ? raw.cwd : undefined;
+		const cwd = rawCwd && pi ? resolve(pi.cwd, home(expandEnv(rawCwd, env))) : undefined;
 		const rawEnv = asStringRecord(raw.env);
 		const missing = [
 			...missingEnvVars(raw.command, env),
+			...missingEnvVars(rawCwd ?? "", env),
 			...(Array.isArray(raw.args) ? raw.args : [])
 				.filter((a): a is string => typeof a === "string")
 				.flatMap((a) => missingEnvVars(a, env)),
@@ -137,15 +193,17 @@ export function parseServer(
 		];
 		const referenced = referencedEnvVars(
 			raw.command,
+			rawCwd ?? "",
 			...(Array.isArray(raw.args) ? raw.args.filter((a): a is string => typeof a === "string") : []),
 			...Object.values(rawEnv ?? {}),
 		);
 		return {
 			kind: "stdio",
 			name,
-			command: expandEnv(raw.command, env),
+			command: home(expandEnv(raw.command, env)),
 			args,
 			env: rawEnv ? Object.fromEntries(Object.entries(rawEnv).map(([k, v]) => [k, expandEnv(v, env)])) : undefined,
+			...(cwd ? { cwd } : {}),
 			source,
 			missingEnv: missing.length > 0 ? [...new Set(missing)] : undefined,
 			referencedEnv: referenced.length > 0 ? referenced : undefined,
@@ -171,7 +229,29 @@ export function findProjectConfigs(cwd: string): string[] {
 	return found.reverse();
 }
 
+/**
+ * `/mcp` with no servers: where to look when that is unexpected (`/doctor`
+ * lists config files that failed validation) and where servers go, by mode.
+ * Claude Code names its own CLI and docs here; One Code names its own.
+ */
+export const MCP_GUIDE_URL = "https://github.com/IsuruMaduranga/one-code/blob/master/docs/guide/skills-plugins-and-mcp.md#mcp-servers";
+export function noMcpServersMessage(claudeSources: boolean): string {
+	const where = claudeSources ? ".mcp.json in the project, ~/.claude.json, .pi/mcp.json or the agent dir's mcp.json" : ".pi/mcp.json or the agent dir's mcp.json";
+	return `No MCP servers configured. Run /doctor if this is unexpected — it lists MCP config files that failed validation. Otherwise, add servers to ${where}; see ${MCP_GUIDE_URL} to learn more.`;
+}
+
+/**
+ * pi's own `mcp.json` files: the agent dir's and the project's. `configDirName`
+ * is pi's `CONFIG_DIR_NAME` (`.pi` unless pi itself is rebranded); callers
+ * that import pi pass it.
+ */
+export function piMcpConfigPaths(agentDir: string, cwd: string, configDirName = ".pi"): { user: string; project: string } {
+	return { user: join(agentDir, "mcp.json"), project: join(cwd, configDirName, "mcp.json") };
+}
+
+/** Claude Code's MCP files; none in independent mode (lib/config-mode.ts), where pi's two `mcp.json` files remain. */
 export function configPaths(cwd: string, home: string): string[] {
+	if (!claudeSourcesOn()) return [];
 	return [claudeJsonPath(home), ...findProjectConfigs(cwd), join(cwd, ".claude", "settings.local.json")];
 }
 
@@ -196,6 +276,25 @@ export interface LoadServersOptions {
 	pluginNames?: ReadonlyMap<string, string>;
 	/** Called for a config file that exists but is not valid JSON (review M11: a silent drop read as "no servers configured"). */
 	onError?: (path: string, message: string) => void;
+	/** pi's own `mcp.json` files (user, then project): read in pi's format, below every Claude Code file. */
+	piConfigs?: { user: string; project: string };
+	/** Called for a pi-format server that is skipped, or overridden by a Claude Code file's server of the same name. */
+	onNote?: (message: string) => void;
+	/** Servers other pi extensions registered (`pi.getMcpServers()`): pi's format, below every file; `source` is the extension's path. */
+	registered?: readonly RegisteredServer[];
+}
+
+/** One `pi.getMcpServers()` entry, structurally (pi 0.99's `RegisteredMcpServer`). */
+export interface RegisteredServer {
+	name: string;
+	config: unknown;
+	extensionPath: string;
+}
+
+/** The servers other extensions registered (`pi.getMcpServers()`, pi 0.99+); none on an older pi. */
+export function registeredMcpServers(pi: object): RegisteredServer[] {
+	const host = pi as { getMcpServers?: () => RegisteredServer[] };
+	return typeof host.getMcpServers === "function" ? host.getMcpServers() : [];
 }
 
 export function loadServers(
@@ -206,8 +305,21 @@ export function loadServers(
 	options: LoadServersOptions = {},
 ): McpServer[] {
 	const byName = new Map<string, McpServer>();
-	// Plugin configs come first so project and user files can override them.
-	for (const path of [...extraPaths, ...configPaths(cwd, home)]) {
+	const piPaths = options.piConfigs ? [options.piConfigs.user, options.piConfigs.project] : [];
+	const piFormat: PiFormat = { home, cwd };
+	for (const { name, config, extensionPath } of options.registered ?? []) {
+		const raw = (config && typeof config === "object" ? config : {}) as RawServer;
+		const problem = piFormatProblem(raw);
+		if (problem) {
+			options.onNote?.(`MCP server "${name}" registered by ${extensionPath} is skipped: ${problem}.`);
+			continue;
+		}
+		const server = parseServer(name, raw, extensionPath, env, piFormat);
+		if (server) byName.set(name, { ...server, piOrigin: "extension" });
+	}
+	// Plugin configs come first so project and user files can override them,
+	// then pi's own files, then Claude Code's.
+	for (const path of [...extraPaths, ...piPaths, ...configPaths(cwd, home)]) {
 		if (!existsSync(path)) continue;
 		let file: Record<string, unknown> | undefined;
 		try {
@@ -219,10 +331,22 @@ export function loadServers(
 		const servers = serverMapOf(file);
 		if (!servers) continue;
 		const plugin = options.pluginNames?.get(path);
+		const piOrigin: PiOrigin | undefined =
+			path === options.piConfigs?.user ? "user" : path === options.piConfigs?.project ? "project" : undefined;
 		for (const [rawName, raw] of Object.entries(servers)) {
 			const name = plugin ? `plugin:${plugin}:${rawName}` : rawName;
-			const server = parseServer(name, raw ?? {}, path, env);
-			if (server) byName.set(name, server);
+			const problem = piOrigin ? piFormatProblem(raw ?? {}) : undefined;
+			if (problem) {
+				options.onNote?.(`MCP server "${name}" in ${path} is skipped: ${problem}.`);
+				continue;
+			}
+			const server = parseServer(name, raw ?? {}, path, env, piOrigin ? piFormat : undefined);
+			const inherited = byName.get(name);
+			// The same server kept in both (common while moving between the two) is not worth a warning.
+			if (!piOrigin && server && inherited?.piOrigin && hashServerConfig(server) !== hashServerConfig(inherited)) {
+				options.onNote?.(`MCP server "${name}" in ${inherited.source} is overridden by the one in ${path}.`);
+			}
+			if (server) byName.set(name, piOrigin ? { ...server, piOrigin } : server);
 			else byName.delete(name); // an explicit `disabled` entry removes an inherited one
 		}
 	}

package/extensions/mcp/discovery.ts

@@ -0,0 +1,19 @@
+/** Collect an MCP list response's cursor pages without silently dropping later entries. */
+export async function collectPages<T>(
+	fetchPage: (cursor?: string) => Promise<{ items: T[]; nextCursor?: string }>,
+	signal?: AbortSignal,
+): Promise<T[]> {
+	const items: T[] = [];
+	const seen = new Set<string>();
+	let cursor: string | undefined;
+	while (true) {
+		signal?.throwIfAborted();
+		const page = await fetchPage(cursor);
+		signal?.throwIfAborted();
+		for (const item of page.items) items.push(item);
+		if (page.nextCursor === undefined) return items;
+		if (seen.has(page.nextCursor)) throw new Error("MCP server repeated a pagination cursor; check the server's list implementation.");
+		seen.add(page.nextCursor);
+		cursor = page.nextCursor;
+	}
+}