pi-code 1.2.1 → 1.3.0

package/README.md

@@ -42,7 +42,7 @@ One `pi install` and everything below loads on the next start. `pi list` shows w
 Each topic links to its own doc with the full contract and any divergences from Claude Code.
 
 - **[Hooks](docs/hooks.md)** — your `.claude/settings.json` hooks on every lifecycle event, with Claude's tool vocabulary, decision fields, and background hooks.
-- **[MCP servers](docs/mcp.md)** — every Claude config scope, all four transports, OAuth, managed policy, timeouts, prompts, and resources.
+- **[MCP servers](docs/mcp.md)** — every Claude config scope, all four transports, OAuth, managed policy, timeouts, prompts, and resources. On pi 0.99 and later the servers are handed to pi's own MCP support.
 - **[Custom slash commands](docs/commands.md)** — `.claude/commands` with arguments, bash spans, `@file` inlining, frontmatter, and model invocation.
 - **[Skills](docs/skills.md)** — `.claude/skills` discovery plus the same dynamic content commands get.
 - **[Subagents](docs/subagents.md)** — built-in and custom agents, background runs, per-agent memory, worktree isolation.

package/extensions/mcp/config.ts

@@ -90,19 +90,34 @@ function claudeJsonPath(home: string): string {
   return override && override.trim().length > 0 ? path.join(claudeConfigDir(home), '.claude.json') : path.join(home, '.claude.json')
 }
 
+/** Claude's own user-scoped MCP config, without pi's mcp.json: what pi-code reads when
+ * pi's native MCP reads pi's files itself. */
+export function claudeUserConfigPaths(home: string): string[] {
+  return [claudeJsonPath(home)]
+}
+
 /** User-scoped MCP config (the user's own; safe to load without project trust). The .pi
  * tree is pi's own and is not relocated by CLAUDE_CONFIG_DIR. */
 export function userConfigPaths(home: string): string[] {
   // mcp.json lives in pi's agent directory, which PI_CODING_AGENT_DIR relocates; the
   // other agent-directory readers (trust store, OAuth tokens) already follow it.
-  return [claudeJsonPath(home), path.join(getAgentDir(), 'mcp.json')]
+  return [...claudeUserConfigPaths(home), path.join(getAgentDir(), 'mcp.json')]
 }
 
 /** Project-scoped MCP config, each file the nearest of its name at or above cwd
  * (bounded at the repository root, matching the approval walk). Loaded only for
  * trusted projects: a server's `command` runs on connect. */
 export function projectConfigPaths(cwd: string): string[] {
-  return ['.mcp.json', path.join('.pi', 'mcp.json')].map((rel) => findNearestFile(cwd, rel) ?? path.join(cwd, rel))
+  return [...claudeProjectConfigPaths(cwd), nearestConfig(cwd, path.join('.pi', 'mcp.json'))]
+}
+
+/** Claude's own project MCP config, without pi's .pi/mcp.json. */
+export function claudeProjectConfigPaths(cwd: string): string[] {
+  return [nearestConfig(cwd, '.mcp.json')]
+}
+
+function nearestConfig(cwd: string, rel: string): string {
+  return findNearestFile(cwd, rel) ?? path.join(cwd, rel)
 }
 
 /** The object entries of a raw `mcpServers` map. A string or null entry (a JSON "comment"
@@ -140,8 +155,8 @@ export function loadConfigFrom(files: string[]): Record<string, ServerConfig> {
  * Both are the user's own config, so neither needs project trust; local wins on a name
  * clash (Claude's precedence is local over user).
  */
