dsh-remote 0.8.41 → 0.8.42

package/lib/client.js

@@ -134,6 +134,14 @@ window.__ModuleLoader__.load({
         'settings.deployUseCommand': '将使用的 dsh',
         'settings.deploySteps': '安装步骤',
         'settings.deployDone': '部署完成，已记录该机器使用的 dsh',
+        'settings.deployFailed': '部署失败',
+        'settings.deployResumed': '已有部署任务在运行，已恢复显示其进度',
+        'settings.deployTaskTitle': '部署任务',
+        'settings.deployTaskRunning': '进行中',
+        'settings.deployTaskDone': '已完成',
+        'settings.deployTaskFailed': '失败',
+        'settings.deployTaskCancelled': '已取消',
+        'settings.deployCancel': '取消',
         'settings.deployInvestigateStarted': '已创建排查会话，请在会话里跟进。',
         'settings.badgePwd': '密码',
         'settings.badgeKeychain': '钥匙串',
@@ -392,6 +400,14 @@ window.__ModuleLoader__.load({
         'settings.deployUseCommand': 'dsh that will be used',
         'settings.deploySteps': 'Install steps',
         'settings.deployDone': 'Deployed; this machine now records the dsh it uses',
+        'settings.deployFailed': 'Deploy failed',
+        'settings.deployResumed': 'A deploy is already running — re-attached to its progress',
+        'settings.deployTaskTitle': 'Deploy task',
+        'settings.deployTaskRunning': 'running',
+        'settings.deployTaskDone': 'done',
+        'settings.deployTaskFailed': 'failed',
+        'settings.deployTaskCancelled': 'cancelled',
+        'settings.deployCancel': 'Cancel',
         'settings.deployInvestigateStarted': 'A session was created — follow up there.',
         'settings.badgePwd': 'password',
         'settings.badgeKeychain': 'keychain',
@@ -860,6 +876,10 @@ window.__ModuleLoader__.load({
       const [deployBusy, setDeployBusy] = React.useState('')
       const [deployErr, setDeployErr] = React.useState('')
       const [deployOpen, setDeployOpen] = React.useState(false)
+      // The HOST-SIDE deploy task (resumable across window close/reopen). This
+      // is the object the poll keeps fresh; it survives because the work runs
+      // on the host, not in this tab.
+      const [deployTask, setDeployTask] = React.useState(null)
       // session's machine", which the host resolves from the session binding.
       React.useEffect(() => { ensureChromeCss() }, [])
 
@@ -953,10 +973,31 @@ window.__ModuleLoader__.load({
       // ── 远程 DSH 界面（issue #46）─────────────────────────────────────────
       // The remote never opens an inbound port; we SSH out and carry the remote
       // loopback web UI back to a local port. One tunnel per machine.
+      //
+      // This SAME poll carries the deploy-task state, so a REOPENED window picks
+      // up an in-flight install on the first tick (15s worst case — plus the
+      // install button itself resumes). When a deploy is running the interval
+      // tightens so step progress looks live.
       const refreshWebAttaches = () => api('GET', '/dsh-remote/web-attach')
-        .then((r) => setWebAttaches(r.attaches || []))
+        .then((r) => {
+          setWebAttaches(r.attaches || [])
+          const t = (r.deploys || []).find((d) => d.machineId === webAttachMachine) || r.deploy || null
+          if (t && (t.status === 'running' || t.status === 'queued')) {
+            setDeployTask(t)
+            setDeployBusy('install')
+          } else if (t) {
+            setDeployTask(t)
+          }
+          return t
+        })
         .catch(() => {})
-      React.useEffect(() => { refreshWebAttaches(); const t = setInterval(refreshWebAttaches, 15000); return () => clearInterval(t) }, [])
+      React.useEffect(() => {
+        refreshWebAttaches()
+        const t = setInterval(() => {
+          refreshWebAttaches()
+        }, 15000)
+        return () => clearInterval(t)
+      }, [])
       const webAttachAction = (action, machineId, extra) => {
         setWebAttachBusy(machineId + ':' + action); setWebAttachErr('')
         return api('POST', '/dsh-remote/web-attach', { action, machineId, ...(extra || {}) })
@@ -968,23 +1009,60 @@ window.__ModuleLoader__.load({
       // ── 远程部署：体检 / 部署并验证 / 让 AI 排查 ───────────────────────────
       // The probe is read-only, so it is safe to run before the user agrees to
       // anything; the install requires an explicit second click (confirm: true).
+      //
+      // Install is a HOST-SIDE BACKGROUND TASK: the call returns immediately
+      // with a task handle, and progress arrives by polling. Closing the window
+      // loses nothing — reopening picks the task back up from the periodic
+      // web-attach poll (which carries the deploy state), and clicking 部署并验证
+      // again while one runs RESUMES it rather than starting a second npm.
+      const deployPoll = () => api('GET', '/dsh-remote/web-attach')
+        .then((r) => {
+          if (!r) return null
+          // Refresh the attach list like before…
+          setWebAttaches(r.attaches || [])
+          // …and adopt any deploy task for the selected machine.
+          const t = r.deploy || (r.deploys || []).find((d) => d.machineId === webAttachMachine) || null
+          if (t) {
+            setDeployTask(t)
+            if (t.status === 'running' || t.status === 'queued') {
+              setDeployBusy('install')
+            } else if (deployBusy === 'install') {
+              // The task settled since the last poll.
+              setDeployBusy('')
+              if (t.status === 'done') setDeployMsg(tr('settings.deployDone'))
+              if (t.status === 'failed') setDeployErr(t.error || tr('settings.deployFailed'))
+            }
+          }
+          return t
+        })
+        .catch(() => null)
+
       const deployAction = (action, machineId, extra) => {
-        setDeployBusy(action); setDeployErr('')
+        setDeployBusy(action); setDeployErr(''); setDeployMsg('')
         return api('POST', '/dsh-remote/web-attach', { action, machineId, ...(extra || {}) })
           .then((r) => {
             if (action === 'probe') setDeploy({ kind: 'probe', ...r, at: Date.now() })
-            if (action === 'install') setDeploy({ kind: 'install', ...r, at: Date.now() })
+            if (action === 'install') {
+              // The task is running on the host NOW. Adopt it immediately so the
+              // steps appear without waiting for the first poll tick.
+              if (r && r.task) setDeployTask(r.task)
+              if (r && r.resumed) setDeployMsg(tr('settings.deployResumed'))
+            }
             if (action === 'investigate') setDeploy({ kind: 'investigate', ...r, at: Date.now() })
             return r
           })
           .catch((e) => {
             const msg = String((e && e.message) || e)
             setDeployErr(msg)
-            // Keep the failing step list so the operator sees WHERE it stopped.
             setDeploy({ kind: action, ok: false, error: msg, at: Date.now() })
             return null
           })
-          .then((r) => { setDeployBusy(''); refreshWebAttaches(); return r })
+          .then((r) => {
+            if (action !== 'install') setDeployBusy('')
+            // install keeps busy='install' until the task settles (poll clears it).
+            refreshWebAttaches()
+            return r
+          })
       }
 
       const setF = (k) => (ev) => setForm({ ...form, [k]: ev.target.value })
@@ -1273,6 +1351,46 @@ window.__ModuleLoader__.load({
                 disabled: !!deployBusy || !webAttachMachine,
                 onClick: () => deployAction('probe', webAttachMachine) },
                 deployBusy === 'probe' ? tr('settings.deployProbing') : tr('settings.deployProbe'))),
+            // ── live deploy task (resumable; survives window close) ─────────
+            deployTask
+              ? React.createElement('div', { style: { marginTop: 6, fontSize: 12, lineHeight: 1.6, border: '1px solid ' + T.border, borderRadius: 8, padding: 8 } },
+                  React.createElement('div', { style: { fontWeight: 600, marginBottom: 4 } },
+                    tr('settings.deployTaskTitle')
+                    + ' — ' + (deployTask.status === 'running' || deployTask.status === 'queued'
+                      ? tr('settings.deployTaskRunning')
+                      : deployTask.status === 'done' ? tr('settings.deployTaskDone')
+                        : deployTask.status === 'cancelled' ? tr('settings.deployTaskCancelled')
+                          : tr('settings.deployTaskFailed'))),
+                  // The in-flight step: the one thing a re-attached user most
+                  // wants to see ("现在装到哪了").
+                  deployTask.current && (deployTask.status === 'running')
+                    ? React.createElement('div', { style: { fontSize: 12, color: T.warn, marginBottom: 4 } }, '▶ ' + deployTask.current)
+                    : null,
+                  (deployTask.steps || []).length
+                    ? React.createElement('div', null,
+                        React.createElement('div', { style: { fontWeight: 600, marginBottom: 2, fontSize: 11, opacity: 0.8 } }, tr('settings.deploySteps')),
+                        deployTask.steps.map((s) => React.createElement('div', { key: s.id, style: { fontSize: 11, fontFamily: 'monospace', display: 'flex', gap: 6 } },
+                          React.createElement('span', { style: { color: s.ok ? T.ok : T.danger } }, s.ok ? '✓' : '✗'),
+                          React.createElement('span', null, s.title),
+                          !s.ok && s.output ? React.createElement('span', { style: { opacity: 0.75, whiteSpace: 'pre-wrap', wordBreak: 'break-all' } }, ' — ' + String(s.output).slice(0, 300)) : null)))
+                    : null,
+                  deployTask.status === 'running' || deployTask.status === 'queued'
+                    ? React.createElement('div', { style: { display: 'flex', gap: 8, alignItems: 'center', marginTop: 6 } },
+                        React.createElement('span', { style: { fontSize: 11, opacity: 0.7 } },
+                          (deployTask.progress && deployTask.progress.doneSteps || 0) + '/' + (deployTask.progress && deployTask.progress.totalSteps || '?')),
+                        React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 10px' },
+                          onClick: () => deployAction('install-cancel', webAttachMachine) }, tr('settings.deployCancel')))
+                    : null,
+                  // A finished task: continue the journey — connect & open.
+                  deployTask.status === 'done'
+                    ? React.createElement('div', { style: { marginTop: 6, color: T.ok, fontSize: 12 } },
+                        tr('settings.deployDone')
+                        + (deployTask.result && deployTask.result.command ? ' · ' + deployTask.result.command : ''))
+                    : null,
+                  deployTask.status === 'failed'
+                    ? React.createElement('div', { style: { marginTop: 6, color: T.danger, fontSize: 12, wordBreak: 'break-all' } }, deployTask.error || tr('settings.deployFailed'))
+                    : null)
+              : null,
             // Verdict from the last probe/install, rendered as findings with the
             // severity the backend assigned — the UI never re-classifies them.
             deploy ? React.createElement('div', { style: { fontSize: 12, lineHeight: 1.6 } },
@@ -1317,9 +1435,13 @@ window.__ModuleLoader__.load({
             // reason to run. The host action re-probes internally anyway, so it is
             // safe to offer directly; clicking it is the explicit consent.
             React.createElement('button', { type: 'button', className: 'dsh-rw-btn dsh-rw-primary', style: { ...primaryBtnS, marginTop: 6 },
-              disabled: !!deployBusy || !webAttachMachine,
+              disabled: !webAttachMachine,
               onClick: () => { if (window.confirm(tr('settings.deployConfirm'))) deployAction('install', webAttachMachine, { confirm: true }) } },
-              deployBusy === 'install' ? tr('settings.deployInstalling') : tr('settings.deployInstall')),
+              // While a task runs, the button is the RESUME affordance (disabled
+              // — the poll renders live state; a second click must not restart).
+              (deployTask && (deployTask.status === 'running' || deployTask.status === 'queued'))
+                ? tr('settings.deployInstalling')
+                : deployBusy === 'install' ? tr('settings.deployInstalling') : tr('settings.deployInstall')),
             // The AI escape hatch: offered after a failure, and ONLY on click —
             // it costs a model call, so it is never automatic.
             (deployErr || (deploy && deploy.ok === false))

package/lib/deploy-tasks.js

@@ -0,0 +1,142 @@
+// dsh-remote — host-side deploy task manager.
+//
+// WHY THIS EXISTS: `install` used to be a single long HTTP request (npm can
+// legitimately take minutes). If the browser tab closed — or the fetch was
+// cancelled — the RESPONSE was lost and, with it, every trace of what the
+// deploy did: the user could not see the progress again, could not tell whether
+// it succeeded, and clicking the button again would start a SECOND concurrent
+// npm install into the same prefix. High availability here means:
+//
+//   · the deploy runs on the HOST, not tied to any request lifecycle;
+//   · every step's outcome is recorded as it happens;
+//   · the UI can re-attach at any time and see the live state;
+//   · a second click while one is running RE-ATTACHES instead of restarting;
+//   · the result (including the machine's webAttachCommand) is recorded even
+//     if no client ever polls for it.
+//
+// One deploy per machine at a time — npm --prefix into the same directory from
+// two processes corrupts the tree. A NEW request for a machine that already has
+// a running or finished deploy returns the EXISTING task (resume semantics);
+// `force: true` starts a fresh one after the previous is finished.
+
+/** A deploy task's lifecycle: queued → running → done | failed | cancelled. */
+export class DeployTasks {
+  constructor() {
+    /** @type {Map<string, object>} machineId → task */
+    this.byMachine = new Map()
+    /** @type {Map<string, object>} taskId → task (for stable polling) */
+    this.byId = new Map()
+    this.nextId = 1
+  }
+
+  /**
+   * The task for a machine, if one exists in ANY state.
+   * @returns {object|null}
+   */
+  forMachine(machineId) {
+    return this.byMachine.get(String(machineId || '')) || null
+  }
+
+  get(id) {
+    return this.byId.get(String(id || '')) || null
+  }
+
+  /**
+   * Start a deploy for a machine, unless one is already running.
+   *
+   * @param {string} machineId
+   * @param {Function} fn - async (ctx) => result. ctx = { progress(patch) }.
+   * @returns {{task: object, reused: boolean}} the task plus whether it already
+   *   existed (caller reports "resumed" so the UI does not claim a fresh start).
+   */
+  start(machineId, label, fn) {
+    const mid = String(machineId || '')
+    const existing = this.byMachine.get(mid)
+    if (existing && (existing.status === 'queued' || existing.status === 'running')) {
+      return { task: existing, reused: true }
+    }
+    const id = `deploy-${this.nextId++}`
+    const task = {
+      id,
+      machineId: mid,
+      kind: 'deploy',
+      label: String(label || ''),
+      status: 'queued',
+      // Steps are appended as they finish; `steps` is what the UI renders.
+      steps: [],
+      // The current in-flight step, so a re-attached UI can show "正在安装…"
+      // rather than a stale list with no hint that more is coming.
+      current: '',
+      progress: {},
+      result: null,
+      error: null,
+      startedAt: null,
+      finishedAt: null,
+      cancelled: false,
+    }
+    this.byMachine.set(mid, task)
+    this.byId.set(id, task)
+    // Deliberately NOT queued through the shared TaskManager: that one is
+    // single-flight across ALL tasks (one sync at a time), while deploys to
+    // DIFFERENT machines must run in parallel.
+    task.status = 'running'
+    task.startedAt = new Date().toISOString()
+    const ctx = {
+      progress: (p) => { task.progress = { ...task.progress, ...p } },
+      get cancelled() { return !!task.cancelled },
+    }
+    Promise.resolve()
+      .then(() => fn(ctx))
+      .then((result) => {
+        task.result = result || null
+        task.status = task.cancelled ? 'cancelled' : 'done'
+      })
+      .catch((err) => {
+        task.error = String((err && err.message) || err)
+        // A step-level failure carries the step list (and hints) as structured
+        // data so the UI can render exactly what the old single-response flow
+        // rendered — re-attaching must lose nothing.
+        if (err && err.detail && typeof err.detail === 'object') task.detail = err.detail
+        task.status = task.cancelled ? 'cancelled' : 'failed'
+      })
+      .finally(() => {
+        task.current = ''
+        task.finishedAt = new Date().toISOString()
+      })
+    return { task, reused: false }
+  }
+
+  /** Cooperative cancel (a running npm step still finishes; later steps stop). */
+  cancel(machineId) {
+    const t = this.byMachine.get(String(machineId || ''))
+    if (!t) return false
+    if (t.status === 'queued' || t.status === 'running') {
+      t.cancelled = true
+      return true
+    }
+    return false
+  }
+
+  /** Serializable view for the UI. */
+  describe(t) {
+    if (!t) return null
+    return {
+      id: t.id,
+      machineId: t.machineId,
+      kind: t.kind,
+      status: t.status,           // queued | running | done | failed | cancelled
+      steps: t.steps,             // [{id,title,ok,code,output}]
+      current: t.current,         // in-flight step title ('' when none)
+      progress: t.progress,
+      result: t.result,
+      error: t.error,
+      detail: t.detail || null,
+      startedAt: t.startedAt,
+      finishedAt: t.finishedAt,
+    }
+  }
+
+  list() {
+    return [...this.byMachine.values()].map((t) => this.describe(t))
+  }
+}

package/lib/index.js

@@ -40,6 +40,7 @@ import { syncTree, pushTree, loadSyncState, saveSyncState, pushOneFile } from '.
 import { searchRemote } from './search.js'
 import { resolveMirror, poolKey, lookupSessionCwd, encodeSegmentSafe, readSessionHeaderCwd, requestSessionHint } from './binding.js'
 import { TaskManager } from './tasks.js'
+import { DeployTasks } from './deploy-tasks.js'
 import { ForwardManager } from './forwards.js'
 import { WebAttach } from './web-attach.js'
 import {
@@ -849,6 +850,10 @@ export async function apply(ctx, config) {
   // starting a second remote server. Lifecycle is owned by the plugin fiber, so
   // unloading the plugin tears every tunnel down.
   const webAttaches = new Map() // machineId → WebAttach
+  // Deploy tasks run on the HOST, detached from any request: closing the browser
+  // window mid-install must not lose the progress, and a re-opened page must be
+  // able to re-attach and see the live state (high-availability requirement).
+  const deployTasks = new DeployTasks()
   ctx.effect(() => () => {
     for (const attach of webAttaches.values()) { try { attach.close() } catch { /* already gone */ } }
     webAttaches.clear()
@@ -3076,10 +3081,15 @@ export async function apply(ctx, config) {
             const q = new URL(req.url, 'http://localhost').searchParams
             const id = q.get('machineId') || ''
             const attach = id ? webAttaches.get(id) : undefined
+            // Deploy tasks ride along so a REOPENED window sees an in-flight
+            // install immediately, without a separate poll's first tick.
+            const deploy = id ? deployTasks.forMachine(id) : null
             return sendJson(res, 200, {
               ok: true,
               attach: attach ? attach.describe() : null,
               attaches: [...webAttaches.values()].map((a) => a.describe()),
+              deploys: deployTasks.list(),
+              deploy: deploy ? deployTasks.describe(deploy) : null,
             })
           }
           if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
@@ -3124,75 +3134,113 @@ export async function apply(ctx, config) {
               })
             }
 
-            // install
+            // install — runs as a HOST-SIDE BACKGROUND TASK.
+            //
+            // It used to be one long HTTP request; npm can legitimately take
+            // minutes, and closing the tab mid-deploy lost the response AND
+            // every trace of the progress — the user could not tell whether it
+            // succeeded, and a second click started a CONCURRENT npm install
+            // into the same prefix. Now the work runs detached from the request
+            // lifecycle, every step's outcome is recorded as it happens, and
+            // the UI re-attaches by polling install-status (or by clicking the
+            // button again, which resumes rather than restarts).
             if (body.confirm !== true) {
               return sendJson(res, 400, { ok: false, error: '安装需要在请求里显式 confirm: true' })
             }
-            const pout = await target.exec(buildProbeCommand({ prefix, installedCommand, defaultPrefixFor: config.webInstallPrefix ? '' : 'home' }), { timeoutMs: 30000 })
-            const facts = parseProbe(pout && pout.stdout)
-            const verdict = judgeProbe(facts, { installedCommand })
-            if (!verdict.canAutoInstall) {
-              const why = verdict.findings.filter((x) => x.severity === 'blocker').map((x) => x.summary).join('；')
-              audit('web-deploy', `install ${machine.host} refused: ${why}`, 1, machine)
-              return sendJson(res, 400, { ok: false, error: `无法自动安装：${why || '远端缺少前提条件'}`, verdict })
+            // RESUME: a running/queued task for this machine is returned as-is.
+            // One deploy per machine at a time — two concurrent `npm --prefix`
+            // into the same directory corrupt the tree.
+            const already = deployTasks.forMachine(machineId)
+            if (already && (already.status === 'queued' || already.status === 'running') && body.force !== true) {
+              return sendJson(res, 200, { ok: true, resumed: true, task: deployTasks.describe(already) })
             }
-            const installPrefix = facts.resolvedPrefix || resolvePrefix(facts, { prefix: config.webInstallPrefix || '' })
-            // A registry the user set explicitly wins; otherwise the remote's own
-            // npm config is left alone, which is what an internal mirror needs.
-            // `--registry` is only added when configured — overriding a working
-            // corporate mirror with the public one would be a regression.
-            const registry = String(body.registry || config.webInstallRegistry || '').trim()
-            // Proxy comes from the remote's own environment; the operator may
-            // override it per-install when the inherited one is wrong.
-            const env = body.proxy && typeof body.proxy === 'object'
-              ? Object.fromEntries(Object.entries(body.proxy).filter(([, v]) => typeof v === 'string'))
-              : undefined
-            const plan = buildInstallPlan({
-              facts,
-              prefix: installPrefix,
-              version: String(body.version || config.webInstallVersion || DEFAULT_INSTALL_VERSION),
-              registry,
-              env,
-            })
-            const results = []
-            for (const step of plan.steps) {
-              let res2
-              try {
-                res2 = await target.exec(step.command, {
-                  timeoutMs: step.timeoutMs || 120000,
-                  // Per-step env exists for the proxy override (P4); pool.exec
-                  // passes it through to the remote process.
-                  ...(step.env ? { env: step.env } : {}),
-                })
-              } catch (err) {
-                results.push({ id: step.id, title: step.title, ok: false, code: -1, output: String((err && err.message) || err) })
-                break
-              }
-              const r = stepResult(step, res2)
-              results.push(r)
-              if (!r.ok) break
-            }
-            const ok = results.length === plan.steps.length && results.every((r) => r.ok)
-            if (ok) {
-              // Persist so the attach flow uses the working build from now on.
-              persistWebAttachCommand(machine, plan.command)
-              audit('web-deploy', `install ${machine.host} → ${plan.command}`, 0, machine)
-              return sendJson(res, 200, { ok: true, steps: results, command: plan.command, prefix: installPrefix })
+            if (already && body.force !== true && already.status !== 'done' && already.status !== 'failed' && already.status !== 'cancelled') {
+              return sendJson(res, 200, { ok: true, resumed: true, task: deployTasks.describe(already) })
             }
-            const failed = results.find((r) => !r.ok)
-            audit('web-deploy', `install ${machine.host} failed at ${failed && failed.id}`, 1, machine)
-            // A failure that looks like a network/registry problem gets the AI
-            // escape hatch suggested, since that is precisely the long tail the
-            // deterministic path cannot classify.
-            const looksNetworky = /ETIMEDOUT|ENOTFOUND|ECONNREFUSED|network|proxy|403|404/i.test(String(failed && failed.output))
-            return sendJson(res, 500, {
-              ok: false,
-              error: `安装失败于「${failed ? failed.title : '未知步骤'}」`,
-              steps: results,
-              prefix: installPrefix,
-              suggestInvestigate: true,
-              ...(looksNetworky ? { hint: '看起来是网络或源的问题，可以让 AI 排查。' } : {}),
+            const { task } = deployTasks.start(machineId, `deploy ${machine.host}`, async (ctx) => {
+              // Everything below is the SAME plan as before, but progress goes
+              // to the task (visible while it runs) instead of one response.
+              const pout = await target.exec(buildProbeCommand({ prefix, installedCommand, defaultPrefixFor: config.webInstallPrefix ? '' : 'home' }), { timeoutMs: 30000 })
+              const facts = parseProbe(pout && pout.stdout)
+              const verdict = judgeProbe(facts, { installedCommand })
+              if (!verdict.canAutoInstall) {
+                const why = verdict.findings.filter((x) => x.severity === 'blocker').map((x) => x.summary).join('；')
+                audit('web-deploy', `install ${machine.host} refused: ${why}`, 1, machine)
+                throw new Error(`无法自动安装：${why || '远端缺少前提条件'}`)
+              }
+              const installPrefix = facts.resolvedPrefix || resolvePrefix(facts, { prefix: config.webInstallPrefix || '' })
+              // A registry the user set explicitly wins; otherwise the remote's
+              // own npm config is left alone (internal mirrors keep working).
+              const registry = String(body.registry || config.webInstallRegistry || '').trim()
+              const env = body.proxy && typeof body.proxy === 'object'
+                ? Object.fromEntries(Object.entries(body.proxy).filter(([, v]) => typeof v === 'string'))
+                : undefined
+              const plan = buildInstallPlan({
+                facts,
+                prefix: installPrefix,
+                version: String(body.version || config.webInstallVersion || DEFAULT_INSTALL_VERSION),
+                registry,
+                env,
+              })
+              ctx.progress({ totalSteps: plan.steps.length, prefix: installPrefix })
+              const results = []
+              for (const step of plan.steps) {
+                if (ctx.cancelled) break
+                task.current = step.title
+                ctx.progress({ doneSteps: results.length })
+                let res2
+                try {
+                  res2 = await target.exec(step.command, {
+                    timeoutMs: step.timeoutMs || 120000,
+                    ...(step.env ? { env: step.env } : {}),
+                  })
+                } catch (err) {
+                  results.push({ id: step.id, title: step.title, ok: false, code: -1, output: String((err && err.message) || err) })
+                  break
+                }
+                const r = stepResult(step, res2)
+                results.push(r)
+                task.steps = [...results]
+                if (!r.ok) break
+              }
+              task.steps = [...results]
+              const ok = results.length === plan.steps.length && results.every((r) => r.ok)
+              if (ok) {
+                // Persist so the attach flow uses the working build from now on.
+                persistWebAttachCommand(machine, plan.command)
+                audit('web-deploy', `install ${machine.host} → ${plan.command}`, 0, machine)
+                return { ok: true, steps: results, command: plan.command, prefix: installPrefix }
+              }
+              const failed = results.find((r) => !r.ok)
+              audit('web-deploy', `install ${machine.host} failed at ${failed && failed.id}`, 1, machine)
+              const looksNetworky = /ETIMEDOUT|ENOTFOUND|ECONNREFUSED|network|proxy|403|404/i.test(String(failed && failed.output))
+              const err = new Error(`安装失败于「${failed ? failed.title : '未知步骤'}」`)
+              err.detail = {
+                steps: results,
+                prefix: installPrefix,
+                suggestInvestigate: true,
+                ...(looksNetworky ? { hint: '看起来是网络或源的问题，可以让 AI 排查。' } : {}),
+              }
+              throw err
             })
+            // Answer immediately: the task object IS the handle the UI polls.
+            return sendJson(res, 200, { ok: true, started: true, task: deployTasks.describe(task) })
+          }
+
+          // install-status: re-attach to a deploy at ANY time (window reopened,
+          // page refreshed). Also carried by GET /dsh-remote/web-attach.
+          if (action === 'install-status') {
+            const t = deployTasks.forMachine(machineId)
+            if (!t) return sendJson(res, 200, { ok: true, task: null })
+            return sendJson(res, 200, { ok: true, task: deployTasks.describe(t) })
+          }
+
+          // install-cancel: cooperative cancel between steps.
+          if (action === 'install-cancel') {
+            const t = deployTasks.forMachine(machineId)
+            if (!t) return sendJson(res, 200, { ok: true, cancelled: false })
+            const did = deployTasks.cancel(machineId)
+            return sendJson(res, 200, { ok: true, cancelled: did, task: deployTasks.describe(t) })
           }
 
           if (action === 'open') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.41",
+  "version": "0.8.42",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 22 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, one-click remote dsh deploy + web UI attach, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",