import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js" import type { ClaudeCodeMcpServer } from "@oh-my-opencode/claude-code-compat-core/claude-code-mcp-loader/types" import { McpOAuthProvider } from "../mcp-oauth/provider" import { disconnectAll, disconnectSession, forceReconnect } from "./cleanup" import { getOrCreateClient, getOrCreateClientWithRetryImpl } from "./connection" import { handlePostRequestAuthError, handleStepUpIfNeeded } from "./oauth-handler" import type { McpClient, OAuthProviderFactory, SkillMcpClientInfo, SkillMcpManagerState, SkillMcpServerContext, } from "./types" export interface SkillMcpClientOptions { cdpUrl?: string } export function buildSkillMcpClientKey(info: SkillMcpClientInfo, options?: SkillMcpClientOptions): string { const baseKey = `${info.sessionID}:${info.skillName}:${info.serverName}` if (!options?.cdpUrl) { return baseKey } return `${baseKey}::cdp=${options.cdpUrl}` } function withInjectedCdpEndpoint( config: ClaudeCodeMcpServer, options?: SkillMcpClientOptions ): ClaudeCodeMcpServer { if (!options?.cdpUrl) { return config } const configWithCdpEndpoint = structuredClone(config) configWithCdpEndpoint.args = [...(configWithCdpEndpoint.args ?? []), "--cdp-endpoint", options.cdpUrl] return configWithCdpEndpoint } export class SkillMcpManager { private readonly state: SkillMcpManagerState constructor(options: { createOAuthProvider?: OAuthProviderFactory } = {}) { this.state = { clients: new Map(), pendingConnections: new Map(), disconnectedSessions: new Map(), authProviders: new Map(), cleanupRegistered: false, cleanupInterval: null, cleanupHandlers: [], idleTimeoutMs: 5 * 60 * 1000, shutdownGeneration: 0, inFlightConnections: new Map(), disposed: false, createOAuthProvider: options.createOAuthProvider ?? ((providerOptions) => new McpOAuthProvider(providerOptions)), } } private getClientKey(info: SkillMcpClientInfo, options?: SkillMcpClientOptions): string { return buildSkillMcpClientKey(info, options) } async getOrCreateClient( info: SkillMcpClientInfo, config: ClaudeCodeMcpServer, options?: SkillMcpClientOptions ): Promise { const clientKey = this.getClientKey(info, options) const resolvedConfig = withInjectedCdpEndpoint(config, options) return await getOrCreateClient({ state: this.state, clientKey, info, config: resolvedConfig, }) } async disconnectSession(sessionID: string): Promise { await disconnectSession(this.state, sessionID) } async disconnectAll(): Promise { await disconnectAll(this.state) } async listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext, options?: SkillMcpClientOptions): Promise { const client = await this.getOrCreateClientWithRetry(info, context.config, options) const result = await client.listTools() return result.tools } async listResources(info: SkillMcpClientInfo, context: SkillMcpServerContext, options?: SkillMcpClientOptions): Promise { const client = await this.getOrCreateClientWithRetry(info, context.config, options) const result = await client.listResources() return result.resources } async listPrompts(info: SkillMcpClientInfo, context: SkillMcpServerContext, options?: SkillMcpClientOptions): Promise { const client = await this.getOrCreateClientWithRetry(info, context.config, options) const result = await client.listPrompts() return result.prompts } async callTool( info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record, options?: SkillMcpClientOptions ): Promise { return await this.withOperationRetry(info, context.config, options, async (client) => { const result = await client.callTool({ name, arguments: args }) return result.content }) } async readResource(info: SkillMcpClientInfo, context: SkillMcpServerContext, uri: string, options?: SkillMcpClientOptions): Promise { return await this.withOperationRetry(info, context.config, options, async (client) => { const result = await client.readResource({ uri }) return result.contents }) } async getPrompt( info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record, options?: SkillMcpClientOptions ): Promise { return await this.withOperationRetry(info, context.config, options, async (client) => { const result = await client.getPrompt({ name, arguments: args }) return result.messages }) } private async withOperationRetry( info: SkillMcpClientInfo, config: ClaudeCodeMcpServer, options: SkillMcpClientOptions | undefined, operation: (client: McpClient) => Promise ): Promise { const maxRetries = 3 let lastError: Error | null = null const refreshAttempted = new Set() for (let attempt = 1; attempt <= maxRetries; attempt++) { try { const client = await this.getOrCreateClientWithRetry(info, config, options) return await operation(client) } catch (error) { lastError = error instanceof Error ? error : new Error(String(error)) const errorMessage = lastError.message.toLowerCase() const stepUpHandled = await handleStepUpIfNeeded({ error: lastError, config, authProviders: this.state.authProviders, createOAuthProvider: this.state.createOAuthProvider, }) if (stepUpHandled) { await forceReconnect(this.state, this.getClientKey(info, options)) continue } const postRequestRefreshHandled = await handlePostRequestAuthError({ error: lastError, config, authProviders: this.state.authProviders, createOAuthProvider: this.state.createOAuthProvider, refreshAttempted, }) if (postRequestRefreshHandled) { continue } if (!errorMessage.includes("not connected")) { throw lastError } if (attempt === maxRetries) { throw new Error(`Failed after ${maxRetries} reconnection attempts: ${lastError.message}`) } await forceReconnect(this.state, this.getClientKey(info, options)) } } throw lastError ?? new Error("Operation failed with unknown error") } private async getOrCreateClientWithRetry( info: SkillMcpClientInfo, config: ClaudeCodeMcpServer, options?: SkillMcpClientOptions ): Promise { const clientKey = this.getClientKey(info, options) const resolvedConfig = withInjectedCdpEndpoint(config, options) return await getOrCreateClientWithRetryImpl({ state: this.state, clientKey, info, config: resolvedConfig, }) } getConnectedServers(): string[] { return Array.from(this.state.clients.keys()) } isConnected(info: SkillMcpClientInfo): boolean { return this.state.clients.has(this.getClientKey(info)) } }