dsh-config-manager 0.1.47 → 0.1.49

package/src/client/snapshots/SnapshotsPanel.tsx

@@ -7,14 +7,31 @@
  * 状态组件内自持（useState），同时经 toSnapshotsStoreSlice() 镜像进模块级 runStore：
  * 模块级单例保证「切 tab 不丢」，sessionStorage 白名单保证「刷新恢复」
  * （选中快照 / dry-run 计划 / 执行报告；快照列表本身可随时重载，不持久化）。
+ *
+ * 视图底部附「定时全量备份」设置卡（BackupScheduleCard，m-backup-schedule）：
+ * 开关 + 间隔档位（6h/12h/24h/7d）保存经 PUT /backup-schedule（host 校验 + 重排
+ * 调度器）；「立即备份」经 POST /backup-schedule/run 复用 BackupScheduler.runOnce
+ * （同一时刻防重）。草稿镜像 runStore.snapshots.backupDraft（未保存修改切 tab /
+ * 刷新保留）。安全：定时备份恒不含 secret、不加密；本卡无敏感字段。
  */
 import { useEffect, useRef, useState } from 'react'
 import type { ReactNode } from 'react'
 import type { RestorePlan, RestoreReport, SnapshotMeta } from '../../core/restore.ts'
 import type { ConfigManagerApi } from '../api.ts'
 import type { TranslateNS } from '../client-types.ts'
-import { Badge, Banner, Button, Card, Empty, SectionTitle, Spinner } from '../common/ui.tsx'
+import { Badge, Banner, Button, Card, Checkbox, Empty, Field, SectionTitle, Spinner } from '../common/ui.tsx'
+import { ConfirmDialog } from '../common/ConfirmDialog.tsx'
 import { runStore, toSnapshotsStoreSlice, type SnapshotsStoreSlice } from '../run-store.ts'
