@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

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

package/src/shared/plugin-identity.ts

@@ -1,8 +0,0 @@
-export const PLUGIN_NAME = "@hiai-gg/hiai-opencode"
-export const LEGACY_PLUGIN_NAME = "hiai-opencode"
-export const PUBLISHED_PACKAGE_NAME = PLUGIN_NAME
-export const ACCEPTED_PACKAGE_NAMES = [PUBLISHED_PACKAGE_NAME, PLUGIN_NAME] as const
-export const CONFIG_BASENAME = "hiai-opencode"
-export const LEGACY_CONFIG_BASENAME = "hiai-opencode"
-export const LOG_FILENAME = "hiai-opencode.log"
-export const CACHE_DIR_NAME = "hiai-opencode"

package/src/shared/port-utils.ts

@@ -1,48 +0,0 @@
-const DEFAULT_SERVER_PORT = 4096
-const MAX_PORT_ATTEMPTS = 20
-
-export async function isPortAvailable(port: number, hostname: string = "127.0.0.1"): Promise<boolean> {
-  try {
-    const server = Bun.serve({
-      port,
-      hostname,
-      fetch: () => new Response(),
-    })
-    server.stop(true)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export async function findAvailablePort(
-  startPort: number = DEFAULT_SERVER_PORT,
-  hostname: string = "127.0.0.1"
-): Promise<number> {
-  for (let attempt = 0; attempt < MAX_PORT_ATTEMPTS; attempt++) {
-    const port = startPort + attempt
-    if (await isPortAvailable(port, hostname)) {
-      return port
-    }
-  }
-  throw new Error(`No available port found in range ${startPort}-${startPort + MAX_PORT_ATTEMPTS - 1}`)
-}
-
-export interface AutoPortResult {
-  port: number
-  wasAutoSelected: boolean
-}
-
-export async function getAvailableServerPort(
-  preferredPort: number = DEFAULT_SERVER_PORT,
-  hostname: string = "127.0.0.1"
-): Promise<AutoPortResult> {
-  if (await isPortAvailable(preferredPort, hostname)) {
-    return { port: preferredPort, wasAutoSelected: false }
-  }
-
-  const port = await findAvailablePort(preferredPort + 1, hostname)
-  return { port, wasAutoSelected: true }
-}
-
-export { DEFAULT_SERVER_PORT }

package/src/shared/project-discovery-dirs.ts

@@ -1,101 +0,0 @@
-import { execFileSync } from "node:child_process"
-import { existsSync, realpathSync } from "node:fs"
-import { dirname, join, resolve } from "node:path"
-
-function normalizePath(path: string): string {
-  const resolvedPath = resolve(path)
-  if (!existsSync(resolvedPath)) {
-    return resolvedPath
-  }
-
-  try {
-    return realpathSync(resolvedPath)
-  } catch {
-    return resolvedPath
-  }
-}
-
-function findAncestorDirectories(
-  startDirectory: string,
-  targetPaths: ReadonlyArray<ReadonlyArray<string>>,
-  stopDirectory?: string,
-): string[] {
-  const directories: string[] = []
-  const seen = new Set<string>()
-  let currentDirectory = normalizePath(startDirectory)
-  const resolvedStopDirectory = stopDirectory ? normalizePath(stopDirectory) : undefined
-
-  while (true) {
-    for (const targetPath of targetPaths) {
-      const candidateDirectory = join(currentDirectory, ...targetPath)
-      if (!existsSync(candidateDirectory) || seen.has(candidateDirectory)) {
-        continue
-      }
-
-      seen.add(candidateDirectory)
-      directories.push(candidateDirectory)
-    }
-
-    if (resolvedStopDirectory === currentDirectory) {
-      return directories
-    }
-
-    const parentDirectory = dirname(currentDirectory)
-    if (parentDirectory === currentDirectory) {
-      return directories
-    }
-
-    currentDirectory = normalizePath(parentDirectory)
-  }
-}
-
-function detectWorktreePath(directory: string): string | undefined {
-  try {
-    return execFileSync("git", ["rev-parse", "--show-toplevel"], {
-      cwd: directory,
-      encoding: "utf-8",
-      timeout: 5000,
-      stdio: ["pipe", "pipe", "pipe"],
-    }).trim()
-  } catch {
-    return undefined
-  }
-}
-
-export function findProjectClaudeSkillDirs(startDirectory: string, stopDirectory?: string): string[] {
-  return findAncestorDirectories(
-    startDirectory,
-    [[".claude", "skills"]],
-    stopDirectory ?? detectWorktreePath(startDirectory),
-  )
-}
-
-export function findProjectAgentsSkillDirs(startDirectory: string, stopDirectory?: string): string[] {
-  return findAncestorDirectories(
-    startDirectory,
-    [[".agents", "skills"]],
-    stopDirectory ?? detectWorktreePath(startDirectory),
-  )
-}
-
-export function findProjectOpencodeSkillDirs(startDirectory: string, stopDirectory?: string): string[] {
-  return findAncestorDirectories(
-    startDirectory,
-    [
-      [".opencode", "skills"],
-      [".opencode", "skill"],
-    ],
-    stopDirectory ?? detectWorktreePath(startDirectory),
-  )
-}
-
-export function findProjectOpencodeCommandDirs(startDirectory: string, stopDirectory?: string): string[] {
-  return findAncestorDirectories(
-    startDirectory,
-    [
-      [".opencode", "commands"],
-      [".opencode", "command"],
-    ],
-    stopDirectory ?? detectWorktreePath(startDirectory),
-  )
-}

package/src/shared/prompt-timeout-context.ts

@@ -1,49 +0,0 @@
-export interface PromptTimeoutArgs {
-  signal?: AbortSignal
-}
-
-export interface PromptRetryOptions {
-  timeoutMs?: number
-}
-
-export const PROMPT_TIMEOUT_MS = 120000
-
-export function createPromptTimeoutContext(args: PromptTimeoutArgs, timeoutMs: number): {
-  signal: AbortSignal
-  wasTimedOut: () => boolean
-  cleanup: () => void
-} {
-  const timeoutController = new AbortController()
-  let timeoutID: ReturnType<typeof setTimeout> | null = null
-  let timedOut = false
-
-  const abortOnUpstreamSignal = (): void => {
-    timeoutController.abort(args.signal?.reason)
-  }
-
-  if (args.signal) {
-    if (args.signal.aborted) {
-      timeoutController.abort(args.signal.reason)
-    } else {
-      args.signal.addEventListener("abort", abortOnUpstreamSignal, { once: true })
-    }
-  }
-
-  timeoutID = setTimeout(() => {
-    timedOut = true
-    timeoutController.abort(new Error(`prompt timed out after ${timeoutMs}ms`))
-  }, timeoutMs)
-
-  return {
-    signal: timeoutController.signal,
-    wasTimedOut: () => timedOut,
-    cleanup: () => {
-      if (timeoutID !== null) {
-        clearTimeout(timeoutID)
-      }
-      if (args.signal) {
-        args.signal.removeEventListener("abort", abortOnUpstreamSignal)
-      }
-    },
-  }
-}

package/src/shared/prompt-tools.ts

@@ -1,35 +0,0 @@
-import { getSessionTools } from "./session-tools-store"
-
-export type PromptToolPermission = boolean | "allow" | "deny" | "ask"
-
-export function normalizePromptTools(
-  tools: Record<string, PromptToolPermission> | undefined
-): Record<string, boolean> | undefined {
-  if (!tools) {
-    return undefined
-  }
-
-  const normalized: Record<string, boolean> = {}
-  for (const [toolName, permission] of Object.entries(tools)) {
-    if (permission === false || permission === "deny") {
-      normalized[toolName] = false
-      continue
-    }
-    if (permission === true || permission === "allow" || permission === "ask") {
-      normalized[toolName] = true
-    }
-  }
-
-  return Object.keys(normalized).length > 0 ? normalized : undefined
-}
-
-export function resolveInheritedPromptTools(
-  sessionID: string,
-  fallbackTools?: Record<string, PromptToolPermission>
-): Record<string, boolean> | undefined {
-  const sessionTools = getSessionTools(sessionID)
-  if (sessionTools && Object.keys(sessionTools).length > 0) {
-    return { ...sessionTools }
-  }
-  return normalizePromptTools(fallbackTools)
-}

package/src/shared/provider-model-id-transform.ts

@@ -1,58 +0,0 @@
-function inferSubProvider(model: string): string | undefined {
-	if (model.startsWith("claude-")) return "anthropic"
-	if (model.startsWith("gpt-")) return "openai"
-	if (model.startsWith("gemini-")) return "google"
-	if (model.startsWith("grok-")) return "xai"
-	if (model.startsWith("minimax-")) return "minimax"
-	if (model.startsWith("kimi-")) return "moonshotai"
-	if (model.startsWith("glm-")) return "zai"
-	return undefined
-}
-
-const CLAUDE_VERSION_DOT = /claude-(\w+)-(\d+)-(\d+)/g
-const GEMINI_31_PRO_PREVIEW = /gemini-3\.1-pro(?!-)/g
-const GEMINI_3_FLASH_PREVIEW = /gemini-3-flash(?!-)/g
-
-function claudeVersionDot(model: string): string {
-	return model.replace(CLAUDE_VERSION_DOT, "claude-$1-$2.$3")
-}
-
-function applyGatewayTransforms(model: string): string {
-	return claudeVersionDot(model)
-		.replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview")
-}
-
-export function transformModelForProvider(provider: string, model: string): string {
-	// Vercel AI Gateway expects <sub-provider>/<model> (e.g. anthropic/claude-opus-4.6).
-	// Canonical names in model-requirements.ts may be bare (claude-opus-4-6) or
-	// already prefixed (anthropic/claude-opus-4-6). Both need gateway-specific transforms.
-	if (provider === "vercel") {
-		// Already prefixed — transform only the model part
-		const slashIndex = model.indexOf("/")
-		if (slashIndex !== -1) {
-			const subProvider = model.substring(0, slashIndex)
-			const subModel = model.substring(slashIndex + 1)
-			return `${subProvider}/${applyGatewayTransforms(subModel)}`
-		}
-		// Bare name — infer sub-provider from model prefix (claude- → anthropic, etc.)
-		const subProvider = inferSubProvider(model)
-		if (subProvider) {
-			return `${subProvider}/${applyGatewayTransforms(model)}`
-		}
-		return model
-	}
-	if (provider === "github-copilot") {
-		return claudeVersionDot(model)
-			.replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview")
-			.replace(GEMINI_3_FLASH_PREVIEW, "gemini-3-flash-preview")
-	}
-	if (provider === "google") {
-		return model
-			.replace(GEMINI_31_PRO_PREVIEW, "gemini-3.1-pro-preview")
-			.replace(GEMINI_3_FLASH_PREVIEW, "gemini-3-flash-preview")
-	}
-	if (provider === "anthropic") {
-		return claudeVersionDot(model)
-	}
-	return model
-}

package/src/shared/question-denied-session-permission.ts

@@ -1,9 +0,0 @@
-export type SessionPermissionRule = {
-  permission: string
-  action: "allow" | "deny"
-  pattern: string
-}
-
-export const QUESTION_DENIED_SESSION_PERMISSION: SessionPermissionRule[] = [
-  { permission: "question", action: "deny", pattern: "*" },
-]

package/src/shared/record-type-guard.ts

@@ -1,3 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null
-}

package/src/shared/resolve-agent-definition-paths.ts

@@ -1,22 +0,0 @@
-import { homedir } from "os"
-import { isAbsolute, resolve } from "path"
-import { isWithinProject } from "./contains-path"
-import { log } from "./logger"
-
-export function resolveAgentDefinitionPaths(
-  paths: string[],
-  baseDir: string,
-  containmentDir: string | null
-): string[] {
-  return paths.flatMap((p) => {
-    const expanded = p.startsWith("~/") ? p.replace(/^~\//, `${homedir()}/`) : p
-    const resolved = isAbsolute(expanded) ? expanded : resolve(baseDir, expanded)
-
-    if (containmentDir !== null && !isWithinProject(resolved, containmentDir)) {
-      log(`agent_definitions path rejected (outside project boundary): ${p} -> ${resolved}`)
-      return []
-    }
-
-    return [resolved]
-  })
-}

package/src/shared/retry-status-utils.ts

@@ -1,19 +0,0 @@
-export function normalizeRetryStatusMessage(message: string): string {
-  return message
-    .replace(/\[retrying in [^\]]*attempt\s*#\d+\]/gi, "[retrying]")
-    .replace(/retrying in\s+[^(]*attempt\s*#\d+/gi, "retrying")
-    .replace(/\s+/g, " ")
-    .trim()
-    .toLowerCase()
-}
-
-export function extractRetryAttempt(statusAttempt: unknown, message: string): string {
-  if (typeof statusAttempt === "number" && Number.isFinite(statusAttempt)) {
-    return String(statusAttempt)
-  }
-  const attemptMatch = message.match(/attempt\s*#\s*(\d+)/i)
-  if (attemptMatch?.[1]) {
-    return attemptMatch[1]
-  }
-  return "?"
-}

package/src/shared/runtime-plugin-config.ts

@@ -1,98 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config"
-import type {
-  CategoryConfig as PlatformCategoryConfig,
-  HiaiOpencodeConfig,
-  LspServerConfig,
-  McpServerConfig,
-} from "../config"
-
-type RuntimePluginConfig = HiaiOpenCodeConfig & {
-  __platformDefaults?: HiaiOpencodeConfig
-}
-
-function mergeRecords<T extends Record<string, unknown>>(
-  base: T | undefined,
-  override: T | undefined,
-): T | undefined {
-  if (!base && !override) return undefined
-  return {
-    ...(base ?? {}),
-    ...(override ?? {}),
-  } as T
-}
-
-function toRuntimeCategory(
-  category: PlatformCategoryConfig,
-): Record<string, unknown> {
-  return {
-    description: category.description,
-    model: category.model,
-    variant: category.variant,
-  }
-}
-
-function hydrateAgentDefaults(
-  pluginConfig: HiaiOpenCodeConfig,
-  platformDefaults: HiaiOpencodeConfig,
-): HiaiOpenCodeConfig["agents"] {
-  const platformAgents = Object.fromEntries(
-    Object.entries(platformDefaults.agents ?? {}).map(([name, config]) => [
-      name,
-      {
-        model: config.model,
-        description: config.description,
-      },
-    ]),
-  )
-
-  return mergeRecords(
-    platformAgents as HiaiOpenCodeConfig["agents"],
-    pluginConfig.agents,
-  )
-}
-
-function hydrateCategoryDefaults(
-  pluginConfig: HiaiOpenCodeConfig,
-  platformDefaults: HiaiOpencodeConfig,
-): HiaiOpenCodeConfig["categories"] {
-  const platformCategories = Object.fromEntries(
-    Object.entries(platformDefaults.categories ?? {}).map(([name, config]) => [
-      name,
-      toRuntimeCategory(config),
-    ]),
-  )
-
-  return mergeRecords(
-    platformCategories as HiaiOpenCodeConfig["categories"],
-    pluginConfig.categories,
-  )
-}
-
-export function hydratePluginConfigWithPlatformDefaults(
-  pluginConfig: HiaiOpenCodeConfig,
-  platformDefaults: HiaiOpencodeConfig,
-): RuntimePluginConfig {
-  return {
-    ...pluginConfig,
-    agents: hydrateAgentDefaults(pluginConfig, platformDefaults),
-    categories: hydrateCategoryDefaults(pluginConfig, platformDefaults),
-    __platformDefaults: {
-      ...platformDefaults,
-      mcp: { ...(platformDefaults.mcp ?? {}) } as Record<string, McpServerConfig>,
-    },
-  }
-}
-
-export function getPlatformMcpDefaults(
-  pluginConfig: HiaiOpenCodeConfig,
-): Record<string, McpServerConfig> {
-  return ((pluginConfig as RuntimePluginConfig).__platformDefaults?.mcp ??
-    {}) as Record<string, McpServerConfig>
-}
-
-export function getPlatformLspDefaults(
-  pluginConfig: HiaiOpenCodeConfig,
-): Record<string, LspServerConfig> {
-  return ((pluginConfig as RuntimePluginConfig).__platformDefaults?.lsp ??
-    {}) as Record<string, LspServerConfig>
-}

package/src/shared/safe-create-hook.ts

@@ -1,24 +0,0 @@
-import { log } from "./logger"
-
-interface SafeCreateHookOptions {
-  enabled?: boolean
-}
-
-export function safeCreateHook<T>(
-  name: string,
-  factory: () => T,
-  options?: SafeCreateHookOptions,
-): T | null {
-  const enabled = options?.enabled ?? true
-
-  if (!enabled) {
-    return factory() ?? null
-  }
-
-  try {
-    return factory() ?? null
-  } catch (error) {
-    log(`[safe-create-hook] Hook creation failed: ${name}`, { error })
-    return null
-  }
-}

package/src/shared/session-category-registry.ts

@@ -1,27 +0,0 @@
-const sessionCategoryMap = new Map<string, string>()
-
-export const SessionCategoryRegistry = {
-  register: (sessionID: string, category: string): void => {
-    sessionCategoryMap.set(sessionID, category)
-  },
-
-  get: (sessionID: string): string | undefined => {
-    return sessionCategoryMap.get(sessionID)
-  },
-
-  remove: (sessionID: string): void => {
-    sessionCategoryMap.delete(sessionID)
-  },
-
-  has: (sessionID: string): boolean => {
-    return sessionCategoryMap.has(sessionID)
-  },
-
-  size: (): number => {
-    return sessionCategoryMap.size
-  },
-
-  clear: (): void => {
-    sessionCategoryMap.clear()
-  },
-}