pi-mcp-adapter 2.6.1 → 2.7.0

package/CHANGELOG.md

@@ -7,6 +7,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.7.0] - 2026-05-22
+
+### Added
+- Added TUI call rendering for MCP proxy and direct tool inputs. Thanks @dmmulroy for PR #102.
+
+### Fixed
+- Hardened OAuth credential storage paths against server-name path traversal without rejecting valid configured server names.
+- Rejected unsafe regex-mode MCP search patterns before executing them.
+
 ## [2.6.1] - 2026-05-13
 
 ### Added

package/index.ts

@@ -9,7 +9,7 @@ import { loadMetadataCache } from "./metadata-cache.ts";
 import { executeCall, executeConnect, executeDescribe, executeList, executeSearch, executeStatus, executeUiMessages } from "./proxy-modes.ts";
 import { getConfigPathFromArgv, truncateAtWord } from "./utils.ts";
 import { initializeOAuth, shutdownOAuth } from "./mcp-auth-flow.ts";
-import { renderMcpToolResult } from "./tool-result-renderer.ts";
+import { createMcpDirectToolCallRenderer, renderMcpProxyToolCall, renderMcpToolResult } from "./tool-result-renderer.ts";
 
 export default function mcpAdapter(pi: ExtensionAPI) {
   let state: McpExtensionState | null = null;
@@ -74,6 +74,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
       promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
       parameters: Type.Unsafe((spec.inputSchema || { type: "object", properties: {} }) as never),
       execute: createDirectToolExecutor(() => state, () => initPromise, spec),
+      renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
       renderResult: renderMcpToolResult,
     });
   }