+import {
+  BACKUP_INTERVAL_OPTIONS,
+  backupDraftDirty,
+  backupRunBadgeKind,
+  validateBackupScheduleDraft,
+  type BackupInterval,
+  type BackupRunStatus,
+  type BackupScheduleDraft,
+  type BackupScheduleStatus,
+} from '../../ui/backup-schedule.ts'
 import css from '../config-manager.module.css'
 
 export interface SnapshotsPanelProps {
@@ -81,12 +98,15 @@ function actionKindLabel(kind: string): string {
 /**
  * 从 runStore 恢复上次的快照面板状态（切 tab 回 / 刷新后挂载）。
  * 无敏感字段；plan/report 为纯数据，可安全序列化恢复。
+ * running 来自 store 镜像（刷新后经 runStore.resume() 以宿主 /runs 为权威重新置位——
+ * 持久化白名单恒为 false，绝不把浏览器陈旧状态当成恢复执行中的依据）。
  */
 function initFromStore(): PanelState {
   const s: SnapshotsStoreSlice = runStore.getSnapshot().snapshots
   return {
     ...initial,
     selectedId: s.selectedId,
+    running: s.running,
     plan: s.plan,
     report: s.report,
     actionError: s.actionError,
@@ -100,23 +120,30 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
   const stateRef = useRef<PanelState>(state)
   /** 挂载守卫：卸载后不再 setState（store 镜像仍执行，异步结果照常落库） */
   const mountedRef = useRef(true)
+  /** dry-run 计划请求代数：快速切换快照时作废在途旧请求（防晚到响应覆盖新选择） */
+  const planGeneration = useRef(0)
+  /** 执行恢复的二次确认弹窗开关（危险操作，DESIGN.md §8.11 场景） */
+  const [confirmOpen, setConfirmOpen] = useState(false)
 
   /**
    * 统一提交入口：更新 stateRef → 挂载时 setState → **总是**镜像进 runStore。
    * 关键：镜像不依赖 effect flush —— 异步操作（dry-run 计划/执行恢复）完成回调
    * 在组件已卸载（切走 tab）时也能把结果（plan/report）写进 store，切回恢复。
+   * backupDraft 由 BackupScheduleCard 独立管理，此处从 store 读回原值避免覆盖。
    */
   const commit = (next: PanelState): void => {
     stateRef.current = next
     if (mountedRef.current) setState(next)
-    runStore.patch({ snapshots: toSnapshotsStoreSlice(next) })
+    const backupDraft = runStore.getSnapshot().snapshots.backupDraft
+    runStore.patch({ snapshots: { ...toSnapshotsStoreSlice({ ...next, backupDraft }), backupDraft } })
   }
   const patch = (p: Partial<PanelState>): void => commit({ ...stateRef.current, ...p })
 
   /** 卸载时置挂载守卫 + 最后镜像一次（防止「最后一次改动后立即切 tab」时丢状态）。 */
   useEffect(() => () => {
     mountedRef.current = false
-    runStore.patch({ snapshots: toSnapshotsStoreSlice(stateRef.current) })
+    const backupDraft = runStore.getSnapshot().snapshots.backupDraft
+    runStore.patch({ snapshots: { ...toSnapshotsStoreSlice({ ...stateRef.current, backupDraft }), backupDraft } })
   }, [])
 
   const load = (): void => {
@@ -135,10 +162,18 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
   useEffect(load, [api])
 
   const select = (id: string): void => {
+    // 每次选择递增代数：用户快速切换快照时，旧 dry-run 请求晚到直接丢弃
+    // （防止「选了 B 却显示 A 的计划」的状态串扰）。
+    const generation = planGeneration.current + 1
+    planGeneration.current = generation
     patch({ selectedId: id, plan: null, report: null, actionError: null, planning: true })
     api.restoreSnapshot(id, true).then(
-      (res) => { patch({ planning: false, plan: res.plan ?? null }) },
+      (res) => {
+        if (generation !== planGeneration.current) return
+        patch({ planning: false, plan: res.plan ?? null })
+      },
       (err) => {
+        if (generation !== planGeneration.current) return
         patch({
           planning: false,
           actionError: err instanceof Error ? err.message : String(err),
@@ -150,6 +185,11 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
   const execute = (): void => {
     if (state.selectedId === null || state.running) return
     patch({ running: true, report: null, actionError: null })
+    setConfirmOpen(false)
+    // m3/P1-1：宿主侧权威防重（/restore 经 RunRegistry 登记，同 kind running → 409）；
+    // 前端 running 只是 UX 镜像。watchRunning 轮询宿主 /runs + /progress——
+    // 切 tab（卸载）后轮询继续，完成/失败经 applySettled 写入 store，切回 initFromStore 恢复。
+    runStore.watchRunning('restore', 500)
     api.restoreSnapshot(state.selectedId, false).then(
       (res) => { patch({ running: false, report: res.report ?? null }) },
       (err) => {
@@ -158,7 +198,7 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
           actionError: err instanceof Error ? err.message : String(err),
         })
       },
-    )
+    ).finally(() => { runStore.stopRunWatch('restore') })
   }
 
   const summary = (): string => {
@@ -219,6 +259,7 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
                   aria-selected={selected}
                   data-active={selected ? '' : undefined}
                   className={css.snapshotRow}
+                  disabled={state.planning || state.running}
                   onClick={() => { select(meta.id) }}
                 >
                   <span title={meta.id}>{new Date(meta.createdAt).toLocaleString()}</span>
@@ -255,8 +296,7 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
                     <Button
                       variant="danger"
                       disabled={state.running || state.plan.actions.every((a) => a.kind === 'skip')}
-                      onClick={execute}
-                      title={t('snapshots.confirmRestore')}
+                      onClick={() => { setConfirmOpen(true) }}
                     >
                       {state.running ? t('snapshots.executing') : t('snapshots.execute')}
                     </Button>
@@ -279,6 +319,220 @@ export function SnapshotsPanel({ api, t }: SnapshotsPanelProps) {
           )}
         </>
       )}
+
+      {/* 定时全量备份设置（独立于快照列表状态，始终展示） */}
+      <BackupScheduleCard api={api} t={t} />
+
+      {/* 执行恢复二次确认（破坏性操作：整文件还原/删除 + 卸载插件；busy 防重复提交） */}
+      <ConfirmDialog
+        open={confirmOpen}
+        title={t('snapshots.confirmTitle')}
+        message={t('snapshots.confirmRestore')}
+        confirmLabel={t('snapshots.execute')}
+        cancelLabel={t('common.cancel')}
+        danger
+        busy={state.running}
+        onConfirm={execute}
+        onCancel={() => { setConfirmOpen(false) }}
+      />
     </div>
   )
 }
+
+/* ------------------------------------------------- 定时全量备份设置卡 */
+
+/** 间隔档位 → 字典键（t 的类型是字面量联合，switch 保持类型安全）。 */
+function intervalLabel(t: TranslateNS<'config-manager'>, interval: BackupInterval): string {
+  switch (interval) {
+    case '6h': return t('backupSchedule.interval.6h')
+    case '12h': return t('backupSchedule.interval.12h')
+    case '24h': return t('backupSchedule.interval.24h')
+    case '7d': return t('backupSchedule.interval.7d')
+  }
+}
+
+/** 上次运行状态 → 字典键。 */
+function runStatusLabel(t: TranslateNS<'config-manager'>, status: BackupRunStatus | undefined): string {
+  switch (status) {
+    case 'success': return t('backupSchedule.status.success')
+    case 'skipped': return t('backupSchedule.status.skipped')
+    case 'failed': return t('backupSchedule.status.failed')
+    default: return '—'
+  }
+}
+
+function formatRunTime(iso: string | undefined): string {
+  if (iso === undefined || iso === '') return ''
+  const d = new Date(iso)
+  return Number.isNaN(d.getTime()) ? iso : d.toLocaleString()
+}
+
+/**
+ * 定时全量备份设置卡：总开关 + 间隔档位 + 上次运行状态 + 保存 / 立即备份。
+ * 状态自持；草稿镜像 runStore.snapshots.backupDraft（未保存修改切 tab/刷新保留），
+ * 保存成功清草稿（宿主配置为权威）。
+ */
+function BackupScheduleCard({ api, t }: { api: ConfigManagerApi; t: TranslateNS<'config-manager'> }) {
+  const [status, setStatus] = useState<'loading' | 'ready' | 'error'>('loading')
+  const [error, setError] = useState<string | null>(null)
+  const [draft, setDraft] = useState<BackupScheduleDraft>({ enabled: false, interval: '24h' })
+  const [saved, setSaved] = useState<BackupScheduleStatus | null>(null)
+  const [saving, setSaving] = useState(false)
+  const [running, setRunning] = useState(false)
+  const [lastRun, setLastRun] = useState<BackupRunStatus | undefined>(undefined)
+  const [lastRunDetail, setLastRunDetail] = useState<string | null>(null)
+  const [flash, setFlash] = useState<string | null>(null)
+  const [actionError, setActionError] = useState<string | null>(null)
+  /** 挂载守卫：切 tab 卸载后异步回调只更新 store（草稿），不再 setState（React 18 无告警但浪费） */
+  const mountedRef = useRef(true)
+
+  useEffect(() => () => { mountedRef.current = false }, [])
+
+  const load = (): void => {
+    setStatus('loading')
+    setError(null)
+    api.backupSchedule().then(
+      (schedule) => {
+        if (!mountedRef.current) return
+        setSaved(schedule)
+        // 有未保存草稿（切 tab 回来）则保留，否则以宿主配置为权威
+        setDraft(runStore.getSnapshot().snapshots.backupDraft ?? { enabled: schedule.enabled, interval: schedule.interval })
+        setLastRun(schedule.lastRunStatus)
+        setLastRunDetail(formatRunTime(schedule.lastRunAt))
+        setStatus('ready')
+      },
+      (err) => {
+        if (!mountedRef.current) return
+        setStatus('error')
+        setError(err instanceof Error ? err.message : String(err))
+      },
+    )
+  }
+
+  useEffect(load, [api])
+
+  const updateDraft = (next: BackupScheduleDraft): void => {
+    setDraft(next)
+    runStore.patch({ snapshots: { backupDraft: next } })
+  }
+
+  const save = (): void => {
+    if (saving || running) return
+    const parsed = validateBackupScheduleDraft(draft)
+    if (!parsed.ok) {
+      setActionError(parsed.error)
+      return
+    }
+    setSaving(true)
+    setFlash(null)
+    setActionError(null)
+    api.saveBackupSchedule(parsed.value).then(
+      (schedule) => {
+        // 宿主已保存：无论面板是否仍挂载都清 store 草稿（否则切回会显示陈旧未保存态）
+        runStore.patch({ snapshots: { backupDraft: null } })
+        if (!mountedRef.current) return
+        setSaved(schedule)
+        setDraft({ enabled: schedule.enabled, interval: schedule.interval })
+        setLastRun(schedule.lastRunStatus)
+        setLastRunDetail(formatRunTime(schedule.lastRunAt))
+        setSaving(false)
+        setFlash(t('backupSchedule.saved'))
+      },
+      (err) => {
+        if (!mountedRef.current) return
+        setSaving(false)
+        setActionError(err instanceof Error ? err.message : String(err))
+      },
+    )
+  }
+
+  const runNow = (): void => {
+    if (running || saving) return
+    setRunning(true)
+    setFlash(null)
+    setActionError(null)
+    api.runBackupNow().then(
+      (res) => {
+        if (!mountedRef.current) return
+        setSaved(res.schedule)
+        setLastRun(res.run.status)
+        setLastRunDetail(res.run.zip !== undefined && res.run.zip !== ''
+          ? res.run.zip
+          : (res.run.skipReason !== undefined ? res.run.skipReason : formatRunTime(res.schedule.lastRunAt)))
+        setRunning(false)
+      },
+      (err) => {
+        if (!mountedRef.current) return
+        setRunning(false)
+        setActionError(err instanceof Error ? err.message : String(err))
+      },
+    )
+  }
+
+  const dirty = backupDraftDirty(draft, saved)
+  const busy = saving || running
+
+  return (
+    <Card className={css.card}>
+      <div className={css.groupLabel}>{t('backupSchedule.title')}</div>
+      <div className={css.hint}>{t('backupSchedule.hint')}</div>
+
+      {status === 'loading' && <Spinner label={t('backupSchedule.loading')} />}
+
+      {status === 'error' && (
+        <Banner kind="error">
+          {t('backupSchedule.error')}
+          <Button variant="primary" onClick={load}>{t('common.retry')}</Button>
+        </Banner>
+      )}
+
+      {status === 'ready' && (
+        <>
+          <Field label={t('backupSchedule.enabled')}>
+            <Checkbox
+              checked={draft.enabled}
+              onChange={(checked) => { updateDraft({ ...draft, enabled: checked }) }}
+              label={t('backupSchedule.enabledHint')}
+              disabled={busy}
+            />
+          </Field>
+          <Field label={t('backupSchedule.interval')}>
+            <select
+              className={css.select}
+              value={draft.interval}
+              disabled={busy}
+              onChange={(event) => { updateDraft({ ...draft, interval: event.target.value as BackupInterval }) }}
+            >
+              {BACKUP_INTERVAL_OPTIONS.map((interval) => (
+                <option key={interval} value={interval}>{intervalLabel(t, interval)}</option>
+              ))}
+            </select>
+          </Field>
+          {lastRun !== undefined && (
+            <div className={css.statRow}>
+              <span className={css.hint}>{t('backupSchedule.lastRun')}</span>
+              <Badge kind={backupRunBadgeKind(lastRun)}>{runStatusLabel(t, lastRun)}</Badge>
+              {lastRunDetail !== null && lastRunDetail !== '' && <span className={css.hint}>{lastRunDetail}</span>}
+            </div>
+          )}
+          <div className={css.actionRow}>
+            <Button
+              variant="primary"
+              disabled={busy || !dirty}
+              onClick={save}
+              title={dirty ? undefined : t('backupSchedule.saved')}
+            >
+              {saving ? <Spinner label={t('backupSchedule.save')} /> : t('backupSchedule.save')}
+            </Button>
+            <Button disabled={busy || !(saved?.enabled ?? false)} onClick={runNow}>
+              {running ? <Spinner label={t('backupSchedule.running')} /> : t('backupSchedule.runNow')}
+            </Button>
+          </div>
+        </>
+      )}
+
+      {flash !== null && <Banner kind="ok">{flash}</Banner>}
+      {actionError !== null && <Banner kind="error">{actionError}</Banner>}
+    </Card>
+  )
+}

package/src/client/sync/SyncHistoryView.tsx

@@ -10,6 +10,7 @@ import { useEffect, useMemo, useState } from 'react'
 import type { ReactNode } from 'react'
 
 import { Badge, Card, SectionTitle, Spinner } from '../common/ui.tsx'
+import { ErrorBanner } from '../common/ErrorBanner.tsx'
 import type { SyncApi, SyncHistoryEntry, AutosyncHistoryEntry } from './sync-api.ts'
 import {
   describeSkipReason, directionLabel, formatDateTime, projectAutosyncEntry,
@@ -36,14 +37,18 @@ export function SyncHistoryView(props: SyncHistoryViewProps): ReactNode {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
   const [entries, setEntries] = useState<SyncHistoryEntry[]>([]);
+  /** 重试计数（错误态点「重试」递增 → 重新加载） */
+  const [reloadKey, setReloadKey] = useState(0);
 
   useEffect(() => {
     let cancelled = false;
+    setLoading(true);
     (async () => {
       try {
         const data = await api.history();
         if (!cancelled) {
           setEntries(data.entries);
+          setError(null);
           setLoading(false);
         }
       } catch (err) {
@@ -54,7 +59,7 @@ export function SyncHistoryView(props: SyncHistoryViewProps): ReactNode {
       }
     })();
     return () => { cancelled = true; };
-  }, [api]);
+  }, [api, reloadKey]);
 
   const rows = useMemo(() => projectSyncHistoryEntries(entries), [entries]);
   // 快照类条目（兼容旧投影；仅统计展示）
@@ -71,7 +76,16 @@ export function SyncHistoryView(props: SyncHistoryViewProps): ReactNode {
   );
 
   if (loading) return <Spinner label={t('common.loading')} />;
-  if (error) return <Card><span className="error">{error}</span></Card>;
+  if (error) {
+    return (
+      <ErrorBanner
+        error={error}
+        onRetry={() => { setReloadKey((k) => k + 1) }}
+        retrying={loading}
+        t={api.t}
+      />
+    );
+  }
   if (rows.length === 0) {
     return (
       <Card>

package/src/core/restore.ts

@@ -94,6 +94,9 @@ export interface RestoreOptions {
   pluginUninstaller?: (
     name: string, profileDir: string, profile: string,
   ) => Promise<{ ok: boolean; message?: string }>;
+  /** 每项动作执行回调（宿主路由埋点：更新 RunRegistry 进度；index/1-based、total=计划动作数、
+   * detail=动作描述。dry-run/planRestore 不触发） */
+  onAction?: (info: { index: number; total: number; detail: string }) => void;
   /** 消息翻译器（缺省 zh；宿主按 DSH 应用语言注入） */
   msg?: MsgFunc;
 }
@@ -494,7 +497,11 @@ export async function restore(opts: RestoreOptions): Promise<RestoreReport> {
   };
 
   let seq = 0;
+  const total = plan.actions.length;
+  let actionIndex = 0;
   for (const action of plan.actions) {
+    actionIndex += 1;
+    opts.onAction?.({ index: actionIndex, total, detail: action.description });
     try {
       switch (action.kind) {
         case 'hostFileRestore': {

package/src/core/run-registry.test.ts

@@ -118,6 +118,46 @@ test('appendLog: 日志行数封顶 MAX_RUN_LOG_LINES（超限截断保留最新
   assert.equal(state?.log[state!.log.length - 1], `line-${MAX_RUN_LOG_LINES + 9}`)
 })
 
+test('appendLog: 不可变追加——每次 append 换新数组引用（React memo 感知新行；封顶后长度恒定但引用仍变）', () => {
+  const reg = new RunRegistry()
+  const run = reg.register('import')
+  const initial = reg.get(run.runId)!.log
+  reg.appendLog(run.runId, 'line-1')
+  const second = reg.get(run.runId)!.log
+  assert.notEqual(second, initial, 'append 必须生成新数组引用（不得原地 push）')
+  assert.deepEqual(second, ['line-1'])
+
+  // 500 行封顶后：长度恒定（memo 按长度比较会漏），但每次 append 引用必变
+  const capRun = reg.register('export')
+  const refs = new Set<unknown[]>()
+  for (let i = 0; i < MAX_RUN_LOG_LINES + 5; i++) {
+    reg.appendLog(capRun.runId, `line-${i}`)
+    refs.add(reg.get(capRun.runId)!.log)
+  }
+  assert.equal(reg.get(capRun.runId)!.log.length, MAX_RUN_LOG_LINES)
+  assert.equal(refs.size, MAX_RUN_LOG_LINES + 5, '每次 append 都是新引用（含封顶后）——前端以引用比较不会漏渲染')
+})
+
+test('register: 快照恢复（restore）同 kind 进行中拒绝（P1-1 并发恢复防护）', () => {
+  const reg = new RunRegistry()
+  const first = reg.register('restore')
+  assert.throws(
+    () => reg.register('restore'),
+    (err: unknown) => {
+      assert.ok(err instanceof RunConflictError)
+      assert.equal((err as RunConflictError).runId, first.runId)
+      return true
+    },
+  )
+  // 恢复中允许导出（不同 kind 互不阻塞）
+  const exp = reg.register('export')
+  assert.equal(exp.kind, 'export')
+  // 完成后的 restore 不阻塞新 restore
+  reg.finish(first.runId, {})
+  const second = reg.register('restore')
+  assert.notEqual(second.runId, first.runId)
+})
+
 test('finish/fail: 状态与 result/error 落账', () => {
   const reg = new RunRegistry()
   const done = reg.register('export')

package/src/core/run-registry.ts

@@ -21,8 +21,8 @@ import { randomBytes } from 'node:crypto'
 import { zhMsg } from './messages.ts'
 import type { MsgFunc } from './messages.ts'
 
-/** run 类型：导出 / 导入 / 自动同步 / 一键同步逐项应用 / 定时备份。 */
-export type RunKind = 'export' | 'import' | 'autosync' | 'sync-apply' | 'backup-schedule'
+/** run 类型：导出 / 导入 / 自动同步 / 一键同步逐项应用 / 定时备份 / 快照恢复。 */
+export type RunKind = 'export' | 'import' | 'autosync' | 'sync-apply' | 'backup-schedule' | 'restore'
 
 /** run 状态：进行中 / 完成 / 失败。 */
 export type RunStatus = 'running' | 'done' | 'failed'
@@ -71,7 +71,9 @@ export class RunConflictError extends Error {
             ? '一键同步已在进行中'
             : kind === 'backup-schedule'
               ? '定时备份已在进行中'
-              : msg('run.conflict.import', { runId }),
+              : kind === 'restore'
+                ? '快照恢复已在进行中（请等待当前恢复完成）'
+                : msg('run.conflict.import', { runId }),
     )
     this.name = 'RunConflictError'
     this.runId = runId
@@ -142,17 +144,22 @@ export class RunRegistry {
     return { ...run }
   }
 
-  /** 追加一行执行日志（导入逐计划项操作 / 子进程命令）；run 不存在返回 undefined，
+  /**
+   * 追加一行执行日志（导入逐计划项操作 / 子进程命令）；run 不存在返回 undefined，
    * 已完成/失败后的晚到追加被忽略（防御异步回调竞态）。行数封顶 MAX_RUN_LOG_LINES，
-   * 超限时截断保留最新行。 */
+   * 超限时截断保留最新行。
+   *
+   * **不可变写入（性能正确性关键）**：每次 append 生成新数组（push + splice 会原地
+   * mutation —— /progress 轮询返回的 RunState.log 与浏览器侧 store 共享同一引用，
+   * 行数封顶后长度恒定，React memo 按引用/长度比较将无法感知新行，日志面板冻结）。
+   * 调用方（mapRunProgress → ImportLogPanel）据此以「数组引用变化」判断有新输出。
+   */
   appendLog(runId: string, line: string): RunState | undefined {
     const run = this.runs.get(runId)
     if (run === undefined) return undefined
     if (run.status !== 'running') return { ...run }
-    run.log.push(line)
-    if (run.log.length > MAX_RUN_LOG_LINES) {
-      run.log.splice(0, run.log.length - MAX_RUN_LOG_LINES)
-    }
+    // 不可变追加：保留最新 MAX_RUN_LOG_LINES 行（slice(-(MAX-1)) 在长度不足时取全量）
+    run.log = [...run.log.slice(-(MAX_RUN_LOG_LINES - 1)), line]
     run.updatedAt = this.now()
     return { ...run }
   }