feat(desktop): drive updates from a sidebar button and one overlay

An Update button appears at the top of the sidebar as soon as a version the
user has not skipped is waiting. It opens a centered overlay that carries the
whole flow: the version and release date, a download that reports transferred
bytes against the total, a cancel that aborts the transfer mid-flight, and the
restart that applies it.

Cancel is new capability, not just UI. The main process now passes a
cancellation token to the downloader and keeps it for the lifetime of that
download, so an abort stops the transfer instead of letting it finish
unwatched. A cancelled download reports through the same error path as a real
failure, so the guard reads the token that owns the rejection rather than the
current one, and a retry started after a cancel cannot inherit the cancelled
download's failure.

Download and install remain two deliberate actions; the overlay shows a
restart step between them rather than chaining them.

The bottom-right update toast is removed. It duplicated the same progress in a
second place and could surface over the open overlay.

Author: elkaix

.changeset/desktop-update-overlay.md

@@ -0,0 +1,5 @@
+---
+"@pymodel/pythinker-code": minor
+---
+
+Add an Update button to the top of the desktop sidebar that opens a single overlay for the whole update: download it, watch the progress, cancel it mid-transfer, then restart to apply it.

apps/desktop/package.json

@@ -19,6 +19,7 @@
     "@pymodel/pythinker-telemetry": "workspace:*",
     "@types/node": "^26.1.2",
     "@types/semver": "^7.7.0",
+    "builder-util-runtime": "9.7.0",
     "electron": "43.4.0",
     "electron-builder": "26.15.3",
     "electron-updater": "6.8.9",

apps/desktop/src/main.ts

