dsh-config-manager 0.2.3 → 0.3.0

package/src/sync/merge-preview-text.ts

@@ -0,0 +1,37 @@
+import { redact } from '../security/redaction.ts';
+
+/** 单侧预览文本上限（2 KiB **字符**预算）：超出截断并追加省略号。 */
+export const MERGE_PREVIEW_TEXT_LIMIT = 2048;
+
+/** 严格 UTF-8 解码器：非法字节序列直接抛错（用于区分文本与二进制文件冲突）。 */
+const STRICT_UTF8 = new TextDecoder('utf-8', { fatal: true });
+
+/**
+ * 预览文本统一出口：先 redact（敏感值绝不回传浏览器），再截断到 2 KiB。
+ *
+ * 顺序恒为「先 redact 再截断」：反过来会把跨边界的敏感值切成半个形状，让脱敏匹配不到它
+ * （等于把秘密截一半发出去）。redact 之后的剩余文本已不含秘密形状，截断才安全。
+ */
+export function finalizePreviewText(text: string): string {
+  const masked = redact(text);
+  return masked.length > MERGE_PREVIEW_TEXT_LIMIT ? `${masked.slice(0, MERGE_PREVIEW_TEXT_LIMIT)}…` : masked;
+}
+
+/** 把任意冲突侧值转成**可读字符串**；二进制只回传形状与字节数，绝不回传原始值对象。 */
+export function previewTextOf(value: unknown): string {
+  if (value === undefined) return '';
+  if (typeof value === 'string') return finalizePreviewText(value);
+  if (value instanceof Uint8Array) {
+    try {
+      return finalizePreviewText(STRICT_UTF8.decode(value));
+    } catch {
+      // 二进制内容解码只会得到乱码（同样误导用户）→ 只回传形状；JSON 是数据形态，不是文案
+      return JSON.stringify({ binary: true, bytes: value.length });
+    }
+  }
+  try {
+    return finalizePreviewText(JSON.stringify(value) ?? '');
+  } catch {
+    return finalizePreviewText(String(value));
+  }
+}

package/src/sync/s3/s3-delete-index-404.test.ts

@@ -11,7 +11,9 @@
  *   ② index 读操作抛错  → 显式失败（F2 语义，绝不回落成空索引）；
  *   ③ index = 200 + []  → 索引权威地声明集合为空，保持既有语义（既有用例
  *      「blob GC：删除最后一份快照后回收超保护窗的无人引用 blob」钉住该路径）；
- *   ④ GC 遇到「索引有条目但快照文件读不出来（非 404）」→ 本轮放弃（读不出来 ≠ 没引用）。
+ *   ④ GC 遇到「索引有条目但快照文件读不出来（非 404）」→ 本轮放弃（读不出来 ≠ 没引用）；
+ *   ⑤ SYN-04（P1）：与 WebDAV 同型 —— **404 也放弃本轮**（孤儿条目 / 假 404 拿不到内容就无法证明
+ *      「没人引用」），本轮 0 删除并记下放弃码（`lastGcSkip`，机器可判定）。
  */
 import test from 'node:test';
 import assert from 'node:assert/strict';
@@ -168,3 +170,26 @@ test('N1⑤：索引有条目但该快照文件读不出来（非 404）→ 本
   assert.equal(remote.deletedBlobs.length, 0, '读不出 sync-ccc-333 就无法证明它没引用 blob → 本轮不得删任何 blob');
   assert.equal(remote.objects.has(PREFIX + '/blobs/' + BLOB_HASH), true);
 });
