pi-mcp-adapter 5.3.0 → 5.3.2

package/project-server-trust.ts

@@ -80,7 +80,8 @@ export function hashProjectServerDefinition(definition: ServerDefinition): strin
 
 export function canonicalProjectRoot(cwd: string): string {
   try {
-    return realpathSync(cwd);
+    // The native realpath returns the on-disk casing, so `C:\Users\Me` and `c:\users\me` share approvals.
+    return realpathSync.native(cwd);
   } catch {
     return resolve(cwd);
   }
@@ -114,9 +115,9 @@ function linkedWorktreeRepoScope(dotGit: string): string | undefined {
     if (!lstatSync(dotGit).isFile()) return undefined;
     const pointer = /^gitdir: (.+)$/m.exec(readFileSync(dotGit, "utf8"))?.[1]?.trim();
     if (!pointer) return undefined;
-    const adminDir = realpathSync(resolve(dirname(dotGit), pointer));
+    const adminDir = realpathSync.native(resolve(dirname(dotGit), pointer));
     const backLink = readFileSync(join(adminDir, "gitdir"), "utf8").trim();
-    if (realpathSync(resolve(adminDir, backLink)) !== realpathSync(dotGit)) return undefined;
+    if (realpathSync.native(resolve(adminDir, backLink)) !== realpathSync.native(dotGit)) return undefined;
     const commonDir = dirname(dirname(adminDir));
     const bare = /^\s*bare\s*=\s*(true|yes|on|1)\s*$/im.test(readFileSync(join(commonDir, "config"), "utf8"));
     return basename(commonDir) === ".git" && !bare ? dirname(commonDir) : `git-dir:${commonDir}`;
@@ -169,6 +170,49 @@ export function approveProjectServer(cwd: string, serverName: string, definition
   });
 }
 
