dsh-clean-desktop-shell 0.1.12 → 0.1.14

package/electron/main.js

@@ -138,9 +138,18 @@ if (!gotLock) {
       cancelId: 1,
     })
     if (choice === 0) {
-      const ok = await createDesktopShortcut()
-      if (!ok) {
-        dialog.showErrorBox('创建快捷方式失败', '无法在桌面创建快捷方式。可稍后在托盘右键菜单中重试。')
+      try {
+        const ok = await createDesktopShortcut()
+        if (!ok) {
+          dialog.showErrorBox('创建快捷方式失败', '无法在桌面创建快捷方式。可稍后在托盘右键菜单中重试。')
+        }
+      } catch (err) {
+        // See tray.js: writeShortcutLink throws on some failures, and an
+        // unguarded rejection here would abort the rest of the ready chain.
+        dialog.showErrorBox(
+          '创建快捷方式失败',
+          `${err && err.message ? err.message : String(err)}\n\n可稍后在托盘右键菜单中重试。`,
+        )
       }
     }
   }

package/electron/outage.js

@@ -0,0 +1,60 @@
+/**
+ * Per-window backend-outage run (liveness-watch state).
+ *
+ * Pure module — no Electron imports — so the recovery self-test
+ * (scripts/selftest-recovery.mjs) can exercise the real transitions under
+ * plain node: consecutive-failure escalation, reset-on-recovery, and the
+ * navigation token that discards probe results which finished after the
+ * window navigated away or was disposed.
+ */
+
+// An outage escalates from transient to persistent/unavailable copy after
+// this many consecutive failed probes (~3 × 4s watch interval).
+export const PERSISTENT_AFTER_FAILURES = 3
+
+export class OutageRun {
+  constructor() {
+    this.failures = 0
+    // Navigation epoch. reset() bumps it; every async probe captures a
+    // checkpoint() before awaiting and apply() discards the result if the
+    // epoch moved meanwhile — a stale probe can never act on a newer
+    // navigation (or on a disposed window's fresh lookalike state).
+    this.epoch = 0
+  }
+
+  /** Capture the current epoch before starting an async probe. */
+  checkpoint() {
+    return this.epoch
+  }
+
+  /** True while the run is still on the navigation `token` was taken under. */
+  isCurrent(token) {
+    return token === this.epoch
+  }
+
+  /** Navigation/flip (or fresh page load): invalidate in-flight probes and start a fresh run. */
+  reset() {
+    this.epoch += 1
+    this.failures = 0
+  }
+
+  /**
+   * Apply a probe result taken under `token`. Returns null when the run was
+   * reset (the window navigated away or was disposed) while the probe was in
+   * flight — the result is stale and must not act. Otherwise advances the
+   * consecutive-failure counter and returns the exact renderer payload for
+   * the in-page connection notice (window.js sends it verbatim).
+   */
+  apply(token, up) {
+    if (!this.isCurrent(token)) return null
+    if (up) {
+      this.failures = 0
+      return { state: 'ok' }
+    }
+    this.failures += 1
+    return {
+      state: 'degraded',
+      persistent: this.failures >= PERSISTENT_AFTER_FAILURES,
+    }
+  }
+}

package/electron/preload.js

@@ -12,9 +12,28 @@
  * use a pragmatic height and rely on the page's own top padding for the
  * DSH top bar area. Overlap is acceptable: the strip is click-through for
  * everything except dragging (app-region drag areas swallow mouse events).
+ *
+ * The in-page connection notice is the non-destructive counterpart of the
+ * offline screen: while a real page is loaded, backend liveness failures
+ * never navigate away — the main process pushes watch results here and we
+ * show/clear a small fixed banner instead. Draft, scroll and selection in
+ * the loaded page are untouched.
  */
 const { contextBridge, ipcRenderer } = require('electron')
 
