@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/features/claude-code-mcp-loader/configure-allowed-env-vars.ts

@@ -1,48 +0,0 @@
-const BUILTIN_ALLOWED_MCP_ENV_VARS = [
-  "PATH",
-  "HOME",
-  "USER",
-  "SHELL",
-  "TERM",
-  "TMPDIR",
-  "TMP",
-  "TEMP",
-  "PWD",
-  "OLDPWD",
-  "LANG",
-  "LC_ALL",
-  "LC_CTYPE",
-  "EDITOR",
-  "VISUAL",
-  "XDG_CONFIG_HOME",
-  "XDG_DATA_HOME",
-  "XDG_CACHE_HOME",
-  "HOSTNAME",
-  "LOGNAME",
-  "USERPROFILE",
-  "APPDATA",
-  "LOCALAPPDATA",
-]
-const SENSITIVE_MCP_ENV_VAR_PATTERN = /KEY|TOKEN|SECRET|PASSWORD|AUTH|CREDENTIAL/i
-
-let additionalAllowedMcpEnvVars = new Set<string>()
-
-export function getAllowedMcpEnvVars(): Set<string> {
-  return new Set([...BUILTIN_ALLOWED_MCP_ENV_VARS, ...additionalAllowedMcpEnvVars])
-}
-
-export function isSensitiveMcpEnvVar(varName: string): boolean {
-  return SENSITIVE_MCP_ENV_VAR_PATTERN.test(varName)
-}
-
-export function isAllowedMcpEnvVar(varName: string): boolean {
-  return getAllowedMcpEnvVars().has(varName)
-}
-
-export function setAdditionalAllowedMcpEnvVars(varNames: string[]): void {
-  additionalAllowedMcpEnvVars = new Set(varNames)
-}
-
-export function resetAdditionalAllowedMcpEnvVars(): void {
-  additionalAllowedMcpEnvVars = new Set()
-}

package/src/features/claude-code-mcp-loader/env-expander.ts

@@ -1,51 +0,0 @@
-import { log } from "../../shared/logger"
-import {
-  isAllowedMcpEnvVar,
-  isSensitiveMcpEnvVar,
-} from "./configure-allowed-env-vars"
-
-export interface ExpandEnvVarsOptions {
-  trusted?: boolean
-}
-
-export function expandEnvVars(value: string, options: ExpandEnvVarsOptions = {}): string {
-  const { trusted = false } = options
-  return value.replace(
-    /\$\{([^}:]+)(?::-([^}]*))?\}/g,
-    (_, varName: string, defaultValue?: string) => {
-      if (!trusted && !isAllowedMcpEnvVar(varName)) {
-        const isSensitive = isSensitiveMcpEnvVar(varName)
-        const reason = isSensitive ? "sensitive variable" : "not in allowlist"
-
-        log(`Blocked MCP env var expansion for ${reason} "${varName}"`, {
-          varName,
-          sensitive: isSensitive,
-        })
-
-        if (defaultValue !== undefined) return defaultValue
-        return ""
-      }
-
-      const envValue = process.env[varName]
-      if (envValue !== undefined) return envValue
-      if (defaultValue !== undefined) return defaultValue
-      return ""
-    }
-  )
-}
-
-export function expandEnvVarsInObject<T>(obj: T, options: ExpandEnvVarsOptions = {}): T {
-  if (obj == null) return obj
-  if (typeof obj === "string") return expandEnvVars(obj, options) as T
-  if (Array.isArray(obj)) {
-    return obj.map((item) => expandEnvVarsInObject(item, options)) as T
-  }
-  if (typeof obj === "object") {
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = expandEnvVarsInObject(value, options)
-    }
-    return result as T
-  }
-  return obj
-}

package/src/features/claude-code-mcp-loader/index.ts

@@ -1,12 +0,0 @@
-/**
- * MCP Configuration Loader
- *
- * Loads Claude Code .mcp.json format configurations from multiple scopes
- * and transforms them to OpenCode SDK format
- */
-
-export * from "./types"
-export * from "./loader"
-export * from "./transformer"
-export * from "./env-expander"
-export * from "./configure-allowed-env-vars"

package/src/features/claude-code-mcp-loader/loader.ts

