@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/shared/opencode-http-api.ts

@@ -1,140 +0,0 @@
-import { getServerBasicAuthHeader } from "./opencode-server-auth"
-import { log } from "./logger"
-import { isRecord } from "./record-type-guard"
-
-type UnknownRecord = Record<string, unknown>
-
-function getInternalClient(client: unknown): UnknownRecord | null {
-  if (!isRecord(client)) {
-    return null
-  }
-
-  const internal = client["_client"]
-  return isRecord(internal) ? internal : null
-}
-
-export function getServerBaseUrl(client: unknown): string | null {
-  // Try client._client.getConfig().baseUrl
-  const internal = getInternalClient(client)
-  if (internal) {
-    const getConfig = internal["getConfig"]
-    if (typeof getConfig === "function") {
-      const config = getConfig()
-      if (isRecord(config)) {
-        const baseUrl = config["baseUrl"]
-        if (typeof baseUrl === "string") {
-          return baseUrl
-        }
-      }
-    }
-  }
-
-  // Try client.session._client.getConfig().baseUrl
-  if (isRecord(client)) {
-    const session = client["session"]
-    if (isRecord(session)) {
-      const internal = session["_client"]
-      if (isRecord(internal)) {
-        const getConfig = internal["getConfig"]
-        if (typeof getConfig === "function") {
-          const config = getConfig()
-          if (isRecord(config)) {
-            const baseUrl = config["baseUrl"]
-            if (typeof baseUrl === "string") {
-              return baseUrl
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return null
-}
-
-export async function patchPart(
-  client: unknown,
-  sessionID: string,
-  messageID: string,
-  partID: string,
-  body: Record<string, unknown>
-): Promise<boolean> {
-  const baseUrl = getServerBaseUrl(client)
-  if (!baseUrl) {
-    log("[opencode-http-api] Could not extract baseUrl from client")
-    return false
-  }
-
-  const auth = getServerBasicAuthHeader()
-  if (!auth) {
-    log("[opencode-http-api] No auth header available")
-    return false
-  }
-
-  const url = `${baseUrl}/session/${encodeURIComponent(sessionID)}/message/${encodeURIComponent(messageID)}/part/${encodeURIComponent(partID)}`
-
-  try {
-    const response = await fetch(url, {
-      method: "PATCH",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": auth,
-      },
-      body: JSON.stringify(body),
-      signal: AbortSignal.timeout(10_000),
-    })
-
-    if (!response.ok) {
-      log("[opencode-http-api] PATCH failed", { status: response.status, url })
-      return false
-    }
-
-    return true
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    log("[opencode-http-api] PATCH error", { message, url })
-    return false
-  }
-}
-
-export async function deletePart(
-  client: unknown,
-  sessionID: string,
-  messageID: string,
-  partID: string
-): Promise<boolean> {
-  const baseUrl = getServerBaseUrl(client)
-  if (!baseUrl) {
-    log("[opencode-http-api] Could not extract baseUrl from client")
-    return false
-  }
-
-  const auth = getServerBasicAuthHeader()
-  if (!auth) {
-    log("[opencode-http-api] No auth header available")
-    return false
-  }
-
-  const url = `${baseUrl}/session/${encodeURIComponent(sessionID)}/message/${encodeURIComponent(messageID)}/part/${encodeURIComponent(partID)}`
-
-  try {
-    const response = await fetch(url, {
-      method: "DELETE",
-      headers: {
-        "Authorization": auth,
-      },
-      signal: AbortSignal.timeout(10_000),
-    })
-
-    if (!response.ok) {
-      log("[opencode-http-api] DELETE failed", { status: response.status, url })
-      return false
-    }
-
-    return true
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    log("[opencode-http-api] DELETE error", { message, url })
-    return false
-  }
-}

package/src/shared/opencode-message-dir.ts

@@ -1,29 +0,0 @@
-import { existsSync, readdirSync } from "node:fs"
-import { join } from "node:path"
-import { MESSAGE_STORAGE } from "./opencode-storage-paths"
-import { log } from "./logger"
-
-export function getMessageDir(sessionID: string): string | null {
-  if (!sessionID.startsWith("ses_")) return null
-  if (/[/\\]|\.\./.test(sessionID)) return null
-  if (!existsSync(MESSAGE_STORAGE)) return null
-
-  const directPath = join(MESSAGE_STORAGE, sessionID)
-  if (existsSync(directPath)) {
-    return directPath
-  }
-
-  try {
-    for (const dir of readdirSync(MESSAGE_STORAGE)) {
-      const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
-      if (existsSync(sessionPath)) {
-        return sessionPath
-      }
-    }
-  } catch (error) {
-    log("[opencode-message-dir] Failed to scan message directories", { sessionID, error: String(error) })
-    return null
-  }
-
-  return null
-}

package/src/shared/opencode-server-auth.ts

@@ -1,190 +0,0 @@
-import { log } from "./logger"
-
-/**
- * Builds HTTP Basic Auth header from environment variables.
- *
- * @returns Basic Auth header string, or undefined if OPENCODE_SERVER_PASSWORD is not set
- */
-export function getServerBasicAuthHeader(): string | undefined {
-  const password = process.env.OPENCODE_SERVER_PASSWORD
-  if (!password) {
-    return undefined
-  }
-
-  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode"
-  const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64")
-
-  return `Basic ${token}`
-}
-
-type UnknownRecord = Record<string, unknown>
-
-function isRecord(value: unknown): value is UnknownRecord {
-  return typeof value === "object" && value !== null
-}
-
-function isRequestFetch(value: unknown): value is (request: Request) => Promise<Response> {
-  return typeof value === "function"
-}
-
-function wrapRequestFetch(
-  baseFetch: (request: Request) => Promise<Response>,
-  auth: string
-): (request: Request) => Promise<Response> {
-  return async (request: Request): Promise<Response> => {
-    const headers = new Headers(request.headers)
-    headers.set("Authorization", auth)
-    return baseFetch(new Request(request, { headers }))
-  }
-}
-
-function getInternalClient(client: unknown): UnknownRecord | null {
-  if (!isRecord(client)) {
-    return null
-  }
-
-  const internal = client["_client"]
-  return isRecord(internal) ? internal : null
-}
-
-function tryInjectViaSetConfigHeaders(internal: UnknownRecord, auth: string): boolean {
-  const setConfig = internal["setConfig"]
-  if (typeof setConfig !== "function") {
-    return false
-  }
-
-  setConfig({
-    headers: {
-      Authorization: auth,
-    },
-  })
-
-  return true
-}
-
-function tryInjectViaInterceptors(internal: UnknownRecord, auth: string): boolean {
-  const interceptors = internal["interceptors"]
-  if (!isRecord(interceptors)) {
-    return false
-  }
-
-  const requestInterceptors = interceptors["request"]
-  if (!isRecord(requestInterceptors)) {
-    return false
-  }
-
-  const use = requestInterceptors["use"]
-  if (typeof use !== "function") {
-    return false
-  }
-
-  use((request: Request): Request => {
-    if (!request.headers.get("Authorization")) {
-      request.headers.set("Authorization", auth)
-    }
-    return request
-  })
-
-  return true
-}
-
-function tryInjectViaFetchWrapper(internal: UnknownRecord, auth: string): boolean {
-  const getConfig = internal["getConfig"]
-  const setConfig = internal["setConfig"]
-  if (typeof getConfig !== "function" || typeof setConfig !== "function") {
-    return false
-  }
-
-  const config = getConfig()
-  if (!isRecord(config)) {
-    return false
-  }
-
-  const fetchValue = config["fetch"]
-  if (!isRequestFetch(fetchValue)) {
-    return false
-  }
-
-  setConfig({
-    fetch: wrapRequestFetch(fetchValue, auth),
-  })
-
-  return true
-}
-
-function tryInjectViaMutableInternalConfig(internal: UnknownRecord, auth: string): boolean {
-  const configValue = internal["_config"]
-  if (!isRecord(configValue)) {
-    return false
-  }
-
-  const fetchValue = configValue["fetch"]
-  if (!isRequestFetch(fetchValue)) {
-    return false
-  }
-
-  configValue["fetch"] = wrapRequestFetch(fetchValue, auth)
-
-  return true
-}
-
-function tryInjectViaTopLevelFetch(client: unknown, auth: string): boolean {
-  if (!isRecord(client)) {
-    return false
-  }
-
-  const fetchValue = client["fetch"]
-  if (!isRequestFetch(fetchValue)) {
-    return false
-  }
-
-  client["fetch"] = wrapRequestFetch(fetchValue, auth)
-
-  return true
-}
-
-/**
- * Injects HTTP Basic Auth header into the OpenCode SDK client.
- *
- * This function accesses the SDK's internal `_client.setConfig()` method.
- * While `_client` has an underscore prefix (suggesting internal use), this is actually
- * a stable public API from `@hey-api/openapi-ts` generated client:
- * - `setConfig()` MERGES headers (does not replace existing ones)
- * - This is the documented way to update client config at runtime
- *
- * @see https://github.com/sst/opencode/blob/main/packages/sdk/js/src/gen/client/client.gen.ts
- * @throws {Error} If OPENCODE_SERVER_PASSWORD is set but client structure is incompatible
- */
-export function injectServerAuthIntoClient(client: unknown): void {
-  const auth = getServerBasicAuthHeader()
-  if (!auth) {
-    return
-  }
-
-  try {
-    const internal = getInternalClient(client)
-    if (internal) {
-      const injectedHeaders = tryInjectViaSetConfigHeaders(internal, auth)
-      const injectedInterceptors = tryInjectViaInterceptors(internal, auth)
-      const injectedFetch = tryInjectViaFetchWrapper(internal, auth)
-      const injectedMutable = tryInjectViaMutableInternalConfig(internal, auth)
-
-      const injected = injectedHeaders || injectedInterceptors || injectedFetch || injectedMutable
-
-      if (!injected) {
-        log("[opencode-server-auth] OPENCODE_SERVER_PASSWORD is set but SDK client structure is incompatible", {
-          keys: Object.keys(internal),
-        })
-      }
-      return
-    }
-
-    const injected = tryInjectViaTopLevelFetch(client, auth)
-    if (!injected) {
-      log("[opencode-server-auth] OPENCODE_SERVER_PASSWORD is set but no compatible SDK client found")
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    log("[opencode-server-auth] Failed to inject server auth", { message })
-  }
-}

package/src/shared/opencode-storage-detection.ts

@@ -1,34 +0,0 @@
-import { existsSync } from "node:fs"
-import { join } from "node:path"
-import { getDataDir } from "./data-path"
-import { isOpenCodeVersionAtLeast, OPENCODE_SQLITE_VERSION } from "./opencode-version"
-
-const NOT_CACHED = Symbol("NOT_CACHED")
-const FALSE_PENDING_RETRY = Symbol("FALSE_PENDING_RETRY")
-let cachedResult: true | false | typeof NOT_CACHED | typeof FALSE_PENDING_RETRY = NOT_CACHED
-
-export function isSqliteBackend(): boolean {
-  if (cachedResult === true) return true
-  if (cachedResult === false) return false
-
-  const check = (): boolean => {
-    const versionOk = isOpenCodeVersionAtLeast(OPENCODE_SQLITE_VERSION)
-    const dbPath = join(getDataDir(), "opencode", "opencode.db")
-    return versionOk && existsSync(dbPath)
-  }
-
-  if (cachedResult === FALSE_PENDING_RETRY) {
-    const result = check()
-    cachedResult = result
-    return result
-  }
-
-  const result = check()
-  if (result) { cachedResult = true }
-  else { cachedResult = FALSE_PENDING_RETRY }
-  return result
-}
-
-export function resetSqliteBackendCache(): void {
-  cachedResult = NOT_CACHED
-}

package/src/shared/opencode-storage-paths.ts

@@ -1,7 +0,0 @@
-import { join } from "node:path"
-import { getOpenCodeStorageDir } from "./data-path"
-
-export const OPENCODE_STORAGE = getOpenCodeStorageDir()
-export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
-export const PART_STORAGE = join(OPENCODE_STORAGE, "part")
-export const SESSION_STORAGE = join(OPENCODE_STORAGE, "session")

package/src/shared/opencode-version.ts

@@ -1,80 +0,0 @@
-import { execSync } from "child_process"
-
-/**
- * Minimum OpenCode version required for this plugin.
- * This plugin only supports OpenCode 1.1.1+ which uses the permission system.
- */
-export const MINIMUM_OPENCODE_VERSION = "1.1.1"
-
-/**
- * OpenCode version that introduced native AGENTS.md injection.
- * PR #10678 merged on Jan 26, 2026 - OpenCode now dynamically resolves
- * AGENTS.md files from subdirectories as the agent explores them.
- * When this version is detected, the directory-agents-injector hook
- * is auto-disabled to prevent duplicate AGENTS.md loading.
- */
-export const OPENCODE_NATIVE_AGENTS_INJECTION_VERSION = "1.1.37"
-
-/**
- * OpenCode version that introduced SQLite backend for storage.
- * When this version is detected AND opencode.db exists, SQLite backend is used.
- */
-export const OPENCODE_SQLITE_VERSION = "1.1.53"
-
-const NOT_CACHED = Symbol("NOT_CACHED")
-let cachedVersion: string | null | typeof NOT_CACHED = NOT_CACHED
-
-export function parseVersion(version: string): number[] {
-  const cleaned = version.replace(/^v/, "").split("-")[0]
-  return cleaned.split(".").map((n) => parseInt(n, 10) || 0)
-}
-
-export function compareVersions(a: string, b: string): -1 | 0 | 1 {
-  const partsA = parseVersion(a)
-  const partsB = parseVersion(b)
-  const maxLen = Math.max(partsA.length, partsB.length)
-
-  for (let i = 0; i < maxLen; i++) {
-    const numA = partsA[i] ?? 0
-    const numB = partsB[i] ?? 0
-    if (numA < numB) return -1
-    if (numA > numB) return 1
-  }
-  return 0
-}
-
-
-export function getOpenCodeVersion(): string | null {
-  if (cachedVersion !== NOT_CACHED) {
-    return cachedVersion
-  }
-
-  try {
-    const result = execSync("opencode --version", {
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim()
-
-    const versionMatch = result.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/)
-    cachedVersion = versionMatch?.[1] ?? null
-    return cachedVersion
-  } catch {
-    cachedVersion = null
-    return null
-  }
-}
-
-export function isOpenCodeVersionAtLeast(version: string): boolean {
-  const current = getOpenCodeVersion()
-  if (!current) return true
-  return compareVersions(current, version) >= 0
-}
-
-export function resetVersionCache(): void {
-  cachedVersion = NOT_CACHED
-}
-
-export function setVersionCache(version: string | null): void {
-  cachedVersion = version
-}

package/src/shared/parse-tools-config.ts

@@ -1,25 +0,0 @@
-/**
- * Parses a tools configuration value into a boolean record.
- * Accepts comma-separated strings, string arrays, or unknown values from config files.
- * Returns undefined when input is empty or invalid.
- */
-export function parseToolsConfig(toolsValue: unknown): Record<string, boolean> | undefined {
-  if (!toolsValue) return undefined
-
-  let items: string[]
-  if (typeof toolsValue === "string") {
-    items = toolsValue.split(",").map((t) => t.trim()).filter(Boolean)
-  } else if (Array.isArray(toolsValue)) {
-    items = toolsValue.filter((t) => typeof t === "string" && t.trim().length > 0).map((t) => (t as string).trim())
-  } else {
-    return undefined
-  }
-
-  if (items.length === 0) return undefined
-
-  const result: Record<string, boolean> = {}
-  for (const tool of items) {
-    result[tool.toLowerCase()] = true
-  }
-  return result
-}

package/src/shared/pattern-matcher.ts

@@ -1,46 +0,0 @@
-import type { ClaudeHooksConfig, HookMatcher } from "../hooks/claude-code-hooks/types"
-
-/**
- * Escape all regex special characters EXCEPT asterisk (*).
- * Asterisk is preserved for glob-to-regex conversion.
- */
-function escapeRegexExceptAsterisk(str: string): string {
-  // Escape all regex special chars except * (which we convert to .* for glob matching)
-  return str.replace(/[.+?^${}()|[\]\\]/g, "\\$&")
-}
-
-const regexCache = new Map<string, RegExp>()
-
-export function matchesToolMatcher(toolName: string, matcher: string): boolean {
-  if (!matcher) {
-    return true
-  }
-  const patterns = matcher.split("|").map((p) => p.trim())
-  return patterns.some((p) => {
-    if (p.includes("*")) {
-      // First escape regex special chars (except *), then convert * to .*
-      let regex = regexCache.get(p)
-      if (!regex) {
-        const escaped = escapeRegexExceptAsterisk(p)
-        regex = new RegExp(`^${escaped.replace(/\*/g, ".*")}$`, "i")
-        regexCache.set(p, regex)
-      }
-      return regex.test(toolName)
-    }
-    return p.toLowerCase() === toolName.toLowerCase()
-  })
-}
-
-export function findMatchingHooks(
-  config: ClaudeHooksConfig,
-  eventName: keyof ClaudeHooksConfig,
-  toolName?: string
-): HookMatcher[] {
-  const hookMatchers = config[eventName]
-  if (!hookMatchers) return []
-
-  return hookMatchers.filter((hookMatcher) => {
-    if (!toolName) return true
-    return matchesToolMatcher(toolName, hookMatcher.matcher)
-  })
-}

package/src/shared/permission-compat.ts

@@ -1,86 +0,0 @@
-/**
- * Permission system utilities for OpenCode 1.1.1+.
- * This module only supports the new permission format.
- */
-
-export type PermissionValue = "ask" | "allow" | "deny"
-
-export interface PermissionFormat {
-  permission: Record<string, PermissionValue>
-}
-
-/**
- * Creates tool restrictions that deny specified tools.
- */
-export function createAgentToolRestrictions(
-  denyTools: string[]
-): PermissionFormat {
-  return {
-    permission: Object.fromEntries(
-      denyTools.map((tool) => [tool, "deny" as const])
-    ),
-  }
-}
-
-/**
- * Creates tool restrictions that ONLY allow specified tools.
- * All other tools are denied by default using `*: deny` pattern.
- */
-export function createAgentToolAllowlist(
-  allowTools: string[]
-): PermissionFormat {
-  return {
-    permission: {
-      "*": "deny" as const,
-      ...Object.fromEntries(
-        allowTools.map((tool) => [tool, "allow" as const])
-      ),
-    },
-  }
-}
-
-/**
- * Converts legacy tools format to permission format.
- * For migrating user configs from older versions.
- */
-export function migrateToolsToPermission(
-  tools: Record<string, boolean>
-): Record<string, PermissionValue> {
-  return Object.fromEntries(
-    Object.entries(tools).map(([key, value]) => [
-      key,
-      value ? ("allow" as const) : ("deny" as const),
-    ])
-  )
-}
-
-/**
- * Migrates agent config from legacy tools format to permission format.
- * If config has `tools`, converts to `permission`.
- */
-export function migrateAgentConfig(
-  config: Record<string, unknown>
-): Record<string, unknown> {
-  const result = { ...config }
-
-  if (result.tools && typeof result.tools === "object") {
-    const existingPermission =
-      (result.permission as Record<string, PermissionValue>) || {}
-    const migratedPermission = migrateToolsToPermission(
-      result.tools as Record<string, boolean>
-    )
-    result.permission = { ...migratedPermission, ...existingPermission }
-    delete result.tools
-  }
-
-  if (result.permission && typeof result.permission === "object") {
-    const perm = { ...(result.permission as Record<string, PermissionValue>) }
-    if ("delegate_task" in perm && !("task" in perm)) {
-      perm["task"] = perm["delegate_task"]
-      delete perm["delegate_task"]
-      result.permission = perm
-    }
-  }
-
-  return result
-}

package/src/shared/plugin-command-discovery.ts

@@ -1,28 +0,0 @@
-import {
-  discoverInstalledPlugins,
-  loadPluginCommands,
-  loadPluginSkillsAsCommands,
-} from "../features/claude-code-plugin-loader"
-import type { CommandDefinition } from "../features/claude-code-command-loader/types"
-
-export interface PluginCommandDiscoveryOptions {
-  pluginsEnabled?: boolean
-  enabledPluginsOverride?: Record<string, boolean>
-}
-
-export function discoverPluginCommandDefinitions(
-  options?: PluginCommandDiscoveryOptions,
-): Record<string, CommandDefinition> {
-  if (options?.pluginsEnabled === false) {
-    return {}
-  }
-
-  const { plugins } = discoverInstalledPlugins({
-    enabledPluginsOverride: options?.enabledPluginsOverride,
-  })
-
-  return {
-    ...loadPluginCommands(plugins),
-    ...loadPluginSkillsAsCommands(plugins),
-  }
-}

package/src/shared/plugin-entry-migrator.ts

@@ -1,21 +0,0 @@
-import { LEGACY_PLUGIN_NAME, PLUGIN_NAME } from "./plugin-identity"
-
-export function isLegacyEntry(entry: string): boolean {
-  return entry === LEGACY_PLUGIN_NAME || entry.startsWith(`${LEGACY_PLUGIN_NAME}@`)
-}
-
-export function isCanonicalEntry(entry: string): boolean {
-  return entry === PLUGIN_NAME || entry.startsWith(`${PLUGIN_NAME}@`)
-}
-
-export function toCanonicalEntry(entry: string): string {
-  if (entry === LEGACY_PLUGIN_NAME) {
-    return PLUGIN_NAME
-  }
-
-  if (entry.startsWith(`${LEGACY_PLUGIN_NAME}@`)) {
-    return `${PLUGIN_NAME}${entry.slice(LEGACY_PLUGIN_NAME.length)}`
-  }
-
-  return entry
-}