dsh-config-manager 0.1.39 → 0.1.41

package/src/client/run-store.test.ts

@@ -102,7 +102,7 @@ test('m2-refresh: password/passwordConfirm/secretInputs 绝不写入 sessionStor
   assert.ok(!('secretInputs' in (parsed['import'] as Record<string, unknown>)))
 })
 
-test('m2-refresh: 非敏感状态往返恢复，敏感字段刷新后清空', () => {
+test('m2-refresh: 非敏感表单状态往返恢复，敏感字段与导出结果瞬态刷新后清空', () => {
   const { storage } = makeStorage()
   const first = new RunStore({ storage })
   first.patch({
@@ -134,7 +134,7 @@ test('m2-refresh: 非敏感状态往返恢复，敏感字段刷新后清空', ()
   assert.deepEqual(st.export.selection, ['settings', 'plugins'])
   assert.equal(st.export.includeSecrets, true)
   assert.equal(st.export.encrypt, true, 'encrypt 为非敏感选项，刷新后恢复')
-  assert.equal(st.export.downloaded, true)
+  assert.equal(st.export.downloaded, false, '导出完成提示（downloaded）为瞬态，刷新后清空')
   assert.equal(st.export.password, '', '密码刷新后清空')
   assert.equal(st.export.passwordConfirm, '', '确认密码刷新后清空')
   assert.equal(st.import.step, 'preview')
@@ -144,6 +144,44 @@ test('m2-refresh: 非敏感状态往返恢复，敏感字段刷新后清空', ()
   assert.deepEqual(st.import.secretInputs, {}, '秘密补录值刷新后清空')
 })
 
+test('m2-refresh: 导出结果/进度/进行中为内存切片瞬态——不写入 sessionStorage、刷新后清空', () => {
+  const { storage, raw } = makeStorage()
+  const store = new RunStore({ storage })
+  store.patch({
+    export: {
+      result: {
+        zipPath: 'export-result-x.zip',
+        manifest: makeManifest(),
+        report: makeExportReport(),
+        text: '备份已创建\n已包含：\n  ✓ settings (21 namespaces)',
+      },
+      downloaded: true,
+      running: true,
+      progress: { stage: 'exporting', step: 1, total: 3, section: 'settings', item: 1, itemTotal: 3 },
+      runId: RUN_ID,
+    },
+  })
+  const text = raw()
+  assert.ok(text !== null, 'patch 后已同步持久化')
+  assert.ok(!text.includes('export-result-x.zip'), '导出结果文件名不得落入 sessionStorage')
+  assert.ok(!text.includes('备份已创建'), '报告文本不得落入 sessionStorage')
+  const parsed = JSON.parse(text) as { export: Record<string, unknown> }
+  assert.ok(!('result' in parsed['export']), 'export 切片不含 result（瞬态不落盘）')
+  assert.ok(!('downloaded' in parsed['export']), 'export 切片不含 downloaded（瞬态不落盘）')
+  assert.ok(!('running' in parsed['export']), 'export 切片不含 running（瞬态不落盘）')
+  assert.ok(!('progress' in parsed['export']), 'export 切片不含 progress（瞬态不落盘）')
+  assert.ok(!('runId' in parsed['export']), 'export 切片不含 runId（瞬态不落盘）')
+
+  // 新实例 + 同一存储 = 模拟页面刷新 → 导出结果清空，回到干净导出页
+  const second = new RunStore({ storage })
+  const st = second.getSnapshot()
+  assert.equal(st.export.result, null, '导出报告刷新后清空（不残留展示）')
+  assert.equal(st.export.downloaded, false, '已保存提示刷新后清空')
+  assert.equal(st.export.running, false, '进行中为瞬态，刷新后回复空闲')
+  assert.equal(st.export.progress, null, '进度刷新后清空')
+  assert.equal(st.export.runId, null, 'runId 刷新后清空')
+})
+
 test('损坏或版本不符的存储数据回退默认并清除脏键', () => {
   const { storage, raw } = makeStorage()
   raw() // no-op to satisfy lint-like usage

package/src/client/run-store.ts

@@ -53,6 +53,8 @@ import type { ChannelSyncState, SyncChannel } from './sync/sync-view.ts'
 import { defaultChannelSyncState } from './sync/sync-view.ts'
 import type { MarketApprovals } from './market/market-view.ts'
 import type { MyItemEntry } from './market/my-configs-api.ts'
+import type { MyInstallSlice, MyWizardSlice } from './market/my-configs-view.ts'
+import type { SyncConflictResolution } from './sync/sync-view.ts'
 
 /* ---------------------------------------------------------------- 基础类型 */
 
@@ -118,6 +120,8 @@ export interface SyncStoreSlice {
   pullReport: SyncPullReport | null
   /** 一键同步差异确认会话（items 供 UI 逐项确认；宿主侧 30 分钟 TTL 内存登记） */
   confirmSession: SyncStartResponse | null
+  /** 一键同步差异确认的逐项决策（adopted/resolution；非敏感，与 confirmSession 生命周期绑定——切 tab/刷新不丢，刷新后会话仍在可恢复决策） */
+  confirmDecisions: SyncConfirmDecisions | null
   /** 最近一次一键同步执行结果（回滚入口） */
   lastRestoreId: string | null
   /** 已 redact 的错误文本 */
@@ -128,6 +132,15 @@ export interface SyncStoreSlice {
 /** 同步视图的进行中操作标记（与 SyncUiState.busy 同形状；无 busy 时为空闲）。 */
 export type SyncBusyState = 'sync' | 'push' | 'pull' | 'rollback' | null
 
+/**
+ * 一键同步差异确认的单条决策（非敏感；resolution 仅在 Conflict 项已解决时存在）。
+ * 与 SyncConfirmView 的 ItemState 同构（resolution 序列化为 SyncConflictResolution 字符串）。
+ */
+export type SyncConfirmDecision = { adopted: boolean; resolution?: SyncConflictResolution }
+
+/** 一键同步差异确认的逐项决策表（itemId → 决策；null = 无进行中的确认会话决策）。 */
+export type SyncConfirmDecisions = Record<string, SyncConfirmDecision>
+
 /** 单通道状态的持久化切片 = 运行时剔除密码类敏感字段（安全关键，白名单单一出口）。 */
 export type PersistedChannelSyncState = Omit<
   ChannelSyncState,
@@ -164,6 +177,12 @@ export interface MarketStoreSlice {
   myItems: MyItemEntry[] | null
   /** 我的配置子视图：列表加载错误（已 redact 文本；null = 无） */
   myItemsError: string | null
+  /** 我的配置子视图：上传/更新向导持久化切片（仅非敏感字段；null = 未开始或已完成，见 my-configs-view.ts MyWizardSlice） */
+  myWizard: MyWizardSlice | null
+  /** 我的配置子视图：装回本地（下载+逐分区批准+导入结果）持久化切片（仅非敏感；null = 未开始或已关闭） */
+  myInstall: MyInstallSlice | null
+  /** 我的配置子视图：删除确认弹窗的目标条目 id（非敏感；切 tab/刷新不丢，用户可见的确认态） */
+  myConfirmDeleteId: string | null
 }
 
 /** 快照恢复面板的切片（无敏感字段；快照列表本身可随时重载，不持久化）。 */
@@ -177,7 +196,14 @@ export interface SnapshotsStoreSlice {
 
 /* ------------------------------------------------- 持久化（非敏感）状态形状 */
 
-/** 导出视图的持久化切片（不含 password/passwordConfirm）。 */
+/**
+ * 导出视图的持久化切片 = 仅「表单配置类」非敏感字段（模式/勾选/安全选项/错误）。
+ *
+ * 导出结果（result / downloaded）与进行中/进度（running / progress / runId）是
+ * **内存切片瞬态**：切 tab / 关面板由模块级单例保留，刷新 / 关闭 DSH 重开后自动
+ * 清空 —— 旧导出报告与「已保存到下载目录」提示不残留展示（与 sync 面板 busy 同级）。
+ * 不含 password/passwordConfirm（仅内存）。
+ */
 export interface PersistedExportState {
   mode: ExportMode
   selection: SectionId[]
@@ -185,14 +211,8 @@ export interface PersistedExportState {
   includeSecrets: boolean
   /** 是否加密备份（独立选项；不导出密钥也可单独加密） */
   encrypt: boolean
-  running: boolean
-  progress: RunProgress | null
-  result: ExportRunResult | null
   /** 错误消息（已 redact 的文本；Error 对象不可 JSON 序列化，统一转字符串） */
   error: string | null
-  downloaded: boolean
-  /** 最近一次导出 run id（/runs + /progress 重新订阅用；32-hex 不可猜） */
-  runId: string | null
 }
 
 /** 导入向导的持久化切片（不含 secretInputs）。 */
@@ -235,11 +255,27 @@ export interface PersistedState {
 
 /* --------------------------------------- 运行时状态（含仅内存的敏感字段） */
 
-/** 导出运行时状态 = 持久化字段 + 仅内存的密码字段。 */
+/**
+ * 导出运行时状态 = 持久化字段 + 密码字段（仅内存）+ 导出结果/进度瞬态。
+ *
+ * result / downloaded / running / progress / runId 为「内存切片」：toPersistedState
+ * 白名单剔除、applyPersisted 硬性清空 —— 刷新 / 关闭 DSH 重开后不残留；
+ * 进行中导出由 m2-resume 从宿主 /runs 重新发现并恢复轮询。
+ */
 export interface ExportLiveState extends PersistedExportState {
   /** 加密密码（仅内存，绝不写入 sessionStorage；刷新后清空） */
   password: string
   passwordConfirm: string
+  /** 导出进行中（内存切片瞬态：切 tab 保留、刷新清空） */
+  running: boolean
+  /** 导出进度（内存切片瞬态；进行中由 m2-resume 重回填，否则清空） */
+  progress: RunProgress | null
+  /** 导出结果报告（内存切片瞬态；刷新/关闭 DSH 后清空，不残留展示） */
+  result: ExportRunResult | null
+  /** 「已保存到下载目录」提示（内存切片瞬态；刷新后清空） */
+  downloaded: boolean
+  /** 最近一次导出 run id（/runs + /progress 重新订阅用；resume 自 /runs 发现，纯瞬态） */
+  runId: string | null
 }
 
 /** 导入运行时状态 = 持久化字段 + 仅内存的敏感/实例字段。 */
@@ -347,6 +383,7 @@ function defaultSyncState(): SyncStoreSlice {
     pushReport: null,
     pullReport: null,
     confirmSession: null,
+    confirmDecisions: null,
     lastRestoreId: null,
     error: null,
     loadError: null,
@@ -366,6 +403,9 @@ function defaultMarketState(): MarketStoreSlice {
     loadError: null,
     myItems: null,
     myItemsError: null,
+    myWizard: null,
+    myInstall: null,
+    myConfirmDeleteId: null,
   }
 }
 
@@ -418,6 +458,7 @@ export function toSyncStoreSlice(s: SyncStoreSlice): SyncStoreSlice {
     pushReport: s.pushReport,
     pullReport: s.pullReport,
     confirmSession: s.confirmSession,
+    confirmDecisions: s.confirmDecisions,
     lastRestoreId: s.lastRestoreId,
     error: s.error,
     loadError: s.loadError,
@@ -438,6 +479,9 @@ export function toMarketStoreSlice(s: MarketStoreSlice): MarketStoreSlice {
     loadError: s.loadError,
     myItems: s.myItems,
     myItemsError: s.myItemsError,
+    myWizard: s.myWizard,
+    myInstall: s.myInstall,
+    myConfirmDeleteId: s.myConfirmDeleteId,
   }
 }
 
@@ -457,11 +501,20 @@ export function toSnapshotsStoreSlice(s: SnapshotsStoreSlice): SnapshotsStoreSli
  * 与不可序列化的实例字段（conflictCollector），以及同步面板的凭据字段
  * （token/webdavPassword/encryptPassword/encryptPasswordConfirm/decryptPassword ——
  * 含 byChannel 内每通道的加密/解密密码）与瞬态字段（busy/savingConfig —— 刷新后
- * 回复空闲，不把「进行中」状态带到新页面），其余原样落入 sessionStorage。
+ * 回复空闲，不把「进行中」状态带到新页面）；导出面板的结果字段（result/downloaded）
+ * 与进行中/进度（running/progress/runId）同为内存切片瞬态一并剔除（刷新/关闭 DSH
+ * 后不残留上次导出报告），其余原样落入 sessionStorage。
  * 这是 sessionStorage 的唯一写入路径 —— 敏感值在此被硬性隔离。
  */
 export function toPersistedState(state: StoreState): PersistedState {
-  const { password: _password, passwordConfirm: _passwordConfirm, ...exportRest } = state.export
+  const {
+    password: _password, passwordConfirm: _passwordConfirm,
+    // 导出结果/进度为内存切片瞬态（切 tab 由模块级单例保留、刷新/关闭 DSH 清空）：
+    // 不落盘，旧导出报告与「已保存」提示不残留展示 —— 与 sync 面板 busy 同级
+    result: _result, downloaded: _downloaded, running: _running,
+    progress: _progress, runId: _runId,
+    ...exportRest
+  } = state.export
   const {
     secretInputs: _secretInputs, decryptPassword: _decryptPassword, decryptRefs: _decryptRefs,
     archiveUnlocked: _archiveUnlocked, conflictCollector: _conflictCollector, ...importRest
@@ -753,6 +806,13 @@ export class RunStore {
         // 硬性：密码/确认密码绝不从存储恢复
         password: '',
         passwordConfirm: '',
+        // 硬性：导出结果/进度/进行中为内存切片瞬态，绝不从存储恢复（即便旧版持久化
+        // 载荷携带这些字段也清空）—— 刷新/关闭 DSH 重开后导出页干净，不残留上次结果
+        result: null,
+        downloaded: false,
+        running: false,
+        progress: null,
+        runId: null,
       },
       import: {
         ...defaultImportState(),

package/src/client/sync/SyncConfirmView.tsx

@@ -19,6 +19,7 @@ import {
 } from './sync-view.ts'
 import type { ApplyItemsResponse } from './sync-api.ts'
 import type { TranslateNS } from '../client-types.ts'
+import type { SyncConfirmDecisions } from '../run-store.ts'
 import css from '../config-manager.module.css'
 
 export interface SyncConfirmViewProps {
@@ -33,6 +34,10 @@ export interface SyncConfirmViewProps {
   compatibility?: 'excellent' | 'good' | 'partial' | 'unsupported'
   /** 翻译器。 */
   t: TranslateNS<'config-manager-sync'>
+  /** 逐项决策（受控：来自 runStore.sync.confirmDecisions；null = 无持久化决策，按 defaultAdopt 初始化） */
+  decisions: SyncConfirmDecisions | null
+  /** 决策变更上抛（SyncSettingsView patch 镜像 runStore，切 tab/刷新不丢） */
+  onDecisionsChange: (decisions: SyncConfirmDecisions) => void
   /** 用户取消确认后回调（复位到空闲态）。 */
   onCancel: () => void
   /** 回滚成功后回调（清空 lastRestoreId）。 */
@@ -49,13 +54,17 @@ interface ItemState {
 }
 
 export function SyncConfirmView(props: SyncConfirmViewProps): ReactNode {
-  const { api, syncSessionId, snapshotId, items, needsReview, compatibility, t, onCancel, onRollbackDone } = props;
-  // 逐项决策状态（初始 = defaultAdopt）
-  const [states, setStates] = useState<Record<string, ItemState>>(() => {
-    const init: Record<string, ItemState> = {};
-    for (const it of items) init[it.itemId] = { adopted: it.defaultAdopt, resolution: undefined };
-    return init;
-  });
+  const { api, syncSessionId, snapshotId, items, needsReview, compatibility, t, decisions, onDecisionsChange, onCancel, onRollbackDone } = props;
+  // 逐项决策状态（受控：来自 props.decisions；null 时按 defaultAdopt 初始化；持久化决策覆盖同名项）
+  const states = useMemo<Record<string, ItemState>>(() => {
+    const base: Record<string, ItemState> = {};
+    for (const it of items) base[it.itemId] = { adopted: it.defaultAdopt, resolution: undefined };
+    if (decisions === null) return base;
+    for (const [id, d] of Object.entries(decisions)) {
+      if (base[id] !== undefined) base[id] = { adopted: d.adopted, resolution: d.resolution };
+    }
+    return base;
+  }, [items, decisions]);
   // 执行阶段：'idle' | 'applying' | 'done' | 'failed' | 'cancelling'
   const [phase, setPhase] = useState<'idle' | 'applying' | 'done' | 'failed' | 'cancelling'>('idle');
   const [applyResult, setApplyResult] = useState<ApplyItemsResponse | null>(null);
@@ -69,27 +78,24 @@ export function SyncConfirmView(props: SyncConfirmViewProps): ReactNode {
   const displayItems = useMemo(() => reviewItems(items), [items]);
 
   const setAdopted = (itemId: string, adopted: boolean): void => {
-    setStates((prev) => ({ ...prev, [itemId]: { ...prev[itemId], adopted } }));
+    const existing: ItemState = states[itemId] ?? { adopted: false, resolution: undefined };
+    onDecisionsChange({ ...(decisions ?? {}), [itemId]: { adopted, resolution: existing.resolution } });
   };
 
   const setResolution = (itemId: string, resolution: ConflictResolution): void => {
-    setStates((prev) => {
-      const existing: ItemState = prev[itemId] ?? { adopted: false, resolution: undefined };
-      return { ...prev, [itemId]: { ...existing, resolution } };
-    });
+    const existing: ItemState = states[itemId] ?? { adopted: false, resolution: undefined };
+    onDecisionsChange({ ...(decisions ?? {}), [itemId]: { adopted: existing.adopted, resolution } });
   };
 
   // 批量决策（仅作用于 Conflict 项；非 Conflict 项的 adopt 保持默认）
-  const applyBulkDecision = (decisions: readonly { itemId: string; resolution: ConflictResolution; adopt: boolean }[]): void => {
-    if (decisions.length === 0) return;
-    setStates((prev) => {
-      const next: Record<string, ItemState> = { ...prev };
-      for (const d of decisions) {
-        const existing: ItemState = prev[d.itemId] ?? { adopted: false, resolution: undefined };
-        next[d.itemId] = { ...existing, resolution: d.resolution, adopted: d.adopt };
-      }
-      return next;
-    });
+  const applyBulkDecision = (bulk: readonly { itemId: string; resolution: ConflictResolution; adopt: boolean }[]): void => {
+    if (bulk.length === 0) return;
+    const next: SyncConfirmDecisions = { ...(decisions ?? {}) };
+    for (const d of bulk) {
+      const existing: ItemState = states[d.itemId] ?? { adopted: false, resolution: undefined };
+      next[d.itemId] = { ...existing, resolution: d.resolution, adopted: d.adopt };
+    }
+    onDecisionsChange(next);
   };
 
   const runApply = async (): Promise<void> => {