+// Page-side handler invoked when the main process asks the DSH client
+// runtime (injected page module, src/client/client.js) to reconnect. One
+// handler per page context — navigation resets it with the page.
+let reconnectHandler = null
+
+ipcRenderer.on('shell:client-reconnect', () => {
+  try {
+    if (typeof reconnectHandler === 'function') reconnectHandler()
+  } catch {
+    // page handler errors must not break the shell
+  }
+})
+
 contextBridge.exposeInMainWorld('shellAPI', {
   // Ask the main process to (re)load the real target URL. Used by the
   // offline screen's retry button.
@@ -23,12 +42,153 @@ contextBridge.exposeInMainWorld('shellAPI', {
   startBackend: () => ipcRenderer.send('shell:start-backend'),
   detectBackend: () => ipcRenderer.send('shell:detect-backend'),
   chooseBackendFolder: () => ipcRenderer.send('shell:choose-backend-folder'),
+  // DSH client-runtime connection bridge (see src/client/client.js):
+  // - connectionReport(state) forwards the page connection lifecycle
+  //   ('connected' | 'connecting' | 'disconnected') to the main process so
+  //   HTTP health alone can never hide a terminal disconnect;
+  // - onReconnectRequest(cb) registers the page-side reconnect action (the
+  //   runtime's own reconnect(), never a page reload); returns an
+  //   unregister function.
+  connectionReport: (state) => ipcRenderer.send('shell:client-connection', state),
+  onReconnectRequest: (cb) => {
+    if (typeof cb !== 'function') return () => {}
+    reconnectHandler = cb
+    return () => {
+      if (reconnectHandler === cb) reconnectHandler = null
+    }
+  },
+})
+
+// ---------- in-page connection notice ----------
+
+// Latest push from window.js refreshNotice: { state: 'ok' } or
+// { state: 'degraded', persistent: boolean }, computed from merged HTTP
+// probe + client-runtime connection state. Kept until the DOM is ready
+// (messages can arrive before DOMContentLoaded on very fast loads).
+let connState = null
+let connUi = null
+
+ipcRenderer.on('shell:connection-state', (_event, state) => {
+  connState = state
+  applyConnState()
 })
 
+function applyConnState() {
+  if (!connState || !connUi) return
+  if (!connState.state || connState.state === 'ok') {
+    connUi.el.style.display = 'none'
+    return
+  }
+  const persistent = connState.persistent === true
+  connUi.title.textContent = persistent
+    ? '后端暂时无法访问'
+    : '与后端的连接暂时中断'
+  connUi.sub.textContent = persistent
+    ? '当前页面已保留，连接恢复后本页会自动继续，也可手动重试。'
+    : '正在自动重连，当前页面已保留。'
+  connUi.retryBtn.hidden = false
+  // Full reload is only offered once the outage is persistent: it is
+  // destructive to unsaved page state, so it stays an explicit user choice.
+  connUi.reloadBtn.hidden = !persistent
+  connUi.el.style.display = 'flex'
+}
+
+/**
+ * Build the notice banner below the drag strip (top-center, fixed). Uses
+ * inline styles like the drag strip — no <style> injection, so the loaded
+ * page's Content-Security-Policy cannot block it. The element itself is
+ * inert while hidden and never steals focus while visible.
+ */
+function buildConnUi() {
+  const base = {
+    position: 'fixed',
+    top: '0',
+    left: '50%',
+    transform: 'translateX(-50%)',
+    display: 'none',
+    alignItems: 'center',
+    gap: '14px',
+    maxWidth: '76vw',
+    padding: '8px 14px',
+    background: 'rgba(16, 19, 26, 0.94)',
+    border: '1px solid #33405a',
+    borderRadius: '10px',
+    color: '#e8eaf0',
+    font: '13px/1.4 system-ui, "Segoe UI", "Microsoft YaHei", sans-serif',
+    boxShadow: '0 8px 24px rgba(0, 0, 0, 0.45)',
+    zIndex: '2147483646',
+    pointerEvents: 'auto',
+    userSelect: 'none',
+    WebkitUserSelect: 'none',
+  }
+  const el = document.createElement('div')
+  el.id = 'dsh-clean-shell-conn'
+  el.setAttribute('role', 'status')
+  el.setAttribute('aria-live', 'polite')
+  Object.assign(el.style, base)
+
+  const copy = document.createElement('div')
+  copy.style.display = 'flex'
+  copy.style.flexDirection = 'column'
+  copy.style.gap = '2px'
+
+  const title = document.createElement('div')
+  title.id = 'dsh-clean-shell-conn-title'
+  title.style.fontWeight = '600'
+  title.style.color = '#e8eaf0'
+  const sub = document.createElement('div')
+  sub.id = 'dsh-clean-shell-conn-sub'
+  sub.style.fontSize = '12px'
+  sub.style.opacity = '0.75'
+  copy.append(title, sub)
+
+  const actions = document.createElement('div')
+  actions.style.display = 'flex'
+  actions.style.gap = '8px'
+
+  const btnStyle = {
+    padding: '5px 12px',
+    fontSize: '12px',
+    color: '#e8eaf0',
+    background: '#232d3d',
+    border: '1px solid #33405a',
+    borderRadius: '7px',
+    cursor: 'pointer',
+  }
+
+  const retryBtn = document.createElement('button')
+  retryBtn.id = 'dsh-clean-shell-conn-retry'
+  retryBtn.type = 'button'
+  retryBtn.textContent = '立即重试'
+  Object.assign(retryBtn.style, btnStyle)
+  retryBtn.addEventListener('mouseenter', () => { retryBtn.style.background = '#2b3750' })
+  retryBtn.addEventListener('mouseleave', () => { retryBtn.style.background = '#232d3d' })
+  retryBtn.addEventListener('click', () => ipcRenderer.send('shell:retry-connection'))
+
+  const reloadBtn = document.createElement('button')
+  reloadBtn.id = 'dsh-clean-shell-conn-reload'
+  reloadBtn.type = 'button'
+  reloadBtn.textContent = '重新加载页面'
+  Object.assign(reloadBtn.style, btnStyle)
+  reloadBtn.hidden = true
+  reloadBtn.addEventListener('mouseenter', () => { reloadBtn.style.background = '#2b3750' })
+  reloadBtn.addEventListener('mouseleave', () => { reloadBtn.style.background = '#232d3d' })
+  reloadBtn.addEventListener('click', () => ipcRenderer.send('shell:reload'))
+
+  actions.append(retryBtn, reloadBtn)
+  el.append(copy, actions)
+  return { el, title, sub, retryBtn, reloadBtn }
+}
+
 window.addEventListener('DOMContentLoaded', () => {
   const platform = process.platform
   const isWin = platform === 'win32'
-  const dragHeight = isWin ? 32 : 28
+  // macOS: 12px (was 28). The DSH web UI's own top toolbar starts ~16px
+  // from the window top and does NOT consume dsh-desktop-titlebar-inset,
+  // so a 28px strip swallowed the upper half of every toolbar control —
+  // clicks had to aim low. 12px stays above that padding (drag-only band)
+  // while better-sidebar keeps yielding 28px for the traffic lights.
+  const dragHeight = isWin ? 32 : 12
   // Width reserved for native window controls (Win caption buttons / mac
   // traffic lights live at the top-right / top-left).
   const rightReserve = isWin ? 138 : 80
@@ -46,4 +206,11 @@ window.addEventListener('DOMContentLoaded', () => {
     z-index: 2147483647;
   `
   document.body.appendChild(strip)
+
+  connUi = buildConnUi()
+  // Clear the drag band so the banner is clickable, then render any state
+  // pushed before the DOM was ready.
+  connUi.el.style.top = `${dragHeight + 10}px`
+  document.body.appendChild(connUi.el)
+  applyConnState()
 })

package/electron/service.js

@@ -6,6 +6,16 @@
  *  - start() / stop() / restart()
  *  - status: 'running' | 'stopped' | 'starting' | 'error'
  *
+ * Lifecycle vs responsiveness: every status carries a `cause` so consumers
+ * can tell a CONFIRMED lifecycle event from an OBSERVED state:
+ *  - cause 'exit'  — the managed child process really exited (or died while
+ *    starting);
+ *  - cause 'stop'  — an explicit tray stop terminated the backend;
+ *  - cause 'probe' — detect() found nothing answering on the port (an
+ *    observation; the backend may merely be slow or external).
+ * Only 'exit'/'stop' mean the backend that owns a loaded page is gone; a
+ * 'probe'-derived 'stopped' must never be treated as a process exit.
+ *
  * Shell/core decoupling: when a remote target URL is configured, no local
  * backend is ever touched — this module only manages the local dsh CLI.
  */
@@ -32,6 +42,7 @@ function cappedAppend(prev, chunk) {
 let child = null
 let currentStatus = 'stopped'
 let lastError = null
+let currentCause = null
 let startResolver = null
 
 // dsh 0.1.2+ gates the web index behind a per-process launch token: the
@@ -64,10 +75,14 @@ export function onStatusChange(cb) {
   return () => listeners.delete(cb)
 }
 
-function setStatus(next, error = null) {
-  if (currentStatus !== next || lastError !== error) {
+function setStatus(next, error = null, cause = null) {
+  // A same-status re-emission with a different cause (e.g. probe-derived
+  // 'stopped' followed by the real child exit) must still notify — the
+  // cause is what upgrades an observation to a confirmed lifecycle event.
+  if (currentStatus !== next || lastError !== error || currentCause !== cause) {
     currentStatus = next
     lastError = error
+    currentCause = cause
     for (const cb of listeners) {
       try {
         cb(getStatus())
@@ -81,6 +96,7 @@ function setStatus(next, error = null) {
 export function getStatus() {
   return {
     status: currentStatus,
+    cause: currentCause,
     port: DEFAULT_PORT,
     url: LOCAL_URL,
     launchUrl: currentLaunchUrl,
@@ -122,17 +138,30 @@ export async function probe(url, timeoutMs = 1500) {
  * Detect a reachable local dsh web service.
  * Returns the URL when something already listens on the port,
  * or null when the backend is down.
+ *
+ * Never demotes a shell-managed child: while one is alive, reachability is
+ * the liveness watch's job (window.js probes), so a transient probe failure
+ * here cannot corrupt lifecycle state. The status is likewise never
+ * promoted here — during 'starting' the launch URL is not minted yet, and
+ * only the ready line (or the start-timeout probe) may flip 'starting' →
+ * 'running'. Unmanaged results are observations and are reported with
+ * cause 'probe' — not confirmed exits.
  */
 export async function detect() {
+  if (child && child.exitCode === null) {
+    // Managed child alive — lifecycle state owns itself; no probe, no
+    // status change (in particular: no promotion out of 'starting').
+    return LOCAL_URL
+  }
   const state = await probeState(LOCAL_URL)
   if (state.alive) {
-    setStatus('running')
+    setStatus('running', null, 'probe')
     return LOCAL_URL
   }
   // The old process token (if any) belongs to a backend that is no longer
   // listening. Keep it out of the next backend's bootstrap.
   currentLaunchUrl = null
-  setStatus('stopped')
+  setStatus('stopped', null, 'probe')
   return null
 }
 
@@ -196,10 +225,14 @@ export async function start({ backendPath } = {}) {
     if (currentStatus === 'starting' && startResolver) {
       const r = startResolver
       startResolver = null
-      setStatus('error', `dsh 后端异常退出 (code ${code})`)
+      setStatus('error', `dsh 后端异常退出 (code ${code})`, 'exit')
       r.reject(new Error(lastError))
-    } else if (currentStatus !== 'stopped') {
-      setStatus('stopped')
+    } else {
+      // Confirmed lifecycle exit. Always (re)emit with cause 'exit' — when a
+      // probe-derived 'stopped' preceded the real exit, the cause upgrade is
+      // what tells listeners this was a genuine process death, not an
+      // observation.
+      setStatus('stopped', null, 'exit')
     }
   })
 
@@ -274,7 +307,9 @@ export async function stop() {
   if (child) {
     const proc = child
     child = null
-    setStatus('stopped')
+    // Intentional lifecycle stop of the managed child — a confirmed exit
+    // (cause 'stop'), unlike an observed unreachability.
+    setStatus('stopped', null, 'stop')
     await terminate(proc)
     await ensurePortFree(DEFAULT_PORT)
     return
@@ -287,9 +322,12 @@ export async function stop() {
     if (name && /node/i.test(name)) {
       await killProcess(pid)
       await ensurePortFree(DEFAULT_PORT)
+      setStatus('stopped', null, 'stop')
     }
   }
-  setStatus('stopped')
+  // Nothing was terminated: no status change at all. Emitting 'stopped'
+  // here would fabricate a confirmed exit (cause 'stop') where none
+  // happened — a probe-derived 'stopped' must stay an observation.
 }
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))

package/electron/shortcut.js

@@ -52,8 +52,11 @@ export function shortcutSupported() {
  * The user's real Desktop. app.getPath('desktop') resolves OneDrive
  * redirection and roaming profile policies — a hardcoded ~/Desktop misses
  * those and writes the shortcut where the user will never see it.
+ * Exported so callers can tell the user which folder actually received the
+ * .lnk (a shortcut written to a redirected Desktop is a classic
+ * "nothing happened" report).
  */
-function desktopDir() {
+export function desktopDir() {
   try {
     return app.getPath('desktop')
   } catch {

package/electron/tray.js

@@ -20,7 +20,7 @@ import {
 } from './service.js'
 import { showProgress, setProgress, closeProgress } from './progress.js'
 import { checkForUpdatesAuto, openRepo } from './update.js'
-import { shortcutSupported, createDesktopShortcut } from './shortcut.js'
+import { shortcutSupported, createDesktopShortcut, desktopDir } from './shortcut.js'
 
 const trayIconPath = join(
   fileURLToPath(new URL('.', import.meta.url)),
@@ -71,19 +71,31 @@ export function refreshTrayMenu() {
       label: '创建桌面快捷方式',
       visible: shortcutSupported(),
       click: async () => {
-        const ok = await createDesktopShortcut()
-        if (ok) {
-          dialog.showMessageBoxSync({
-            type: 'info',
-            title: '已创建',
-            message: '桌面快捷方式已创建。',
-          })
-        } else {
-          dialog.showMessageBoxSync({
-            type: 'warning',
-            title: '创建失败',
-            message: '无法创建桌面快捷方式，请稍后重试。',
-          })
+        try {
+          const ok = await createDesktopShortcut()
+          if (ok) {
+            dialog.showMessageBoxSync({
+              type: 'info',
+              title: '已创建',
+              message: '桌面快捷方式已创建。',
+              detail: `位置：${desktopDir()}`,
+            })
+          } else {
+            dialog.showMessageBoxSync({
+              type: 'warning',
+              title: '创建失败',
+              message: '无法创建桌面快捷方式，请稍后重试。',
+            })
+          }
+        } catch (err) {
+          // shell.writeShortcutLink throws (instead of returning false) for
+          // several failure modes. Without this guard the rejection is
+          // swallowed by the async click handler and the menu item looks like
+          // it did nothing at all.
+          dialog.showErrorBox(
+            '创建桌面快捷方式失败',
+            `${err && err.message ? err.message : String(err)}\n\n位置：${desktopDir()}`,
+          )
         }
       },
     },