@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/features/skill-mcp-manager/http-client.ts

@@ -1,126 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js"
-import { registerProcessCleanup, startCleanupTimer } from "./cleanup"
-import { buildHttpRequestInit } from "./oauth-handler"
-import type { ManagedClient, McpClient, McpTransport, SkillMcpClientConnectionParams } from "./types"
-
-type HttpClientFactory = (
-  clientInfo: { name: string; version: string },
-  options: { capabilities: Record<string, never> }
-) => McpClient
-
-type HttpTransportFactory = (
-  url: URL,
-  options?: { requestInit?: RequestInit }
-) => McpTransport
-
-interface HttpClientDependencies {
-  createClient: HttpClientFactory
-  createTransport: HttpTransportFactory
-}
-
-const defaultHttpClientDependencies: HttpClientDependencies = {
-  createClient: (clientInfo, options) => new Client(clientInfo, options),
-  createTransport: (url, options) => new StreamableHTTPClientTransport(url, options),
-}
-
-let httpClientDependencies: HttpClientDependencies = defaultHttpClientDependencies
-
-export function setHttpClientDependenciesForTesting(
-  dependencies?: Partial<HttpClientDependencies>
-): void {
-  httpClientDependencies = dependencies
-    ? {
-        ...defaultHttpClientDependencies,
-        ...dependencies,
-      }
-    : defaultHttpClientDependencies
-}
-
-function redactUrl(urlStr: string): string {
-  try {
-    const u = new URL(urlStr)
-    for (const key of u.searchParams.keys()) {
-      if (
-        key.toLowerCase().includes("key") ||
-        key.toLowerCase().includes("token") ||
-        key.toLowerCase().includes("secret")
-      ) {
-        u.searchParams.set(key, "***REDACTED***")
-      }
-    }
-    return u.toString()
-  } catch {
-    return urlStr
-  }
-}
-
-export async function createHttpClient(params: SkillMcpClientConnectionParams): Promise<McpClient> {
-  const { state, clientKey, info, config } = params
-  const shutdownGenAtStart = state.shutdownGeneration
-
-  if (!config.url) {
-    throw new Error(`MCP server "${info.serverName}" is configured for HTTP but missing 'url' field.`)
-  }
-
-  let url: URL
-  try {
-    url = new URL(config.url)
-  } catch {
-    throw new Error(
-      `MCP server "${info.serverName}" has invalid URL: ${redactUrl(config.url)}\n\n` +
-      `Expected a valid URL like: https://mcp.example.com/mcp`
-    )
-  }
-
-  registerProcessCleanup(state)
-
-  const requestInit = await buildHttpRequestInit(config, state.authProviders, state.createOAuthProvider)
-  const transport: McpTransport = httpClientDependencies.createTransport(url, {
-    requestInit,
-  })
-
-  const client: McpClient = httpClientDependencies.createClient(
-    { name: `skill-mcp-${info.skillName}-${info.serverName}`, version: "1.0.0" },
-    { capabilities: {} }
-  )
-
-  try {
-    await client.connect(transport)
-  } catch (error) {
-    try {
-      await transport.close()
-    } catch {
-      // Transport may already be closed
-    }
-
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    throw new Error(
-      `Failed to connect to MCP server "${info.serverName}".\n\n` +
-      `URL: ${redactUrl(config.url)}\n` +
-      `Reason: ${errorMessage}\n\n` +
-      `Hints:\n` +
-      `  - Verify the URL is correct and the server is running\n` +
-      `  - Check if authentication headers are required\n` +
-      `  - Ensure the server supports MCP over HTTP`
-    )
-  }
-
-  if (state.shutdownGeneration !== shutdownGenAtStart) {
-    try { await client.close() } catch {}
-    try { await transport.close() } catch {}
-    throw new Error(`MCP server "${info.serverName}" connection completed after shutdown`)
-  }
-
-  const managedClient = {
-    client,
-    transport,
-    skillName: info.skillName,
-    lastUsedAt: Date.now(),
-    connectionType: "http",
-  } satisfies ManagedClient
-
-  state.clients.set(clientKey, managedClient)
-  startCleanupTimer(state)
-  return client
-}