@@ -38,6 +38,7 @@ import {
 import { createSplashWindow } from './splash'
 import {
   acknowledgeCompletedUpdate,
+  cancelUpdateDownload,
   checkForUpdatesNow,
   getUpdateState,
   initUpdater,
@@ -274,6 +275,10 @@ ipcMain.handle('pythinker:update:download', (event) => {
   assertTrustedSender(event)
   return startUpdateDownload()
 })
+ipcMain.handle('pythinker:update:cancel', (event) => {
+  assertTrustedSender(event)
+  return cancelUpdateDownload()
+})
 ipcMain.handle('pythinker:update:skip', (event, version: unknown) => {
   assertTrustedSender(event)
   return skipUpdate(updateVersion(version))

apps/desktop/src/preload.ts

@@ -6,6 +6,7 @@ contextBridge.exposeInMainWorld('pythinkerDesktop', {
   setAutoUpdate: (enabled: boolean) => ipcRenderer.invoke('pythinker:update:set-auto', enabled),
   checkForUpdates: () => ipcRenderer.invoke('pythinker:update:check'),
   downloadUpdate: () => ipcRenderer.invoke('pythinker:update:download'),
+  cancelUpdateDownload: () => ipcRenderer.invoke('pythinker:update:cancel'),
   skipUpdate: (version: string) => ipcRenderer.invoke('pythinker:update:skip', version),
   undoSkippedUpdate: () => ipcRenderer.invoke('pythinker:update:undo-skip'),
   markUpdateNotified: (version: string) => ipcRenderer.invoke('pythinker:update:notified', version),

apps/desktop/src/updater.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { app, type BrowserWindow } from 'electron'
+import { CancellationToken } from 'builder-util-runtime'
 import electronUpdater, { type ProgressInfo, type UpdateInfo } from 'electron-updater'
 import { gt, valid } from 'semver'
 
@@ -130,6 +131,7 @@ let initialCheckTimer: ReturnType<typeof setTimeout> | undefined
 let checkInterval: ReturnType<typeof setInterval> | undefined
 let checkPromise: Promise<UpdateState> | undefined
 let installRequestedVersion: string | undefined
+let activeDownloadToken: CancellationToken | undefined
 let listenersWired = false
 let initialized = false
 let updateTelemetryTrack: UpdateTelemetryTrack = () => {}
@@ -207,6 +209,19 @@ function stateError(error: unknown): void {
   })
 }
 
+/**
+ * electron-updater reports a cancelled download through the same `error` path
+ * as a genuine failure, and `CancellationError` carries no distinguishing
+ * `name`, so the token itself is the discriminator: `cancel()` flips
+ * `cancelled` synchronously, before the rejection reaches us. The guard reads
+ * the token that owns this rejection rather than the current one, so a retry
+ * started after a cancel cannot inherit the cancelled download's failure.
+ */
+function downloadError(token: CancellationToken, error: unknown): void {
+  if (token.cancelled) return
+  stateError(error)
+}
+
 function clearTimers(): void {
   if (initialCheckTimer !== undefined) clearTimeout(initialCheckTimer)
   if (checkInterval !== undefined) clearInterval(checkInterval)
@@ -457,13 +472,41 @@ export function startUpdateDownload(): UpdateState {
       bytesPerSecond: undefined,
       message: undefined,
     })
-    void autoUpdater.downloadUpdate().catch(stateError)
+    const token = new CancellationToken()
+    activeDownloadToken = token
+    void autoUpdater
+      .downloadUpdate(token)
+      .catch((error: unknown) => downloadError(token, error))
+      .finally(() => {
+        if (activeDownloadToken === token) activeDownloadToken = undefined
+        token.dispose()
+      })
   } catch (error) {
+    activeDownloadToken = undefined
     stateError(error)
   }
   return state
 }
 
+/**
+ * Aborts an in-flight download and returns the update to the state it had
+ * before the user consented, so the same version can be downloaded again.
+ */
+export function cancelUpdateDownload(): UpdateState {
+  const token = activeDownloadToken
+  if (state.status !== 'downloading' || token === undefined) return state
+  token.cancel()
+  updateState({
+    status: 'available',
+    percent: undefined,
+    transferred: undefined,
+    total: undefined,
+    bytesPerSecond: undefined,
+    message: undefined,
+  })
+  return state
+}
+
 export function installDownloadedUpdateNow(): UpdateState {
   const version = state.availableVersion
   if (!app.isPackaged || !hasUpdateConfig() || state.status !== 'downloaded' || version === undefined) {

apps/desktop/tests/updater.spec.ts

@@ -388,6 +388,102 @@ describe('strict update consent', () => {
     expect(localAutoUpdater.downloadUpdate).toHaveBeenCalledTimes(2)
     expect(localAutoUpdater.autoDownload).toBe(false)
   })
+
+  it('cancelling an in-flight download aborts the transfer and restores the available state', async () => {
+    vi.resetModules()
+    const directory = temporaryDirectory()
+    writeFileSync(join(directory, 'app-update.yml'), '', 'utf8')
+    writeFileSync(join(directory, 'update-settings.json'), '{"autoUpdate":false}\n', 'utf8')
+    const { app: localApp } = await import('electron')
+    const { default: localElectronUpdater } = await import('electron-updater')
+    const {
+      cancelUpdateDownload: cancelLocalUpdateDownload,
+      getUpdateState: getLocalUpdateState,
+      initUpdater: initLocalUpdater,
+      startUpdateDownload: startLocalUpdateDownload,
+    } = await import('../src/updater')
+    const localAutoUpdater = localElectronUpdater.autoUpdater
+    vi.mocked(localApp.getPath).mockReturnValue(directory)
+    Object.defineProperty(localApp, 'isPackaged', { configurable: true, value: true })
+    Object.defineProperty(process, 'resourcesPath', { configurable: true, value: directory })
+
+    initLocalUpdater(() => undefined)
+    const available = vi.mocked(localAutoUpdater.on).mock.calls.find(
+      ([event]) => event === 'update-available',
+    )?.[1] as ((info: { version: string }) => void) | undefined
+    const progress = vi.mocked(localAutoUpdater.on).mock.calls.find(
+      ([event]) => event === 'download-progress',
+    )?.[1] as ((info: {
+      percent: number
+      transferred: number
+      total: number
+      bytesPerSecond: number
+    }) => void) | undefined
+    available?.({ version: '1.2.3' })
+
+    startLocalUpdateDownload()
+    progress?.({ percent: 40, transferred: 400, total: 1_000, bytesPerSecond: 80 })
+    expect(getLocalUpdateState()).toMatchObject({ status: 'downloading', percent: 40 })
+
+    const token = vi.mocked(localAutoUpdater.downloadUpdate).mock.calls[0]?.[0] as
+      | { cancelled: boolean }
+      | undefined
+    expect(token).toBeDefined()
+    expect(token?.cancelled).toBe(false)
+
+    expect(cancelLocalUpdateDownload()).toMatchObject({
+      status: 'available',
+      availableVersion: '1.2.3',
+      percent: undefined,
+      transferred: undefined,
+      total: undefined,
+      bytesPerSecond: undefined,
+    })
+    expect(token?.cancelled).toBe(true)
+    expect(localAutoUpdater.autoDownload).toBe(false)
+    expect(localAutoUpdater.quitAndInstall).not.toHaveBeenCalled()
+  })
+
+  it('does not report an error when the cancelled download rejects', async () => {
+    vi.resetModules()
+    const directory = temporaryDirectory()
+    writeFileSync(join(directory, 'app-update.yml'), '', 'utf8')
+    writeFileSync(join(directory, 'update-settings.json'), '{"autoUpdate":false}\n', 'utf8')
+    const { app: localApp } = await import('electron')
+    const { default: localElectronUpdater } = await import('electron-updater')
+    const {
+      cancelUpdateDownload: cancelLocalUpdateDownload,
+      getUpdateState: getLocalUpdateState,
+      initUpdater: initLocalUpdater,
+      startUpdateDownload: startLocalUpdateDownload,
+    } = await import('../src/updater')
+    const localAutoUpdater = localElectronUpdater.autoUpdater
+    vi.mocked(localApp.getPath).mockReturnValue(directory)
+    Object.defineProperty(localApp, 'isPackaged', { configurable: true, value: true })
+    Object.defineProperty(process, 'resourcesPath', { configurable: true, value: directory })
+
+    let rejectDownload: ((error: Error) => void) | undefined
+    vi.mocked(localAutoUpdater.downloadUpdate).mockReturnValueOnce(
+      new Promise<string[]>((_resolve, reject) => {
+        rejectDownload = reject
+      }),
+    )
+
+    initLocalUpdater(() => undefined)
+    const available = vi.mocked(localAutoUpdater.on).mock.calls.find(
+      ([event]) => event === 'update-available',
+    )?.[1] as ((info: { version: string }) => void) | undefined
+    available?.({ version: '1.2.3' })
+
+    startLocalUpdateDownload()
+    cancelLocalUpdateDownload()
+    rejectDownload?.(new Error('cancelled'))
+    await Promise.resolve()
+    await Promise.resolve()
+
+    expect(getLocalUpdateState()).toMatchObject({ status: 'available', availableVersion: '1.2.3' })
+    expect(getLocalUpdateState().message).toBeUndefined()
+  })
 })
 
 describe('update prompt receipts', () => {

apps/pythinker-code/dist-web/.web-bundle-manifest.json

@@ -1,4 +1,4 @@
 {
-  "sourceHash": "88d1ce5b6a9e547d95f58e7c12da9767e9741da5b9af3e0663d0ba66c9783432",
-  "sourceFileCount": 390
+  "sourceHash": "601145dfae3f453f1f25a8e4ab9bf2734da59a3032fde032a6e2c8c7b779d93e",
+  "sourceFileCount": 391
 }