@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/shared/agent-display-names.ts

@@ -1,187 +0,0 @@
-import { AGENT_NAME_MAP } from "./migration/agent-names"
-
-/**
- * Agent config keys to display names mapping.
- * Config keys are lowercase (e.g., "bob", "guard").
- * Display names include suffixes for UI/logs (e.g., "Bob - Ultraworker").
- *
- * IMPORTANT: Display names MUST NOT contain parentheses or other characters
- * that are invalid in HTTP header values per RFC 7230. OpenCode passes the
- * agent name in the `x-opencode-agent-name` header, and parentheses cause
- * header validation failures that prevent agents from appearing in the UI
- * type selector dropdown. Use ` - ` (space-dash-space) instead of `(...)`.
- */
-export const AGENT_DISPLAY_NAMES: Record<string, string> = {
-  "bob": "Bob",
-  "coder": "Coder",
-  "strategist": "Strategist",
-  "critic": "Critic",
-  "designer": "Designer",
-  "researcher": "Researcher",
-  "quality-guardian": "Quality Guardian",
-  "platform-manager": "Manager",
-  "brainstormer": "Brainstormer",
-  "agent-skills": "Agent Skills",
-  "guard": "Guard",
-  "sub": "Sub",
-  "multimodal": "Vision",
-  "ui": "Vision",
-}
-
-const AGENT_LIST_SORT_PREFIXES: Record<string, string> = {}
-
-const INVISIBLE_AGENT_CHARACTERS_REGEX = /[\u200B\u200C\u200D\uFEFF]/g
-
-export function stripInvisibleAgentCharacters(agentName: string): string {
-  return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "")
-}
-
-export function stripAgentListSortPrefix(agentName: string): string {
-  return stripInvisibleAgentCharacters(agentName)
-}
-
-export function getAgentRuntimeName(configKey: string): string {
-  const canonicalKey = resolveKnownAgentConfigKey(configKey) ?? configKey
-  const displayName = getAgentDisplayName(canonicalKey)
-  const prefix = AGENT_LIST_SORT_PREFIXES[canonicalKey.toLowerCase()]
-
-  return prefix ? `${prefix}${displayName}` : displayName
-}
-
-/**
- * Get display name for an agent config key.
- * Uses case-insensitive lookup for backward compatibility.
- * Returns original key if not found.
- */
-export function getAgentDisplayName(configKey: string): string {
-  const resolvedConfigKey = resolveKnownAgentConfigKey(configKey)
-  if (resolvedConfigKey !== undefined) {
-    const resolvedDisplayName = AGENT_DISPLAY_NAMES[resolvedConfigKey]
-    if (resolvedDisplayName !== undefined) return resolvedDisplayName
-  }
-
-  // Try exact match first
-  const exactMatch = AGENT_DISPLAY_NAMES[configKey]
-  if (exactMatch !== undefined) return exactMatch
-  
-  // Fall back to case-insensitive search
-  const lowerKey = configKey.toLowerCase()
-  for (const [k, v] of Object.entries(AGENT_DISPLAY_NAMES)) {
-    if (k.toLowerCase() === lowerKey) return v
-  }
-  
-  // Unknown agent: return original key
-  return configKey
-}
-
-/**
- * Runtime-facing agent name used for OpenCode list ordering.
- */
-export function getAgentListDisplayName(configKey: string): string {
-  return getAgentRuntimeName(configKey)
-}
-
-const REVERSE_DISPLAY_NAMES: Record<string, string> = Object.fromEntries(
-  Object.entries(AGENT_DISPLAY_NAMES).map(([key, displayName]) => [displayName.toLowerCase(), key]),
-)
-
-// Legacy parenthesized display names for backward compatibility.
-// Old configs/sessions may reference these names; resolve them to config keys.
-const LEGACY_DISPLAY_NAMES: Record<string, string> = {
-  "bob (ultraworker)": "bob",
-  "bob - ultraworker": "bob",
-  "coder (deep agent)": "coder",
-  "coder - deep agent": "coder",
-  "strategist (plan builder)": "strategist",
-  "strategist - plan builder": "strategist",
-  "guard (plan executor)": "guard",
-  "guard - plan executor": "guard",
-  "pre-plan (plan consultant)": "strategist",
-  "critic (plan critic)": "critic",
-  "critic - plan critic": "critic",
-  "designer": "designer",
-  "athena (council)": "strategist",
-  "athena-junior (council)": "strategist",
-  "researcher (codebase explorer)": "researcher",
-  "researcher - codebase explorer": "researcher",
-  "quality guardian (verifier)": "quality-guardian",
-  "quality guardian - verifier": "quality-guardian",
-  "manager": "platform-manager",
-  "platform manager (utility)": "platform-manager",
-  "platform manager - utility": "platform-manager",
-  "brainstormer - idea explorer": "brainstormer",
-  "writer": "brainstormer",
-  "copywriter": "brainstormer",
-  "content-writer": "brainstormer",
-  "content writer": "brainstormer",
-  "website-writer": "brainstormer",
-  "agent skills - skill composer": "agent-skills",
-  "subagent": "sub",
-  "ui": "multimodal",
-  "vision": "multimodal",
-  "ui - multimodal": "multimodal",
-}
-
-function resolveKnownAgentConfigKey(agentName: string): string | undefined {
-  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase()
-  if (!lower) return undefined
-
-  const reversed = REVERSE_DISPLAY_NAMES[lower]
-  if (reversed !== undefined) return reversed
-
-  const legacy = LEGACY_DISPLAY_NAMES[lower]
-  if (legacy !== undefined) return legacy
-
-  const migrated = AGENT_NAME_MAP[lower]
-  if (migrated !== undefined) return migrated
-
-  if (AGENT_DISPLAY_NAMES[lower] !== undefined) return lower
-
-  return undefined
-}
-
-/**
- * Resolve an agent name (display name or config key) to its lowercase config key.
- * "Guard - Plan Executor" -> "guard", "Guard (Plan Executor)" -> "guard", "guard" -> "guard"
- */
-export function getAgentConfigKey(agentName: string): string {
-  const lower = stripAgentListSortPrefix(agentName).trim().toLowerCase()
-  return resolveKnownAgentConfigKey(agentName) ?? lower
-}
-
-/**
- * Normalize an agent name for prompt APIs.
- * - Known display names -> canonical display names
- * - Known config keys (any case) -> canonical display names
- * - Unknown/custom names -> preserved as-is (trimmed)
- */
-export function normalizeAgentForPrompt(agentName: string | undefined): string | undefined {
-  if (typeof agentName !== "string") {
-    return undefined
-  }
-
-  const trimmed = stripAgentListSortPrefix(agentName).trim()
-  if (!trimmed) {
-    return undefined
-  }
-
-  const configKey = resolveKnownAgentConfigKey(trimmed)
-  if (configKey !== undefined) {
-    return AGENT_DISPLAY_NAMES[configKey] ?? trimmed
-  }
-
-  return trimmed
-}
-
-export function normalizeAgentForPromptKey(agentName: string | undefined): string | undefined {
-  if (typeof agentName !== "string") {
-    return undefined
-  }
-
-  const trimmed = stripAgentListSortPrefix(agentName).trim()
-  if (!trimmed) {
-    return undefined
-  }
-
-  return resolveKnownAgentConfigKey(trimmed) ?? trimmed
-}