package/src/features/skill-mcp-manager/index.ts

@@ -1,2 +0,0 @@
-export * from "./types"
-export { SkillMcpManager } from "./manager"

package/src/features/skill-mcp-manager/manager.ts

@@ -1,178 +0,0 @@
-import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js"
-import type { ClaudeCodeMcpServer } from "../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 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): string {
-    return `${info.sessionID}:${info.skillName}:${info.serverName}`
-  }
-
-  async getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<McpClient> {
-    const clientKey = this.getClientKey(info)
-    return await getOrCreateClient({
-      state: this.state,
-      clientKey,
-      info,
-      config,
-    })
-  }
-
-  async disconnectSession(sessionID: string): Promise<void> {
-    await disconnectSession(this.state, sessionID)
-  }
-
-  async disconnectAll(): Promise<void> {
-    await disconnectAll(this.state)
-  }
-
-  async listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]> {
-    const client = await this.getOrCreateClientWithRetry(info, context.config)
-    const result = await client.listTools()
-    return result.tools
-  }
-
-  async listResources(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Resource[]> {
-    const client = await this.getOrCreateClientWithRetry(info, context.config)
-    const result = await client.listResources()
-    return result.resources
-  }
-
-  async listPrompts(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Prompt[]> {
-    const client = await this.getOrCreateClientWithRetry(info, context.config)
-    const result = await client.listPrompts()
-    return result.prompts
-  }
-
-  async callTool(
-    info: SkillMcpClientInfo,
-    context: SkillMcpServerContext,
-    name: string,
-    args: Record<string, unknown>
-  ): Promise<unknown> {
-    return await this.withOperationRetry(info, context.config, async (client) => {
-      const result = await client.callTool({ name, arguments: args })
-      return result.content
-    })
-  }
-
-  async readResource(info: SkillMcpClientInfo, context: SkillMcpServerContext, uri: string): Promise<unknown> {
-    return await this.withOperationRetry(info, context.config, async (client) => {
-      const result = await client.readResource({ uri })
-      return result.contents
-    })
-  }
-
-  async getPrompt(
-    info: SkillMcpClientInfo,
-    context: SkillMcpServerContext,
-    name: string,
-    args: Record<string, string>
-  ): Promise<unknown> {
-    return await this.withOperationRetry(info, context.config, async (client) => {
-      const result = await client.getPrompt({ name, arguments: args })
-      return result.messages
-    })
-  }
-
-  private async withOperationRetry<T>(
-    info: SkillMcpClientInfo,
-    config: ClaudeCodeMcpServer,
-    operation: (client: McpClient) => Promise<T>
-  ): Promise<T> {
-    const maxRetries = 3
-    let lastError: Error | null = null
-    const refreshAttempted = new Set<string>()
-
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        const client = await this.getOrCreateClientWithRetry(info, config)
-        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))
-          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))
-      }
-    }
-
-    throw lastError ?? new Error("Operation failed with unknown error")
-  }
-
-  // NOTE: tests spy on this exact method name via `spyOn(manager as any, 'getOrCreateClientWithRetry')`.
-  private async getOrCreateClientWithRetry(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<McpClient> {
-    const clientKey = this.getClientKey(info)
-    return await getOrCreateClientWithRetryImpl({
-      state: this.state,
-      clientKey,
-      info,
-      config,
-    })
-  }
-
-  getConnectedServers(): string[] {
-    return Array.from(this.state.clients.keys())
-  }
-
-  isConnected(info: SkillMcpClientInfo): boolean {
-    return this.state.clients.has(this.getClientKey(info))
-  }
-}

package/src/features/skill-mcp-manager/oauth-handler.ts

