Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

14.6 KB
Raw Blame
import { createHash } from 'node:crypto'
import type { EngineNormalizer } from '../types.js'
import type { LastTurnText, LiveEvent, SessionEvent } from '../../lib/normalize.js'

type JsonObject = Record<string, unknown>

const MAX_OUTPUT = 2_000
const TODO_STATUSES = new Set(['pending', 'in_progress', 'completed'])

interface PendingTool {
  tool: string
  fromHook: boolean
}

interface CursorTodo {
  id: string
  content: string
  status: string
}

export interface CursorTaskHook {
  toolUseId: string
  input: unknown
}

export interface CursorTaskCompletion {
  output: string
  isError: boolean
  agentId?: string
  agentType?: string
  totalToolUseCount?: number
  totalDurationMs?: number
  events?: SessionEvent[]
}

export interface CursorReplayTaskLink extends CursorTaskCompletion {
  toolUseId: string
  prompt: string
  description?: string
}

function object(value: unknown): JsonObject | null {
  return value !== null && typeof value === 'object' && !Array.isArray(value)
    ? value as JsonObject
    : null
}

function string(value: unknown): string {
  return typeof value === 'string' ? value : ''
}

function parse(line: string): JsonObject | null {
  try { return object(JSON.parse(line)) } catch { return null }
}

function clip(value: string): string {
  return value.length > MAX_OUTPUT ? `${value.slice(0, MAX_OUTPUT)}\n...[truncated]` : value
}

function contentBlocks(raw: JsonObject): JsonObject[] {
  const message = object(raw.message)
  return Array.isArray(message?.content)
    ? message.content.map(object).filter((item): item is JsonObject => item !== null)
    : []
}

function cursorAssistantText(rawText: string): string | null {
  const lines = rawText.split(/\r?\n/)
  while (lines.at(-1)?.trim() === '[REDACTED]') {
    lines.pop()
    while (lines.at(-1)?.trim() === '') lines.pop()
  }
  const text = lines.join('\n').trimEnd()
  return text.trim() ? text : null
}

export function cursorUserText(rawText: string): string | null {
  const wrapped = /^\s*<timestamp>[\s\S]*?<\/timestamp>\s*<user_query>\s*([\s\S]*?)\s*<\/user_query>\s*$/.exec(rawText)
  if (wrapped) return wrapped[1].trim()
  return rawText.trim() || null
}

function taskInput(value: unknown): JsonObject {
  return object(value) ?? {}
}

function cursorToolInput(tool: string, value: unknown): unknown {
  const input = object(value)
  if (tool === 'WebSearch' && input && !string(input.query) && string(input.search_term)) {
    return { ...input, query: input.search_term }
  }
  return value ?? {}
}

function taskKey(value: unknown): string {
  const input = taskInput(value)
  return JSON.stringify({
    description: string(input.description),
    prompt: string(input.prompt),
    model: string(input.model),
  })
}

export function cursorTaskId(sessionId: string, toolUseId: string): string {
  return `cursor-task:${createHash('sha256').update(sessionId).update('\0').update(toolUseId).digest('hex')}`
}

function taskSummary(output: string, isError: boolean): string {
  if (isError) return 'Subagent failed'
  return output.trim().split('\n')[0]?.slice(0, 120) || 'Subagent completed'
}

function applyTodoInput(
  todoById: Map<string, CursorTodo>,
  todoOrder: string[],
  value: unknown,
): boolean {
  const input = object(value)
  const merge = input?.merge
  const todos = Array.isArray(input?.todos) ? input.todos : null
  if (typeof merge !== 'boolean' || !todos) return false
  if (!merge) {
    todoById.clear()
    todoOrder.splice(0)
  }
  for (const rawTodo of todos) {
    const todo = object(rawTodo)
    const todoId = string(todo?.id)
    if (!todoId) continue
    if (todo?.status === 'deleted') {
      todoById.delete(todoId)
      const index = todoOrder.indexOf(todoId)
      if (index >= 0) todoOrder.splice(index, 1)
      continue
    }
    const previous = todoById.get(todoId)
    const content = string(todo?.content) || previous?.content || ''
    if (!content) continue
    const rawStatus = string(todo?.status)
    const status = TODO_STATUSES.has(rawStatus) ? rawStatus : previous?.status ?? 'pending'
    if (!previous) todoOrder.push(todoId)
    todoById.set(todoId, { id: todoId, content, status })
  }
  return true
}

function todoSnapshot(todoById: Map<string, CursorTodo>, todoOrder: string[]): CursorTodo[] {
  return todoOrder
    .map((todoId) => todoById.get(todoId))
    .filter((todo): todo is CursorTodo => todo !== undefined)
}

function cursorTodoState(rawLines: string[]): CursorTodo[] {
  const todoById = new Map<string, CursorTodo>()
  const todoOrder: string[] = []
  for (const line of rawLines) {
    const raw = parse(line)
    if (raw?.role !== 'assistant') continue
    for (const block of contentBlocks(raw)) {
      if (block.type === 'tool_use' && block.name === 'TodoWrite') {
        applyTodoInput(todoById, todoOrder, block.input)
      }
    }
  }
  return todoSnapshot(todoById, todoOrder)
}

