@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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

package/src/shared/closure-protocol.ts

@@ -1,53 +0,0 @@
-/**
- * Shared Closure Protocol for HiaiOpenCode.
- * All agents MUST wrap their final response in a <CLOSURE> block.
- */
-
-export interface ClosureBlock {
-  reasoning: string;
-  evidence: string[];
-  readiness: "accept" | "reject" | "done";
-}
-
-export const CLOSURE_SCHEMA_PROMPT = `
-<CLOSURE_PROTOCOL>
-## Mandatory Task Finalization
-
-You MUST end your final response with a structured <CLOSURE> block. This block serves as your formal "end of contour" and provides the evidence required for the Guard agent to accept your work.
-
-### Schema:
-\`\`\`xml
-<CLOSURE>
-{
-  "reasoning": "Concise summary of what was achieved and why it satisfies the request.",
-  "evidence": ["Link to test results", "File path to changes", "Log snippets", "LSP diagnostics clean"],
-  "readiness": "done" | "accept" | "reject"
-}
-</CLOSURE>
-\`\`\`
-
-### Readiness mapping:
-- "done": Task completed successfully.
-- "accept": (Reviewer mode) The proposed changes are approved.
-- "reject": (Reviewer mode) The proposed changes are denied with feedback.
-
-**WARNING**: Responses without a valid <CLOSURE> block will be automatically REJECTED by the Guard system.
-</CLOSURE_PROTOCOL>
-`;
-
-export function validateClosure(text: string): { isValid: boolean; error?: string; data?: ClosureBlock } {
-  const match = text.match(/<CLOSURE>\s*([\s\S]*?)\s*<\/CLOSURE>/i);
-  if (!match) {
-    return { isValid: false, error: "Missing mandatory <CLOSURE> block." };
-  }
-
-  try {
-    const data = JSON.parse(match[1]) as ClosureBlock;
-    if (!data.reasoning || !data.evidence || !data.readiness) {
-      return { isValid: false, error: "Invalid <CLOSURE> schema: missing reasoning, evidence, or readiness fields." };
-    }
-    return { isValid: true, data };
-  } catch (e) {
-    return { isValid: false, error: "Malformed <CLOSURE> block: must be a valid JSON object." };
-  }
-}

package/src/shared/command-executor/embedded-commands.ts

@@ -1,26 +0,0 @@
-export interface CommandMatch {
-	fullMatch: string
-	command: string
-	start: number
-	end: number
-}
-
-const COMMAND_PATTERN = /!`([^`]+)`/g
-
-export function findEmbeddedCommands(text: string): CommandMatch[] {
-	const matches: CommandMatch[] = []
-	let match: RegExpExecArray | null
-
-	COMMAND_PATTERN.lastIndex = 0
-
-	while ((match = COMMAND_PATTERN.exec(text)) !== null) {
-		matches.push({
-			fullMatch: match[0],
-			command: match[1],
-			start: match.index,
-			end: match.index + match[0].length,
-		})
-	}
-
-	return matches
-}

package/src/shared/command-executor/execute-command.ts

@@ -1,28 +0,0 @@
-import { exec } from "node:child_process"
-import { promisify } from "node:util"
-
-const execAsync = promisify(exec)
-
-type ExecError = { stdout?: Buffer; stderr?: Buffer; message?: string }
-
-export async function executeCommand(command: string): Promise<string> {
-	try {
-		const { stdout, stderr } = await execAsync(command)
-
-		const out = stdout?.toString().trim() ?? ""
-		const err = stderr?.toString().trim() ?? ""
-
-		if (err) {
-			return out ? `${out}\n[stderr: ${err}]` : `[stderr: ${err}]`
-		}
-
-		return out
-	} catch (error: unknown) {
-		const e = error as ExecError
-		const stdout = e?.stdout?.toString().trim() ?? ""
-		const stderr = e?.stderr?.toString().trim() ?? ""
-		const errorMessage = stderr || e?.message || String(error)
-
-		return stdout ? `${stdout}\n[stderr: ${errorMessage}]` : `[stderr: ${errorMessage}]`
-	}
-}