LCOV - code coverage report
Current view: top level - src/workbench/extensions/agent/crdt - agentWriteOverwrites.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 38.9 % 72 28
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { isEqual } from 'es-toolkit'
       2              : 
       3              : import { onGraphIntent } from '@/lib/litegraph/src/graphIntents'
       4              : import type {
       5              :   GraphIntentEvent,
       6              :   GraphIntentSource
       7              : } from '@/lib/litegraph/src/graphIntents'
       8              : import { reportError } from '@comfyorg/telemetry/reportError'
       9              : import type { NodeId } from '@comfyorg/graph-model/nodeId'
      10              : 
      11              : import { isLiveAgentTurnWrite } from './agentRemoteProvenance'
      12              : import { recordDevEvent } from './devPanelLog'
      13              : 
      14              : type OverwritingEditKind = 'canvas-edit' | 'undo-redo-restore' | 'graph-load'
      15              : 
      16              : export interface WidgetValueShape {
      17              :   type:
      18              :     | 'boolean'
      19              :     | 'number'
      20              :     | 'string'
      21              :     | 'array'
      22              :     | 'object'
      23              :     | 'null'
      24              :     | 'undefined'
      25              :     | 'other'
      26              :   literal?: boolean | number
      27              :   length?: number
      28              : }
      29              : 
      30              : export interface AgentWriteOverwriteWatchDeps {
      31              :   isEnabled(): boolean
      32              :   isRestoringState(): boolean
      33              : }
      34              : 
      35              : export interface AgentWriteOverwriteWatch {
      36              :   detach(): void
      37              : }
      38              : 
      39            1 : const MAX_TRACKED_REGISTERS = 256
      40              : 
      41            1 : const MAX_TELEMETRY_REPORTS_PER_SESSION = 32
      42              : 
      43            0 : export function describeWidgetValue(value: unknown): WidgetValueShape {
      44            0 :   if (value === null) return { type: 'null' }
      45            0 :   switch (typeof value) {
      46              :     case 'undefined':
      47            0 :       return { type: 'undefined' }
      48              :     case 'boolean':
      49            0 :       return { type: 'boolean', literal: value }
      50              :     case 'number':
      51            0 :       return { type: 'number', literal: value }
      52              :     case 'string':
      53            0 :       return { type: 'string', length: value.length }
      54              :     case 'object':
      55            0 :       return Array.isArray(value)
      56              :         ? { type: 'array', length: value.length }
      57              :         : { type: 'object', length: Object.keys(value).length }
      58              :     default:
      59            0 :       return { type: 'other' }
      60              :   }
      61              : }
      62              : 
      63            0 : function editKindOf(
      64              :   source: Exclude<GraphIntentSource, 'agent-remote'>,
      65              :   isRestoringState: boolean
      66              : ): OverwritingEditKind {
      67            0 :   if (isRestoringState) return 'undo-redo-restore'
      68            0 :   return source === 'local' ? 'canvas-edit' : 'graph-load'
      69              : }
      70              : 
      71            1 : const KEY_SEPARATOR = '\0'
      72              : 
      73            1 : function registerKey(graphId: string, nodeId: NodeId, widget: string): string {
      74            1 :   return [graphId, String(nodeId), widget].join(KEY_SEPARATOR)
      75              : }
      76              : 
      77            0 : function nodePrefix(graphId: string, nodeId: NodeId): string {
      78            0 :   return `${graphId}${KEY_SEPARATOR}${String(nodeId)}${KEY_SEPARATOR}`
      79              : }
      80              : 
      81              : interface RememberedAgentWrite {
      82              :   value: unknown
      83              :   at: number
      84              : }
      85              : 
      86              : /**
      87              :  * Records which later edit changed a value a live Agent turn wrote (PM-2379).
      88              :  * Reads the widget-value seam only; never writes. Known blind spots are in
      89              :  * the pull request description.
      90              :  */
      91            1 : export function attachAgentWriteOverwriteWatch(
      92              :   deps: AgentWriteOverwriteWatchDeps
      93              : ): AgentWriteOverwriteWatch {
      94            1 :   const agentWrites = new Map<string, RememberedAgentWrite>()
      95            1 :   let detached = false
      96            1 :   let telemetryReports = 0
      97              : 
      98            0 :   function rememberAgentWrite(key: string, value: unknown): void {
      99            0 :     agentWrites.delete(key)
     100            0 :     agentWrites.set(key, { value, at: performance.now() })
     101            0 :     if (agentWrites.size <= MAX_TRACKED_REGISTERS) return
     102            0 :     const oldest = agentWrites.keys().next()
     103            0 :     if (!oldest.done) agentWrites.delete(oldest.value)
     104              :   }
     105              : 
     106            0 :   function forgetNode(graphId: string, nodeId: NodeId): void {
     107            0 :     const prefix = nodePrefix(graphId, nodeId)
     108            0 :     for (const key of agentWrites.keys())
     109            0 :       if (key.startsWith(prefix)) agentWrites.delete(key)
     110              :   }
     111              : 
     112            2 :   function forgetGraph(graphId: string): void {
     113            2 :     const prefix = `${graphId}${KEY_SEPARATOR}`
     114            2 :     for (const key of agentWrites.keys())
     115            0 :       if (key.startsWith(prefix)) agentWrites.delete(key)
     116              :   }
     117              : 
     118            0 :   function recordOverwrite(
     119              :     kind: OverwritingEditKind,
     120              :     event: Extract<GraphIntentEvent, { type: 'set_widget' }>,
     121              :     agentWrite: RememberedAgentWrite
     122              :   ): void {
     123            0 :     const detail = {
     124              :       kind,
     125              :       graph_id: event.graphId,
     126              :       node_id: String(event.nodeId),
     127              :       name: event.name,
     128              :       agent_value: describeWidgetValue(agentWrite.value),
     129              :       replaced_value: describeWidgetValue(event.previous),
     130              :       new_value: describeWidgetValue(event.value),
     131              :       ms_since_agent_write: Math.round(performance.now() - agentWrite.at)
     132              :     }
     133            0 :     recordDevEvent('agent_write_overwritten', detail, { level: 'warn' })
     134            0 :     if (telemetryReports >= MAX_TELEMETRY_REPORTS_PER_SESSION) return
     135            0 :     telemetryReports++
     136            0 :     reportError(new Error('agent_write_overwritten'), {
     137              :       surface: 'agent',
     138              :       errorType: 'agent_write_overwritten',
     139              :       level: 'warning',
     140              :       fingerprint: ['agent_write_overwritten', kind],
     141              :       tags: { overwrite_kind: kind, widget: event.name },
     142              :       context: {
     143              :         ...detail,
     144              :         report_index: telemetryReports,
     145              :         report_cap: MAX_TELEMETRY_REPORTS_PER_SESSION
     146              :       }
     147              :     })
     148              :   }
     149              : 
     150            1 :   function onWidgetWrite(
     151              :     event: Extract<GraphIntentEvent, { type: 'set_widget' }>
     152              :   ): void {
     153            1 :     const key = registerKey(event.graphId, event.nodeId, event.name)
     154            1 :     if (event.source === 'agent-remote') {
     155            0 :       if (isLiveAgentTurnWrite()) rememberAgentWrite(key, event.value)
     156            0 :       else agentWrites.delete(key)
     157            0 :       return
     158              :     }
     159            1 :     const agentWrite = agentWrites.get(key)
     160            1 :     if (!agentWrite) return
     161            0 :     if (isEqual(agentWrite.value, event.value)) return
     162            0 :     agentWrites.delete(key)
     163            0 :     recordOverwrite(
     164              :       editKindOf(event.source, deps.isRestoringState()),
     165              :       event,
     166              :       agentWrite
     167              :     )
     168              :   }
     169              : 
     170            4 :   function onIntent(event: GraphIntentEvent): void {
     171            4 :     if (detached) return
     172            4 :     if (!deps.isEnabled()) {
     173            0 :       agentWrites.clear()
     174            0 :       return
     175              :     }
     176            4 :     switch (event.type) {
     177              :       case 'set_widget':
     178            1 :         onWidgetWrite(event)
     179            1 :         return
     180              :       case 'remove_node':
     181            0 :         forgetNode(event.graph.rootGraph.id, event.node.id)
     182            0 :         return
     183              :       case 'clear':
     184            2 :         forgetGraph(event.graphId)
     185            2 :         return
     186              :       default:
     187            1 :         return
     188              :     }
     189              :   }
     190              : 
     191            1 :   const detachIntents = onGraphIntent(onIntent)
     192              : 
     193            1 :   return {
     194              :     detach() {
     195            0 :       detached = true
     196            0 :       agentWrites.clear()
     197            0 :       detachIntents()
     198              :     }
     199              :   }
     200              : }
        

Generated by: LCOV version 2.0-1