pi-webdav-backup 1.0.0

package/extensions/webdav-backup/test-redact.mjs

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+/**
+ * test-redact.mjs — 敏感信息脱敏测试（安全关键路径）
+ *
+ * 背景：早期实现只按字段名（key/token/...）匹配，
+ * 形如 {"k": "sk-xxxx"} 的凭据会被【原样上传到云端】。
+ * 这里锁定修复后的行为。
+ */
+
+import { redactSensitive } from "./backup.mjs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { startDavServer } from "./dav-mock.mjs";
+import { runBackup } from "./backup.mjs";
+import { collectFiles } from "./collect.mjs";
+
+let pass = 0;
+let fail = 0;
+const lines = [];
+const check = (n, c, d = "") => {
+  if (c) {
+    pass++;
+    lines.push(`  ✅ ${n}`);
+  } else {
+    fail++;
+    lines.push(`  ❌ ${n}${d ? ` — ${d}` : ""}`);
+  }
+};
+
+const b = (s) => Buffer.from(s, "utf8");
+const redact = (rel, text, opts) => {
+  const r = redactSensitive(rel, b(text), opts);
+  return r ? r.toString("utf8") : null;
+};
+
+console.log("pi WebDAV 备份 — 脱敏安全性测试\n");
+
+// ── 1. 字段名匹配（传统情况）
+const r1 = redact("auth.json", JSON.stringify({ openai: { key: "sk-abc123", type: "api" } }));
+check("字段名 key 被脱敏", !r1.includes("sk-abc123"), r1);
+check("非敏感字段保留", r1.includes('"type": "api"') || r1.includes('"type":"api"'));
+
+// ── 2. 字段名不含敏感词，但值是凭据（回归：早期版本会泄漏）
+const r2 = redact("auth.json", JSON.stringify({ p: { k: "sk-SECRET-CANARY-1234567890" } }));
+check("字段名无关但值像密钥 → 脱敏（回归）", !r2.includes("sk-SECRET-CANARY"), r2);
+
+const r3 = redact("auth.json", JSON.stringify({ a: { b: "ghp_abcdefghijklmnopqrstuvwxyz0123456789" } }));
+check("GitHub token 值被识别", !r3.includes("ghp_abcdefghij"), r3);
+
+const r4 = redact("auth.json", JSON.stringify({ x: "AIzaSyA1234567890abcdefghijklmnopqrst" }));
+check("Google API key 值被识别", !r4.includes("AIzaSy"), r4);
+
+const jwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxIn0.abcdefghijklmnop";
+const r5 = redact("auth.json", JSON.stringify({ t: jwt }));
+check("JWT 值被识别", !r5.includes("eyJhbGciOiJIUzI1NiJ9"), r5);
+
+// ── 3. 深层嵌套与数组
+const r6 = redact(
+  "auth.json",
+  JSON.stringify({ providers: [{ name: "a", creds: { token: "tok-1234567890" } }], list: ["sk-deep-secret-value-1"] }),
+);
+check("嵌套对象内的 token 被脱敏", !r6.includes("tok-1234567890"), r6);
+check("数组内的凭据被脱敏", !r6.includes("sk-deep-secret-value-1"), r6);
+check("脱敏后仍是合法 JSON", (() => { try { JSON.parse(r6); return true; } catch { return false; } })());
+
+// ── 4. 不应误伤普通值
+const r7 = redact("auth.json", JSON.stringify({ model: "claude-sonnet-4", theme: "dark", count: 42 }));
+check("普通短字符串不被脱敏", r7.includes("claude-sonnet-4") && r7.includes("dark"), r7);
+
+// ── 5. 无法解析时绝不原样上传
+try {
+  const r8 = redact("auth.json", "{ not valid json ");
+  check("无法解析的 auth.json 不泄漏原文", r8 !== null && !r8.includes("not valid json"), String(r8));
+} catch {
+  check("无法解析的 auth.json 不泄漏原文", false, "抛出了异常");
+}
+
+// ── 6. 配置文件：密码与加密密钥
+const cfgText = JSON.stringify({
+  remote: { url: "https://dav.example.com/dav/", username: "me@example.com", password: "MyRealPassword123", remoteDir: "bk" },
+  encryptKey: "super-secret-passphrase",
+  encrypt: false,
+});
+const r9 = redact("webdav-backup.json", cfgText);
+check("配置里的 password 被脱敏", !r9.includes("MyRealPassword123"), r9);
+check("配置里的 encryptKey 被脱敏", !r9.includes("super-secret-passphrase"), r9);
+check("配置里的 url 保留（便于诊断）", r9.includes("dav.example.com"), r9);
+
+// ── 7. 加密备份时（aggressive=false）仍保护已知字段
+const r10 = redact("webdav-backup.json", cfgText, { aggressive: false });
+check("aggressive=false 仍脱敏 password", !r10.includes("MyRealPassword123"), r10);
+
+const r11 = redact("auth.json", JSON.stringify({ openai: { key: "sk-known-field" } }), { aggressive: false });
+check("aggressive=false 仍按字段名脱敏", !r11.includes("sk-known-field"), r11);
+
+// ── 8. 不相关文件返回 null（不做无谓改写）
+check("普通文件返回 null", redactSensitive("extensions/a.ts", b("const x = 1;")) === null);
+check("settings.json 返回 null", redactSensitive("settings.json", b('{"theme":"dark"}')) === null);
+
+// ── 9. 子目录下的 auth.json 同样处理
+const r12 = redact("deep/nested/auth.json", JSON.stringify({ z: "sk-nested-canary-0123456789" }));
+check("嵌套路径 auth.json 也被脱敏", !r12.includes("sk-nested-canary"), r12);
+
+// ── 10. 空对象/边界
+check("空对象不报错", (() => { try { redact("auth.json", "{}"); return true; } catch { return false; } })());
+check("null 值不报错", (() => { try { redact("auth.json", '{"a":null,"b":1}'); return true; } catch { return false; } })());
+
+// ── 12. 明文审计（防止备份副本把密钥带上云）
+{
+  const { auditForPlaintext, looksCredentialFile } = await import("./backup.mjs");
+
+  // 带有 .bak-* 副本的目录（真实场景：迁移后遗留）
+  const leakDir = mkdtempSync(join(tmpdir(), "pi-audit-"));
+  mkdirSync(join(leakDir, "extensions"), { recursive: true });
+  mkdirSync(join(leakDir, "secrets"), { recursive: true });
+
+  writeFileSync(
+    join(leakDir, "auth.json"),
+    JSON.stringify({ deepseek: { type: "api_key", key: "$PI_PI_KEY_DEEPSEEK" } }, null, 2),
+  );
+  // 审计应看“脱敏后”的内容：这里的引用不会被抹
+  const filesOk = [{ rel: "auth.json", size: 100, mtimeMs: 1, abs: join(leakDir, "auth.json") }];
+  const auditOk = auditForPlaintext(filesOk, {
+    agentDir: leakDir,
+    config: { encrypt: false },
+  });
+  check("审计放过已迁移的 auth.json（引用形式）", auditOk.clean === true, JSON.stringify(auditOk.leaks));
+
+  // 磁盘上留着明文备份副本：现在前缀匹配会一并脱敏，
+  // 所以要断言的是“上传内容不含明文”，而不是“审计报错”。
+  writeFileSync(
+    join(leakDir, "auth.json.bak-2026-01-01"),
+    JSON.stringify({ deepseek: { key: "sk-leaked-in-backup-copy-1234567890" } }),
+  );
+  const bakRel = "auth.json.bak-2026-01-01";
+  const bakFiles = [{ rel: bakRel, size: 100, mtimeMs: 1, abs: join(leakDir, bakRel) }];
+  const auditBak = auditForPlaintext(bakFiles, { agentDir: leakDir, config: { encrypt: false } });
+  check("审计此时放行（因为会被脱敏）", auditBak.clean === true, JSON.stringify(auditBak.leaks));
+
+  const { isRedactable } = await import("./backup.mjs");
+  check("isRedactable 覆盖 .bak 副本", isRedactable(bakRel) === true);
+  const redactedBak = redactSensitive(bakRel, Buffer.from(JSON.stringify({ deepseek: { key: "sk-leaked-in-backup-copy-1234567890" } })), {
+    aggressive: true,
+  });
+  check(
+    "auth.json.bak-* 的明文确实被脱敏（关键回归）",
+    redactedBak !== null && !redactedBak.toString("utf8").includes("sk-leaked-in-backup-copy"),
+    String(redactedBak).slice(0, 100),
+  );
+
+  // 真正无法脱敏的文件（不是 auth 类）仍应被审计拦下
+  writeFileSync(join(leakDir, "extensions", "leakyconfig.json"), JSON.stringify({ token: "sk-plaintext-that-audit-must-catch-99" }));
+  const auditLeaky = auditForPlaintext(
+    [{ rel: "extensions/leakyconfig.json", size: 60, mtimeMs: 1, abs: join(leakDir, "extensions", "leakyconfig.json") }],
+    { agentDir: leakDir, config: { encrypt: false } },
+  );
+  check("审计拦下非凭据文件里的明文", auditLeaky.clean === false, JSON.stringify(auditLeaky));
+
+  // secrets/ 目录内的东西根本不该进入待上传列表
+  writeFileSync(join(leakDir, "secrets", "password.txt"), "plain-password-here");
+  check("looksCredentialFile 识别 secrets/", looksCredentialFile("secrets/password.txt") === true);
+  check("looksCredentialFile 识别 secrets.dpapi.json", looksCredentialFile("secrets.dpapi.json") === true);
+  check("looksCredentialFile 不误判普通扩展", looksCredentialFile("extensions/a.ts") === false);
+  const auditSecrets = auditForPlaintext(
+    [{ rel: "secrets/password.txt", size: 20, mtimeMs: 1, abs: join(leakDir, "secrets", "password.txt") }],
+    { agentDir: leakDir, config: { encrypt: false } },
+  );
+  check("审计拦下 secrets/ 内文件", auditSecrets.clean === false, JSON.stringify(auditSecrets));
+
+  // 默认排除规则必须拦住这些
+  const { loadConfig } = await import("./config.mjs");
+  writeFileSync(
+    join(leakDir, "webdav-backup.json"),
+    JSON.stringify({ remote: { url: "https://dav.example.com/dav/", username: "u", password: "pw-abcdefgh" } }),
+  );
+  process.env.PI_CODING_AGENT_DIR = leakDir;
+  const lc = loadConfig();
+  if (!lc.config) {
+    check("审计用配置可加载", false, JSON.stringify(lc.errors));
+  }
+  const exc = lc.config?.exclude ?? [];
+  check("默认排除含 secrets/**", exc.includes("secrets/**"));
+  check("默认排除含 secrets.dpapi.json", exc.includes("secrets.dpapi.json"));
+  check("默认排除含 *.bak-* 副本", exc.includes("**/*.bak-*"));
+
+  const collected = collectFiles({ agentDir: leakDir, scope: ["."], exclude: exc });
+  const rels2 = collected.files.map((f) => f.rel);
+  check("收集时排除 auth.json.bak-*", !rels2.some((r) => r.includes(".bak-")), rels2.join(","));
+  check("收集时排除 secrets/ 目录", !rels2.some((r) => r.startsWith("secrets/")), rels2.join(","));
+
+  // 端到端：未加密备份遇到明文副本必须中止
+  const davL = await startDavServer();
+  davL.dirs.add("/dav");
+  writeFileSync(
+    join(leakDir, "webdav-backup.json"),
+    JSON.stringify({
+      remote: {
+        url: `http://127.0.0.1:${davL.port}/dav`,
+        username: "user",
+        password: "pass",
+        remoteDir: "bk",
+        remoteName: "pi",
+      },
+    }),
+  );
+  process.env.PI_CODING_AGENT_DIR = leakDir;
+  const lc2 = loadConfig();
+  if (!lc2.config) {
+    check("端到端审计配置可加载", false, JSON.stringify(lc2.errors));
+  }
+  // 手工把一个含明文的文件混进配置扫描范围，验证审计会阻断
+  writeFileSync(join(leakDir, "extensions", "leaky.json"), JSON.stringify({ apiKey: "sk-thisistotallyplaintextkey1234" }));
+  const blocked = await runBackup({ ...lc2.config, snapshot: false }, {
+    log: () => {},
+    agentDir: leakDir,
+    stateFile: join(leakDir, "s.json"),
+    reason: "manual",
+  });
+  const blockedLeak = blocked.ok === false && Array.isArray(blocked.leaks);
+  check("含明文凭据时备份被中止", blockedLeak, JSON.stringify(blocked).slice(0, 300));
+  check("中止时未上传任何文件", davL.stats().putCount === 0, `putCount=${davL.stats().putCount}`);
+
+  // 加密模式应放行（密文上传）
+  process.env.PI_CODING_AGENT_DIR = leakDir;
+  const encBlocked = await runBackup(
+    { ...lc2.config, encrypt: true, encryptKey: "test-key-for-audit-16chars" },
+    { log: () => {}, agentDir: leakDir, stateFile: join(leakDir, "s.json"), reason: "manual" },
+  );
+  check("加密模式下审计不阻断", encBlocked.ok === true, JSON.stringify(encBlocked).slice(0, 200));
+
+  // 关键端到端：目录里存在 auth.json.bak-* 明文副本时，
+  // 未加密备份应仍能完成（因为会被脱敏），且归档里绝不能出现明文。
+  rmSync(join(leakDir, "extensions", "leaky.json"), { force: true });
+  rmSync(join(leakDir, "extensions", "leakyconfig.json"), { force: true });
+  davL.reset();
+  const bakRun = await runBackup(
+    { ...lc2.config, encrypt: false, remoteName: "pi-bak" },
+    { log: () => {}, agentDir: leakDir, stateFile: join(leakDir, "s.json"), reason: "manual" },
+  );
+  check("含 .bak 副本时未加密备份仍可完成", bakRun.ok === true, JSON.stringify(bakRun).slice(0, 250));
+  if (bakRun.ok) {
+    const blobRaw = davL.store.get(`/dav/bk/${bakRun.archive}`);
+    check("归档已上传", !!blobRaw);
+    if (blobRaw) {
+      const { gunzipSync } = await import("node:zlib");
+      const text = gunzipSync(blobRaw).toString("latin1");
+      // 排除规则是第一道防线：.bak 副本根本不进归档。
+      // （即使有人删掉该规则，前面的脱敏回归测试保证明文也会被抹掉）
+      check("归档不含 .bak 副本（被排除规则挡住）", !text.includes("auth.json.bak-"));
+      check(
+        "归档中无 .bak 副本明文（关键回归）",
+        !text.includes("sk-leaked-in-backup-copy"),
+        "明文密钥随备份副本泄露！",
+      );
+      check("正文 auth.json 仍在归档内", text.includes("auth.json"));
+    }
+  }
+
+  davL.server.close();
+  try {
+    rmSync(leakDir, { recursive: true, force: true });
+  } catch {
+    /* ignore */
+  }
+}
+
+console.log(lines.join("\n"));
+console.log(`\n结果：${pass} 通过，${fail} 失败`);
+process.exit(fail === 0 ? 0 : 1);