@@ -1,160 +0,0 @@
-import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types"
-import { McpOAuthProvider } from "../mcp-oauth/provider"
-import { withRefreshMutex } from "../mcp-oauth/refresh-mutex"
-import type { OAuthTokenData } from "../mcp-oauth/storage"
-import { isStepUpRequired, mergeScopes } from "../mcp-oauth/step-up"
-import type { OAuthProviderFactory, OAuthProviderLike } from "./types"
-
-export function getOrCreateAuthProvider(
-  authProviders: Map<string, OAuthProviderLike>,
-  serverUrl: string,
-  oauth: NonNullable<ClaudeCodeMcpServer["oauth"]>,
-  createOAuthProvider: OAuthProviderFactory = (options) => new McpOAuthProvider(options),
-): OAuthProviderLike {
-  const existing = authProviders.get(serverUrl)
-  if (existing) return existing
-
-  const provider = createOAuthProvider({
-    serverUrl,
-    clientId: oauth.clientId,
-    scopes: oauth.scopes,
-  })
-  authProviders.set(serverUrl, provider)
-  return provider
-}
-
-function isTokenExpired(tokenData: OAuthTokenData): boolean {
-  if (tokenData.expiresAt == null) return false
-  return tokenData.expiresAt < Math.floor(Date.now() / 1000)
-}
-
-export async function buildHttpRequestInit(
-  config: ClaudeCodeMcpServer,
-  authProviders: Map<string, OAuthProviderLike>,
-  createOAuthProvider?: OAuthProviderFactory,
-): Promise<RequestInit | undefined> {
-  const headers: Record<string, string> = {}
-
-  if (config.headers) {
-    for (const [key, value] of Object.entries(config.headers)) {
-      headers[key] = value
-    }
-  }
-
-  if (config.oauth && config.url) {
-    const provider = getOrCreateAuthProvider(authProviders, config.url, config.oauth, createOAuthProvider)
-    let tokenData = provider.tokens()
-
-    if (!tokenData) {
-      try {
-        tokenData = await provider.login()
-      } catch {
-        tokenData = null
-      }
-    }
-
-      if (tokenData && isTokenExpired(tokenData)) {
-        try {
-          const refreshToken = tokenData.refreshToken
-          tokenData = refreshToken
-            ? await withRefreshMutex(config.url, () => provider.refresh(refreshToken))
-            : await provider.login()
-        } catch {
-          try {
-            tokenData = await provider.login()
-        } catch {
-          tokenData = null
-        }
-      }
-    }
-
-    if (tokenData) {
-      headers.Authorization = `Bearer ${tokenData.accessToken}`
-    }
-  }
-
-  return Object.keys(headers).length > 0 ? { headers } : undefined
-}
-
-export async function handleStepUpIfNeeded(params: {
-  error: Error
-  config: ClaudeCodeMcpServer
-  authProviders: Map<string, OAuthProviderLike>
-  createOAuthProvider?: OAuthProviderFactory
-}): Promise<boolean> {
-  const { error, config, authProviders, createOAuthProvider } = params
-
-  if (!config.oauth || !config.url) {
-    return false
-  }
-
-  const statusMatch = /\b403\b/.exec(error.message)
-  if (!statusMatch) {
-    return false
-  }
-
-  const headers: Record<string, string> = {}
-  const wwwAuthMatch = /WWW-Authenticate:\s*(.+)/i.exec(error.message)
-  if (wwwAuthMatch?.[1]) {
-    headers["www-authenticate"] = wwwAuthMatch[1]
-  }
-
-  const stepUp = isStepUpRequired(403, headers)
-  if (!stepUp) {
-    return false
-  }
-
-  const currentScopes = config.oauth.scopes ?? []
-  const mergedScopes = mergeScopes(currentScopes, stepUp.requiredScopes)
-  config.oauth.scopes = mergedScopes
-
-  authProviders.delete(config.url)
-  const provider = getOrCreateAuthProvider(authProviders, config.url, config.oauth, createOAuthProvider)
-
-  try {
-    await provider.login()
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function handlePostRequestAuthError(params: {
-  error: Error
-  config: ClaudeCodeMcpServer
-  authProviders: Map<string, OAuthProviderLike>
-  createOAuthProvider?: OAuthProviderFactory
-  refreshAttempted?: Set<string>
-}): Promise<boolean> {
-  const { error, config, authProviders, createOAuthProvider, refreshAttempted = new Set() } = params
-
-  if (!config.oauth || !config.url) {
-    return false
-  }
-
-  const statusMatch = /\b(401|403)\b/.exec(error.message)
-  if (!statusMatch) {
-    return false
-  }
-
-  const provider = getOrCreateAuthProvider(authProviders, config.url, config.oauth, createOAuthProvider)
-  const tokenData = provider.tokens()
-
-  if (!tokenData?.refreshToken) {
-    return false
-  }
-
-  if (refreshAttempted.has(config.url)) {
-    return false
-  }
-
-  refreshAttempted.add(config.url)
-
-  try {
-    const refreshToken = tokenData.refreshToken
-    await withRefreshMutex(config.url, () => provider.refresh(refreshToken))
-    return true
-  } catch {
-    return false
-  }
-}

package/src/features/skill-mcp-manager/stdio-client.ts

@@ -1,112 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
-import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types"
-import { createCleanMcpEnvironment } from "./env-cleaner"
-import { registerProcessCleanup, startCleanupTimer } from "./cleanup"
-import { redactSensitiveData } from "./error-redaction"
-import type { ManagedClient, McpClient, McpTransport, SkillMcpClientConnectionParams } from "./types"
-
-type StdioClientFactory = (
-  clientInfo: { name: string; version: string },
-  options: { capabilities: Record<string, never> }
-) => McpClient
-
-type StdioTransportFactory = (
-  options: ConstructorParameters<typeof StdioClientTransport>[0]
-) => McpTransport
-
-interface StdioClientDependencies {
-  createClient: StdioClientFactory
-  createTransport: StdioTransportFactory
-}
-
-const defaultStdioClientDependencies: StdioClientDependencies = {
-  createClient: (clientInfo, options) => new Client(clientInfo, options),
-  createTransport: (options) => new StdioClientTransport(options),
-}
-
-let stdioClientDependencies: StdioClientDependencies = defaultStdioClientDependencies
-
-export function setStdioClientDependenciesForTesting(
-  dependencies?: Partial<StdioClientDependencies>
-): void {
-  stdioClientDependencies = dependencies
-    ? {
-        ...defaultStdioClientDependencies,
-        ...dependencies,
-      }
-    : defaultStdioClientDependencies
-}
-
-function getStdioCommand(config: ClaudeCodeMcpServer, serverName: string): string {
-  if (!config.command) {
-    throw new Error(`MCP server "${serverName}" is configured for stdio but missing 'command' field.`)
-  }
-  return config.command
-}
-
-export async function createStdioClient(params: SkillMcpClientConnectionParams): Promise<McpClient> {
-  const { state, clientKey, info, config } = params
-  const shutdownGenAtStart = state.shutdownGeneration
-
-  const command = getStdioCommand(config, info.serverName)
-  const args = config.args ?? []
-  const mergedEnv = createCleanMcpEnvironment(config.env)
-
-  registerProcessCleanup(state)
-
-  const transport: McpTransport = stdioClientDependencies.createTransport({
-    command,
-    args,
-    env: mergedEnv,
-    stderr: "ignore",
-  })
-
-  const client: McpClient = stdioClientDependencies.createClient(
-    { name: `skill-mcp-${info.skillName}-${info.serverName}`, version: "1.0.0" },
-    { capabilities: {} }
-  )
-
-  try {
-    await client.connect(transport)
-  } catch (error) {
-    // Close transport to prevent orphaned MCP process on connection failure
-    try {
-      await transport.close()
-    } catch {
-      // Process may already be terminated
-    }
-
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    const fullCommand = `${command} ${args.join(" ")}`
-    const safeCommand = redactSensitiveData(fullCommand)
-    const safeErrorMessage = redactSensitiveData(errorMessage)
-    throw new Error(
-      `Failed to connect to MCP server "${info.serverName}".\n\n` +
-      `Command: ${safeCommand}\n` +
-      `Reason: ${safeErrorMessage}\n\n` +
-      `Hints:\n` +
-      `  - Ensure the command is installed and available in PATH\n` +
-      `  - Check if the MCP server package exists\n` +
-      `  - Verify the args are correct for this server`
-    )
-  }
-
-  if (state.shutdownGeneration !== shutdownGenAtStart) {
-    try { await client.close() } catch {}
-    try { await transport.close() } catch {}
-    throw new Error(`MCP server "${info.serverName}" connection completed after shutdown`)
-  }
-
-  const managedClient = {
-    client,
-    transport,
-    skillName: info.skillName,
-    lastUsedAt: Date.now(),
-    connectionType: "stdio",
-  } satisfies ManagedClient
-
-  state.clients.set(clientKey, managedClient)
-  startCleanupTimer(state)
-  return client
-}

package/src/features/skill-mcp-manager/types.ts

@@ -1,96 +0,0 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js"
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js"
-import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types"
-import type { McpOAuthProvider } from "../mcp-oauth/provider"
-import type { SkillScope } from "../opencode-skill-loader/types"
-
-export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>
-
-export type McpTransport = Transport
-
-export interface McpClient {
-  connect: Client["connect"]
-  close: Client["close"]
-  listTools: Client["listTools"]
-  listResources: Client["listResources"]
-  listPrompts: Client["listPrompts"]
-  callTool: Client["callTool"]
-  readResource: Client["readResource"]
-  getPrompt: Client["getPrompt"]
-}
-
-export interface SkillMcpClientInfo {
-  serverName: string
-  skillName: string
-  sessionID: string
-  scope?: SkillScope | "local"
-}
-
-export interface SkillMcpServerContext {
-  config: ClaudeCodeMcpServer
-  skillName: string
-}
-
-/**
- * Connection type for a managed MCP client.
- * - "stdio": Local process via stdin/stdout
- * - "http": Remote server via HTTP (Streamable HTTP transport)
- */
-export type ConnectionType = "stdio" | "http"
-
-export interface ManagedClientBase {
-  client: McpClient
-  skillName: string
-  lastUsedAt: number
-  connectionType: ConnectionType
-}
-
-export interface ManagedStdioClient extends ManagedClientBase {
-  connectionType: "stdio"
-  transport: McpTransport
-}
-
-export interface ManagedHttpClient extends ManagedClientBase {
-  connectionType: "http"
-  transport: McpTransport
-}
-
-export type ManagedClient = ManagedStdioClient | ManagedHttpClient
-
-export interface ProcessCleanupHandler {
-  signal: NodeJS.Signals
-  listener: () => void
-}
-
-export type OAuthProviderLike = Pick<
-  McpOAuthProvider,
-  "tokens" | "login" | "refresh"
->
-
-export type OAuthProviderFactory = (options: {
-  serverUrl: string
-  clientId?: string
-  scopes?: string[]
-}) => OAuthProviderLike
-
-export interface SkillMcpManagerState {
-  clients: Map<string, ManagedClient>
-  pendingConnections: Map<string, Promise<McpClient>>
-  disconnectedSessions: Map<string, number>
-  authProviders: Map<string, McpOAuthProvider>
-  cleanupRegistered: boolean
-  cleanupInterval: ReturnType<typeof setInterval> | null
-  cleanupHandlers: ProcessCleanupHandler[]
-  idleTimeoutMs: number
-  shutdownGeneration: number
-  inFlightConnections: Map<string, number>
-  disposed: boolean
-  createOAuthProvider: OAuthProviderFactory
-}
-
-export interface SkillMcpClientConnectionParams {
-  state: SkillMcpManagerState
-  clientKey: string
-  info: SkillMcpClientInfo
-  config: ClaudeCodeMcpServer
-}

package/src/features/task-toast-manager/index.ts

@@ -1,2 +0,0 @@
-export { TaskToastManager, getTaskToastManager, initTaskToastManager } from "./manager"
-export type { TrackedTask, TaskStatus, TaskToastOptions, ModelFallbackInfo } from "./types"