+
+test('N1⑥（SYN-04）：索引有条目但该快照文件真 404 → 本轮放弃 GC（404 也证明不了「没引用」）+ 记放弃码', async () => {
+  const remote = makeRemote({
+    index: JSON.stringify([meta('sync-aaa-111', '1'), meta('sync-ccc-333', '3')]),
+    snapshotFiles: { 'sync-aaa-111': snapOf('sync-aaa-111', PLAIN) },
+  });
+  const t = new S3Transport(makeOptions(remote));
+  await t.delete('sync-aaa-111');
+  assert.equal(remote.deletedBlobs.length, 0, '404 与「读不出来」同属「无法证明没有引用」→ 本轮 0 删除');
+  assert.equal(remote.objects.has(PREFIX + '/blobs/' + BLOB_HASH), true, '没有被证明无引用的 blob 必须保留');
+  assert.equal(t.lastGcSkip, 'gc-skip-reference-missing', '必须记下本轮放弃码（机器可判定，文案由上层按码翻译）');
+});
+
+test('N1⑦（SYN-04）：引用者 200 但内容坏掉 → 本轮放弃，放弃码 = snapshot-unparsable', async () => {
+  const remote = makeRemote({
+    index: JSON.stringify([meta('sync-aaa-111', '1'), meta('sync-ccc-333', '3')]),
+    snapshotFiles: { 'sync-aaa-111': snapOf('sync-aaa-111', PLAIN), 'sync-ccc-333': 'not-json' },
+  });
+  const t = new S3Transport(makeOptions(remote));
+  await t.delete('sync-aaa-111');
+  assert.equal(remote.deletedBlobs.length, 0, '解析不了 ⇒ 引用集不完整 ⇒ 本轮不得删任何 blob');
+  assert.equal(t.lastGcSkip, 'gc-skip-snapshot-unparsable');
+});

package/src/sync/s3/s3-transport.ts

@@ -26,6 +26,8 @@ import { requestOnce } from '../../utils/proxy.ts';
 import type { RawResponse } from '../../utils/proxy.ts';
 import { parseJsonSafe } from '../../utils/json.ts';
 import type { MsgFunc } from '../../core/msg-types.ts';