@@ -1,156 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { join } from "path"
-import { homedir } from "os"
-import { getClaudeConfigDir } from "../../shared"
-import type {
-  ClaudeCodeMcpConfig,
-  LoadedMcpServer,
-  McpLoadResult,
-  McpScope,
-} from "./types"
-import { transformMcpServer } from "./transformer"
-import { log } from "../../shared/logger"
-import { shouldLoadMcpServer } from "./scope-filter"
-
-interface McpConfigPath {
-  path: string
-  scope: McpScope
-}
-
-function getMcpConfigPaths(): McpConfigPath[] {
-  const claudeConfigDir = getClaudeConfigDir()
-  const cwd = process.cwd()
-  const explicitClaudeConfigDir =
-    process.env.CLAUDE_CONFIG_DIR?.trim() || process.env.OPENCODE_CONFIG_DIR?.trim()
-
-  const candidates: McpConfigPath[] = [
-    ...(explicitClaudeConfigDir
-      ? []
-      : [{ path: join(homedir(), ".claude.json"), scope: "user" as const }]),
-    { path: join(claudeConfigDir, ".mcp.json"), scope: "user" },
-    { path: join(cwd, ".mcp.json"), scope: "project" },
-    { path: join(cwd, ".claude", ".mcp.json"), scope: "local" },
-  ]
-
-  const seen = new Set<string>()
-  return candidates.filter(({ path }) => {
-    if (seen.has(path)) return false
-    seen.add(path)
-    return true
-  })
-}
-
-async function loadMcpConfigFile(
-  filePath: string
-): Promise<ClaudeCodeMcpConfig | null> {
-  if (!existsSync(filePath)) {
-    return null
-  }
-
-  try {
-    const content = await Bun.file(filePath).text()
-    return JSON.parse(content) as ClaudeCodeMcpConfig
-  } catch (error) {
-    log(`Failed to load MCP config from ${filePath}`, error)
-    return null
-  }
-}
-
-export function getSystemMcpServerNames(): Set<string> {
-  const names = new Set<string>()
-  const paths = getMcpConfigPaths()
-  const cwd = process.cwd()
-
-  for (const { path } of paths) {
-    if (!existsSync(path)) continue
-
-    try {
-      const content = readFileSync(path, "utf-8")
-      const config = JSON.parse(content) as ClaudeCodeMcpConfig
-      if (!config?.mcpServers) continue
-
-      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-        if (serverConfig.disabled) {
-          names.delete(name)
-          continue
-        }
-        if (!shouldLoadMcpServer(serverConfig, cwd)) continue
-        names.add(name)
-      }
-    } catch {
-      continue
-    }
-  }
-
-  return names
-}
-
-export async function loadMcpConfigs(
-  disabledMcps: string[] = []
-): Promise<McpLoadResult> {
-  const servers: McpLoadResult["servers"] = {}
-  const loadedServers: LoadedMcpServer[] = []
-  const paths = getMcpConfigPaths()
-  const disabledSet = new Set(disabledMcps)
-  const cwd = process.cwd()
-
-  for (const { path, scope } of paths) {
-    const config = await loadMcpConfigFile(path)
-    if (!config?.mcpServers) continue
-
-    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-      if (disabledSet.has(name)) {
-        log(`Skipping MCP "${name}" (in disabled_mcps)`, { path })
-        continue
-      }
-
-      if (!shouldLoadMcpServer(serverConfig, cwd)) {
-        log(`Skipping MCP server "${name}" because local scope does not match cwd`, {
-          path,
-          projectPath: serverConfig.projectPath,
-          cwd,
-        })
-        continue
-      }
-
-      if (serverConfig.disabled) {
-        log(`Disabling MCP server "${name}"`, { path })
-        delete servers[name]
-        const existingIndex = loadedServers.findIndex((s) => s.name === name)
-        if (existingIndex !== -1) {
-          loadedServers.splice(existingIndex, 1)
-          log(`Removed previously loaded MCP server "${name}"`, { path })
-        }
-        continue
-      }
-
-      try {
-        const transformed = transformMcpServer(name, serverConfig)
-        servers[name] = transformed
-
-        const existingIndex = loadedServers.findIndex((s) => s.name === name)
-        if (existingIndex !== -1) {
-          loadedServers.splice(existingIndex, 1)
-        }
-
-        loadedServers.push({ name, scope, config: transformed })
-
-        log(`Loaded MCP server "${name}" from ${scope}`, { path })
-      } catch (error) {
-        log(`Failed to transform MCP server "${name}"`, error)
-      }
-    }
-  }
-
-  return { servers, loadedServers }
-}
-
-export function formatLoadedServersForToast(
-  loadedServers: LoadedMcpServer[]
-): string {
-  if (loadedServers.length === 0) return ""
-
-  return loadedServers
-    .map((server) => `${server.name} (${server.scope})`)
-    .join(", ")
-}

