@hyzyn/dsh-docker 0.9.6 → 0.11.0

package/client-src/index.js

@@ -22,6 +22,13 @@ import { currentSessionIdOf } from './current-session.js'
 import { createLogBuffer, splitLogLines } from './log-buffer.js'
 import { createLogWindow, LOG_ROW_ESTIMATE_PX, LOG_WINDOW_OVERSCAN, LOG_HEIGHT_CACHE_LIMIT } from './log-window.js'
 import { subscribeLogStream, reconnectTail, LOG_RECONNECT_BASE_MS, LOG_RECONNECT_MAX_MS } from './log-stream.js'
+import { upsertElevationRecord, removeElevationRecord, markElevationGranted, pruneElevationRecords, buildMergedElevationText, mergeElevationCommands, joinElevationCommands, shouldOfferMerge } from './elevation.js'
+
+/**
+ * 「复制全部」按钮的反馈归属哨兵键：能力名不会取这个值，所以它与单条按钮的反馈天然不串。
+ * （`copiedKey` 逐能力隔离见卡片里那段注释。）
+ */
+const ELEVATION_COPY_ALL = '__all__'
 
 /* ================================ 国际化 ================================ */
 
@@ -55,10 +62,11 @@ const I18N_ZH = {
   'status.restarting': '重启中',
   'status.removing': '删除中',
   'status.unknown': '未知',
-  'hint.pickMaxLocal': '最多 {max} 个容器，浏览器并发长连接有限制',
-  'hint.pickMaxSsh': '最多 {max} 个容器（SSH 目标上一条连接要同时装实时流与刷新等短命令）',
-  'hint.pickMany': '连接数较多，浏览器并发长连接有限制',
+  'hint.pickMaxLocal': '最多 {max} 个容器——再多会占满浏览器的同源连接，整个页面都会卡',
+  'hint.pickMaxSsh': '最多 {max} 个容器——再多会占满浏览器的同源连接，整个页面都会卡',
+  'hint.pickMany': '已接近上限，再选下去整个页面会变卡',
   'hint.pickAtLeastTwo': '至少选择 2 个容器',
+  'hint.pickBudget': '浏览器每个站点最多同时保持 4 条实时流（含活动条的事件流），再多页面就会卡住',
   'option.presetAll': '全部可见',
   'status.unhealthy': '不健康',
   'status.attention': '需关注',
@@ -354,7 +362,8 @@ const I18N_ZH = {
   'status.backToListRefresh': '，列表回到 AUTO REFRESH / 手动刷新；活动条上点「重连」可重新订阅',
   'btn.reconnectEvents': '重连',
   'hint.reconnectEvents': '重新打开容器事件流（docker events）；列表刷新按钮也会一并重连',
-  'hint.eventsClosedNoAuto': '事件流断开后不会自己回来（EventSource 只在连接层抖动时自愈；docker events 进程退出属于终止态）——点它重连，或点右上角刷新列表',
+  'hint.eventsClosedNoAuto': '不会自动恢复，点「重连」',
+  'hint.eventsReconnectRefused': '重连被拒：{message}',
   'hint.conversationHidden': ' · 会话在面板后面：关掉或最小化面板/终端即可看到',
   'msg.copied': '已复制：',
   'error.copyManual': '复制失败，请手动执行：',
@@ -474,11 +483,16 @@ const I18N_ZH = {
   'field.execTimeout': 'exec 超时（秒）',
   'section.capabilities': '能力开关（默认关闭）',
   'check.allowMutations': '允许变更操作（容器启停删、镜像拉取 / 删除 / 清理）',
-  'check.allowExec': '允许 exec（在容器内执行命令）',
+  // 限定到「一次性」通道：旧文案「（在容器内执行命令）」会被读成「exec 整体要授权」，
+  // 而卡片「终端」按钮的 docker exec -it 不受它管（D163）。设置卡片是用户第一眼看到的地方。
+  'check.allowExec': '允许一次性 exec（面板命令框与 docker_exec；交互式进容器不由它管）',
   'hint.socketRoot': 'docker socket 等价于目标主机的 root 权限。开启后，浏览器面板与 agent 都能执行对应操作，请只在可信环境下打开。',
   'hint.capabilityNotGranted': '⚠ 宿主尚未授权：这两个开关现在打不开，点它会给出一条就地确认的命令（免重启）。关掉它们随时可用。',
   'badge.notEffective': '未生效：未获宿主授权',
   'elev.title': '就地授权（免重启）',
+  'elev.copyAll': '复制全部（{count} 条）',
+  'elev.copyAllHint': '每个能力各要一条命令。一次粘贴全部命令，执行后全部开关自动解锁（各自的探测周期内先后生效）。',
+  'elev.copyAllCopied': '已复制全部 {count} 条',
   'elev.lockedWhy': '本机任意进程都能发回环请求，所以「打开危险能力」这件事不能由这个页面自己说了算——必须在宿主的文件系统上确认一次。',
   'elev.step': '在宿主的终端里执行下一条命令，开关会自动解锁：',
   'elev.copy': '复制命令',
@@ -539,10 +553,11 @@ const I18N_EN = {
   'status.restarting': 'Restarting',
   'status.removing': 'Removing',
   'status.unknown': 'Unknown',
-  'hint.pickMaxLocal': 'At most {max} containers; browsers limit concurrent long-lived connections',
-  'hint.pickMaxSsh': 'At most {max} containers (a single SSH connection must also carry live streams and short refresh commands)',
-  'hint.pickMany': 'Many streams — browsers limit concurrent long-lived connections',
+  'hint.pickMaxLocal': 'At most {max} containers — more would exhaust the browser\'s per-origin connections and stall the whole page',
+  'hint.pickMaxSsh': 'At most {max} containers — more would exhaust the browser\'s per-origin connections and stall the whole page',
+  'hint.pickMany': 'Close to the limit — selecting more will slow the whole page down',
   'hint.pickAtLeastTwo': 'Select at least 2 containers',
+  'hint.pickBudget': 'A browser keeps at most 4 live streams per origin (including the Activity strip\'s event stream); more will stall the page',
   'option.presetAll': 'All visible',
   'status.unhealthy': 'Unhealthy',
   'status.attention': 'Needs attention',
@@ -838,7 +853,8 @@ const I18N_EN = {
   'status.backToListRefresh': ', the list returns to AUTO REFRESH / manual refresh; hit “Reconnect” on the activity bar to resubscribe',
   'btn.reconnectEvents': 'Reconnect',
   'hint.reconnectEvents': 'Reopen the container event stream (docker events); the list refresh button reconnects it too',
-  'hint.eventsClosedNoAuto': 'A closed event stream does not come back on its own (EventSource only self-heals connection blips; the docker events process exiting is terminal) — click to reconnect, or hit refresh in the top right',
+  'hint.eventsClosedNoAuto': 'Will not recover on its own — click Reconnect',
+  'hint.eventsReconnectRefused': 'Reconnect refused: {message}',
   'hint.conversationHidden': ' · the session is behind this panel: close or minimise the panel/terminal to see it',
   'msg.copied': 'Copied: ',
   'error.copyManual': 'Copy failed, run it manually: ',
@@ -958,11 +974,14 @@ const I18N_EN = {
   'field.execTimeout': 'exec timeout (seconds)',
   'section.capabilities': 'Capability switches (off by default)',
   'check.allowMutations': 'Allow changes (start/stop/remove containers, pull / remove / prune images)',
-  'check.allowExec': 'Allow exec (run commands inside containers)',
+  'check.allowExec': 'Allow one-shot exec (panel command box and docker_exec; interactive container access is not gated by it)',
   'hint.socketRoot': 'The docker socket is equivalent to root on the target host. Once enabled, both the browser panel and the agent can run these operations — only turn it on in a trusted environment.',
   'hint.capabilityNotGranted': '⚠ Not granted by the host: these two switches cannot be turned on right now — clicking one gives you a command to confirm in place (no restart). Turning them off always works.',
   'badge.notEffective': 'Not effective: not granted by the host',
   'elev.title': 'Grant in place (no restart)',
+  'elev.copyAll': 'Copy all ({count})',
+  'elev.copyAllHint': 'Each capability needs its own command. Paste both lines at once; every switch unlocks by itself once they run (each on its own probe cycle).',
+  'elev.copyAllCopied': 'Copied all {count}',
   'elev.lockedWhy': 'Any local process can send loopback requests, so “turn on a dangerous capability” cannot be decided by this page alone — it has to be confirmed on the host’s filesystem once.',
   'elev.step': 'Run the command below in a terminal on the host and the switch unlocks by itself:',
   'elev.copy': 'Copy command',
@@ -1540,17 +1559,42 @@ const ICON_VOLUME =
  * 不进 settings，也不新增任何服务端字段，刷新后按 id 对账即可。
  */
 
-/** 超过这个数就给「浏览器并发长连接有限制」的软提示（仍可聚合）。 */
-const PICK_SOFT_MAX = 6
-/** 硬上限：再多就置灰——同源长连接排队后，聚合流反而会「看起来卡住」。 */
-const PICK_MAX = 8
+/*
+ * 浏览器**同源并发连接**预算（D165，2026-10-08 实测）。
+ *
+ * 为什么这是硬约束而不是「性能建议」：宿主是 **HTTP/1.1**（没有 h2 多路复用），浏览器对
+ * 每个源只放这么多条 TCP；而**每条 EventSource 独占一条连接、且永不主动释放**。吃满之后
+ * 同一个页面里**所有**普通请求（`/api/*`、列表刷新、会话加载……）全部排队——用户看到的是
+ * 「整个 DSH 页面卡住」，不只是 docker 面板。
+ *
+ * 实测（真 Chrome + test profile 宿主，页内连打 10 次普通请求、2s 超时）：
+ *   常驻流 4 条 → 6/6 成功、中位 29ms；常驻流 5 条 → **0/6 全部超时**。
+ * 宿主侧同时刻实测 41ms（进程外请求正常）——**堵在浏览器，不在宿主**。
+ * 所以预算是 4 条常驻流，且要**连同事件流一起算**：面板停在容器页时事件流恒开
+ * （见下方 events effect），聚合日志只能用掉剩下的 3 条。
+ *
+ * 这个数**不是猜的**，是量出来的；改它之前请重跑那组实验（README「已知限制」有复现步骤）。
+ */
+const SAME_ORIGIN_STREAM_BUDGET = 4
+/** 容器页常开的那条事件流（活动条）。它在预算里，不能被聚合日志挤掉。 */
+const RESERVED_STREAMS = 1
+/** 聚合日志可达的硬上限 = 预算 − 事件流。 */
+const PICK_MAX = SAME_ORIGIN_STREAM_BUDGET - RESERVED_STREAMS
+/**
+ * 超过这个数就给软提示（仍可聚合）。
+ *
+ * 与硬上限之间刻意**留一档**：硬上限是「再点就连页面都卡」的红线，而用户在 3 条时
+ * 已经在消耗大部分预算——给一句提醒，但不禁用。
+ */
+const PICK_SOFT_MAX = 2
 /**
- * SSH 目标的硬上限：一个目标只维持**一条** TCP 连接，通道额度（OpenSSH `MaxSessions`
- * 默认 10）要同时装下聚合流、统计流、事件流与「刷新列表」这类短命令。留出余量之后
- * 聚合最多 6 条——正好等于软提示线，于是 SSH 上不再有「可点但已偏多」的区间。
- * 本地目标走子进程，没有这个约束，仍是 {@link PICK_MAX}。
+ * SSH 目标为什么不再单独降一档：真正卡住页面的是**浏览器同源预算**（上面那条，与目标
+ * 类型无关），而不是 SSH 的 `MaxSessions`。旧代码把上限按「SSH 要同时装实时流与短命令」
+ * 设成 6——那条例由针对的是**宿主侧**通道额度，与浏览器这一层是两笔独立的账，写成同一个
+ * 数字正好把两者都算错（6 > 实测安全值）。现在两者各归各：浏览器预算管上限，
+ * `MaxSessions` 由宿主侧的 `MAX_STREAMS_PER_TARGET` 管。
  */
-const PICK_MAX_SSH = 6
+const PICK_MAX_SSH = PICK_MAX
 
 /**
  * 目标下拉里要不要列「＋ 连接本机」那一项。
@@ -1615,8 +1659,8 @@ function pickReconcile(ids, containers) {
 
 /**
  * 「按条件一键选择」的预设（0.15.0）。
- * 为什么需要：跨 30+ 容器里挑 4 个不健康的，手动点既慢又容易漏；而聚合日志的上限是
- * 8 条流，所以条件选择必须能**按上限截断并如实告知略过了几个**。
+ * 为什么需要：跨 30+ 容器里挑几个不健康的，手动点既慢又容易漏；而聚合日志有上限
+ * （见 {@link PICK_MAX}），所以条件选择必须能**按上限截断并如实告知略过了几个**。
  * `needsBase` 的项要先有勾选（拿第一个勾选的容器当基准：同镜像 / 同项目）。
  */
 const PICK_PRESETS = [
@@ -1954,6 +1998,36 @@ function canReconnectEvents(status) {
   return status === 'closed'
 }
 
+/**
+ * 从事件流的 `error` 事件里解出**服务端给的原因**（D164）。
+ *
+ * 为什么必须解出来：这条流的 `event: error` 带着 data 时（服务端主动拒绝 / 收尾），原文案
+ * 是宿主侧唯一一句可执行的话——例如长流配额满时的「关掉部分实时跟随、把聚合容器数减到 6 个
+ * 以内」。老代码把它整个丢掉、只置 `closed`，于是**点「重连」看起来毫无反应**：拒绝 →
+ * 状态回 `closed` → 界面与点击前逐像素相同，用户只能反复点。统计流一直是对的
+ * （`setStatsError(message)`），这里补齐同一套语义。
+ *
+ * 连接层错误（无 data 的普通 Event）不是「服务端说了什么」，返回空串——那种情况
+ * EventSource 会自己重连，不该冒充成一次被拒绝的重连。
+ *
+ * 抽成纯函数而不是写在组件闭包里：离线冒烟的 React 桩把 `useState` 冻在初值，组件里
+ * 遍历渲染树取不到真实调用结果，判定必须能直接驱动（与 canReconnectEvents 同一个理由）。
+ */
+function eventsErrorMessage(raw) {
+  if (raw === null || raw === undefined) return ''
+  const data = raw.data
+  if (typeof data !== 'string' || data === '') return ''
+  try {
+    const payload = JSON.parse(data)
+    if (payload !== null && typeof payload === 'object' && typeof payload.message === 'string') {
+      return payload.message
+    }
+  } catch {
+    /* 畸形载荷：按「没有可读原因」处理，不要拿半截 JSON 当文案 */
+  }
+  return data
+}
+
 /** 新事件放最前（活动条按时间倒序读），超出上限丢最旧。 */
 function pushEvent(list, event, limit) {
   const next = [event, ...list]
@@ -5467,6 +5541,19 @@ window.__ModuleLoader__.load({
        * `unsupported` 刻意不给这个按钮：那个环境根本没有 EventSource，重连必然还是失败。
        */
       const canReconnect = canReconnectEvents(props.status)
+      /*
+       * 断开时右侧那句提示（D164）：**被拒过就优先说原因**。「事件流已断开」只说状态，
+       * 用户据此以为点一下就好；而真正拦着重连的是服务端那句话（例如长流配额满），
+       * 不显示出来，「重连」按钮点多少次都像假的。
+       *
+       * 文案要**短**（2026-10-08 用户反馈「啰嗦又生硬」）：这里是折叠头右侧的单行小字，
+       * 长句会挤成多行墙。状态行左边已经写着「事件流已断开」，这句不再复述，
+       * 只说「不会自愈 + 点哪」；成因与上限写进 README，不塞进界面。
+       */
+      const refused = typeof props.refused === 'string' ? props.refused : ''
+      const hintText = canReconnect
+        ? (refused === '' ? t('hint.eventsClosedNoAuto') : t('hint.eventsReconnectRefused', { message: refused }))
+        : (events.length === 0 ? t('list.noEvents') : t('list.recentEvents', { recent: recent.length, total: events.length }))
       return jsxs('div', { className: 'dk_activity', 'data-open': open ? '1' : '0', children: [
         /*
          * 折叠按钮与「重连」是**兄弟**，不是嵌套——按钮里嵌按钮既不是合法 HTML，
@@ -5484,10 +5571,8 @@ window.__ModuleLoader__.load({
               jsx('span', { className: 'dk_activityState', 'data-state': props.status ?? '', children: props.statusText ?? '' }),
               jsx('span', { className: 'dk_headerSpacer' }),
               // 断开时右侧那句「暂无事件」是误导（不是「没动静」，是「听不见了」），
-              // 换成一句说明为什么需要手动重连
-              jsx('span', { className: 'dk_hint', children: canReconnect
-                ? t('hint.eventsClosedNoAuto')
-                : (events.length === 0 ? t('list.noEvents') : t('list.recentEvents', { recent: recent.length, total: events.length })) }),
+              // 换成一句说明为什么需要手动重连；**被拒过就改成说原因**（D164）
+              jsx('span', { className: 'dk_hint', children: hintText }),
               jsx('span', { className: 'dk_activityChevron', dangerouslySetInnerHTML: { __html: ICON_CHEVRON } }),
             ],
           }, 'head'),
@@ -5557,6 +5642,7 @@ window.__ModuleLoader__.load({
             onClick: props.onClear,
             children: t('btn.clear'),
           }, 'clear') : null,
+          props.budget === undefined ? null : jsx('span', { className: 'dk_hint dk_pickBudget', children: props.budget }),
           props.notice === '' ? null : jsx('span', { className: 'dk_hint dk_pickNotice', children: props.notice }),
         ] }) : null,
       ] })
@@ -5786,6 +5872,12 @@ window.__ModuleLoader__.load({
       /** 面板是否可见（S3）：折叠的 tab 不建流；模态 / dock 形态恒为 true。 */
       const active = usePanelActive()
       const [eventsStatus, setEventsStatus] = useState('')
+      /**
+       * 上一次被服务端**拒绝**的原因（D164）：配额满这类拒绝在界面上必须看得见，
+       * 否则「点重连 → 被拒 → 回到 closed」在视觉上与「点了没反应」不可区分。
+       * 重连**成功**时清空（那说明这个原因已经过去了）。
+       */
+      const [eventsRefused, setEventsRefused] = useState('')
       /**
        * 手动重连令牌（D160）：事件流断开后是**终止态**（EventSource 只在连接层抖动时自愈；
        * `docker events` 进程退出 / 服务端发 `end` 帧都会走 close()，之后没有东西会再开流）。
@@ -6445,6 +6537,9 @@ window.__ModuleLoader__.load({
          */
         let hadOpen = sameTarget && (eventsOpenedRef.current.opened || manualReconnect)
         setEventsStatus('connecting')
+        // 每次重新建流都先把上一条拒绝原因清掉（D164）：这是「又试了一次」，不是「一直坏着」；
+        // 若这次仍被拒，onError 会立刻把它写回来。
+        setEventsRefused('')
         const debounced = makeDebounced(EVENTS_REFRESH_DEBOUNCE_MS, () => {
           const load = loadContainersRef.current
           if (load !== null) load()
@@ -6473,8 +6568,15 @@ window.__ModuleLoader__.load({
           close()
         }
         const onError = (raw) => {
-          if (typeof raw.data === 'string' && raw.data !== '') {
+          /*
+           * 服务端主动说了原因（带 data 的 error 帧）：**显式收尾**，并把那句话留下来
+           * （D164）。老代码把它丢掉、只置 `closed`，于是「重连」点了看起来毫无反应——
+           * 拒绝 → 回 `closed` → 界面与点击前一样。统计流一直是读出 message 的。
+           */
+          const message = eventsErrorMessage(raw)
+          if (message !== '') {
             setEventsStatus('closed')
+            setEventsRefused(message)
             close()
             return
           }
@@ -6486,6 +6588,8 @@ window.__ModuleLoader__.load({
         es.addEventListener('error', onError)
         es.onopen = () => {
           setEventsStatus('open')
+          // 连上了就说明上次那条拒绝原因已经过去（D164）：留着会让人以为现在还坏着
+          setEventsRefused('')
           if (hadOpen) {
             // 重连补偿**不走事件驱动的那条防抖**（D93）：debounced 是 500ms 尾沿防抖，
             // 每条事件都 schedule() 一次；容器多 + healthcheck 时事件持续 >2 条/秒，
@@ -7327,6 +7431,9 @@ window.__ModuleLoader__.load({
               info: pickInfo,
               presets: pickPresetList,
               max: pickMax,
+              // 上限为什么是 3 得写在脸上（D165）：它是量出来的浏览器连接预算，
+              // 不写清楚，看起来就只是一个随手定的数字，用户只会觉得「怎么才 3 个」。
+              budget: t('hint.pickBudget'),
               notice: pickNotice,
               onPreset: applyPreset,
               onClear: () => { setPickedIds([]); setPickNotice('') },
@@ -7373,6 +7480,7 @@ window.__ModuleLoader__.load({
                   events,
                   status: eventsStatus,
                   statusText: eventsStatusText(),
+                  refused: eventsRefused,
                   open: activityOpen,
                   onToggle: () => setActivityOpen((value) => !value),
                   // 只重开事件流，不顺带刷列表：列表有自己的 ⟳ 与 AUTO REFRESH，
@@ -7534,6 +7642,118 @@ window.__ModuleLoader__.load({
      * 设置卡片
      * ------------------------------------------------------------------ */
 
+    /** 能力开关名 → 宿主侧环境变量名（「另一种方式」那一栏要写出具体变量名）。 */
+    const CAPABILITY_ENV = {
+      allowMutations: 'DSH_DOCKER_ALLOW_MUTATIONS',
+      allowExec: 'DSH_DOCKER_ALLOW_EXEC',
+    }
+
+    /** 能力名 → 开关文案（面板标题靠它）。 */
+    function capabilityLabelOf(capability) {
+      return capability === 'allowMutations' ? t('check.allowMutations') : t('check.allowExec')
+    }
+
+    /**
+     * 就地提权面板组——**纯渲染函数**（入参是纯数据 + 一组回调，返回 jsx 树），刻意不做成组件：
+     * 离线冒烟的 React 桩把 `useState` 冻在初值上、`useEffect` 是空实现，「两个能力同时 pending」
+     * 这件事在组件里根本走不到，而它正是本次改造要保证的行为。做成普通函数后，用例可以真的调用它、
+     * 遍历返回的 jsx 树、并**驱动合并按钮的 onClick** 断言被复制下去的字节（见 scripts/client-smoke.mjs）。
+     *
+     * 结构：合并复制行（≥2 个能力 pending 时才有）→ 逐能力堆叠的面板（已授权的留痕不渲染）。
+     */
+    function elevationPanelsView(records, options) {
+      const list = Array.isArray(records) ? records : []
+      const now = options.now === undefined ? Date.now() : options.now
+      const pending = list.filter((record) => record !== null && record !== undefined && record.granted !== true)
+      if (pending.length === 0) return null
+      const merged = mergeElevationCommands(list, now)
+      const panel = (record) => {
+        const capability = String(record.capability)
+        const seconds = Number.isFinite(record.expiresAt)
+          ? Math.max(0, Math.ceil((Number(record.expiresAt) - now) / 1000))
+          : 0
+        return jsxs('div', { className: 'dk_elevPanel', children: [
+          jsxs('div', { className: 'dk_row', children: [
+            jsx('span', { className: 'dk_label', children: t('elev.title') + ' · ' + capabilityLabelOf(capability) }),
+            jsx('button', {
+              type: 'button',
+              className: 'dk_btn',
+              onClick: () => options.onClose(capability),
+              children: t('elev.close'),
+            }, 'close'),
+          ] }),
+          jsx('span', { className: 'dk_hint', children: t('elev.lockedWhy') }),
+          record.error === undefined
+            ? null
+            : jsx('span', { className: 'dk_hint dk_hintWarn', children: t('elev.error') + String(record.error) }),
+          record.command === undefined
+            ? null
+            : jsxs('div', { className: 'dk_elevSteps', children: [
+              jsx('span', { className: 'dk_hint', children: t('elev.step') }),
+              jsx('code', { className: 'dk_elevCommand', children: String(record.command) }),
+              /*
+               * 动作行：复制 / 重新生成 / 倒计时**并排一行、紧贴命令**。
+               *
+               * 早先这三样各自占一条栅格行，而且「重新生成」被「282 秒后失效」「等待确认…」两行
+               * 说明文字隔在下面——2026-09-27 的真机报告（Windows）里那块看上去就是散的：
+               * 按钮离自己的命令越远，越像「不知道点了会发生什么」。命令与它的按钮是一件事（docker D149）。
+               */
+              jsxs('div', { className: 'dk_elevActions', children: [
+                jsx('button', {
+                  type: 'button',
+                  className: 'dk_btn dk_btnPrimary',
+                  // 复制反馈**逐能力**隔离：这个按钮只认自己能力的键
+                  onClick: () => options.onCopy(capability, String(record.command)),
+                  children: options.copiedKey === capability ? t('elev.copied') : t('elev.copy'),
+                }, 'copy'),
+                jsx('button', {
+                  type: 'button',
+                  className: 'dk_btn',
+                  onClick: () => options.onRegenerate(capability),
+                  children: t('elev.regenerate'),
+                }, 'regen'),
+                jsx('span', {
+                  className: seconds > 0 ? 'dk_hint' : 'dk_hint dk_hintWarn',
+                  children: seconds > 0 ? t('elev.expiresIn', { sec: seconds }) : t('elev.expired'),
+                }),
+              ] }),
+              jsx('span', { className: 'dk_hint', children: t('elev.waiting') }),
+              jsxs('details', { className: 'dk_elevOther', children: [
+                jsx('summary', { children: t('elev.otherWay') }),
+                jsx('span', {
+                  className: 'dk_hint',
+                  children: t('elev.envHow', { env: CAPABILITY_ENV[capability] ?? '' }),
+                }),
+              ] }),
+            ] }),
+          options.configured(capability) === true
+            ? jsx('button', {
+              type: 'button',
+              className: 'dk_btn',
+              onClick: () => options.onDisableFirst(capability),
+              children: t('elev.disableFirst'),
+            }, 'disable')
+            : null,
+        ] })
+      }
+      return jsxs('div', { className: 'dk_elevPanels', children: [
+        shouldOfferMerge(list, now)
+          ? jsxs('div', { className: 'dk_elevMerge', children: [
+            jsx('button', {
+              type: 'button',
+              className: 'dk_btn dk_btnPrimary',
+              onClick: () => options.onCopyAll(joinElevationCommands(merged), merged.length),
+              children: options.copiedKey === ELEVATION_COPY_ALL
+                ? t('elev.copyAllCopied', { count: merged.length })
+                : t('elev.copyAll', { count: merged.length }),
+            }, 'copyAll'),
+            jsx('span', { className: 'dk_hint', children: t('elev.copyAllHint') }),
+          ] })
+          : null,
+        ...pending.map((record) => panel(record)),
+      ] })
+    }
+
     function DockerSettingsCard(props) {
       // DSH ≥0.1.6 的插件配置页把同一条目按 view 渲染两次：summary 一句话摘要、page 完整表单。
       // 旧版（≤0.1.5）的 settings.plugin.item 卡片不带 view，走原有可折叠卡片分支。
@@ -7565,10 +7785,26 @@ window.__ModuleLoader__.load({
        * 就地提权（见 kit 的 elevation.ts）：点开关 → 面板给出一条「在宿主上落地一个随机名文件」的
        * 命令 → 宿主发现文件即授权，免重启。状态放在卡片里而不是子组件里：离线冒烟的 React 桩不执行
        * 函数组件体（见文件里其它地方的说明），状态留在卡片里才测得动。
+       *
+       * **逐能力**记录（数组，按发起顺序）而不是单槽：面板开着时再点另一个开关，单槽会把前一个
+       * 能力的面板**替换**掉——它的命令从界面消失（宿主侧 challenge 仍 pending），用户于是要在宿主
+       * 终端粘贴两次（2026-09-26 截图实测：两次授权差 14 秒）。逐能力记录让两块面板同时在场，
+       * 顶部出一个「复制全部」。纯逻辑在 `client-src/elevation.js`（冒烟能直接驱动）。
+       *
+       * 为什么不做「kit 侧 begin 返回合并命令」（备选方案，已否）：`finishElevation` 只处理**被轮询
+       * 到的那个**能力，合并命令会让另一个能力停在「宿主已授权、配置开关没开」的半状态；还要处理
+       * 两条独立探测定时器之间的授权竞态。客户端合并零 API 变更、零新安全面——kit 的
+       * begin / status / revoke 契约一字不动（nonce 仍只出现在 begin 响应里）。
        */
-      const [elevation, setElevation] = useState(null)
+      const [elevations, setElevations] = useState([])
       const [elevationNotice, setElevationNotice] = useState('')
-      const [copied, setCopied] = useState(false)
+      /**
+       * 复制反馈的归属键（**不是**布尔）：单条按钮传自己的能力名、合并按钮传哨兵
+       * `ELEVATION_COPY_ALL`，渲染时各自判自己的键——于是「复制了 A」不会让 B 的按钮也显示
+       * 「已复制」，而「复制全部」也不会让每一块面板都亮起来（改前是一个全局 `copied` 布尔，
+       * 两个按钮会一起变成已复制）。同一时刻只留一处反馈是刻意的：它说的是「你刚复制的是哪一份」。
+       */
+      const [copiedKey, setCopiedKey] = useState('')
       /** 每秒推进一次的计数：只为了让「还剩 N 秒」自己走（读的是渲染期的时间差）。 */
       const [nowTick, setNowTick] = useState(0)
       /** 授权到达后要「先把开关写进表单、再自动保存」：保存读的是表单镜像，得等一次提交。 */
@@ -7691,12 +7927,6 @@ window.__ModuleLoader__.load({
 
       /* ---------------- 就地提权（capability elevation） ---------------- */
 
-      /** 能力开关名 → 宿主侧环境变量名（「另一种方式」那一栏要写出具体变量名）。 */
-      const CAPABILITY_ENV = {
-        allowMutations: 'DSH_DOCKER_ALLOW_MUTATIONS',
-        allowExec: 'DSH_DOCKER_ALLOW_EXEC',
-      }
-
       /**
        * 快照 → 表单：能力开关在表单里存**配置值**（用户写下的那个），不是快照里的有效值。
        *
@@ -7735,8 +7965,18 @@ window.__ModuleLoader__.load({
        * 一起写进去。脏的时候只把开关置上并提示「点保存生效」——不替用户做决定。
        */
       const finishElevation = (capability) => {
-        setElevation(null)
-        setCopied(false)
+        /*
+         * **不删记录**，只把它标成已授权并把命令清掉（面板据此消失）。为什么留着这条痕迹：
+         * 合并按钮的存续跟着「面板组里有过几个能力」，不是跟着当前还剩几条命令——两个能力
+         * 都点过之后，其中一个先解锁，按钮要留着把**剩下那条**交给用户（此时再让他回单条面板
+         * 里找命令，等于把刚刚那次「一次粘贴」的动作拆回去）。两个都解锁后组里没有可复制命令，
+         * 按钮自然消失（见 shouldOfferMerge）。
+         *
+         * 反向也成立：「单个 pending → 无合并按钮」——只动过一个开关时组里只有一条记录，
+         * 那条命令就在它自己的面板里，不需要一个「复制全部（1 条）」的按钮。
+         */
+        setElevations((current) => markElevationGranted(current, capability))
+        setCopiedKey('')
         const clean = JSON.stringify(toPayload(formRef.current)) === cleanPayloadRef.current
         setForm((current) => (current === null ? current : { ...current, [capability]: true }))
         setElevationNotice(clean ? t('elev.granted') : t('elev.grantedNeedSave'))
@@ -7746,19 +7986,37 @@ window.__ModuleLoader__.load({
 
       const beginElevation = (capability) => {
         setElevationNotice('')
-        setCopied(false)
-        setElevation({ capability })
+        setCopiedKey('')
+        // 只增改**这一个**能力的记录，别的 pending 原样留着（面板不再被替换）
+        setElevations((current) => upsertElevationRecord(current, capability, {
+          capability,
+          command: undefined,
+          expiresAt: undefined,
+          error: undefined,
+          // 清掉上一轮的「已授权」痕迹：撤销授权后再点这个开关要能重新出面板
+          granted: false,
+        }))
         api.elevateBegin(capability).then((result) => {
           if (result !== null && result.status === 'granted') {
             finishElevation(capability)
             return
           }
           if (result !== null && result.status === 'pending') {
-            setElevation({ capability, command: String(result.command), expiresAt: Number(result.expiresAt) })
+            setElevations((current) => upsertElevationRecord(current, capability, {
+              capability,
+              command: String(result.command),
+              expiresAt: Number(result.expiresAt),
+            }))
             return
           }
-          setElevation({ capability, error: String((result && result.error) ?? '') })
-        }).catch((error) => setElevation({ capability, error: String(error.message) }))
+          setElevations((current) => upsertElevationRecord(current, capability, {
+            capability,
+            error: String((result && result.error) ?? ''),
+          }))
+        }).catch((error) => setElevations((current) => upsertElevationRecord(current, capability, {
+          capability,
+          error: String(error.message),
+        })))
       }
 
       const revokeElevation = (capability) => {
@@ -7769,14 +8027,36 @@ window.__ModuleLoader__.load({
         }).catch((error) => setElevationNotice(t('elev.error') + String(error.message)))
       }
 
-      /** 复制命令：拿不到剪贴板（老宿主 / 非安全上下文）时退回「请手动复制」。 */
-      const copyCommand = (command) => {
+      /**
+       * 复制命令：拿不到剪贴板（老宿主 / 非安全上下文）时退回「请手动复制」。
+       *
+       * `key` 是反馈的归属：单条按钮传能力名，合并按钮传 `ELEVATION_COPY_ALL`——
+       * 于是「复制了 A」不会让 B 的按钮也显示「已复制」（早先是一个全局 `copied`）。
+       */
+      const copyCommand = (key, command) => {
         const clipboard = typeof navigator === 'undefined' ? undefined : navigator.clipboard
         if (clipboard === undefined || typeof clipboard.writeText !== 'function') {
           setElevationNotice(t('elev.copyManual'))
           return
         }
-        clipboard.writeText(command).then(() => setCopied(true)).catch(() => setElevationNotice(t('elev.copyManual')))
+        clipboard.writeText(command).then(() => setCopiedKey(key)).catch(() => setElevationNotice(t('elev.copyManual')))
+      }
+
+      /**
+       * 合并复制：把所有**仍 pending**（未过期、已拿到命令）的命令按发起顺序用换行连接后一次复制。
+       *
+       * 命令的取用 / 排序 / 连接全在纯函数里（`client-src/elevation.js` 的 `buildMergedElevationText`
+       * 与 `joinElevationCommands`），这里只负责把它交给剪贴板。连接方式为什么是换行而不是 `&&` / `;`：
+       * bash / zsh / PowerShell / cmd 粘贴多行都逐行执行，平台无关；`&&` 在 PS 5.1 上不认，`;` 在 cmd
+       * 上不认。文案只说「执行后全部开关自动解锁」，不承诺同一时刻：两个 challenge 的 TTL 与探测
+       * 周期各自独立（逐面板倒计时照旧显示）。
+       */
+      const copyAllElevations = (text) => {
+        if (text === '') {
+          setElevationNotice(t('elev.copyManual'))
+          return
+        }
+        copyCommand(ELEVATION_COPY_ALL, text)
       }
 
       /*
@@ -7793,20 +8073,33 @@ window.__ModuleLoader__.load({
       /*
        * 面板开着时轮询授权状态（1.5s）并顺带推进倒计时。轮询而不是等推送：这条通道本来就是
        * 「用户在别的终端里做了一件事」，宿主没有可订阅的事件面。
+       *
+       * **轮询全部 pending 能力**（不再只盯单槽那一个）：两个 challenge 是各自独立开始的，
+       * 各自的授权时刻可以差十几秒；只轮询一个会让另一个停在「宿主已授权、开关没开」。
+       * deps 用**能力名的拼接串**而不是数组：数组每次渲染都是新引用，effect 会被反复拆装，
+       * 1.5s 的节拍随之漂成「每渲染一次就重建定时器」。内容不变时它一字不变，effect 就不动。
        */
-      const elevationCapability = elevation === null ? '' : String(elevation.capability)
+      const elevationPendingKey = elevations
+        // 已授权的那条只是「留痕」（面板已消失），不再轮询——否则每 1.5s 又会走一遍 finishElevation
+        .filter((item) => item.granted !== true)
+        .map((item) => String(item.capability))
+        .sort()
+        .join(',')
       useEffect(() => {
-        if (elevationCapability === '') return undefined
+        if (elevationPendingKey === '') return undefined
+        const capabilities = elevationPendingKey.split(',')
         const timer = setInterval(() => {
           setNowTick((value) => value + 1)
-          api.elevateStatus(elevationCapability).then((status) => {
-            if (status !== null && status.status === 'granted') finishElevation(elevationCapability)
-          }).catch(() => {
-            /* 轮询失败静默：宿主可能在重启，下一次再试 */
-          })
+          for (const capability of capabilities) {
+            api.elevateStatus(capability).then((status) => {
+              if (status !== null && status.status === 'granted') finishElevation(capability)
+            }).catch(() => {
+              /* 轮询失败静默：宿主可能在重启，下一次再试 */
+            })
+          }
         }, 1500)
         return () => clearInterval(timer)
-      }, [elevationCapability])
+      }, [elevationPendingKey])
 
       /* ---------------- 能力开关那一段的渲染 ---------------- */
 
@@ -7912,79 +8205,35 @@ window.__ModuleLoader__.load({
         ] })
       }
 
-      /** 就地提权面板（内联展开；不用 confirm()——那会在 React 之外同步阻塞渲染）。 */
-      const elevationPanel = () => {
-        const capability = String(elevation.capability)
-        const label = capability === 'allowMutations' ? t('check.allowMutations') : t('check.allowExec')
-        const seconds = elevation.expiresAt === undefined
-          ? 0
-          : Math.max(0, Math.ceil((Number(elevation.expiresAt) - Date.now()) / 1000))
-        const close = () => {
-          setElevation(null)
-          setCopied(false)
-        }
-        return jsxs('div', { className: 'dk_elevPanel', children: [
-          jsxs('div', { className: 'dk_row', children: [
-            jsx('span', { className: 'dk_label', children: t('elev.title') + ' · ' + label }),
-            jsx('button', { type: 'button', className: 'dk_btn', onClick: close, children: t('elev.close') }, 'close'),
-          ] }),
-          jsx('span', { className: 'dk_hint', children: t('elev.lockedWhy') }),
-          elevation.error === undefined
-            ? null
-            : jsx('span', { className: 'dk_hint dk_hintWarn', children: t('elev.error') + String(elevation.error) }),
-          elevation.command === undefined
-            ? null
-            : jsxs('div', { className: 'dk_elevSteps', children: [
-              jsx('span', { className: 'dk_hint', children: t('elev.step') }),
-              jsx('code', { className: 'dk_elevCommand', children: String(elevation.command) }),
-              /*
-               * 动作行：复制 / 重新生成 / 倒计时**并排一行、紧贴命令**。
-               *
-               * 早先这三样各自占一条栅格行，而且「重新生成」被「282 秒后失效」「等待确认…」两行
-               * 说明文字隔在下面——2026-09-27 的真机报告（Windows）里那块看上去就是散的：
-               * 按钮离自己的命令越远，越像「不知道点了会发生什么」。命令与它的按钮是一件事（docker D149）。
-               */
-              jsxs('div', { className: 'dk_elevActions', children: [
-                jsx('button', {
-                  type: 'button',
-                  className: 'dk_btn dk_btnPrimary',
-                  onClick: () => copyCommand(String(elevation.command)),
-                  children: copied ? t('elev.copied') : t('elev.copy'),
-                }, 'copy'),
-                jsx('button', {
-                  type: 'button',
-                  className: 'dk_btn',
-                  onClick: () => beginElevation(capability),
-                  children: t('elev.regenerate'),
-                }, 'regen'),
-                jsx('span', {
-                  className: seconds > 0 ? 'dk_hint' : 'dk_hint dk_hintWarn',
-                  children: seconds > 0 ? t('elev.expiresIn', { sec: seconds }) : t('elev.expired'),
-                }),
-              ] }),
-              jsx('span', { className: 'dk_hint', children: t('elev.waiting') }),
-              jsxs('details', { className: 'dk_elevOther', children: [
-                jsx('summary', { children: t('elev.otherWay') }),
-                jsx('span', {
-                  className: 'dk_hint',
-                  children: t('elev.envHow', { env: CAPABILITY_ENV[capability] ?? '' }),
-                }),
-              ] }),
-            ] }),
-          form[capability] === true
-            ? jsx('button', {
-              type: 'button',
-              className: 'dk_btn',
-              onClick: () => {
-                patch({ [capability]: false })
-                close()
-              },
-              children: t('elev.disableFirst'),
-            }, 'disable')
-            : null,
-        ] })
+      /**
+       * 一块能力的面板（✕）与整个面板组都渲染自 `elevationPanelsView`（factory 级纯函数，
+       * 见那段注释）：组件这边只提供**状态与回调**，界面结构留在纯函数里，冒烟才驱动得动。
+       *
+       * 逐个能力的动作语义：
+       * - ✕ 只收起**这一个**能力的面板；别的 pending 原样留着（也不撤销宿主侧 challenge，
+       *   与改造前 close 的语义一致——challenge 仍在 pending，重新点开关即复用同一条命令）。
+       * - 「重新生成」= 再走一次 `beginElevation`（逐能力幂等，不动别的能力）。
+       * - 「先关掉这个配置开关」= 关配置 + 收起自己那块面板。
+       */
+      const closeElevationPanel = (capability) => {
+        setElevations((current) => pruneElevationRecords(removeElevationRecord(current, capability)))
+        setCopiedKey('')
       }
 
+      const elevationPanels = () => elevationPanelsView(elevations, {
+        now: Date.now(),
+        copiedKey,
+        configured: (capability) => form[capability] === true,
+        onCopy: (capability, command) => copyCommand(capability, command),
+        onCopyAll: (text) => copyAllElevations(text),
+        onRegenerate: (capability) => beginElevation(capability),
+        onClose: (capability) => closeElevationPanel(capability),
+        onDisableFirst: (capability) => {
+          patch({ [capability]: false })
+          closeElevationPanel(capability)
+        },
+      })
+
       const sectionTitle = (text) => jsx('div', { className: 'dk_cardSection', children: text })
 
       const field = (label, control, hint, span) => jsxs('div', {
@@ -8096,7 +8345,7 @@ window.__ModuleLoader__.load({
         elevationNotice === ''
           ? null
           : jsx('span', { className: 'dk_hint', children: elevationNotice }),
-        elevation === null ? null : elevationPanel(),
+        elevations.length === 0 ? null : elevationPanels(),
 
         sectionTitle(t('field.target')),
         ...form.targets.map((item, index) => {
@@ -8528,8 +8777,11 @@ window.__ModuleLoader__.load({
     }
     exports.__pick = {
       MAX: PICK_MAX,
-      /** SSH 目标的上限（= MAX 之外更紧的一档）：一条连接要同时装实时流与短命令。 */
+      /** SSH 目标的上限（D165 后与本地同值：卡页面的是浏览器同源预算）。 */
       SSH_MAX: PICK_MAX_SSH,
+      /** 同源常驻流预算与其中留给事件流的名额（上限的推导依据，测试直接钉住）。 */
+      BUDGET: SAME_ORIGIN_STREAM_BUDGET,
+      RESERVED: RESERVED_STREAMS,
       PRESETS: PICK_PRESETS,
       presetCounts: pickPresetCounts,
       apply: pickApply,
@@ -8552,6 +8804,7 @@ window.__ModuleLoader__.load({
       timeText: eventTimeText,
       debounce: makeDebounced,
       canReconnect: canReconnectEvents,
+      errorMessage: eventsErrorMessage,
     }
     /*
      * 同一类测试缝：总览的折叠逻辑与**正文渲染**都是纯函数（正文刻意写成普通函数而不是
@@ -8619,6 +8872,29 @@ window.__ModuleLoader__.load({
       PENDING_MAX: LOG_PENDING_MAX,
       FLUSH_MS: FOLLOW_FLUSH_MS,
     }
+    /*
+     * 就地提权「合并复制」的测试缝：逐能力记录的增改 / 收尾、取哪几条命令、顺序、怎么连接，
+     * 全是纯逻辑（`client-src/elevation.js`）。**必须直接驱动**而不是渲染卡片：离线冒烟的
+     * React 桩把 `useState` 冻在初值上、且 `useEffect` 是空实现，两块面板同时在场这件事
+     * 在组件里根本走不到（这正是 2026-09-26 那次「必须粘贴两次」漏掉测试入口的原因）。
+     */
+    exports.__elevation = {
+      upsert: upsertElevationRecord,
+      remove: removeElevationRecord,
+      markGranted: markElevationGranted,
+      prune: pruneElevationRecords,
+      merge: mergeElevationCommands,
+      join: joinElevationCommands,
+      text: buildMergedElevationText,
+      shouldOfferMerge,
+      COPY_ALL_KEY: ELEVATION_COPY_ALL,
+      /**
+       * 面板组的**渲染**（与 `__overview.body` 同一形态）：用例据它断言「几个 pending 才出
+       * 合并按钮」「按钮的 onClick 到底把什么字符串交下去」——只钉纯函数的话，「界面上没有
+       * 那个按钮」与「按钮接错了内容」这两类错都漏得掉。
+       */
+      view: elevationPanelsView,
+    }
     /*
      * 窗口化挂载（D152）的测试缝：布局是纯逻辑，离线冒烟直接驱动（真 DOM 里的量高与
      * 滚动位置由 test/log-window.test.ts 与性能门禁覆盖）。常量挂出来供用例对齐。