@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/claude-code-hooks/execute-http-hook.ts

@@ -1,116 +0,0 @@
-import type { HookHttp } from "./types"
-import type { CommandResult } from "../../shared/command-executor/execute-hook-command"
-import { log } from "../../shared"
-
-const DEFAULT_HTTP_HOOK_TIMEOUT_S = 30
-const ALLOWED_SCHEMES = new Set(["http:", "https:"])
-const LOCALHOST_HOSTNAMES = new Set(["localhost", "127.0.0.1", "[::1]"])
-
-function isLocalhost(url: URL): boolean {
-  return LOCALHOST_HOSTNAMES.has(url.hostname)
-}
-
-function isPlainHttp(url: URL): boolean {
-  return url.protocol === "http:"
-}
-
-export function interpolateEnvVars(
-  value: string,
-  allowedEnvVars: string[]
-): string {
-  const allowedSet = new Set(allowedEnvVars)
-
-  return value.replace(/\$\{(\w+)\}|\$(\w+)/g, (_match, bracedVar: string | undefined, bareVar: string | undefined) => {
-    const varName = (bracedVar ?? bareVar) as string
-    if (allowedSet.has(varName)) {
-      return process.env[varName] ?? ""
-    }
-    return ""
-  })
-}
-
-function resolveHeaders(
-  hook: HookHttp
-): Record<string, string> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-  }
-
-  if (!hook.headers) return headers
-
-  const allowedEnvVars = hook.allowedEnvVars ?? []
-  for (const [key, value] of Object.entries(hook.headers)) {
-    headers[key] = interpolateEnvVars(value, allowedEnvVars)
-  }
-
-  return headers
-}
-
-export async function executeHttpHook(
-  hook: HookHttp,
-  stdin: string
-): Promise<CommandResult> {
-  let parsed: URL
-  try {
-    parsed = new URL(hook.url)
-    if (!ALLOWED_SCHEMES.has(parsed.protocol)) {
-      return {
-        exitCode: 1,
-        stderr: `HTTP hook URL scheme "${parsed.protocol}" is not allowed. Only http: and https: are permitted.`,
-      }
-    }
-  } catch {
-    return { exitCode: 1, stderr: `HTTP hook URL is invalid: ${hook.url}` }
-  }
-
-  if (isPlainHttp(parsed)) {
-    if (!isLocalhost(parsed)) {
-      log("HTTP hook URL uses insecure protocol", { url: hook.url })
-      return {
-        exitCode: 1,
-        stderr: "HTTP hook URL must use HTTPS. Plain HTTP is only allowed for localhost, 127.0.0.1, and ::1.",
-      }
-    }
-  }
-
-  const timeoutS = hook.timeout ?? DEFAULT_HTTP_HOOK_TIMEOUT_S
-  const headers = resolveHeaders(hook)
-
-  try {
-    const response = await fetch(hook.url, {
-      method: "POST",
-      headers,
-      body: stdin,
-      // Reject all redirects so HTTPS hooks cannot be silently rewritten to a different origin or protocol.
-      redirect: "manual",
-      signal: AbortSignal.timeout(timeoutS * 1000),
-    })
-
-    if (!response.ok) {
-      return {
-        exitCode: 1,
-        stderr: `HTTP hook returned status ${response.status}: ${response.statusText}`,
-        stdout: await response.text().catch(() => ""),
-      }
-    }
-
-    const body = await response.text()
-    if (!body) {
-      return { exitCode: 0, stdout: "", stderr: "" }
-    }
-
-    try {
-      const parsed = JSON.parse(body) as { exitCode?: number }
-      if (typeof parsed.exitCode === "number") {
-        return { exitCode: parsed.exitCode, stdout: body, stderr: "" }
-      }
-    } catch {
-      // Non-JSON bodies are allowed and returned as stdout below.
-    }
-
-    return { exitCode: 0, stdout: body, stderr: "" }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    return { exitCode: 1, stderr: `HTTP hook error: ${message}` }
-  }
-}

