@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

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
-}

package/src/features/opencode-skill-loader/config-source-discovery.ts

@@ -1,114 +0,0 @@
-import { promises as fs } from "fs"
-import { homedir } from "os"
-import { dirname, extname, isAbsolute, join, relative } from "path"
-import picomatch from "picomatch"
-import type { SkillsConfig } from "../../config/schema"
-import { normalizeSkillsConfig } from "./merger/skills-config-normalizer"
-import { deduplicateSkillsByName } from "./skill-deduplication"
-import { loadSkillsFromDir } from "./skill-directory-loader"
-import { inferSkillNameFromFileName, loadSkillFromPath } from "./loaded-skill-from-path"
-import type { LoadedSkill } from "./types"
-
-const MAX_RECURSIVE_DEPTH = 10
-
-function isHttpUrl(path: string): boolean {
-  return path.startsWith("http://") || path.startsWith("https://")
-}
-
-function toAbsolutePath(path: string, configDir: string): string {
-  if (path === "~") {
-    return homedir()
-  }
-
-  if (path.startsWith("~/")) {
-    return join(homedir(), path.slice(2))
-  }
-
-  if (isAbsolute(path)) {
-    return path
-  }
-  return join(configDir, path)
-}
-
-function isMarkdownPath(path: string): boolean {
-  return extname(path).toLowerCase() === ".md"
-}
-
-export function normalizePathForGlob(path: string): string {
-  return path.split("\\").join("/")
-}
-
-function filterByGlob(skills: LoadedSkill[], sourceBaseDir: string, globPattern?: string): LoadedSkill[] {
-  if (!globPattern) return skills
-
-  return skills.filter((skill) => {
-    if (!skill.path) return false
-    const rel = normalizePathForGlob(relative(sourceBaseDir, skill.path))
-    return picomatch.isMatch(rel, globPattern, { dot: true, bash: true })
-  })
-}
-
-async function loadSourcePath(options: {
-  sourcePath: string
-  recursive: boolean
-  globPattern?: string
-  configDir: string
-}): Promise<LoadedSkill[]> {
-  if (isHttpUrl(options.sourcePath)) {
-    return []
-  }
-
-  const absolutePath = toAbsolutePath(options.sourcePath, options.configDir)
-  const stat = await fs.stat(absolutePath).catch(() => null)
-  if (!stat) return []
-
-  if (stat.isFile()) {
-    if (!isMarkdownPath(absolutePath)) return []
-    const loaded = await loadSkillFromPath({
-      skillPath: absolutePath,
-      resolvedPath: dirname(absolutePath),
-      defaultName: inferSkillNameFromFileName(absolutePath),
-      scope: "config",
-    })
-    if (!loaded) return []
-    return filterByGlob([loaded], dirname(absolutePath), options.globPattern)
-  }
-
-  if (!stat.isDirectory()) return []
-
-  const directorySkills = await loadSkillsFromDir({
-    skillsDir: absolutePath,
-    scope: "config",
-    maxDepth: options.recursive ? MAX_RECURSIVE_DEPTH : 0,
-  })
-  return filterByGlob(directorySkills, absolutePath, options.globPattern)
-}
-
-export async function discoverConfigSourceSkills(options: {
-  config: SkillsConfig | undefined
-  configDir: string
-}): Promise<LoadedSkill[]> {
-  const normalized = normalizeSkillsConfig(options.config)
-  if (normalized.sources.length === 0) return []
-
-  const loadedBySource = await Promise.all(
-    normalized.sources.map((source) => {
-      if (typeof source === "string") {
-        return loadSourcePath({
-          sourcePath: source,
-          recursive: false,
-          configDir: options.configDir,
-        })
-      }
-
-      return loadSourcePath({
-        sourcePath: source.path,
-        recursive: source.recursive ?? false,
-        globPattern: source.glob,
-        configDir: options.configDir,
-      })
-    }),
-  )
-
-  return deduplicateSkillsByName(loadedBySource.flat())
-}