dsh-config-manager 0.1.78 → 0.1.79

package/src/sync/watch-scope.test.ts

@@ -0,0 +1,122 @@
+/**
+ * **监听范围**单测（src/sync/watch-scope.ts）。
+ *
+ * 盯三件事：
+ *  1. 路径必须覆盖「承载可同步分区的落盘位置」，且一律 posix 相对 $DSH_HOME；
+ *  2. 绝**不**监听会话日志 / 同步工作副本 / 自身状态文件（自激循环 + 铁律冲突）；
+ *  3. 噪声判据只吞依赖树、.git 与原子写临时文件 —— 误吞会让真实改动漏同步。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+
+import {
+  WATCH_IGNORED_SEGMENTS,
+  buildWatchTargets,
+  isNoiseRelPath,
+  targetAbsPath,
+  toHomeRelPath,
+} from './watch-scope.ts';
+
+const HOME = path.join(path.sep, 'home', 'u', '.dsh');
+
+test('buildWatchTargets：默认 profile=web，覆盖全部分区的落盘位置（posix 相对路径）', () => {
+  const targets = buildWatchTargets({ homeDir: HOME });
+  const rels = targets.map((t) => t.relPath);
+  for (const rel of rels) {
+    assert.ok(!rel.startsWith('/'), rel + ' 必须是 home 相对路径');
+    assert.ok(!rel.includes('\\'), rel + ' 必须用 posix 分隔符');
+    assert.ok(!rel.startsWith('./'), rel + ' 不得带 ./ 前缀');
+  }
+  // 关键落盘点逐条钉住（漏一个 = 那类改动永远要等定时器）
+  for (const expected of [
+    'settings.yaml',
+    'cordis.patch.yml',
+    'AGENTS.md',
+    'profiles/web/cordis.patch.yml',
+    'profiles/web/pnpm-workspace.yaml',
+    'profiles/web/package.json',
+    'profiles/web/patches',
+    'skills',
+    '.agent-presets',
+    'dsh-config-manager/sync/sync-config.json',
+    'dsh-config-manager/sync/sync-selection.json',
+    'dsh-config-manager/sync/ui-prefs.json',
+    'dsh-config-manager/market/market-config.json',
+    'dsh-config-manager/exports/.backup-notes.json',
+  ]) {
+    assert.ok(rels.includes(expected), '缺监听目标：' + expected);
+  }
+  // 分区可见性：诊断要能说出「这条路径为什么被监听」
+  for (const t of targets) assert.ok(t.sections.length > 0, t.relPath + ' 必须声明承载的分区');
+  const covered = new Set(targets.flatMap((t) => [...t.sections]));
+  for (const id of ['settings', 'providers', 'ui', 'prompts', 'mcp', 'plugins', 'skills', 'agentPresets', 'agentInstructions', 'self']) {
+    assert.ok(covered.has(id as never), '分区 ' + id + ' 没有任何监听路径');
+  }
+  // 目录目标才递归，文件目标恒 false（Windows 上递归 fs.watch 更贵）
+  for (const t of targets) {
+    if (t.kind === 'file') assert.equal(t.recursive, false, t.relPath + ' 文件目标不得设递归');
+  }
+});
+
+test('buildWatchTargets：profile 决定 profile 层路径；空串回落 web', () => {
+  const desktop = buildWatchTargets({ homeDir: HOME, profile: 'desktop' }).map((t) => t.relPath);
+  assert.ok(desktop.includes('profiles/desktop/cordis.patch.yml'));
+  assert.ok(!desktop.includes('profiles/web/cordis.patch.yml'), '不得同时监听别的 profile');
+  const empty = buildWatchTargets({ homeDir: HOME, profile: '' }).map((t) => t.relPath);
+  assert.ok(empty.includes('profiles/web/cordis.patch.yml'), '空 profile 回落 web（与 core/backup.ts 同口径）');
+});
+
+test('buildWatchTargets：绝不监听 sessions / 工作副本 / 自身状态（自激循环与铁律）', () => {
+  const rels = buildWatchTargets({ homeDir: HOME }).map((t) => t.relPath);
+  assert.ok(!rels.includes(''), '绝不监听 home 根本身（会递归吃到 sessions/ 与 node_modules）');
+  assert.ok(!rels.some((r) => r === '.' || r === './'), '绝不监听 home 根本身');
+  assert.ok(!rels.some((r) => r.split('/').includes('sessions')), '会话日志可能几 GB，必须等定时器');
+  assert.ok(!rels.includes('profiles'), '绝不递归 profiles/（含整棵 pnpm 依赖树）');
+  // 调度器每轮都改写这些文件 → 监听即自激
+  for (const selfState of [
+    'dsh-config-manager/sync/sync-state.json',
+    'dsh-config-manager/sync/sync-history.json',
+    'dsh-config-manager/sync/sync-autosync.json',
+    'dsh-config-manager/sync/backup-schedule.json',
+  ]) {
+    assert.ok(!rels.includes(selfState), '绝不要监听自身状态文件：' + selfState);
+  }
+});
+
+test('toHomeRelPath：home 内给 posix 相对路径，home 外与交叉盘给 null', () => {
+  assert.equal(toHomeRelPath(HOME, path.join(HOME, 'skills', 'a', 'SKILL.md')), 'skills/a/SKILL.md');
+  assert.equal(toHomeRelPath(HOME, path.join(HOME, 'settings.yaml')), 'settings.yaml');
+  assert.equal(toHomeRelPath(HOME, HOME), null, 'home 自身没有相对路径');
+  assert.equal(toHomeRelPath(HOME, path.join(HOME, '..', 'other', 'x.json')), null, 'home 外一律 null');
+});
+
+test('isNoiseRelPath：只吞依赖树 / .git / 原子写临时文件（宁可多跑一轮，绝不误吞真实改动）', () => {
+  for (const noise of [
+    '',
+    'node_modules/pkg/index.js',
+    'profiles/web/node_modules/.bin/x',
+    'skills/.git/HEAD',
+    'settings.yaml.tmp-1234-0',
+    'dsh-config-manager/sync/sync-config.json.tmp-9-1',
+  ]) {
+    assert.equal(isNoiseRelPath(noise), true, noise + ' 应视为噪声');
+  }
+  for (const real of [
+    'settings.yaml',
+    'AGENTS.md',
+    'skills/nodejs-testing/SKILL.md',
+    'profiles/web/patches/fix.patch',
+    'dsh-config-manager/sync/sync-config.json',
+    '.agent-presets/reviewer.json',
+  ]) {
+    assert.equal(isNoiseRelPath(real), false, real + ' 是真实改动，不得过滤');
+  }
+  assert.deepEqual([...WATCH_IGNORED_SEGMENTS], ['node_modules', '.git']);
+});
+
+test('targetAbsPath：home + posix 相对路径还原成本机绝对路径', () => {
+  const target = buildWatchTargets({ homeDir: HOME }).find((t) => t.relPath === 'profiles/web/patches');
+  assert.ok(target !== undefined);
+  assert.equal(targetAbsPath(HOME, target!), path.join(HOME, 'profiles', 'web', 'patches'));
+});

package/src/sync/watch-scope.ts

@@ -0,0 +1,120 @@
+/**
+ * m-autosync-realtime：**监听范围**（纯函数，host 侧）。
+ *
+ * 自动同步要「像 VS Code 一样」在本地改动后立刻上行，就必须知道**哪些磁盘路径承载了
+ * 可同步的分区内容**。这份映射不能从注册表的 ZIP 内路径推出来 —— 两者是两件事：
+ *   - 注册表 `SECTION_JSON_PATHS` / `SECTION_FILE_PREFIXES` 说的是**快照 ZIP 内部**的布局；
+ *   - 真正被监视的是 `$DSH_HOME` 下的落盘位置（`skills/`、`settings.yaml`、
+ *     `profiles/<p>/cordis.patch.yml` … 见 `src/core/backup.ts` 的 FILE_BASES 与
+ *     `src/core/patch-layers.ts` 的两层 patch）。
+ *
+ * 因此本文件是「分区 → home 相对路径」的**唯一静态表**，只做事实声明，不做 I/O。
+ * 监听器（`sync-watcher.ts`）只负责 fs.watch + 去抖；判定「变了哪些分区」始终回到引擎的
+ * `hasLocalChanges()`（按分区 hash 比对基线），这里绝不猜。
+ *
+ * 关键取舍（勿“优化”成监听整个 home）：
+ *  - **不递归监听 `$DSH_HOME` 根**：`sessions/`（会话日志，可能几个 GB）、
+ *    `node_modules`、`dsh-config-manager/{sync/work,snapshots,exports,tmp}` 全在里面，
+ *    一旦监听就会自己把自己点着（同步写工作副本 → 触发 → 再同步），且与「sessions 绝不自动
+ *    上下行」的铁律直接冲突；
+ *  - **只监听 `profiles/<p>` 下的具体文件与 `patches/`**，绝不递归 `profiles/`：
+ *    那下面有整个 pnpm 依赖树；
+ *  - `self` 分区只监听白名单里那几个 `*.json`（与 `src/adapters/self.ts` 的
+ *    SELF_CONFIG_FILES 对齐），**刻意不监听 `sync/sync-state.json` / `sync/sync-history.json` /
+ *    `sync/sync-autosync.json` / `sync/backup-schedule.json`** —— 调度器每轮都会改写它们，
+ *    监听就是自激循环；
+ *  - `node_modules` / `.git` / 原子写临时文件在任何层级都被过滤。
+ */
+import path from 'node:path';
+
+import type { SectionId } from '../schema/types.ts';
+
+/** 监听目标的形态：单个文件，或（递归）目录。 */
+export type WatchTargetKind = 'file' | 'dir';
+
+export interface WatchTarget {
+  /** home 相对路径，posix 分隔符（Windows 上也用 `/`，便于比较与日志） */
+  relPath: string;
+  kind: WatchTargetKind;
+  /** 目录目标是否递归（file 恒 false） */
+  recursive: boolean;
+  /** 该路径承载的分区（诊断/日志用，不参与「是否触发」判定） */
+  sections: readonly SectionId[];
+}
+
+/** 组装监听目标所需的宿主事实（只读）。 */
+export interface WatchScopeInput {
+  /** `$DSH_HOME` 绝对路径 */
+  homeDir: string;
+  /** 当前 profile（决定 plugins / prompts / mcp 的落盘位置）；缺省 'web'（与 core/backup.ts 一致） */
+  profile?: string;
+}
+
+/** 任意层级都要过滤的目录名（依赖树、git 内部、同步工作副本）。 */
+export const WATCH_IGNORED_SEGMENTS: readonly string[] = ['node_modules', '.git'];
+
+/** 任意层级都要过滤的文件名模式（原子写临时文件：`x.json.tmp-1234-0`）。 */
+const TMP_FILE_RE = /\.tmp-/u;
+
+/**
+ * 组装监听目标清单。
+ *
+ * 清单顺序即日志顺序（稳定，便于测试与排查）；路径一律 posix 相对 `$DSH_HOME`。
+ */
+export function buildWatchTargets(input: WatchScopeInput): WatchTarget[] {
+  const profile = input.profile !== undefined && input.profile !== '' ? input.profile : 'web';
+  const profileDir = `profiles/${profile}`;
+  const dataBase = 'dsh-config-manager';
+  return [
+    // settings / providers / ui：同一个 settings.yaml 的顶层 namespace
+    { relPath: 'settings.yaml', kind: 'file', recursive: false, sections: ['settings', 'providers', 'ui'] },
+    // prompts / mcp：两层组合 patch 的 home 层
+    { relPath: 'cordis.patch.yml', kind: 'file', recursive: false, sections: ['prompts', 'mcp'] },
+    // agentInstructions：home 根 AGENTS.md
+    { relPath: 'AGENTS.md', kind: 'file', recursive: false, sections: ['agentInstructions'] },
+    // prompts / mcp / plugins：两层组合 patch 的 profile 层 + pnpm 工作区声明 + profile manifest
+    { relPath: `${profileDir}/cordis.patch.yml`, kind: 'file', recursive: false, sections: ['prompts', 'mcp', 'plugins'] },
+    { relPath: `${profileDir}/pnpm-workspace.yaml`, kind: 'file', recursive: false, sections: ['plugins'] },
+    { relPath: `${profileDir}/package.json`, kind: 'file', recursive: false, sections: ['plugins'] },
+    // plugins：pnpm patch 文件（`patchFile:<profile 相对路径>`）
+    { relPath: `${profileDir}/patches`, kind: 'dir', recursive: true, sections: ['plugins'] },
+    // skills / agentPresets：整棵目录
+    { relPath: 'skills', kind: 'dir', recursive: true, sections: ['skills'] },
+    { relPath: '.agent-presets', kind: 'dir', recursive: true, sections: ['agentPresets'] },
+    // self：**只**监听白名单配置文件（与 adapters/self.ts 的 SELF_CONFIG_FILES 对齐）。
+    // 刻意不含 sync-state.json / sync-history.json / sync-autosync.json / backup-schedule.json。
+    { relPath: `${dataBase}/sync/sync-config.json`, kind: 'file', recursive: false, sections: ['self'] },
+    { relPath: `${dataBase}/sync/sync-selection.json`, kind: 'file', recursive: false, sections: ['self'] },
+    { relPath: `${dataBase}/sync/ui-prefs.json`, kind: 'file', recursive: false, sections: ['self'] },
+    { relPath: `${dataBase}/market/market-config.json`, kind: 'file', recursive: false, sections: ['self'] },
+    { relPath: `${dataBase}/exports/.backup-notes.json`, kind: 'file', recursive: false, sections: ['self'] },
+  ];
+}
+
+/** 把任一绝对路径转成 home 相对 posix 路径；不在 home 内 → null。 */
+export function toHomeRelPath(homeDir: string, absPath: string): string | null {
+  const rel = path.relative(homeDir, absPath);
+  if (rel === '' || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join('/');
+}
+
+/**
+ * 该 home 相对路径是否属于「绝不该触发同步」的噪声。
+ *
+ * 判据只有两类（宁少不多：漏过滤只是多跑一轮空同步，误过滤会漏掉真实改动）：
+ * 依赖树 / git 内部目录，以及原子写临时文件。
+ */
+export function isNoiseRelPath(relPath: string): boolean {
+  if (relPath === '') return true;
+  const segments = relPath.split('/');
+  for (const segment of segments) {
+    if (WATCH_IGNORED_SEGMENTS.includes(segment)) return true;
+  }
+  const base = segments[segments.length - 1] ?? '';
+  return TMP_FILE_RE.test(base);
+}
+
+/** 监视目标的绝对路径。 */
+export function targetAbsPath(homeDir: string, target: WatchTarget): string {
+  return path.join(homeDir, target.relPath.split('/').join(path.sep));
+}

package/src/sync/webdav/webdav-conditional-write.test.ts

@@ -0,0 +1,360 @@
+/**
+ * WebDAV 通道：本轮借鉴项的**针对性**单测（不重复 webdav-transport.test.ts 的既有契约）。
+ *  - ① 条件写：索引 ETag → If-Match；索引缺失且远端无内容 → If-None-Match: *；
+ *    索引 404 但远端已有内容 → 零写入中止（既有行为的回归钉子）；
+ *  - ① 索引 PUT 回 412 → SyncTransportError(kind='conflict')，文案来自字典键 sync.webdav.concurrentWrite；
+ *  - ③ 首连逐级 MKCOL：直连 409 → 对 baseUrl 每一层发 MKCOL → 重试目标集合；
+ *    probe() 的 createdCollections **只含本次真建出来的层级**；
+ *  - ② 探针：PROPFIND 401/403 必须抛错，绝不谎报连接正常。
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { WebDavTransport, WebDavTransportError } from './webdav-transport.ts';
+import type { WebDavRequestFn, WebDavResponse, WebDavTransportOptions } from './webdav-transport.ts';
+import { SyncTransportError } from '../transport.ts';
+import type { SyncSnapshot } from '../transport.ts';
+import { zhMsg } from '../../core/messages.ts';
+
+const BASE = 'https://dav.example.com/dav/config';
+const COL = BASE + '/dsh-config-manager';
+const COL_URL = COL + '/';
+const INDEX_URL = COL + '/index.json';
+const BLOBS_INDEX_URL = COL + '/blobs-index.json';
+const SNAPSHOT_URL = COL + '/snap-001.json';
+const TEST_PASSWORD = 'super-secret-password-9876';
+
+interface MockCall { method: string; url: string; headers?: Record<string, string>; body?: string }
+
+function res(status: number, bodyText = '', headers?: Record<string, string>): WebDavResponse {
+  return {
+    status,
+    ok: status >= 200 && status < 300,
+    ...(headers !== undefined ? { headers } : {}),
+    async text() { return bodyText; },
+  };
+}
+
+function makeOptions(request: WebDavRequestFn, overrides: Partial<WebDavTransportOptions> = {}): WebDavTransportOptions {
+  return {
+    baseUrl: BASE,
+    username: 'alice',
+    credentials: { getPassword: async () => TEST_PASSWORD },
+    request,
+    ...overrides,
+  };
+}
+
+/** 记录每次请求的 mock 包装（请求头一并记录，条件写断言依赖它） */
+function recorder(calls: MockCall[], handler: (m: MockCall) => WebDavResponse): WebDavRequestFn {
+  return async (method, url, opts = {}) => {
+    const rec: MockCall = { method, url, headers: opts.headers, body: opts.body };
+    calls.push(rec);
+    return handler(rec);
+  };
+}
+
+function sampleSnapshot(overrides: Partial<SyncSnapshot> = {}): SyncSnapshot {
+  return {
+    id: 'snap-001',
+    createdAt: '2026-10-18T10:00:00.000Z',
+    manifest: {
+      schemaVersion: 1,
+      dshVersion: '1.2.3',
+      platform: 'win32',
+      sectionIds: ['settings', 'providers'],
+      containsSecrets: false,
+    },
+    sections: {
+      settings: { version: 1, namespaces: { general: { value: { theme: 'dark' }, revision: 1, secrets: [] } } },
+      providers: { version: 1, providers: { deepseek: { route: '/v1' } } },
+    },
+    ...overrides,
+  };
+}
+
+const putIndexCalls = (calls: MockCall[]): MockCall[] => calls.filter((c) => c.method === 'PUT' && c.url === INDEX_URL);
+const mkcolUrls = (calls: MockCall[]): string[] => calls.filter((c) => c.method === 'MKCOL').map((c) => c.url);
+
+/* ---------------- ① 条件写 ---------------- */
+
+test('条件写①：GET index 回 ETag → 随后的索引 PUT 带 If-Match 钉住该 ETag', async () => {
+  const calls: MockCall[] = [];
+  const ETAG = '"v1-abc123"';
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL') return res(201, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(200, '[]', { etag: ETAG });
+    if (m.method === 'PUT' && m.url === SNAPSHOT_URL) return res(201, '');
+    if (m.method === 'PUT' && m.url === INDEX_URL) return res(201, '');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  await t.upload(sampleSnapshot());
+
+  const puts = putIndexCalls(calls);
+  assert.equal(puts.length, 1, '索引必须只 PUT 一次');
+  assert.equal(puts[0]!.headers?.['If-Match'], ETAG, '有 ETag 时必须用 If-Match 钉住读到的那一版');
+  assert.equal(puts[0]!.headers?.['If-None-Match'], undefined, '有 ETag 时不得同时发 If-None-Match');
+});
+
+test('条件写①：索引 404 且远端确无内容（blobs-index 也 404）→ PUT 带 If-None-Match: *', async () => {
+  const calls: MockCall[] = [];
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL') return res(201, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(404, '');
+    if (m.method === 'GET' && m.url === BLOBS_INDEX_URL) return res(404, '');
+    if (m.method === 'PUT' && m.url === SNAPSHOT_URL) return res(201, '');
+    if (m.method === 'PUT' && m.url === INDEX_URL) return res(201, '');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  await t.upload(sampleSnapshot());
+
+  const puts = putIndexCalls(calls);
+  assert.equal(puts.length, 1);
+  assert.equal(puts[0]!.headers?.['If-None-Match'], '*', '首推（远端无内容）必须用 If-None-Match: * 防两设备同时首推');
+  assert.equal(puts[0]!.headers?.['If-Match'], undefined);
+});
+
+test('回归：索引 404 但远端已有内容（blobs-index 有记录）→ 任何字节都不写就中止', async () => {
+  const calls: MockCall[] = [];
+  const blobHash = 'a'.repeat(64);
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL') return res(201, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(404, '');
+    if (m.method === 'GET' && m.url === BLOBS_INDEX_URL) return res(200, JSON.stringify({ [blobHash]: 1 }));
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  await assert.rejects(
+    () => t.upload(sampleSnapshot()),
+    (err: unknown) => {
+      assert.ok(err instanceof WebDavTransportError, '必须是 WebDavTransportError');
+      assert.equal(err.kind, 'protocol', '缺信息而不是事实 → protocol（不可重试）');
+      assert.equal(err.retryable, false);
+      return true;
+    },
+  );
+  const writes = calls.filter((c) => c.method !== 'MKCOL' && c.method !== 'GET');
+  assert.deepEqual(writes.map((c) => c.method), [], '零写入：索引 404 + 远端有内容时不得有任何 PUT/DELETE');
+});
+
+test('条件写①：索引 PUT 回 412 → 抛 conflict，文案来自字典键 sync.webdav.concurrentWrite', async () => {
+  const calls: MockCall[] = [];
+  const ETAG = '"v1-abc123"';
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL') return res(201, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(200, '[]', { etag: ETAG });
+    if (m.method === 'PUT' && m.url === SNAPSHOT_URL) return res(201, '');
+    if (m.method === 'PUT' && m.url === INDEX_URL) return res(412, 'precondition failed');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  await assert.rejects(
+    () => t.upload(sampleSnapshot()),
+    (err: unknown) => {
+      assert.ok(err instanceof WebDavTransportError);
+      assert.ok(err instanceof SyncTransportError, '必须是统一错误基类（上层按 kind 分流）');
+      assert.equal(err.kind, 'conflict');
+      assert.equal(err.retryable, false, '并发冲突需人工重跑，绝不自动重试');
+      assert.equal(err.status, 412);
+      assert.equal(
+        err.message,
+        zhMsg('sync.webdav.concurrentWrite', { status: '412', url: INDEX_URL }),
+        '文案必须来自字典键（不是硬编码）',
+      );
+      assert.match(err.message, /412/);
+      return true;
+    },
+  );
+});
+
+test('条件写①（删除路径）：delete 读 index 拿 ETag → 写回剩余索引的 PUT 带 If-Match', async () => {
+  const calls: MockCall[] = [];
+  const ETAG = '"v1-del"';
+  const meta = {
+    id: 'snap-001',
+    createdAt: '2026-10-18T09:00:00.000Z',
+    sections: {},
+    manifest: { schemaVersion: 1, dshVersion: '1', platform: 'win32', sectionIds: [], containsSecrets: false },
+  };
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(200, JSON.stringify([meta]), { etag: ETAG });
+    if (m.method === 'DELETE' && m.url === SNAPSHOT_URL) return res(204, '');
+    if (m.method === 'PUT' && m.url === INDEX_URL) return res(201, '');
+    if (m.method === 'GET' && m.url === BLOBS_INDEX_URL) return res(404, '');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  await t.delete('snap-001');
+
+  const puts = putIndexCalls(calls);
+  assert.equal(puts.length, 1, '删除后必须写回一次索引');
+  assert.equal(puts[0]!.headers?.['If-Match'], ETAG, '删除路径的索引写回同样是条件写');
+  assert.equal(puts[0]!.headers?.['If-None-Match'], undefined);
+  assert.equal(puts[0]!.body, '[]', '剩余索引确实摘掉了目标条目');
+});
+
+test('条件写①（删除路径）：索引写回回 412 → conflict（绝不静默吞掉并发冲突）', async () => {
+  const calls: MockCall[] = [];
+  const meta = {
+    id: 'snap-001',
+    createdAt: '2026-10-18T09:00:00.000Z',
+    sections: {},
+    manifest: { schemaVersion: 1, dshVersion: '1', platform: 'win32', sectionIds: [], containsSecrets: false },
+  };
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(200, JSON.stringify([meta]), { etag: '"v1-del"' });
+    if (m.method === 'DELETE' && m.url === SNAPSHOT_URL) return res(204, '');
+    if (m.method === 'PUT' && m.url === INDEX_URL) return res(412, 'precondition failed');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  await assert.rejects(
+    () => t.delete('snap-001'),
+    (err: unknown) => {
+      assert.ok(err instanceof WebDavTransportError);
+      assert.equal(err.kind, 'conflict');
+      assert.equal(err.status, 412);
+      assert.equal(err.message, zhMsg('sync.webdav.concurrentWrite', { status: '412', url: INDEX_URL }));
+      return true;
+    },
+  );
+});
+
+/* ---------------- ③ 首连逐级 MKCOL ---------------- */
+
+test('③ 首连自建：MKCOL 首次 409 → 逐层补齐 baseUrl → 重试目标集合；probe 只回报本次真建的层级', async () => {
+  const calls: MockCall[] = [];
+  const DAV_URL = 'https://dav.example.com/dav/';
+  const CONFIG_URL = 'https://dav.example.com/dav/config/';
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL' && m.url === COL_URL) {
+      // 首连 = 缺父目录（409）；重试 = 建成功（201）
+      const prior = calls.filter((c) => c.method === 'MKCOL' && c.url === COL_URL).length;
+      return prior === 1 ? res(409, 'Conflict') : res(201, '');
+    }
+    if (m.method === 'MKCOL' && m.url === DAV_URL) return res(201, '');       // 本次真建
+    if (m.method === 'MKCOL' && m.url === CONFIG_URL) return res(405, '');    // 早就存在 → 不回报
+    if (m.method === 'PROPFIND') return res(207, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(404, '');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  const result = await t.probe();
+
+  assert.deepEqual(mkcolUrls(calls), [COL_URL, DAV_URL, CONFIG_URL, COL_URL],
+    'MKCOL 顺序 = 首连目标集合(409) → baseUrl 每一层(top-down) → 重试目标集合');
+  assert.deepEqual(result.createdCollections, [DAV_URL, COL_URL],
+    'createdCollections = 本次所有真建出来的目录（含重试建出的目标集合；405 的 config/ 不进）');
+  assert.equal(result.snapshotCount, 0, '索引 404（全新远端）= 0 份快照');
+  assert.equal(result.message, zhMsg('sync.webdav.probeOk', { count: '0' }));
+});
+
+test('③ 首连自建：重试仍回 409（网盘「已存在」语义）→ 按成功接受，不谎报已创建', async () => {
+  const calls: MockCall[] = [];
+  const DAV_URL = 'https://dav.example.com/dav/';
+  const CONFIG_URL = 'https://dav.example.com/dav/config/';
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL' && m.url === COL_URL) return res(409, 'Conflict'); // 首连与重试都 409
+    if (m.method === 'MKCOL' && m.url === DAV_URL) return res(405, '');          // 上级已存在
+    if (m.method === 'MKCOL' && m.url === CONFIG_URL) return res(409, '');       // 上级已存在（网盘回 409）
+    if (m.method === 'PROPFIND') return res(207, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(404, '');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  const result = await t.probe();
+  assert.deepEqual(mkcolUrls(calls), [COL_URL, DAV_URL, CONFIG_URL, COL_URL],
+    '重试确实发生（不是首连 409 就直接放弃）');
+  assert.equal(result.createdCollections, undefined,
+    '没有任何一层真返回 201/200/204 → 省略 createdCollections（不谎报「已创建」）');
+  assert.equal(result.snapshotCount, 0);
+});
+
+test('③ 首连失败（非 409）：401/403/5xx 必须立即抛错，不进入逐级自建', async () => {
+  for (const status of [401, 403, 500]) {
+    const calls: MockCall[] = [];
+    const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+      if (m.method === 'MKCOL') return res(status, 'nope');
+      return res(500, 'unexpected ' + m.method + ' ' + m.url);
+    })));
+
+    await assert.rejects(
+      () => t.probe(),
+      (err: unknown) => {
+        assert.ok(err instanceof WebDavTransportError);
+        assert.equal(err.status, status);
+        assert.equal(err.kind, status >= 500 ? 'server' : 'auth');
+        return true;
+      },
+    );
+    assert.equal(calls.filter((c) => c.method === 'MKCOL').length, 1,
+      '非 409 的首连失败不得触发逐级 MKCOL（更不得吞成成功）');
+  }
+});
+
+/* ---------------- ② 探针 ---------------- */
+
+for (const status of [401, 403]) {
+  test('② 探针：PROPFIND ' + status + ' → 抛错（kind=auth），绝不谎报连接正常', async () => {
+    const calls: MockCall[] = [];
+    const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+      if (m.method === 'MKCOL') return res(201, '');
+      if (m.method === 'PROPFIND') return res(status, 'denied');
+      return res(500, 'unexpected ' + m.method + ' ' + m.url);
+    })));
+
+    await assert.rejects(
+      () => t.probe(),
+      (err: unknown) => {
+        assert.ok(err instanceof WebDavTransportError);
+        assert.equal(err.kind, 'auth');
+        assert.equal(err.retryable, false);
+        assert.equal(err.status, status);
+        assert.equal(err.message, zhMsg('sync.webdav.probeUnreachable', { status: String(status), url: COL_URL }));
+        return true;
+      },
+    );
+    assert.equal(calls.some((c) => c.method === 'GET'), false,
+      'PROPFIND 鉴权失败后不得继续读索引（更不得回报连接正常）');
+  });
+}
+
+test('② 探针：服务端不支持 PROPFIND（405）→ 退回索引作证据，不算失败', async () => {
+  const calls: MockCall[] = [];
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL') return res(201, '');
+    if (m.method === 'PROPFIND') return res(405, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(200, '[]');
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  const result = await t.probe();
+  assert.equal(result.snapshotCount, 0);
+  assert.equal(result.createdCollections, undefined, '本次没有新建层级 → 省略该字段');
+});
+
+test('② 探针：PROPFIND 207 + index 有 2 条 → snapshotCount=2、message 带计数', async () => {
+  const calls: MockCall[] = [];
+  const mkMeta = (id: string, createdAt: string): Record<string, unknown> => ({
+    id,
+    createdAt,
+    sections: {},
+    manifest: { schemaVersion: 1, dshVersion: '1', platform: 'win32', sectionIds: [], containsSecrets: false },
+  });
+  const metas = [mkMeta('snap-a', '2026-10-18T08:00:00.000Z'), mkMeta('snap-b', '2026-10-18T09:00:00.000Z')];
+  const t = new WebDavTransport(makeOptions(recorder(calls, (m) => {
+    if (m.method === 'MKCOL') return res(201, '');
+    if (m.method === 'PROPFIND') return res(207, '');
+    if (m.method === 'GET' && m.url === INDEX_URL) return res(200, JSON.stringify(metas));
+    return res(500, 'unexpected ' + m.method + ' ' + m.url);
+  })));
+
+  const result = await t.probe();
+  assert.equal(result.snapshotCount, 2);
+  assert.equal(result.message, zhMsg('sync.webdav.probeOk', { count: '2' }));
+  assert.equal(calls.filter((c) => c.method === 'PROPFIND').length, 1);
+  assert.equal(calls.filter((c) => c.method === 'PUT' || c.method === 'DELETE').length, 0,
+    '探针零写入（索引与快照都不写）');
+});