package/src/hooks/claude-code-hooks/handlers/chat-message-handler.ts

@@ -1,140 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { loadClaudeHooksConfig } from "../config"
-import { loadPluginExtendedConfig } from "../config-loader"
-import {
-	executeUserPromptSubmitHooks,
-	type MessagePart,
-	type UserPromptSubmitContext,
-} from "../user-prompt-submit"
-import type { PluginConfig } from "../types"
-import type { ContextCollector } from "../../../features/context-injector"
-import { isHookDisabled, log } from "../../../shared"
-import { appendTranscriptEntry } from "../transcript"
-import { sessionFirstMessageProcessed, sessionInterruptState } from "../session-hook-state"
-
-export function createChatMessageHandler(
-	ctx: PluginInput,
-	config: PluginConfig,
-	contextCollector?: ContextCollector,
-) {
-	return async (
-		input: {
-			sessionID: string
-			agent?: string
-			model?: { providerID: string; modelID: string }
-			messageID?: string
-		},
-		output: {
-			message: Record<string, unknown>
-			parts: Array<{ type: string; text?: string; [key: string]: unknown }>
-		},
-	): Promise<void> => {
-		const interruptState = sessionInterruptState.get(input.sessionID)
-		if (interruptState?.interrupted) {
-			log("chat.message hook skipped - session interrupted", {
-				sessionID: input.sessionID,
-			})
-			return
-		}
-
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
-
-		const textParts = output.parts.filter((p) => p.type === "text" && p.text)
-		const prompt = textParts.map((p) => p.text ?? "").join("\n")
-
-		appendTranscriptEntry(input.sessionID, {
-			type: "user",
-			timestamp: new Date().toISOString(),
-			content: prompt,
-		})
-
-		const messageParts: MessagePart[] = textParts.map((p) => ({
-			type: "text",
-			text: p.text,
-		}))
-
-		const interruptStateBeforeHooks = sessionInterruptState.get(input.sessionID)
-		if (interruptStateBeforeHooks?.interrupted) {
-			log("chat.message hooks skipped - interrupted during preparation", {
-				sessionID: input.sessionID,
-			})
-			return
-		}
-
-		let parentSessionId: string | undefined
-		try {
-			const sessionInfo = await ctx.client.session.get({
-				path: { id: input.sessionID },
-			})
-			parentSessionId = sessionInfo.data?.parentID
-		} catch {
-			parentSessionId = undefined
-		}
-
-		const isFirstMessage = !sessionFirstMessageProcessed.has(input.sessionID)
-		sessionFirstMessageProcessed.add(input.sessionID)
-
-		if (isHookDisabled(config, "UserPromptSubmit")) {
-			return
-		}
-
-		const userPromptCtx: UserPromptSubmitContext = {
-			sessionId: input.sessionID,
-			parentSessionId,
-			prompt,
-			parts: messageParts,
-			cwd: ctx.directory,
-		}
-
-		const result = await executeUserPromptSubmitHooks(
-			userPromptCtx,
-			claudeConfig,
-			extendedConfig,
-		)
-
-		if (result.block) {
-			throw new Error(result.reason ?? "Hook blocked the prompt")
-		}
-
-		const interruptStateAfterHooks = sessionInterruptState.get(input.sessionID)
-		if (interruptStateAfterHooks?.interrupted) {
-			log("chat.message injection skipped - interrupted during hooks", {
-				sessionID: input.sessionID,
-			})
-			return
-		}
-
-		if (result.messages.length === 0) {
-			return
-		}
-
-		const hookContent = result.messages.join("\n\n")
-		log(`[claude-code-hooks] Injecting ${result.messages.length} hook messages`, {
-			sessionID: input.sessionID,
-			contentLength: hookContent.length,
-			isFirstMessage,
-		})
-
-		if (!contextCollector) {
-			return
-		}
-
-		log("[DEBUG] Registering hook content to contextCollector", {
-			sessionID: input.sessionID,
-			contentLength: hookContent.length,
-			contentPreview: hookContent.slice(0, 100),
-		})
-		contextCollector.register(input.sessionID, {
-			id: "hook-context",
-			source: "custom",
-			content: hookContent,
-			priority: "high",
-		})
-
-		log("Hook content registered for synthetic message injection", {
-			sessionID: input.sessionID,
-			contentLength: hookContent.length,
-		})
-	}
-}