export class CursorNormalizer implements EngineNormalizer {
  private open = false
  private recordIndex: number
  private readonly pending = new Map<string, PendingTool>()
  private readonly hookQueue: Array<{ id: string; key: string; matched: boolean }> = []
  private readonly todoById = new Map<string, CursorTodo>()
  private readonly todoOrder: string[] = []
  private readonly replayLinks: CursorReplayTaskLink[]

  constructor(
    private readonly mode: 'live' | 'replay',
    private readonly sessionId: string,
    options: {
      startIndex?: number
      replayLinks?: CursorReplayTaskLink[]
      initialTodos?: CursorTodo[]
    } = {},
  ) {
    this.recordIndex = options.startIndex ?? 0
    this.replayLinks = [...(options.replayLinks ?? [])]
    for (const todo of options.initialTodos ?? []) {
      this.todoOrder.push(todo.id)
      this.todoById.set(todo.id, { ...todo })
    }
  }

  get turnOpen(): boolean { return this.open }

  ingest(line: string): LiveEvent[] {
    const index = this.recordIndex++
    const raw = parse(line)
    if (!raw) return []

    if (raw.type === 'turn_ended') {
      return this.finishTurn(string(raw.status).toLowerCase() === 'error')
    }

    if (raw.role === 'user') {
      const first = contentBlocks(raw).find((block) => block.type === 'text')
      const userText = cursorUserText(string(first?.text))
      if (!userText) return []
      if (this.mode === 'replay') {
        this.open = true
        return [{ type: 'user_message', payload: { content: userText } }]
      }
      const events: LiveEvent[] = []
      if (this.open) events.push(...this.finishTurn(false))
      this.open = true
      events.push({ type: 'turn_started', payload: { userMessage: userText } })
      return events
    }

    if (raw.role !== 'assistant') return []
    const events: LiveEvent[] = []
    const blocks = contentBlocks(raw)
    for (let contentIndex = 0; contentIndex < blocks.length; contentIndex++) {
      const block = blocks[contentIndex]
      if (block.type === 'text') {
        const text = cursorAssistantText(string(block.text))
        if (text) events.push({ type: 'text_delta', payload: { content: text } })
        continue
      }
      if (block.type !== 'tool_use') continue
      const tool = string(block.name) || 'Tool'
      const input = cursorToolInput(tool, block.input)
      const id = `cursor:${this.sessionId}:${index}:${contentIndex}`
      if (tool === 'TodoWrite') {
        events.push(...this.todoEvents(id, input))
      } else if (tool === 'Task') {
        events.push(...this.taskEvents(id, input))
      } else {
        this.pending.set(id, { tool, fromHook: false })
        events.push({ type: 'tool_start', payload: { id, tool, input } })
      }
    }
    return events
  }

  ingestTaskHook(hook: CursorTaskHook): LiveEvent[] {
    if (!hook.toolUseId) return []
    const id = cursorTaskId(this.sessionId, hook.toolUseId)
    if (this.pending.has(id)) return []
    this.pending.set(id, { tool: 'Task', fromHook: true })
    this.hookQueue.push({ id, key: taskKey(hook.input), matched: false })
    return [{ type: 'tool_start', payload: { id, tool: 'Task', input: hook.input } }]
  }

  completeTask(id: string, completion: CursorTaskCompletion): LiveEvent[] {
    const pending = this.pending.get(id)
    if (!pending || pending.tool !== 'Task') return []
    this.pending.delete(id)
    const events: LiveEvent[] = []
    for (const event of completion.events ?? []) {
      if (event.type === 'tool_start') {
        events.push({ type: 'tool_start', payload: { ...event.payload, parentToolUseId: id } })
      } else if (event.type === 'tool_end') {
        events.push({ type: 'tool_end', payload: { ...event.payload, parentToolUseId: id } })
      }
    }
    const output = completion.output || (completion.isError ? 'Subagent failed' : 'Subagent completed')
    events.push({
      type: 'tool_end',
      payload: {
        id,
        tool: 'Task',
        output: clip(output),
        isError: completion.isError,
        summary: taskSummary(output, completion.isError),
        subagent: completion.agentId || completion.agentType || completion.totalToolUseCount != null
          ? {
              agentId: completion.agentId,
              agentType: completion.agentType,
              totalToolUseCount: completion.totalToolUseCount,
              totalDurationMs: completion.totalDurationMs,
            }
          : undefined,
      },
    })
    return events
  }

  closeOutstandingTasks(isError = false): LiveEvent[] {
    const events: LiveEvent[] = []
    for (const [id, pending] of [...this.pending]) {
      if (pending.tool !== 'Task') continue
      this.pending.delete(id)
      const output = isError ? 'Subagent turn aborted' : 'Subagent completed'
      events.push({
        type: 'tool_end',
        payload: { id, tool: 'Task', output: '', isError, summary: output },
      })
    }
    return events
  }

  closeTurn(): LiveEvent[] {
    return this.finishTurn(false)
  }

  finishReplay(): LiveEvent[] {
    return this.closePending(false, true)
  }

