agent-ui/server/routes/claude-hook.ts

import { jsonResponse, errorResponse } from '../utils/cors'
import { PORT_TERMINAL } from '../config'
import { existsSync, readFileSync } from 'fs'
import { setActiveSession, getIncrementalMessages } from '../services/transcript-engine'
import { deriveStatus, type HookPayload } from '../services/session-state'

export async function handleClaudeHook(req: Request): Promise<Response | null> {
  if (req.method !== 'POST') return null

  try {
    const url = new URL(req.url)
    const agent = url.searchParams.get('agent') || ''
    const body = await req.json() as HookPayload

    // On Stop events, extract last assistant response from transcript
    if (body.hook_event_name === 'Stop' && body.transcript_path) {
      try {
        let tp = body.transcript_path as string
        // Normalize path for Windows (handle both C:\ and /c/ formats)
        tp = tp.replace(/\\/g, '/')
        if (/^\/[a-zA-Z]\//.test(tp)) {
          tp = tp[1].toUpperCase() + ':' + tp.slice(2)
        }
        if (existsSync(tp)) {
          const lines = readFileSync(tp, 'utf8').trim().split('\n')
          for (let i = lines.length - 1; i >= Math.max(0, lines.length - 30); i--) {
            try {
              const obj = JSON.parse(lines[i])
              if (obj.type === 'assistant' && obj.message?.role === 'assistant') {
                const content = obj.message.content
                if (Array.isArray(content)) {
                  const text = content.filter((c: any) => c.type === 'text').map((c: any) => c.text).join('\n')
                  if (text) {
                    body.assistant_response = text.slice(0, 500)
                    break
                  }
                }
              }
            } catch { /* skip unparseable lines */ }
          }
        }
      } catch (e) {
        console.error('[claude-hook] Failed to read transcript:', e)
      }
    }

    // Inject agent name into hook data for WS consumers
    const hookData = { ...body, agent_name: agent || 'main' }

    // 1. Broadcast full hook data via WebSocket (always, even for subagents)
    try {
      await fetch(`http://localhost:${PORT_TERMINAL}/claude-hook`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(hookData)
      })
    } catch (e) {
      console.error('[claude-hook] Failed to forward hook to terminal server:', e)
    }

    // 2. Forward PermissionRequest to /claude-permission for hooks approval system
    if (body.hook_event_name === 'PermissionRequest') {
      try {
        await fetch(`http://localhost:${PORT_TERMINAL}/claude-permission`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(hookData)
        })
      } catch (e) {
        console.error('[claude-hook] Failed to forward permission to terminal server:', e)
      }
    }

    // 3. Derive status and broadcast via WebSocket
    const derived = deriveStatus(body)
    if (derived) {
      try {
        await fetch(`http://localhost:${PORT_TERMINAL}/claude-status`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({ status: derived.status, tool: derived.tool, agent: agent || 'main' })
        })
      } catch (e) {
        console.error('[claude-hook] Failed to forward status to terminal server:', e)
      }
    }

    // 4. Incremental transcript reading for real-time chat
    if (body.session_id && body.transcript_path) {
      const agentName = agent || 'main'
      setActiveSession(agentName, body.session_id, body.transcript_path as string)

      const newMessages = getIncrementalMessages(body.session_id, body.transcript_path as string)
      if (newMessages.length > 0) {
        try {
          await fetch(`http://localhost:${PORT_TERMINAL}/transcript-update`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
              sessionId: body.session_id,
              agent: agentName,
              messages: newMessages,
              hookEvent: body.hook_event_name
            })
          })
        } catch (e) {
          console.error('[claude-hook] Failed to forward transcript update:', e)
        }
      }
    }

    return jsonResponse({ success: true, event: body.hook_event_name, agent: agent || 'main' })
  } catch (e) {
    return errorResponse('Invalid JSON body', 400)
  }
}