package/src/hooks/claude-code-hooks/handlers/pre-compact-handler.ts

@@ -1,41 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { loadClaudeHooksConfig } from "../config"
-import { loadPluginExtendedConfig } from "../config-loader"
-import { executePreCompactHooks, type PreCompactContext } from "../pre-compact"
-import type { PluginConfig } from "../types"
-import { isHookDisabled, log } from "../../../shared"
-
-export function createPreCompactHandler(ctx: PluginInput, config: PluginConfig) {
-	return async (
-		input: { sessionID: string },
-		output: { context: string[] },
-	): Promise<void> => {
-		if (isHookDisabled(config, "PreCompact")) {
-			return
-		}
-
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
-
-		const preCompactCtx: PreCompactContext = {
-			sessionId: input.sessionID,
-			cwd: ctx.directory,
-		}
-
-		const result = await executePreCompactHooks(
-			preCompactCtx,
-			claudeConfig,
-			extendedConfig,
-		)
-
-		if (result.context.length > 0) {
-			log("PreCompact hooks injecting context", {
-				sessionID: input.sessionID,
-				contextCount: result.context.length,
-				hookName: result.hookName,
-				elapsedMs: result.elapsedMs,
-			})
-			output.context.push(...result.context)
-		}
-	}
-}

package/src/hooks/claude-code-hooks/handlers/session-event-handler.ts

