@humain/terminal 0.1.1 → 0.2.2

package/dist/humain/mcp-adapter/vendor/init.ts

@@ -2,7 +2,7 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import type { McpExtensionState } from "./state.ts";
 import { formatToolName, isServerDisabled, resolveToolPrefix, type McpAdapterOptions, type PromptMetadata, type ToolMetadata, type ToolSelectorCandidateIndex } from "./types.ts";
 import { existsSync } from "node:fs";
-import { cloneMcpConfig, loadMcpConfig } from "./config.ts";
+import { cloneMcpConfig, loadMcpConfig, resolveConfiguredClaudePluginMcp } from "./config.ts";
 import { ConsentManager } from "./consent-manager.ts";
 import { McpLifecycleManager } from "./lifecycle.ts";
 import {
@@ -38,6 +38,10 @@ import {
 } from "./runtime-owner.ts";
 import { publishMcpStatusSnapshot } from "./mcp-status.ts";
 import { FAILURE_BACKOFF_MS, getFailureAgeSeconds } from "./failure-backoff.ts";
+import {
+  createSessionApprovalWriter,
+  restoreSessionApprovalState,
+} from "./session-approvals.ts";
 export { getFailureAgeSeconds, getFailureMessage, isServerInActiveFailureBackoff } from "./failure-backoff.ts";
 
 const MAX_FAILURE_MESSAGE_CHARS = 8 * 1024;
@@ -117,12 +121,27 @@ export async function initializeMcp(
   const rawUi = hasUI ? ctx.ui : undefined;
   const modelRegistry = ctx.modelRegistry;
   const initialSignal = ctx.signal;
+  let sessionManager: ExtensionContext["sessionManager"] | undefined;
+  try {
+    sessionManager = ctx.sessionManager;
+  } catch {
+    // Synthetic/load-time contexts may not expose a session manager.
+  }
+  let sessionBranch: readonly unknown[] = [];
+  if (sessionManager) {
+    try {
+      sessionBranch = sessionManager.getBranch();
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      logger.debug(`MCP: could not read the active session branch for approval restore: ${detail}`);
+    }
+  }
   const ui = rawUi ? createOwnedUi(rawUi, owner) : undefined;
   const runtimeSignal = combineAbortSignals(owner.signal, initialSignal);
   const config = options.config !== undefined
-    ? cloneMcpConfig(options.config)
+    ? resolveConfiguredClaudePluginMcp(cloneMcpConfig(options.config), cwd)
     : loadMcpConfig(configPath, cwd);
-  const authStorageOptions = getAuthStorageOptions(config.settings?.oauthDir, cwd);
+  const authStorageOptions = getAuthStorageOptions(config.settings?.oauthDir, cwd, config.settings?.oauthCredentialStore);
 
   const ownsOAuthRuntime = options.oauthRuntime === undefined;
   const oauthRuntime = options.oauthRuntime ?? createOAuthRuntime(owner.signal);
@@ -153,6 +172,7 @@ export async function initializeMcp(
   }
   const lifecycle = new McpLifecycleManager(manager, (serverName) => hasPendingAuth(serverName, undefined, oauthRuntime));
   const toolMetadata = new Map<string, ToolMetadata[]>();
+  const directToolCounts = new Map<string, number>();
   const resourceCounts = new Map<string, number>();
   const promptMetadata = new Map<string, PromptMetadata[]>();
   const promptMetadataLive = new Set<string>();
@@ -161,12 +181,23 @@ export async function initializeMcp(
   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");
+  let appendEntry: ((customType: string, data?: unknown) => void) | undefined;
+  try {
+    const candidate = pi.appendEntry;
+    appendEntry = typeof candidate === "function" ? candidate.bind(pi) : undefined;
+  } catch {
+    // Load-time or synthetic APIs may not expose appendEntry yet.
+  }
+  const persistSessionApproval = sessionManager && appendEntry
+    ? createSessionApprovalWriter(appendEntry, () => owner.isActive())
+    : undefined;
+  const consentManager = new ConsentManager("once-per-server", persistSessionApproval);
   const state: McpExtensionState = {
     owner,
     manager,
     lifecycle,
     toolMetadata,
+    directToolCounts,
     resourceCounts,
     promptMetadata,
     promptMetadataLive,
@@ -178,6 +209,8 @@ export async function initializeMcp(
     failureTracker,
     failureMessages,
     approvedToolCalls,
+    ...(persistSessionApproval !== undefined ? { persistSessionApproval } : {}),
+    ...(sessionManager !== undefined ? { sessionManager } : {}),
     approvalEvents: pi.events,
     uiResourceHandler,
     consentManager,
@@ -207,11 +240,12 @@ export async function initializeMcp(
     },
     ...(options.statusEvents !== undefined ? { statusEvents: options.statusEvents } : {}),
   };
+  if (sessionManager) restoreSessionApprovalState(state, sessionBranch);
   if (ownsOAuthRuntime) owner.addCleanup(() => shutdownOAuth(oauthRuntime));
   manager.setMetadataListChangedListener?.((serverName, reason) => {
     if (!owner.isActive()) return;
     updateServerMetadata(state, serverName);
-    updateMetadataCache(state, serverName, { preserveEmptyResources: false });
+    updateMetadataCache(state, serverName);
     notifyToolMetadataUpdated(state, serverName, reason);
     updateStatusBar(state);
   });
@@ -500,7 +534,12 @@ export function markKeepAliveAfterConnect(state: McpExtensionState, serverName:
 
 export function updateServerMetadata(state: McpExtensionState, serverName: string): void {
   const connection = state.manager.getConnection(serverName);
-  if (!connection || connection.status !== "connected") return;
+  if (!connection || connection.status !== "connected") {
+    state.toolMetadata.delete(serverName);
+    state.resourceCounts?.delete(serverName);
+    state.directToolCounts?.delete(serverName);
+    return;
+  }
 
   const definition = state.config.mcpServers[serverName];
   if (!definition) return;
@@ -532,8 +571,8 @@ export function updateServerMetadata(state: McpExtensionState, serverName: strin
 export function updateMetadataCache(
   state: McpExtensionState,
   serverName: string,
-  options: { preserveEmptyResources?: boolean } = {},
 ): void {
+  if (state.provisionalInstalls?.has(serverName)) return;
   const connection = state.manager.getConnection(serverName);
   if (!connection || connection.status !== "connected") return;
 
@@ -552,10 +591,9 @@ export function updateMetadataCache(
 
   if (
     definition.exposeResources !== false &&
-    resources.length === 0 &&
+    connection.resourceDiscoveryFailed === true &&
     existingEntry?.resources?.length &&
-    existingEntry.configHash === configHash &&
-    options.preserveEmptyResources !== false
+    isServerCacheValid(existingEntry, definition)
   ) {
     resources = existingEntry.resources;
   }

package/dist/humain/mcp-adapter/vendor/lazy-loader.ts

@@ -0,0 +1,7 @@
+export function createRetryableLoader<T>(load: () => Promise<T>): () => Promise<T> {
+  let pending: Promise<T> | null = null;
+  return () => pending ??= load().catch((error) => {
+    pending = null;
+    throw error;
+  });
+}

package/dist/humain/mcp-adapter/vendor/mcp-auth-fetch.ts

@@ -0,0 +1,113 @@
+import type { FetchLike } from "@modelcontextprotocol/client"
+import { combineAbortSignals } from "./runtime-owner.ts"
+import { interpolateEnvRecord, resolveCommandSecretsRecord } from "./utils.ts"
+
+/**
+ * Resolve only at a connection/authentication boundary, never during config discovery.
+ * TypeError is fatal to the native SDK's fresh and cached discovery paths; ordinary
+ * errors can be swallowed and allow authentication to continue without credentials.
+ */
+type OAuthHeaderOptions = { commands?: boolean; literal?: boolean }
+
+export function resolveOAuthHeaders(values: Record<string, string> | undefined, options: OAuthHeaderOptions = {}): Headers {
+  const { commands = true, literal = false } = options
+  if (literal) return new Headers(values)
+  const selected = Object.fromEntries(Object.entries(values ?? {}).filter(([, value]) =>
+    commands || !value.startsWith("!") || value.startsWith("!!")))
+  for (const value of Object.values(selected)) {
+    if (value.startsWith("!") && !value.startsWith("!!")) continue
+    for (const match of value.matchAll(/\$\{(\w+)\}|\$env:(\w+)|\{env:(\w+)\}/g)) {
+      const name = (match[1] ?? match[2] ?? match[3])!
+      if (!process.env[name]) throw new TypeError("Missing environment credential in OAuth HTTP headers")
+    }
+  }
+  try {
+    const resolved = commands
+      ? resolveCommandSecretsRecord(selected, () => "OAuth HTTP header")
+      : interpolateEnvRecord(selected)
+    if (Object.values(resolved ?? {}).some(value => !value.trim())) {
+      throw new Error("empty header")
+    }
+    return new Headers(resolved)
+  } catch {
+    // Header constructors and command errors can otherwise include secret values.
+    throw new TypeError("Failed to resolve OAuth HTTP headers")
+  }
+}
+
+const DEFAULT_OAUTH_REQUEST_TIMEOUT_MS = 30_000
+function resolveOAuthRequestTimeoutMs(): number {
+  const parsed = Number(process.env.PI_MCP_OAUTH_REQUEST_TIMEOUT_MS)
+  return Number.isSafeInteger(parsed) && parsed > 0 && parsed <= 2_147_483_647
+    ? parsed : DEFAULT_OAUTH_REQUEST_TIMEOUT_MS
+}
+
+export type OAuthFetch = FetchLike & { throwIfHeaderResolutionFailed(): void }
+
+/**
+ * Configured service headers belong only to the configured MCP origin, not to
+ * discovered issuers. SDK request headers win (notably Authorization and MIME
+ * types). Credential-bearing redirects fail closed, including same-origin ones.
+ */
+export function createOAuthFetch(
+  serverUrl: string,
+  getHeaders: () => Headers = () => new Headers(),
+  signal?: AbortSignal,
+  options: { timeout?: boolean; delegate?: FetchLike } = {},
+): OAuthFetch {
+  const origin = new URL(serverUrl).origin
+  let headerResolutionError: TypeError | undefined
+  const throwIfHeaderResolutionFailed = () => {
+    if (headerResolutionError) throw headerResolutionError
+  }
+  const fetchFn: FetchLike = async (input, init) => {
+    const request = input instanceof Request ? input : undefined
+    const url = new URL(request ? request.url : String(input))
+    const combined = combineAbortSignals(signal, init?.signal ?? request?.signal,
+      options.timeout === false ? undefined : AbortSignal.timeout(resolveOAuthRequestTimeoutMs()))
+    combined?.throwIfAborted()
+    throwIfHeaderResolutionFailed()
+    let serviceHeaders: Headers
+    try {
+      serviceHeaders = url.origin === origin ? getHeaders() : new Headers()
+    } catch {
+      headerResolutionError = new TypeError("Failed to resolve OAuth HTTP headers")
+      throw headerResolutionError
+    }
+    const headers = new Headers(serviceHeaders)
+    new Headers(init?.headers ?? request?.headers).forEach((value, key) => headers.set(key, value))
+    const protectedRequest = [...serviceHeaders].length > 0
+    try {
+      return await (options.delegate ?? globalThis.fetch)(input, {
+        ...init,
+        headers,
+        ...(combined ? { signal: combined } : {}),
+        ...(protectedRequest ? { redirect: "error" as const } : {}),
+      })
+    } catch (error) {
+      combined?.throwIfAborted()
+      // Fetch failures also include DNS, TLS, and connection errors. Do not
+      // misdiagnose them as redirects or expose a potentially secret-bearing cause.
+      if (protectedRequest) throw new TypeError("OAuth HTTP request failed")
+      throw error
+    }
+  }
+  return Object.assign(fetchFn, { throwIfHeaderResolutionFailed })
+}
+
+/** Cache success or failure only in the owning auth leg/connection, never in storage. */
+export function oauthHeaderResolver(values: Record<string, string> | undefined, options: Pick<OAuthHeaderOptions, "literal"> = {}): () => Headers {
+  const snapshot = values ? { ...values } : undefined
+  let result: { headers: Headers } | { error: unknown } | undefined
+  return () => {
+    if (!result) {
+      try {
+        result = { headers: resolveOAuthHeaders(snapshot, options) }
+      } catch (error) {
+        result = { error }
+      }
+    }
+    if ("error" in result) throw result.error
+    return result.headers
+  }
+}