Files
knowledge-governance/web/src/WeKnoraMonitor.tsx
T
姚章浩 a1b46d2b7c feat(monitor): 需下架车道可逐条移除测试库知识 —— 补齐最后一个没有页面入口的流程
背景:来源侧被判「禁止导入」后,已建好的测试库知识不会自动消失;此前只有变更集
删除路径会入队 test.remove,页面既列不出条目也没有按钮,运维无法闭环(车道只有按
库计数)。

新增:
- GET /api/v1/test-publications?removal=required:条目级列表,判据与车道计数同源
  (superseded_at IS NULL / 有 knowledge_id / completed / retrieval_state NOT IN
  (disabling,disabled) / policy_state='blocked'),过滤是叠加而不是替换。
- POST /api/v1/test-publications/{id}/removal:engineer 级写路由,要求 Idempotency-Key,
  按条目幂等(operator-remove:<id>);置 disabling 并交既有 test.remove 工作流去删除
  远端知识并读回校验。错误映射 404/409(已移除)/409(不可移除)/501(未接线)。
- 界面:需下架车道逐条显示条目 + 「下架(从测试库移除)」,页内二次确认,成功提示,
  完成后计数归零。

修掉过程中踩到的两个真问题:
1. 二次确认的确认态原先经容器 props 传给视图,一次容器改动把三个 props 丢了 ——
   视图永远渲染原按钮、确认步骤静默消失,而所有静态单元测试仍然通过。改为把确认态
   放在视图内部;并把「取消」放在原按钮位置(真实指针连点两下只会落到取消)。
2. jobs 上有部分唯一索引 UNIQUE (business_change_set_id, business_version_id,
   business_target_kb_id, business_action) WHERE business_change_set_id IS NOT NULL。
   本路径给这三列写空串(非 NULL),('','','','remove') 对所有条目是同一个键 ——
   第一条之后每次 INSERT 都撞唯一索引、被 ON CONFLICT DO NOTHING 静默吞掉,留下
   「状态已 disabling、没有任务」的永久卡死条目,而车道恰好隐藏 disabling,运维也
   看不到。改为写 NULL(语义:无变更集身份)+ 冲突目标收敛到 idempotency_key +
   校验 RowsAffected()(0 行回查既有任务;查不到就报错,不提交无任务的 disabling)。
   卡死状态在重试时可自愈。

测试:internal/platform/postgres/test_publication_removal_integration_test.go(两条发布
各自入队、business_* 为 NULL、卡死自愈;把修复退回旧写法该测试即 FAIL,已实测)、
internal/httpapi/test_publication_removal_test.go(权限/幂等键/错误映射/未接线 501/列表
过滤)、前端 testPublications.test.ts + WeKnoraMonitor.test.tsx。

验收(纯界面,两条都走完):解析监控 → 需下架(2)→ 逐条「下架」+ 二次确认 →
retrieval_state=disabled(PDF 03:57:03Z、md 04:08:55Z),jobs completed(attempt 2,
首次 test_remove_pending=远端仍在处理,重试通过;工作流以 GetKnowledge 读回 404 判
成功)→ 车道需下架(0)。核验「确认前不执行」:首次点击后仍 unpublished、移除任务数仍 1。
2026-10-10 12:10:46 +08:00

