@phuetz/code-buddy 2.0.0 → 2.2.0

package/dist/mcp/config.js

@@ -3,7 +3,7 @@ import path from 'path';
 import os from 'os';
 import { getSettingsManager } from "../utils/settings-manager.js";
 import { logger } from '../utils/logger.js';
-import { readJsonAtomicSync, writeJsonAtomicSync } from '../utils/atomic-write.js';
+import { readJsonAtomicSync, readJsonAtomicSyncReadOnly, writeJsonAtomicSync } from '../utils/atomic-write.js';
 /**
  * Resolve ${ENV_VAR} references in env values from process.env
  */
@@ -14,7 +14,7 @@ function resolveEnvVars(env) {
     for (const [key, value] of Object.entries(env)) {
         const match = value.match(/^\$\{(\w+)\}$/);
         const varName = match?.[1];
-        resolved[key] = varName !== undefined ? (process.env[varName] || '') : value;
+        resolved[key] = varName !== undefined ? (process.env[varName] || value) : value;
     }
     return resolved;
 }
@@ -30,11 +30,27 @@ function resolveServerEnv(server) {
     }
     return server;
 }
+/** `mcpServers` of a project `.codebuddy/settings.json` read directly (explicit `cwd`). */
+function readProjectSettingsServers(projectDir) {
+    const settingsPath = path.join(projectDir, '.codebuddy', 'settings.json');
+    if (!fs.existsSync(settingsPath))
+        return undefined;
+    try {
+        const settings = readJsonAtomicSync(settingsPath, null, { mode: 0o600 });
+        const servers = settings?.mcpServers;
+        return servers && typeof servers === 'object' && !Array.isArray(servers) ? servers : undefined;
+    }
+    catch (error) {
+        logger.warn('Failed to load project settings MCP servers', { error });
+        return undefined;
+    }
+}
 export function loadMCPConfig(options = {}) {
     const servers = [];
     const seenServers = new Set();
     // 1. First, try project-level .codebuddy/mcp.json (highest priority, committable)
-    const projectMCPPath = path.join(process.cwd(), '.codebuddy', 'mcp.json');
+    const projectDir = options.cwd ?? process.cwd();
+    const projectMCPPath = path.join(projectDir, '.codebuddy', 'mcp.json');
     if (fs.existsSync(projectMCPPath)) {
         try {
             const projectMCP = readJsonAtomicSync(projectMCPPath, {});
@@ -56,11 +72,13 @@ export function loadMCPConfig(options = {}) {
             logger.warn('Failed to load project MCP config', { error });
         }
     }
-    // 2. Then, try project settings (.codebuddy/settings.json)
-    const manager = getSettingsManager();
-    const projectSettings = manager.loadProjectSettings();
-    if (projectSettings.mcpServers) {
-        for (const [name, config] of Object.entries(projectSettings.mcpServers)) {
+    // 2. Then, try project settings (.codebuddy/settings.json). Without an explicit `cwd`
+    // the settings manager keeps its historical path; with one, that project's file is read.
+    const projectSettingsServers = options.cwd === undefined
+        ? getSettingsManager().loadProjectSettings().mcpServers
+        : readProjectSettingsServers(projectDir);
+    if (projectSettingsServers) {
+        for (const [name, config] of Object.entries(projectSettingsServers)) {
             if (!seenServers.has(name)) {
                 const serverConfig = resolveServerEnv({ ...config, name });
                 if (serverConfig.enabled !== false || options.includeDisabled) {
@@ -92,6 +110,101 @@ export function loadMCPConfig(options = {}) {
     }
     return { servers };
 }
+function isServerMap(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readOnlyServersFromFile(filePath, label, warnings, keys) {
+    const outcome = readJsonAtomicSyncReadOnly(filePath, isServerMap);
+    if (outcome.status === 'missing')
+        return undefined;
+    if (outcome.status === 'unreadable') {
+        warnings.push(`${label} is unreadable`);
+        return undefined;
+    }
+    if (outcome.status === 'corrupt') {
+        warnings.push(`${label} is corrupt or not a JSON object`);
+        return undefined;
+    }
+    const parsed = outcome.value;
+    if (keys === 'mcpServers-only') {
+        // The runtime never reads a `servers` key here: report it instead of counting it.
+        if (parsed.servers !== undefined) {
+            warnings.push(`${label} has a "servers" key, which is not read at runtime; use mcpServers`);
+        }
+        if (parsed.mcpServers === undefined)
+            return undefined;
+        if (!isServerMap(parsed.mcpServers)) {
+            warnings.push(`${label} has an invalid mcpServers value (expected an object)`);
+            return undefined;
+        }
+        return parsed.mcpServers;
+    }
+    // Same selection as the runtime (`mcpServers || servers`).
+    const servers = parsed.mcpServers || parsed.servers;
+    if (!servers)
+        return undefined;
+    if (!isServerMap(servers)) {
+        warnings.push(`${label} has an invalid mcpServers/servers value (expected an object)`);
+        return undefined;
+    }
+    return servers;
+}
+/**
+ * Strictly read-only MCP configuration loader for diagnostics. Reads the same
+ * three sources with the same precedence, disabled masking, and env resolution
+ * as `loadMCPConfig`, but never restores/renames/chmods/creates config or
+ * backups/temporaries. Corrupt or unreadable sources yield sanitized warnings
+ * instead of being silently treated as "no server configured". Missing config
+ * is normal and produces no warning.
+ */
+export function loadMCPConfigReadOnly(options = {}) {
+    const servers = [];
+    const seenServers = new Set();
+    const warnings = [];
+    const projectDir = options.cwd ?? process.cwd();
+    const projectMCPPath = path.join(projectDir, '.codebuddy', 'mcp.json');
+    const projectMCP = readOnlyServersFromFile(projectMCPPath, 'project .codebuddy/mcp.json', warnings, 'mcpServers-or-servers');
+    if (projectMCP) {
+        for (const [name, config] of Object.entries(projectMCP)) {
+            if (seenServers.has(name))
+                continue;
+            const serverConfig = resolveServerEnv({ ...config, name });
+            if (serverConfig.enabled === false && !options.includeDisabled) {
+                seenServers.add(name);
+                continue;
+            }
+            servers.push(serverConfig);
+            seenServers.add(name);
+        }
+    }
+    const projectSettingsPath = path.join(projectDir, '.codebuddy', 'settings.json');
+    const projectSettings = readOnlyServersFromFile(projectSettingsPath, 'project .codebuddy/settings.json', warnings, 'mcpServers-only');
+    if (projectSettings) {
+        for (const [name, config] of Object.entries(projectSettings)) {
+            if (seenServers.has(name))
+                continue;
+            const serverConfig = resolveServerEnv({ ...config, name });
+            if (serverConfig.enabled !== false || options.includeDisabled) {
+                servers.push(serverConfig);
+            }
+            seenServers.add(name);
+        }
+    }
+    const userMCPPath = path.join(os.homedir(), '.codebuddy', 'mcp.json');
+    const userMCP = readOnlyServersFromFile(userMCPPath, 'user ~/.codebuddy/mcp.json', warnings, 'mcpServers-or-servers');
+    if (userMCP) {
+        for (const [name, config] of Object.entries(userMCP)) {
+            if (seenServers.has(name))
+                continue;
+            const serverConfig = resolveServerEnv({ ...config, name });
+            if (serverConfig.enabled !== false || options.includeDisabled) {
+                servers.push(serverConfig);
+            }
+            seenServers.add(name);
+        }
+    }
+    return { servers, warnings };
+}
 export function saveMCPConfig(config) {
     const manager = getSettingsManager();
     const mcpServers = {};

package/dist/mcp/import-normalize.d.ts

@@ -0,0 +1,12 @@
+import type { MCPServerConfig } from './types.js';
+export type MCPImportSource = 'hermes' | 'openclaw';
+export interface MCPImportResult {
+    servers: MCPServerConfig[];
+    warnings: string[];
+    rejected: string[];
+}
+/** Supported subset: exact names and star globs. Unsupported exclusions must never broaden exposure. */
+export declare function validateMCPToolFilter(filter: MCPServerConfig['toolFilter']): void;
+export declare function mcpToolAllowed(name: string, filter: MCPServerConfig['toolFilter']): boolean;
+/** Pure import: never resolve env, connect, run commands or transfer credentials. */
+export declare function normalizeMCPImports(input: unknown, source: MCPImportSource): MCPImportResult;

package/dist/mcp/import-normalize.js

@@ -0,0 +1,114 @@
+import { SECRET_PATTERNS } from '../security/secret-patterns.js';
+const record = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const sensitiveKey = /KEY|TOKEN|SECRET|PASSWORD|AUTHORIZATION|COOKIE/i;
+const reference = /^\$\{[A-Za-z_][A-Za-z0-9_]*\}$/;
+const hasSecret = (value) => SECRET_PATTERNS.some(p => new RegExp(p.pattern.source, p.pattern.flags.replace('g', '')).test(value));
+/** Supported subset: exact names and star globs. Unsupported exclusions must never broaden exposure. */
+export function validateMCPToolFilter(filter) {
+    if (!filter)
+        return;
+    for (const patterns of [filter.include, filter.exclude]) {
+        if (patterns !== undefined && (!Array.isArray(patterns) || patterns.some(p => typeof p !== 'string' || !/^[A-Za-z0-9_.:*-]+$/.test(p)))) {
+            throw new Error('Unsupported MCP tool filter; only names and * are supported');
+        }
+    }
+}
+export function mcpToolAllowed(name, filter) {
+    validateMCPToolFilter(filter);
+    const matches = (pattern) => new RegExp(`^${pattern.split('*').map(p => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('.*')}$`).test(name);
+    return (!filter?.include || filter.include.some(matches)) && !filter?.exclude?.some(matches);
+}
+/** Pure import: never resolve env, connect, run commands or transfer credentials. */
+export function normalizeMCPImports(input, source) {
+    const result = { servers: [], warnings: [], rejected: [] };
+    if (!record(input)) {
+        result.rejected.push('MCP server map must be an object');
+        return result;
+    }
+    for (const [name, raw] of Object.entries(input)) {
+        if (!/^[A-Za-z0-9][A-Za-z0-9_.-]{0,95}$/.test(name) || !record(raw)) {
+            result.rejected.push('Invalid MCP server entry');
+            continue;
+        }
+        const warn = (message) => result.warnings.push(`${name}: ${message}`);
+        try {
+            const clean = (key, value) => {
+                if (typeof value !== 'string')
+                    throw new Error('Expected string configuration value');
+                if (reference.test(value) || /^Bearer \$\{[A-Za-z_][A-Za-z0-9_]*\}$/i.test(value))
+                    return value;
+                if (sensitiveKey.test(key) || /^(?:--)?[^=]*(?:token|secret|password|authorization|api[_-]?key)[^=]*=/i.test(value) || hasSecret(value)) {
+                    const envName = `MCP_IMPORT_${name}_${key}`.replace(/[^A-Za-z0-9_]/g, '_').toUpperCase();
+                    warn(`secret not copied; configure environment ${envName}`);
+                    return '${' + envName + '}';
+                }
+                return value;
+            };
+            const map = (key) => {
+                if (raw[key] === undefined)
+                    return undefined;
+                if (!record(raw[key]))
+                    throw new Error(`Invalid ${key}`);
+                return Object.fromEntries(Object.entries(raw[key]).map(([k, v]) => [k, clean(`${key}_${k}`, v)]));
+            };
+            const type = raw.transport ?? raw.type;
+            let transport;
+            if (type === 'stdio' || (type === undefined && typeof raw.command === 'string')) {
+                if (typeof raw.command !== 'string' || !raw.command.trim())
+                    throw new Error('stdio requires command');
+                if (raw.args !== undefined && (!Array.isArray(raw.args) || raw.args.some(a => typeof a !== 'string')))
+                    throw new Error('Invalid args');
+                const args = (raw.args ?? []);
+                transport = { type: 'stdio', inheritEnv: false, command: clean('command', raw.command), args: args.map((v, i) => clean(sensitiveKey.test(args[i - 1] ?? '') ? `arg_secret_${i}` : `arg_${i}`, v)), env: map('env') };
+                if (raw.cwd !== undefined)
+                    transport.cwd = clean('cwd', raw.cwd);
+            }
+            else {
+                const mapped = type === undefined ? (source === 'hermes' ? 'streamable_http' : 'sse')
+                    : type === 'http' || type === 'streamable-http' || type === 'streamable_http' ? 'streamable_http'
+                        : type === 'sse' || type === 'sse_sdk' ? 'sse' : undefined;
+                if (!mapped)
+                    throw new Error('Unsupported transport');
+                if (typeof raw.url !== 'string')
+                    throw new Error('Remote transport requires URL');
+                if (!reference.test(raw.url)) {
+                    const url = new URL(raw.url);
+                    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash || url.search)
+                        throw new Error('Remote URL must not contain credentials, query or fragment; use environment reference');
+                }
+                transport = { type: mapped, url: raw.url, headers: map('headers') };
+                if (type === undefined && source === 'hermes')
+                    warn('streamable HTTP selected; implicit SSE fallback is not imported');
+            }
+            const server = { name, transport, enabled: raw.enabled !== false };
+            const filter = raw.toolFilter ?? raw.tool_filter ?? raw.tools;
+            if (filter !== undefined) {
+                if (!record(filter))
+                    throw new Error('Invalid tool filter');
+                const allowedKeys = filter === raw.tools ? ['include', 'exclude', 'resources', 'prompts'] : ['include', 'exclude'];
+                if (Object.keys(filter).some(key => !allowedKeys.includes(key)))
+                    throw new Error('Unsupported tool filter fields');
+                if (filter.resources !== undefined || filter.prompts !== undefined)
+                    warn('resource/prompt utilities are not imported; Buddy imports native tools only');
+                if (filter.include !== undefined || filter.exclude !== undefined) {
+                    server.toolFilter = { ...(filter.include !== undefined ? { include: typeof filter.include === 'string' ? [filter.include] : filter.include } : {}),
+                        ...(filter.exclude !== undefined ? { exclude: typeof filter.exclude === 'string' ? [filter.exclude] : filter.exclude } : {}) };
+                    validateMCPToolFilter(server.toolFilter);
+                    // OpenClaw treats an empty include as unrestricted, unlike Hermes.
+                    if (source === 'openclaw' && server.toolFilter.include?.length === 0)
+                        delete server.toolFilter.include;
+                }
+            }
+            if (raw.auth !== undefined || raw.oauth !== undefined) {
+                server.enabled = false;
+                warn('authentication settings not imported; server disabled until operator configures authentication in Buddy');
+            }
+            result.servers.push(server);
+        }
+        catch {
+            result.rejected.push(`${name}: unsupported or unsafe configuration; no values copied`);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=import-normalize.js.map

package/dist/mcp/mcp-oauth-constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shared MCP OAuth markers.
+ *
+ * Kept in a leaf module so `mcp-oauth.ts` and `mcp-oauth-provider.ts` can share
+ * them without an import cycle.
+ */
+/** Marker stored as tokenUrl: refresh is handled by the SDK, never by MCPOAuthManager.getValidToken(). */
+export declare const SDK_MANAGED_TOKEN_URL = "sdk-managed";

package/dist/mcp/mcp-oauth-constants.js

@@ -0,0 +1,9 @@
+/**
+ * Shared MCP OAuth markers.
+ *
+ * Kept in a leaf module so `mcp-oauth.ts` and `mcp-oauth-provider.ts` can share
+ * them without an import cycle.
+ */
+/** Marker stored as tokenUrl: refresh is handled by the SDK, never by MCPOAuthManager.getValidToken(). */
+export const SDK_MANAGED_TOKEN_URL = 'sdk-managed';
+//# sourceMappingURL=mcp-oauth-constants.js.map

package/dist/mcp/mcp-oauth-provider.d.ts

@@ -0,0 +1,80 @@
+/**
+ * OAuth provider bridge for HTTP MCP transports.
+ *
+ * Adapts the SDK `OAuthClientProvider` contract (RFC 9728 discovery, PKCE,
+ * URL-based client IDs / dynamic registration handled by the SDK itself) onto
+ * the existing encrypted token store of `mcp-oauth.ts`. No parallel OAuth
+ * implementation: PKCE, discovery and token exchange come from the SDK; the
+ * local callback server, browser opening and token persistence come from the
+ * existing manager.
+ */
+import type { OAuthClientProvider } from '@modelcontextprotocol/sdk/client/auth.js';
+import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from '@modelcontextprotocol/sdk/shared/auth.js';
+import { SDK_MANAGED_TOKEN_URL } from './mcp-oauth-constants.js';
+import { type CallbackSession } from './mcp-oauth.js';
+export { SDK_MANAGED_TOKEN_URL };
+export interface MCPTransportOAuthConfig {
+    type: 'oauth';
+    /** Key of the stored token; defaults to the server URL host. */
+    serverId?: string;
+    /** SEP-991 URL-based client id (HTTPS document). Used when the server advertises support. */
+    clientMetadataUrl?: string;
+    /** Pre-registered public client id (token_endpoint_auth_method none). */
+    clientId?: string;
+    scopes?: string[];
+    /** Loopback redirect; default http://localhost:19836/callback (same as mcp-oauth.ts). */
+    redirectUri?: string;
+    /** When false, an authorization requirement fails closed instead of opening a browser. */
+    interactive?: boolean;
+}
+export interface OAuthWaitOptions {
+    signal?: AbortSignal;
+}
+export interface OAuthInteraction {
+    openUrl: (url: string) => Promise<void>;
+    waitForCode: (redirectUri: string, state: string, opts?: OAuthWaitOptions) => Promise<string>;
+    /** Production default: bind the callback port before openUrl. Tests may omit this. */
+    beginWaitForCode?: (redirectUri: string, state: string, opts?: OAuthWaitOptions) => CallbackSession;
+}
+/** Tests inject a fake browser; production keeps the default loopback flow. */
+export declare function setMCPOAuthInteraction(next: OAuthInteraction | null): void;
+interface FinishAuthTransport {
+    finishAuth(authorizationCode: string): Promise<void>;
+}
+export declare class MCPStoredOAuthProvider implements OAuthClientProvider {
+    private readonly serverId;
+    private readonly auth;
+    private verifier?;
+    private stateValue?;
+    private client?;
+    private transport?;
+    /** Single in-flight authorization: concurrent SDK auth() calls share it. */
+    private pending?;
+    private flowAbort?;
+    private callbackSession?;
+    /** Set by abortAuthorization so a late successful callback cannot finishAuth. */
+    private authCancelled;
+    constructor(serverId: string, auth: MCPTransportOAuthConfig);
+    attachTransport(transport: FinishAuthTransport): void;
+    get redirectUrl(): string;
+    get clientMetadataUrl(): string | undefined;
+    get clientMetadata(): OAuthClientMetadata;
+    state(): string;
+    clientInformation(): OAuthClientInformationMixed | undefined;
+    saveClientInformation(info: OAuthClientInformationMixed): void;
+    tokens(): OAuthTokens | undefined;
+    saveTokens(tokens: OAuthTokens): void;
+    abortAuthorization(reason?: Error): void;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    private throwIfAuthCancelled;
+    /**
+     * Open the system browser. A slow opener is raced against abort so
+     * removeServer does not stay stuck in openUrl; a failed opener still
+     * prints the URL so the user can complete the loopback callback by hand.
+     */
+    private openAuthorizationUrl;
+    saveCodeVerifier(codeVerifier: string): void;
+    codeVerifier(): string;
+    invalidateCredentials(scope: 'all' | 'client' | 'tokens' | 'verifier'): void;
+}
+export declare function createOAuthProvider(url: string, auth: MCPTransportOAuthConfig): MCPStoredOAuthProvider;

package/dist/mcp/mcp-oauth-provider.js

@@ -0,0 +1,241 @@
+/**
+ * OAuth provider bridge for HTTP MCP transports.
+ *
+ * Adapts the SDK `OAuthClientProvider` contract (RFC 9728 discovery, PKCE,
+ * URL-based client IDs / dynamic registration handled by the SDK itself) onto
+ * the existing encrypted token store of `mcp-oauth.ts`. No parallel OAuth
+ * implementation: PKCE, discovery and token exchange come from the SDK; the
+ * local callback server, browser opening and token persistence come from the
+ * existing manager.
+ */
+import * as crypto from 'crypto';
+import { logger } from '../utils/logger.js';
+import { SDK_MANAGED_TOKEN_URL } from './mcp-oauth-constants.js';
+import { getMCPOAuthManager, OAuthCallbackCancelledError, openBrowser, startCallbackServer, startCallbackSession, } from './mcp-oauth.js';
+export { SDK_MANAGED_TOKEN_URL };
+const DEFAULT_REDIRECT = 'http://localhost:19836/callback';
+function waitUntilAborted(signal) {
+    if (signal.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        signal.addEventListener('abort', () => resolve(), { once: true });
+    });
+}
+function storedClientFromMixed(info) {
+    const client = { client_id: info.client_id };
+    if (info.client_secret)
+        client.client_secret = info.client_secret;
+    if (info.client_id_issued_at !== undefined)
+        client.client_id_issued_at = info.client_id_issued_at;
+    if (info.client_secret_expires_at !== undefined)
+        client.client_secret_expires_at = info.client_secret_expires_at;
+    if ('redirect_uris' in info && info.redirect_uris)
+        client.redirect_uris = info.redirect_uris.map(String);
+    if ('token_endpoint_auth_method' in info && info.token_endpoint_auth_method) {
+        client.token_endpoint_auth_method = info.token_endpoint_auth_method;
+    }
+    if ('grant_types' in info && info.grant_types)
+        client.grant_types = info.grant_types;
+    if ('response_types' in info && info.response_types)
+        client.response_types = info.response_types;
+    if ('client_name' in info && info.client_name)
+        client.client_name = info.client_name;
+    if ('scope' in info && info.scope)
+        client.scope = info.scope;
+    return client;
+}
+function defaultInteraction() {
+    return {
+        openUrl: (url) => openBrowser(url),
+        waitForCode: async (redirectUri, state, opts) => (await startCallbackServer(redirectUri, state, 120_000, opts?.signal)).code,
+        beginWaitForCode: (redirectUri, state, opts) => startCallbackSession(redirectUri, state, 120_000, opts?.signal),
+    };
+}
+let interaction = defaultInteraction();
+/** Tests inject a fake browser; production keeps the default loopback flow. */
+export function setMCPOAuthInteraction(next) {
+    interaction = next ?? defaultInteraction();
+}
+export class MCPStoredOAuthProvider {
+    serverId;
+    auth;
+    verifier;
+    stateValue;
+    client;
+    transport;
+    /** Single in-flight authorization: concurrent SDK auth() calls share it. */
+    pending;
+    flowAbort;
+    callbackSession;
+    /** Set by abortAuthorization so a late successful callback cannot finishAuth. */
+    authCancelled = false;
+    constructor(serverId, auth) {
+        this.serverId = serverId;
+        this.auth = auth;
+    }
+    attachTransport(transport) {
+        this.transport = transport;
+    }
+    get redirectUrl() {
+        return this.auth.redirectUri ?? DEFAULT_REDIRECT;
+    }
+    get clientMetadataUrl() {
+        return this.auth.clientMetadataUrl;
+    }
+    get clientMetadata() {
+        return {
+            client_name: 'Code Buddy',
+            redirect_uris: [this.redirectUrl],
+            grant_types: ['authorization_code', 'refresh_token'],
+            response_types: ['code'],
+            token_endpoint_auth_method: 'none',
+            ...(this.auth.scopes?.length ? { scope: this.auth.scopes.join(' ') } : {}),
+        };
+    }
+    state() {
+        this.stateValue = crypto.randomBytes(16).toString('hex');
+        return this.stateValue;
+    }
+    clientInformation() {
+        if (this.auth.clientId)
+            return { client_id: this.auth.clientId };
+        if (this.client)
+            return this.client;
+        const stored = getMCPOAuthManager().getStoredClientInformation(this.serverId);
+        return stored ?? undefined;
+    }
+    saveClientInformation(info) {
+        this.client = info;
+        getMCPOAuthManager().storeClientInformation(this.serverId, storedClientFromMixed(info));
+    }
+    tokens() {
+        const stored = getMCPOAuthManager().getStoredToken(this.serverId);
+        if (!stored)
+            return undefined;
+        const { token } = stored;
+        return {
+            access_token: token.accessToken,
+            token_type: 'bearer',
+            ...(token.refreshToken ? { refresh_token: token.refreshToken } : {}),
+            expires_in: Math.max(0, Math.floor((token.expiresAt - Date.now()) / 1000)),
+            ...(token.scopes.length ? { scope: token.scopes.join(' ') } : {}),
+        };
+    }
+    saveTokens(tokens) {
+        const clientId = this.clientInformation()?.client_id ?? '';
+        getMCPOAuthManager().storeToken(this.serverId, {
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            expiresAt: Date.now() + (tokens.expires_in ?? 3600) * 1000,
+            scopes: tokens.scope ? tokens.scope.split(' ') : (this.auth.scopes ?? []),
+        }, { clientId, clientSecret: undefined, authorizationUrl: '', tokenUrl: SDK_MANAGED_TOKEN_URL, scopes: this.auth.scopes ?? [] });
+    }
+    abortAuthorization(reason) {
+        this.authCancelled = true;
+        this.flowAbort?.abort();
+        this.callbackSession?.abort(reason);
+    }
+    redirectToAuthorization(authorizationUrl) {
+        if (this.auth.interactive === false) {
+            return Promise.reject(new Error(`MCP server "${this.serverId}" requires OAuth authorization; run the connection interactively to sign in.`));
+        }
+        if (!this.transport) {
+            return Promise.reject(new Error('OAuth provider is not attached to a transport'));
+        }
+        if (this.pending)
+            return this.pending;
+        this.authCancelled = false;
+        this.flowAbort = new AbortController();
+        const signal = this.flowAbort.signal;
+        const url = authorizationUrl.toString();
+        this.pending = (async () => {
+            const state = this.stateValue ?? this.state();
+            const opts = { signal };
+            let code;
+            if (interaction.beginWaitForCode) {
+                const session = interaction.beginWaitForCode(this.redirectUrl, state, opts);
+                this.callbackSession = session;
+                await session.listening;
+                this.throwIfAuthCancelled(signal);
+                logger.info(`MCP "${this.serverId}": opening browser for OAuth authorization`);
+                await this.openAuthorizationUrl(url, signal);
+                this.throwIfAuthCancelled(signal);
+                code = (await session.result).code;
+            }
+            else {
+                const codePromise = interaction.waitForCode(this.redirectUrl, state, opts);
+                logger.info(`MCP "${this.serverId}": opening browser for OAuth authorization`);
+                await this.openAuthorizationUrl(url, signal);
+                this.throwIfAuthCancelled(signal);
+                code = await codePromise;
+            }
+            this.throwIfAuthCancelled(signal);
+            await this.transport.finishAuth(code);
+        })().finally(() => {
+            this.pending = undefined;
+            this.callbackSession = undefined;
+            this.flowAbort = undefined;
+        });
+        return this.pending;
+    }
+    throwIfAuthCancelled(signal) {
+        if (this.authCancelled || signal.aborted) {
+            throw new OAuthCallbackCancelledError();
+        }
+    }
+    /**
+     * Open the system browser. A slow opener is raced against abort so
+     * removeServer does not stay stuck in openUrl; a failed opener still
+     * prints the URL so the user can complete the loopback callback by hand.
+     */
+    async openAuthorizationUrl(url, signal) {
+        this.throwIfAuthCancelled(signal);
+        const aborted = waitUntilAborted(signal);
+        aborted.catch(() => undefined);
+        const opener = interaction.openUrl(url).then(() => 'opened', () => 'failed');
+        const outcome = await Promise.race([
+            opener.then((kind) => ({ kind })),
+            aborted.then(() => ({ kind: 'aborted' })),
+        ]);
+        if (outcome.kind === 'aborted' || this.authCancelled) {
+            throw new OAuthCallbackCancelledError();
+        }
+        if (outcome.kind === 'failed') {
+            logger.warn(`MCP "${this.serverId}": browser could not be opened; open this URL manually:\n${url}`);
+        }
+    }
+    saveCodeVerifier(codeVerifier) {
+        // A concurrent auth() while the browser flow is pending must not replace the
+        // verifier the pending flow will exchange its code with.
+        if (this.pending)
+            return;
+        this.verifier = codeVerifier;
+    }
+    codeVerifier() {
+        if (!this.verifier)
+            throw new Error('No PKCE code verifier saved');
+        return this.verifier;
+    }
+    invalidateCredentials(scope) {
+        if (scope === 'tokens') {
+            getMCPOAuthManager().clearTokens(this.serverId);
+            return;
+        }
+        if (scope === 'all' || scope === 'client') {
+            getMCPOAuthManager().removeToken(this.serverId);
+            this.client = undefined;
+        }
+        if (scope === 'all' || scope === 'verifier')
+            this.verifier = undefined;
+    }
+}
+export function createOAuthProvider(url, auth) {
+    const serverId = auth.serverId ?? new URL(url).host;
+    // Fail closed before the SDK performs discovery or client registration: without a
+    // stored token, a non-interactive connection can never complete.
+    if (auth.interactive === false && !getMCPOAuthManager().getStoredToken(serverId)) {
+        throw new Error(`MCP server "${serverId}" requires OAuth authorization; run the connection interactively to sign in.`);
+    }
+    return new MCPStoredOAuthProvider(serverId, auth);
+}
+//# sourceMappingURL=mcp-oauth-provider.js.map