@@ -1,137 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { ContextCollector } from "../../../features/context-injector"
-import { clearClaudeHooksConfigCache, loadClaudeHooksConfig } from "../config"
-import { clearPluginExtendedConfigCache, loadPluginExtendedConfig } from "../config-loader"
-import { executeStopHooks, type StopContext } from "../stop"
-import { clearTranscriptCache } from "../transcript"
-import { clearToolInputCache, stopToolInputCacheCleanup } from "../tool-input-cache"
-import type { PluginConfig } from "../types"
-import { createInternalAgentTextPart, isHookDisabled, log } from "../../../shared"
-import {
-	clearAllSessionHookState,
-	clearSessionHookState,
-	sessionErrorState,
-	sessionInterruptState,
-} from "../session-hook-state"
-
-export function createSessionEventHandler(
-	ctx: PluginInput,
-	config: PluginConfig,
-	contextCollector?: ContextCollector,
-) {
-	const parentSessionIdCache = new Map<string, string | undefined>()
-
-	return async (input: { event: { type: string; properties?: unknown } }) => {
-		const { event } = input
-
-		if (event.type === "session.error") {
-			const props = event.properties as Record<string, unknown> | undefined
-			const sessionID = props?.sessionID as string | undefined
-			if (sessionID) {
-				sessionErrorState.set(sessionID, {
-					hasError: true,
-					errorMessage: String(props?.error ?? "Unknown error"),
-				})
-			}
-			return
-		}
-
-		if (event.type === "session.deleted") {
-			const props = event.properties as Record<string, unknown> | undefined
-			const sessionInfo = props?.info as { id?: string } | undefined
-			if (sessionInfo?.id) {
-				parentSessionIdCache.delete(sessionInfo.id)
-				clearTranscriptCache(sessionInfo.id)
-				clearToolInputCache(sessionInfo.id)
-				contextCollector?.clear(sessionInfo.id)
-				clearSessionHookState(sessionInfo.id)
-			}
-			return
-		}
-
-		if (event.type !== "session.idle") {
-			return
-		}
-
-		const props = event.properties as Record<string, unknown> | undefined
-		const sessionID = props?.sessionID as string | undefined
-		if (!sessionID) return
-
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
-
-		const errorStateBefore = sessionErrorState.get(sessionID)
-		const endedWithErrorBefore = errorStateBefore?.hasError === true
-		const interruptStateBefore = sessionInterruptState.get(sessionID)
-		const interruptedBefore = interruptStateBefore?.interrupted === true
-
-		let parentSessionId = parentSessionIdCache.get(sessionID)
-		if (parentSessionId === undefined && !parentSessionIdCache.has(sessionID)) {
-			try {
-				const sessionInfo = await ctx.client.session.get({
-					path: { id: sessionID },
-				})
-				parentSessionId = sessionInfo.data?.parentID
-				parentSessionIdCache.set(sessionID, parentSessionId)
-			} catch {
-				parentSessionId = undefined
-			}
-		}
-
-		if (!isHookDisabled(config, "Stop")) {
-			const stopCtx: StopContext = {
-				sessionId: sessionID,
-				parentSessionId,
-				cwd: ctx.directory,
-			}
-
-			const stopResult = await executeStopHooks(stopCtx, claudeConfig, extendedConfig)
-
-			const errorStateAfter = sessionErrorState.get(sessionID)
-			const endedWithErrorAfter = errorStateAfter?.hasError === true
-			const interruptStateAfter = sessionInterruptState.get(sessionID)
-			const interruptedAfter = interruptStateAfter?.interrupted === true
-
-			const shouldBypass =
-				endedWithErrorBefore ||
-				endedWithErrorAfter ||
-				interruptedBefore ||
-				interruptedAfter
-
-			if (shouldBypass && stopResult.block) {
-				log("Stop hook block ignored", {
-					sessionID,
-					block: stopResult.block,
-					interrupted: interruptedBefore || interruptedAfter,
-					endedWithError: endedWithErrorBefore || endedWithErrorAfter,
-				})
-			} else if (stopResult.block && stopResult.injectPrompt) {
-				log("Stop hook returned block with inject_prompt", { sessionID })
-				ctx.client.session
-					.prompt({
-						path: { id: sessionID },
-						body: {
-							parts: [createInternalAgentTextPart(stopResult.injectPrompt)],
-						},
-						query: { directory: ctx.directory },
-					})
-					.catch((err: unknown) =>
-						log("Failed to inject prompt from Stop hook", { error: String(err) }),
-					)
-			} else if (stopResult.block) {
-				log("Stop hook returned block", { sessionID, reason: stopResult.reason })
-			}
-		}
-
-		clearSessionHookState(sessionID)
-	}
-}
-
-export function disposeSessionEventHandler(contextCollector?: ContextCollector): void {
-	clearTranscriptCache()
-	clearClaudeHooksConfigCache()
-	clearPluginExtendedConfigCache()
-	stopToolInputCacheCleanup()
-	contextCollector?.clearAll()
-	clearAllSessionHookState()
-}

package/src/hooks/claude-code-hooks/handlers/tool-execute-after-handler.ts