  private todoEvents(id: string, value: unknown): LiveEvent[] {
    if (!applyTodoInput(this.todoById, this.todoOrder, value)) return []
    const snapshot = todoSnapshot(this.todoById, this.todoOrder)
    return [
      { type: 'tool_start', payload: { id, tool: 'TodoWrite', input: { todos: snapshot } } },
      {
        type: 'tool_end',
        payload: { id, tool: 'TodoWrite', output: 'Updated tasks', isError: false, summary: 'Updated tasks' },
      },
    ]
  }

  private taskEvents(fallbackId: string, input: unknown): LiveEvent[] {
    const key = taskKey(input)
    const hook = this.hookQueue.find((entry) => !entry.matched && entry.key === key)
    if (hook) {
      hook.matched = true
      return []
    }

    if (this.mode === 'replay') {
      const task = taskInput(input)
      const prompt = string(task.prompt)
      const description = string(task.description)
      const linkIndex = this.replayLinks.findIndex((candidate) =>
        candidate.prompt === prompt
        && (!candidate.description || !description || candidate.description === description))
      if (linkIndex >= 0) {
        const link = this.replayLinks.splice(linkIndex, 1)[0]
        const id = cursorTaskId(this.sessionId, link.toolUseId)
        this.pending.set(id, { tool: 'Task', fromHook: false })
        return [
          { type: 'tool_start', payload: { id, tool: 'Task', input } },
          ...this.completeTask(id, link),
        ]
      }
    }

    this.pending.set(fallbackId, { tool: 'Task', fromHook: false })
    return [{ type: 'tool_start', payload: { id: fallbackId, tool: 'Task', input } }]
  }

  private finishTurn(isError: boolean): LiveEvent[] {
    const events = this.closePending(isError, false)
    if (!this.open) return events
    events.push({ type: 'done', payload: { result: isError ? 'error' : 'success' } })
    if (this.mode === 'live') events.push({ type: 'turn_ended', payload: {} })
    this.open = false
    return events
  }

  private closePending(isError: boolean, includeHookTasks: boolean): LiveEvent[] {
    const events: LiveEvent[] = []
    for (const [id, pending] of [...this.pending]) {
      if (pending.fromHook && !includeHookTasks) continue
      this.pending.delete(id)
      const output = isError ? 'Turn failed' : ''
      events.push({
        type: 'tool_end',
        payload: {
          id,
          tool: pending.tool,
          output,
          isError,
          summary: isError ? 'Turn failed' : 'Completed',
        },
      })
    }
    return events
  }
}

export function cursorMessagesToEvents(
  rawLines: string[],
  sessionId: string,
  replayLinks: CursorReplayTaskLink[] = [],
  startIndex = 0,
  initialTodos: CursorTodo[] = [],
): SessionEvent[] {
  const normalizer = new CursorNormalizer('replay', sessionId, { replayLinks, startIndex, initialTodos })
  const events: SessionEvent[] = []
  for (const line of rawLines) events.push(...normalizer.ingest(line) as SessionEvent[])
  events.push(...normalizer.finishReplay() as SessionEvent[])
  return events
}

export function lastCursorTurnText(rawLines: string[]): LastTurnText | null {
  let userMessage = ''
  let assistantText = ''
  for (const line of rawLines) {
    const raw = parse(line)
    if (!raw) continue
    if (raw.role === 'user') {
      const first = contentBlocks(raw).find((block) => block.type === 'text')
      const text = cursorUserText(string(first?.text))
      if (text) { userMessage = text; assistantText = '' }
    } else if (raw.role === 'assistant') {
      for (const block of contentBlocks(raw)) {
        if (block.type === 'text') {
          const text = cursorAssistantText(string(block.text))
          if (text) assistantText += `${assistantText ? '\n\n' : ''}${text}`
        }
      }
    }
  }
  return assistantText ? { userMessage, assistantText } : null
}

export function windowCursorLines(
  rawLines: string[],
  opts: { limit: number; before?: string },
): {
  window: string[]
  startIndex: number
  initialTodos: CursorTodo[]
  hasMore: boolean
  oldestCursor: string | null
  staleCursor?: boolean
} {
  let endIndex = rawLines.length
  if (opts.before) {
    const match = /^cursor:(\d+)$/.exec(opts.before)
    if (!match) return { window: [], startIndex: 0, initialTodos: [], hasMore: false, oldestCursor: null, staleCursor: true }
    endIndex = Number(match[1])
    if (!Number.isSafeInteger(endIndex) || endIndex < 0 || endIndex > rawLines.length) {
      return { window: [], startIndex: 0, initialTodos: [], hasMore: false, oldestCursor: null, staleCursor: true }
    }
  }
  let start = Math.max(0, endIndex - opts.limit)
  while (start > 0) {
    const raw = parse(rawLines[start])
    if (raw?.role === 'user') break
    start--
  }
  return {
    window: rawLines.slice(start, endIndex),
    startIndex: start,
    initialTodos: cursorTodoState(rawLines.slice(0, start)),
    hasMore: start > 0,
    oldestCursor: `cursor:${start}`,
  }
}