@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/features/mcp-oauth/refresh-mutex.ts

@@ -1,58 +0,0 @@
-import type { OAuthTokenData } from "./storage"
-
-/**
- * Per-server OAuth refresh mutex to prevent concurrent refresh race conditions.
- *
- * When multiple operations need to refresh a token for the same server,
- * this ensures only one refresh request is made and all waiters receive
- * the same result.
- */
-
-const ongoingRefreshes = new Map<string, Promise<OAuthTokenData>>()
-
-/**
- * Execute a token refresh with per-server mutual exclusion.
- *
- * If a refresh is already in progress for the given server, this will
- * return the same promise to all concurrent callers. Once the refresh
- * completes (success or failure), the lock is released.
- *
- * @param serverUrl - The OAuth server URL (used as mutex key)
- * @param refreshFn - The actual refresh operation to execute
- * @returns Promise that resolves to the new token data
- */
-export async function withRefreshMutex(
-  serverUrl: string,
-  refreshFn: () => Promise<OAuthTokenData>,
-): Promise<OAuthTokenData> {
-  const existing = ongoingRefreshes.get(serverUrl)
-  if (existing) {
-    return existing
-  }
-
-  const refreshPromise = refreshFn().finally(() => {
-    ongoingRefreshes.delete(serverUrl)
-  })
-
-  ongoingRefreshes.set(serverUrl, refreshPromise)
-  return refreshPromise
-}
-
-/**
- * Check if a refresh is currently in progress for a server.
- *
- * @param serverUrl - The OAuth server URL
- * @returns true if a refresh operation is active
- */
-export function isRefreshInProgress(serverUrl: string): boolean {
-  return ongoingRefreshes.has(serverUrl)
-}
-
-/**
- * Get the number of servers currently undergoing token refresh.
- *
- * @returns Number of active refresh operations
- */
-export function getActiveRefreshCount(): number {
-  return ongoingRefreshes.size
-}

package/src/features/mcp-oauth/resource-indicator.ts

@@ -1,16 +0,0 @@
-export function getResourceIndicator(url: string): string {
-  const parsed = new URL(url)
-  parsed.search = ""
-  parsed.hash = ""
-
-  let normalized = parsed.toString()
-  if (normalized.endsWith("/")) {
-    normalized = normalized.slice(0, -1)
-  }
-
-  return normalized
-}
-
-export function addResourceToParams(params: URLSearchParams, resource: string): void {
-  params.set("resource", resource)
-}

package/src/features/mcp-oauth/schema.ts

@@ -1,8 +0,0 @@
-import { z } from "zod"
-
-export const McpOauthSchema = z.object({
-  clientId: z.string().optional(),
-  scopes: z.array(z.string()).optional(),
-})
-
-export type McpOauth = z.infer<typeof McpOauthSchema>

package/src/features/mcp-oauth/step-up.ts

@@ -1,79 +0,0 @@
-export interface StepUpInfo {
-  requiredScopes: string[]
-  error?: string
-  errorDescription?: string
-}
-
-export function parseWwwAuthenticate(header: string): StepUpInfo | null {
-  const trimmed = header.trim()
-  const lowerHeader = trimmed.toLowerCase()
-  const bearerIndex = lowerHeader.indexOf("bearer")
-  if (bearerIndex === -1) {
-    return null
-  }
-
-  const params = trimmed.slice(bearerIndex + "bearer".length).trim()
-  if (params.length === 0) {
-    return null
-  }
-
-  const scope = extractParam(params, "scope")
-  if (scope === null) {
-    return null
-  }
-
-  const requiredScopes = scope
-    .split(/\s+/)
-    .filter((s) => s.length > 0)
-
-  if (requiredScopes.length === 0) {
-    return null
-  }
-
-  const info: StepUpInfo = { requiredScopes }
-
-  const error = extractParam(params, "error")
-  if (error !== null) {
-    info.error = error
-  }
-
-  const errorDescription = extractParam(params, "error_description")
-  if (errorDescription !== null) {
-    info.errorDescription = errorDescription
-  }
-
-  return info
-}
-
-function extractParam(params: string, name: string): string | null {
-  const quotedPattern = new RegExp(`${name}="([^"]*)"`)
-  const quotedMatch = quotedPattern.exec(params)
-  if (quotedMatch) {
-    return quotedMatch[1]
-  }
-
-  const unquotedPattern = new RegExp(`${name}=([^\\s,]+)`)
-  const unquotedMatch = unquotedPattern.exec(params)
-  return unquotedMatch?.[1] ?? null
-}
-
-export function mergeScopes(existing: string[], required: string[]): string[] {
-  const set = new Set(existing)
-  for (const scope of required) {
-    set.add(scope)
-  }
-  return [...set]
-}
-
-export function isStepUpRequired(statusCode: number, headers: Record<string, string>): StepUpInfo | null {
-  if (statusCode !== 403) {
-    return null
-  }
-
-  const wwwAuth = headers["www-authenticate"] ?? headers["WWW-Authenticate"]
-  if (!wwwAuth) {
-    return null
-  }
-
-  return parseWwwAuthenticate(wwwAuth)
-}

