pi-mcp-adapter 2.16.0 → 2.18.0

package/init.ts

@@ -147,6 +147,7 @@ export async function initializeMcp(
   const serverInstructions = new Map<string, string>();
   const failureTracker = new Map<string, number>();
   const failureMessages = new Map<string, string>();
+  const approvedToolCalls = new Map<string, true>();
   const uiResourceHandler = new UiResourceHandler(manager, config);
   const consentManager = new ConsentManager("once-per-server");
   const state: McpExtensionState = {
@@ -164,6 +165,7 @@ export async function initializeMcp(
     authStorageOptions,
     failureTracker,
     failureMessages,
+    approvedToolCalls,
     uiResourceHandler,
     consentManager,
     uiServer: null,
@@ -261,7 +263,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 +402,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 +530,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 +585,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

@@ -10,10 +10,12 @@
  * then the plaintext file is removed.
  */
 
+import { spawnSync } from 'child_process';
 import { createHash } from 'crypto';
 import { createRequire } from 'module';
 import { readFileSync, existsSync, rmSync } from 'fs';
-import { join } from 'path';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { getAgentPath } from './agent-dir.ts';
 import { resolveConfiguredOAuthDir } from './config.ts';
 
@@ -21,6 +23,12 @@ const require = createRequire(import.meta.url);
 const AUTH_SECRET_SERVICE = 'pi-mcp-adapter.oauth';
 const TEST_AUTH_STORE_ENV = 'PI_MCP_ADAPTER_TEST_AUTH_STORE';
 const AUTH_SECRET_CHUNK_SIZE = 1800;
+const KEYRING_RECOVERY_DISABLED_ENV = 'PI_MCP_ADAPTER_DISABLE_KEYRING_RECOVERY';
+const KEYRING_RECOVERY_KEYCTL_ENV = 'PI_MCP_ADAPTER_KEYRING_RECOVERY_KEYCTL';
+const KEYRING_RECOVERY_NODE_ENV = 'PI_MCP_ADAPTER_KEYRING_RECOVERY_NODE';
+const KEYRING_RECOVERY_HELPER_ENV = 'PI_MCP_ADAPTER_KEYRING_RECOVERY_HELPER';
+const TEST_LINUX_KEYRING_RECOVERY_ENV = 'PI_MCP_ADAPTER_TEST_LINUX_KEYRING_RECOVERY';
+const KEYRING_RECOVERY_TIMEOUT_MS = 10_000;
 const AUTH_CHUNK_MANIFEST_KEY = '__piMcpAdapterOAuthChunked';
 
 /** OAuth token storage format */
@@ -113,6 +121,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;
@@ -165,6 +175,22 @@ const unavailableAuthSecretStore: AuthSecretStore = {
   },
 };
 
+function createKeyRevokedTestError(): Error {
+  return new Error("Couldn't access platform storage: KeyRevoked", { cause: new Error('KeyRevoked') });
+}
+
+const keyRevokedAuthSecretStore: AuthSecretStore = {
+  read() {
+    throw createKeyRevokedTestError();
+  },
+  write() {
+    throw createKeyRevokedTestError();
+  },
+  remove() {
+    throw createKeyRevokedTestError();
+  },
+};
+
 export function resetTestAuthSecretStore(): void {
   memoryAuthEntries.clear();
 }
@@ -180,18 +206,156 @@ export function removeTestAuthSecretStoreEntry(account: string): void {
 function getAuthSecretStore(): AuthSecretStore {
   if (process.env[TEST_AUTH_STORE_ENV] === 'memory') return memoryAuthSecretStore;
   if (process.env[TEST_AUTH_STORE_ENV] === 'unavailable') return unavailableAuthSecretStore;
+  if (process.env[TEST_AUTH_STORE_ENV] === 'keyrevoked') return keyRevokedAuthSecretStore;
   return keyringAuthSecretStore;
 }
 
 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);
+}
+
+type KeyringRecoveryOperation = 'read' | 'write' | 'remove';
+
+type KeyringRecoveryResponse =
+  | { ok: true; found?: boolean; value?: string }
+  | { ok: false; error?: string };
+
+function isLinuxKeyringRecoveryEnabled(): boolean {
+  if (process.env[KEYRING_RECOVERY_DISABLED_ENV] === '1') return false;
+  return process.platform === 'linux' || process.env[TEST_LINUX_KEYRING_RECOVERY_ENV] === '1';
+}
+
+function shouldAttemptLinuxKeyringRecovery(error: unknown): boolean {
+  return isLinuxKeyringRecoveryEnabled()
+    && causeChainContains(error, /key\s*(?:has been\s*)?revoked|keyrevoked/i);
+}
+
+function runLinuxKeyringRecoveryOperation(operation: KeyringRecoveryOperation, account: string, payload?: string): KeyringRecoveryResponse {
+  const keyctl = process.env[KEYRING_RECOVERY_KEYCTL_ENV]?.trim() || 'keyctl';
+  const node = process.env[KEYRING_RECOVERY_NODE_ENV]?.trim() || 'node';
+  const helper = process.env[KEYRING_RECOVERY_HELPER_ENV]?.trim()
+    || fileURLToPath(new URL('./mcp-keyring-helper.cjs', import.meta.url));
+  const request = JSON.stringify({ operation, service: AUTH_SECRET_SERVICE, account, payload });
+  const result = spawnSync(keyctl, ['session', '-', node, helper], {
+    input: `${request}\n`,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+    timeout: KEYRING_RECOVERY_TIMEOUT_MS,
+    windowsHide: true,
+  });
+
+  if (result.error) {
+    throw new Error(`Linux keyring recovery helper could not start: ${result.error.message}`, { cause: result.error });
+  }
+  if (result.status !== 0) {
+    throw new Error(`Linux keyring recovery helper failed with exit code ${result.status ?? 'unknown'}`);
+  }
+
+  let response: unknown;
+  try {
+    response = JSON.parse(result.stdout.trim()) as unknown;
+  } catch (error) {
+    throw new Error('Linux keyring recovery helper returned invalid JSON', { cause: error });
+  }
+  if (typeof response !== 'object' || response === null || typeof (response as { ok?: unknown }).ok !== 'boolean') {
+    throw new Error('Linux keyring recovery helper returned an invalid response');
+  }
+  const typedResponse = response as KeyringRecoveryResponse;
+  if (typedResponse.ok === false) {
+    throw new Error(typedResponse.error || 'Linux keyring recovery helper failed');
+  }
+  if (operation === 'read' && typedResponse.found === true && typeof typedResponse.value !== 'string') {
+    throw new Error('Linux keyring recovery helper returned an invalid read response');
+  }
+  return typedResponse;
+}
+
+const linuxKeyringRecoveryAuthSecretStore: AuthSecretStore = {
+  read(account) {
+    const response = runLinuxKeyringRecoveryOperation('read', account);
+    return response.ok && response.found === true ? response.value : undefined;
+  },
+  write(account, payload) {
+    runLinuxKeyringRecoveryOperation('write', account, payload);
+  },
+  remove(account) {
+    runLinuxKeyringRecoveryOperation('remove', account);
+  },
+};
+
+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 } : {};
@@ -296,8 +460,7 @@ function createChunkManifest(payload: string): AuthEntryChunkManifest {
   };
 }
 