+import { GC_SKIP_REFERENCE_MISSING, GC_SKIP_REFERENCE_UNREADABLE, GC_SKIP_SNAPSHOT_UNPARSABLE } from '../gc-skip.ts';
+import type { GcSkipCode } from '../gc-skip.ts';
 import { deserializeSnapshot, serializeSnapshot } from '../snapshot-json.ts';
 import {
   BLOB_SECTIONS, gcBlobs, isBlobRefsSection, isFilesSectionLike, referencedBlobHashes,
@@ -213,6 +215,14 @@ export class S3Transport implements SyncTransport {
     msg: MsgFunc;
   };
 
+  /** 最近一轮 blob GC 的放弃码（`null` = 跑完或未触发；SYN-04）。 */
+  private gcSkip: GcSkipCode | null = null;
+
+  /** 最近一轮 blob GC 是否因「无法证明引用集完整」而整体放弃（`null` = 正常跑完），供上层给用户提示。 */
+  get lastGcSkip(): GcSkipCode | null {
+    return this.gcSkip;
+  }
+
   constructor(options: S3TransportOptions) {
     // t79：宿主传进来的 msg（core 目录）**不包含** sync.s3.* 键，直接用会显示裸键名 —— 合并本地目录。
     const msg = composeMsg(options.msg, s3Msg);
@@ -708,20 +718,29 @@ export class S3Transport implements SyncTransport {
   }
 
   /** blob 仓 GC：逐份读仍存在的快照收集引用，删除无人引用且超保护窗的 blob；
-   *  读坏任一份快照 → 本轮直接放弃（宁可留垃圾，不可删在用的） */
+   *  读不坏任何一份快照 → 正常回收，否则本轮整体放弃（宁可留垃圾，不可删在用的）。
+   *  SYN-04（P1）：**404 也放弃本轮** —— 条目在但文件 404 = 拿不到内容 = 无法证明「没人引用」，
+   *  按残集回收会删掉仍在用的 blob（与 WebDAV 同型，口径一致）。 */
   private async gcBlobStore(secret: string, remaining: SyncSnapshotMeta[]): Promise<void> {
+    this.gcSkip = null;
     const index = await this.readBlobIndex(secret);
     if (Object.keys(index).length === 0) return;
     const referenced = new Set<string>();
     for (const meta of remaining) {
       const sent = await this.send('GET', snapshotKey(this.target.prefix, meta.id), { secret });
-      // 条目在但文件 404 ⇒ 不可能引用 blob（安全跳过）；其它失败 ⇒ 读不出来 ≠ 没引用，本轮放弃。
-      if (sent.res.status === 404) continue;
-      if (!sent.res.ok) return;
+      if (sent.res.status === 404) {
+        this.gcSkip = GC_SKIP_REFERENCE_MISSING;
+        return;
+      }
+      if (!sent.res.ok) {
+        this.gcSkip = GC_SKIP_REFERENCE_UNREADABLE;
+        return;
+      }
       let snap: SyncSnapshot;
       try {
         snap = deserializeSnapshot(await sent.res.text());
       } catch {
+        this.gcSkip = GC_SKIP_SNAPSHOT_UNPARSABLE;
         return;
       }
       const plain = snap.sections as Partial<Record<SectionId, unknown>>;

package/src/sync/session-tombstones.ts

@@ -18,6 +18,9 @@
  *    本次不实现（保留信息可见，不代用户删数据）。
  */
 import { sha256Hex } from '../utils/hashing.ts';
+import { isEncryptedSections } from './transport.ts';
+import type { SectionData, SectionId } from '../schema/types.ts';
+import type { SyncSnapshotMeta, SyncTransport } from './transport.ts';
 
 /** 会话单元 id 前缀（与 SessionsAdapter.unitIdOf 同口径：`sessions:<projectKey>/<sessionId>`）。 */
 export const SESSION_UNIT_PREFIX = 'sessions:';
@@ -121,3 +124,90 @@ export function sessionUnitIdsOfSection(section: unknown): string[] {
 export function unitSetFingerprint(units: readonly string[]): string {
   return sha256Hex([...units].sort().join('\n'));
 }
+
+/* ---------------- SYN-02：墓碑跨设备继承（远端 → 本机 → 下一份快照） ---------------- */
+
+/**
+ * 一次远端 list() 的读取结果。
+ *
+ * `metas` 为空**且**无 `reason` 才代表「远端确实为空」；有 reason = 读不到（按「看不到远端」
+ * 处理，调用方告警后继续，绝不把它当成「远端没东西」而误判）。
+ */
+export interface RemoteSnapshotIndex {
+  metas: SyncSnapshotMeta[];
+  reason?: string;
+}
+
+/** 读一次远端快照索引（只读、零写入）。push 的「是否被推进」判定与墓碑继承共用这一份。 */
+export async function listRemoteSnapshotIndex(transport: Pick<SyncTransport, 'list'>): Promise<RemoteSnapshotIndex> {
+  try {
+    return { metas: await transport.list() };
+  } catch (error) {
+    return { metas: [], reason: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/**
+ * 远端最新快照携带的会话删除墓碑（去重、去空、保序）。
+ *
+ * 只取**最新一份**：manifest.deletedSessions 是累积清单（见文件头），旧快照的墓碑必然被后续
+ * 快照包含；把整段历史并起来只会让「已经在别处撤销的墓碑」复活。
+ * 远端为空 / 老快照缺字段 → 空数组（行为与改造前逐字一致：不继承任何墓碑）。
+ */
+export function remoteTombstonesOf(metas: readonly SyncSnapshotMeta[]): string[] {
+  const latest = metas.length === 0 ? undefined : metas[metas.length - 1];
+  const list = latest?.manifest.deletedSessions ?? [];
+  return [...new Set(list.filter((id) => typeof id === 'string' && id !== ''))];
+}
+
+/** 一次 push 的会话簿记结果（manifest / baseline / 告警共用这一份）。 */
+export interface SessionBookkeepingResult {
+  /** false = 本次没有可用的会话枚举（没推 sessions / 适配器不支持 / 枚举失败或为空） */
+  tracked: boolean;
+  sessionUnits: string[];
+  tombstones: string[];
+  /** 本次**新**发现的删除（之前推过、这次本机没了） */
+  deletedNow: string[];
+  /** 从远端继承来的墓碑条数（本机此前没有、且本机也没有实体） */
+  inherited: number;
+}
+
+/**
+ * 墓碑集合的唯一计算点（本机删除 + 远端继承合进同一条累积链）。
+ *
+ * 去重、FIFO 上限、以及「本机还有实体 ⇒ 撤销墓碑」这条不变量对继承来的墓碑同样适用：
+ * 另一台设备删了、本机仍有 → 用户在本机显然没删，绝不把它记成本机删除。
+ */
+export function planSessionBookkeeping(args: {
+  previousUnits: readonly string[];
+  previousTombstones: readonly string[];
+  localUnits: readonly string[];
+  exportedSessions: SectionData | undefined;
+  remoteTombstones: readonly string[];
+}): Omit<SessionBookkeepingResult, 'tracked'> {
+  const known = args.previousTombstones;
+  const knownSet = new Set(known);
+  const localSet = new Set(args.localUnits);
+  const inherited = args.remoteTombstones.filter((id) => !knownSet.has(id) && !localSet.has(id)).length;
+  const { tombstones, deletedNow } = nextSessionTombstones({
+    previousUnits: [...args.previousUnits],
+    localUnits: [...args.localUnits],
+    previousTombstones: [...known, ...args.remoteTombstones],
+  });
+  return { sessionUnits: sessionUnitIdsOfSection(args.exportedSessions), tombstones, deletedNow, inherited };
+}
+
+/** 按墓碑剔除**将要导入**的会话（旧快照不得复活已删除的对话）。只动载荷，不动本机数据。 */
+export function stripTombstonedSessionsInPlace<P extends {
+  manifest: { deletedSessions?: readonly string[] };
+  sections: unknown;
+}>(snapshot: P): string[] {
+  const tombstones = snapshot.manifest.deletedSessions ?? [];
+  if (tombstones.length === 0 || isEncryptedSections(snapshot.sections)) return [];
+  const plain = snapshot.sections as Partial<Record<SectionId, SectionData>>;
+  const stripped = stripTombstonedUnits(plain['sessions'], tombstones);
+  if (stripped.removed.length === 0) return [];
+  plain['sessions'] = stripped.section as SectionData;
+  return stripped.removed;
+}
+

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

@@ -24,7 +24,7 @@ import {
   readSyncConfig, readFullSyncConfig, readSyncConfigFor, writeSyncConfig, isGitConfig, isWebDavConfig,
   isS3Config, isGistConfig, listConfiguredChannels, readActiveS3Provider,
   SYNC_CONFIG_FILE, SYNC_CONFIG_SCHEMA_VERSION, SYNC_CONFIG_SUPPORTED_VERSIONS, CLOUD_SYNC_CONFIG_FILE,
-  validateWebDavUrl, type SyncConfig,
+  validateWebDavUrl, validateRepoUrl, type SyncConfig, type SyncConfigIssue,
   SYNC_CHANNELS, channelOf, channelMap, isSyncTransportType, parseSyncChannel, clearSyncChannel,
   S3_COMPAT_PROVIDERS, CLOUD_SYNC_PROVIDERS, cloudSecretRef,
 } from './sync-config.ts';
@@ -739,3 +739,172 @@ test('t88 跨侧常量守卫：S3 兼容商清单与云端点密钥槽位引用
     'client 侧必须 re-export 共享派生函数（不得自己再实现一遍）',
   );
 });
+/* ------------------------------------------------------------------------------------------------
+ * SEC-02 / SEC-03 / SEC-12：repoUrl 白名单（审计 §安全 P0 链）
+ *
+ * 事实：repoUrl 直接进 git 子进程 argv，且 http(s) 通道会把凭据注入到它的 host 上。原实现只拒
+ * 空白与 userinfo，于是「file:// 任意本机仓」「ext::sh -c …」「-c core.pager=…」、环回/私网地址
+ * 全都能当同步目标 —— 一旦写进本机配置，git 就会按包方指定的地址执行/送凭据。
+ * 白名单口径：只认 http/https/ssh/scp-like 远端；无 host、私网/环回/链路本地、非网络方案、
+ * 整串以 '-' 开头一律拒绝。本机路径保留（git 通道的老用法，见 GitTransportOptions.repoUrl 注释）。
+ * ---------------------------------------------------------------------------------------------- */
+
+test('validateRepoUrl（SEC-02/03/12）：白名单 —— http(s)/ssh/scp-like 远端通过，危险方案与私网地址一律拒绝', () => {
+  // 通过：真实用法的四种形状（https / http / ssh:// / scp-like）+ 本机路径
+  for (const ok of [
+    'https://github.com/u/r.git',
+    'http://git.example.com/u/r.git',
+    'ssh://git@git.example.com:2222/u/r.git',
+    'git@github.com:u/r.git',
+    'git@git.example.com:team/r.git',
+    '/home/bob/repos/config.git',
+    '../bare',
+    'D:/repos/bare',
+    'https://github.com/u/r-1.git',
+    // 私网边界外（172.16/12 之外的 172.x 与 11.x 不是保留段）
+    'https://172.32.0.1/r.git',
+    'https://11.0.0.1/r.git',
+  ]) {
+    assert.equal(validateRepoUrl(ok), null, '应通过: ' + ok);
+  }
+
+  // 拒绝：方案白名单（SEC-03）+ 无 host + 私网/环回/链路本地（SEC-02）+ 以 '-' 开头（SEC-12）
+  for (const bad of [
+    'file:///c:/repos/x.git',
+    'file:///etc/passwd',
+    'ext::sh -c touch% /tmp/pwned',
+    'ftp://git.example.com/r.git',
+    'git://git.example.com/r.git',
+    'https://',
+    'https:///r.git',
+    'https://127.0.0.1:8443/r.git',
+    'http://localhost:3000/r.git',
+    'https://[::1]/r.git',
+    'ssh://git@127.0.0.1/r.git',
+    'git@localhost:r.git',
+    'https://10.0.0.5/r.git',
+    'https://192.168.1.10/r.git',
+    'https://172.16.0.9/r.git',
+    'https://172.31.255.1/r.git',
+    'https://169.254.169.254/latest/meta-data/',
+    'https://[fe80::1]/r.git',
+    '-c core.pager=touch /tmp/pwned',
+    '--upload-pack=touch /tmp/pwned',
+    'https://user:ghp_token@github.com/u/r.git',
+    'https://github.com/u/r .git',
+  ]) {
+    const err = validateRepoUrl(bad);
+    assert.equal(typeof err, 'string', '必须拒绝: ' + bad);
+    assert.ok(err !== null && err.length > 0, '拒绝必须带可展示原因: ' + bad);
+  }
+});
+
+test('readSyncConfig（SEC-01 读侧）：已存 repoUrl 走同一校验；不合法 → 不返回该配置并给明确 issue', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'dsh-sync-cfg-repo-'));
+  try {
+    // 合法：照常读出，无 issue
+    await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), JSON.stringify({
+      schemaVersion: 3, transport: 'git',
+      git: { repoUrl: 'https://github.com/u/r.git' }, webdav: {},
+    }, null, 2), 'utf8');
+    const issues: SyncConfigIssue[] = [];
+    const ok = await readSyncConfig(dir, issues);
+    assert.equal(issues.length, 0, '合法 repoUrl 不该产生 issue');
+    assert.ok(ok !== null && isGitConfig(ok));
+
+    // 不合法：包方写进来的 file:// 目标 —— 读侧必须当成「未配置」，且给出明确原因
+    for (const badUrl of [
+      'file:///c:/repos/x.git',
+      'ext::sh -c touch% /tmp/pwned',
+      'https://169.254.169.254/latest/meta-data/',
+      'https://user:ghp_x@github.com/u/r.git',
+    ]) {
+      await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), JSON.stringify({
+        schemaVersion: 3, transport: 'git', git: { repoUrl: badUrl }, webdav: {},
+      }, null, 2), 'utf8');
+      const local: SyncConfigIssue[] = [];
+      const cfg = await readSyncConfig(dir, local);
+      assert.equal(cfg, null, '不合法的 repoUrl 不得进入后续凭据注入: ' + badUrl);
+      assert.equal(local.length, 1, '必须显式记录被拒的通道，不得静默: ' + badUrl);
+      assert.equal(local[0]?.code, 'repo-url-invalid');
+      assert.equal(local[0]?.channel, 'git');
+      assert.ok((local[0]?.message ?? '').length > 0, '必须带可展示原因');
+
+      // 省略 issue 收集参数时行为不变（老调用方仍拿 null = 未配置）
+      assert.equal(await readSyncConfig(dir), null);
+    }
+
+    // v1 旧文件（扁平 repoUrl）走同一校验
+    await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), JSON.stringify({ schemaVersion: 1, repoUrl: 'file:///etc' }), 'utf8');
+    const legacyIssues: SyncConfigIssue[] = [];
+    assert.equal(await readSyncConfig(dir, legacyIssues), null, 'v1 旧文件的 repoUrl 也要校验');
+    assert.equal(legacyIssues.length, 1);
+
+    // 本机路径仍是 git 通道的合法目标（产品既有能力，不因白名单被砍）
+    await fs.writeFile(path.join(dir, SYNC_CONFIG_FILE), JSON.stringify({
+      schemaVersion: 3, transport: 'git', git: { repoUrl: '/home/bob/repos/config.git' }, webdav: {},
+    }, null, 2), 'utf8');
+    const localIssues: SyncConfigIssue[] = [];
+    const localCfg = await readSyncConfig(dir, localIssues);
+    assert.equal(localIssues.length, 0);
+    assert.ok(localCfg !== null && isGitConfig(localCfg) && localCfg.git.repoUrl === '/home/bob/repos/config.git');
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});
+
+/* ------------------------------------------------------------------------------------------------
+ * RV1-F6 / F7：私网拒绝的文案口径 + userinfo 覆盖 ssh（复核在 SEC-02/12 里抓到的两处边角）
+ *
+ * F6：环回/私网复用「无法解析仓库地址」= 给了用户错的方向（他会反复改写法）。真实判据是
+ *     「这个地址指向本机/内网，不作为同步目标」，因此单独一条 sync.configPrivateHost。
+ * F7：userinfo 检查原来只在 http/https 分支内，`ssh://user:tok@host/r.git` 能过白名单，
+ *     token 会跟着 repoUrl 进 argv、进 sync-config.json。口径改成「password 位任何 scheme 都拒」。
+ * ---------------------------------------------------------------------------------------------- */
+
+test('validateRepoUrl（RV1-F6）：私网/环回用专属文案，且回显地址已脱敏（不含 userinfo）', () => {
+  const cases: Array<[string, string]> = [
+    ['https://127.0.0.1:8443/r.git', '127.0.0.1:8443'],
+    ['http://localhost:3000/r.git', 'localhost:3000'],
+    ['https://192.168.1.10/r.git', '192.168.1.10'],
+    ['https://169.254.169.254/latest/meta-data/', '169.254.169.254'],
+    ['ssh://git@10.0.0.5/r.git', '10.0.0.5'],
+  ];
+  for (const [url, host] of cases) {
+    const err = validateRepoUrl(url);
+    assert.ok(err !== null, '私网地址必须拒绝: ' + url);
+    assert.ok(err.includes('本机或内网'), '原因必须是「指向本机/内网」，不能复用解析失败: ' + err);
+    assert.ok(!err.includes('无法解析'), '不得再用「无法解析仓库地址」描述私网: ' + err);
+    assert.ok(err.includes(host), '要能认出被拒的是哪个地址: ' + err);
+  }
+
+  // 回显脱敏：私网 + userinfo 同时出现时，文案里只能有 host，不能有 user/token
+  const withToken = validateRepoUrl('https://user:ghp_secretvalue@192.168.1.10/r.git');
+  assert.ok(withToken !== null);
+  assert.ok(withToken.includes('192.168.1.10'), '地址主体保留: ' + withToken);
+  assert.ok(!withToken.includes('ghp_secretvalue') && !withToken.includes('user:'), '文案不得回显凭据: ' + withToken);
+
+  // 私网判定先于 userinfo：带 userinfo 的私网地址仍报「内网」，而不是「别带凭据」
+  assert.ok(withToken.includes('本机或内网'), '私网判定优先: ' + withToken);
+});
+
+test('validateRepoUrl（RV1-F7）：带 scheme 的 userinfo —— ssh 的 token 也被拒，ssh 登录名仍放行', () => {
+  // ssh 里 password 位 = 可粘贴的 token → 拒
+  for (const bad of ['ssh://user:tok@example.com/r.git', 'ssh://git:ghp_abc@example.com:22/u/r.git', 'ssh://:tok@example.com/r.git']) {
+    assert.equal(validateRepoUrl(bad), validateRepoUrl('https://user:tok@example.com/r.git'), 'ssh userinfo 与 http 同口径: ' + bad);
+    assert.ok((validateRepoUrl(bad) ?? '').includes('用户名/密码'), '必须是 userinfo 文案: ' + bad);
+  }
+  // ssh 的 username 是登录名（标准写法）→ 放行；否则会杀掉合法用法
+  for (const ok of ['ssh://git@git.example.com:2222/u/r.git', 'ssh://deploy@git.example.com/u/r.git', 'git@github.com:u/r.git']) {
+    assert.equal(validateRepoUrl(ok), null, 'ssh 登录名不是凭据，必须放行: ' + ok);
+  }
+  // http(s) 的 username 与口令等同（Basic 认证）→ 仍拒
+  for (const bad of ['https://user@github.com/u/r.git', 'http://user@git.example.com/u/r.git']) {
+    assert.ok((validateRepoUrl(bad) ?? '').includes('用户名/密码'), 'http(s) 的 username 仍拒: ' + bad);
+  }
+
+  // 解析不了的半截地址也必须脱敏回显（`https://user:tok@` 前缀就是凭据）
+  const half = validateRepoUrl('https://user:ghp_halfsecret@');
+  assert.ok(half !== null);
+  assert.ok(!half.includes('ghp_halfsecret'), '无法解析的地址同样不得回显凭据: ' + half);
+});