A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
fix(desktop): stop looping on an update that never installs (#2879)
Hampus78d105b46ef4
diff --git a/fluxer_desktop/src/main/Updater.test.mjs b/fluxer_desktop/src/main/Updater.test.mjsindex dbb9097f5..1cc924fc6 100644--- a/fluxer_desktop/src/main/Updater.test.mjs+++ b/fluxer_desktop/src/main/Updater.test.mjs@@ -65,6 +65,7 @@ before(async () => {files: {appimage: {url: `${baseUrl}/appimage`, sha256: NEW_SHA256},deb: {url: `${baseUrl}/deb`, sha256: 'deadbeef'},+ setup: {url: `${baseUrl}/setup`, sha256: 'cafebabe'},},}),);@@ -106,13 +107,35 @@ function createInstall() {return {applications, installedPath, mount};}-function loadUpdater({appImagePath, version = CURRENT_VERSION, appDir, execPath, stagingErrno}) {+function loadUpdater({+ appImagePath,+ version = CURRENT_VERSION,+ appDir,+ execPath,+ stagingErrno,+ platform = 'linux',+ arch = 'arm64',+ velopack,+ applyAttempt = null,+}) {const events = [];const handlers = new Map();const appEvents = new Map();const state = {relaunched: false, electronRelaunched: false};+ const applyState = {attempt: applyAttempt, recorded: [], cleared: 0};const module = {exports: {}};const stubs = {+ '@electron/main/UpdaterApplyState': {+ readVelopackApplyAttempt: () => applyState.attempt,+ recordVelopackApplyAttempt: (recordedVersion) => {+ applyState.recorded.push(recordedVersion);+ applyState.attempt = {version: recordedVersion, attemptedAt: 0};+ },+ clearVelopackApplyAttempt: () => {+ applyState.cleared += 1;+ applyState.attempt = null;+ },+ },'@electron/common/BuildChannel': {BUILD_CHANNEL: 'canary'},'@electron/common/UserDataPath': {isPortableMode: () => false},'@electron/main/DesktopTray': {destroyDesktopTray() {}},@@ -149,8 +172,8 @@ function loadUpdater({appImagePath, version = CURRENT_VERSION, appDir, execPath,Buffer,process: {...process,- platform: 'linux',- arch: 'arm64',+ platform,+ arch,execPath: execPath ?? (appDir ? join(appDir, 'fluxer-canary') : process.execPath),env: {...(appImagePath ? {APPIMAGE: appImagePath} : {}),@@ -159,11 +182,18 @@ function loadUpdater({appImagePath, version = CURRENT_VERSION, appDir, execPath,},setTimeout,clearTimeout,+ setImmediate,fetch: (input, init) => {- const url = String(input).replace('https://pkgs.fluxer.com/desktop/canary/linux/arm64', baseUrl);+ const url = String(input).replace(/https:\/\/pkgs\.fluxer\.com\/desktop\/canary\/[^/]+\/[^/]+/, baseUrl);return fetch(url, init);},require: (specifier) => {+ if (specifier === 'node:module' && velopack) {+ return {+ ...require('node:module'),+ createRequire: () => (name) => (name === 'velopack' ? velopack : require(name)),+ };+ }if (specifier === 'node:fs/promises' && stagingErrno) {return {...require(specifier),@@ -200,6 +230,7 @@ function loadUpdater({appImagePath, version = CURRENT_VERSION, appDir, execPath,module.exports.registerUpdater(() => ({webContents: {send: (_channel, event) => events.push(event)}}));return {+ applyState,events,state,check: () => handlers.get('updater-check')({}, 'user'),@@ -446,3 +477,93 @@ describe('Updater AppImage lifecycle', () => {assert.equal(readFileSync(install.installedPath).equals(OLD_BYTES), true);});});++function createVelopackStub({installedVersion, pendingRestart = null, remoteUpdate = null}) {+ const applied = [];+ class UpdateManager {+ getCurrentVersion() {+ return installedVersion;+ }+ getUpdatePendingRestart() {+ return pendingRestart;+ }+ checkForUpdatesAsync() {+ return Promise.resolve(remoteUpdate);+ }+ downloadUpdateAsync() {+ return Promise.resolve();+ }+ waitExitThenApplyUpdate(update) {+ applied.push(update);+ }+ }+ return {applied, module: {UpdateManager}};+}++function loadWindowsUpdater({installedVersion, pendingRestart, remoteUpdate, applyAttempt = null}) {+ const velopack = createVelopackStub({installedVersion, pendingRestart, remoteUpdate});+ const updater = loadUpdater({+ platform: 'win32',+ arch: 'x64',+ velopack: velopack.module,+ applyAttempt,+ });+ return {...updater, applied: velopack.applied};+}++describe('Updater Windows apply failures', () => {+ test('offers the installer when a downloaded update never applied', async () => {+ const updater = loadWindowsUpdater({+ installedVersion: CURRENT_VERSION,+ pendingRestart: {Version: PUBLISHED_VERSION, Size: 100},+ applyAttempt: {version: PUBLISHED_VERSION, attemptedAt: 0},+ });++ await updater.check();++ assert.deepEqual(types(updater.events), ['checking', 'error', 'available']);+ assert.equal(updater.events[1].phase, 'install');+ assert.ok(updater.events[1].message.includes(PUBLISHED_VERSION));+ assert.equal(updater.events[2].downloadStarted, false);+ assert.equal(updater.events[2].downloadUrl, `${baseUrl}/setup`);+ assert.equal(updater.applyState.attempt.version, PUBLISHED_VERSION);+ });++ test('resumes normal updates once the installed version catches up', async () => {+ const updater = loadWindowsUpdater({+ installedVersion: PUBLISHED_VERSION,+ applyAttempt: {version: PUBLISHED_VERSION, attemptedAt: 0},+ });++ await updater.check();++ assert.equal(updater.applyState.cleared, 1);+ assert.equal(updater.applyState.attempt, null);+ assert.deepEqual(types(updater.events), ['checking', 'not-available']);+ });++ test('records the version it hands to the updater before quitting', async () => {+ const updater = loadWindowsUpdater({+ installedVersion: CURRENT_VERSION,+ pendingRestart: {Version: PUBLISHED_VERSION, Size: 100},+ });++ await updater.install();++ assert.deepEqual(updater.applyState.recorded, [PUBLISHED_VERSION]);+ assert.deepEqual(updater.applied, [{Version: PUBLISHED_VERSION, Size: 100}]);+ });++ test('refuses to re-apply a version that already failed to install', async () => {+ const updater = loadWindowsUpdater({+ installedVersion: CURRENT_VERSION,+ pendingRestart: {Version: PUBLISHED_VERSION, Size: 100},+ applyAttempt: {version: PUBLISHED_VERSION, attemptedAt: 0},+ });++ await assert.rejects(() => updater.install(), /Download the installer/);++ assert.deepEqual(updater.applied, []);+ assert.deepEqual(updater.applyState.recorded, []);+ });+});diff --git a/fluxer_desktop/src/main/Updater.ts b/fluxer_desktop/src/main/Updater.tsindex d52c209d5..fa5d1c3ef 100644--- a/fluxer_desktop/src/main/Updater.ts+++ b/fluxer_desktop/src/main/Updater.ts@@ -17,6 +17,12 @@ import {import {destroyDesktopTray} from '@electron/main/DesktopTray';import {isFlatpakRuntime} from '@electron/main/LinuxSandbox';import {relaunchAndExit} from '@electron/main/Troubleshooting';+import {+ clearVelopackApplyAttempt,+ readVelopackApplyAttempt,+ recordVelopackApplyAttempt,+ type VelopackApplyAttempt,+} from '@electron/main/UpdaterApplyState';import {buildManualVersionDownloadUrl,DOWNLOAD_PAGE_URL,@@ -149,6 +155,60 @@ function createVelopackUpdateManager() {return new UpdateManager(UPDATE_BASE_URL);}+type VelopackUpdateManager = ReturnType<typeof createVelopackUpdateManager>;++function getInstalledVelopackVersion(updateManager: VelopackUpdateManager): string | null {+ try {+ const version = updateManager.getCurrentVersion();+ return typeof version === 'string' && version.length > 0 ? version : null;+ } catch (error) {+ log.warn('Failed to read the installed Velopack version', error);+ return null;+ }+}++function resolveFailedVelopackApply(updateManager: VelopackUpdateManager): VelopackApplyAttempt | null {+ const attempt = readVelopackApplyAttempt();+ if (!attempt) {+ return null;+ }+ const installedVersion = getInstalledVelopackVersion(updateManager) ?? app.getVersion();+ if (compareVersions(installedVersion, attempt.version) >= 0) {+ clearVelopackApplyAttempt();+ return null;+ }+ return attempt;+}++async function sendVelopackApplyFailure(+ context: UpdaterContext,+ getMainWindow: () => BrowserWindow | null,+ attempt: VelopackApplyAttempt,+): Promise<void> {+ log.error('A downloaded update was never applied, so the installer is offered instead.', attempt);+ send(getMainWindow(), {+ type: 'error',+ context,+ phase: 'install',+ message: `Fluxer could not finish installing version ${attempt.version}.`,+ });+ try {+ const latest = await fetchManualLatest({forceRefresh: true});+ sendManualUpdateAvailable(getMainWindow, context, latest);+ return;+ } catch (error) {+ log.warn('Failed to resolve the installer download after a failed update apply', error);+ }+ send(getMainWindow(), {+ type: 'available',+ context,+ version: attempt.version,+ downloadSize: null,+ downloadStarted: false,+ downloadUrl: buildManualVersionDownloadUrl(attempt.version, 'setup'),+ });+}+async function checkVelopackForUpdates(context: UpdaterContext,getMainWindow: () => BrowserWindow | null,@@ -160,6 +220,11 @@ async function checkVelopackForUpdates(try {send(getMainWindow(), {type: 'checking', context});const updateManager = createVelopackUpdateManager();+ const failedApply = resolveFailedVelopackApply(updateManager);+ if (failedApply) {+ await sendVelopackApplyFailure(context, getMainWindow, failedApply);+ return;+ }const pendingUpdate = updateManager.getUpdatePendingRestart();const update = await updateManager.checkForUpdatesAsync();if (!update) {@@ -300,6 +365,13 @@ function installVelopackUpdate(): void {if (!update) {throw new Error('No Velopack update is ready to install.');}+ if (resolveFailedVelopackApply(updateManager)) {+ throw new Error('The last update could not be installed. Download the installer to update.');+ }+ const updateVersion = getVelopackUpdateVersion(update);+ if (updateVersion) {+ recordVelopackApplyAttempt(updateVersion);+ }velopackInstallStarted = true;setQuitting(true);destroyDesktopTray();diff --git a/fluxer_desktop/src/main/UpdaterApplyState.test.mjs b/fluxer_desktop/src/main/UpdaterApplyState.test.mjsnew file mode 100644index 000000000..e852899bd--- /dev/null+++ b/fluxer_desktop/src/main/UpdaterApplyState.test.mjs@@ -0,0 +1,119 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import assert from 'node:assert/strict';+import {readFileSync} from 'node:fs';+import {createRequire} from 'node:module';+import path from 'node:path';+import {describe, test} from 'node:test';+import {fileURLToPath} from 'node:url';+import vm from 'node:vm';++const require = createRequire(import.meta.url);+const esbuild = require('esbuild');++const sourcePath = fileURLToPath(new URL('./UpdaterApplyState.ts', import.meta.url));+const source = readFileSync(sourcePath, 'utf8');+const transformedSource = esbuild.transformSync(source, {+ loader: 'ts',+ format: 'cjs',+ platform: 'node',+ target: 'node20',+}).code;++const USER_DATA = 'C:\\Users\\csh\\AppData\\Roaming\\fluxercanary';+const STATE_PATH = path.win32.join(USER_DATA, 'update-apply-state.json');++function loadApplyState(initialFiles = []) {+ const files = new Map(initialFiles);+ const warnings = [];+ const fakeFs = {+ readFileSync: (target) => {+ if (!files.has(target)) throw new Error(`ENOENT ${target}`);+ return files.get(target);+ },+ writeFileSync: (target, contents) => {+ files.set(target, contents);+ },+ rmSync: (target) => {+ files.delete(target);+ },+ };++ const module = {exports: {}};+ const context = vm.createContext({+ module,+ exports: module.exports,+ console,+ Date,+ JSON,+ require: (specifier) => {+ if (specifier === 'node:fs') {+ return {default: fakeFs, ...fakeFs};+ }+ if (specifier === 'node:path') {+ return {default: path.win32, ...path.win32};+ }+ if (specifier === 'electron') {+ return {app: {getPath: () => USER_DATA}};+ }+ if (specifier === 'electron-log') {+ const log = {warn: (...args) => warnings.push(args)};+ return {default: log, ...log};+ }+ return require(specifier);+ },+ });+ vm.runInContext(transformedSource, context, {filename: sourcePath});+ return {...module.exports, files, warnings};+}++describe('update apply attempt state', () => {+ test('records an attempt that reads back with its version', () => {+ const harness = loadApplyState();++ harness.recordVelopackApplyAttempt('2026.920.144552');++ const attempt = harness.readVelopackApplyAttempt();+ assert.equal(attempt.version, '2026.920.144552');+ assert.equal(typeof attempt.attemptedAt, 'number');+ assert.equal(harness.files.has(STATE_PATH), true);+ });++ test('reads nothing when no attempt was ever recorded', () => {+ const harness = loadApplyState();++ assert.equal(harness.readVelopackApplyAttempt(), null);+ assert.deepEqual(harness.warnings, []);+ });++ test('clearing an attempt removes the state file', () => {+ const harness = loadApplyState();+ harness.recordVelopackApplyAttempt('2026.920.144552');++ harness.clearVelopackApplyAttempt();++ assert.equal(harness.files.has(STATE_PATH), false);+ assert.equal(harness.readVelopackApplyAttempt(), null);+ });++ test('treats a corrupt state file as no attempt', () => {+ const harness = loadApplyState([[STATE_PATH, '{not json']]);++ assert.equal(harness.readVelopackApplyAttempt(), null);+ assert.equal(harness.warnings.length, 1);+ });++ test('treats a state file without a version as no attempt', () => {+ const harness = loadApplyState([[STATE_PATH, JSON.stringify({attemptedAt: 1})]]);++ assert.equal(harness.readVelopackApplyAttempt(), null);+ });++ test('defaults a missing timestamp so an old state file still blocks the loop', () => {+ const harness = loadApplyState([[STATE_PATH, JSON.stringify({version: '2026.920.144552'})]]);++ const attempt = harness.readVelopackApplyAttempt();+ assert.equal(attempt.version, '2026.920.144552');+ assert.equal(attempt.attemptedAt, 0);+ });+});diff --git a/fluxer_desktop/src/main/UpdaterApplyState.ts b/fluxer_desktop/src/main/UpdaterApplyState.tsnew file mode 100644index 000000000..a9280a455--- /dev/null+++ b/fluxer_desktop/src/main/UpdaterApplyState.ts@@ -0,0 +1,56 @@+// SPDX-License-Identifier: AGPL-3.0-or-later++import fs from 'node:fs';+import path from 'node:path';+import {app} from 'electron';+import log from 'electron-log';++const APPLY_STATE_FILE_NAME = 'update-apply-state.json';++export type VelopackApplyAttempt = {+ version: string;+ attemptedAt: number;+};++function getApplyStatePath(): string {+ return path.join(app.getPath('userData'), APPLY_STATE_FILE_NAME);+}++export function readVelopackApplyAttempt(): VelopackApplyAttempt | null {+ let raw: string;+ try {+ raw = fs.readFileSync(getApplyStatePath(), 'utf8');+ } catch {+ return null;+ }+ try {+ const parsed = JSON.parse(raw) as {version?: unknown; attemptedAt?: unknown};+ if (typeof parsed.version !== 'string' || parsed.version.length === 0) {+ return null;+ }+ return {+ version: parsed.version,+ attemptedAt: typeof parsed.attemptedAt === 'number' ? parsed.attemptedAt : 0,+ };+ } catch (error) {+ log.warn('Failed to parse the recorded update apply attempt', error);+ return null;+ }+}++export function recordVelopackApplyAttempt(version: string): void {+ const payload: VelopackApplyAttempt = {version, attemptedAt: Date.now()};+ try {+ fs.writeFileSync(getApplyStatePath(), JSON.stringify(payload), 'utf8');+ } catch (error) {+ log.warn('Failed to record the update apply attempt', error);+ }+}++export function clearVelopackApplyAttempt(): void {+ try {+ fs.rmSync(getApplyStatePath(), {force: true});+ } catch (error) {+ log.warn('Failed to clear the recorded update apply attempt', error);+ }+}