dsh-clean-desktop-shell 0.1.0 → 0.1.2

package/electron/update.js

@@ -1,74 +1,201 @@
-/**
- * Version check and repo links.
- *
- * Checks the latest GitHub release of dsh-clean-desktop-shell against the
- * local app version (from app.getVersion()). Network failures are treated
- * as "no update" — never block or error in the tray.
- */
-import { app, shell } from 'electron'
-
-const REPO_URL = 'https://github.com/Icather/dsh-clean-desktop-shell'
-const RELEASES_API = 'https://api.github.com/repos/Icather/dsh-clean-desktop-shell/releases/latest'
-
-/** Parse "v1.2.3" / "1.2.3" → [1,2,3]; null when malformed. */
-function parseVersion(v) {
-  if (!v) return null
-  const m = String(v).replace(/^v/i, '').trim().match(/^(\d+)\.(\d+)\.(\d+)/)
-  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null
-}
-
-/** True when a is strictly newer than b. */
-function isNewer(a, b) {
-  if (!a || !b) return false
-  for (let i = 0; i < 3; i++) {
-    if (a[i] !== b[i]) return a[i] > b[i]
-  }
-  return false
-}
-
-/**
- * Check for a newer release.
- * @returns {{ hasUpdate: boolean, latest?: string, current: string, url: string }}
- */
-export async function checkForUpdate() {
-  const current = app.getVersion()
-  let latest = null
-  let tag = null
-  let url = REPO_URL
-
-  try {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), 8000)
-    const res = await fetch(RELEASES_API, {
-      signal: controller.signal,
-      headers: { Accept: 'application/vnd.github+json' },
-    })
-    clearTimeout(timer)
-    if (res.ok) {
-      const data = await res.json()
-      tag = data.tag_name || null
-      latest = parseVersion(tag)
-      if (data.html_url) url = data.html_url
-    }
-  } catch {
-    // Network error — no update known.
-  }
-
-  const currentV = parseVersion(current)
-  return {
-    hasUpdate: isNewer(latest, currentV),
-    latest: tag,
-    current,
-    url,
-  }
-}
-
-/** Open the repository homepage in the default browser. */
-export function openRepo() {
-  shell.openExternal(REPO_URL)
-}
-
-/** Open an arbitrary URL in the default browser. */
-export function openUrl(url) {
-  shell.openExternal(url)
-}
+/**
+ * Update handling — Windows auto-update, macOS manual download.
+ *
+ * Windows (packaged app): uses electron-updater to download the new
+ * installer from GitHub Releases in the background and install it on
+ * restart. Progress is shown in the small progress window.
+ *
+ * macOS / dev mode: falls back to a manual check that opens the GitHub
+ * Releases page (macOS auto-update needs a Developer ID signature which
+ * this project does not have yet).
+ */
+import { app, shell, dialog } from 'electron'
+import { showProgress, setProgress, closeProgress } from './progress.js'
+
+const REPO_URL = 'https://github.com/Icather/dsh-clean-desktop-shell'
+const RELEASES_API = 'https://api.github.com/repos/Icather/dsh-clean-desktop-shell/releases/latest'
+
+let autoUpdater = null
+let updaterPromise = null
+
+/** Lazy-load electron-updater (CJS → ESM interop via dynamic import). */
+function getAutoUpdater() {
+  if (!updaterPromise) {
+    updaterPromise = import('electron-updater').then((m) => m.autoUpdater)
+  }
+  return updaterPromise
+}
+
+/** Windows packaged apps can auto-update; everything else uses manual. */
+export function isAutoUpdateSupported() {
+  return process.platform === 'win32' && app.isPackaged
+}
+
+/** Wire the auto-updater events once (no-op on mac / dev mode). */
+export function setupAutoUpdater() {
+  if (!isAutoUpdateSupported()) return
+  getAutoUpdater()
+    .then((au) => {
+      if (autoUpdater) return
+      autoUpdater = au
+      autoUpdater.autoDownload = true
+      autoUpdater.autoInstallOnAppQuit = true
+
+      autoUpdater.on('update-available', () => {
+        showProgress({ title: '检查更新', message: '发现新版本，正在后台下载…' })
+      })
+      autoUpdater.on('download-progress', (p) => {
+        const pct = Math.round(p.percent)
+        setProgress({
+          title: '检查更新',
+          message: `正在下载更新：${pct}%`,
+          state: pct >= 100 ? 'ok' : 'busy',
+        })
+      })
+      autoUpdater.on('update-downloaded', () => {
+        setProgress({ title: '检查更新', message: '更新已下载', state: 'ok' })
+        setTimeout(() => {
+          closeProgress()
+          const choice = dialog.showMessageBoxSync({
+            type: 'info',
+            title: '更新已就绪',
+            message: '新版本已下载完成，重启应用即可安装。',
+            detail: '是否立即重启安装？',
+            buttons: ['立即重启', '稍后'],
+            defaultId: 0,
+            cancelId: 1,
+          })
+          if (choice === 0) autoUpdater.quitAndInstall()
+        }, 800)
+      })
+      autoUpdater.on('update-not-available', () => {
+        closeProgress()
+        dialog.showMessageBoxSync({
+          type: 'info',
+          title: '已是最新版本',
+          message: '当前已是最新版本。',
+        })
+      })
+      autoUpdater.on('error', (err) => {
+        closeProgress()
+        dialog.showMessageBoxSync({
+          type: 'warning',
+          title: '检查更新失败',
+          message: `自动更新失败：${err?.message || '未知错误'}`,
+          detail: '可前往 GitHub Releases 手动下载。',
+        })
+      })
+    })
+    .catch(() => {
+      // electron-updater failed to load — auto-update silently disabled.
+    })
+}
+
+/** Tray "check for update": auto flow on Windows, manual fallback elsewhere. */
+export async function checkForUpdatesAuto() {
+  if (isAutoUpdateSupported()) {
+    try {
+      await getAutoUpdater()
+      await autoUpdater?.checkForUpdates()
+    } catch (err) {
+      closeProgress()
+      dialog.showMessageBoxSync({
+        type: 'warning',
+        title: '检查更新失败',
+        message: `自动更新失败：${err?.message || '未知错误'}`,
+        detail: '可前往 GitHub Releases 手动下载。',
+      })
+    }
+    return
+  }
+
+  // Manual path (macOS / dev mode): compare versions, offer GitHub page.
+  const r = await checkForUpdate()
+  if (r.hasUpdate) {
+    const choice = dialog.showMessageBoxSync({
+      type: 'info',
+      title: '发现新版本',
+      message: `当前版本 ${r.current}，最新版本 ${r.latest}。`,
+      detail: 'macOS 自动更新需要代码签名，当前请前往 GitHub Releases 手动下载。',
+      buttons: ['前往下载', '取消'],
+      defaultId: 0,
+      cancelId: 1,
+    })
+    if (choice === 0) openUrl(r.url)
+  } else if (r.latest) {
+    dialog.showMessageBoxSync({
+      type: 'info',
+      title: '已是最新版本',
+      message: `当前版本 ${r.current} 已是最新（${r.latest}）。`,
+    })
+  } else {
+    dialog.showMessageBoxSync({
+      type: 'warning',
+      title: '检查更新失败',
+      message: '无法连接 GitHub 检查更新，请检查网络后重试。',
+    })
+  }
+}
+
+/** Parse "v1.2.3" / "1.2.3" → [1,2,3]; null when malformed. */
+function parseVersion(v) {
+  if (!v) return null
+  const m = String(v).replace(/^v/i, '').trim().match(/^(\d+)\.(\d+)\.(\d+)/)
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null
+}
+
+/** True when a is strictly newer than b. */
+function isNewer(a, b) {
+  if (!a || !b) return false
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] > b[i]
+  }
+  return false
+}
+
+/**
+ * Manual version check against the latest GitHub release (macOS path).
+ * @returns {{ hasUpdate: boolean, latest?: string, current: string, url: string }}
+ */
+export async function checkForUpdate() {
+  const current = app.getVersion()
+  let latest = null
+  let tag = null
+  let url = REPO_URL
+
+  try {
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), 8000)
+    const res = await fetch(RELEASES_API, {
+      signal: controller.signal,
+      headers: { Accept: 'application/vnd.github+json' },
+    })
+    clearTimeout(timer)
+    if (res.ok) {
+      const data = await res.json()
+      tag = data.tag_name || null
+      latest = parseVersion(tag)
+      if (data.html_url) url = data.html_url
+    }
+  } catch {
+    // Network error — no update known.
+  }
+
+  const currentV = parseVersion(current)
+  return {
+    hasUpdate: isNewer(latest, currentV),
+    latest: tag,
+    current,
+    url,
+  }
+}
+
+/** Open the repository homepage in the default browser. */
+export function openRepo() {
+  shell.openExternal(REPO_URL)
+}
+
+/** Open an arbitrary URL in the default browser. */
+export function openUrl(url) {
+  shell.openExternal(url)
+}