package/src/features/mcp-oauth/storage.ts

@@ -1,155 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs"
-import { dirname, join } from "node:path"
-import { getOpenCodeConfigDir } from "../../shared"
-
-export interface OAuthTokenData {
-  accessToken: string
-  refreshToken?: string
-  expiresAt?: number
-  clientInfo?: {
-    clientId: string
-    clientSecret?: string
-  }
-}
-
-type TokenStore = Record<string, OAuthTokenData>
-
-const STORAGE_FILE_NAME = "mcp-oauth.json"
-
-export function getMcpOauthStoragePath(): string {
-  return join(getOpenCodeConfigDir({ binary: "opencode" }), STORAGE_FILE_NAME)
-}
-
-function normalizeHost(serverHost: string): string {
-  let host = serverHost.trim()
-  if (!host) return host
-
-  if (host.includes("://")) {
-    try {
-      host = new URL(host).hostname
-    } catch {
-      host = host.split("/")[0]
-    }
-  } else {
-    host = host.split("/")[0]
-  }
-
-  if (host.startsWith("[")) {
-    const closing = host.indexOf("]")
-    if (closing !== -1) {
-      host = host.slice(0, closing + 1)
-    }
-    return host
-  }
-
-  if (host.includes(":")) {
-    host = host.split(":")[0]
-  }
-
-  return host
-}
-
-function normalizeResource(resource: string): string {
-  return resource.replace(/^\/+/, "")
-}
-
-function buildKey(serverHost: string, resource: string): string {
-  const host = normalizeHost(serverHost)
-  const normalizedResource = normalizeResource(resource)
-  return `${host}/${normalizedResource}`
-}
-
-function readStore(): TokenStore | null {
-  const filePath = getMcpOauthStoragePath()
-  if (!existsSync(filePath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(filePath, "utf-8")
-    return JSON.parse(content) as TokenStore
-  } catch {
-    return null
-  }
-}
-
-function writeStore(store: TokenStore): boolean {
-  const filePath = getMcpOauthStoragePath()
-
-  try {
-    const dir = dirname(filePath)
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true })
-    }
-
-    const tempPath = `${filePath}.tmp.${Date.now()}`
-    writeFileSync(tempPath, JSON.stringify(store, null, 2), { encoding: "utf-8", mode: 0o600 })
-    chmodSync(tempPath, 0o600)
-    renameSync(tempPath, filePath)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function loadToken(serverHost: string, resource: string): OAuthTokenData | null {
-  const store = readStore()
-  if (!store) return null
-
-  const key = buildKey(serverHost, resource)
-  return store[key] ?? null
-}
-
-export function saveToken(serverHost: string, resource: string, token: OAuthTokenData): boolean {
-  const store = readStore() ?? {}
-  const key = buildKey(serverHost, resource)
-  store[key] = token
-  return writeStore(store)
-}
-
-export function deleteToken(serverHost: string, resource: string): boolean {
-  const store = readStore()
-  if (!store) return true
-
-  const key = buildKey(serverHost, resource)
-  if (!(key in store)) {
-    return true
-  }
-
-  delete store[key]
-
-  if (Object.keys(store).length === 0) {
-    try {
-      const filePath = getMcpOauthStoragePath()
-      if (existsSync(filePath)) {
-        unlinkSync(filePath)
-      }
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  return writeStore(store)
-}
-
-export function listTokensByHost(serverHost: string): TokenStore {
-  const store = readStore()
-  if (!store) return {}
-
-  const host = normalizeHost(serverHost)
-  const prefix = `${host}/`
-  const result: TokenStore = {}
-
-  for (const [key, value] of Object.entries(store)) {
-    if (key.startsWith(prefix)) {
-      result[key] = value
-    }
-  }
-
-  return result
-}
-
-export function listAllTokens(): TokenStore {
-  return readStore() ?? {}
-}

package/src/features/opencode-skill-loader/AGENTS.md

@@ -1,59 +0,0 @@
-# src/features/opencode-skill-loader/ — 4-Scope Skill Discovery
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-28 files (~3.2k LOC). Discovers, parses, merges, and resolves SKILL.md files from 4 scopes with priority deduplication.
-
-## 4-SCOPE PRIORITY (highest → lowest)
-
-```
-1. Project (.opencode/skills/)
-2. OpenCode config (~/.config/opencode/skills/)
-3. User (~/.config/opencode/oh-my-opencode/skills/)
-4. Global (built-in skills)
-```
-
-Same-named skill at higher scope overrides lower.
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `loader.ts` | Main `loadSkills()` — orchestrates discovery → parse → merge |
-| `async-loader.ts` | Async variant for non-blocking skill loading |
-| `blocking.ts` | Sync variant for initial load |
-| `merger.ts` | Priority-based deduplication across scopes |
-| `skill-content.ts` | YAML frontmatter parsing from SKILL.md |
-| `skill-discovery.ts` | Find SKILL.md files in directory trees |
-| `skill-directory-loader.ts` | Load all skills from a single directory |
-| `config-source-discovery.ts` | Discover scope directories from config |
-| `skill-template-resolver.ts` | Variable substitution in skill templates |
-| `skill-mcp-config.ts` | Extract MCP configs from skill YAML |
-| `types.ts` | `LoadedSkill`, `SkillScope`, `SkillDiscoveryResult` |
-
-## SKILL FORMAT (SKILL.md)
-
-```markdown
----
-name: my-skill
-description: What this skill does
-tools: [Bash, Read, Write]
-mcp:
-  - name: my-mcp
-    type: stdio
-    command: npx
-    args: [-y, my-mcp-server]
----
-
-Skill content (instructions for the agent)...
-```
-
-## MERGER SUBDIRECTORY
-
-Handles complex merge logic when skills from multiple scopes have overlapping names or MCP configs.
-
-## TEMPLATE RESOLUTION
-
-Variables like `{{directory}}`, `{{agent}}` in skill content get resolved at load time based on current context.

package/src/features/opencode-skill-loader/allowed-tools-parser.ts

@@ -1,9 +0,0 @@
-export function parseAllowedTools(allowedTools: string | string[] | undefined): string[] | undefined {
-  if (!allowedTools) return undefined
-
-  if (Array.isArray(allowedTools)) {
-    return allowedTools.map((tool) => tool.trim()).filter(Boolean)
-  }
-
-  return allowedTools.split(/\s+/).filter(Boolean)
-}

package/src/features/opencode-skill-loader/async-loader.ts

@@ -1,213 +0,0 @@
-import { readFile, readdir } from "fs/promises"
-import type { Dirent } from "fs"
-import { join, basename } from "path"
-import yaml from "js-yaml"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { sanitizeModelField } from "../../shared/model-sanitizer"
-import { resolveSymlink, isMarkdownFile } from "../../shared/file-utils"
-import { resolveSkillPathReferences } from "../../shared/skill-path-resolver"
-import type { CommandDefinition } from "../claude-code-command-loader/types"
-import type { SkillScope, SkillMetadata, LoadedSkill } from "./types"
-import type { SkillMcpConfig } from "../skill-mcp-manager/types"
-
-export async function mapWithConcurrency<T, R>(
-  items: T[],
-  mapper: (item: T) => Promise<R>,
-  concurrency: number
-): Promise<R[]> {
-  const results: R[] = new Array(items.length)
-  let index = 0
-  
-  const worker = async () => {
-    while (index < items.length) {
-      const currentIndex = index++
-      results[currentIndex] = await mapper(items[currentIndex])
-    }
-  }
-  
-  const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => worker())
-  await Promise.all(workers)
-  
-  return results
-}
-
-function parseSkillMcpConfigFromFrontmatter(content: string): SkillMcpConfig | undefined {
-  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/)
-  if (!frontmatterMatch) return undefined
-
-  try {
-    const parsed = yaml.load(frontmatterMatch[1]) as Record<string, unknown>
-    if (parsed && typeof parsed === "object" && "mcp" in parsed && parsed.mcp) {
-      return parsed.mcp as SkillMcpConfig
-    }
-  } catch {
-    return undefined
-  }
-  return undefined
-}
-
-export async function loadMcpJsonFromDirAsync(skillDir: string): Promise<SkillMcpConfig | undefined> {
-  const mcpJsonPath = join(skillDir, "mcp.json")
-
-  try {
-    const content = await readFile(mcpJsonPath, "utf-8")
-    const parsed = JSON.parse(content) as Record<string, unknown>
-    
-    if (parsed && typeof parsed === "object" && "mcpServers" in parsed && parsed.mcpServers) {
-      return parsed.mcpServers as SkillMcpConfig
-    }
-    
-    if (parsed && typeof parsed === "object" && !("mcpServers" in parsed)) {
-      const hasCommandField = Object.values(parsed).some(
-        (v) => v && typeof v === "object" && "command" in (v as Record<string, unknown>)
-      )
-      if (hasCommandField) {
-        return parsed as SkillMcpConfig
-      }
-    }
-  } catch {
-    return undefined
-  }
-  return undefined
-}
-
-export async function loadSkillFromPathAsync(
-  skillPath: string,
-  resolvedPath: string,
-  defaultName: string,
-  scope: SkillScope,
-  namePrefix = ""
-): Promise<LoadedSkill | null> {
-  try {
-    const content = await readFile(skillPath, "utf-8")
-    const { data, body, parseError } = parseFrontmatter<SkillMetadata>(content)
-    if (parseError) return null
-    
-    const frontmatterMcp = parseSkillMcpConfigFromFrontmatter(content)
-    const mcpJsonMcp = await loadMcpJsonFromDirAsync(resolvedPath)
-    const mcpConfig = mcpJsonMcp || frontmatterMcp
-
-    const baseName = String(data.name || defaultName)
-    const skillName = namePrefix ? `${namePrefix}/${baseName}` : baseName
-    const originalDescription = data.description || ""
-    const isOpencodeSource = scope === "opencode" || scope === "opencode-project"
-    const formattedDescription = `(${scope} - Skill) ${originalDescription}`
-
-    const resolvedBody = resolveSkillPathReferences(body.trim(), resolvedPath)
-    const wrappedTemplate = `<skill-instruction>
-Base directory for this skill: ${resolvedPath}/
-File references (@path) in this skill are relative to this directory.
-
-${resolvedBody}
-</skill-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`
-
-    const definition: CommandDefinition = {
-      name: skillName,
-      description: formattedDescription,
-      template: wrappedTemplate,
-      model: sanitizeModelField(data.model, isOpencodeSource ? "opencode" : "claude-code"),
-      agent: data.agent,
-      subtask: data.subtask,
-      argumentHint: data["argument-hint"],
-    }
-
-    return {
-      name: skillName,
-      path: skillPath,
-      resolvedPath,
-      definition,
-      scope,
-      license: data.license,
-      compatibility: data.compatibility,
-      metadata: data.metadata,
-      allowedTools: parseAllowedTools(data["allowed-tools"]),
-      mcpConfig,
-    }
-  } catch {
-    return null
-  }
-}
-
-function parseAllowedTools(allowedTools: string | string[] | undefined): string[] | undefined {
-  if (!allowedTools) return undefined
-  
-  // Handle YAML array format: already parsed as string[]
-  if (Array.isArray(allowedTools)) {
-    return allowedTools.map(t => t.trim()).filter(Boolean)
-  }
-  
-  // Handle space-separated string format: "Read Write Edit Bash"
-  return allowedTools.split(/\s+/).filter(Boolean)
-}
-
-export async function discoverSkillsInDirAsync(
-  skillsDir: string,
-  scope: SkillScope = "opencode-project",
-  namePrefix = "",
-  depth = 0,
-  maxDepth = 2
-): Promise<LoadedSkill[]> {
-  try {
-    const entries = await readdir(skillsDir, { withFileTypes: true })
-    
-    const processEntry = async (entry: Dirent): Promise<LoadedSkill | LoadedSkill[] | null> => {
-      if (entry.name.startsWith(".")) return null
-
-      const entryPath = join(skillsDir, entry.name)
-
-      if (entry.isDirectory() || entry.isSymbolicLink()) {
-        const resolvedPath = resolveSymlink(entryPath)
-        const dirName = entry.name
-
-        const skillMdPath = join(resolvedPath, "SKILL.md")
-        try {
-          await readFile(skillMdPath, "utf-8")
-          return await loadSkillFromPathAsync(skillMdPath, resolvedPath, dirName, scope, namePrefix)
-        } catch {
-          const namedSkillMdPath = join(resolvedPath, `${dirName}.md`)
-          try {
-            await readFile(namedSkillMdPath, "utf-8")
-            return await loadSkillFromPathAsync(namedSkillMdPath, resolvedPath, dirName, scope, namePrefix)
-          } catch {
-            if (depth >= maxDepth) {
-              return null
-            }
-
-            const nestedPrefix = namePrefix ? `${namePrefix}/${dirName}` : dirName
-            const nestedSkills = await discoverSkillsInDirAsync(
-              resolvedPath,
-              scope,
-              nestedPrefix,
-              depth + 1,
-              maxDepth
-            )
-
-            return nestedSkills.length > 0 ? nestedSkills : null
-          }
-        }
-      }
-
-      if (isMarkdownFile(entry)) {
-        const skillName = basename(entry.name, ".md")
-        return await loadSkillFromPathAsync(entryPath, skillsDir, skillName, scope, namePrefix)
-      }
-
-      return null
-    }
-
-    const skillPromises = await mapWithConcurrency(entries, processEntry, 16)
-    return skillPromises.flatMap((skill): LoadedSkill[] => {
-      if (skill === null) return []
-      return Array.isArray(skill) ? skill : [skill]
-    })
-  } catch (error: unknown) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-      return []
-    }
-    return []
-  }
-}

