@hyzyn/dsh-safe 0.1.0 → 0.3.0

package/README.en.md

@@ -0,0 +1,94 @@
+# dsh-safe · Startup Fuse for dsh
+
+[中文](./README.md) | English
+
+When a community plugin of DeepSeek Harness (DSH) is incompatible with the dsh runtime, `dsh web` **fails to boot entirely** — the loader flattens all patch layers into a single load tree, so if any plugin fails to import, throws inside `apply`, or times out waiting for an injected service, the boot audit rejects the whole tree and the process exits. The only remedy was manually editing `cordis.patch.yml` to disable the broken plugin.
+
+**dsh-safe automates that manual step**: it wraps `dsh`, identifies the offending plugin from the startup error, sets the matching row to `disabled: true` in the profile patch (recording it in a quarantine ledger), and retries automatically. A broken plugin only breaks itself; dsh boots as usual.
+
+## Installation
+
+```bash
+npm install -g @hyzyn/dsh-safe
+```
+
+Requires Node >= 20 and a local `dsh` command. Zero runtime dependencies.
+
+## Quick Start
+
+Just replace `dsh` with `dsh-safe`:
+
+```bash
+dsh-safe web          # same as dsh web, with auto-quarantine
+dsh-safe --profile tui --patch ./extra.yml
+```
+
+Sample output (shown with a zh locale: a broken plugin is quarantined, then startup retries):
+
+```
+Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broken (@smoke/broken-impl): Cannot find package '@smoke/broken-impl' ...
+[dsh-safe] 已禁用 @smoke/broken-impl (id: smoke-broken) → /Users/me/.dsh/profiles/web/cordis.patch.yml
+           原因: Error: failed to import loader entry smoke-broken (@smoke/broken-impl): Cannot find package …
+[dsh-safe] 重试启动…
+```
+
+## Commands
+
+```
+dsh-safe <dsh args…>              wrap and run dsh
+dsh-safe -u [dsh args…]           upgrade dsh first (skip if latest), then boot
+dsh-safe list [--profile <name>]  show quarantined plugins (defaults to all profiles)
+dsh-safe restore --profile <name> (--id <id> | --all) [--dry-run]
+                                  re-enable auto-disabled plugins (after a fixed plugin upgrade)
+dsh-safe update [-y] [--to <ver>] [--self] [--no-restore] [--pm npm|pnpm]
+                                  upgrade dsh and dsh-safe itself, auto-restore quarantined plugins
+dsh-safe help
+```
+
+Wrapper-mode options (must come before the profile / subcommand):
+
+| Option | Description |
+| --- | --- |
+| `--dry-run` | Parse and report only; no files are modified |
+| `--max-retries <n>` | Max startup retries after an auto-quarantine (default 2; `0` means pass through without quarantining) |
+| `--allow-first-party` | Allow auto-disabling first-party `@deepseek-ai/*` plugins (skipped by default; handle manually) |
+
+Upgrading dsh: `dsh-safe update` auto-detects the dsh package name and install method (npm / pnpm global installs), compares against the latest version and runs the upgrade for you, then automatically restores all quarantined plugins — any still incompatible under the new dsh will be auto-quarantined again on the next start. `--to <version>` pins a target version (also how you roll back), `--no-restore` skips the restore, `-y` skips the confirmation.
+
+update / -u also checks dsh-safe's own version and upgrades whichever is outdated (single install command); `--self` updates dsh-safe only. Additionally, every wrapped boot checks for a new dsh-safe version at most once a day and prints a one-line notice (fully silent on check failure); disable with `DSH_SAFE_NO_UPDATE_CHECK=1`.
+
+For daily use, just make `dsh-safe -u web` your start command: boots immediately when dsh is already latest (one version check), upgrades + restores first when an update is available, and only warns (still boots) if the update check itself fails. `-u` accepts update options (e.g. `-u -y web`) and wrapper flags (e.g. `-u --max-retries 0 web`).
+
+Messages follow `LC_ALL` / `LC_MESSAGES` / `LANG` / `LANGUAGE` (`zh*` → Chinese, otherwise English); force with `DSH_SAFE_LANG=zh|en`.
+
+## How It Works
+
+1. **Failure identification**: when dsh fails to start, stderr carries four kinds of signatures (`plugin(s) failed to load: …`, `N entries did not activate` with per-row failures, `failed to apply/import loader entry <id> (<name>)`, and outer stack frames `…#<entryId>`). dsh-safe extracts the broken plugin's package name and row id from them.
+2. **Match against real rows**: it scans the profile patch, `$DSH_HOME/cordis.patch.yml` (home layer) and each bundle's patch to build a "row id ↔ plugin package" mapping; only rows that actually exist are disabled, avoiding collateral damage.
+3. **Managed block writing**: it appends a marker-commented managed block at the end of the matching patch file (same convention as `dsh-mcp-config managed`), setting matched rows to `disabled: true`. Existing user content and comments are preserved; a fresh profile's `[]` template is correctly replaced with a block sequence.
+4. **Ledger & restore**: quarantine records live in `$DSH_HOME/dsh-safe/quarantine.json`. Once a plugin upgrade fixes the issue, `dsh-safe restore --profile web --all` removes the managed block and re-mounts the plugin (hot-applied for profiles with `patchReload: live`).
+
+## Safety Boundaries
+
+- **First-party protection**: rows of `@deepseek-ai/*` plugins are skipped by default (disabling plugins like `dsh-web-app` would strip dsh of its core capabilities); pass `--allow-first-party` to touch them.
+- **Startup-phase failures only**: module resolution failures / `apply` throws / timed-out service injection. Uncaught runtime exceptions are still handled by dsh's own fail-loud policy and are out of scope for boot quarantine.
+- **Auditable**: every write records the reason and a timestamp; `--dry-run` previews which plugins would be disabled.
+- **Faithful pass-through**: when no broken plugin can be identified, the retry limit is exceeded, or for `dsh plugin` (pnpm forwarding), the exit code is passed through untouched and no files are modified.
+
+## Known Limitations
+
+- If the patch file itself fails YAML parsing (e.g. broken by hand-editing), plugins cannot be identified and the failure is passed through.
+- Rows inserted via `--patch` overlay layers are not part of the mapping (only the profile patch, the home patch and bundle patches are scanned).
+- To capture stderr, the wrapper pipes dsh's stderr (content is still echoed to the terminal in real time); stdout/stdin pass through unaffected.
+- Match patterns target the dsh 0.1.x error formats; a major dsh upgrade that changes them requires updating the parser.
+- Windows is best-effort: update / --self / list / restore are adapted (.cmd shim parsing, shelled npm/pnpm invocations), but the wrapped dsh boot's child-process spawn is unverified on Windows.
+
+## Development
+
+```bash
+npm test        # node:test unit tests + fake-dsh integration tests
+```
+
+## License
+
+[MIT](./LICENSE)

package/README.md

@@ -1,6 +1,6 @@
 # dsh-safe · dsh 启动保险丝
 