@@ -1,160 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { loadClaudeHooksConfig } from "../config"
-import { loadPluginExtendedConfig } from "../config-loader"
-import {
-	executePostToolUseHooks,
-	type PostToolUseClient,
-	type PostToolUseContext,
-} from "../post-tool-use"
-import { getToolInput } from "../tool-input-cache"
-import { appendTranscriptEntry, getTranscriptPath } from "../transcript"
-import type { PluginConfig } from "../types"
-import { isHookDisabled } from "../../../shared"
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function getStringValue(record: Record<string, unknown>, key: string): string | undefined {
-	const value = record[key]
-	return typeof value === "string" && value.length > 0 ? value : undefined
-}
-
-function getNumberValue(record: Record<string, unknown>, key: string): number | undefined {
-	const value = record[key]
-	return typeof value === "number" ? value : undefined
-}
-
-function buildTranscriptToolOutput(outputText: string, metadata: unknown): Record<string, unknown> {
-	const compactOutput: Record<string, unknown> = { output: outputText }
-	if (!isRecord(metadata)) {
-		return compactOutput
-	}
-
-	const filePath = getStringValue(metadata, "filePath")
-		?? getStringValue(metadata, "path")
-		?? getStringValue(metadata, "file")
-	if (filePath) {
-		compactOutput.filePath = filePath
-	}
-
-	const sessionId = getStringValue(metadata, "sessionId")
-	if (sessionId) {
-		compactOutput.sessionId = sessionId
-	}
-
-	const agent = getStringValue(metadata, "agent")
-	if (agent) {
-		compactOutput.agent = agent
-	}
-
-	for (const key of ["noopEdits", "deduplicatedEdits", "firstChangedLine"] as const) {
-		const value = getNumberValue(metadata, key)
-		if (value !== undefined) {
-			compactOutput[key] = value
-		}
-	}
-
-	const filediff = metadata.filediff
-	if (isRecord(filediff)) {
-		const additions = getNumberValue(filediff, "additions")
-		const deletions = getNumberValue(filediff, "deletions")
-		if (additions !== undefined || deletions !== undefined) {
-			compactOutput.filediff = {
-				...(additions !== undefined ? { additions } : {}),
-				...(deletions !== undefined ? { deletions } : {}),
-			}
-		}
-	}
-
-	return compactOutput
-}
-
-export function createToolExecuteAfterHandler(ctx: PluginInput, config: PluginConfig) {
-	return async (
-		input: { tool: string; sessionID: string; callID: string },
-		output: { title: string; output: string; metadata: unknown } | undefined,
-	): Promise<void> => {
-		if (!output) {
-			return
-		}
-
-
-		const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {}
-
-		appendTranscriptEntry(input.sessionID, {
-			type: "tool_result",
-			timestamp: new Date().toISOString(),
-			tool_name: input.tool,
-			tool_input: cachedInput,
-			tool_output: buildTranscriptToolOutput(output.output, output.metadata),
-		})
-
-		if (isHookDisabled(config, "PostToolUse")) {
-			return
-		}
-
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
-
-		const postClient: PostToolUseClient = {
-			session: {
-				messages: (opts) => ctx.client.session.messages(opts),
-			},
-		}
-
-		const postCtx: PostToolUseContext = {
-			sessionId: input.sessionID,
-			toolName: input.tool,
-			toolInput: cachedInput,
-			toolOutput: {
-				title: input.tool,
-				output: output.output,
-				metadata: output.metadata as Record<string, unknown>,
-			},
-			cwd: ctx.directory,
-			transcriptPath: getTranscriptPath(input.sessionID),
-			toolUseId: input.callID,
-			client: postClient,
-			permissionMode: "bypassPermissions",
-		}
-
-		const result = await executePostToolUseHooks(postCtx, claudeConfig, extendedConfig)
-
-		if (result.block) {
-			ctx.client.tui
-				.showToast({
-					body: {
-						title: "PostToolUse Hook Warning",
-						message: result.reason ?? "Hook returned warning",
-						variant: "warning",
-						duration: 4000,
-					},
-				})
-				.catch(() => {})
-		}
-
-		if (result.warnings && result.warnings.length > 0) {
-			output.output = `${output.output}\n\n${result.warnings.join("\n")}`
-		}
-
-		if (result.message) {
-			output.output = `${output.output}\n\n${result.message}`
-		}
-
-		if (result.hookName) {
-			ctx.client.tui
-				.showToast({
-					body: {
-						title: "PostToolUse Hook Executed",
-						message: `▶ ${result.toolName ?? input.tool} ${result.hookName}: ${
-							result.elapsedMs ?? 0
-						}ms`,
-						variant: "success",
-						duration: 2000,
-					},
-				})
-				.catch(() => {})
-		}
-	}
-}

package/src/hooks/claude-code-hooks/handlers/tool-execute-before-handler.ts

