pi-mcp-adapter 2.16.0 → 2.17.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.17.0] - 2026-07-31
+
+### Added
+- Added `settings.mcpFooterStatus` to compact or hide the persistent MCP footer status. Thanks @jwintz for issue #5.
+- Added per-server OAuth `authorizationParams` for provider-specific authorization URL parameters such as Google's `access_type=offline`, while rejecting OAuth flow-owned parameter overrides. Thanks @hank-warren for issue #238.
+
+### Fixed
+- Added a best-effort absolute-path fallback for loading the `@napi-rs/keyring` native binding when compiled Pi/Bun cannot resolve the package loader. Thanks @sgiath for issue #230.
+- Bound collapsed MCP tool result rendering by character count as well as line count, preventing huge single-line results from slowing long TUI sessions. Thanks @Whisperfall for issue #249.
+- Let configured `oauth.scope` override OAuth discovery scopes during authorization flows. Thanks @viggy28 for issue #225 and @adity982 for PR #226.
+
 ## [2.16.0] - 2026-07-30
 
 ### Added

package/README.md

@@ -258,6 +258,7 @@ When any enabled server uses `eager` or `keep-alive`, initialization also starts
     "idleTimeout": 10,
     "requestTimeoutMs": 30000,
     "showStatusIcon": true,