package/src/shared/agent-tool-restrictions.ts

@@ -1,80 +0,0 @@
-import { getAgentConfigKey, stripInvisibleAgentCharacters } from "./agent-display-names"
-
-/**
- * Agent tool restrictions for session.prompt calls.
- * OpenCode SDK's session.prompt `tools` parameter expects boolean values.
- * true = tool allowed, false = tool denied.
- */
-
-const RESEARCHER_DENYLIST: Record<string, boolean> = {
-  write: false,
-  edit: false,
-  task: false,
-  call_omo_agent: false,
-}
-
-const CANONICAL_AGENT_RESTRICTIONS: Record<string, Record<string, boolean>> = {
-  researcher: RESEARCHER_DENYLIST,
-  critic: {
-    write: false,
-    edit: false,
-    task: false,
-  },
-  multimodal: {
-    read: true,
-  },
-  sub: {
-    task: false,
-  },
-}
-
-const LEGACY_AGENT_RESTRICTION_OVERRIDES: Record<string, Record<string, boolean>> = {
-  ui: CANONICAL_AGENT_RESTRICTIONS.multimodal,
-}
-
-const LEGACY_AGENT_ALIAS_TO_CANONICAL: Record<string, string> = {
-  ui: "multimodal",
-  "plan-consultant": "critic",
-}
-
-function toNormalizedAgentKey(agentName: string): string {
-  return stripInvisibleAgentCharacters(agentName).trim().toLowerCase()
-}
-
-function getRestrictionCandidates(agentName: string): string[] {
-  const direct = toNormalizedAgentKey(agentName)
-  const configKey = toNormalizedAgentKey(getAgentConfigKey(agentName))
-  return direct === configKey ? [direct] : [direct, configKey]
-}
-
-function resolveRestrictions(agentName: string): Record<string, boolean> | undefined {
-  const candidates = getRestrictionCandidates(agentName)
-
-  for (const candidate of candidates) {
-    const override = LEGACY_AGENT_RESTRICTION_OVERRIDES[candidate]
-    if (override) {
-      return override
-    }
-  }
-
-  for (const candidate of candidates) {
-    const canonicalKey = LEGACY_AGENT_ALIAS_TO_CANONICAL[candidate] ?? candidate
-    const canonical = CANONICAL_AGENT_RESTRICTIONS[canonicalKey]
-    if (canonical) {
-      return canonical
-    }
-  }
-
-  return undefined
-}
-
-export function getAgentToolRestrictions(agentName: string): Record<string, boolean> {
-  // Custom/unknown agents get no restrictions (empty object), matching Claude Code's
-  // trust model where project-registered agents retain full tool access including bash.
-  return resolveRestrictions(agentName) ?? {}
-}
-
-export function hasAgentToolRestrictions(agentName: string): boolean {
-  const restrictions = getAgentToolRestrictions(agentName)
-  return Object.keys(restrictions).length > 0
-}