package/electron/window.js

@@ -4,16 +4,142 @@
  * Pure shell philosophy: the window is a normal native frame with
  * window-controls overlay (Win) / hiddenInset (mac), and nothing else.
  * No Mica, no vibrancy — keep it clean.
+ *
+ * Window reliability (Edge-style instant refresh):
+ *  - the window shows immediately on launch (never waits for the backend);
+ *  - while the backend is unreachable the page load fails and we swap in a
+ *    local "backend offline" screen;
+ *  - a background poll keeps probing the target; as soon as the backend
+ *    answers, the real page is loaded automatically;
+ *  - the moment the backend goes down (tray stop, external kill, crash) the
+ *    window flips back to the offline screen instead of showing a stale page
+ *    that suggests the app is still alive.
  */
-import { BrowserWindow } from 'electron'
+import { BrowserWindow, ipcMain } from 'electron'
 import { fileURLToPath } from 'node:url'
-import { join } from 'node:path'
+import { probe, onStatusChange, detect } from './service.js'
+import { startBackendWithProgress, chooseBackendFolder } from './tray.js'
 
 export const WINDOWS_TITLEBAR_HEIGHT = 32
 
 const PRELOAD_PATH = fileURLToPath(new URL('./preload.js', import.meta.url))
 // Black-whale app icon (matches the DSH web favicon).
 const ICON_PATH = fileURLToPath(new URL('../build/icon.png', import.meta.url))
