dsh-config-manager 0.1.21 → 0.1.23

package/src/sync/git/git-transport.test.ts

@@ -454,3 +454,42 @@ test('集成：list 按 createdAt 升序（真实 git 多快照）', async (t) =
   const listed = await transport.list();
   assert.deepEqual(listed.map((m) => m.id), ['snap-a', 'snap-b', 'snap-c']);
 });
+
+// ─── t5：远端快照裁剪的 git 契约（upload 先 push，再 delete 删旧，各自独立 commit+push） ───
+
+test('集成：裁剪删除旧快照 → 每次 delete 独立 commit+push，add 提交先于 delete 提交', async (t) => {
+  const bare = await makeBareRepo(t);
+  const workDir = await makeTempDir(t);
+  const transport = new GitTransport({ repoUrl: bare, workDir, credentials: { getToken: async () => TEST_TOKEN } });
+
+  // 模拟裁剪场景：先上传多个快照（adds），随后逐个 delete 旧的
+  for (let i = 1; i <= 4; i++) {
+    await transport.upload(sampleSnapshot({ id: `snap-0${i}`, createdAt: `2026-08-16T0${i}:00:00.000Z` }));
+  }
+  // delete 3 个旧的，保留最新 1 个
+  await transport.delete('snap-01');
+  await transport.delete('snap-02');
+  await transport.delete('snap-03');
+
+  // list 只反映保留的快照
+  const listed = await transport.list();
+  assert.deepEqual(listed.map((m) => m.id), ['snap-04'], '裁剪后远端只保留最新快照');
+
+  // git 提交历史：先 add 后 delete（顺序正确，新快照先推再删旧）
+  const log = await runRealGit(['log', '--oneline', '--all'], bare);
+  assert.equal(log.code, 0, `git log 失败: ${log.stderr}`);
+  const addIdx = log.stdout.indexOf('sync: add snapshot snap-04');
+  const delIdx = log.stdout.indexOf('sync: delete snapshot snap-01');
+  assert.ok(addIdx >= 0, 'add 提交应存在');
+  assert.ok(delIdx >= 0, 'delete 提交应存在');
+  // git log 默认按最新提交在前；delete 是较新的提交，应出现在 add 之前（add 更旧在列表更靠后）
+  assert.ok(delIdx < addIdx, 'delete 提交应晚于（在 log 中靠前于）add 提交 → 先推新再删旧');
+
+  // 每个 delete 独立 commit+push
+  const delCount = (log.stdout.match(/sync: delete snapshot snap-0/g) ?? []).length;
+  assert.equal(delCount, 3, '每个被删快照对应一次独立 delete 提交');
+
+  // 已删除快照目录从工作副本移除
+  const dirs = await fs.readdir(path.join(workDir, 'snapshots'));
+  assert.deepEqual(dirs, ['snap-04']);
+});

package/src/sync/sync-engine.test.ts

@@ -12,7 +12,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 
-import { SyncEngine } from './sync-engine.ts';
+import { SyncEngine, MAX_REMOTE_SNAPSHOTS } from './sync-engine.ts';
 import type { SyncApplyPlan } from './risk.ts';
 import { hashSection, loadSyncState, SYNC_STATE_FILE } from './sync-state.ts';
 import { computeSnapshotMeta } from './transport.ts';
@@ -47,6 +47,7 @@ class MemSyncTransport implements SyncTransport {
   async delete(id: string): Promise<void> {
     this.calls.push('delete');
     this.snapshots.delete(id);
+    this.metas = this.metas.filter((m) => m.id !== id);
   }
 }
 
@@ -686,3 +687,122 @@ test('applyItems: 空子计划 → 直接返回 ok:true（不调 Importer）', a
     await fs.rm(tmp, { recursive: true, force: true });
   }
 });