package/src/shared/agent-variant.ts

@@ -1,101 +0,0 @@
-import type { HiaiOpenCodeConfig } from "../config"
-import { stripInvisibleAgentCharacters } from "./agent-display-names"
-import { AGENT_MODEL_REQUIREMENTS, CATEGORY_MODEL_REQUIREMENTS } from "./model-requirements"
-
-export function resolveAgentVariant(
-  config: HiaiOpenCodeConfig,
-  agentName?: string
-): string | undefined {
-  if (!agentName) {
-    return undefined
-  }
-
-  const stripped = stripInvisibleAgentCharacters(agentName)
-  const agentOverrides = config.agents as
-    | Record<string, { variant?: string; category?: string }>
-    | undefined
-  const agentOverride = agentOverrides
-    ? agentOverrides[stripped]
-      ?? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === stripped.toLowerCase())?.[1]
-    : undefined
-  if (!agentOverride) {
-    return undefined
-  }
-
-  if (agentOverride.variant) {
-    return agentOverride.variant
-  }
-
-  const categoryName = agentOverride.category
-  if (!categoryName) {
-    return undefined
-  }
-
-  return config.categories?.[categoryName]?.variant
-}
-
-export function resolveVariantForModel(
-  config: HiaiOpenCodeConfig,
-  agentName: string,
-  currentModel: { providerID: string; modelID: string },
-): string | undefined {
-  const stripped = stripInvisibleAgentCharacters(agentName)
-  const agentOverrides = config.agents as
-    | Record<string, { variant?: string; category?: string }>
-    | undefined
-  const agentOverride = agentOverrides
-    ? agentOverrides[stripped]
-      ?? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === stripped.toLowerCase())?.[1]
-    : undefined
-  if (agentOverride?.variant) {
-    return agentOverride.variant
-  }
-
-  const agentRequirement = AGENT_MODEL_REQUIREMENTS[stripped]
-  if (agentRequirement) {
-    return findVariantInChain(agentRequirement.fallbackChain, currentModel)
-  }
-  const categoryName = agentOverride?.category
-  if (categoryName) {
-    const categoryRequirement = CATEGORY_MODEL_REQUIREMENTS[categoryName]
-    if (categoryRequirement) {
-      return findVariantInChain(categoryRequirement.fallbackChain, currentModel)
-    }
-  }
-
-  return undefined
-}
-
-function findVariantInChain(
-  fallbackChain: { providers: string[]; model: string; variant?: string }[],
-  currentModel: { providerID: string; modelID: string },
-): string | undefined {
-  for (const entry of fallbackChain) {
-    if (
-      entry.providers.includes(currentModel.providerID)
-      && entry.model === currentModel.modelID
-    ) {
-      return entry.variant
-    }
-  }
-
-  // Some providers expose identical model IDs (e.g. OpenAI models via different providers).
-  // If we didn't find an exact provider+model match, fall back to model-only matching.
-  for (const entry of fallbackChain) {
-    if (entry.model === currentModel.modelID) {
-      return entry.variant
-    }
-  }
-  return undefined
-}
-
-export function applyAgentVariant(
-  config: HiaiOpenCodeConfig,
-  agentName: string | undefined,
-  message: { variant?: string }
-): void {
-  const variant = resolveAgentVariant(config, agentName)
-  if (variant !== undefined && message.variant === undefined) {
-    message.variant = variant
-  }
-}

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