479 lines
40 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { useContext, useEffect, useMemo, useState } from 'react'
import { fetchMonitorFiles, fetchMonitorOverview, fetchRunMetrics } from './monitor'
import type { RunMetrics } from './monitor'
import type { KnowledgeProgress, MonitorFilePage, MonitorOverview, MonitorStatus } from './monitor'
import { fetchJobFailures, fetchTestPublications, retryPublication, retryPublicationsBatch, cancelPublicationsBatch, requeueJobFailure, startTestPublications, fetchRemovalRequiredPublications, startPublicationRemoval } from './testPublications'
import type { JobFailure, ProcessingState, TestPublication, TestPublicationPage } from './testPublications'
import { fetchActiveUISettings, settingsRefreshDelays } from './uiSettings'
import { WorkspaceContextTabsSetter } from './workspaceContext'
import './weknoraMonitor.css'
const emptyQueue: TestPublicationPage = { items: [], total: 0, limit: 50, offset: 0 }
const gb = (value: number) => `${(value / 1073741824).toFixed(1)}`
const scope = (value: string) => value === 'internal' ? '对内' : value === 'external' ? '对外' : '混合'
const duration = (seconds: number) => seconds <= 0 ? '完成' : seconds < 60 ? `${seconds}秒` : seconds < 3600 ? `${Math.floor(seconds / 60)}分钟` : `${(seconds / 3600).toFixed(1)}小时`
const statusLabels: Record<MonitorStatus, string> = { completed: 'completed', pending: 'pending', processing: 'processing', finalizing: 'finalizing', failed: 'failed', cancelled: 'cancelled' }
const processingLabels: Record<ProcessingState, string> = { planned: '待入库', pending: '等待解析', processing: '解析中', finalizing: '索引与增强', completed: '成功', failed: '失败', stalled: '停滞', cancelled: '已取消' }
const secondsSince = (iso: string) => Math.max(0, Math.round((Date.now() - new Date(iso).getTime()) / 1000))
const adviceFor = (stage: string, code: string) => {
if (stage === '文档解析') return '建议先在 WeKnora 手动解析该文件确认格式,再决定是否重试。'
if (stage === '索引 / 增强') return '多为 MinerU 容量或超时问题,确认服务恢复接单后重试。'
if (stage === 'WeKnora 上传') return '上传失败,确认 WeKnora 可达后重试;重复提交不会创建第二份知识。'
if (stage === '源头取件') return '文件尚未从源头取回:钉钉来源需可导出的登录会话,AList/PP 需直连可用;恢复后系统会自动重试。'
if (stage === 'Hash / 文件校验' || stage === 'OSS') return '文件或暂存校验问题,重新入队会重新拉取来源文件。'
if (stage === '测试知识移除') return '移除失败,请先在测试知识库确认该文档当前状态。'
if (stage === '治理策略') return '按治理策略阻止,请先在来源目录修正对内/对外标注。'
if (code.includes('429')) return '远端容量已满,恢复后可一键重新入队。'
return '确认错误码后可直接重试;尝试次数耗尽将进入死信队列。'
}
// failureHint turns a dead-letter row's machine code into a plain-Chinese
// diagnosis of what actually went wrong and what to do.
const failureHint = (failure: JobFailure) => {
const detail = `${failure.error_code} ${failure.last_error || ''}`
if (detail.includes('not ingestable')) return '钉钉侧该类型不是可下载文档(快捷方式、占位或内部对象),重试也不会成功;建议用“文件名筛选”把它排除,或在钉钉确认它是否为空目录残留。'
if (detail.includes('source_auth_required')) return '来源存储需要网页登录授权(服务凭据未配置),请联系管理员在“系统设置”重新扫码。'
if (detail.includes('invalid_format')) return '取回的内容不是有效的文档/文本格式,可能源头文件本身损坏;可下载原件确认后重试。'
if (detail.includes('source_unavailable')) return '来源服务当时不可达(网络/接口抖动)。任务若已自动重试成功,这里只是历史记录;仍在列表说明源头仍不可达。'
if (failure.error_code === 'test_upload_remote_failed' || detail.includes('test_upload_remote_failed')) return '向测试知识库上传被拒:确认 WeKnora 测试实例可达、目标知识库未停用后,点击重新入队。'
if (detail.includes('empty_document')) return '钉钉文档正文为空(源头就是空文档),解析器拒收空内容;无需重试,在钉钉里补充内容后重新取件即可。'
if (failure.error_code === 'remote_parse_failed') return '文档解析失败:建议先在 WeKnora 手动解析该文件确认格式,再重新入队。'
if (failure.error_code === 'handler_error') return '处理环节报错,展开原始错误定位;确认原因后可重新入队。'
return `错误码 ${failure.error_code}:确认原因后可重新入队。`
}
const pipelineStages = ['源头取件', 'Hash', 'OSS', '文档解析', 'WeKnora 上传', '索引', '完成']
const stageIndex = (label: string) => label === 'Hash / 文件校验' ? 1 : label === 'OSS' ? 2 : label === '文档解析' ? 3 : label === 'WeKnora 上传' ? 4 : label === '索引 / 增强' || label === '测试知识移除' || label === '治理策略' || label === '处理链路' ? 5 : -1
function chainSteps(item: TestPublication) {
const broken = item.processing_state === 'failed' || item.processing_state === 'stalled'
const stopAt = broken ? stageIndex(failureStage(item)) : -1
const activeAt = item.processing_state === 'completed' ? 7 : item.processing_state === 'finalizing' ? 5 : item.processing_state === 'processing' ? 3 : item.processing_state === 'planned' && !item.can_start ? 0 : item.processing_state === 'pending' ? 1 : 0
return pipelineStages.map((stage, index) => {
if (stopAt >= 0 && index === stopAt) return { stage, state: 'bad' as const }
if (stopAt >= 0) return { stage, state: index < stopAt ? 'done' as const : 'todo' as const }
if (index < activeAt) return { stage, state: 'done' as const }
if (index === activeAt && item.processing_state !== 'pending' && item.processing_state !== 'completed' && item.processing_state !== 'planned') return { stage, state: 'active' as const }
if ((item.processing_state === 'pending' || (item.processing_state === 'planned' && !item.can_start)) && index === 0) return { stage, state: item.can_start || item.processing_state === 'pending' ? 'done' as const : 'active' as const }
return { stage, state: 'todo' as const }
})
}
function failureStage(item: TestPublication) {
const code = item.last_error
if (code.includes('artifact') || code.includes('fetch')) return '源头取件'
if (code.includes('hash')) return 'Hash / 文件校验'
if (code.includes('oss')) return 'OSS'
if (code.includes('upload')) return 'WeKnora 上传'
if (code.includes('parse')) return '文档解析'
if (code.includes('stalled') || code.includes('index')) return '索引 / 增强'
if (code.includes('removal')) return '测试知识移除'
if (code.includes('blocked')) return '治理策略'
return item.processing_state === 'failed' ? '处理链路' : '—'
}
interface ViewProps {
overview: MonitorOverview | null
files: MonitorFilePage | null
queue?: TestPublicationPage
plans?: TestPublication[]
attention?: TestPublication[]
loadingMore?: boolean
selectedKB: KnowledgeProgress | null
status: MonitorStatus | ''
queueStatus?: ProcessingState | ''
queueScope?: 'internal' | 'external' | ''
loading: boolean
error: string | null
retryingIDs?: string[]
requeueingIDs?: string[]
cancellingIDs?: string[]
starting?: boolean
startMessage?: string
batchMessage?: string
failures?: JobFailure[]
metrics?: RunMetrics | null
onSelectKB: (kb: KnowledgeProgress) => void
onStatus: (status: MonitorStatus | '') => void
onQueueStatus: (value: ProcessingState | '') => void
onQueueScope: (value: 'internal' | 'external' | '') => void
lane?: string
onLaneChange?: (lane: string) => void
onRetry?: (id: string) => void
onBatchRetry?: (ids: string[]) => void
onBatchCancel?: (ids: string[]) => void
onRequeueFailure?: (id: string) => void
onStart?: (ids: string[]) => void
onLoadMore?: () => void
onRefresh: () => void
/** 需下架车道的条目列表(被禁止导入但仍存活在测试库),以及移除动作。 */
removalItems?: TestPublication[]
removalBusyIDs?: string[]
removalMessage?: string
onStartRemoval?: (id: string) => void
}
export function WeKnoraMonitorView({
overview,
files,
queue = emptyQueue,
plans = queue.items,
attention,
selectedKB,
status,
queueStatus = '',
queueScope = '',
lane = 'waiting',
onLaneChange = () => undefined,
loading,
error,
retryingIDs = [],
requeueingIDs = [],
cancellingIDs = [],
starting = false,
loadingMore = false,
startMessage = '',
batchMessage = '',
failures = [],
metrics = null,
onSelectKB,
onStatus,
onQueueStatus = () => undefined,
onQueueScope = () => undefined,
onRetry = () => undefined,
onBatchRetry = () => undefined,
onBatchCancel = () => undefined,
onRequeueFailure = () => undefined,
onStart = () => undefined,
onLoadMore = () => undefined,
onRefresh,
removalItems = [],
removalBusyIDs = [],
removalMessage = '',
onStartRemoval = () => undefined,
}: ViewProps) {
const [selectedStartIDs, setSelectedStartIDs] = useState<string[]>([])
const [selectedRetryIDs, setSelectedRetryIDs] = useState<string[]>([])
// 破坏性动作的二次确认状态放在视图内部:容器漏传参也不会把"确认"这一步静默降级掉。
const [confirmRemovalID, setConfirmRemovalID] = useState('')
const toggleStartSelection = (id: string) => setSelectedStartIDs((current) => current.includes(id) ? current.filter((value) => value !== id) : [...current, id])
const toggleRetrySelection = (id: string) => setSelectedRetryIDs((current) => current.includes(id) ? current.filter((value) => value !== id) : [...current, id])
const stages: Array<[MonitorStatus, number]> = selectedKB ? [
['completed', selectedKB.completed], ['pending', selectedKB.pending], ['finalizing', selectedKB.finalizing],
['processing', selectedKB.processing], ['failed', selectedKB.failed], ['cancelled', selectedKB.cancelled],
] : []
const orderedQueue = useMemo(() => [...queue.items].sort((left, right) => {
const priority = (item: TestPublication) => item.processing_state === 'failed' || item.processing_state === 'stalled' ? 0 : 1
return priority(left) - priority(right)
}), [queue.items])
// Batch actions must target every failing item the lane shows, not just the
// rows that happen to sit inside the current queue page.
const retryableIDs = (attention ?? queue.items).filter((item) => item.can_retry).map((item) => item.id)
const batchTargets = selectedRetryIDs.length ? retryableIDs.filter((id) => selectedRetryIDs.includes(id)) : retryableIDs
const startablePlans = plans.filter((item) => item.can_start)
const startTargets = selectedStartIDs.length ? startablePlans.filter((item) => selectedStartIDs.includes(item.id)).map((item) => item.id) : startablePlans.map((item) => item.id)
// Failures needing a human must never be hidden by the queue page window:
// prefer the dedicated attention fetch, fall back to the visible page.
const attentionItems = (attention ?? queue.items).filter((item) => item.processing_state === 'failed' || item.processing_state === 'stalled')
const inflightItems = queue.items.filter((item) => item.processing_state === 'processing' || item.processing_state === 'finalizing' || (item.processing_state === 'pending' && !item.can_start))
const doneItems = queue.items.filter((item) => item.processing_state === 'completed')
const plannedItems = queue.items.filter((item) => item.processing_state === 'planned')
const fetchingPlanned = plannedItems.filter((item) => !item.can_start)
const laneCounts: Record<string, number> = {
waiting: startablePlans.length + fetchingPlanned.length,
attention: attentionItems.length + failures.length,
removal: (overview?.knowledge_bases || []).reduce((total, kb) => total + (kb.needs_removal || 0), 0),
inflight: inflightItems.length,
done: doneItems.length,
queue: queue.total,
}
const laneTitles: Record<string, string> = { waiting: '待入库', attention: '需人工处理', removal: '需下架', inflight: '处理中', done: '已完成', queue: '全部任务' }
const actionTask = (item: TestPublication) => <article className="inbox-task" key={item.id}>
<div className="inbox-task-mark">{item.can_start ? <input type="checkbox" aria-label={`选择入库${item.title}`} checked={selectedStartIDs.length === 0 || selectedStartIDs.includes(item.id)} onChange={() => toggleStartSelection(item.id)} /> : item.can_retry ? <input type="checkbox" aria-label={`选择重试${item.title}`} checked={selectedRetryIDs.includes(item.id)} onChange={() => toggleRetrySelection(item.id)} /> : null}</div>
<div>
<h4>{item.title} <span className={`scope-badge ${item.target_scope}`}>{scope(item.target_scope)}</span> {item.change_type === 'added' ? <span className="task-badge add">新增</span> : item.change_type === 'updated' ? <span className="task-badge update">更新</span> : null}</h4>
<div className="why">{item.processing_state === 'failed' || item.processing_state === 'stalled' ? <>{item.processing_state === 'stalled' ? '任务停滞:' : '为什么失败:'}错误码 <code>{item.last_error || '—'}</code> · 第{item.retry_count + 1}次尝试 · 已停留{duration(secondsSince(item.updated_at))} · 失败阶段 {failureStage(item)}</> : <>状态 <code>{processingLabels[item.processing_state]}</code>{item.last_error ? <> · 最近错误 <code>{item.last_error}</code></> : null} · 已停留{duration(secondsSince(item.updated_at))}</>}</div>
<div className="task-chain" aria-label={`处理链${item.title}`}>{chainSteps(item).map((step) => <span key={step.stage} className={`chain-step ${step.state}`}>{step.stage}{step.state === 'done' ? ' ✓' : step.state === 'bad' ? ' ✗' : step.state === 'active' ? ` 中 ${duration(secondsSince(item.updated_at))}` : ''}</span>)}</div>
<div className={item.processing_state === 'failed' || item.processing_state === 'stalled' ? 'errline' : 'tiny muted-line'}>{item.processing_state === 'failed' || item.processing_state === 'stalled' ? adviceFor(failureStage(item), item.last_error) : item.processing_state === 'planned' && !item.can_start ? '正在从源头取回文件,完成后自动进入可处理状态' : item.can_start ? '文件已就绪,等待开始处理' : '无需操作,等待自动处理'} · <code>{item.id}</code></div>
</div>
<div className="inbox-task-actions">{item.can_retry ? <button className="primary" disabled={retryingIDs.includes(item.id)} onClick={() => onRetry(item.id)}>{retryingIDs.includes(item.id) ? '重试中…' : '重试'}</button> : null}{item.can_retry ? <button disabled={cancellingIDs.includes(item.id) || retryingIDs.length > 0} title="不再自动重试;原始记录保留,重新标记入库可再次处理" onClick={() => onBatchCancel([item.id])}>{cancellingIDs.includes(item.id) ? '取消中…' : '不再处理'}</button> : null}</div>
</article>
const emptyLane = (text: string) => <div className="empty-state">{text}</div>
return <main className="page-shell weknora-monitor inbox-layout">
<header className="hero compact"><div><h1>解析监控</h1><p className="subtitle">站在知识库视角看差异:来源与目录里标好的对内/对外文件应不应该在这里,还差哪一步,一目了然。</p></div><span className="monitor-meta">{overview ? `快照 ${new Date(overview.observed_at).toLocaleString('zh-CN', { hour12: false })}` : ''} · 队列 等待{queue.total}条{overview?.pipeline ? ` · 取件中 ${overview.pipeline.fetch_pending}${overview.pipeline.fetch_failed ? ` · 取件失败 ${overview.pipeline.fetch_failed}` : ''}` : ''}</span><button onClick={onRefresh} disabled={loading}>{loading ? '刷新中…' : '刷新'}</button></header>
{error ? <div className="error-banner" role="alert">{error}</div> : null}
{overview?.simulated ? <div className="simulation-banner"><strong>本地模拟数据</strong><span>资源和知识库汇总用于确认页面流程,不代表测试服务器真实数据;任务卡片来自真实治理 API。</span></div> : null}
<div className="inbox-grid">
<nav className="inbox-nav" aria-label="解析监控收件箱">
<h2>知识库差异</h2>
{[['waiting', '待入库', 'blocked'], ['attention', '需人工处理', ''], ['removal', '需下架', ''], ['inflight', '处理中', ''], ['done', '已完成', 'okall']].map(([value, label, tone]) => <button key={value} className={`${lane === value ? 'active' : ''} ${laneCounts[value] ? tone : ''}`} aria-label={`切换到${label}`} onClick={() => onLaneChange(value)}><span>{label}</span><em className="lane-count">{laneCounts[value]}</em></button>)}
<button className={`${lane === 'queue' ? 'active' : ''}`} aria-label="切换到全部任务" onClick={() => onLaneChange('queue')}><span>全部任务</span><em className="lane-count">{queue.total}</em></button>
</nav>
<div className="inbox-work">
{lane === 'waiting' ? <section className="inbox-section" aria-label="待入库">
<div className="section-head"><h2>待入库({startablePlans.length + fetchingPlanned.length})</h2><span className="spacer" /><button className="primary" disabled={starting || !startTargets.length} onClick={() => onStart(startTargets)}>{starting ? '正在生成任务…' : `开始处理(${startTargets.length})`}</button></div>
<p className="tiny">来源目录中标记对内/对外的文件会自动出现在这里;“开始处理”按系统设置的并发上限(当前 {overview?.pipeline?.concurrency ?? 2})创建解析任务,无需再确认。</p>
{startMessage ? <p className="difference-message" role="status">{startMessage}</p> : null}
{plannedItems.length ? plannedItems.map(actionTask) : emptyLane('还没有标记入库的文件。去“来源与目录”把文件或目录标为对内/对外即可。')}
{fetchingPlanned.length ? <p className="tiny">其中 {fetchingPlanned.length} 项仍在从源头取件,取回后自动可处理。</p> : null}
</section> : null}
{lane === 'attention' ? <section className="inbox-section" aria-label="需人工处理">
<div className="section-head"><h2>需要你出手({attentionItems.length})</h2><span className="spacer" /><button disabled={!batchTargets.length || cancellingIDs.length > 0 || retryingIDs.length > 0} title="不再自动重试(如源头就是空文档);原始记录保留,重新标记入库可再次处理" onClick={() => onBatchCancel(batchTargets)}>{cancellingIDs.length ? '取消中…' : `批量取消所选(${batchTargets.length})`}</button><button className="danger" disabled={!batchTargets.length || retryingIDs.length > 0} onClick={() => onBatchRetry(batchTargets)}>{retryingIDs.length ? '重试中…' : `批量重试所选(${batchTargets.length})`}</button></div>
{batchMessage ? <p className="queue-batch-message" role="status">{batchMessage}</p> : null}
{attentionItems.length ? attentionItems.map(actionTask) : emptyLane('没有失败或停滞的任务。')}
<div className="section-head sub"><h3>死信(重试次数用完,系统不再自动处理)</h3><span className="tiny">“源头取件”=从钉钉/AList 把原始文件拉回本地;“上传解析”=把文件送进知识库做解析。死信只是失败任务的登记表,不会改动原始记录;重新入队=再给它一次机会</span></div>
{failures.length ? <ul className="dlq-list">{failures.map((failure) => <li key={failure.id}><span className="monitor-status failed">{failure.error_code}</span><b>{failure.job_type === 'test.upload' ? '上传解析' : failure.job_type === 'artifact.fetch' ? '源头取件' : failure.job_type}</b>{failure.doc_name ? <b>「{failure.doc_name}」</b> : failure.publication_id ? <code>{failure.publication_id}</code> : null}<small>{failure.attempt}/{failure.max_attempts_at_failure} 次 · {new Date(failure.created_at).toLocaleString('zh-CN', { hour12: false })}</small><small>{failureHint(failure)}</small>{failure.job_type === 'artifact.fetch' ? <button disabled={requeueingIDs.includes(failure.id)} onClick={() => onRequeueFailure(failure.id)}>{requeueingIDs.includes(failure.id) ? '重排中…' : '重新入队'}</button> : failure.publication_id ? <button disabled={retryingIDs.includes(failure.publication_id)} onClick={() => onBatchRetry([failure.publication_id as string])}>重新入队</button> : null}</li>)}</ul> : emptyLane('当前没有等待处理的死信记录。')}
</section> : null}
{lane === 'removal' ? <section className="inbox-section" aria-label="需下架">
<div className="section-head"><h2>需下架({laneCounts.removal})</h2><span className="tiny">来源目录里被改为“禁止导入”或撤销标注、但仍在知识库中可检索的文件</span></div>
{removalMessage ? <p className="tiny" role="status">{removalMessage}</p> : null}
{removalItems.length ? <ul className="dlq-list">{removalItems.map((item) => <li key={item.id}><span className="monitor-status failed">需下架</span><b>「{item.title}」</b><small>{scope(item.target_scope)} · 知识仍在测试库中可检索</small>{confirmRemovalID === item.id ? <><button onClick={() => setConfirmRemovalID('')}>取消</button><button disabled={removalBusyIDs.includes(item.id)} onClick={() => { setConfirmRemovalID(''); onStartRemoval(item.id) }}>{removalBusyIDs.includes(item.id) ? '下架中…' : '确认下架(从测试库移除)'}</button></> : <button disabled={removalBusyIDs.includes(item.id)} onClick={() => setConfirmRemovalID(item.id)}>下架(从测试库移除)</button>}</li>)}</ul> : null}
{(overview?.knowledge_bases || []).some((kb) => kb.needs_removal > 0) ? <ul className="dlq-list">{(overview?.knowledge_bases || []).filter((kb) => kb.needs_removal > 0).map((kb) => <li key={kb.id}><span className="monitor-status failed">需下架</span><b>{kb.name}</b><small>{kb.needs_removal} 份仍在检索中</small></li>)}</ul> : removalItems.length ? null : emptyLane('没有标注为禁止但仍留在知识库里的文件。')}
<p className="tiny">这里只负责把差异暴露出来:来源项被判“禁止导入”后,仍存活在测试库里的知识必须移除。逐条点“下架(从测试库移除)”并二次确认后,走 <code>test.remove</code> 工作流删除测试库里的知识条目(会读回校验;重新标注后可再次入库,不影响生产知识库)。</p>
</section> : null}
{lane === 'inflight' ? <section className="inbox-section" aria-label="处理中">
<div className="section-head"><h2>处理中({inflightItems.length})</h2><span className="tiny">无需操作,仅供查看</span></div>
{inflightItems.length ? inflightItems.map(actionTask) : emptyLane('当前没有正在处理或索引增强的任务。')}
{overview ? <>
<div className="pipeline-strip" aria-label="解析处理链">源头取件 → Hash → OSS → 文档解析 → WeKnora 上传 → 索引 → 完成</div>
<div className="monitor-kb-layout" id="monitor-kb-progress">
<aside className="monitor-kb-list"><h2>知识库解析进度</h2>{overview.knowledge_bases.map((kb) => <button key={kb.id} className={selectedKB?.id === kb.id ? 'active' : ''} onClick={() => onSelectKB(kb)}><span><b>{kb.name}</b><small>{scope(kb.visibility)} · 已导入 {kb.imported}{kb.planned ? ` · 待入库 ${kb.planned}` : ''}</small></span><strong>{kb.completed}完成</strong></button>)}</aside>
<div className="monitor-kb-detail">{selectedKB ? <>
<div className="monitor-kb-heading"><div><h2>{selectedKB.name}</h2><span>{scope(selectedKB.visibility)} · 已导入 {selectedKB.imported}{selectedKB.planned ? ` · 待入库 ${selectedKB.planned}` : ''}</span></div><div><span>对内 {selectedKB.internal_completed} / {selectedKB.internal_imported}</span><span>对外 {selectedKB.external_completed} / {selectedKB.external_imported}</span></div></div>
<div className="monitor-stage-tabs"><button className={status === '' ? 'active' : ''} onClick={() => onStatus('')}>全部 {selectedKB.imported}</button>{stages.filter(([, count]) => count > 0).map(([value, count]) => <button className={status === value ? 'active' : ''} key={value} onClick={() => onStatus(value)}>{statusLabels[value]} {count}</button>)}</div>
<p className="finalizing-note"><b>finalizing:</b>基础解析、切片和向量通常已完成,Wiki、摘要或图谱仍在生成;不能算全部完成。</p>
{files?.sample_only ? <p className="sample-note">当前只展示本地模拟文件样例;真实模式会列出所选状态下的实际文件。</p> : null}
{files?.items.length ? <div className="monitor-file-wrap"><table className="monitor-file-table"><thead><tr><th>文件名</th><th>来源目录</th><th>对内/对外</th><th>当前阶段</th><th>已停留</th><th>说明</th></tr></thead><tbody>{files.items.map((file) => <tr key={`${file.name}-${file.status}`}><td>{file.name}</td><td>{file.directory}</td><td><span className={`scope-badge ${file.visibility}`}>{scope(file.visibility)}</span></td><td><span className={`monitor-status ${file.status}`}>{file.status}</span></td><td>{duration(file.elapsed_seconds)}</td><td>{file.stage_detail}{file.error_code ? <small>{file.error_code}</small> : null}</td></tr>)}</tbody></table></div> : !loading ? <div className="empty-state">当前筛选没有文件。</div> : null}
</> : null}</div>
</div>
</> : null}
</section> : null}
{lane === 'done' ? <section className="inbox-section" aria-label="已完成">
<div className="section-head"><h2>已完成({doneItems.length})</h2><span className="tiny">最近一页数据中的成功任务</span></div>
{doneItems.length ? doneItems.map(actionTask) : emptyLane('当前页没有已完成任务;用全部任务视图翻页查看。')}
</section> : null}
{lane === 'queue' ? <section className="inbox-section" aria-label="全部任务">
<div className="section-head"><h2>全部任务({queue.total})</h2><span className="spacer" /><label>目标知识库<select aria-label="队列目标知识库" value={queueScope} onChange={(event) => onQueueScope(event.target.value as 'internal' | 'external' | '')}><option value="">内/外全部</option><option value="internal">对内知识库</option><option value="external">对外知识库</option></select><select aria-label="队列状态" value={queueStatus} onChange={(event) => onQueueStatus(event.target.value as ProcessingState | '')}><option value="">全部状态</option><option value="planned">待入库</option><option value="pending">等待解析</option><option value="processing">解析中</option><option value="finalizing">索引与增强</option><option value="completed">成功</option><option value="failed">失败</option><option value="stalled">停滞</option><option value="cancelled">已取消</option></select></label></div>
{orderedQueue.length ? orderedQueue.map(actionTask) : !loading ? emptyLane('当前筛选没有解析任务。') : null}
{queue.items.length < queue.total ? <div className="queue-more"><span>已显示 {queue.items.length} / 共 {queue.total}</span><button type="button" disabled={loadingMore} onClick={() => onLoadMore?.()}>{loadingMore ? '加载中…' : '加载更多'}</button></div> : null}
</section> : null}
{metrics ? <footer className="monitor-strip" aria-label="真实运行指标"><div>1小时·成功 <b className={metrics.short_window.failure_rate !== null && metrics.short_window.failure_rate > 5 ? 'bad' : 'good'}>{metrics.short_window.success_rate === null ? '数据不足' : `${metrics.short_window.success_rate}%`}</b></div><div>24小时·成功 <b>{metrics.long_window.success_rate === null ? '数据不足' : `${metrics.long_window.success_rate}%`}</b></div><div>p50 {metrics.short_window.duration_p50_seconds === null ? '—' : duration(Math.round(metrics.short_window.duration_p50_seconds))} · p95 {metrics.short_window.duration_p95_seconds === null ? '—' : duration(Math.round(metrics.short_window.duration_p95_seconds))}</div><div>Worker {metrics.active_workers} · 等待 {metrics.queue.pending} · 运行 {metrics.queue.running}{metrics.queue.failed ? <span className="bad"> · 失败 {metrics.queue.failed}</span> : null}</div>{overview?.health.map((service) => <div key={service.key}>{service.name} <b className={service.readiness === 'ready' ? 'good' : service.readiness === 'blocked' || service.readiness === 'down' ? 'bad' : ''}>{service.readiness === 'ready' ? '可接单' : service.readiness === 'degraded' ? '降级' : service.readiness === 'not_configured' ? '未配置' : service.readiness === 'down' ? '不可达' : '阻断'}</b></div>)}{overview ? <div>CPU {overview.host.cpu_percent.toFixed(0)}% · 内存 {gb(overview.host.memory_used_bytes)}/{gb(overview.host.memory_total_bytes)}GB</div> : null}</footer> : null}
</div>
</div>
</main>
}
export function WeKnoraMonitor() {
const [overview, setOverview] = useState<MonitorOverview | null>(null)
const [selected, setSelected] = useState<KnowledgeProgress | null>(null)
const [files, setFiles] = useState<MonitorFilePage | null>(null)
const [queue, setQueue] = useState<TestPublicationPage>(emptyQueue)
const [plans, setPlans] = useState<TestPublication[]>([])
const [status, setStatus] = useState<MonitorStatus | ''>('')
const [queueStatus, setQueueStatus] = useState<ProcessingState | ''>('')
const [queueScope, setQueueScope] = useState<'internal' | 'external' | ''>('')
const [lane, setLane] = useState<'waiting' | 'attention' | 'removal' | 'inflight' | 'done' | 'queue'>('waiting')
const [loading, setLoading] = useState(true)
const [error, setError] = useState<string | null>(null)
const [documentRevision, setDocumentRevision] = useState(0)
const [resourceRevision, setResourceRevision] = useState(0)
const [documentRefreshMs, setDocumentRefreshMs] = useState(15000)
const [resourceRefreshMs, setResourceRefreshMs] = useState(30000)
const [retryingIDs, setRetryingIDs] = useState<string[]>([])
const [requeueingIDs, setRequeueingIDs] = useState<string[]>([])
const [cancellingIDs, setCancellingIDs] = useState<string[]>([])
const [starting, setStarting] = useState(false)
const [startMessage, setStartMessage] = useState('')
const [batchMessage, setBatchMessage] = useState('')
const [failures, setFailures] = useState<JobFailure[]>([])
const [attention, setAttention] = useState<TestPublication[] | null>(null)
const [removalItems, setRemovalItems] = useState<TestPublication[]>([])
const [removalBusyIDs, setRemovalBusyIDs] = useState<string[]>([])
const [removalMessage, setRemovalMessage] = useState('')
const [loadingMore, setLoadingMore] = useState(false)
const [metrics, setMetrics] = useState<RunMetrics | null>(null)
const setContextTabs = useContext(WorkspaceContextTabsSetter)
useEffect(() => {
const controller = new AbortController()
void fetchActiveUISettings(controller.signal).then((active) => {
const delays = settingsRefreshDelays(active)
if (!controller.signal.aborted) { setDocumentRefreshMs(delays.documentMs); setResourceRefreshMs(delays.resourceMs) }
}).catch((cause) => { if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : '加载刷新设置失败') })
return () => controller.abort()
}, [])
useEffect(() => {
const controller = new AbortController(); setLoading(true)
void fetchMonitorOverview(controller.signal).then((result) => {
if (controller.signal.aborted) return
setOverview(result)
setSelected((current) => current && result.knowledge_bases.find((kb) => kb.id === current.id) || result.knowledge_bases[0] || null)
setError(null)
}).catch((cause) => { if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : '加载资源监控失败') }).finally(() => { if (!controller.signal.aborted) setLoading(false) })
return () => controller.abort()
}, [resourceRevision])
useEffect(() => {
const controller = new AbortController(); setLoading(true)
void Promise.all([
fetchTestPublications({ processing_state: queueStatus, target_scope: queueScope, limit: 50, offset: 0 }, controller.signal),
fetchTestPublications({ processing_state: 'planned', limit: 100, offset: 0 }, controller.signal),
fetchTestPublications({ processing_state: ['failed', 'stalled'], limit: 100, offset: 0 }, controller.signal),
fetchRemovalRequiredPublications(controller.signal),
]).then(([queuePage, planPage, attentionPage, removalPage]) => {
if (!controller.signal.aborted) { setQueue(queuePage); setPlans(planPage.items); setAttention(attentionPage.items); setRemovalItems(removalPage.items); setError(null) }
}).catch((cause) => { if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : '加载解析队列失败') }).finally(() => { if (!controller.signal.aborted) setLoading(false) })
return () => controller.abort()
}, [queueStatus, queueScope, documentRevision])
useEffect(() => {
if (!selected) return
const controller = new AbortController()
setLoading(true)
void fetchMonitorFiles(selected.id, status, 20, 0, controller.signal).then((result) => {
if (!controller.signal.aborted) setFiles(result)
}).catch((cause) => {
if (!controller.signal.aborted) setError(cause instanceof Error ? cause.message : '加载文档阶段失败')
}).finally(() => {
if (!controller.signal.aborted) setLoading(false)
})
return () => controller.abort()
}, [selected, status, documentRevision])
useEffect(() => {
const timer = window.setTimeout(() => setDocumentRevision((value) => value + 1), documentRefreshMs)
return () => window.clearTimeout(timer)
}, [documentRevision, documentRefreshMs])
useEffect(() => {
const timer = window.setTimeout(() => setResourceRevision((value) => value + 1), resourceRefreshMs)
return () => window.clearTimeout(timer)
}, [resourceRevision, resourceRefreshMs])
useEffect(() => {
setContextTabs(selected ? [{ key: selected.id, label: selected.name, onActivate: () => setStatus('') }] : [])
return () => setContextTabs([])
}, [selected, setContextTabs])
useEffect(() => {
const controller = new AbortController()
void fetchJobFailures(controller.signal).then((items) => { if (!controller.signal.aborted) setFailures(items) }).catch(() => undefined)
return () => controller.abort()
}, [documentRevision, resourceRevision])
useEffect(() => {
const controller = new AbortController()
void fetchRunMetrics(controller.signal).then((result) => { if (!controller.signal.aborted) setMetrics(result) }).catch(() => undefined)
return () => controller.abort()
}, [documentRevision, resourceRevision])
const requeueFailure = async (failureID: string) => {
setRequeueingIDs((current) => [...current, failureID])
setBatchMessage('')
try {
const result = await requeueJobFailure(failureID, '源头取件死信重新入队')
setError(null)
setBatchMessage(result.already_queued
? `该取件任务已在队列中(第 ${result.round} 轮)`
: `已重新入队:${result.doc_name || result.version_id.slice(0, 12)}(第 ${result.round} 轮取件),取回后自动进入待入库`)
setDocumentRevision((value) => value + 1)
} catch (cause) {
setError(cause instanceof Error ? cause.message : '重新取件失败')
} finally {
setRequeueingIDs((current) => current.filter((value) => value !== failureID))
}
}
const retryOne = async (id: string) => {
setRetryingIDs((current) => [...current, id])
try {
await retryPublication(id)
setError(null)
setDocumentRevision((value) => value + 1)
} catch (cause) {
setError(cause instanceof Error ? cause.message : '重试失败')
} finally {
setRetryingIDs((current) => current.filter((value) => value !== id))
}
}
// 需下架 → 移除:把被禁止导入、但仍存活在测试库的知识交给既有的 test.remove 工作流。
const startRemoval = async (id: string) => {
if (removalBusyIDs.includes(id)) return
setRemovalBusyIDs((current: string[]) => [...current, id])
setRemovalMessage('')
try {
await startPublicationRemoval(id)
setRemovalMessage('已受理下架:正在移除测试库中的知识条目,完成后本条会从「需下架」消失。')
setDocumentRevision((value) => value + 1)
} catch (cause) {
setRemovalMessage(cause instanceof Error ? cause.message : '触发下架失败')
} finally {
setRemovalBusyIDs((current: string[]) => current.filter((value) => value !== id))
}
}
const loadMoreQueue = async () => {
if (loadingMore) return
setLoadingMore(true)
try {
const next = await fetchTestPublications({ processing_state: queueStatus, target_scope: queueScope, limit: 50, offset: queue.items.length })
setQueue((current) => {
const seen = new Set(current.items.map((item) => item.id))
return { ...next, offset: 0, items: [...current.items, ...next.items.filter((item) => !seen.has(item.id))] }
})
setError(null)
} catch (cause) {
setError(cause instanceof Error ? cause.message : '加载更多失败')
} finally {
setLoadingMore(false)
}
}
const retryBatch = async (ids: string[]) => {
setRetryingIDs(ids)
setBatchMessage('')
try {
const result = await retryPublicationsBatch(ids, '解析队列批量重试')
setError(null)
const skipped = result.already_running + result.not_retryable
setBatchMessage(`已重新入队 ${result.started} 项${skipped ? `,跳过 ${skipped} 项(处理中或不可重试)` : ''}`)
setDocumentRevision((value) => value + 1)
} catch (cause) {
setError(cause instanceof Error ? cause.message : '批量重试失败')
} finally {
setRetryingIDs([])
}
}
const cancelBatch = async (ids: string[]) => {
setCancellingIDs(ids)
setBatchMessage('')
try {
const result = await cancelPublicationsBatch(ids, '解析队列批量取消(不再重试)')
setError(null)
const skipped = result.already_running + result.not_retryable
setBatchMessage(`已取消 ${result.started} 项,不再自动重试${skipped ? `,跳过 ${skipped} 项(处理中或不可取消)` : ''};原始记录未删除,重新标记入库可再次处理`)
setDocumentRevision((value) => value + 1)
} catch (cause) {
setError(cause instanceof Error ? cause.message : '批量取消失败')
} finally {
setCancellingIDs([])
}
}
const startPlans = async (ids: string[]) => {
setStarting(true)
setStartMessage('')
try {
const result = await startTestPublications(ids, '开始处理')
setStartMessage(`已提交 ${result.selected} 项;新建解析任务 ${result.started} 项;已在队列 ${result.already_started} 项;不可处理 ${result.unavailable} 项(多为源头取件未完成,稍后自动重试)。`)
setError(null)
setDocumentRevision((value) => value + 1)
} catch (cause) {
setStartMessage(cause instanceof Error ? cause.message : '开始处理失败')
} finally {
setStarting(false)
}
}
return <WeKnoraMonitorView overview={overview} files={files} queue={queue} plans={plans} selectedKB={selected} status={status} queueStatus={queueStatus} queueScope={queueScope} loading={loading} error={error} retryingIDs={retryingIDs} requeueingIDs={requeueingIDs} cancellingIDs={cancellingIDs} starting={starting} startMessage={startMessage} batchMessage={batchMessage} failures={failures} metrics={metrics} onSelectKB={(kb) => { setSelected(kb); setStatus(''); setFiles(null) }} onStatus={(value) => { setStatus(value); setFiles(null) }} onQueueStatus={setQueueStatus} onQueueScope={setQueueScope} lane={lane} onLaneChange={(value) => setLane(value as typeof lane)} onRetry={(id) => void retryOne(id)} onBatchRetry={(ids) => void retryBatch(ids)} onBatchCancel={(ids) => void cancelBatch(ids)} onRequeueFailure={(id) => void requeueFailure(id)} onStart={(ids) => void startPlans(ids)} attention={attention ?? undefined} loadingMore={loadingMore} onLoadMore={() => void loadMoreQueue()} onRefresh={() => { setDocumentRevision((value) => value + 1); setResourceRevision((value) => value + 1) }} removalItems={removalItems} removalBusyIDs={removalBusyIDs} removalMessage={removalMessage} onStartRemoval={(id) => void startRemoval(id)} />
}