package/extensions/webdav-backup/test-restore.mjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+/**
+ * test-restore.mjs — 恢复流程测试
+ *
+ * 验证：
+ *   1. listBackups 能列出归档与快照
+ *   2. 归档恢复：解出全部文件且内容一致
+ *   3. 加密归档恢复：需要正确密钥
+ *   4. 快照恢复：逐文件还原
+ *   5. tar 解包拒绝目录穿越
+ *   6. 未指定 --to 时落到临时目录，不覆盖原目录
+ */
+
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { startDavServer } from "./dav-mock.mjs";
+import { loadConfig } from "./config.mjs";
+import { runBackup } from "./backup.mjs";
+import { restoreBackup, listBackups } from "./restore.mjs";
+import { extractTar } from "./tar.mjs";
+import { WebDAVClient } from "./webdav.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+
+let pass = 0;
+let fail = 0;
+const lines = [];
+const check = (n, c, d = "") => {
+  if (c) {
+    pass++;
+    lines.push(`  ✅ ${n}`);
+  } else {
+    fail++;
+    lines.push(`  ❌ ${n}${d ? ` — ${d}` : ""}`);
+  }
+};
+
+async function main() {
+  console.log("pi WebDAV 备份 — 恢复流程测试\n");
+
+  const dav = await startDavServer();
+  const baseUrl = `http://127.0.0.1:${dav.port}/dav`;
+  dav.dirs.add("/dav");
+
+  const agentDir = mkdtempSync(join(tmpdir(), "pi-restore-test-"));
+  mkdirSync(join(agentDir, "extensions", "deep", "nested"), { recursive: true });
+  writeFileSync(join(agentDir, "extensions", "one.ts"), "// one\n");
+  writeFileSync(join(agentDir, "extensions", "deep", "two.ts"), "// two\n");
+  writeFileSync(join(agentDir, "extensions", "deep", "nested", "three.json"), '{"three":true}\n');
+  writeFileSync(join(agentDir, "settings.json"), '{"theme":"dark","x":1}\n');
+  writeFileSync(join(agentDir, "auth.json"), JSON.stringify({ k: "sk-CANARY-2" }));
+  writeFileSync(
+    join(agentDir, "webdav-backup.json"),
+    JSON.stringify({
+      remote: { url: baseUrl, username: "user", password: "pass", remoteDir: "bk", remoteName: "pi" },
+      encrypt: false,
+      includeSessions: false,
+    }),
+  );
+
+  process.env.PI_CODING_AGENT_DIR = agentDir;
+  const loaded = loadConfig();
+  check("配置加载", loaded.ok, loaded.errors.join("; "));
+  const config = loaded.config;
+
+  // 1. 先做一个普通归档
+  const bk = await runBackup(config, { log: () => {}, agentDir, stateFile: join(agentDir, "state.json") });
+  check("归档备份成功", bk.ok === true, bk.error);
+
+  // 2. listBackups
+  const listing = await listBackups(config);
+  check("listBackups 列出归档", listing.archives.length === 1, `archives=${listing.archives.length}`);
+  check("listBackups 无快照时不报错", listing.snapshot === null);
+
+  // 3. 恢复到指定目录
+  const dest = join(agentDir, "restored-to");
+  const r1 = await restoreBackup(config, { agentDir, file: null, to: dest, log: () => {} });
+  check("归档恢复成功", r1.ok === true, JSON.stringify(r1));
+  check("恢复到指定目录", r1.dest === dest);
+  check("恢复出 one.ts", existsSync(join(dest, "extensions", "one.ts")));
+  check("恢复出嵌套 three.json", existsSync(join(dest, "extensions", "deep", "nested", "three.json")));
+  check("恢复出 settings.json", existsSync(join(dest, "settings.json")));
+  check(
+    "恢复内容与原始一致",
+    readFileSync(join(dest, "extensions", "deep", "nested", "three.json"), "utf8") === '{"three":true}\n',
+  );
+  check(
+    "恢复的 auth.json 仍是脱敏版（不含明文密钥）",
+    !readFileSync(join(dest, "auth.json"), "utf8").includes("sk-CANARY-2"),
+  );
+
+  // 4. 加密归档恢复
+  const encConfig = { ...config, encrypt: true, encryptKey: "restore-test-secret-key-1", remoteName: "pi-enc" };
+  const encBk = await runBackup(encConfig, {
+    log: () => {},
+    agentDir,
+    stateFile: join(agentDir, "state.json"),
+  });
+  check("加密备份成功", encBk.ok === true, encBk.error);
+
+  const encDest = join(agentDir, "restored-enc");
+  const r2 = await restoreBackup(encConfig, { agentDir, to: encDest, log: () => {} });
+  check("加密归档恢复成功", r2.ok === true, JSON.stringify(r2));
+  check("加密恢复报告 encrypted=true", r2.encrypted === true);
+  check("加密恢复出 one.ts", existsSync(join(encDest, "extensions", "one.ts")));
+
+  // 错误密钥
+  const wrongKeyConfig = { ...encConfig, encryptKey: "totally-wrong-key-value" };
+  let wrongOk = true;
+  let wrongErr = "";
+  try {
+    const rw = await restoreBackup(wrongKeyConfig, {
+      agentDir,
+      to: join(agentDir, "restored-wrong"),
+      log: () => {},
+    });
+    wrongOk = rw.ok;
+    wrongErr = String(rw.error ?? "");
+  } catch (e) {
+    wrongOk = false;
+    wrongErr = String(e.message);
+  }
+  check("错误密钥恢复失败", wrongOk === false, wrongErr);
+
+  // 无密钥时给出明确提示
+  const noKeyConfig = { ...encConfig, encryptKey: null };
+  const rn = await restoreBackup(noKeyConfig, { agentDir, to: join(agentDir, "restored-nokey"), log: () => {} });
+  check("缺密钥时提示明确", rn.ok === false && /encryptKey|密钥/.test(String(rn.error)), JSON.stringify(rn));
+
+  // 5. 快照恢复
+  const snapConfig = { ...config, snapshot: true, remoteName: "pi-snap" };
+  const snapBk = await runBackup(snapConfig, {
+    log: () => {},
+    agentDir,
+    stateFile: join(agentDir, "state.json"),
+  });
+  check("快照备份成功", snapBk.ok === true, snapBk.error);
+
+  const snapListing = await listBackups(snapConfig);
+  check("listBackups 识别快照", !!snapListing.snapshot, JSON.stringify(snapListing.snapshot));
+
+  const snapDest = join(agentDir, "restored-snap");
+  const r3 = await restoreBackup(snapConfig, { agentDir, file: "pi-snap", to: snapDest, log: () => {} });
+  check("快照恢复成功", r3.ok === true, JSON.stringify(r3));
+  check("快照恢复出文件", existsSync(join(snapDest, "extensions", "one.ts")));
+  check("快照恢复出嵌套文件", existsSync(join(snapDest, "extensions", "deep", "nested", "three.json")));
+
+  // 6. 恢复不存在的文件
+  const r4 = await restoreBackup(config, { agentDir, file: "不存在.tar.gz", to: join(agentDir, "x"), log: () => {} });
+  check("指定不存在的备份时失败并列出可选", r4.ok === false && Array.isArray(r4.available));
+
+  // 7. listOnly
+  const r5 = await restoreBackup(config, { agentDir, listOnly: true, log: () => {} });
+  check("listOnly 只列不下载", r5.ok === true && r5.listOnly === true && Array.isArray(r5.archives));
+
+  // 8. tar 目录穿越防护
+  const evilDir = mkdtempSync(join(tmpdir(), "pi-evil-"));
+  const evilTar = join(evilDir, "evil.tar");
+  // 手工构造一个含 ../../evil.txt 的 tar
+  {
+    const name = Buffer.from("../../evil.txt", "utf8");
+    const hdr = Buffer.alloc(512);
+    name.copy(hdr, 0);
+    hdr.write("0000644\0", 100, 8, "ascii");
+    hdr.write("0000000\0", 108, 8, "ascii");
+    hdr.write("0000000\0", 116, 8, "ascii");
+    hdr.write("00000000005\0", 124, 12, "ascii");
+    hdr.write("00000000000\0", 136, 12, "ascii");
+    hdr.write("        ", 148, 8, "ascii");
+    hdr.write("0", 156, 1, "ascii");
+    hdr.write("ustar\0", 257, 6, "ascii");
+    hdr.write("00", 263, 2, "ascii");
+    let sum = 0;
+    for (const b of hdr) sum += b;
+    hdr.write(sum.toString(8).padStart(6, "0") + "\0 ", 148, 8, "ascii");
+    const body = Buffer.alloc(512);
+    body.write("PWNED", 0, "utf8");
+    const end = Buffer.alloc(1024);
+    writeFileSync(evilTar, Buffer.concat([hdr, body, end]));
+  }
+  let traversalBlocked = false;
+  try {
+    await extractTar(evilTar, join(evilDir, "out"));
+  } catch (e) {
+    traversalBlocked = /不安全路径/.test(String(e.message));
+  }
+  check("tar 解包拒绝目录穿越", traversalBlocked);
+  check("穿越文件未被写出", !existsSync(join(tmpdir(), "evil.txt")) && !existsSync(join(evilDir, "evil.txt")));
+
+  // 9. 未指定 --to 时不动原目录
+  const beforeSettings = readFileSync(join(agentDir, "settings.json"), "utf8");
+  const r6 = await restoreBackup(config, { agentDir, log: () => {} });
+  check("默认恢复到临时目录", r6.ok === true && r6.dest.includes("pi-restore-"), String(r6.dest));
+  check("未覆盖原文件", readFileSync(join(agentDir, "settings.json"), "utf8") === beforeSettings);
+
+  dav.server.close();
+  try {
+    rmSync(agentDir, { recursive: true, force: true });
+    rmSync(evilDir, { recursive: true, force: true });
+    if (r6.dest && r6.dest.includes("pi-restore-")) {
+      rmSync(dirname(r6.dest), { recursive: true, force: true });
+    }
+  } catch {
+    /* ignore */
+  }
+
+  console.log(lines.join("\n"));
+  console.log(`\n结果：${pass} 通过，${fail} 失败`);
+  process.exit(fail === 0 ? 0 : 1);
+}
+
+main().catch((e) => {
+  console.log(lines.join("\n"));
+  console.error(`\n测试异常：${e?.stack ?? e}`);
+  process.exit(1);
+});