@@ -1,93 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { loadClaudeHooksConfig } from "../config"
-import { loadPluginExtendedConfig } from "../config-loader"
-import {
-	executePreToolUseHooks,
-	type PreToolUseContext,
-} from "../pre-tool-use"
-import { appendTranscriptEntry } from "../transcript"
-import { cacheToolInput } from "../tool-input-cache"
-import type { PluginConfig } from "../types"
-import { isHookDisabled, log } from "../../../shared"
-
-export function createToolExecuteBeforeHandler(ctx: PluginInput, config: PluginConfig) {
-	return async (
-		input: { tool: string; sessionID: string; callID: string },
-		output: { args: Record<string, unknown> },
-	): Promise<void> => {
-		if (input.tool.trim() === "todowrite" && typeof output.args.todos === "string") {
-			let parsed: unknown
-			try {
-				parsed = JSON.parse(output.args.todos)
-			} catch {
-				throw new Error(
-					`[todowrite ERROR] Failed to parse todos string as JSON. ` +
-						`Received: ${
-							output.args.todos.length > 100
-								? output.args.todos.slice(0, 100) + "..."
-								: output.args.todos
-						} ` +
-						`Expected: Valid JSON array. Pass todos as an array, not a string.`,
-				)
-			}
-
-			if (!Array.isArray(parsed)) {
-				throw new Error(
-					`[todowrite ERROR] Parsed JSON is not an array. ` +
-						`Received type: ${typeof parsed}. ` +
-						`Expected: Array of todo objects. Pass todos as [{id, content, status, priority}, ...].`,
-				)
-			}
-
-			output.args.todos = parsed
-			log("todowrite: parsed todos string to array", { sessionID: input.sessionID })
-		}
-
-
-		appendTranscriptEntry(input.sessionID, {
-			type: "tool_use",
-			timestamp: new Date().toISOString(),
-			tool_name: input.tool,
-			tool_input: output.args,
-		})
-
-		cacheToolInput(input.sessionID, input.tool, input.callID, output.args)
-
-		if (isHookDisabled(config, "PreToolUse")) {
-			return
-		}
-
-		const claudeConfig = await loadClaudeHooksConfig()
-		const extendedConfig = await loadPluginExtendedConfig()
-
-		const preCtx: PreToolUseContext = {
-			sessionId: input.sessionID,
-			toolName: input.tool,
-			toolInput: output.args,
-			cwd: ctx.directory,
-			toolUseId: input.callID,
-		}
-
-		const result = await executePreToolUseHooks(preCtx, claudeConfig, extendedConfig)
-
-		if (result.decision === "deny") {
-			ctx.client.tui
-				.showToast({
-					body: {
-						title: "PreToolUse Hook Executed",
-						message: `[BLOCKED] ${result.toolName ?? input.tool} ${
-							result.hookName ?? "hook"
-						}: ${result.elapsedMs ?? 0}ms\n${result.inputLines ?? ""}`,
-						variant: "error" as const,
-						duration: 4000,
-					},
-				})
-				.catch(() => {})
-			throw new Error(result.reason ?? "Hook blocked the operation")
-		}
-
-		if (result.modifiedInput) {
-			Object.assign(output.args, result.modifiedInput)
-		}
-	}
-}

package/src/hooks/claude-code-hooks/index.ts

@@ -1 +0,0 @@
-export { createClaudeCodeHooksHook } from "./claude-code-hooks-hook"

package/src/hooks/claude-code-hooks/plugin-config.ts

@@ -1,12 +0,0 @@
-/**
- * Plugin configuration for Claude Code hooks execution
- * Contains settings for hook command execution (zsh, etc.)
- */
-
-const isWindows = process.platform === "win32"
-
-export const DEFAULT_CONFIG = {
-  // Windows doesn't have zsh by default, so we disable forceZsh on Windows
-  forceZsh: !isWindows,
-  zshPath: "/bin/zsh",
-}