-function readChunkedAuthEntry(serverName: string, account: string, manifest: AuthEntryChunkManifest): AuthEntry {
-  const store = getAuthSecretStore();
+function readChunkedAuthEntry(store: AuthSecretStore, serverName: string, account: string, manifest: AuthEntryChunkManifest): AuthEntry {
   const chunks = getAuthEntryChunkAccounts(account, manifest).map((chunkAccount) => {
     try {
       const chunk = store.read(chunkAccount);
@@ -340,9 +503,8 @@ function removeLegacyAuthEntry(serverName: string, options?: AuthStorageOptions)
   }
 }
 
-function writeSecureAuthEntry(serverName: string, entry: AuthEntry): void {
+function writeSecureAuthEntryToStore(store: AuthSecretStore, serverName: string, entry: AuthEntry): void {
   const account = getAuthEntryAccount(serverName);
-  const store = getAuthSecretStore();
   const payload = JSON.stringify(entry);
   const previousManifest = readExistingChunkManifest(store, serverName, account);
   const manifest = payload.length > AUTH_SECRET_CHUNK_SIZE ? createChunkManifest(payload) : undefined;
@@ -371,11 +533,21 @@ function writeSecureAuthEntry(serverName: string, entry: AuthEntry): void {
   }
 }
 
+function writeSecureAuthEntry(serverName: string, entry: AuthEntry): void {
+  try {
+    writeSecureAuthEntryToStore(getAuthSecretStore(), serverName, entry);
+  } catch (error) {
+    if (!shouldAttemptLinuxKeyringRecovery(error)) throw error;
+    writeSecureAuthEntryToStore(linuxKeyringRecoveryAuthSecretStore, serverName, entry);
+  }
+}
+
 /**
  * Read the auth entry for a server from the OS secure store, importing and
  * deleting a legacy plaintext entry when present.
  */
-function readAuthEntry(
+function readAuthEntryFromStore(
+  store: AuthSecretStore,
   serverName: string,
   options?: AuthStorageOptions,
   behavior: { migrateLegacy?: boolean } = {},
@@ -383,7 +555,7 @@ function readAuthEntry(
   const account = getAuthEntryAccount(serverName);
   let payload: string | undefined;
   try {
-    payload = getAuthSecretStore().read(account);
+    payload = store.read(account);
   } catch (error) {
     throw new OAuthCredentialStoreError(
       `Failed to read OAuth credentials for ${serverName} from the OS secure credential store`,
@@ -395,7 +567,7 @@ function readAuthEntry(
   if (payload !== undefined) {
     const manifest = readChunkManifestFromPayload(serverName, payload, 'OS secure credential store');
     const entry = manifest
-      ? readChunkedAuthEntry(serverName, account, manifest)
+      ? readChunkedAuthEntry(store, serverName, account, manifest)
       : parseAuthEntryPayload(serverName, payload, 'OS secure credential store');
     removeLegacyAuthEntry(serverName, options);
     return entry;
@@ -404,11 +576,24 @@ function readAuthEntry(
   const legacyEntry = readLegacyAuthEntry(serverName, options);
   if (!legacyEntry) return undefined;
   if (behavior.migrateLegacy === false) return legacyEntry;
-  writeSecureAuthEntry(serverName, legacyEntry);
+  writeSecureAuthEntryToStore(store, serverName, legacyEntry);
   removeLegacyAuthEntry(serverName, options);
   return legacyEntry;
 }
 
+function readAuthEntry(
+  serverName: string,
+  options?: AuthStorageOptions,
+  behavior: { migrateLegacy?: boolean } = {},
+): AuthEntry | undefined {
+  try {
+    return readAuthEntryFromStore(getAuthSecretStore(), serverName, options, behavior);
+  } catch (error) {
+    if (!shouldAttemptLinuxKeyringRecovery(error)) throw error;
+    return readAuthEntryFromStore(linuxKeyringRecoveryAuthSecretStore, serverName, options, behavior);
+  }
+}
+
 /**
  * Get auth entry for a server.
  */
@@ -468,9 +653,8 @@ export function saveAuthEntry(serverName: string, entry: AuthEntry, serverUrl?:
 /**
  * Remove auth entry for a server.
  */
-export function removeAuthEntry(serverName: string, options?: AuthStorageOptions): void {
+function removeAuthEntryFromStore(store: AuthSecretStore, serverName: string): void {
   const account = getAuthEntryAccount(serverName);
-  const store = getAuthSecretStore();
   try {
     const payload = store.read(account);
     const manifest = payload === undefined ? undefined : readChunkManifestFromPayload(serverName, payload, 'OS secure credential store');
@@ -483,6 +667,15 @@ export function removeAuthEntry(serverName: string, options?: AuthStorageOptions
       error,
     );
   }
+}
+
+export function removeAuthEntry(serverName: string, options?: AuthStorageOptions): void {
+  try {
+    removeAuthEntryFromStore(getAuthSecretStore(), serverName);
+  } catch (error) {
+    if (!shouldAttemptLinuxKeyringRecovery(error)) throw error;
+    removeAuthEntryFromStore(linuxKeyringRecoveryAuthSecretStore, serverName);
+  }
   removeLegacyAuthEntry(serverName, options);
 }