@noob-stupid/dsh-plugin-console 0.3.52 → 0.3.54

package/lib/index.js

@@ -591,6 +591,250 @@ async function removeBundleFromManifest(profileDir, bundlePkg) {
   })
 }
 
+// ============================================================
+// 撤销「已安装但尚未生效」的安装（POST /uninstall { jobId } 的落地实现）
+//
+// 为什么需要（2026-09-20 真装真卸演练实测）：面板装完一个 bundle 型插件后 /install 返回 entryId: null、
+// GET /state 里**新增 loader 条目 = 0**（bundle 型要重启才被加载），而 /uninstall 只按**运行中** loader
+// 条目查找 → 恒 404「没有名为 X 的插件条目」——刚装错的插件在重启前无法从面板卸载，用户只能手改 patch
+// + package.json + 删 node_modules 才能撤回。安装任务里其实记着撤销所需的信息：
+// job.packageName（装成了什么）/ job.bundle（是否注册进 dsh.profile.bundles）/ job.entryId（追加的补丁行）。
+//
+// ★ 三个子项各自 try/catch + **回读核实**，绝不 throw：补丁行 / bundles 清单 / 包目录。删除类操作在本机
+//   某些环境下会**静默落空**（不抛错、目录仍在，见 removeDirVerified 注释），删完直接报成功就是对用户撒谎。
+// ============================================================
+
+/** 插件控制台自身的包名（撤销分支禁止删自己；@deepseek-ai/* 由通用护栏拒绝）。 */
+const CONSOLE_PACKAGE = name
+
+/** profile 内 node_modules/<pkg> 的目录（作用域包按 / 分段，与 pnpm 布局一致）。 */
+function packageDirIn(profileDir, packageName) {
+  const name = String(packageName)
+  const segments = name.startsWith('@') ? name.split('/') : [name]
+  return join(profileDir, 'node_modules', ...segments)
+}
+
+/** profile 的 package.json 是否还把这个包当依赖（pnpm add 会写进 dependencies）。 */
+async function manifestRefsPackage(profileDir, packageName) {
+  try {
+    const manifest = JSON.parse(await readFile(join(profileDir, 'package.json'), 'utf8'))
+    return ['dependencies', 'devDependencies', 'optionalDependencies', 'peerDependencies']
+      .some((key) => manifest?.[key] !== null && typeof manifest?.[key] === 'object'
+        && Object.prototype.hasOwnProperty.call(manifest[key], packageName))
+  } catch {
+    return false
+  }
+}
+
+/** 这个包是否还需要一次 pnpm remove：目录还在盘上，或 manifest 还引用它。
+ * 两者都不成立时拉 pnpm 只会换来一句没有信息量的 `Command failed: corepack pnpm remove …`（演练实测）
+ * —— 但 manifest 仍引用时必须跑，否则 package.json 会留下指向空目录的幽灵依赖。 */
+async function needsPnpmRemove(profileDir, packageName) {
+  return existsSync(packageDirIn(profileDir, packageName)) || await manifestRefsPackage(profileDir, packageName)
+}
+
+/** bundle 包自带 patch（node_modules/<pkg>/cordis.patch.yml）里**归属该包**的 insert 行 id。
+ * 为什么要它：这类行由 bundle 的补丁在下次启动时组合进树，profile 补丁里没有 insert 块，但可能留着
+ * 它们的 `- id: X` + `disabled: true` 覆盖块（聚合包完整性检查自动禁用 / 用户手动停用）。
+ * 只认模块名等于该包或它的子路径的行 —— 聚合包补丁里常引用**别人家**的包（如 @deepseek-ai/dsh-root），
+ * 那些行的覆盖块不属于本次撤销，动了就是越界。 */
+async function bundleOwnRowIds(profileDir, packageName) {
+  const ids = new Set()
+  try {
+    const text = await readFile(join(packageDirIn(profileDir, packageName), 'cordis.patch.yml'), 'utf8')
+    for (const [rowId, moduleName] of parseInsertNames(text)) {
+      if (moduleName === packageName || String(moduleName).startsWith(`${packageName}/`)) ids.add(rowId)
+    }
+  } catch {}
+  return ids
+}
+
+/**
+ * 撤销一个「已安装但未生效」的安装任务。三个子项各自 try/catch，成败如实汇报；本函数不抛错。
+ * 返回 { packageName, bundle, rowIds, verified: { patchClean, bundlesClean, packageGone }, warn, uninstallError }
+ */
+export async function revokePendingInstall(job, { profileDir, patchPath, pnpmRemove: removeFn }) {
+  const packageName = typeof job?.packageName === 'string' ? job.packageName.trim() : ''
+  const isBundle = job?.bundle === true
+  // 兜底（路由已先拦）：没有包名就什么都别碰 —— 靠 entryId 单点删除可能误伤别的包
+  if (packageName === '') {
+    return {
+      packageName, bundle: isBundle, rowIds: [],
+      verified: { patchClean: false, bundlesClean: false, packageGone: false },
+      warn: '该安装任务没有记录包名，未执行任何删除（补丁行 / bundles 清单 / 包目录都未处理）',
+      uninstallError: null,
+    }
+  }
+  // ── a) 补丁行：删掉这次安装注册的 insert 行 + 它的 disabled/forced 覆盖块 ──────────
+  const rowIds = new Set()
+  let patchClean = false
+  let patchProblem = null
+  try {
+    const before = await readPatchState(patchPath)
+    const declared = parseInsertNames(before.text) // insert 行 id → 模块名
+    if (typeof job?.entryId === 'string' && job.entryId !== '') {
+      const owner = declared.get(job.entryId)
+      // 补丁里这一行若明确属于**别的包**，绝不按 entryId 删（归属判定以补丁文本为准）
+      if (owner === undefined || owner === packageName) rowIds.add(job.entryId)
+    }
+    for (const [rowId, moduleName] of declared) if (moduleName === packageName) rowIds.add(rowId)
+    for (const rowId of await bundleOwnRowIds(profileDir, packageName)) rowIds.add(rowId)
+    for (const rowId of rowIds) {
+      if (before.inserts.includes(rowId)) await removeInsertRow(patchPath, rowId)
+      await removeDisableBlock(patchPath, rowId)
+    }
+    // 回读核实：目标行（insert / disabled / forced）都不在了，补丁文本也不该再出现这个包名
+    const after = await readPatchState(patchPath)
+    const leakedRows = [...rowIds].filter((id) => after.inserts.includes(id) || after.disables.includes(id) || after.forced.includes(id))
+    const leakedNames = [...parseInsertNames(after.text).values()].filter((name) => name === packageName)
+    patchClean = leakedRows.length === 0 && leakedNames.length === 0 && !String(after.text ?? '').includes(packageName)
+    if (!patchClean) patchProblem = `仍有残留行 ${[...new Set([...leakedRows, ...leakedNames])].join('、') || packageName}`
+  } catch (error) {
+    patchProblem = error instanceof Error ? error.message : String(error)
+  }
+  // ── b) bundles 清单：只删这一个包名（保留顺序、保留其余项）──────────────────────
+  let bundlesClean = !isBundle
+  let bundlesProblem = null
+  if (isBundle) {
+    try {
+      await removeBundleFromManifest(profileDir, packageName)
+      const manifest = JSON.parse(await readFile(join(profileDir, 'package.json'), 'utf8'))
+      bundlesClean = !(manifest?.dsh?.profile?.bundles ?? []).includes(packageName)
+      if (!bundlesClean) bundlesProblem = `dsh.profile.bundles 里仍有 ${packageName}`
+    } catch (error) {
+      bundlesProblem = error instanceof Error ? error.message : String(error)
+    }
+  }
+  // ── c) 包目录：pnpm remove（与安装同一管理器）──────────────────────────────────
+  const packageDir = packageDirIn(profileDir, packageName)
+  let uninstallError = null
+  if (await needsPnpmRemove(profileDir, packageName)) {
+    try {
+      await removeFn(profileDir, packageName)
+    } catch (error) {
+      uninstallError = error instanceof Error ? error.message : String(error)
+    }
+  }
+  const packageGone = !existsSync(packageDir)
+  // ── d) 核实汇总：任一子项没清干净 → ok 仍为 true，但必须带 warn 说清是哪项、路径在哪 ──
+  const verified = { patchClean, bundlesClean, packageGone }
+  const problems = []
+  if (!patchClean) problems.push(`补丁未清干净（${patchPath}）：${patchProblem ?? '仍有残留行'}`)
+  if (!bundlesClean) problems.push(`bundles 清单未清干净（${join(profileDir, 'package.json')}）：${bundlesProblem ?? `仍有 ${packageName}`}`)
+  if (!packageGone) problems.push(`包目录仍在（${packageDir}）${uninstallError !== null ? `，pnpm remove 失败：${uninstallError}` : ''}`)
+  const warn = problems.length > 0 ? `撤销未完全生效 —— ${problems.join('；')}；请手动处理后重试` : null
+  return { packageName, bundle: isBundle, rowIds: [...rowIds], verified, warn, uninstallError }
+}
+
+/**
+ * 「已安装 · 重启后生效」清单：status === 'done'、未撤销、有包名，且该包**不在**运行中的 loader 条目里。
+ * bundle 型插件要重启才被加载（演练实测：装完新增 loader 条目 = 0），前端据此把这类任务渲染成带待重启
+ * 徽标的行，并允许按 jobId 撤销。entries 传 listEntries(ctx) 的结果（含子路径条目 → 归一到根包名再比）。
+ */
+function pendingRestartJobs(jobs, entries) {
+  const running = new Set()
+  for (const entry of entries ?? []) {
+    const moduleName = entry?.moduleName
+    if (typeof moduleName !== 'string' || moduleName === '' || moduleName.startsWith('cordis:')) continue
+    running.add(moduleName)
+    const root = packageNameOf(moduleName)
+    if (typeof root === 'string' && root !== '') running.add(root)
+  }
+  // 同一包名的多次安装/更新（安装表里会有多条 done 记录）只留最后一次：
+  // 否则一个插件在面板上会出现好几行「已安装·重启后生效」。
+  const latest = new Map()
+  for (const job of jobs ?? []) {
+    if (job?.status !== 'done' || job.revokedAt !== undefined) continue
+    if (typeof job.packageName !== 'string' || job.packageName.trim() === '') continue
+    if (running.has(job.packageName)) continue
+    latest.set(job.packageName, job)
+  }
+  return [...latest.values()].map((job) => ({
+    jobId: job.id,
+    repo: job.repo ?? null,
+    packageName: job.packageName,
+    bundle: job.bundle === true,
+    finishedAt: job.finishedAt ?? null,
+  }))
+}
+
+/** 把与这次删除对应的「已安装·重启后生效」任务记为已撤销（/state 的 pendingRestart 据此过滤）。
+ * 为什么两处都要调：无论按 entryId（重启后从列表删）还是按 jobId（重启前撤销）删掉一个包，它的安装任务
+ * 若还挂着 status==='done'，/state 就会继续显示一行删不掉的幽灵行。同一包名的多条记录（装过又更新过）
+ * 一并作废 —— 它们指向同一个包。 */
+function markJobsRevoked(packageName, rowId) {
+  for (const job of installJobs.values()) {
+    if (job.status !== 'done' || job.revokedAt !== undefined) continue
+    if (job.packageName === packageName || (typeof rowId === 'string' && rowId !== '' && job.entryId === rowId)) {
+      job.revokedAt = Date.now()
+    }
+  }
+}
+
+/**
+ * 按安装任务撤销「已安装但尚未生效」的安装（/uninstall 的 jobId 分支）。
+ * 安全护栏与 entry 分支完全一致：@deepseek-ai/* · isProtectedModule · 控制台自身。
+ */
+async function uninstallByJobId(ctx, res, jobId) {
+  const job = installJobs.get(jobId)
+  if (job === undefined) {
+    sendError(res, 404, `没有这个安装任务（jobId=${jobId}）——无法撤销`)
+    return
+  }
+  if (job.revokedAt !== undefined) {
+    sendError(res, 400, `该安装任务已经撤销过了（${new Date(job.revokedAt).toISOString()}），无需重复操作`)
+    return
+  }
+  if (job.status !== 'done') {
+    sendError(res, 400, job.status === 'installing'
+      ? `该安装任务还在进行中（stage=${job.stage ?? '?'}），完成后才能撤销`
+      : `该安装任务没有成功装成（status=${job.status}${job.error ? `：${job.error}` : ''}），没有可撤销的安装`)
+    return
+  }
+  const packageName = typeof job.packageName === 'string' ? job.packageName.trim() : ''
+  if (packageName === '') {
+    sendError(res, 400, '该安装任务没有记录包名（可能未装成、或已由现有聚合包提供），无法按任务撤销')
+    return
+  }
+  if (packageName.startsWith('@deepseek-ai/')) {
+    sendError(res, 403, `${packageName} 是 DSH 框架官方包，禁止删除`)
+    return
+  }
+  if (isProtectedModule(packageName)) {
+    sendError(res, 403, `${packageName} 属于宿主基础设施，禁止删除`)
+    return
+  }
+  const rowId = typeof job.entryId === 'string' && job.entryId !== '' ? job.entryId : deriveEntryId(packageName, new Set())
+  if (rowId === 'plugin-console' || packageName === CONSOLE_PACKAGE) {
+    sendError(res, 400, '不能删除插件控制台自身')
+    return
+  }
+  // 本分支只服务「已安装但尚未生效」：包名若已在运行中的 loader 条目里（重启已完成），撤销会留下
+  // 「包已删、模块还挂在内存里」的半状态 —— 如实拒绝并指路（按列表条目删除）。
+  if (pendingRestartJobs([job], listEntries(ctx)).length === 0) {
+    sendError(res, 400, `「${packageName}」已经在运行中的插件列表里（重启已完成）——请直接在列表里删除该条目，不必按 jobId 撤销`)
+    return
+  }
+  const patchPath = findPatchPath(ctx)
+  const profileDir = dirname(patchPath)
+  const result = await revokePendingInstall(job, { profileDir, patchPath, pnpmRemove })
+  // 只有包目录真的没了才算「这次安装已撤销」：此后不再出现在 /state 的 pendingRestart 里。
+  // 包还在盘上时不打这个标记 —— 保留待重启条目让用户能再点一次删除，比假装干净好。
+  if (result.verified.packageGone === true) markJobsRevoked(result.packageName, typeof job.entryId === 'string' ? job.entryId : null)
+  sendJson(res, 200, {
+    ok: true,
+    removed: 'pending-install',
+    jobId,
+    packageName: result.packageName,
+    bundle: result.bundle,
+    restart: false,
+    rowIds: result.rowIds,
+    verified: result.verified,
+    warn: result.warn,
+    uninstallError: result.uninstallError,
+  })
+}
+
 /** 用 corepack pnpm 移除包（与安装同一管理器与凭据抑制环境）。
  * 注意：pnpm remove 不支持 --registry 选项，去掉避免静默失败。 */
 export async function pnpmRemove(profileDir, packageName) {
@@ -632,6 +876,53 @@ function cleanupStalePackageDir(profileDir, packageName) {
   return removed
 }
 
+/** 安装失败清场：把本次尝试过的候选包目录与 pnpm `_tmp_` 半成品一起清掉，并**如实汇报**清了什么、
+ * 什么没清掉。为什么需要（2026-09-20 真装演练）：11 个子包的聚合仓库跑 19 分钟后失败，node_modules 里
+ * 留着 `@captain1275/dsh-full-stats_tmp_56272_2` 这类半成品和一个真包，而面板只报"安装失败"——
+ * 用户既不知道有东西被落盘，也不知道要不要手动清。删除一律走 removeDirVerified（本机 C 盘/`%TEMP%`
+ * 下 rmSync 会静默落空，不核实就会谎报干净）。 */
+export function cleanupAttemptedCandidates(profileDir, candidates) {
+  const cleaned = []
+  const failed = []
+  for (const name of candidates) {
+    const dir = join(profileDir, 'node_modules', ...String(name).split('/'))
+    const parent = dirname(dir)
+    const base = basename(dir)
+    let touched = 0
+    if (existsSync(dir)) {
+      const result = removeDirVerified(dir)
+      if (result.ok) touched += 1
+      else failed.push({ name, path: dir, error: result.error })
+    }
+    try {
+      for (const entry of readdirSync(parent)) {
+        if (!entry.startsWith(`${base}_tmp_`)) continue
+        const tmpPath = join(parent, entry)
+        const result = removeDirVerified(tmpPath)
+        if (result.ok) touched += 1
+        else failed.push({ name: `${name}（临时目录）`, path: tmpPath, error: result.error })
+      }
+    } catch {}
+    if (touched > 0) cleaned.push(name)
+  }
+  return { cleaned, failed }
+}
+
+/** 授权被拒/超时后的失败文案（纯函数，单测覆盖）：说清为什么失败、清理了什么、什么没清掉。
+ * 时长取自 AI_CONSENT_TIMEOUT_MS —— 文案里的"10 分钟"不能与实际等待时间脱节。 */
+export function aiConsentFailureText(decision, leftovers) {
+  const base = decision?.timeout === true
+    ? `等待授权超时（${Math.round(AI_CONSENT_TIMEOUT_MS / 60000)} 分钟），已取消本地 AI 兜底（该操作会调用模型 API 产生费用）`
+    : '用户取消本地 AI 兜底（该操作会调用模型 API 产生费用）'
+  const cleaned = leftovers?.cleaned ?? []
+  const failed = leftovers?.failed ?? []
+  const cleanedNote = cleaned.length > 0 ? `；已清理本次落盘残留：${cleaned.join('、')}` : ''
+  const failedNote = failed.length > 0
+    ? `；**有 ${failed.length} 项没能清理**（当前环境可能禁止删除，请手动删除）：${failed.map((f) => f.path).join('、')}`
+    : ''
+  return `${base}${cleanedNote}${failedNote}`
+}
+
 /** 软件源配置文件（registry 列表，安装链按主→备依次尝试）。 */
 const SOURCES_FILE = join(dshHome(), 'plugin-console-sources.json')
 /** 敏感凭据单独落盘（避免与可分享配置混存）：自定义搜索源 headers + Gitee secret/token。 */
@@ -2824,7 +3115,7 @@ async function ensureBundlePatchIntegrity(profileDir, pkgName, userPatchPath, tr
  * 后台安装任务注册表：请求立即返回，安装继续在服务端执行；
  * 面板通过 /install-status 轮询进度（stage + status），离开面板不中断。
  */
-const installJobs = new Map()
+export const installJobs = new Map()
 let installJobSeq = 0
 /** AI 赋能任务注册表（规划/执行均常驻服务端，面板轮询进度）。 */
 const aiJobs = new Map()
@@ -2900,6 +3191,9 @@ function loadAiJobs() {
 /** 静态插件索引内存缓存（/market-index 用）。 */
 let marketIndexCache = null
 
+/** 本地 AI 兜底授权的等待上限（10 分钟）：超时即视为用户未授权（见 runInstallJob 的 ai-consent 段）。 */
+const AI_CONSENT_TIMEOUT_MS = 600000
+
 function installJobView(job) {
   return {
     jobId: job.id,
@@ -2926,6 +3220,16 @@ function installJobView(job) {
     suiteReport: job.suiteReport ?? null,
     suiteNote: job.suiteNote ?? null,
     hint: job.hint ?? null,
+    // 子包级/套装级进度（2026-09-20 真装实测缺口：11 个子包的聚合仓库跑了 19 分钟，面板只显示
+    // "安装中"，用户不知道在装第几个、还剩几个）。子包通道来自 runInstallJob 候选循环维护的
+    // candidateXxx；套装通道来自 runSuiteInstallJob 维护的 suiteProgress（clone/装配两阶段）。
+    progress: job.suiteProgress
+      ? { channel: 'suite', ...job.suiteProgress }
+      : job.candidateTotal > 0
+        ? { channel: 'subpackage', phase: 'install', index: job.candidateIndex ?? 0, total: job.candidateTotal, name: job.candidateName ?? null, done: job.candidateDone === true }
+        : null,
+    // 授权请求（等本地 AI 兜底同意）：面板要显示倒计时 + 同意/取消，所以时间与最后错误一起下发
+    aiConsent: { pending: job.aiPending != null, since: job.aiPendingSince ?? null, timeoutMs: job.aiConsentTimeoutMs ?? AI_CONSENT_TIMEOUT_MS, lastError: job.aiPending?.lastError ?? job.lastError ?? null },
   }
 }
 
@@ -3098,15 +3402,55 @@ function gitCloneUrls(repoFullName, source = 'github') {
   return urls.length > 0 ? urls : [`https://github.com/${repoFullName}.git`]
 }
 
+/**
+ * 删除目录树并**核实删除结果**。理由：本机某些环境（受限令牌/沙箱/杀软占用）下 `rmSync` 会
+ * **静默落空**——不抛错、目录仍在。删完直接报成功就是对用户撒谎（2026-09-20 多类型演练实测：
+ * 同一个 `rmSync` 在 `D:\dsh\repos` 删得掉，在 `C:\Users\<user>\.dsh\...` 与 `%TEMP%` 下返回成功
+ * 但目录原封不动；技能删不掉、残留清理假装清干净、套装子模块重试撞"目录非空"都是它引起的）。
+ */
+export function removeDirVerified(dir) {
+  let lastError = null
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    try {
+      rmSync(dir, { recursive: true, force: true, maxRetries: 3, retryDelay: 120 })
+    } catch (error) {
+      lastError = error
+    }
+    if (!existsSync(dir)) return { ok: true, attempts: attempt }
+  }
+  return { ok: false, attempts: 2, error: lastError instanceof Error ? lastError.message : null }
+}
+
+/** 取 git 自己说的话（stderr 末两行）。`--quiet` 只静音进度，真实原因（HTTP 502/无法解析主机/
+ * 认证失败）仍在 stderr 里；只报 `Command failed: git clone …` 等于没告诉用户任何信息。 */
+function gitErrorDetail(error) {
+  const raw = typeof error?.stderr === 'string' && error.stderr.trim() !== ''
+    ? error.stderr
+    : (typeof error?.message === 'string' ? error.message : '')
+  return raw
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .filter((line) => line !== '' && !/^Command failed/u.test(line))
+    .slice(-2)
+    .join(' | ')
+}
+
 /** 逐条尝试的错误汇总（纯函数，单测覆盖）：报**第一个**错误（真实原因）+ 尝试清单。
  * 为什么要这样：多源重试时若第一次失败留下半成品目录，第二次会以
  * `fatal: destination path '…' already exists and is not an empty directory` 失败，
  * 旧代码把它当 lastError 抛出去 → 用户只看到"目录非空"，真实原因（镜像/网络不可达）被完全掩盖。
- * 2026-09-20 另一位用户实测报的就是这句。 */
+ * 2026-09-20 另一位用户实测报的就是这句；同日演练又发现：**清理半成品本身失败**时（环境禁止删除
+ * %TEMP%），第二个源的好戏只有"目录非空"，必须把"清不掉"讲明白，否则用户永远猜不到真相。 */
 export function summarizeCloneErrors(errors) {
   const first = errors[0]
-  const tried = errors.map((e) => (/already exists and is not an empty directory/u.test(e.message) ? `${e.url}（目录非空）` : e.url)).join('；')
-  return `git clone 失败（首个错误：${first?.message ?? '未知'}）；已尝试 ${errors.length} 个源：${tried}`
+  const tried = errors.map((e) => (e.unclean === true
+    ? `${e.url}（目标目录清不掉，未重试）`
+    : (/already exists and is not an empty directory/u.test(e.message) ? `${e.url}（目录非空）` : e.url))).join('；')
+  const detail = gitErrorDetail(first)
+  const uncleanNote = errors.some((e) => e.unclean === true)
+    ? '；注意：上一次失败留下的半成品目录无法清理（当前环境禁止删除），多源重试因此无效——请手动删除该目录后重试'
+    : ''
+  return `git clone 失败（首个错误：${first?.message ?? '未知'}${detail !== '' ? `；git 说：${detail}` : ''}）；已尝试 ${errors.length} 个源：${tried}${uncleanNote}`
 }
 
 /** git clone（镜像→直连；gitee 直连），返回 { url } 或抛错。 */
@@ -3116,7 +3460,13 @@ export async function gitCloneRepo(repo, dest, source = 'github', timeout = 1800
   for (const [attempt, url] of urls.entries()) {
     // 每次尝试前都清掉目标目录：上一次可能留下半成品（git 会先建目录再传输），
     // 不清就会让第二次以"目录非空"失败并掩盖真实原因（见 summarizeCloneErrors 注释）。
-    try { rmSync(dest, { recursive: true, force: true }) } catch {}
+    // 关键是**核实**清理结果：清不掉就别再试下一个源了——那只会得到一条"目录非空"，
+    // 把第一个源的真实错误也一起搅浑（本机 %TEMP% 下删除被静默忽略时就是这样）。
+    const cleared = removeDirVerified(dest)
+    if (!cleared.ok) {
+      errors.push({ url, message: `克隆目标目录无法清理（环境禁止删除）：${dest}`, unclean: true })
+      break
+    }
     try {
       // eslint-disable-next-line no-await-in-loop
       await execFileAsync('git', ['clone', '--depth', '1', '--quiet', url, dest], {
@@ -3126,7 +3476,7 @@ export async function gitCloneRepo(repo, dest, source = 'github', timeout = 1800
       })
       return { url, attempt: attempt + 1 }
     } catch (error) {
-      errors.push({ url, message: error?.message ?? String(error) })
+      errors.push({ url, message: error?.message ?? String(error), stderr: error?.stderr })
     }
   }
   throw new Error(summarizeCloneErrors(errors))
@@ -3187,7 +3537,7 @@ export function resolveInstallKind(requestKind, probeText) {
 /** 套装安装（submodule 聚合仓库）：照仓库 install.ps1/README 语义——
  * clone 套装 → 手动镜像拉取子模块 → 按类型装配（bundle 插件含 Release tgz 兜底 / 普通插件 / 技能 / agent 预设）。
  * 不执行第三方脚本本体（安全护栏：脚本型只读语义不运行）。 */
-async function runSuiteInstallJob(job, ctx) {
+export async function runSuiteInstallJob(job, ctx) {
   const tmpDir = join(tmpdir(), `dsh-suite-${job.id}-${Date.now()}`)
   const report = []
   try {
@@ -3205,7 +3555,10 @@ async function runSuiteInstallJob(job, ctx) {
     const patchPath = findPatchPath(ctx)
     const profileDir = dirname(patchPath)
     // 手动拉取子模块（git 的 insteadOf 重写对 submodule 不生效，按镜像 URL 逐个 clone）
-    for (const sub of subs) {
+    // 套装级进度：套装动辄几分钟（clone 每个子模块 + 逐个装配），面板要能显示"第 i/n 个子模块"
+    for (let si = 0; si < subs.length; si += 1) {
+      const sub = subs[si]
+      job.suiteProgress = { phase: 'clone', index: si + 1, total: subs.length, name: sub.name, done: false }
       const subRepo = sub.url.replace(/^https?:\/\/[^/]+\//u, '').replace(/\.git$/u, '')
       const dest = join(tmpDir, sub.path)
       try {
@@ -3215,7 +3568,9 @@ async function runSuiteInstallJob(job, ctx) {
         report.push({ component: sub.name, type: 'clone', ok: false, note: `子模块拉取失败：${error.message}` })
       }
     }
-    for (const sub of subs) {
+    for (let pi = 0; pi < subs.length; pi += 1) {
+      const sub = subs[pi]
+      job.suiteProgress = { phase: 'assemble', index: pi + 1, total: subs.length, name: sub.name, done: false }
       const subDir = join(tmpDir, sub.path)
       if (!existsSync(subDir)) continue
       const subRepo = sub.url.replace(/^https?:\/\/[^/]+\//u, '').replace(/\.git$/u, '')
@@ -3271,7 +3626,12 @@ async function runSuiteInstallJob(job, ctx) {
       // d. 普通 npm 插件（无 bundle 且无预设/技能）
       if (!handled && pkg && typeof pkg.name === 'string') {
         const target = join(profileDir, 'node_modules', pkg.name)
-        if (existsSync(target)) rmSync(target, { recursive: true, force: true })
+        if (existsSync(target)) {
+          // 核实清理结果：删不掉就明确报错，别把新包**合并**进旧目录（半新半旧最难查），
+          // 也别让后续 rename/copyTree 以 EPERM 之类的次生错误掩盖真实原因（见 removeDirVerified）。
+          const cleared = removeDirVerified(target)
+          if (!cleared.ok) throw new Error(`无法清理已存在的目录（当前环境禁止删除）：${target}${cleared.error ? `，原因：${cleared.error}` : ''}——请手动删除后重试`)
+        }
         mkdirSync(dirname(target), { recursive: true })
         copyTree(subDir, target)
         const taken = new Set(listEntries(ctx).map((e) => e.rowId))
@@ -3287,6 +3647,8 @@ async function runSuiteInstallJob(job, ctx) {
     job.status = 'done'
     job.stage = 'done'
     job.suiteReport = report
+    // 装配全部走完：进度标记完成（保留最后一轮的 i/n 与名字，前端显示"已完成 n/n 个子模块"）
+    if (job.suiteProgress) job.suiteProgress = { ...job.suiteProgress, done: true }
     const okCount = report.filter((r) => r.ok).length
     const failCount = report.filter((r) => !r.ok).length
     const bundleCount = report.filter((r) => r.type === 'bundle' && r.ok).length
@@ -3473,9 +3835,11 @@ async function fetchSubpackageNames(repo, branch, auth) {
   }
 }
 
-/** 子包候选：聚合包（名字带 all）优先，上限 8 个。 */
+/** 子包候选：聚合包（名字带 all）优先，上限 8 个。
+ * 2026-09-20 真装演练：`@dsh-suite/all` 这种 **scope 根形式**（`/all` 结尾）不被 `(^|-)all$` 命中，
+ * 聚合包没能排到最前（那次纯属仓库目录顺序碰巧第一）。补上 `/all$`。 */
 async function subpackageCandidates(repo, branch, auth) {
-  const isAll = (name) => /(^|-)all$/u.test(name) || /-all-/u.test(name)
+  const isAll = (name) => /(^|-)all$/u.test(name) || /-all-/u.test(name) || /\/all$/u.test(name)
   const subs = await fetchSubpackageNames(repo, branch, auth)
   return subs
     .slice()
@@ -4888,7 +5252,7 @@ async function runInstallJob(job, ctx) {
           job.status = 'failed'
           // 文案要点：说清"这是读不到、不是没有"，并给出可直接复制的安装命令 ——
           // 用户看到"未发现子包"会去翻仓库找，而真相多半只是本次网络没读成。
-          job.error = `仓库 ${job.repo} 的根包未发布到 npm（private: true），且本次没能读到它的子包列表（多为网络受限/超时，不代表没有子包）。请重试；或在「查看」详情里确认子包名后直接安装，例如：dsh plugin --profile web add @linxin666/dsh-web-all`
+          job.error = `仓库 ${job.repo} 的根包未发布到 npm（private: true：${pkg.name}），且本次没能读到它的子包列表（多为网络受限/超时，不代表没有子包）。请重试；或在「查看」详情里确认子包名后直接安装，例如：dsh plugin --profile web add <子包名>；若该仓库根包本身即可作为插件，也可直接：dsh plugin --profile web add github:${job.repo}`
           job.probeReason = 'subpackages-unreadable'
           return
         }
@@ -4924,9 +5288,16 @@ async function runInstallJob(job, ctx) {
     // 可配置软件源：主→备依次尝试（默认 npmmirror → npmjs，可增删自定义/内网源）
     const registries = orderedRegistries(readSources())
     const deadline = Date.now() + 8 * 60 * 1000
+    // 子包级进度（2026-09-20 真装实测：11 个子包的聚合仓库跑了 19 分钟，job.stage 一直停在
+    // installing，面板只有一个不动的进度条）。candidateTotal/Index/Name 每轮开始时更新，
+    // 由 installJobView 折算成 progress{index,total,name} 下发给面板。
+    job.candidateTotal = candidates.length
+    job.candidateDone = false
     for (let index = 0; index < candidates.length && installedName === null; index += 1) {
       if (Date.now() > deadline) break
       const name = candidates[index]
+      job.candidateIndex = index + 1
+      job.candidateName = name
         // 加法优化：包已在 node_modules 且名字匹配时，不再重复安装/触发 EPERM，直接进入启用流程
         if (installedName === null) {
           const existingTarget = join(profileDir, 'node_modules', name, 'package.json')
@@ -5049,12 +5420,15 @@ async function runInstallJob(job, ctx) {
         if (subs.length > 0) {
           const extra = subs
             .slice()
-            .sort((a, b) => Number(/(^|-)all$/u.test(b.name) || /-all-/u.test(b.name)) - Number(/(^|-)all$/u.test(a.name) || /-all-/u.test(a.name)))
+            // 聚合包优先：`@dsh-suite/all` 这类 scope 根形式（/all 结尾）也要认（演练实测）
+            .sort((a, b) => Number(/(^|-)all$/u.test(b.name) || /-all-/u.test(b.name) || /\/all$/u.test(b.name)) - Number(/(^|-)all$/u.test(a.name) || /-all-/u.test(a.name) || /\/all$/u.test(a.name)))
             .map((sub) => sub.name)
             .filter((n) => !candidates.includes(n))
             .slice(0, 8)
           if (extra.length > 0) {
             candidates = [...candidates, ...extra]
+            // 懒惰展开后候选变多：总数要跟着更新，否则面板会显示"第 9/1 个"
+            job.candidateTotal = candidates.length
             if (!Array.isArray(job.subpackages)) job.subpackages = []
             for (const e of extra) if (!job.subpackages.includes(e)) job.subpackages.push(e)
           }
@@ -5065,10 +5439,14 @@ async function runInstallJob(job, ctx) {
       // 本地 AI 兜底会调用模型 API、产生费用：挂起等待用户明确同意后再执行
       job.stage = 'ai-consent'
       job.aiPending = { lastError: lastError?.message ?? null }
+      // 等授权期间要能展示"为什么卡住、还能等多久"：请求时间 + 超时上限 + 最后一个确定性错误
+      job.aiPendingSince = Date.now()
+      job.aiConsentTimeoutMs = AI_CONSENT_TIMEOUT_MS
+      job.lastError = lastError?.message ?? null
       job.aiWait = new Promise((resolve) => { job.aiPending.resolver = resolve })
       const decision = await Promise.race([
         job.aiWait,
-        new Promise((resolve) => setTimeout(() => resolve({ approved: false, timeout: true }), 600000)),
+        new Promise((resolve) => setTimeout(() => resolve({ approved: false, timeout: true }), AI_CONSENT_TIMEOUT_MS)),
       ])
       job.aiPending = null
       job.aiWait = null
@@ -5076,12 +5454,17 @@ async function runInstallJob(job, ctx) {
         await aiRepair(job, ctx, profileDir, candidates, lastError?.message ?? null)
       } else {
         job.status = 'failed'
-        job.error = decision.timeout === true
-          ? '等待授权超时（10 分钟），已取消本地 AI 兜底（该操作会调用模型 API 产生费用）'
-          : '用户取消本地 AI 兜底（该操作会调用模型 API 产生费用）'
+        // 失败/取消时清场并如实汇报（见 cleanupAttemptedCandidates 注释）：
+        // 不能让用户面对"面板说失败、磁盘上却留了半个包和 _tmp_ 残留"的糊涂账。
+        const leftovers = cleanupAttemptedCandidates(profileDir, candidates)
+        job.leftovers = leftovers
+        job.error = aiConsentFailureText(decision, leftovers)
       }
       return
     }
+    // 装成功：进度标记完成（index 停在真正装上的那一轮，前端显示"第 i/n 个：<包名>"即为成功项）
+    job.candidateDone = true
+    job.candidateName = installedName
     job.packageName = installedName
     // 聚合包子包版本对齐（确保更新后所有子包也到新版声明版本）
     let syncedNames = []
@@ -5284,6 +5667,10 @@ async function handle(ctx, req, res) {
     const auth = readGithubAuth()
     const jobs = [...installJobs.values()].filter((job) => job.status === 'installing').map(installJobView)
     const recentFailures = [...installJobs.values()].filter((job) => job.status === 'failed').slice(-3).map(installJobView)
+    // 已安装但尚未生效的任务（2026-09-20 真装真卸演练实测）：bundle 型插件要重启才被加载，装完
+    // /install 返回 entryId: null、/state 里新增 loader 条目 = 0 —— 面板过去完全看不出「装了但还没
+    // 生效」，也无法撤销。前端据此渲染「已安装·重启后生效」徽标 + 按 jobId 删除。
+    const pendingRestart = pendingRestartJobs([...installJobs.values()], listEntries(ctx))
     // 框架升级检测与适配（备份快照 + 重打框架补丁），try 包裹不阻塞 state 返回
     let framework = null
     try { framework = detectFrameworkUpgrade(ctx) } catch {}
@@ -5298,7 +5685,7 @@ async function handle(ctx, req, res) {
       const selfPkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json'), 'utf8'))
       selfVersion = typeof selfPkg.version === 'string' ? selfPkg.version : null
     } catch {}
-    sendJson(res, 200, { ok: true, entries, patchPath, compat, installJobs: jobs, recentFailures, github: { loggedIn: auth.loggedIn, login: auth.login }, patch: { disables: patch.disables, forced: patch.forced, inserts: patch.inserts }, framework, patchHeal: patchHeal === null ? null : { healed: patchHeal.healed ?? [], autoDisabled: patchHeal.autoDisabled ?? [], healedAt: patchHeal.healedAt ?? 0 }, compatPending: compatPending === null ? null : { frameworkVersion: compatPending.frameworkVersion ?? null, upgradeFrom: compatPending.upgradeFrom ?? null, pending: (compatPending.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending').map((p) => ({ rowId: p.rowId, moduleName: p.moduleName, version: p.version ?? null, checkNote: p.checkNote ?? null, check: p.check ?? null, riskyApprovedAt: p.riskyApprovedAt ?? null, adoptable: adoptable.get(p.rowId) ?? null })) }, compatGate, rollback: rollbackRec, selfVersion, components: findComponents().map((c) => ({ id: c.id, name: c.name, kind: c.kind ?? 'server', pid: c.pid ?? null, port: c.port ?? null, healthUrl: c.healthUrl ?? null, uiUrl: compUiUrl(c), autoStart: c.autoStart === true })) })
+    sendJson(res, 200, { ok: true, entries, patchPath, compat, installJobs: jobs, recentFailures, pendingRestart, github: { loggedIn: auth.loggedIn, login: auth.login }, patch: { disables: patch.disables, forced: patch.forced, inserts: patch.inserts }, framework, patchHeal: patchHeal === null ? null : { healed: patchHeal.healed ?? [], autoDisabled: patchHeal.autoDisabled ?? [], healedAt: patchHeal.healedAt ?? 0 }, compatPending: compatPending === null ? null : { frameworkVersion: compatPending.frameworkVersion ?? null, upgradeFrom: compatPending.upgradeFrom ?? null, pending: (compatPending.pending ?? []).filter((p) => (p.status ?? 'pending') === 'pending').map((p) => ({ rowId: p.rowId, moduleName: p.moduleName, version: p.version ?? null, checkNote: p.checkNote ?? null, check: p.check ?? null, riskyApprovedAt: p.riskyApprovedAt ?? null, adoptable: adoptable.get(p.rowId) ?? null })) }, compatGate, rollback: rollbackRec, selfVersion, components: findComponents().map((c) => ({ id: c.id, name: c.name, kind: c.kind ?? 'server', pid: c.pid ?? null, port: c.port ?? null, healthUrl: c.healthUrl ?? null, uiUrl: compUiUrl(c), autoStart: c.autoStart === true })) })
     return
   }
 
@@ -5555,6 +5942,55 @@ async function handle(ctx, req, res) {
     return
   }
 
+  if (pathname === `${ROUTE_PREFIX}/github-open-login`) {
+    // 设备码（窗口）登录：唤起独立插件 dsh-github-login 的登录窗口 —— 登录的首选通道，token 只是兜底。
+    //
+    // 为什么是"调另一个插件的 HTTP 接口"而不是自己实现设备码：Device Flow + 桌面窗口 + 令牌落盘
+    // 已经由那个插件实现好了，它挂在**同一个宿主 webServer** 上（源码：<profile>/node_modules/
+    // dsh-github-login/lib/index.js）：
+    //   POST /github-auth/open    → { ok:true, launched:"<exe 路径>" } 或 { ok:true, launched:false, hint }
+    //   GET  /github-auth/status  → { ok, loggedIn, login }
+    // 为什么失败也回 200：这个能力是**外挂**的 —— 插件可能没装、装了也可能没打包 exe、当前 profile
+    // 也可能没把它挂上（2026-09-20 实测：本机装了它，但跑着的宿主里 GET /github-auth/status 仍是 404）。
+    // 那是"这条通道现在不可用"，不是"服务端出错"：回 500 只会让用户看到一句看不懂的报错，还看不出
+    // "该走 token 兜底"这条正路。所以统一回 200 + started:false + 可读 reason，由前端决定降级。
+    const port = webPort(ctx)
+    const base = `http://127.0.0.1:${port}`
+    const unavailable = '未检测到 dsh-github-login 插件（或当前平台不支持它的登录窗口）'
+    const fallback = (detail) => {
+      sendJson(res, 200, { ok: true, started: false, reason: detail ? `${unavailable}：${detail}` : unavailable })
+    }
+    let opened = null
+    try {
+      const response = await fetch(`${base}/github-auth/open`, { method: 'POST', signal: AbortSignal.timeout(8000) })
+      if (!response.ok) {
+        fallback(`对方接口返回 HTTP ${response.status}`)
+        return
+      }
+      opened = await response.json()
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      // fetch 的 "fetch failed" 不带 cause 等于没说；超时原文也没有信息量 —— 都压成一行可读文案
+      const cause = error?.cause?.code ?? error?.cause?.message ?? ''
+      fallback(/abort/iu.test(message) ? '调用超时（8000ms）' : (cause ? `${message}（${cause}）` : message))
+      return
+    }
+    // 对方"接口在、但本机没有登录工具 exe"时回 { ok:true, launched:false, hint }：窗口其实没起来。
+    // 这里必须跟着报 started:false —— 报 true 会让前端开 60s 轮询，等一个永远不会出现的登录。
+    if (opened?.launched === false) {
+      fallback(typeof opened.hint === 'string' && opened.hint !== '' ? opened.hint : '对方未启动登录窗口（未找到 DSH-GitHub-Login 可执行文件）')
+      return
+    }
+    // 顺手把对方的登录态透传给前端（best-effort：拿不到就 status:null，不影响"窗口已打开"这个结论）
+    let status = null
+    try {
+      const stateRes = await fetch(`${base}/github-auth/status`, { signal: AbortSignal.timeout(2000) })
+      if (stateRes.ok) status = await stateRes.json()
+    } catch {}
+    sendJson(res, 200, { ok: true, started: true, status })
+    return
+  }
+
   if (pathname === `${ROUTE_PREFIX}/details`) {
     const { entryId } = body
     if (typeof entryId !== 'string' || !/^[A-Za-z0-9_:.-]{1,80}$/u.test(entryId)) {
@@ -5664,13 +6100,22 @@ async function handle(ctx, req, res) {
   }
 
   if (pathname === `${ROUTE_PREFIX}/uninstall`) {
-    const { entryId } = body
-    if (typeof entryId !== 'string' || !/^[A-Za-z0-9_:.-]{1,80}$/u.test(entryId)) {
-      sendError(res, 400, 'entryId 无效')
+    // 入参两种形态：entryId（运行中的 loader 条目）· jobId（已安装但尚未生效的安装任务，见 revokePendingInstall）
+    const { entryId, jobId } = body
+    const entryIdOk = typeof entryId === 'string' && /^[A-Za-z0-9_:.-]{1,80}$/u.test(entryId)
+    const jobIdOk = typeof jobId === 'string' && /^[A-Za-z0-9_.:-]{1,80}$/u.test(jobId)
+    if (!entryIdOk && !jobIdOk) {
+      sendError(res, 400, 'entryId 无效（撤销尚未生效的安装请改传 jobId）')
       return
     }
-    const entry = ctx.loader.entries().find((candidate) => candidate.id === entryId)
+    const entry = entryIdOk ? ctx.loader.entries().find((candidate) => candidate.id === entryId) : undefined
     if (!entry) {
+      // 2026-09-20 演练实测缺口：bundle 型插件装完要重启才进 loader，过去这里恒 404 →
+      // 「刚装错的插件在重启前无法从面板卸载」。带 jobId 时改走安装任务撤销。
+      if (jobIdOk) {
+        await uninstallByJobId(ctx, res, jobId)
+        return
+      }
       sendError(res, 404, `没有名为 ${entryId} 的插件条目`)
       return
     }
@@ -5711,11 +6156,17 @@ async function handle(ctx, req, res) {
     }
     await removeInsertRow(patchPath, rowId)
     let uninstallError = null
-    try {
-      await pnpmRemove(profileDir, moduleName)
-    } catch (error) {
-      uninstallError = error instanceof Error ? error.message : String(error)
+    // 目录已不在、manifest 也没引用 → 不必再拉一次 pnpm：那只会在本机换来一句没有信息量的
+    // "Command failed: corepack pnpm remove …"（演练实测）。判断规则与 jobId 撤销分支同一套。
+    if (await needsPnpmRemove(profileDir, moduleName)) {
+      try {
+        await pnpmRemove(profileDir, moduleName)
+      } catch (error) {
+        uninstallError = error instanceof Error ? error.message : String(error)
+      }
     }
+    // 任务记录是否作废看**事实**（包目录真的没了），不看 pnpm 的退出码；删不干净时留着让用户重试
+    if (!existsSync(packageDirIn(profileDir, moduleName))) markJobsRevoked(moduleName, rowId)
     sendJson(res, 200, { ok: true, removed: 'entry', packageName: moduleName, restart: false, uninstallError })
     return
   }
@@ -7465,6 +7916,7 @@ async function handle(ctx, req, res) {
     const profileDir = dirname(findPatchPath(ctx))
     const nodeModules = join(profileDir, 'node_modules')
     const removed = []
+    const failed = []
     // 1) 删除 .old-* 残余备份（顶层 + 作用域目录）
     const scanDirs = [nodeModules]
     try { if (existsSync(join(nodeModules, '@linxin666'))) scanDirs.push(join(nodeModules, '@linxin666')) } catch {}
@@ -7474,8 +7926,10 @@ async function handle(ctx, req, res) {
           if (!entry.isDirectory()) continue
           if (!/\.old-/u.test(entry.name)) continue
           const target = join(dir, entry.name)
-          rmSync(target, { recursive: true, force: true })
-          removed.push(entry.name)
+          // 核实后再计入 removed：删不掉却报成功会让用户以为清干净了（见 removeDirVerified 注释）
+          const result = removeDirVerified(target)
+          if (result.ok) removed.push(entry.name)
+          else failed.push({ name: entry.name, path: target, error: result.error })
         }
       } catch {}
     }
@@ -7493,12 +7947,18 @@ async function handle(ctx, req, res) {
           if (declared.has(full)) continue
           const pkgJson = join(scoped, entry.name, 'package.json')
           if (existsSync(pkgJson)) {
-            rmSync(join(scoped, entry.name), { recursive: true, force: true })
-            removed.push(full)
+            const target = join(scoped, entry.name)
+            const result = removeDirVerified(target)
+            if (result.ok) removed.push(full)
+            else failed.push({ name: full, path: target, error: result.error })
           }
         }
       }
     } catch {}
+    if (failed.length > 0) {
+      sendJson(res, 200, { ok: false, removed, count: removed.length, failed, error: `有 ${failed.length} 项没能删除（目录仍存在）：${failed.map((f) => f.name).join('、')}——当前环境可能禁止删除，请手动处理` })
+      return
+    }
     sendJson(res, 200, { ok: true, removed, count: removed.length })
     return
   }
@@ -7626,12 +8086,14 @@ async function handle(ctx, req, res) {
       sendError(res, 404, `技能 ${name} 不存在`)
       return
     }
-    try {
-      rmSync(dest, { recursive: true, force: true })
-      sendJson(res, 200, { ok: true, name })
-    } catch (error) {
-      sendError(res, 500, `删除技能失败：${error instanceof Error ? error.message : String(error)}`)
+    // 删完必须核实：本机环境可能让 rmSync 静默落空（见 removeDirVerified 注释），
+    // 旧代码删完直接 {ok:true} → 用户以为删了，技能其实还在（2026-09-20 演练实测）。
+    const result = removeDirVerified(dest)
+    if (!result.ok) {
+      sendError(res, 500, `删除技能失败：目录仍存在（${dest}）${result.error ? `，原因：${result.error}` : ''}——当前环境可能禁止删除该目录，请手动删除它`)
+      return
     }
+    sendJson(res, 200, { ok: true, name })
     return
   }
 
@@ -7860,7 +8322,9 @@ async function handle(ctx, req, res) {
         } catch (error) {
           lastError = error
           // 失败可能留下半成品目录，清理后再试下一个源，否则会因目标已存在而连环失败
-          try { rmSync(target, { recursive: true, force: true }) } catch {}
+          // 失败可能留下半成品目录，清理后再试下一个源，否则会因目标已存在而连环失败；
+          // 清理同样要核实（见 removeDirVerified）——清不掉时下一个源只会报"目录非空"。
+          removeDirVerified(target)
         }
       }
       if (!cloned) throw lastError ?? new Error('未知错误')
@@ -7903,12 +8367,14 @@ async function handle(ctx, req, res) {
       sendError(res, 400, '路径不在仓库落地目录内或不存在')
       return
     }
-    try {
-      rmSync(target, { recursive: true, force: true })
-      sendJson(res, 200, { ok: true })
-    } catch (error) {
-      sendError(res, 500, `删除失败：${error instanceof Error ? error.message : String(error)}`)
+    // 核实删除结果：本机环境可能让 rmSync 静默落空（见 removeDirVerified 注释），
+    // 删不掉却回 {ok:true} 会让用户以为仓库已清理。
+    const result = removeDirVerified(target)
+    if (!result.ok) {
+      sendError(res, 500, `删除失败：目录仍存在（${target}）${result.error ? `，原因：${result.error}` : ''}——当前环境可能禁止删除该目录，请手动删除`)
+      return
     }
+    sendJson(res, 200, { ok: true })
     return
   }