Files
knowledge-governance/web/src/ReleaseTargets.tsx
T
姚章浩 0cc3cac837
build / build (push) Successful in 1m47s
feat(release): 发布管理显示真实测试库名
业务名「对内知识库」在 WeKnora 里叫 wiki-demo,两边对不上号。
页面从测试知识库绑定读取库名并拼在业务名后,读不到就只显示业务名,
不影响发布状态判定。
2026-11-17 14:42:04 +08:00

2567 lines
105 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 { useCallback, useEffect, useRef, useState } from 'react'
import {
createLibraryRestoreAuthorization,
createLibrarySyncAuthorization,
enqueueLibraryBaseline,
enqueueLibraryCapture,
enqueueLibraryRecovery,
enqueueLibraryRestore,
enqueueLibrarySync,
fetchLibraryCaptures,
fetchLibraryJobDetail,
fetchLibraryMaintenance,
maintenanceOwnerJobID,
fetchLibraryOverview,
fetchLibraryRestoreAvailability,
fetchLibrarySnapshots,
reconcileLibraryCapture,
formatBytes,
scopeLabel,
type LibraryCaptureJob,
type LibraryJobLookup,
type LibraryJobRecord,
type LibraryMaintenanceView,
type LibraryOverview,
type LibraryRestoreAvailability,
type LibrarySnapshot,
type LibrarySnapshotList,
type LibraryStageRow,
type LibraryVersionRef,
} from './librarySnapshots'
import { useOptionalAuth } from './auth'
import './releaseTargets.css'
import { RestoreVerificationSection } from './RestoreVerificationSection'
import { fetchSnapshotVerification } from './restoreVerification'
import { fetchRoutingBindings } from './routingBindings'
// 一个知识库对应一个发布工作区。主操作随封存、授权、执行状态推进;
// 诊断按需展开,维护占用与失败恢复始终可见。
const stamp = (value: string) =>
value && Number.isFinite(new Date(value).getTime())
? new Date(value).toLocaleString('zh-CN', {
timeZone: 'Asia/Shanghai',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
hour12: false,
})
: '—'
const elapsed = (from: string, to: number) => {
const start = new Date(from).getTime()
if (!Number.isFinite(start) || to <= start) return '—'
const total = Math.floor((to - start) / 1000)
const minutes = Math.floor(total / 60)
const seconds = total % 60
return `${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')}`
}
const ACTIVE_STATES = ['pending', 'running', 'retry']
const jobStateLabel: Record<string, string> = {
pending: '排队中',
running: '执行中',
retry: '重试中',
completed: '已完成',
failed: '失败',
}
type Scope = 'internal' | 'external'
// 签发授权与执行是两步:页面只提供入口,不会替人签发,也不会自动重试执行。
export interface ReleaseSyncActions {
// 管理员才能签发;工程师看得到条件但没有按钮。
canSign: boolean
pendingGrant: boolean
onGrant: () => void
// 闸口全部满足才能启动(接口用同一份判定,按钮只是提前说明)。
canStart: boolean
pending: boolean
onStart: () => void
}
export interface ReleaseBaselineActions {
canStart: boolean
pending: boolean
onStart: () => void
}
interface ScopeView {
scope: Scope
snapshot?: LibrarySnapshot
history: LibrarySnapshot[]
activeJob?: LibraryCaptureJob
lastJob?: LibraryCaptureJob
// 持久作业与三类版本:来自 /api/v1/library/overview,重启后仍可读。
overview?: LibraryOverview | null
job?: LibraryJobRecord
syncJob?: LibraryJobRecord
}
interface ViewProps {
page: LibrarySnapshotList | null
jobs: LibraryCaptureJob[]
loading: boolean
error: string | null
notice: string | null
scope: Scope
onScope: (scope: Scope) => void
// 真实库名(来自测试知识库绑定):scope 是业务名,光看"对内知识库"对不上 WeKnora 里的库。
kbNames?: Record<Scope, string>
drawerOpen: boolean
onDrawer: (open: boolean) => void
expandedSnapshot: string | null
onExpandSnapshot: (id: string | null) => void
pendingCapture: boolean
canCapture: boolean
canWrite: boolean
// 管理员核对已完成 queue/精确版本/归档后修复 pending 封存作业终态。
canReconcileCapture: boolean
pendingReconcileCapture: string
onReconcileCapture: (jobID: string) => void
// 发布动作:签发授权(管理员)与启动同步是两个独立步骤,页面绝不自动签发。
sync: ReleaseSyncActions
// 目标非空又没有生效版本时,唯一入口是"建立目标权威基线"(管理员)。
baseline: ReleaseBaselineActions
// 恢复验证(真实作业)的接受/终态要回到父页面:父级据此启动轮询并在终态读回
// overview/维护/闸口,不能只在子面板里刷新自己。
verification: {
onAccepted: (jobId: string) => void
onComplete: (jobId: string) => void
}
// 按版本恢复是管理员动作:工程师看得到条件,但拿不到恢复入口。
canRestore: boolean
restore: LibraryRestoreAvailability | null
restoreNotice: string | null
pendingRestore: boolean
pendingGrant: boolean
onGrantRestore: () => void
onRestore: () => void
overview: LibraryOverview | null
/** F09: 每个 scope 的独立观测;不能拿当前 scope 的 overview 重算另一个页签。 */
overviews?: Record<Scope, LibraryOverview | null>
maintenance: LibraryMaintenanceView | null
// 维护记录里 owner_job_id 对应的作业详情;缺失就是“未读取”,不能用 overview.job 顶替。
maintenanceOwnerJob?: LibraryJobLookup
now: number
onRefresh: () => void
onCapture: () => void
onRecover: (windowJobID: string) => void
}
function scopeView(
page: LibrarySnapshotList | null,
jobs: LibraryCaptureJob[],
scope: Scope,
overview: LibraryOverview | null
): ScopeView {
const history = (page?.snapshots ?? []).filter((item) => item.scope === scope)
const scoped = jobs.filter((job) => job.scope === scope)
const persisted = overview?.jobs ?? []
// F02/F06: 顶部阶段必须跟当前在飞作业;只有没有在飞作业时才显示最近终态。
// 同一个 overview 里可能有刚完成的封存和正在跑的同步,不能用"最近一条"覆盖当前阶段。
const job =
persisted.find((item) => item.state === 'pending' || item.state === 'running') ?? overview?.job ?? persisted[0]
return {
scope,
// 候选只认接口给的 test_sealed(来自版本登记):归档里还有生产预备份与
// 目标基线快照,按"最新一份"挑会把目标自己的内容显示成测试封存。
snapshot: overview?.test_sealed,
history,
activeJob: scoped.find((job) => ACTIVE_STATES.includes(job.state)),
lastJob: scoped[0],
overview,
job,
syncJob: persisted.find((item) => item.kind === 'sync'),
}
}
const scopeName = (scope: Scope) => (scope === 'internal' ? '对内知识库' : '对外知识库')
// 绑定里拿不到库名时只显示业务名,不编一个名字出来。
const scopeTitle = (scope: Scope, kbName?: string) => {
const kb = kbName?.trim()
return kb ? `${scopeName(scope)} · ${kb}` : scopeName(scope)
}
// 生产目标必须按接口的四类状态原样呈现:把"已读且为空"和"读不到"都写成"未知",
// 会让人去点一个必然被拒绝的"建立基线"(后端对空目标返回 409 library_baseline_target_empty,
// 对读不到的目标返回 503 library_baseline_unprobeable)。
type ProductionTargetClass = 'known' | 'empty' | 'nonempty' | 'unreachable' | 'no-observation'
// 只有真正读到的 overview 才能分类。页面自己补的 {state:'unknown'} 与后端
// "已探测且非空"在 JSON 上无法区分,所以缺观测必须单列一类(no-observation),
// 否则首次加载、整体读取失败、当前范围没数据都会被误报成"目标非空"(F1)。
function productionTargetClass(production: LibraryOverview['production'] | null | undefined): ProductionTargetClass {
if (!production) return 'no-observation'
if (production.state === 'known' && production.version) return 'known'
if (production.state === 'unreachable') return 'unreachable'
// unknown 有两种:可读且空(空基线,首次发布合法起点)与可读但非空(缺权威版本)。
return production.empty_baseline ? 'empty' : 'nonempty'
}
// 刷新失败时页面会保留上一次的 overview:那份观测仍是当时的真实结果,
// 但已经不是刚刚验证过的状态,必须标出来,不能混作当前结论。
const STALE_NOTE = '上次观测 · 刷新失败,可能已过期'
function noObservationText(loading: boolean, error: string | null): string {
if (loading) return '正在读取目标状态(尚未确认空或非空)'
if (error) return '读取失败,还没有读到目标状态(不能据此判定空或非空)'
return '还没有读到该范围的目标状态'
}
// 不可发起时必须说清是哪一条不满足:读的是接口给出的真实原因(执行器不可达、
// 指向别的实例、降级、观测过期),不是一句写死的"通道未接线"。
function captureHint(view: ScopeView, canWrite: boolean): string {
if (!canWrite) return '封存需要知识工程师及以上权限'
const executor = view.overview?.executor
const reason = view.overview?.capture_reason || executor?.reason
const observed = executor?.observed_at ? `(观测于 ${stamp(executor.observed_at)})` : ''
const identity = executor?.project
? `执行器 ${executor.project}${executor.source_app ? ` / ${executor.source_app}` : ''} · `
: ''
if (reason) return `${identity}封存通道不可用:${reason}${observed}`
return '封存通道状态未知:还没有读到执行器观测'
}
function statusOf(view: ScopeView) {
const job = view.job
if (job && (job.state === 'running' || job.state === 'pending')) {
// 页签徽标也要说清是哪一类作业在跑:把"建立基线"写成"同步中"会让人
// 以为生产正在被写入。
const text =
job.kind === 'seal'
? '封存中'
: job.kind === 'restore'
? '恢复中'
: job.kind === 'baseline'
? '建基线中'
: '同步中'
return { text, tone: 'blue' as const }
}
if (view.overview?.production.state === 'known') return { text: '生产已记录版本', tone: 'green' as const }
if (view.overview?.test_sealed || view.snapshot) return { text: '已有封存', tone: 'green' as const }
return { text: '尚无封存', tone: 'gray' as const }
}
const jstate = (state?: string) =>
state === 'failed' ? '封存失败,可在版本与快照里查看原因' : state ? '封存已完成,生产段未接入' : '尚无作业'
// 五个阶段对应原稿:固定测试版本 → 备份生产 → 同步数据与 Wiki → 生产验证 → 新版本生效。
// 勾选只能来自**当前这次作业**的阶段证据;历史封存记录不代表本次作业推进过,
// 所以没有作业时全部是"本次作业尚未开始",不再把旧快照打勾。
function stageOf(job: LibraryJobRecord | undefined, name: string): LibraryStageRow | undefined {
return job?.stages.find((item) => item.stage === name)
}
function worstState(rows: LibraryStageRow[]): 'succeeded' | 'running' | 'failed' | 'pending' {
if (rows.some((row) => row.state === 'failed')) return 'failed'
if (rows.some((row) => row.state === 'running')) return 'running'
if (rows.length > 0 && rows.every((row) => row.state === 'succeeded' || row.state === 'skipped')) return 'succeeded'
return 'pending'
}
type StepState = 'done' | 'live' | 'fail' | 'idle'
function toState(value: 'succeeded' | 'running' | 'failed' | 'pending'): StepState {
return value === 'succeeded' ? 'done' : value === 'running' ? 'live' : value === 'failed' ? 'fail' : 'idle'
}
function jobStateText(job: LibraryJobRecord): string {
const map: Record<string, string> = {
pending: '排队中',
running: '执行中',
succeeded: '已完成',
failed: '失败',
cancelled: '已取消',
}
return map[job.state] ?? job.state
}
// 作业类型必须逐类写清:基线不是同步,恢复也不是同步。混写会让人以为
// "建立基线"正在把测试内容写进生产,或者把恢复当成一次正式发布。
export function jobKindText(kind?: string): string {
if (kind === 'seal') return '测试封存'
if (kind === 'sync') return '生产同步'
if (kind === 'restore') return '按版本恢复'
if (kind === 'baseline') return '建立目标基线'
if (kind === 'verify') return '恢复验证'
return kind ? kind : '—'
}
// 归档里的每一份快照属于哪一类版本:只能来自版本登记,不能一律写"测试封存"。
export function snapshotVersionLabel(refs: LibraryVersionRef[] | undefined, snapshotID: string): string {
const kinds = new Set((refs ?? []).filter((item) => item.snapshot_id === snapshotID).map((item) => item.kind))
const labels: string[] = []
if (kinds.has('test_sealed')) labels.push('测试封存')
if (kinds.has('production_effective')) labels.push('生产生效')
if (kinds.has('production_prebackup')) labels.push('生产预备份')
return labels.length > 0 ? labels.join(' · ') : '未登记(归档文件,不作为发布候选)'
}
// 生产写入的当前状态:不能用一句写死的"尚未启动"顶替已经完成的作业。
export function publishStateText(job?: LibraryJobRecord): string {
if (!job) return '尚未启动,不修改生产'
if (job.state === 'pending' || job.state === 'running') {
return job.kind === 'seal'
? '封存进行中(只读导出测试版本,不修改目标生产)'
: job.kind === 'restore'
? '恢复进行中(目标在维护中)'
: job.kind === 'baseline'
? '建立基线进行中(只读捕获目标,不写内容)'
: job.kind === 'verify'
? '恢复验证进行中(目标在维护中)'
: '同步进行中(目标在维护中)'
}
if (job.state === 'succeeded') return `${jobKindText(job.kind)}已完成 · ${stamp(job.finished_at ?? job.updated_at)}`
if (job.state === 'failed') return `${jobKindText(job.kind)}失败 · ${stamp(job.finished_at ?? job.updated_at)}`
return `${jobKindText(job.kind)}已取消 · ${stamp(job.finished_at ?? job.updated_at)}`
}
// 轮询范围 = 投递中 + 有在飞作业(封存队列与持久作业都算)。
// 终态(成功/失败/取消)必须停下来:无限轮询一个失败作业既没意义,
// 也会把"作业已经结束"这个事实淹没在不停刷新的页面里。
export function libraryPollingActive(input: {
captures: LibraryCaptureJob[]
overviews: Record<Scope, LibraryOverview | null>
pending: boolean
/** 按预备份恢复是一次队列作业,不产生新的 library_jobs 行:必须单独记住"还在等它"。 */
recoveryPending?: boolean
/** 维护窗口仍被持有 ⇒ 恢复/收尾还没结束,页面必须继续读回。 */
maintenances?: Record<Scope, LibraryMaintenanceView | null>
}): boolean {
if (input.pending) return true
if (input.recoveryPending) return true
if (input.captures.some((job) => ACTIVE_STATES.includes(job.state))) return true
const maintenanceHeld = (['internal', 'external'] as Scope[]).some((scope) => {
const view = input.maintenances?.[scope]
return Boolean(view?.held)
})
if (maintenanceHeld) return true
return (['internal', 'external'] as Scope[]).some((scope) => {
const job = input.overviews[scope]?.job
return Boolean(job && ACTIVE_STATES.includes(job.state))
})
}
// ---- 目标维护窗口:级别 / 进度 / 恢复错误 ----
//
// 维护窗口有两种级别:实例级(跨 scope 共用一把锁,真正挡住写入者)和库级。
// 页面必须说清是哪一级、入口是开还是关、作业走到哪、恢复失败的具体错误——
// 这些都来自 /api/v1/library/maintenance 的真实记录,没有记录就说"未接入"。
export interface MaintenanceSummary {
level: string
held: boolean
owner: string
state: string
ingress: string
services: string
acquiredAt: string
releasedAt: string
progress: string
recoveryError: string
// 作业失败但维护窗口已释放:只保留失败记录,不能再说"目标保持维护"。
releasedFailure: string
recoveryNote: string
// 窗口未释放但持有作业已经是终态成功:对账缺口,页面不提供强制成功。
unreconciledNote: string
// 实例级窗口属于另一个 scope:不在此投递恢复,提示切回持有 scope。
scopeNote: string
canRecover: boolean
}
// 阶段名给操作员看的映射;没映射到的阶段原样显示,不猜。
const stageLabel: Record<string, string> = {
prebackup: '预备份',
database: '数据库',
resources: '资源',
index: '索引',
wiki: 'Wiki',
verify: '校验',
finalize: '登记版本',
rollback: '回滚',
export: '导出',
acquire: '开窗口',
drain: '排空',
stop: '停写入者',
}
const ingressText = (state?: string) =>
state === 'closed'
? '已关闭(排空后等待写入)'
: state === 'none'
? '无闸门(测试模式)'
: state === 'open'
? '打开'
: state
? state
: '未知'
// 持有作业详情没读到时只写未读取/未知,绝不拿同 scope 最新作业顶替。
const ownerJobText = (lookup: LibraryJobLookup | undefined, ownerJobID: string) => {
const id = ownerJobID || '—'
if (lookup?.state === 'error') return `持有作业状态读取失败:${lookup.reason}(不使用其他作业推断)`
if (lookup?.state === 'missing') return `持有作业 ${id} 不存在(维护记录引用了未登记的作业)`
if (lookup?.state === 'loaded')
return `持有作业状态未读取/未知(维护记录为 ${id},读取到的是 ${lookup.job.id},不采用)`
return `持有作业状态未读取/未知(owner_job_id=${id};不使用最新作业代替)`
}
// 维护卡只消费“维护记录里的持有作业”。同 scope 最新作业可能是一次无关封存:
// 拿它当窗口进度会把 needs_restore 显示成“导出 · 已完成”(真实事故 2026-11-03)。
export function maintenanceSummary(
maintenance: LibraryMaintenanceView | null | undefined,
ownerJob?: LibraryJobLookup,
scope?: string
): MaintenanceSummary {
const record = maintenance?.instance_maintenance ?? maintenance?.maintenance ?? null
const level = !record
? '未接入'
: record.level === 'instance'
? '实例级'
: record.level === 'library'
? '库级'
: record.level || '未知'
const held = Boolean(maintenance?.held)
const ownerScope = maintenance?.instance_maintenance?.owner_scope ?? record?.scope ?? ''
const ownerJobID = record?.owner_job_id ?? ''
// 只有 id 与维护记录一致的作业才是本窗口的进度;其余按“未读取”处理。
const owner = ownerJob?.state === 'loaded' && ownerJob.job.id === ownerJobID ? ownerJob.job : undefined
const failed = owner?.state === 'failed'
const progress = owner
? `${stageLabel[owner.stage] ?? owner.stage ?? '—'} · ${jobStateText(owner)}`
: record
? ownerJobText(ownerJob, ownerJobID)
: '尚无作业进度'
// 实例级窗口跨 scope 共用:只有持有 scope 才能投递恢复,否则后端必然 409。
const sameScope = !scope || !ownerScope || ownerScope === scope
const scopeNote =
held && !sameScope
? `维护窗口属于 ${ownerScope},当前查看 ${scope}:页面不向另一个 scope 投递恢复,请切回 ${ownerScope} 再处理`
: ''
// 恢复只由“维护仍持有 + 本窗口作业未收口”决定,与无关的最新作业无关。
const unsettled = owner
? owner.state === 'failed' || owner.state === 'cancelled'
: record?.state === 'needs_restore' || record?.state === 'failed' || record?.state === 'held'
return {
level,
held,
owner: record ? `${ownerScope || '—'} · ${record.owner_job_id || '—'}` : '—',
state: record?.state || '—',
ingress: record ? ingressText(record.ingress_state) : '—',
services: (record?.services ?? []).join('、') || '—',
acquiredAt: record?.acquired_at ? stamp(record.acquired_at) : '—',
releasedAt: record?.released_at ? stamp(record.released_at) : '',
progress,
// 只有仍然 held 的失败才配 held 处置说明;窗口已释放时那段文案是假的。
recoveryError: failed && held ? owner?.error || '作业失败但没有留下错误明细' : '',
releasedFailure: failed && !held ? owner?.error || '作业失败但没有留下错误明细' : '',
recoveryNote: owner?.recovery || '',
unreconciledNote:
held && owner && owner.state === 'succeeded'
? '持有作业已完成但维护窗口仍未释放:维护记录与作业终态未对账,页面不提供强制成功,需按窗口记录人工核验'
: '',
scopeNote,
canRecover: held && Boolean(record) && sameScope && Boolean(unsettled),
}
}
export function MaintenanceCard({
maintenance,
ownerJob,
scope,
canWrite,
onRecover,
}: {
maintenance: LibraryMaintenanceView | null | undefined
// 只收“按 owner_job_id 读到的持有作业”,不是 scope 的最新作业。
ownerJob?: LibraryJobLookup
scope?: string
canWrite: boolean
onRecover: (windowJobID: string) => void
}) {
const summary = maintenanceSummary(maintenance, ownerJob, scope)
const record = maintenance?.instance_maintenance ?? maintenance?.maintenance
// "没有窗口记录"不等于"没有维护能力":能力是配置事实,接口单独返回。
// 接口没给能力信息时也不能猜,明确写"未知"。
const capability = maintenance?.capability
const capabilityText = !capability
? '维护能力状态未知:接口没有返回能力信息,无法区分"未运行维护"与"能力未接线"'
: capability.configured
? `维护能力已接线:实例 ${capability.instance || '—'} · 写入者 ${(capability.writers ?? []).join('、') || '—'}`
: `维护能力未接线:缺少 ${(capability.missing ?? []).join('、') || '必要配置'}`
return (
<div className="rel-panel rel-maintenance">
<header className="rel-panel-head">
<div>
<h2>目标维护</h2>
<p>同步/恢复期间目标写入者被停住;级别与入口状态来自维护记录本身</p>
</div>
<span
className={`rel-pill ${summary.held ? 'blue' : record ? 'green' : capability?.configured ? 'gray' : 'red'}`}
>
{summary.held
? `${summary.level} · 占用中`
: record
? '未占用'
: capability?.configured
? '未运行维护'
: capability
? '能力未接线'
: '能力未知'}
</span>
</header>
{!record ? (
<p className="rel-scope-note">
暂无维护窗口记录。{capabilityText}
{capability?.configured
? ';窗口只在同步或建立基线时开启,页面不会单独开窗口。'
: ';维护类操作保持 fail closed,不会在此状态下写目标。'}
</p>
) : (
<>
<ul className="rel-maintenance-rows">
<li>
<span>级别</span>
<b>{summary.level}</b>
</li>
<li>
<span>持有</span>
<b>{summary.owner}</b>
</li>
<li>
<span>阶段</span>
<b>{summary.state}</b>
</li>
<li>
<span>入口(维护记录,未实时探测)</span>
<b>{summary.ingress}</b>
</li>
<li>
<span>服务</span>
<b>{summary.services}</b>
</li>
<li>
<span>开始</span>
<b>{summary.acquiredAt}</b>
</li>
<li>
<span>释放</span>
<b>{summary.releasedAt || '未释放'}</b>
</li>
</ul>
<p className="rel-scope-note">
进度:{summary.progress}
{summary.releasedAt ? ` · 窗口已于 ${summary.releasedAt} 释放` : ''}
</p>
{summary.scopeNote ? <p className="rel-scope-note">{summary.scopeNote}</p> : null}
{summary.held ? (
<p className="rel-scope-note">
窗口仍被持有:只有维护记录本身释放才算结束,其他作业的完成或失败不改变本窗口。
</p>
) : null}
{summary.unreconciledNote ? (
<div className="rel-scope-note">
<strong>维护记录未对账</strong>
<p>{summary.unreconciledNote}</p>
</div>
) : null}
{summary.releasedFailure ? (
<div className="rel-scope-note">
<strong>作业失败(维护窗口已释放)</strong>
<p>{summary.releasedFailure}</p>
{summary.recoveryNote ? <p>处理记录:{summary.recoveryNote}</p> : null}
<p>
窗口已释放,维护记录中的入口状态:{summary.ingress}(未实时探测):这里是历史失败记录,不再按 held
处置,也不提供强制成功。
</p>
</div>
) : null}
{summary.recoveryError ? (
<div className="rel-blocked">
<strong>恢复错误</strong>
<p>{summary.recoveryError}</p>
{summary.recoveryNote ? <p>处理记录:{summary.recoveryNote}</p> : null}
<p>
内容可能已写入并通过校验,但收尾没有完成:目标保持维护、入口未开。请按本作业的预备份与校验证据人工核验后再放行;
页面不提供“强制成功”,也不会因为“看起来已经写进去了”就开门。
</p>
</div>
) : null}
<p className="rel-scope-note">
发布或恢复完成后,Wiki 与日志页面需要刷新再翻页:发布前的分页游标在发布后失效(本地编号会被重新编排),
用旧标签页继续翻页会得到错位的结果,这不是数据损坏。
</p>
{canWrite && summary.canRecover && record ? (
<button type="button" className="rel-secondary" onClick={() => onRecover(record.owner_job_id)}>
按预备份恢复
</button>
) : null}
</>
)}
</div>
)
}
// 逐页贡献级差异:一条页面一行,直接写清来源少了几份、引用从几变几。
export function wikiContributionLines(diff: LibraryOverview['diff'] | undefined): string[] {
const wiki = diff?.wiki
if (!wiki || wiki.state !== 'computed' || !wiki.pages || wiki.pages.length === 0) return []
const label: Record<string, string> = { added: '新增', updated: '更新', removed: '整页撤销' }
return wiki.pages.map((page) => {
const parts = [`${label[page.status] ?? page.status} ${page.title || page.slug}`]
if (page.changed.length > 0) parts.push(page.changed.join('、'))
if ((page.sources_removed ?? []).length > 0) parts.push(`来源 -${page.sources_removed!.length}`)
if ((page.sources_added ?? []).length > 0) parts.push(`来源 +${page.sources_added!.length}`)
if (page.citations_before !== page.citations_after)
parts.push(`引用 ${page.citations_before}→${page.citations_after}`)
return parts.join(' · ')
})
}
function StageBar({ view }: { view: ScopeView }) {
const job = view.job
if (job?.kind === 'verify') {
const labels: Record<string, string> = {
capture: '捕获目标',
verify: '基线校验',
canary: '写入并核对 canary',
restore: '按预备份恢复',
finalize: '登记验证证据',
}
return (
<>
<ol className="rel-steps" aria-label="恢复验证阶段">
{Object.entries(labels).map(([name, label], index) => {
const row = job.stages.find((item) => item.stage === name)
const state = row ? toState(row.state as 'succeeded' | 'running' | 'failed' | 'pending') : 'idle'
return (
<li key={name} className={`rel-step ${state}`}>
<span className="rel-step-mark">
{state === 'done' ? '✓' : state === 'live' ? '●' : state === 'fail' ? '!' : '○'}
</span>
<strong>{label}</strong>
<small>{row?.detail || (state === 'idle' ? '未开始' : '')}</small>
{index < 4 ? <span className="rel-step-arrow">→</span> : null}
</li>
)
})}
</ol>
<p className="rel-steps-note">
作业 {job.id} · 恢复验证 · {jobStateText(job)}
{job.error ? ` · ${job.error}` : ''};完成只表示本次恢复验证证据已登记,不会登记新版本。
</p>
</>
)
}
if (job?.kind === 'seal') {
const exportRow = job.stages.find((item) => item.stage === 'export')
const state =
job.state === 'succeeded'
? 'done'
: job.state === 'failed'
? 'fail'
: job.state === 'running' || job.state === 'pending'
? 'live'
: 'idle'
return (
<>
<ol className="rel-steps" aria-label="测试库封存阶段">
<li className={`rel-step ${state}`}>
<span className="rel-step-mark">
{state === 'done' ? '✓' : state === 'live' ? '●' : state === 'fail' ? '!' : '○'}
</span>
<strong>只读导出测试版本</strong>
<small>
{exportRow?.detail ||
(state === 'done'
? '测试库快照已导出并登记'
: state === 'fail'
? '封存未完成'
: state === 'live'
? '正在读取测试库并导出快照'
: '未开始')}
</small>
</li>
</ol>
<p className="rel-steps-note">
作业 {job.id} · 测试封存 · {jobStateText(job)}
{job.error ? ` · ${job.error}` : ''};封存只读测试库,不备份、不写入、不切换目标生产。
</p>
</>
)
}
// 同步、恢复、建立基线共用同一串阶段(预备份 → 数据四类 → 校验 → 登记版本)。
// 只按"sync"找阶段会让刚跑完的恢复/基线在页面上显示成"本次作业尚未开始"。
const writeJob = job
let first: { state: StepState; hint: string }
if (writeJob) {
first =
writeJob.kind === 'restore'
? { state: 'done', hint: '恢复到选定快照(不经过测试封存)' }
: writeJob.kind === 'baseline'
? { state: 'done', hint: '目标自身内容,非测试封存' }
: { state: 'done', hint: '已绑定的测试版本' }
} else {
first = { state: 'idle', hint: '本次作业尚未开始' }
}
const prebackup = writeJob ? stageOf(writeJob, 'prebackup') : undefined
const dataStages = writeJob
? ['database', 'resources', 'index', 'wiki']
.map((name) => stageOf(writeJob, name))
.filter((row): row is LibraryStageRow => Boolean(row))
: []
const verifyStage = writeJob ? stageOf(writeJob, 'verify') : undefined
const stages: { label: string; state: StepState; hint: string }[] = [
{ label: '固定测试版本', ...first },
{
label: '备份生产',
state: prebackup ? toState(worstState([prebackup])) : 'idle',
hint: prebackup
? prebackup.state === 'succeeded'
? '已完成生产预备份'
: prebackup.state === 'running'
? '正在备份生产'
: prebackup.state === 'failed'
? '预备份失败'
: '未开始'
: '未接入',
},
{
label: '同步数据与 Wiki',
state: dataStages.length > 0 ? toState(worstState(dataStages)) : 'idle',
hint: dataStages.length > 0 ? '按数据库 / 资源 / 索引 / Wiki 分项上报' : '未接入',
},
{
label: '生产验证',
state: verifyStage ? toState(worstState([verifyStage])) : 'idle',
hint: verifyStage ? (verifyStage.state === 'succeeded' ? '校验通过' : '未完成') : '未接入',
},
{
label: writeJob?.kind === 'restore' ? '目标恢复生效' : '生产生效',
state: writeJob && writeJob.state === 'succeeded' ? 'done' : 'idle',
hint:
writeJob && writeJob.state === 'succeeded'
? writeJob.kind === 'restore'
? '目标已回到该快照,恢复后复核通过'
: writeJob.kind === 'baseline'
? '目标基线已登记(目标内容未改)'
: '生产已生效'
: '未开始',
},
]
return (
<>
<ol className="rel-steps" aria-label="作业阶段">
{stages.map((stage, index) => (
<li key={stage.label} className={`rel-step ${stage.state}`}>
<span className="rel-step-mark">
{stage.state === 'done' ? '✓' : stage.state === 'live' ? '●' : stage.state === 'fail' ? '!' : '○'}
</span>
<strong>{stage.label}</strong>
<small>{stage.hint}</small>
{index < stages.length - 1 ? <span className="rel-step-arrow">→</span> : null}
</li>
))}
</ol>
<p className="rel-steps-note">
{job
? `作业 ${job.id} · ${jobKindText(job.kind)} · ${jobStateText(job)}${job.error ? ` · ${job.error}` : ''}`
: view.snapshot
? `已有测试封存 ${stamp(view.snapshot.created_at)}(历史记录),但本次作业尚未开始;没有当前作业证据时不会把历史封存当作阶段完成。`
: '本次作业尚未开始。'}
</p>
</>
)
}
// 差异行是 {id,title,digest} 对象;只展示人能核对的身份,不摊开内部摘要。
function diffLabel(item: unknown): string {
if (typeof item === 'string') return item
if (item && typeof item === 'object') {
const record = item as Record<string, unknown>
const title = typeof record.title === 'string' ? record.title : ''
const id = typeof record.id === 'string' ? record.id : ''
if (title && id) return `${title} · ${id.slice(0, 8)}`
if (title) return title
if (id) return id
}
return JSON.stringify(item)
}
function ChangeTable({ diff }: { diff: LibraryOverview['diff'] }) {
const computed = diff.state === 'computed'
const rows = computed
? [
...diff.added.map((item) => ({ action: '新增', item })),
...diff.updated.map((item) => ({ action: '更新', item })),
...diff.removed.map((item) => ({ action: '删除', item })),
]
: []
return (
<div className="rel-panel rel-changes">
<header className="rel-panel-head">
<div>
<h2>本次变更</h2>
<p>整库版本同步,不单独勾选文件</p>
</div>
<span className={`rel-pill ${computed ? 'green' : 'gray'}`}>{computed ? `${rows.length} 条` : '未接入'}</span>
</header>
{computed && diff.base_snapshot && diff.target_snapshot ? (
<p className="rel-scope-note">
生产 {diff.base_snapshot.slice(0, 12)} → 测试 {diff.target_snapshot.slice(0, 12)}
</p>
) : null}
<table>
<thead>
<tr>
<th>动作</th>
<th>文档</th>
</tr>
</thead>
<tbody>
{rows.length === 0 ? (
<tr>
<td colSpan={2} className="rel-table-empty">
{computed
? '生产与测试版本没有文档差异'
: `尚无记录 · ${diff.reason || '变更清单来自生产与测试版本对比,这项数据还没有接入'}`}
</td>
</tr>
) : (
rows.map((row, index) => (
<tr key={`${row.action}-${index}`}>
<td>{row.action}</td>
<td>{diffLabel(row.item)}</td>
</tr>
))
)}
</tbody>
</table>
{diff.wiki && diff.wiki.state === 'computed' ? (
<div className="rel-wiki-diff">
<p className="rel-scope-note">
Wiki 页面:新增 {diff.wiki.added} · 更新 {diff.wiki.updated} · 撤销 {diff.wiki.removed}
{typeof diff.wiki.sources_removed === 'number'
? ` · 来源文档变化 −${diff.wiki.sources_removed} / +${diff.wiki.sources_added ?? 0}`
: ''}
(逐页比对来源、引用、出入边与目录;重算发生在源侧)
</p>
{wikiContributionLines(diff).length > 0 ? (
<ul className="rel-wiki-pages">
{wikiContributionLines(diff).map((line) => (
<li key={line}>{line}</li>
))}
</ul>
) : null}
{diff.wiki.pages_truncated ? <p className="rel-scope-note">逐页明细超过 50 条,只列出前 50 条。</p> : null}
</div>
) : null}
</div>
)
}
function ProtectionCard({
production,
productionNote,
stale,
prebackup,
gate,
authorization,
targetSealed,
sync,
baseline,
scope,
verification,
}: {
production: LibraryOverview['production'] | null
// 没有目标观测时显示的原因(加载中 / 整体读取失败 / 当前范围没数据)。
productionNote: string
stale: boolean
prebackup: LibraryOverview['prebackup']
gate: LibraryOverview['gate']
authorization: LibraryOverview['authorization']
targetSealed: boolean
sync: ReleaseSyncActions
baseline: ReleaseBaselineActions
scope: Scope
verification: {
onAccepted: (jobId: string) => void
onComplete: (jobId: string) => void
}
}) {
const backupKnown = prebackup.state === 'known' && prebackup.version
// 基线入口只在"目标非空、却没有生效版本"时才是答案;空库走首次同步(预备份+登记),
// 读不到或还没读到观测时必须先修连接/等读取,两者都不能被引导到会 409/503 的基线入口。
const productionTarget = productionTargetClass(production)
const baselineNeeded = productionTarget === 'nonempty' && targetSealed
const staleNote = stale ? `(${STALE_NOTE})` : ''
return (
<aside className="rel-panel rel-protection">
<header className="rel-panel-head">
<h2>生产保护与恢复</h2>
<span className={`rel-pill ${backupKnown ? 'green' : 'gray'}`}>
{backupKnown ? '已登记预备份' : '尚未创建'}
</span>
</header>
<dl>
<dt>最近一次生产写入前备份</dt>
<dd>
{backupKnown ? (
<>
{stamp(prebackup.version!.created_at)} ·{' '}
{prebackup.version!.version_label || prebackup.version!.snapshot_id.slice(0, 12)}
{prebackup.version!.source_job_id ? ` · 作业 ${prebackup.version!.source_job_id}` : ''}
<br />
<small>
{prebackup.bound_to_target
? '与当前拟发布目标是同一份快照'
: targetSealed
? '不是当前拟发布目标的快照(是那次生产写入前的状态)'
: '归档里没有拟发布目标,无法比对'}
</small>
</>
) : (
'未登记(这个范围还没有任何生产预备份)'
)}
</dd>
<dt>生产当前版本</dt>
<dd>
{productionTarget === 'known' && production?.version ? (
<>
{production.version.version_label || production.version.snapshot_id.slice(0, 12)}
<br />
<small>
快照 {production.version.snapshot_id.slice(0, 12)} · 登记于 {stamp(production.version.created_at)}
</small>
</>
) : productionTarget === 'empty' ? (
`目标已读且为空:首次发布还没有生效版本(写前仍会生成完整预备份)${staleNote}`
) : productionTarget === 'unreachable' ? (
`${production?.reason || '读取失败:无法确认目标是否为空'}${staleNote}`
) : productionTarget === 'nonempty' ? (
`未知(目标非空且还没有权威版本)${staleNote}`
) : (
productionNote
)}
</dd>
<dt>备份范围</dt>
<dd>数据库 / 资源 / 索引 / Wiki</dd>
<dt>发布授权</dt>
<dd>
{authorization.state === 'active'
? `${authorization.authorized_by || '管理员'} 签发 · 有效至 ${stamp(authorization.expires_at ?? '')}`
: '无有效授权(需管理员按目标+快照签发)'}
</dd>
<dt>恢复条件</dt>
<dd>{gate.reasons.length === 0 ? '已满足' : `缺 ${gate.reasons.length} 项`}</dd>
</dl>
<RestoreVerificationSection
scope={scope}
isAdmin={sync.canSign}
onAccepted={verification.onAccepted}
onComplete={verification.onComplete}
/>
<div className="rel-drawer-actions">
{baseline.canStart && baselineNeeded ? (
<button type="button" className="rel-secondary" onClick={baseline.onStart} disabled={baseline.pending}>
{baseline.pending ? '投递中…' : '建立目标权威基线(维护隔离)'}
</button>
) : null}
</div>
{authorization.state !== 'active' && !sync.canSign ? (
<p className="rel-hint">同步授权只能由管理员按目标+快照签发;工程师看不到签发入口。</p>
) : null}
<p className="rel-hint">需要恢复旧版本时,从页面右上角「版本与快照」选择恢复点。</p>
</aside>
)
}
interface ReadyProps {
view: ScopeView
diff: LibraryOverview['diff']
production: LibraryOverview['production'] | null
// 缺观测时的说明与"旧观测"标记都由上层按 loading/error 判定,子组件只负责显示。
productionNote: string
stale: boolean
prebackup: LibraryOverview['prebackup']
gate: LibraryOverview['gate']
authorization: LibraryOverview['authorization']
sync: ReleaseSyncActions
baseline: ReleaseBaselineActions
verification: {
onAccepted: (jobId: string) => void
onComplete: (jobId: string) => void
}
}
function ReadyBody({
view,
diff,
production,
productionNote,
stale,
prebackup,
gate,
authorization,
sync,
baseline,
verification,
}: ReadyProps) {
return (
<>
<details className="rel-disclosure" key={`changes-${view.scope}`}>
<summary>
查看变更明细{' '}
<span>
{diff.state === 'computed'
? `${diff.added.length + diff.updated.length + diff.removed.length} 篇文档`
: '尚未取得对比结果'}
</span>
</summary>
<ChangeTable diff={diff} />
</details>
<details className="rel-disclosure" key={`protection-${view.scope}`}>
<summary>
发布准备与恢复验证{' '}
<span>{gate.reasons.length ? `待满足 ${gate.reasons.length} 项发布条件` : '查看备份与验证记录'}</span>
</summary>
<ProtectionCard
production={production}
productionNote={productionNote}
stale={stale}
prebackup={prebackup}
gate={gate}
authorization={authorization}
targetSealed={Boolean(view.snapshot)}
sync={sync}
baseline={baseline}
scope={view.scope}
verification={verification}
/>
</details>
{view.job ? (
<details className="rel-disclosure" key={`job-${view.scope}-${view.job.id}`} open={view.job.state === 'failed'}>
<summary>
最近作业{' '}
<span>
{jobKindText(view.job.kind)} · {jobStateText(view.job)}
</span>
</summary>
<div className="rel-panel rel-jobbar">
<header className="rel-panel-head">
<h2>启动后的作业进度</h2>
{/* 作业跑完/失败后不能还说"此时尚未运行":这个徽标说的是**最近一次作业**的终态。 */}
<span className={`rel-pill ${view.job ? (view.job.state === 'failed' ? 'red' : 'green') : 'gray'}`}>
{view.job
? `${jobKindText(view.job.kind)} · ${jobStateText(view.job)} · ${stamp(view.job.finished_at ?? view.job.updated_at)}`
: '此时尚未运行'}
</span>
</header>
<StageBar view={view} />
{view.job.error ? <p className="rel-warn">{view.job.error}</p> : null}
</div>
</details>
) : null}
</>
)
}
function ProgressBody({
view,
now,
canReconcileCapture,
pendingReconcileCapture,
onReconcileCapture,
}: {
view: ScopeView
now: number
canReconcileCapture: boolean
pendingReconcileCapture: string
onReconcileCapture: (jobID: string) => void
}) {
const job = view.job
const sealJob = job?.kind === 'seal' ? job : undefined
// 四类数据阶段对同步/恢复/基线都成立:分项读的是这份作业自己的阶段,
// 不是"只有 sync 才有"。写死 sync 会让恢复作业的分项全显示"未接入"。
const dataJob = job && job.kind !== 'seal' ? job : undefined
const running = job?.state === 'running' || job?.state === 'pending'
// Startup reconciliation used to rewrite a completed capture as "队列不存在".
// Only that exact legacy shape gets an admin reconcile action; real failures do not.
const legacyOrphan =
sealJob?.state === 'failed' &&
sealJob.stage === '' &&
sealJob.snapshot_id === '' &&
sealJob.error === '队列中已无对应作业,业务作业未收到结果' &&
sealJob.recovery === '封存作业由 agent 恢复来源;确认来源 healthy 后可重发'
const stage = (name: string) => (dataJob ?? sealJob)?.stages.find((item) => item.stage === name)
// F11: counts must belong to the snapshot this job actually used. A newly
// sealed test version must not decorate an older sync/restore/verify job.
const jobSnapshotID = job?.target_snapshot_id || job?.snapshot_id || ''
const sealed = jobSnapshotID
? view.history.find((item) => item.snapshot_id === jobSnapshotID)
: job
? undefined
: view.overview?.test_sealed
const breakdown = (keys: [string, string][]) =>
sealed
? keys
.map(([key, label]) => `${label} ${typeof sealed.totals[key] === 'number' ? sealed.totals[key] : '未知'}`)
.join(' · ')
: ''
const cards = [
// F11: these totals are storage rows, not business document/page counts.
{
title: '数据库 · 存储行',
row: stage('database'),
axis: '行(文档/分块/标签/关系)',
counts: breakdown([
['documents', '文档'],
['chunks', '分块'],
['resources', '资源'],
['bindings', '绑定'],
]),
},
{ title: '原文件 · 图片 · 附件', row: stage('resources'), axis: '对象 / 字节', counts: '' },
{ title: '检索索引 · 向量', row: stage('index'), axis: '索引文档', counts: '' },
{
title: 'Wiki · 存储行',
row: stage('wiki'),
axis: '页面 / 目录 / 日志',
counts: breakdown([
['wiki_pages', '页面'],
['wiki_folders', '目录'],
['wiki_log_entries', '日志'],
]),
},
].map((card) => ({
...card,
// 只有真实的 total 才画进度;没有 total 就是"未知总量",绝不按 0 或 100% 画。
percent:
card.row && card.row.total && card.row.total > 0
? Math.min(100, Math.round(((card.row.completed ?? 0) / card.row.total) * 100))
: null,
count: card.row && card.row.total != null ? `${card.row.completed ?? '—'} / ${card.row.total}` : '— / 未知总量',
}))
return (
<>
<div className="rel-panel rel-progress-head" id="rel-progress">
<div className="rel-between">
<h2>
{sealJob ? '测试库封存作业' : dataJob ? `${jobKindText(dataJob.kind)}作业` : '本次作业'}
<span className="rel-version">
{sealJob ? (
<>只读导出测试库快照 → 不修改目标生产</>
) : (
<>
{dataJob?.kind === 'restore'
? `恢复到 ${dataJob.target_snapshot_id.slice(0, 12) || '—'}`
: dataJob?.kind === 'baseline'
? `目标基线 ${dataJob.target_snapshot_id.slice(0, 12) || '(本次捕获后登记)'}`
: `测试封存 ${view.overview?.test_sealed?.snapshot_id.slice(0, 12) ?? '未接入'}`}{' '}
→ 目标当前{' '}
<b>
{view.overview?.production.state === 'known' && view.overview.production.version
? view.overview.production.version.version_label ||
view.overview.production.version.snapshot_id.slice(0, 12)
: '未知'}
</b>
</>
)}
</span>
</h2>
<span className={`rel-pill ${running ? 'blue' : job?.state === 'failed' ? 'red' : job ? 'green' : 'gray'}`}>
{job ? `${jobStateText(job)} · 已用时 ${elapsed(job.created_at, now)}` : '无作业'}
</span>
</div>
<p className="rel-jobmeta">
作业 <code>{job?.id ?? '未接入'}</code> · 类型 {job ? jobKindText(job.kind) : '—'} · 操作人{' '}
{job?.actor || '—'} · 最近进展 {job ? stamp(job.updated_at) : '—'}
{job?.recovery ? ` · 恢复:${job.recovery}` : ''}
</p>
<StageBar view={view} />
{sealJob &&
canReconcileCapture &&
(sealJob.state === 'pending' || sealJob.state === 'running' || legacyOrphan) &&
stage('export')?.state === 'succeeded' ? (
<div className="rel-between rel-progress-foot" aria-label="核对封存结果">
<span>队列已完成、导出阶段已成功,但作业终态尚未回写。</span>
<button
type="button"
className="rel-secondary"
onClick={() => onReconcileCapture(sealJob.id)}
disabled={pendingReconcileCapture === sealJob.id}
>
{pendingReconcileCapture === sealJob.id ? '核对中…' : '核对封存结果'}
</button>
</div>
) : null}
<div className="rel-between rel-progress-foot">
<span>
当前:
{job?.state === 'running'
? job.stage || '执行中'
: job?.state === 'failed'
? job.error || '失败'
: job
? jobStateText(job)
: '本次作业尚未开始'}
</span>
</div>
</div>
<details className="rel-disclosure" key={`progress-detail-${view.scope}`}>
<summary>
查看执行明细 <span>各类数据进度与阶段记录</span>
</summary>
{sealJob ? (
<div className="rel-panel">
<header className="rel-panel-head">
<h2>封存范围</h2>
<span className="rel-pill gray">只读</span>
</header>
<p className="rel-scope-note">
本作业只读取测试库并导出快照,不备份生产、不写目标、不做生产验证,也不持有目标维护窗口。
快照完成后在“版本与快照”查看;没有真实导出总量时显示未知,不补零或 100%。
</p>
</div>
) : (
<>
<div className="rel-panel rel-datatypes">
<header className="rel-panel-head">
<h2>各类数据同步情况</h2>
<span className="rel-hint">没有真实总量与完成量的项目只显示状态,不编造百分比</span>
</header>
<div className="rel-grid rel-grid-4">
{cards.map((card) => (
<article key={card.title} className="rel-datacard">
<header>
<h3>{card.title}</h3>
<span
className={`rel-pill ${card.row?.state === 'succeeded' ? 'green' : card.row?.state === 'failed' ? 'red' : card.row?.state === 'running' ? 'blue' : 'gray'}`}
>
{card.row
? card.row.state === 'succeeded'
? '已完成'
: card.row.state === 'running'
? '执行中'
: card.row.state === 'failed'
? '失败'
: '等待'
: '未接入'}
</span>
</header>
<p className="rel-datacount">
<strong>{card.count}</strong> · {card.axis}
</p>
{card.counts ? <p className="rel-datadetail">封存快照分项:{card.counts}</p> : null}
<div className="rel-progress" aria-hidden={card.percent === null ? 'true' : undefined}>
<span style={{ width: `${card.percent ?? 0}%` }} />
</div>
<p className="rel-datadetail">
{card.row?.detail
? card.row.detail
: card.row
? card.row.state === 'running'
? '执行中;执行器尚未提供该分项明细'
: card.row.state === 'pending'
? '等待执行;不能按完成展示'
: card.row.state === 'failed'
? '失败;没有可核对完成量'
: card.row.state === 'succeeded'
? card.row.total != null
? `已完成 ${card.row.completed ?? card.row.total} / ${card.row.total} 条存储行`
: '该分项已完成,执行器未提供可核对总量'
: '状态未知;不按完成展示'
: dataJob
? '本次作业没有产生该分项阶段记录'
: '目标同步执行链未接通,分项不会产生数据'}
</p>
</article>
))}
</div>
</div>
<div className="rel-panel rel-details">
<header className="rel-panel-head">
<h2>同步明细</h2>
<span className="rel-hint">行来自持久作业阶段,worker 重启后仍可读</span>
</header>
<table>
<thead>
<tr>
<th>任务 / 对象</th>
<th>阶段</th>
<th>进度</th>
<th>状态</th>
<th>说明</th>
</tr>
</thead>
<tbody>
{(job?.stages ?? []).length === 0 ? (
<tr>
<td colSpan={5} className="rel-table-empty">
尚无阶段记录
</td>
</tr>
) : (
job!.stages.map((row) => (
<tr key={row.stage}>
<td>{row.stage}</td>
<td>{row.stage === 'export' ? '测试封存' : row.stage}</td>
<td>
{row.total != null ? `${row.completed ?? '—'} / ${row.total}` : '未知总量'}
{row.bytes_total != null
? ` · ${formatBytes(row.bytes_done ?? 0)} / ${formatBytes(row.bytes_total)}`
: ''}
</td>
<td>
{row.state === 'succeeded'
? '已完成'
: row.state === 'running'
? '执行中'
: row.state === 'failed'
? '失败'
: row.state === 'skipped'
? '已跳过'
: '等待'}
</td>
<td>{row.detail || '—'}</td>
</tr>
))
)}
</tbody>
</table>
<footer className="rel-log">
<span>
最近事件:
{job?.error
? job.error.slice(0, 120)
: running
? '作业执行中;无错误。'
: job
? `作业${jobStateText(job)};无错误。`
: sealJob
? '封存作业已结束。'
: '尚无作业记录。'}
</span>
<span>文件传输 100% ≠ 作业完成;生产验证通过前不显示“完成”。</span>
</footer>
</div>
</>
)}
</details>
</>
)
}
// F03: list rows must use the same exact snapshot query as the detail. The
// scope-wide latest passed record is never allowed to color another snapshot.
function SnapshotVerificationBadge({ scope, snapshotID }: { scope: Scope; snapshotID: string }) {
const [state, setState] = useState<'loading' | 'loaded' | 'error'>('loading')
const [record, setRecord] = useState<Awaited<ReturnType<typeof fetchSnapshotVerification>>['snapshot_latest']>(null)
const [error, setError] = useState('')
useEffect(() => {
const controller = new AbortController()
setState('loading')
setRecord(null)
setError('')
fetchSnapshotVerification(scope, snapshotID, controller.signal)
.then((value) => {
setRecord(value.snapshot_latest ?? null)
setState('loaded')
})
.catch((reason: unknown) => {
if ((reason as Error)?.name === 'AbortError') return
setError(reason instanceof Error ? reason.message : '读取该快照的恢复验证记录失败')
setState('error')
})
return () => controller.abort()
}, [scope, snapshotID])
if (state === 'loading') return <span className="rel-pill gray">读取验证记录…</span>
if (state === 'error')
return (
<span className="rel-pill red" title={error}>
验证状态读取失败
</span>
)
if (!record) return <span className="rel-pill gray">未做生产恢复验证</span>
return record.status === 'passed' ? (
<span className="rel-pill green">恢复验证通过 · {record.job_id}</span>
) : (
<span className="rel-pill red">恢复验证未通过 · {record.job_id}</span>
)
}
// F03: exact snapshot evidence. This component deliberately reads
// snapshot_latest, not latest: a passed record for another snapshot must not
// make this one look verified.
function SnapshotVerification({ scope, snapshotID }: { scope: Scope; snapshotID: string }) {
const [state, setState] = useState<'loading' | 'loaded' | 'error'>('loading')
const [record, setRecord] = useState<Awaited<ReturnType<typeof fetchSnapshotVerification>>['snapshot_latest']>(null)
const [error, setError] = useState('')
useEffect(() => {
const controller = new AbortController()
setState('loading')
setRecord(null)
setError('')
fetchSnapshotVerification(scope, snapshotID, controller.signal)
.then((value) => {
setRecord(value.snapshot_latest ?? null)
setState('loaded')
})
.catch((reason: unknown) => {
if ((reason as Error)?.name === 'AbortError') return
setError(reason instanceof Error ? reason.message : '读取该快照的恢复验证记录失败')
setState('error')
})
return () => controller.abort()
}, [scope, snapshotID])
return (
<details className="rel-snapshot-verification">
<summary>查看校验记录</summary>
{state === 'loading' ? <p className="rel-hint">正在读取该快照的恢复验证记录…</p> : null}
{state === 'error' ? <p className="rel-warn">{error}</p> : null}
{state === 'loaded' && !record ? (
<p className="rel-hint">该快照没有真实恢复验证记录;未验证,原因不是加载失败。</p>
) : null}
{record ? (
<div>
<p className="rel-hint">
该快照最近一次:{record.status === 'passed' ? '通过' : '未通过'} · {record.finished_at} · 作业{' '}
{record.job_id}
</p>
{record.failure ? <p className="rel-warn">原因:{record.failure}</p> : null}
{record.report ? (
<details>
<summary>本次恢复验证报告</summary>
<pre>{JSON.stringify(record.report, null, 2)}</pre>
</details>
) : null}
</div>
) : null}
</details>
)
}
interface DrawerProps {
view: ScopeView
page: LibrarySnapshotList | null
now: number
open: boolean
expanded: string | null
onExpand: (id: string | null) => void
onClose: () => void
canRestore: boolean
// 恢复条件来自容器(真实接口判定):双闸 / 该快照的授权 / 目标是否在维护。
restore: LibraryRestoreAvailability | null
restoreNotice: string | null
pendingRestore: boolean
pendingGrant: boolean
onGrantRestore: () => void
onRestore: () => void
}
function Drawer({
view,
page,
now,
open,
expanded,
onExpand,
onClose,
canRestore,
restore,
restoreNotice,
pendingRestore,
pendingGrant,
onGrantRestore,
onRestore,
}: DrawerProps) {
const listing = view.history
const [kindFilter, setKindFilter] = useState<'registered' | 'all' | 'test' | 'production'>('registered')
const [historyPage, setHistoryPage] = useState(0)
const [confirmRestore, setConfirmRestore] = useState(false)
const selectedRef = useRef<HTMLElement | null>(null)
useEffect(() => {
setKindFilter('registered')
setHistoryPage(0)
setConfirmRestore(false)
}, [view.scope, open])
useEffect(() => {
if (expanded) selectedRef.current?.scrollIntoView?.({ block: 'nearest' })
}, [expanded])
const versionLabelOf = (snapshot: LibrarySnapshot) =>
snapshotVersionLabel(view.overview?.versions, snapshot.snapshot_id)
const filtered = listing.filter((snapshot) => {
const label = versionLabelOf(snapshot)
if (kindFilter === 'all') return true
if (kindFilter === 'test') return label.includes('测试封存')
if (kindFilter === 'production') return label.includes('生产生效')
return !label.startsWith('未登记')
})
const pageSize = 8
const pageCount = Math.max(1, Math.ceil(filtered.length / pageSize))
const currentPage = Math.min(historyPage, pageCount - 1)
const pageItems = filtered.slice(currentPage * pageSize, currentPage * pageSize + pageSize)
const selected = listing.find((item) => item.snapshot_id === expanded)
if (!open) return null
return (
<div className="rel-drawer-backdrop" role="presentation" onClick={onClose}>
<aside className="rel-drawer" role="dialog" aria-label="版本与快照" onClick={(event) => event.stopPropagation()}>
<header className="rel-drawer-head">
<div>
<h2>版本与快照</h2>
<p>{scopeName(view.scope)} · 归档里的全部快照,类型按版本登记标注</p>
</div>
<button type="button" className="rel-close" onClick={onClose}>
关闭 ✕
</button>
</header>
<dl className="rel-drawer-kinds">
<div>
<dt>目标当前生效</dt>
<dd>
{view.overview?.production.state === 'known' && view.overview.production.version
? `${view.overview.production.version.version_label || view.overview.production.version.snapshot_id.slice(0, 12)} · ${stamp(view.overview.production.version.created_at)}`
: '无记录(未知)'}
</dd>
</div>
<div>
<dt>最近一次生产预备份</dt>
<dd>
{view.overview?.prebackup.state === 'known' && view.overview.prebackup.version
? `${view.overview.prebackup.version.version_label || view.overview.prebackup.version.snapshot_id.slice(0, 12)} · ${stamp(view.overview.prebackup.version.created_at)}${
view.overview.prebackup.version.source_job_id
? ` · 作业 ${view.overview.prebackup.version.source_job_id}`
: ''
}${view.overview.prebackup.bound_to_target ? ' · 与拟发布目标同快照' : ''}`
: '无记录(这个范围还没有任何生产预备份)'}
</dd>
</div>
<div>
<dt>测试封存</dt>
<dd>
{view.overview?.test_sealed
? `封存 ${view.overview.test_sealed.snapshot_id.slice(0, 12)} · ${stamp(view.overview.test_sealed.created_at)}`
: '无记录'}
</dd>
</div>
</dl>
<p className="rel-notice">三类版本分别记录,不能互相顶替:测试封存不等于生产生效,预备份不等于已验证恢复。</p>
<nav className="rel-history-filters" aria-label="快照类型筛选">
{(
[
['registered', '已登记版本'],
['test', '测试封存'],
['production', '生产生效'],
['all', '全部归档(含未登记)'],
] as const
).map(([value, label]) => (
<button
key={value}
type="button"
className={kindFilter === value ? 'active' : ''}
aria-pressed={kindFilter === value}
onClick={() => {
setKindFilter(value)
setHistoryPage(0)
}}
>
{label}
</button>
))}
</nav>
<table className="rel-drawer-table">
<thead>
<tr>
<th>版本 / 发布记录</th>
<th>状态</th>
<th>恢复资料</th>
<th>操作</th>
</tr>
</thead>
<tbody>
{filtered.length === 0 ? (
<tr>
<td colSpan={4} className="rel-table-empty">
{kindFilter === 'all'
? '尚无封存记录。封存测试版本后,这里会按时间列出每一份完整版本。'
: '当前筛选下没有已登记版本;切到「全部归档」可查看未登记文件。'}
</td>
</tr>
) : (
pageItems.map((snapshot) => {
const isSelected = expanded === snapshot.snapshot_id
// 类型只能来自版本登记:归档里的目标基线与预备份也在同一个根下。
const versionLabel = snapshotVersionLabel(view.overview?.versions, snapshot.snapshot_id)
const sealed = versionLabel.includes('测试封存')
return (
<tr key={snapshot.snapshot_id} className={isSelected ? 'selected' : ''}>
<td>
<strong>快照 {snapshot.snapshot_id.slice(0, 12)}</strong>
<small>{stamp(snapshot.created_at)}</small>
</td>
<td>
<span className={`rel-pill ${sealed ? 'green' : 'gray'}`}>{versionLabel}</span>
</td>
<td>
<SnapshotVerificationBadge scope={view.scope} snapshotID={snapshot.snapshot_id} />
</td>
<td>
<button
type="button"
className="rel-link"
onClick={() => onExpand(isSelected ? null : snapshot.snapshot_id)}
>
{isSelected ? '收起快照' : '查看快照'}
</button>
<button
type="button"
className="rel-link"
onClick={() => onExpand(isSelected ? null : snapshot.snapshot_id)}
>
{isSelected ? '恢复条件见下方' : '查看恢复条件'}
</button>
</td>
</tr>
)
})
)}
</tbody>
</table>
<div className="rel-history-pager" aria-label="快照分页">
<button type="button" disabled={currentPage <= 0} onClick={() => setHistoryPage(currentPage - 1)}>
上一页
</button>
<span>
第 {currentPage + 1} / {pageCount} 页 · 共 {filtered.length} 份
</span>
<button type="button" disabled={currentPage >= pageCount - 1} onClick={() => setHistoryPage(currentPage + 1)}>
下一页
</button>
</div>
{selected ? (
<section className="rel-snapshot" ref={selectedRef}>
<header>
<h3>封存 {selected.snapshot_id.slice(0, 12)} · 恢复资料</h3>
<span className="rel-pill green">
{snapshotVersionLabel(view.overview?.versions, selected.snapshot_id)}
</span>
</header>
<p className="rel-hint">
完整快照 <code>{selected.snapshot_id}</code> · 封存于 {stamp(selected.created_at)} · 模型{' '}
{selected.compatibility.embedding_model || '未记录'}
</p>
<dl className="rel-snapshot-grid">
<div>
<dt>文档 / 分块</dt>
<dd>
{selected.totals.documents ?? 0} 份 · {selected.totals.chunks ?? 0} 分块 ✓
</dd>
</div>
<div>
<dt>检索索引 / 向量</dt>
<dd>{selected.totals.index_documents ?? 0} 条 ✓</dd>
</div>
<div>
<dt>原文件 / 图片 / 附件</dt>
<dd>{selected.totals.resources ?? 0} 个 ✓</dd>
</div>
<div>
<dt>Wiki 完整快照</dt>
<dd>{selected.totals.wiki_pages ?? 0} 页 ✓</dd>
</div>
</dl>
<details className="rel-parts">
<summary>分项数量 / 字节 / 摘要({selected.parts.length} 项)</summary>
<table>
<thead>
<tr>
<th>类别</th>
<th>分项</th>
<th>数量</th>
<th>字节</th>
<th>摘要</th>
</tr>
</thead>
<tbody>
{selected.parts.map((part) => (
<tr key={`${part.kind}-${part.name}`}>
<td>{part.kind}</td>
<td>{part.name}</td>
<td>{part.count}</td>
<td>{part.bytes.toLocaleString('zh-CN')}</td>
<td>
<code>{part.sha256.slice(0, 10)}</code>
</td>
</tr>
))}
</tbody>
</table>
</details>
<p className="rel-hint">
以上是同一恢复点的配套内容,不支持只选择 Wiki 或某张数据表恢复。恢复速度需实测;“有备份文件”不等于可恢复。
</p>
<div className="rel-drawer-actions">
<SnapshotVerification scope={view.scope} snapshotID={selected.snapshot_id} />
{canRestore && restore && restore.authorization.state !== 'active' ? (
<button type="button" className="rel-secondary" onClick={onGrantRestore} disabled={pendingGrant}>
{pendingGrant ? '签发中…' : '签发恢复授权(30 分钟)'}
</button>
) : null}
{canRestore ? (
<button
type="button"
className="rel-danger"
onClick={() => setConfirmRestore(true)}
disabled={pendingRestore || restore?.allowed !== true}
title={
restore?.allowed
? '把整套生产知识状态恢复到这个快照'
: (restore?.reasons ?? []).join(';') || '恢复条件尚未读取到'
}
>
{pendingRestore ? '投递中…' : '恢复至该版本'}
</button>
) : (
<span className="rel-hint">按版本恢复仅管理员可发起</span>
)}
</div>
{restore && !restore.allowed ? (
<ul className="rel-gate" aria-label="恢复条件">
{restore.reasons.map((reason) => (
<li key={reason}>{reason}</li>
))}
</ul>
) : null}
{confirmRestore && selected ? (
<div className="rel-blocked" aria-label="按版本恢复影响确认">
<strong>确认按该快照恢复目标?</strong>
<p>
目标:{view.overview?.target_instance || '目标实例未读取'} · 知识库{' '}
{view.overview?.target_knowledge_base_id || '未读取'} · 快照 {selected.snapshot_id.slice(0, 12)}
</p>
<p>影响:停止目标写入者并关闭入口,按该快照回放数据库、索引、对象与 Wiki;恢复后复核通过才开入口。</p>
<p>恢复方式:本快照的完整写前镜像与预备份;不是同步,也不会登记新版本。</p>
<div className="rel-drawer-actions">
<button
type="button"
className="rel-danger"
onClick={() => {
setConfirmRestore(false)
onRestore()
}}
disabled={pendingRestore}
>
确认并恢复
</button>
<button type="button" className="rel-secondary" onClick={() => setConfirmRestore(false)}>
取消
</button>
</div>
</div>
) : null}
{restore?.allowed ? (
<p className="rel-hint">
条件已满足:生产写入闸口打开、这份快照有恢复授权
{restore.authorization.expires_at ? `(有效至 ${stamp(restore.authorization.expires_at)})` : ''}
、目标实例未在维护。
</p>
) : null}
{restore === null ? <p className="rel-hint">正在读取恢复条件…</p> : null}
{restoreNotice ? <p className="rel-notice">{restoreNotice}</p> : null}
</section>
) : null}
<footer className="rel-drawer-foot">
<div>
<strong>封存测试版本</strong>
<p>
封存只读测试库、短暂停住测试写入者并恢复;不会写入生产。当前作业:
{view.activeJob
? ` ${jobStateLabel[view.activeJob.state] ?? view.activeJob.state}(${elapsed(view.activeJob.created_at, now)})`
: ' 无'}
</p>
</div>
</footer>
<p className="rel-hint">
归档占用(只读):被版本引用的去重内容 {formatBytes(page?.content_bytes ?? 0)} · 磁盘分配{' '}
{formatBytes(page?.blob_allocated_bytes ?? 0)} · 未被引用 {page?.unreferenced_blobs ?? 0}{' '}
个。清理与保留策略在系统设置 → 存储管理:当前可查看去重与保护范围,删除与保留策略尚未开放。
</p>
</aside>
</div>
)
}
const viewScopeLabel = (scope: Scope, kbNames?: Record<Scope, string>) => scopeTitle(scope, kbNames?.[scope])
export function ReleaseTargetsView(props: ViewProps) {
const {
page,
jobs,
overview,
overviews,
loading,
error,
notice,
scope,
onScope,
kbNames,
drawerOpen,
onDrawer,
expandedSnapshot,
onExpandSnapshot,
pendingCapture,
canCapture,
canWrite,
canReconcileCapture,
pendingReconcileCapture,
onReconcileCapture,
sync,
baseline,
verification,
canRestore,
restore,
restoreNotice,
pendingRestore,
pendingGrant,
onGrantRestore,
onRestore,
now,
maintenance,
maintenanceOwnerJob,
onRefresh,
onCapture,
onRecover,
} = props
// A response with a different scope is not an observation for this tab.
const scopedOverview = (target: Scope): LibraryOverview | null => {
const candidate = overviews?.[target] ?? overview
return candidate?.scope === target ? candidate : null
}
const internal = scopeView(page, jobs, 'internal', scopedOverview('internal'))
const external = scopeView(page, jobs, 'external', scopedOverview('external'))
const view = scope === 'internal' ? internal : external
const legacyOrphanJob = Boolean(
view.job &&
view.job.kind === 'seal' &&
view.job.state === 'failed' &&
view.job.stage === '' &&
view.job.snapshot_id === '' &&
view.job.error === '队列中已无对应作业,业务作业未收到结果' &&
view.job.recovery === '封存作业由 agent 恢复来源;确认来源 healthy 后可重发'
)
const active =
Boolean(view.activeJob) || view.job?.state === 'running' || view.job?.state === 'pending' || legacyOrphanJob
// F06: 运行中禁止再次启动,也禁止把主按钮继续显示成可启动的绿色动作。
// 三类版本严格分开:target 是测试封存,production 是生产权威版本,prebackup 是本次预备份。
const target = view.overview?.test_sealed
// 没有 overview 时不能补一个 {state:'unknown'} 再当成"已探测且非空":
// production 保持 null,分类走 no-observation。
const production = view.overview?.production ?? null
const productionClass = productionTargetClass(production)
// 刷新失败但仍保留上一份 overview:显示可以继续,但必须标成上次观测。
const productionStale = Boolean(error) && production !== null
const productionNote = noObservationText(loading, error)
const prebackup = view.overview?.prebackup ?? { state: 'unknown' as const }
const diff = view.overview?.diff ?? {
state: 'unknown' as const,
reason: '生产与测试的文档级差异读取未接线',
added: [],
updated: [],
removed: [],
}
const gate = view.overview?.gate ?? { sync_allowed: false, reasons: ['整库状态接口不可用'] }
const authorization = view.overview?.authorization ?? { state: 'none' as const, reason: '整库状态接口不可用' }
const primaryAction = active
? {
label: '查看当前任务',
disabled: false,
hint: '作业正在处理,请勿重复启动',
onClick: () =>
document.getElementById('rel-progress')?.scrollIntoView?.({ behavior: 'smooth', block: 'start' }),
}
: !target
? {
label: pendingCapture ? '投递中…' : '封存测试版本',
disabled: !canCapture || pendingCapture || loading || Boolean(error),
hint: canCapture ? '短暂停止测试写入,保存完整版本后恢复' : captureHint(view, canWrite),
onClick: onCapture,
}
: authorization.state !== 'active'
? {
label: !sync.canSign ? '等待管理员授权' : sync.pendingGrant ? '签发中…' : '签发同步授权(30 分钟)',
disabled: !sync.canSign || sync.pendingGrant || pendingCapture || loading || Boolean(error),
hint: sync.canSign ? '授权绑定当前目标与快照;签发后仍需单独启动同步' : '请管理员完成本次授权',
onClick: sync.onGrant,
}
: {
label: sync.pending ? '投递中…' : '▶ 启动同步',
disabled: !sync.canStart || sync.pending || pendingCapture || loading || Boolean(error),
hint: sync.canStart
? '按已签发的同步授权启动:先固定测试版本,再备份目标并写入'
: `暂不能启动同步:${gate.reasons.join(';')}`,
onClick: sync.onStart,
}
return (
<section className="release-targets" aria-label="发布管理">
<header className="rel-head page-header">
<div>
<h1 className="page-title">发布管理</h1>
<p className="page-subtitle">封存测试版本 → 检查并授权 → 同步到生产</p>
</div>
<div className="rel-head-actions page-header-actions">
<button type="button" className="rel-secondary" onClick={() => onDrawer(true)}>
▣ 版本与快照
</button>
<button type="button" className="rel-secondary" onClick={onRefresh} disabled={loading}>
{loading ? '刷新中…' : '刷新'}
</button>
</div>
</header>
<div className="rel-tabs" role="tablist" aria-label="知识库">
{[internal, external].map((item) => {
const status = statusOf(item)
const isSelected = item.scope === scope
return (
<button
key={item.scope}
type="button"
role="tab"
aria-selected={isSelected}
className={isSelected ? 'rel-tab selected' : 'rel-tab'}
onClick={() => onScope(item.scope)}
>
<strong>{viewScopeLabel(item.scope, kbNames)}</strong>
<span className={`rel-pill ${status.tone}`}>{status.text}</span>
</button>
)
})}
</div>
{error ? (
<div className="rel-blocked">
<strong>读取失败</strong>
<p>{error}</p>
</div>
) : null}
{page && !page.available ? (
<div className="rel-blocked">
<strong>归档未接线</strong>
<p>{page.reason || '整库归档根未配置'}</p>
</div>
) : null}
{notice ? <p className="rel-notice">{notice}</p> : null}
<div className="rel-panel rel-jobhead">
<div className="rel-between">
<h2>
{viewScopeLabel(scope, kbNames)} ·{' '}
{active
? `${jobKindText(view.job?.kind)}进行中`
: view.snapshot
? '已封存,同步按条件放行'
: '尚无测试封存'}
</h2>
<div className="rel-head-actions">
{target && !active && canCapture ? (
<button
type="button"
className="rel-secondary"
onClick={onCapture}
disabled={pendingCapture || sync.pending || sync.pendingGrant || loading || Boolean(error)}
>
{pendingCapture ? '投递中…' : '重新封存'}
</button>
) : null}
<button
type="button"
className="rel-primary"
onClick={primaryAction.onClick}
disabled={primaryAction.disabled}
title={primaryAction.hint}
>
{primaryAction.label}
</button>
</div>
</div>
<p className="rel-target-identity" aria-label="实际目标实例">
目标实例 {view.overview?.target_instance || view.overview?.executor?.instance || '未读取'} · 项目{' '}
{view.overview?.target_project || view.overview?.executor?.project || '未读取'} · 知识库{' '}
{view.overview?.target_knowledge_base_id || target?.knowledge_base_id || '未读取'}({scopeName(scope)})
</p>
<p className="rel-versionline">
目标当前{' '}
{productionClass === 'known' && production?.version ? (
<b>
{production.version.version_label || `生效 ${production.version.snapshot_id.slice(0, 12)}`}
{' · '}
快照 {production.version.snapshot_id.slice(0, 12)}
</b>
) : productionClass === 'empty' ? (
<b>目标已读且为空(首次发布)</b>
) : productionClass === 'unreachable' ? (
<b className="rel-unknown">读取失败:{production?.reason || '无法读取目标整库状态'}</b>
) : productionClass === 'nonempty' ? (
<b className="rel-unknown">目标非空,尚无权威版本</b>
) : (
<b className="rel-unknown">{productionNote}</b>
)}
{productionStale ? <em className="rel-scope">({STALE_NOTE})</em> : null} → 拟发布{' '}
<b>{target ? `封存 ${target.snapshot_id.slice(0, 12)} · ${stamp(target.created_at)}` : '还没有测试封存'}</b> ·{' '}
{publishStateText(view.job)}
</p>
<dl className="rel-metrics">
<div>
<dt>新增文档</dt>
<dd className={diff.state === 'computed' ? '' : 'rel-unknown'}>
{diff.state === 'computed' ? diff.added.length : '未接入'}
</dd>
</div>
<div>
<dt>更新文档</dt>
<dd className={diff.state === 'computed' ? '' : 'rel-unknown'}>
{diff.state === 'computed' ? diff.updated.length : '未接入'}
</dd>
</div>
<div>
<dt>删除文档</dt>
<dd className={diff.state === 'computed' ? '' : 'rel-unknown'}>
{diff.state === 'computed' ? diff.removed.length : '未接入'}
</dd>
</div>
<div>
<dt>Wiki 发布方式</dt>
<dd>{target ? '完整快照' : '未接入'}</dd>
</div>
</dl>
{target?.source_identity ? (
<details className="rel-source-identity">
<summary>来源身份与完整摘要</summary>
<p>
来源实例:{target.source_identity.project} / {target.source_identity.app}
</p>
<p>
来源租户 / 知识库:{target.source_identity.tenant_id} / {target.source_identity.knowledge_base_id}
</p>
<p>来源身份:{target.source_id}</p>
<p>快照摘要:{target.snapshot_id}</p>
</details>
) : null}
<details className="rel-disclosure rel-integrity" key={`integrity-${scope}`}>
<summary>
封存完整性 <span>{target ? '查看分块、索引与 Wiki 清单' : '尚无封存'}</span>
</summary>
<ul className="rel-checklist">
<li className={target ? 'ok' : 'unknown'}>
{target
? `✓ 文档解析与索引完整(${target.totals.chunks ?? 0} 分块 / ${target.totals.index_documents ?? 0} 索引)`
: '○ 文档解析与索引:未接入'}
{target ? (
<em className="rel-scope">
依据 {stamp(target.created_at)} 封存的测试库全库快照,不代表实时测试库已就绪
</em>
) : null}
</li>
<li className={target ? 'ok' : 'unknown'}>
{target ? `✓ Wiki 快照完整(${target.totals.wiki_pages ?? 0} 页)` : '○ Wiki 快照:未接入'}
{target ? <em className="rel-scope">同一份封存快照,不是实时 Wiki 队列状态</em> : null}
</li>
<li className={target ? 'ok' : 'unknown'}>
{target ? `✓ 清单与摘要登记:${target.parts.length} 项部件摘要已记录` : '○ 数据完整性:尚无封存可核验'}
{target ? (
<em className="rel-scope">封存时逐项哈希登记;列表只校验清单自身,字节级复核在同步/恢复执行前进行</em>
) : null}
</li>
</ul>
{!canCapture ? <p className="rel-hint">{captureHint(view, canWrite)}</p> : null}
</details>
<p className="rel-next-step">
{active
? '正在处理,页面会自动更新进度。'
: !target
? canCapture
? '还没有测试库封存。下一步:封存测试版本。'
: captureHint(view, canWrite)
: authorization.state !== 'active'
? sync.canSign
? '下一步:检查下方发布条件,再签发本次同步授权。'
: '下一步:请管理员签发本次同步授权。'
: sync.canStart
? '条件已满足,可启动同步。'
: '请先处理以下阻塞项;备份与恢复验证入口在下方「发布准备与恢复验证」。'}
</p>
{!active && gate.reasons.length > 0 ? (
<ul className="rel-gate" aria-label="启动同步的缺项">
{gate.reasons.map((reason) => (
<li key={reason}>{reason}</li>
))}
</ul>
) : null}
<p className="rel-footnote">启动后先固定测试版本,再备份生产。备份失败或恢复条件不满足,不进入生产写入。</p>
</div>
<details
className="rel-disclosure"
key={`maintenance-${scope}-${Boolean(maintenance?.held)}`}
open={Boolean(maintenance?.held)}
>
<summary>
目标维护{' '}
<span>
{maintenance?.held ? '维护占用中,请关注当前作业' : maintenance ? '查看维护记录与诊断' : '维护状态尚未读取'}
</span>
</summary>
<MaintenanceCard
maintenance={maintenance}
ownerJob={maintenanceOwnerJob}
scope={scope}
canWrite={canWrite}
onRecover={onRecover}
/>
</details>
{active ? (
<ProgressBody
view={view}
now={now}
canReconcileCapture={canReconcileCapture}
pendingReconcileCapture={pendingReconcileCapture}
onReconcileCapture={onReconcileCapture}
/>
) : (
<ReadyBody
view={view}
diff={diff}
production={production}
productionNote={productionNote}
stale={productionStale}
prebackup={prebackup}
gate={gate}
authorization={authorization}
sync={sync}
baseline={baseline}
verification={verification}
/>
)}
<Drawer
view={view}
page={page}
now={now}
open={drawerOpen}
expanded={expandedSnapshot}
onExpand={onExpandSnapshot}
onClose={() => onDrawer(false)}
canRestore={canRestore}
restore={restore}
restoreNotice={restoreNotice}
pendingRestore={pendingRestore}
pendingGrant={pendingGrant}
onGrantRestore={onGrantRestore}
onRestore={onRestore}
/>
</section>
)
}
export function ReleaseTargets() {
const auth = useOptionalAuth()
const [page, setPage] = useState<LibrarySnapshotList | null>(null)
const [jobs, setJobs] = useState<LibraryCaptureJob[]>([])
const [overviews, setOverviews] = useState<Record<Scope, LibraryOverview | null>>({
internal: null,
external: null,
})
const [loading, setLoading] = useState(true)
const [error, setError] = useState<string | null>(null)
const [notice, setNotice] = useState<string | null>(null)
const [maintenances, setMaintenances] = useState<Record<Scope, LibraryMaintenanceView | null>>({
internal: null,
external: null,
})
// 维护窗口持有作业的详情:按 owner_job_id 单独读,和 scope 最新作业无关。
const [maintenanceJobs, setMaintenanceJobs] = useState<Record<Scope, LibraryJobLookup>>({
internal: { state: 'unread' },
external: { state: 'unread' },
})
// 轮询会并发多次 load:晚到的旧响应不许覆盖更新的维护窗口/作业。
const loadSeq = useRef(0)
const [scope, setScope] = useState<Scope>('internal')
const [drawerOpen, setDrawerOpen] = useState(false)
const [expandedSnapshot, setExpandedSnapshot] = useState<string | null>(null)
const [pendingCapture, setPendingCapture] = useState(false)
// 真实库名只用于显示:读不到就退回业务名,不让它影响发布状态。
const [kbNames, setKbNames] = useState<Record<Scope, string>>({ internal: '', external: '' })
const [pendingReconcileCapture, setPendingReconcileCapture] = useState('')
const [now, setNow] = useState(() => Date.now())
const load = useCallback(async (signal?: AbortSignal) => {
const seq = ++loadSeq.current
setLoading(true)
try {
const [
snapshots,
captures,
internalOverview,
externalOverview,
internalMaintenance,
externalMaintenance,
bindings,
] = await Promise.all([
fetchLibrarySnapshots(signal),
fetchLibraryCaptures(signal),
fetchLibraryOverview('internal', signal),
fetchLibraryOverview('external', signal),
fetchLibraryMaintenance('internal', signal),
fetchLibraryMaintenance('external', signal),
// 库名只是展示用:读不到(未登录/WeKnora 未连接)不能让整页报错。
fetchRoutingBindings(signal).catch(() => null),
])
// 只读既有作业详情接口,按维护记录的 owner_job_id 精确取;读不到就记下来,
// 不用 overview 的最新作业兜底(那是另一件事,会把失败窗口显示成已完成)。
const ownerIDs = {
internal: maintenanceOwnerJobID(internalMaintenance),
external: maintenanceOwnerJobID(externalMaintenance),
}
const [internalOwnerJob, externalOwnerJob] = await Promise.all([
ownerIDs.internal
? fetchLibraryJobDetail(ownerIDs.internal, signal)
: Promise.resolve<LibraryJobLookup>({ state: 'unread' }),
ownerIDs.external
? fetchLibraryJobDetail(ownerIDs.external, signal)
: Promise.resolve<LibraryJobLookup>({ state: 'unread' }),
])
// 晚回包直接丢掉:不覆盖更新的窗口,也不把旧窗口的作业挂到新窗口上。
if (seq !== loadSeq.current) return
setPage(snapshots)
setJobs(captures)
setOverviews({ internal: internalOverview, external: externalOverview })
setMaintenances({ internal: internalMaintenance, external: externalMaintenance })
setMaintenanceJobs({ internal: internalOwnerJob, external: externalOwnerJob })
if (bindings) {
setKbNames({ internal: bindings.internal_kb_name, external: bindings.external_kb_name })
}
setNow(Date.now())
setError(null)
} catch (loadError) {
if ((loadError as Error).name === 'AbortError') return
if (seq !== loadSeq.current) return
setError(loadError instanceof Error ? loadError.message : '加载发布状态失败')
} finally {
if (seq === loadSeq.current) setLoading(false)
}
}, [])
useEffect(() => {
const controller = new AbortController()
void load(controller.signal)
return () => controller.abort()
}, [load])
const role = auth?.identity?.role
const canWrite = role === 'engineer' || role === 'admin'
// 恢复写的是整套生产知识状态,接口只认管理员;页面必须与它一致。
const canRestore = role === 'admin'
// 签发同步授权同样是管理员动作:授权=钉死目标+快照+参数,不等于执行。
const canSignSync = role === 'admin'
const canCapture = canWrite && page?.capture_available === true
const [pendingSyncGrant, setPendingSyncGrant] = useState(false)
const [pendingSync, setPendingSync] = useState(false)
const [pendingBaseline, setPendingBaseline] = useState(false)
const current = overviews[scope]
const targetSnapshot = current?.test_sealed?.snapshot_id ?? ''
const grantSync = async () => {
if (!targetSnapshot) {
setNotice('还没有可发布的测试封存:先封存测试版本,再签发同步授权')
return
}
setPendingSyncGrant(true)
setNotice(null)
try {
const grant = await createLibrarySyncAuthorization(scope, targetSnapshot)
setNotice(
`已签发同步授权${grant.authorized_by ? `(${grant.authorized_by})` : ''},有效至 ${stamp(grant.expires_at)};` +
'执行仍需在下一次操作里点"启动同步"'
)
await load()
} catch (grantError) {
setNotice(grantError instanceof Error ? grantError.message : '签发同步授权失败')
} finally {
setPendingSyncGrant(false)
}
}
const startSync = async () => {
if (!targetSnapshot || !current?.test_sealed?.source_id) {
setNotice('还没有与当前来源绑定的可发布封存,请刷新状态')
return
}
setPendingSync(true)
setNotice(null)
try {
const accepted = await enqueueLibrarySync(scope, targetSnapshot, current?.test_sealed?.source_id ?? '')
setNotice(`已投递同步:${accepted.job_id}(先固定测试版本并生成预备份,再写目标)`)
await load()
} catch (syncError) {
setNotice(syncError instanceof Error ? syncError.message : '启动同步失败')
} finally {
setPendingSync(false)
}
}
const startBaseline = async () => {
setPendingBaseline(true)
setNotice(null)
try {
const accepted = await enqueueLibraryBaseline(scope)
setNotice(`已投递建立基线:${accepted.job_id}(维护隔离下捕获目标整库,逐类校验后登记为权威基线)`)
await load()
} catch (baselineError) {
setNotice(baselineError instanceof Error ? baselineError.message : '建立目标权威基线失败')
} finally {
setPendingBaseline(false)
}
}
// 恢复条件随"展开的那份快照"变化:闸口、该快照的授权、实例是否在维护都由接口判定。
const [restore, setRestore] = useState<LibraryRestoreAvailability | null>(null)
const [restoreNotice, setRestoreNotice] = useState<string | null>(null)
const [pendingRestore, setPendingRestore] = useState(false)
// 按预备份恢复(library.recover)是独立的队列作业,不会产生新的 library_jobs 行:
// 只靠 jobs/overview 判断会让页面在投递后立刻停止轮询,恢复完成也停在旧状态(F12)。
const [pendingRecovery, setPendingRecovery] = useState(false)
const recoveryStartedAt = useRef(0)
// 恢复验证是独立业务作业:投递后父页面必须自己轮询 overview/维护/闸口,
// 只在子面板刷新证据会让页面停在点击前的状态(审核 B4)。
const [activeVerifyJob, setActiveVerifyJob] = useState('')
const [pendingGrant, setPendingGrant] = useState(false)
// 轮询覆盖"投递 → 终态读回":投递中的动作也算在跑(点完到 worker 落库之间
// 有一次空窗,只看已有作业会让页面停在"尚未启动")。终态(成功/失败/取消)
// 再做一次读回就停,不会无限轮询失败作业。
const polling = libraryPollingActive({
captures: jobs,
overviews,
pending:
pendingCapture ||
pendingSync ||
pendingBaseline ||
pendingRestore ||
pendingSyncGrant ||
pendingGrant ||
activeVerifyJob !== '',
recoveryPending: pendingRecovery,
maintenances,
})
const wasPolling = useRef(false)
useEffect(() => {
if (polling) {
wasPolling.current = true
const timer = window.setInterval(() => {
setNow(Date.now())
void load().catch(() => undefined)
}, 3000)
return () => window.clearInterval(timer)
}
if (wasPolling.current) {
wasPolling.current = false
// 终态读回:拿最后一次的 finished_at / 阶段终值,然后停下。
void load().catch(() => undefined)
}
return undefined
}, [polling, load])
const [restoreRound, setRestoreRound] = useState(0)
const restoreSnapshot = expandedSnapshot ?? ''
useEffect(() => {
if (!drawerOpen || !restoreSnapshot) {
setRestore(null)
return
}
const controller = new AbortController()
void fetchLibraryRestoreAvailability(scope, restoreSnapshot, controller.signal)
.then((value) => setRestore(value))
.catch(() => setRestore(null))
return () => controller.abort()
}, [drawerOpen, restoreSnapshot, scope, restoreRound])
const grantRestore = async () => {
if (!restoreSnapshot) return
setPendingGrant(true)
setRestoreNotice(null)
try {
const grant = await createLibraryRestoreAuthorization(scope, restoreSnapshot)
setRestoreNotice(
`已签发恢复授权${grant.authorized_by ? `(${grant.authorized_by})` : ''},有效至 ${stamp(grant.expires_at)}`
)
setRestoreRound((round) => round + 1)
await load()
} catch (grantError) {
setRestoreNotice(grantError instanceof Error ? grantError.message : '签发恢复授权失败')
} finally {
setPendingGrant(false)
}
}
const startRestore = async () => {
if (!restoreSnapshot) return
setPendingRestore(true)
setRestoreNotice(null)
try {
const accepted = await enqueueLibraryRestore(scope, restoreSnapshot)
setRestoreNotice(`已投递恢复:${accepted.job_id}(整套生产知识状态回到该快照)`)
setRestoreRound((round) => round + 1)
await load()
} catch (restoreError) {
setRestoreNotice(restoreError instanceof Error ? restoreError.message : '发起恢复失败')
} finally {
setPendingRestore(false)
}
}
const startCapture = async () => {
setPendingCapture(true)
setNotice(null)
try {
const accepted = await enqueueLibraryCapture(scope)
setNotice(
accepted.reused
? `该封存作业已存在:${scopeLabel(scope)} · ${accepted.capture_job}(${jobStateLabel[accepted.state] ?? accepted.state})`
: `已投递封存:${scopeLabel(scope)} · ${accepted.capture_job}`
)
await load()
} catch (captureError) {
setNotice(captureError instanceof Error ? captureError.message : '发起封存失败')
} finally {
setPendingCapture(false)
}
}
const reconcileCapture = async (jobID: string) => {
setPendingReconcileCapture(jobID)
setNotice(null)
try {
const result = await reconcileLibraryCapture(jobID)
setNotice(
result.already_succeeded
? `封存作业 ${jobID} 已是成功终态,未重复写入`
: `已核对封存结果:${jobID} → ${result.snapshot_id.slice(0, 12)}(审计 ${result.audit_operation_id ?? '已记录'})`
)
await load()
} catch (reconcileError) {
setNotice(reconcileError instanceof Error ? reconcileError.message : '核对封存结果失败')
} finally {
setPendingReconcileCapture('')
}
}
const recover = async (windowJobID: string) => {
setNotice(null)
try {
const accepted = await enqueueLibraryRecovery(scope, windowJobID)
// 从这里开始页面必须持续读回,直到维护窗口真的关闭(成功)或恢复失败被记下来。
recoveryStartedAt.current = Date.now()
setPendingRecovery(true)
setNotice(`已投递按预备份恢复:${accepted.recovery_job || '(未返回作业号)'};正在等待恢复与校验完成`)
await load()
} catch (recoveryError) {
setPendingRecovery(false)
setNotice(recoveryError instanceof Error ? recoveryError.message : '恢复请求失败')
}
}
// 恢复轮询的收尾:维护窗口不再被持有 ⇒ 读到终态,停止等待并给出结论。
// 超时不是"成功":只停止轮询并把状态留给页面显示(恢复失败会继续 held + needs_restore)。
useEffect(() => {
if (!pendingRecovery) return
const held = Boolean(maintenances[scope]?.held)
const timedOut = Date.now() - recoveryStartedAt.current > 15 * 60 * 1000
if (!held || timedOut) {
setPendingRecovery(false)
if (timedOut) setNotice('恢复轮询超时:请查看维护窗口状态(仍在维护说明恢复/校验未通过)')
void load().catch(() => undefined)
}
}, [pendingRecovery, maintenances, scope, load])
return (
<>
<ReleaseTargetsView
page={page}
jobs={jobs}
overview={overviews[scope]}
overviews={overviews}
loading={loading}
error={error}
notice={notice}
scope={scope}
onScope={(next) => {
setScope(next)
setExpandedSnapshot(null)
// F10: 旧操作通知属于旧作业/旧对象,切范围后不得继续挂在页顶。
setNotice(null)
}}
kbNames={kbNames}
drawerOpen={drawerOpen}
onDrawer={setDrawerOpen}
expandedSnapshot={expandedSnapshot}
onExpandSnapshot={setExpandedSnapshot}
pendingCapture={pendingCapture}
canCapture={canCapture}
canWrite={canWrite}
canReconcileCapture={role === 'admin'}
pendingReconcileCapture={pendingReconcileCapture}
onReconcileCapture={(jobID) => void reconcileCapture(jobID)}
sync={{
canSign: canSignSync,
pendingGrant: pendingSyncGrant,
onGrant: () => void grantSync(),
canStart: current?.gate.sync_allowed === true && Boolean(current?.test_sealed?.source_id),
pending: pendingSync,
onStart: () => void startSync(),
}}
baseline={{
canStart: canSignSync,
pending: pendingBaseline,
onStart: () => void startBaseline(),
}}
verification={{
onAccepted: (jobId) => {
// F10: 新验证作业开始时清掉上一次封存/同步的旧通知。
setNotice(null)
setActiveVerifyJob(jobId)
void load()
},
onComplete: () => {
setActiveVerifyJob('')
void load()
},
}}
canRestore={canRestore}
restore={restore}
restoreNotice={restoreNotice}
pendingRestore={pendingRestore}
pendingGrant={pendingGrant}
onGrantRestore={() => void grantRestore()}
onRestore={() => void startRestore()}
maintenance={maintenances[scope]}
maintenanceOwnerJob={maintenanceJobs[scope]}
now={now}
onRefresh={() => void load()}
onCapture={() => void startCapture()}
onRecover={(windowJobID) => void recover(windowJobID)}
/>
</>
)
}