@@ -1,23 +0,0 @@
-import { homedir } from "node:os"
-import { join, resolve } from "node:path"
-
-function resolveAgentsDir(pathValue: string): string {
-  return resolve(pathValue)
-}
-
-export function getAgentsConfigDir(): string {
-  const explicitDir =
-    process.env.AGENTS_CONFIG_DIR?.trim() ||
-    process.env.OPENCODE_AGENTS_DIR?.trim()
-
-  if (explicitDir) {
-    return resolveAgentsDir(explicitDir)
-  }
-
-  const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim()
-  if (opencodeConfigDir) {
-    return resolveAgentsDir(join(opencodeConfigDir, ".agents"))
-  }
-
-  return resolveAgentsDir(join(homedir(), ".agents"))
-}

package/src/shared/archive-entry-validator.ts

@@ -1,83 +0,0 @@
-import { dirname, isAbsolute, relative, resolve, sep } from "node:path"
-
-export type ArchiveEntry = {
-	path: string
-	type: "file" | "directory" | "symlink" | "hardlink"
-	linkPath?: string
-}
-
-function normalizeArchivePath(filePath: string): string {
-	return filePath.replaceAll("\\", "/")
-}
-
-function containsTraversalSegment(filePath: string): boolean {
-	return normalizeArchivePath(filePath)
-		.split("/")
-		.some(segment => segment === "..")
-}
-
-function isArchiveAbsolutePath(filePath: string): boolean {
-	const normalizedPath = normalizeArchivePath(filePath)
-	return isAbsolute(normalizedPath) || /^[A-Za-z]:\//.test(normalizedPath) || normalizedPath.startsWith("//")
-}
-
-function escapesDirectory(rootDir: string, candidatePath: string): boolean {
-	const relativePath = relative(rootDir, candidatePath)
-	return relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)
-}
-
-function resolveContainedPath(rootDir: string, filePath: string, errorLabel: string): string {
-	const normalizedPath = normalizeArchivePath(filePath)
-	if (isArchiveAbsolutePath(normalizedPath)) {
-		throw new Error(`Unsafe archive entry: ${errorLabel} uses an absolute path (${filePath})`)
-	}
-
-	if (containsTraversalSegment(normalizedPath)) {
-		throw new Error(`Unsafe archive entry: ${errorLabel} contains path traversal (${filePath})`)
-	}
-
-	const resolvedPath = resolve(rootDir, normalizedPath)
-	if (escapesDirectory(rootDir, resolvedPath)) {
-		throw new Error(`Unsafe archive entry: ${errorLabel} contains path traversal (${filePath})`)
-	}
-
-	return resolvedPath
-}
-
-export function validateArchiveEntries(entries: ArchiveEntry[], destDir: string): void {
-	const resolvedDestDir = resolve(destDir)
-
-	for (const entry of entries) {
-		const resolvedEntryPath = resolveContainedPath(resolvedDestDir, entry.path, "path")
-		if (entry.type !== "symlink" && entry.type !== "hardlink") {
-			continue
-		}
-
-		if (!entry.linkPath) {
-			throw new Error(
-				`Unsafe archive entry: ${entry.type === "symlink" ? "symlink" : "hard link"} target missing for ${entry.path}`
-			)
-		}
-
-		const normalizedLinkPath = normalizeArchivePath(entry.linkPath)
-		const linkTypeLabel = entry.type === "symlink" ? "symlink target" : "hard link target"
-		if (isArchiveAbsolutePath(normalizedLinkPath)) {
-			throw new Error(
-				`Unsafe archive entry: ${linkTypeLabel} uses an absolute path (${entry.linkPath})`
-			)
-		}
-
-		if (containsTraversalSegment(normalizedLinkPath)) {
-			throw new Error(
-				`Unsafe archive entry: ${linkTypeLabel} contains path traversal (${entry.linkPath})`
-			)
-		}
-
-		const resolvedLinkPath = resolve(dirname(resolvedEntryPath), normalizedLinkPath)
-		if (escapesDirectory(resolvedDestDir, resolvedLinkPath)) {
-			throw new Error(
-				`Unsafe archive entry: ${linkTypeLabel} escapes extraction directory (${entry.linkPath})`
-			)
-		}
-	}
-}

