fix: harden updater stale pending handling

packages/app/src/components/settings-general.tsx

@@ -149,13 +149,12 @@ export const SettingsGeneral: Component = () => {
         }
 
         const actions =
-          platform.update && platform.restart
+          platform.update
             ? [
                 {
                   label: language.t("toast.update.action.installRestart"),
                   onClick: async () => {
                     await platform.update!()
-                    await platform.restart!()
                   },
                 },
                 {

packages/app/src/context/platform.tsx

@@ -7,7 +7,7 @@ type PickerPaths = string | string[] | null
 type OpenDirectoryPickerOptions = { title?: string; multiple?: boolean }
 type OpenFilePickerOptions = { title?: string; multiple?: boolean; accept?: string[]; extensions?: string[] }
 type SaveFilePickerOptions = { title?: string; defaultPath?: string }
-type UpdateFailureReason = "check" | "download" | "metadata"
+type UpdateFailureReason = "check" | "download" | "metadata" | "cache"
 export type UpdateInfo =
   | { updateAvailable: false; status: "disabled" | "none" | "busy"; version?: undefined }
   | { updateAvailable: true; status: "ready"; version: string }

packages/app/src/pages/error.tsx

@@ -264,10 +264,9 @@ export const ErrorPage: Component<ErrorPageProps> = (props) => {
   }
 
   async function installUpdate() {
-    if (!platform.update || !platform.restart) return
+    if (!platform.update) return
     await platform
       .update()
-      .then(() => platform.restart!())
       .then(() => setStore({ actionError: undefined, actionMessage: undefined }))
       .catch((err) => {
         setStore({ actionError: formatError(err, language.t), actionMessage: undefined })

packages/app/src/pages/layout.tsx

@@ -367,7 +367,7 @@ export default function Layout(props: ParentProps) {
 
   const useUpdatePolling = () =>
     onMount(() => {
-      if (!platform.checkUpdate || !platform.update || !platform.restart) return
+      if (!platform.checkUpdate || !platform.update) return
 
       let toastId: number | undefined
       let interval: ReturnType<typeof setInterval> | undefined
@@ -386,7 +386,6 @@ export default function Layout(props: ParentProps) {
                 label: language.t("toast.update.action.installRestart"),
                 onClick: async () => {
                   await platform.update!()
-                  await platform.restart!()
                 },
               },
               {

packages/app/src/pages/update-install-flow-source.test.ts

@@ -0,0 +1,29 @@
+import { readFileSync } from "node:fs"
+import { describe, expect, test } from "bun:test"
+
+const layout = readFileSync(new URL("./layout.tsx", import.meta.url), "utf8")
+const errorPage = readFileSync(new URL("./error.tsx", import.meta.url), "utf8")
+const settings = readFileSync(new URL("../components/settings-general.tsx", import.meta.url), "utf8")
+const platform = readFileSync(new URL("../context/platform.tsx", import.meta.url), "utf8")
+
+describe("update install renderer contracts", () => {
+  test("renderer install actions do not relaunch after platform update", () => {
+    expect(layout).not.toMatch(/await\s+platform\.restart!\(\)/)
+    expect(settings).not.toMatch(/await\s+platform\.restart!\(\)/)
+    expect(errorPage).not.toMatch(/await\s+platform\.restart!\(\)/)
+    expect(layout).not.toMatch(/\.then\(\(\)\s*=>\s*platform\.restart!\(\)\)/)
+    expect(settings).not.toMatch(/\.then\(\(\)\s*=>\s*platform\.restart!\(\)\)/)
+    expect(errorPage).not.toMatch(/\.then\(\(\)\s*=>\s*platform\.restart!\(\)\)/)
+  })
+
+  test("renderer update prompts only require platform update", () => {
+    expect(layout).toContain("if (!platform.checkUpdate || !platform.update) return")
+    expect(layout).not.toContain("if (!platform.checkUpdate || !platform.update || !platform.restart) return")
+    expect(settings).toContain("platform.update")
+    expect(settings).not.toContain("platform.update && platform.restart")
+  })
+
+  test("cache update failures are part of the renderer-facing type", () => {
+    expect(platform).toContain('"check" | "download" | "metadata" | "cache"')
+  })
+})

packages/desktop-electron/package.json

@@ -34,7 +34,8 @@
     "electron-store": "^10",
     "electron-updater": "^6",
     "electron-window-state": "^5.0.3",
-    "marked": "^15"
+    "marked": "^15",
+    "semver": "^7.6.0"
   },
   "devDependencies": {
     "@actions/artifact": "4.0.0",
@@ -45,6 +46,7 @@
     "@solid-primitives/storage": "catalog:",
     "@solidjs/meta": "catalog:",
     "@solidjs/router": "0.15.4",
+    "@types/semver": "catalog:",
     "@types/bun": "catalog:",
     "@types/node": "catalog:",
     "@typescript/native-preview": "catalog:",

packages/desktop-electron/scripts/write-app-update-config.test.ts

@@ -3,6 +3,7 @@ import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs"
 import { tmpdir } from "node:os"
 import { join } from "node:path"
 
+import { UPDATER_CACHE_DIR_NAME } from "../src/main/updater-cache"
 import { serializeAppUpdateConfig, writeAppUpdateConfig } from "./write-app-update-config"
 
 const roots: string[] = []
@@ -26,12 +27,23 @@ describe("write-app-update-config", () => {
         "owner: Astro-Han",
         "repo: pawwork",
         "channel: latest",
-        "updaterCacheDirName: pawwork-updater",
+        `updaterCacheDirName: ${UPDATER_CACHE_DIR_NAME}`,
         "",
       ].join("\n"),
     )
   })
 
+  test("serializes updater cache dir from the shared constant", () => {
+    expect(
+      serializeAppUpdateConfig({
+        provider: "github",
+        owner: "Astro-Han",
+        repo: "pawwork",
+        channel: "latest",
+      }),
+    ).toContain(`updaterCacheDirName: ${UPDATER_CACHE_DIR_NAME}`)
+  })
+
   test("serializes beta GitHub updater config", () => {
     expect(
       serializeAppUpdateConfig({
@@ -65,7 +77,8 @@ describe("write-app-update-config", () => {
     ).toBe(true)
 
     const configPath = join(root, "PawWork.app", "Contents", "Resources", "app-update.yml")
-    expect(readFileSync(configPath, "utf8")).toContain("repo: pawwork")
-    expect(readFileSync(configPath, "utf8")).toContain("updaterCacheDirName: pawwork-updater")
+    const config = readFileSync(configPath, "utf8")
+    expect(config).toContain("repo: pawwork")
+    expect(config).toContain(`updaterCacheDirName: ${UPDATER_CACHE_DIR_NAME}`)
   })
 })

packages/desktop-electron/scripts/write-app-update-config.ts

@@ -1,15 +1,15 @@
 import { mkdir, writeFile } from "node:fs/promises"
 import { join } from "node:path"
 
+import { UPDATER_CACHE_DIR_NAME } from "../src/main/updater-cache"
+
 export type GitHubPublishConfig = {
   provider: "github"
   owner: string
   repo: string
   channel: string
 }
 
-const UPDATER_CACHE_DIR_NAME = "pawwork-updater"
-
 export function serializeAppUpdateConfig(publish: GitHubPublishConfig) {
   return [
     "provider: github",

packages/desktop-electron/src/main/index-updater-source.test.ts

@@ -0,0 +1,27 @@
+import { readFileSync } from "node:fs"
+import { describe, expect, test } from "bun:test"
+
+const source = readFileSync(new URL("./index.ts", import.meta.url), "utf8")
+
+describe("main updater source contracts", () => {
+  test("disables stable downgrades after assigning latest channel", () => {
+    const channelIndex = source.search(/autoUpdater\.channel\s*=\s*"latest"/)
+    const downgradeIndex = source.search(/autoUpdater\.allowDowngrade\s*=\s*false/)
+    expect(channelIndex).toBeGreaterThanOrEqual(0)
+    expect(downgradeIndex).toBeGreaterThan(channelIndex)
+    expect(source).not.toContain("autoUpdater.allowDowngrade = true")
+  })
+
+  test("disables auto install on quit only on macOS", () => {
+    expect(source).toContain('autoUpdater.autoInstallOnAppQuit = process.platform !== "darwin"')
+    expect(source).not.toContain("autoUpdater.autoInstallOnAppQuit = false")
+  })
+
+  test("strict pending cleanup uses shared updater cache helper and propagates rm errors", () => {
+    expect(source).toContain('import { pendingUpdateCacheDir } from "./updater-cache"')
+    expect(source).toContain("await rm(pendingUpdateCacheDir(), { recursive: true, force: true })")
+    expect(source).not.toMatch(
+      /rm\(pendingUpdateCacheDir\(\),\s*\{\s*recursive:\s*true,\s*force:\s*true\s*\}\)\s*\.catch\(\(\)\s*=>/,
+    )
+  })
+})

packages/desktop-electron/src/main/index.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto"
 import { EventEmitter } from "node:events"
 import { mkdirSync, writeFileSync } from "node:fs"
+import { rm } from "node:fs/promises"
 import { createServer } from "node:net"
 import os, { homedir } from "node:os"
 import { dirname, join } from "node:path"
@@ -61,6 +62,7 @@ import { readStoredMenuLocale, writeStoredMenuLocale } from "./menu-i18n"
 import { getDefaultServerUrl, getWslConfig, setDefaultServerUrl, setWslConfig, spawnLocalServer } from "./server"
 import { PAWWORK_RUNTIME } from "./runtime-namespace"
 import { createUpdaterController } from "./updater"
+import { pendingUpdateCacheDir } from "./updater-cache"
 import { updaterDialogLabels } from "./updater-dialog-labels"
 import {
   createLoadingWindow,
@@ -106,6 +108,7 @@ const updater = createUpdaterController({
   currentVersion: () => app.getVersion(),
   checkForUpdates: () => autoUpdater.checkForUpdates(),
   downloadUpdate: () => autoUpdater.downloadUpdate(),
+  clearPendingUpdate: clearPendingUpdate,
   quitAndInstall: () => {
     killSidecar()
     autoUpdater.quitAndInstall()
@@ -544,18 +547,23 @@ async function getSidecarPort() {
   })
 }
 
+async function clearPendingUpdate() {
+  await rm(pendingUpdateCacheDir(), { recursive: true, force: true })
+}
+
 function setupAutoUpdater() {
   if (!UPDATER_ENABLED) return
   autoUpdater.logger = logger
   autoUpdater.channel = "latest"
   autoUpdater.allowPrerelease = false
-  autoUpdater.allowDowngrade = true
+  autoUpdater.allowDowngrade = false
   autoUpdater.autoDownload = false
-  autoUpdater.autoInstallOnAppQuit = true
+  autoUpdater.autoInstallOnAppQuit = process.platform !== "darwin"
   logger.log("auto updater configured", {
     channel: autoUpdater.channel,
     allowPrerelease: autoUpdater.allowPrerelease,
     allowDowngrade: autoUpdater.allowDowngrade,
+    autoInstallOnAppQuit: autoUpdater.autoInstallOnAppQuit,
     currentVersion: app.getVersion(),
   })
 }

packages/desktop-electron/src/main/updater-cache.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test"
+import { getAppCacheDir, pendingUpdateCacheDir, UPDATER_CACHE_DIR_NAME } from "./updater-cache"
+
+describe("updater cache path", () => {
+  test("uses the same updater cache dir name as app-update.yml", () => {
+    expect(UPDATER_CACHE_DIR_NAME).toBe("pawwork-updater")
+  })
+
+  test("resolves macOS pending cache from the user library cache root", () => {
+    expect(getAppCacheDir({ platform: "darwin", homedir: "/Users/demo", env: {} })).toBe("/Users/demo/Library/Caches")
+    expect(pendingUpdateCacheDir({ platform: "darwin", homedir: "/Users/demo", env: {} })).toBe(
+      "/Users/demo/Library/Caches/pawwork-updater/pending",
+    )
+  })
+
+  test("resolves Windows pending cache from LOCALAPPDATA when present", () => {
+    expect(
+      pendingUpdateCacheDir({
+        platform: "win32",
+        homedir: "C:\\Users\\demo",
+        env: { LOCALAPPDATA: "C:\\Users\\demo\\AppData\\Local" },
+      }),
+    ).toBe("C:\\Users\\demo\\AppData\\Local\\pawwork-updater\\pending")
+  })
+
+  test("resolves Windows pending cache from localappdata casing when present", () => {
+    expect(
+      pendingUpdateCacheDir({
+        platform: "win32",
+        homedir: "C:\\Users\\demo",
+        env: { localappdata: "D:\\Cache" },
+      }),
+    ).toBe("D:\\Cache\\pawwork-updater\\pending")
+  })
+
+  test("falls back to AppData\\Local on Windows when LOCALAPPDATA is missing", () => {
+    expect(pendingUpdateCacheDir({ platform: "win32", homedir: "C:\\Users\\demo", env: {} })).toBe(
+      "C:\\Users\\demo\\AppData\\Local\\pawwork-updater\\pending",
+    )
+  })
+
+  test("ignores relative Windows cache roots from env", () => {
+    expect(
+      pendingUpdateCacheDir({
+        platform: "win32",
+        homedir: "C:\\Users\\demo",
+        env: { LOCALAPPDATA: "relative-cache" },
+      }),
+    ).toBe("C:\\Users\\demo\\AppData\\Local\\pawwork-updater\\pending")
+  })
+
+  test("uses lowercase Windows cache root when uppercase env is relative", () => {
+    expect(
+      pendingUpdateCacheDir({
+        platform: "win32",
+        homedir: "C:\\Users\\demo",
+        env: { LOCALAPPDATA: "relative-cache", localappdata: "D:\\Cache" },
+      }),
+    ).toBe("D:\\Cache\\pawwork-updater\\pending")
+  })
+
+  test("resolves Linux pending cache from XDG_CACHE_HOME when present", () => {
+    expect(
+      pendingUpdateCacheDir({ platform: "linux", homedir: "/home/demo", env: { XDG_CACHE_HOME: "/tmp/cache" } }),
+    ).toBe("/tmp/cache/pawwork-updater/pending")
+  })
+
+  test("falls back to ~/.cache on Linux when XDG_CACHE_HOME is missing", () => {
+    expect(pendingUpdateCacheDir({ platform: "linux", homedir: "/home/demo", env: {} })).toBe(
+      "/home/demo/.cache/pawwork-updater/pending",
+    )
+  })
+
+  test("ignores relative Linux cache roots from env", () => {
+    expect(
+      pendingUpdateCacheDir({ platform: "linux", homedir: "/home/demo", env: { XDG_CACHE_HOME: "relative-cache" } }),
+    ).toBe("/home/demo/.cache/pawwork-updater/pending")
+  })
+})

packages/desktop-electron/src/main/updater-cache.ts

@@ -0,0 +1,44 @@
+import { homedir as currentHomedir } from "node:os"
+import path from "node:path"
+
+export const UPDATER_CACHE_DIR_NAME = "pawwork-updater"
+
+type CacheInput = {
+  platform?: NodeJS.Platform
+  homedir?: string
+  env?: NodeJS.ProcessEnv
+}
+
+function pathForPlatform(platform: NodeJS.Platform) {
+  return platform === "win32" ? path.win32 : path.posix
+}
+
+function firstAbsolutePath(
+  platformPath: typeof path.posix | typeof path.win32,
+  fallback: string,
+  ...values: Array<string | undefined>
+) {
+  return values.find((value) => value && platformPath.isAbsolute(value)) ?? fallback
+}
+
+export function getAppCacheDir(input: CacheInput = {}) {
+  const platform = input.platform ?? process.platform
+  const homedir = input.homedir ?? currentHomedir()
+  const env = input.env ?? process.env
+  const platformPath = pathForPlatform(platform)
+
+  if (platform === "win32")
+    return firstAbsolutePath(
+      platformPath,
+      platformPath.join(homedir, "AppData", "Local"),
+      env.LOCALAPPDATA,
+      env.localappdata,
+    )
+  if (platform === "darwin") return platformPath.join(homedir, "Library", "Caches")
+  return firstAbsolutePath(platformPath, platformPath.join(homedir, ".cache"), env.XDG_CACHE_HOME)
+}
+
+export function pendingUpdateCacheDir(input: CacheInput = {}) {
+  const platform = input.platform ?? process.platform
+  return pathForPlatform(platform).join(getAppCacheDir(input), UPDATER_CACHE_DIR_NAME, "pending")
+}