dsh-clean-desktop-shell 0.1.8 → 0.1.10

package/electron/update.js

@@ -1,18 +1,26 @@
 /**
- * Update handling — Windows auto-update, macOS manual download.
+ * Update handling — three install forms, three update sources.
  *
  * 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).
+ * macOS (packaged app): manual check that opens the GitHub Releases page
+ * (macOS auto-update needs a Developer ID signature which this project
+ * does not have yet).
+ *
+ * Plugin mode (npm-installed, !app.isPackaged): checks the npm registry for
+ * dist-tags.latest and offers a one-click update executed through the
+ * package manager that actually installed the plugin (inferred from the
+ * lockfile next to the install, vercel-style), with command variants to
+ * absorb environment and pnpm-version differences.
  */
 import { app, shell, dialog } from 'electron'
-import { readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { existsSync, readFileSync } from 'node:fs'
+import { spawn } from 'node:child_process'
+import { basename, dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import semver from 'semver'
 import { showProgress, setProgress, closeProgress } from './progress.js'
 import { loadConfig } from './config.js'
 
@@ -25,13 +33,16 @@ const NPM_REGISTRY_API = 'https://registry.npmjs.org/dsh-clean-desktop-shell'
 // the Electron runtime version (e.g. 33.4.11). Read the plugin's own version
 // from its package.json instead.
 const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)))