package/src/features/claude-code-mcp-loader/scope-filter.ts

@@ -1,17 +0,0 @@
-import { containsPath } from "../../shared/contains-path"
-import type { ClaudeCodeMcpServer } from "./types"
-
-export function shouldLoadMcpServer(
-  server: Pick<ClaudeCodeMcpServer, "scope" | "projectPath">,
-  cwd = process.cwd()
-): boolean {
-  if (server.scope !== "local") {
-    return true
-  }
-
-  if (!server.projectPath) {
-    return false
-  }
-
-  return containsPath(server.projectPath, cwd)
-}

package/src/features/claude-code-mcp-loader/transformer.ts

@@ -1,57 +0,0 @@
-import type {
-  ClaudeCodeMcpServer,
-  McpLocalConfig,
-  McpRemoteConfig,
-  McpServerConfig,
-} from "./types"
-import { expandEnvVarsInObject } from "./env-expander"
-
-export function transformMcpServer(
-  name: string,
-  server: ClaudeCodeMcpServer
-): McpServerConfig {
-  const expanded = expandEnvVarsInObject(server)
-  const serverType = expanded.type ?? "stdio"
-
-  if (serverType === "http" || serverType === "sse") {
-    if (!expanded.url) {
-      throw new Error(
-        `MCP server "${name}" requires url for type "${serverType}"`
-      )
-    }
-
-    const config: McpRemoteConfig = {
-      type: "remote",
-      url: expanded.url,
-      enabled: true,
-    }
-
-    if (expanded.headers && Object.keys(expanded.headers).length > 0) {
-      config.headers = expanded.headers
-    }
-
-    if (expanded.oauth && Object.keys(expanded.oauth).length > 0) {
-      config.oauth = expanded.oauth
-    }
-
-    return config
-  }
-
-  if (!expanded.command) {
-    throw new Error(`MCP server "${name}" requires command for stdio type`)
-  }
-
-  const commandArray = [expanded.command, ...(expanded.args ?? [])]
-
-  const config: McpLocalConfig = {
-    type: "local",
-    command: commandArray,
-    enabled: true,
-  }
-
-  if (expanded.env && Object.keys(expanded.env).length > 0) {
-    config.environment = expanded.env
-  }
-
-  return config
-}

package/src/features/claude-code-mcp-loader/types.ts

@@ -1,51 +0,0 @@
-export type McpScope = "user" | "project" | "local"
-
-export interface McpOAuthConfig {
-  clientId?: string
-  scopes?: string[]
-}
-
-export interface ClaudeCodeMcpServer {
-  type?: "http" | "sse" | "stdio"
-  url?: string
-  command?: string
-  args?: string[]
-  env?: Record<string, string>
-  headers?: Record<string, string>
-  oauth?: McpOAuthConfig
-  scope?: McpScope
-  projectPath?: string
-  disabled?: boolean
-}
-
-export interface ClaudeCodeMcpConfig {
-  mcpServers?: Record<string, ClaudeCodeMcpServer>
-}
-
-export interface McpLocalConfig {
-  type: "local"
-  command: string[]
-  environment?: Record<string, string>
-  enabled?: boolean
-}
-
-export interface McpRemoteConfig {
-  type: "remote"
-  url: string
-  headers?: Record<string, string>
-  oauth?: McpOAuthConfig
-  enabled?: boolean
-}
-
-export type McpServerConfig = McpLocalConfig | McpRemoteConfig
-
-export interface LoadedMcpServer {
-  name: string
-  scope: McpScope
-  config: McpServerConfig
-}
-
-export interface McpLoadResult {
-  servers: Record<string, McpServerConfig>
-  loadedServers: LoadedMcpServer[]
-}

package/src/features/claude-code-plugin-loader/agent-loader.ts

