mirror of
https://github.com/ThearchyHelios/AgentLab.git
synced 2026-11-17 21:22:00 +00:00
e10c4f23fc
来自 2026-09 的 UI/UX 审查(142 条)。本提交是前两波,第三波(记录页接入时间轴、跨页互链、check-ui 更新、全站扫尾)另行提交。 地基 - 设计令牌:全局规则和 .btn/.field/.chip 放进 CSS 层,Tailwind 工具类重新生效,选中态、开启态不再被吞掉;字号阶梯; 辅助文字在所有底色上 >= 4.5:1;状态色专用,节点类型色与之拉开色相;「跟随系统」真的跟随,首帧不闪深色;新字标与 favicon - 基础组件:confirmDialog / promptDialog 取代原生对话框;toast 出错不自动消失、可复制、读屏可播报;离线横幅与断线恢复; 九种剪影的状态徽标;唯一一份状态文案(lib/status)、格式化(lib/format)、术语(lib/terms)、报错人话(lib/errors) - 运行态内核:事件折成航迹(run/trace.ts),可投影到任意时刻;取消 / 失败 / 服务重启后统一收尾,不再永远转圈; run.status 随事件回写;token 事件不再堆进 events - 后端:协作成员逐个完成即发事件,调度者决策有事件;时长分执行 / 墙钟 / 等人;API 时间带时区; 中断的运行也发 stream.end;运行列表可筛选翻页;删除运行 / 工作流有保护;运行默认值接通;可测未保存的配置; 报错说清发生了什么、为什么、怎么办 功能 - 画布:状态四重编码、固定高度遥测槽、按缩放三档、运行胶囊与 HUD、航迹时间轴与回放、执行轨迹边、 等待闸门、跟随执行、正式运行只读、一次性时刻(开场点亮、回扫、阻断级联、出具印章) - 编辑:撤销重做、版本历史、问题面板可定位、三栏可收起、模板与表达式字段区分、变量血缘、快捷键、带搜索的选择器 - 回答流 / 问数据:贴底才跟随滚动、工件下钻、出具横幅列出缺口、答案可复制导出、按会话的忙闲、 答案不再在 2000 字处截断、重启后这一轮会收尾 - 记录页:待审批 / 运行中 / 失败页签、筛选翻页、实时接流、排错路径指到节点、封存凭证常驻 - 管理页:新的「数据」页、写操作失败都有反馈、弹窗里先测连接、统一持久的连接状态 - 外壳:导航改版、⌘K 命令面板、? 快捷键帮助、404、页面标题与 favicon 状态点、后台提醒 验证(沙箱):tsc 干净,pytest 579 passed,14 个检查脚本中 13 个全绿;check-ui 剩 1 项旧断言(按旧日期格式找运行行),第三波更新。
843 lines
38 KiB
TypeScript
843 lines
38 KiB
TypeScript
import {
|
||
memo, useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState,
|
||
type CSSProperties, type KeyboardEvent as ReactKeyboardEvent, type ReactNode, type RefObject,
|
||
} from 'react'
|
||
import { createPortal } from 'react-dom'
|
||
import { Handle, Position, type Edge, type NodeProps } from '@xyflow/react'
|
||
import { Sparkles, Wrench } from 'lucide-react'
|
||
import clsx from 'clsx'
|
||
import { NODE_DEFS, sourceHandles } from './nodeDefs'
|
||
import { NODE_WIDTH } from './routing'
|
||
import { LiveClock, stillClock, TeamMatrix, teamBrief } from './TeamMatrix'
|
||
import { edgeKey, topology } from '../run/derive'
|
||
import { api } from '../api/client'
|
||
import { isComposing, StatusBadge } from '../components/ui'
|
||
import { formatClock, formatDuration, formatNumber, formatTokens, NONE } from '../lib/format'
|
||
import { statusMeta } from '../lib/status'
|
||
import { issuanceLabel, RUN_CLASS_LABEL } from '../lib/terms'
|
||
import { ApprovalCard } from '../run/RunPanel'
|
||
import type { NodeState, NodeTrace } from '../run/trace'
|
||
import { loopSince, loopSpan, openSince, useNodeView, type NodeView } from '../run/useNodeView'
|
||
import { useCatalog } from '../store/catalog'
|
||
import { configSig, useStudio, type FlowNode } from '../store/studio'
|
||
import type { Approval, NodeType, RunEvent, ValidationIssue } from '../types'
|
||
|
||
/** 卡片正文的一行摘要:不用打开属性面板就能看懂这个节点在干什么。 */
|
||
function summarize(type: NodeType, config: Record<string, any>): string {
|
||
const first = (...vals: any[]) => vals.find((v) => typeof v === 'string' && v.trim())?.trim() ?? ''
|
||
switch (type) {
|
||
case 'input':
|
||
return (config.fields ?? []).map((f: any) => f.name).filter(Boolean).join(' · ') || '未定义输入'
|
||
case 'output': {
|
||
const names = (config.fields ?? []).map((f: any) => f.name).filter(Boolean).join(' · ')
|
||
return (config.contract ? '⚖ 出具契约 · ' : '') + (names || '未定义成果')
|
||
}
|
||
case 'llm':
|
||
return first(config.prompt, config.system) || '未填提示'
|
||
case 'agent': {
|
||
const tools = (config.tools ?? []).length
|
||
return `${first(config.prompt, config.system) || '未填任务'}${tools ? ` · ${tools} 个工具` : ''}`
|
||
}
|
||
case 'supervisor':
|
||
return `${(config.agents ?? []).map((a: any) => a.name).join(' / ') || '未配成员'}`
|
||
case 'tool':
|
||
return config.tool ? `${config.tool}()` : '未选择工具'
|
||
case 'code':
|
||
return `${config.language ?? 'python'} · ${(config.code ?? '').split('\n')[0].slice(0, 48) || '空'}`
|
||
case 'branch':
|
||
return (config.cases ?? []).map((c: any) => c.key).filter(Boolean).join(' / ') || '未配分支'
|
||
case 'loop':
|
||
return config.mode === 'while'
|
||
? `当 ${config.condition || '?'} 时重复`
|
||
: `遍历 ${config.items || '?'}`
|
||
case 'retrieve':
|
||
return `${config.collection || 'default'} · 取 ${config.limit ?? 5} 条`
|
||
case 'memory':
|
||
return `${{ recall: '回忆', write: '记住', clear: '清空' }[config.action as string] ?? ''} @ ${config.scope || 'default'}`
|
||
case 'human':
|
||
return first(config.title) || '等待人工'
|
||
case 'validate':
|
||
return 'JSON Schema 校验' + (config.repair_with_llm ? ' · 失败自动返工' : '')
|
||
case 'metrics':
|
||
return `${config.caliber || '口径'}@${config.caliber_version || 'v1'} · ${(config.metrics ?? []).length} 个指标`
|
||
case 'transform':
|
||
return first(config.expression, config.template) || '未配置'
|
||
case 'subgraph':
|
||
return config.workflow_id ? '嵌套工作流' : '未选择工作流'
|
||
default:
|
||
return ''
|
||
}
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
// 从 store 里取的几样小东西。选择器都返回原始值或稳定引用:每条事件都会把
|
||
// 全部卡片的选择器跑一遍,返回新对象就等于整张画布跟着重渲染
|
||
// -------------------------------------------------------------------------
|
||
|
||
/** 这个节点的校验问题,压成一个字符串(数量 + 第一条),好让选择器返回稳定值 */
|
||
function issueKey(issues: ValidationIssue[], id: string): string {
|
||
let errors = 0
|
||
let warnings = 0
|
||
let first = ''
|
||
for (const i of issues) {
|
||
if (i.node_id !== id) continue
|
||
if (i.level === 'error') {
|
||
if (!errors) first = i.message
|
||
errors += 1
|
||
} else {
|
||
if (!errors && !warnings) first = i.message
|
||
warnings += 1
|
||
}
|
||
}
|
||
return errors || warnings ? `${errors}\u0000${warnings}\u0000${first}` : ''
|
||
}
|
||
|
||
/**
|
||
* 出具判定挂在哪个成果节点上、什么时候落下的(毫秒,和航迹同一条时间轴,回放时
|
||
* 游标没走到这一刻就不盖章)。按事件数组缓存:一张图里通常只有一两个成果节点在问
|
||
*/
|
||
const issuanceCache = new WeakMap<RunEvent[], { id: string | null; at: number | null }>()
|
||
function issuanceOf(events: RunEvent[]): { id: string | null; at: number | null } {
|
||
const hit = issuanceCache.get(events)
|
||
if (hit) return hit
|
||
let found = { id: null as string | null, at: null as number | null }
|
||
for (let i = events.length - 1; i >= 0; i -= 1) {
|
||
const e = events[i]
|
||
if (e.type === 'issuance') {
|
||
found = { id: e.node_id ?? null, at: typeof e.ts === 'number' ? e.ts * 1000 : null }
|
||
break
|
||
}
|
||
}
|
||
issuanceCache.set(events, found)
|
||
return found
|
||
}
|
||
|
||
/**
|
||
* 每个节点有几路上游(不算循环的回边)。排队中的节点据此说清在等什么:
|
||
* 汇合点是「等其余上游」,单入口的只是轮到它之前那一拍。按拓扑缓存
|
||
*/
|
||
const fanInCache = new WeakMap<object, Record<string, number>>()
|
||
function fanInOf(nodes: FlowNode[], edges: Edge[]): Record<string, number> {
|
||
const topo = topology({ nodes, edges })
|
||
const hit = fanInCache.get(topo)
|
||
if (hit) return hit
|
||
const sources: Record<string, Set<string>> = {}
|
||
for (const e of edges) {
|
||
if (topo.back.has(edgeKey(e))) continue
|
||
;(sources[e.target] ??= new Set()).add(e.source)
|
||
}
|
||
const out = Object.fromEntries(Object.entries(sources).map(([id, set]) => [id, set.size]))
|
||
fanInCache.set(topo, out)
|
||
return out
|
||
}
|
||
|
||
/** 报错的第一句。后端的报错是「发生了什么 + 原因 + 怎么办」,槽里只放得下第一句 */
|
||
function firstSentence(text: string | undefined): string {
|
||
const t = (text ?? '').trim()
|
||
if (!t) return ''
|
||
const line = t.split('\n')[0]
|
||
const cut = line.search(/[。;;]/)
|
||
return cut > 0 ? line.slice(0, cut) : line
|
||
}
|
||
|
||
/** 回放到某一刻时,最近一次跑完走的是哪个出口(那一刻还没跑完的不算) */
|
||
function takenAt(n: NodeTrace | undefined, at: number): string | undefined {
|
||
let handle: string | undefined
|
||
for (const s of n?.segments ?? []) {
|
||
if (s.kind === 'run' && s.end != null && s.end <= at && s.handle) handle = s.handle
|
||
}
|
||
return handle
|
||
}
|
||
|
||
/** 完成之后的产出量:模型出了多少 token、查到几行、取回几条 */
|
||
function outputOf(n: NodeTrace | undefined, preview: any): string {
|
||
if (n && n.tokensOut > 0) return formatTokens(n.tokensOut, { compact: true })
|
||
if (Array.isArray(preview)) return `${formatNumber(preview.length)} 条`
|
||
if (preview && typeof preview === 'object') {
|
||
if (typeof preview.row_count === 'number') return `${formatNumber(preview.row_count)} 行`
|
||
for (const v of Object.values(preview)) {
|
||
if (Array.isArray(v)) return `${formatNumber(v.length)} 条`
|
||
}
|
||
}
|
||
return ''
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
// 遥测槽:固定 22px,一行说完状态、计时和产出
|
||
// -------------------------------------------------------------------------
|
||
|
||
interface Reading {
|
||
/** 主读数:计时、耗时、进度。远景档精简卡上只剩它 */
|
||
main: ReactNode
|
||
/** 主读数之后的补充:理由、错误摘要、产出量 */
|
||
note?: ReactNode
|
||
noteTitle?: string
|
||
/** 靠右的一组小读数:token、工具 */
|
||
side?: ReactNode
|
||
}
|
||
|
||
interface ReadingInput {
|
||
state: NodeState
|
||
view: NodeView
|
||
type: NodeType
|
||
config: Record<string, any>
|
||
skewMs: number
|
||
timed: boolean
|
||
/** 上游有几路:排队时说清在等什么 */
|
||
fanIn: number
|
||
}
|
||
|
||
/**
|
||
* 循环节点的分段进度:foreach 按总项数分段,while 按上限分段。
|
||
* phase:live 在跑(当前那格亮运行色)、done 走了 done 出口、stopped 半路停下
|
||
* (失败、取消、挂起:当前那格不亮,停在哪一格一眼看得出)
|
||
*/
|
||
function LoopProgress({ n, iteration = 0, config, phase }: {
|
||
n: NodeTrace | undefined
|
||
/** 当前第几轮:实时取航迹,回放取那一刻的投影 */
|
||
iteration?: number
|
||
config: Record<string, any>
|
||
phase: 'live' | 'done' | 'stopped'
|
||
}) {
|
||
const done = phase === 'done'
|
||
const cap = Number(config.max_iterations) || 0
|
||
const total = n?.iterTotal != null ? (cap ? Math.min(n.iterTotal, cap) : n.iterTotal) : undefined
|
||
const finished = done ? iteration : Math.max(0, iteration - 1)
|
||
const slots = total ?? cap
|
||
// 分段超过 12 格就看不清了,改成一条连续的进度
|
||
const segs = slots > 0 && slots <= 12 ? Array.from({ length: slots }, (_, i) => i) : null
|
||
const label = config.mode === 'while'
|
||
? done ? `共 ${iteration} 轮` : iteration ? `第 ${iteration} 轮${cap ? ` · 上限 ${cap}` : ''}` : NONE
|
||
: total != null
|
||
? done ? `共 ${total} 项` : `${Math.min(iteration, total)}/${total}`
|
||
: iteration ? `第 ${iteration} 项` : NONE
|
||
return (
|
||
<>
|
||
{segs ? (
|
||
<span className="nc-seg" aria-hidden>
|
||
{segs.map((i) => (
|
||
<i key={i} className={clsx(i < finished && 'is-done', phase === 'live' && i === finished && iteration > 0 && 'is-cur')} />
|
||
))}
|
||
</span>
|
||
) : slots > 0 ? (
|
||
<span className="nc-seg nc-seg-bar" aria-hidden>
|
||
<i style={{ width: `${Math.min(100, (finished / slots) * 100)}%` }} />
|
||
</span>
|
||
) : null}
|
||
<span className="tnum">{label}</span>
|
||
</>
|
||
)
|
||
}
|
||
|
||
function readingOf({ state, view, type, config, skewMs, timed, fanIn }: ReadingInput): Reading {
|
||
const n = view.trace
|
||
const runtime = view.runtime
|
||
const at = view.at
|
||
// 回放时计时是定值:游标减去那一段的起点。实时的交给 LiveClock 自己走
|
||
const clock = (from: number | undefined, coarse = false): ReactNode => {
|
||
if (at != null) return stillClock(from != null ? at - from : undefined)
|
||
return timed && from != null ? <LiveClock from={from} skewMs={skewMs} coarse={coarse} /> : NONE
|
||
}
|
||
const loop = (phase: 'live' | 'done' | 'stopped') => (
|
||
<LoopProgress n={n} iteration={view.iteration} config={config} phase={phase} />
|
||
)
|
||
const tokens = (n?.tokensIn ?? 0) + (n?.tokensOut ?? 0)
|
||
const failedTools = (runtime?.toolCalls ?? []).filter((c) => c.ok === false).length
|
||
const runningTool = n?.toolsRunning
|
||
? [...(runtime?.toolCalls ?? [])].reverse().find((c) => c.ok === undefined)?.tool
|
||
: undefined
|
||
// 工具明细放悬停:谁调的(成员首字)、调了什么、成没成
|
||
const toolTitle = (runtime?.toolCalls ?? []).slice(-8).map((c) =>
|
||
`${c.agent ? `[${c.agent.slice(0, 1)}] ` : ''}${c.tool} ${c.ok === false ? '✗ 失败' : c.ok ? '✓' : '⋯ 进行中'}`).join('\n')
|
||
const side = (
|
||
<>
|
||
{tokens > 0 && (
|
||
<span className="tnum" title={`输入 ${formatNumber(n?.tokensIn)} · 输出 ${formatNumber(n?.tokensOut)} tokens`}>
|
||
{formatTokens(tokens, { compact: true })}
|
||
</span>
|
||
)}
|
||
{!!n?.tools && (
|
||
<span
|
||
className={clsx('nc-tools tnum', runningTool && 'is-live', failedTools && 'is-bad')}
|
||
title={toolTitle}
|
||
>
|
||
<Wrench size={9} aria-hidden />
|
||
{runningTool ? `${runningTool} ⋯` : n.tools}
|
||
</span>
|
||
)}
|
||
</>
|
||
)
|
||
|
||
// 航迹里的 token、工具是整次运行的累计,回放到半路时它们还没发生:不拿终值冒充那一刻
|
||
const final = at == null || view.count === (n?.count ?? 0)
|
||
|
||
switch (state) {
|
||
case 'running':
|
||
if (type === 'loop') {
|
||
return { main: loop('live'), side: clock(loopSince(n, at), true) }
|
||
}
|
||
return { main: clock(openSince(n, 'run', at)), side: at == null ? side : undefined }
|
||
case 'waiting':
|
||
return { main: <>已等 {clock(openSince(n, 'wait', at), true)}</> }
|
||
case 'done':
|
||
if (type === 'loop') {
|
||
return { main: loop('done'), side: <span className="tnum">{formatDuration(timed ? loopSpan(n, at) ?? n?.lastDurationMs : n?.lastDurationMs)}</span> }
|
||
}
|
||
return {
|
||
main: formatDuration(at != null ? view.replayElapsedMs : n?.lastDurationMs ?? runtime?.durationMs),
|
||
note: final ? outputOf(n, runtime?.preview) : '',
|
||
// 跑完了只留工具次数:token 已经在产出量里说过(输出多少),再挂一个总数是两套数
|
||
side: n?.tools && final ? (
|
||
<span className={clsx('nc-tools tnum', failedTools && 'is-bad')} title={toolTitle}>
|
||
<Wrench size={9} aria-hidden />{n.tools}
|
||
</span>
|
||
) : undefined,
|
||
}
|
||
case 'failed': {
|
||
const error = n?.error || runtime?.error || ''
|
||
if (type === 'loop') {
|
||
return { main: loop('stopped'), note: firstSentence(error), noteTitle: error }
|
||
}
|
||
return {
|
||
main: formatDuration(n?.lastDurationMs ?? runtime?.durationMs),
|
||
note: firstSentence(error) || '没有给出原因',
|
||
noteTitle: error,
|
||
}
|
||
}
|
||
case 'queued':
|
||
return { main: '', note: fanIn > 1 ? '等其余上游汇合' : '上游已交付,等待开始' }
|
||
case 'skipped':
|
||
return { main: '', note: n?.skippedReason || '跳过条件成立', noteTitle: n?.skippedReason }
|
||
case 'blocked':
|
||
return { main: '', note: '上游失败,走不到这里' }
|
||
case 'unreached':
|
||
return { main: '', note: '本次未执行' }
|
||
case 'cancelled':
|
||
// 循环容器停下时要说的是做到第几项,不是这一轮跑了多久
|
||
if (type === 'loop') {
|
||
return { main: loop('stopped'), side: <span className="tnum">{formatDuration(timed ? loopSpan(n, at) : undefined)}</span> }
|
||
}
|
||
return {
|
||
main: n?.startedAt != null && n.endedAt != null && timed ? `停在 ${formatClock(n.endedAt - n.startedAt)}` : '',
|
||
note: n?.count ? '' : '没有开始',
|
||
}
|
||
case 'suspended':
|
||
if (type === 'loop') return { main: loop('stopped'), note: '可接着跑' }
|
||
return { main: '', note: '服务重启打断,可接着跑' }
|
||
default:
|
||
return { main: '' }
|
||
}
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
// 等待节点上的「去审批」浮层:复用右栏同一张审批卡,口径只有一份
|
||
// -------------------------------------------------------------------------
|
||
|
||
/** 浮层里能拿到键盘焦点的元素,按文档顺序 */
|
||
const FOCUSABLE = 'a[href], button:not([disabled]), input:not([disabled]), textarea:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])'
|
||
|
||
function ApprovalPopover({ id, nodeId, runId, anchor, returnTo, onClose }: {
|
||
id: string
|
||
nodeId: string
|
||
runId: string
|
||
anchor: HTMLElement
|
||
/** 收起后焦点回到哪(「去审批」按钮) */
|
||
returnTo: RefObject<HTMLButtonElement | null>
|
||
onClose: () => void
|
||
}) {
|
||
const listed = useCatalog((s) => s.approvals.find((a) =>
|
||
a.run_id === runId && a.node_id === nodeId && a.status === 'pending'))
|
||
const [fetched, setFetched] = useState<Approval | null | undefined>(undefined)
|
||
const [pos, setPos] = useState<{ left: number; top: number; above: boolean } | null>(null)
|
||
const box = useRef<HTMLDivElement>(null)
|
||
|
||
// 全局列表 4 秒轮询一次,刚停下的那一刻它可能还没有这一条:按运行问一次
|
||
useEffect(() => {
|
||
if (listed) return
|
||
let alive = true
|
||
api.approvals.list({ run_id: runId, status: 'pending' })
|
||
.then((list) => { if (alive) setFetched(list.find((a) => a.node_id === nodeId) ?? null) })
|
||
.catch(() => { if (alive) setFetched(null) })
|
||
return () => { alive = false }
|
||
}, [listed, runId, nodeId])
|
||
|
||
useLayoutEffect(() => {
|
||
const r = anchor.getBoundingClientRect()
|
||
const width = 340
|
||
const left = Math.max(8, Math.min(r.left, window.innerWidth - width - 8))
|
||
const below = window.innerHeight - r.bottom
|
||
setPos(below > 320 || below > r.top
|
||
? { left, top: r.bottom + 8, above: false }
|
||
: { left, top: r.top - 8, above: true })
|
||
}, [anchor])
|
||
|
||
// 点外面、按 Esc、滚轮缩放画布都收起:它钉在打开时的屏幕位置上,画布一动就对不上了。
|
||
// 这里的 Esc 只管焦点还在「去审批」按钮上的时候;焦点进了浮层,按键在浮层根上处理
|
||
useEffect(() => {
|
||
const onDown = (e: PointerEvent) => {
|
||
if (box.current?.contains(e.target as Node) || anchor.contains(e.target as Node)) return
|
||
onClose()
|
||
}
|
||
const onKey = (e: KeyboardEvent) => { if (e.key === 'Escape' && !isComposing(e)) onClose() }
|
||
const onWheel = (e: WheelEvent) => { if (!box.current?.contains(e.target as Node)) onClose() }
|
||
document.addEventListener('pointerdown', onDown, true)
|
||
document.addEventListener('keydown', onKey)
|
||
window.addEventListener('wheel', onWheel, { passive: true })
|
||
return () => {
|
||
document.removeEventListener('pointerdown', onDown, true)
|
||
document.removeEventListener('keydown', onKey)
|
||
window.removeEventListener('wheel', onWheel)
|
||
}
|
||
}, [anchor, onClose])
|
||
|
||
const approval = listed ?? fetched
|
||
|
||
// 打开就把焦点送进去:浮层挂在 body 末尾,不送进去的话键盘用户从「去审批」
|
||
// 按 Tab 会跳到下一个节点,永远够不着「通过 / 驳回」。审批卡还在取的时候先
|
||
// 落在浮层本身,取到了再往里送;送进去之后全局列表每轮询一次都换一个对象,
|
||
// 那时不再抢焦点
|
||
const placed = useRef(false)
|
||
useEffect(() => {
|
||
const el = box.current
|
||
if (!pos || !el) return
|
||
if (placed.current && document.activeElement !== el) return
|
||
const first = el.querySelector<HTMLElement>(FOCUSABLE)
|
||
;(first ?? el).focus({ preventScroll: true })
|
||
placed.current = !!first
|
||
}, [pos, approval])
|
||
|
||
// 收起时焦点还在浮层里(或者已经无处可去)就还给「去审批」;批完了按钮也没了,
|
||
// 就还给节点本身。焦点已经去了别处(点了右栏的输入框)的不去抢。卸载时 ref
|
||
// 已经摘掉了,焦点在不在里面靠 focus / blur 记着
|
||
const holding = useRef(false)
|
||
useEffect(() => () => {
|
||
const active = document.activeElement
|
||
if (!holding.current && active && active !== document.body) return
|
||
if (returnTo.current?.isConnected) returnTo.current.focus({ preventScroll: true })
|
||
else anchor.closest<HTMLElement>('.react-flow__node')?.focus({ preventScroll: true })
|
||
}, [anchor, returnTo])
|
||
|
||
if (!pos) return null
|
||
// 挂到 body 上:画布是缩放过的,挂在节点里的话 0.4 倍时整张审批卡小得没法点。
|
||
// React 的合成事件仍会顺着组件树冒到 React Flow 的节点上(点一下就选中节点、
|
||
// 打开检查器),所以在浮层根上把它们截住
|
||
const stop = (e: { stopPropagation: () => void }) => e.stopPropagation()
|
||
// 键盘同理要截住(不然 Enter 会冒到节点上去选中它);截住之前先把 Esc 和
|
||
// Tab 处理掉:Esc 收起,Tab 在浮层里转圈,不从末尾掉出页面
|
||
const onKeyDown = (e: ReactKeyboardEvent<HTMLDivElement>) => {
|
||
e.stopPropagation()
|
||
if (isComposing(e)) return
|
||
if (e.key === 'Escape') {
|
||
e.preventDefault()
|
||
onClose()
|
||
return
|
||
}
|
||
if (e.key !== 'Tab' || !box.current) return
|
||
const items = [...box.current.querySelectorAll<HTMLElement>(FOCUSABLE)]
|
||
if (!items.length) return
|
||
const first = items[0]
|
||
const last = items[items.length - 1]
|
||
const active = document.activeElement
|
||
if (e.shiftKey && (active === first || active === box.current)) {
|
||
e.preventDefault()
|
||
last.focus()
|
||
} else if (!e.shiftKey && active === last) {
|
||
e.preventDefault()
|
||
first.focus()
|
||
}
|
||
}
|
||
return createPortal(
|
||
<div
|
||
ref={box}
|
||
id={id}
|
||
className="nc-pop fade-up nodrag nopan nowheel"
|
||
style={{ left: pos.left, top: pos.top, transform: pos.above ? 'translateY(-100%)' : undefined }}
|
||
role="dialog"
|
||
aria-label="审批卡"
|
||
tabIndex={-1}
|
||
onClick={stop}
|
||
onPointerDown={stop}
|
||
onMouseDown={stop}
|
||
onDoubleClick={stop}
|
||
onKeyDown={onKeyDown}
|
||
onFocus={(e) => { holding.current = true; e.stopPropagation() }}
|
||
onBlur={(e) => {
|
||
if (!box.current?.contains(e.relatedTarget as Node | null)) holding.current = false
|
||
e.stopPropagation()
|
||
}}
|
||
>
|
||
{approval ? (
|
||
<ApprovalCard approval={approval} showWorkflow={false} />
|
||
) : (
|
||
<div className="p-3 text-xs text-dim">
|
||
{approval === null ? '没找到这一步的待审批,可能已经处理过了' : '正在取审批卡…'}
|
||
</div>
|
||
)}
|
||
</div>,
|
||
document.body,
|
||
)
|
||
}
|
||
|
||
// -------------------------------------------------------------------------
|
||
|
||
function NodeCardImpl({ id, data, selected, isConnectable }: NodeProps<FlowNode>) {
|
||
const def = NODE_DEFS[data.nodeType]
|
||
const type = data.nodeType
|
||
const view = useNodeView(id)
|
||
const { state, runtime, trace: nt } = view
|
||
|
||
const runActive = useStudio((s) => s.runPhase !== 'idle')
|
||
const runId = useStudio((s) => s.run?.id ?? null)
|
||
const skewMs = useStudio((s) => s.trace.skewMs ?? 0)
|
||
const timed = useStudio((s) => s.trace.timed)
|
||
const lastReplay = useStudio((s) => s.trace.lastReplay)
|
||
const runClass = useStudio((s) => s.trace.runClass ?? s.run?.run_class)
|
||
const isSelected = useStudio((s) => s.selectedId === id)
|
||
const hasSelection = useStudio((s) => s.selectedId != null)
|
||
const hovered = useStudio((s) => s.hoveredNodeId === id)
|
||
const dimmed = useStudio((s) => s.hoveredNodeId != null && s.hoveredNodeId !== id)
|
||
const focusSeq = useStudio((s) => (s.focusRequest?.id === id ? s.focusRequest.seq : 0))
|
||
const copilotNew = useStudio((s) => s.copilotNew.includes(id))
|
||
const issues = useStudio((s) => issueKey(s.issues, id))
|
||
const snapSig = useStudio((s) => s.runSnapshot?.configs[id])
|
||
const issuance = useStudio((s) =>
|
||
(type === 'output' && issuanceOf(s.events).id === id ? s.trace.issuance : undefined))
|
||
const issuedAt = useStudio((s) => (type === 'output' ? issuanceOf(s.events).at : null))
|
||
const issuanceDetail = useStudio((s) =>
|
||
(type === 'output' ? (s.run?.output as any)?._issuance as Record<string, any> | undefined : undefined))
|
||
// 只有排队中的卡片要知道自己有几路上游,别的卡片不必为改图重跑这一趟
|
||
const fanIn = useStudio((s) => (state === 'queued' ? fanInOf(s.nodes, s.edges)[id] ?? 0 : 0))
|
||
|
||
const Icon = def?.icon ?? Sparkles
|
||
const handles = sourceHandles(type, data.config)
|
||
const summary = summarize(type, data.config)
|
||
const meta = statusMeta(state)
|
||
// 循环容器在两轮之间也是 running,但在跑的是循环体:不转圈、不挂光弧。
|
||
// 回放时取游标那一刻的(航迹上的 looping 是最后的值)
|
||
const executing = state === 'running' && !view.looping
|
||
const card = useRef<HTMLDivElement>(null)
|
||
const approveBtn = useRef<HTMLButtonElement>(null)
|
||
const popId = useId()
|
||
const [approving, setApproving] = useState(false)
|
||
const closeApproval = useCallback(() => setApproving(false), [])
|
||
// 印章能不能点:右栏的出具横幅在不在页面上。悬停时再看——横幅跟着右栏的
|
||
// 视图切换挂上摘下,渲染时看一眼作不了准
|
||
const [stampLink, setStampLink] = useState(false)
|
||
|
||
// 结果是不是拿改动前的配置跑出来的:发起运行时记了一份签名,和现在的比
|
||
const stale = useMemo(
|
||
() => snapSig != null && snapSig !== configSig(data.config),
|
||
[snapSig, data.config],
|
||
)
|
||
|
||
// 进入某个状态的那一下(抖一下、扫一遍、落章)只在实时事件里播。回放、打开
|
||
// 一条历史运行时几十个节点同时落到终态,要是每张都扫一遍就成了烟花
|
||
const prev = useRef<NodeState>(state)
|
||
const entered = useRef<NodeState | null>(null)
|
||
if (prev.current !== state) {
|
||
entered.current = !view.replay && !lastReplay ? state : null
|
||
prev.current = state
|
||
}
|
||
const liveEntry = entered.current === state
|
||
|
||
// 印章同理:跟着实时的出具判定落下来才有落章的动作,否则直接在那儿
|
||
const stampLive = useRef<boolean | null>(null)
|
||
if (issuance?.tier && stampLive.current == null) stampLive.current = !view.replay && !lastReplay
|
||
if (!issuance?.tier) stampLive.current = null
|
||
|
||
// 离开等待(批了、驳了、运行被取消)就把浮层收掉
|
||
useEffect(() => {
|
||
if (state !== 'waiting' || view.replay) setApproving(false)
|
||
}, [state, view.replay])
|
||
|
||
// 协作矩阵从编辑态起就在(那时就是花名册),跑起来只换内容,卡片不长个子
|
||
const agents = data.config.agents as { name?: string; description?: string }[] | undefined
|
||
const roster = useMemo(
|
||
() => (agents ?? []).filter((a) => a.name).map((a) => ({ name: a.name!, description: a.description })),
|
||
[agents],
|
||
)
|
||
const isTeam = type === 'supervisor' && roster.length > 0
|
||
|
||
// 流式正文只在真的在跑时替换摘要位。取消了、跑完了就换回摘要——
|
||
// 正文在右栏和检查器里,卡片上留着 80px 的尾巴只会压住下面的邻居
|
||
const streamText = executing && !view.replay ? (runtime?.tokens || runtime?.thinking || '') : ''
|
||
const thinkingOnly = !!streamText && !runtime?.tokens
|
||
|
||
const reading = readingOf({ state, view, type, config: data.config, skewMs, timed, fanIn })
|
||
|
||
// 编辑态(没有运行)槽里放校验问题,有运行时放遥测
|
||
const [errCount, warnCount, firstIssue] = issues ? issues.split('\u0000') : ['0', '0', '']
|
||
const hasErrors = Number(errCount) > 0
|
||
const hasWarnings = Number(warnCount) > 0
|
||
const editing = !runActive && state === 'idle'
|
||
|
||
// 头部小徽标:执行了几次、重试了几次、配置改过了
|
||
const count = type === 'loop' ? 0 : view.count
|
||
// 回放时只数游标之前的重试(node_retry 日志在航迹里是一段 retry)
|
||
const retries = view.at != null
|
||
? (nt?.segments ?? []).filter((x) => x.kind === 'retry' && x.start <= view.at!).length
|
||
: Math.max(0, (nt?.attempt ?? 1) - 1)
|
||
const taken = view.at != null ? takenAt(nt, view.at) : nt?.takenHandle ?? runtime?.takenHandle
|
||
// 模型名放悬停:槽里放不下 claude-sonnet-4-5 这么长的名字,也不是一眼要看的东西
|
||
const teleTitle = !editing && nt ? [
|
||
nt.model ? `模型 ${nt.model}` : '',
|
||
nt.tokensIn + nt.tokensOut > 0 ? `输入 ${formatNumber(nt.tokensIn)} · 输出 ${formatNumber(nt.tokensOut)} tokens` : '',
|
||
retries > 0 ? `失败后重试了 ${retries} 次` : '',
|
||
].filter(Boolean).join('\n') || undefined : undefined
|
||
|
||
const pin = state === 'failed' || state === 'waiting'
|
||
const tier = view.at != null && issuedAt != null && view.at < issuedAt ? undefined : issuance?.tier
|
||
const tierClass = tier === 'formal' ? 'is-formal' : tier === 'degraded' ? 'is-degraded' : tier === 'withheld' ? 'is-withheld' : ''
|
||
const detail = issuanceDetail?.tier ? issuanceDetail : undefined
|
||
const gaps: string[] = Array.isArray(detail?.gaps) ? detail.gaps.map(String) : []
|
||
const stampTitle = tier ? [
|
||
`出具判定:${issuanceLabel(tier)}`,
|
||
detail ? `回指 ${detail.matched_numbers ?? 0} 个数字 / 核对 ${detail.metrics_checked ?? 0} 个指标` : '',
|
||
// 降档常常不是数字对不上,而是校验根本没跑全(叙述模板渲染为空、指标集为空):
|
||
// 不写出来,悬停在一个「降档出具」上看不到任何理由
|
||
gaps.length ? `校验没跑全:${gaps.join(';')}` : '',
|
||
(detail?.missing_required ?? issuance?.missingRequired ?? []).length
|
||
? `缺必需指标:${(detail?.missing_required ?? issuance?.missingRequired).join('、')}` : '',
|
||
(detail?.unmatched_numbers ?? issuance?.unmatched ?? []).length
|
||
? `无法回指的数字:${(detail?.unmatched_numbers ?? issuance?.unmatched).map((u: any) => u?.token ?? u).join('、')}`
|
||
: issuance?.unmatchedCount ? `无法回指的数字 ${issuance.unmatchedCount} 个` : '',
|
||
(detail?.missing_expected ?? []).length ? `缺数据声明:${detail!.missing_expected.join('、')} 本期缺失` : '',
|
||
runClass === 'exploratory' ? '探索运行的结论不进正式归档' : '',
|
||
'完整判定在右栏运行视图的成果区',
|
||
].filter(Boolean).join('\n') : ''
|
||
|
||
const rank = typeof (data as any).rank === 'number' ? (data as any).rank : undefined
|
||
const style: CSSProperties & Record<string, any> = { width: NODE_WIDTH }
|
||
if (rank != null) style['--rank'] = rank
|
||
|
||
return (
|
||
<div
|
||
ref={card}
|
||
className={clsx(
|
||
`nc nt-${type} node-${state}`,
|
||
liveEntry && 'nc-enter',
|
||
isSelected && 'nc-selected',
|
||
selected && !isSelected && !hasSelection && 'nc-selected',
|
||
hovered && 'nc-hover',
|
||
dimmed && 'nc-dim',
|
||
copilotNew && 'node-copilot-new',
|
||
// 出口一多(92px 高的卡上 5 个起,间距不到 16px),画在线上方的标签会压住
|
||
// 上一条出口的线:改成标签骑在自己那条线上,谁是谁的不会看错
|
||
handles.length >= 5 && 'nc-exits-dense',
|
||
)}
|
||
data-state={state}
|
||
data-type={type}
|
||
style={style}
|
||
>
|
||
{/* 左侧状态槽:线型 / 纹理是颜色之外的第二条通道(色弱、灰度投影下也分得开) */}
|
||
<div className="nc-slot" aria-hidden />
|
||
|
||
{/* 光效层。独立一层,见 index.css 里 .node-fx 的说明 */}
|
||
<div className="node-fx" aria-hidden>
|
||
{executing && (
|
||
<>
|
||
<div className="fx-halo" />
|
||
<div className="fx-clip"><div className="fx-scan" /></div>
|
||
</>
|
||
)}
|
||
<div className="fx-clip">
|
||
<div className="fx-sweep" />
|
||
{liveEntry && state === 'done' && <div className="fx-done" />}
|
||
</div>
|
||
<div className="fx-moment" />
|
||
{focusSeq > 0 && <div key={focusSeq} className="fx-focus" />}
|
||
</div>
|
||
|
||
{def?.hasTarget && (
|
||
<Handle type="target" position={Position.Left} isConnectable={isConnectable} style={{ left: -5 }} />
|
||
)}
|
||
|
||
<div className="nc-content">
|
||
{/* 标题栏:类型色只在图标块和极淡的底色里,边框、光弧一律是状态色 */}
|
||
<div className="nc-head">
|
||
<div className="nc-icon"><Icon size={12} /></div>
|
||
<div className="nc-title">{data.label || def?.label}</div>
|
||
{stale && (
|
||
<span className="nc-chip" title="画布上的配置在这次运行之后改过,这张卡上的结果来自改动前的配置">旧配置</span>
|
||
)}
|
||
{count > 1 && (
|
||
<span className="nc-chip tnum" title={`这次运行里执行了 ${count} 次`}>×{count}</span>
|
||
)}
|
||
{retries > 0 && (
|
||
<span className="nc-chip nc-chip-warn tnum" title={`失败后重试了 ${retries} 次`}>↻{retries}</span>
|
||
)}
|
||
{(runActive || state !== 'idle') && (
|
||
<StatusBadge status={state} size={14} animate={executing} className="nc-badge" />
|
||
)}
|
||
</div>
|
||
|
||
{isTeam ? (
|
||
<TeamMatrix
|
||
roster={roster}
|
||
team={runtime?.team}
|
||
trace={nt}
|
||
live={state === 'running'}
|
||
replay={view.replay}
|
||
at={view.at}
|
||
maxRounds={Number(data.config.max_rounds) || 0}
|
||
maxParallel={Number(data.config.max_parallel) || 0}
|
||
skewMs={skewMs}
|
||
/>
|
||
) : (
|
||
<div className={clsx('nc-body', streamText && 'is-stream')}>
|
||
{streamText ? (
|
||
<div className="nc-stream mono">
|
||
{thinkingOnly && <span className="nc-stream-tag">思考中 · </span>}
|
||
{streamText.slice(-160)}
|
||
</div>
|
||
) : (
|
||
<div className="nc-summary">{summary}</div>
|
||
)}
|
||
</div>
|
||
)}
|
||
|
||
{/* 遥测槽:固定高度。状态文字是第四条通道(剪影、线型、颜色之外) */}
|
||
<div className="nc-tele" title={teleTitle}>
|
||
{editing ? (
|
||
hasErrors || hasWarnings ? (
|
||
<span className={clsx('nc-tele-issue', hasErrors ? 'is-error' : 'is-warning')} title={firstIssue}>
|
||
{firstIssue}
|
||
</span>
|
||
) : (
|
||
<span className="nc-tele-dash">{NONE}</span>
|
||
)
|
||
) : (
|
||
<>
|
||
<span className="nc-tele-state" style={{ color: meta.color }}>{meta.short}</span>
|
||
{reading.main !== '' && <span className="nc-tele-main tnum">{reading.main}</span>}
|
||
{reading.note && (
|
||
<span className="nc-tele-note" title={reading.noteTitle}>{reading.note}</span>
|
||
)}
|
||
<span className="flex-1" />
|
||
{reading.side && <span className="nc-tele-side">{reading.side}</span>}
|
||
{state === 'waiting' && !view.replay && runId && (
|
||
<button
|
||
ref={approveBtn}
|
||
type="button"
|
||
className="nc-approve nodrag nokey"
|
||
onPointerDown={(e) => e.stopPropagation()}
|
||
onClick={(e) => { e.stopPropagation(); setApproving((v) => !v) }}
|
||
aria-haspopup="dialog"
|
||
aria-expanded={approving}
|
||
aria-controls={approving ? popId : undefined}
|
||
>
|
||
去审批
|
||
</button>
|
||
)}
|
||
</>
|
||
)}
|
||
</div>
|
||
</div>
|
||
|
||
{/* 精简档(缩放 0.35–0.6):盒子不变,内容换成大字的标题 + 一个主读数 */}
|
||
<div className="nc-lod" aria-hidden>
|
||
<div className="nc-lod-title">
|
||
{(runActive || state !== 'idle') && <StatusBadge status={state} size={18} animate={false} decorative />}
|
||
<span>{data.label || def?.label}</span>
|
||
</div>
|
||
{/* 这一档只放得下一个读数:状态已经有标题前的剪影、左侧槽和颜色三条通道,
|
||
这里不再写状态字,把位置让给计时、进度;没有读数的状态才写状态字 */}
|
||
<div className="nc-lod-read tnum" style={{ color: state === 'idle' ? undefined : meta.color }}>
|
||
{isTeam && state === 'running'
|
||
? teamBrief(runtime?.team, nt, true, view.at)
|
||
: state === 'idle' ? (runActive ? NONE : '') : reading.main !== '' ? reading.main : meta.short}
|
||
</div>
|
||
</div>
|
||
|
||
{/* 信号档(< 0.35):整张卡成了一块状态色,中间留一枚大号剪影;
|
||
异常节点另挂一枚反向缩放的牌子,任何缩放下都是正常字号 */}
|
||
{(runActive || state !== 'idle') && (
|
||
<div className="nc-sig" aria-hidden>
|
||
<StatusBadge status={state} size={40} animate={false} decorative />
|
||
</div>
|
||
)}
|
||
{pin && (
|
||
<div className="nc-pin" aria-hidden>
|
||
<StatusBadge status={state} size={12} animate={false} decorative />
|
||
<b>{meta.label}</b>
|
||
<span>{data.label || def?.label}</span>
|
||
{state === 'waiting' ? <em className="tnum">{reading.main}</em> : null}
|
||
</div>
|
||
)}
|
||
|
||
{/* 校验问题的角标:error 和 warning 同样醒目,谁也不挡谁 */}
|
||
{(hasErrors || hasWarnings) && (
|
||
<div className="nc-issue" title={firstIssue}>
|
||
{hasErrors && <span className="is-error tnum">✕ {errCount}</span>}
|
||
{hasWarnings && <span className="is-warning tnum">! {warnCount}</span>}
|
||
</div>
|
||
)}
|
||
|
||
{/* 出具印章:成果节点上,跟着 issuance 事件落下。它是一枚章不是按钮:
|
||
只有右栏的出具横幅在页面上时,点它才滚过去(悬停时看一眼,届时才有
|
||
手形光标);没有横幅就是一张带悬停说明的图,不装作能点 */}
|
||
{tier && (
|
||
<span
|
||
role="img"
|
||
aria-label={stampTitle}
|
||
className={clsx('nc-stamp', tierClass, stampLive.current && 'nc-stamp-in', stampLink && 'is-link nodrag')}
|
||
title={stampTitle}
|
||
onPointerEnter={() => setStampLink(!!document.querySelector('[data-issuance-banner]'))}
|
||
onPointerDown={stampLink ? (e) => e.stopPropagation() : undefined}
|
||
onClick={stampLink ? (e) => {
|
||
const banner = document.querySelector('[data-issuance-banner]')
|
||
if (!banner) return
|
||
e.stopPropagation()
|
||
banner.scrollIntoView({ behavior: 'smooth', block: 'center' })
|
||
} : undefined}
|
||
>
|
||
<StatusBadge status={tier === 'formal' ? 'done' : tier === 'withheld' ? 'failed' : 'waiting'} size={11} animate={false} decorative />
|
||
<span aria-hidden>{issuanceLabel(tier)}</span>
|
||
{runClass === 'exploratory' && <small aria-hidden>{RUN_CLASS_LABEL.exploratory} · 不归档</small>}
|
||
</span>
|
||
)}
|
||
|
||
{/* 出口:标签画在出线第一段的上方,不压在线上。跑过之后命中的那条亮起来、
|
||
落空的压暗——六出口的分支节点跑完,不这样的话谁也说不清它到底选了哪条。
|
||
运行前一律中性色:绿色的「通过」挂在还没跑的分支上,读起来像已经通过了 */}
|
||
{handles.map((handle, i) => {
|
||
const top = handles.length === 1 ? '50%' : `${((i + 1) / (handles.length + 1)) * 100}%`
|
||
const hit = taken ? taken === handle.id : null
|
||
return (
|
||
<div key={handle.id}>
|
||
<Handle
|
||
id={handle.id}
|
||
type="source"
|
||
position={Position.Right}
|
||
isConnectable={isConnectable}
|
||
className={clsx(hit === true && 'handle-taken', hit === false && 'handle-idle')}
|
||
style={{ top, right: -5 }}
|
||
/>
|
||
{handle.label && (
|
||
<span
|
||
className={clsx('nc-exit', hit === true && 'is-hit', hit === false && 'is-miss')}
|
||
style={{ top }}
|
||
>
|
||
{handle.label}
|
||
</span>
|
||
)}
|
||
</div>
|
||
)
|
||
})}
|
||
|
||
{approving && runId && card.current && (
|
||
<ApprovalPopover
|
||
id={popId}
|
||
nodeId={id}
|
||
runId={runId}
|
||
anchor={card.current}
|
||
returnTo={approveBtn}
|
||
onClose={closeApproval}
|
||
/>
|
||
)}
|
||
</div>
|
||
)
|
||
}
|
||
|
||
export const NodeCard = memo(NodeCardImpl)
|