-export function loadUserScope(home: string, cwd: string): Record<string, ServerConfig> {
-  const servers = loadConfigFrom(userConfigPaths(home))
+export function loadUserScope(home: string, cwd: string, files: string[] = userConfigPaths(home)): Record<string, ServerConfig> {
+  const servers = loadConfigFrom(files)
   Object.assign(servers, serverEntries(projectRecord(home, cwd).mcpServers, claudeJsonPath(home)))
   return servers
 }

package/extensions/mcp/index.ts

@@ -32,6 +32,7 @@
  * so the byte cap stands in for it.
  */
 
+import * as fs from 'node:fs'
 import * as os from 'node:os'
 import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent'
 import type { Client } from '@modelcontextprotocol/sdk/client/index.js'
@@ -45,9 +46,10 @@ import { isProjectApproved, isProjectApprovedSilently } from '../internal/projec
 import { checkoutRoot } from '../internal/project-root.js'
 import { claudeSettingsChain } from '../internal/settings-chain.js'
 import { errorMessage } from '../internal/values.js'
-import { disabledServerNames, loadConfigFrom, loadPluginServers, loadUserScope, localScopeServerNames, projectConfigPaths, type ServerConfig, warnOnTypelessUrl } from './config.js'
+import { claudeProjectConfigPaths, claudeUserConfigPaths, disabledServerNames, loadConfigFrom, loadPluginServers, loadUserScope, localScopeServerNames, projectConfigPaths, type ServerConfig, userConfigPaths, warnOnTypelessUrl } from './config.js'
 import { collectServerResourceEntries, listAllPrompts, listAllTools, type McpToolInfo, resourceServerFilter } from './listing.js'
 import { formatPromptCommandName, formatToolName, type McpContentBlock, type McpPromptInfo, mapContent, mapPromptArguments, normalizeSchema, promptMessageContent } from './mapping.js'
+import { nativeMode, nativeToolAliases, piMcpRunning, toNativeServer } from './native.js'
 import { applyServerPolicy, loadManagedMcpServers, type McpPolicy, mcpAllowDeny, projectServerPolicy, splitByPolicy } from './policy.js'
 import { type AuthUi, callRequestOptions, callTimeoutMs, connect, connectTimeoutMs, connectWithRetries, isConnectionLost, isUnauthorized, mcpConnectTimeoutMs, type ServerCallTuning, type SessionDirs, serverCallTuning, withTimeout } from './transport.js'
 
@@ -84,6 +86,13 @@ function authUiFor(ctx: ExtensionContext): AuthUi | undefined {
 
 export default async function mcpExtension(pi: ExtensionAPI) {
   const clients = new Map<string, Client>()
+  // pi 0.99 and later connect MCP servers themselves (docs/specs/mcp-native.md). Decided
+  // at load, since registering /mcp here is what drops pi's own; project settings count
+  // only once approved, so the policy read here is the managed and user one.
+  const native = nativeMode(pi, loadManagedMcpServers(), mcpAllowDeny(claudeSettingsChain(process.cwd(), os.homedir(), false)))
+  // Whether pi's /mcp is running this session, and the names handed to pi.registerMcpServer.
+  let nativeActive = false
+  const nativeRegistered = new Set<string>()
   // Names with a connect in flight. A name enters `clients` only once its connect
   // resolves, and shutdown clears that map without awaiting anything in flight, so
   // without this set a session switch during a slow connect (or a backoff sleep) let
@@ -135,6 +144,8 @@ export default async function mcpExtension(pi: ExtensionAPI) {
   const registered = new Map<string, string>()
   // Original server/tool names per registered pi name, for Claude-style hook matchers.
   const aliases: McpToolAlias[] = []
+  // The roster other extensions read: pi-code's own aliases plus the tools pi connected.
+  const roster = (): McpToolAlias[] => [...aliases, ...(nativeActive ? nativeToolAliases(pi.getAllTools()) : [])]
 
   /** How many tools a server actually has registered. Counted from `registered` (the
    * durable owner map) rather than registerTools' return, so a reconnect on a second
@@ -367,6 +378,8 @@ export default async function mcpExtension(pi: ExtensionAPI) {
    * fetched live on every call, so a resources list_changed needs no cache
    * invalidation; its handler only re-checks this gate (see subscribeToResourceChanges). */
   function ensureResourceTools(): void {
+    // pi registers list_mcp_resources and read_mcp_resource for the servers it connects.
+    if (nativeActive) return
     if (resourceToolsRegistered || resourceServers().length === 0) return
     resourceToolsRegistered = true
     pi.registerTool({
@@ -433,7 +446,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
           if (added === 0) return
           const current = status.get(name)
           status.set(name, { state: current?.state ?? 'connected', tools: serverToolCount(name) })
-          pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
+          pi.events.emit(MCP_TOOLS_CHANNEL, roster())
         } catch (error) {
           console.warn(`pi-code-mcp: tool refresh failed for ${name}: ${errorMessage(error)}`)
         }
@@ -443,9 +456,37 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     }
   }
 
+  /** Hands every server pi can connect to pi.registerMcpServer and returns the rest, which
+   * pi-code connects itself. */
+  function registerWithPi(servers: Record<string, ServerConfig>): Record<string, ServerConfig> {
+    const own: Record<string, ServerConfig> = {}
+    for (const [name, config] of Object.entries(servers)) {
+      const translated = toNativeServer(name, config, sessionDirs)
+      if (!('native' in translated)) {
+        own[name] = config
+        continue
+      }
+      if (config.pluginDataDir !== undefined) {
+        try {
+          fs.mkdirSync(config.pluginDataDir, { recursive: true })
+        } catch {
+          // The server still starts; one that needs the directory reports its own failure.
+        }
+      }
+      try {
+        pi.registerMcpServer(translated.native.name, translated.native.config)
+        nativeRegistered.add(translated.native.name)
+      } catch (error) {
+        console.warn(`pi-code-mcp: pi did not accept server ${name} (${errorMessage(error)}); connecting it directly`)
+        own[name] = config
+      }
+    }
+    return own
+  }
+
   async function connectServers(servers: Record<string, ServerConfig>, authUi?: AuthUi, noRetry = false): Promise<void> {
     const pending: [string, ServerConfig][] = []
-    for (const [name, config] of Object.entries(servers)) {
+    for (const [name, config] of Object.entries(nativeActive ? registerWithPi(servers) : servers)) {
       // A later scope must not take the name of a server that already connected: it
       // would evict that client from the map, leaking it at shutdown, and misreport
       // the earlier server's status.
@@ -565,7 +606,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // in ~/.claude.json's per-project disabledMcpServers list never connects.
     const pluginServers = loadPluginServers(installedPlugins(os.homedir()), checkoutRoot(ctx.cwd))
     const disabled = disabledServerNames(os.homedir(), ctx.cwd)
-    const merged = Object.fromEntries(Object.entries({ ...pluginServers, ...loadUserScope(os.homedir(), ctx.cwd) }).filter(([name]) => !disabled.has(name)))
+    const merged = Object.fromEntries(Object.entries({ ...pluginServers, ...loadUserScope(os.homedir(), ctx.cwd, nativeActive ? claudeUserConfigPaths(os.homedir()) : userConfigPaths(os.homedir())) }).filter(([name]) => !disabled.has(name)))
     const scoped = applyServerPolicy(merged, policy)
     // Claude's precedence is project over user for a duplicate name. A project .mcp.json
     // server only outranks the user's own when it will actually connect (the user already
@@ -579,7 +620,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     const projectPolicy = projectServerPolicy(ctx.cwd, os.homedir(), projectApproved)
     // Tag the scope on each project server: a repository-supplied headersHelper runs
     // with credential variables stripped, unlike a user-scope one.
-    const projectServers = Object.fromEntries(Object.entries(loadConfigFrom(projectConfigPaths(ctx.cwd))).map(([name, config]) => [name, { ...config, projectScope: true }]))
+    const projectServers = Object.fromEntries(Object.entries(loadConfigFrom(nativeActive ? claudeProjectConfigPaths(ctx.cwd) : projectConfigPaths(ctx.cwd))).map(([name, config]) => [name, { ...config, projectScope: true }]))
     const { consented: consentedRaw, gated } = splitByPolicy(applyServerPolicy(projectServers, policy), projectPolicy)
     // Claude's scope precedence is local over project: a name the local scope defines
     // stays with the local (user-side) definition, so the project's entry is dropped
@@ -619,7 +660,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
    * then) and again when a still-connecting tail finishes, so a server that connects
    * late still gets its aliases published and counted. */
   function publishConnectionSummary(ctx: ExtensionContext): void {
-    pi.events.emit(MCP_TOOLS_CHANNEL, [...aliases])
+    pi.events.emit(MCP_TOOLS_CHANNEL, roster())
     const connected = [...status.values()].filter((s) => s.state === 'connected')
     const failed = [...status.entries()].filter(([, s]) => s.state !== 'connected' && s.state !== 'connecting')
     if (connected.length > 0 || failed.length > 0) {
@@ -647,6 +688,7 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // Claude answers roots/list with the session's launch directory and exports the
     // project root as CLAUDE_PROJECT_DIR to stdio servers; both derive from ctx.cwd.
     sessionDirs = { projectDir: checkoutRoot(ctx.cwd), launchDir: ctx.cwd, sessionId: ctx.sessionManager?.getSessionId?.() }
+    nativeActive = native && piMcpRunning(pi.getCommands())
     const authUi = authUiFor(ctx)
     sessionAuthUi = authUi
     // The allow/deny lists filter every scope, including a managed-mcp.json set. They
@@ -705,6 +747,20 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     // closure on a closed client. session_start resets status too, so a switch rebuilds it.
     clients.clear()
     status.clear()
+    for (const name of nativeRegistered) {
+      try {
+        pi.unregisterMcpServer(name)
+      } catch {
+        // pi is tearing the session down; a name it no longer knows needs no removal.
+      }
+    }
+    nativeRegistered.clear()
+  })
+
+  // pi's MCP tools register as their servers connect, after session_start; each turn
+  // republishes the roster so hook matchers and subagent patterns see them.
+  pi.on('turn_start', () => {
+    if (nativeActive) pi.events.emit(MCP_TOOLS_CHANNEL, roster())
   })
 
   // Claude references MCP resources with @server:uri mentions, fetched into the
@@ -735,15 +791,17 @@ export default async function mcpExtension(pi: ExtensionAPI) {
     return { action: 'transform', text: `${event.text}\n\n${sections.join('\n\n')}` }
   })
 
-  pi.registerCommand('mcp', {
-    description: 'Show MCP server status and tools',
-    handler: async (_args, ctx) => {
-      if (status.size === 0) {
-        ctx.ui.notify('No MCP servers configured. Add them to .mcp.json, .pi/mcp.json, ~/.claude.json, or ~/.pi/agent/mcp.json', 'info')
-        return
-      }
-      const lines = [...status.entries()].map(([name, s]) => `${name}: ${s.state} (${s.tools} tools)`)
-      ctx.ui.notify(lines.join('\n'), 'info')
-    },
-  })
+  // In native mode /mcp is pi's.
+  if (!native)
+    pi.registerCommand('mcp', {
+      description: 'Show MCP server status and tools',
+      handler: async (_args, ctx) => {
+        if (status.size === 0) {
+          ctx.ui.notify('No MCP servers configured. Add them to .mcp.json, .pi/mcp.json, ~/.claude.json, or ~/.pi/agent/mcp.json', 'info')
+          return
+        }
+        const lines = [...status.entries()].map(([name, s]) => `${name}: ${s.state} (${s.tools} tools)`)
+        ctx.ui.notify(lines.join('\n'), 'info')
+      },
+    })
 }

package/extensions/mcp/native.ts

@@ -0,0 +1,123 @@
+/**
+ * pi's native MCP (pi 0.99 and later): translation of pi-code's server configs into the
+ * `McpServerConfig` pi.registerMcpServer() takes.
+ */
+
+import * as os from 'node:os'
+import type { McpServerConfig } from '@earendil-works/pi-coding-agent'
+import type { McpToolAlias } from '../internal/mcp-alias.js'
+import { type HttpServerConfig, interpolateEnv, type ServerConfig, type StdioServerConfig } from './config.js'
+import type { McpPolicy } from './policy.js'
+import { callBudgetMs, type SessionDirs } from './transport.js'
+
+export interface NativeServer {
+  name: string
+  config: McpServerConfig
+}
+
+/** A server pi can connect, or why it stays on pi-code's client. */
+export type NativeTranslation = { native: NativeServer } | { reason: string }
+
+// pi's server names; its tools become mcp__<name>__<tool>.
+const NATIVE_NAME = /^[A-Za-z0-9_-]+$/
+
+/** pi resolves env and header values itself: a leading `!` runs the value as a shell
+ * command and `$NAME` / `${NAME}` expand. pi-code has already applied Claude's expansion,
+ * so the result is escaped to reach the server as written (`$$` is `$`, `$!` is `!`). */
+function literal(value: string): string {
+  return value.replaceAll('$', () => '$$').replace(/^!/, () => '$!')
+}
+
+function mapValues(record: Record<string, string>, map: (value: string) => string): Record<string, string> {
+  return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, map(value)]))
+}
+
+/** Plugin servers register as plugin_<plugin>_<server>, so pi's tool names match
+ * Claude's mcp__plugin_<plugin>_<server>__<tool>. */
+function nativeName(name: string, config: ServerConfig): string {
+  return config.aliasPrefix?.replace(/^mcp__/, '').replace(/__$/, '') ?? name
+}
+
+function stdioConfig(config: StdioServerConfig, fill: (value: string) => string, session?: SessionDirs): McpServerConfig {
+  // The variables pi-code's own client exports to a stdio server (transport.ts stdioEnv).
+  const env: Record<string, string> = { ...mapValues(config.env ?? {}, fill), CLAUDECODE: '1' }
+  if (session) env.CLAUDE_PROJECT_DIR = session.projectDir
+  if (session?.sessionId) env.CLAUDE_CODE_SESSION_ID = session.sessionId
+  if (config.pluginRoot !== undefined) env.CLAUDE_PLUGIN_ROOT = config.pluginRoot
+  if (config.pluginDataDir !== undefined) env.CLAUDE_PLUGIN_DATA = config.pluginDataDir
+  const cwd = config.cwd ? fill(config.cwd).replace(/^~(?=\/|$)/, os.homedir()) : undefined
+  return {
+    command: fill(config.command),
+    args: (config.args ?? []).map(fill),
+    env: mapValues(env, literal),
+    ...(cwd === undefined ? {} : { cwd }),
+  }
+}
+
+/** An inline bearerToken (expanded) wins over bearerTokenEnv, which names a variable read as is. */
+function bearerToken(config: HttpServerConfig, fill: (value: string) => string, env: NodeJS.ProcessEnv): string | undefined {
+  if (config.bearerToken) return fill(config.bearerToken)
+  return config.bearerTokenEnv ? env[config.bearerTokenEnv] : undefined
+}
+
+function httpConfig(config: HttpServerConfig, fill: (value: string) => string, env: NodeJS.ProcessEnv): McpServerConfig {
+  const headers = mapValues(config.headers ?? {}, fill)
+  const token = bearerToken(config, fill, env)
+  if (token) headers.Authorization = `Bearer ${token}`
+  const oauth = config.oauth
+  const secret = env.MCP_CLIENT_SECRET
+  return {
+    url: fill(config.url),
+    ...(Object.keys(headers).length > 0 ? { headers: mapValues(headers, literal) } : {}),
+    ...(oauth
+      ? {
+          oauth: {
+            ...(oauth.clientId === undefined ? {} : { clientId: oauth.clientId }),
+            ...(oauth.clientId !== undefined && secret ? { clientSecret: literal(secret) } : {}),
+            ...(oauth.callbackPort === undefined ? {} : { callbackPort: oauth.callbackPort }),
+            ...(oauth.scopes === undefined ? {} : { scope: oauth.scopes }),
+          },
+        }
+      : {}),
+  }
+}
+
+function unsupported(config: ServerConfig): string | undefined {
+  if ('url' in config) {
+    if (config.type === 'sse' || config.type === 'ws' || config.type === 'websocket') return `${config.type} transport`
+    if (config.headersHelper !== undefined) return 'headersHelper'
+  }
+  return undefined
+}
+
+/** The config pi connects for this server, or the reason pi-code keeps it: pi has no SSE
+ * or WebSocket transport, no header helper, and accepts only [A-Za-z0-9_-] names. */
+export function toNativeServer(name: string, config: ServerConfig, session?: SessionDirs, env: NodeJS.ProcessEnv = process.env): NativeTranslation {
+  const reason = unsupported(config)
+  if (reason) return { reason }
+  const registered = nativeName(name, config)
+  if (!NATIVE_NAME.test(registered)) return { reason: 'server name' }
+  const fill = (value: string): string => interpolateEnv(value, env)
+  const transport = 'url' in config ? httpConfig(config, fill, env) : stdioConfig(config, fill, session)
+  return { native: { name: registered, config: { ...transport, exposure: 'direct', timeout: Math.ceil(callBudgetMs(config) / 1000) } as McpServerConfig } }
+}
+
+/** Whether pi connects the servers: its API exists (pi 0.99 and later) and no MCP policy
+ * is configured. pi also connects the servers in its own mcp.json files, which Claude's
+ * managed-mcp.json and allow and deny lists would not reach, so a policy keeps pi-code's
+ * own client for everything. */
+export function nativeMode(api: object, managed: unknown, policy: McpPolicy): boolean {
+  if (typeof (api as { registerMcpServer?: unknown }).registerMcpServer !== 'function') return false
+  return managed === null && policy.allowed === null && policy.denied.length === 0
+}
+
+/** Whether pi's own /mcp is loaded, i.e. its MCP extension was neither disabled
+ * (`-builtin:mcp`) nor replaced by another extension's /mcp. */
+export function piMcpRunning(commands: ReadonlyArray<{ name: string; sourceInfo?: { path?: string } }>): boolean {
+  return commands.some((command) => command.name === 'mcp' && command.sourceInfo?.path === 'builtin:mcp')
+}
+
+/** pi's MCP tools already carry Claude's mcp__<server>__<tool> names, so each is its own alias. */
+export function nativeToolAliases(tools: ReadonlyArray<{ name: string }>): McpToolAlias[] {
+  return tools.filter((tool) => tool.name.startsWith('mcp__')).map((tool) => ({ pi: tool.name, claude: tool.name }))
+}

package/extensions/mcp/transport.ts

@@ -98,6 +98,15 @@ export function callRequestOptions(wall: number, tuning: ServerCallTuning = {}):
   return { timeout: idle, resetTimeoutOnProgress: true, maxTotalTimeout: wall, onprogress: () => {} }
 }
 