-中文 | [English](#english)
+中文 | [English](./README.en.md)
 
 DeepSeek Harness（DSH）的社区插件与 dsh 运行时不兼容时，`dsh web` 会**整体启动失败**——加载器把所有 patch 层拉平成同一棵加载树，任何一个插件 import 失败、`apply` 抛错、或等不到注入的服务，启动审计就会拒绝整棵树，进程退出。此时只能手动编辑 `cordis.patch.yml` 把坏插件禁用。
 
@@ -36,9 +36,12 @@ Error: dsh: plugin tree failed to load: failed to apply loader entry smoke-broke
 
 ```
 dsh-safe <dsh 参数…>             包装运行 dsh
+dsh-safe -u [dsh 参数…]            先升级 dsh（已最新则跳过），再启动
 dsh-safe list [--profile <名>]    查看隔离名单（缺省列出全部 profile）
 dsh-safe restore --profile <名> (--id <id> | --all) [--dry-run]
                                   恢复被自动禁用的插件（升级修复后使用）
+dsh-safe update [-y] [--to <版本>] [--self] [--no-restore] [--pm npm|pnpm]
+                                  升级 dsh 与 dsh-safe 自身，并自动恢复被隔离的插件
 dsh-safe help
 ```
 
@@ -50,6 +53,14 @@ dsh-safe help
 | `--max-retries <n>` | 自动隔离后最多重试启动的次数（默认 2；`0` 表示不隔离只透传） |
 | `--allow-first-party` | 允许自动禁用 `@deepseek-ai/*` 第一方插件（默认跳过，需手动处理） |
 
+升级 dsh：`dsh-safe update` 自动探测 dsh 的包名与安装方式（npm / pnpm 全局安装）、对比最新版本后代跑升级，完成后自动恢复所有被隔离的插件——新 dsh 下仍不兼容的会在下次启动时再次被自动隔离。`--to <版本>` 指定目标版本（也是回滚方式），`--no-restore` 跳过恢复，`-y` 跳过确认。
+
+update / -u 会同时检查 dsh-safe 自身的版本，谁旧升谁（一条安装命令）；`--self` 只更新 dsh-safe。另外每次包装启动时最多每天一次检查 dsh-safe 新版并提示一行（检查失败完全静默），`DSH_SAFE_NO_UPDATE_CHECK=1` 关闭。
+
+日常把 `dsh-safe -u web` 当启动命令即可：dsh 已是最新时直接启动（仅一次版本检查），有更新时先升级并恢复隔离再启动，更新检查失败只告警、照常启动。`-u` 后可接 update 的选项（如 `-u -y web`）与包装旗标（如 `-u --max-retries 0 web`）。
+
+提示信息语言跟随 `LC_ALL` / `LC_MESSAGES` / `LANG` / `LANGUAGE`（`zh*` 为中文，其余英文），也可用环境变量 `DSH_SAFE_LANG=zh|en` 强制指定。
+
 ## 工作原理
 
 1. **识别失败**：dsh 启动失败时，stderr 里有四类特征（`plugin(s) failed to load: …`、`N entries did not activate` 逐行失败、`failed to apply/import loader entry <id> (<name>)`、外层栈 `…#<entryId>`）。dsh-safe 从中提取坏插件的包名与行 id。
@@ -70,6 +81,7 @@ dsh-safe help
 - `--patch` 覆盖层里插入的行不参与对照表（对照表只扫 profile patch、home patch 与 bundle patch）。
 - 为了捕获 stderr，包装器把 dsh 的 stderr 接到管道（内容仍实时回显到终端）；stdout/stdin 直通不受影响。
 - 本项目针对 dsh 0.1.x 的报错格式做匹配；dsh 大版本升级后格式变化时需要同步更新解析器。
+- Windows 为尽力支持：update / --self / list / restore 已适配（.cmd shim 解析、shell 方式调用 npm/pnpm），包装启动 dsh 的子进程方式未在 Windows 验证。
 
 ## 开发
 
@@ -77,18 +89,6 @@ dsh-safe help
 npm test        # node:test 单元测试 + 假 dsh 集成测试
 ```
 
-<a name="english"></a>
-## English
-
-**dsh-safe** is a fuse for DeepSeek Harness (DSH) startup: when a community plugin is incompatible with the running dsh version, `dsh web` normally fails to boot entirely — one broken plugin rejects the whole loader tree. dsh-safe wraps any `dsh` invocation, parses the startup-failure diagnostics on stderr, marks the offending patch rows as `disabled: true` inside a managed block in your profile patch file (keeping all user content and comments), records the action in a quarantine ledger, and retries. First-party `@deepseek-ai/*` plugins are protected by default; `dsh-safe restore --profile <name> --all` re-enables quarantined rows after you upgrade the plugin.
-
-```bash
-npm install -g @hyzyn/dsh-safe
-dsh-safe web                 # run dsh web with auto-quarantine
-dsh-safe list                # show quarantined plugins
-dsh-safe restore --profile web --all
-```
-
 ## License
 
 [MIT](./LICENSE)

package/lib/cli.js

@@ -10,38 +10,14 @@
 import { createRequire } from 'node:module'
 import { loadLedger, restoreQuarantine } from './quarantine.js'
 import { runWrapped } from './wrap.js'
+import { cmdUpdate, cmdUpdateAndBoot, maybeNotifySelfUpdate } from './update.js'
+import { t } from './i18n.js'
 
 const require = createRequire(import.meta.url)
 const { version } = require('../package.json')
 
-const HELP = `dsh-safe ${version} — dsh 启动保险丝
-
-社区插件与 dsh 运行时不兼容会让 dsh 整体启动失败。dsh-safe 包装运行 dsh：
-启动失败时从报错里识别坏插件，在 profile patch 里把对应行置为 disabled
-（记录进隔离台账），然后自动重试。
-
-用法:
-  dsh-safe <dsh 参数…>             包装运行 dsh，例: dsh-safe web
-  dsh-safe list [--profile <名>]    查看隔离名单（缺省列出全部 profile）
-  dsh-safe restore --profile <名> (--id <id> | --all) [--dry-run]
-                                    恢复被自动禁用的插件（升级修复后使用）
-  dsh-safe help                     显示本帮助
-  dsh-safe --version                显示版本
-
-包装模式选项（必须写在 profile / 子命令之前）:
-  --dry-run                只解析与报告，不修改任何文件
-  --max-retries <n>        自动隔离后最多重试启动的次数（默认 2）
-  --allow-first-party      允许自动禁用 @deepseek-ai/* 第一方插件（默认跳过）
-
-说明:
-  - 行的禁用以 patch 文件末尾的托管区块写入（带标记注释），不改动用户内容；
-    恢复用 dsh-safe restore，或手动删除区块。
-  - 只隔离"启动期"失败（模块解析失败 / apply 抛错 / 等不到注入服务）；
-    运行期的未捕获异常仍由 dsh 自身的 fail-loud 策略处理。
-`
-
 function printHelp() {
-  process.stdout.write(HELP)
+  process.stdout.write(t('helpText', { version }))
 }
 
 function printVersion() {
@@ -92,10 +68,12 @@ function cmdList(args) {
     process.stdout.write(`${p}:\n`)
     for (const e of entries) {
       found++
-      process.stdout.write(`  - ${e.name ?? '(未知包名)'} (id: ${e.id})\n      隔离于 ${e.quarantinedAt}\n      原因: ${e.reason}\n      位置: ${e.file}\n`)
+      process.stdout.write(
+        `  - ${e.name ?? t('unknownName')} (id: ${e.id})\n${t('quarantinedAt', { time: e.quarantinedAt })}\n${t('reasonLine', { reason: e.reason })}\n${t('locationLine', { file: e.file })}\n`,
+      )
     }
   }
-  if (!found) process.stdout.write(profile ? `${profile}: 没有隔离记录\n` : '没有隔离记录\n')
+  if (!found) process.stdout.write(profile ? `${t('noRecordsProfile', { profile })}\n` : `${t('noRecords')}\n`)
   return 0
 }
 
@@ -106,19 +84,19 @@ function cmdRestore(args) {
   const all = rest1.includes('--all')
   const profile = profile0
   if (!profile) {
-    process.stderr.write('[dsh-safe] restore 需要 --profile <名>\n')
+    process.stderr.write(`${t('restoreNeedsProfile')}\n`)
     return 2
   }
   if (!all && ids0.length === 0) {
-    process.stderr.write('[dsh-safe] restore 需要 --id <id>（可重复）或 --all\n')
+    process.stderr.write(`${t('restoreNeedsId')}\n`)
     return 2
   }
   const { restored, kept } = restoreQuarantine(profile, all ? 'all' : ids0, dryRun)
-  const verb = dryRun ? '（dry-run）将恢复' : '已恢复'
+  const verb = t(dryRun ? 'restoredDry' : 'restored')
   for (const e of restored) process.stdout.write(`[dsh-safe] ${verb} ${e.name ?? e.id} (id: ${e.id})\n`)
-  if (!restored.length) process.stdout.write('[dsh-safe] 没有匹配的隔离记录\n')
-  else if (kept.length) process.stdout.write(`[dsh-safe] ${profile} 仍隔离 ${kept.length} 行；重启 dsh 生效。\n`)
-  else process.stdout.write('[dsh-safe] 该 profile 的隔离名单已清空；重启 dsh 生效。\n')
+  if (!restored.length) process.stdout.write(`${t('noMatching')}\n`)
+  else if (kept.length) process.stdout.write(`${t('stillQuarantined', { profile, count: kept.length })}\n`)
+  else process.stdout.write(`${t('ledgerCleared')}\n`)
   return 0
 }
 
@@ -142,9 +120,17 @@ export async function main(argv) {
   }
   if (cmd === 'list') return cmdList(argv.slice(1))
   if (cmd === 'restore') return cmdRestore(argv.slice(1))
+  if (cmd === 'update') return cmdUpdate(argv.slice(1))
+  if (cmd === '-u' || cmd === '--update') return cmdUpdateAndBoot(argv.slice(1), { boot: runWrapperMode })
 
   // 包装模式：剥掉 dsh-safe 自己的旗标（必须出现在第一个位置参数之前），
   // 其余原样转发给 dsh。
+  return runWrapperMode(argv)
+}
+
+/** 包装模式：剥离 dsh-safe 的旗标后运行 dsh；-u 升级完成后的启动也走这里。 */
+async function runWrapperMode(argv) {
+  maybeNotifySelfUpdate()
   const forwardArgs = []
   let dryRun = false
   let maxRetries = 2
@@ -158,7 +144,7 @@ export async function main(argv) {
       const raw = argv[++i]
       const v = raw === undefined || raw === '' ? NaN : Number(raw)
       if (!Number.isFinite(v) || v < 0) {
-        process.stderr.write('[dsh-safe] --max-retries 需要一个非负整数\n')
+        process.stderr.write(`${t('maxRetriesInvalid')}\n`)
         return 2
       }
       maxRetries = v
@@ -168,7 +154,7 @@ export async function main(argv) {
       const raw = a.slice('--max-retries='.length)
       const v = raw === '' ? NaN : Number(raw)
       if (!Number.isFinite(v) || v < 0) {
-        process.stderr.write('[dsh-safe] --max-retries 需要一个非负整数\n')
+        process.stderr.write(`${t('maxRetriesInvalid')}\n`)
         return 2
       }
       maxRetries = v
@@ -181,6 +167,6 @@ export async function main(argv) {
     printHelp()
     return 0
   }
-  if (dryRun) process.stderr.write('[dsh-safe] dry-run：只报告，不修改文件。\n')
+  if (dryRun) process.stderr.write(`${t('dryRunNotice')}\n`)
   return runWrapped({ forwardArgs, dryRun, maxRetries, allowFirstParty })
 }

package/lib/dshpaths.js

@@ -28,6 +28,9 @@ export const homePatchPath = () => join(dshHome(), 'cordis.patch.yml')
 /** dsh-safe 的隔离台账。 */
 export const ledgerFile = () => join(dshHome(), 'dsh-safe', 'quarantine.json')
 
+/** dsh-safe 的更新检查时间戳缓存（每天最多提示一次新版）。 */
+export const updateCheckFile = () => join(dshHome(), 'dsh-safe', 'update-check.json')
+
 /** 读文件，不存在或读不了返回 undefined。 */
 export const readIfExists = (path) => {
   try {

package/lib/i18n.js

@@ -0,0 +1,234 @@
+/**
+ * @hyzyn/dsh-safe — 输出语言自适应。
+ *
+ * 语言判定优先级：DSH_SAFE_LANG > LC_ALL > LC_MESSAGES > LANG > LANGUAGE。
+ * 值为 zh* 时用中文，否则英文；全部未设置（或为 C/POSIX）时退回 Node 的
+ * Intl 默认 locale，仍非 zh 则英文。零依赖，不引 i18n 库。
+ */
+
+const ZH = {
+  // ---- cli.js ----
+  helpText: `dsh-safe {version} — dsh 启动保险丝
+
+社区插件与 dsh 运行时不兼容会让 dsh 整体启动失败。dsh-safe 包装运行 dsh：
+启动失败时从报错里识别坏插件，在 profile patch 里把对应行置为 disabled
+（记录进隔离台账），然后自动重试。
+
+用法:
+  dsh-safe <dsh 参数…>             包装运行 dsh，例: dsh-safe web
+  dsh-safe -u [<dsh 参数…>]         先升级 dsh（已最新则跳过），再启动
+  dsh-safe list [--profile <名>]    查看隔离名单（缺省列出全部 profile）
+  dsh-safe restore --profile <名> (--id <id> | --all) [--dry-run]
+                                    恢复被自动禁用的插件（升级修复后使用）
+  dsh-safe update [-y] [--to <版本>] [--self] [--no-restore] [--pm npm|pnpm]
+                                    升级 dsh 与 dsh-safe 自身，并自动恢复被隔离的插件
+  dsh-safe help                     显示本帮助
+  dsh-safe --version                显示版本
+
+包装模式选项（必须写在 profile / 子命令之前）:
+  --dry-run                只解析与报告，不修改任何文件
+  --max-retries <n>        自动隔离后最多重试启动的次数（默认 2）
+  --allow-first-party      允许自动禁用 @deepseek-ai/* 第一方插件（默认跳过）
+
+说明:
+  - 行的禁用以 patch 文件末尾的托管区块写入（带标记注释），不改动用户内容；
+    恢复用 dsh-safe restore，或手动删除区块。
+  - 只隔离"启动期"失败（模块解析失败 / apply 抛错 / 等不到注入服务）；
+    运行期的未捕获异常仍由 dsh 自身的 fail-loud 策略处理。
+  - update/-u 会同时检查 dsh 与 dsh-safe 自身；--self 只更新 dsh-safe。
+  - 启动时每天最多提示一次 dsh-safe 新版；DSH_SAFE_NO_UPDATE_CHECK=1 关闭。
+  - 输出语言跟随 LC_ALL / LC_MESSAGES / LANG / LANGUAGE（zh* 中文，其余英文）；
+    可用环境变量 DSH_SAFE_LANG=zh|en 强制指定。
+`,
+  unknownName: '(未知包名)',
+  quarantinedAt: '      隔离于 {time}',
+  reasonLine: '      原因: {reason}',
+  locationLine: '      位置: {file}',
+  noRecordsProfile: '{profile}: 没有隔离记录',
+  noRecords: '没有隔离记录',
+  restoreNeedsProfile: '[dsh-safe] restore 需要 --profile <名>',
+  restoreNeedsId: '[dsh-safe] restore 需要 --id <id>（可重复）或 --all',
+  restored: '已恢复',
+  restoredDry: '（dry-run）将恢复',
+  noMatching: '[dsh-safe] 没有匹配的隔离记录',
+  stillQuarantined: '[dsh-safe] {profile} 仍隔离 {count} 行；重启 dsh 生效。',
+  ledgerCleared: '[dsh-safe] 该 profile 的隔离名单已清空；重启 dsh 生效。',
+  maxRetriesInvalid: '[dsh-safe] --max-retries 需要一个非负整数',
+  dryRunNotice: '[dsh-safe] dry-run：只报告，不修改文件。',
+
+  // ---- wrap.js ----
+  spawnFailed: '[dsh-safe] 无法启动 {command}: {message}',
+  pluginPassthrough: '[dsh-safe] `dsh plugin` 为 pnpm 转发，不做隔离，原样透传。',
+  noProfile:
+    '[dsh-safe] 未能从参数确定 profile（launcher 旗标需在最前，或用 --profile <name>），无法自动隔离，原样透传。',
+  skipFirstParty:
+    '[dsh-safe] 跳过第一方插件 {name} (id: {id}) —— 默认保护 @deepseek-ai/*，需要手动处理；确认要禁用可加 --allow-first-party。',
+  nothingFound: '[dsh-safe] 报错里没有识别出可自动隔离的已挂载插件，原样透传。',
+  maxRetriesReached: '[dsh-safe] 已达最大重试次数（--max-retries {count}），不再重试。',
+  disabled: '已禁用',
+  willDisable: '（dry-run）将禁用',
+  reasonIndent: '           原因: {reason}',
+  retrying: '[dsh-safe] 重试启动…',
+
+  // ---- update.js ----
+  updateDshNotFound: '[dsh-safe] 在 PATH 上找不到 dsh 命令，无法升级。',
+  updatePlan: '[dsh-safe] {label} {name} {old} → {target} ({pm})',
+  updateInstallCmd: '[dsh-safe] 即将执行: {command}',
+  updateConfirm: '继续? [y/N] ',
+  updateNonInteractive: '[dsh-safe] 当前不是交互终端，无法确认；加 -y 跳过确认后重试。',
+  updateAborted: '[dsh-safe] 已取消。',
+  updateInstalling: '[dsh-safe] 正在升级 dsh…',
+  updateInstallFail: '[dsh-safe] 升级失败（退出码 {code}），未恢复任何隔离插件。',
+  updateLatestFetchFail: '[dsh-safe] 无法获取 {name} 的最新版本（{pm} view 失败）；可用 --to <版本> 指定目标版本。',
+  updateSkipCheckWarn: '[dsh-safe] 无法检查 dsh 更新（{pm} view 失败），跳过升级直接启动。',
+  updateAlreadyLatest: '[dsh-safe] 已是最新，无需更新（dsh {dsh} / dsh-safe {self}）。',
+  updateDone: '[dsh-safe] dsh 已更新: {old} → {new}',
+  updateVerifyWarn: '[dsh-safe] 警告：升级后无法重新解析 dsh 版本，请自行确认。',
+  updateNothingToRestore: '[dsh-safe] 没有需要恢复的隔离记录。',
+  updateRestoredProfile: '[dsh-safe] 已恢复 {count} 个被隔离的插件 (profile: {profile})',
+  updateRestoreSkipped: '[dsh-safe] 已按 --no-restore 跳过恢复；可稍后用 dsh-safe restore --profile <名> --all 恢复。',
+  updateVerifyHint: '[dsh-safe] 请启动 dsh 验证；仍不兼容的插件会自动再次隔离。',
+  updateRollbackHint: '[dsh-safe] 如需回滚: dsh-safe update --to {version}',
+  selfUpdateLagHint: '[dsh-safe] dsh-safe 已更新: {old} → {new}（本次运行仍是旧版，下次启动生效）',
+  updateNotify: '[dsh-safe] 提示: dsh-safe 有新版本 {new}（当前 {old}）',
+  updateNotifyHow: '           升级: npm i -g {name} 或 dsh-safe update --self',
+  updateUnknownFlag: '[dsh-safe] update 无法识别的参数: {arg}',
+  updatePmInvalid: '[dsh-safe] --pm 只支持 npm 或 pnpm。',
+  updateToInvalid: '[dsh-safe] --to 需要合法的版本号（如 1.2.3 或 1.2.3-rc.1）。',
+}
+
+const EN = {
+  // ---- cli.js ----
+  helpText: `dsh-safe {version} — startup fuse for dsh
+
+When a community plugin is incompatible with the dsh runtime, dsh fails to boot as a
+whole. dsh-safe wraps dsh: on startup failure it identifies the broken plugin from
+the error, marks its row disabled in the profile patch (recording it in a quarantine
+ledger), and retries automatically.
+
+Usage:
+  dsh-safe <dsh args…>             wrap and run dsh, e.g. dsh-safe web
+  dsh-safe -u [<dsh args…>]         upgrade dsh first (skip if latest), then boot
+  dsh-safe list [--profile <name>] show quarantined plugins (defaults to all profiles)
+  dsh-safe restore --profile <name> (--id <id> | --all) [--dry-run]
+                                    re-enable auto-disabled plugins (after a fixed plugin upgrade)
+  dsh-safe update [-y] [--to <ver>] [--self] [--no-restore] [--pm npm|pnpm]
+                                    upgrade dsh and dsh-safe itself, auto-restore quarantined plugins
+  dsh-safe help                     show this help
+  dsh-safe --version                show version
+
+Wrapper-mode options (must come before the profile / subcommand):
+  --dry-run                parse and report only; no files are modified
+  --max-retries <n>        max startup retries after an auto-quarantine (default 2)
+  --allow-first-party      allow auto-disabling @deepseek-ai/* first-party plugins (skipped by default)
+
+Notes:
+  - Rows are disabled via a marker-commented managed block appended to the patch file;
+    user content is untouched. Restore with dsh-safe restore, or delete the block manually.
+  - Only startup-phase failures are quarantined (module resolution / apply throw /
+    missing injected service); runtime uncaught exceptions stay under dsh's own
+    fail-loud policy.
+  - update/-u checks both dsh and dsh-safe itself; --self updates dsh-safe only.
+  - A new-version notice for dsh-safe is shown at most once a day on boot;
+    disable it with DSH_SAFE_NO_UPDATE_CHECK=1.
+  - Output language follows LC_ALL / LC_MESSAGES / LANG / LANGUAGE (zh* → Chinese,
+    otherwise English); force it with DSH_SAFE_LANG=zh|en.
+`,
+  unknownName: '(unknown package)',
+  quarantinedAt: '      quarantined at {time}',
+  reasonLine: '      reason: {reason}',
+  locationLine: '      location: {file}',
+  noRecordsProfile: '{profile}: no quarantine records',
+  noRecords: 'no quarantine records',
+  restoreNeedsProfile: '[dsh-safe] restore requires --profile <name>',
+  restoreNeedsId: '[dsh-safe] restore requires --id <id> (repeatable) or --all',
+  restored: 'restored',
+  restoredDry: '(dry-run) would restore',
+  noMatching: '[dsh-safe] no matching quarantine records',
+  stillQuarantined: '[dsh-safe] {profile} still has {count} quarantined row(s); restart dsh to apply.',
+  ledgerCleared: '[dsh-safe] quarantine list for this profile is now empty; restart dsh to apply.',
+  maxRetriesInvalid: '[dsh-safe] --max-retries requires a non-negative integer',
+  dryRunNotice: '[dsh-safe] dry-run: report only, no files will be modified.',
+
+  // ---- wrap.js ----
+  spawnFailed: '[dsh-safe] failed to start {command}: {message}',
+  pluginPassthrough: '[dsh-safe] `dsh plugin` is a pnpm forwarder; no quarantine, exit code passed through.',
+  noProfile:
+    '[dsh-safe] could not determine the profile from args (launcher flags must come first, or use --profile <name>); no auto-quarantine, exit code passed through.',
+  skipFirstParty:
+    '[dsh-safe] skipping first-party plugin {name} (id: {id}) — @deepseek-ai/* is protected by default; handle manually, or pass --allow-first-party to allow disabling.',
+  nothingFound:
+    '[dsh-safe] no mounted plugin could be identified as auto-quarantinable from the error; exit code passed through.',
+  maxRetriesReached: '[dsh-safe] max retries reached (--max-retries {count}); giving up.',
+  disabled: 'disabled',
+  willDisable: '(dry-run) would disable',
+  reasonIndent: '           reason: {reason}',
+  retrying: '[dsh-safe] retrying…',
+
+  // ---- update.js ----
+  updateDshNotFound: '[dsh-safe] could not find the `dsh` command on PATH; nothing to upgrade.',
+  updatePlan: '[dsh-safe] {label} {name} {old} → {target} ({pm})',
+  updateInstallCmd: '[dsh-safe] about to run: {command}',
+  updateConfirm: 'continue? [y/N] ',
+  updateNonInteractive: '[dsh-safe] not an interactive terminal; re-run with -y to skip the confirmation.',
+  updateAborted: '[dsh-safe] cancelled.',
+  updateInstalling: '[dsh-safe] upgrading dsh…',
+  updateInstallFail: '[dsh-safe] upgrade failed (exit code {code}); no quarantined plugins were restored.',
+  updateLatestFetchFail: '[dsh-safe] could not fetch the latest version of {name} ({pm} view failed); specify a target with --to <version>.',
+  updateSkipCheckWarn: '[dsh-safe] could not check for dsh updates ({pm} view failed); starting without upgrading.',
+  updateAlreadyLatest: '[dsh-safe] already up to date (dsh {dsh} / dsh-safe {self}); nothing to update.',
+  updateDone: '[dsh-safe] dsh updated: {old} → {new}',
+  updateVerifyWarn: '[dsh-safe] warning: could not re-resolve the dsh version after the upgrade; please verify manually.',
+  updateNothingToRestore: '[dsh-safe] no quarantine records to restore.',
+  updateRestoredProfile: '[dsh-safe] restored {count} quarantined plugin(s) (profile: {profile})',
+  updateRestoreSkipped: '[dsh-safe] restore skipped due to --no-restore; restore later with dsh-safe restore --profile <name> --all.',
+  updateVerifyHint: '[dsh-safe] start dsh to verify; plugins still incompatible will be auto-quarantined again.',
+  updateRollbackHint: '[dsh-safe] to roll back: dsh-safe update --to {version}',
+  selfUpdateLagHint: '[dsh-safe] dsh-safe updated: {old} → {new} (this run still uses the old version; takes effect on the next run)',
+  updateNotify: '[dsh-safe] notice: a new dsh-safe version is available: {new} (current {old})',
+  updateNotifyHow: '           to upgrade: npm i -g {name} or dsh-safe update --self',
+  updateUnknownFlag: '[dsh-safe] unrecognized argument for update: {arg}',
+  updatePmInvalid: '[dsh-safe] --pm only accepts npm or pnpm.',
+  updateToInvalid: '[dsh-safe] --to requires a valid version (e.g. 1.2.3 or 1.2.3-rc.1).',
+}
+
+const CATALOG = { zh: ZH, en: EN }
+
+/** 把 locale 值归一成 'zh' | 'en'；空值 / C / POSIX 返回 null（交给下一优先级）。 */
+function parseLocale(raw) {
+  if (!raw) return null
+  const base = raw.split(':')[0].split('.')[0].split('@')[0].trim().toLowerCase()
+  if (!base || base === 'c' || base === 'posix') return null
+  return base.startsWith('zh') ? 'zh' : 'en'
+}
+
+/**
+ * 纯函数，方便单测。默认参数取真实环境。
+ * @param {Record<string, string | undefined>} env
+ * @param {string} [intlLocale] 环境变量全部缺失时的兜底（生产为 Node 的 Intl 默认 locale）
+ */
+export function detectLocale(env = process.env, intlLocale = Intl.DateTimeFormat().resolvedOptions().locale) {
+  for (const key of ['DSH_SAFE_LANG', 'LC_ALL', 'LC_MESSAGES', 'LANG', 'LANGUAGE']) {
+    const lang = parseLocale(env[key])
+    if (lang) return lang
+  }
+  return typeof intlLocale === 'string' && intlLocale.toLowerCase().startsWith('zh') ? 'zh' : 'en'
+}
+
+let cached
+
+/** 当前进程的输出语言（首次调用时检测并缓存）。 */
+export function getLocale() {
+  return (cached ??= detectLocale())
+}
+
+/** 指定语言取词条，主要用于单测。 */
+export function translate(locale, key, params = {}) {
+  const text = CATALOG[locale]?.[key] ?? CATALOG.en[key] ?? key
+  return text.replace(/\{(\w+)\}/g, (match, name) => (params[name] !== undefined ? String(params[name]) : match))
+}
+
+/** 按当前语言取词条并做 {name} 插值。 */
+export function t(key, params = {}) {
+  return translate(getLocale(), key, params)
+}

package/lib/knownrows.js

@@ -1,11 +1,14 @@
 /**
  * @hyzyn/dsh-safe — 收集一个 profile 下"行 id ↔ 插件包名"的对照表。
  *
- * 来源（后写的层优先级更高）：
- * 1. profile 自己的 cordis.patch.yml（写层）
- * 2. `$DSH_HOME/cordis.patch.yml` home 层（写层：发现的行写回 home patch）
- * 3. profile package.json `dsh.profile.bundles` 里每个 bundle 的 patch
- *    （只读对照；禁用行写入 profile 层，它在 bundle 层之后合成，同 id 后写覆盖）
+ * 收集顺序 = dsh 的 patch 合成顺序（同 id 后写覆盖）：
+ * 1. profile package.json `dsh.profile.bundles` 里每个 bundle 的 patch
+ *    （只读对照；禁用行写入 profile 层——它在 bundle 层之后合成，同 id 覆盖 bundle 行）
+ * 2. `$DSH_HOME/cordis.patch.yml` home 层
+ * 3. profile 自己的 cordis.patch.yml（写层，dsh-safe 托管区块也在其中）
+ *
+ * 因此对照表数组里越靠后的行优先级越高：profile 层（含托管区块的 disabled 行）
+ * 覆盖 home / bundle 层的同 id 行。
  */
 import { join } from 'node:path'
 import { scanPatchRows } from './patchfile.js'
@@ -32,16 +35,6 @@ export function collectKnownRows(profile) {
   const profilePatch = profilePatchPath(profile)
   const homePatch = homePatchPath()
 
-  const profileText = readIfExists(profilePatch)
-  if (profileText !== undefined) {
-    for (const row of scanPatchRows(profileText)) rows.push({ ...row, source: 'profile', file: profilePatch })
-  }
-
-  const homeText = readIfExists(homePatch)
-  if (homeText !== undefined) {
-    for (const row of scanPatchRows(homeText)) rows.push({ ...row, source: 'home', file: homePatch })
-  }
-
   const manifest = readJsonIfExists(profileManifestPath(profile))
   const bundles = manifest?.dsh?.profile?.bundles ?? []
   for (const bundle of bundles) {
@@ -54,12 +47,23 @@ export function collectKnownRows(profile) {
     for (const row of scanPatchRows(patchText)) rows.push({ ...row, source: bundle, file: profilePatch })
   }
 
+  const homeText = readIfExists(homePatch)
+  if (homeText !== undefined) {
+    for (const row of scanPatchRows(homeText)) rows.push({ ...row, source: 'home', file: homePatch })
+  }
+
+  const profileText = readIfExists(profilePatch)
+  if (profileText !== undefined) {
+    for (const row of scanPatchRows(profileText)) rows.push({ ...row, source: 'profile', file: profilePatch })
+  }
+
   return { rows, profilePatch, homePatch }
 }
 
 /**
  * 把失败报告对照到真实存在的 patch 行。
  * 包名命中该包的全部行（一个包可能挂多个 id）；行 id 命中对应行。
+ * 同一 id 在多层重复出现时，取合成顺序里最后出现的行（profile/托管区块覆盖 home/bundle）。
  * @param {{ names: Array<[string, string]>, entryIds: Array<[string, string]> }} report
  * @param {{ rows: Array<{ id: string, name: string|null, disabled: boolean, file: string }> }} known
  * @returns {Array<{ id: string, name: string|null, disabled: boolean, file: string, line: string }>}
@@ -68,7 +72,7 @@ export function matchFailures(report, known) {
   const byId = new Map()
   const byName = new Map()
   for (const row of known.rows) {
-    if (!byId.has(row.id)) byId.set(row.id, row)
+    byId.set(row.id, row) // 同 id 后写覆盖
     if (row.name) {
       if (!byName.has(row.name)) byName.set(row.name, [])
       byName.get(row.name).push(row)

package/lib/update.js

@@ -0,0 +1,423 @@
+/**
+ * @hyzyn/dsh-safe — `dsh-safe update`：升级 dsh 并自动恢复被隔离的插件。
+ *
+ * 自动探测：PATH 上的 dsh 可执行文件 realpath → 向上找最近的 package.json
+ * 得到包名与当前版本；包管理器按 realpath 是否落在 pnpm 全局根下判定
+ * （PATH 上有 pnpm 时探测，否则默认 npm），--pm 可强制指定。
+ * 升级完成后遍历台账恢复全部被隔离的插件（新 dsh 下仍不兼容的会在
+ * 下次启动时再次被自动隔离），并提示回滚方式。
+ */
+import { accessSync, constants, mkdirSync, realpathSync, writeFileSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { createInterface } from 'node:readline/promises'
+import { delimiter, dirname, join } from 'node:path'
+import { loadLedger, restoreQuarantine } from './quarantine.js'
+import { readIfExists, updateCheckFile } from './dshpaths.js'
+import { t } from './i18n.js'
+
+const err = (line) => process.stderr.write(`${line}\n`)
+const out = (line) => process.stdout.write(`${line}\n`)
+
+const WIN32 = process.platform === 'win32'
+
+/**
+ * 运行包管理器命令并捕获输出（view / pnpm root -g）。
+ * Windows 上 npm/pnpm 是 .cmd 批处理，Node 禁止无 shell 地 spawn（EINVAL），
+ * 必须走 cmd.exe；传参只含已校验的包名与版本号（--to 有 ^[\w.+-]+$ 校验）。
+ */
+function spawnPmCapture(bin, args) {
+  return WIN32
+    ? spawnSync(bin, args, { encoding: 'utf8', shell: true })
+    : spawnSync(bin, args, { encoding: 'utf8' })
+}
+
+/** 运行包管理器命令并透传 stdio（install）。Windows 处理同上。 */
+function spawnPmInherit(bin, args) {
+  return WIN32
+    ? spawnSync(bin, args, { shell: true, stdio: 'inherit' })
+    : spawnSync(bin, args, { stdio: 'inherit' })
+}
+
+/** Windows 上全局 bin 的可执行是 .cmd/.exe 拷贝而非 symlink，候选名不同。 */
+function binCandidates(name) {
+  return WIN32 ? [`${name}.cmd`, `${name}.exe`, `${name}.ps1`, name] : [name]
+}
+
+const readJsonIfExists = (path) => {
+  const raw = readIfExists(path)
+  if (raw === undefined) return undefined
+  try {
+    return JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+}
+
+/** 在 PATH 上找可执行文件（Windows 展开为 .cmd/.exe/.ps1/裸名多候选），返回绝对路径或 null。 */
+function whichCmd(name) {
+  for (const dir of (process.env.PATH ?? '').split(delimiter)) {
+    if (!dir) continue
+    for (const candidate of binCandidates(name).map((n) => join(dir, n))) {
+      try {
+        accessSync(candidate, constants.X_OK)
+        return candidate
+      } catch {}
+    }
+  }
+  return null
+}
+
+/** 从某个目录向上找最近的 package.json，返回 { name, version, pkgDir }。 */
+function resolvePackageFromDir(dir) {
+  for (;;) {
+    const pkg = readJsonIfExists(join(dir, 'package.json'))
+    if (pkg && typeof pkg.name === 'string' && pkg.name) {
+      return { name: pkg.name, version: typeof pkg.version === 'string' ? pkg.version : '0.0.0', pkgDir: dir }
+    }
+    const parent = dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+/**
+ * 从可执行文件解析所属包：symlink → realpath 后向上找 package.json（macOS/Linux
+ * 的 npm/pnpm 全局 bin 都是链接）；独立 shim 文件（Windows 的 .cmd/sh 拷贝）→
+ * 解析其内容里内嵌的 node_modules 入口路径。
+ */
+function resolvePackageFromBinFile(file) {
+  let real
+  try {
+    real = realpathSync(file)
+  } catch {
+    return null
+  }
+  const viaWalkUp = resolvePackageFromDir(dirname(real))
+  if (viaWalkUp) return viaWalkUp
+  return resolvePackageFromShim(file)
+}
+
+/** 解析 npm/pnpm 的 cmd/ps1/sh shim：内容里都内嵌 node_modules/<pkg> 的入口路径。 */
+export function resolvePackageFromShim(shimPath) {
+  const content = readIfExists(shimPath)
+  if (!content) return null
+  const m = /node_modules[\\\/]((?:@[^\\\/"'`\s]+[\\\/])?[^\\\/"'`\s]+)/.exec(content)
+  if (!m) return null
+  const name = m[1].replace(/[\\\/]/g, '/')
+  // 候选 pkgDir：npm 全局布局（shim 同级的 node_modules）与 pnpm 全局根
+  const candidates = [join(dirname(shimPath), 'node_modules', ...name.split('/'))]
+  const pnpmBin = whichCmd('pnpm')
+  if (pnpmBin) {
+    const { status, stdout } = spawnPmCapture(pnpmBin, ['root', '-g'])
+    const root = status === 0 ? (stdout ?? '').trim() : ''
+    if (root) candidates.push(join(root, ...name.split('/')))
+  }
+  for (const dir of candidates) {
+    const pkg = readJsonIfExists(join(dir, 'package.json'))
+    if (pkg?.name === name) {
+      return { name, version: typeof pkg.version === 'string' ? pkg.version : '0.0.0', pkgDir: dir }
+    }
+  }
+  return null
+}
+
+/**
+ * 解析 PATH 上的 dsh。
+ * @returns {{ name: string, version: string, pkgDir: string } | null}
+ */
+export function resolveDshPackage() {
+  const bin = whichCmd('dsh')
+  if (!bin) return null
+  return resolvePackageFromBinFile(bin)
+}
+
+/**
+ * 解析正在运行的 dsh-safe 自身（argv[1]，npm/pnpm 全局 bin symlink 或仓库内直跑均适用）。
+ * @returns {{ name: string, version: string, pkgDir: string } | null}
+ */
+export function resolveSelfPackage() {
+  const entry = process.argv[1]
+  if (!entry) return null
+  return resolvePackageFromBinFile(entry)
+}
+
+/** 判断 dsh 的安装方式：落在 pnpm 全局根下则为 pnpm，否则 npm。 */
+export function detectPm(pkgDir) {
+  const pnpmBin = whichCmd('pnpm')
+  if (!pnpmBin) return 'npm'
+  const { status, stdout } = spawnPmCapture(pnpmBin, ['root', '-g'])
+  const root = status === 0 ? (stdout ?? '').trim() : ''
+  if (root && (pkgDir === root || pkgDir.startsWith(`${root}/`) || pkgDir.startsWith(`${root}\\`))) return 'pnpm'
+  return 'npm'
+}
+
+/** npm view 查最新版本（只查 registry，与安装方式无关），失败返回 null。 */
+function fetchLatestVersion(name) {
+  const { status, stdout } = spawnPmCapture(whichCmd('npm') ?? 'npm', ['view', name, 'version'])
+  const version = status === 0 ? (stdout ?? '').trim() : ''
+  return /^[\w.+-]+$/.test(version) ? version : null
+}
+
+/**
+ * 比较 semver 风格版本：a > b 返回 true（零依赖的够用版）。
+ * 核心段按数字逐段比较；核心相同时正式版 > 预发布，预发布逐段比较（数字段按数值）。
+ * 自动检查用它避免"registry 落后于本地开发版"时的自降级；--to 显式指定不走这里，允许降级回滚。
+ */
+export function isNewerVersion(a, b) {
+  if (a === b) return false
+  const [aCore, aPre] = String(a).split('-', 2)
+  const [bCore, bPre] = String(b).split('-', 2)
+  const pa = aCore.split('.').map((n) => parseInt(n, 10) || 0)
+  const pb = bCore.split('.').map((n) => parseInt(n, 10) || 0)
+  for (let i = 0; i < 3; i++) {
+    const x = pa[i] ?? 0
+    const y = pb[i] ?? 0
+    if (x !== y) return x > y
+  }
+  if (aPre && !bPre) return false
+  if (!aPre && bPre) return true
+  const qa = (aPre ?? '').split('.')
+  const qb = (bPre ?? '').split('.')
+  for (let i = 0; i < Math.max(qa.length, qb.length); i++) {
+    const x = qa[i]
+    const y = qb[i]
+    if (x === undefined) return false
+    if (y === undefined) return true
+    const numericX = /^\d+$/.test(x)
+    const numericY = /^\d+$/.test(y)
+    if (numericX && numericY) {
+      const d = Number(x) - Number(y)
+      if (d) return d > 0
+    } else if (x !== y) {
+      return x > y
+    }
+  }
+  return false
+}
+
+/**
+ * @param {string[]} args update 子命令参数
+ * @returns {Promise<number>} 退出码
+ */
+export async function cmdUpdate(args) {
+  if (args.includes('-h') || args.includes('--help')) {
+    out(t('helpText', {}))
+    return 0
+  }
+  const { opts, error } = parseUpdateArgs(args)
+  if (error) {
+    err(t(error.key, error.params))
+    return 2
+  }
+  return updateAndMaybeBoot(opts, null, {})
+}
+
+/**
+ * `-u`/`--update` 模式：前缀解析 update 选项（-y/--to/--pm/--no-restore），
+ * 第一个不属于 update 的参数起就是 dsh 启动参数（可再带包装旗标）。
+ * 启动优先：更新检查失败只告警并照常启动；升级失败/用户取消则不启动。
+ * @param {string[]} args
+ * @param {{ boot?: (args: string[]) => Promise<number> }} hooks cli 传入的包装启动
+ */
+export async function cmdUpdateAndBoot(args, { boot } = {}) {
+  if (args.includes('-h') || args.includes('--help')) {
+    out(t('helpText', {}))
+    return 0
+  }
+  const { opts, rest, error } = parseLeadingUpdateArgs(args)
+  if (error) {
+    err(t(error.key, error.params))
+    return 2
+  }
+  return updateAndMaybeBoot(opts, rest.length ? rest : null, { boot })
+}
+
+/**
+ * 更新主体；bootArgs 非空时更新成功（或已最新/检查失败）后继续启动。
+ * 默认同时检查 dsh 与 dsh-safe 自身，谁旧升谁（一条安装命令）；--self 只更新自身。
+ * @param {{ to?: string, yes?: boolean, restore?: boolean, pm?: string, selfOnly?: boolean }} opts
+ * @param {string[] | null} bootArgs
+ * @param {{ boot?: (args: string[]) => Promise<number> }} hooks
+ */
+async function updateAndMaybeBoot(opts, bootArgs, { boot } = {}) {
+  const dshPkg = opts.selfOnly ? null : resolveDshPackage()
+  const selfPkg = resolveSelfPackage()
+  if (!dshPkg && !selfPkg) {
+    err(t('updateDshNotFound'))
+    return 1
+  }
+  const pm = opts.pm ?? (dshPkg ? detectPm(dshPkg.pkgDir) : detectPm(selfPkg.pkgDir))
+
+  // 组装更新计划：[{ pkg, target }]
+  const plans = []
+  if (dshPkg) {
+    if (opts.to) {
+      if (opts.to !== dshPkg.version) plans.push({ pkg: dshPkg, target: opts.to })
+    } else {
+      const latest = fetchLatestVersion(dshPkg.name)
+      if (!latest) {
+        if (bootArgs) {
+          err(t('updateSkipCheckWarn', { pm }))
+          return boot(bootArgs)
+        }
+        err(t('updateLatestFetchFail', { name: dshPkg.name, pm }))
+        return 1
+      }
+      if (isNewerVersion(latest, dshPkg.version)) plans.push({ pkg: dshPkg, target: latest })
+    }
+  }
+  if (selfPkg && !opts.to) {
+    const selfLatest = fetchLatestVersion(selfPkg.name)
+    if (selfLatest && isNewerVersion(selfLatest, selfPkg.version)) plans.push({ pkg: selfPkg, target: selfLatest })
+  }
+
+  if (!plans.length) {
+    if (bootArgs) return boot(bootArgs)
+    err(t('updateAlreadyLatest', { dsh: dshPkg?.version ?? '未安装', self: selfPkg?.version ?? '未知' }))
+    return 0
+  }
+
+  const installCmd = pm === 'pnpm' ? 'pnpm' : 'npm'
+  const specs = plans.map((p) => `${p.pkg.name}@${p.target}`)
+  const installArgs =
+    pm === 'pnpm' ? ['add', '-g', ...specs] : ['install', '-g', ...specs]
+  for (const p of plans) {
+    err(t('updatePlan', { label: p.pkg === dshPkg ? 'dsh' : 'dsh-safe', name: p.pkg.name, old: p.pkg.version, target: p.target, pm }))
+  }
+  err(t('updateInstallCmd', { command: `${installCmd} ${installArgs.join(' ')}` }))
+  if (!opts.yes) {
+    if (!process.stdin.isTTY) {
+      err(t('updateNonInteractive'))
+      return 1
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stderr })
+    const answer = (await rl.question(t('updateConfirm'))).trim().toLowerCase()
+    rl.close()
+    if (answer !== 'y' && answer !== 'yes') {
+      err(t('updateAborted'))
+      return 0
+    }
+  }
+
+  err(t('updateInstalling'))
+  const { status } = spawnPmInherit(whichCmd(installCmd) ?? installCmd, installArgs)
+  if (status !== 0) {
+    err(t('updateInstallFail', { code: status ?? '?' }))
+    return status ?? 1
+  }
+
+  let dshUpdated = false
+  for (const p of plans) {
+    if (p.pkg === dshPkg) {
+      dshUpdated = true
+      const fresh = resolveDshPackage()
+      if (!fresh?.version) err(t('updateVerifyWarn'))
+      else err(t('updateDone', { old: p.pkg.version, new: fresh.version }))
+    } else {
+      err(t('selfUpdateLagHint', { old: p.pkg.version, new: p.target }))
+    }
+  }
+
+  if (opts.restore && dshUpdated) {
+    const ledger = loadLedger()
+    const profiles = Object.keys(ledger.profiles).filter((p) => (ledger.profiles[p] ?? []).length)
+    if (!profiles.length) {
+      out(t('updateNothingToRestore'))
+    } else {
+      for (const profile of profiles) {
+        const { restored } = restoreQuarantine(profile, 'all', false)
+        if (restored.length) out(t('updateRestoredProfile', { profile, count: restored.length }))
+      }
+      err(t('updateVerifyHint'))
+    }
+  } else if (dshUpdated && !opts.restore) {
+    err(t('updateRestoreSkipped'))
+  }
+  if (dshUpdated) {
+    const oldDsh = plans.find((p) => p.pkg === dshPkg)?.pkg.version
+    if (oldDsh) err(t('updateRollbackHint', { version: oldDsh }))
+  }
+  if (bootArgs) return boot(bootArgs)
+  return 0
+}
+
+/** 解析 update 子命令参数；出错返回 { error: { key, params? } } 供 i18n。 */
+function parseUpdateArgs(args) {
+  const opts = { to: undefined, yes: false, restore: true, pm: undefined, selfOnly: false }
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '-y' || a === '--yes') opts.yes = true
+    else if (a === '--no-restore') opts.restore = false
+    else if (a === '--self') opts.selfOnly = true
+    else if (a === '--to') {
+      const v = args[++i]
+      if (v === undefined) return { error: { key: 'updateUnknownFlag', params: { arg: '--to' } } }
+      opts.to = v
+    } else if (a.startsWith('--to=')) opts.to = a.slice('--to='.length)
+    else if (a === '--pm') {
+      const v = args[++i]
+      if (v === undefined) return { error: { key: 'updateUnknownFlag', params: { arg: '--pm' } } }
+      opts.pm = v
+    } else if (a.startsWith('--pm=')) opts.pm = a.slice('--pm='.length)
+    else return { error: { key: 'updateUnknownFlag', params: { arg: a } } }
+  }
+  if (opts.pm !== undefined && opts.pm !== 'npm' && opts.pm !== 'pnpm') {
+    return { error: { key: 'updatePmInvalid' } }
+  }
+  if (opts.to !== undefined && !/^[\w.+-]+$/.test(opts.to)) {
+    return { error: { key: 'updateToInvalid' } }
+  }
+  return { opts }
+}
+
+/**
+ * `-u` 模式的前缀解析：从头吃掉 update 选项，第一个不认识的参数起就是
+ * dsh 启动参数（宽松处理——不像子命令那样对未知参数报错）。
+ */
+function parseLeadingUpdateArgs(args) {
+  const opts = { to: undefined, yes: false, restore: true, pm: undefined, selfOnly: false }
+  let i = 0
+  for (; i < args.length; i++) {
+    const a = args[i]
+    if (a === '-y' || a === '--yes') opts.yes = true
+    else if (a === '--no-restore') opts.restore = false
+    else if (a === '--self') opts.selfOnly = true
+    else if (a === '--to' && args[i + 1] !== undefined) opts.to = args[++i]
+    else if (a.startsWith('--to=')) opts.to = a.slice('--to='.length)
+    else if (a === '--pm' && args[i + 1] !== undefined) opts.pm = args[++i]
+    else if (a.startsWith('--pm=')) opts.pm = a.slice('--pm='.length)
+    else break
+  }
+  const rest = args.slice(i)
+  if (opts.pm !== undefined && opts.pm !== 'npm' && opts.pm !== 'pnpm') {
+    return { error: { key: 'updatePmInvalid' } }
+  }
+  if (opts.to !== undefined && !/^[\w.+-]+$/.test(opts.to)) {
+    return { error: { key: 'updateToInvalid' } }
+  }
+  return { opts, rest }
+}
+
+/**
+ * 每日一次的 dsh-safe 新版提示（只在包装启动路径调用；update/-u 有自己的检查）。
+ * 时间戳缓存于 $DSH_HOME/dsh-safe/update-check.json；任何失败都完全静默。
+ */
+export function maybeNotifySelfUpdate() {
+  try {
+    if (process.env.DSH_SAFE_NO_UPDATE_CHECK === '1') return
+    const selfPkg = resolveSelfPackage()
+    if (!selfPkg) return
+    const file = updateCheckFile()
+    const last = readJsonIfExists(file)
+    if (last?.lastCheckAt && Date.now() - Date.parse(last.lastCheckAt) < 24 * 60 * 60 * 1000) return
+    try {
+      mkdirSync(dirname(file), { recursive: true })
+      writeFileSync(file, `${JSON.stringify({ lastCheckAt: new Date().toISOString() }, null, 2)}\n`)
+    } catch {}
+    const latest = fetchLatestVersion(selfPkg.name)
+    if (latest && isNewerVersion(latest, selfPkg.version)) {
+      err(t('updateNotify', { new: latest, old: selfPkg.version }))
+      err(t('updateNotifyHow', { name: selfPkg.name }))
+    }
+  } catch {}
+}

package/lib/wrap.js

@@ -12,6 +12,7 @@ import { summarizeLine, parseFailureReport } from './failures.js'
 import { collectKnownRows, matchFailures } from './knownrows.js'
 import { detectInvocation } from './dshpaths.js'
 import { writeQuarantine } from './quarantine.js'
+import { t } from './i18n.js'
 
 const CAPTURE_LIMIT = 512 * 1024
 const FIRST_PARTY_PREFIX = '@deepseek-ai/'
@@ -31,7 +32,7 @@ export function spawnDsh(args, { command = 'dsh' } = {}) {
       if (captured.length < CAPTURE_LIMIT) captured += chunk
     })
     child.on('error', (error) => {
-      process.stderr.write(`[dsh-safe] 无法启动 ${command}: ${error.message}\n`)
+      process.stderr.write(`${t('spawnFailed', { command, message: error.message })}\n`)
       resolve({ code: 127, stderr: captured })
     })
     child.on('close', (code) => resolve({ code: code ?? 1, stderr: captured }))
@@ -63,11 +64,11 @@ export async function runWrapped(options) {
     const { code, stderr } = await spawnFn(forwardArgs)
     if (code === 0) return 0
     if (invocation.mode === 'plugin') {
-      log('[dsh-safe] `dsh plugin` 为 pnpm 转发，不做隔离，原样透传。')
+      log(t('pluginPassthrough'))
       return code
     }
     if (!invocation.profile) {
-      log('[dsh-safe] 未能从参数确定 profile（launcher 旗标需在最前，或用 --profile <name>），无法自动隔离，原样透传。')
+      log(t('noProfile'))
       return code
     }
     const known = collectKnownRows(invocation.profile)
@@ -81,14 +82,14 @@ export async function runWrapped(options) {
       else quarantinable.push(hit)
     }
     for (const hit of firstParty) {
-      log(`[dsh-safe] 跳过第一方插件 ${hit.name} (id: ${hit.id}) —— 默认保护 @deepseek-ai/*，需要手动处理；确认要禁用可加 --allow-first-party。`)
+      log(t('skipFirstParty', { name: hit.name, id: hit.id }))
     }
     if (!quarantinable.length) {
-      if (!firstParty.length) log('[dsh-safe] 报错里没有识别出可自动隔离的已挂载插件，原样透传。')
+      if (!firstParty.length) log(t('nothingFound'))
       return code
     }
     if (attempt >= maxRetries) {
-      log(`[dsh-safe] 已达最大重试次数（--max-retries ${maxRetries}），不再重试。`)
+      log(t('maxRetriesReached', { count: maxRetries }))
       return code
     }
     const targets = quarantinable.map((hit) => ({
@@ -98,12 +99,12 @@ export async function runWrapped(options) {
       file: hit.file,
     }))
     writeQuarantine(invocation.profile, targets, dryRun)
-    for (const t of targets) {
-      const verb = dryRun ? '（dry-run）将禁用' : '已禁用'
-      log(`[dsh-safe] ${verb} ${t.name ?? t.id} (id: ${t.id}) → ${t.file}`)
-      log(`           原因: ${t.reason}`)
+    for (const target of targets) {
+      const verb = t(dryRun ? 'willDisable' : 'disabled')
+      log(`[dsh-safe] ${verb} ${target.name ?? target.id} (id: ${target.id}) → ${target.file}`)
+      log(t('reasonIndent', { reason: target.reason }))
     }
     if (dryRun) return code
-    log('[dsh-safe] 重试启动…')
+    log(t('retrying'))
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyzyn/dsh-safe",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "dsh 启动保险丝：社区插件不兼容导致 dsh 启动失败时，自动禁用坏插件并重试",
   "type": "module",
   "license": "MIT",
@@ -10,7 +10,8 @@
   "files": [
     "bin",
     "lib",
-    "README.md"
+    "README.md",
+    "README.en.md"
   ],
   "engines": {
     "node": ">=20"
@@ -24,6 +25,7 @@
   },
   "keywords": [
     "dsh",
+    "dsh-plugin",
     "deepseek-harness",
     "plugin",
     "quarantine",