+    "mcpFooterStatus": "full",
     "hostConfigDiscovery": "off",
     "oauthDir": ".pi/mcp-oauth",
     "trace": {
@@ -277,8 +278,10 @@ When any enabled server uses `eager` or `keep-alive`, initialization also starts
 | `idleTimeout` | Global idle timeout in minutes (default: 10, 0 to disable) |
 | `requestTimeoutMs` | Global request timeout in milliseconds for live MCP calls (if omitted or `<= 0`, the MCP SDK default timeout is used) |
 | `showStatusIcon` | Show the plug icon in MCP status and connection text (default: `true`). Set to `false` for plain `MCP: ...` text. |
+| `mcpFooterStatus` | MCP footer verbosity: `"full"` (default), `"compact"` for `MCP connected/enabled`, or `"off"` to clear the persistent footer status. `/mcp status` remains available. |
 | `hostConfigDiscovery` | Host-specific config policy: `"off"` (default), `"prompt"` (detect/report only), or `"on"` (explicitly load detected host configs as the lowest-precedence fallback) |
 | `oauthDir` | Legacy OAuth `tokens.json` import directory for this MCP config. Relative paths resolve from the active project cwd. `MCP_OAUTH_DIR` still wins when set. Persistent OAuth credentials are stored in the OS credential store, not this directory. |
+| `mcpServers.<name>.oauth.authorizationParams` | Extra authorization URL parameters for provider-specific OAuth extensions. Flow-owned parameters such as `client_id`, `redirect_uri`, `scope`, `state`, `code_challenge`, `response_type`, and `resource` cannot be overridden. |
 | `directTools` | Global default for all servers (default: false). Per-server overrides this. |
 | `disableProxyTool` | Hide the `mcp` proxy tool once configured direct tools are fully available from cache. |
 | `autoAuth` | Auto-run OAuth on `connect`/tool calls when a server needs auth, then retry once (default: false). |

package/init.ts

@@ -261,7 +261,8 @@ export async function initializeMcp(
       });
 
   if (ui && startupServers.length > 0) {
-    ui.setStatus("mcp", formatMcpStatus(state.config, `connecting to ${startupServers.length} servers...`));
+    const status = formatMcpStatus(state.config, `connecting to ${startupServers.length} servers...`);
+    ui.setStatus("mcp", status);
   }
 
   const results = await parallelLimit(startupServers, 10, async ([name, definition]) => {
@@ -399,6 +400,9 @@ export async function initializeMcp(
 
   owner.throwIfInactive();
   lifecycle.startHealthChecks(runtimeSignal);
+  if (config.settings?.mcpFooterStatus === "off") {
+    ui?.setStatus("mcp", undefined);
+  }
   publishMcpStatusSnapshot(state);
 
   return state;
@@ -524,10 +528,24 @@ export function updateStatusBar(state: McpExtensionState): void {
     const definition = state.config.mcpServers[name];
     return connection.status === "connected" && definition !== undefined && !isServerDisabled(definition);
   }).length;
-  let status = `${enabledCount} ${enabledCount === 1 ? "server" : "servers"} enabled`;
-  if (connectedCount > 0) status += ` (${connectedCount} connected)`;
-  if (disabledCount > 0) status += ` (${disabledCount} disabled)`;
-  const formattedStatus = formatMcpStatus(state.config, status);
+  const footerStatus = state.config.settings?.mcpFooterStatus ?? "full";
+  if (footerStatus === "off") {
+    ui.setStatus("mcp", undefined);
+    return;
+  }
+
+  let status = footerStatus === "compact"
+    ? `MCP ${connectedCount}/${enabledCount}`
+    : `${enabledCount} ${enabledCount === 1 ? "server" : "servers"} enabled`;
+  if (footerStatus === "full") {
+    if (connectedCount > 0) status += ` (${connectedCount} connected)`;
+    if (disabledCount > 0) status += ` (${disabledCount} disabled)`;
+  }
+  const formattedStatus = footerStatus === "compact" ? status : formatMcpStatus(state.config, status);
+  if (formattedStatus === undefined) {
+    ui.setStatus("mcp", undefined);
+    return;
+  }
   ui.setStatus("mcp", ui.theme ? ui.theme.fg("accent", formattedStatus) : formattedStatus);
 }
 
@@ -565,7 +583,8 @@ export async function lazyConnect(state: McpExtensionState, serverName: string,
 
   try {
     if (state.ui) {
-      state.ui.setStatus("mcp", formatMcpStatus(state.config, `connecting to ${serverName}...`));
+      const status = formatMcpStatus(state.config, `connecting to ${serverName}...`);
+      state.ui.setStatus("mcp", status);
     }
     const newConnection = await state.manager.connect(serverName, definition, ownedSignal);
     if (newConnection.status === "needs-auth") {

package/mcp-auth-flow.ts

@@ -57,6 +57,10 @@ type AuthDiscovery = {
   scope?: string
 }
 
+function applyConfiguredScope(discovery: AuthDiscovery, config: McpOAuthConfig): AuthDiscovery {
+  return config.scope !== undefined ? { ...discovery, scope: config.scope } : discovery
+}
+
 type PendingAuth = {
   serverName: string
   authProvider: McpOAuthProvider
@@ -162,6 +166,18 @@ export function extractOAuthConfig(definition: ServerEntry): McpOAuthConfig {
     if (typeof definition.oauth.scope !== "string") throw new Error("OAuth scope must be a string")
     config.scope = interpolateEnvVars(definition.oauth.scope)
   }
+  if (definition.oauth?.authorizationParams !== undefined) {
+    const params = definition.oauth.authorizationParams
+    if (!params || typeof params !== "object" || Array.isArray(params)) {
+      throw new Error("OAuth authorizationParams must be an object")
+    }
+    config.authorizationParams = {}
+    for (const [key, value] of Object.entries(params)) {
+      if (!key) throw new Error("OAuth authorizationParams keys must not be empty")
+      if (typeof value !== "string") throw new Error(`OAuth authorizationParams.${key} must be a string`)
+      config.authorizationParams[key] = interpolateEnvVars(value)
+    }
+  }
   if (definition.oauth?.redirectUri !== undefined) {
     if (typeof definition.oauth.redirectUri !== "string") {
       throw new Error("OAuth redirectUri must be a string")
@@ -304,7 +320,7 @@ export async function startAuth(
       },
     }, authStorageOptions, runtime.signal)
     try {
-      const discovery = await probeAuthDiscovery(serverUrl, definition, signal)
+      const discovery = applyConfiguredScope(await probeAuthDiscovery(serverUrl, definition, signal), config)
       throwIfAborted(signal)
       const result = await abortable(runSdkAuth(authProvider, { serverUrl, ...discovery }), signal)
       throwIfAborted(signal)
@@ -370,7 +386,7 @@ export async function startAuth(
 
     throwIfAborted(signal)
 
-    const discovery = await probeAuthDiscovery(serverUrl, definition, signal)
+    const discovery = applyConfiguredScope(await probeAuthDiscovery(serverUrl, definition, signal), config)
     throwIfAborted(signal)
     const result = await abortable(runSdkAuth(authProvider, { serverUrl, ...discovery }), signal)
     throwIfAborted(signal)

package/mcp-auth.ts

@@ -13,7 +13,7 @@
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
 import { readFileSync, existsSync, rmSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
 import { getAgentPath } from './agent-dir.ts';
 import { resolveConfiguredOAuthDir } from './config.ts';
 
@@ -113,6 +113,8 @@ interface KeyringEntry {
 }
 
 type KeyringEntryConstructor = new (service: string, account: string) => KeyringEntry;
+type KeyringModule = { Entry: KeyringEntryConstructor };
+type KeyringRequire = ((id: string) => unknown) & { resolve(id: string): string };
 
 interface AuthSecretStore {
   read(account: string): string | undefined;
@@ -185,13 +187,81 @@ function getAuthSecretStore(): AuthSecretStore {
 
 function getKeyringEntry(account: string): KeyringEntry {
   try {
-    KeyringEntryClass ??= (require('@napi-rs/keyring') as { Entry: KeyringEntryConstructor }).Entry;
+    KeyringEntryClass ??= loadKeyringEntryClass();
     return new KeyringEntryClass(AUTH_SECRET_SERVICE, account);
   } catch (error) {
     throw new Error('OAuth secure credential storage is unavailable. Configure the OS credential store and retry authentication.', { cause: error });
   }
 }
 
+function loadKeyringEntryClass(keyringRequire: KeyringRequire = require, platform: NodeJS.Platform = process.platform, arch: NodeJS.Architecture = process.arch): KeyringEntryConstructor {
+  try {
+    return (keyringRequire('@napi-rs/keyring') as KeyringModule).Entry;
+  } catch (loaderError) {
+    try {
+      return loadKeyringNativeBindingFallback(keyringRequire, platform, arch).Entry;
+    } catch (fallbackError) {
+      throw new Error(`Failed to load @napi-rs/keyring; absolute-path native binding fallback also failed: ${formatErrorMessage(fallbackError)}`, {
+        cause: loaderError,
+      });
+    }
+  }
+}
+
+function loadKeyringNativeBindingFallback(keyringRequire: KeyringRequire, platform: NodeJS.Platform, arch: NodeJS.Architecture): KeyringModule {
+  const targets = getKeyringNativeBindingTargets(platform, arch);
+  if (targets.length === 0) {
+    throw new Error(`Unsupported @napi-rs/keyring native binding target: ${platform}-${arch}`);
+  }
+
+  let lastError: unknown;
+  for (const target of targets) {
+    try {
+      const packageJsonPath = keyringRequire.resolve(`${target.packageName}/package.json`);
+      return keyringRequire(join(dirname(packageJsonPath), target.bindingFile)) as KeyringModule;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
+function getKeyringNativeBindingTargets(platform: NodeJS.Platform, arch: NodeJS.Architecture): { packageName: string; bindingFile: string }[] {
+  return getKeyringNativeBindingSuffixes(platform, arch).map(suffix => ({
+    packageName: `@napi-rs/keyring-${suffix}`,
+    bindingFile: `keyring.${suffix}.node`,
+  }));
+}
+
+function getKeyringNativeBindingSuffixes(platform: NodeJS.Platform, arch: NodeJS.Architecture): string[] {
+  if (platform === 'darwin') {
+    if (arch === 'arm64') return ['darwin-arm64'];
+    if (arch === 'x64') return ['darwin-x64'];
+  }
+  if (platform === 'win32') {
+    if (arch === 'arm64') return ['win32-arm64-msvc'];
+    if (arch === 'x64') return ['win32-x64-msvc'];
+    if (arch === 'ia32') return ['win32-ia32-msvc'];
+  }
+  if (platform === 'linux') {
+    if (arch === 'arm64') return ['linux-arm64-gnu', 'linux-arm64-musl'];
+    if (arch === 'arm') return ['linux-arm-gnueabihf'];
+    if (arch === 'riscv64') return ['linux-riscv64-gnu'];
+    if (arch === 'x64') return ['linux-x64-gnu', 'linux-x64-musl'];
+  }
+  if (platform === 'freebsd' && arch === 'x64') return ['freebsd-x64'];
+  return [];
+}
+
+function formatErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function loadTestKeyringEntryClass(keyringRequire: KeyringRequire, platform: NodeJS.Platform, arch: NodeJS.Architecture): KeyringEntryConstructor {
+  return loadKeyringEntryClass(keyringRequire, platform, arch);
+}
+
 export function getAuthStorageOptions(oauthDir: unknown, cwd = process.cwd()): AuthStorageOptions {
   const baseDir = resolveConfiguredOAuthDir(oauthDir, cwd);
   return baseDir ? { baseDir } : {};

package/mcp-oauth-provider.ts

@@ -82,11 +82,35 @@ export interface McpOAuthConfig {
   clientId?: string
   clientSecret?: string
   scope?: string
+  authorizationParams?: Record<string, string>
   redirectUri?: string
   clientName?: string
   clientUri?: string
 }
 
+const reservedAuthorizationParams = new Set([
+  "client_id",
+  "code_challenge",
+  "code_challenge_method",
+  "redirect_uri",
+  "resource",
+  "response_type",
+  "scope",
+  "state",
+])
+
+function addAuthorizationParams(authorizationUrl: URL, params: Record<string, string> | undefined): URL {
+  if (!params) return authorizationUrl
+  const nextUrl = new URL(authorizationUrl.toString())
+  for (const [key, value] of Object.entries(params)) {
+    if (reservedAuthorizationParams.has(key) || nextUrl.searchParams.has(key)) {
+      throw new Error(`OAuth authorizationParams.${key} cannot override an authorization flow parameter`)
+    }
+    nextUrl.searchParams.set(key, value)
+  }
+  return nextUrl
+}
+
 /** Callbacks for OAuth flow interactions */
 export interface McpOAuthCallbacks {
   onRedirect: (url: URL) => void | Promise<void>
@@ -386,7 +410,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
       )
     }
     // URL is passed to callback, not logged (may contain sensitive params)
-    await this.callbacks.onRedirect(authorizationUrl)
+    await this.callbacks.onRedirect(addAuthorizationParams(authorizationUrl, this.config.authorizationParams))
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "types": "./index.ts",

package/tool-result-renderer.ts

@@ -34,6 +34,7 @@ export interface McpToolResultDisplay {
 
 const DEFAULT_MAX_CALL_INPUT_CHARS = 1500;
 const DEFAULT_MAX_COLLAPSED_LINES = 3;
+const DEFAULT_MAX_COLLAPSED_CHARS = 8000;
 const COLLAPSED_RENDER_CHAR_SLACK = 8;
 
 class CollapsibleText implements Component {
@@ -47,6 +48,7 @@ class CollapsibleText implements Component {
     private readonly maxCollapsedLines: number,
     private readonly ellipsis: string,
     private readonly expandHint: string,
+    private readonly preTruncated = false,
   ) {
     this.fullText = new Text(text, 0, 0);
     this.footerText = new Text(`${ellipsis}\n${expandHint}`, 0, 0);
@@ -71,7 +73,7 @@ class CollapsibleText implements Component {
     }
 
     const lines = this.collapsedText.text.render(width);
-    if (this.collapsedText.fullyIncluded && lines.length <= this.maxCollapsedLines) return lines;
+    if (!this.preTruncated && this.collapsedText.fullyIncluded && lines.length <= this.maxCollapsedLines) return lines;
 
     return [
       ...lines.slice(0, this.maxCollapsedLines),
@@ -171,6 +173,58 @@ function blockToLines(block: McpToolContentBlock): string[] {
   return [`[image: ${block.mimeType}]`];
 }
 
+function collectCollapsedResultLines(
+  content: AgentToolResult<McpToolResultDetails>["content"],
+  maxLines: number,
+  maxChars: number,
+): McpToolResultDisplay {
+  if (content.length === 0) return { lines: ["(empty result)"], truncated: false };
+
+  const lines: string[] = [];
+  let remainingChars = maxChars;
+  let truncated = false;
+
+  const appendLine = (line: string) => {
+    if (lines.length >= maxLines || remainingChars <= 0) {
+      truncated = true;
+      return false;
+    }
+
+    if (line.length > remainingChars) {
+      lines.push(line.slice(0, remainingChars));
+      truncated = true;
+      remainingChars = 0;
+      return false;
+    }
+
+    lines.push(line);
+    remainingChars -= line.length + 1;
+    return true;
+  };
+
+  for (const block of content) {
+    if (block.type !== "text") {
+      if (!appendLine(`[image: ${block.mimeType}]`)) break;
+      continue;
+    }
+
+    let start = 0;
+    while (start <= block.text.length) {
+      const newline = block.text.indexOf("\n", start);
+      const line = newline === -1 ? block.text.slice(start) : block.text.slice(start, newline);
+      if (!appendLine(line)) break;
+      if (newline === -1) break;
+      start = newline + 1;
+    }
+
+    if (truncated) break;
+  }
+
+  if (lines.length === 0) lines.push("");
+  if (truncated && lines.length >= maxLines) lines.push("…");
+  return { lines, truncated };
+}
+
 export function formatMcpToolResultIdentity(details: McpToolResultDetails | undefined): string | null {
   if (details?.mode !== "call") return null;
   const server = typeof details.server === "string"
@@ -189,18 +243,15 @@ export function formatMcpToolResultLines(
   result: Pick<AgentToolResult<McpToolResultDetails>, "content">,
   expanded: boolean,
   maxCollapsedLines = 3,
+  maxCollapsedChars = DEFAULT_MAX_COLLAPSED_CHARS,
 ): McpToolResultDisplay {
-  const allLines = result.content.flatMap(blockToLines);
-  const lines = allLines.length > 0 ? allLines : ["(empty result)"];
-
-  if (expanded || lines.length <= maxCollapsedLines) {
-    return { lines, truncated: false };
+  if (!expanded) {
+    return collectCollapsedResultLines(result.content, maxCollapsedLines, maxCollapsedChars);
   }
 
-  return {
-    lines: [...lines.slice(0, maxCollapsedLines), "…"],
-    truncated: true,
-  };
+  const allLines = result.content.flatMap(blockToLines);
+  const lines = allLines.length > 0 ? allLines : ["(empty result)"];
+  return { lines, truncated: false };
 }
 
 export function renderMcpToolResult(
@@ -229,5 +280,6 @@ export function renderMcpToolResult(
     DEFAULT_MAX_COLLAPSED_LINES + (identity ? 1 : 0),
     activeTheme.fg("muted", "…"),
     activeTheme.fg("muted", "(Ctrl+O to expand)"),
+    display.truncated,
   );
 }

package/types.ts

@@ -307,6 +307,8 @@ export interface OAuthConfig {
   clientSecret?: string;
   /** Requested OAuth scopes */
   scope?: string;
+  /** Extra authorization URL parameters for provider-specific extensions. Flow-owned parameters cannot be overridden. */
+  authorizationParams?: Record<string, string>;
   /** Exact authorization-code redirect URI for pre-registered clients */
   redirectUri?: string;
   /** Client display name for dynamic registration */
@@ -380,6 +382,7 @@ export interface McpOutputGuardSettings {
 // Settings
 export type ToolPrefix = "server" | "none" | "short" | "mcp";
 export type HostConfigDiscovery = "off" | "prompt" | "on";
+export type McpFooterStatus = "full" | "compact" | "off";
 
 export interface McpTraceSettings {
   /** Enable tracing for all servers unless a server sets trace to false. */
@@ -396,6 +399,8 @@ export interface McpSettings {
   toolPrefix?: ToolPrefix;
   /** Show the plug prefix in MCP status and connection text (default: true). Set to false to disable it. */
   showStatusIcon?: boolean;
+  /** Footer status verbosity: full details, compact connected/enabled count, or no footer status. Defaults to full. */
+  mcpFooterStatus?: McpFooterStatus;
   /** Discover detected host-specific MCP configs only when explicitly enabled. */
   hostConfigDiscovery?: HostConfigDiscovery;
   idleTimeout?: number; // minutes, default 10, 0 to disable

package/utils.ts

@@ -277,7 +277,8 @@ export function formatAuthRequiredMessage(
   return template ? template.replaceAll("${server}", serverName) : defaultMessage;
 }
 
-export function formatMcpStatus(config: Pick<McpConfig, "settings">, message: string): string {
+export function formatMcpStatus(config: Pick<McpConfig, "settings">, message: string): string | undefined {
+  if (config.settings?.mcpFooterStatus === "off") return undefined;
   return `${config.settings?.showStatusIcon === false ? "MCP: " : "🔌 MCP: "}${message}`;
 }