+
+// ─── t5：push 后远端快照裁剪（保留最新 MAX_REMOTE_SNAPSHOTS 个） ─────────────────
+
+/** 预置 n 个远端快照（id=remote-N，createdAt 递增） */
+function seedRemoteSnapshots(transport: MemSyncTransport, n: number): void {
+  for (let i = 1; i <= n; i++) {
+    const id = `remote-${String(i).padStart(2, '0')}`;
+    const snap: SyncSnapshot = {
+      id,
+      createdAt: `2026-08-15T${String(i - 1).padStart(2, '0')}:00:00.000Z`,
+      manifest: { schemaVersion: 1, dshVersion: '1.2.3', platform: 'win32', sectionIds: ['settings'], containsSecrets: false },
+      sections: { settings: { version: 1, namespaces: {} } },
+    };
+    transport.snapshots.set(id, snap);
+    transport.metas.push(computeSnapshotMeta(snap));
+  }
+}
+
+test('push: 远端快照数超过 MAX_REMOTE_SNAPSHOTS → 裁剪只保留最新 10 个（含刚 push 的）', async () => {
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-engine-prune-'));
+  try {
+    const ctx = makeContext('win32', 'C:\\Users\\alice');
+    seedSource(ctx);
+    const transport = new MemSyncTransport();
+    seedRemoteSnapshots(transport, 13); // 预置 13 个旧快照
+    const engine = makeEngine({ ctx, transport, stateDir: tmp });
+
+    const report = await engine.push({ snapshotId: 'sync-new' });
+    assert.equal(report.ok, true);
+    // 本次 push 的快照应保留
+    assert.ok(transport.snapshots.has('sync-new'), '刚 push 的快照必须保留');
+
+    const remaining = [...transport.snapshots.keys()];
+    // 保留 13 个预置里最新的 9 个（remote-05..remote-13）+ 本次 push 的 sync-new = 10
+    assert.equal(remaining.length, MAX_REMOTE_SNAPSHOTS, `裁剪后应恰剩 ${MAX_REMOTE_SNAPSHOTS} 个`);
+    // 最旧的 4 个（remote-01..remote-04）被删
+    for (let i = 1; i <= 4; i++) {
+      assert.ok(!transport.snapshots.has(`remote-0${i}`), `最旧的 remote-0${i} 应被裁剪`);
+    }
+    // 最新保留集含 5..13 与 sync-new
+    for (let i = 5; i <= 13; i++) {
+      assert.ok(transport.snapshots.has(`remote-${String(i).padStart(2, '0')}`), `最新的 remote-${i} 应保留`);
+    }
+    // 裁剪通过 transport.delete 逐个删除（删除调用次数 = 4）
+    assert.equal(transport.calls.filter((c) => c === 'delete').length, 4);
+    // 顺序：upload → list(裁剪) → delete×4 → recordBaseline（无本地裁剪）→ push 返回
+    // 断言 upload 在首次 delete 之前（保证新快照先推送成功再删旧的）
+    assert.ok(transport.calls.indexOf('upload') < transport.calls.indexOf('delete'), '先 push 新快照再删旧的');
+    // 无裁剪告警（push 会带若干基础导出告警，如未注册 namespace，但不应有裁剪告警）
+    assert.ok(!report.warnings.some((w) => w.includes('裁剪')), '正常裁剪不应产生告警');
+  } finally {
+    await fs.rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('push: 远端快照数未超上限 → 不触发任何删除', async () => {
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-engine-prune-ok-'));
+  try {
+    const ctx = makeContext('win32', 'C:\\Users\\alice');
+    seedSource(ctx);
+    const transport = new MemSyncTransport();
+    seedRemoteSnapshots(transport, 9); // 9 旧 + 本次 1 = 10，恰好达标不裁剪
+    const engine = makeEngine({ ctx, transport, stateDir: tmp });
+
+    const report = await engine.push({ snapshotId: 'sync-new' });
+    assert.equal(report.ok, true);
+    assert.equal(transport.calls.filter((c) => c === 'delete').length, 0, '未超上限不得删除');
+    assert.equal(transport.snapshots.size, 10);
+    assert.ok(!report.warnings.some((w) => w.includes('裁剪')), '未超上限不应有裁剪告警');
+  } finally {
+    await fs.rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('push: 裁剪 list 失败 → 只告警不上抛，push 仍 ok', async () => {
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-engine-prune-listfail-'));
+  try {
+    const ctx = makeContext('win32', 'C:\\Users\\alice');
+    seedSource(ctx);
+    const transport = new MemSyncTransport();
+    seedRemoteSnapshots(transport, 13);
+    transport.list = async () => { throw new Error('list boom'); };
+    const engine = makeEngine({ ctx, transport, stateDir: tmp });
+
+    const report = await engine.push({ snapshotId: 'sync-new' });
+    assert.equal(report.ok, true, '裁剪失败不得阻断 push');
+    assert.ok(transport.snapshots.has('sync-new'), '快照本身已上传');
+    assert.ok(report.warnings.some((w) => w.includes('裁剪')), '应有裁剪告警');
+    assert.ok(report.warnings.some((w) => w.includes('无法列出远端快照')), '告警应说明 list 失败');
+  } finally {
+    await fs.rm(tmp, { recursive: true, force: true });
+  }
+});
+
+test('push: 裁剪单个 delete 失败 → 只告警不上抛，其余旧快照照常删除', async () => {
+  const tmp = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-engine-prune-delfail-'));
+  try {
+    const ctx = makeContext('win32', 'C:\\Users\\alice');
+    seedSource(ctx);
+    const transport = new MemSyncTransport();
+    seedRemoteSnapshots(transport, 13);
+    // 让删除 remote-02 时抛错，其余正常
+    const origDelete = transport.delete.bind(transport);
+    transport.delete = async (id: string) => {
+      if (id === 'remote-02') throw new Error('delete boom');
+      return origDelete(id);
+    };
+    const engine = makeEngine({ ctx, transport, stateDir: tmp });
+
+    const report = await engine.push({ snapshotId: 'sync-new' });
+    assert.equal(report.ok, true, '单个删除失败不得阻断 push');
+    assert.ok(report.warnings.some((w) => w.includes('删除快照 remote-02 失败')), '应有删除失败告警');
+    // remote-02 仍残留（删除失败），其余旧快照被删
+    assert.ok(transport.snapshots.has('remote-02'), '删除失败的 remote-02 应残留');
+    assert.ok(!transport.snapshots.has('remote-01'), '其余旧快照照常删除');
+  } finally {
+    await fs.rm(tmp, { recursive: true, force: true });
+  }
+});

package/src/sync/sync-engine.ts

@@ -164,6 +164,13 @@ export interface ApplyItemsReport {
  * 注：'credentials' 不是合法 SectionId——凭据状态分区为 credentialsStatus） */
 const FORBIDDEN_SECTIONS: readonly SectionId[] = ['credentialsStatus', 'secrets'];
 
+/**
+ * 远端快照保留数量上限：每次 push 上传成功后对远端裁剪，
+ * 保留最新 N 个（按 createdAt 升序的最末 N 个，含刚 push 的），更旧的逐个删除。
+ * 只按数量裁剪，不按时间窗口。删除失败只告警（进 push 的 warnings），不上抛阻断主流程。
+ */
+export const MAX_REMOTE_SNAPSHOTS = 10;
+
 export class SyncEngine {
   private readonly ctx: HostContext;
   private readonly transport: SyncTransport;
@@ -269,12 +276,48 @@ export class SyncEngine {
     }
     // ② 上传远端（传输通道负责散文件落盘 + 提交推送）
     await this.transport.upload(snapshot);
+    // ②·1 裁剪远端快照：保留最新 MAX_REMOTE_SNAPSHOTS 个（含刚 push 的）。
+    //      删除失败只告警（进 warnings），不上抛 —— 不阻断 push 主流程。
+    //      放在 upload 之后（保证新快照已推送成功）与 recordBaseline 之前（先管好远端再记基线）。
+    await this.pruneRemoteSnapshots(id, warnings);
     // ③ 记录祖先基线：写 sync-state（lastSnapshotId + 每分区 hash/updatedAt + lastSyncAt + transport）+ 裁剪
     await this.recordBaseline(id, snapshot.sections, nowIso);
 
     return { ok: true, snapshotId: id, sections: Object.keys(sections) as SectionId[], warnings };
   }
 
+  /**
+   * 裁剪远端快照：调用 transport.list() 获取全部快照（按 createdAt 升序），
+   * 保留最新 MAX_REMOTE_SNAPSHOTS 个（含刚 push 的 pushedId），对更旧的逐个调用 transport.delete()。
+   * 只按数量裁剪，不按时间窗口。
+   *
+   * 失败语义：list/delete 失败均只 push 进 warnings，不上抛 —— 裁剪是「尽力而为」的后台整理，
+   * 绝不影响 push 主流程的成功与否（§34.17 分区级告警同款语义）。
+   */
+  private async pruneRemoteSnapshots(pushedId: string, warnings: string[]): Promise<void> {
+    let metas: SyncSnapshotMeta[];
+    try {
+      metas = await this.transport.list();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      warnings.push(this.msg('sync.pruneListFailed', { reason }));
+      return;
+    }
+    if (metas.length <= MAX_REMOTE_SNAPSHOTS) return;
+    // 升序最末 N 个保留；刚 push 的快照（createdAt 最新）必在其中，防御性也把它计入保留集
+    const keep = new Set(metas.slice(-MAX_REMOTE_SNAPSHOTS).map((m) => m.id));
+    keep.add(pushedId);
+    for (const m of metas) {
+      if (keep.has(m.id)) continue;
+      try {
+        await this.transport.delete(m.id);
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        warnings.push(this.msg('sync.pruneDeleteFailed', { id: m.id, reason }));
+      }
+    }
+  }
+
   /**
    * pull：拉取远端最新（或指定）快照 → 过滤 portable 分区 → 转临时标准 ZIP →
    * 复用 Importer 预览流程（analyzeImport/createImportPlan）产出差异报告。

package/src/ui/conflict-view.test.ts

@@ -60,3 +60,19 @@ test('conflict-view: viewItems 提供视图数据（React 绑定）', () => {
   assert.equal(first.resolution, 'useImported');
   assert.ok(first.currentSummary !== undefined);
 });
+
+test('conflict-view: 批量决策（ConflictList 按钮语义）遍历所有冲突并清空未决', () => {
+  // 「全部保留当前配置」
+  const keepAll = new ConflictCollector(conflictPlan());
+  for (const item of keepAll.conflicts) keepAll.resolve(item.id, 'keepCurrent');
+  assert.equal(keepAll.hasUnresolved, false);
+  assert.equal(keepAll.toResolutions()['settings:a'], 'keepCurrent');
+  assert.equal(keepAll.toResolutions()['plugin:c'], 'keepCurrent');
+
+  // 「全部使用备份配置」
+  const useAll = new ConflictCollector(conflictPlan());
+  for (const item of useAll.conflicts) useAll.resolve(item.id, 'useImported');
+  assert.equal(useAll.hasUnresolved, false);
+  assert.equal(useAll.toResolutions()['settings:a'], 'useImported');
+  assert.equal(useAll.toResolutions()['plugin:c'], 'useImported');
+});