package/src/shared/background-output-consumption.ts

@@ -1,69 +0,0 @@
-import { getMessageCursor, restoreMessageCursor, type CursorState } from "./session-cursor"
-
-type MessageConsumptionKey = `${string}:${string}`
-
-const cursorSnapshotsByMessage = new Map<MessageConsumptionKey, Map<string, CursorState | undefined>>()
-
-function getMessageKey(sessionID: string, messageID: string): MessageConsumptionKey {
-  return `${sessionID}:${messageID}`
-}
-
-export function recordBackgroundOutputConsumption(
-  parentSessionID: string | undefined,
-  parentMessageID: string | undefined,
-  taskSessionID: string | undefined
-): void {
-  if (!parentSessionID || !parentMessageID || !taskSessionID) return
-
-  const messageKey = getMessageKey(parentSessionID, parentMessageID)
-  const existing = cursorSnapshotsByMessage.get(messageKey) ?? new Map<string, CursorState | undefined>()
-
-  if (!cursorSnapshotsByMessage.has(messageKey)) {
-    cursorSnapshotsByMessage.set(messageKey, existing)
-  }
-
-  if (existing.has(taskSessionID)) return
-  existing.set(taskSessionID, getMessageCursor(taskSessionID))
-}
-
-export function restoreBackgroundOutputConsumption(
-  parentSessionID: string | undefined,
-  parentMessageID: string | undefined
-): void {
-  if (!parentSessionID || !parentMessageID) return
-
-  const messageKey = getMessageKey(parentSessionID, parentMessageID)
-  const snapshots = cursorSnapshotsByMessage.get(messageKey)
-  if (!snapshots) return
-
-  cursorSnapshotsByMessage.delete(messageKey)
-  for (const [taskSessionID, cursor] of snapshots) {
-    restoreMessageCursor(taskSessionID, cursor)
-  }
-}
-
-export function clearBackgroundOutputConsumptionsForParentSession(sessionID: string | undefined): void {
-  if (!sessionID) return
-
-  const prefix = `${sessionID}:`
-  for (const messageKey of cursorSnapshotsByMessage.keys()) {
-    if (messageKey.startsWith(prefix)) {
-      cursorSnapshotsByMessage.delete(messageKey)
-    }
-  }
-}
-
-export function clearBackgroundOutputConsumptionsForTaskSession(taskSessionID: string | undefined): void {
-  if (!taskSessionID) return
-
-  for (const [messageKey, snapshots] of cursorSnapshotsByMessage) {
-    snapshots.delete(taskSessionID)
-    if (snapshots.size === 0) {
-      cursorSnapshotsByMessage.delete(messageKey)
-    }
-  }
-}
-
-export function clearBackgroundOutputConsumptionState(): void {
-  cursorSnapshotsByMessage.clear()
-}

package/src/shared/binary-downloader.ts

