dsh-calibguard 0.3.3 → 0.3.5

package/README.en.md

@@ -4,7 +4,7 @@ English | [中文](README.md)
 
 ![license](https://img.shields.io/badge/license-MIT-green)
 ![node](https://img.shields.io/badge/node-%E2%89%A520-blue)
-![tests](https://img.shields.io/badge/tests-95%20passed-brightgreen)
+![tests](https://img.shields.io/badge/tests-103%20passed-brightgreen)
 [![npm](https://img.shields.io/npm/v/dsh-calibguard.svg)](https://www.npmjs.com/package/dsh-calibguard)
 
 Plugs the [CalibGuard](https://github.com/P-436/CG) file-security auditing engine into
@@ -77,6 +77,19 @@ mirrors, and pip tries Tsinghua → Aliyun → USTC → Tencent → PyPI in orde
 the installer pulls the **CUDA (cu128) build of torch**; otherwise it installs the CPU build (GTX 10 series is
 SM 6.1 and has no kernels in the cu128 wheels). The panel header shows the inference device and the reason.
 
+Manual override (optional): `node setup.mjs --force-cuda` (force the CUDA build, skipping the CUDA/compute
+checks — use at your own risk) or `node setup.mjs --cpu` (force CPU), or the env vars
+`DSH_CALIBGUARD_FORCE_CUDA=1` / `DSH_CALIBGUARD_CPU_ONLY=1`. Switch later with
+`node setup.mjs --reinstall-torch --force-cuda` (or `--cpu`).
+
+> The CPU and CUDA builds of torch **cannot coexist in one venv** (same package name; installing one replaces
+> the other). The CUDA build is a full torch and falls back to CPU when no GPU is available, so coexistence is
+> unnecessary.
+>
+> **Machines that already have the CPU build**: with ≥0.3.5 the panel header detects "NVIDIA … but torch is the
+> CPU build" and offers a **one-click "Reinstall GPU torch (~2.5 GB)"** button (uninstalls the CPU build, installs
+> CUDA, then restarts the bridge). CLI equivalent: `node "<plugin dir>/setup.mjs" --reinstall-torch --force-cuda`.
+
 **Where to watch progress**: the panel shows a "First run: preparing engine and dependencies" card with
 the current step and the tail of the installer output; host logs show `[calibguard]` lines. The audit
 button stays disabled until it is ready — press "刷新状态 / Refresh" afterwards. Expect **10–20 minutes**
@@ -268,6 +281,7 @@ Common keys of the loader row `config` (full table: [docs/configuration.md](docs
 | **Where are audit results saved / how to clear them** | In the engine's `reports/` directory (default `<engineRoot>/reports`): JSON + Markdown per audit. The panel shows the path and has a "clear results" button; AI tools return `report_md_path` / `report_json_path` |
 | **"First audit will load the model" hint shows every time** | Since 0.3.3 it is only shown while the model is not loaded yet; afterwards the button just says "auditing…" and the header shows "model loaded" |
 | **NVIDIA GPU (e.g. RTX 2060) but the engine keeps using CPU** | The installed torch is the CPU build (old installer behavior). Upgrade to ≥0.3.3 (the panel will tell you) and run `node setup.mjs --reinstall-torch` (~2.5 GB) in the plugin directory, then restart DSH |
+| **Want to force the GPU / CPU torch build** | Add `--force-cuda` / `--cpu` at install time (combine with `--reinstall-torch` to replace an existing build); the runtime device is controlled by the plugin config `device` (auto/cpu/cuda); `cuda` requires the CUDA build |
 | A legitimate third-party library is BLOCKed | Minified libraries are full of eval/base64 patterns and the corpus is Python-heavy — known false-positive tendency, see [docs/troubleshooting.md](docs/troubleshooting.md) |
 | Panel returns 401/403 | Browser session isn't authenticated with the host: refresh / sign in again |
 | The AI ignores changed settings | Press Save in the panel; editing fields without saving applies to that run only |
@@ -285,7 +299,7 @@ dsh-CalibGuard/
 ├── engine/              Bundled engine core copied from CG_GUI (code / tokenizer / calibration, no weights)
 ├── cordis.patch.yml     Bundle patch (inserts the loader row)
 ├── scripts/             link-dsh (dev-time junction), bridge-selftest (engine self-check)
-├── test/                node --test (95 cases; auto-skip when the engine env is missing)
+├── test/                node --test (103 cases; auto-skip when the engine env is missing)
 ├── .github/workflows/   publish.yml: npm trusted publishing (OIDC, optional)
 └── docs/                configuration, performance, troubleshooting, plugin contract, design notes
 ```

package/README.md

@@ -4,7 +4,7 @@
 
 ![license](https://img.shields.io/badge/license-MIT-green)
 ![node](https://img.shields.io/badge/node-%E2%89%A520-blue)
-![tests](https://img.shields.io/badge/tests-95%20passed-brightgreen)
+![tests](https://img.shields.io/badge/tests-103%20passed-brightgreen)
 [![npm](https://img.shields.io/npm/v/dsh-calibguard.svg)](https://www.npmjs.com/package/dsh-calibguard)
 
 把 [CalibGuard](https://github.com/P-436/CG) 的文件安全审计引擎接进 **DeepSeek Harness（DSH）**：
@@ -70,6 +70,19 @@ GitHub 直连失败会自动换 gh-proxy / ghfast / ghproxy 镜像；pip 依赖
 **CUDA（cu128）版 torch**；否则装 CPU 版（GTX 10 系算力 6.1，cu128 轮子里没有对应 kernel，只能 CPU）。
 面板顶部会显示「推理设备：cpu/cuda」和定档原因。
 
+手动覆盖（可选）：
+`node setup.mjs --force-cuda`（强制装 CUDA 版，跳过 CUDA/算力检查，风险自负）、
+`node setup.mjs --cpu`（强制 CPU 版），或环境变量 `DSH_CALIBGUARD_FORCE_CUDA=1` /
+`DSH_CALIBGUARD_CPU_ONLY=1`。装完想切换：`node setup.mjs --reinstall-torch --force-cuda` 或
+`--reinstall-torch --cpu`。
+
+> CPU 版与 CUDA 版 torch **不能同时存在于同一个 venv**（同名包会互相覆盖）；
+> 但 CUDA 版 torch 本身就是完整 torch，没有 GPU 时会自动用 CPU，所以不需要共存。
+>
+> **已经有 CPU 版的机器**：升级到 ≥0.3.5 后，面板顶部会显示「检测到 NVIDIA … 但当前 torch 是 CPU 版」
+> 并提供 **「一键重装 GPU 版 torch（约 2.5 GB）」** 按钮（会先卸载 CPU 版再装 CUDA 版，完成后自动重启桥接）；
+> 也可以用命令行：`node "<插件目录>/setup.mjs" --reinstall-torch --force-cuda`。
+
 **进度在哪看**：面板顶部会出现「首次运行：正在自动准备引擎与依赖」卡片（含当前步骤与输出尾巴）；
 宿主日志里是 `[calibguard]` 开头的行。准备期间审计按钮不可用，完成后点「刷新状态」即可。
 首次约需 **10–20 分钟**（取决于网速和 pip 源），只需一次。
@@ -253,6 +266,7 @@ AI 能看到完整四档结论与证据；若你说「只审高危文件」，
 | **审计结果保存在哪 / 想清空** | 保存在引擎 `reports/` 目录（默认 `<engineRoot>/reports`），每次审计生成 JSON + Markdown；面板结果区显示路径并带「清空结果」按钮；AI 工具返回 `report_md_path` / `report_json_path` |
 | **审计时总提示"首次会加载模型"** | 0.3.3 起只在模型尚未加载时提示；加载后按钮只显示「审计中…」，顶部状态显示「模型 已加载」 |
 | **有 NVIDIA 显卡（如 RTX 2060）但一直显示 CPU** | 说明装的是 CPU 版 torch（旧版安装器行为）。升级到 ≥0.3.3 后面板会给出提示；在插件目录运行 `node setup.mjs --reinstall-torch`（约 2.5 GB）装上 CUDA 版即可，之后重启 DSH |
+| **想强制用 GPU / CPU 版 torch** | 安装时加 `--force-cuda` / `--cpu`（配合 `--reinstall-torch` 可覆盖已装版本）；运行时设备由插件配置 `device`（auto/cpu/cuda）决定，`cuda` 需要 CUDA 版 torch |
 | 大文件审计几十秒 | 正常：全文滑窗逐窗推理，见 [docs/performance.md](docs/performance.md) |
 | 灰区全部转人工 | 没配凭据：在面板「凭据名 + API Key」保存，或设 `credentialRef`、或在 DSH Models 页配置 |
 | 正规第三方库被判 BLOCK | 压缩库充满 eval/base64 等特征，模型语料偏 Python 生态 → 属已知误报倾向，见 [docs/troubleshooting.md](docs/troubleshooting.md) |
@@ -272,7 +286,7 @@ dsh-CalibGuard/
 ├── engine/              从 CG_GUI 复制来的引擎核心（代码/词表/校准参数，不含 475 MB 权重）
 ├── cordis.patch.yml     组合包 patch（把插件行插进 profile 配置树）
 ├── scripts/             link-dsh（开发期挂包）、bridge-selftest（引擎自检）
-├── test/                node --test（95 个用例；缺引擎环境时自动 skip）
+├── test/                node --test（103 个用例；缺引擎环境时自动 skip）
 ├── .github/workflows/   publish.yml：npm 可信发布（OIDC，可选）
 └── docs/                配置全表、性能、排错、插件契约、实现决策
 ```

package/docs/configuration.md

@@ -30,6 +30,9 @@
 
 > **GPU 定档**：安装器检测到 NVIDIA 且 CUDA ≥ 12.8、算力 ≥ 7.5 时自动装 CUDA（cu128）版 torch，
 > 否则装 CPU 版。已经装成 CPU 版时：在插件目录运行 `node setup.mjs --reinstall-torch`。
+> 手动覆盖：`--force-cuda` / `--cpu`（或环境变量）决定**安装哪个 build**（面板顶部也有「一键重装 GPU 版 torch」按钮，走 `POST /install-torch`）；插件配置 `device`
+> （auto/cpu/cuda）决定**运行时用哪个设备**。CPU 版与 CUDA 版 torch 不能共存于同一个 venv
+>（同名包互斥）；CUDA 版在无 GPU 时也能跑 CPU。
 
 ## 二、参数优先级
 
@@ -70,6 +73,7 @@
 |---|---|
 | `DSH_CALIBGUARD_PYTHON` | 指定桥接进程使用的 Python 解释器（优先于 `<engineRoot>/.venv`） |
 | `DSH_CALIBGUARD_CPU_ONLY` | 设为 `1` 强制使用 CPU 版 torch（跳过 GPU 定档） |
+| `DSH_CALIBGUARD_FORCE_CUDA` | 设为 `1` 强制安装 CUDA 版 torch（跳过 CUDA 版本/算力检查，风险自负） |
 | `DSH_CALIBGUARD_DOWNLOAD_CONNECTIONS` | 大文件并发分段下载的连接数（默认 4；模型/引擎包下载提速） |
 | `DSH_CALIBGUARD_TORCH_INDEX` | CUDA 版 torch 的安装索引（默认 `https://download.pytorch.org/whl/cu128`） |
 | `DSH_CALIBGUARD_PIP_INDEX` | 指定 pip 主索引（默认依次尝试 清华 → 阿里 → 中科大 → 腾讯 → 官方） |

package/docs/troubleshooting.md

@@ -13,6 +13,8 @@
 | **审计结果在哪里 / 怎么清空** | 引擎 `reports/` 目录（默认 `<engineRoot>/reports`）：每次审计生成 JSON + Markdown；面板结果区显示路径并有「清空结果」，工具返回 `report_md_path` / `report_json_path` |
 | **每次审计都提示"首次会加载模型"** | 0.3.3 起仅在模型未加载时提示；加载后不再出现，顶部状态显示「模型 已加载」 |
 | **有 NVIDIA 显卡但引擎显示 CPU** | 装的是 CPU 版 torch。升级到 ≥0.3.3（面板顶部会提示），然后在插件目录运行 `node setup.mjs --reinstall-torch`（约 2.5 GB）装 CUDA 版；装完重启 DSH。`DSH_CALIBGUARD_CPU_ONLY=1` 可反向强制 CPU |
+| **已经装了 CPU 版 torch，想换成 GPU 版** | 升级到 ≥0.3.5：面板顶部点「一键重装 GPU 版 torch（约 2.5 GB）」（先卸载再装，完成自动重启桥接）；或命令行 `node "<插件目录>/setup.mjs" --reinstall-torch --force-cuda` |
+| **想强制装 GPU / CPU 版 torch** | 安装时加 `--force-cuda` / `--cpu`（可配合 `--reinstall-torch` 覆盖已装版本）；CPU 版与 CUDA 版不能共存于同一 venv，CUDA 版在无 GPU 时会自动回落 CPU |
 | **首次安装特别慢 / 提示某个源不可用** | 模型默认 4 路并发分段下载（`DSH_CALIBGUARD_DOWNLOAD_CONNECTIONS` 可调），GitHub 失败自动换 gh-proxy/ghfast/ghproxy 镜像；pip 自动在 清华/阿里/中科大/腾讯/官方 之间回退。实在慢可手动下载 `calibguard-model-1.0.0.zip` 放到缓存目录（见下一条） |
 | **模型下载失败 / 想离线** | 手动下载 `calibguard-model-1.0.0.zip`（Release `model-v1.0.0`），解压出 `model.safetensors` 放到 `~/.dsh/calibguard-tools/model-cache/model.safetensors`（或 `<engineRoot>/models/codebert_finetuned/`），重跑安装即会校验 SHA 并跳过下载 |
 | **首次运行卡在"正在准备环境"** | 正常：首次下载模型（约 442 MB，自动镜像回退）+ 装依赖（1–3 GB），约 10–20 分钟；面板顶部有进度与输出尾巴。若长时间无进度，可看 `~/.dsh/calibguard-tools/model-cache` 是否在增长 |

package/lib/client.js

@@ -345,6 +345,11 @@ window.__ModuleLoader__.load({
       var credName = credNameState[0]
       var setCredName = credNameState[1]
 
+      // torch 重装提示（面板按钮/结果）
+      var torchMsgState = useState('')
+      var torchMsg = torchMsgState[0]
+      var setTorchMsg = torchMsgState[1]
+
       var busyState = useState(false)
       var busy = busyState[0]
       var setBusy = busyState[1]
@@ -382,6 +387,15 @@ window.__ModuleLoader__.load({
         loadSettings()
       }, [])
 
+      useEffect(function () {
+        if (!torchRunning) return undefined
+        var timer = setInterval(refreshStatus, 3000)
+        return function () { clearInterval(timer) }
+      }, [torchRunning])
+      useEffect(function () {
+        if (torchState === 'done') refreshStatus()
+      }, [torchState])
+
       function applyStatus(payload) {
         var data = (payload && payload.status) || {}
         var llm = data.llm || {}
@@ -554,6 +568,19 @@ window.__ModuleLoader__.load({
         })
       }
 
+      function installTorch(mode) {
+        setTorchMsg('已启动重装 torch（后台进行，面板自动刷新进度）…')
+        apiFetch('/install-torch', {
+          method: 'POST',
+          headers: { 'content-type': 'application/json' },
+          body: JSON.stringify({ mode: mode }),
+        }).then(function () {
+          refreshStatus()
+        }).catch(function (err) {
+          setTorchMsg('重装启动失败：' + String((err && err.message) || err))
+        })
+      }
+
       function clearResult() {
         setResult(null)
         setReport(null)
@@ -610,9 +637,15 @@ window.__ModuleLoader__.load({
         || ''
       var devicePolicy = (engineInfo && engineInfo.devicePolicy) || null
       var setupScript = (status && status.setupScript) || '<插件目录>/setup.mjs'
-      // 有 NVIDIA 显卡、但 torch 没启用 CUDA（装的是 CPU 版）→ 提示怎么开 GPU
+      var torchJob = (status && status.torchJob) || null
+      var torchRunning = Boolean(torchJob && torchJob.state === 'running')
+      var torchState = (torchJob && torchJob.state) || 'idle'
+      var gpuInfo = (status && status.gpuTorch) || null
+      // 有 NVIDIA 显卡、但 torch 没启用 CUDA（装的是 CPU 版）→ 提示并允许一键重装
       var gpuTorchHint = engineInfo && engineInfo.cudaAvailable === false
-        && devicePolicy && devicePolicy.gpuName ? devicePolicy.gpuName : ''
+        && ((gpuInfo && gpuInfo.gpuName) || (devicePolicy && devicePolicy.gpuName))
+        ? ((gpuInfo && gpuInfo.gpuName) || (devicePolicy && devicePolicy.gpuName))
+        : ''
       var engineReady = Boolean(engineInfo)
       var envBusy = Boolean(envInfo) && !engineReady && envInfo.state !== 'failed'
       var envFailed = Boolean(envInfo) && !engineReady && envInfo.state === 'failed'
@@ -646,13 +679,62 @@ window.__ModuleLoader__.load({
                   + ' ｜ ' + devicePolicy.reason,
               })
               : null,
-            gpuTorchHint
-              ? jsx('div', {
-                style: S.note,
-                children: '检测到 NVIDIA ' + gpuTorchHint + '，但当前 torch 是 CPU 版，审计会走 CPU。'
-                  + '要启用 GPU（RTX 20/30/40 系需算力 ≥7.5 且 CUDA ≥12.8）：'
-                  + '在插件目录运行 node "' + setupScript + '" --reinstall-torch（约 2.5 GB），'
-                  + '装完重启 DSH；或重装插件到最新版会自动选 CUDA 版 torch。',
+            gpuTorchHint && torchState !== 'running'
+              ? jsxs('div', {
+                style: S.card,
+                children: [
+                  jsx('div', { style: S.cardTitle, children: '检测到 NVIDIA ' + gpuTorchHint + '，但当前 torch 是 CPU 版' }),
+                  jsx('div', {
+                    style: S.muted,
+                    children: 'CPU 版与 GPU 版 torch 不能共存于同一个 venv，重装会先卸载当前的再装 CUDA（cu128）版'
+                      + '（约 2.5 GB，下载走 PyTorch 官方源）。装完桥接会自动重启，无需重启 DSH。',
+                  }),
+                  jsxs('div', {
+                    style: S.row,
+                    children: [
+                      jsx('button', {
+                        style: S.buttonPrimary,
+                        onClick: function () { installTorch('cuda') },
+                        children: '一键重装 GPU 版 torch（约 2.5 GB）',
+                      }),
+                      jsx('button', {
+                        style: S.button,
+                        onClick: function () { installTorch('auto') },
+                        children: '按自动定档重装',
+                      }),
+                      torchMsg ? jsx('span', { style: S.muted, children: torchMsg }) : null,
+                    ],
+                  }),
+                  torchState === 'done'
+                    ? jsx('div', { style: { color: C.allow, fontSize: 12, marginTop: 6 }, children: torchMsg || 'torch 重装完成（如仍显示 CPU，点「刷新状态」）' })
+                    : null,
+                  torchState === 'failed'
+                    ? jsx('div', {
+                      style: { color: C.error, fontSize: 12, whiteSpace: 'pre-wrap', marginTop: 6 },
+                      children: '重装失败：' + ((torchJob && (torchJob.error || torchJob.message)) || '详见日志')
+                        + '\n手动方式：node "' + setupScript + '" --reinstall-torch --force-cuda',
+                    })
+                    : null,
+                  jsx('div', {
+                    style: S.note,
+                    children: '不想用面板也可以手动运行：node "' + setupScript + '" --reinstall-torch --force-cuda',
+                  }),
+                ],
+              })
+              : null,
+            torchRunning
+              ? jsxs('div', {
+                style: S.card,
+                children: [
+                  jsx('div', { style: S.cardTitle, children: '正在重装 torch…' }),
+                  jsx('div', { style: S.muted, children: (torchJob && (torchJob.step || torchJob.message)) || '准备中…' }),
+                  torchJob && torchJob.tail && torchJob.tail.length > 0
+                    ? jsx('pre', {
+                      style: Object.assign({}, S.pre, { maxHeight: 140, marginTop: 8 }),
+                      children: torchJob.tail.slice(-5).join('\n'),
+                    })
+                    : null,
+                ],
               })
               : null,
 

package/lib/engine.js

@@ -32,6 +32,8 @@ import { EnvironmentBootstrap, venvPythonPath } from './bootstrap.js'
 
 /** 桥接脚本相对本文件的位置（spawn 需要真实路径，不能直接把 URL 对象交给子进程）。 */
 const BRIDGE_SCRIPT = fileURLToPath(new URL('../bridge/calibguard_bridge.py', import.meta.url))
+/** 安装器脚本（面板「重装 GPU 版 torch」会调用它）。 */
+const SETUP_SCRIPT = fileURLToPath(new URL('../setup.mjs', import.meta.url))
 
 /** 单次 status 请求的默认超时（毫秒）：只做文件探测与 torch 导入，很快。 */
 const STATUS_TIMEOUT_MS = 60_000
@@ -71,6 +73,9 @@ export class CalibGuardEngine {
     this.statusCache = null
     /** 最近一次凭据解析结果（只用于诊断，不缓存值给下次复用）。 */
     this.lastCredential = { source: 'none', configured: false }
+    /** 面板「重装 torch」任务状态（CPU 版 → GPU 版一键替换用）。 */
+    this.torchJob = { state: 'idle', step: '', message: '', tail: [], startedAt: null, finishedAt: null, error: null }
+    this.torchChild = null
     /**
      * 首次运行自动准备环境（对齐 CG_GUI 的 launcher 首启装环境）：
      * 缺 `<engineRoot>/.venv` 时在后台跑 setup.mjs（内置引擎 + npm 模型分片 → 建 venv → 装依赖）。
@@ -156,6 +161,9 @@ export class CalibGuardEngine {
     const ref = this.effectiveCredentialRef()
     if (!ref) {
       this.lastCredential = { source: 'none', configured: false }
+    /** 面板「重装 torch」任务状态（CPU 版 → GPU 版一键替换用）。 */
+    this.torchJob = { state: 'idle', step: '', message: '', tail: [], startedAt: null, finishedAt: null, error: null }
+    this.torchChild = null
       return { key: undefined, source: 'none' }
     }
 
@@ -274,6 +282,121 @@ export class CalibGuardEngine {
     )
   }
 
+  /**
+   * GPU/CPU torch 状态（面板据此决定是否显示「重装 GPU 版」）。
+   * 数据来自最近一次 status 快照：gpuName 仅当检测到 NVIDIA；cudaAvailable=torch 是否启用 CUDA。
+   */
+  gpuTorchStatus() {
+    const status = this.statusCache
+    if (!status) return { gpuName: null, cudaAvailable: null, device: null, policyMode: null, reason: '' }
+    const policy = status.devicePolicy || {}
+    return {
+      gpuName: policy.gpuName ?? null,
+      cudaAvailable: status.cudaAvailable ?? null,
+      device: status.device ?? null,
+      policyMode: policy.mode ?? null,
+      reason: policy.reason ?? '',
+    }
+  }
+
+  /** 重装 torch 任务快照。 */
+  torchJobSnapshot() {
+    const job = this.torchJob
+    return {
+      state: job.state,
+      step: job.step,
+      message: job.message,
+      startedAt: job.startedAt,
+      finishedAt: job.finishedAt,
+      error: job.error,
+      tail: [...job.tail],
+    }
+  }
+
+  /**
+   * 重装 torch（CPU 版 ↔ GPU 版互斥，先卸载再装），完成后停掉桥接让下次请求用新的 torch。
+   * @param {'auto'|'cuda'|'cpu'} [mode] auto=按自动定档；cuda=强制 CUDA 版（跳过兼容检查）；cpu=强制 CPU 版
+   */
+  async installTorch(mode = 'auto') {
+    if (this.torchJob.state === 'running') return this.torchJobSnapshot()
+    if (!['auto', 'cuda', 'cpu'].includes(mode)) throw new Error('mode 必须是 auto / cuda / cpu')
+    if (!existsSync(venvPythonPath(this.config.engineRoot))) {
+      throw new Error('环境还没准备好（缺 .venv）：请先完成首次环境准备再重装 torch。')
+    }
+    this.torchJob = {
+      state: 'running', step: '', message: '正在重装 torch…', tail: [],
+      startedAt: Date.now(), finishedAt: null, error: null,
+    }
+    const extra = ['--reinstall-torch']
+    if (mode === 'cuda') extra.push('--force-cuda')
+    if (mode === 'cpu') extra.push('--cpu')
+    const args = [SETUP_SCRIPT, '--dest', this.config.engineRoot, '--skip-verify', ...extra]
+    this.logger?.info?.(`[calibguard] 重装 torch：node setup.mjs ${args.slice(1).join(' ')}`)
+
+    const finish = new Promise((resolvePromise) => {
+      const child = spawn(process.execPath, args, {
+        cwd: this.config.engineRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+      })
+      this.torchChild = child
+      const onLine = (line) => {
+        const text = String(line).trim()
+        if (!text) return
+        this.torchJob.tail.push(text)
+        if (this.torchJob.tail.length > 20) this.torchJob.tail.shift()
+        const stepMatch = /^==\s*(.+?)\s*==$/.exec(text)
+        if (stepMatch) {
+          this.torchJob.step = stepMatch[1]
+          this.torchJob.message = `${stepMatch[1]}…`
+          return
+        }
+        this.torchJob.message = text
+      }
+      const wire = (stream) => {
+        let buffer = ''
+        stream.setEncoding('utf8')
+        stream.on('data', (chunk) => {
+          buffer += chunk
+          const lines = buffer.split(/\r?\n/)
+          buffer = lines.pop() ?? ''
+          for (const line of lines) onLine(line)
+        })
+        stream.on('end', () => { if (buffer) onLine(buffer) })
+      }
+      wire(child.stdout)
+      wire(child.stderr)
+      child.on('error', (error) => {
+        this.torchJob.state = 'failed'
+        this.torchJob.error = String(error?.message ?? error)
+        this.torchJob.message = `重装失败：${this.torchJob.error}`
+        this.torchJob.finishedAt = Date.now()
+        this.torchChild = null
+        resolvePromise(this.torchJobSnapshot())
+      })
+      child.on('close', async (code) => {
+        this.torchChild = null
+        this.torchJob.finishedAt = Date.now()
+        if (code === 0) {
+          this.torchJob.state = 'done'
+          this.torchJob.step = ''
+          this.torchJob.message = 'torch 重装完成，桥接将重启以使用新的 torch'
+          this.statusCache = null
+          try { await this.stop('torch-reinstalled') } catch { /* 忽略 */ }
+          this.logger?.info?.('[calibguard] torch 重装完成，桥接已停止（下次调用重启）')
+        } else {
+          this.torchJob.state = 'failed'
+          this.torchJob.error = `setup.mjs 退出码 ${code}`
+          this.torchJob.message = `重装失败（${this.torchJob.error}）：${this.torchJob.tail.slice(-3).join(' ｜ ')}`
+          this.logger?.warn?.(`[calibguard] ${this.torchJob.message}`)
+        }
+        resolvePromise(this.torchJobSnapshot())
+      })
+    })
+    this.torchJob.promise = finish
+    return finish
+  }
+
   // ============================== 进程生命周期 ==============================
 
   /** 启动常驻桥接进程（已启动则直接返回）。子进程环境经过凭据清洗。 */
@@ -503,6 +626,8 @@ export class CalibGuardEngine {
       credentialRef: this.effectiveCredentialRef() || null,
       credentialWritable: typeof this.credentials?.set === 'function',
       environment: this.bootstrap.snapshot(),
+      torchJob: this.torchJobSnapshot(),
+      gpuTorch: this.gpuTorchStatus(),
       settings: this.settings(),
       stderrTail: [...this.stderrTail],
     }

package/lib/routes.js

@@ -149,6 +149,8 @@ export function createCalibGuardRoutes({ engine, config, logger, settingsStore }
           credentialRef: diagnostics.credentialRef ?? null,
           credentialWritable: Boolean(diagnostics.credentialWritable),
           setupScript,
+          torchJob: typeof engine.torchJobSnapshot === 'function' ? engine.torchJobSnapshot() : null,
+          gpuTorch: typeof engine.gpuTorchStatus === 'function' ? engine.gpuTorchStatus() : null,
           settings: engine.settings(),
           settingsFile: settingsStore?.file ?? null,
         })
@@ -180,6 +182,8 @@ export function createCalibGuardRoutes({ engine, config, logger, settingsStore }
           credentialRef: diagnostics.credentialRef ?? null,
           credentialWritable: Boolean(diagnostics.credentialWritable),
           setupScript,
+          torchJob: typeof engine.torchJobSnapshot === 'function' ? engine.torchJobSnapshot() : null,
+          gpuTorch: typeof engine.gpuTorchStatus === 'function' ? engine.gpuTorchStatus() : null,
           settings: engine.settings(),
           settingsFile: settingsStore?.file ?? null,
         })
@@ -216,6 +220,30 @@ export function createCalibGuardRoutes({ engine, config, logger, settingsStore }
     }
   }
 
+  /** POST /install-torch —— 面板「重装 GPU/CPU 版 torch」。启动后台任务，进度走 /status 的 torchJob。 */
+  async function handleInstallTorch(req, res) {
+    if (req.method !== 'POST') return sendJson(res, 405, { error: '仅支持 POST' })
+    try {
+      const body = await readBody(req, 1024 * 1024)
+      let payload
+      try {
+        payload = JSON.parse(body.toString('utf8') || '{}')
+      } catch {
+        return sendJson(res, 400, { error: '请求体必须是合法 JSON' })
+      }
+      const mode = typeof payload?.mode === 'string' ? payload.mode : 'auto'
+      if (typeof engine.installTorch !== 'function') {
+        return sendJson(res, 503, { error: '当前插件版本不支持重装 torch' })
+      }
+      engine.installTorch(mode).catch((error) => {
+        logger?.warn?.(`[calibguard] 重装 torch 失败：${error?.message ?? error}`)
+      })
+      sendJson(res, 200, { ok: true, started: true, mode })
+    } catch (error) {
+      sendJson(res, 400, { error: String(error?.message ?? error) })
+    }
+  }
+
   /** POST /audit */
   async function handleAudit(req, res) {
     if (req.method !== 'POST') return sendJson(res, 405, { error: '仅支持 POST' })
@@ -308,6 +336,7 @@ export function createCalibGuardRoutes({ engine, config, logger, settingsStore }
     state,
     routes: [
       { kind: 'exact', path: `${ROUTE_PREFIX}/status`, handler: handleStatus },
+      { kind: 'exact', path: `${ROUTE_PREFIX}/install-torch`, handler: handleInstallTorch },
       { kind: 'exact', path: `${ROUTE_PREFIX}/audit`, handler: handleAudit },
       { kind: 'exact', path: `${ROUTE_PREFIX}/report`, handler: handleReport },
       { kind: 'exact', path: `${ROUTE_PREFIX}/settings`, handler: async (req, res) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-calibguard",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "publishConfig": {
     "access": "public"
   },

package/setup.mjs

@@ -123,10 +123,25 @@ function detectGpu() {
   return { hasNvidia: true, gpuName, computeCap, cudaVersion }
 }
 
-/** 是否需要安装 CUDA 版 torch（与 CG_GUI launcher 同款「CUDA 版本 + 算力」双检）。 */
-function decideCudaTorch(gpu) {
-  if (String(process.env.DSH_CALIBGUARD_CPU_ONLY || '') === '1') {
-    return { useCuda: false, reason: 'DSH_CALIBGUARD_CPU_ONLY=1，强制 CPU' }
+/**
+ * 是否需要安装 CUDA 版 torch。
+ * 优先级（高 → 低）：--cpu / DSH_CALIBGUARD_CPU_ONLY=1 ＞ --force-cuda / DSH_CALIBGUARD_FORCE_CUDA=1
+ * ＞ auto（CG_GUI launcher 同款「CUDA 版本 + 算力」双检）。
+ * 说明：CUDA 版 torch 在没有 GPU 时也能正常跑 CPU，所以「强制 CUDA」只是安装时跳过兼容性检查；
+ * 风险：cu128 轮子里没有该显卡算力的 kernel 时，运行期会回落 CPU 或报错（自担）。
+ */
+function decideCudaTorch(gpu, options = {}) {
+  if (options.forceCpu || String(process.env.DSH_CALIBGUARD_CPU_ONLY || '') === '1') {
+    return { useCuda: false, reason: options.forceCpu ? '--cpu 指定' : 'DSH_CALIBGUARD_CPU_ONLY=1，强制 CPU' }
+  }
+  if (options.forceCuda || String(process.env.DSH_CALIBGUARD_FORCE_CUDA || '') === '1') {
+    return {
+      useCuda: true,
+      forced: true,
+      reason: options.forceCuda
+        ? '--force-cuda 显式强制（跳过 CUDA/算力检查，风险自负）'
+        : 'DSH_CALIBGUARD_FORCE_CUDA=1 强制（跳过 CUDA/算力检查，风险自负）',
+    }
   }
   if (!gpu.hasNvidia) return { useCuda: false, reason: '未检测到 NVIDIA 显卡（nvidia-smi 不可用）' }
   if (!gpu.cudaVersion || cmpVersion(gpu.cudaVersion, CUDA_MIN) < 0) {
@@ -311,6 +326,8 @@ function parseArgs(argv) {
     noPortablePython: false,
     forcePortablePython: false,
     reinstallTorch: false,
+    forceCuda: false,
+    forceCpu: false,
     help: false,
   }
   for (let i = 0; i < argv.length; i += 1) {
@@ -334,6 +351,8 @@ function parseArgs(argv) {
       case '--no-portable-python': options.noPortablePython = true; break
       case '--force-portable-python': options.forcePortablePython = true; break
       case '--reinstall-torch': options.reinstallTorch = true; break
+      case '--force-cuda': options.forceCuda = true; break
+      case '--cpu': options.forceCpu = true; break
       default: fail(`未知参数：${arg}（用 --help 查看用法）`)
     }
   }
@@ -360,6 +379,8 @@ function printHelp() {
   --no-portable-python  本机没有 Python 时不自动下载便携版（默认会自动下载）
   --force-portable-python  跳过本机 Python 检测，强制用便携版（测试用）
   --reinstall-torch 重新安装 torch（检测到 NVIDIA 时装 CUDA/cu128 版，约 2.5 GB）
+  --force-cuda      安装时强制选 CUDA 版 torch（跳过 CUDA版本/算力检查，风险自负）
+  --cpu             安装时强制选 CPU 版 torch
   -h, --help        显示本帮助
 
 示例：
@@ -378,7 +399,10 @@ function printHelp() {
     可用 DSH_CALIBGUARD_PIP_INDEX 指定其它索引；
   • 从 npm 安装时引擎默认放在 ~/.dsh/calibguard-engine（可用 --dest 或插件配置 engineRoot 指定）；
   • GPU 自动定档：检测到 NVIDIA 且 CUDA≥12.8、算力≥7.5（如 RTX 20/30/40 系）时
-    自动安装 CUDA（cu128）版 torch；否则用 CPU 版；可用 DSH_CALIBGUARD_CPU_ONLY=1 强制 CPU；
+    自动安装 CUDA（cu128）版 torch；否则用 CPU 版；
+    - 手动覆盖：--force-cuda（强制 GPU 版）/ --cpu（强制 CPU 版），
+      或环境变量 DSH_CALIBGUARD_FORCE_CUDA=1 / DSH_CALIBGUARD_CPU_ONLY=1；
+    - CUDA 版 torch 在无 GPU 时也能跑 CPU，两者**不能同时装在同一个 venv**（同名包互斥）；
   • 大文件（模型/引擎包）默认 4 路并发分段下载，可用 DSH_CALIBGUARD_DOWNLOAD_CONNECTIONS 调整；
   • 装完想换 GPU/CPU 版 torch：node setup.mjs --reinstall-torch。
 `)
@@ -1003,7 +1027,10 @@ async function main() {
     // GPU 定档：有可用 NVIDIA（CUDA≥12.8、算力≥7.5）时先装 CUDA 版 torch，
     // 与 CG_GUI launcher 的口径一致；否则装 CPU 版 torch。
     const gpu = detectGpu()
-    const decision = decideCudaTorch(gpu)
+    const decision = decideCudaTorch(gpu, options)
+    if (decision.forced && !gpu.hasNvidia) {
+      warn('强制 CUDA 但未检测到 NVIDIA 显卡：torch 会安装成功，但运行期仍会回落 CPU。')
+    }
     const gpuLabel = gpu.gpuName ? `（${gpu.gpuName}）` : ''
     log(`GPU 定档：${decision.useCuda ? 'CUDA（cu128）' : 'CPU'} —— ${decision.reason}${gpuLabel}`)
     const existingTorchCuda = installedTorchCuda(python)
@@ -1030,8 +1057,8 @@ async function main() {
     const finalTorchCuda = installedTorchCuda(python)
     log(`torch CUDA：${finalTorchCuda || '无（CPU 版）'}`)
     if (decision.useCuda && !finalTorchCuda) {
-      warn('检测到可用 GPU 但 torch 是 CPU 版：审计仍可运行，只是用 CPU。'
-        + '可重跑：node setup.mjs --reinstall-torch')
+      warn('当前 torch 是 CPU 版：审计仍可运行，只是用 CPU。'
+        + '可重跑：node setup.mjs --reinstall-torch（或 --force-cuda 跳过兼容性检查）')
     }
     log('✓ 依赖安装完成')
   }