+/** The single timeout a server's calls get where only one can be set (pi's native MCP,
+ * whose timeout resets on progress): the idle window, or the wall budget when the idle
+ * timeout is disabled or looser than it. */
+export function callBudgetMs(config: ServerConfig): number {
+  const wall = callTimeoutMs()
+  const idle = idleTimeoutMs(serverCallTuning(config))
+  return idle === 0 || idle >= wall ? wall : idle
+}
+
 /** The tuning one server's config yields: its transport kind, and its declared
  * per-server timeout. Per Claude, timeout values below 1000 are ignored and fall
  * through to MCP_TOOL_TIMEOUT. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-code",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "Claude Code experience for the pi coding agent: reads your .claude config (rules, commands, skills, hooks, output styles, MCP servers, agents) and adds todo, checkpoints, memory, web, subagents, and goals",
   "keywords": [
     "pi",
@@ -63,10 +63,10 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.4",
-    "@earendil-works/pi-agent-core": "^0.85.1",
-    "@earendil-works/pi-ai": "^0.85.1",
-    "@earendil-works/pi-coding-agent": "^0.85.1",
-    "@earendil-works/pi-tui": "^0.85.1",
+    "@earendil-works/pi-agent-core": "^0.99.1",
+    "@earendil-works/pi-ai": "^0.99.1",
+    "@earendil-works/pi-coding-agent": "^0.99.1",
+    "@earendil-works/pi-tui": "^0.99.1",
     "@types/node": "^26.1.1",
     "@vitest/coverage-v8": "^5.0.0",
     "fast-check": "^4.9.0",