@hyzyn/dsh-safe 0.13.0 → 0.14.0

package/README.en.md

@@ -48,7 +48,8 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 | `dsh-safe doctor` | environment check: versions, DSH_HOME, profiles, ledger, patch health |
 | `dsh-safe restore [--profile <name>] (--id <id> \| --all) [--dry-run]` | re-enable auto-disabled plugins (omit `--profile` to cover every profile in the ledger) |
 | `dsh-safe explain [id] [--profile <name> \| --file <path>]` | interpret failure info with AI: an `id` interprets that quarantine record (with repair advice); defaults to the last failure log, falling back to the ledger; `--file`/stdin read any log (needs `DSH_SAFE_AI_KEY`) |
-| `dsh-safe repair [id] [--profile <name>] [--to <version>] [-y] [--dry-run]` | reinstall/upgrade a quarantined plugin and auto-restore it (failures a reinstall/upgrade may fix: package resolution, export mismatches; installs via `dsh plugin`'s pnpm channel); duplicate mounts support auto-dedup (interactively pick which source to keep) |
+| `dsh-safe -r [dsh args…]` | repair all repairable quarantined plugins first, then boot in wrap mode (`--repair` alias; mirrors `-u`) |
+| `dsh-safe repair [id] [--all] [--profile <name>] [--to <version>] [-y] [--dry-run]` | reinstall/upgrade a quarantined plugin and auto-restore it (failures a reinstall/upgrade may fix: package resolution, export mismatches; installs via `dsh plugin`'s pnpm channel); duplicate mounts support auto-dedup (interactively pick which source to keep) |
 | `dsh-safe help` (`-h` / `--help`) | show help |
 | `dsh-safe --version` (`-V`) | show version |
 

package/README.md

@@ -48,7 +48,8 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 | `dsh-safe doctor` | 环境体检：版本、DSH_HOME、profiles、台账、各 patch 健康度 |
 | `dsh-safe restore [--profile <名>] (--id <id> \| --all) [--dry-run]` | 恢复被自动禁用的插件（省略 `--profile` 时遍历台账全部 profile） |
 | `dsh-safe explain [id] [--profile <名> \| --file <路径>]` | 用 AI 解读失败信息：指定 `id` 解读该条隔离记录（给 repair 建议）；默认解读最近一次失败日志，无日志则解读隔离台账；`--file`/stdin 读任意日志（需 `DSH_SAFE_AI_KEY`） |
-| `dsh-safe repair [id] [--profile <名>] [--to <版本>] [-y] [--dry-run]` | 重装/升级被隔离的插件并自动恢复（限重装/升级可能修复的失败：包解析失败、导出版本不匹配等；经 `dsh plugin` 的 pnpm 通道安装）；重复挂载类支持自动去重（交互选择保留哪个来源，从 bundles 移除冗余） |
+| `dsh-safe -r [dsh 参数…]` | 先修复全部可修复的隔离记录，再按包装模式启动（`--repair` 等价；与 `-u` 对称） |
+| `dsh-safe repair [id] [--all] [--profile <名>] [--to <版本>] [-y] [--dry-run]` | 重装/升级被隔离的插件并自动恢复（限重装/升级可能修复的失败：包解析失败、导出版本不匹配等；经 `dsh plugin` 的 pnpm 通道安装）；重复挂载类支持自动去重（交互选择保留哪个来源，从 bundles 移除冗余） |
 | `dsh-safe help`（`-h` / `--help`） | 显示帮助 |
 | `dsh-safe --version`（`-V`） | 显示版本 |
 

package/lib/cli.js

@@ -11,7 +11,7 @@ import { createRequire } from 'node:module'
 import { loadLedger, restoreQuarantine } from './quarantine.js'
 import { runWrapped } from './wrap.js'
 import { cmdUpdate, cmdUpdateAndBoot, maybeNotifySelfUpdate } from './update.js'
-import { cmdRepair } from './repair.js'
+import { cmdRepair, cmdRepairAndBoot } from './repair.js'
 import { printDoctor } from './doctor.js'
 import { cmdExplain } from './ai.js'
 import { t } from './i18n.js'
@@ -142,6 +142,7 @@ export async function main(argv) {
     return 0
   }
   if (cmd === '-u' || cmd === '--update') return cmdUpdateAndBoot(argv.slice(1), { boot: runWrapperMode })
+  if (cmd === '-r' || cmd === '--repair') return cmdRepairAndBoot(argv.slice(1), { boot: runWrapperMode })
 
   // 包装模式：剥掉 dsh-safe 自己的旗标（必须出现在第一个位置参数之前），
   // 其余原样转发给 dsh。

package/lib/i18n.js

@@ -25,8 +25,9 @@ const ZH = {
   dsh-safe update [-y] [--to <版本>] [--self] [--no-restore] [--no-verify] [--pm npm|pnpm]
                                     升级 dsh 与 dsh-safe 自身，并自动恢复被隔离的插件
   dsh-safe explain [id] [--profile <名> | --file <路径>]  用 AI 解读：最近失败日志 / 隔离台账 / 任意日志
-  dsh-safe repair [id] [--profile <名>] [--to <版本>] [-y] [--dry-run]
-                                    重装/升级被隔离的插件并自动恢复（限包解析/导出不匹配类；省略 id 时只有一条记录则直接修）
+  dsh-safe repair [id] [--all] [--profile <名>] [--to <版本>] [-y] [--dry-run]
+                                    重装/升级被隔离的插件并自动恢复（--all 批量；限可自动修复类；省略 id 时只有一条记录则直接修）
+  dsh-safe -r [dsh 参数…]            先修复全部可修复的隔离记录，再启动（--repair 等价）
   dsh-safe help                     显示本帮助
   dsh-safe --version                显示版本
 
@@ -142,6 +143,11 @@ const ZH = {
   repairDedupePlan: '[dsh-safe] 修复方案：保留 {keep} 的挂载，从 bundles 移除 {remove}，并摘除 {id} 的禁用行',
   repairDedupeNoManifest: '[dsh-safe] profile 清单中没有可编辑的 bundles 数组，请手动处理。',
   repairDedupeDone: '[dsh-safe] 去重完成：已从 bundles 移除 {removed}；{keep} 的挂载保留、禁用行已摘除。跑 dsh-safe <启动命令> 验证。',
+  repairAllConflict: '[dsh-safe] --all 与 <id> 不能同时使用。',
+  repairUnknownArg: '[dsh-safe] repair 无法识别的参数: {arg}',
+  repairBatchPlan: '[dsh-safe] 将修复 {count} 条隔离记录: {ids}',
+  repairBatchSkip: '[dsh-safe] 跳过 {count} 条（不支持自动修复）: {ids}',
+  repairBatchDone: '[dsh-safe] 批量修复完成：成功 {repaired} 条，失败 {failed} 条。',
   repairInstallFailed: '[dsh-safe] 插件安装失败（退出码 {code}），隔离状态保持不变。',
   repairDone: '[dsh-safe] 修复完成：跑 dsh-safe <启动命令> 验证；若仍失败会被自动重新隔离。',
 }
@@ -166,8 +172,9 @@ Usage:
   dsh-safe update [-y] [--to <ver>] [--self] [--no-restore] [--no-verify] [--pm npm|pnpm]
                                     upgrade dsh and dsh-safe itself, auto-restore quarantined plugins
   dsh-safe explain [id] [--profile <name> | --file <path>]  interpret with AI: last failure log / ledger / any log
-  dsh-safe repair [id] [--profile <name>] [--to <ver>] [-y] [--dry-run]
-                                    reinstall/upgrade a quarantined plugin and auto-restore it (resolution/export-mismatch failures; omit id when there is exactly one record)
+  dsh-safe repair [id] [--all] [--profile <name>] [--to <ver>] [-y] [--dry-run]
+                                    reinstall/upgrade quarantined plugins and auto-restore (--all for batch; repairable failures only; omit id when there is exactly one record)
+  dsh-safe -r [dsh args…]            repair all repairable quarantined plugins, then boot (--repair alias)
   dsh-safe help                     show this help
   dsh-safe --version                show version
 
@@ -286,6 +293,11 @@ Notes:
   repairDedupePlan: '[dsh-safe] fix plan: keep {keep} mounted, remove {remove} from bundles, and drop the disabled row for {id}',
   repairDedupeNoManifest: '[dsh-safe] the profile manifest has no editable bundles array; handle it manually.',
   repairDedupeDone: '[dsh-safe] dedupe finished: removed {removed} from bundles; {keep} stays mounted and the disabled row was dropped. Run dsh-safe <boot command> to verify.',
+  repairAllConflict: '[dsh-safe] --all and <id> are mutually exclusive.',
+  repairUnknownArg: '[dsh-safe] unrecognized argument for repair: {arg}',
+  repairBatchPlan: '[dsh-safe] repairing {count} quarantine record(s): {ids}',
+  repairBatchSkip: '[dsh-safe] skipping {count} (not auto-repairable): {ids}',
+  repairBatchDone: '[dsh-safe] batch repair finished: {repaired} succeeded, {failed} failed.',
   repairInstallFailed: '[dsh-safe] plugin install failed (exit code {code}); quarantine state left unchanged.',
   repairDone: '[dsh-safe] repair finished: run dsh-safe <boot command> to verify; a still-broken plugin will be auto-quarantined again.',
 }

package/lib/repair.js

@@ -1,14 +1,25 @@
 /**
- * @hyzyn/dsh-safe — `dsh-safe repair <id>`：半自动修复被隔离的插件。
+ * @hyzyn/dsh-safe — `dsh-safe repair` 与 `dsh-safe -r`：修复被隔离的插件。
  *
- * 只处理"模块解析失败"类（Cannot find package / could not be resolved /
- * ERR_MODULE_NOT_FOUND）——这类问题重装/升级插件包即可修复。其它类型
- * （apply 抛错、pending 服务等待等）属于代码或配置问题，明确拒接。
+ * repair 可修复的失败特征：问题出在"包的安装状态或版本适配"上，重装/升级
+ * 插件包可能修复——
+ *   - 模块解析失败：包缺失/损坏/未安装 → 重装即愈；
+ *   - ESM 导出不匹配（does not provide an [export|import binding]）：插件与
+ *     当前 dsh API 版本不兼容，升级插件到适配版本可能修复（真实案例：
+ *     describe-image 隔离于 dsh-settings 导出变更）。修复失败不恢复、无损。
+ * 注意：台账 reason 经 summarizeLine 截断过（160 字符），关键短语可能被
+ * "…" 切断，因此导出不匹配的特征只匹配到 "does not provide an" 为止。
  *
- * 流程：台账定位条目 → 类别门禁 → 展示计划 → 确认 → 经 `dsh plugin add`
- * （dsh 官方的 pnpm 转发通道）安装 → 自动摘除隔离行。不内置启动：装好后
- * 由用户跑 dsh-safe 验证，再失败会自动回到隔离管线。安装失败则保持隔离
- * 状态不变，退出码透传。
+ * duplicate（同一 id 被多个 bundle 挂载）是配置层问题，重装无意义——但
+ * 支持自动去重：从 profile 清单的 bundles 移除一个来源（交互选择保留哪个，
+ * -y 保留先声明者），并摘除无效的禁用行。include 子文件里的重复不在
+ * bundle 层对照表内，自动去重帮不上，给手动指引。
+ *
+ * 安装路径修复完成后会复查该 id 的挂载来源：修复的插件若同时被聚合包等
+ * 其它 bundle 挂载，恢复后下次启动会 duplicate——自动去重防复发。
+ *
+ * `--all` 批量修复台账里全部可修复记录；`-r/--repair` = 批量修复 + 启动
+ * （与 -u 对称：位置参数全部是 dsh 启动参数）。
  */
 import { spawnSync } from 'node:child_process'
 import { createInterface } from 'node:readline/promises'
@@ -22,25 +33,190 @@ import { t } from './i18n.js'
 const err = (line) => process.stderr.write(`${line}\n`)
 const out = (line) => process.stdout.write(`${line}\n`)
 
-/**
- * repair 可修复的失败特征：问题出在"包的安装状态或版本适配"上，重装/升级
- * 插件包可能修复——
- *   - 模块解析失败：包缺失/损坏/未安装 → 重装即愈；
- *   - ESM 导出不匹配（does not provide an [export|import binding]）：插件与
- *     当前 dsh API 版本不兼容，升级插件到适配版本可能修复（真实案例：
- *     describe-image 隔离于 dsh-settings 导出变更）。修复失败不恢复、无损。
- * 注意：台账 reason 经 summarizeLine 截断过（160 字符），关键短语可能被
- * "…" 切断，因此导出不匹配的特征只匹配到 "does not provide an" 为止。
- */
 const REPAIRABLE_RE =
   /Cannot find package|could not be resolved|ERR_MODULE_NOT_FOUND|does not provide an( (?:export|import binding))?/i
+const DUPLICATE_RE = /duplicate loader entry id/i
+
+const isRepairable = (reason) => REPAIRABLE_RE.test(reason ?? '') || DUPLICATE_RE.test(reason ?? '')
+
+const readJsonIfExists = (path) => {
+  const raw = readIfExists(path)
+  if (raw === undefined) return undefined
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+}
+
+/** 该 id 的 bundle 挂载来源（profile/home 层是 override，不算挂载来源）。 */
+function bundleMountSources(known, id) {
+  return [
+    ...new Set(
+      known.rows.filter((r) => r.id === id && r.source !== 'profile' && r.source !== 'home').map((r) => r.source),
+    ),
+  ]
+}
+
+/** 从 profile 清单的 bundles 数组移除指定来源；没有变化返回 false。 */
+function removeFromManifestBundles(profile, removeNames) {
+  const manifestPath = profileManifestPath(profile)
+  const manifest = readJsonIfExists(manifestPath)
+  const current = manifest?.dsh?.profile?.bundles
+  if (!Array.isArray(current)) return false
+  const next = current.filter((b) => !removeNames.includes(b))
+  if (next.length === current.length) return false
+  manifest.dsh.profile.bundles = next
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+  return true
+}
+
+function askConfirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr })
+  return rl.question(question).then(
+    (answer) => {
+      rl.close()
+      const a = answer.trim().toLowerCase()
+      return a === 'y' || a === 'yes'
+    },
+    () => {
+      rl.close()
+      return false
+    },
+  )
+}
+
+/**
+ * 对单条隔离记录执行修复动作。安装确认由调用方完成（单条路径确认、批量
+ * 路径整体确认后以 yes: true 调用）。
+ * @returns {Promise<{ code: number, outcome: 'repaired'|'deduped'|'skipped'|'failed' }>}
+ */
+async function repairEntry({ profile, entry, to = undefined, yes = false, tty = true, dryRun = false, spawn = spawnSync, log = err, write = out }) {
+  const id = entry.id
+
+  // duplicate：自动去重（多 bundle 来源），来源不足给手动指引
+  if (DUPLICATE_RE.test(entry.reason ?? '')) {
+    const sources = bundleMountSources(collectKnownRows(profile), id)
+    if (sources.length < 2) {
+      log(t('repairDuplicate'))
+      return { code: 1, outcome: 'skipped' }
+    }
+    const manifest = readJsonIfExists(profileManifestPath(profile))
+    const declared = manifest?.dsh?.profile?.bundles
+    const ordered = Array.isArray(declared)
+      ? [...sources].sort(
+          (a, b) =>
+            (declared.indexOf(a) < 0 ? 999 : declared.indexOf(a)) - (declared.indexOf(b) < 0 ? 999 : declared.indexOf(b)),
+        )
+      : sources
+    let keep = ordered[0]
+    if (!yes && !dryRun) {
+      if (!tty) {
+        log(t('updateNonInteractive'))
+        return { code: 1, outcome: 'failed' }
+      }
+      const rl = createInterface({ input: process.stdin, output: process.stderr })
+      log(t('repairDedupePick', { id }))
+      ordered.forEach((b, i) => log(`${i + 1}. ${b}${i === 0 ? t('repairDedupeDefault') : ''}`))
+      const answer = await rl.question(t('repairDedupeChoose'))
+      rl.close()
+      const pick = Math.min(Math.max(parseInt(answer, 10) || 1, 1), ordered.length)
+      keep = ordered[pick - 1]
+    }
+    const remove = ordered.filter((b) => b !== keep)
+    log(t('repairDedupePlan', { keep, remove: remove.join(', '), id }))
+    if (dryRun) {
+      log(t('dryRunNotice'))
+      return { code: 0, outcome: 'deduped' }
+    }
+    if (!removeFromManifestBundles(profile, remove)) {
+      log(t('repairDedupeNoManifest'))
+      return { code: 1, outcome: 'failed' }
+    }
+    const { restored } = restoreQuarantine(profile, [id], false)
+    if (restored.length) {
+      const e = restored[0]
+      write(`[dsh-safe] ${t('restored')} ${e.name ?? e.id} (id: ${e.id})`)
+    }
+    log(t('repairDedupeDone', { removed: remove.join(', '), keep }))
+    log(t('repairDone'))
+    return { code: 0, outcome: 'deduped' }
+  }
+
+  // 其它非包类失败：拒接并给针对性指引
+  if (!REPAIRABLE_RE.test(entry.reason ?? '')) {
+    log(t('repairUnsupported', { reason: summarizeLine(entry.reason) }))
+    return { code: 1, outcome: 'skipped' }
+  }
+
+  // 安装 + 恢复
+  const spec = `${entry.name ?? entry.id}@${to ?? 'latest'}`
+  const spawnTarget = resolveDshSpawnTarget('dsh')
+  const commandDesc = `dsh plugin --profile ${profile} add ${spec}`
+  log(t('repairPlan', { profile, name: entry.name ?? entry.id, command: commandDesc }))
+  if (dryRun) {
+    log(t('dryRunNotice'))
+    return { code: 0, outcome: 'repaired' }
+  }
+
+  const { status } = spawn(spawnTarget.file, [...spawnTarget.prefix, 'plugin', '--profile', profile, 'add', spec], {
+    stdio: 'inherit',
+    shell: spawnTarget.shell,
+    env: process.env,
+  })
+  if (status !== 0) {
+    log(t('repairInstallFailed', { code: status ?? '?' }))
+    return { code: status ?? 1, outcome: 'failed' }
+  }
+
+  const { restored } = restoreQuarantine(profile, [id], false)
+  if (!restored.length) {
+    log(t('noMatching'))
+  } else {
+    const e = restored[0]
+    write(`[dsh-safe] ${t('restored')} ${e.name ?? e.id} (id: ${e.id})`)
+  }
+
+  // 防复发：修复的插件若同时被多个 bundle 挂载（如聚合包已内置同一插件），
+  // 恢复后下次启动会 duplicate——自动去重（交互选择保留来源，-y 保留先声明者）
+  const knownAfter = collectKnownRows(profile)
+  const sources = bundleMountSources(knownAfter, id)
+  if (sources.length >= 2) {
+    const manifest = readJsonIfExists(profileManifestPath(profile))
+    const declared = manifest?.dsh?.profile?.bundles
+    const ordered = Array.isArray(declared)
+      ? [...sources].sort(
+          (a, b) =>
+            (declared.indexOf(a) < 0 ? 999 : declared.indexOf(a)) - (declared.indexOf(b) < 0 ? 999 : declared.indexOf(b)),
+        )
+      : sources
+    let keep = ordered[0]
+    if (!yes) {
+      const rl = createInterface({ input: process.stdin, output: process.stderr })
+      log(t('repairDedupePick', { id }))
+      ordered.forEach((b, i) => log(`${i + 1}. ${b}${i === 0 ? t('repairDedupeDefault') : ''}`))
+      const answer = await rl.question(t('repairDedupeChoose'))
+      rl.close()
+      const pick = Math.min(Math.max(parseInt(answer, 10) || 1, 1), ordered.length)
+      keep = ordered[pick - 1]
+    }
+    const removed = ordered.filter((b) => b !== keep)
+    if (removeFromManifestBundles(profile, removed)) {
+      log(t('repairDedupeDone', { removed: removed.join(', '), keep }))
+    }
+  }
+
+  log(t('repairDone'))
+  return { code: 0, outcome: 'repaired' }
+}
 
 function parseRepairArgs(args) {
-  const opts = { id: undefined, profile: undefined, to: undefined, yes: false, dryRun: false }
+  const opts = { id: undefined, all: false, profile: undefined, to: undefined, yes: false, dryRun: false }
   for (let i = 0; i < args.length; i++) {
     const a = args[i]
     if (a === '-y' || a === '--yes') opts.yes = true
     else if (a === '--dry-run') opts.dryRun = true
+    else if (a === '--all') opts.all = true
     else if (a === '--profile') {
       const v = args[++i]
       if (v === undefined) return { error: { key: 'updateUnknownFlag', params: { arg: '--profile' } } }
@@ -52,19 +228,74 @@ function parseRepairArgs(args) {
       opts.to = v
     } else if (a.startsWith('--to=')) opts.to = a.slice('--to='.length)
     else if (!a.startsWith('-') && opts.id === undefined) opts.id = a
-    else return { error: { key: 'updateUnknownFlag', params: { arg: a } } }
+    else return { error: { key: 'repairUnknownArg', params: { arg: a } } }
   }
+  if (opts.all && opts.id !== undefined) return { error: { key: 'repairAllConflict' } }
   if (opts.to !== undefined && !/^[\w.+-]+$/.test(opts.to)) return { error: { key: 'updateToInvalid' } }
   return { opts }
 }
 
+/** 台账定位：按 id / --all / 菜单三种形态收集修复目标。 */
+function collectTargets(opts, ledger) {
+  const matches = []
+  for (const [profile, entries] of Object.entries(ledger.profiles)) {
+    if (opts.profile && profile !== opts.profile) continue
+    for (const entry of entries ?? []) {
+      if (opts.all || opts.id === undefined || entry.id === opts.id) matches.push({ profile, entry })
+    }
+  }
+  return matches
+}
+
+/** 批量修复：一次确认，逐条执行，汇总结果。返回失败的条数。 */
+async function repairBatch(targets, { to = undefined, yes = false, dryRun = false, spawn = spawnSync, log = err, write = out }) {
+  const repairable = targets.filter((t) => isRepairable(t.entry.reason))
+  const unsupported = targets.filter((t) => !repairable.includes(t))
+  log(
+    t('repairBatchPlan', {
+      count: repairable.length,
+      ids: repairable.map((t) => t.entry.id).join(', ') || '-',
+    }),
+  )
+  if (unsupported.length) {
+    log(t('repairBatchSkip', { count: unsupported.length, ids: unsupported.map((t) => t.entry.id).join(', ') }))
+  }
+  if (dryRun) {
+    for (const t of repairable) {
+      await repairEntry({ profile: t.profile, entry: t.entry, to: to, yes: true, tty: true, dryRun: true, spawn, log, write })
+    }
+    log(t('dryRunNotice'))
+    return { failed: 0 }
+  }
+  if (!yes) {
+    if (!process.stdin.isTTY) {
+      log(t('updateNonInteractive'))
+      return { failed: targets.length }
+    }
+    const ok = await askConfirm(t('updateConfirm'))
+    if (!ok) {
+      log(t('updateAborted'))
+      return { failed: 0 }
+    }
+  }
+  let repaired = 0
+  let failed = 0
+  for (const t of repairable) {
+    const { code } = await repairEntry({ profile: t.profile, entry: t.entry, to: to, yes: true, tty: true, spawn, log, write })
+    if (code === 0) repaired++
+    else failed++
+  }
+  log(t('repairBatchDone', { repaired, failed }))
+  return { failed }
+}
+
 /**
  * @param {string[]} args
  * @param {{
  *   spawn?: typeof spawnSync,
  *   log?: (line: string) => void,
  *   write?: (line: string) => void,
- * }} [hooks] spawn/log/write 可注入（测试）
+ * }} [hooks]
  * @returns {Promise<number>} 退出码
  */
 export async function cmdRepair(args, { spawn = spawnSync, log = err, write = out } = {}) {
@@ -78,17 +309,20 @@ export async function cmdRepair(args, { spawn = spawnSync, log = err, write = ou
     return 2
   }
 
-  // 台账定位：省略 --profile 时跨 profile 搜索；省略 id 时——
-  //   恰好一条隔离记录 → 直接修它（最常见情况）；
-  //   多条 → 列出清单让用户挑（标记哪些可自动修复）。
   const ledger = loadLedger()
-  let matches = []
-  for (const [profile, entries] of Object.entries(ledger.profiles)) {
-    if (opts.profile && profile !== opts.profile) continue
-    for (const entry of entries ?? []) {
-      if (opts.id === undefined || entry.id === opts.id) matches.push({ profile, entry })
+  const matches = collectTargets(opts, ledger)
+
+  // --all：批量修复（一次确认，默认策略）
+  if (opts.all) {
+    if (!matches.length) {
+      log(t('noRecords'))
+      return 0
     }
+    const { failed } = await repairBatch(matches, { to: opts.to, yes: opts.yes, dryRun: opts.dryRun, spawn, log, write })
+    return failed ? 1 : 0
   }
+
+  // 无 id：单条直接修；多条列菜单让用户挑
   if (opts.id === undefined) {
     if (!matches.length) {
       log(t('noRecords'))
@@ -97,13 +331,39 @@ export async function cmdRepair(args, { spawn = spawnSync, log = err, write = ou
     if (matches.length > 1) {
       log(t('repairPickOne', { count: matches.length }))
       for (const m of matches) {
-        const repairable = REPAIRABLE_RE.test(m.entry.reason ?? '')
+        const repairable = isRepairable(m.entry.reason)
         log(`  - ${m.entry.id}（${m.entry.name ?? '-'}）${repairable ? '' : t('repairNotSupportedTag')}`)
       }
       return 0
     }
     opts.id = matches[0].entry.id
   }
+
+  if (!matches.length) {
+    // duplicate 类失败不会产生台账条目（0.12.1 起的设计）——台账查无记录时，
+    // 按挂载来源直接支持去重：该 id 被 ≥2 个 bundle 挂载即视为重复挂载目标。
+    const candidates = opts.profile
+      ? [opts.profile]
+      : (() => {
+          try {
+            return readdirSync(join(dshHome(), 'profiles'), { withFileTypes: true })
+              .filter((e) => e.isDirectory())
+              .map((e) => e.name)
+          } catch {
+            return []
+          }
+        })()
+    for (const p of candidates) {
+      if (bundleMountSources(collectKnownRows(p), opts.id).length >= 2) {
+        const rows = collectKnownRows(p).rows.filter((r) => r.id === opts.id)
+        matches.push({
+          profile: p,
+          entry: { id: opts.id, name: rows[0]?.name ?? null, reason: 'duplicate loader entry id' },
+        })
+        break
+      }
+    }
+  }
   if (!matches.length) {
     log(t('repairEntryMissing', { id: opts.id }))
     return 1
@@ -113,169 +373,73 @@ export async function cmdRepair(args, { spawn = spawnSync, log = err, write = ou
     return 2
   }
   const { profile, entry } = matches[0]
-  const name = entry.name ?? entry.id
-
-  // 类别门禁：重复挂载是配置层问题（同一 id 多处挂载），重装无意义——
-  // 但可以自动去重：从 profile 的 bundles 移除一个挂载来源
-  if (/duplicate loader entry id/i.test(entry.reason ?? '')) {
-    return dedupeForDuplicate({ id: opts.id, profile, opts, spawn, log, write })
-  }
-  // 只修"包的安装状态/版本适配"类
-  if (!REPAIRABLE_RE.test(entry.reason ?? '')) {
-    log(t('repairUnsupported', { reason: summarizeLine(entry.reason) }))
-    return 1
-  }
 
-  const target = opts.to ?? 'latest'
-  const spec = `${name}@${target}`
-  const spawnTarget = resolveDshSpawnTarget('dsh')
-  const commandDesc = `dsh plugin --profile ${profile} add ${spec}`
-  log(t('repairPlan', { profile, name, command: commandDesc }))
-  if (opts.dryRun) {
-    log(t('dryRunNotice'))
-    return 0
-  }
-  if (!opts.yes) {
+  // 单条路径：安装前确认（dry-run 免确认）
+  if (!opts.dryRun && !opts.yes) {
     if (!process.stdin.isTTY) {
       log(t('updateNonInteractive'))
       return 1
     }
-    const ok = await askConfirm(t('updateConfirm'))
-    if (!ok) {
+    if (!(await askConfirm(t('updateConfirm')))) {
       log(t('updateAborted'))
       return 0
     }
   }
-
-  const { status } = spawn(spawnTarget.file, [...spawnTarget.prefix, 'plugin', '--profile', profile, 'add', spec], {
-    stdio: 'inherit',
-    shell: spawnTarget.shell,
-    env: process.env,
-  })
-  if (status !== 0) {
-    log(t('repairInstallFailed', { code: status ?? '?' }))
-    return status ?? 1
-  }
-
-  const { restored } = restoreQuarantine(profile, [opts.id], false)
-  if (!restored.length) {
-    log(t('noMatching'))
-  } else {
-    const e = restored[0]
-    write(`[dsh-safe] ${t('restored')} ${e.name ?? e.id} (id: ${e.id})`)
-  }
-  log(t('repairDone'))
-  return 0
-}
-
-function askConfirm(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr })
-  return rl.question(question).then(
-    (answer) => {
-      rl.close()
-      const a = answer.trim().toLowerCase()
-      return a === 'y' || a === 'yes'
-    },
-    () => {
-      rl.close()
-      return false
-    },
-  )
-}
-
-const readJsonIfExists = (path) => {
-  const raw = readIfExists(path)
-  if (raw === undefined) return undefined
-  try {
-    return JSON.parse(raw)
-  } catch {
-    return undefined
-  }
+  const { code } = await repairEntry({ profile, entry, to: opts.to, yes: opts.yes || !opts.dryRun ? true : false, tty: true, dryRun: opts.dryRun, spawn, log, write })
+  return code
 }
 
 /**
- * duplicate 类的自动去重：同一 id 被多个 bundle 挂载时，从 profile 清单的
- * bundles 数组移除一个来源（保留的来源继续提供插件），并摘除无效的禁用行。
- * 编辑的是用户自己的 profile 清单（与 cordis.patch.yml 托管区块同信任级别），
- * 有确认环节、可逆（bundles 加回来即可）。
+ * `-r/--repair [dsh 参数…]`：批量修复全部可修复的隔离记录，再按包装模式
+ * 启动（与 -u 对称：位置参数全部是 dsh 启动参数）。
+ * @param {string[]} args
+ * @param {{
+ *   spawn?: typeof spawnSync,
+ *   boot?: (args: string[]) => Promise<number>,
+ *   log?: (line: string) => void,
+ *   write?: (line: string) => void,
+ *   isTTY?: boolean,
+ *   readStdin?: never,
+ * }} [hooks]
+ * @returns {Promise<number>} 退出码
  */
-async function dedupeForDuplicate({ id, profile, opts, spawn, log, write }) {
-  const known = collectKnownRows(profile)
-  // 挂载来源只统计 bundle 层；profile/home 层的同 id 是 override，不是重复来源
-  const sources = new Set()
-  for (const row of known.rows) {
-    if (row.id !== id) continue
-    if (row.source === 'profile' || row.source === 'home') continue
-    sources.add(row.source)
-  }
-  const sourceList = [...sources]
-  if (sourceList.length < 2) {
-    // 重复不在 bundle 层（可能在 include 文件或用户层），自动去重帮不上，给指引
-    log(t('repairDuplicate'))
-    return 1
-  }
-
-  const manifestPath = profileManifestPath(profile)
-  const manifest = readJsonIfExists(manifestPath)
-  const bundles = manifest?.dsh?.profile?.bundles
-  if (!Array.isArray(bundles)) {
-    log(t('repairDedupeNoManifest'))
-    return 1
-  }
-  // 按 bundles 数组声明顺序排序：先声明的是既有来源，缺省保留
-  const ordered = [...sourceList].sort((a, b) => {
-    const ia = bundles.indexOf(a)
-    const ib = bundles.indexOf(b)
-    return (ia < 0 ? 999 : ia) - (ib < 0 ? 999 : ib)
-  })
-
-  const keepDefault = ordered[0]
-  const planLine = () => log(t('repairDedupePlan', { keep: keep, remove: remove.join(', '), id }))
-  if (opts.dryRun) {
-    log(t('repairDedupePlan', { keep: keepDefault, remove: ordered.slice(1).join(', '), id }))
-    log(t('dryRunNotice'))
+export async function cmdRepairAndBoot(args, { boot, spawn = spawnSync, log = err, write = out, isTTY = process.stdin.isTTY } = {}) {
+  if (args.includes('-h') || args.includes('--help')) {
+    out(t('helpText', {}))
     return 0
   }
-
-  let keep
-  if (!opts.yes && !process.stdin.isTTY) {
-    log(t('updateNonInteractive'))
-    return 1
+  // 位置参数全部是 dsh 启动参数（修全部可修复记录）；前缀旗标为 repair 选项
+  const opts = { profile: undefined, to: undefined, yes: false, dryRun: false }
+  let i = 0
+  for (; i < args.length; i++) {
+    const a = args[i]
+    if (a === '-y' || a === '--yes') opts.yes = true
+    else if (a === '--dry-run') opts.dryRun = true
+    else if (a === '--profile' && args[i + 1] !== undefined) opts.profile = args[++i]
+    else if (a.startsWith('--profile=')) opts.profile = a.slice('--profile='.length)
+    else if (a === '--to' && args[i + 1] !== undefined) opts.to = args[++i]
+    else if (a.startsWith('--to=')) opts.to = a.slice('--to='.length)
+    else break
   }
-  if (opts.yes) {
-    keep = keepDefault // -y：保留先声明的来源
-  } else {
-    const rl = createInterface({ input: process.stdin, output: process.stderr })
-    log(t('repairDedupePick', { id }))
-    ordered.forEach((b, i) => log(`${i + 1}. ${b}${i === 0 ? t('repairDedupeDefault') : ''}`))
-    const answer = await rl.question(t('repairDedupeChoose'))
-    rl.close()
-    const pick = Math.min(Math.max(parseInt(answer, 10) || 1, 1), ordered.length)
-    keep = ordered[pick - 1]
+  if (opts.to !== undefined && !/^[\w.+-]+$/.test(opts.to)) {
+    log(t('updateToInvalid'))
+    return 2
   }
-  const remove = ordered.filter((b) => b !== keep)
-  planLine()
+  const bootArgs = args.slice(i)
 
-  const fresh = readJsonIfExists(manifestPath)
-  const current = fresh?.dsh?.profile?.bundles
-  if (!Array.isArray(current)) {
-    log(t('repairDedupeNoManifest'))
-    return 1
+  const ledger = loadLedger()
+  const targets = []
+  for (const [profile, entries] of Object.entries(ledger.profiles)) {
+    if (opts.profile && profile !== opts.profile) continue
+    for (const entry of entries ?? []) targets.push({ profile, entry })
   }
-  const next = current.filter((b) => !remove.includes(b))
-  if (next.length === current.length) {
-    log(t('repairDedupeNoManifest'))
-    return 1
+  if (!targets.length) {
+    log(t('noRecords'))
+    if (bootArgs.length) return boot(bootArgs)
+    return 0
   }
-  fresh.dsh.profile.bundles = next
-  writeFileSync(manifestPath, `${JSON.stringify(fresh, null, 2)}\n`)
 
-  const { restored } = restoreQuarantine(profile, [id], false)
-  if (restored.length) {
-    const e = restored[0]
-    write(`[dsh-safe] ${t('restored')} ${e.name ?? e.id} (id: ${e.id})`)
-  }
-  log(t('repairDedupeDone', { removed: remove.join(', '), keep }))
-  log(t('repairDone'))
-  return 0
+  const { failed } = await repairBatch(targets, { to: opts.to, yes: opts.yes, dryRun: opts.dryRun, spawn, log, write })
+  if (bootArgs.length) return boot(bootArgs)
+  return failed ? 1 : 0
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyzyn/dsh-safe",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "dsh 启动保险丝：社区插件不兼容导致 dsh 启动失败时，自动禁用坏插件并重试",
   "type": "module",
   "license": "MIT",