package/src/features/opencode-skill-loader/blocking.ts

@@ -1,62 +0,0 @@
-import { Worker, MessageChannel, receiveMessageOnPort } from "worker_threads"
-import type { LoadedSkill, SkillScope } from "./types"
-
-interface WorkerInput {
-  dirs: string[]
-  scopes: SkillScope[]
-}
-
-interface WorkerOutputSuccess {
-  ok: true
-  skills: LoadedSkill[]
-}
-
-interface WorkerOutputError {
-  ok: false
-  error: { message: string; stack?: string }
-}
-
-type WorkerOutput = WorkerOutputSuccess | WorkerOutputError
-
-const TIMEOUT_MS = 30000
-
-export function discoverAllSkillsBlocking(dirs: string[], scopes: SkillScope[]): LoadedSkill[] {
-  const signal = new Int32Array(new SharedArrayBuffer(4))
-  const { port1, port2 } = new MessageChannel()
-  
-  const worker = new Worker(new URL("./discover-worker.ts", import.meta.url), {
-    // workerData is structured-cloned; pass the SharedArrayBuffer and recreate the view in the worker.
-    workerData: { signalBuffer: signal.buffer },
-  })
-
-  const input: WorkerInput = { dirs, scopes }
-  // Avoid a race where the worker hasn't attached listeners to the MessagePort yet.
-  worker.postMessage({ port: port2, input }, [port2])
-
-  const waitResult = Atomics.wait(signal, 0, 0, TIMEOUT_MS)
-
-  if (waitResult === "timed-out") {
-    worker.terminate()
-    port1.close()
-    throw new Error(`Worker timeout after ${TIMEOUT_MS}ms`)
-  }
-
-  const message = receiveMessageOnPort(port1)
-  
-  worker.terminate()
-  port1.close()
-
-  if (!message) {
-    throw new Error("Worker did not return result")
-  }
-
-  const output = message.message as WorkerOutput
-
-  if (output.ok === false) {
-    const error = new Error(output.error.message)
-    error.stack = output.error.stack
-    throw error
-  }
-
-  return output.skills
-}