@@ -1,59 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs"
-import { basename, join } from "path"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { isMarkdownFile } from "../../shared/file-utils"
-import { log } from "../../shared/logger"
-import { parseToolsConfig } from "../../shared/parse-tools-config"
-import type { AgentFrontmatter, ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types"
-import { mapClaudeModelToOpenCode } from "../claude-code-agent-loader/claude-model-mapper"
-import type { LoadedPlugin } from "./types"
-
-export function loadPluginAgents(plugins: LoadedPlugin[]): Record<string, ClaudeCodeAgentConfig> {
-  const agents: Record<string, ClaudeCodeAgentConfig> = {}
-
-  for (const plugin of plugins) {
-    if (!plugin.agentsDir || !existsSync(plugin.agentsDir)) continue
-
-    const entries = readdirSync(plugin.agentsDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (!isMarkdownFile(entry)) continue
-
-      const agentPath = join(plugin.agentsDir, entry.name)
-      const agentName = basename(entry.name, ".md")
-      const namespacedName = `${plugin.name}:${agentName}`
-
-      try {
-        const content = readFileSync(agentPath, "utf-8")
-        const { data, body } = parseFrontmatter<AgentFrontmatter>(content)
-
-        const originalDescription = data.description || ""
-        const formattedDescription = `(plugin: ${plugin.name}) ${originalDescription}`
-
-        const mappedModelOverride = mapClaudeModelToOpenCode(data.model)
-        const modelString = mappedModelOverride
-          ? `${mappedModelOverride.providerID}/${mappedModelOverride.modelID}`
-          : undefined
-
-        const config: ClaudeCodeAgentConfig = {
-          description: formattedDescription,
-          mode: "subagent",
-          prompt: body.trim(),
-          ...(modelString ? { model: modelString } : {}),
-        }
-
-        const toolsConfig = parseToolsConfig(data.tools)
-        if (toolsConfig) {
-          config.tools = toolsConfig
-        }
-
-        agents[namespacedName] = config
-        log(`Loaded plugin agent: ${namespacedName}`, { path: agentPath })
-      } catch (error) {
-        log(`Failed to load plugin agent: ${agentPath}`, error)
-      }
-    }
-  }
-
-  return agents
-}

package/src/features/claude-code-plugin-loader/command-loader.ts

@@ -1,53 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs"
-import { basename, join } from "path"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { isMarkdownFile } from "../../shared/file-utils"
-import { sanitizeModelField } from "../../shared/model-sanitizer"
-import { log } from "../../shared/logger"
-import type { CommandDefinition, CommandFrontmatter } from "../claude-code-command-loader/types"
-import type { LoadedPlugin } from "./types"
-
-export function loadPluginCommands(plugins: LoadedPlugin[]): Record<string, CommandDefinition> {
-  const commands: Record<string, CommandDefinition> = {}
-
-  for (const plugin of plugins) {
-    if (!plugin.commandsDir || !existsSync(plugin.commandsDir)) continue
-
-    const entries = readdirSync(plugin.commandsDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (!isMarkdownFile(entry)) continue
-
-      const commandPath = join(plugin.commandsDir, entry.name)
-      const commandName = basename(entry.name, ".md")
-      const namespacedName = `${plugin.name}:${commandName}`
-
-      try {
-        const content = readFileSync(commandPath, "utf-8")
-        const { data, body } = parseFrontmatter<CommandFrontmatter>(content)
-
-        const wrappedTemplate = `<command-instruction>\n${body.trim()}\n</command-instruction>\n\n<user-request>\n$ARGUMENTS\n</user-request>`
-        const formattedDescription = `(plugin: ${plugin.name}) ${data.description || ""}`
-
-        const definition = {
-          name: namespacedName,
-          description: formattedDescription,
-          template: wrappedTemplate,
-          agent: data.agent,
-          model: sanitizeModelField(data.model, "claude-code"),
-          subtask: data.subtask,
-          argumentHint: data["argument-hint"],
-        }
-
-        const { name: _name, argumentHint: _argumentHint, ...openCodeCompatible } = definition
-        commands[namespacedName] = openCodeCompatible as CommandDefinition
-
-        log(`Loaded plugin command: ${namespacedName}`, { path: commandPath })
-      } catch (error) {
-        log(`Failed to load plugin command: ${commandPath}`, error)
-      }
-    }
-  }
-
-  return commands
-}