@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

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

@@ -1,135 +0,0 @@
-import { existsSync, realpathSync } from "node:fs"
-import { homedir } from "node:os"
-import { join, resolve, win32 } from "node:path"
-
-import { CONFIG_BASENAME } from "./plugin-identity"
-
-import type {
-  OpenCodeBinaryType,
-  OpenCodeConfigDirOptions,
-  OpenCodeConfigPaths,
-} from "./opencode-config-dir-types"
-
-export type {
-  OpenCodeBinaryType,
-  OpenCodeConfigDirOptions,
-  OpenCodeConfigPaths,
-} from "./opencode-config-dir-types"
-
-export const TAURI_APP_IDENTIFIER = "ai.opencode.desktop"
-export const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev"
-
-export function isDevBuild(version: string | null | undefined): boolean {
-  if (!version) return false
-  return version.includes("-dev") || version.includes(".dev")
-}
-
-function getTauriConfigDir(identifier: string): string {
-  const platform = process.platform
-
-  switch (platform) {
-    case "darwin":
-      return join(homedir(), "Library", "Application Support", identifier)
-
-    case "win32": {
-      const appData = process.env.APPDATA || join(homedir(), "AppData", "Roaming")
-      return win32.join(appData, identifier)
-    }
-
-    case "linux":
-    default: {
-      const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
-      return join(xdgConfig, identifier)
-    }
-  }
-}
-
-function resolveConfigPath(pathValue: string): string {
-  const resolvedPath = resolve(pathValue)
-  if (!existsSync(resolvedPath)) return resolvedPath
-
-  try {
-    return realpathSync(resolvedPath)
-  } catch {
-    return resolvedPath
-  }
-}
-
-function getCliConfigDir(): string {
-  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim()
-  if (envConfigDir) {
-    return resolveConfigPath(envConfigDir)
-  }
-
-  const xdgConfig = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
-  return resolveConfigPath(join(xdgConfig, "opencode"))
-}
-
-export function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string {
-  const { binary, version, checkExisting = true } = options
-
-  if (binary === "opencode") {
-    return getCliConfigDir()
-  }
-
-  const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER
-  const tauriDirBase = getTauriConfigDir(identifier)
-  const tauriDir = process.platform === "win32"
-    ? (win32.isAbsolute(tauriDirBase) ? win32.normalize(tauriDirBase) : win32.resolve(tauriDirBase))
-    : resolveConfigPath(tauriDirBase)
-
-  if (checkExisting) {
-    const legacyDir = getCliConfigDir()
-    const legacyConfig = join(legacyDir, "opencode.json")
-    const legacyConfigC = join(legacyDir, "opencode.jsonc")
-
-    if (existsSync(legacyConfig) || existsSync(legacyConfigC)) {
-      return legacyDir
-    }
-  }
-
-  return tauriDir
-}
-
-export function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths {
-  const configDir = getOpenCodeConfigDir(options)
-
-  return {
-    configDir,
-    configJson: join(configDir, "opencode.json"),
-    configJsonc: join(configDir, "opencode.jsonc"),
-    packageJson: join(configDir, "package.json"),
-    omoConfig: join(configDir, `${CONFIG_BASENAME}.json`),
-  }
-}
-
-export function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null {
-  const locations: string[] = []
-
-  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim()
-  if (envConfigDir) {
-    locations.push(resolveConfigPath(envConfigDir))
-  }
-
-  if (binary === "opencode-desktop") {
-    const identifier = isDevBuild(version) ? TAURI_APP_IDENTIFIER_DEV : TAURI_APP_IDENTIFIER
-    locations.push(getTauriConfigDir(identifier))
-
-    if (isDevBuild(version)) {
-      locations.push(getTauriConfigDir(TAURI_APP_IDENTIFIER))
-    }
-  }
-
-  locations.push(getCliConfigDir())
-
-  for (const dir of locations) {
-    const configJson = join(dir, "opencode.json")
-    const configJsonc = join(dir, "opencode.jsonc")
-
-    if (existsSync(configJson) || existsSync(configJsonc)) {
-      return dir
-    }
-  }
-
-  return null
-}

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