+function isApproved(approvals: ApprovalStore, projectRoot: string, serverName: string, definition: ServerDefinition): boolean {
+  const definitionHash = hashProjectServerDefinition(definition);
+  return approvals.approvals.some(entry =>
+    entry.projectRoot === projectRoot && entry.serverName === serverName && entry.definitionHash === definitionHash);
+}
+
+function isProjectTrusted(ctx: Pick<ExtensionContext, "isProjectTrusted">): boolean {
+  try {
+    return ctx.isProjectTrusted();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * After the adapter edits config on the user's behalf (a panel save), re-approve each named project
+ * server whose pre-edit definition was approved, so the edit does not revoke the approval. Only a
+ * `directTools` change carries the approval over; any other difference, such as a concurrent edit to
+ * the file, still needs a new approval. A server without a matching approval stays unapproved: an
+ * adapter edit never creates one.
+ */
+export function keepProjectServerApprovals(
+  ctx: Pick<ExtensionContext, "cwd" | "isProjectTrusted">,
+  before: McpConfig,
+  after: McpConfig,
+  serverNames: Iterable<string>,
+): void {
+  if (!isProjectTrusted(ctx)) return;
+  const projectServers = asLoadedConfig(after).projectServers;
+  const projectRoot = projectApprovalScope(ctx.cwd);
+  const approvals = loadApprovals();
+  for (const name of serverNames) {
+    const previous = before.mcpServers[name];
+    const next = after.mcpServers[name];
+    if (!previous || !next || !projectServers.has(name)) continue;
+    if (!isApproved(approvals, projectRoot, name, previous)) continue;
+    const { directTools: _previousDirectTools, ...previousRest } = previous;
+    const { directTools: _nextDirectTools, ...nextRest } = next;
+    if (hashProjectServerDefinition(previousRest) !== hashProjectServerDefinition(nextRest)) continue;
+    approveProjectServer(ctx.cwd, name, next);
+  }
+}
+
 function describeServer(definition: ServerDefinition): string {
   if (definition.command) {
     return [definition.command, ...(definition.args ?? [])].map(value => JSON.stringify(value)).join(" ");
@@ -186,12 +230,7 @@ export async function applyProjectServerTrust(
   const blockedServers = new Map<string, ProjectServerBlock>();
   if (loaded.projectServers.size === 0) return { config, blockedServers };
 
-  let projectTrusted = false;
-  try {
-    projectTrusted = ctx.isProjectTrusted();
-  } catch {
-    projectTrusted = false;
-  }
+  const projectTrusted = isProjectTrusted(ctx);
   // RPC sessions also have a UI, but Pi reads RPC input only after session_start, so a dialog here never resolves.
   const interactive = ctx.hasUI && ctx.mode === "tui";
   const projectRoot = projectApprovalScope(ctx.cwd);
@@ -200,9 +239,7 @@ export async function applyProjectServerTrust(
   for (const [name, source] of loaded.projectServers) {
     const definition = config.mcpServers[name];
     if (!definition || isServerDisabled(definition)) continue;
-    const definitionHash = hashProjectServerDefinition(definition);
-    const approved = approvals.approvals.some(entry =>
-      entry.projectRoot === projectRoot && entry.serverName === name && entry.definitionHash === definitionHash);
+    const approved = isApproved(approvals, projectRoot, name, definition);
     if (projectTrusted && (approved || (!interactive && loaded.projectServerPolicy === "allow"))) continue;
 
     let reason: ProjectServerBlockReason;

package/proxy-modes.ts

@@ -7,7 +7,7 @@ import { getServerPrefix, getToolNameCandidates, isServerDisabled, parseUiPrompt
 import { lazyConnect, markKeepAliveAfterConnect, notifyToolMetadataUpdated, updateServerMetadata, updateMetadataCache, getFailureAgeSeconds, updateStatusBar, clearFailure, recordFailure } from "./init.ts";
 import { abortable, throwIfAborted } from "./abort.ts";
 import { combineAbortSignals, isAbortError } from "./runtime-owner.ts";
-import { buildToolMetadata, getToolNames, formatSchema } from "./tool-metadata.ts";
+import { buildToolMetadata, getToolNames, formatSchema, isPlainTypeSchema } from "./tool-metadata.ts";
 import { renderTsShape } from "./ts-shape.ts";
 import { getObservedOutput, observedOutputRecorder, renderOutputShape } from "./output-shape.ts";
 import { reconstructPromptMetadata } from "./metadata-cache.ts";
@@ -800,7 +800,9 @@ export function executeDescribe(state: McpExtensionState, toolName: string, serv
 
   if (toolMeta.inputSchema && !toolMeta.resourceUri) {
     const shape = renderTsShape(toolMeta.inputSchema);
-    text += shape === null ? `\nParameters:\n${formatSchema(toolMeta.inputSchema)}` : `\nShape:\n${shape}`;
+    text += shape !== null && isPlainTypeSchema(toolMeta.inputSchema)
+      ? `\nShape:\n${shape}`
+      : `\nInput schema (JSON Schema):\n\`\`\`json\n${JSON.stringify(toolMeta.inputSchema, null, 2)}\n\`\`\``;
   } else if (toolMeta.resourceUri) {
     text += `\nNo parameters required (resource tool).`;
   } else {
@@ -819,6 +821,16 @@ export function executeDescribe(state: McpExtensionState, toolName: string, serv
   };
 }
 
+export async function executeGuardedDescribe(state: McpExtensionState, toolName: string, serverOverride?: string): Promise<ProxyToolResult> {
+  const result = executeDescribe(state, toolName, serverOverride);
+  const guarded = await guardMcpOutput(result.content, resolveMcpOutputGuardOptions(state.config.settings));
+  return {
+    ...result,
+    content: guarded.content,
+    details: { ...result.details, ...guardedMcpDetails(guarded) },
+  };
+}
+
 function renderSearchResults(
   state: McpExtensionState,
   query: string,
@@ -868,6 +880,9 @@ function renderSearchResults(
         text += shape === null
           ? `\n  Parameters:\n${formatSchema(match.tool.inputSchema, "    ")}\n`
           : `\n  Shape:\n${shape.split("\n").map(line => `    ${line}`).join("\n")}\n`;
+        if (shape === null || !isPlainTypeSchema(match.tool.inputSchema)) {
+          text += `  Parameter summary only. Full input schema: mcp(${JSON.stringify({ describe: match.tool.name, server: match.server })})\n`;
+        }
       } else if (match.tool.resourceUri) {
         text += "  No parameters (resource tool).\n";
       }

package/sampling-handler.ts

@@ -1,4 +1,4 @@
-import type { Api, AssistantMessage, Message, Model, TextContent } from "@earendil-works/pi-ai";
+import type { Api, AssistantMessage, Message, Model, ModelThinkingLevel, TextContent } from "@earendil-works/pi-ai";
 import { truncateAtWord } from "./utils.ts";
 import { throwIfAborted } from "./abort.ts";
 import type { ExtensionUIContext, ModelRegistry } from "@earendil-works/pi-coding-agent";
@@ -12,7 +12,7 @@ import {
 } from "@modelcontextprotocol/client";
 
 export type SamplingUIContext = Pick<ExtensionUIContext, "confirm">;
-export type SamplingModelRegistry = Pick<ModelRegistry, "getAvailable" | "complete">;
+export type SamplingModelRegistry = Pick<ModelRegistry, "getAvailable" | "complete"> & Partial<Pick<ModelRegistry, "streamSimple">>;
 
 export interface SamplingHandlerOptions {
   serverName: string;
@@ -20,6 +20,7 @@ export interface SamplingHandlerOptions {
   ui?: SamplingUIContext;
   modelRegistry: SamplingModelRegistry;
   getCurrentModel: () => Model<Api> | undefined;
+  getThinkingLevel: () => ModelThinkingLevel;
   getSignal: () => AbortSignal | undefined;
 }
 
@@ -65,19 +66,24 @@ export async function handleSamplingRequest(
   );
   throwIfAborted(signal);
 
-  const result = await options.modelRegistry.complete(
-    model,
-    {
-      ...(params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {}),
-      messages,
-    },
-    {
-      maxTokens: params.maxTokens,
-      ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
-      ...(params.metadata !== undefined ? { metadata: params.metadata as Record<string, unknown> } : {}),
-      ...(signal ? { signal } : {}),
-    },
-  );
+  const context = {
+    ...(params.systemPrompt !== undefined ? { systemPrompt: params.systemPrompt } : {}),
+    messages,
+  };
+  const requestOptions = {
+    maxTokens: params.maxTokens,
+    ...(params.temperature !== undefined ? { temperature: params.temperature } : {}),
+    ...(params.metadata !== undefined ? { metadata: params.metadata as Record<string, unknown> } : {}),
+    ...(signal ? { signal } : {}),
+  };
+  const thinkingLevel = options.getThinkingLevel();
+  // Only streamSimple applies the thinking level; Pi before 0.86 has no streamSimple, so sampling runs with thinking off there.
+  const result = options.modelRegistry.streamSimple
+    ? await options.modelRegistry.streamSimple(model, context, {
+      ...requestOptions,
+      ...(thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
+    }).result()
+    : await options.modelRegistry.complete(model, context, requestOptions);
 
   const converted = convertAssistantResult(result);
   throwIfAborted(signal);

package/server-manager.ts

@@ -1307,7 +1307,7 @@ export class McpServerManager {
             transport,
             requestTimeoutMs: this.getResolvedRequestTimeoutMs(definition),
             clientInfo: { name: `pi-mcp-${name}`, version: "1.0.0" },
-            clientCapabilities: this.buildClientCapabilities(),
+            clientCapabilities: this.buildClientCapabilities(definition),
             ...(this.elicitationConfig
               ? {
                   onElicitation: (request: Parameters<typeof handleElicitationRequest>[1], signal?: AbortSignal) =>
@@ -1449,13 +1449,12 @@ export class McpServerManager {
     }
   }
 
-  private buildClientCapabilities() {
+  private buildClientCapabilities(definition: ServerDefinition) {
     return {
-      extensions: {
-        "io.modelcontextprotocol/ui": {
-          mimeTypes: [RESOURCE_MIME_TYPE],
-        },
-      },
+      // openUi: false tells the server there is no UI, so MCP App tools return results instead of deferring to a form.
+      ...(definition.openUi === false
+        ? {}
+        : { extensions: { "io.modelcontextprotocol/ui": { mimeTypes: [RESOURCE_MIME_TYPE] } } }),
       ...(this.samplingConfig ? { sampling: {} } : {}),
       ...(this.elicitationConfig
         ? {
@@ -1469,7 +1468,7 @@ export class McpServerManager {
   }
 
   private createClient(serverName: string, definition: ServerDefinition): Client {
-    const capabilities = this.buildClientCapabilities();
+    const capabilities = this.buildClientCapabilities(definition);
     const versionNegotiation = resolveVersionNegotiation(definition);
     let client: Client;
     client = new AdapterClient(

package/tool-metadata.ts

@@ -154,6 +154,25 @@ export function findToolByName(metadata: ToolMetadata[] | undefined, toolName: s
   return metadata.find(m => m.name.replace(/-/g, "_") === normalized);
 }
 
+/** Keep only plain structural schemas compact; preserve everything else as original JSON. */
+export function isPlainTypeSchema(schema: unknown): boolean {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) return false;
+  const s = schema as Record<string, unknown>;
+  if (Object.keys(s).some(key => !["type", "properties", "required", "items"].includes(key))) return false;
+  if (s.type === "integer" || Array.isArray(s.type)) return false;
+
+  const properties = s.properties;
+  if (properties !== undefined) {
+    if (s.type !== "object" || !properties || typeof properties !== "object" || Array.isArray(properties)) return false;
+    if (!Object.values(properties).every(isPlainTypeSchema)) return false;
+  }
+  if (s.required !== undefined) {
+    if (!Array.isArray(s.required) || s.required.some(name => typeof name !== "string" || !Object.hasOwn(properties ?? {}, name))) return false;
+  }
+  if (s.items !== undefined && (s.type !== "array" || !isPlainTypeSchema(s.items))) return false;
+  return true;
+}
+
 /** Whether the schema formatter has field descriptions worth showing beside a compact shape. */
 export function hasSchemaDescriptions(schema: unknown, includeRoot = false): boolean {
   if (!schema || typeof schema !== "object" || Array.isArray(schema)) return false;

package/types.ts

@@ -493,7 +493,7 @@ export interface ServerEntry {
   searchKeywords?: Record<string, string[]>;
   // Require interactive approval before calling matching MCP tools/resources.
   approveTools?: boolean | "destructive" | string[];
-  /** Set to false to never open MCP App UIs for this server's tools; results stay inline. */
+  /** Set to false to tell this server the host has no MCP App UI; its tools run and return results inline. */
   openUi?: boolean;
   // Debug
   debug?: boolean;  // Show server stderr (default: false)
@@ -785,8 +785,17 @@ export interface ServerProvenance {
   path: string;
   kind: "user" | "project" | "import";
   importKind?: string;
-  /** Settings from Pi's `mcp.json` that the adapter could not translate for this server. */
+  /** Settings from Pi's `mcp.json` that the adapter could not translate, or that OpenCode ignores in an imported server. */
   ignoredSettings?: string[];
+  /** Set when `ignoredSettings` came from an imported OpenCode server rather than Pi's `mcp.json`. */
+  ignoredSettingsSource?: "opencode";
+}
+
+/** The line `/mcp-adapter` and `doctor` show for a server's ignored settings. */
+export function describeIgnoredSettings(provenance: ServerProvenance | undefined): string | undefined {
+  if (!provenance?.ignoredSettings) return undefined;
+  const file = provenance.ignoredSettingsSource === "opencode" ? "OpenCode" : "Pi mcp.json";
+  return `Ignored ${file} settings: ${provenance.ignoredSettings.join(", ")}`;
 }
 
 export interface McpAuthResult {

package/utils.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { spawnSync } from "node:child_process";
+import { spawnSync, type SpawnSyncOptionsWithStringEncoding } from "node:child_process";
 import { existsSync, realpathSync } from "node:fs";
 import { homedir, platform } from "node:os";
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
@@ -180,6 +180,41 @@ export function interpolateEnvRecord(values: Record<string, string> | undefined,
 const COMMAND_SECRET_TIMEOUT_MS = 10_000;
 const COMMAND_SECRET_MAX_OUTPUT_BYTES = 1024 * 1024;
 
+let windowsCommandBash: string | null | undefined;
+
+function isLegacyWslBash(path: string): boolean {
+  return /^[a-z]:\\windows\\(?:system32|sysnative)\\bash\.exe$/.test(path.replace(/\//g, "\\").toLowerCase());
+}
+
+function findWindowsBash(): string | null {
+  const installs = [process.env.ProgramFiles, process.env["ProgramFiles(x86)"]]
+    .filter((dir): dir is string => Boolean(dir))
+    .map(dir => `${dir}\\Git\\bin\\bash.exe`);
+  const found = installs.find(path => existsSync(path));
+  if (found) return found;
+  try {
+    const result = spawnSync("where", ["bash.exe"], { encoding: "utf8", timeout: 5000, windowsHide: true });
+    if (result.status !== 0 || !result.stdout) return null;
+    return result.stdout.split(/\r?\n/)
+      .map(line => line.trim())
+      .find(path => path && !isLegacyWslBash(path) && existsSync(path)) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * On Windows, the bash used to run `!command` values: Git Bash in its standard
+ * install locations, then bash.exe on PATH (skipping the legacy WSL launcher),
+ * as Pi does. Undefined elsewhere or when none is found, so callers keep the
+ * platform default shell.
+ */
+export function getWindowsCommandBash(): string | undefined {
+  if (process.platform !== "win32") return undefined;
+  if (windowsCommandBash === undefined) windowsCommandBash = findWindowsBash();
+  return windowsCommandBash ?? undefined;
+}
+
 /** Resolve a secret value, executing only a single leading `!` command marker. */
 export function resolveCommandSecret(value: string, context: string): string;
 export function resolveCommandSecret(value: undefined, context: string): undefined;
@@ -189,14 +224,17 @@ export function resolveCommandSecret(value: string | undefined, context: string)
   if (value.startsWith("!!")) return interpolateEnvVars(value.slice(1));
   if (!value.startsWith("!")) return interpolateEnvVars(value);
 
-  const result = spawnSync(value.slice(1), {
-    shell: true,
+  const options: SpawnSyncOptionsWithStringEncoding = {
     encoding: "utf8",
     timeout: COMMAND_SECRET_TIMEOUT_MS,
     maxBuffer: COMMAND_SECRET_MAX_OUTPUT_BYTES,
     stdio: ["ignore", "pipe", "ignore"],
     windowsHide: true,
-  });
+  };
+  const bash = getWindowsCommandBash();
+  const result = bash === undefined
+    ? spawnSync(value.slice(1), { ...options, shell: true })
+    : spawnSync(bash, ["-c", value.slice(1)], { ...options, shell: false });
   if (result.error) {
     const code = (result.error as NodeJS.ErrnoException).code;
     const reason = code === "ETIMEDOUT"