@@ -1,127 +0,0 @@
-import { chmodSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
-import * as path from "node:path";
-import { spawn } from "bun";
-import { validateArchiveEntries, type ArchiveEntry } from "./archive-entry-validator";
-import { extractZip } from "./zip-extractor";
-
-function isTarTraversalErrorOutput(output: string): boolean {
-  return /path contains '\.\.'|member name contains '\.\.'|removing leading [`'\"]?\.\.\//i.test(output)
-}
-
-export function getCachedBinaryPath(cacheDir: string, binaryName: string): string | null {
-  const binaryPath = path.join(cacheDir, binaryName);
-  return existsSync(binaryPath) ? binaryPath : null;
-}
-
-export function ensureCacheDir(cacheDir: string): void {
-  if (!existsSync(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
-  }
-}
-
-export async function downloadArchive(downloadUrl: string, archivePath: string): Promise<void> {
-  const response = await fetch(downloadUrl, { redirect: "follow" });
-  if (!response.ok) {
-    throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-  }
-
-  const arrayBuffer = await response.arrayBuffer();
-  await Bun.write(archivePath, arrayBuffer);
-}
-
-export async function extractTarGz(
-  archivePath: string,
-  destDir: string,
-  options?: { args?: string[]; cwd?: string }
-): Promise<void> {
-  const entries = await listTarEntries(archivePath, options?.cwd)
-  validateArchiveEntries(entries, destDir)
-
-  const args = options?.args ?? ["tar", "-xzf", archivePath, "-C", destDir];
-  const proc = spawn(args, {
-    cwd: options?.cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const exitCode = await proc.exited;
-  if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
-
-    if (isTarTraversalErrorOutput(stderr)) {
-      throw new Error(`Unsafe archive entry: path contains path traversal (${archivePath})`)
-    }
-    throw new Error(`tar extraction failed (exit ${exitCode}): ${stderr}`);
-  }
-}
-
-export async function extractZipArchive(archivePath: string, destDir: string): Promise<void> {
-  await extractZip(archivePath, destDir);
-}
-
-export function cleanupArchive(archivePath: string): void {
-  if (existsSync(archivePath)) {
-    unlinkSync(archivePath);
-  }
-}
-
-export function ensureExecutable(binaryPath: string): void {
-  if (process.platform !== "win32" && existsSync(binaryPath)) {
-    chmodSync(binaryPath, 0o755);
-  }
-}
-
-function parseTarEntry(line: string): ArchiveEntry | null {
-  const match = line.match(/^([^\s])\S*\s+\d+\s+\S+\s+\S+\s+\d+\s+\w+\s+\d+\s+(?:\d{2}:\d{2}|\d{4})\s+(.*)$/)
-  if (!match) {
-    return null
-  }
-
-  const [, rawType, rawEntryPath] = match
-  if (rawType === "l" || rawType === "h") {
-    const arrowIndex = rawEntryPath.lastIndexOf(" -> ")
-    if (arrowIndex === -1) {
-      return { path: rawEntryPath, type: rawType === "l" ? "symlink" : "hardlink" }
-    }
-
-    return {
-      path: rawEntryPath.slice(0, arrowIndex),
-      type: rawType === "l" ? "symlink" : "hardlink",
-      linkPath: rawEntryPath.slice(arrowIndex + 4),
-    }
-  }
-
-  return {
-    path: rawEntryPath,
-    type: rawType === "d" ? "directory" : "file",
-  }
-}
-
-async function listTarEntries(archivePath: string, cwd?: string): Promise<ArchiveEntry[]> {
-  const proc = spawn(["tar", "-tvzf", archivePath], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-
-  const [exitCode, stdout, stderr] = await Promise.all([
-    proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-  ])
-
-  if (isTarTraversalErrorOutput(stderr)) {
-    throw new Error(`Unsafe archive entry: path contains path traversal (${archivePath})`)
-  }
-
-  if (exitCode !== 0) {
-    throw new Error(`tar entry listing failed (exit ${exitCode}): ${stderr}`)
-  }
-
-  return stdout
-    .split(/\r?\n/)
-    .map(line => line.trim())
-    .filter(Boolean)
-    .map(line => parseTarEntry(line))
-    .filter((entry): entry is ArchiveEntry => entry !== null)
-}

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

@@ -1,16 +0,0 @@
-import { homedir } from "node:os"
-import { join } from "node:path"
-
-export function getClaudeConfigDir(): string {
-  const envConfigDir = process.env.CLAUDE_CONFIG_DIR
-  if (envConfigDir) {
-    return envConfigDir
-  }
-
-  const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR
-  if (opencodeConfigDir) {
-    return opencodeConfigDir
-  }
-  
-  return join(homedir(), ".claude")
-}