+// Local fallback page shown while the backend is down.
+const ERROR_PAGE = fileURLToPath(new URL('./error.html', import.meta.url))
+
+// How often we re-probe the backend while the window is in "offline" mode.
+const RECONNECT_INTERVAL_MS = 2500
+// How often we check the backend is still alive while the page is shown.
+const WATCH_INTERVAL_MS = 4000
+// ERR_ABORTED — navigation was cancelled, not a real failure. Ignore it.
+const ERR_ABORTED = -3
+
+// Per-window state, keyed by webContents id.
+const reconnectTimers = new Map()
+const watchTimers = new Map()
+const windowTargets = new Map()
+const statusUnsubs = new Map()
+
+// Manual reload requests come from the tray button and from the offline
+// screen's retry button (via preload -> ipcRenderer). Route them to the
+// window that sent the message.
+ipcMain.on('shell:reload', (event) => {
+  const win = BrowserWindow.fromWebContents(event.sender)
+  if (win && !win.isDestroyed()) {
+    reloadWindow(win, windowTargets.get(win.id))
+  }
+})
+
+// Offline-screen quick actions: start / detect backend, pick install
+// folder. The resulting state changes propagate via onStatusChange
+// (window flip + tray refresh), so no extra wiring is needed here.
+ipcMain.on('shell:start-backend', () => startBackendWithProgress())
+ipcMain.on('shell:detect-backend', () => detect())
+ipcMain.on('shell:choose-backend-folder', () => chooseBackendFolder())
+
+// ---------- offline mode ----------
+
+function stopReconnect(win) {
+  const timer = reconnectTimers.get(win.id)
+  if (timer) {
+    clearInterval(timer)
+    reconnectTimers.delete(win.id)
+  }
+}
+
+function startReconnect(win, target) {
+  if (reconnectTimers.has(win.id)) return
+  const timer = setInterval(async () => {
+    if (win.isDestroyed()) {
+      stopReconnect(win)
+      return
+    }
+    const up = await probe(target)
+    if (up) {
+      stopReconnect(win)
+      win.webContents.loadURL(target).catch(() => startReconnect(win, target))
+    }
+  }, RECONNECT_INTERVAL_MS)
+  reconnectTimers.set(win.id, timer)
+}
+
+// ---------- online mode (backend liveness watch) ----------
+
+function stopWatch(win) {
+  const timer = watchTimers.get(win.id)
+  if (timer) {
+    clearInterval(timer)
+    watchTimers.delete(win.id)
+  }
+}
+
+/** While the real page is shown, watch that the backend stays alive. */
+function startWatch(win, target) {
+  if (watchTimers.has(win.id)) return
+  const timer = setInterval(async () => {
+    if (win.isDestroyed()) {
+      stopWatch(win)
+      return
+    }
+    const up = await probe(target, 1500)
+    if (!up) {
+      // Backend vanished — flip to the offline screen immediately so the
+      // stale page cannot fool the user into thinking the app is alive.
+      showOffline(win)
+    }
+  }, WATCH_INTERVAL_MS)
+  watchTimers.set(win.id, timer)
+}
+
+// ---------- state flips ----------
+
+/** Switch to the offline screen and start re-probing. */
+function showOffline(win) {
+  if (win.isDestroyed()) return
+  const target = windowTargets.get(win.id)
+  stopWatch(win)
+  win.loadFile(ERROR_PAGE).catch(() => {})
+  if (target) startReconnect(win, target)
+}
+
+/** Load the real backend page and start watching it. */
+function showOnline(win) {
+  if (win.isDestroyed()) return
+  const target = windowTargets.get(win.id)
+  if (!target) return
+  stopReconnect(win)
+  win.webContents.loadURL(target).catch(() => startReconnect(win, target))
+}
+
+/** Load the real target URL in a window (used by tray + offline retry). */
+export function reloadWindow(win, target) {
+  if (!win || win.isDestroyed()) return
+  stopReconnect(win)
+  win.webContents.loadURL(target).catch(() => startReconnect(win, target))
+}
+
+// ---------- window creation ----------
 
 export function createMainWindow({ target }) {
   const platform = process.platform
@@ -25,7 +151,9 @@ export function createMainWindow({ target }) {
     height: 800,
     minWidth: 760,
     minHeight: 520,
-    show: false,
+    // Show immediately — the backend may be starting, the window must not
+    // wait for `ready-to-show` (which lags when the page fails to load).
+    show: true,
     title: 'DeepSeek Harness',
     backgroundColor: '#10131A',
     icon: isWin ? ICON_PATH : undefined,
@@ -61,9 +189,55 @@ export function createMainWindow({ target }) {
   // Linux / other: keep the native frame.
 
   const win = new BrowserWindow(options)
-  win.loadURL(target)
+  windowTargets.set(win.id, target)
+  win.loadURL(target).catch(() => startReconnect(win, target))
 
-  win.once('ready-to-show', () => win.show())
+  // Instant flip when the backend state machine changes (tray stop/start).
+  const unsub = onStatusChange((st) => {
+    if (win.isDestroyed()) return
+    const current = win.webContents.getURL()
+    const isOffline = current.includes('error.html')
+    if ((st.status === 'stopped' || st.status === 'error') && !isOffline) {
+      // Backend went down while a real page is showing — go dark at once.
+      showOffline(win)
+    } else if (st.status === 'running' && isOffline) {
+      // Backend came up while we are on the offline screen — load it.
+      showOnline(win)
+    }
+  })
+  statusUnsubs.set(win.id, unsub)
+
+  win.webContents.on('did-fail-load', (_e, code, _desc, url, isMainFrame) => {
+    if (!isMainFrame || code === ERR_ABORTED) return
+    // Offline screen already showing — just keep re-probing, do not
+    // reload the offline page again (avoids a reload loop if it fails).
+    if (win.webContents.getURL().includes('error.html')) {
+      startReconnect(win, target)
+      return
+    }
+    // Backend unreachable: show the offline screen and start re-probing.
+    showOffline(win)
+  })
+
+  win.webContents.on('did-finish-load', () => {
+    const current = win.webContents.getURL()
+    if (current.startsWith(target)) {
+      // Real backend page reached — stop re-probing and watch it.
+      stopReconnect(win)
+      startWatch(win, target)
+    }
+  })
+
+  win.on('closed', () => {
+    stopReconnect(win)
+    stopWatch(win)
+    const unsub = statusUnsubs.get(win.id)
+    if (unsub) {
+      unsub()
+      statusUnsubs.delete(win.id)
+    }
+    windowTargets.delete(win.id)
+  })
 
   return win
 }

package/lib/client.js

@@ -1,10 +1,10 @@
-/**
- * dsh-clean-desktop-shell — client half (web browser bundle).
- *
- * Registers a settings row so the shell's target URL / material options
- * are editable from Settings → General. This is a minimal placeholder:
- * real UI wiring lands with the Electron shell work.
- */
-export function apply() {
-  // placeholder: settings-row wiring arrives with the shell implementation
-}
+/**
+ * dsh-clean-desktop-shell — client half (web browser bundle).
+ *
+ * Registers a settings row so the shell's target URL / material options
+ * are editable from Settings → General. This is a minimal placeholder:
+ * real UI wiring lands with the Electron shell work.
+ */
+export function apply() {
+  // placeholder: settings-row wiring arrives with the shell implementation
+}

package/lib/index.js

@@ -1,13 +1,13 @@
-/**
- * dsh-clean-desktop-shell — host half (plugin loader entry).
- *
- * The desktop shell is an Electron client; the host half only registers
- * the plugin so it mounts cleanly into a dsh profile and exposes its
- * settings surface. Window material (Mica / vibrancy) lives in the
- * Electron main process (see src/main/).
- */
-export function apply(ctx) {
-  ctx.on('ready', () => {
-    ctx.logger.info('[clean-desktop-shell] mounted (host half)')
-  })
-}
+/**
+ * dsh-clean-desktop-shell — host half (plugin loader entry).
+ *
+ * The desktop shell is an Electron client; the host half only registers
+ * the plugin so it mounts cleanly into a dsh profile and exposes its
+ * settings surface. Window material (Mica / vibrancy) lives in the
+ * Electron main process (see src/main/).
+ */
+export function apply(ctx) {
+  ctx.on('ready', () => {
+    ctx.logger.info('[clean-desktop-shell] mounted (host half)')
+  })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-clean-desktop-shell",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Clean desktop shell for DeepSeek Harness (DSH) as a DSH plugin — reuses your web profile, tray/single-instance/auto-launch, zero visual changes. DSH 插件形态的纯净桌面壳：复用现有 web profile，托盘管理后端，零视觉改造。",
   "type": "module",
   "main": "lib/index.js",
@@ -91,14 +91,22 @@
       "category": "public.app-category.developer-tools"
     },
     "nsis": {
-      "oneClick": false,
-      "allowToChangeInstallationDirectory": true,
+      "oneClick": true,
+      "perMachine": false,
       "createDesktopShortcut": true,
       "createStartMenuShortcut": true
+    },
+    "publish": {
+      "provider": "github",
+      "owner": "Icather",
+      "repo": "dsh-clean-desktop-shell"
     }
   },
   "license": "MIT",
   "allowScripts": {
     "electron@33.4.11": true
+  },
+  "dependencies": {
+    "electron-updater": "^6.8.9"
   }
 }

package/scripts/build.mjs

@@ -1,12 +1,12 @@
-#!/usr/bin/env node
-// Minimal zero-dependency build: copies src → lib.
-// Real bundling (tsdown/vite) lands with the Electron shell work.
-import { cpSync, mkdirSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const root = dirname(dirname(fileURLToPath(import.meta.url)))
-mkdirSync(join(root, 'lib'), { recursive: true })
-cpSync(join(root, 'src', 'host', 'index.js'), join(root, 'lib', 'index.js'))
-cpSync(join(root, 'src', 'client', 'client.js'), join(root, 'lib', 'client.js'))
-console.log('[dsh-clean-desktop-shell] built lib/ from src/')
+#!/usr/bin/env node
+// Minimal zero-dependency build: copies src → lib.
+// Real bundling (tsdown/vite) lands with the Electron shell work.
+import { cpSync, mkdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)))
+mkdirSync(join(root, 'lib'), { recursive: true })
+cpSync(join(root, 'src', 'host', 'index.js'), join(root, 'lib', 'index.js'))
+cpSync(join(root, 'src', 'client', 'client.js'), join(root, 'lib', 'client.js'))
+console.log('[dsh-clean-desktop-shell] built lib/ from src/')