@@ -252,6 +253,7 @@ export default function mcpAdapter(pi: ExtensionAPI) {
       label: "MCP",
       description: buildProxyDescription(earlyConfig, earlyCache, directSpecs),
       promptSnippet: "MCP gateway - connect to MCP servers and call their tools",
+      renderCall: renderMcpProxyToolCall,
       parameters: Type.Object({
         tool: Type.Optional(Type.String({ description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
         args: Type.Optional(Type.String({ description: "Arguments as JSON string (e.g., '{\"key\": \"value\"}')" })),

package/mcp-auth.ts

@@ -2,13 +2,13 @@
  * MCP Auth Storage Module
  * 
  * Handles secure storage of OAuth credentials, tokens, client information,
- * and PKCE state for MCP servers. Maintains backward compatibility with
- * per-server directory structure.
+ * and PKCE state for MCP servers.
  * 
- * Token storage location: $MCP_OAUTH_DIR/<server>/tokens.json when set,
- * otherwise <Pi agent dir>/mcp-oauth/<server>/tokens.json
+ * Token storage location: $MCP_OAUTH_DIR/sha256-<server-hash>/tokens.json when set,
+ * otherwise <Pi agent dir>/mcp-oauth/sha256-<server-hash>/tokens.json
  */
 
+import { createHash } from 'crypto';
 import { mkdirSync, readFileSync, writeFileSync, existsSync, rmSync } from 'fs';
 import { join } from 'path';
 import { getAgentPath } from './agent-dir.ts';
@@ -48,13 +48,17 @@ function getAuthBaseDir(): string {
  * Get the server-specific directory path.
  */
 function getServerDir(serverName: string): string {
-  return join(getAuthBaseDir(), serverName);
+  if (typeof serverName !== 'string') {
+    throw new Error(`Invalid MCP server name: ${JSON.stringify(serverName)}`);
+  }
+  const storageKey = createHash('sha256').update(serverName, 'utf8').digest('hex');
+  return join(getAuthBaseDir(), `sha256-${storageKey}`);
 }
 
 /**
  * Get the tokens file path for a server.
  */
-function getTokensFilePath(serverName: string): string {
+export function getAuthEntryFilePath(serverName: string): string {
   return join(getServerDir(serverName), 'tokens.json');
 }
 
@@ -73,8 +77,8 @@ function ensureServerDir(serverName: string): void {
  * Returns undefined if file doesn't exist.
  */
 function readAuthEntry(serverName: string): AuthEntry | undefined {
+  const filePath = getAuthEntryFilePath(serverName);
   try {
-    const filePath = getTokensFilePath(serverName);
     if (!existsSync(filePath)) {
       return undefined;
     }
@@ -91,7 +95,7 @@ function readAuthEntry(serverName: string): AuthEntry | undefined {
  */
 function writeAuthEntry(serverName: string, entry: AuthEntry): void {
   ensureServerDir(serverName);
-  const filePath = getTokensFilePath(serverName);
+  const filePath = getAuthEntryFilePath(serverName);
   writeFileSync(filePath, JSON.stringify(entry, null, 2), { mode: 0o600 });
 }
 
@@ -136,7 +140,7 @@ export function saveAuthEntry(serverName: string, entry: AuthEntry, serverUrl?:
  */
 export function removeAuthEntry(serverName: string): void {
   try {
-    const filePath = getTokensFilePath(serverName);
+    const filePath = getAuthEntryFilePath(serverName);
     if (existsSync(filePath)) {
       writeFileSync(filePath, '{}', { mode: 0o600 });
     }

package/oauth-handler.ts

@@ -1,22 +1,19 @@
 // oauth-handler.ts - OAuth token management for MCP servers
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentPath } from "./agent-dir.ts";
 import type { OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import { getAuthEntryFilePath } from "./mcp-auth.ts";
 
 // Token storage path for a server
 function getTokensPath(serverName: string): string {
-  const override = process.env.MCP_OAUTH_DIR?.trim();
-  const authDir = override ? override : getAgentPath("mcp-oauth");
-  return join(authDir, serverName, "tokens.json");
+  return getAuthEntryFilePath(serverName);
 }
 
 /**
  * Get stored OAuth tokens for a server (if any).
  * Returns undefined if no tokens or tokens are expired.
  * 
- * Token file location: $MCP_OAUTH_DIR/<server>/tokens.json when set,
- * otherwise <Pi agent dir>/mcp-oauth/<server>/tokens.json
+ * Token file location: $MCP_OAUTH_DIR/sha256-<server-hash>/tokens.json when set,
+ * otherwise <Pi agent dir>/mcp-oauth/sha256-<server-hash>/tokens.json
  * 
  * Expected format:
  * {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "2.6.1",
+  "version": "2.7.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -85,6 +85,7 @@
     "@modelcontextprotocol/ext-apps": "^1.2.2",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "open": "^10.2.0",
+    "recheck": "^4.5.0",
     "typebox": "^1.1.24",
     "zod": "^3.25.0 || ^4.0.0"
   },

package/proxy-modes.ts

@@ -1,4 +1,5 @@
 import type { AgentToolResult, ToolInfo } from "@earendil-works/pi-coding-agent";
+import { checkSync } from "recheck";
 import type { McpExtensionState } from "./state.ts";
 import type { ToolMetadata, McpContent } from "./types.ts";
 import { getServerPrefix, parseUiPromptHandoff } from "./types.ts";
@@ -11,6 +12,13 @@ import { authenticate, supportsOAuth } from "./mcp-auth-flow.ts";
 
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
 
+const MAX_REGEX_SEARCH_QUERY_LENGTH = 256;
+const REGEX_SAFETY_CHECK_PARAMS = {
+  attackTimeout: 50,
+  incubationTimeout: 50,
+  timeout: 250,
+} as const;
+
 type AutoAuthResult =
   | { status: "skipped" }
   | { status: "success" }
@@ -258,7 +266,30 @@ export function executeSearch(
   let pattern: RegExp;
   try {
     if (regex) {
+      if (query.length > MAX_REGEX_SEARCH_QUERY_LENGTH) {
+        return {
+          content: [{ type: "text" as const, text: `Regex query is too long; maximum length is ${MAX_REGEX_SEARCH_QUERY_LENGTH} characters.` }],
+          details: { mode: "search", error: "query_too_long", query, maxLength: MAX_REGEX_SEARCH_QUERY_LENGTH },
+        };
+      }
+
       pattern = new RegExp(query, "i");
+      let safety;
+      try {
+        safety = checkSync(query, "i", REGEX_SAFETY_CHECK_PARAMS);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [{ type: "text" as const, text: "Regex query rejected because safety analysis failed." }],
+          details: { mode: "search", error: "unsafe_pattern", query, reason: message },
+        };
+      }
+      if (safety.status !== "safe") {
+        return {
+          content: [{ type: "text" as const, text: `Regex query rejected as unsafe (${safety.status}).` }],
+          details: { mode: "search", error: "unsafe_pattern", query, safetyStatus: safety.status },
+        };
+      }
     } else {
       const terms = query.trim().split(/\s+/).filter(t => t.length > 0);
       if (terms.length === 0) {

package/tool-result-renderer.ts

@@ -6,6 +6,19 @@ type McpToolContentBlock = AgentToolResult<McpToolResultDetails>["content"][numb
 
 interface RenderTheme {
   fg: (name: string, text: string) => string;
+  bold?: (text: string) => string;
+}
+
+export interface McpProxyToolCallInput {
+  tool?: string;
+  args?: string;
+  connect?: string;
+  describe?: string;
+  search?: string;
+  regex?: boolean;
+  includeSchemas?: boolean;
+  server?: string;
+  action?: string;
 }
 
 interface McpToolRenderContext {
@@ -17,6 +30,89 @@ export interface McpToolResultDisplay {
   truncated: boolean;
 }
 
+const DEFAULT_MAX_CALL_INPUT_CHARS = 1500;
+
+function truncateText(value: string, maxChars: number): string {
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+
+function formatJsonish(value: unknown, maxChars: number): string {
+  if (typeof value === "string") {
+    try {
+      return truncateText(JSON.stringify(JSON.parse(value), null, 2), maxChars);
+    } catch {
+      return truncateText(value, maxChars);
+    }
+  }
+
+  try {
+    return truncateText(JSON.stringify(value, null, 2), maxChars);
+  } catch {
+    return truncateText(String(value), maxChars);
+  }
+}
+
+function hasUsefulObjectContent(value: unknown): boolean {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+
+export function formatMcpProxyToolCallLines(
+  args: McpProxyToolCallInput,
+  maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS,
+): string[] {
+  if (args.action === "ui-messages") return [`mcp ${args.action}`];
+
+  if (args.tool) {
+    const target = args.server ? `${args.tool} @ ${args.server}` : args.tool;
+    const lines = [`mcp call ${target}`];
+    if (args.args) lines.push(formatJsonish(args.args, maxInputChars));
+    return lines;
+  }
+
+  if (args.connect) return [`mcp connect ${args.connect}`];
+  if (args.describe) return [`mcp describe ${args.describe}`];
+
+  if (args.search) {
+    let line = `mcp search ${args.search}`;
+    if (args.server) line += ` @ ${args.server}`;
+    if (args.regex === true) line += " (regex)";
+    if (args.includeSchemas === false) line += " (schemas hidden)";
+    return [line];
+  }
+
+  if (args.server) return [`mcp list ${args.server}`];
+  if (args.action) return [`mcp ${args.action}`];
+
+  return ["mcp status"];
+}
+
+export function formatMcpDirectToolCallLines(
+  displayName: string,
+  args: Record<string, unknown>,
+  maxInputChars = DEFAULT_MAX_CALL_INPUT_CHARS,
+): string[] {
+  if (!hasUsefulObjectContent(args)) return [displayName];
+  return [displayName, formatJsonish(args, maxInputChars)];
+}
+
+function renderToolCallLines(lines: string[], theme: RenderTheme) {
+  const [title = "mcp", ...rest] = lines;
+  const styledTitle = theme.fg("toolTitle", theme.bold ? theme.bold(title) : title);
+  const styledRest = rest.map(line => theme.fg("muted", line));
+  return new Text([styledTitle, ...styledRest].join("\n"), 0, 0);
+}
+
+export function renderMcpProxyToolCall(args: McpProxyToolCallInput, theme: RenderTheme) {
+  return renderToolCallLines(formatMcpProxyToolCallLines(args), theme);
+}
+
+export function createMcpDirectToolCallRenderer(displayName: string) {
+  return (args: Record<string, unknown>, theme: RenderTheme) => {
+    return renderToolCallLines(formatMcpDirectToolCallLines(displayName, args), theme);
+  };
+}
+
 function blockToLines(block: McpToolContentBlock): string[] {
   if (block.type === "text") {
     return block.text.split("\n");