-const PKG_VERSION = (() => {
+const PKG_INFO = (() => {
   try {
-    return JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8')).version
+    return JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8'))
   } catch {
     return null
   }
 })()
+const PKG_VERSION = PKG_INFO?.version ?? null
+// Read from the plugin's own manifest — never hardcode the package name.
+const PKG_NAME = PKG_INFO?.name ?? 'dsh-clean-desktop-shell'
 
 let autoUpdater = null
 let updaterPromise = null
@@ -132,18 +143,44 @@ export async function checkForUpdatesAuto() {
   const isPlugin = !app.isPackaged
   const r = isPlugin ? await checkForUpdateNpm() : await checkForUpdate()
   if (r.hasUpdate) {
+    if (!isPlugin) {
+      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)
+      return
+    }
+
+    // Plugin mode (Plan B + A): offer a one-click update executed through the
+    // package manager that actually installed this package, and show the
+    // equivalent manual command plus the DSH market path.
+    const plan = detectPluginUpdatePlan()
+    const variants = plan ? updateCommandVariants(plan.pm) : []
+    const cmdLine = variants[0] || null
+    const marketHint = '① DSH 网页「设置 → 插件市场 → 已安装」→「更新」（完成后按提示重启）。'
+    const detail = cmdLine
+      ? `${marketHint}\n② 或在目录 ${plan.profileRoot} 下执行：\n${cmdLine}\n（按 Ctrl+C 可复制本对话框全部文字）`
+      : marketHint
     const choice = dialog.showMessageBoxSync({
       type: 'info',
       title: '发现新版本',
       message: `当前版本 ${r.current}，最新版本 ${r.latest}。`,
-      detail: isPlugin
-        ? '插件形态请到 DSH 网页的「设置 → 插件市场 → 已安装」里点「更新」，完成后按提示重启即可生效。'
-        : 'macOS 自动更新需要代码签名，当前请前往 GitHub Releases 手动下载。',
-      buttons: isPlugin ? ['打开 DSH 网页', '稍后'] : ['前往下载', '取消'],
+      detail,
+      buttons: cmdLine ? ['立即更新', '打开 DSH 网页', '稍后'] : ['打开 DSH 网页', '稍后'],
       defaultId: 0,
-      cancelId: 1,
+      cancelId: cmdLine ? 2 : 1,
     })
-    if (choice === 0) openUrl(isPlugin ? loadConfig().targetUrl : r.url)
+    if (cmdLine && choice === 0) {
+      await updatePluginViaPackageManager(plan, variants, r)
+    } else if (choice === (cmdLine ? 1 : 0)) {
+      openUrl(loadConfig().targetUrl)
+    }
   } else if (r.latest) {
     dialog.showMessageBoxSync({
       type: 'info',
@@ -161,11 +198,16 @@ export async function checkForUpdatesAuto() {
   }
 }
 
-/** Parse "v1.2.3" / "1.2.3" → [1,2,3]; null when malformed. */
-function parseVersion(v) {
+/**
+ * Version parsing/comparison via semver — the industry-standard
+ * implementation (update-notifier, npm itself). Coercion strips the 'v'
+ * prefix and any prerelease/build suffix; gt compares correctly across
+ * digit-width differences that a hand-rolled tuple or string compare
+ * would get wrong.
+ */
+function coerceVersion(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
+  return semver.coerce(String(v))
 }
 
 /**
@@ -179,11 +221,7 @@ function currentVersion() {
 
 /** 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
+  return !!(a && b && semver.gt(a, b))
 }
 
 /**
@@ -197,17 +235,14 @@ export async function checkForUpdate() {
   let url = REPO_URL
 
   try {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), 8000)
     const res = await fetch(RELEASES_API, {
-      signal: controller.signal,
+      signal: AbortSignal.timeout(8000),
       headers: { Accept: 'application/vnd.github+json' },
     })
-    clearTimeout(timer)
     if (res.ok) {
       const data = await res.json()
       tag = data.tag_name || null
-      latest = parseVersion(tag)
+      latest = coerceVersion(tag)
       if (data.html_url) url = data.html_url
     }
   } catch {
@@ -245,10 +280,7 @@ export async function checkForUpdateNpm() {
   const url = 'https://www.npmjs.com/package/dsh-clean-desktop-shell'
 
   try {
-    const controller = new AbortController()
-    const timer = setTimeout(() => controller.abort(), 8000)
-    const res = await fetch(NPM_REGISTRY_API, { signal: controller.signal })
-    clearTimeout(timer)
+    const res = await fetch(NPM_REGISTRY_API, { signal: AbortSignal.timeout(8000) })
     if (res.ok) {
       const data = await res.json()
       latestStr = data['dist-tags']?.latest || null
@@ -257,8 +289,8 @@ export async function checkForUpdateNpm() {
     // Network error — no update known.
   }
 
-  const currentV = parseVersion(current)
-  const latestV = parseVersion(latestStr)
+  const currentV = coerceVersion(current)
+  const latestV = coerceVersion(latestStr)
   return {
     hasUpdate: isNewer(latestV, currentV),
     latest: latestStr ? `v${latestStr}` : null,
@@ -266,3 +298,174 @@ export async function checkForUpdateNpm() {
     url,
   }
 }
+
+/**
+ * Locate the directory whose package.json declares this plugin as a dependency
+ * (the DSH profile root: <root>/node_modules/<pkg>), and infer the package
+ * manager that manages it from the lockfile found there (vercel-style).
+ * @returns {{ pm: 'pnpm'|'npm'|'yarn'|'bun', profileRoot: string } | null}
+ */
+function detectPluginUpdatePlan() {
+  try {
+    const nm = dirname(PKG_ROOT)
+    if (basename(nm) !== 'node_modules') return null
+    const profileRoot = dirname(nm)
+    if (!existsSync(join(profileRoot, 'package.json'))) return null
+    const pm = existsSync(join(profileRoot, 'pnpm-lock.yaml')) ? 'pnpm'
+      : existsSync(join(profileRoot, 'package-lock.json')) ? 'npm'
+      : existsSync(join(profileRoot, 'yarn.lock')) ? 'yarn'
+      : (existsSync(join(profileRoot, 'bun.lockb')) || existsSync(join(profileRoot, 'bun.lock'))) ? 'bun'
+      : null
+    return pm ? { pm, profileRoot } : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Command candidates for the detected package manager, ordered from the most
+ * explicit to the most tolerant. Environment differences (pnpm only reachable
+ * via corepack) and pnpm version/flag differences are absorbed by trying them
+ * in order — the first variant that exits 0 wins. Quoting via JSON.stringify
+ * keeps paths/args safe in cmd.exe, PowerShell and POSIX shells alike.
+ */
+function updateCommandVariants(pm) {
+  const q = JSON.stringify(PKG_NAME)
+  switch (pm) {
+    case 'pnpm':
+      return [
+        `pnpm update ${q} --latest --config.minimumReleaseAge=0`,
+        `pnpm update ${q} --latest`,
+        `pnpm update ${q}`,
+        `corepack pnpm update ${q} --latest`,
+      ]
+    case 'npm':
+      return [`npm install ${q}@latest`]
+    case 'yarn':
+      return [`yarn up ${q}@latest`, `yarn upgrade ${q} --latest`]
+    case 'bun':
+      return [`bun update ${q}`, `bun add ${q}@latest`]
+    default:
+      return []
+  }
+}
+
+/**
+ * Kill a shell-spawned child and its whole subtree. On Windows the direct
+ * child is a cmd.exe wrapper — killing it alone leaves the actual worker
+ * (e.g. pnpm/node) running; `taskkill /T` is the recognized tree kill.
+ */
+function treeKill(child) {
+  if (process.platform === 'win32' && child.pid) {
+    spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+      windowsHide: true,
+      stdio: 'ignore',
+    })
+  } else {
+    try {
+      child.kill('SIGKILL')
+    } catch {
+      // already gone
+    }
+  }
+}
+
+/**
+ * Run a shell command, capturing tail output. Node's spawn with shell:true
+ * always uses cmd.exe on Windows (regardless of the user's login shell being
+ * PowerShell or cmd), which is also required for .cmd shims like pnpm — a
+ * bare spawn would throw EINVAL. Output is kept as a bounded tail so a
+ * chatty build cannot grow memory without limit. Resolves { ok, out, err }.
+ */
+function runShell(cmd, cwd, timeoutMs = 5 * 60 * 1000) {
+  const CAP = 16 * 1024
+  const cap = (s) => (s.length > CAP ? s.slice(-CAP) : s)
+  return new Promise((resolve) => {
+    let out = ''
+    let err = ''
+    let settled = false
+    const child = spawn(cmd, {
+      cwd,
+      shell: true,
+      windowsHide: true, // no console flash from the GUI process
+    })
+    const timer = setTimeout(() => {
+      if (!settled) treeKill(child)
+    }, timeoutMs)
+    child.stdout?.on('data', (d) => { out = cap(out + d) })
+    child.stderr?.on('data', (d) => { err = cap(err + d) })
+    child.on('error', () => {
+      settled = true
+      clearTimeout(timer)
+      resolve({ ok: false, out: tail(out), err: tail(err) })
+    })
+    child.on('close', (code) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve({ ok: code === 0, out: tail(out), err: tail(err) })
+    })
+  })
+}
+
+function tail(s, n = 4000) {
+  return s.length > n ? s.slice(-n) : s
+}
+
+/** Read the currently installed plugin version from disk (post-update check). */
+function installedPluginVersion() {
+  try {
+    return JSON.parse(readFileSync(join(PKG_ROOT, 'package.json'), 'utf8')).version || null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * One-click plugin update: try each command variant until one exits 0, then
+ * verify the on-disk version actually changed. Three outcomes — success,
+ * "ran but version unchanged" (constraint/cooldown), or failure with the
+ * attempted commands and output tail for manual retry.
+ */
+async function updatePluginViaPackageManager(plan, variants, check) {
+  showProgress({ title: '插件更新', message: `正在通过 ${plan.pm} 更新插件…` })
+  let result = null
+  for (const cmd of variants) {
+    setProgress({ title: '插件更新', message: `正在执行：${cmd}`, state: 'busy' })
+    result = await runShell(cmd, plan.profileRoot)
+    if (result.ok) break
+  }
+  closeProgress()
+
+  const newVer = installedPluginVersion()
+  if (result?.ok && newVer && newVer !== check.current) {
+    dialog.showMessageBoxSync({
+      type: 'info',
+      title: '更新完成',
+      message: `插件已更新到 ${newVer}。`,
+      detail: '重启 dsh web 后生效（可从本应用托盘菜单重启后端）。',
+    })
+    return
+  }
+  if (result?.ok) {
+    dialog.showMessageBoxSync({
+      type: 'warning',
+      title: '版本未变化',
+      message: `命令执行成功，但插件版本仍为 ${check.current}。`,
+      detail: '可能被 package.json 的版本约束或新版本冷却策略限制，可稍后重试，或到 DSH 插件市场更新。',
+    })
+    return
+  }
+  const logTail = [result?.out, result?.err].filter(Boolean).join('\n').trim()
+  dialog.showMessageBoxSync({
+    type: 'warning',
+    title: '自动更新失败',
+    message: '无法自动更新插件，请手动执行或到 DSH 插件市场更新。',
+    detail: [
+      `已依次尝试：\n${variants.join('\n')}`,
+      logTail ? `命令输出（末尾）：\n${logTail}` : '',
+      `手动命令（在目录 ${plan.profileRoot} 下）：\n${variants[0]}`,
+      '按 Ctrl+C 可复制本对话框全部文字。',
+    ].filter(Boolean).join('\n\n'),
+  })
+}

package/electron/window.js

@@ -18,7 +18,7 @@
 import { app, BrowserWindow, ipcMain } from 'electron'
 import { existsSync } from 'node:fs'
 import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 import { probe, onStatusChange, detect } from './service.js'
 import { startBackendWithProgress, chooseBackendFolder } from './tray.js'
 import { APP_USER_MODEL_ID } from './aumid.js'
@@ -35,8 +35,11 @@ const TASKBAR_ICO = join(PKG_ROOT, 'build', 'icon.ico')
 const ICON_PATH = existsSync(TASKBAR_ICO)
   ? TASKBAR_ICO
   : fileURLToPath(new URL('../build/icon.png', import.meta.url))
-// Local fallback page shown while the backend is down.
+// Local fallback page shown while the backend is down. The file URL is
+// precomputed so "is the offline page showing?" is an exact comparison,
+// not a substring sniff over arbitrary web content.
 const ERROR_PAGE = fileURLToPath(new URL('./error.html', import.meta.url))
+const ERROR_PAGE_URL = pathToFileURL(ERROR_PAGE).href
 
 // How often we re-probe the backend while the window is in "offline" mode.
 const RECONNECT_INTERVAL_MS = 2500
@@ -214,8 +217,7 @@ export function createMainWindow({ target }) {
   // 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')
+    const isOffline = win.webContents.getURL().startsWith(ERROR_PAGE_URL)
     if ((st.status === 'stopped' || st.status === 'error') && !isOffline) {
       // Backend went down while a real page is showing — go dark at once.
       showOffline(win)
@@ -230,7 +232,7 @@ export function createMainWindow({ target }) {
     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')) {
+    if (win.webContents.getURL().startsWith(ERROR_PAGE_URL)) {
       startReconnect(win, target)
       return
     }

package/lib/common.js

@@ -6,6 +6,7 @@
  * location electron/ and build/ live in the published package.
  */
 import { homedir } from 'node:os'
+import { spawn } from 'node:child_process'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -51,3 +52,23 @@ export function runtimeRoot() {
 export function launchLogPath() {
   return join(dshHome(), 'desktop-shell-launch.log')
 }
+
+/**
+ * Download a file to disk via curl — shared by runtime provisioning and
+ * icon patching. Chosen over native fetch because undici (Node's fetch)
+ * ignores HTTP(S)_PROXY env vars unless a proxy dispatcher is wired in,
+ * while curl honors them out of the box (users behind Clash/v2ray rely on
+ * that). --max-time keeps a stalled proxy from hanging forever; --retry
+ * rides out transient failures.
+ */
+export function fetchFile(url, dest, timeoutSec = 600) {
+  return new Promise((resolve) => {
+    const child = spawn(
+      'curl',
+      ['-L', '--fail', '--silent', '--show-error', '--retry', '2', '--max-time', String(timeoutSec), '-o', dest, url],
+      { windowsHide: true, stdio: 'ignore' },
+    )
+    child.on('error', () => resolve(false))
+    child.on('exit', (code) => resolve(code === 0))
+  })
+}

package/lib/icon.js

@@ -14,7 +14,7 @@
 import { spawn } from 'node:child_process'
 import { existsSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
-import { PKG_ROOT, isWin, runtimeRoot } from './common.js'
+import { PKG_ROOT, isWin, runtimeRoot, fetchFile } from './common.js'
 
 export async function patchExeIcon(ctx, exe) {
   if (!isWin) return
@@ -49,15 +49,3 @@ export async function patchExeIcon(ctx, exe) {
     ctx.logger.warn('[clean-desktop-shell] rcedit patch failed — taskbar icon stays default')
   }
 }
-
-function fetchFile(url, dest) {
-  return new Promise((resolve) => {
-    const child = spawn(
-      'curl',
-      ['-L', '--fail', '--silent', '--show-error', '--retry', '2', '--max-time', '600', '-o', dest, url],
-      { windowsHide: true, stdio: 'ignore' },
-    )
-    child.on('error', () => resolve(false))
-    child.on('exit', (code) => resolve(code === 0))
-  })
-}

package/lib/runtime.js

@@ -13,6 +13,8 @@
  *   4. drop stale electron-v* dirs (no unbounded disk growth)
  */
 import { spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { createReadStream } from 'node:fs'
 import {
   cpSync,
   existsSync,
@@ -23,6 +25,7 @@ import {
   rmSync,
   symlinkSync,
 } from 'node:fs'
+import { pipeline } from 'node:stream/promises'
 import { basename, join } from 'node:path'
 import {
   PKG_ROOT,
@@ -33,6 +36,7 @@ import {
   isWin,
   isMac,
   runtimeRoot,
+  fetchFile,
 } from './common.js'
 
 function electronVersion() {
@@ -124,17 +128,26 @@ function ensureExecutable(ctx, target) {
 async function downloadRuntime(ctx, version, root, dir) {
   const tmpZip = join(root, `.electron-${version}.zip.tmp`)
   rmSync(tmpZip, { force: true })
-  const urls = await runtimeUrls(version)
-  const innerName = zipName(version).replace(/\.zip$/, '')
+  const candidates = await runtimeCandidates(version)
+  const zip = zipName(version)
+  const innerName = zip.replace(/\.zip$/, '')
 
-  for (const url of urls) {
-    ctx.logger.info(`[clean-desktop-shell] downloading electron ${version} from ${url}`)
-    if (!(await fetchFile(url, tmpZip))) {
+  for (const c of candidates) {
+    ctx.logger.info(`[clean-desktop-shell] downloading electron ${version} from ${c.url}`)
+    if (!(await fetchFile(c.url, tmpZip))) {
       // Failed download — drop the partial file so a later run starts clean.
       rmSync(tmpZip, { force: true })
       continue
     }
 
+    // Integrity check against the source's own SHASUMS256.txt (same check
+    // the `electron` package's installer performs). A mismatch means the
+    // bytes are corrupt or tampered — the source is skipped entirely.
+    if (!(await verifySha256(ctx, tmpZip, c.shasums, zip))) {
+      rmSync(tmpZip, { force: true })
+      continue
+    }
+
     // Extract into a scratch dir, never into the shared runtime root: a
     // half-extracted zip there would be indistinguishable from a real
     // runtime, and the sibling electron-v* dirs must not be disturbed.
@@ -142,7 +155,7 @@ async function downloadRuntime(ctx, version, root, dir) {
     const ok = await extractZip(ctx, tmpZip, scratch)
     rmSync(tmpZip, { force: true })
     if (!ok) {
-      ctx.logger.warn(`[clean-desktop-shell] no extractor succeeded for ${url}`)
+      ctx.logger.warn(`[clean-desktop-shell] no extractor succeeded for ${c.url}`)
       rmSync(scratch, { recursive: true, force: true })
       continue
     }
@@ -169,6 +182,54 @@ async function downloadRuntime(ctx, version, root, dir) {
   throw new Error('electron download failed from all sources')
 }
 
+/**
+ * Verify a downloaded zip against the source's SHASUMS256.txt — the same
+ * integrity check the `electron` package's own installer performs. Returns
+ * false on a checksum mismatch (fatal for that source); a temporarily
+ * unreachable SHASUMS file only warns, so a reachable zip is not wasted
+ * over an unrelated blocker.
+ */
+async function verifySha256(ctx, file, shasumsUrl, name) {
+  let expected = null
+  let reason = ''
+  try {
+    const res = await fetch(shasumsUrl, { signal: AbortSignal.timeout(10000) })
+    if (!res.ok) {
+      reason = `HTTP ${res.status}`
+    } else {
+      const text = await res.text()
+      for (const line of text.split('\n')) {
+        const m = line.trim().match(/^([0-9a-f]{64})\s+\*?(.+)$/i)
+        if (m && m[2].trim() === name) {
+          expected = m[1].toLowerCase()
+          break
+        }
+      }
+      if (!expected) reason = 'entry not found'
+    }
+  } catch (err) {
+    reason = err?.message || 'fetch failed'
+  }
+  if (!expected) {
+    ctx.logger.warn(
+      `[clean-desktop-shell] SHASUMS256.txt unavailable from ${shasumsUrl} (${reason}) — skipping integrity check`,
+    )
+    return true
+  }
+  // Stream the hash — the zip can be ~270 MB and must not be read whole
+  // into memory.
+  const hash = createHash('sha256')
+  await pipeline(createReadStream(file), hash)
+  const actual = hash.digest('hex')
+  if (actual !== expected) {
+    ctx.logger.warn(
+      `[clean-desktop-shell] checksum mismatch for ${name}: expected ${expected}, got ${actual}`,
+    )
+    return false
+  }
+  return true
+}
+
 /** The dir that directly holds the electron payload right after extraction. */
 function findPayload(scratch, wrapper) {
   if (existsSync(join(wrapper, EXE_TOP))) return wrapper
@@ -212,21 +273,25 @@ function clearQuarantine(ctx, target) {
  * (direct connection, 3s each). The fastest reachable source goes first —
  * this naturally prefers the domestic npmmirror mirror on CN networks,
  * the official GitHub source on international/well-proxied networks, and
- * never wastes a full download on a dead source.
+ * never wastes a full download on a dead source. Each candidate carries
+ * its own SHASUMS256.txt location for the post-download integrity check.
  */
-async function runtimeUrls(version) {
+async function runtimeCandidates(version) {
+  const base = (name, urlBase) => ({
+    name,
+    url: `${urlBase}/${zipName(version)}`,
+    shasums: `${urlBase}/SHASUMS256.txt`,
+  })
   const candidates = [
-    { name: 'github', url: `https://github.com/electron/electron/releases/download/v${version}/${zipName(version)}` },
-    { name: 'npmmirror', url: `https://npmmirror.com/mirrors/electron/${version}/${zipName(version)}` },
+    base('github', `https://github.com/electron/electron/releases/download/v${version}`),
+    base('npmmirror', `https://npmmirror.com/mirrors/electron/${version}`),
   ]
   const results = await Promise.all(
     candidates.map(async (c) => {
       const t0 = Date.now()
       try {
-        const ctrl = new AbortController()
-        const timer = setTimeout(() => ctrl.abort(), 3000)
-        const res = await fetch(c.url, { signal: ctrl.signal, method: 'HEAD' })
-        clearTimeout(timer)
+        // AbortSignal.timeout — the standard self-cleaning probe timeout.
+        const res = await fetch(c.url, { signal: AbortSignal.timeout(3000), method: 'HEAD' })
         if (res.status < 500) return { ...c, ms: Date.now() - t0 }
       } catch {
         // unreachable — drop
@@ -237,26 +302,10 @@ async function runtimeUrls(version) {
   const ok = results.filter(Boolean).sort((a, b) => a.ms - b.ms)
   if (ok.length === 0) {
     // Probes all failed (offline?) — still try both, mirror first (cheap).
-    return [candidates[1].url, candidates[0].url]
+    return [candidates[1], candidates[0]]
   }
-  const rest = candidates.map((c) => c.url).filter((u) => u !== ok[0].url)
-  return [ok[0].url, ...rest]
-}
-
-function fetchFile(url, dest) {
-  return new Promise((resolve) => {
-    // curl is available on Windows 10+; streams to disk, honors proxy env.
-    // --max-time keeps a stalled download from hanging forever (a proxy
-    // stall previously left a half-written .zip.tmp and blocked the shell
-    // launch); --retry 2 rides out transient failures.
-    const child = spawn(
-      'curl',
-      ['-L', '--fail', '--silent', '--show-error', '--retry', '2', '--max-time', '600', '-o', dest, url],
-      { windowsHide: true, stdio: 'ignore' },
-    )
-    child.on('error', () => resolve(false))
-    child.on('exit', (code) => resolve(code === 0))
-  })
+  const rest = candidates.filter((c) => c.url !== ok[0].url)
+  return [ok[0], ...rest]
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-clean-desktop-shell",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Clean desktop shell for DeepSeek Harness (DSH) as a DSH plugin — wraps your web profile in a native window, tray-managed backend, offline auto-reconnect, zero visual changes. DSH 插件形态的纯净桌面壳：复用现有 web profile，托盘管理后端，零视觉改造。",
   "repository": {
     "type": "git",
@@ -33,7 +33,7 @@
   },
   "scripts": {
     "build": "node scripts/build.mjs",
-    "check": "node --check lib/index.js && node scripts/selftest-runtime.mjs",
+    "check": "node scripts/check-syntax.mjs && node scripts/selftest-runtime.mjs",
     "dev": "electron electron/main.js",
     "icons": "node scripts/gen-icons.mjs",
     "pack": "electron-builder --win nsis",
@@ -118,7 +118,8 @@
     "electron@33.4.11": true
   },
   "dependencies": {
-    "electron-updater": "^6.8.9"
+    "electron-updater": "^6.8.9",
+    "semver": "^7.7.2"
   },
   "desktopShell": {
     "electronVersion": "33.4.11"